protocol.c 17.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2017 Sven Schnelle <svens@stackframe.org>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
21 22 23
#include <math.h>
#include <stdlib.h>
#include "scpi.h"
24 25
#include "protocol.h"

26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
struct lecroy_wavedesc_2_x {
	uint16_t comm_type;
	uint16_t comm_order; /* 1 - little endian */
	uint32_t wave_descriptor_length;
	uint32_t user_text_len;
	uint32_t res_desc1;
	uint32_t trigtime_array_length;
	uint32_t ris_time1_array_length;
	uint32_t res_array1;
	uint32_t wave_array1_length;
	uint32_t wave_array2_length;
	uint32_t wave_array3_length;
	uint32_t wave_array4_length;
	char instrument_name[16];
	uint32_t instrument_number;
	char trace_label[16];
	uint32_t reserved;
	uint32_t wave_array_count;
	uint32_t points_per_screen;
	uint32_t first_valid_point;
	uint32_t last_valid_point;
	uint32_t first_point;
	uint32_t sparsing_factor;
	uint32_t segment_index;
	uint32_t subarray_count;
	uint32_t sweeps_per_acq;
	uint16_t points_per_pair;
	uint16_t pair_offset;
	float vertical_gain;
	float vertical_offset;
	float max_value;
	float min_value;
	uint16_t nominal_bits;
	uint16_t nom_subarray_count;
	float horiz_interval;
	double horiz_offset;
	double pixel_offset;
	char vertunit[48];
	char horunit[48];
	uint32_t reserved1;
	double trigger_time;
} __attribute__((packed));

struct lecroy_wavedesc {
	char descriptor_name[16];
	char template_name[16];
	union {
		struct lecroy_wavedesc_2_x version_2_x;
	};
} __attribute__((packed));

77
static const char *coupling_options[] = {
78 79 80
	"A1M", ///< AC with 1 MOhm termination
	"D50", ///< DC with 50 Ohm termination
	"D1M", ///< DC with 1 MOhm termination
81 82 83 84 85
	"GND",
	"OVL",
};

static const char *scope_trigger_slopes[] = {
86
	"POS", "NEG",
87 88
};

89
static const char *trigger_sources[] = {
90
	"C1", "C2", "C3", "C4", "LINE", "EXT",
91 92
};

93
static const uint64_t timebases[][2] = {
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
	/* picoseconds */
	{ 20, 1000000000000 },
	{ 50, 1000000000000 },
	{ 100, 1000000000000 },
	{ 200, 1000000000000 },
	{ 500, 1000000000000 },
	/* nanoseconds */
	{ 1, 1000000000 },
	{ 2, 1000000000 },
	{ 5, 1000000000 },
	{ 10, 1000000000 },
	{ 20, 1000000000 },
	{ 50, 1000000000 },
	{ 100, 1000000000 },
	{ 200, 1000000000 },
	{ 500, 1000000000 },
	/* microseconds */
	{ 1, 1000000 },
	{ 2, 1000000 },
	{ 5, 1000000 },
	{ 10, 1000000 },
	{ 20, 1000000 },
	{ 50, 1000000 },
	{ 100, 1000000 },
	{ 200, 1000000 },
	{ 500, 1000000 },
	/* milliseconds */
	{ 1, 1000 },
	{ 2, 1000 },
	{ 5, 1000 },
	{ 10, 1000 },
	{ 20, 1000 },
	{ 50, 1000 },
	{ 100, 1000 },
	{ 200, 1000 },
	{ 500, 1000 },
	/* seconds */
	{ 1, 1 },
	{ 2, 1 },
	{ 5, 1 },
	{ 10, 1 },
	{ 20, 1 },
	{ 50, 1 },
	{ 100, 1 },
	{ 200, 1 },
	{ 500, 1 },
	{ 1000, 1 },
};

143
static const uint64_t vdivs[][2] = {
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
	/* millivolts */
	{ 1, 1000 },
	{ 2, 1000 },
	{ 5, 1000 },
	{ 10, 1000 },
	{ 20, 1000 },
	{ 50, 1000 },
	{ 100, 1000 },
	{ 200, 1000 },
	{ 500, 1000 },
	/* volts */
	{ 1, 1 },
	{ 2, 1 },
	{ 5, 1 },
	{ 10, 1 },
	{ 20, 1 },
	{ 50, 1 },
};

static const char *scope_analog_channel_names[] = {
164
	"CH1", "CH2", "CH3", "CH4",
165 166 167 168
};

