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_SAMPLE_RATE_LIVE] = ":%s:DATA:POINTS?",
41 [SCPI_CMD_GET_ANALOG_DATA] = ":FORM:BORD %s;" \
42 ":FORM REAL,32;:CHAN%d:DATA?",
43 [SCPI_CMD_GET_VERTICAL_DIV] = ":CHAN%d:SCAL?",
44 [SCPI_CMD_SET_VERTICAL_DIV] = ":CHAN%d:SCAL %s",
45 [SCPI_CMD_GET_DIG_POD_STATE] = ":POD%d:STAT?",
46 [SCPI_CMD_SET_DIG_POD_STATE] = ":POD%d:STAT %d",
47 [SCPI_CMD_GET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP?",
48 [SCPI_CMD_SET_TRIGGER_SLOPE] = ":TRIG:A:TYPE EDGE;:TRIG:A:EDGE:SLOP %s",
49 [SCPI_CMD_GET_TRIGGER_PATTERN] = ":TRIG:A:PATT:SOUR?",
50 [SCPI_CMD_SET_TRIGGER_PATTERN] = ":TRIG:A:TYPE LOGIC;" \
51 ":TRIG:A:PATT:FUNC AND;" \
52 ":TRIG:A:PATT:COND TRUE;" \
53 ":TRIG:A:PATT:MODE OFF;" \
54 ":TRIG:A:PATT:SOUR \"%s\"",
55 [SCPI_CMD_GET_TRIGGER_SOURCE] = ":TRIG:A:SOUR?",
56 [SCPI_CMD_SET_TRIGGER_SOURCE] = ":TRIG:A:SOUR %s",
57 [SCPI_CMD_GET_DIG_CHAN_STATE] = ":LOG%d:STAT?",
58 [SCPI_CMD_SET_DIG_CHAN_STATE] = ":LOG%d:STAT %d",
59 [SCPI_CMD_GET_VERTICAL_OFFSET] = ":CHAN%d:POS?",
60 [SCPI_CMD_GET_HORIZ_TRIGGERPOS] = ":TIM:POS?",
61 [SCPI_CMD_SET_HORIZ_TRIGGERPOS] = ":TIM:POS %s",
62 [SCPI_CMD_GET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT?",
63 [SCPI_CMD_SET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT %d",
64 [SCPI_CMD_GET_PROBE_UNIT] = ":PROB%d:SET:ATT:UNIT?",
65 [SCPI_CMD_GET_DIG_POD_THRESHOLD] = ":POD%d:THR?",
66 [SCPI_CMD_SET_DIG_POD_THRESHOLD] = ":POD%d:THR %s",
67 [SCPI_CMD_GET_DIG_POD_USER_THRESHOLD] = ":POD%d:THR:UDL%d?",
68 [SCPI_CMD_SET_DIG_POD_USER_THRESHOLD] = ":POD%d:THR:UDL%d %s",
71 static const uint32_t devopts[] = {
73 SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
74 SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET,
75 SR_CONF_SAMPLERATE | SR_CONF_GET,
76 SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
77 SR_CONF_NUM_HDIV | SR_CONF_GET,
78 SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
79 SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
80 SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
81 SR_CONF_TRIGGER_PATTERN | SR_CONF_GET | SR_CONF_SET,
84 static const uint32_t devopts_cg_analog[] = {
85 SR_CONF_NUM_VDIV | SR_CONF_GET,
86 SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
87 SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
90 static const uint32_t devopts_cg_digital[] = {
91 SR_CONF_LOGIC_THRESHOLD | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
92 SR_CONF_LOGIC_THRESHOLD_CUSTOM | SR_CONF_GET | SR_CONF_SET,
95 static const char *coupling_options[] = {
96 "AC", // AC with 50 Ohm termination (152x, 202x, 30xx, 1202)
97 "ACL", // AC with 1 MOhm termination
98 "DC", // DC with 50 Ohm termination
99 "DCL", // DC with 1 MOhm termination
103 static const char *scope_trigger_slopes[] = {
109 /* Predefined logic thresholds. */
110 static const char *logic_threshold[] = {
115 "USER2", // overwritten by logic_threshold_custom, use USER1 for permanent setting
118 /* RTC1002, HMO Compact2 and HMO1002/HMO1202 */
119 static const char *an2_dig8_trigger_sources[] = {
121 "LINE", "EXT", "PATT", "BUS1", "BUS2",
122 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
126 static const char *an2_dig16_trigger_sources[] = {
128 "LINE", "EXT", "PATT", "BUS1", "BUS2",
129 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
130 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
134 static const char *an4_dig8_trigger_sources[] = {
135 "CH1", "CH2", "CH3", "CH4",
136 "LINE", "EXT", "PATT", "BUS1", "BUS2",
137 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
140 /* HMO3xx4 and HMO2524 */
141 static const char *an4_dig16_trigger_sources[] = {
142 "CH1", "CH2", "CH3", "CH4",
143 "LINE", "EXT", "PATT", "BUS1", "BUS2",
144 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
145 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
148 static const uint64_t timebases[][2] = {
187 static const uint64_t vdivs[][2] = {
207 static const char *scope_analog_channel_names[] = {
208 "CH1", "CH2", "CH3", "CH4",
211 static const char *scope_digital_channel_names[] = {
212 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
213 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
216 static const struct scope_config scope_models[] = {
218 /* RTC1002 and HMO722/1002/1022/1202/1522/2022 support only 8 digital channels. */
219 .name = {"RTC1002", "HMO722", "HMO1002", "HMO1022", "HMO1202", "HMO1522", "HMO2022", NULL},
220 .analog_channels = 2,
221 .digital_channels = 8,
224 .analog_names = &scope_analog_channel_names,
225 .digital_names = &scope_digital_channel_names,
228 .num_devopts = ARRAY_SIZE(devopts),
230 .devopts_cg_analog = &devopts_cg_analog,
231 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
233 .devopts_cg_digital = &devopts_cg_digital,
234 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
236 .coupling_options = &coupling_options,
237 .num_coupling_options = ARRAY_SIZE(coupling_options),
239 .logic_threshold = &logic_threshold,
240 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
242 .trigger_sources = &an2_dig8_trigger_sources,
243 .num_trigger_sources = ARRAY_SIZE(an2_dig8_trigger_sources),
245 .trigger_slopes = &scope_trigger_slopes,
246 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
248 .timebases = &timebases,
249 .num_timebases = ARRAY_SIZE(timebases),
252 .num_vdivs = ARRAY_SIZE(vdivs),
257 .scpi_dialect = &hameg_scpi_dialect,
260 /* HMO3032/3042/3052/3522 support 16 digital channels. */
261 .name = {"HMO3032", "HMO3042", "HMO3052", "HMO3522", NULL},
262 .analog_channels = 2,
263 .digital_channels = 16,
266 .analog_names = &scope_analog_channel_names,
267 .digital_names = &scope_digital_channel_names,
270 .num_devopts = ARRAY_SIZE(devopts),
272 .devopts_cg_analog = &devopts_cg_analog,
273 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
275 .devopts_cg_digital = &devopts_cg_digital,
276 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
278 .coupling_options = &coupling_options,
279 .num_coupling_options = ARRAY_SIZE(coupling_options),
281 .logic_threshold = &logic_threshold,
282 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
284 .trigger_sources = &an2_dig16_trigger_sources,
285 .num_trigger_sources = ARRAY_SIZE(an2_dig16_trigger_sources),
287 .trigger_slopes = &scope_trigger_slopes,
288 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
290 .timebases = &timebases,
291 .num_timebases = ARRAY_SIZE(timebases),
294 .num_vdivs = ARRAY_SIZE(vdivs),
299 .scpi_dialect = &hameg_scpi_dialect,
302 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
303 .analog_channels = 4,
304 .digital_channels = 8,
307 .analog_names = &scope_analog_channel_names,
308 .digital_names = &scope_digital_channel_names,
311 .num_devopts = ARRAY_SIZE(devopts),
313 .devopts_cg_analog = &devopts_cg_analog,
314 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
316 .devopts_cg_digital = &devopts_cg_digital,
317 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
319 .coupling_options = &coupling_options,
320 .num_coupling_options = ARRAY_SIZE(coupling_options),
322 .logic_threshold = &logic_threshold,
323 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
325 .trigger_sources = &an4_dig8_trigger_sources,
326 .num_trigger_sources = ARRAY_SIZE(an4_dig8_trigger_sources),
328 .trigger_slopes = &scope_trigger_slopes,
329 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
331 .timebases = &timebases,
332 .num_timebases = ARRAY_SIZE(timebases),
335 .num_vdivs = ARRAY_SIZE(vdivs),
340 .scpi_dialect = &hameg_scpi_dialect,
343 .name = {"HMO2524", "HMO3034", "HMO3044", "HMO3054", "HMO3524", NULL},
344 .analog_channels = 4,
345 .digital_channels = 16,
348 .analog_names = &scope_analog_channel_names,
349 .digital_names = &scope_digital_channel_names,
352 .num_devopts = ARRAY_SIZE(devopts),
354 .devopts_cg_analog = &devopts_cg_analog,
355 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
357 .devopts_cg_digital = &devopts_cg_digital,
358 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
360 .coupling_options = &coupling_options,
361 .num_coupling_options = ARRAY_SIZE(coupling_options),
363 .logic_threshold = &logic_threshold,
364 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
366 .trigger_sources = &an4_dig16_trigger_sources,
367 .num_trigger_sources = ARRAY_SIZE(an4_dig16_trigger_sources),
369 .trigger_slopes = &scope_trigger_slopes,
370 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
372 .timebases = &timebases,
373 .num_timebases = ARRAY_SIZE(timebases),
376 .num_vdivs = ARRAY_SIZE(vdivs),
381 .scpi_dialect = &hameg_scpi_dialect,
385 static void scope_state_dump(const struct scope_config *config,
386 struct scope_state *state)
391 for (i = 0; i < config->analog_channels; i++) {
392 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
393 (*config->vdivs)[state->analog_channels[i].vdiv][1]);
394 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
395 i + 1, state->analog_channels[i].state ? "On" : "Off",
396 (*config->coupling_options)[state->analog_channels[i].coupling],
397 tmp, state->analog_channels[i].vertical_offset);
400 for (i = 0; i < config->digital_channels; i++) {
401 sr_info("State of digital channel %d -> %s", i,
402 state->digital_channels[i] ? "On" : "Off");
405 for (i = 0; i < config->digital_pods; i++) {
406 if (strncmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold], 4))
407 sr_info("State of digital POD %d -> %s : %s (threshold)", i,
408 state->digital_pods[i].state ? "On" : "Off",
409 (*config->logic_threshold)[state->digital_pods[i].threshold]);
410 else // user-defined or custom logic threshold
411 sr_info("State of digital POD %d -> %s : %E (threshold)", i,
412 state->digital_pods[i].state ? "On" : "Off",
413 state->digital_pods[i].user_threshold);
416 tmp = sr_period_string((*config->timebases)[state->timebase][0],
417 (*config->timebases)[state->timebase][1]);
418 sr_info("Current timebase: %s", tmp);
421 tmp = sr_samplerate_string(state->sample_rate);
422 sr_info("Current samplerate: %s", tmp);
425 if (!strcmp("PATT", (*config->trigger_sources)[state->trigger_source]))
426 sr_info("Current trigger: %s (pattern), %.2f (offset)",
427 state->trigger_pattern,
428 state->horiz_triggerpos);
429 else // Edge (slope) trigger
430 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
431 (*config->trigger_sources)[state->trigger_source],
432 (*config->trigger_slopes)[state->trigger_slope],
433 state->horiz_triggerpos);
436 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
437 const char *command, const char *(*array)[], unsigned int n, int *result)
442 if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK) {
447 if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
460 * This function takes a value of the form "2.000E-03" and returns the index
461 * of an array where a matching pair was found.
463 * @param value The string to be parsed.
464 * @param array The array of s/f pairs.
465 * @param array_len The number of pairs in the array.
466 * @param result The index at which a matching pair was found.
468 * @return SR_ERR on any parsing error, SR_OK otherwise.
470 static int array_float_get(gchar *value, const uint64_t array[][2],
471 int array_len, unsigned int *result)
473 struct sr_rational rval;
474 struct sr_rational aval;
476 if (sr_parse_rational(value, &rval) != SR_OK)
479 for (int i = 0; i < array_len; i++) {
480 sr_rational_set(&aval, array[i][0], array[i][1]);
481 if (sr_rational_eq(&rval, &aval)) {
490 static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
493 while (channel_lhead) {
494 struct sr_channel *ch = channel_lhead->data;
495 if (ch->index == index && ch->type == type)
498 channel_lhead = channel_lhead->next;
504 static int analog_channel_state_get(struct sr_dev_inst *sdi,
505 const struct scope_config *config,
506 struct scope_state *state)
509 char command[MAX_COMMAND_SIZE];
511 struct sr_channel *ch;
512 struct sr_scpi_dev_inst *scpi = sdi->conn;
514 for (i = 0; i < config->analog_channels; i++) {
515 g_snprintf(command, sizeof(command),
516 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
519 if (sr_scpi_get_bool(scpi, command,
520 &state->analog_channels[i].state) != SR_OK)
523 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
525 ch->enabled = state->analog_channels[i].state;
527 g_snprintf(command, sizeof(command),
528 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
531 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
534 if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
536 sr_err("Could not determine array index for vertical div scale.");
541 state->analog_channels[i].vdiv = j;
543 g_snprintf(command, sizeof(command),
544 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
547 if (sr_scpi_get_float(scpi, command,
548 &state->analog_channels[i].vertical_offset) != SR_OK)
551 g_snprintf(command, sizeof(command),
552 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
555 if (scope_state_get_array_option(scpi, command, config->coupling_options,
556 config->num_coupling_options,
557 &state->analog_channels[i].coupling) != SR_OK)
560 g_snprintf(command, sizeof(command),
561 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
564 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
567 if (tmp_str[0] == 'A')
568 state->analog_channels[i].probe_unit = 'A';
570 state->analog_channels[i].probe_unit = 'V';
577 static int digital_channel_state_get(struct sr_dev_inst *sdi,
578 const struct scope_config *config,
579 struct scope_state *state)
583 static char *logic_threshold_short[] = {};
584 char command[MAX_COMMAND_SIZE];
585 struct sr_channel *ch;
586 struct sr_scpi_dev_inst *scpi = sdi->conn;
588 for (i = 0; i < config->digital_channels; i++) {
589 g_snprintf(command, sizeof(command),
590 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
593 if (sr_scpi_get_bool(scpi, command,
594 &state->digital_channels[i]) != SR_OK)
597 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
599 ch->enabled = state->digital_channels[i];
602 /* According to the SCPI standard, the response to the command
603 * SCPI_CMD_GET_DIG_POD_THRESHOLD might return "USER" instead of
606 * This makes more difficult to validate the response when the logic
607 * threshold is set to "USER1" and therefore we need to prevent device
608 * opening failures in such configuration case...
610 for (i = 0; i < config->num_logic_threshold; i++) {
611 logic_threshold_short[i] = g_strdup((*config->logic_threshold)[i]);
612 if (!strcmp("USER1", (*config->logic_threshold)[i]))
613 g_strlcpy(logic_threshold_short[i],
614 (*config->logic_threshold)[i], strlen((*config->logic_threshold)[i]));
617 for (i = 0; i < config->digital_pods; i++) {
618 g_snprintf(command, sizeof(command),
619 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
622 if (sr_scpi_get_bool(scpi, command,
623 &state->digital_pods[i].state) != SR_OK)
626 g_snprintf(command, sizeof(command),
627 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_THRESHOLD],
630 /* Check for both standard and shortened responses. */
631 if (scope_state_get_array_option(scpi, command, config->logic_threshold,
632 config->num_logic_threshold,
633 &state->digital_pods[i].threshold) != SR_OK)
634 if (scope_state_get_array_option(scpi, command, (const char * (*)[]) &logic_threshold_short,
635 config->num_logic_threshold,
636 &state->digital_pods[i].threshold) != SR_OK)
639 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]))
640 g_snprintf(command, sizeof(command),
641 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
642 i + 1, 1); // USER1 logic threshold setting
644 if (!strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
645 g_snprintf(command, sizeof(command),
646 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
647 i + 1, 2); // USER2 for custom logic_threshold setting
649 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
650 !strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
651 if (sr_scpi_get_float(scpi, command,
652 &state->digital_pods[i].user_threshold) != SR_OK)
659 for (i = 0; i < config->num_logic_threshold; i++)
660 g_free(logic_threshold_short[i]);
665 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
667 struct dev_context *devc;
668 struct scope_state *state;
669 const struct scope_config *config;
673 gboolean channel_found;
674 char tmp_str[MAX_COMMAND_SIZE];
678 config = devc->model_config;
679 state = devc->model_state;
680 channel_found = FALSE;
682 for (i = 0; i < config->analog_channels; i++) {
683 if (!state->analog_channels[i].state)
685 g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
686 g_snprintf(tmp_str, sizeof(tmp_str),
687 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
689 channel_found = TRUE;
693 if (!channel_found) {
694 for (i = 0; i < config->digital_pods; i++) {
695 if (!state->digital_pods[i].state)
697 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
698 g_snprintf(tmp_str, sizeof(tmp_str),
699 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
701 channel_found = TRUE;
706 /* No channel is active, ask the instrument for the sample rate
707 * in single shot mode */
708 if (!channel_found) {
709 if (sr_scpi_get_float(sdi->conn,
710 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
711 &tmp_float) != SR_OK)
714 state->sample_rate = tmp_float;
716 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
718 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
719 (*config->timebases)[state->timebase][1]) *
726 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
728 struct dev_context *devc;
729 struct scope_state *state;
730 const struct scope_config *config;
736 config = devc->model_config;
737 state = devc->model_state;
739 sr_info("Fetching scope state");
741 if (analog_channel_state_get(sdi, config, state) != SR_OK)
744 if (digital_channel_state_get(sdi, config, state) != SR_OK)
747 if (sr_scpi_get_float(sdi->conn,
748 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
749 &tmp_float) != SR_OK)
752 if (sr_scpi_get_string(sdi->conn,
753 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
757 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
759 sr_err("Could not determine array index for time base.");
766 if (sr_scpi_get_float(sdi->conn,
767 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
768 &tmp_float) != SR_OK)
770 state->horiz_triggerpos = tmp_float /
771 (((double) (*config->timebases)[state->timebase][0] /
772 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
773 state->horiz_triggerpos -= 0.5;
774 state->horiz_triggerpos *= -1;
776 if (scope_state_get_array_option(sdi->conn,
777 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
778 config->trigger_sources, config->num_trigger_sources,
779 &state->trigger_source) != SR_OK)
782 if (scope_state_get_array_option(sdi->conn,
783 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
784 config->trigger_slopes, config->num_trigger_slopes,
785 &state->trigger_slope) != SR_OK)
788 if (sr_scpi_get_string(sdi->conn,
789 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_PATTERN],
790 &state->trigger_pattern) != SR_OK)
793 if (hmo_update_sample_rate(sdi) != SR_OK)
796 sr_info("Fetching finished.");
798 scope_state_dump(config, state);
803 static struct scope_state *scope_state_new(const struct scope_config *config)
805 struct scope_state *state;
807 state = g_malloc0(sizeof(struct scope_state));
808 state->analog_channels = g_malloc0_n(config->analog_channels,
809 sizeof(struct analog_channel_state));
810 state->digital_channels = g_malloc0_n(
811 config->digital_channels, sizeof(gboolean));
812 state->digital_pods = g_malloc0_n(config->digital_pods,
813 sizeof(struct digital_pod_state));
818 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
820 g_free(state->analog_channels);
821 g_free(state->digital_channels);
822 g_free(state->digital_pods);
826 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
829 unsigned int i, j, group;
830 struct sr_channel *ch;
831 struct dev_context *devc;
837 /* Find the exact model. */
838 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
839 for (j = 0; scope_models[i].name[j]; j++) {
840 if (!strcmp(sdi->model, scope_models[i].name[j])) {
845 if (model_index != -1)
849 if (model_index == -1) {
850 sr_dbg("Unsupported device.");
854 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
855 scope_models[model_index].analog_channels);
856 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
857 scope_models[model_index].digital_pods);
858 if (!devc->analog_groups || !devc->digital_groups) {
859 g_free(devc->analog_groups);
860 g_free(devc->digital_groups);
861 return SR_ERR_MALLOC;
864 /* Add analog channels. */
865 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
866 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
867 (*scope_models[model_index].analog_names)[i]);
869 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
871 devc->analog_groups[i]->name = g_strdup(
872 (char *)(*scope_models[model_index].analog_names)[i]);
873 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
875 sdi->channel_groups = g_slist_append(sdi->channel_groups,
876 devc->analog_groups[i]);
879 /* Add digital channel groups. */
881 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
882 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
883 if (!devc->digital_groups[i]) {
887 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i);
888 sdi->channel_groups = g_slist_append(sdi->channel_groups,
889 devc->digital_groups[i]);
894 /* Add digital channels. */
895 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
896 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
897 (*scope_models[model_index].digital_names)[i]);
900 devc->digital_groups[group]->channels = g_slist_append(
901 devc->digital_groups[group]->channels, ch);
904 devc->model_config = &scope_models[model_index];
905 devc->samples_limit = 0;
906 devc->frame_limit = 0;
908 if (!(devc->model_state = scope_state_new(devc->model_config)))
909 return SR_ERR_MALLOC;
914 /* Queue data of one channel group, for later submission. */
915 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
916 size_t group, GByteArray *pod_data)
921 size_t idx, logic_step;
924 * Upon first invocation, allocate the array which can hold the
925 * combined logic data for all channels. Assume that each channel
926 * will yield an identical number of samples per receive call.
928 * As a poor man's safety measure: (Silently) skip processing
929 * for unexpected sample counts, and ignore samples for
930 * unexpected channel groups. Don't bother with complicated
931 * resize logic, considering that many models only support one
932 * pod, and the most capable supported models have two pods of
933 * identical size. We haven't yet seen any "odd" configuration.
935 if (!devc->logic_data) {
936 size = pod_data->len * devc->pod_count;
937 store = g_byte_array_sized_new(size);
938 memset(store->data, 0, size);
939 store = g_byte_array_set_size(store, size);
940 devc->logic_data = store;
942 store = devc->logic_data;
943 size = store->len / devc->pod_count;
944 if (group >= devc->pod_count)
949 * Fold the data of the most recently received channel group into
950 * the storage, where data resides for all channels combined.
952 logic_data = store->data;
954 logic_step = devc->pod_count;
955 for (idx = 0; idx < pod_data->len; idx++) {
956 *logic_data = pod_data->data[idx];
957 logic_data += logic_step;
960 /* Truncate acquisition if a smaller number of samples has been requested. */
961 if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
962 devc->logic_data->len = devc->samples_limit * devc->pod_count;
965 /* Submit data for all channels, after the individual groups got collected. */
966 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
967 struct dev_context *devc)
969 struct sr_datafeed_packet packet;
970 struct sr_datafeed_logic logic;
972 if (!devc->logic_data)
975 logic.data = devc->logic_data->data;
976 logic.length = devc->logic_data->len;
977 logic.unitsize = devc->pod_count;
979 packet.type = SR_DF_LOGIC;
980 packet.payload = &logic;
982 sr_session_send(sdi, &packet);
985 /* Undo previous resource allocation. */
986 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
989 if (devc->logic_data) {
990 g_byte_array_free(devc->logic_data, TRUE);
991 devc->logic_data = NULL;
994 * Keep 'pod_count'! It's required when more frames will be
995 * received, and does not harm when kept after acquisition.
999 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
1001 struct sr_channel *ch;
1002 struct sr_dev_inst *sdi;
1003 struct dev_context *devc;
1004 struct scope_state *state;
1005 struct sr_datafeed_packet packet;
1007 struct sr_datafeed_analog analog;
1008 struct sr_analog_encoding encoding;
1009 struct sr_analog_meaning meaning;
1010 struct sr_analog_spec spec;
1011 struct sr_datafeed_logic logic;
1019 if (!(sdi = cb_data))
1022 if (!(devc = sdi->priv))
1025 /* Although this is correct in general, the USBTMC libusb implementation
1026 * currently does not generate an event prior to the first read. Often
1027 * it is ok to start reading just after the 50ms timeout. See bug #785.
1028 if (revents != G_IO_IN)
1032 ch = devc->current_channel->data;
1033 state = devc->model_state;
1036 * Send "frame begin" packet upon reception of data for the
1037 * first enabled channel.
1039 if (devc->current_channel == devc->enabled_channels) {
1040 packet.type = SR_DF_FRAME_BEGIN;
1041 sr_session_send(sdi, &packet);
1045 * Pass on the received data of the channel(s).
1048 case SR_CHANNEL_ANALOG:
1049 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1051 g_byte_array_free(data, TRUE);
1055 packet.type = SR_DF_ANALOG;
1057 analog.data = data->data;
1058 analog.num_samples = data->len / sizeof(float);
1059 /* Truncate acquisition if a smaller number of samples has been requested. */
1060 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1061 analog.num_samples = devc->samples_limit;
1062 analog.encoding = &encoding;
1063 analog.meaning = &meaning;
1064 analog.spec = &spec;
1066 encoding.unitsize = sizeof(float);
1067 encoding.is_signed = TRUE;
1068 encoding.is_float = TRUE;
1069 #ifdef WORDS_BIGENDIAN
1070 encoding.is_bigendian = TRUE;
1072 encoding.is_bigendian = FALSE;
1074 /* TODO: Use proper 'digits' value for this device (and its modes). */
1075 encoding.digits = 2;
1076 encoding.is_digits_decimal = FALSE;
1077 encoding.scale.p = 1;
1078 encoding.scale.q = 1;
1079 encoding.offset.p = 0;
1080 encoding.offset.q = 1;
1081 if (state->analog_channels[ch->index].probe_unit == 'V') {
1082 meaning.mq = SR_MQ_VOLTAGE;
1083 meaning.unit = SR_UNIT_VOLT;
1085 meaning.mq = SR_MQ_CURRENT;
1086 meaning.unit = SR_UNIT_AMPERE;
1088 meaning.mqflags = 0;
1089 meaning.channels = g_slist_append(NULL, ch);
1090 /* TODO: Use proper 'digits' value for this device (and its modes). */
1091 spec.spec_digits = 2;
1092 packet.payload = &analog;
1093 sr_session_send(sdi, &packet);
1094 devc->num_samples = data->len / sizeof(float);
1095 g_slist_free(meaning.channels);
1096 g_byte_array_free(data, TRUE);
1099 case SR_CHANNEL_LOGIC:
1100 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1102 g_byte_array_free(data, TRUE);
1107 * If only data from the first pod is involved in the
1108 * acquisition, then the raw input bytes can get passed
1109 * forward for performance reasons. When the second pod
1110 * is involved (either alone, or in combination with the
1111 * first pod), then the received bytes need to be put
1112 * into memory in such a layout that all channel groups
1113 * get combined, and a unitsize larger than a single byte
1114 * applies. The "queue" logic transparently copes with
1115 * any such configuration. This works around the lack
1116 * of support for "meaning" to logic data, which is used
1117 * above for analog data.
1119 if (devc->pod_count == 1) {
1120 packet.type = SR_DF_LOGIC;
1121 logic.data = data->data;
1122 logic.length = data->len;
1123 /* Truncate acquisition if a smaller number of samples has been requested. */
1124 if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1125 logic.length = devc->samples_limit;
1127 packet.payload = &logic;
1128 sr_session_send(sdi, &packet);
1130 group = ch->index / 8;
1131 hmo_queue_logic_data(devc, group, data);
1134 devc->num_samples = data->len / devc->pod_count;
1135 g_byte_array_free(data, TRUE);
1139 sr_err("Invalid channel type.");
1144 * Advance to the next enabled channel. When data for all enabled
1145 * channels was received, then flush potentially queued logic data,
1146 * and send the "frame end" packet.
1148 if (devc->current_channel->next) {
1149 devc->current_channel = devc->current_channel->next;
1150 hmo_request_data(sdi);
1153 hmo_send_logic_packet(sdi, devc);
1156 * Release the logic data storage after each frame. This copes
1157 * with sample counts that differ in length per frame. -- Is
1158 * this a real constraint when acquiring multiple frames with
1159 * identical device settings?
1161 hmo_cleanup_logic_data(devc);
1163 packet.type = SR_DF_FRAME_END;
1164 sr_session_send(sdi, &packet);
1167 * End of frame was reached. Stop acquisition after the specified
1168 * number of frames or after the specified number of samples, or
1169 * continue reception by starting over at the first enabled channel.
1171 if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1172 sr_dev_acquisition_stop(sdi);
1173 hmo_cleanup_logic_data(devc);
1175 devc->current_channel = devc->enabled_channels;
1176 hmo_request_data(sdi);