[libsigrok.git] / src / hardware / gwinstek-gds-800 / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2015 Martin Lederhilger <martin.lederhilger@gmx.at>
 *
 * 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 "protocol.h"
#include <math.h>
#include <string.h>

#define ANALOG_CHANNELS 2
#define VERTICAL_DIVISIONS 10

static int read_data(struct sr_dev_inst *sdi,
		struct sr_scpi_dev_inst *scpi, struct dev_context *devc,
		int data_size)
{
	int len;

	len = sr_scpi_read_data(scpi,
		&devc->rcv_buffer[devc->cur_rcv_buffer_position],
		data_size - devc->cur_rcv_buffer_position);
	if (len < 0) {
		sr_err("Read data error.");
		sr_dev_acquisition_stop(sdi);
		devc->cur_rcv_buffer_position = 0;
		return SR_ERR;
	}

	devc->cur_rcv_buffer_position += len;

	/* Handle the case where sr_scpi_read_data stopped at the newline. */
	if (len < data_size && sr_scpi_read_complete(scpi)) {
		devc->rcv_buffer[devc->cur_rcv_buffer_position] = '\n';
		devc->cur_rcv_buffer_position++;
	}

	if (devc->cur_rcv_buffer_position < data_size)
		return SR_ERR; /* Not finished yet. */
	else if (devc->cur_rcv_buffer_position == data_size) {
		 devc->cur_rcv_buffer_position = 0;
		return SR_OK;
	} else {
		sr_err("Too many bytes read.");
		sr_dev_acquisition_stop(sdi);
		devc->cur_rcv_buffer_position = 0;
		return SR_ERR;
	}
}