static const struct scope_config scope_models[] = {
	{
169 170
		 /* Default config */
		.name = {NULL},
171 172 173 174

		.analog_channels = 4,
		.analog_names = &scope_analog_channel_names,

175
		.coupling_options = &coupling_options,
176 177
		.num_coupling_options = ARRAY_SIZE(coupling_options),

178
		.trigger_sources = &trigger_sources,
179 180
		.num_trigger_sources = ARRAY_SIZE(trigger_sources),

181
		.trigger_slopes = &scope_trigger_slopes,
182
		.num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
183

184
		.timebases = &timebases,
185
		.num_timebases = ARRAY_SIZE(timebases),
186

187
		.vdivs = &vdivs,
188
		.num_vdivs = ARRAY_SIZE(vdivs),
189 190 191 192 193 194 195

		.num_xdivs = 10,
		.num_ydivs = 8,
	},
};

static void scope_state_dump(const struct scope_config *config,
196
		struct scope_state *state)
197 198 199 200 201
{
	unsigned int i;
	char *tmp;

	for (i = 0; i < config->analog_channels; i++) {
202
		tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
203
				(*config->vdivs)[state->analog_channels[i].vdiv][1]);
204
		sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
205 206 207
				i + 1, state->analog_channels[i].state ? "On" : "Off",
				(*config->coupling_options)[state->analog_channels[i].coupling],
				tmp, state->analog_channels[i].vertical_offset);
208 209
	}

210
	tmp = sr_period_string((*config->timebases)[state->timebase][0],
211
			(*config->timebases)[state->timebase][1]);
212 213 214 215 216 217 218 219
	sr_info("Current timebase: %s", tmp);
	g_free(tmp);

	tmp = sr_samplerate_string(state->sample_rate);
	sr_info("Current samplerate: %s", tmp);
	g_free(tmp);

	sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
220 221 222
			(*config->trigger_sources)[state->trigger_source],
			(*config->trigger_slopes)[state->trigger_slope],
			state->horiz_triggerpos);
223 224 225
}

static int scope_state_get_array_option(const char *resp,
226
		const char *(*array)[], unsigned int n, int *result)
227 228 229
{
	unsigned int i;

230
	for (i = 0; i < n; i++) {
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
		if (!g_strcmp0(resp, (*array)[i])) {
			*result = i;
			return SR_OK;
		}
	}

	return SR_ERR;
}

/**
 * This function takes a value of the form "2.000E-03" and returns the index
 * of an array where a matching pair was found.
 *
 * @param value The string to be parsed.
 * @param array The array of s/f pairs.
 * @param array_len The number of pairs in the array.
 * @param result The index at which a matching pair was found.
 *
 * @return SR_ERR on any parsing error, SR_OK otherwise.
 */
251
static int array_float_get(gchar *value, const uint64_t array[][2],
252 253 254
		int array_len, unsigned int *result)
{
	struct sr_rational rval;
255
	struct sr_rational aval;
256 257 258 259 260

	if (sr_parse_rational(value, &rval) != SR_OK)
		return SR_ERR;

	for (int i = 0; i < array_len; i++) {
261 262
		sr_rational_set(&aval, array[i][0], array[i][1]);
		if (sr_rational_eq(&rval, &aval)) {
263 264 265 266 267 268 269 270 271
			*result = i;
			return SR_OK;
		}
	}

	return SR_ERR;
}

static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi,
272
		const struct scope_config *config, struct scope_state *state)
273 274 275 276 277 278
{
	unsigned int i, j;
	char command[MAX_COMMAND_SIZE];
	char *tmp_str;

	for (i = 0; i < config->analog_channels; i++) {
279
		g_snprintf(command, sizeof(command), "C%d:TRACE?", i + 1);
280 281

		if (sr_scpi_get_bool(scpi, command,
282
				&state->analog_channels[i].state) != SR_OK)
283 284
			return SR_ERR;

285
		g_snprintf(command, sizeof(command), "C%d:VDIV?", i + 1);
286 287 288 289

		if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
			return SR_ERR;

290
		if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
291 292 293 294 295 296 297 298
			g_free(tmp_str);
			sr_err("Could not determine array index for vertical div scale.");
			return SR_ERR;
		}

		g_free(tmp_str);
		state->analog_channels[i].vdiv = j;

299
		g_snprintf(command, sizeof(command), "C%d:OFFSET?", i + 1);
300 301 302 303

		if (sr_scpi_get_float(scpi, command, &state->analog_channels[i].vertical_offset) != SR_OK)
			return SR_ERR;

304
		g_snprintf(command, sizeof(command), "C%d:COUPLING?", i + 1);
305 306 307 308 309 310

		if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
			return SR_ERR;


		if (scope_state_get_array_option(tmp_str, config->coupling_options,
311
				 config->num_coupling_options,
312
				 &state->analog_channels[i].coupling) != SR_OK)
313 314 315 316 317 318 319 320
			return SR_ERR;

		g_free(tmp_str);
	}

	return SR_OK;
}

