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] = {
260 /* HMO Compact series (HMO722/724/1022/1024/1522/1524/2022/2024) do
261 * not support 1 ns timebase setting.
263 static const uint64_t timebases_hmo_compact[][2] = {
302 static const uint64_t vdivs[][2] = {
320 static const char *scope_analog_channel_names[] = {
321 "CH1", "CH2", "CH3", "CH4",
324 static const char *scope_digital_channel_names[] = {
325 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
326 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
329 static const struct scope_config scope_models[] = {
331 /* HMO Compact2: HMO722/1022/1522/2022 support only 8 digital channels. */
332 .name = {"HMO722", "HMO1022", "HMO1522", "HMO2022", NULL},
333 .analog_channels = 2,
334 .digital_channels = 8,
336 .analog_names = &scope_analog_channel_names,
337 .digital_names = &scope_digital_channel_names,
340 .num_devopts = ARRAY_SIZE(devopts),
342 .devopts_cg_analog = &devopts_cg_analog,
343 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
345 .devopts_cg_digital = &devopts_cg_digital,
346 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
348 .coupling_options = &coupling_options,
349 .num_coupling_options = ARRAY_SIZE(coupling_options),
351 .logic_threshold = &logic_threshold,
352 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
353 .logic_threshold_for_pod = TRUE,
355 .trigger_sources = &an2_dig8_trigger_sources,
356 .num_trigger_sources = ARRAY_SIZE(an2_dig8_trigger_sources),
358 .trigger_slopes = &scope_trigger_slopes,
359 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
361 .timebases = &timebases_hmo_compact,
362 .num_timebases = ARRAY_SIZE(timebases_hmo_compact),
365 .num_vdivs = ARRAY_SIZE(vdivs),
370 .scpi_dialect = &hameg_scpi_dialect,
373 /* RTC1002 and HMO1002/HMO1202 support only 8 digital channels. */
374 .name = {"RTC1002", "HMO1002", "HMO1202", NULL},
375 .analog_channels = 2,
376 .digital_channels = 8,
379 .analog_names = &scope_analog_channel_names,
380 .digital_names = &scope_digital_channel_names,
383 .num_devopts = ARRAY_SIZE(devopts),
385 .devopts_cg_analog = &devopts_cg_analog,
386 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
388 .devopts_cg_digital = &devopts_cg_digital,
389 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
391 .coupling_options = &coupling_options,
392 .num_coupling_options = ARRAY_SIZE(coupling_options),
394 .logic_threshold = &logic_threshold,
395 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
396 .logic_threshold_for_pod = TRUE,
398 .trigger_sources = &an2_dig8_trigger_sources,
399 .num_trigger_sources = ARRAY_SIZE(an2_dig8_trigger_sources),
401 .trigger_slopes = &scope_trigger_slopes,
402 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
404 .timebases = &timebases,
405 .num_timebases = ARRAY_SIZE(timebases),
408 .num_vdivs = ARRAY_SIZE(vdivs),
413 .scpi_dialect = &hameg_scpi_dialect,
416 /* HMO3032/3042/3052/3522 support 16 digital channels. */
417 .name = {"HMO3032", "HMO3042", "HMO3052", "HMO3522", NULL},
418 .analog_channels = 2,
419 .digital_channels = 16,
422 .analog_names = &scope_analog_channel_names,
423 .digital_names = &scope_digital_channel_names,
426 .num_devopts = ARRAY_SIZE(devopts),
428 .devopts_cg_analog = &devopts_cg_analog,
429 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
431 .devopts_cg_digital = &devopts_cg_digital,
432 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
434 .coupling_options = &coupling_options,
435 .num_coupling_options = ARRAY_SIZE(coupling_options),
437 .logic_threshold = &logic_threshold,
438 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
439 .logic_threshold_for_pod = TRUE,
441 .trigger_sources = &an2_dig16_trigger_sources,
442 .num_trigger_sources = ARRAY_SIZE(an2_dig16_trigger_sources),
444 .trigger_slopes = &scope_trigger_slopes,
445 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
447 .timebases = &timebases,
448 .num_timebases = ARRAY_SIZE(timebases),
451 .num_vdivs = ARRAY_SIZE(vdivs),
456 .scpi_dialect = &hameg_scpi_dialect,
459 /* HMO Compact4: HMO724/1024/1524/2024 support only 8 digital channels. */
460 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
461 .analog_channels = 4,
462 .digital_channels = 8,
465 .analog_names = &scope_analog_channel_names,
466 .digital_names = &scope_digital_channel_names,
469 .num_devopts = ARRAY_SIZE(devopts),
471 .devopts_cg_analog = &devopts_cg_analog,
472 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
474 .devopts_cg_digital = &devopts_cg_digital,
475 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
477 .coupling_options = &coupling_options,
478 .num_coupling_options = ARRAY_SIZE(coupling_options),
480 .logic_threshold = &logic_threshold,
481 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
482 .logic_threshold_for_pod = TRUE,
484 .trigger_sources = &an4_dig8_trigger_sources,
485 .num_trigger_sources = ARRAY_SIZE(an4_dig8_trigger_sources),
487 .trigger_slopes = &scope_trigger_slopes,
488 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
490 .timebases = &timebases_hmo_compact,
491 .num_timebases = ARRAY_SIZE(timebases_hmo_compact),
494 .num_vdivs = ARRAY_SIZE(vdivs),
499 .scpi_dialect = &hameg_scpi_dialect,
502 .name = {"HMO2524", "HMO3034", "HMO3044", "HMO3054", "HMO3524", NULL},
503 .analog_channels = 4,
504 .digital_channels = 16,
507 .analog_names = &scope_analog_channel_names,
508 .digital_names = &scope_digital_channel_names,
511 .num_devopts = ARRAY_SIZE(devopts),
513 .devopts_cg_analog = &devopts_cg_analog,
514 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
516 .devopts_cg_digital = &devopts_cg_digital,
517 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
519 .coupling_options = &coupling_options,
520 .num_coupling_options = ARRAY_SIZE(coupling_options),
522 .logic_threshold = &logic_threshold,
523 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
524 .logic_threshold_for_pod = TRUE,
526 .trigger_sources = &an4_dig16_trigger_sources,
527 .num_trigger_sources = ARRAY_SIZE(an4_dig16_trigger_sources),
529 .trigger_slopes = &scope_trigger_slopes,
530 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
532 .timebases = &timebases,
533 .num_timebases = ARRAY_SIZE(timebases),
536 .num_vdivs = ARRAY_SIZE(vdivs),
541 .scpi_dialect = &hameg_scpi_dialect,
544 .name = {"RTB2002", NULL},
545 .analog_channels = 2,
546 .digital_channels = 16,
549 .analog_names = &scope_analog_channel_names,
550 .digital_names = &scope_digital_channel_names,
553 .num_devopts = ARRAY_SIZE(devopts),
555 .devopts_cg_analog = &devopts_cg_analog,
556 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
558 .devopts_cg_digital = &devopts_cg_digital,
559 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
561 .coupling_options = &coupling_options_rtb200x,
562 .num_coupling_options = ARRAY_SIZE(coupling_options_rtb200x),
564 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
565 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
566 .logic_threshold_for_pod = FALSE,
568 .trigger_sources = &an2_dig16_sbus_trigger_sources,
569 .num_trigger_sources = ARRAY_SIZE(an2_dig16_sbus_trigger_sources),
571 .trigger_slopes = &scope_trigger_slopes,
572 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
574 .timebases = &timebases,
575 .num_timebases = ARRAY_SIZE(timebases),
578 .num_vdivs = ARRAY_SIZE(vdivs),
583 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
586 .name = {"RTB2004", NULL},
587 .analog_channels = 4,
588 .digital_channels = 16,
591 .analog_names = &scope_analog_channel_names,
592 .digital_names = &scope_digital_channel_names,
595 .num_devopts = ARRAY_SIZE(devopts),
597 .devopts_cg_analog = &devopts_cg_analog,
598 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
600 .devopts_cg_digital = &devopts_cg_digital,
601 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
603 .coupling_options = &coupling_options_rtb200x,
604 .num_coupling_options = ARRAY_SIZE(coupling_options_rtb200x),
606 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
607 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
608 .logic_threshold_for_pod = FALSE,
610 .trigger_sources = &an4_dig16_sbus_trigger_sources,
611 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
613 .trigger_slopes = &scope_trigger_slopes,
614 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
616 .timebases = &timebases,
617 .num_timebases = ARRAY_SIZE(timebases),
620 .num_vdivs = ARRAY_SIZE(vdivs),
625 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
628 .name = {"RTM3002", NULL},
629 .analog_channels = 2,
630 .digital_channels = 16,
633 .analog_names = &scope_analog_channel_names,
634 .digital_names = &scope_digital_channel_names,
637 .num_devopts = ARRAY_SIZE(devopts),
639 .devopts_cg_analog = &devopts_cg_analog,
640 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
642 .devopts_cg_digital = &devopts_cg_digital,
643 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
645 .coupling_options = &coupling_options_rtm300x,
646 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
648 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
649 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
650 .logic_threshold_for_pod = FALSE,
652 .trigger_sources = &an2_dig16_sbus_trigger_sources,
653 .num_trigger_sources = ARRAY_SIZE(an2_dig16_sbus_trigger_sources),
655 .trigger_slopes = &scope_trigger_slopes,
656 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
658 .timebases = &timebases,
659 .num_timebases = ARRAY_SIZE(timebases),
662 .num_vdivs = ARRAY_SIZE(vdivs),
667 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
670 .name = {"RTM3004", NULL},
671 .analog_channels = 4,
672 .digital_channels = 16,
675 .analog_names = &scope_analog_channel_names,
676 .digital_names = &scope_digital_channel_names,
679 .num_devopts = ARRAY_SIZE(devopts),
681 .devopts_cg_analog = &devopts_cg_analog,
682 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
684 .devopts_cg_digital = &devopts_cg_digital,
685 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
687 .coupling_options = &coupling_options_rtm300x,
688 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
690 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
691 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
692 .logic_threshold_for_pod = FALSE,
694 .trigger_sources = &an4_dig16_sbus_trigger_sources,
695 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
697 .trigger_slopes = &scope_trigger_slopes,
698 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
700 .timebases = &timebases,
701 .num_timebases = ARRAY_SIZE(timebases),
704 .num_vdivs = ARRAY_SIZE(vdivs),
709 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
712 .name = {"RTA4004", NULL},
713 .analog_channels = 4,
714 .digital_channels = 16,
717 .analog_names = &scope_analog_channel_names,
718 .digital_names = &scope_digital_channel_names,
721 .num_devopts = ARRAY_SIZE(devopts),
723 .devopts_cg_analog = &devopts_cg_analog,
724 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
726 .devopts_cg_digital = &devopts_cg_digital,
727 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
729 .coupling_options = &coupling_options_rtm300x,
730 .num_coupling_options = ARRAY_SIZE(coupling_options_rtm300x),
732 .logic_threshold = &logic_threshold_rtb200x_rtm300x,
733 .num_logic_threshold = ARRAY_SIZE(logic_threshold_rtb200x_rtm300x),
734 .logic_threshold_for_pod = FALSE,
736 .trigger_sources = &an4_dig16_sbus_trigger_sources,
737 .num_trigger_sources = ARRAY_SIZE(an4_dig16_sbus_trigger_sources),
739 .trigger_slopes = &scope_trigger_slopes,
740 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
742 .timebases = &timebases,
743 .num_timebases = ARRAY_SIZE(timebases),
746 .num_vdivs = ARRAY_SIZE(vdivs),
751 .scpi_dialect = &rohde_schwarz_log_not_pod_scpi_dialect,
755 static void scope_state_dump(const struct scope_config *config,
756 struct scope_state *state)
761 for (i = 0; i < config->analog_channels; i++) {
762 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
763 (*config->vdivs)[state->analog_channels[i].vdiv][1]);
764 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
765 i + 1, state->analog_channels[i].state ? "On" : "Off",
766 (*config->coupling_options)[state->analog_channels[i].coupling],
767 tmp, state->analog_channels[i].vertical_offset);
770 for (i = 0; i < config->digital_channels; i++) {
771 sr_info("State of digital channel %d -> %s", i,
772 state->digital_channels[i] ? "On" : "Off");
775 for (i = 0; i < config->digital_pods; i++) {
776 if (!strncmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold], 4) ||
777 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
778 sr_info("State of digital POD %d -> %s : %E (threshold)", i + 1,
779 state->digital_pods[i].state ? "On" : "Off",
780 state->digital_pods[i].user_threshold);
782 sr_info("State of digital POD %d -> %s : %s (threshold)", i + 1,
783 state->digital_pods[i].state ? "On" : "Off",
784 (*config->logic_threshold)[state->digital_pods[i].threshold]);
787 tmp = sr_period_string((*config->timebases)[state->timebase][0],
788 (*config->timebases)[state->timebase][1]);
789 sr_info("Current timebase: %s", tmp);
792 tmp = sr_samplerate_string(state->sample_rate);
793 sr_info("Current samplerate: %s", tmp);
796 if (!strcmp("PATT", (*config->trigger_sources)[state->trigger_source]))
797 sr_info("Current trigger: %s (pattern), %.2f (offset)",
798 state->trigger_pattern,
799 state->horiz_triggerpos);
800 else // Edge (slope) trigger
801 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
802 (*config->trigger_sources)[state->trigger_source],
803 (*config->trigger_slopes)[state->trigger_slope],
804 state->horiz_triggerpos);
807 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
808 const char *command, const char *(*array)[], unsigned int n, int *result)
813 if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK)
816 if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
829 * This function takes a value of the form "2.000E-03" and returns the index
830 * of an array where a matching pair was found.
832 * @param value The string to be parsed.
833 * @param array The array of s/f pairs.
834 * @param array_len The number of pairs in the array.
835 * @param result The index at which a matching pair was found.
837 * @return SR_ERR on any parsing error, SR_OK otherwise.
839 static int array_float_get(gchar *value, const uint64_t array[][2],
840 int array_len, unsigned int *result)
842 struct sr_rational rval;
843 struct sr_rational aval;
845 if (sr_parse_rational(value, &rval) != SR_OK)
848 for (int i = 0; i < array_len; i++) {
849 sr_rational_set(&aval, array[i][0], array[i][1]);
850 if (sr_rational_eq(&rval, &aval)) {
859 static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
862 while (channel_lhead) {
863 struct sr_channel *ch = channel_lhead->data;
864 if (ch->index == index && ch->type == type)
867 channel_lhead = channel_lhead->next;
873 static int analog_channel_state_get(struct sr_dev_inst *sdi,
874 const struct scope_config *config,
875 struct scope_state *state)
878 char command[MAX_COMMAND_SIZE];
880 struct sr_channel *ch;
881 struct sr_scpi_dev_inst *scpi = sdi->conn;
883 for (i = 0; i < config->analog_channels; i++) {
884 g_snprintf(command, sizeof(command),
885 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
888 if (sr_scpi_get_bool(scpi, command,
889 &state->analog_channels[i].state) != SR_OK)
892 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
894 ch->enabled = state->analog_channels[i].state;
896 g_snprintf(command, sizeof(command),
897 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
900 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
903 if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
905 sr_err("Could not determine array index for vertical div scale.");
910 state->analog_channels[i].vdiv = j;
912 g_snprintf(command, sizeof(command),
913 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
916 if (sr_scpi_get_float(scpi, command,
917 &state->analog_channels[i].vertical_offset) != SR_OK)
920 g_snprintf(command, sizeof(command),
921 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
924 if (scope_state_get_array_option(scpi, command, config->coupling_options,
925 config->num_coupling_options,
926 &state->analog_channels[i].coupling) != SR_OK)
929 g_snprintf(command, sizeof(command),
930 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
933 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
936 if (tmp_str[0] == 'A')
937 state->analog_channels[i].probe_unit = 'A';
939 state->analog_channels[i].probe_unit = 'V';
946 static int digital_channel_state_get(struct sr_dev_inst *sdi,
947 const struct scope_config *config,
948 struct scope_state *state)
952 static char *logic_threshold_short[] = {};
953 char command[MAX_COMMAND_SIZE];
954 struct sr_channel *ch;
955 struct sr_scpi_dev_inst *scpi = sdi->conn;
957 for (i = 0; i < config->digital_channels; i++) {
958 g_snprintf(command, sizeof(command),
959 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
962 if (sr_scpi_get_bool(scpi, command,
963 &state->digital_channels[i]) != SR_OK)
966 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
968 ch->enabled = state->digital_channels[i];
971 /* According to the SCPI standard, on models that support multiple
972 * user-defined logic threshold settings the response to the command
973 * SCPI_CMD_GET_DIG_POD_THRESHOLD might return "USER" instead of
976 * This makes more difficult to validate the response when the logic
977 * threshold is set to "USER1" and therefore we need to prevent device
978 * opening failures in such configuration case...
980 for (i = 0; i < config->num_logic_threshold; i++) {
981 logic_threshold_short[i] = g_strdup((*config->logic_threshold)[i]);
982 if (!strcmp("USER1", (*config->logic_threshold)[i]))
983 g_strlcpy(logic_threshold_short[i],
984 (*config->logic_threshold)[i], strlen((*config->logic_threshold)[i]));
987 for (i = 0; i < config->digital_pods; i++) {
988 g_snprintf(command, sizeof(command),
989 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
992 if (sr_scpi_get_bool(scpi, command,
993 &state->digital_pods[i].state) != SR_OK)
996 /* Check if the threshold command is based on the POD or digital channel index. */
997 if (config->logic_threshold_for_pod)
1002 g_snprintf(command, sizeof(command),
1003 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_THRESHOLD],
1006 /* Check for both standard and shortened responses. */
1007 if (scope_state_get_array_option(scpi, command, config->logic_threshold,
1008 config->num_logic_threshold,
1009 &state->digital_pods[i].threshold) != SR_OK)
1010 if (scope_state_get_array_option(scpi, command, (const char * (*)[]) &logic_threshold_short,
1011 config->num_logic_threshold,
1012 &state->digital_pods[i].threshold) != SR_OK)
1015 /* If used-defined or custom threshold is active, get the level. */
1016 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1017 g_snprintf(command, sizeof(command),
1018 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1019 idx, 1); /* USER1 logic threshold setting. */
1020 else if (!strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1021 g_snprintf(command, sizeof(command),
1022 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1023 idx, 2); /* USER2 for custom logic_threshold setting. */
1024 else if (!strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1025 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1026 g_snprintf(command, sizeof(command),
1027 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
1028 idx); /* USER or MAN for custom logic_threshold setting. */
1029 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1030 !strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1031 !strcmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
1032 !strcmp("MAN", (*config->logic_threshold)[state->digital_pods[i].threshold]))
1033 if (sr_scpi_get_float(scpi, command,
1034 &state->digital_pods[i].user_threshold) != SR_OK)
1041 for (i = 0; i < config->num_logic_threshold; i++)
1042 g_free(logic_threshold_short[i]);
1047 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
1049 struct dev_context *devc;
1050 struct scope_state *state;
1051 const struct scope_config *config;
1055 config = devc->model_config;
1056 state = devc->model_state;
1058 if (sr_scpi_get_float(sdi->conn,
1059 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
1060 &tmp_float) != SR_OK)
1063 state->sample_rate = tmp_float;
1068 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
1070 struct dev_context *devc;
1071 struct scope_state *state;
1072 const struct scope_config *config;
1078 config = devc->model_config;
1079 state = devc->model_state;
1081 sr_info("Fetching scope state");
1083 if (analog_channel_state_get(sdi, config, state) != SR_OK)
1086 if (digital_channel_state_get(sdi, config, state) != SR_OK)
1089 if (sr_scpi_get_float(sdi->conn,
1090 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
1091 &tmp_float) != SR_OK)
1094 if (sr_scpi_get_string(sdi->conn,
1095 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
1099 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
1101 sr_err("Could not determine array index for time base.");
1106 state->timebase = i;
1108 if (sr_scpi_get_float(sdi->conn,
1109 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
1110 &tmp_float) != SR_OK)
1112 state->horiz_triggerpos = tmp_float /
1113 (((double) (*config->timebases)[state->timebase][0] /
1114 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
1115 state->horiz_triggerpos -= 0.5;
1116 state->horiz_triggerpos *= -1;
1118 if (scope_state_get_array_option(sdi->conn,
1119 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
1120 config->trigger_sources, config->num_trigger_sources,
1121 &state->trigger_source) != SR_OK)
1124 if (scope_state_get_array_option(sdi->conn,
1125 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
1126 config->trigger_slopes, config->num_trigger_slopes,
1127 &state->trigger_slope) != SR_OK)
1130 if (sr_scpi_get_string(sdi->conn,
1131 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_PATTERN],
1132 &state->trigger_pattern) != SR_OK)
1135 if (hmo_update_sample_rate(sdi) != SR_OK)
1138 sr_info("Fetching finished.");
1140 scope_state_dump(config, state);
1145 static struct scope_state *scope_state_new(const struct scope_config *config)
1147 struct scope_state *state;
1149 state = g_malloc0(sizeof(struct scope_state));
1150 state->analog_channels = g_malloc0_n(config->analog_channels,
1151 sizeof(struct analog_channel_state));
1152 state->digital_channels = g_malloc0_n(
1153 config->digital_channels, sizeof(gboolean));
1154 state->digital_pods = g_malloc0_n(config->digital_pods,
1155 sizeof(struct digital_pod_state));
1160 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
1162 g_free(state->analog_channels);
1163 g_free(state->digital_channels);
1164 g_free(state->digital_pods);
1168 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
1171 unsigned int i, j, group;
1172 struct sr_channel *ch;
1173 struct dev_context *devc;
1179 /* Find the exact model. */
1180 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
1181 for (j = 0; scope_models[i].name[j]; j++) {
1182 if (!strcmp(sdi->model, scope_models[i].name[j])) {
1187 if (model_index != -1)
1191 if (model_index == -1) {
1192 sr_dbg("Unsupported device.");
1196 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1197 scope_models[model_index].analog_channels);
1198 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
1199 scope_models[model_index].digital_pods);
1200 if (!devc->analog_groups || !devc->digital_groups) {
1201 g_free(devc->analog_groups);
1202 g_free(devc->digital_groups);
1203 return SR_ERR_MALLOC;
1206 /* Add analog channels. */
1207 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
1208 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
1209 (*scope_models[model_index].analog_names)[i]);
1211 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
1213 devc->analog_groups[i]->name = g_strdup(
1214 (char *)(*scope_models[model_index].analog_names)[i]);
1215 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
1217 sdi->channel_groups = g_slist_append(sdi->channel_groups,
1218 devc->analog_groups[i]);
1221 /* Add digital channel groups. */
1223 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
1224 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
1225 if (!devc->digital_groups[i]) {
1226 ret = SR_ERR_MALLOC;
1229 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i + 1);
1230 sdi->channel_groups = g_slist_append(sdi->channel_groups,
1231 devc->digital_groups[i]);
1236 /* Add digital channels. */
1237 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
1238 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
1239 (*scope_models[model_index].digital_names)[i]);
1242 devc->digital_groups[group]->channels = g_slist_append(
1243 devc->digital_groups[group]->channels, ch);
1246 devc->model_config = &scope_models[model_index];
1247 devc->samples_limit = 0;
1248 devc->frame_limit = 0;
1250 if (!(devc->model_state = scope_state_new(devc->model_config)))
1251 return SR_ERR_MALLOC;
1256 /* Queue data of one channel group, for later submission. */
1257 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
1258 size_t group, GByteArray *pod_data)
1262 uint8_t *logic_data;
1263 size_t idx, logic_step;
1266 * Upon first invocation, allocate the array which can hold the
1267 * combined logic data for all channels. Assume that each channel
1268 * will yield an identical number of samples per receive call.
1270 * As a poor man's safety measure: (Silently) skip processing
1271 * for unexpected sample counts, and ignore samples for
1272 * unexpected channel groups. Don't bother with complicated
1273 * resize logic, considering that many models only support one
1274 * pod, and the most capable supported models have two pods of
1275 * identical size. We haven't yet seen any "odd" configuration.
1277 if (!devc->logic_data) {
1278 size = pod_data->len * devc->pod_count;
1279 store = g_byte_array_sized_new(size);
1280 memset(store->data, 0, size);
1281 store = g_byte_array_set_size(store, size);
1282 devc->logic_data = store;
1284 store = devc->logic_data;
1285 size = store->len / devc->pod_count;
1286 if (group >= devc->pod_count)
1291 * Fold the data of the most recently received channel group into
1292 * the storage, where data resides for all channels combined.
1294 logic_data = store->data;
1295 logic_data += group;
1296 logic_step = devc->pod_count;
1297 for (idx = 0; idx < pod_data->len; idx++) {
1298 *logic_data = pod_data->data[idx];
1299 logic_data += logic_step;
1302 /* Truncate acquisition if a smaller number of samples has been requested. */
1303 if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
1304 devc->logic_data->len = devc->samples_limit * devc->pod_count;
1307 /* Submit data for all channels, after the individual groups got collected. */
1308 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
1309 struct dev_context *devc)
1311 struct sr_datafeed_packet packet;
1312 struct sr_datafeed_logic logic;
1314 if (!devc->logic_data)
1317 logic.data = devc->logic_data->data;
1318 logic.length = devc->logic_data->len;
1319 logic.unitsize = devc->pod_count;
1321 packet.type = SR_DF_LOGIC;
1322 packet.payload = &logic;
1324 sr_session_send(sdi, &packet);
1327 /* Undo previous resource allocation. */
1328 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
1331 if (devc->logic_data) {
1332 g_byte_array_free(devc->logic_data, TRUE);
1333 devc->logic_data = NULL;
1336 * Keep 'pod_count'! It's required when more frames will be
1337 * received, and does not harm when kept after acquisition.
1341 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
1343 struct sr_channel *ch;
1344 struct sr_dev_inst *sdi;
1345 struct dev_context *devc;
1346 struct scope_state *state;
1347 struct sr_datafeed_packet packet;
1349 struct sr_datafeed_analog analog;
1350 struct sr_analog_encoding encoding;
1351 struct sr_analog_meaning meaning;
1352 struct sr_analog_spec spec;
1353 struct sr_datafeed_logic logic;
1361 if (!(sdi = cb_data))
1364 if (!(devc = sdi->priv))
1367 /* Although this is correct in general, the USBTMC libusb implementation
1368 * currently does not generate an event prior to the first read. Often
1369 * it is ok to start reading just after the 50ms timeout. See bug #785.
1370 if (revents != G_IO_IN)
1374 ch = devc->current_channel->data;
1375 state = devc->model_state;
1378 * Send "frame begin" packet upon reception of data for the
1379 * first enabled channel.
1381 if (devc->current_channel == devc->enabled_channels) {
1382 packet.type = SR_DF_FRAME_BEGIN;
1383 sr_session_send(sdi, &packet);
1387 * Pass on the received data of the channel(s).
1390 case SR_CHANNEL_ANALOG:
1391 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1393 g_byte_array_free(data, TRUE);
1397 packet.type = SR_DF_ANALOG;
1399 analog.data = data->data;
1400 analog.num_samples = data->len / sizeof(float);
1401 /* Truncate acquisition if a smaller number of samples has been requested. */
1402 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1403 analog.num_samples = devc->samples_limit;
1404 analog.encoding = &encoding;
1405 analog.meaning = &meaning;
1406 analog.spec = &spec;
1408 encoding.unitsize = sizeof(float);
1409 encoding.is_signed = TRUE;
1410 encoding.is_float = TRUE;
1411 #ifdef WORDS_BIGENDIAN
1412 encoding.is_bigendian = TRUE;
1414 encoding.is_bigendian = FALSE;
1416 /* TODO: Use proper 'digits' value for this device (and its modes). */
1417 encoding.digits = 2;
1418 encoding.is_digits_decimal = FALSE;
1419 encoding.scale.p = 1;
1420 encoding.scale.q = 1;
1421 encoding.offset.p = 0;
1422 encoding.offset.q = 1;
1423 if (state->analog_channels[ch->index].probe_unit == 'V') {
1424 meaning.mq = SR_MQ_VOLTAGE;
1425 meaning.unit = SR_UNIT_VOLT;
1427 meaning.mq = SR_MQ_CURRENT;
1428 meaning.unit = SR_UNIT_AMPERE;
1430 meaning.mqflags = 0;
1431 meaning.channels = g_slist_append(NULL, ch);
1432 /* TODO: Use proper 'digits' value for this device (and its modes). */
1433 spec.spec_digits = 2;
1434 packet.payload = &analog;
1435 sr_session_send(sdi, &packet);
1436 devc->num_samples = data->len / sizeof(float);
1437 g_slist_free(meaning.channels);
1438 g_byte_array_free(data, TRUE);
1441 case SR_CHANNEL_LOGIC:
1442 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1444 g_byte_array_free(data, TRUE);
1449 * If only data from the first pod is involved in the
1450 * acquisition, then the raw input bytes can get passed
1451 * forward for performance reasons. When the second pod
1452 * is involved (either alone, or in combination with the
1453 * first pod), then the received bytes need to be put
1454 * into memory in such a layout that all channel groups
1455 * get combined, and a unitsize larger than a single byte
1456 * applies. The "queue" logic transparently copes with
1457 * any such configuration. This works around the lack
1458 * of support for "meaning" to logic data, which is used
1459 * above for analog data.
1461 if (devc->pod_count == 1) {
1462 packet.type = SR_DF_LOGIC;
1463 logic.data = data->data;
1464 logic.length = data->len;
1465 /* Truncate acquisition if a smaller number of samples has been requested. */
1466 if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1467 logic.length = devc->samples_limit;
1469 packet.payload = &logic;
1470 sr_session_send(sdi, &packet);
1472 group = ch->index / 8;
1473 hmo_queue_logic_data(devc, group, data);
1476 devc->num_samples = data->len / devc->pod_count;
1477 g_byte_array_free(data, TRUE);
1481 sr_err("Invalid channel type.");
1486 * Advance to the next enabled channel. When data for all enabled
1487 * channels was received, then flush potentially queued logic data,
1488 * and send the "frame end" packet.
1490 if (devc->current_channel->next) {
1491 devc->current_channel = devc->current_channel->next;
1492 hmo_request_data(sdi);
1495 hmo_send_logic_packet(sdi, devc);
1498 * Release the logic data storage after each frame. This copes
1499 * with sample counts that differ in length per frame. -- Is
1500 * this a real constraint when acquiring multiple frames with
1501 * identical device settings?
1503 hmo_cleanup_logic_data(devc);
1505 packet.type = SR_DF_FRAME_END;
1506 sr_session_send(sdi, &packet);
1509 * End of frame was reached. Stop acquisition after the specified
1510 * number of frames or after the specified number of samples, or
1511 * continue reception by starting over at the first enabled channel.
1513 if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1514 sr_dev_acquisition_stop(sdi);
1515 hmo_cleanup_logic_data(devc);
1517 devc->current_channel = devc->enabled_channels;
1518 hmo_request_data(sdi);