SR_PRIV int gwinstek_gds_800_receive_data(int fd, int revents, void *cb_data)
{
	struct sr_dev_inst *sdi;
	struct sr_scpi_dev_inst *scpi;
	struct dev_context *devc;
	struct sr_datafeed_packet packet;
	struct sr_datafeed_analog analog;
	struct sr_analog_encoding encoding;
	struct sr_analog_meaning meaning;
	struct sr_analog_spec spec;
	char command[32];
	char *response;
	float volts_per_division;
	int num_samples, i;
	float samples[MAX_SAMPLES];
	uint32_t sample_rate;
	char *end_ptr;

	(void)fd;

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

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

	scpi = sdi->conn;

	if (!(revents == G_IO_IN || revents == 0))
		return TRUE;

	switch (devc->state) {
	case START_ACQUISITION:
		if (sr_scpi_send(scpi, ":TRIG:MOD 3") != SR_OK) {
			sr_err("Failed to set trigger mode to SINGLE.");
			sr_dev_acquisition_stop(sdi);
			return TRUE;
		}
		if (sr_scpi_send(scpi, ":STOP") != SR_OK) {
			sr_err("Failed to put the trigger system into STOP state.");
			sr_dev_acquisition_stop(sdi);
			return TRUE;
		}
		if (sr_scpi_send(scpi, ":RUN") != SR_OK) {
			sr_err("Failed to put the trigger system into RUN state.");
			sr_dev_acquisition_stop(sdi);
			return TRUE;
		}

		devc->cur_acq_channel = 0;
		devc->state = START_TRANSFER_OF_CHANNEL_DATA;
		break;
	case START_TRANSFER_OF_CHANNEL_DATA:
		if (((struct sr_channel *)g_slist_nth_data(sdi->channels, devc->cur_acq_channel))->enabled) {
			if (sr_scpi_send(scpi, ":ACQ%d:MEM?", devc->cur_acq_channel+1) != SR_OK) {
				sr_err("Failed to acquire memory.");
				sr_dev_acquisition_stop(sdi);
				return TRUE;
			}
			if (sr_scpi_read_begin(scpi) != SR_OK) {
				sr_err("Could not begin reading SCPI response.");
				sr_dev_acquisition_stop(sdi);
				return TRUE;
			}
			devc->state = WAIT_FOR_TRANSFER_OF_BEGIN_TRANSMISSION_COMPLETE;
			devc->cur_rcv_buffer_position = 0;
		} else {
			/* All channels acquired. */
			if (devc->cur_acq_channel == ANALOG_CHANNELS - 1) {
				sr_spew("All channels acquired.");

				if (devc->cur_acq_frame == devc->frame_limit - 1) {
					/* All frames accquired. */
					sr_spew("All frames acquired.");

					sr_dev_acquisition_stop(sdi);
					return TRUE;
				} else {
					/* Start acquiring next frame. */
					if (devc->df_started) {
						packet.type = SR_DF_FRAME_END;
						sr_session_send(sdi, &packet);

						packet.type = SR_DF_FRAME_BEGIN;
						sr_session_send(sdi, &packet);
					}

					devc->cur_acq_frame++;
					devc->state = START_ACQUISITION;
				}
			} else {
				/* Start acquiring next channel. */
				devc->cur_acq_channel++;
			}
		}
		break;
	case WAIT_FOR_TRANSFER_OF_BEGIN_TRANSMISSION_COMPLETE:
		if (read_data(sdi, scpi, devc, 1) < 0)
			break;
		if (devc->rcv_buffer[0] == '#')
			devc->state = WAIT_FOR_TRANSFER_OF_DATA_SIZE_DIGIT_COMPLETE;
		break;
	case WAIT_FOR_TRANSFER_OF_DATA_SIZE_DIGIT_COMPLETE:
		if (read_data(sdi, scpi, devc, 1) < 0)
			break;
		if (devc->rcv_buffer[0] != '4' &&
			devc->rcv_buffer[0] != '5' &&
			devc->rcv_buffer[0] != '6') {
			sr_err("Data size digits is not 4, 5 or 6 but "
			       "'%c'.", devc->rcv_buffer[0]);
			sr_dev_acquisition_stop(sdi);
			return TRUE;
		} else {
			devc->data_size_digits = devc->rcv_buffer[0] - '0';
			devc->state = WAIT_FOR_TRANSFER_OF_DATA_SIZE_COMPLETE;
		}
		break;
	case WAIT_FOR_TRANSFER_OF_DATA_SIZE_COMPLETE:
		if (read_data(sdi, scpi, devc, devc->data_size_digits) < 0)
			break;
		devc->rcv_buffer[devc->data_size_digits] = 0;
		if (sr_atoi(devc->rcv_buffer, &devc->data_size) != SR_OK) {
			sr_err("Could not parse data size '%s'", devc->rcv_buffer);
			sr_dev_acquisition_stop(sdi);
			return TRUE;
		} else
			devc->state = WAIT_FOR_TRANSFER_OF_SAMPLE_RATE_COMPLETE;
		break;
	case WAIT_FOR_TRANSFER_OF_SAMPLE_RATE_COMPLETE:
		if (read_data(sdi, scpi, devc, sizeof(float)) < 0)
			break;
		/*
		 * Contrary to the documentation, this field is
		 * transfered with most significant byte first!
		 */
		sample_rate = RB32(devc->rcv_buffer);
		memcpy(&devc->sample_rate, &sample_rate, sizeof(float));
		devc->state = WAIT_FOR_TRANSFER_OF_CHANNEL_INDICATOR_COMPLETE;

		if (!devc->df_started) {
			std_session_send_df_header(sdi);

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

			devc->df_started = TRUE;
		}
		break;
	case WAIT_FOR_TRANSFER_OF_CHANNEL_INDICATOR_COMPLETE:
		if (read_data(sdi, scpi, devc, 1) == SR_OK)
			devc->state = WAIT_FOR_TRANSFER_OF_RESERVED_DATA_COMPLETE;
		break;
	case WAIT_FOR_TRANSFER_OF_RESERVED_DATA_COMPLETE:
		if (read_data(sdi, scpi, devc, 3) == SR_OK)
			devc->state = WAIT_FOR_TRANSFER_OF_CHANNEL_DATA_COMPLETE;
		break;
	case WAIT_FOR_TRANSFER_OF_CHANNEL_DATA_COMPLETE:
		if (read_data(sdi, scpi, devc, devc->data_size - 8) < 0)
			break;

		/* Fetch data needed for conversion from device. */
		snprintf(command, sizeof(command), ":CHAN%d:SCAL?",
				devc->cur_acq_channel + 1);
		if (sr_scpi_get_string(scpi, command, &response) != SR_OK) {
			sr_err("Failed to get volts per division.");
			sr_dev_acquisition_stop(sdi);
			return TRUE;
		}
		volts_per_division = g_ascii_strtod(response, &end_ptr);
		if (!strcmp(end_ptr, "mV"))
			volts_per_division *= 1.e-3;
		g_free(response);

		num_samples = (devc->data_size - 8) / 2;
		sr_spew("Received %d number of samples from channel "
			"%d.", num_samples, devc->cur_acq_channel + 1);

		float vbit = volts_per_division * VERTICAL_DIVISIONS / 256.0;
		float vbitlog = log10f(vbit);
		int digits = -(int)vbitlog + (vbitlog < 0.0);

		/* Convert data. */
		for (i = 0; i < num_samples; i++)
			samples[i] = ((float) ((int16_t) (RB16(&devc->rcv_buffer[i*2])))) * vbit;

		/* Fill frame. */
		sr_analog_init(&analog, &encoding, &meaning, &spec, digits);
		analog.meaning->channels = g_slist_append(NULL, g_slist_nth_data(sdi->channels, devc->cur_acq_channel));
		analog.num_samples = num_samples;
		analog.data = samples;
		analog.meaning->mq = SR_MQ_VOLTAGE;
		analog.meaning->unit = SR_UNIT_VOLT;
		analog.meaning->mqflags = 0;
		packet.type = SR_DF_ANALOG;
		packet.payload = &analog;
		sr_session_send(sdi, &packet);
		g_slist_free(analog.meaning->channels);

		/* All channels acquired. */
		if (devc->cur_acq_channel == ANALOG_CHANNELS - 1) {
			sr_spew("All channels acquired.");

			if (devc->cur_acq_frame == devc->frame_limit - 1) {
				/* All frames acquired. */
				sr_spew("All frames acquired.");
				sr_dev_acquisition_stop(sdi);
				return TRUE;
			} else {
				/* Start acquiring next frame. */
				if (devc->df_started) {
					packet.type = SR_DF_FRAME_END;
					sr_session_send(sdi, &packet);

					packet.type = SR_DF_FRAME_BEGIN;
					sr_session_send(sdi, &packet);
				}
				devc->cur_acq_frame++;
				devc->state = START_ACQUISITION;
			}
		} else {
			/* Start acquiring next channel. */
			devc->state = START_TRANSFER_OF_CHANNEL_DATA;
			devc->cur_acq_channel++;
			return TRUE;
		}
		break;
	}

	return TRUE;
}
Commit	Line	Data
7c198f96 ML	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2015 Martin Lederhilger <martin.lederhilger@gmx.at>
	5	*
	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.
	10	*
	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.
	15	*
	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/>.
	18	*/
	19
	20	#include "protocol.h"