321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
SR_PRIV int lecroy_xstream_channel_state_set(const struct sr_dev_inst *sdi,
		const int ch_index, gboolean ch_state)
{
	GSList *l;
	struct sr_channel *ch;
	struct dev_context *devc = NULL;
	struct scope_state *state;
	char command[MAX_COMMAND_SIZE];
	gboolean chan_found;
	int result;

	result = SR_OK;

	devc = sdi->priv;
	state = devc->model_state;
	chan_found = FALSE;

	for (l = sdi->channels; l; l = l->next) {
		ch = l->data;

		switch (ch->type) {
		case SR_CHANNEL_ANALOG:
			if (ch->index == ch_index) {
				g_snprintf(command, sizeof(command), "C%d:TRACE %s", ch_index + 1,
						(ch_state ? "ON" : "OFF"));
				if ((sr_scpi_send(sdi->conn, command) != SR_OK ||
						sr_scpi_get_opc(sdi->conn) != SR_OK)) {
					result = SR_ERR;
					break;
				}

				ch->enabled = ch_state;
				state->analog_channels[ch->index].state = ch_state;
				chan_found = TRUE;
				break;
			}
			break;
		default:
			result = SR_ERR_NA;
		}
	}

	if ((result == SR_OK) && !chan_found)
		result = SR_ERR_BUG;

	return result;
}

369
SR_PRIV int lecroy_xstream_update_sample_rate(const struct sr_dev_inst *sdi)
370 371
{
	struct dev_context *devc;
372 373 374 375 376 377 378 379 380
	struct scope_state *state;
	const struct scope_config *config;
	float memsize, timediv;

	devc = sdi->priv;
	state = devc->model_state;
	config = devc->model_config;

	if (sr_scpi_get_float(sdi->conn, "MEMORY_SIZE?", &memsize) != SR_OK)
381
		return SR_ERR;
382 383 384 385

	if (sr_scpi_get_float(sdi->conn, "TIME_DIV?", &timediv) != SR_OK)
		return SR_ERR;

386
	state->sample_rate = 1 / ((timediv * config->num_xdivs) / memsize);
387 388 389 390 391 392 393

	return SR_OK;
}

SR_PRIV int lecroy_xstream_state_get(struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
394 395
	struct scope_state *state;
	const struct scope_config *config;
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
	unsigned int i;
	char *tmp_str, *tmp_str2, *tmpp, *p, *key;
	char command[MAX_COMMAND_SIZE];
	char *trig_source = NULL;

	devc = sdi->priv;
	config = devc->model_config;
	state = devc->model_state;

	sr_info("Fetching scope state");

	if (analog_channel_state_get(sdi->conn, config, state) != SR_OK)
		return SR_ERR;

	if (sr_scpi_get_string(sdi->conn, "TIME_DIV?", &tmp_str) != SR_OK)
		return SR_ERR;

413
	if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
414 415 416 417 418 419 420 421 422 423
		g_free(tmp_str);
		sr_err("Could not determine array index for timbase scale.");
		return SR_ERR;
	}
	g_free(tmp_str);
	state->timebase = i;

	if (sr_scpi_get_string(sdi->conn, "TRIG_SELECT?", &tmp_str) != SR_OK)
		return SR_ERR;

424
	key = tmpp = NULL;
425 426
	tmp_str2 = tmp_str;
	i = 0;
427
	while ((p = strtok_r(tmp_str2, ",", &tmpp))) {
428 429 430 431 432 433 434 435 436 437 438 439 440
		tmp_str2 = NULL;
		if (i == 0) {
			/* trigger type */
		} else if (i & 1) {
			key = p;
			/* key */
		} else if (!(i & 1)) {
			if (!strcmp(key, "SR"))
				trig_source = p;
		}
		i++;
	}

441 442 443
	if (!trig_source || scope_state_get_array_option(trig_source,
			config->trigger_sources, config->num_trigger_sources,
			&state->trigger_source) != SR_OK)
444 445 446 447 448 449
		return SR_ERR;

	g_snprintf(command, sizeof(command), "%s:TRIG_SLOPE?", trig_source);
	if (sr_scpi_get_string(sdi->conn, command, &tmp_str) != SR_OK)
		return SR_ERR;

450 451
	if (scope_state_get_array_option(tmp_str, config->trigger_slopes,
			config->num_trigger_slopes, &state->trigger_slope) != SR_OK)
