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 for (i = 0; i < n; i++) {
340 if (!g_strcmp0(tmp, (*array)[i])) {
357 * This function takes a value of the form "2.000E-03" and returns the index
358 * of an array where a matching pair was found.
360 * @param value The string to be parsed.
361 * @param array The array of s/f pairs.
362 * @param array_len The number of pairs in the array.
363 * @param result The index at which a matching pair was found.
365 * @return SR_ERR on any parsing error, SR_OK otherwise.
367 static int array_float_get(gchar *value, const uint64_t array[][2],
368 int array_len, unsigned int *result)
370 struct sr_rational rval;
371 struct sr_rational aval;
373 if (sr_parse_rational(value, &rval) != SR_OK)
376 for (int i = 0; i < array_len; i++) {
377 sr_rational_set(&aval, array[i][0], array[i][1]);
378 if (sr_rational_eq(&rval, &aval)) {
387 static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi,
388 const struct scope_config *config,
389 struct scope_state *state)
392 char command[MAX_COMMAND_SIZE];
395 for (i = 0; i < config->analog_channels; i++) {
396 g_snprintf(command, sizeof(command),
397 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
400 if (sr_scpi_get_bool(scpi, command,
401 &state->analog_channels[i].state) != SR_OK)
404 g_snprintf(command, sizeof(command),
405 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
408 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
411 if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
413 sr_err("Could not determine array index for vertical div scale.");
418 state->analog_channels[i].vdiv = j;
420 g_snprintf(command, sizeof(command),
421 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
424 if (sr_scpi_get_float(scpi, command,
425 &state->analog_channels[i].vertical_offset) != SR_OK)
428 g_snprintf(command, sizeof(command),
429 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
432 if (scope_state_get_array_option(scpi, command, config->coupling_options,
433 config->num_coupling_options,
434 &state->analog_channels[i].coupling) != SR_OK)
437 g_snprintf(command, sizeof(command),
438 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
441 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
444 if (tmp_str[0] == 'A')
445 state->analog_channels[i].probe_unit = 'A';
447 state->analog_channels[i].probe_unit = 'V';
454 static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi,
455 const struct scope_config *config,
456 struct scope_state *state)
459 char command[MAX_COMMAND_SIZE];
461 for (i = 0; i < config->digital_channels; i++) {
462 g_snprintf(command, sizeof(command),
463 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
466 if (sr_scpi_get_bool(scpi, command,
467 &state->digital_channels[i]) != SR_OK)
471 for (i = 0; i < config->digital_pods; i++) {
472 g_snprintf(command, sizeof(command),
473 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
476 if (sr_scpi_get_bool(scpi, command,
477 &state->digital_pods[i]) != SR_OK)
484 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
486 struct dev_context *devc;
487 struct scope_state *state;
488 const struct scope_config *config;
493 gboolean channel_found;
494 char tmp_str[MAX_COMMAND_SIZE];
498 config = devc->model_config;
499 state = devc->model_state;
500 channel_found = FALSE;
502 for (i = 0; i < config->analog_channels; i++) {
503 if (state->analog_channels[i].state) {
504 g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
505 g_snprintf(tmp_str, sizeof(tmp_str),
506 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
508 channel_found = TRUE;
513 if (!channel_found) {
514 for (i = 0; i < config->digital_pods; i++) {
515 if (state->digital_pods[i]) {
516 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
517 g_snprintf(tmp_str, sizeof(tmp_str),
518 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
520 channel_found = TRUE;
526 /* No channel is active, ask the instrument for the sample rate
527 * in single shot mode */
528 if (!channel_found) {
529 if (sr_scpi_get_float(sdi->conn,
530 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
531 &tmp_float) != SR_OK)
534 state->sample_rate = tmp_float;
536 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
538 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
539 (*config->timebases)[state->timebase][1]) *
546 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
548 struct dev_context *devc;
549 struct scope_state *state;
550 const struct scope_config *config;
556 config = devc->model_config;
557 state = devc->model_state;
559 sr_info("Fetching scope state");
561 if (analog_channel_state_get(sdi->conn, config, state) != SR_OK)
564 if (digital_channel_state_get(sdi->conn, config, state) != SR_OK)
567 if (sr_scpi_get_float(sdi->conn,
568 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
569 &tmp_float) != SR_OK)
572 if (sr_scpi_get_string(sdi->conn,
573 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
577 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
579 sr_err("Could not determine array index for time base.");
586 if (sr_scpi_get_float(sdi->conn,
587 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
588 &tmp_float) != SR_OK)
590 state->horiz_triggerpos = tmp_float /
591 (((double) (*config->timebases)[state->timebase][0] /
592 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
593 state->horiz_triggerpos -= 0.5;
594 state->horiz_triggerpos *= -1;
596 if (scope_state_get_array_option(sdi->conn,
597 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
598 config->trigger_sources, config->num_trigger_sources,
599 &state->trigger_source) != SR_OK)
602 if (scope_state_get_array_option(sdi->conn,
603 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
604 config->trigger_slopes, config->num_trigger_slopes,
605 &state->trigger_slope) != SR_OK)
608 if (hmo_update_sample_rate(sdi) != SR_OK)
611 sr_info("Fetching finished.");
613 scope_state_dump(config, state);
618 static struct scope_state *scope_state_new(const struct scope_config *config)
620 struct scope_state *state;
622 state = g_malloc0(sizeof(struct scope_state));
623 state->analog_channels = g_malloc0_n(config->analog_channels,
624 sizeof(struct analog_channel_state));
625 state->digital_channels = g_malloc0_n(
626 config->digital_channels, sizeof(gboolean));
627 state->digital_pods = g_malloc0_n(config->digital_pods,
633 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
635 g_free(state->analog_channels);
636 g_free(state->digital_channels);
637 g_free(state->digital_pods);
641 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
645 unsigned int i, j, group;
646 struct sr_channel *ch;
647 struct dev_context *devc;
652 /* Find the exact model. */
653 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
654 for (j = 0; scope_models[i].name[j]; j++) {
655 if (!strcmp(sdi->model, scope_models[i].name[j])) {
660 if (model_index != -1)
664 if (model_index == -1) {
665 sr_dbg("Unsupported HMO device.");
669 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
670 scope_models[model_index].analog_channels);
672 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
673 scope_models[model_index].digital_pods);
675 /* Add analog channels. */
676 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
677 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
678 (*scope_models[model_index].analog_names)[i]);
680 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
682 devc->analog_groups[i]->name = g_strdup(
683 (char *)(*scope_models[model_index].analog_names)[i]);
684 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
686 sdi->channel_groups = g_slist_append(sdi->channel_groups,
687 devc->analog_groups[i]);
690 /* Add digital channel groups. */
691 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
692 g_snprintf(tmp, 25, "POD%d", i);
694 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
696 devc->digital_groups[i]->name = g_strdup(tmp);
697 sdi->channel_groups = g_slist_append(sdi->channel_groups,
698 devc->digital_groups[i]);
701 /* Add digital channels. */
702 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
703 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
704 (*scope_models[model_index].digital_names)[i]);
707 devc->digital_groups[group]->channels = g_slist_append(
708 devc->digital_groups[group]->channels, ch);
711 devc->model_config = &scope_models[model_index];
712 devc->frame_limit = 0;
714 if (!(devc->model_state = scope_state_new(devc->model_config)))
715 return SR_ERR_MALLOC;
720 /* Queue data of one channel group, for later submission. */
721 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
722 size_t group, GByteArray *pod_data)
727 size_t idx, logic_step;
730 * Upon first invocation, allocate the array which can hold the
731 * combined logic data for all channels. Assume that each channel
732 * will yield an identical number of samples per receive call.
734 * As a poor man's safety measure: (Silently) skip processing
735 * for unexpected sample counts, and ignore samples for
736 * unexpected channel groups. Don't bother with complicated
737 * resize logic, considering that many models only support one
738 * pod, and the most capable supported models have two pods of
739 * identical size. We haven't yet seen any "odd" configuration.
741 if (!devc->logic_data) {
742 size = pod_data->len * devc->pod_count;
743 store = g_byte_array_sized_new(size);
744 memset(store->data, 0, size);
745 store = g_byte_array_set_size(store, size);
746 devc->logic_data = store;
748 store = devc->logic_data;
749 size = store->len / devc->pod_count;
750 if (size != pod_data->len)
752 if (group >= devc->pod_count)
757 * Fold the data of the most recently received channel group into
758 * the storage, where data resides for all channels combined.
760 logic_data = store->data;
762 logic_step = devc->pod_count;
763 for (idx = 0; idx < pod_data->len; idx++) {
764 *logic_data = pod_data->data[idx];
765 logic_data += logic_step;
769 /* Submit data for all channels, after the individual groups got collected. */
770 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
771 struct dev_context *devc)
773 struct sr_datafeed_packet packet;
774 struct sr_datafeed_logic logic;
776 if (!devc->logic_data)
779 logic.data = devc->logic_data->data;
780 logic.length = devc->logic_data->len;
781 logic.unitsize = devc->pod_count;
783 packet.type = SR_DF_LOGIC;
784 packet.payload = &logic;
786 sr_session_send(sdi, &packet);
789 /* Undo previous resource allocation. */
790 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
793 if (devc->logic_data) {
794 g_byte_array_free(devc->logic_data, TRUE);
795 devc->logic_data = NULL;
798 * Keep 'pod_count'! It's required when more frames will be
799 * received, and does not harm when kept after acquisition.
803 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
805 struct sr_channel *ch;
806 struct sr_dev_inst *sdi;
807 struct dev_context *devc;
808 struct scope_state *state;
809 struct sr_datafeed_packet packet;
811 struct sr_datafeed_analog analog;
812 struct sr_analog_encoding encoding;
813 struct sr_analog_meaning meaning;
814 struct sr_analog_spec spec;
815 struct sr_datafeed_logic logic;
823 if (!(sdi = cb_data))
826 if (!(devc = sdi->priv))
829 /* Although this is correct in general, the USBTMC libusb implementation
830 * currently does not generate an event prior to the first read. Often
831 * it is ok to start reading just after the 50ms timeout. See bug #785.
832 if (revents != G_IO_IN)
836 ch = devc->current_channel->data;
837 state = devc->model_state;
840 * Send "frame begin" packet upon reception of data for the
841 * first enabled channel.
843 if (devc->current_channel == devc->enabled_channels) {
844 packet.type = SR_DF_FRAME_BEGIN;
845 sr_session_send(sdi, &packet);
849 * Pass on the received data of the channel(s).
852 case SR_CHANNEL_ANALOG:
853 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
855 g_byte_array_free(data, TRUE);
860 packet.type = SR_DF_ANALOG;
862 analog.data = data->data;
863 analog.num_samples = data->len / sizeof(float);
864 analog.encoding = &encoding;
865 analog.meaning = &meaning;
868 encoding.unitsize = sizeof(float);
869 encoding.is_signed = TRUE;
870 encoding.is_float = TRUE;
871 #ifdef WORDS_BIGENDIAN
872 encoding.is_bigendian = TRUE;
874 encoding.is_bigendian = FALSE;
876 /* TODO: Use proper 'digits' value for this device (and its modes). */
878 encoding.is_digits_decimal = FALSE;
879 encoding.scale.p = 1;
880 encoding.scale.q = 1;
881 encoding.offset.p = 0;
882 encoding.offset.q = 1;
883 if (state->analog_channels[ch->index].probe_unit == 'V') {
884 meaning.mq = SR_MQ_VOLTAGE;
885 meaning.unit = SR_UNIT_VOLT;
887 meaning.mq = SR_MQ_CURRENT;
888 meaning.unit = SR_UNIT_AMPERE;
891 meaning.channels = g_slist_append(NULL, ch);
892 /* TODO: Use proper 'digits' value for this device (and its modes). */
893 spec.spec_digits = 2;
894 packet.payload = &analog;
895 sr_session_send(sdi, &packet);
896 g_slist_free(meaning.channels);
897 g_byte_array_free(data, TRUE);
900 case SR_CHANNEL_LOGIC:
901 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
907 * If only data from the first pod is involved in the
908 * acquisition, then the raw input bytes can get passed
909 * forward for performance reasons. When the second pod
910 * is involved (either alone, or in combination with the
911 * first pod), then the received bytes need to be put
912 * into memory in such a layout that all channel groups
913 * get combined, and a unitsize larger than a single byte
914 * applies. The "queue" logic transparently copes with
915 * any such configuration. This works around the lack
916 * of support for "meaning" to logic data, which is used
917 * above for analog data.
919 if (devc->pod_count == 1) {
920 packet.type = SR_DF_LOGIC;
921 logic.data = data->data;
922 logic.length = data->len;
924 packet.payload = &logic;
925 sr_session_send(sdi, &packet);
927 group = ch->index / 8;
928 hmo_queue_logic_data(devc, group, data);
931 g_byte_array_free(data, TRUE);
935 sr_err("Invalid channel type.");
940 * Advance to the next enabled channel. When data for all enabled
941 * channels was received, then flush potentially queued logic data,
942 * and send the "frame end" packet.
944 if (devc->current_channel->next) {
945 devc->current_channel = devc->current_channel->next;
946 hmo_request_data(sdi);
949 hmo_send_logic_packet(sdi, devc);
952 * Release the logic data storage after each frame. This copes
953 * with sample counts that differ in length per frame. -- Is
954 * this a real constraint when acquiring multiple frames with
955 * identical device settings?
957 hmo_cleanup_logic_data(devc);
959 packet.type = SR_DF_FRAME_END;
960 sr_session_send(sdi, &packet);
963 * End of frame was reached. Stop acquisition after the specified
964 * number of frames, or continue reception by starting over at
965 * the first enabled channel.
967 if (++devc->num_frames == devc->frame_limit) {
968 sr_dev_acquisition_stop(sdi);
969 hmo_cleanup_logic_data(devc);
971 devc->current_channel = devc->enabled_channels;
972 hmo_request_data(sdi);