2 * This file is part of the libsigrok project.
4 * Copyright (C) 2014 abraxa (Soeren Apel) <soeren@apelpie.net>
5 * Based on the Hameg HMO driver by poljar (Damir Jelić) <poljarinho@gmail.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/>.
25 static const char *coupling_options[] = {
26 "AC", "DC", "DC50", "GND",
30 static const char *trigger_sources_2ch[] = {
31 "1", "2", "LINE", "EXT",
35 /* TODO: Is BITx handled correctly or is Dx required? */
36 static const char *trigger_sources_4ch[] = {
38 "LINE", "EXT", "BIT1",
39 "BIT2", "BIT3", "BIT4", "BIT5", "BIT6", "BIT7", "BIT8",
43 /* Note: Values must correlate to the trigger_slopes values. */
44 const char *dlm_trigger_slopes[3] = {
49 const uint64_t dlm_timebases[36][2] = {
92 const uint64_t dlm_vdivs[17][2] = {
114 static const char *scope_analog_channel_names[] = {
118 static const char *scope_digital_channel_names_8[] = {
119 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
122 static const char *scope_digital_channel_names_32[] = {
123 "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
124 "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7",
125 "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7",
126 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
129 static const struct scope_config scope_models[] = {
131 .model_id = {"710105", "710115", "710125", NULL},
132 .model_name = {"DLM2022", "DLM2032", "DLM2052", NULL},
133 .analog_channels = 2,
134 .digital_channels = 0,
137 .analog_names = &scope_analog_channel_names,
138 .digital_names = &scope_digital_channel_names_8,
140 .coupling_options = &coupling_options,
141 .trigger_sources = &trigger_sources_2ch,
147 .model_id = {"710110", "710120", "710130", NULL},
148 .model_name = {"DLM2024", "DLM2034", "DLM2054", NULL},
149 .analog_channels = 4,
150 .digital_channels = 8,
153 .analog_names = &scope_analog_channel_names,
154 .digital_names = &scope_digital_channel_names_8,
156 .coupling_options = &coupling_options,
157 .trigger_sources = &trigger_sources_4ch,
163 .model_id = {"701307", "701308", "701310", "701311",
164 "701312", "701313", NULL},
165 .model_name = {"DL9040", "DL9040L", "DL9140", "DL9140L",
166 "DL9240", "DL9240L", NULL},
167 .analog_channels = 4,
168 .digital_channels = 0,
171 .analog_names = &scope_analog_channel_names,
172 .digital_names = NULL,
174 .coupling_options = &coupling_options,
175 .trigger_sources = &trigger_sources_4ch,
181 .model_id = {"701320", "701321", NULL},
182 .model_name = {"DL9505L", "DL9510L", NULL},
183 .analog_channels = 4,
184 .digital_channels = 16,
187 .analog_names = &scope_analog_channel_names,
188 .digital_names = &scope_digital_channel_names_32,
190 .coupling_options = &coupling_options,
191 .trigger_sources = &trigger_sources_4ch,
197 .model_id = {"701330", "701331", NULL},
198 .model_name = {"DL9705L", "DL9710L", NULL},
199 .analog_channels = 4,
200 .digital_channels = 32,
203 .analog_names = &scope_analog_channel_names,
204 .digital_names = &scope_digital_channel_names_32,
206 .coupling_options = &coupling_options,
207 .trigger_sources = &trigger_sources_4ch,
215 * Prints out the state of the device as we currently know it.
217 * @param config This is the scope configuration.
218 * @param state The current scope state to print.
220 static void scope_state_dump(const struct scope_config *config,
221 struct scope_state *state)
226 for (i = 0; i < config->analog_channels; i++) {
227 tmp = sr_voltage_string(dlm_vdivs[state->analog_states[i].vdiv][0],
228 dlm_vdivs[state->analog_states[i].vdiv][1]);
229 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
230 i + 1, state->analog_states[i].state ? "On" : "Off",
231 (*config->coupling_options)[state->analog_states[i].coupling],
232 tmp, state->analog_states[i].vertical_offset);
235 for (i = 0; i < config->digital_channels; i++) {
236 sr_info("State of digital channel %d -> %s", i,
237 state->digital_states[i] ? "On" : "Off");
240 for (i = 0; i < config->pods; i++) {
241 sr_info("State of digital POD %d -> %s", i,
242 state->pod_states[i] ? "On" : "Off");
245 tmp = sr_period_string(dlm_timebases[state->timebase][0],
246 dlm_timebases[state->timebase][1]);
247 sr_info("Current timebase: %s", tmp);
250 tmp = sr_samplerate_string(state->sample_rate);
251 sr_info("Current samplerate: %s", tmp);
254 sr_info("Current samples per acquisition (i.e. frame): %d",
255 state->samples_per_frame);
257 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
258 (*config->trigger_sources)[state->trigger_source],
259 dlm_trigger_slopes[state->trigger_slope],
260 state->horiz_triggerpos);
264 * Searches through an array of strings and returns the index to the
265 * array where a given string is located.
267 * @param value The string to search for.
268 * @param array The array of strings.
269 * @param result The index at which value is located in array. -1 on error.
271 * @return SR_ERR when value couldn't be found, SR_OK otherwise.
273 static int array_option_get(char *value, const char *(*array)[],
280 for (i = 0; (*array)[i]; i++)
281 if (!g_strcmp0(value, (*array)[i])) {
293 * This function takes a value of the form "2.000E-03", converts it to a
294 * significand / factor pair and returns the index of an array where
295 * a matching pair was found.
297 * It's a bit convoluted because of floating-point issues. The value "10.00E-09"
298 * is parsed by g_ascii_strtod() as 0.000000009999999939, for example.
299 * Therefore it's easier to break the number up into two strings and handle
302 * @param value The string to be parsed.
303 * @param array The array of s/f pairs.
304 * @param array_len The number of pairs in the array.
305 * @param result The index at which a matching pair was found.
307 * @return SR_ERR on any parsing error, SR_OK otherwise.
309 static int array_float_get(gchar *value, const uint64_t array[][2],
310 int array_len, int *result)
317 gchar ss[10], es[10];
319 memset(ss, 0, sizeof(ss));
320 memset(es, 0, sizeof(es));
322 /* Get index of the separating 'E' character and break up the string. */
323 pos = strcspn(value, "E");
325 strncpy(ss, value, pos);
326 strncpy(es, &(value[pos+1]), 3);
328 if (sr_atof_ascii(ss, &s) != SR_OK)
330 if (sr_atoi(es, &e) != SR_OK)
333 /* Transform e.g. 10^-03 to 1000 as the array stores the inverse. */
337 * Adjust the significand/factor pair to make sure
338 * that f is a multiple of 1000.
340 while ((int)fmod(log10(f), 3) > 0) {
349 /* Truncate s to circumvent rounding errors. */
350 s_int = (unsigned int)s;
352 for (i = 0; i < array_len; i++) {
353 if ((s_int == array[i][0]) && (f == array[i][1])) {
363 * Obtains information about all analog channels from the oscilloscope.
364 * The internal state information is updated accordingly.
366 * @param sdi The device instance.
367 * @param config The device's device configuration.
368 * @param state The device's state information.
370 * @return SR_ERR on error, SR_OK otherwise.
372 static int analog_channel_state_get(const struct sr_dev_inst *sdi,
373 const struct scope_config *config,
374 struct scope_state *state)
376 struct sr_scpi_dev_inst *scpi;
379 struct sr_channel *ch;
384 for (i = 0; i < config->analog_channels; i++) {
386 if (dlm_analog_chan_state_get(scpi, i + 1,
387 &state->analog_states[i].state) != SR_OK)
390 for (l = sdi->channels; l; l = l->next) {
392 if (ch->index == i) {
393 ch->enabled = state->analog_states[i].state;
398 if (dlm_analog_chan_vdiv_get(scpi, i + 1, &response) != SR_OK)
401 if (array_float_get(response, ARRAY_AND_SIZE(dlm_vdivs),
408 state->analog_states[i].vdiv = j;
410 if (dlm_analog_chan_voffs_get(scpi, i + 1,
411 &state->analog_states[i].vertical_offset) != SR_OK)
414 if (dlm_analog_chan_wrange_get(scpi, i + 1,
415 &state->analog_states[i].waveform_range) != SR_OK)
418 if (dlm_analog_chan_woffs_get(scpi, i + 1,
419 &state->analog_states[i].waveform_offset) != SR_OK)
422 if (dlm_analog_chan_coupl_get(scpi, i + 1, &response) != SR_OK) {
427 if (array_option_get(response, config->coupling_options,
428 &state->analog_states[i].coupling) != SR_OK) {
439 * Obtains information about all digital channels from the oscilloscope.
440 * The internal state information is updated accordingly.
442 * @param sdi The device instance.
443 * @param config The device's device configuration.
444 * @param state The device's state information.
446 * @return SR_ERR on error, SR_OK otherwise.
448 static int digital_channel_state_get(const struct sr_dev_inst *sdi,
449 const struct scope_config *config,
450 struct scope_state *state)
452 struct sr_scpi_dev_inst *scpi;
455 struct sr_channel *ch;
459 if (!config->digital_channels) {
460 sr_warn("Tried obtaining digital channel states on a " \
461 "model without digital inputs.");
465 for (i = 0; i < config->digital_channels; i++) {
466 if (dlm_digital_chan_state_get(scpi, i + 1,
467 &state->digital_states[i]) != SR_OK) {
471 for (l = sdi->channels; l; l = l->next) {
473 if (ch->index == i + DLM_DIG_CHAN_INDEX_OFFS) {
474 ch->enabled = state->digital_states[i];
481 sr_warn("Tried obtaining pod states on a model without pods.");
485 for (i = 0; i < config->pods; i++) {
486 if (dlm_digital_pod_state_get(scpi, i + 'A',
487 &state->pod_states[i]) != SR_OK)
494 SR_PRIV int dlm_channel_state_set(const struct sr_dev_inst *sdi,
495 const int ch_index, gboolean ch_state)
498 struct sr_channel *ch;
499 struct dev_context *devc = NULL;
500 struct scope_state *state;
501 const struct scope_config *model = NULL;
502 struct sr_scpi_dev_inst *scpi;
504 gboolean *pod_enabled;
511 state = devc->model_state;
512 model = devc->model_config;
515 pod_enabled = g_malloc0(sizeof(gboolean) * model->pods);
517 for (l = sdi->channels; l; l = l->next) {
521 case SR_CHANNEL_ANALOG:
522 if (ch->index == ch_index) {
523 if (dlm_analog_chan_state_set(scpi, ch->index + 1, ch_state) != SR_OK) {
528 ch->enabled = ch_state;
529 state->analog_states[ch->index].state = ch_state;
534 case SR_CHANNEL_LOGIC:
535 i = ch->index - DLM_DIG_CHAN_INDEX_OFFS;
537 if (ch->index == ch_index) {
538 if (dlm_digital_chan_state_set(scpi, i + 1, ch_state) != SR_OK) {
543 ch->enabled = ch_state;
544 state->digital_states[i] = ch_state;
547 /* The corresponding pod has to be enabled also. */
548 pod_enabled[i / 8] |= ch->enabled;
550 /* Also check all other channels. Maybe we can disable a pod. */
551 pod_enabled[i / 8] |= ch->enabled;
559 for (i = 0; i < model->pods; i++) {
560 if (state->pod_states[i] == pod_enabled[i])
563 if (dlm_digital_pod_state_set(scpi, i + 1, pod_enabled[i]) != SR_OK) {
568 state->pod_states[i] = pod_enabled[i];
573 if ((result == SR_OK) && !chan_found)
580 * Obtains information about the sample rate from the oscilloscope.
581 * The internal state information is updated accordingly.
583 * @param sdi The device instance.
585 * @return SR_ERR on error, SR_OK otherwise.
587 SR_PRIV int dlm_sample_rate_query(const struct sr_dev_inst *sdi)
589 struct dev_context *devc;
590 struct scope_state *state;
594 state = devc->model_state;
597 * No need to find an active channel to query the sample rate:
598 * querying any channel will do, so we use channel 1 all the time.
600 if (dlm_analog_chan_srate_get(sdi->conn, 1, &tmp_float) != SR_OK)
603 state->sample_rate = tmp_float;
609 * Obtains information about the current device state from the oscilloscope,
610 * including all analog and digital channel configurations.
611 * The internal state information is updated accordingly.
613 * @param sdi The device instance.
615 * @return SR_ERR on error, SR_OK otherwise.
617 SR_PRIV int dlm_scope_state_query(struct sr_dev_inst *sdi)
619 struct dev_context *devc;
620 struct scope_state *state;
621 const struct scope_config *config;
627 config = devc->model_config;
628 state = devc->model_state;
630 if (analog_channel_state_get(sdi, config, state) != SR_OK)
633 if (digital_channel_state_get(sdi, config, state) != SR_OK)
636 if (dlm_timebase_get(sdi->conn, &response) != SR_OK)
639 if (array_float_get(response, ARRAY_AND_SIZE(dlm_timebases), &i) != SR_OK) {
647 if (dlm_horiz_trigger_pos_get(sdi->conn, &tmp_float) != SR_OK)
650 /* TODO: Check if the calculation makes sense for the DLM. */
651 state->horiz_triggerpos = tmp_float /
652 (((double)dlm_timebases[state->timebase][0] /
653 dlm_timebases[state->timebase][1]) * config->num_xdivs);
654 state->horiz_triggerpos -= 0.5;
655 state->horiz_triggerpos *= -1;
657 if (dlm_trigger_source_get(sdi->conn, &response) != SR_OK) {
662 if (array_option_get(response, config->trigger_sources,
663 &state->trigger_source) != SR_OK) {
670 if (dlm_trigger_slope_get(sdi->conn, &i) != SR_OK)
673 state->trigger_slope = i;
675 if (dlm_acq_length_get(sdi->conn, &state->samples_per_frame) != SR_OK) {
676 sr_err("Failed to query acquisition length.");
680 dlm_sample_rate_query(sdi);
682 scope_state_dump(config, state);
688 * Creates a new device state structure.
690 * @param config The device configuration to use.
692 * @return The newly allocated scope_state struct.
694 static struct scope_state *dlm_scope_state_new(const struct scope_config *config)
696 struct scope_state *state;
698 state = g_malloc0(sizeof(struct scope_state));
700 state->analog_states = g_malloc0(config->analog_channels *
701 sizeof(struct analog_channel_state));
703 state->digital_states = g_malloc0(config->digital_channels *
706 state->pod_states = g_malloc0(config->pods * sizeof(gboolean));
712 * Frees the memory that was allocated by a call to dlm_scope_state_new().
714 * @param state The device state structure whose memory is to be freed.
716 SR_PRIV void dlm_scope_state_destroy(struct scope_state *state)
718 g_free(state->analog_states);
719 g_free(state->digital_states);
720 g_free(state->pod_states);
724 SR_PRIV int dlm_model_get(char *model_id, char **model_name, int *model_index)
731 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
732 for (j = 0; scope_models[i].model_id[j]; j++) {
733 if (!strcmp(model_id, scope_models[i].model_id[j])) {
735 *model_name = (char *)scope_models[i].model_name[j];
739 if (*model_index != -1)
743 if (*model_index == -1) {
744 sr_err("Found unsupported DLM device with model identifier %s.",
753 * Attempts to initialize a DL/DLM device and prepares internal structures
754 * if a suitable device was found.
756 * @param sdi The device instance.
758 SR_PRIV int dlm_device_init(struct sr_dev_inst *sdi, int model_index)
762 struct sr_channel *ch;
763 struct dev_context *devc;
767 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
768 scope_models[model_index].analog_channels);
770 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
771 scope_models[model_index].pods);
773 /* Add analog channels, each in its own group. */
774 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
775 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
776 (*scope_models[model_index].analog_names)[i]);
778 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
780 devc->analog_groups[i]->name = g_strdup(
781 (char *)(*scope_models[model_index].analog_names)[i]);
782 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
784 sdi->channel_groups = g_slist_append(sdi->channel_groups,
785 devc->analog_groups[i]);
788 /* Add digital channel groups. */
789 for (i = 0; i < scope_models[model_index].pods; i++) {
790 g_snprintf(tmp, sizeof(tmp), "POD%d", i);
792 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
793 if (!devc->digital_groups[i])
794 return SR_ERR_MALLOC;
796 devc->digital_groups[i]->name = g_strdup(tmp);
797 sdi->channel_groups = g_slist_append(sdi->channel_groups,
798 devc->digital_groups[i]);
801 /* Add digital channels. */
802 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
803 ch = sr_channel_new(sdi, DLM_DIG_CHAN_INDEX_OFFS + i,
804 SR_CHANNEL_LOGIC, TRUE,
805 (*scope_models[model_index].digital_names)[i]);
807 devc->digital_groups[i / 8]->channels = g_slist_append(
808 devc->digital_groups[i / 8]->channels, ch);
810 devc->model_config = &scope_models[model_index];
811 devc->frame_limit = 0;
813 if (!(devc->model_state = dlm_scope_state_new(devc->model_config)))
814 return SR_ERR_MALLOC;
816 /* Disable non-standard response behavior. */
817 if (dlm_response_headers_set(sdi->conn, FALSE) != SR_OK)
823 SR_PRIV int dlm_channel_data_request(const struct sr_dev_inst *sdi)
825 struct dev_context *devc;
826 struct sr_channel *ch;
830 ch = devc->current_channel->data;
833 case SR_CHANNEL_ANALOG:
834 result = dlm_analog_data_get(sdi->conn, ch->index + 1);
836 case SR_CHANNEL_LOGIC:
837 result = dlm_digital_data_get(sdi->conn);
840 sr_err("Invalid channel type encountered (%d).",
846 devc->data_pending = TRUE;
848 devc->data_pending = FALSE;
854 * Reads and removes the block data header from a given data input.
855 * Format is #ndddd... with n being the number of decimal digits d.
856 * The string dddd... contains the decimal-encoded length of the data.
857 * Example: #9000000013 would yield a length of 13 bytes.
859 * @param data The input data.
860 * @param len The determined input data length.
862 static int dlm_block_data_header_process(GArray *data, int *len)
867 if (g_array_index(data, gchar, 0) != '#')
870 n = (uint8_t)(g_array_index(data, gchar, 1) - '0');
872 for (i = 0; i < n; i++)
873 s[i] = g_array_index(data, gchar, 2 + i);
876 if (sr_atoi(s, len) != SR_OK)
879 g_array_remove_range(data, 0, 2 + n);
885 * Turns raw sample data into voltages and sends them off to the session bus.
887 * @param data The raw sample data.
888 * @ch_state Pointer to the state of the channel whose data we're processing.
889 * @sdi The device instance.
891 * @return SR_ERR when data is trucated, SR_OK otherwise.
893 static int dlm_analog_samples_send(GArray *data,
894 struct analog_channel_state *ch_state,
895 struct sr_dev_inst *sdi)
898 float voltage, range, offset;
900 struct dev_context *devc;
901 struct scope_state *model_state;
902 struct sr_channel *ch;
903 struct sr_datafeed_analog analog;
904 struct sr_analog_encoding encoding;
905 struct sr_analog_meaning meaning;
906 struct sr_analog_spec spec;
907 struct sr_datafeed_packet packet;
910 model_state = devc->model_state;
911 samples = model_state->samples_per_frame;
912 ch = devc->current_channel->data;
914 if (data->len < samples * sizeof(uint8_t)) {
915 sr_err("Truncated waveform data packet received.");
919 range = ch_state->waveform_range;
920 offset = ch_state->waveform_offset;
923 * Convert byte sample to voltage according to
924 * page 269 of the Communication Interface User's Manual.
926 float_data = g_array_new(FALSE, FALSE, sizeof(float));
927 for (i = 0; i < samples; i++) {
928 voltage = (float)g_array_index(data, int8_t, i);
929 voltage = (range * voltage /
930 DLM_DIVISION_FOR_BYTE_FORMAT) + offset;
931 g_array_append_val(float_data, voltage);
934 /* TODO: Use proper 'digits' value for this device (and its modes). */
935 sr_analog_init(&analog, &encoding, &meaning, &spec, 2);
936 analog.meaning->channels = g_slist_append(NULL, ch);
937 analog.num_samples = float_data->len;
938 analog.data = (float*)float_data->data;
939 analog.meaning->mq = SR_MQ_VOLTAGE;
940 analog.meaning->unit = SR_UNIT_VOLT;
941 analog.meaning->mqflags = 0;
942 packet.type = SR_DF_ANALOG;
943 packet.payload = &analog;
944 sr_session_send(sdi, &packet);
945 g_slist_free(analog.meaning->channels);
947 g_array_free(float_data, TRUE);
948 g_array_remove_range(data, 0, samples * sizeof(uint8_t));
954 * Sends logic sample data off to the session bus.
956 * @param data The raw sample data.
957 * @ch_state Pointer to the state of the channel whose data we're processing.
958 * @sdi The device instance.
960 * @return SR_ERR when data is trucated, SR_OK otherwise.
962 static int dlm_digital_samples_send(GArray *data,
963 struct sr_dev_inst *sdi)
965 struct dev_context *devc;
966 struct scope_state *model_state;
968 struct sr_datafeed_logic logic;
969 struct sr_datafeed_packet packet;
972 model_state = devc->model_state;
973 samples = model_state->samples_per_frame;
975 if (data->len < samples * sizeof(uint8_t)) {
976 sr_err("Truncated waveform data packet received.");
980 logic.length = samples;
982 logic.data = data->data;
983 packet.type = SR_DF_LOGIC;
984 packet.payload = &logic;
985 sr_session_send(sdi, &packet);
987 g_array_remove_range(data, 0, samples * sizeof(uint8_t));
993 * Attempts to query sample data from the oscilloscope in order to send it
994 * to the session bus for further processing.
996 * @param fd The file descriptor used as the event source.
997 * @param revents The received events.
998 * @param cb_data Callback data, in this case our device instance.
1000 * @return TRUE in case of success or a recoverable error,
1001 * FALSE when a fatal error was encountered.
1003 SR_PRIV int dlm_data_receive(int fd, int revents, void *cb_data)
1005 struct sr_dev_inst *sdi;
1006 struct scope_state *model_state;
1007 struct dev_context *devc;
1008 struct sr_channel *ch;
1009 struct sr_datafeed_packet packet;
1010 int chunk_len, num_bytes;
1011 static GArray *data = NULL;
1016 if (!(sdi = cb_data))
1019 if (!(devc = sdi->priv))
1022 if (!(model_state = (struct scope_state*)devc->model_state))
1025 /* Are we waiting for a response from the device? */
1026 if (!devc->data_pending)
1029 /* Check if a new query response is coming our way. */
1031 if (sr_scpi_read_begin(sdi->conn) == SR_OK)
1032 /* The 16 here accounts for the header and EOL. */
1033 data = g_array_sized_new(FALSE, FALSE, sizeof(uint8_t),
1034 16 + model_state->samples_per_frame);
1039 /* Store incoming data. */
1040 chunk_len = sr_scpi_read_data(sdi->conn, devc->receive_buffer,
1041 RECEIVE_BUFFER_SIZE);
1042 if (chunk_len < 0) {
1043 sr_err("Error while reading data: %d", chunk_len);
1046 g_array_append_vals(data, devc->receive_buffer, chunk_len);
1048 /* Read the entire query response before processing. */
1049 if (!sr_scpi_read_complete(sdi->conn))
1052 /* We finished reading and are no longer waiting for data. */
1053 devc->data_pending = FALSE;
1055 /* Signal the beginning of a new frame if this is the first channel. */
1056 if (devc->current_channel == devc->enabled_channels) {
1057 packet.type = SR_DF_FRAME_BEGIN;
1058 sr_session_send(sdi, &packet);
1061 if (dlm_block_data_header_process(data, &num_bytes) != SR_OK) {
1062 sr_err("Encountered malformed block data header.");
1066 if (num_bytes == 0) {
1067 sr_warn("Zero-length waveform data packet received. " \
1068 "Live mode not supported yet, stopping " \
1069 "acquisition and retrying.");
1070 /* Don't care about return value here. */
1071 dlm_acquisition_stop(sdi->conn);
1072 g_array_free(data, TRUE);
1073 dlm_channel_data_request(sdi);
1077 ch = devc->current_channel->data;
1079 case SR_CHANNEL_ANALOG:
1080 if (dlm_analog_samples_send(data,
1081 &model_state->analog_states[ch->index],
1085 case SR_CHANNEL_LOGIC:
1086 if (dlm_digital_samples_send(data, sdi) != SR_OK)
1090 sr_err("Invalid channel type encountered.");
1094 g_array_free(data, TRUE);
1098 * Signal the end of this frame if this was the last enabled channel
1099 * and set the next enabled channel. Then, request its data.
1101 if (!devc->current_channel->next) {
1102 packet.type = SR_DF_FRAME_END;
1103 sr_session_send(sdi, &packet);
1104 devc->current_channel = devc->enabled_channels;
1107 * As of now we only support importing the current acquisition
1108 * data so we're going to stop at this point.
1110 sr_dev_acquisition_stop(sdi);
1113 devc->current_channel = devc->current_channel->next;
1115 if (dlm_channel_data_request(sdi) != SR_OK) {
1116 sr_err("Failed to request acquisition data.");
1124 g_array_free(data, TRUE);