6c1c13cd	21	#include <math.h>
b11afbb1 ML	22	#include <string.h>
	23
	24	#define ANALOG_CHANNELS 2
	25	#define VERTICAL_DIVISIONS 10
	26
695dc859	27	static int read_data(struct sr_dev_inst *sdi,
b11afbb1 ML	28	struct sr_scpi_dev_inst scpi, struct dev_context devc,
	29	int data_size)
	30	{
	31	int len;
	32
	33	len = sr_scpi_read_data(scpi,
	34	&devc->rcv_buffer[devc->cur_rcv_buffer_position],
	35	data_size - devc->cur_rcv_buffer_position);
	36	if (len < 0) {
	37	sr_err("Read data error.");
d2f7c417	38	sr_dev_acquisition_stop(sdi);
b11afbb1 ML	39	devc->cur_rcv_buffer_position = 0;
	40	return SR_ERR;
	41	}
	42
	43	devc->cur_rcv_buffer_position += len;
	44
	45	/* Handle the case where sr_scpi_read_data stopped at the newline. */
	46	if (len < data_size && sr_scpi_read_complete(scpi)) {
	47	devc->rcv_buffer[devc->cur_rcv_buffer_position] = '\n';
	48	devc->cur_rcv_buffer_position++;
	49	}
	50
	51	if (devc->cur_rcv_buffer_position < data_size)
	52	return SR_ERR; /* Not finished yet. */
	53	else if (devc->cur_rcv_buffer_position == data_size) {
	54	devc->cur_rcv_buffer_position = 0;
	55	return SR_OK;
	56	} else {
	57	sr_err("Too many bytes read.");
d2f7c417	58	sr_dev_acquisition_stop(sdi);
b11afbb1 ML	59	devc->cur_rcv_buffer_position = 0;
	60	return SR_ERR;
	61	}
	62	}
