2 * This file is part of the libsigrok project.
4 * Copyright (C) 2013 poljar (Damir Jelić) <poljarinho@gmail.com>
5 * Copyright (C) 2018 Guido Trentalancia <guido@trentalancia.com>
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
27 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
28 size_t group, GByteArray *pod_data);
29 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
30 struct dev_context *devc);
31 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc);
33 static const char *hameg_scpi_dialect[] = {
34 [SCPI_CMD_GET_DIG_DATA] = ":FORM UINT,8;:POD%d:DATA?",
35 [SCPI_CMD_GET_TIMEBASE] = ":TIM:SCAL?",
36 [SCPI_CMD_SET_TIMEBASE] = ":TIM:SCAL %s",
37 [SCPI_CMD_GET_COUPLING] = ":CHAN%d:COUP?",
38 [SCPI_CMD_SET_COUPLING] = ":CHAN%d:COUP %s",
39 [SCPI_CMD_GET_SAMPLE_RATE] = ":ACQ:SRAT?",
40 [SCPI_CMD_GET_ANALOG_DATA] = ":FORM:BORD %s;" \
41 ":FORM REAL,32;:CHAN%d:DATA?",
42 [SCPI_CMD_GET_VERTICAL_SCALE] = ":CHAN%d:SCAL?",
43 [SCPI_CMD_SET_VERTICAL_SCALE] = ":CHAN%d:SCAL %s",
44 [SCPI_CMD_GET_DIG_POD_STATE] = ":POD%d:STAT?",
45 [SCPI_CMD_SET_DIG_POD_STATE] = ":POD%d:STAT %d",
46 [SCPI_CMD_GET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP?",
47 [SCPI_CMD_SET_TRIGGER_SLOPE] = ":TRIG:A:TYPE EDGE;:TRIG:A:EDGE:SLOP %s",
48 [SCPI_CMD_GET_TRIGGER_PATTERN] = ":TRIG:A:PATT:SOUR?",
49 [SCPI_CMD_SET_TRIGGER_PATTERN] = ":TRIG:A:TYPE LOGIC;" \
50 ":TRIG:A:PATT:FUNC AND;" \
51 ":TRIG:A:PATT:COND \"TRUE\";" \
52 ":TRIG:A:PATT:MODE OFF;" \
53 ":TRIG:A:PATT:SOUR \"%s\"",
54 [SCPI_CMD_GET_TRIGGER_SOURCE] = ":TRIG:A:SOUR?",
55 [SCPI_CMD_SET_TRIGGER_SOURCE] = ":TRIG:A:SOUR %s",
56 [SCPI_CMD_GET_DIG_CHAN_STATE] = ":LOG%d:STAT?",
57 [SCPI_CMD_SET_DIG_CHAN_STATE] = ":LOG%d:STAT %d",
58 [SCPI_CMD_GET_VERTICAL_OFFSET] = ":CHAN%d:POS?",
59 [SCPI_CMD_GET_HORIZ_TRIGGERPOS] = ":TIM:POS?",
60 [SCPI_CMD_SET_HORIZ_TRIGGERPOS] = ":TIM:POS %s",
61 [SCPI_CMD_GET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT?",
62 [SCPI_CMD_SET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT %d",
63 [SCPI_CMD_GET_PROBE_UNIT] = ":PROB%d:SET:ATT:UNIT?",
64 [SCPI_CMD_GET_DIG_POD_THRESHOLD] = ":POD%d:THR?",
65 [SCPI_CMD_SET_DIG_POD_THRESHOLD] = ":POD%d:THR %s",
66 [SCPI_CMD_GET_DIG_POD_USER_THRESHOLD] = ":POD%d:THR:UDL%d?",
67 [SCPI_CMD_SET_DIG_POD_USER_THRESHOLD] = ":POD%d:THR:UDL%d %s",
70 static const char *rohde_schwarz_log_not_pod_scpi_dialect[] = {
71 [SCPI_CMD_GET_DIG_DATA] = ":FORM UINT,8;:LOG%d:DATA?",
72 [SCPI_CMD_GET_TIMEBASE] = ":TIM:SCAL?",
73 [SCPI_CMD_SET_TIMEBASE] = ":TIM:SCAL %s",
74 [SCPI_CMD_GET_COUPLING] = ":CHAN%d:COUP?",
75 [SCPI_CMD_SET_COUPLING] = ":CHAN%d:COUP %s",
76 [SCPI_CMD_GET_SAMPLE_RATE] = ":ACQ:SRAT?",
77 [SCPI_CMD_GET_ANALOG_DATA] = ":FORM:BORD %s;" \
78 ":FORM REAL,32;:CHAN%d:DATA?",
79 [SCPI_CMD_GET_VERTICAL_SCALE] = ":CHAN%d:SCAL?",
80 [SCPI_CMD_SET_VERTICAL_SCALE] = ":CHAN%d:SCAL %s",
81 [SCPI_CMD_GET_DIG_POD_STATE] = ":LOG%d:STAT?",
82 [SCPI_CMD_SET_DIG_POD_STATE] = ":LOG%d:STAT %d",
83 [SCPI_CMD_GET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP?",
84 [SCPI_CMD_SET_TRIGGER_SLOPE] = ":TRIG:A:TYPE EDGE;:TRIG:A:EDGE:SLOP %s",
85 [SCPI_CMD_GET_TRIGGER_PATTERN] = ":TRIG:A:PATT:SOUR?",
86 [SCPI_CMD_SET_TRIGGER_PATTERN] = ":TRIG:A:TYPE LOGIC;" \
87 ":TRIG:A:PATT:FUNC AND;" \
88 ":TRIG:A:PATT:COND \"TRUE\";" \
89 ":TRIG:A:PATT:MODE OFF;" \
90 ":TRIG:A:PATT:SOUR \"%s\"",
91 [SCPI_CMD_GET_TRIGGER_SOURCE] = ":TRIG:A:SOUR?",
92 [SCPI_CMD_SET_TRIGGER_SOURCE] = ":TRIG:A:SOUR %s",
93 [SCPI_CMD_GET_DIG_CHAN_STATE] = ":LOG%d:STAT?",
94 [SCPI_CMD_SET_DIG_CHAN_STATE] = ":LOG%d:STAT %d",
95 [SCPI_CMD_GET_VERTICAL_OFFSET] = ":CHAN%d:POS?", /* Might not be supported on RTB200x... */
96 [SCPI_CMD_GET_HORIZ_TRIGGERPOS] = ":TIM:POS?",
97 [SCPI_CMD_SET_HORIZ_TRIGGERPOS] = ":TIM:POS %s",
98 [SCPI_CMD_GET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT?",
99 [SCPI_CMD_SET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT %d",
100 [SCPI_CMD_GET_PROBE_UNIT] = ":PROB%d:SET:ATT:UNIT?",
101 [SCPI_CMD_GET_DIG_POD_THRESHOLD] = ":DIG%d:TECH?",
102 [SCPI_CMD_SET_DIG_POD_THRESHOLD] = ":DIG%d:TECH %s",
103 [SCPI_CMD_GET_DIG_POD_USER_THRESHOLD] = ":DIG%d:THR?",
104 [SCPI_CMD_SET_DIG_POD_USER_THRESHOLD] = ":DIG%d:THR %s",
107 static const uint32_t devopts[] = {
108 SR_CONF_OSCILLOSCOPE,
109 SR_CONF_LIMIT_SAMPLES | SR_CONF_SET,
110 SR_CONF_LIMIT_FRAMES | SR_CONF_SET,
111 SR_CONF_SAMPLERATE | SR_CONF_GET,
112 SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
113 SR_CONF_NUM_HDIV | SR_CONF_GET,
114 SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
115 SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
116 SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
117 SR_CONF_TRIGGER_PATTERN | SR_CONF_GET | SR_CONF_SET,
120 static const uint32_t devopts_cg_analog[] = {
121 SR_CONF_NUM_VDIV | SR_CONF_GET,
122 SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
123 SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
126 static const uint32_t devopts_cg_digital[] = {
127 SR_CONF_LOGIC_THRESHOLD | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
128 SR_CONF_LOGIC_THRESHOLD_CUSTOM | SR_CONF_GET | SR_CONF_SET,
131 static const char *coupling_options[] = {
132 "AC", // AC with 50 Ohm termination (152x, 202x, 30xx, 1202)
133 "ACL", // AC with 1 MOhm termination
134 "DC", // DC with 50 Ohm termination
135 "DCL", // DC with 1 MOhm termination
139 static const char *coupling_options_rtb200x[] = {
140 "ACL", // AC with 1 MOhm termination
141 "DCL", // DC with 1 MOhm termination
145 static const char *coupling_options_rtm300x[] = {
146 "ACL", // AC with 1 MOhm termination
147 "DC", // DC with 50 Ohm termination
148 "DCL", // DC with 1 MOhm termination
152 static const char *scope_trigger_slopes[] = {
158 /* Predefined logic thresholds. */
159 static const char *logic_threshold[] = {
164 "USER2", // overwritten by logic_threshold_custom, use USER1 for permanent setting
167 static const char *logic_threshold_rtb200x_rtm300x[] = {
171 "MAN", // overwritten by logic_threshold_custom
174 /* RTC1002, HMO Compact2 and HMO1002/HMO1202 */
175 static const char *an2_dig8_trigger_sources[] = {
177 "LINE", "EXT", "PATT", "BUS1", "BUS2",
178 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
182 static const char *an2_dig16_trigger_sources[] = {
184 "LINE", "EXT", "PATT", "BUS1", "BUS2",
185 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
186 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
189 /* RTB2002 and RTM3002 */
190 static const char *an2_dig16_sbus_trigger_sources[] = {
192 "LINE", "EXT", "PATT", "SBUS1", "SBUS2",
193 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
194 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
198 static const char *an4_dig8_trigger_sources[] = {
199 "CH1", "CH2", "CH3", "CH4",
200 "LINE", "EXT", "PATT", "BUS1", "BUS2",
201 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
204 /* HMO3xx4 and HMO2524 */
205 static const char *an4_dig16_trigger_sources[] = {
206 "CH1", "CH2", "CH3", "CH4",
207 "LINE", "EXT", "PATT", "BUS1", "BUS2",
208 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
209 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
212 /* RTB2004, RTM3004 and RTA4004 */
213 static const char *an4_dig16_sbus_trigger_sources[] = {
214 "CH1", "CH2", "CH3", "CH4",
215 "LINE", "EXT", "PATT", "SBUS1", "SBUS2",
216 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
217 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
220 static const uint64_t timebases[][2] = {
260 /* HMO Compact series (HMO722/724/1022/1024/1522/1524/2022/2024) do
261 * not support 1 ns timebase setting.
263 static const uint64_t timebases_hmo_compact[][2] = {
302 static const uint64_t vdivs[][2] = {
320 static const char *scope_analog_channel_names[] = {
321 "CH1", "CH2", "CH3", "CH4",
324 static const char *scope_digital_channel_names[] = {
325 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
326 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
329 static const struct scope_config scope_models[] = {
331 /* HMO Compact2: HMO722/1022/1522/2022 support only 8 digital channels. */
332 .name = {"HMO722", "HMO1022", "HMO1522", "HMO2022", NULL},
333 .analog_channels = 2,
334 .digital_channels = 8,
336 .analog_names = &scope_analog_channel_names,
337 .digital_names = &scope_digital_channel_names,
340 .num_devopts = ARRAY_SIZE(devopts),
342 .devopts_cg_analog = &devopts_cg_analog,
343 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
345 .devopts_cg_digital = &devopts_cg_digital,
346 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
348 .coupling_options = &coupling_options,
349 .num_coupling_options = ARRAY_SIZE(coupling_options),
351 .logic_threshold = &logic_threshold,
352 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
353 .logic_threshold_for_pod = TRUE,
355 .trigger_sources = &an2_dig8_trigger_sources,
356 .num_trigger_sources = ARRAY_SIZE(an2_dig8_trigger_sources),
358 .trigger_slopes = &scope_trigger_slopes,
359 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
361 .timebases = &timebases_hmo_compact,
362 .num_timebases = ARRAY_SIZE(timebases_hmo_compact),
365 .num_vdivs = ARRAY_SIZE(vdivs),
370 .scpi_dialect = &hameg_scpi_dialect,
373 /* RTC1002 and HMO1002/HMO1202 support only 8 digital channels. */
374 .name = {"RTC1002", "HMO1002", "HMO1202", NULL},
375 .analog_channels = 2,
376 .digital_channels = 8,
379 .analog_names = &scope_analog_channel_names,
380 .digital_names = &scope_digital_channel_names,
383 .num_devopts = ARRAY_SIZE(devopts),
385 .devopts_cg_analog = &devopts_cg_analog,
386 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
388 .devopts_cg_digital = &devopts_cg_digital,
389 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
391 .coupling_options = &coupling_options,
392 .num_coupling_options = ARRAY_SIZE(coupling_options),
394 .logic_threshold = &logic_threshold,
395 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
396 .logic_threshold_for_pod = TRUE,
398 .trigger_sources = &an2_dig8_trigger_sources,
399 .num_trigger_sources = ARRAY_SIZE(an2_dig8_trigger_sources),
401 .trigger_slopes = &scope_trigger_slopes,
402 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
404 .timebases = &timebases,
405 .num_timebases = ARRAY_SIZE(timebases),
408 .num_vdivs = ARRAY_SIZE(vdivs),
413 .scpi_dialect = &hameg_scpi_dialect,
416 /* HMO3032/3042/3052/3522 support 16 digital channels. */
417 .name = {"HMO3032", "HMO3042", "HMO3052", "HMO3522", NULL},
418 .analog_channels = 2,
419 .digital_channels = 16,
422 .analog_names = &scope_analog_channel_names,
423 .digital_names = &scope_digital_channel_names,
426 .num_devopts = ARRAY_SIZE(devopts),
428 .devopts_cg_analog = &devopts_cg_analog,
429 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
431 .devopts_cg_digital = &devopts_cg_digital,
432 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
434 .coupling_options = &coupling_options,
435 .num_coupling_options = ARRAY_SIZE(coupling_options),
437 .logic_threshold = &logic_threshold,
438 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
439 .logic_threshold_for_pod = TRUE,
441 .trigger_sources = &an2_dig16_trigger_sources,
442 .num_trigger_sources = ARRAY_SIZE(an2_dig16_trigger_sources),
444 .trigger_slopes = &scope_trigger_slopes,
445 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
447 .timebases = &timebases,
448 .num_timebases = ARRAY_SIZE(timebases),
451 .num_vdivs = ARRAY_SIZE(vdivs),
456 .scpi_dialect = &hameg_scpi_dialect,
459 /* HMO Compact4: HMO724/1024/1524/2024 support only 8 digital channels. */
460 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
461 .analog_channels = 4,
462 .digital_channels = 8,
465 .analog_names = &scope_analog_channel_names,
466 .digital_names = &scope_digital_channel_names,
469 .num_devopts = ARRAY_SIZE(devopts),
471 .devopts_cg_analog = &devopts_cg_analog,
472 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
474 .devopts_cg_digital = &devopts_cg_digital,
475 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
477 .coupling_options = &coupling_options,
478 .num_coupling_options = ARRAY_SIZE(coupling_options),
480 .logic_threshold = &logic_threshold,
481 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
482 .logic_threshold_for_pod = TRUE,
484 .trigger_sources = &an4_dig8_trigger_sources,
485 .num_trigger_sources = ARRAY_SIZE(an4_dig8_trigger_sources),
487 .trigger_slopes = &scope_trigger_slopes,
488 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
490 .timebases = &timebases_hmo_compact,
491 .num_timebases = ARRAY_SIZE(timebases_hmo_compact),
494 .num_vdivs = ARRAY_SIZE(vdivs),
499 .scpi_dialect = &hameg_scpi_dialect,
502 .name = {"HMO2524", "HMO3034", "HMO3044", "HMO3054", "HMO3524", NULL},
503 .analog_channels = 4,
504 .digital_channels = 16,
507 .analog_names = &scope_analog_channel_names,
508 .digital_names = &scope_digital_channel_names,
511 .num_devopts = ARRAY_SIZE(devopts),
513 .devopts_cg_analog = &devopts_cg_analog,
514 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
516 .devopts_cg_digital = &devopts_cg_digital,
517 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
519 .coupling_options = &coupling_options,
520 .num_coupling_options = ARRAY_SIZE(coupling_options),
522 .logic_threshold = &logic_threshold,
523 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
524 .logic_threshold_for_pod = TRUE,
526 .trigger_sources = &an4_dig16_trigger_sources,
527 .num_trigger_sources = ARRAY_SIZE(an4_dig16_trigger_sources),
529 .trigger_slopes = &scope_trigger_slopes,
530 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
532 .timebases = &timebases,
533 .num_timebases = ARRAY_SIZE(timebases),
536 .num_vdivs = ARRAY_SIZE(vdivs),
541 .scpi_dialect = &hameg_scpi_dialect,
544 .name = {"RTB2002", NULL},
545 .analog_channels = 2,
546 .digital_channels = 16,
549 .analog_names = &scope_analog_channel_names,
550 .digital_names = &scope_digital_channel_names,
553 .num_devopts = ARRAY_SIZE(devopts),
555 .devopts_cg_analog = &devopts_cg_analog,
556 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
558 .devopts_cg_digital = &devopts_cg_digital,
559 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
561 .coupling_options = &coupling_options_rtb200x,
562 .num_coupling_options = ARRAY_SIZE(coupling_options_rtb200x),
564 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
565 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
566 .logic_threshold_for_pod = FALSE,
568 .trigger_sources = &an2_dig16_sbus_trigger_sources,
569 .num_trigger_sources = ARRAY_SIZE(an2_dig16_sbus_trigger_sources),
571 .trigger_slopes = &scope_trigger_slopes,
572 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
574 .timebases = &timebases,
575 .num_timebases = ARRAY_SIZE(timebases),
578 .num_vdivs = ARRAY_SIZE(vdivs),
583 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
586 .name = {"RTB2004", NULL},
587 .analog_channels = 4,
588 .digital_channels = 16,
591 .analog_names = &scope_analog_channel_names,
592 .digital_names = &scope_digital_channel_names,
595 .num_devopts = ARRAY_SIZE(devopts),
597 .devopts_cg_analog = &devopts_cg_analog,
598 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
600 .devopts_cg_digital = &devopts_cg_digital,
601 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
603 .coupling_options = &coupling_options_rtb200x,
604 .num_coupling_options = ARRAY_SIZE(coupling_options_rtb200x),
606 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
607 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
608 .logic_threshold_for_pod = FALSE,
610 .trigger_sources = &an4_dig16_sbus_trigger_sources,
611 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
613 .trigger_slopes = &scope_trigger_slopes,
614 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
616 .timebases = &timebases,
617 .num_timebases = ARRAY_SIZE(timebases),
620 .num_vdivs = ARRAY_SIZE(vdivs),
625 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
628 .name = {"RTM3002", NULL},
629 .analog_channels = 2,
630 .digital_channels = 16,
633 .analog_names = &scope_analog_channel_names,
634 .digital_names = &scope_digital_channel_names,
637 .num_devopts = ARRAY_SIZE(devopts),
639 .devopts_cg_analog = &devopts_cg_analog,
640 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
642 .devopts_cg_digital = &devopts_cg_digital,
643 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
645 .coupling_options = &coupling_options_rtm300x,
646 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
648 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
649 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
650 .logic_threshold_for_pod = FALSE,
652 .trigger_sources = &an2_dig16_sbus_trigger_sources,
653 .num_trigger_sources = ARRAY_SIZE(an2_dig16_sbus_trigger_sources),
655 .trigger_slopes = &scope_trigger_slopes,
656 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
658 .timebases = &timebases,
659 .num_timebases = ARRAY_SIZE(timebases),
662 .num_vdivs = ARRAY_SIZE(vdivs),
667 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
670 .name = {"RTM3004", NULL},
671 .analog_channels = 4,
672 .digital_channels = 16,
675 .analog_names = &scope_analog_channel_names,
676 .digital_names = &scope_digital_channel_names,
679 .num_devopts = ARRAY_SIZE(devopts),
681 .devopts_cg_analog = &devopts_cg_analog,
682 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
684 .devopts_cg_digital = &devopts_cg_digital,
685 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
687 .coupling_options = &coupling_options_rtm300x,
688 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
690 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
691 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
692 .logic_threshold_for_pod = FALSE,
694 .trigger_sources = &an4_dig16_sbus_trigger_sources,
695 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
697 .trigger_slopes = &scope_trigger_slopes,
698 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
700 .timebases = &timebases,
701 .num_timebases = ARRAY_SIZE(timebases),
704 .num_vdivs = ARRAY_SIZE(vdivs),
709 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
712 .name = {"RTA4004", NULL},
713 .analog_channels = 4,
714 .digital_channels = 16,
717 .analog_names = &scope_analog_channel_names,
718 .digital_names = &scope_digital_channel_names,
721 .num_devopts = ARRAY_SIZE(devopts),
723 .devopts_cg_analog = &devopts_cg_analog,
724 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
726 .devopts_cg_digital = &devopts_cg_digital,
727 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
729 .coupling_options = &coupling_options_rtm300x,
730 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
732 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
733 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
734 .logic_threshold_for_pod = FALSE,
736 .trigger_sources = &an4_dig16_sbus_trigger_sources,
737 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
739 .trigger_slopes = &scope_trigger_slopes,
740 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
742 .timebases = &timebases,
743 .num_timebases = ARRAY_SIZE(timebases),
746 .num_vdivs = ARRAY_SIZE(vdivs),
751 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
755 static void scope_state_dump(const struct scope_config *config,
756 struct scope_state *state)
761 for (i = 0; i < config->analog_channels; i++) {
762 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
763 (*config->vdivs)[state->analog_channels[i].vdiv][1]);
764 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
765 i + 1, state->analog_channels[i].state ? "On" : "Off",
766 (*config->coupling_options)[state->analog_channels[i].coupling],
767 tmp, state->analog_channels[i].vertical_offset);
770 for (i = 0; i < config->digital_channels; i++) {
771 sr_info("State of digital channel %d -> %s", i,
772 state->digital_channels[i] ? "On" : "Off");
775 for (i = 0; i < config->digital_pods; i++) {
776 if (!strncmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold], 4) ||
777 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
778 sr_info("State of digital POD %d -> %s : %E (threshold)", i + 1,
779 state->digital_pods[i].state ? "On" : "Off",
780 state->digital_pods[i].user_threshold);
782 sr_info("State of digital POD %d -> %s : %s (threshold)", i + 1,
783 state->digital_pods[i].state ? "On" : "Off",
784 (*config->logic_threshold)[state->digital_pods[i].threshold]);
787 tmp = sr_period_string((*config->timebases)[state->timebase][0],
788 (*config->timebases)[state->timebase][1]);
789 sr_info("Current timebase: %s", tmp);
792 tmp = sr_samplerate_string(state->sample_rate);
793 sr_info("Current samplerate: %s", tmp);
796 if (!strcmp("PATT", (*config->trigger_sources)[state->trigger_source]))
797 sr_info("Current trigger: %s (pattern), %.2f (offset)",
798 state->trigger_pattern,
799 state->horiz_triggerpos);
800 else // Edge (slope) trigger
801 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
802 (*config->trigger_sources)[state->trigger_source],
803 (*config->trigger_slopes)[state->trigger_slope],
804 state->horiz_triggerpos);
807 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
808 const char *command, const char *(*array)[], unsigned int n, int *result)
813 if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK)
816 if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
829 * This function takes a value of the form "2.000E-03" and returns the index
830 * of an array where a matching pair was found.
832 * @param value The string to be parsed.
833 * @param array The array of s/f pairs.
834 * @param array_len The number of pairs in the array.
835 * @param result The index at which a matching pair was found.
837 * @return SR_ERR on any parsing error, SR_OK otherwise.
839 static int array_float_get(gchar *value, const uint64_t array[][2],
840 int array_len, unsigned int *result)
842 struct sr_rational rval;
843 struct sr_rational aval;
845 if (sr_parse_rational(value, &rval) != SR_OK)
848 for (int i = 0; i < array_len; i++) {
849 sr_rational_set(&aval, array[i][0], array[i][1]);
850 if (sr_rational_eq(&rval, &aval)) {
859 static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
862 while (channel_lhead) {
863 struct sr_channel *ch = channel_lhead->data;
864 if (ch->index == index && ch->type == type)
867 channel_lhead = channel_lhead->next;
873 static int analog_channel_state_get(struct sr_dev_inst *sdi,
874 const struct scope_config *config,
875 struct scope_state *state)
878 char command[MAX_COMMAND_SIZE];
880 struct sr_channel *ch;
881 struct sr_scpi_dev_inst *scpi = sdi->conn;
883 for (i = 0; i < config->analog_channels; i++) {
884 g_snprintf(command, sizeof(command),
885 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
888 if (sr_scpi_get_bool(scpi, command,
889 &state->analog_channels[i].state) != SR_OK)
892 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
894 ch->enabled = state->analog_channels[i].state;
896 g_snprintf(command, sizeof(command),
897 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_SCALE],
900 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
903 if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
905 sr_err("Could not determine array index for vertical div scale.");
910 state->analog_channels[i].vdiv = j;
912 g_snprintf(command, sizeof(command),
913 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
916 if (sr_scpi_get_float(scpi, command,
917 &state->analog_channels[i].vertical_offset) != SR_OK)
920 g_snprintf(command, sizeof(command),
921 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
924 if (scope_state_get_array_option(scpi, command, config->coupling_options,
925 config->num_coupling_options,
926 &state->analog_channels[i].coupling) != SR_OK)
929 g_snprintf(command, sizeof(command),
930 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
933 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
936 if (tmp_str[0] == 'A')
937 state->analog_channels[i].probe_unit = 'A';
939 state->analog_channels[i].probe_unit = 'V';
946 static int digital_channel_state_get(struct sr_dev_inst *sdi,
947 const struct scope_config *config,
948 struct scope_state *state)
952 static char *logic_threshold_short[] = {};
953 char command[MAX_COMMAND_SIZE];
954 struct sr_channel *ch;
955 struct sr_scpi_dev_inst *scpi = sdi->conn;
957 for (i = 0; i < config->digital_channels; i++) {
958 g_snprintf(command, sizeof(command),
959 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
962 if (sr_scpi_get_bool(scpi, command,
963 &state->digital_channels[i]) != SR_OK)
966 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
968 ch->enabled = state->digital_channels[i];
971 /* According to the SCPI standard, on models that support multiple
972 * user-defined logic threshold settings the response to the command
973 * SCPI_CMD_GET_DIG_POD_THRESHOLD might return "USER" instead of
976 * This makes more difficult to validate the response when the logic
977 * threshold is set to "USER1" and therefore we need to prevent device
978 * opening failures in such configuration case...
980 for (i = 0; i < config->num_logic_threshold; i++) {
981 logic_threshold_short[i] = g_strdup((*config->logic_threshold)[i]);
982 if (!strcmp("USER1", (*config->logic_threshold)[i]))
983 g_strlcpy(logic_threshold_short[i],
984 (*config->logic_threshold)[i], strlen((*config->logic_threshold)[i]));
987 for (i = 0; i < config->digital_pods; i++) {
988 g_snprintf(command, sizeof(command),
989 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
992 if (sr_scpi_get_bool(scpi, command,
993 &state->digital_pods[i].state) != SR_OK)
996 /* Check if the threshold command is based on the POD or digital channel index. */
997 if (config->logic_threshold_for_pod)
1002 g_snprintf(command, sizeof(command),
1003 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_THRESHOLD],
1006 /* Check for both standard and shortened responses. */
1007 if (scope_state_get_array_option(scpi, command, config->logic_threshold,
1008 config->num_logic_threshold,
1009 &state->digital_pods[i].threshold) != SR_OK)
1010 if (scope_state_get_array_option(scpi, command, (const char * (*)[]) &logic_threshold_short,
1011 config->num_logic_threshold,
1012 &state->digital_pods[i].threshold) != SR_OK)
1015 /* If used-defined or custom threshold is active, get the level. */
1016 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1017 g_snprintf(command, sizeof(command),
1018 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1019 idx, 1); /* USER1 logic threshold setting. */
1020 else if (!strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1021 g_snprintf(command, sizeof(command),
1022 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1023 idx, 2); /* USER2 for custom logic_threshold setting. */
1024 else if (!strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1025 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1026 g_snprintf(command, sizeof(command),
1027 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1028 idx); /* USER or MAN for custom logic_threshold setting. */
1029 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1030 !strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1031 !strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1032 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1033 if (sr_scpi_get_float(scpi, command,
1034 &state->digital_pods[i].user_threshold) != SR_OK)
1041 for (i = 0; i < config->num_logic_threshold; i++)
1042 g_free(logic_threshold_short[i]);
1047 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
1049 struct dev_context *devc;
1050 struct scope_state *state;
1051 const struct scope_config *config;
1055 config = devc->model_config;
1056 state = devc->model_state;
1058 if (sr_scpi_get_float(sdi->conn,
1059 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
1060 &tmp_float) != SR_OK)
1063 state->sample_rate = tmp_float;
1068 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
1070 struct dev_context *devc;
1071 struct scope_state *state;
1072 const struct scope_config *config;
1078 config = devc->model_config;
1079 state = devc->model_state;
1081 sr_info("Fetching scope state");
1083 if (analog_channel_state_get(sdi, config, state) != SR_OK)
1086 if (digital_channel_state_get(sdi, config, state) != SR_OK)
1089 if (sr_scpi_get_string(sdi->conn,
1090 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
1094 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
1096 sr_err("Could not determine array index for time base.");
1101 state->timebase = i;
1103 if (sr_scpi_get_float(sdi->conn,
1104 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
1105 &tmp_float) != SR_OK)
1107 state->horiz_triggerpos = tmp_float /
1108 (((double) (*config->timebases)[state->timebase][0] /
1109 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
1110 state->horiz_triggerpos -= 0.5;
1111 state->horiz_triggerpos *= -1;
1113 if (scope_state_get_array_option(sdi->conn,
1114 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
1115 config->trigger_sources, config->num_trigger_sources,
1116 &state->trigger_source) != SR_OK)
1119 if (scope_state_get_array_option(sdi->conn,
1120 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
1121 config->trigger_slopes, config->num_trigger_slopes,
1122 &state->trigger_slope) != SR_OK)
1125 if (sr_scpi_get_string(sdi->conn,
1126 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_PATTERN],
1129 strncpy(state->trigger_pattern,
1130 sr_scpi_unquote_string(tmp_str),
1131 MAX_ANALOG_CHANNEL_COUNT + MAX_DIGITAL_CHANNEL_COUNT);
1134 if (hmo_update_sample_rate(sdi) != SR_OK)
1137 sr_info("Fetching finished.");
1139 scope_state_dump(config, state);
1144 static struct scope_state *scope_state_new(const struct scope_config *config)
1146 struct scope_state *state;
1148 state = g_malloc0(sizeof(struct scope_state));
1149 state->analog_channels = g_malloc0_n(config->analog_channels,
1150 sizeof(struct analog_channel_state));
1151 state->digital_channels = g_malloc0_n(
1152 config->digital_channels, sizeof(gboolean));
1153 state->digital_pods = g_malloc0_n(config->digital_pods,
1154 sizeof(struct digital_pod_state));
1159 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
1161 g_free(state->analog_channels);
1162 g_free(state->digital_channels);
1163 g_free(state->digital_pods);
1167 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
1170 unsigned int i, j, group;
1171 struct sr_channel *ch;
1172 struct dev_context *devc;
1178 /* Find the exact model. */
1179 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
1180 for (j = 0; scope_models[i].name[j]; j++) {
1181 if (!strcmp(sdi->model, scope_models[i].name[j])) {
1186 if (model_index != -1)
1190 if (model_index == -1) {
1191 sr_dbg("Unsupported device.");
1195 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1196 scope_models[model_index].analog_channels);
1197 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1198 scope_models[model_index].digital_pods);
1199 if (!devc->analog_groups || !devc->digital_groups) {
1200 g_free(devc->analog_groups);
1201 g_free(devc->digital_groups);
1202 return SR_ERR_MALLOC;
1205 /* Add analog channels. */
1206 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
1207 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
1208 (*scope_models[model_index].analog_names)[i]);
1210 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
1212 devc->analog_groups[i]->name = g_strdup(
1213 (char *)(*scope_models[model_index].analog_names)[i]);
1214 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
1216 sdi->channel_groups = g_slist_append(sdi->channel_groups,
1217 devc->analog_groups[i]);
1220 /* Add digital channel groups. */
1222 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
1223 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
1224 if (!devc->digital_groups[i]) {
1225 ret = SR_ERR_MALLOC;
1228 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i + 1);
1229 sdi->channel_groups = g_slist_append(sdi->channel_groups,
1230 devc->digital_groups[i]);
1235 /* Add digital channels. */
1236 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
1237 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
1238 (*scope_models[model_index].digital_names)[i]);
1241 devc->digital_groups[group]->channels = g_slist_append(
1242 devc->digital_groups[group]->channels, ch);
1245 devc->model_config = &scope_models[model_index];
1246 devc->samples_limit = 0;
1247 devc->frame_limit = 0;
1249 if (!(devc->model_state = scope_state_new(devc->model_config)))
1250 return SR_ERR_MALLOC;
1255 /* Queue data of one channel group, for later submission. */
1256 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
1257 size_t group, GByteArray *pod_data)
1261 uint8_t *logic_data;
1262 size_t idx, logic_step;
1265 * Upon first invocation, allocate the array which can hold the
1266 * combined logic data for all channels. Assume that each channel
1267 * will yield an identical number of samples per receive call.
1269 * As a poor man's safety measure: (Silently) skip processing
1270 * for unexpected sample counts, and ignore samples for
1271 * unexpected channel groups. Don't bother with complicated
1272 * resize logic, considering that many models only support one
1273 * pod, and the most capable supported models have two pods of
1274 * identical size. We haven't yet seen any "odd" configuration.
1276 if (!devc->logic_data) {
1277 size = pod_data->len * devc->pod_count;
1278 store = g_byte_array_sized_new(size);
1279 memset(store->data, 0, size);
1280 store = g_byte_array_set_size(store, size);
1281 devc->logic_data = store;
1283 store = devc->logic_data;
1284 size = store->len / devc->pod_count;
1285 if (group >= devc->pod_count)
1290 * Fold the data of the most recently received channel group into
1291 * the storage, where data resides for all channels combined.
1293 logic_data = store->data;
1294 logic_data += group;
1295 logic_step = devc->pod_count;
1296 for (idx = 0; idx < pod_data->len; idx++) {
1297 *logic_data = pod_data->data[idx];
1298 logic_data += logic_step;
1301 /* Truncate acquisition if a smaller number of samples has been requested. */
1302 if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
1303 devc->logic_data->len = devc->samples_limit * devc->pod_count;
1306 /* Submit data for all channels, after the individual groups got collected. */
1307 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
1308 struct dev_context *devc)
1310 struct sr_datafeed_packet packet;
1311 struct sr_datafeed_logic logic;
1313 if (!devc->logic_data)
1316 logic.data = devc->logic_data->data;
1317 logic.length = devc->logic_data->len;
1318 logic.unitsize = devc->pod_count;
1320 packet.type = SR_DF_LOGIC;
1321 packet.payload = &logic;
1323 sr_session_send(sdi, &packet);
1326 /* Undo previous resource allocation. */
1327 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
1330 if (devc->logic_data) {
1331 g_byte_array_free(devc->logic_data, TRUE);
1332 devc->logic_data = NULL;
1335 * Keep 'pod_count'! It's required when more frames will be
1336 * received, and does not harm when kept after acquisition.
1340 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
1342 struct sr_channel *ch;
1343 struct sr_dev_inst *sdi;
1344 struct dev_context *devc;
1345 struct scope_state *state;
1346 struct sr_datafeed_packet packet;
1348 struct sr_datafeed_analog analog;
1349 struct sr_analog_encoding encoding;
1350 struct sr_analog_meaning meaning;
1351 struct sr_analog_spec spec;
1352 struct sr_datafeed_logic logic;
1360 if (!(sdi = cb_data))
1363 if (!(devc = sdi->priv))
1366 /* Although this is correct in general, the USBTMC libusb implementation
1367 * currently does not generate an event prior to the first read. Often
1368 * it is ok to start reading just after the 50ms timeout. See bug #785.
1369 if (revents != G_IO_IN)
1373 ch = devc->current_channel->data;
1374 state = devc->model_state;
1377 * Send "frame begin" packet upon reception of data for the
1378 * first enabled channel.
1380 if (devc->current_channel == devc->enabled_channels) {
1381 packet.type = SR_DF_FRAME_BEGIN;
1382 sr_session_send(sdi, &packet);
1386 * Pass on the received data of the channel(s).
1389 case SR_CHANNEL_ANALOG:
1390 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1392 g_byte_array_free(data, TRUE);
1396 packet.type = SR_DF_ANALOG;
1398 analog.data = data->data;
1399 analog.num_samples = data->len / sizeof(float);
1400 /* Truncate acquisition if a smaller number of samples has been requested. */
1401 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1402 analog.num_samples = devc->samples_limit;
1403 analog.encoding = &encoding;
1404 analog.meaning = &meaning;
1405 analog.spec = &spec;
1407 encoding.unitsize = sizeof(float);
1408 encoding.is_signed = TRUE;
1409 encoding.is_float = TRUE;
1410 #ifdef WORDS_BIGENDIAN
1411 encoding.is_bigendian = TRUE;
1413 encoding.is_bigendian = FALSE;
1415 /* TODO: Use proper 'digits' value for this device (and its modes). */
1416 encoding.digits = 2;
1417 encoding.is_digits_decimal = FALSE;
1418 encoding.scale.p = 1;
1419 encoding.scale.q = 1;
1420 encoding.offset.p = 0;
1421 encoding.offset.q = 1;
1422 if (state->analog_channels[ch->index].probe_unit == 'V') {
1423 meaning.mq = SR_MQ_VOLTAGE;
1424 meaning.unit = SR_UNIT_VOLT;
1426 meaning.mq = SR_MQ_CURRENT;
1427 meaning.unit = SR_UNIT_AMPERE;
1429 meaning.mqflags = 0;
1430 meaning.channels = g_slist_append(NULL, ch);
1431 /* TODO: Use proper 'digits' value for this device (and its modes). */
1432 spec.spec_digits = 2;
1433 packet.payload = &analog;
1434 sr_session_send(sdi, &packet);
1435 devc->num_samples = data->len / sizeof(float);
1436 g_slist_free(meaning.channels);
1437 g_byte_array_free(data, TRUE);
1440 case SR_CHANNEL_LOGIC:
1441 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1443 g_byte_array_free(data, TRUE);
1448 * If only data from the first pod is involved in the
1449 * acquisition, then the raw input bytes can get passed
1450 * forward for performance reasons. When the second pod
1451 * is involved (either alone, or in combination with the
1452 * first pod), then the received bytes need to be put
1453 * into memory in such a layout that all channel groups
1454 * get combined, and a unitsize larger than a single byte
1455 * applies. The "queue" logic transparently copes with
1456 * any such configuration. This works around the lack
1457 * of support for "meaning" to logic data, which is used
1458 * above for analog data.
1460 if (devc->pod_count == 1) {
1461 packet.type = SR_DF_LOGIC;
1462 logic.data = data->data;
1463 logic.length = data->len;
1464 /* Truncate acquisition if a smaller number of samples has been requested. */
1465 if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1466 logic.length = devc->samples_limit;
1468 packet.payload = &logic;
1469 sr_session_send(sdi, &packet);
1471 group = ch->index / 8;
1472 hmo_queue_logic_data(devc, group, data);
1475 devc->num_samples = data->len / devc->pod_count;
1476 g_byte_array_free(data, TRUE);
1480 sr_err("Invalid channel type.");
1485 * Advance to the next enabled channel. When data for all enabled
1486 * channels was received, then flush potentially queued logic data,
1487 * and send the "frame end" packet.
1489 if (devc->current_channel->next) {
1490 devc->current_channel = devc->current_channel->next;
1491 hmo_request_data(sdi);
1494 hmo_send_logic_packet(sdi, devc);
1497 * Release the logic data storage after each frame. This copes
1498 * with sample counts that differ in length per frame. -- Is
1499 * this a real constraint when acquiring multiple frames with
1500 * identical device settings?
1502 hmo_cleanup_logic_data(devc);
1504 packet.type = SR_DF_FRAME_END;
1505 sr_session_send(sdi, &packet);
1508 * End of frame was reached. Stop acquisition after the specified
1509 * number of frames or after the specified number of samples, or
1510 * continue reception by starting over at the first enabled channel.
1512 if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1513 sr_dev_acquisition_stop(sdi);
1514 hmo_cleanup_logic_data(devc);
1516 devc->current_channel = devc->enabled_channels;
1517 hmo_request_data(sdi);