2 * This file is part of the libsigrok project.
4 * Copyright (C) 2013 poljar (Damir Jelić) <poljarinho@gmail.com>
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
26 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
27 size_t group, GByteArray *pod_data);
28 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
29 struct dev_context *devc);
30 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc);
32 static const char *hameg_scpi_dialect[] = {
33 [SCPI_CMD_GET_DIG_DATA] = ":FORM UINT,8;:POD%d:DATA?",
34 [SCPI_CMD_GET_TIMEBASE] = ":TIM:SCAL?",
35 [SCPI_CMD_SET_TIMEBASE] = ":TIM:SCAL %s",
36 [SCPI_CMD_GET_COUPLING] = ":CHAN%d:COUP?",
37 [SCPI_CMD_SET_COUPLING] = ":CHAN%d:COUP %s",
38 [SCPI_CMD_GET_SAMPLE_RATE] = ":ACQ:SRAT?",
39 [SCPI_CMD_GET_SAMPLE_RATE_LIVE] = ":%s:DATA:POINTS?",
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:EDGE:SLOP %s",
48 [SCPI_CMD_GET_TRIGGER_SOURCE] = ":TRIG:A:SOUR?",
49 [SCPI_CMD_SET_TRIGGER_SOURCE] = ":TRIG:A:SOUR %s",
50 [SCPI_CMD_GET_DIG_CHAN_STATE] = ":LOG%d:STAT?",
51 [SCPI_CMD_SET_DIG_CHAN_STATE] = ":LOG%d:STAT %d",
52 [SCPI_CMD_GET_VERTICAL_OFFSET] = ":CHAN%d:POS?",
53 [SCPI_CMD_GET_HORIZ_TRIGGERPOS] = ":TIM:POS?",
54 [SCPI_CMD_SET_HORIZ_TRIGGERPOS] = ":TIM:POS %s",
55 [SCPI_CMD_GET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT?",
56 [SCPI_CMD_SET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT %d",
57 [SCPI_CMD_GET_PROBE_UNIT] = ":PROB%d:SET:ATT:UNIT?",
60 static const uint32_t devopts[] = {
62 SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET,
63 SR_CONF_SAMPLERATE | SR_CONF_GET,
64 SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
65 SR_CONF_NUM_HDIV | SR_CONF_GET,
66 SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
67 SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
68 SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
71 static const uint32_t devopts_cg_analog[] = {
72 SR_CONF_NUM_VDIV | SR_CONF_GET,
73 SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
74 SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
77 static const char *coupling_options[] = {
78 "AC", // AC with 50 Ohm termination (152x, 202x, 30xx, 1202)
79 "ACL", // AC with 1 MOhm termination
80 "DC", // DC with 50 Ohm termination
81 "DCL", // DC with 1 MOhm termination
85 static const char *scope_trigger_slopes[] = {
91 static const char *compact2_trigger_sources[] = {
93 "LINE", "EXT", "PATT", "BUS1", "BUS2",
94 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
97 static const char *compact4_trigger_sources[] = {
98 "CH1", "CH2", "CH3", "CH4",
99 "LINE", "EXT", "PATT", "BUS1", "BUS2",
100 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
103 static const char *compact4_dig16_trigger_sources[] = {
104 "CH1", "CH2", "CH3", "CH4",
105 "LINE", "EXT", "PATT", "BUS1", "BUS2",
106 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
107 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
110 static const uint64_t timebases[][2] = {
149 static const uint64_t vdivs[][2] = {
169 static const char *scope_analog_channel_names[] = {
170 "CH1", "CH2", "CH3", "CH4",
173 static const char *scope_digital_channel_names[] = {
174 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
175 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
178 static const struct scope_config scope_models[] = {
180 /* HMO2522/3032/3042/3052 support 16 digital channels but they're not supported yet. */
181 .name = {"HMO1002", "HMO722", "HMO1022", "HMO1522", "HMO2022", "HMO2522",
182 "HMO3032", "HMO3042", "HMO3052", NULL},
183 .analog_channels = 2,
184 .digital_channels = 8,
187 .analog_names = &scope_analog_channel_names,
188 .digital_names = &scope_digital_channel_names,
191 .num_devopts = ARRAY_SIZE(devopts),
193 .devopts_cg_analog = &devopts_cg_analog,
194 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
196 .coupling_options = &coupling_options,
197 .num_coupling_options = ARRAY_SIZE(coupling_options),
199 .trigger_sources = &compact2_trigger_sources,
200 .num_trigger_sources = ARRAY_SIZE(compact2_trigger_sources),
202 .trigger_slopes = &scope_trigger_slopes,
203 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
205 .timebases = &timebases,
206 .num_timebases = ARRAY_SIZE(timebases),
209 .num_vdivs = ARRAY_SIZE(vdivs),
214 .scpi_dialect = &hameg_scpi_dialect,
217 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
218 .analog_channels = 4,
219 .digital_channels = 8,
222 .analog_names = &scope_analog_channel_names,
223 .digital_names = &scope_digital_channel_names,
226 .num_devopts = ARRAY_SIZE(devopts),
228 .devopts_cg_analog = &devopts_cg_analog,
229 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
231 .coupling_options = &coupling_options,
232 .num_coupling_options = ARRAY_SIZE(coupling_options),
234 .trigger_sources = &compact4_trigger_sources,
235 .num_trigger_sources = ARRAY_SIZE(compact4_trigger_sources),
237 .trigger_slopes = &scope_trigger_slopes,
238 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
240 .timebases = &timebases,
241 .num_timebases = ARRAY_SIZE(timebases),
244 .num_vdivs = ARRAY_SIZE(vdivs),
249 .scpi_dialect = &hameg_scpi_dialect,
252 .name = {"HMO2524", "HMO3034", "HMO3044", "HMO3054", "HMO3524", NULL},
253 .analog_channels = 4,
254 .digital_channels = 16,
257 .analog_names = &scope_analog_channel_names,
258 .digital_names = &scope_digital_channel_names,
261 .num_devopts = ARRAY_SIZE(devopts),
263 .devopts_cg_analog = &devopts_cg_analog,
264 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
266 .coupling_options = &coupling_options,
267 .num_coupling_options = ARRAY_SIZE(coupling_options),
269 .trigger_sources = &compact4_dig16_trigger_sources,
270 .num_trigger_sources = ARRAY_SIZE(compact4_dig16_trigger_sources),
272 .trigger_slopes = &scope_trigger_slopes,
273 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
275 .timebases = &timebases,
276 .num_timebases = ARRAY_SIZE(timebases),
279 .num_vdivs = ARRAY_SIZE(vdivs),
284 .scpi_dialect = &hameg_scpi_dialect,
288 static void scope_state_dump(const struct scope_config *config,
289 struct scope_state *state)
294 for (i = 0; i < config->analog_channels; i++) {
295 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
296 (*config->vdivs)[state->analog_channels[i].vdiv][1]);
297 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
298 i + 1, state->analog_channels[i].state ? "On" : "Off",
299 (*config->coupling_options)[state->analog_channels[i].coupling],
300 tmp, state->analog_channels[i].vertical_offset);
303 for (i = 0; i < config->digital_channels; i++) {
304 sr_info("State of digital channel %d -> %s", i,
305 state->digital_channels[i] ? "On" : "Off");
308 for (i = 0; i < config->digital_pods; i++) {
309 sr_info("State of digital POD %d -> %s", i,
310 state->digital_pods[i] ? "On" : "Off");
313 tmp = sr_period_string((*config->timebases)[state->timebase][0],
314 (*config->timebases)[state->timebase][1]);
315 sr_info("Current timebase: %s", tmp);
318 tmp = sr_samplerate_string(state->sample_rate);
319 sr_info("Current samplerate: %s", tmp);
322 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
323 (*config->trigger_sources)[state->trigger_source],
324 (*config->trigger_slopes)[state->trigger_slope],
325 state->horiz_triggerpos);
328 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
329 const char *command, const char *(*array)[], unsigned int n, int *result)
334 if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK) {
339 if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
352 * This function takes a value of the form "2.000E-03" and returns the index
353 * of an array where a matching pair was found.
355 * @param value The string to be parsed.
356 * @param array The array of s/f pairs.
357 * @param array_len The number of pairs in the array.
358 * @param result The index at which a matching pair was found.
360 * @return SR_ERR on any parsing error, SR_OK otherwise.
362 static int array_float_get(gchar *value, const uint64_t array[][2],
363 int array_len, unsigned int *result)
365 struct sr_rational rval;
366 struct sr_rational aval;
368 if (sr_parse_rational(value, &rval) != SR_OK)
371 for (int i = 0; i < array_len; i++) {
372 sr_rational_set(&aval, array[i][0], array[i][1]);
373 if (sr_rational_eq(&rval, &aval)) {
382 static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
385 while (channel_lhead) {
386 struct sr_channel *ch = channel_lhead->data;
387 if (ch->index == index && ch->type == type)
390 channel_lhead = channel_lhead->next;
396 static int analog_channel_state_get(struct sr_dev_inst *sdi,
397 const struct scope_config *config,
398 struct scope_state *state)
401 char command[MAX_COMMAND_SIZE];
403 struct sr_channel *ch;
404 struct sr_scpi_dev_inst *scpi = sdi->conn;
406 for (i = 0; i < config->analog_channels; i++) {
407 g_snprintf(command, sizeof(command),
408 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
411 if (sr_scpi_get_bool(scpi, command,
412 &state->analog_channels[i].state) != SR_OK)
415 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
417 ch->enabled = state->analog_channels[i].state;
419 g_snprintf(command, sizeof(command),
420 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
423 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
426 if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
428 sr_err("Could not determine array index for vertical div scale.");
433 state->analog_channels[i].vdiv = j;
435 g_snprintf(command, sizeof(command),
436 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
439 if (sr_scpi_get_float(scpi, command,
440 &state->analog_channels[i].vertical_offset) != SR_OK)
443 g_snprintf(command, sizeof(command),
444 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
447 if (scope_state_get_array_option(scpi, command, config->coupling_options,
448 config->num_coupling_options,
449 &state->analog_channels[i].coupling) != SR_OK)
452 g_snprintf(command, sizeof(command),
453 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
456 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
459 if (tmp_str[0] == 'A')
460 state->analog_channels[i].probe_unit = 'A';
462 state->analog_channels[i].probe_unit = 'V';
469 static int digital_channel_state_get(struct sr_dev_inst *sdi,
470 const struct scope_config *config,
471 struct scope_state *state)
474 char command[MAX_COMMAND_SIZE];
475 struct sr_channel *ch;
476 struct sr_scpi_dev_inst *scpi = sdi->conn;
478 for (i = 0; i < config->digital_channels; i++) {
479 g_snprintf(command, sizeof(command),
480 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
483 if (sr_scpi_get_bool(scpi, command,
484 &state->digital_channels[i]) != SR_OK)
487 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
489 ch->enabled = state->digital_channels[i];
492 for (i = 0; i < config->digital_pods; i++) {
493 g_snprintf(command, sizeof(command),
494 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
497 if (sr_scpi_get_bool(scpi, command,
498 &state->digital_pods[i]) != SR_OK)
505 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
507 struct dev_context *devc;
508 struct scope_state *state;
509 const struct scope_config *config;
513 gboolean channel_found;
514 char tmp_str[MAX_COMMAND_SIZE];
518 config = devc->model_config;
519 state = devc->model_state;
520 channel_found = FALSE;
522 for (i = 0; i < config->analog_channels; i++) {
523 if (!state->analog_channels[i].state)
525 g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
526 g_snprintf(tmp_str, sizeof(tmp_str),
527 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
529 channel_found = TRUE;
533 if (!channel_found) {
534 for (i = 0; i < config->digital_pods; i++) {
535 if (!state->digital_pods[i])
537 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
538 g_snprintf(tmp_str, sizeof(tmp_str),
539 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
541 channel_found = TRUE;
546 /* No channel is active, ask the instrument for the sample rate
547 * in single shot mode */
548 if (!channel_found) {
549 if (sr_scpi_get_float(sdi->conn,
550 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
551 &tmp_float) != SR_OK)
554 state->sample_rate = tmp_float;
556 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
558 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
559 (*config->timebases)[state->timebase][1]) *
566 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
568 struct dev_context *devc;
569 struct scope_state *state;
570 const struct scope_config *config;
576 config = devc->model_config;
577 state = devc->model_state;
579 sr_info("Fetching scope state");
581 if (analog_channel_state_get(sdi, config, state) != SR_OK)
584 if (digital_channel_state_get(sdi, config, state) != SR_OK)
587 if (sr_scpi_get_float(sdi->conn,
588 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
589 &tmp_float) != SR_OK)
592 if (sr_scpi_get_string(sdi->conn,
593 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
597 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
599 sr_err("Could not determine array index for time base.");
606 if (sr_scpi_get_float(sdi->conn,
607 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
608 &tmp_float) != SR_OK)
610 state->horiz_triggerpos = tmp_float /
611 (((double) (*config->timebases)[state->timebase][0] /
612 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
613 state->horiz_triggerpos -= 0.5;
614 state->horiz_triggerpos *= -1;
616 if (scope_state_get_array_option(sdi->conn,
617 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
618 config->trigger_sources, config->num_trigger_sources,
619 &state->trigger_source) != SR_OK)
622 if (scope_state_get_array_option(sdi->conn,
623 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
624 config->trigger_slopes, config->num_trigger_slopes,
625 &state->trigger_slope) != SR_OK)
628 if (hmo_update_sample_rate(sdi) != SR_OK)
631 sr_info("Fetching finished.");
633 scope_state_dump(config, state);
638 static struct scope_state *scope_state_new(const struct scope_config *config)
640 struct scope_state *state;
642 state = g_malloc0(sizeof(struct scope_state));
643 state->analog_channels = g_malloc0_n(config->analog_channels,
644 sizeof(struct analog_channel_state));
645 state->digital_channels = g_malloc0_n(
646 config->digital_channels, sizeof(gboolean));
647 state->digital_pods = g_malloc0_n(config->digital_pods,
653 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
655 g_free(state->analog_channels);
656 g_free(state->digital_channels);
657 g_free(state->digital_pods);
661 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
664 unsigned int i, j, group;
665 struct sr_channel *ch;
666 struct dev_context *devc;
672 /* Find the exact model. */
673 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
674 for (j = 0; scope_models[i].name[j]; j++) {
675 if (!strcmp(sdi->model, scope_models[i].name[j])) {
680 if (model_index != -1)
684 if (model_index == -1) {
685 sr_dbg("Unsupported HMO device.");
689 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
690 scope_models[model_index].analog_channels);
691 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
692 scope_models[model_index].digital_pods);
693 if (!devc->analog_groups || !devc->digital_groups) {
694 g_free(devc->analog_groups);
695 g_free(devc->digital_groups);
696 return SR_ERR_MALLOC;
699 /* Add analog channels. */
700 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
701 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
702 (*scope_models[model_index].analog_names)[i]);
704 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
706 devc->analog_groups[i]->name = g_strdup(
707 (char *)(*scope_models[model_index].analog_names)[i]);
708 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
710 sdi->channel_groups = g_slist_append(sdi->channel_groups,
711 devc->analog_groups[i]);
714 /* Add digital channel groups. */
716 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
717 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
718 if (!devc->digital_groups[i]) {
722 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i);
723 sdi->channel_groups = g_slist_append(sdi->channel_groups,
724 devc->digital_groups[i]);
729 /* Add digital channels. */
730 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
731 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
732 (*scope_models[model_index].digital_names)[i]);
735 devc->digital_groups[group]->channels = g_slist_append(
736 devc->digital_groups[group]->channels, ch);
739 devc->model_config = &scope_models[model_index];
740 devc->frame_limit = 0;
742 if (!(devc->model_state = scope_state_new(devc->model_config)))
743 return SR_ERR_MALLOC;
748 /* Queue data of one channel group, for later submission. */
749 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
750 size_t group, GByteArray *pod_data)
755 size_t idx, logic_step;
758 * Upon first invocation, allocate the array which can hold the
759 * combined logic data for all channels. Assume that each channel
760 * will yield an identical number of samples per receive call.
762 * As a poor man's safety measure: (Silently) skip processing
763 * for unexpected sample counts, and ignore samples for
764 * unexpected channel groups. Don't bother with complicated
765 * resize logic, considering that many models only support one
766 * pod, and the most capable supported models have two pods of
767 * identical size. We haven't yet seen any "odd" configuration.
769 if (!devc->logic_data) {
770 size = pod_data->len * devc->pod_count;
771 store = g_byte_array_sized_new(size);
772 memset(store->data, 0, size);
773 store = g_byte_array_set_size(store, size);
774 devc->logic_data = store;
776 store = devc->logic_data;
777 size = store->len / devc->pod_count;
778 if (size != pod_data->len)
780 if (group >= devc->pod_count)
785 * Fold the data of the most recently received channel group into
786 * the storage, where data resides for all channels combined.
788 logic_data = store->data;
790 logic_step = devc->pod_count;
791 for (idx = 0; idx < pod_data->len; idx++) {
792 *logic_data = pod_data->data[idx];
793 logic_data += logic_step;
797 /* Submit data for all channels, after the individual groups got collected. */
798 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
799 struct dev_context *devc)
801 struct sr_datafeed_packet packet;
802 struct sr_datafeed_logic logic;
804 if (!devc->logic_data)
807 logic.data = devc->logic_data->data;
808 logic.length = devc->logic_data->len;
809 logic.unitsize = devc->pod_count;
811 packet.type = SR_DF_LOGIC;
812 packet.payload = &logic;
814 sr_session_send(sdi, &packet);
817 /* Undo previous resource allocation. */
818 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
821 if (devc->logic_data) {
822 g_byte_array_free(devc->logic_data, TRUE);
823 devc->logic_data = NULL;
826 * Keep 'pod_count'! It's required when more frames will be
827 * received, and does not harm when kept after acquisition.
831 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
833 struct sr_channel *ch;
834 struct sr_dev_inst *sdi;
835 struct dev_context *devc;
836 struct scope_state *state;
837 struct sr_datafeed_packet packet;
839 struct sr_datafeed_analog analog;
840 struct sr_analog_encoding encoding;
841 struct sr_analog_meaning meaning;
842 struct sr_analog_spec spec;
843 struct sr_datafeed_logic logic;
851 if (!(sdi = cb_data))
854 if (!(devc = sdi->priv))
857 /* Although this is correct in general, the USBTMC libusb implementation
858 * currently does not generate an event prior to the first read. Often
859 * it is ok to start reading just after the 50ms timeout. See bug #785.
860 if (revents != G_IO_IN)
864 ch = devc->current_channel->data;
865 state = devc->model_state;
868 * Send "frame begin" packet upon reception of data for the
869 * first enabled channel.
871 if (devc->current_channel == devc->enabled_channels) {
872 packet.type = SR_DF_FRAME_BEGIN;
873 sr_session_send(sdi, &packet);
877 * Pass on the received data of the channel(s).
880 case SR_CHANNEL_ANALOG:
881 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
883 g_byte_array_free(data, TRUE);
888 packet.type = SR_DF_ANALOG;
890 analog.data = data->data;
891 analog.num_samples = data->len / sizeof(float);
892 analog.encoding = &encoding;
893 analog.meaning = &meaning;
896 encoding.unitsize = sizeof(float);
897 encoding.is_signed = TRUE;
898 encoding.is_float = TRUE;
899 #ifdef WORDS_BIGENDIAN
900 encoding.is_bigendian = TRUE;
902 encoding.is_bigendian = FALSE;
904 /* TODO: Use proper 'digits' value for this device (and its modes). */
906 encoding.is_digits_decimal = FALSE;
907 encoding.scale.p = 1;
908 encoding.scale.q = 1;
909 encoding.offset.p = 0;
910 encoding.offset.q = 1;
911 if (state->analog_channels[ch->index].probe_unit == 'V') {
912 meaning.mq = SR_MQ_VOLTAGE;
913 meaning.unit = SR_UNIT_VOLT;
915 meaning.mq = SR_MQ_CURRENT;
916 meaning.unit = SR_UNIT_AMPERE;
919 meaning.channels = g_slist_append(NULL, ch);
920 /* TODO: Use proper 'digits' value for this device (and its modes). */
921 spec.spec_digits = 2;
922 packet.payload = &analog;
923 sr_session_send(sdi, &packet);
924 g_slist_free(meaning.channels);
925 g_byte_array_free(data, TRUE);
928 case SR_CHANNEL_LOGIC:
929 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
935 * If only data from the first pod is involved in the
936 * acquisition, then the raw input bytes can get passed
937 * forward for performance reasons. When the second pod
938 * is involved (either alone, or in combination with the
939 * first pod), then the received bytes need to be put
940 * into memory in such a layout that all channel groups
941 * get combined, and a unitsize larger than a single byte
942 * applies. The "queue" logic transparently copes with
943 * any such configuration. This works around the lack
944 * of support for "meaning" to logic data, which is used
945 * above for analog data.
947 if (devc->pod_count == 1) {
948 packet.type = SR_DF_LOGIC;
949 logic.data = data->data;
950 logic.length = data->len;
952 packet.payload = &logic;
953 sr_session_send(sdi, &packet);
955 group = ch->index / 8;
956 hmo_queue_logic_data(devc, group, data);
959 g_byte_array_free(data, TRUE);
963 sr_err("Invalid channel type.");
968 * Advance to the next enabled channel. When data for all enabled
969 * channels was received, then flush potentially queued logic data,
970 * and send the "frame end" packet.
972 if (devc->current_channel->next) {
973 devc->current_channel = devc->current_channel->next;
974 hmo_request_data(sdi);
977 hmo_send_logic_packet(sdi, devc);
980 * Release the logic data storage after each frame. This copes
981 * with sample counts that differ in length per frame. -- Is
982 * this a real constraint when acquiring multiple frames with
983 * identical device settings?
985 hmo_cleanup_logic_data(devc);
987 packet.type = SR_DF_FRAME_END;
988 sr_session_send(sdi, &packet);
991 * End of frame was reached. Stop acquisition after the specified
992 * number of frames, or continue reception by starting over at
993 * the first enabled channel.
995 if (++devc->num_frames == devc->frame_limit) {
996 sr_dev_acquisition_stop(sdi);
997 hmo_cleanup_logic_data(devc);
999 devc->current_channel = devc->enabled_channels;
1000 hmo_request_data(sdi);