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 and RTM3004 */
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,
627 static void scope_state_dump(const struct scope_config *config,
628 struct scope_state *state)
633 for (i = 0; i < config->analog_channels; i++) {
634 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
635 (*config->vdivs)[state->analog_channels[i].vdiv][1]);
636 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
637 i + 1, state->analog_channels[i].state ? "On" : "Off",
638 (*config->coupling_options)[state->analog_channels[i].coupling],
639 tmp, state->analog_channels[i].vertical_offset);
642 for (i = 0; i < config->digital_channels; i++) {
643 sr_info("State of digital channel %d -> %s", i,
644 state->digital_channels[i] ? "On" : "Off");
647 for (i = 0; i < config->digital_pods; i++) {
648 if (!strncmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold], 4) ||
649 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
650 sr_info("State of digital POD %d -> %s : %E (threshold)", i + 1,
651 state->digital_pods[i].state ? "On" : "Off",
652 state->digital_pods[i].user_threshold);
654 sr_info("State of digital POD %d -> %s : %s (threshold)", i + 1,
655 state->digital_pods[i].state ? "On" : "Off",
656 (*config->logic_threshold)[state->digital_pods[i].threshold]);
659 tmp = sr_period_string((*config->timebases)[state->timebase][0],
660 (*config->timebases)[state->timebase][1]);
661 sr_info("Current timebase: %s", tmp);
664 tmp = sr_samplerate_string(state->sample_rate);
665 sr_info("Current samplerate: %s", tmp);
668 if (!strcmp("PATT", (*config->trigger_sources)[state->trigger_source]))
669 sr_info("Current trigger: %s (pattern), %.2f (offset)",
670 state->trigger_pattern,
671 state->horiz_triggerpos);
672 else // Edge (slope) trigger
673 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
674 (*config->trigger_sources)[state->trigger_source],
675 (*config->trigger_slopes)[state->trigger_slope],
676 state->horiz_triggerpos);
679 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
680 const char *command, const char *(*array)[], unsigned int n, int *result)
685 if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK)
688 if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
701 * This function takes a value of the form "2.000E-03" and returns the index
702 * of an array where a matching pair was found.
704 * @param value The string to be parsed.
705 * @param array The array of s/f pairs.
706 * @param array_len The number of pairs in the array.
707 * @param result The index at which a matching pair was found.
709 * @return SR_ERR on any parsing error, SR_OK otherwise.
711 static int array_float_get(gchar *value, const uint64_t array[][2],
712 int array_len, unsigned int *result)
714 struct sr_rational rval;
715 struct sr_rational aval;
717 if (sr_parse_rational(value, &rval) != SR_OK)
720 for (int i = 0; i < array_len; i++) {
721 sr_rational_set(&aval, array[i][0], array[i][1]);
722 if (sr_rational_eq(&rval, &aval)) {
731 static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
734 while (channel_lhead) {
735 struct sr_channel *ch = channel_lhead->data;
736 if (ch->index == index && ch->type == type)
739 channel_lhead = channel_lhead->next;
745 static int analog_channel_state_get(struct sr_dev_inst *sdi,
746 const struct scope_config *config,
747 struct scope_state *state)
750 char command[MAX_COMMAND_SIZE];
752 struct sr_channel *ch;
753 struct sr_scpi_dev_inst *scpi = sdi->conn;
755 for (i = 0; i < config->analog_channels; i++) {
756 g_snprintf(command, sizeof(command),
757 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
760 if (sr_scpi_get_bool(scpi, command,
761 &state->analog_channels[i].state) != SR_OK)
764 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
766 ch->enabled = state->analog_channels[i].state;
768 g_snprintf(command, sizeof(command),
769 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
772 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
775 if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
777 sr_err("Could not determine array index for vertical div scale.");
782 state->analog_channels[i].vdiv = j;
784 g_snprintf(command, sizeof(command),
785 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
788 if (sr_scpi_get_float(scpi, command,
789 &state->analog_channels[i].vertical_offset) != SR_OK)
792 g_snprintf(command, sizeof(command),
793 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
796 if (scope_state_get_array_option(scpi, command, config->coupling_options,
797 config->num_coupling_options,
798 &state->analog_channels[i].coupling) != SR_OK)
801 g_snprintf(command, sizeof(command),
802 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
805 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
808 if (tmp_str[0] == 'A')
809 state->analog_channels[i].probe_unit = 'A';
811 state->analog_channels[i].probe_unit = 'V';
818 static int digital_channel_state_get(struct sr_dev_inst *sdi,
819 const struct scope_config *config,
820 struct scope_state *state)
824 static char *logic_threshold_short[] = {};
825 char command[MAX_COMMAND_SIZE];
826 struct sr_channel *ch;
827 struct sr_scpi_dev_inst *scpi = sdi->conn;
829 for (i = 0; i < config->digital_channels; i++) {
830 g_snprintf(command, sizeof(command),
831 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
834 if (sr_scpi_get_bool(scpi, command,
835 &state->digital_channels[i]) != SR_OK)
838 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
840 ch->enabled = state->digital_channels[i];
843 /* According to the SCPI standard, on models that support multiple
844 * user-defined logic threshold settings the response to the command
845 * SCPI_CMD_GET_DIG_POD_THRESHOLD might return "USER" instead of
848 * This makes more difficult to validate the response when the logic
849 * threshold is set to "USER1" and therefore we need to prevent device
850 * opening failures in such configuration case...
852 for (i = 0; i < config->num_logic_threshold; i++) {
853 logic_threshold_short[i] = g_strdup((*config->logic_threshold)[i]);
854 if (!strcmp("USER1", (*config->logic_threshold)[i]))
855 g_strlcpy(logic_threshold_short[i],
856 (*config->logic_threshold)[i], strlen((*config->logic_threshold)[i]));
859 for (i = 0; i < config->digital_pods; i++) {
860 g_snprintf(command, sizeof(command),
861 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
864 if (sr_scpi_get_bool(scpi, command,
865 &state->digital_pods[i].state) != SR_OK)
868 /* Check if the threshold command is based on the POD or digital channel index. */
869 if (config->logic_threshold_for_pod)
874 g_snprintf(command, sizeof(command),
875 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_THRESHOLD],
878 /* Check for both standard and shortened responses. */
879 if (scope_state_get_array_option(scpi, command, config->logic_threshold,
880 config->num_logic_threshold,
881 &state->digital_pods[i].threshold) != SR_OK)
882 if (scope_state_get_array_option(scpi, command, (const char * (*)[]) &logic_threshold_short,
883 config->num_logic_threshold,
884 &state->digital_pods[i].threshold) != SR_OK)
887 /* If used-defined or custom threshold is active, get the level. */
888 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]))
889 g_snprintf(command, sizeof(command),
890 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
891 idx, 1); /* USER1 logic threshold setting. */
892 else if (!strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
893 g_snprintf(command, sizeof(command),
894 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
895 idx, 2); /* USER2 for custom logic_threshold setting. */
896 else if (!strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
897 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
898 g_snprintf(command, sizeof(command),
899 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
900 idx); /* USER or MAN for custom logic_threshold setting. */
901 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
902 !strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
903 !strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
904 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
905 if (sr_scpi_get_float(scpi, command,
906 &state->digital_pods[i].user_threshold) != SR_OK)
913 for (i = 0; i < config->num_logic_threshold; i++)
914 g_free(logic_threshold_short[i]);
919 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
921 struct dev_context *devc;
922 struct scope_state *state;
923 const struct scope_config *config;
927 config = devc->model_config;
928 state = devc->model_state;
930 if (sr_scpi_get_float(sdi->conn,
931 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
932 &tmp_float) != SR_OK)
935 state->sample_rate = tmp_float;
940 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
942 struct dev_context *devc;
943 struct scope_state *state;
944 const struct scope_config *config;
950 config = devc->model_config;
951 state = devc->model_state;
953 sr_info("Fetching scope state");
955 if (analog_channel_state_get(sdi, config, state) != SR_OK)
958 if (digital_channel_state_get(sdi, config, state) != SR_OK)
961 if (sr_scpi_get_float(sdi->conn,
962 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
963 &tmp_float) != SR_OK)
966 if (sr_scpi_get_string(sdi->conn,
967 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
971 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
973 sr_err("Could not determine array index for time base.");
980 if (sr_scpi_get_float(sdi->conn,
981 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
982 &tmp_float) != SR_OK)
984 state->horiz_triggerpos = tmp_float /
985 (((double) (*config->timebases)[state->timebase][0] /
986 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
987 state->horiz_triggerpos -= 0.5;
988 state->horiz_triggerpos *= -1;
990 if (scope_state_get_array_option(sdi->conn,
991 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
992 config->trigger_sources, config->num_trigger_sources,
993 &state->trigger_source) != SR_OK)
996 if (scope_state_get_array_option(sdi->conn,
997 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
998 config->trigger_slopes, config->num_trigger_slopes,
999 &state->trigger_slope) != SR_OK)
1002 if (sr_scpi_get_string(sdi->conn,
1003 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_PATTERN],
1004 &state->trigger_pattern) != SR_OK)
1007 if (hmo_update_sample_rate(sdi) != SR_OK)
1010 sr_info("Fetching finished.");
1012 scope_state_dump(config, state);
1017 static struct scope_state *scope_state_new(const struct scope_config *config)
1019 struct scope_state *state;
1021 state = g_malloc0(sizeof(struct scope_state));
1022 state->analog_channels = g_malloc0_n(config->analog_channels,
1023 sizeof(struct analog_channel_state));
1024 state->digital_channels = g_malloc0_n(
1025 config->digital_channels, sizeof(gboolean));
1026 state->digital_pods = g_malloc0_n(config->digital_pods,
1027 sizeof(struct digital_pod_state));
1032 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
1034 g_free(state->analog_channels);
1035 g_free(state->digital_channels);
1036 g_free(state->digital_pods);
1040 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
1043 unsigned int i, j, group;
1044 struct sr_channel *ch;
1045 struct dev_context *devc;
1051 /* Find the exact model. */
1052 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
1053 for (j = 0; scope_models[i].name[j]; j++) {
1054 if (!strcmp(sdi->model, scope_models[i].name[j])) {
1059 if (model_index != -1)
1063 if (model_index == -1) {
1064 sr_dbg("Unsupported device.");
1068 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1069 scope_models[model_index].analog_channels);
1070 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1071 scope_models[model_index].digital_pods);
1072 if (!devc->analog_groups || !devc->digital_groups) {
1073 g_free(devc->analog_groups);
1074 g_free(devc->digital_groups);
1075 return SR_ERR_MALLOC;
1078 /* Add analog channels. */
1079 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
1080 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
1081 (*scope_models[model_index].analog_names)[i]);
1083 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
1085 devc->analog_groups[i]->name = g_strdup(
1086 (char *)(*scope_models[model_index].analog_names)[i]);
1087 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
1089 sdi->channel_groups = g_slist_append(sdi->channel_groups,
1090 devc->analog_groups[i]);
1093 /* Add digital channel groups. */
1095 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
1096 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
1097 if (!devc->digital_groups[i]) {
1098 ret = SR_ERR_MALLOC;
1101 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i + 1);
1102 sdi->channel_groups = g_slist_append(sdi->channel_groups,
1103 devc->digital_groups[i]);
1108 /* Add digital channels. */
1109 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
1110 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
1111 (*scope_models[model_index].digital_names)[i]);
1114 devc->digital_groups[group]->channels = g_slist_append(
1115 devc->digital_groups[group]->channels, ch);
1118 devc->model_config = &scope_models[model_index];
1119 devc->samples_limit = 0;
1120 devc->frame_limit = 0;
1122 if (!(devc->model_state = scope_state_new(devc->model_config)))
1123 return SR_ERR_MALLOC;
1128 /* Queue data of one channel group, for later submission. */
1129 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
1130 size_t group, GByteArray *pod_data)
1134 uint8_t *logic_data;
1135 size_t idx, logic_step;
1138 * Upon first invocation, allocate the array which can hold the
1139 * combined logic data for all channels. Assume that each channel
1140 * will yield an identical number of samples per receive call.
1142 * As a poor man's safety measure: (Silently) skip processing
1143 * for unexpected sample counts, and ignore samples for
1144 * unexpected channel groups. Don't bother with complicated
1145 * resize logic, considering that many models only support one
1146 * pod, and the most capable supported models have two pods of
1147 * identical size. We haven't yet seen any "odd" configuration.
1149 if (!devc->logic_data) {
1150 size = pod_data->len * devc->pod_count;
1151 store = g_byte_array_sized_new(size);
1152 memset(store->data, 0, size);
1153 store = g_byte_array_set_size(store, size);
1154 devc->logic_data = store;
1156 store = devc->logic_data;
1157 size = store->len / devc->pod_count;
1158 if (group >= devc->pod_count)
1163 * Fold the data of the most recently received channel group into
1164 * the storage, where data resides for all channels combined.
1166 logic_data = store->data;
1167 logic_data += group;
1168 logic_step = devc->pod_count;
1169 for (idx = 0; idx < pod_data->len; idx++) {
1170 *logic_data = pod_data->data[idx];
1171 logic_data += logic_step;
1174 /* Truncate acquisition if a smaller number of samples has been requested. */
1175 if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
1176 devc->logic_data->len = devc->samples_limit * devc->pod_count;
1179 /* Submit data for all channels, after the individual groups got collected. */
1180 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
1181 struct dev_context *devc)
1183 struct sr_datafeed_packet packet;
1184 struct sr_datafeed_logic logic;
1186 if (!devc->logic_data)
1189 logic.data = devc->logic_data->data;
1190 logic.length = devc->logic_data->len;
1191 logic.unitsize = devc->pod_count;
1193 packet.type = SR_DF_LOGIC;
1194 packet.payload = &logic;
1196 sr_session_send(sdi, &packet);
1199 /* Undo previous resource allocation. */
1200 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
1203 if (devc->logic_data) {
1204 g_byte_array_free(devc->logic_data, TRUE);
1205 devc->logic_data = NULL;
1208 * Keep 'pod_count'! It's required when more frames will be
1209 * received, and does not harm when kept after acquisition.
1213 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
1215 struct sr_channel *ch;
1216 struct sr_dev_inst *sdi;
1217 struct dev_context *devc;
1218 struct scope_state *state;
1219 struct sr_datafeed_packet packet;
1221 struct sr_datafeed_analog analog;
1222 struct sr_analog_encoding encoding;
1223 struct sr_analog_meaning meaning;
1224 struct sr_analog_spec spec;
1225 struct sr_datafeed_logic logic;
1233 if (!(sdi = cb_data))
1236 if (!(devc = sdi->priv))
1239 /* Although this is correct in general, the USBTMC libusb implementation
1240 * currently does not generate an event prior to the first read. Often
1241 * it is ok to start reading just after the 50ms timeout. See bug #785.
1242 if (revents != G_IO_IN)
1246 ch = devc->current_channel->data;
1247 state = devc->model_state;
1250 * Send "frame begin" packet upon reception of data for the
1251 * first enabled channel.
1253 if (devc->current_channel == devc->enabled_channels) {
1254 packet.type = SR_DF_FRAME_BEGIN;
1255 sr_session_send(sdi, &packet);
1259 * Pass on the received data of the channel(s).
1262 case SR_CHANNEL_ANALOG:
1263 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1265 g_byte_array_free(data, TRUE);
1269 packet.type = SR_DF_ANALOG;
1271 analog.data = data->data;
1272 analog.num_samples = data->len / sizeof(float);
1273 /* Truncate acquisition if a smaller number of samples has been requested. */
1274 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1275 analog.num_samples = devc->samples_limit;
1276 analog.encoding = &encoding;
1277 analog.meaning = &meaning;
1278 analog.spec = &spec;
1280 encoding.unitsize = sizeof(float);
1281 encoding.is_signed = TRUE;
1282 encoding.is_float = TRUE;
1283 #ifdef WORDS_BIGENDIAN
1284 encoding.is_bigendian = TRUE;
1286 encoding.is_bigendian = FALSE;
1288 /* TODO: Use proper 'digits' value for this device (and its modes). */
1289 encoding.digits = 2;
1290 encoding.is_digits_decimal = FALSE;
1291 encoding.scale.p = 1;
1292 encoding.scale.q = 1;
1293 encoding.offset.p = 0;
1294 encoding.offset.q = 1;
1295 if (state->analog_channels[ch->index].probe_unit == 'V') {
1296 meaning.mq = SR_MQ_VOLTAGE;
1297 meaning.unit = SR_UNIT_VOLT;
1299 meaning.mq = SR_MQ_CURRENT;
1300 meaning.unit = SR_UNIT_AMPERE;
1302 meaning.mqflags = 0;
1303 meaning.channels = g_slist_append(NULL, ch);
1304 /* TODO: Use proper 'digits' value for this device (and its modes). */
1305 spec.spec_digits = 2;
1306 packet.payload = &analog;
1307 sr_session_send(sdi, &packet);
1308 devc->num_samples = data->len / sizeof(float);
1309 g_slist_free(meaning.channels);
1310 g_byte_array_free(data, TRUE);
1313 case SR_CHANNEL_LOGIC:
1314 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1316 g_byte_array_free(data, TRUE);
1321 * If only data from the first pod is involved in the
1322 * acquisition, then the raw input bytes can get passed
1323 * forward for performance reasons. When the second pod
1324 * is involved (either alone, or in combination with the
1325 * first pod), then the received bytes need to be put
1326 * into memory in such a layout that all channel groups
1327 * get combined, and a unitsize larger than a single byte
1328 * applies. The "queue" logic transparently copes with
1329 * any such configuration. This works around the lack
1330 * of support for "meaning" to logic data, which is used
1331 * above for analog data.
1333 if (devc->pod_count == 1) {
1334 packet.type = SR_DF_LOGIC;
1335 logic.data = data->data;
1336 logic.length = data->len;
1337 /* Truncate acquisition if a smaller number of samples has been requested. */
1338 if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1339 logic.length = devc->samples_limit;
1341 packet.payload = &logic;
1342 sr_session_send(sdi, &packet);
1344 group = ch->index / 8;
1345 hmo_queue_logic_data(devc, group, data);
1348 devc->num_samples = data->len / devc->pod_count;
1349 g_byte_array_free(data, TRUE);
1353 sr_err("Invalid channel type.");
1358 * Advance to the next enabled channel. When data for all enabled
1359 * channels was received, then flush potentially queued logic data,
1360 * and send the "frame end" packet.
1362 if (devc->current_channel->next) {
1363 devc->current_channel = devc->current_channel->next;
1364 hmo_request_data(sdi);
1367 hmo_send_logic_packet(sdi, devc);
1370 * Release the logic data storage after each frame. This copes
1371 * with sample counts that differ in length per frame. -- Is
1372 * this a real constraint when acquiring multiple frames with
1373 * identical device settings?
1375 hmo_cleanup_logic_data(devc);
1377 packet.type = SR_DF_FRAME_END;
1378 sr_session_send(sdi, &packet);
1381 * End of frame was reached. Stop acquisition after the specified
1382 * number of frames or after the specified number of samples, or
1383 * continue reception by starting over at the first enabled channel.
1385 if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1386 sr_dev_acquisition_stop(sdi);
1387 hmo_cleanup_logic_data(devc);
1389 devc->current_channel = devc->enabled_channels;
1390 hmo_request_data(sdi);