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_DIV] = ":CHAN%d:SCAL?",
43 [SCPI_CMD_SET_VERTICAL_DIV] = ":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_DIV] = ":CHAN%d:SCAL?",
80 [SCPI_CMD_SET_VERTICAL_DIV] = ":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] = {
259 static const uint64_t vdivs[][2] = {
277 static const char *scope_analog_channel_names[] = {
278 "CH1", "CH2", "CH3", "CH4",
281 static const char *scope_digital_channel_names[] = {
282 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
283 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
286 static const struct scope_config scope_models[] = {
288 /* RTC1002 and HMO722/1002/1022/1202/1522/2022 support only 8 digital channels. */
289 .name = {"RTC1002", "HMO722", "HMO1002", "HMO1022", "HMO1202", "HMO1522", "HMO2022", NULL},
290 .analog_channels = 2,
291 .digital_channels = 8,
294 .analog_names = &scope_analog_channel_names,
295 .digital_names = &scope_digital_channel_names,
298 .num_devopts = ARRAY_SIZE(devopts),
300 .devopts_cg_analog = &devopts_cg_analog,
301 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
303 .devopts_cg_digital = &devopts_cg_digital,
304 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
306 .coupling_options = &coupling_options,
307 .num_coupling_options = ARRAY_SIZE(coupling_options),
309 .logic_threshold = &logic_threshold,
310 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
311 .logic_threshold_for_pod = TRUE,
313 .trigger_sources = &an2_dig8_trigger_sources,
314 .num_trigger_sources = ARRAY_SIZE(an2_dig8_trigger_sources),
316 .trigger_slopes = &scope_trigger_slopes,
317 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
319 .timebases = &timebases,
320 .num_timebases = ARRAY_SIZE(timebases),
323 .num_vdivs = ARRAY_SIZE(vdivs),
328 .scpi_dialect = &hameg_scpi_dialect,
331 /* HMO3032/3042/3052/3522 support 16 digital channels. */
332 .name = {"HMO3032", "HMO3042", "HMO3052", "HMO3522", NULL},
333 .analog_channels = 2,
334 .digital_channels = 16,
337 .analog_names = &scope_analog_channel_names,
338 .digital_names = &scope_digital_channel_names,
341 .num_devopts = ARRAY_SIZE(devopts),
343 .devopts_cg_analog = &devopts_cg_analog,
344 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
346 .devopts_cg_digital = &devopts_cg_digital,
347 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
349 .coupling_options = &coupling_options,
350 .num_coupling_options = ARRAY_SIZE(coupling_options),
352 .logic_threshold = &logic_threshold,
353 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
354 .logic_threshold_for_pod = TRUE,
356 .trigger_sources = &an2_dig16_trigger_sources,
357 .num_trigger_sources = ARRAY_SIZE(an2_dig16_trigger_sources),
359 .trigger_slopes = &scope_trigger_slopes,
360 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
362 .timebases = &timebases,
363 .num_timebases = ARRAY_SIZE(timebases),
366 .num_vdivs = ARRAY_SIZE(vdivs),
371 .scpi_dialect = &hameg_scpi_dialect,
374 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
375 .analog_channels = 4,
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 = &an4_dig8_trigger_sources,
399 .num_trigger_sources = ARRAY_SIZE(an4_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 .name = {"HMO2524", "HMO3034", "HMO3044", "HMO3054", "HMO3524", NULL},
417 .analog_channels = 4,
418 .digital_channels = 16,
421 .analog_names = &scope_analog_channel_names,
422 .digital_names = &scope_digital_channel_names,
425 .num_devopts = ARRAY_SIZE(devopts),
427 .devopts_cg_analog = &devopts_cg_analog,
428 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
430 .devopts_cg_digital = &devopts_cg_digital,
431 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
433 .coupling_options = &coupling_options,
434 .num_coupling_options = ARRAY_SIZE(coupling_options),
436 .logic_threshold = &logic_threshold,
437 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
438 .logic_threshold_for_pod = TRUE,
440 .trigger_sources = &an4_dig16_trigger_sources,
441 .num_trigger_sources = ARRAY_SIZE(an4_dig16_trigger_sources),
443 .trigger_slopes = &scope_trigger_slopes,
444 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
446 .timebases = &timebases,
447 .num_timebases = ARRAY_SIZE(timebases),
450 .num_vdivs = ARRAY_SIZE(vdivs),
455 .scpi_dialect = &hameg_scpi_dialect,
458 .name = {"RTB2002", NULL},
459 .analog_channels = 2,
460 .digital_channels = 16,
463 .analog_names = &scope_analog_channel_names,
464 .digital_names = &scope_digital_channel_names,
467 .num_devopts = ARRAY_SIZE(devopts),
469 .devopts_cg_analog = &devopts_cg_analog,
470 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
472 .devopts_cg_digital = &devopts_cg_digital,
473 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
475 .coupling_options = &coupling_options_rtb200x,
476 .num_coupling_options = ARRAY_SIZE(coupling_options_rtb200x),
478 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
479 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
480 .logic_threshold_for_pod = FALSE,
482 .trigger_sources = &an2_dig16_sbus_trigger_sources,
483 .num_trigger_sources = ARRAY_SIZE(an2_dig16_sbus_trigger_sources),
485 .trigger_slopes = &scope_trigger_slopes,
486 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
488 .timebases = &timebases,
489 .num_timebases = ARRAY_SIZE(timebases),
492 .num_vdivs = ARRAY_SIZE(vdivs),
497 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
500 .name = {"RTB2004", NULL},
501 .analog_channels = 4,
502 .digital_channels = 16,
505 .analog_names = &scope_analog_channel_names,
506 .digital_names = &scope_digital_channel_names,
509 .num_devopts = ARRAY_SIZE(devopts),
511 .devopts_cg_analog = &devopts_cg_analog,
512 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
514 .devopts_cg_digital = &devopts_cg_digital,
515 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
517 .coupling_options = &coupling_options_rtb200x,
518 .num_coupling_options = ARRAY_SIZE(coupling_options_rtb200x),
520 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
521 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
522 .logic_threshold_for_pod = FALSE,
524 .trigger_sources = &an4_dig16_sbus_trigger_sources,
525 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
527 .trigger_slopes = &scope_trigger_slopes,
528 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
530 .timebases = &timebases,
531 .num_timebases = ARRAY_SIZE(timebases),
534 .num_vdivs = ARRAY_SIZE(vdivs),
539 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
542 .name = {"RTM3002", NULL},
543 .analog_channels = 2,
544 .digital_channels = 16,
547 .analog_names = &scope_analog_channel_names,
548 .digital_names = &scope_digital_channel_names,
551 .num_devopts = ARRAY_SIZE(devopts),
553 .devopts_cg_analog = &devopts_cg_analog,
554 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
556 .devopts_cg_digital = &devopts_cg_digital,
557 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
559 .coupling_options = &coupling_options_rtm300x,
560 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
562 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
563 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
564 .logic_threshold_for_pod = FALSE,
566 .trigger_sources = &an2_dig16_sbus_trigger_sources,
567 .num_trigger_sources = ARRAY_SIZE(an2_dig16_sbus_trigger_sources),
569 .trigger_slopes = &scope_trigger_slopes,
570 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
572 .timebases = &timebases,
573 .num_timebases = ARRAY_SIZE(timebases),
576 .num_vdivs = ARRAY_SIZE(vdivs),
581 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
584 .name = {"RTM3004", NULL},
585 .analog_channels = 4,
586 .digital_channels = 16,
589 .analog_names = &scope_analog_channel_names,
590 .digital_names = &scope_digital_channel_names,
593 .num_devopts = ARRAY_SIZE(devopts),
595 .devopts_cg_analog = &devopts_cg_analog,
596 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
598 .devopts_cg_digital = &devopts_cg_digital,
599 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
601 .coupling_options = &coupling_options_rtm300x,
602 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
604 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
605 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
606 .logic_threshold_for_pod = FALSE,
608 .trigger_sources = &an4_dig16_sbus_trigger_sources,
609 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
611 .trigger_slopes = &scope_trigger_slopes,
612 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
614 .timebases = &timebases,
615 .num_timebases = ARRAY_SIZE(timebases),
618 .num_vdivs = ARRAY_SIZE(vdivs),
623 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
626 .name = {"RTA4004", NULL},
627 .analog_channels = 4,
628 .digital_channels = 16,
631 .analog_names = &scope_analog_channel_names,
632 .digital_names = &scope_digital_channel_names,
635 .num_devopts = ARRAY_SIZE(devopts),
637 .devopts_cg_analog = &devopts_cg_analog,
638 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
640 .devopts_cg_digital = &devopts_cg_digital,
641 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
643 .coupling_options = &coupling_options_rtm300x,
644 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
646 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
647 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
648 .logic_threshold_for_pod = FALSE,
650 .trigger_sources = &an4_dig16_sbus_trigger_sources,
651 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
653 .trigger_slopes = &scope_trigger_slopes,
654 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
656 .timebases = &timebases,
657 .num_timebases = ARRAY_SIZE(timebases),
660 .num_vdivs = ARRAY_SIZE(vdivs),
665 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
669 static void scope_state_dump(const struct scope_config *config,
670 struct scope_state *state)
675 for (i = 0; i < config->analog_channels; i++) {
676 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
677 (*config->vdivs)[state->analog_channels[i].vdiv][1]);
678 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
679 i + 1, state->analog_channels[i].state ? "On" : "Off",
680 (*config->coupling_options)[state->analog_channels[i].coupling],
681 tmp, state->analog_channels[i].vertical_offset);
684 for (i = 0; i < config->digital_channels; i++) {
685 sr_info("State of digital channel %d -> %s", i,
686 state->digital_channels[i] ? "On" : "Off");
689 for (i = 0; i < config->digital_pods; i++) {
690 if (!strncmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold], 4) ||
691 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
692 sr_info("State of digital POD %d -> %s : %E (threshold)", i + 1,
693 state->digital_pods[i].state ? "On" : "Off",
694 state->digital_pods[i].user_threshold);
696 sr_info("State of digital POD %d -> %s : %s (threshold)", i + 1,
697 state->digital_pods[i].state ? "On" : "Off",
698 (*config->logic_threshold)[state->digital_pods[i].threshold]);
701 tmp = sr_period_string((*config->timebases)[state->timebase][0],
702 (*config->timebases)[state->timebase][1]);
703 sr_info("Current timebase: %s", tmp);
706 tmp = sr_samplerate_string(state->sample_rate);
707 sr_info("Current samplerate: %s", tmp);
710 if (!strcmp("PATT", (*config->trigger_sources)[state->trigger_source]))
711 sr_info("Current trigger: %s (pattern), %.2f (offset)",
712 state->trigger_pattern,
713 state->horiz_triggerpos);
714 else // Edge (slope) trigger
715 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
716 (*config->trigger_sources)[state->trigger_source],
717 (*config->trigger_slopes)[state->trigger_slope],
718 state->horiz_triggerpos);
721 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
722 const char *command, const char *(*array)[], unsigned int n, int *result)
727 if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK)
730 if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
743 * This function takes a value of the form "2.000E-03" and returns the index
744 * of an array where a matching pair was found.
746 * @param value The string to be parsed.
747 * @param array The array of s/f pairs.
748 * @param array_len The number of pairs in the array.
749 * @param result The index at which a matching pair was found.
751 * @return SR_ERR on any parsing error, SR_OK otherwise.
753 static int array_float_get(gchar *value, const uint64_t array[][2],
754 int array_len, unsigned int *result)
756 struct sr_rational rval;
757 struct sr_rational aval;
759 if (sr_parse_rational(value, &rval) != SR_OK)
762 for (int i = 0; i < array_len; i++) {
763 sr_rational_set(&aval, array[i][0], array[i][1]);
764 if (sr_rational_eq(&rval, &aval)) {
773 static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
776 while (channel_lhead) {
777 struct sr_channel *ch = channel_lhead->data;
778 if (ch->index == index && ch->type == type)
781 channel_lhead = channel_lhead->next;
787 static int analog_channel_state_get(struct sr_dev_inst *sdi,
788 const struct scope_config *config,
789 struct scope_state *state)
792 char command[MAX_COMMAND_SIZE];
794 struct sr_channel *ch;
795 struct sr_scpi_dev_inst *scpi = sdi->conn;
797 for (i = 0; i < config->analog_channels; i++) {
798 g_snprintf(command, sizeof(command),
799 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
802 if (sr_scpi_get_bool(scpi, command,
803 &state->analog_channels[i].state) != SR_OK)
806 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
808 ch->enabled = state->analog_channels[i].state;
810 g_snprintf(command, sizeof(command),
811 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
814 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
817 if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
819 sr_err("Could not determine array index for vertical div scale.");
824 state->analog_channels[i].vdiv = j;
826 g_snprintf(command, sizeof(command),
827 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
830 if (sr_scpi_get_float(scpi, command,
831 &state->analog_channels[i].vertical_offset) != SR_OK)
834 g_snprintf(command, sizeof(command),
835 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
838 if (scope_state_get_array_option(scpi, command, config->coupling_options,
839 config->num_coupling_options,
840 &state->analog_channels[i].coupling) != SR_OK)
843 g_snprintf(command, sizeof(command),
844 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
847 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
850 if (tmp_str[0] == 'A')
851 state->analog_channels[i].probe_unit = 'A';
853 state->analog_channels[i].probe_unit = 'V';
860 static int digital_channel_state_get(struct sr_dev_inst *sdi,
861 const struct scope_config *config,
862 struct scope_state *state)
866 static char *logic_threshold_short[] = {};
867 char command[MAX_COMMAND_SIZE];
868 struct sr_channel *ch;
869 struct sr_scpi_dev_inst *scpi = sdi->conn;
871 for (i = 0; i < config->digital_channels; i++) {
872 g_snprintf(command, sizeof(command),
873 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
876 if (sr_scpi_get_bool(scpi, command,
877 &state->digital_channels[i]) != SR_OK)
880 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
882 ch->enabled = state->digital_channels[i];
885 /* According to the SCPI standard, on models that support multiple
886 * user-defined logic threshold settings the response to the command
887 * SCPI_CMD_GET_DIG_POD_THRESHOLD might return "USER" instead of
890 * This makes more difficult to validate the response when the logic
891 * threshold is set to "USER1" and therefore we need to prevent device
892 * opening failures in such configuration case...
894 for (i = 0; i < config->num_logic_threshold; i++) {
895 logic_threshold_short[i] = g_strdup((*config->logic_threshold)[i]);
896 if (!strcmp("USER1", (*config->logic_threshold)[i]))
897 g_strlcpy(logic_threshold_short[i],
898 (*config->logic_threshold)[i], strlen((*config->logic_threshold)[i]));
901 for (i = 0; i < config->digital_pods; i++) {
902 g_snprintf(command, sizeof(command),
903 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
906 if (sr_scpi_get_bool(scpi, command,
907 &state->digital_pods[i].state) != SR_OK)
910 /* Check if the threshold command is based on the POD or digital channel index. */
911 if (config->logic_threshold_for_pod)
916 g_snprintf(command, sizeof(command),
917 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_THRESHOLD],
920 /* Check for both standard and shortened responses. */
921 if (scope_state_get_array_option(scpi, command, config->logic_threshold,
922 config->num_logic_threshold,
923 &state->digital_pods[i].threshold) != SR_OK)
924 if (scope_state_get_array_option(scpi, command, (const char * (*)[]) &logic_threshold_short,
925 config->num_logic_threshold,
926 &state->digital_pods[i].threshold) != SR_OK)
929 /* If used-defined or custom threshold is active, get the level. */
930 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]))
931 g_snprintf(command, sizeof(command),
932 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
933 idx, 1); /* USER1 logic threshold setting. */
934 else if (!strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
935 g_snprintf(command, sizeof(command),
936 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
937 idx, 2); /* USER2 for custom logic_threshold setting. */
938 else if (!strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
939 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
940 g_snprintf(command, sizeof(command),
941 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
942 idx); /* USER or MAN for custom logic_threshold setting. */
943 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
944 !strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
945 !strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
946 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
947 if (sr_scpi_get_float(scpi, command,
948 &state->digital_pods[i].user_threshold) != SR_OK)
955 for (i = 0; i < config->num_logic_threshold; i++)
956 g_free(logic_threshold_short[i]);
961 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
963 struct dev_context *devc;
964 struct scope_state *state;
965 const struct scope_config *config;
969 config = devc->model_config;
970 state = devc->model_state;
972 if (sr_scpi_get_float(sdi->conn,
973 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
974 &tmp_float) != SR_OK)
977 state->sample_rate = tmp_float;
982 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
984 struct dev_context *devc;
985 struct scope_state *state;
986 const struct scope_config *config;
992 config = devc->model_config;
993 state = devc->model_state;
995 sr_info("Fetching scope state");
997 if (analog_channel_state_get(sdi, config, state) != SR_OK)
1000 if (digital_channel_state_get(sdi, config, state) != SR_OK)
1003 if (sr_scpi_get_float(sdi->conn,
1004 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
1005 &tmp_float) != SR_OK)
1008 if (sr_scpi_get_string(sdi->conn,
1009 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
1013 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
1015 sr_err("Could not determine array index for time base.");
1020 state->timebase = i;
1022 if (sr_scpi_get_float(sdi->conn,
1023 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
1024 &tmp_float) != SR_OK)
1026 state->horiz_triggerpos = tmp_float /
1027 (((double) (*config->timebases)[state->timebase][0] /
1028 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
1029 state->horiz_triggerpos -= 0.5;
1030 state->horiz_triggerpos *= -1;
1032 if (scope_state_get_array_option(sdi->conn,
1033 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
1034 config->trigger_sources, config->num_trigger_sources,
1035 &state->trigger_source) != SR_OK)
1038 if (scope_state_get_array_option(sdi->conn,
1039 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
1040 config->trigger_slopes, config->num_trigger_slopes,
1041 &state->trigger_slope) != SR_OK)
1044 if (sr_scpi_get_string(sdi->conn,
1045 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_PATTERN],
1046 &state->trigger_pattern) != SR_OK)
1049 if (hmo_update_sample_rate(sdi) != SR_OK)
1052 sr_info("Fetching finished.");
1054 scope_state_dump(config, state);
1059 static struct scope_state *scope_state_new(const struct scope_config *config)
1061 struct scope_state *state;
1063 state = g_malloc0(sizeof(struct scope_state));
1064 state->analog_channels = g_malloc0_n(config->analog_channels,
1065 sizeof(struct analog_channel_state));
1066 state->digital_channels = g_malloc0_n(
1067 config->digital_channels, sizeof(gboolean));
1068 state->digital_pods = g_malloc0_n(config->digital_pods,
1069 sizeof(struct digital_pod_state));
1074 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
1076 g_free(state->analog_channels);
1077 g_free(state->digital_channels);
1078 g_free(state->digital_pods);
1082 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
1085 unsigned int i, j, group;
1086 struct sr_channel *ch;
1087 struct dev_context *devc;
1093 /* Find the exact model. */
1094 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
1095 for (j = 0; scope_models[i].name[j]; j++) {
1096 if (!strcmp(sdi->model, scope_models[i].name[j])) {
1101 if (model_index != -1)
1105 if (model_index == -1) {
1106 sr_dbg("Unsupported device.");
1110 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1111 scope_models[model_index].analog_channels);
1112 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1113 scope_models[model_index].digital_pods);
1114 if (!devc->analog_groups || !devc->digital_groups) {
1115 g_free(devc->analog_groups);
1116 g_free(devc->digital_groups);
1117 return SR_ERR_MALLOC;
1120 /* Add analog channels. */
1121 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
1122 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
1123 (*scope_models[model_index].analog_names)[i]);
1125 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
1127 devc->analog_groups[i]->name = g_strdup(
1128 (char *)(*scope_models[model_index].analog_names)[i]);
1129 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
1131 sdi->channel_groups = g_slist_append(sdi->channel_groups,
1132 devc->analog_groups[i]);
1135 /* Add digital channel groups. */
1137 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
1138 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
1139 if (!devc->digital_groups[i]) {
1140 ret = SR_ERR_MALLOC;
1143 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i + 1);
1144 sdi->channel_groups = g_slist_append(sdi->channel_groups,
1145 devc->digital_groups[i]);
1150 /* Add digital channels. */
1151 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
1152 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
1153 (*scope_models[model_index].digital_names)[i]);
1156 devc->digital_groups[group]->channels = g_slist_append(
1157 devc->digital_groups[group]->channels, ch);
1160 devc->model_config = &scope_models[model_index];
1161 devc->samples_limit = 0;
1162 devc->frame_limit = 0;
1164 if (!(devc->model_state = scope_state_new(devc->model_config)))
1165 return SR_ERR_MALLOC;
1170 /* Queue data of one channel group, for later submission. */
1171 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
1172 size_t group, GByteArray *pod_data)
1176 uint8_t *logic_data;
1177 size_t idx, logic_step;
1180 * Upon first invocation, allocate the array which can hold the
1181 * combined logic data for all channels. Assume that each channel
1182 * will yield an identical number of samples per receive call.
1184 * As a poor man's safety measure: (Silently) skip processing
1185 * for unexpected sample counts, and ignore samples for
1186 * unexpected channel groups. Don't bother with complicated
1187 * resize logic, considering that many models only support one
1188 * pod, and the most capable supported models have two pods of
1189 * identical size. We haven't yet seen any "odd" configuration.
1191 if (!devc->logic_data) {
1192 size = pod_data->len * devc->pod_count;
1193 store = g_byte_array_sized_new(size);
1194 memset(store->data, 0, size);
1195 store = g_byte_array_set_size(store, size);
1196 devc->logic_data = store;
1198 store = devc->logic_data;
1199 size = store->len / devc->pod_count;
1200 if (group >= devc->pod_count)
1205 * Fold the data of the most recently received channel group into
1206 * the storage, where data resides for all channels combined.
1208 logic_data = store->data;
1209 logic_data += group;
1210 logic_step = devc->pod_count;
1211 for (idx = 0; idx < pod_data->len; idx++) {
1212 *logic_data = pod_data->data[idx];
1213 logic_data += logic_step;
1216 /* Truncate acquisition if a smaller number of samples has been requested. */
1217 if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
1218 devc->logic_data->len = devc->samples_limit * devc->pod_count;
1221 /* Submit data for all channels, after the individual groups got collected. */
1222 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
1223 struct dev_context *devc)
1225 struct sr_datafeed_packet packet;
1226 struct sr_datafeed_logic logic;
1228 if (!devc->logic_data)
1231 logic.data = devc->logic_data->data;
1232 logic.length = devc->logic_data->len;
1233 logic.unitsize = devc->pod_count;
1235 packet.type = SR_DF_LOGIC;
1236 packet.payload = &logic;
1238 sr_session_send(sdi, &packet);
1241 /* Undo previous resource allocation. */
1242 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
1245 if (devc->logic_data) {
1246 g_byte_array_free(devc->logic_data, TRUE);
1247 devc->logic_data = NULL;
1250 * Keep 'pod_count'! It's required when more frames will be
1251 * received, and does not harm when kept after acquisition.
1255 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
1257 struct sr_channel *ch;
1258 struct sr_dev_inst *sdi;
1259 struct dev_context *devc;
1260 struct scope_state *state;
1261 struct sr_datafeed_packet packet;
1263 struct sr_datafeed_analog analog;
1264 struct sr_analog_encoding encoding;
1265 struct sr_analog_meaning meaning;
1266 struct sr_analog_spec spec;
1267 struct sr_datafeed_logic logic;
1275 if (!(sdi = cb_data))
1278 if (!(devc = sdi->priv))
1281 /* Although this is correct in general, the USBTMC libusb implementation
1282 * currently does not generate an event prior to the first read. Often
1283 * it is ok to start reading just after the 50ms timeout. See bug #785.
1284 if (revents != G_IO_IN)
1288 ch = devc->current_channel->data;
1289 state = devc->model_state;
1292 * Send "frame begin" packet upon reception of data for the
1293 * first enabled channel.
1295 if (devc->current_channel == devc->enabled_channels) {
1296 packet.type = SR_DF_FRAME_BEGIN;
1297 sr_session_send(sdi, &packet);
1301 * Pass on the received data of the channel(s).
1304 case SR_CHANNEL_ANALOG:
1305 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1307 g_byte_array_free(data, TRUE);
1311 packet.type = SR_DF_ANALOG;
1313 analog.data = data->data;
1314 analog.num_samples = data->len / sizeof(float);
1315 /* Truncate acquisition if a smaller number of samples has been requested. */
1316 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1317 analog.num_samples = devc->samples_limit;
1318 analog.encoding = &encoding;
1319 analog.meaning = &meaning;
1320 analog.spec = &spec;
1322 encoding.unitsize = sizeof(float);
1323 encoding.is_signed = TRUE;
1324 encoding.is_float = TRUE;
1325 #ifdef WORDS_BIGENDIAN
1326 encoding.is_bigendian = TRUE;
1328 encoding.is_bigendian = FALSE;
1330 /* TODO: Use proper 'digits' value for this device (and its modes). */
1331 encoding.digits = 2;
1332 encoding.is_digits_decimal = FALSE;
1333 encoding.scale.p = 1;
1334 encoding.scale.q = 1;
1335 encoding.offset.p = 0;
1336 encoding.offset.q = 1;
1337 if (state->analog_channels[ch->index].probe_unit == 'V') {
1338 meaning.mq = SR_MQ_VOLTAGE;
1339 meaning.unit = SR_UNIT_VOLT;
1341 meaning.mq = SR_MQ_CURRENT;
1342 meaning.unit = SR_UNIT_AMPERE;
1344 meaning.mqflags = 0;
1345 meaning.channels = g_slist_append(NULL, ch);
1346 /* TODO: Use proper 'digits' value for this device (and its modes). */
1347 spec.spec_digits = 2;
1348 packet.payload = &analog;
1349 sr_session_send(sdi, &packet);
1350 devc->num_samples = data->len / sizeof(float);
1351 g_slist_free(meaning.channels);
1352 g_byte_array_free(data, TRUE);
1355 case SR_CHANNEL_LOGIC:
1356 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1358 g_byte_array_free(data, TRUE);
1363 * If only data from the first pod is involved in the
1364 * acquisition, then the raw input bytes can get passed
1365 * forward for performance reasons. When the second pod
1366 * is involved (either alone, or in combination with the
1367 * first pod), then the received bytes need to be put
1368 * into memory in such a layout that all channel groups
1369 * get combined, and a unitsize larger than a single byte
1370 * applies. The "queue" logic transparently copes with
1371 * any such configuration. This works around the lack
1372 * of support for "meaning" to logic data, which is used
1373 * above for analog data.
1375 if (devc->pod_count == 1) {
1376 packet.type = SR_DF_LOGIC;
1377 logic.data = data->data;
1378 logic.length = data->len;
1379 /* Truncate acquisition if a smaller number of samples has been requested. */
1380 if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1381 logic.length = devc->samples_limit;
1383 packet.payload = &logic;
1384 sr_session_send(sdi, &packet);
1386 group = ch->index / 8;
1387 hmo_queue_logic_data(devc, group, data);
1390 devc->num_samples = data->len / devc->pod_count;
1391 g_byte_array_free(data, TRUE);
1395 sr_err("Invalid channel type.");
1400 * Advance to the next enabled channel. When data for all enabled
1401 * channels was received, then flush potentially queued logic data,
1402 * and send the "frame end" packet.
1404 if (devc->current_channel->next) {
1405 devc->current_channel = devc->current_channel->next;
1406 hmo_request_data(sdi);
1409 hmo_send_logic_packet(sdi, devc);
1412 * Release the logic data storage after each frame. This copes
1413 * with sample counts that differ in length per frame. -- Is
1414 * this a real constraint when acquiring multiple frames with
1415 * identical device settings?
1417 hmo_cleanup_logic_data(devc);
1419 packet.type = SR_DF_FRAME_END;
1420 sr_session_send(sdi, &packet);
1423 * End of frame was reached. Stop acquisition after the specified
1424 * number of frames or after the specified number of samples, or
1425 * continue reception by starting over at the first enabled channel.
1427 if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1428 sr_dev_acquisition_stop(sdi);
1429 hmo_cleanup_logic_data(devc);
1431 devc->current_channel = devc->enabled_channels;
1432 hmo_request_data(sdi);