452 453
		return SR_ERR;

454
	if (sr_scpi_get_float(sdi->conn, "TRIG_DELAY?", &state->horiz_triggerpos) != SR_OK)
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
		return SR_ERR;

	if (lecroy_xstream_update_sample_rate(sdi) != SR_OK)
		return SR_ERR;

	sr_info("Fetching finished.");

	scope_state_dump(config, state);

	return SR_OK;
}

static struct scope_state *scope_state_new(const struct scope_config *config)
{
	struct scope_state *state;

	state = g_malloc0(sizeof(struct scope_state));
	state->analog_channels = g_malloc0_n(config->analog_channels,
			sizeof(struct analog_channel_state));
	return state;
}

SR_PRIV void lecroy_xstream_state_free(struct scope_state *state)
{
	g_free(state->analog_channels);
	g_free(state);
}

SR_PRIV int lecroy_xstream_init_device(struct sr_dev_inst *sdi)
{
	char command[MAX_COMMAND_SIZE];
	int model_index;
	unsigned int i, j;
	struct sr_channel *ch;
	struct dev_context *devc;
	gboolean channel_enabled;

	devc = sdi->priv;
	model_index = -1;

	/* Find the exact model. */
	for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
		for (j = 0; scope_models[i].name[j]; j++) {
			if (!strcmp(sdi->model, scope_models[i].name[j])) {
				model_index = i;
				break;
			}
		}
		if (model_index != -1)
			break;
	}

	if (model_index == -1) {
508 509 510 511
		sr_dbg("Unknown LeCroy device, using default config.");
		for (i = 0; i < ARRAY_SIZE(scope_models); i++)
			if (scope_models[i].name[0] == NULL)
				model_index = i;
512 513
	}

514 515
	/* Set the desired response and format modes. */
	sr_scpi_send(sdi->conn, "COMM_HEADER OFF");
516
	sr_scpi_send(sdi->conn, "COMM_FORMAT DEF9,WORD,BIN");
517

518
	devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
519
				scope_models[model_index].analog_channels);
520 521 522

	/* Add analog channels. */
	for (i = 0; i < scope_models[model_index].analog_channels; i++) {
523
		g_snprintf(command, sizeof(command), "C%d:TRACE?", i + 1);
524 525 526 527

		if (sr_scpi_get_bool(sdi->conn, command, &channel_enabled) != SR_OK)
			return SR_ERR;

528
		g_snprintf(command, sizeof(command), "C%d:VDIV?", i + 1);
529 530

		ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, channel_enabled,
531
			(*scope_models[model_index].analog_names)[i]);
532 533 534 535 536 537 538 539

		devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));

		devc->analog_groups[i]->name = g_strdup(
			(char *)(*scope_models[model_index].analog_names)[i]);
		devc->analog_groups[i]->channels = g_slist_append(NULL, ch);

		sdi->channel_groups = g_slist_append(sdi->channel_groups,
540
			devc->analog_groups[i]);
541 542 543 544
	}

	devc->model_config = &scope_models[model_index];
	devc->frame_limit = 0;
545
	devc->model_state = scope_state_new(devc->model_config);
546 547 548 549 550

	return SR_OK;
}

static int lecroy_waveform_2_x_to_analog(GByteArray *data,
551
		struct lecroy_wavedesc *desc, struct sr_datafeed_analog *analog)
552 553 554 555 556 557 558 559
{
	struct sr_analog_encoding *encoding = analog->encoding;
	struct sr_analog_meaning *meaning = analog->meaning;
	struct sr_analog_spec *spec = analog->spec;
	float *data_float;
	int16_t *waveform_data;
	unsigned int i, num_samples;

560
	data_float = g_malloc(desc->version_2_x.wave_array_count * sizeof(float));
561 562
	num_samples = desc->version_2_x.wave_array_count;

563 564 565
	waveform_data = (int16_t*)(data->data +
		+ desc->version_2_x.wave_descriptor_length
		+ desc->version_2_x.user_text_len);
566

567
	for (i = 0; i < num_samples; i++)
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
		data_float[i] = (float)waveform_data[i]
			* desc->version_2_x.vertical_gain
			+ desc->version_2_x.vertical_offset;

	analog->data = data_float;
	analog->num_samples = num_samples;

	encoding->unitsize = sizeof(float);
	encoding->is_signed = TRUE;
	encoding->is_float = TRUE;
	encoding->is_bigendian = FALSE;
	encoding->scale.p = 1;
	encoding->scale.q = 1;
	encoding->offset.p = 0;
	encoding->offset.q = 1;

	encoding->digits = 6;
	encoding->is_digits_decimal = FALSE;

	if (strcmp(desc->version_2_x.vertunit, "A")) {
		meaning->mq = SR_MQ_CURRENT;
		meaning->unit = SR_UNIT_AMPERE;
	} else {
591
		/* Default to voltage. */
592 593 594 595 596 597
		meaning->mq = SR_MQ_VOLTAGE;
		meaning->unit = SR_UNIT_VOLT;
	}

	meaning->mqflags = 0;
	spec->spec_digits = 3;
598

599 600 601 602
	return SR_OK;
}

