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_HORIZONTAL_DIV] = ":TIM:DIV?",
38 [SCPI_CMD_GET_COUPLING] = ":CHAN%d:COUP?",
39 [SCPI_CMD_SET_COUPLING] = ":CHAN%d:COUP %s",
40 [SCPI_CMD_GET_SAMPLE_RATE] = ":ACQ:SRAT?",
41 [SCPI_CMD_GET_ANALOG_DATA] = ":FORM:BORD %s;" \
42 ":FORM REAL,32;:CHAN%d:DATA?",
43 [SCPI_CMD_GET_VERTICAL_SCALE] = ":CHAN%d:SCAL?",
44 [SCPI_CMD_SET_VERTICAL_SCALE] = ":CHAN%d:SCAL %s",
45 [SCPI_CMD_GET_DIG_POD_STATE] = ":POD%d:STAT?",
46 [SCPI_CMD_SET_DIG_POD_STATE] = ":POD%d:STAT %d",
47 [SCPI_CMD_GET_TRIGGER_SOURCE] = ":TRIG:A:SOUR?",
48 [SCPI_CMD_SET_TRIGGER_SOURCE] = ":TRIG:A:SOUR %s",
49 [SCPI_CMD_GET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP?",
50 [SCPI_CMD_SET_TRIGGER_SLOPE] = ":TRIG:A:TYPE EDGE;:TRIG:A:EDGE:SLOP %s",
51 [SCPI_CMD_GET_TRIGGER_PATTERN] = ":TRIG:A:PATT:SOUR?",
52 [SCPI_CMD_SET_TRIGGER_PATTERN] = ":TRIG:A:TYPE LOGIC;" \
53 ":TRIG:A:PATT:FUNC AND;" \
54 ":TRIG:A:PATT:COND \"TRUE\";" \
55 ":TRIG:A:PATT:MODE OFF;" \
56 ":TRIG:A:PATT:SOUR \"%s\"",
57 [SCPI_CMD_GET_HIGH_RESOLUTION] = ":ACQ:HRES?",
58 [SCPI_CMD_SET_HIGH_RESOLUTION] = ":ACQ:HRES %s",
59 [SCPI_CMD_GET_PEAK_DETECTION] = ":ACQ:PEAK?",
60 [SCPI_CMD_SET_PEAK_DETECTION] = ":ACQ:PEAK %s",
61 [SCPI_CMD_GET_DIG_CHAN_STATE] = ":LOG%d:STAT?",
62 [SCPI_CMD_SET_DIG_CHAN_STATE] = ":LOG%d:STAT %d",
63 [SCPI_CMD_GET_VERTICAL_OFFSET] = ":CHAN%d:POS?",
64 [SCPI_CMD_GET_HORIZ_TRIGGERPOS] = ":TIM:POS?",
65 [SCPI_CMD_SET_HORIZ_TRIGGERPOS] = ":TIM:POS %s",
66 [SCPI_CMD_GET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT?",
67 [SCPI_CMD_SET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT %d",
68 [SCPI_CMD_GET_PROBE_UNIT] = ":PROB%d:SET:ATT:UNIT?",
69 [SCPI_CMD_GET_DIG_POD_THRESHOLD] = ":POD%d:THR?",
70 [SCPI_CMD_SET_DIG_POD_THRESHOLD] = ":POD%d:THR %s",
71 [SCPI_CMD_GET_DIG_POD_USER_THRESHOLD] = ":POD%d:THR:UDL%d?",
72 [SCPI_CMD_SET_DIG_POD_USER_THRESHOLD] = ":POD%d:THR:UDL%d %s",
75 static const char *rohde_schwarz_log_not_pod_scpi_dialect[] = {
76 [SCPI_CMD_GET_DIG_DATA] = ":FORM UINT,8;:LOG%d:DATA?",
77 [SCPI_CMD_GET_TIMEBASE] = ":TIM:SCAL?",
78 [SCPI_CMD_SET_TIMEBASE] = ":TIM:SCAL %s",
79 [SCPI_CMD_GET_HORIZONTAL_DIV] = ":TIM:DIV?",
80 [SCPI_CMD_GET_COUPLING] = ":CHAN%d:COUP?",
81 [SCPI_CMD_SET_COUPLING] = ":CHAN%d:COUP %s",
82 [SCPI_CMD_GET_SAMPLE_RATE] = ":ACQ:SRAT?",
83 [SCPI_CMD_GET_ANALOG_DATA] = ":FORM:BORD %s;" \
84 ":FORM REAL,32;:CHAN%d:DATA?",
85 [SCPI_CMD_GET_VERTICAL_SCALE] = ":CHAN%d:SCAL?",
86 [SCPI_CMD_SET_VERTICAL_SCALE] = ":CHAN%d:SCAL %s",
87 [SCPI_CMD_GET_DIG_POD_STATE] = ":LOG%d:STAT?",
88 [SCPI_CMD_SET_DIG_POD_STATE] = ":LOG%d:STAT %d",
89 [SCPI_CMD_GET_TRIGGER_SOURCE] = ":TRIG:A:SOUR?",
90 [SCPI_CMD_SET_TRIGGER_SOURCE] = ":TRIG:A:SOUR %s",
91 [SCPI_CMD_GET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP?",
92 [SCPI_CMD_SET_TRIGGER_SLOPE] = ":TRIG:A:TYPE EDGE;:TRIG:A:EDGE:SLOP %s",
93 [SCPI_CMD_GET_TRIGGER_PATTERN] = ":TRIG:A:PATT:SOUR?",
94 [SCPI_CMD_SET_TRIGGER_PATTERN] = ":TRIG:A:TYPE LOGIC;" \
95 ":TRIG:A:PATT:FUNC AND;" \
96 ":TRIG:A:PATT:COND \"TRUE\";" \
97 ":TRIG:A:PATT:MODE OFF;" \
98 ":TRIG:A:PATT:SOUR \"%s\"",
99 [SCPI_CMD_GET_HIGH_RESOLUTION] = ":ACQ:HRES?",
100 [SCPI_CMD_SET_HIGH_RESOLUTION] = ":ACQ:HRES %s",
101 [SCPI_CMD_GET_PEAK_DETECTION] = ":ACQ:PEAK?",
102 [SCPI_CMD_SET_PEAK_DETECTION] = ":ACQ:PEAK %s",
103 [SCPI_CMD_GET_DIG_CHAN_STATE] = ":LOG%d:STAT?",
104 [SCPI_CMD_SET_DIG_CHAN_STATE] = ":LOG%d:STAT %d",
105 [SCPI_CMD_GET_VERTICAL_OFFSET] = ":CHAN%d:POS?", /* Might not be supported on RTB200x... */
106 [SCPI_CMD_GET_HORIZ_TRIGGERPOS] = ":TIM:POS?",
107 [SCPI_CMD_SET_HORIZ_TRIGGERPOS] = ":TIM:POS %s",
108 [SCPI_CMD_GET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT?",
109 [SCPI_CMD_SET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT %d",
110 [SCPI_CMD_GET_PROBE_UNIT] = ":PROB%d:SET:ATT:UNIT?",
111 [SCPI_CMD_GET_DIG_POD_THRESHOLD] = ":DIG%d:TECH?",
112 [SCPI_CMD_SET_DIG_POD_THRESHOLD] = ":DIG%d:TECH %s",
113 [SCPI_CMD_GET_DIG_POD_USER_THRESHOLD] = ":DIG%d:THR?",
114 [SCPI_CMD_SET_DIG_POD_USER_THRESHOLD] = ":DIG%d:THR %s",
117 static const uint32_t devopts[] = {
118 SR_CONF_OSCILLOSCOPE,
119 SR_CONF_LIMIT_SAMPLES | SR_CONF_SET,
120 SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET,
121 SR_CONF_SAMPLERATE | SR_CONF_GET,
122 SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
123 SR_CONF_NUM_HDIV | SR_CONF_GET,
124 SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
125 SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
126 SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
127 SR_CONF_TRIGGER_PATTERN | SR_CONF_GET | SR_CONF_SET,
128 SR_CONF_HIGH_RESOLUTION | SR_CONF_GET | SR_CONF_SET,
129 SR_CONF_PEAK_DETECTION | SR_CONF_GET | SR_CONF_SET,
132 static const uint32_t devopts_cg_analog[] = {
133 SR_CONF_NUM_VDIV | SR_CONF_GET,
134 SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
135 SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
138 static const uint32_t devopts_cg_digital[] = {
139 SR_CONF_LOGIC_THRESHOLD | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
140 SR_CONF_LOGIC_THRESHOLD_CUSTOM | SR_CONF_GET | SR_CONF_SET,
143 static const char *coupling_options[] = {
144 "AC", // AC with 50 Ohm termination (152x, 202x, 30xx, 1202)
145 "ACL", // AC with 1 MOhm termination
146 "DC", // DC with 50 Ohm termination
147 "DCL", // DC with 1 MOhm termination
151 static const char *coupling_options_rtb200x[] = {
152 "ACL", // AC with 1 MOhm termination
153 "DCL", // DC with 1 MOhm termination
157 static const char *coupling_options_rtm300x[] = {
158 "ACL", // AC with 1 MOhm termination
159 "DC", // DC with 50 Ohm termination
160 "DCL", // DC with 1 MOhm termination
164 static const char *coupling_options_rth100x[] = {
165 "ACL", // AC with 1 MOhm termination
166 "DCL", // DC with 1 MOhm termination
169 static const char *scope_trigger_slopes[] = {
175 /* Predefined logic thresholds. */
176 static const char *logic_threshold[] = {
181 "USER2", // overwritten by logic_threshold_custom, use USER1 for permanent setting
184 static const char *logic_threshold_rtb200x_rtm300x[] = {
188 "MAN", // overwritten by logic_threshold_custom
191 /* This might need updates whenever logic_threshold* above change. */
192 #define MAX_NUM_LOGIC_THRESHOLD_ENTRIES ARRAY_SIZE(logic_threshold)
194 /* RTC1002, HMO Compact2 and HMO1002/HMO1202 */
195 static const char *an2_dig8_trigger_sources[] = {
197 "LINE", "EXT", "PATT", "BUS1", "BUS2",
198 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
202 static const char *an2_dig16_trigger_sources[] = {
204 "LINE", "EXT", "PATT", "BUS1", "BUS2",
205 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
206 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
209 /* RTB2002 and RTM3002 */
210 static const char *an2_dig16_sbus_trigger_sources[] = {
212 "LINE", "EXT", "PATT", "SBUS1", "SBUS2",
213 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
214 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
218 static const char *an2_dig8_isol_trigger_sources[] = {
220 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
224 static const char *an4_dig8_trigger_sources[] = {
225 "CH1", "CH2", "CH3", "CH4",
226 "LINE", "EXT", "PATT", "BUS1", "BUS2",
227 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
230 /* HMO3xx4 and HMO2524 */
231 static const char *an4_dig16_trigger_sources[] = {
232 "CH1", "CH2", "CH3", "CH4",
233 "LINE", "EXT", "PATT", "BUS1", "BUS2",
234 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
235 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
238 /* RTB2004, RTM3004 and RTA4004 */
239 static const char *an4_dig16_sbus_trigger_sources[] = {
240 "CH1", "CH2", "CH3", "CH4",
241 "LINE", "EXT", "PATT", "SBUS1", "SBUS2",
242 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
243 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
247 static const char *an4_dig8_isol_trigger_sources[] = {
248 "CH1", "CH2", "CH3", "CH4",
249 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
252 static const uint64_t timebases[][2] = {
292 /* HMO Compact series (HMO722/724/1022/1024/1522/1524/2022/2024) do
293 * not support 1 ns timebase setting.
295 static const uint64_t timebases_hmo_compact[][2] = {
334 static const uint64_t vdivs[][2] = {
354 * It feels a little hacky to use a single table yet use different item
355 * count values here. But it simplifies maintenance, reduces redundancy
356 * by avoiding several vdivs[] table versions of mostly identical content,
357 * still references which declare models' capabilities remain readable.
359 #define VDIVS_COUNT_UPTO_10V (ARRAY_SIZE(vdivs) - 2)
360 #define VDIVS_COUNT_UPTO_50V (ARRAY_SIZE(vdivs))
362 static const char *scope_analog_channel_names[] = {
363 "CH1", "CH2", "CH3", "CH4",
366 static const char *scope_digital_channel_names[] = {
367 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
368 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
371 static struct scope_config scope_models[] = {
373 /* HMO Compact2: HMO722/1022/1522/2022 support only 8 digital channels. */
374 .name = {"HMO722", "HMO1022", "HMO1522", "HMO2022", NULL},
375 .analog_channels = 2,
376 .digital_channels = 8,
378 .analog_names = &scope_analog_channel_names,
379 .digital_names = &scope_digital_channel_names,
382 .num_devopts = ARRAY_SIZE(devopts),
384 .devopts_cg_analog = &devopts_cg_analog,
385 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
387 .devopts_cg_digital = &devopts_cg_digital,
388 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
390 .coupling_options = &coupling_options,
391 .num_coupling_options = ARRAY_SIZE(coupling_options),
393 .logic_threshold = &logic_threshold,
394 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
395 .logic_threshold_for_pod = TRUE,
397 .trigger_sources = &an2_dig8_trigger_sources,
398 .num_trigger_sources = ARRAY_SIZE(an2_dig8_trigger_sources),
400 .trigger_slopes = &scope_trigger_slopes,
401 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
403 .timebases = &timebases_hmo_compact,
404 .num_timebases = ARRAY_SIZE(timebases_hmo_compact),
407 .num_vdivs = VDIVS_COUNT_UPTO_10V,
411 .scpi_dialect = &hameg_scpi_dialect,
414 /* RTC1002 and HMO1002/HMO1202 support only 8 digital channels. */
415 .name = {"RTC1002", "HMO1002", "HMO1202", NULL},
416 .analog_channels = 2,
417 .digital_channels = 8,
419 .analog_names = &scope_analog_channel_names,
420 .digital_names = &scope_digital_channel_names,
423 .num_devopts = ARRAY_SIZE(devopts),
425 .devopts_cg_analog = &devopts_cg_analog,
426 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
428 .devopts_cg_digital = &devopts_cg_digital,
429 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
431 .coupling_options = &coupling_options,
432 .num_coupling_options = ARRAY_SIZE(coupling_options),
434 .logic_threshold = &logic_threshold,
435 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
436 .logic_threshold_for_pod = TRUE,
438 .trigger_sources = &an2_dig8_trigger_sources,
439 .num_trigger_sources = ARRAY_SIZE(an2_dig8_trigger_sources),
441 .trigger_slopes = &scope_trigger_slopes,
442 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
444 .timebases = &timebases,
445 .num_timebases = ARRAY_SIZE(timebases),
448 .num_vdivs = VDIVS_COUNT_UPTO_10V,
452 .scpi_dialect = &hameg_scpi_dialect,
455 /* HMO3032/3042/3052/3522 support 16 digital channels. */
456 .name = {"HMO3032", "HMO3042", "HMO3052", "HMO3522", NULL},
457 .analog_channels = 2,
458 .digital_channels = 16,
460 .analog_names = &scope_analog_channel_names,
461 .digital_names = &scope_digital_channel_names,
464 .num_devopts = ARRAY_SIZE(devopts),
466 .devopts_cg_analog = &devopts_cg_analog,
467 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
469 .devopts_cg_digital = &devopts_cg_digital,
470 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
472 .coupling_options = &coupling_options,
473 .num_coupling_options = ARRAY_SIZE(coupling_options),
475 .logic_threshold = &logic_threshold,
476 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
477 .logic_threshold_for_pod = TRUE,
479 .trigger_sources = &an2_dig16_trigger_sources,
480 .num_trigger_sources = ARRAY_SIZE(an2_dig16_trigger_sources),
482 .trigger_slopes = &scope_trigger_slopes,
483 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
485 .timebases = &timebases,
486 .num_timebases = ARRAY_SIZE(timebases),
489 .num_vdivs = VDIVS_COUNT_UPTO_10V,
493 .scpi_dialect = &hameg_scpi_dialect,
496 /* HMO Compact4: HMO724/1024/1524/2024 support only 8 digital channels. */
497 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
498 .analog_channels = 4,
499 .digital_channels = 8,
501 .analog_names = &scope_analog_channel_names,
502 .digital_names = &scope_digital_channel_names,
505 .num_devopts = ARRAY_SIZE(devopts),
507 .devopts_cg_analog = &devopts_cg_analog,
508 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
510 .devopts_cg_digital = &devopts_cg_digital,
511 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
513 .coupling_options = &coupling_options,
514 .num_coupling_options = ARRAY_SIZE(coupling_options),
516 .logic_threshold = &logic_threshold,
517 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
518 .logic_threshold_for_pod = TRUE,
520 .trigger_sources = &an4_dig8_trigger_sources,
521 .num_trigger_sources = ARRAY_SIZE(an4_dig8_trigger_sources),
523 .trigger_slopes = &scope_trigger_slopes,
524 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
526 .timebases = &timebases_hmo_compact,
527 .num_timebases = ARRAY_SIZE(timebases_hmo_compact),
530 .num_vdivs = VDIVS_COUNT_UPTO_10V,
534 .scpi_dialect = &hameg_scpi_dialect,
537 .name = {"HMO2524", "HMO3034", "HMO3044", "HMO3054", "HMO3524", NULL},
538 .analog_channels = 4,
539 .digital_channels = 16,
541 .analog_names = &scope_analog_channel_names,
542 .digital_names = &scope_digital_channel_names,
545 .num_devopts = ARRAY_SIZE(devopts),
547 .devopts_cg_analog = &devopts_cg_analog,
548 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
550 .devopts_cg_digital = &devopts_cg_digital,
551 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
553 .coupling_options = &coupling_options,
554 .num_coupling_options = ARRAY_SIZE(coupling_options),
556 .logic_threshold = &logic_threshold,
557 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
558 .logic_threshold_for_pod = TRUE,
560 .trigger_sources = &an4_dig16_trigger_sources,
561 .num_trigger_sources = ARRAY_SIZE(an4_dig16_trigger_sources),
563 .trigger_slopes = &scope_trigger_slopes,
564 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
566 .timebases = &timebases,
567 .num_timebases = ARRAY_SIZE(timebases),
570 .num_vdivs = VDIVS_COUNT_UPTO_10V,
574 .scpi_dialect = &hameg_scpi_dialect,
577 .name = {"RTB2002", NULL},
578 .analog_channels = 2,
579 .digital_channels = 16,
581 .analog_names = &scope_analog_channel_names,
582 .digital_names = &scope_digital_channel_names,
585 .num_devopts = ARRAY_SIZE(devopts),
587 .devopts_cg_analog = &devopts_cg_analog,
588 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
590 .devopts_cg_digital = &devopts_cg_digital,
591 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
593 .coupling_options = &coupling_options_rtb200x,
594 .num_coupling_options = ARRAY_SIZE(coupling_options_rtb200x),
596 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
597 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
598 .logic_threshold_for_pod = FALSE,
600 .trigger_sources = &an2_dig16_sbus_trigger_sources,
601 .num_trigger_sources = ARRAY_SIZE(an2_dig16_sbus_trigger_sources),
603 .trigger_slopes = &scope_trigger_slopes,
604 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
606 .timebases = &timebases,
607 .num_timebases = ARRAY_SIZE(timebases),
610 .num_vdivs = VDIVS_COUNT_UPTO_50V,
614 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
617 .name = {"RTB2004", NULL},
618 .analog_channels = 4,
619 .digital_channels = 16,
621 .analog_names = &scope_analog_channel_names,
622 .digital_names = &scope_digital_channel_names,
625 .num_devopts = ARRAY_SIZE(devopts),
627 .devopts_cg_analog = &devopts_cg_analog,
628 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
630 .devopts_cg_digital = &devopts_cg_digital,
631 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
633 .coupling_options = &coupling_options_rtb200x,
634 .num_coupling_options = ARRAY_SIZE(coupling_options_rtb200x),
636 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
637 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
638 .logic_threshold_for_pod = FALSE,
640 .trigger_sources = &an4_dig16_sbus_trigger_sources,
641 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
643 .trigger_slopes = &scope_trigger_slopes,
644 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
646 .timebases = &timebases,
647 .num_timebases = ARRAY_SIZE(timebases),
650 .num_vdivs = VDIVS_COUNT_UPTO_50V,
654 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
657 .name = {"RTM3002", NULL},
658 .analog_channels = 2,
659 .digital_channels = 16,
661 .analog_names = &scope_analog_channel_names,
662 .digital_names = &scope_digital_channel_names,
665 .num_devopts = ARRAY_SIZE(devopts),
667 .devopts_cg_analog = &devopts_cg_analog,
668 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
670 .devopts_cg_digital = &devopts_cg_digital,
671 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
673 .coupling_options = &coupling_options_rtm300x,
674 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
676 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
677 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
678 .logic_threshold_for_pod = FALSE,
680 .trigger_sources = &an2_dig16_sbus_trigger_sources,
681 .num_trigger_sources = ARRAY_SIZE(an2_dig16_sbus_trigger_sources),
683 .trigger_slopes = &scope_trigger_slopes,
684 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
686 .timebases = &timebases,
687 .num_timebases = ARRAY_SIZE(timebases),
690 .num_vdivs = VDIVS_COUNT_UPTO_10V,
694 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
697 .name = {"RTM3004", NULL},
698 .analog_channels = 4,
699 .digital_channels = 16,
701 .analog_names = &scope_analog_channel_names,
702 .digital_names = &scope_digital_channel_names,
705 .num_devopts = ARRAY_SIZE(devopts),
707 .devopts_cg_analog = &devopts_cg_analog,
708 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
710 .devopts_cg_digital = &devopts_cg_digital,
711 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
713 .coupling_options = &coupling_options_rtm300x,
714 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
716 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
717 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
718 .logic_threshold_for_pod = FALSE,
720 .trigger_sources = &an4_dig16_sbus_trigger_sources,
721 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
723 .trigger_slopes = &scope_trigger_slopes,
724 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
726 .timebases = &timebases,
727 .num_timebases = ARRAY_SIZE(timebases),
730 .num_vdivs = VDIVS_COUNT_UPTO_10V,
734 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
737 .name = {"RTA4004", NULL},
738 .analog_channels = 4,
739 .digital_channels = 16,
741 .analog_names = &scope_analog_channel_names,
742 .digital_names = &scope_digital_channel_names,
745 .num_devopts = ARRAY_SIZE(devopts),
747 .devopts_cg_analog = &devopts_cg_analog,
748 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
750 .devopts_cg_digital = &devopts_cg_digital,
751 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
753 .coupling_options = &coupling_options_rtm300x,
754 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
756 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
757 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
758 .logic_threshold_for_pod = FALSE,
760 .trigger_sources = &an4_dig16_sbus_trigger_sources,
761 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
763 .trigger_slopes = &scope_trigger_slopes,
764 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
766 .timebases = &timebases,
767 .num_timebases = ARRAY_SIZE(timebases),
770 .num_vdivs = VDIVS_COUNT_UPTO_10V,
774 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
776 /* RTH1002 & RTH1004 are both identified as RTH */
778 .name = {"RTH", NULL},
779 .analog_channels = 4,
780 .digital_channels = 8,
782 .analog_names = &scope_analog_channel_names,
783 .digital_names = &scope_digital_channel_names,
786 .num_devopts = ARRAY_SIZE(devopts),
788 .devopts_cg_analog = &devopts_cg_analog,
789 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
791 .devopts_cg_digital = &devopts_cg_digital,
792 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
794 .coupling_options = &coupling_options_rth100x,
795 .num_coupling_options = ARRAY_SIZE(coupling_options_rth100x),
797 .logic_threshold = &logic_threshold,
798 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
799 .logic_threshold_for_pod = TRUE,
801 .trigger_sources = &an4_dig8_isol_trigger_sources,
802 .num_trigger_sources = ARRAY_SIZE(an4_dig8_isol_trigger_sources),
804 .trigger_slopes = &scope_trigger_slopes,
805 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
807 .timebases = &timebases,
808 .num_timebases = ARRAY_SIZE(timebases),
811 .num_vdivs = ARRAY_SIZE(vdivs),
815 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
819 static void scope_state_dump(const struct scope_config *config,
820 struct scope_state *state)
825 for (i = 0; i < config->analog_channels; i++) {
826 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
827 (*config->vdivs)[state->analog_channels[i].vdiv][1]);
828 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
829 i + 1, state->analog_channels[i].state ? "On" : "Off",
830 (*config->coupling_options)[state->analog_channels[i].coupling],
831 tmp, state->analog_channels[i].vertical_offset);
834 for (i = 0; i < config->digital_channels; i++) {
835 sr_info("State of digital channel %d -> %s", i,
836 state->digital_channels[i] ? "On" : "Off");
839 for (i = 0; i < config->digital_pods; i++) {
840 if (!strncmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold], 4) ||
841 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
842 sr_info("State of digital POD %d -> %s : %E (threshold)", i + 1,
843 state->digital_pods[i].state ? "On" : "Off",
844 state->digital_pods[i].user_threshold);
846 sr_info("State of digital POD %d -> %s : %s (threshold)", i + 1,
847 state->digital_pods[i].state ? "On" : "Off",
848 (*config->logic_threshold)[state->digital_pods[i].threshold]);
851 tmp = sr_period_string((*config->timebases)[state->timebase][0],
852 (*config->timebases)[state->timebase][1]);
853 sr_info("Current timebase: %s", tmp);
856 tmp = sr_samplerate_string(state->sample_rate);
857 sr_info("Current samplerate: %s", tmp);
860 if (!strcmp("PATT", (*config->trigger_sources)[state->trigger_source]))
861 sr_info("Current trigger: %s (pattern), %.2f (offset)",
862 state->trigger_pattern,
863 state->horiz_triggerpos);
864 else // Edge (slope) trigger
865 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
866 (*config->trigger_sources)[state->trigger_source],
867 (*config->trigger_slopes)[state->trigger_slope],
868 state->horiz_triggerpos);
871 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
872 const char *command, const char *(*array)[], unsigned int n, int *result)
877 if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK)
880 if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
893 * This function takes a value of the form "2.000E-03" and returns the index
894 * of an array where a matching pair was found.
896 * @param value The string to be parsed.
897 * @param array The array of s/f pairs.
898 * @param array_len The number of pairs in the array.
899 * @param result The index at which a matching pair was found.
901 * @return SR_ERR on any parsing error, SR_OK otherwise.
903 static int array_float_get(gchar *value, const uint64_t array[][2],
904 int array_len, unsigned int *result)
906 struct sr_rational rval;
907 struct sr_rational aval;
909 if (sr_parse_rational(value, &rval) != SR_OK)
912 for (int i = 0; i < array_len; i++) {
913 sr_rational_set(&aval, array[i][0], array[i][1]);
914 if (sr_rational_eq(&rval, &aval)) {
923 static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
926 while (channel_lhead) {
927 struct sr_channel *ch = channel_lhead->data;
928 if (ch->index == index && ch->type == type)
931 channel_lhead = channel_lhead->next;
937 static int analog_channel_state_get(struct sr_dev_inst *sdi,
938 const struct scope_config *config,
939 struct scope_state *state)
942 char command[MAX_COMMAND_SIZE];
944 struct sr_channel *ch;
945 struct sr_scpi_dev_inst *scpi = sdi->conn;
947 for (i = 0; i < config->analog_channels; i++) {
948 g_snprintf(command, sizeof(command),
949 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
952 if (sr_scpi_get_bool(scpi, command,
953 &state->analog_channels[i].state) != SR_OK)
956 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
958 ch->enabled = state->analog_channels[i].state;
960 g_snprintf(command, sizeof(command),
961 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_SCALE],
964 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
967 if (array_float_get(tmp_str, *(config->vdivs), config->num_vdivs, &j) != SR_OK) {
969 sr_err("Could not determine array index for vertical div scale.");
974 state->analog_channels[i].vdiv = j;
976 g_snprintf(command, sizeof(command),
977 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
980 if (sr_scpi_get_float(scpi, command,
981 &state->analog_channels[i].vertical_offset) != SR_OK)
984 g_snprintf(command, sizeof(command),
985 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
988 if (scope_state_get_array_option(scpi, command, config->coupling_options,
989 config->num_coupling_options,
990 &state->analog_channels[i].coupling) != SR_OK)
993 g_snprintf(command, sizeof(command),
994 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
997 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
1000 if (tmp_str[0] == 'A')
1001 state->analog_channels[i].probe_unit = 'A';
1003 state->analog_channels[i].probe_unit = 'V';
1010 static int digital_channel_state_get(struct sr_dev_inst *sdi,
1011 const struct scope_config *config,
1012 struct scope_state *state)
1014 unsigned int i, idx;
1015 int result = SR_ERR;
1016 char *logic_threshold_short[MAX_NUM_LOGIC_THRESHOLD_ENTRIES];
1017 char command[MAX_COMMAND_SIZE];
1018 struct sr_channel *ch;
1019 struct sr_scpi_dev_inst *scpi = sdi->conn;
1021 for (i = 0; i < config->digital_channels; i++) {
1022 g_snprintf(command, sizeof(command),
1023 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
1026 if (sr_scpi_get_bool(scpi, command,
1027 &state->digital_channels[i]) != SR_OK)
1030 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
1032 ch->enabled = state->digital_channels[i];
1035 /* According to the SCPI standard, on models that support multiple
1036 * user-defined logic threshold settings the response to the command
1037 * SCPI_CMD_GET_DIG_POD_THRESHOLD might return "USER" instead of
1040 * This makes more difficult to validate the response when the logic
1041 * threshold is set to "USER1" and therefore we need to prevent device
1042 * opening failures in such configuration case...
1044 for (i = 0; i < config->num_logic_threshold; i++) {
1045 logic_threshold_short[i] = g_strdup((*config->logic_threshold)[i]);
1046 if (!strcmp("USER1", (*config->logic_threshold)[i]))
1047 g_strlcpy(logic_threshold_short[i],
1048 (*config->logic_threshold)[i], strlen((*config->logic_threshold)[i]));
1051 for (i = 0; i < config->digital_pods; i++) {
1052 g_snprintf(command, sizeof(command),
1053 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
1056 if (sr_scpi_get_bool(scpi, command,
1057 &state->digital_pods[i].state) != SR_OK)
1060 /* Check if the threshold command is based on the POD or digital channel index. */
1061 if (config->logic_threshold_for_pod)
1064 idx = i * DIGITAL_CHANNELS_PER_POD;
1066 g_snprintf(command, sizeof(command),
1067 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_THRESHOLD],
1070 /* Check for both standard and shortened responses. */
1071 if (scope_state_get_array_option(scpi, command, config->logic_threshold,
1072 config->num_logic_threshold,
1073 &state->digital_pods[i].threshold) != SR_OK)
1074 if (scope_state_get_array_option(scpi, command, (const char * (*)[]) &logic_threshold_short,
1075 config->num_logic_threshold,
1076 &state->digital_pods[i].threshold) != SR_OK)
1079 /* If used-defined or custom threshold is active, get the level. */
1080 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1081 g_snprintf(command, sizeof(command),
1082 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1083 idx, 1); /* USER1 logic threshold setting. */
1084 else if (!strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1085 g_snprintf(command, sizeof(command),
1086 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1087 idx, 2); /* USER2 for custom logic_threshold setting. */
1088 else if (!strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1089 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1090 g_snprintf(command, sizeof(command),
1091 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1092 idx); /* USER or MAN for custom logic_threshold setting. */
1093 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1094 !strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1095 !strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1096 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1097 if (sr_scpi_get_float(scpi, command,
1098 &state->digital_pods[i].user_threshold) != SR_OK)
1105 for (i = 0; i < config->num_logic_threshold; i++)
1106 g_free(logic_threshold_short[i]);
1111 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
1113 struct dev_context *devc;
1114 struct scope_state *state;
1115 const struct scope_config *config;
1119 config = devc->model_config;
1120 state = devc->model_state;
1122 if (sr_scpi_get_float(sdi->conn,
1123 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
1124 &tmp_float) != SR_OK)
1127 state->sample_rate = tmp_float;
1132 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
1134 struct dev_context *devc;
1135 struct scope_state *state;
1136 const struct scope_config *config;
1142 config = devc->model_config;
1143 state = devc->model_state;
1145 sr_info("Fetching scope state");
1147 if (analog_channel_state_get(sdi, config, state) != SR_OK)
1150 if (digital_channel_state_get(sdi, config, state) != SR_OK)
1153 if (sr_scpi_get_string(sdi->conn,
1154 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
1158 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
1160 sr_err("Could not determine array index for time base.");
1165 state->timebase = i;
1167 /* Determine the number of horizontal (x) divisions. */
1168 if (sr_scpi_get_int(sdi->conn,
1169 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZONTAL_DIV],
1170 (int *)&config->num_xdivs) != SR_OK)
1173 if (sr_scpi_get_float(sdi->conn,
1174 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
1175 &tmp_float) != SR_OK)
1177 state->horiz_triggerpos = tmp_float /
1178 (((double) (*config->timebases)[state->timebase][0] /
1179 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
1180 state->horiz_triggerpos -= 0.5;
1181 state->horiz_triggerpos *= -1;
1183 if (scope_state_get_array_option(sdi->conn,
1184 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
1185 config->trigger_sources, config->num_trigger_sources,
1186 &state->trigger_source) != SR_OK)
1189 if (scope_state_get_array_option(sdi->conn,
1190 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
1191 config->trigger_slopes, config->num_trigger_slopes,
1192 &state->trigger_slope) != SR_OK)
1195 if (sr_scpi_get_string(sdi->conn,
1196 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_PATTERN],
1199 strncpy(state->trigger_pattern,
1200 sr_scpi_unquote_string(tmp_str),
1201 MAX_ANALOG_CHANNEL_COUNT + MAX_DIGITAL_CHANNEL_COUNT);
1204 if (sr_scpi_get_string(sdi->conn,
1205 (*config->scpi_dialect)[SCPI_CMD_GET_HIGH_RESOLUTION],
1208 if (!strcmp("OFF", tmp_str))
1209 state->high_resolution = FALSE;
1211 state->high_resolution = TRUE;
1214 if (sr_scpi_get_string(sdi->conn,
1215 (*config->scpi_dialect)[SCPI_CMD_GET_PEAK_DETECTION],
1218 if (!strcmp("OFF", tmp_str))
1219 state->peak_detection = FALSE;
1221 state->peak_detection = TRUE;
1224 if (hmo_update_sample_rate(sdi) != SR_OK)
1227 sr_info("Fetching finished.");
1229 scope_state_dump(config, state);
1234 static struct scope_state *scope_state_new(const struct scope_config *config)
1236 struct scope_state *state;
1238 state = g_malloc0(sizeof(struct scope_state));
1239 state->analog_channels = g_malloc0_n(config->analog_channels,
1240 sizeof(struct analog_channel_state));
1241 state->digital_channels = g_malloc0_n(
1242 config->digital_channels, sizeof(gboolean));
1243 state->digital_pods = g_malloc0_n(config->digital_pods,
1244 sizeof(struct digital_pod_state));
1249 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
1251 g_free(state->analog_channels);
1252 g_free(state->digital_channels);
1253 g_free(state->digital_pods);
1257 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
1260 unsigned int i, j, group;
1261 struct sr_channel *ch;
1262 struct dev_context *devc;
1263 const char *cg_name;
1269 /* Find the exact model. */
1270 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
1271 for (j = 0; scope_models[i].name[j]; j++) {
1272 if (!strcmp(sdi->model, scope_models[i].name[j])) {
1277 if (model_index != -1)
1281 if (model_index == -1) {
1282 sr_dbg("Unsupported device.");
1286 /* Configure the number of PODs given the number of digital channels. */
1287 scope_models[model_index].digital_pods = scope_models[model_index].digital_channels / DIGITAL_CHANNELS_PER_POD;
1289 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1290 scope_models[model_index].analog_channels);
1291 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1292 scope_models[model_index].digital_pods);
1293 if (!devc->analog_groups || !devc->digital_groups) {
1294 g_free(devc->analog_groups);
1295 g_free(devc->digital_groups);
1296 return SR_ERR_MALLOC;
1299 /* Add analog channels. */
1300 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
1301 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
1302 (*scope_models[model_index].analog_names)[i]);
1304 cg_name = (*scope_models[model_index].analog_names)[i];
1305 devc->analog_groups[i] = sr_channel_group_new(sdi, cg_name, NULL);
1306 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
1309 /* Add digital channel groups. */
1311 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
1312 devc->digital_groups[i] = sr_channel_group_new(sdi, NULL, NULL);
1313 if (!devc->digital_groups[i]) {
1314 ret = SR_ERR_MALLOC;
1317 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i + 1);
1322 /* Add digital channels. */
1323 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
1324 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
1325 (*scope_models[model_index].digital_names)[i]);
1327 group = i / DIGITAL_CHANNELS_PER_POD;
1328 devc->digital_groups[group]->channels = g_slist_append(
1329 devc->digital_groups[group]->channels, ch);
1332 devc->model_config = &scope_models[model_index];
1333 devc->samples_limit = 0;
1334 devc->frame_limit = 0;
1336 if (!(devc->model_state = scope_state_new(devc->model_config)))
1337 return SR_ERR_MALLOC;
1342 /* Queue data of one channel group, for later submission. */
1343 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
1344 size_t group, GByteArray *pod_data)
1348 uint8_t *logic_data;
1349 size_t idx, logic_step;
1352 * Upon first invocation, allocate the array which can hold the
1353 * combined logic data for all channels. Assume that each channel
1354 * will yield an identical number of samples per receive call.
1356 * As a poor man's safety measure: (Silently) skip processing
1357 * for unexpected sample counts, and ignore samples for
1358 * unexpected channel groups. Don't bother with complicated
1359 * resize logic, considering that many models only support one
1360 * pod, and the most capable supported models have two pods of
1361 * identical size. We haven't yet seen any "odd" configuration.
1363 if (!devc->logic_data) {
1364 size = pod_data->len * devc->pod_count;
1365 store = g_byte_array_sized_new(size);
1366 memset(store->data, 0, size);
1367 store = g_byte_array_set_size(store, size);
1368 devc->logic_data = store;
1370 store = devc->logic_data;
1371 size = store->len / devc->pod_count;
1372 if (group >= devc->pod_count)
1377 * Fold the data of the most recently received channel group into
1378 * the storage, where data resides for all channels combined.
1380 logic_data = store->data;
1381 logic_data += group;
1382 logic_step = devc->pod_count;
1383 for (idx = 0; idx < pod_data->len; idx++) {
1384 *logic_data = pod_data->data[idx];
1385 logic_data += logic_step;
1388 /* Truncate acquisition if a smaller number of samples has been requested. */
1389 if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
1390 devc->logic_data->len = devc->samples_limit * devc->pod_count;
1393 /* Submit data for all channels, after the individual groups got collected. */
1394 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
1395 struct dev_context *devc)
1397 struct sr_datafeed_packet packet;
1398 struct sr_datafeed_logic logic;
1400 if (!devc->logic_data)
1403 logic.data = devc->logic_data->data;
1404 logic.length = devc->logic_data->len;
1405 logic.unitsize = devc->pod_count;
1407 packet.type = SR_DF_LOGIC;
1408 packet.payload = &logic;
1410 sr_session_send(sdi, &packet);
1413 /* Undo previous resource allocation. */
1414 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
1417 if (devc->logic_data) {
1418 g_byte_array_free(devc->logic_data, TRUE);
1419 devc->logic_data = NULL;
1422 * Keep 'pod_count'! It's required when more frames will be
1423 * received, and does not harm when kept after acquisition.
1427 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
1429 struct sr_channel *ch;
1430 struct sr_dev_inst *sdi;
1431 struct dev_context *devc;
1432 struct scope_state *state;
1433 struct sr_datafeed_packet packet;
1435 struct sr_datafeed_analog analog;
1436 struct sr_analog_encoding encoding;
1437 struct sr_analog_meaning meaning;
1438 struct sr_analog_spec spec;
1439 struct sr_datafeed_logic logic;
1445 if (!(sdi = cb_data))
1448 if (!(devc = sdi->priv))
1451 /* Although this is correct in general, the USBTMC libusb implementation
1452 * currently does not generate an event prior to the first read. Often
1453 * it is ok to start reading just after the 50ms timeout. See bug #785.
1454 if (revents != G_IO_IN)
1458 ch = devc->current_channel->data;
1459 state = devc->model_state;
1462 * Send "frame begin" packet upon reception of data for the
1463 * first enabled channel.
1465 if (devc->current_channel == devc->enabled_channels)
1466 std_session_send_df_frame_begin(sdi);
1469 * Pass on the received data of the channel(s).
1472 case SR_CHANNEL_ANALOG:
1474 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1476 g_byte_array_free(data, TRUE);
1480 packet.type = SR_DF_ANALOG;
1482 analog.data = data->data;
1483 analog.num_samples = data->len / sizeof(float);
1484 /* Truncate acquisition if a smaller number of samples has been requested. */
1485 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1486 analog.num_samples = devc->samples_limit;
1487 /* TODO: Use proper 'digits' value for this device (and its modes). */
1488 sr_analog_init(&analog, &encoding, &meaning, &spec, 2);
1489 encoding.is_signed = TRUE;
1490 if (state->analog_channels[ch->index].probe_unit == 'V') {
1491 meaning.mq = SR_MQ_VOLTAGE;
1492 meaning.unit = SR_UNIT_VOLT;
1494 meaning.mq = SR_MQ_CURRENT;
1495 meaning.unit = SR_UNIT_AMPERE;
1497 meaning.channels = g_slist_append(NULL, ch);
1498 packet.payload = &analog;
1499 sr_session_send(sdi, &packet);
1500 devc->num_samples = data->len / sizeof(float);
1501 g_slist_free(meaning.channels);
1502 g_byte_array_free(data, TRUE);
1505 case SR_CHANNEL_LOGIC:
1507 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1509 g_byte_array_free(data, TRUE);
1514 * If only data from the first pod is involved in the
1515 * acquisition, then the raw input bytes can get passed
1516 * forward for performance reasons. When the second pod
1517 * is involved (either alone, or in combination with the
1518 * first pod), then the received bytes need to be put
1519 * into memory in such a layout that all channel groups
1520 * get combined, and a unitsize larger than a single byte
1521 * applies. The "queue" logic transparently copes with
1522 * any such configuration. This works around the lack
1523 * of support for "meaning" to logic data, which is used
1524 * above for analog data.
1526 if (devc->pod_count == 1) {
1527 packet.type = SR_DF_LOGIC;
1528 logic.data = data->data;
1529 logic.length = data->len;
1530 /* Truncate acquisition if a smaller number of samples has been requested. */
1531 if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1532 logic.length = devc->samples_limit;
1534 packet.payload = &logic;
1535 sr_session_send(sdi, &packet);
1537 group = ch->index / DIGITAL_CHANNELS_PER_POD;
1538 hmo_queue_logic_data(devc, group, data);
1541 devc->num_samples = data->len / devc->pod_count;
1542 g_byte_array_free(data, TRUE);
1546 sr_err("Invalid channel type.");
1551 * Advance to the next enabled channel. When data for all enabled
1552 * channels was received, then flush potentially queued logic data,
1553 * and send the "frame end" packet.
1555 if (devc->current_channel->next) {
1556 devc->current_channel = devc->current_channel->next;
1557 hmo_request_data(sdi);
1560 hmo_send_logic_packet(sdi, devc);
1563 * Release the logic data storage after each frame. This copes
1564 * with sample counts that differ in length per frame. -- Is
1565 * this a real constraint when acquiring multiple frames with
1566 * identical device settings?
1568 hmo_cleanup_logic_data(devc);
1570 std_session_send_df_frame_end(sdi);
1573 * End of frame was reached. Stop acquisition after the specified
1574 * number of frames or after the specified number of samples, or
1575 * continue reception by starting over at the first enabled channel.
1577 if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1578 sr_dev_acquisition_stop(sdi);
1579 hmo_cleanup_logic_data(devc);
1581 devc->current_channel = devc->enabled_channels;
1582 hmo_request_data(sdi);