7c198f96 ML	63
	64	SR_PRIV int gwinstek_gds_800_receive_data(int fd, int revents, void *cb_data)
	65	{
b11afbb1 ML	66	struct sr_dev_inst *sdi;
b11afbb1 ML	67	struct sr_scpi_dev_inst *scpi;
7c198f96	68	struct dev_context *devc;
b11afbb1	69	struct sr_datafeed_packet packet;
6cfb9729 UH	70	struct sr_datafeed_analog analog;
	71	struct sr_analog_encoding encoding;
	72	struct sr_analog_meaning meaning;
	73	struct sr_analog_spec spec;
b11afbb1 ML	74	char command[32];
	75	char *response;
	76	float volts_per_division;
	77	int num_samples, i;
	78	float samples[MAX_SAMPLES];
	79	uint32_t sample_rate;
	80	char *end_ptr;
7c198f96 ML	81
	82	(void)fd;
	83
	84	if (!(sdi = cb_data))
	85	return TRUE;
	86
	87	if (!(devc = sdi->priv))
	88	return TRUE;
	89
b11afbb1 ML	90	scpi = sdi->conn;
	91
	92	if (!(revents == G_IO_IN \|\| revents == 0))
	93	return TRUE;
	94
	95	switch (devc->state) {
	96	case START_ACQUISITION:
	97	if (sr_scpi_send(scpi, ":TRIG:MOD 3") != SR_OK) {
	98	sr_err("Failed to set trigger mode to SINGLE.");
d2f7c417	99	sr_dev_acquisition_stop(sdi);
b11afbb1 ML	100	return TRUE;
	101	}
	102	if (sr_scpi_send(scpi, ":STOP") != SR_OK) {
	103	sr_err("Failed to put the trigger system into STOP state.");
d2f7c417	104	sr_dev_acquisition_stop(sdi);
b11afbb1 ML	105	return TRUE;
	106	}
	107	if (sr_scpi_send(scpi, ":RUN") != SR_OK) {
	108	sr_err("Failed to put the trigger system into RUN state.");
d2f7c417	109	sr_dev_acquisition_stop(sdi);
b11afbb1 ML	110	return TRUE;
	111	}
	112
	113	devc->cur_acq_channel = 0;
	114	devc->state = START_TRANSFER_OF_CHANNEL_DATA;
	115	break;
	116	case START_TRANSFER_OF_CHANNEL_DATA:
	117	if (((struct sr_channel *)g_slist_nth_data(sdi->channels, devc->cur_acq_channel))->enabled) {
	118	if (sr_scpi_send(scpi, ":ACQ%d:MEM?", devc->cur_acq_channel+1) != SR_OK) {
	119	sr_err("Failed to acquire memory.");
d2f7c417	120	sr_dev_acquisition_stop(sdi);
b11afbb1 ML	121	return TRUE;
	122	}
	123	if (sr_scpi_read_begin(scpi) != SR_OK) {
	124	sr_err("Could not begin reading SCPI response.");
d2f7c417	125	sr_dev_acquisition_stop(sdi);
b11afbb1 ML	126	return TRUE;
	127	}
	128	devc->state = WAIT_FOR_TRANSFER_OF_BEGIN_TRANSMISSION_COMPLETE;
	129	devc->cur_rcv_buffer_position = 0;
	130	} else {
	131	/* All channels acquired. */
	132	if (devc->cur_acq_channel == ANALOG_CHANNELS - 1) {
	133	sr_spew("All channels acquired.");
	134
	135	if (devc->cur_acq_frame == devc->frame_limit - 1) {
	136	/* All frames accquired. */
	137	sr_spew("All frames acquired.");
176d785d	138
d2f7c417	139	sr_dev_acquisition_stop(sdi);
b11afbb1 ML	140	return TRUE;
	141	} else {
	142	/* Start acquiring next frame. */
	143	if (devc->df_started) {
	144	packet.type = SR_DF_FRAME_END;
	145	sr_session_send(sdi, &packet);
176d785d	146
b11afbb1 ML	147	packet.type = SR_DF_FRAME_BEGIN;
	148	sr_session_send(sdi, &packet);
	149	}
	150
	151	devc->cur_acq_frame++;
	152	devc->state = START_ACQUISITION;
	153	}
	154	} else {
	155	/* Start acquiring next channel. */
	156	devc->cur_acq_channel++;
	157	}
	158	}
	159	break;
	160	case WAIT_FOR_TRANSFER_OF_BEGIN_TRANSMISSION_COMPLETE:
3782e571 UH	161	if (read_data(sdi, scpi, devc, 1) < 0)
	162	break;
	163	if (devc->rcv_buffer[0] == '#')
	164	devc->state = WAIT_FOR_TRANSFER_OF_DATA_SIZE_DIGIT_COMPLETE;
b11afbb1 ML	165	break;
b11afbb1 ML	166	case WAIT_FOR_TRANSFER_OF_DATA_SIZE_DIGIT_COMPLETE:
3782e571 UH	167	if (read_data(sdi, scpi, devc, 1) < 0)
	168	break;
	169	if (devc->rcv_buffer[0] != '4' &&
	170	devc->rcv_buffer[0] != '5' &&
	171	devc->rcv_buffer[0] != '6') {
	172	sr_err("Data size digits is not 4, 5 or 6 but "
	173	"'%c'.", devc->rcv_buffer[0]);
	174	sr_dev_acquisition_stop(sdi);
	175	return TRUE;
	176	} else {
	177	devc->data_size_digits = devc->rcv_buffer[0] - '0';
	178	devc->state = WAIT_FOR_TRANSFER_OF_DATA_SIZE_COMPLETE;
b11afbb1 ML	179	}
	180	break;
	181	case WAIT_FOR_TRANSFER_OF_DATA_SIZE_COMPLETE:
3782e571 UH	182	if (read_data(sdi, scpi, devc, devc->data_size_digits) < 0)
	183	break;
	184	devc->rcv_buffer[devc->data_size_digits] = 0;
	185	if (sr_atoi(devc->rcv_buffer, &devc->data_size) != SR_OK) {
	186	sr_err("Could not parse data size '%s'", devc->rcv_buffer);
	187	sr_dev_acquisition_stop(sdi);
	188	return TRUE;
	189	} else
	190	devc->state = WAIT_FOR_TRANSFER_OF_SAMPLE_RATE_COMPLETE;
b11afbb1 ML	191	break;
b11afbb1 ML	192	case WAIT_FOR_TRANSFER_OF_SAMPLE_RATE_COMPLETE:
3782e571 UH	193	if (read_data(sdi, scpi, devc, sizeof(float)) < 0)
	194	break;
	195	/*
	196	* Contrary to the documentation, this field is
	197	* transfered with most significant byte first!
	198	*/
	199	sample_rate = RB32(devc->rcv_buffer);
	200	memcpy(&devc->sample_rate, &sample_rate, sizeof(float));
	201	devc->state = WAIT_FOR_TRANSFER_OF_CHANNEL_INDICATOR_COMPLETE;
b11afbb1	202
3782e571 UH	203	if (!devc->df_started) {
3782e571 UH	204	std_session_send_df_header(sdi);
b11afbb1	205
3782e571 UH	206	packet.type = SR_DF_FRAME_BEGIN;
3782e571 UH	207	sr_session_send(sdi, &packet);
b11afbb1	208
3782e571	209	devc->df_started = TRUE;
b11afbb1 ML	210	}
	211	break;
	212	case WAIT_FOR_TRANSFER_OF_CHANNEL_INDICATOR_COMPLETE:
695dc859	213	if (read_data(sdi, scpi, devc, 1) == SR_OK)
b11afbb1 ML	214	devc->state = WAIT_FOR_TRANSFER_OF_RESERVED_DATA_COMPLETE;
	215	break;
	216	case WAIT_FOR_TRANSFER_OF_RESERVED_DATA_COMPLETE:
695dc859	217	if (read_data(sdi, scpi, devc, 3) == SR_OK)
b11afbb1 ML	218	devc->state = WAIT_FOR_TRANSFER_OF_CHANNEL_DATA_COMPLETE;
	219	break;
	220	case WAIT_FOR_TRANSFER_OF_CHANNEL_DATA_COMPLETE:
3782e571 UH	221	if (read_data(sdi, scpi, devc, devc->data_size - 8) < 0)
3782e571 UH	222	break;
b11afbb1	223
3782e571 UH	224	/* Fetch data needed for conversion from device. */
	225	snprintf(command, sizeof(command), ":CHAN%d:SCAL?",
	226	devc->cur_acq_channel + 1);
	227	if (sr_scpi_get_string(scpi, command, &response) != SR_OK) {
	228	sr_err("Failed to get volts per division.");
	229	sr_dev_acquisition_stop(sdi);
	230	return TRUE;
	231	}
	232	volts_per_division = g_ascii_strtod(response, &end_ptr);
	233	if (!strcmp(end_ptr, "mV"))
	234	volts_per_division *= 1.e-3;
	235	g_free(response);
b11afbb1	236
3782e571 UH	237	num_samples = (devc->data_size - 8) / 2;
	238	sr_spew("Received %d number of samples from channel "
	239	"%d.", num_samples, devc->cur_acq_channel + 1);
6c1c13cd	240
3782e571 UH	241	float vbit = volts_per_division * VERTICAL_DIVISIONS / 256.0;
	242	float vbitlog = log10f(vbit);
	243	int digits = -(int)vbitlog + (vbitlog < 0.0);
b11afbb1	244
3782e571 UH	245	/* Convert data. */
	246	for (i = 0; i < num_samples; i++)
	247	samples[i] = ((float) ((int16_t) (RB16(&devc->rcv_buffer[i2])))) vbit;
b11afbb1	248
3782e571 UH	249	/* Fill frame. */
	250	sr_analog_init(&analog, &encoding, &meaning, &spec, digits);
	251	analog.meaning->channels = g_slist_append(NULL, g_slist_nth_data(sdi->channels, devc->cur_acq_channel));
	252	analog.num_samples = num_samples;
	253	analog.data = samples;
	254	analog.meaning->mq = SR_MQ_VOLTAGE;
	255	analog.meaning->unit = SR_UNIT_VOLT;
	256	analog.meaning->mqflags = 0;
	257	packet.type = SR_DF_ANALOG;
	258	packet.payload = &analog;
	259	sr_session_send(sdi, &packet);
	260	g_slist_free(analog.meaning->channels);
b11afbb1	261
3782e571 UH	262	/* All channels acquired. */
	263	if (devc->cur_acq_channel == ANALOG_CHANNELS - 1) {
	264	sr_spew("All channels acquired.");
176d785d	265
3782e571 UH	266	if (devc->cur_acq_frame == devc->frame_limit - 1) {
	267	/* All frames acquired. */
	268	sr_spew("All frames acquired.");
	269	sr_dev_acquisition_stop(sdi);
b11afbb1	270	return TRUE;
3782e571 UH	271	} else {
	272	/* Start acquiring next frame. */
	273	if (devc->df_started) {
	274	packet.type = SR_DF_FRAME_END;
	275	sr_session_send(sdi, &packet);
	276
	277	packet.type = SR_DF_FRAME_BEGIN;
	278	sr_session_send(sdi, &packet);
	279	}
	280	devc->cur_acq_frame++;
	281	devc->state = START_ACQUISITION;
b11afbb1	282	}
3782e571 UH	283	} else {
	284	/* Start acquiring next channel. */
	285	devc->state = START_TRANSFER_OF_CHANNEL_DATA;
	286	devc->cur_acq_channel++;
	287	return TRUE;
b11afbb1 ML	288	}
b11afbb1 ML	289	break;
7c198f96 ML	290	}
	291
	292	return TRUE;
	293	}