static int lecroy_waveform_to_analog(GByteArray *data,
603
		struct sr_datafeed_analog *analog)
604 605 606 607 608 609
{
	struct lecroy_wavedesc *desc;

	if (data->len < sizeof(struct lecroy_wavedesc))
		return SR_ERR;

610
	desc = (struct lecroy_wavedesc*)data->data;
611 612 613 614 615 616

	if (!strncmp(desc->template_name, "LECROY_2_2", 16) ||
	    !strncmp(desc->template_name, "LECROY_2_3", 16)) {
		return lecroy_waveform_2_x_to_analog(data, desc, analog);
	}

617
	sr_err("Waveformat template '%.16s' not supported.", desc->template_name);
618 619 620 621 622
	return SR_ERR;
}

SR_PRIV int lecroy_xstream_receive_data(int fd, int revents, void *cb_data)
{
623
	char command[MAX_COMMAND_SIZE];
624 625 626 627 628 629 630 631 632 633
	struct sr_channel *ch;
	struct sr_dev_inst *sdi;
	struct dev_context *devc;
	struct sr_datafeed_packet packet;
	GByteArray *data;
	struct sr_datafeed_analog analog;
	struct sr_analog_encoding encoding;
	struct sr_analog_meaning meaning;
	struct sr_analog_spec spec;
	char buf[8];
634

635
	(void)fd;
636 637 638
	(void)revents;

	data = NULL;
639 640 641 642 643 644 645

	if (!(sdi = cb_data))
		return TRUE;

	if (!(devc = sdi->priv))
		return TRUE;

646 647 648 649
	ch = devc->current_channel->data;

	if (ch->type != SR_CHANNEL_ANALOG)
		return SR_ERR;
650 651

	/* Pass on the received data of the channel(s). */
652
	if (sr_scpi_read_data(sdi->conn, buf, 4) != 4) {
653
		sr_err("Reading header failed, scope probably didn't send any data.");
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
		return TRUE;
	}

	if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
		if (data)
			g_byte_array_free(data, TRUE);
		return TRUE;
	}

	analog.encoding = &encoding;
	analog.meaning = &meaning;
	analog.spec = &spec;

	if (lecroy_waveform_to_analog(data, &analog) != SR_OK)
		return SR_ERR;

670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
	if (analog.num_samples == 0) {
		/* No data available, we have to acquire data first. */
		g_snprintf(command, sizeof(command), "ARM;WAIT;*OPC;C%d:WAVEFORM?", ch->index + 1);
		sr_scpi_send(sdi->conn, command);
		return TRUE;
	}

	/*
	 * Send "frame begin" packet upon reception of data for the
	 * first enabled channel.
	 */
	if (devc->current_channel == devc->enabled_channels) {
		packet.type = SR_DF_FRAME_BEGIN;
		sr_session_send(sdi, &packet);
	}

686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
	meaning.channels = g_slist_append(NULL, ch);
	packet.payload = &analog;
	packet.type = SR_DF_ANALOG;
	sr_session_send(sdi, &packet);

	g_byte_array_free(data, TRUE);
	data = NULL;

	g_slist_free(meaning.channels);
	g_free(analog.data);

	/*
	 * Advance to the next enabled channel. When data for all enabled
	 * channels was received, then flush potentially queued logic data,
	 * and send the "frame end" packet.
	 */
	if (devc->current_channel->next) {
		devc->current_channel = devc->current_channel->next;
		lecroy_xstream_request_data(sdi);
		return TRUE;
	}

	packet.type = SR_DF_FRAME_END;
	sr_session_send(sdi, &packet);

	/*
	 * End of frame was reached. Stop acquisition after the specified
	 * number of frames, or continue reception by starting over at
	 * the first enabled channel.
	 */
	if (++devc->num_frames == devc->frame_limit) {
717
		sr_dev_acquisition_stop(sdi);
718 719 720
	} else {
		devc->current_channel = devc->enabled_channels;
		lecroy_xstream_request_data(sdi);
721 722 723 724
	}

	return TRUE;
}