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_isol_trigger_sources[] = {
225 "CH1", "CH2", "CH3", "CH4",
226 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
230 static const char *an4_dig8_trigger_sources[] = {
231 "CH1", "CH2", "CH3", "CH4",
232 "LINE", "EXT", "PATT", "BUS1", "BUS2",
233 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
236 /* HMO3xx4 and HMO2524 */
237 static const char *an4_dig16_trigger_sources[] = {
238 "CH1", "CH2", "CH3", "CH4",
239 "LINE", "EXT", "PATT", "BUS1", "BUS2",
240 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
241 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
244 /* RTB2004, RTM3004 and RTA4004 */
245 static const char *an4_dig16_sbus_trigger_sources[] = {
246 "CH1", "CH2", "CH3", "CH4",
247 "LINE", "EXT", "PATT", "SBUS1", "SBUS2",
248 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
249 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
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,
777 .name = {"RTH1002", NULL},
778 .analog_channels = 2,
779 .digital_channels = 8,
781 .analog_names = &scope_analog_channel_names,
782 .digital_names = &scope_digital_channel_names,
785 .num_devopts = ARRAY_SIZE(devopts),
787 .devopts_cg_analog = &devopts_cg_analog,
788 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
790 .devopts_cg_digital = &devopts_cg_digital,
791 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
793 .coupling_options = &coupling_options_rth100x,
794 .num_coupling_options = ARRAY_SIZE(coupling_options_rth100x),
796 .logic_threshold = &logic_threshold,
797 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
798 .logic_threshold_for_pod = TRUE,
800 .trigger_sources = &an2_dig8_isol_trigger_sources,
801 .num_trigger_sources = ARRAY_SIZE(an2_dig8_isol_trigger_sources),
803 .trigger_slopes = &scope_trigger_slopes,
804 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
806 .timebases = &timebases,
807 .num_timebases = ARRAY_SIZE(timebases),
810 .num_vdivs = ARRAY_SIZE(vdivs),
814 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
817 .name = {"RTH1004", NULL},
818 .analog_channels = 4,
819 .digital_channels = 8,
821 .analog_names = &scope_analog_channel_names,
822 .digital_names = &scope_digital_channel_names,
825 .num_devopts = ARRAY_SIZE(devopts),
827 .devopts_cg_analog = &devopts_cg_analog,
828 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
830 .devopts_cg_digital = &devopts_cg_digital,
831 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
833 .coupling_options = &coupling_options_rth100x,
834 .num_coupling_options = ARRAY_SIZE(coupling_options_rth100x),
836 .logic_threshold = &logic_threshold,
837 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
838 .logic_threshold_for_pod = TRUE,
840 .trigger_sources = &an4_dig8_isol_trigger_sources,
841 .num_trigger_sources = ARRAY_SIZE(an4_dig8_isol_trigger_sources),
843 .trigger_slopes = &scope_trigger_slopes,
844 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
846 .timebases = &timebases,
847 .num_timebases = ARRAY_SIZE(timebases),
850 .num_vdivs = ARRAY_SIZE(vdivs),
854 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
858 static void scope_state_dump(const struct scope_config *config,
859 struct scope_state *state)
864 for (i = 0; i < config->analog_channels; i++) {
865 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
866 (*config->vdivs)[state->analog_channels[i].vdiv][1]);
867 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
868 i + 1, state->analog_channels[i].state ? "On" : "Off",
869 (*config->coupling_options)[state->analog_channels[i].coupling],
870 tmp, state->analog_channels[i].vertical_offset);
873 for (i = 0; i < config->digital_channels; i++) {
874 sr_info("State of digital channel %d -> %s", i,
875 state->digital_channels[i] ? "On" : "Off");
878 for (i = 0; i < config->digital_pods; i++) {
879 if (!strncmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold], 4) ||
880 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
881 sr_info("State of digital POD %d -> %s : %E (threshold)", i + 1,
882 state->digital_pods[i].state ? "On" : "Off",
883 state->digital_pods[i].user_threshold);
885 sr_info("State of digital POD %d -> %s : %s (threshold)", i + 1,
886 state->digital_pods[i].state ? "On" : "Off",
887 (*config->logic_threshold)[state->digital_pods[i].threshold]);
890 tmp = sr_period_string((*config->timebases)[state->timebase][0],
891 (*config->timebases)[state->timebase][1]);
892 sr_info("Current timebase: %s", tmp);
895 tmp = sr_samplerate_string(state->sample_rate);
896 sr_info("Current samplerate: %s", tmp);
899 if (!strcmp("PATT", (*config->trigger_sources)[state->trigger_source]))
900 sr_info("Current trigger: %s (pattern), %.2f (offset)",
901 state->trigger_pattern,
902 state->horiz_triggerpos);
903 else // Edge (slope) trigger
904 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
905 (*config->trigger_sources)[state->trigger_source],
906 (*config->trigger_slopes)[state->trigger_slope],
907 state->horiz_triggerpos);
910 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
911 const char *command, const char *(*array)[], unsigned int n, int *result)
916 if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK)
919 if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
932 * This function takes a value of the form "2.000E-03" and returns the index
933 * of an array where a matching pair was found.
935 * @param value The string to be parsed.
936 * @param array The array of s/f pairs.
937 * @param array_len The number of pairs in the array.
938 * @param result The index at which a matching pair was found.
940 * @return SR_ERR on any parsing error, SR_OK otherwise.
942 static int array_float_get(gchar *value, const uint64_t array[][2],
943 int array_len, unsigned int *result)
945 struct sr_rational rval;
946 struct sr_rational aval;
948 if (sr_parse_rational(value, &rval) != SR_OK)
951 for (int i = 0; i < array_len; i++) {
952 sr_rational_set(&aval, array[i][0], array[i][1]);
953 if (sr_rational_eq(&rval, &aval)) {
962 static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
965 while (channel_lhead) {
966 struct sr_channel *ch = channel_lhead->data;
967 if (ch->index == index && ch->type == type)
970 channel_lhead = channel_lhead->next;
976 static int analog_channel_state_get(struct sr_dev_inst *sdi,
977 const struct scope_config *config,
978 struct scope_state *state)
981 char command[MAX_COMMAND_SIZE];
983 struct sr_channel *ch;
984 struct sr_scpi_dev_inst *scpi = sdi->conn;
986 for (i = 0; i < config->analog_channels; i++) {
987 g_snprintf(command, sizeof(command),
988 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
991 if (sr_scpi_get_bool(scpi, command,
992 &state->analog_channels[i].state) != SR_OK)
995 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
997 ch->enabled = state->analog_channels[i].state;
999 g_snprintf(command, sizeof(command),
1000 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_SCALE],
1003 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
1006 if (array_float_get(tmp_str, *(config->vdivs), config->num_vdivs, &j) != SR_OK) {
1008 sr_err("Could not determine array index for vertical div scale.");
1013 state->analog_channels[i].vdiv = j;
1015 g_snprintf(command, sizeof(command),
1016 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
1019 if (sr_scpi_get_float(scpi, command,
1020 &state->analog_channels[i].vertical_offset) != SR_OK)
1023 g_snprintf(command, sizeof(command),
1024 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
1027 if (scope_state_get_array_option(scpi, command, config->coupling_options,
1028 config->num_coupling_options,
1029 &state->analog_channels[i].coupling) != SR_OK)
1032 g_snprintf(command, sizeof(command),
1033 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
1036 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
1039 if (tmp_str[0] == 'A')
1040 state->analog_channels[i].probe_unit = 'A';
1042 state->analog_channels[i].probe_unit = 'V';
1049 static int digital_channel_state_get(struct sr_dev_inst *sdi,
1050 const struct scope_config *config,
1051 struct scope_state *state)
1053 unsigned int i, idx;
1054 int result = SR_ERR;
1055 char *logic_threshold_short[MAX_NUM_LOGIC_THRESHOLD_ENTRIES];
1056 char command[MAX_COMMAND_SIZE];
1057 struct sr_channel *ch;
1058 struct sr_scpi_dev_inst *scpi = sdi->conn;
1060 for (i = 0; i < config->digital_channels; i++) {
1061 g_snprintf(command, sizeof(command),
1062 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
1065 if (sr_scpi_get_bool(scpi, command,
1066 &state->digital_channels[i]) != SR_OK)
1069 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
1071 ch->enabled = state->digital_channels[i];
1074 /* According to the SCPI standard, on models that support multiple
1075 * user-defined logic threshold settings the response to the command
1076 * SCPI_CMD_GET_DIG_POD_THRESHOLD might return "USER" instead of
1079 * This makes more difficult to validate the response when the logic
1080 * threshold is set to "USER1" and therefore we need to prevent device
1081 * opening failures in such configuration case...
1083 for (i = 0; i < config->num_logic_threshold; i++) {
1084 logic_threshold_short[i] = g_strdup((*config->logic_threshold)[i]);
1085 if (!strcmp("USER1", (*config->logic_threshold)[i]))
1086 g_strlcpy(logic_threshold_short[i],
1087 (*config->logic_threshold)[i], strlen((*config->logic_threshold)[i]));
1090 for (i = 0; i < config->digital_pods; i++) {
1091 g_snprintf(command, sizeof(command),
1092 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
1095 if (sr_scpi_get_bool(scpi, command,
1096 &state->digital_pods[i].state) != SR_OK)
1099 /* Check if the threshold command is based on the POD or digital channel index. */
1100 if (config->logic_threshold_for_pod)
1103 idx = i * DIGITAL_CHANNELS_PER_POD;
1105 g_snprintf(command, sizeof(command),
1106 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_THRESHOLD],
1109 /* Check for both standard and shortened responses. */
1110 if (scope_state_get_array_option(scpi, command, config->logic_threshold,
1111 config->num_logic_threshold,
1112 &state->digital_pods[i].threshold) != SR_OK)
1113 if (scope_state_get_array_option(scpi, command, (const char * (*)[]) &logic_threshold_short,
1114 config->num_logic_threshold,
1115 &state->digital_pods[i].threshold) != SR_OK)
1118 /* If used-defined or custom threshold is active, get the level. */
1119 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1120 g_snprintf(command, sizeof(command),
1121 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1122 idx, 1); /* USER1 logic threshold setting. */
1123 else if (!strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1124 g_snprintf(command, sizeof(command),
1125 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1126 idx, 2); /* USER2 for custom logic_threshold setting. */
1127 else if (!strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1128 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1129 g_snprintf(command, sizeof(command),
1130 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1131 idx); /* USER or MAN for custom logic_threshold setting. */
1132 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1133 !strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1134 !strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1135 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1136 if (sr_scpi_get_float(scpi, command,
1137 &state->digital_pods[i].user_threshold) != SR_OK)
1144 for (i = 0; i < config->num_logic_threshold; i++)
1145 g_free(logic_threshold_short[i]);
1150 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
1152 struct dev_context *devc;
1153 struct scope_state *state;
1154 const struct scope_config *config;
1158 config = devc->model_config;
1159 state = devc->model_state;
1161 if (sr_scpi_get_float(sdi->conn,
1162 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
1163 &tmp_float) != SR_OK)
1166 state->sample_rate = tmp_float;
1171 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
1173 struct dev_context *devc;
1174 struct scope_state *state;
1175 const struct scope_config *config;
1181 config = devc->model_config;
1182 state = devc->model_state;
1184 sr_info("Fetching scope state");
1186 if (analog_channel_state_get(sdi, config, state) != SR_OK)
1189 if (digital_channel_state_get(sdi, config, state) != SR_OK)
1192 if (sr_scpi_get_string(sdi->conn,
1193 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
1197 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
1199 sr_err("Could not determine array index for time base.");
1204 state->timebase = i;
1206 /* Determine the number of horizontal (x) divisions. */
1207 if (sr_scpi_get_int(sdi->conn,
1208 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZONTAL_DIV],
1209 (int *)&config->num_xdivs) != SR_OK)
1212 if (sr_scpi_get_float(sdi->conn,
1213 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
1214 &tmp_float) != SR_OK)
1216 state->horiz_triggerpos = tmp_float /
1217 (((double) (*config->timebases)[state->timebase][0] /
1218 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
1219 state->horiz_triggerpos -= 0.5;
1220 state->horiz_triggerpos *= -1;
1222 if (scope_state_get_array_option(sdi->conn,
1223 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
1224 config->trigger_sources, config->num_trigger_sources,
1225 &state->trigger_source) != SR_OK)
1228 if (scope_state_get_array_option(sdi->conn,
1229 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
1230 config->trigger_slopes, config->num_trigger_slopes,
1231 &state->trigger_slope) != SR_OK)
1234 if (sr_scpi_get_string(sdi->conn,
1235 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_PATTERN],
1238 strncpy(state->trigger_pattern,
1239 sr_scpi_unquote_string(tmp_str),
1240 MAX_ANALOG_CHANNEL_COUNT + MAX_DIGITAL_CHANNEL_COUNT);
1243 if (sr_scpi_get_string(sdi->conn,
1244 (*config->scpi_dialect)[SCPI_CMD_GET_HIGH_RESOLUTION],
1247 if (!strcmp("OFF", tmp_str))
1248 state->high_resolution = FALSE;
1250 state->high_resolution = TRUE;
1253 if (sr_scpi_get_string(sdi->conn,
1254 (*config->scpi_dialect)[SCPI_CMD_GET_PEAK_DETECTION],
1257 if (!strcmp("OFF", tmp_str))
1258 state->peak_detection = FALSE;
1260 state->peak_detection = TRUE;
1263 if (hmo_update_sample_rate(sdi) != SR_OK)
1266 sr_info("Fetching finished.");
1268 scope_state_dump(config, state);
1273 static struct scope_state *scope_state_new(const struct scope_config *config)
1275 struct scope_state *state;
1277 state = g_malloc0(sizeof(struct scope_state));
1278 state->analog_channels = g_malloc0_n(config->analog_channels,
1279 sizeof(struct analog_channel_state));
1280 state->digital_channels = g_malloc0_n(
1281 config->digital_channels, sizeof(gboolean));
1282 state->digital_pods = g_malloc0_n(config->digital_pods,
1283 sizeof(struct digital_pod_state));
1288 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
1290 g_free(state->analog_channels);
1291 g_free(state->digital_channels);
1292 g_free(state->digital_pods);
1296 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
1299 unsigned int i, j, group;
1300 struct sr_channel *ch;
1301 struct dev_context *devc;
1302 const char *cg_name;
1308 /* Find the exact model. */
1309 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
1310 for (j = 0; scope_models[i].name[j]; j++) {
1311 if (!strcmp(sdi->model, scope_models[i].name[j])) {
1316 if (model_index != -1)
1320 if (model_index == -1) {
1321 sr_dbg("Unsupported device.");
1325 /* Configure the number of PODs given the number of digital channels. */
1326 scope_models[model_index].digital_pods = scope_models[model_index].digital_channels / DIGITAL_CHANNELS_PER_POD;
1328 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1329 scope_models[model_index].analog_channels);
1330 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1331 scope_models[model_index].digital_pods);
1332 if (!devc->analog_groups || !devc->digital_groups) {
1333 g_free(devc->analog_groups);
1334 g_free(devc->digital_groups);
1335 return SR_ERR_MALLOC;
1338 /* Add analog channels. */
1339 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
1340 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
1341 (*scope_models[model_index].analog_names)[i]);
1343 cg_name = (*scope_models[model_index].analog_names)[i];
1344 devc->analog_groups[i] = sr_channel_group_new(sdi, cg_name, NULL);
1345 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
1348 /* Add digital channel groups. */
1350 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
1351 devc->digital_groups[i] = sr_channel_group_new(sdi, NULL, NULL);
1352 if (!devc->digital_groups[i]) {
1353 ret = SR_ERR_MALLOC;
1356 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i + 1);
1361 /* Add digital channels. */
1362 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
1363 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
1364 (*scope_models[model_index].digital_names)[i]);
1366 group = i / DIGITAL_CHANNELS_PER_POD;
1367 devc->digital_groups[group]->channels = g_slist_append(
1368 devc->digital_groups[group]->channels, ch);
1371 devc->model_config = &scope_models[model_index];
1372 devc->samples_limit = 0;
1373 devc->frame_limit = 0;
1375 if (!(devc->model_state = scope_state_new(devc->model_config)))
1376 return SR_ERR_MALLOC;
1381 /* Queue data of one channel group, for later submission. */
1382 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
1383 size_t group, GByteArray *pod_data)
1387 uint8_t *logic_data;
1388 size_t idx, logic_step;
1391 * Upon first invocation, allocate the array which can hold the
1392 * combined logic data for all channels. Assume that each channel
1393 * will yield an identical number of samples per receive call.
1395 * As a poor man's safety measure: (Silently) skip processing
1396 * for unexpected sample counts, and ignore samples for
1397 * unexpected channel groups. Don't bother with complicated
1398 * resize logic, considering that many models only support one
1399 * pod, and the most capable supported models have two pods of
1400 * identical size. We haven't yet seen any "odd" configuration.
1402 if (!devc->logic_data) {
1403 size = pod_data->len * devc->pod_count;
1404 store = g_byte_array_sized_new(size);
1405 memset(store->data, 0, size);
1406 store = g_byte_array_set_size(store, size);
1407 devc->logic_data = store;
1409 store = devc->logic_data;
1410 size = store->len / devc->pod_count;
1411 if (group >= devc->pod_count)
1416 * Fold the data of the most recently received channel group into
1417 * the storage, where data resides for all channels combined.
1419 logic_data = store->data;
1420 logic_data += group;
1421 logic_step = devc->pod_count;
1422 for (idx = 0; idx < pod_data->len; idx++) {
1423 *logic_data = pod_data->data[idx];
1424 logic_data += logic_step;
1427 /* Truncate acquisition if a smaller number of samples has been requested. */
1428 if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
1429 devc->logic_data->len = devc->samples_limit * devc->pod_count;
1432 /* Submit data for all channels, after the individual groups got collected. */
1433 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
1434 struct dev_context *devc)
1436 struct sr_datafeed_packet packet;
1437 struct sr_datafeed_logic logic;
1439 if (!devc->logic_data)
1442 logic.data = devc->logic_data->data;
1443 logic.length = devc->logic_data->len;
1444 logic.unitsize = devc->pod_count;
1446 packet.type = SR_DF_LOGIC;
1447 packet.payload = &logic;
1449 sr_session_send(sdi, &packet);
1452 /* Undo previous resource allocation. */
1453 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
1456 if (devc->logic_data) {
1457 g_byte_array_free(devc->logic_data, TRUE);
1458 devc->logic_data = NULL;
1461 * Keep 'pod_count'! It's required when more frames will be
1462 * received, and does not harm when kept after acquisition.
1466 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
1468 struct sr_channel *ch;
1469 struct sr_dev_inst *sdi;
1470 struct dev_context *devc;
1471 struct scope_state *state;
1472 struct sr_datafeed_packet packet;
1474 struct sr_datafeed_analog analog;
1475 struct sr_analog_encoding encoding;
1476 struct sr_analog_meaning meaning;
1477 struct sr_analog_spec spec;
1478 struct sr_datafeed_logic logic;
1484 if (!(sdi = cb_data))
1487 if (!(devc = sdi->priv))
1490 /* Although this is correct in general, the USBTMC libusb implementation
1491 * currently does not generate an event prior to the first read. Often
1492 * it is ok to start reading just after the 50ms timeout. See bug #785.
1493 if (revents != G_IO_IN)
1497 ch = devc->current_channel->data;
1498 state = devc->model_state;
1501 * Send "frame begin" packet upon reception of data for the
1502 * first enabled channel.
1504 if (devc->current_channel == devc->enabled_channels)
1505 std_session_send_df_frame_begin(sdi);
1508 * Pass on the received data of the channel(s).
1511 case SR_CHANNEL_ANALOG:
1513 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1515 g_byte_array_free(data, TRUE);
1519 packet.type = SR_DF_ANALOG;
1521 analog.data = data->data;
1522 analog.num_samples = data->len / sizeof(float);
1523 /* Truncate acquisition if a smaller number of samples has been requested. */
1524 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1525 analog.num_samples = devc->samples_limit;
1526 /* TODO: Use proper 'digits' value for this device (and its modes). */
1527 sr_analog_init(&analog, &encoding, &meaning, &spec, 2);
1528 encoding.is_signed = TRUE;
1529 if (state->analog_channels[ch->index].probe_unit == 'V') {
1530 meaning.mq = SR_MQ_VOLTAGE;
1531 meaning.unit = SR_UNIT_VOLT;
1533 meaning.mq = SR_MQ_CURRENT;
1534 meaning.unit = SR_UNIT_AMPERE;
1536 meaning.channels = g_slist_append(NULL, ch);
1537 packet.payload = &analog;
1538 sr_session_send(sdi, &packet);
1539 devc->num_samples = data->len / sizeof(float);
1540 g_slist_free(meaning.channels);
1541 g_byte_array_free(data, TRUE);
1544 case SR_CHANNEL_LOGIC:
1546 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1548 g_byte_array_free(data, TRUE);
1553 * If only data from the first pod is involved in the
1554 * acquisition, then the raw input bytes can get passed
1555 * forward for performance reasons. When the second pod
1556 * is involved (either alone, or in combination with the
1557 * first pod), then the received bytes need to be put
1558 * into memory in such a layout that all channel groups
1559 * get combined, and a unitsize larger than a single byte
1560 * applies. The "queue" logic transparently copes with
1561 * any such configuration. This works around the lack
1562 * of support for "meaning" to logic data, which is used
1563 * above for analog data.
1565 if (devc->pod_count == 1) {
1566 packet.type = SR_DF_LOGIC;
1567 logic.data = data->data;
1568 logic.length = data->len;
1569 /* Truncate acquisition if a smaller number of samples has been requested. */
1570 if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1571 logic.length = devc->samples_limit;
1573 packet.payload = &logic;
1574 sr_session_send(sdi, &packet);
1576 group = ch->index / DIGITAL_CHANNELS_PER_POD;
1577 hmo_queue_logic_data(devc, group, data);
1580 devc->num_samples = data->len / devc->pod_count;
1581 g_byte_array_free(data, TRUE);
1585 sr_err("Invalid channel type.");
1590 * Advance to the next enabled channel. When data for all enabled
1591 * channels was received, then flush potentially queued logic data,
1592 * and send the "frame end" packet.
1594 if (devc->current_channel->next) {
1595 devc->current_channel = devc->current_channel->next;
1596 hmo_request_data(sdi);
1599 hmo_send_logic_packet(sdi, devc);
1602 * Release the logic data storage after each frame. This copes
1603 * with sample counts that differ in length per frame. -- Is
1604 * this a real constraint when acquiring multiple frames with
1605 * identical device settings?
1607 hmo_cleanup_logic_data(devc);
1609 std_session_send_df_frame_end(sdi);
1612 * End of frame was reached. Stop acquisition after the specified
1613 * number of frames or after the specified number of samples, or
1614 * continue reception by starting over at the first enabled channel.
1616 if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1617 sr_dev_acquisition_stop(sdi);
1618 hmo_cleanup_logic_data(devc);
1620 devc->current_channel = devc->enabled_channels;
1621 hmo_request_data(sdi);