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_float(sdi->conn,
1090 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
1091 &tmp_float) != SR_OK)
1094 if (sr_scpi_get_string(sdi->conn,
1095 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
1099 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
1101 sr_err("Could not determine array index for time base.");
1106 state->timebase = i;
1108 if (sr_scpi_get_float(sdi->conn,
1109 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
1110 &tmp_float) != SR_OK)
1112 state->horiz_triggerpos = tmp_float /
1113 (((double) (*config->timebases)[state->timebase][0] /
1114 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
1115 state->horiz_triggerpos -= 0.5;
1116 state->horiz_triggerpos *= -1;
1118 if (scope_state_get_array_option(sdi->conn,
1119 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
1120 config->trigger_sources, config->num_trigger_sources,
1121 &state->trigger_source) != SR_OK)
1124 if (scope_state_get_array_option(sdi->conn,
1125 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
1126 config->trigger_slopes, config->num_trigger_slopes,
1127 &state->trigger_slope) != SR_OK)
1130 if (sr_scpi_get_string(sdi->conn,
1131 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_PATTERN],
1134 strncpy(state->trigger_pattern,
1135 sr_scpi_unquote_string(tmp_str),
1136 MAX_ANALOG_CHANNEL_COUNT + MAX_DIGITAL_CHANNEL_COUNT);
1139 if (hmo_update_sample_rate(sdi) != SR_OK)
1142 sr_info("Fetching finished.");
1144 scope_state_dump(config, state);
1149 static struct scope_state *scope_state_new(const struct scope_config *config)
1151 struct scope_state *state;
1153 state = g_malloc0(sizeof(struct scope_state));
1154 state->analog_channels = g_malloc0_n(config->analog_channels,
1155 sizeof(struct analog_channel_state));
1156 state->digital_channels = g_malloc0_n(
1157 config->digital_channels, sizeof(gboolean));
1158 state->digital_pods = g_malloc0_n(config->digital_pods,
1159 sizeof(struct digital_pod_state));
1164 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
1166 g_free(state->analog_channels);
1167 g_free(state->digital_channels);
1168 g_free(state->digital_pods);
1172 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
1175 unsigned int i, j, group;
1176 struct sr_channel *ch;
1177 struct dev_context *devc;
1183 /* Find the exact model. */
1184 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
1185 for (j = 0; scope_models[i].name[j]; j++) {
1186 if (!strcmp(sdi->model, scope_models[i].name[j])) {
1191 if (model_index != -1)
1195 if (model_index == -1) {
1196 sr_dbg("Unsupported device.");
1200 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1201 scope_models[model_index].analog_channels);
1202 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1203 scope_models[model_index].digital_pods);
1204 if (!devc->analog_groups || !devc->digital_groups) {
1205 g_free(devc->analog_groups);
1206 g_free(devc->digital_groups);
1207 return SR_ERR_MALLOC;
1210 /* Add analog channels. */
1211 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
1212 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
1213 (*scope_models[model_index].analog_names)[i]);
1215 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
1217 devc->analog_groups[i]->name = g_strdup(
1218 (char *)(*scope_models[model_index].analog_names)[i]);
1219 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
1221 sdi->channel_groups = g_slist_append(sdi->channel_groups,
1222 devc->analog_groups[i]);
1225 /* Add digital channel groups. */
1227 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
1228 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
1229 if (!devc->digital_groups[i]) {
1230 ret = SR_ERR_MALLOC;
1233 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i + 1);
1234 sdi->channel_groups = g_slist_append(sdi->channel_groups,
1235 devc->digital_groups[i]);
1240 /* Add digital channels. */
1241 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
1242 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
1243 (*scope_models[model_index].digital_names)[i]);
1246 devc->digital_groups[group]->channels = g_slist_append(
1247 devc->digital_groups[group]->channels, ch);
1250 devc->model_config = &scope_models[model_index];
1251 devc->samples_limit = 0;
1252 devc->frame_limit = 0;
1254 if (!(devc->model_state = scope_state_new(devc->model_config)))
1255 return SR_ERR_MALLOC;
1260 /* Queue data of one channel group, for later submission. */
1261 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
1262 size_t group, GByteArray *pod_data)
1266 uint8_t *logic_data;
1267 size_t idx, logic_step;
1270 * Upon first invocation, allocate the array which can hold the
1271 * combined logic data for all channels. Assume that each channel
1272 * will yield an identical number of samples per receive call.
1274 * As a poor man's safety measure: (Silently) skip processing
1275 * for unexpected sample counts, and ignore samples for
1276 * unexpected channel groups. Don't bother with complicated
1277 * resize logic, considering that many models only support one
1278 * pod, and the most capable supported models have two pods of
1279 * identical size. We haven't yet seen any "odd" configuration.
1281 if (!devc->logic_data) {
1282 size = pod_data->len * devc->pod_count;
1283 store = g_byte_array_sized_new(size);
1284 memset(store->data, 0, size);
1285 store = g_byte_array_set_size(store, size);
1286 devc->logic_data = store;
1288 store = devc->logic_data;
1289 size = store->len / devc->pod_count;
1290 if (group >= devc->pod_count)
1295 * Fold the data of the most recently received channel group into
1296 * the storage, where data resides for all channels combined.
1298 logic_data = store->data;
1299 logic_data += group;
1300 logic_step = devc->pod_count;
1301 for (idx = 0; idx < pod_data->len; idx++) {
1302 *logic_data = pod_data->data[idx];
1303 logic_data += logic_step;
1306 /* Truncate acquisition if a smaller number of samples has been requested. */
1307 if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
1308 devc->logic_data->len = devc->samples_limit * devc->pod_count;
1311 /* Submit data for all channels, after the individual groups got collected. */
1312 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
1313 struct dev_context *devc)
1315 struct sr_datafeed_packet packet;
1316 struct sr_datafeed_logic logic;
1318 if (!devc->logic_data)
1321 logic.data = devc->logic_data->data;
1322 logic.length = devc->logic_data->len;
1323 logic.unitsize = devc->pod_count;
1325 packet.type = SR_DF_LOGIC;
1326 packet.payload = &logic;
1328 sr_session_send(sdi, &packet);
1331 /* Undo previous resource allocation. */
1332 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
1335 if (devc->logic_data) {
1336 g_byte_array_free(devc->logic_data, TRUE);
1337 devc->logic_data = NULL;
1340 * Keep 'pod_count'! It's required when more frames will be
1341 * received, and does not harm when kept after acquisition.
1345 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
1347 struct sr_channel *ch;
1348 struct sr_dev_inst *sdi;
1349 struct dev_context *devc;
1350 struct scope_state *state;
1351 struct sr_datafeed_packet packet;
1353 struct sr_datafeed_analog analog;
1354 struct sr_analog_encoding encoding;
1355 struct sr_analog_meaning meaning;
1356 struct sr_analog_spec spec;
1357 struct sr_datafeed_logic logic;
1365 if (!(sdi = cb_data))
1368 if (!(devc = sdi->priv))
1371 /* Although this is correct in general, the USBTMC libusb implementation
1372 * currently does not generate an event prior to the first read. Often
1373 * it is ok to start reading just after the 50ms timeout. See bug #785.
1374 if (revents != G_IO_IN)
1378 ch = devc->current_channel->data;
1379 state = devc->model_state;
1382 * Send "frame begin" packet upon reception of data for the
1383 * first enabled channel.
1385 if (devc->current_channel == devc->enabled_channels) {
1386 packet.type = SR_DF_FRAME_BEGIN;
1387 sr_session_send(sdi, &packet);
1391 * Pass on the received data of the channel(s).
1394 case SR_CHANNEL_ANALOG:
1395 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1397 g_byte_array_free(data, TRUE);
1401 packet.type = SR_DF_ANALOG;
1403 analog.data = data->data;
1404 analog.num_samples = data->len / sizeof(float);
1405 /* Truncate acquisition if a smaller number of samples has been requested. */
1406 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1407 analog.num_samples = devc->samples_limit;
1408 analog.encoding = &encoding;
1409 analog.meaning = &meaning;
1410 analog.spec = &spec;
1412 encoding.unitsize = sizeof(float);
1413 encoding.is_signed = TRUE;
1414 encoding.is_float = TRUE;
1415 #ifdef WORDS_BIGENDIAN
1416 encoding.is_bigendian = TRUE;
1418 encoding.is_bigendian = FALSE;
1420 /* TODO: Use proper 'digits' value for this device (and its modes). */
1421 encoding.digits = 2;
1422 encoding.is_digits_decimal = FALSE;
1423 encoding.scale.p = 1;
1424 encoding.scale.q = 1;
1425 encoding.offset.p = 0;
1426 encoding.offset.q = 1;
1427 if (state->analog_channels[ch->index].probe_unit == 'V') {
1428 meaning.mq = SR_MQ_VOLTAGE;
1429 meaning.unit = SR_UNIT_VOLT;
1431 meaning.mq = SR_MQ_CURRENT;
1432 meaning.unit = SR_UNIT_AMPERE;
1434 meaning.mqflags = 0;
1435 meaning.channels = g_slist_append(NULL, ch);
1436 /* TODO: Use proper 'digits' value for this device (and its modes). */
1437 spec.spec_digits = 2;
1438 packet.payload = &analog;
1439 sr_session_send(sdi, &packet);
1440 devc->num_samples = data->len / sizeof(float);
1441 g_slist_free(meaning.channels);
1442 g_byte_array_free(data, TRUE);
1445 case SR_CHANNEL_LOGIC:
1446 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1448 g_byte_array_free(data, TRUE);
1453 * If only data from the first pod is involved in the
1454 * acquisition, then the raw input bytes can get passed
1455 * forward for performance reasons. When the second pod
1456 * is involved (either alone, or in combination with the
1457 * first pod), then the received bytes need to be put
1458 * into memory in such a layout that all channel groups
1459 * get combined, and a unitsize larger than a single byte
1460 * applies. The "queue" logic transparently copes with
1461 * any such configuration. This works around the lack
1462 * of support for "meaning" to logic data, which is used
1463 * above for analog data.
1465 if (devc->pod_count == 1) {
1466 packet.type = SR_DF_LOGIC;
1467 logic.data = data->data;
1468 logic.length = data->len;
1469 /* Truncate acquisition if a smaller number of samples has been requested. */
1470 if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1471 logic.length = devc->samples_limit;
1473 packet.payload = &logic;
1474 sr_session_send(sdi, &packet);
1476 group = ch->index / 8;
1477 hmo_queue_logic_data(devc, group, data);
1480 devc->num_samples = data->len / devc->pod_count;
1481 g_byte_array_free(data, TRUE);
1485 sr_err("Invalid channel type.");
1490 * Advance to the next enabled channel. When data for all enabled
1491 * channels was received, then flush potentially queued logic data,
1492 * and send the "frame end" packet.
1494 if (devc->current_channel->next) {
1495 devc->current_channel = devc->current_channel->next;
1496 hmo_request_data(sdi);
1499 hmo_send_logic_packet(sdi, devc);
1502 * Release the logic data storage after each frame. This copes
1503 * with sample counts that differ in length per frame. -- Is
1504 * this a real constraint when acquiring multiple frames with
1505 * identical device settings?
1507 hmo_cleanup_logic_data(devc);
1509 packet.type = SR_DF_FRAME_END;
1510 sr_session_send(sdi, &packet);
1513 * End of frame was reached. Stop acquisition after the specified
1514 * number of frames or after the specified number of samples, or
1515 * continue reception by starting over at the first enabled channel.
1517 if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1518 sr_dev_acquisition_stop(sdi);
1519 hmo_cleanup_logic_data(devc);
1521 devc->current_channel = devc->enabled_channels;
1522 hmo_request_data(sdi);