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_SET,
74 SR_CONF_LIMIT_FRAMES | 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 + 1,
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 + 1,
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)
445 if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
458 * This function takes a value of the form "2.000E-03" and returns the index
459 * of an array where a matching pair was found.
461 * @param value The string to be parsed.
462 * @param array The array of s/f pairs.
463 * @param array_len The number of pairs in the array.
464 * @param result The index at which a matching pair was found.
466 * @return SR_ERR on any parsing error, SR_OK otherwise.
468 static int array_float_get(gchar *value, const uint64_t array[][2],
469 int array_len, unsigned int *result)
471 struct sr_rational rval;
472 struct sr_rational aval;
474 if (sr_parse_rational(value, &rval) != SR_OK)
477 for (int i = 0; i < array_len; i++) {
478 sr_rational_set(&aval, array[i][0], array[i][1]);
479 if (sr_rational_eq(&rval, &aval)) {
488 static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
491 while (channel_lhead) {
492 struct sr_channel *ch = channel_lhead->data;
493 if (ch->index == index && ch->type == type)
496 channel_lhead = channel_lhead->next;
502 static int analog_channel_state_get(struct sr_dev_inst *sdi,
503 const struct scope_config *config,
504 struct scope_state *state)
507 char command[MAX_COMMAND_SIZE];
509 struct sr_channel *ch;
510 struct sr_scpi_dev_inst *scpi = sdi->conn;
512 for (i = 0; i < config->analog_channels; i++) {
513 g_snprintf(command, sizeof(command),
514 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
517 if (sr_scpi_get_bool(scpi, command,
518 &state->analog_channels[i].state) != SR_OK)
521 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
523 ch->enabled = state->analog_channels[i].state;
525 g_snprintf(command, sizeof(command),
526 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
529 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
532 if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
534 sr_err("Could not determine array index for vertical div scale.");
539 state->analog_channels[i].vdiv = j;
541 g_snprintf(command, sizeof(command),
542 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
545 if (sr_scpi_get_float(scpi, command,
546 &state->analog_channels[i].vertical_offset) != SR_OK)
549 g_snprintf(command, sizeof(command),
550 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
553 if (scope_state_get_array_option(scpi, command, config->coupling_options,
554 config->num_coupling_options,
555 &state->analog_channels[i].coupling) != SR_OK)
558 g_snprintf(command, sizeof(command),
559 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
562 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
565 if (tmp_str[0] == 'A')
566 state->analog_channels[i].probe_unit = 'A';
568 state->analog_channels[i].probe_unit = 'V';
575 static int digital_channel_state_get(struct sr_dev_inst *sdi,
576 const struct scope_config *config,
577 struct scope_state *state)
581 static char *logic_threshold_short[] = {};
582 char command[MAX_COMMAND_SIZE];
583 struct sr_channel *ch;
584 struct sr_scpi_dev_inst *scpi = sdi->conn;
586 for (i = 0; i < config->digital_channels; i++) {
587 g_snprintf(command, sizeof(command),
588 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
591 if (sr_scpi_get_bool(scpi, command,
592 &state->digital_channels[i]) != SR_OK)
595 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
597 ch->enabled = state->digital_channels[i];
600 /* According to the SCPI standard, the response to the command
601 * SCPI_CMD_GET_DIG_POD_THRESHOLD might return "USER" instead of
604 * This makes more difficult to validate the response when the logic
605 * threshold is set to "USER1" and therefore we need to prevent device
606 * opening failures in such configuration case...
608 for (i = 0; i < config->num_logic_threshold; i++) {
609 logic_threshold_short[i] = g_strdup((*config->logic_threshold)[i]);
610 if (!strcmp("USER1", (*config->logic_threshold)[i]))
611 g_strlcpy(logic_threshold_short[i],
612 (*config->logic_threshold)[i], strlen((*config->logic_threshold)[i]));
615 for (i = 0; i < config->digital_pods; i++) {
616 g_snprintf(command, sizeof(command),
617 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
620 if (sr_scpi_get_bool(scpi, command,
621 &state->digital_pods[i].state) != SR_OK)
624 g_snprintf(command, sizeof(command),
625 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_THRESHOLD],
628 /* Check for both standard and shortened responses. */
629 if (scope_state_get_array_option(scpi, command, config->logic_threshold,
630 config->num_logic_threshold,
631 &state->digital_pods[i].threshold) != SR_OK)
632 if (scope_state_get_array_option(scpi, command, (const char * (*)[]) &logic_threshold_short,
633 config->num_logic_threshold,
634 &state->digital_pods[i].threshold) != SR_OK)
637 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]))
638 g_snprintf(command, sizeof(command),
639 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
640 i + 1, 1); // USER1 logic threshold setting
642 if (!strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
643 g_snprintf(command, sizeof(command),
644 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
645 i + 1, 2); // USER2 for custom logic_threshold setting
647 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
648 !strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
649 if (sr_scpi_get_float(scpi, command,
650 &state->digital_pods[i].user_threshold) != SR_OK)
657 for (i = 0; i < config->num_logic_threshold; i++)
658 g_free(logic_threshold_short[i]);
663 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
665 struct dev_context *devc;
666 struct scope_state *state;
667 const struct scope_config *config;
671 gboolean channel_found;
672 char tmp_str[MAX_COMMAND_SIZE];
676 config = devc->model_config;
677 state = devc->model_state;
678 channel_found = FALSE;
680 for (i = 0; i < config->analog_channels; i++) {
681 if (!state->analog_channels[i].state)
683 g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
684 g_snprintf(tmp_str, sizeof(tmp_str),
685 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
687 channel_found = TRUE;
691 if (!channel_found) {
692 for (i = 0; i < config->digital_pods; i++) {
693 if (!state->digital_pods[i].state)
695 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
696 g_snprintf(tmp_str, sizeof(tmp_str),
697 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
699 channel_found = TRUE;
704 /* No channel is active, ask the instrument for the sample rate
705 * in single shot mode */
706 if (!channel_found) {
707 if (sr_scpi_get_float(sdi->conn,
708 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
709 &tmp_float) != SR_OK)
712 state->sample_rate = tmp_float;
714 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
716 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
717 (*config->timebases)[state->timebase][1]) *
724 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
726 struct dev_context *devc;
727 struct scope_state *state;
728 const struct scope_config *config;
734 config = devc->model_config;
735 state = devc->model_state;
737 sr_info("Fetching scope state");
739 if (analog_channel_state_get(sdi, config, state) != SR_OK)
742 if (digital_channel_state_get(sdi, config, state) != SR_OK)
745 if (sr_scpi_get_float(sdi->conn,
746 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
747 &tmp_float) != SR_OK)
750 if (sr_scpi_get_string(sdi->conn,
751 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
755 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
757 sr_err("Could not determine array index for time base.");
764 if (sr_scpi_get_float(sdi->conn,
765 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
766 &tmp_float) != SR_OK)
768 state->horiz_triggerpos = tmp_float /
769 (((double) (*config->timebases)[state->timebase][0] /
770 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
771 state->horiz_triggerpos -= 0.5;
772 state->horiz_triggerpos *= -1;
774 if (scope_state_get_array_option(sdi->conn,
775 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
776 config->trigger_sources, config->num_trigger_sources,
777 &state->trigger_source) != SR_OK)
780 if (scope_state_get_array_option(sdi->conn,
781 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
782 config->trigger_slopes, config->num_trigger_slopes,
783 &state->trigger_slope) != SR_OK)
786 if (sr_scpi_get_string(sdi->conn,
787 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_PATTERN],
788 &state->trigger_pattern) != SR_OK)
791 if (hmo_update_sample_rate(sdi) != SR_OK)
794 sr_info("Fetching finished.");
796 scope_state_dump(config, state);
801 static struct scope_state *scope_state_new(const struct scope_config *config)
803 struct scope_state *state;
805 state = g_malloc0(sizeof(struct scope_state));
806 state->analog_channels = g_malloc0_n(config->analog_channels,
807 sizeof(struct analog_channel_state));
808 state->digital_channels = g_malloc0_n(
809 config->digital_channels, sizeof(gboolean));
810 state->digital_pods = g_malloc0_n(config->digital_pods,
811 sizeof(struct digital_pod_state));
816 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
818 g_free(state->analog_channels);
819 g_free(state->digital_channels);
820 g_free(state->digital_pods);
824 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
827 unsigned int i, j, group;
828 struct sr_channel *ch;
829 struct dev_context *devc;
835 /* Find the exact model. */
836 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
837 for (j = 0; scope_models[i].name[j]; j++) {
838 if (!strcmp(sdi->model, scope_models[i].name[j])) {
843 if (model_index != -1)
847 if (model_index == -1) {
848 sr_dbg("Unsupported device.");
852 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
853 scope_models[model_index].analog_channels);
854 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
855 scope_models[model_index].digital_pods);
856 if (!devc->analog_groups || !devc->digital_groups) {
857 g_free(devc->analog_groups);
858 g_free(devc->digital_groups);
859 return SR_ERR_MALLOC;
862 /* Add analog channels. */
863 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
864 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
865 (*scope_models[model_index].analog_names)[i]);
867 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
869 devc->analog_groups[i]->name = g_strdup(
870 (char *)(*scope_models[model_index].analog_names)[i]);
871 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
873 sdi->channel_groups = g_slist_append(sdi->channel_groups,
874 devc->analog_groups[i]);
877 /* Add digital channel groups. */
879 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
880 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
881 if (!devc->digital_groups[i]) {
885 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i + 1);
886 sdi->channel_groups = g_slist_append(sdi->channel_groups,
887 devc->digital_groups[i]);
892 /* Add digital channels. */
893 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
894 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
895 (*scope_models[model_index].digital_names)[i]);
898 devc->digital_groups[group]->channels = g_slist_append(
899 devc->digital_groups[group]->channels, ch);
902 devc->model_config = &scope_models[model_index];
903 devc->samples_limit = 0;
904 devc->frame_limit = 0;
906 if (!(devc->model_state = scope_state_new(devc->model_config)))
907 return SR_ERR_MALLOC;
912 /* Queue data of one channel group, for later submission. */
913 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
914 size_t group, GByteArray *pod_data)
919 size_t idx, logic_step;
922 * Upon first invocation, allocate the array which can hold the
923 * combined logic data for all channels. Assume that each channel
924 * will yield an identical number of samples per receive call.
926 * As a poor man's safety measure: (Silently) skip processing
927 * for unexpected sample counts, and ignore samples for
928 * unexpected channel groups. Don't bother with complicated
929 * resize logic, considering that many models only support one
930 * pod, and the most capable supported models have two pods of
931 * identical size. We haven't yet seen any "odd" configuration.
933 if (!devc->logic_data) {
934 size = pod_data->len * devc->pod_count;
935 store = g_byte_array_sized_new(size);
936 memset(store->data, 0, size);
937 store = g_byte_array_set_size(store, size);
938 devc->logic_data = store;
940 store = devc->logic_data;
941 size = store->len / devc->pod_count;
942 if (group >= devc->pod_count)
947 * Fold the data of the most recently received channel group into
948 * the storage, where data resides for all channels combined.
950 logic_data = store->data;
952 logic_step = devc->pod_count;
953 for (idx = 0; idx < pod_data->len; idx++) {
954 *logic_data = pod_data->data[idx];
955 logic_data += logic_step;
958 /* Truncate acquisition if a smaller number of samples has been requested. */
959 if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
960 devc->logic_data->len = devc->samples_limit * devc->pod_count;
963 /* Submit data for all channels, after the individual groups got collected. */
964 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
965 struct dev_context *devc)
967 struct sr_datafeed_packet packet;
968 struct sr_datafeed_logic logic;
970 if (!devc->logic_data)
973 logic.data = devc->logic_data->data;
974 logic.length = devc->logic_data->len;
975 logic.unitsize = devc->pod_count;
977 packet.type = SR_DF_LOGIC;
978 packet.payload = &logic;
980 sr_session_send(sdi, &packet);
983 /* Undo previous resource allocation. */
984 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
987 if (devc->logic_data) {
988 g_byte_array_free(devc->logic_data, TRUE);
989 devc->logic_data = NULL;
992 * Keep 'pod_count'! It's required when more frames will be
993 * received, and does not harm when kept after acquisition.
997 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
999 struct sr_channel *ch;
1000 struct sr_dev_inst *sdi;
1001 struct dev_context *devc;
1002 struct scope_state *state;
1003 struct sr_datafeed_packet packet;
1005 struct sr_datafeed_analog analog;
1006 struct sr_analog_encoding encoding;
1007 struct sr_analog_meaning meaning;
1008 struct sr_analog_spec spec;
1009 struct sr_datafeed_logic logic;
1017 if (!(sdi = cb_data))
1020 if (!(devc = sdi->priv))
1023 /* Although this is correct in general, the USBTMC libusb implementation
1024 * currently does not generate an event prior to the first read. Often
1025 * it is ok to start reading just after the 50ms timeout. See bug #785.
1026 if (revents != G_IO_IN)
1030 ch = devc->current_channel->data;
1031 state = devc->model_state;
1034 * Send "frame begin" packet upon reception of data for the
1035 * first enabled channel.
1037 if (devc->current_channel == devc->enabled_channels) {
1038 packet.type = SR_DF_FRAME_BEGIN;
1039 sr_session_send(sdi, &packet);
1043 * Pass on the received data of the channel(s).
1046 case SR_CHANNEL_ANALOG:
1047 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1049 g_byte_array_free(data, TRUE);
1053 packet.type = SR_DF_ANALOG;
1055 analog.data = data->data;
1056 analog.num_samples = data->len / sizeof(float);
1057 /* Truncate acquisition if a smaller number of samples has been requested. */
1058 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1059 analog.num_samples = devc->samples_limit;
1060 analog.encoding = &encoding;
1061 analog.meaning = &meaning;
1062 analog.spec = &spec;
1064 encoding.unitsize = sizeof(float);
1065 encoding.is_signed = TRUE;
1066 encoding.is_float = TRUE;
1067 #ifdef WORDS_BIGENDIAN
1068 encoding.is_bigendian = TRUE;
1070 encoding.is_bigendian = FALSE;
1072 /* TODO: Use proper 'digits' value for this device (and its modes). */
1073 encoding.digits = 2;
1074 encoding.is_digits_decimal = FALSE;
1075 encoding.scale.p = 1;
1076 encoding.scale.q = 1;
1077 encoding.offset.p = 0;
1078 encoding.offset.q = 1;
1079 if (state->analog_channels[ch->index].probe_unit == 'V') {
1080 meaning.mq = SR_MQ_VOLTAGE;
1081 meaning.unit = SR_UNIT_VOLT;
1083 meaning.mq = SR_MQ_CURRENT;
1084 meaning.unit = SR_UNIT_AMPERE;
1086 meaning.mqflags = 0;
1087 meaning.channels = g_slist_append(NULL, ch);
1088 /* TODO: Use proper 'digits' value for this device (and its modes). */
1089 spec.spec_digits = 2;
1090 packet.payload = &analog;
1091 sr_session_send(sdi, &packet);
1092 devc->num_samples = data->len / sizeof(float);
1093 g_slist_free(meaning.channels);
1094 g_byte_array_free(data, TRUE);
1097 case SR_CHANNEL_LOGIC:
1098 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1100 g_byte_array_free(data, TRUE);
1105 * If only data from the first pod is involved in the
1106 * acquisition, then the raw input bytes can get passed
1107 * forward for performance reasons. When the second pod
1108 * is involved (either alone, or in combination with the
1109 * first pod), then the received bytes need to be put
1110 * into memory in such a layout that all channel groups
1111 * get combined, and a unitsize larger than a single byte
1112 * applies. The "queue" logic transparently copes with
1113 * any such configuration. This works around the lack
1114 * of support for "meaning" to logic data, which is used
1115 * above for analog data.
1117 if (devc->pod_count == 1) {
1118 packet.type = SR_DF_LOGIC;
1119 logic.data = data->data;
1120 logic.length = data->len;
1121 /* Truncate acquisition if a smaller number of samples has been requested. */
1122 if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1123 logic.length = devc->samples_limit;
1125 packet.payload = &logic;
1126 sr_session_send(sdi, &packet);
1128 group = ch->index / 8;
1129 hmo_queue_logic_data(devc, group, data);
1132 devc->num_samples = data->len / devc->pod_count;
1133 g_byte_array_free(data, TRUE);
1137 sr_err("Invalid channel type.");
1142 * Advance to the next enabled channel. When data for all enabled
1143 * channels was received, then flush potentially queued logic data,
1144 * and send the "frame end" packet.
1146 if (devc->current_channel->next) {
1147 devc->current_channel = devc->current_channel->next;
1148 hmo_request_data(sdi);
1151 hmo_send_logic_packet(sdi, devc);
1154 * Release the logic data storage after each frame. This copes
1155 * with sample counts that differ in length per frame. -- Is
1156 * this a real constraint when acquiring multiple frames with
1157 * identical device settings?
1159 hmo_cleanup_logic_data(devc);
1161 packet.type = SR_DF_FRAME_END;
1162 sr_session_send(sdi, &packet);
1165 * End of frame was reached. Stop acquisition after the specified
1166 * number of frames or after the specified number of samples, or
1167 * continue reception by starting over at the first enabled channel.
1169 if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1170 sr_dev_acquisition_stop(sdi);
1171 hmo_cleanup_logic_data(devc);
1173 devc->current_channel = devc->enabled_channels;
1174 hmo_request_data(sdi);