[libsigrok.git] / src / hardware / demo / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
 * Copyright (C) 2011 Olivier Fauchon <olivier@aixmarseille.com>
 * Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
 * Copyright (C) 2015 Bartosz Golaszewski <bgolaszewski@baylibre.com>
 *
 * 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 2 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>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <libsigrok/libsigrok.h>
#include "libsigrok-internal.h"
#include "protocol.h"

#define ANALOG_SAMPLES_PER_PERIOD 20

static const uint8_t pattern_sigrok[] = {
	0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
	0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
	0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
	0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
	0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
	0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};

SR_PRIV void demo_generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
{
	double t, frequency;
	float value;
	unsigned int num_samples, i;
	int last_end;

	sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);

	num_samples = ANALOG_BUFSIZE / sizeof(float);

	switch (ag->pattern) {
	case PATTERN_SQUARE:
		value = ag->amplitude;
		last_end = 0;
		for (i = 0; i < num_samples; i++) {
			if (i % 5 == 0)
				value = -value;
			if (i % 10 == 0)
				last_end = i;
			ag->pattern_data[i] = value;
		}
		ag->num_samples = last_end;
		break;
	case PATTERN_SINE:
		frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;

		/* Make sure the number of samples we put out is an integer
		 * multiple of our period size */
		/* FIXME we actually need only one period. A ringbuffer would be
		 * useful here. */
		while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
			num_samples--;

		for (i = 0; i < num_samples; i++) {
			t = (double) i / (double) sample_rate;
			ag->pattern_data[i] = ag->amplitude *
						sin(2 * G_PI * frequency * t);
		}

		ag->num_samples = num_samples;
		break;
	case PATTERN_TRIANGLE:
		frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;

		while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
			num_samples--;

		for (i = 0; i < num_samples; i++) {
			t = (double) i / (double) sample_rate;
			ag->pattern_data[i] = (2 * ag->amplitude / G_PI) *
						asin(sin(2 * G_PI * frequency * t));
		}

		ag->num_samples = num_samples;
		break;
	case PATTERN_SAWTOOTH:
		frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;

		while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
			num_samples--;

		for (i = 0; i < num_samples; i++) {
			t = (double) i / (double) sample_rate;
			ag->pattern_data[i] = 2 * ag->amplitude *
						((t * frequency) - floor(0.5f + t * frequency));
		}

		ag->num_samples = num_samples;
		break;
	}
}

static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
{
	struct dev_context *devc;
	uint64_t i, j;
	uint8_t pat;

	devc = sdi->priv;

	switch (devc->logic_pattern) {
	case PATTERN_SIGROK:
		memset(devc->logic_data, 0x00, size);
		for (i = 0; i < size; i += devc->logic_unitsize) {
			for (j = 0; j < devc->logic_unitsize; j++) {
				pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
				devc->logic_data[i + j] = ~pat;
			}
			devc->step++;
		}
		break;
	case PATTERN_RANDOM:
		for (i = 0; i < size; i++)
			devc->logic_data[i] = (uint8_t)(rand() & 0xff);
		break;
	case PATTERN_INC:
		for (i = 0; i < size; i++) {
			for (j = 0; j < devc->logic_unitsize; j++) {
				devc->logic_data[i + j] = devc->step;
			}
			devc->step++;
		}
		break;
	case PATTERN_ALL_LOW:
	case PATTERN_ALL_HIGH:
		/* These were set when the pattern mode was selected. */
		break;
	default:
		sr_err("Unknown pattern: %d.", devc->logic_pattern);
		break;
	}
}

static void send_analog_packet(struct analog_gen *ag,
		struct sr_dev_inst *sdi, uint64_t *analog_sent,
		uint64_t analog_pos, uint64_t analog_todo)
{
	struct sr_datafeed_packet packet;
	struct dev_context *devc;
	uint64_t sending_now, to_avg;
	int ag_pattern_pos;
	unsigned int i;

	devc = sdi->priv;
	packet.type = SR_DF_ANALOG;
	packet.payload = &ag->packet;

	if (!devc->avg) {
		ag_pattern_pos = analog_pos % ag->num_samples;
		sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
		ag->packet.data = ag->pattern_data + ag_pattern_pos;
		ag->packet.num_samples = sending_now;
		sr_session_send(sdi, &packet);

		/* Whichever channel group gets there first. */
		*analog_sent = MAX(*analog_sent, sending_now);
	} else {
		ag_pattern_pos = analog_pos % ag->num_samples;
		to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);

		for (i = 0; i < to_avg; i++) {
			ag->avg_val = (ag->avg_val +
					*(ag->pattern_data +
					  ag_pattern_pos + i)) / 2;
			ag->num_avgs++;
			/* Time to send averaged data? */
			if (devc->avg_samples > 0 &&
			    ag->num_avgs >= devc->avg_samples)
				goto do_send;
		}

		if (devc->avg_samples == 0) {
			/* We're averaging all the samples, so wait with
			 * sending until the very end.
			 */
			*analog_sent = ag->num_avgs;
			return;
		}

do_send:
		ag->packet.data = &ag->avg_val;
		ag->packet.num_samples = 1;

		sr_session_send(sdi, &packet);
		*analog_sent = ag->num_avgs;

		ag->num_avgs = 0;
		ag->avg_val = 0.0f;
	}
}

/* Callback handling data */
SR_PRIV int demo_prepare_data(int fd, int revents, void *cb_data)
{
	struct sr_dev_inst *sdi;
	struct dev_context *devc;
	struct sr_datafeed_packet packet;
	struct sr_datafeed_logic logic;
	struct analog_gen *ag;
	GHashTableIter iter;
	void *value;
	uint64_t samples_todo, logic_done, analog_done, analog_sent, sending_now;
	int64_t elapsed_us, limit_us, todo_us;

	(void)fd;
	(void)revents;

	sdi = cb_data;
	devc = sdi->priv;

	/* Just in case. */
	if (devc->cur_samplerate <= 0
			|| (devc->num_logic_channels <= 0
			&& devc->num_analog_channels <= 0)) {
		sdi->driver->dev_acquisition_stop(sdi);
		return G_SOURCE_CONTINUE;
	}

	/* What time span should we send samples for? */
	elapsed_us = g_get_monotonic_time() - devc->start_us;
	limit_us = 1000 * devc->limit_msec;
	if (limit_us > 0 && limit_us < elapsed_us)
		todo_us = MAX(0, limit_us - devc->spent_us);
	else
		todo_us = MAX(0, elapsed_us - devc->spent_us);

	/* How many samples are outstanding since the last round? */
	samples_todo = (todo_us * devc->cur_samplerate + G_USEC_PER_SEC - 1)
			/ G_USEC_PER_SEC;
	if (devc->limit_samples > 0) {
		if (devc->limit_samples < devc->sent_samples)
			samples_todo = 0;
		else if (devc->limit_samples - devc->sent_samples < samples_todo)
			samples_todo = devc->limit_samples - devc->sent_samples;
	}
	/* Calculate the actual time covered by this run back from the sample
	 * count, rounded towards zero. This avoids getting stuck on a too-low
	 * time delta with no samples being sent due to round-off.
	 */
	todo_us = samples_todo * G_USEC_PER_SEC / devc->cur_samplerate;

	logic_done  = devc->num_logic_channels  > 0 ? 0 : samples_todo;
	analog_done = devc->num_analog_channels > 0 ? 0 : samples_todo;

	while (logic_done < samples_todo || analog_done < samples_todo) {
		/* Logic */
		if (logic_done < samples_todo) {
			sending_now = MIN(samples_todo - logic_done,
					LOGIC_BUFSIZE / devc->logic_unitsize);
			logic_generator(sdi, sending_now * devc->logic_unitsize);
			packet.type = SR_DF_LOGIC;
			packet.payload = &logic;
			logic.length = sending_now * devc->logic_unitsize;
			logic.unitsize = devc->logic_unitsize;
			logic.data = devc->logic_data;
			sr_session_send(sdi, &packet);
			logic_done += sending_now;
		}

		/* Analog, one channel at a time */
		if (analog_done < samples_todo) {
			analog_sent = 0;

			g_hash_table_iter_init(&iter, devc->ch_ag);
			while (g_hash_table_iter_next(&iter, NULL, &value)) {
				send_analog_packet(value, sdi, &analog_sent,
						devc->sent_samples + analog_done,
						samples_todo - analog_done);
			}
			analog_done += analog_sent;
		}
	}
	/* At this point, both logic_done and analog_done should be
	 * exactly equal to samples_todo, or else.
	 */
	if (logic_done != samples_todo || analog_done != samples_todo) {
		sr_err("BUG: Sample count mismatch.");
		return G_SOURCE_REMOVE;
	}
	devc->sent_samples += samples_todo;
	devc->spent_us += todo_us;

	if ((devc->limit_samples > 0 && devc->sent_samples >= devc->limit_samples)
			|| (limit_us > 0 && devc->spent_us >= limit_us)) {

		/* If we're averaging everything - now is the time to send data */
		if (devc->avg_samples == 0) {
			g_hash_table_iter_init(&iter, devc->ch_ag);
			while (g_hash_table_iter_next(&iter, NULL, &value)) {
				ag = value;
				packet.type = SR_DF_ANALOG;
				packet.payload = &ag->packet;
				ag->packet.data = &ag->avg_val;
				ag->packet.num_samples = 1;
				sr_session_send(sdi, &packet);
			}
		}
		sr_dbg("Requested number of samples reached.");
		sdi->driver->dev_acquisition_stop(sdi);
	}

	return G_SOURCE_CONTINUE;
}
Commit	Line	Data
ba508e22 UH	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
	5	* Copyright (C) 2011 Olivier Fauchon <olivier@aixmarseille.com>
	6	* Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
	7	* Copyright (C) 2015 Bartosz Golaszewski <bgolaszewski@baylibre.com>
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
2ea1fdf1	20	* along with this program; if not, see <http://www.gnu.org/licenses/>.
ba508e22 UH	21	*/
	22
	23	#include <config.h>
	24	#include <stdlib.h>
	25	#include <string.h>
	26	#include <math.h>
	27	#include <libsigrok/libsigrok.h>
	28	#include "libsigrok-internal.h"
	29	#include "protocol.h"
	30
	31	#define ANALOG_SAMPLES_PER_PERIOD 20
	32
	33	static const uint8_t pattern_sigrok[] = {
	34	0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
	35	0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
	36	0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
	37	0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
	38	0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
	39	0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
	40	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	41	0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	42	};
	43
	44	SR_PRIV void demo_generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
	45	{
	46	double t, frequency;
	47	float value;
	48	unsigned int num_samples, i;
	49	int last_end;
	50
	51	sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
	52
	53	num_samples = ANALOG_BUFSIZE / sizeof(float);
	54
	55	switch (ag->pattern) {
	56	case PATTERN_SQUARE:
	57	value = ag->amplitude;
	58	last_end = 0;
	59	for (i = 0; i < num_samples; i++) {
	60	if (i % 5 == 0)
	61	value = -value;
	62	if (i % 10 == 0)
	63	last_end = i;
	64	ag->pattern_data[i] = value;
	65	}
	66	ag->num_samples = last_end;
	67	break;
	68	case PATTERN_SINE:
	69	frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
	70
	71	/* Make sure the number of samples we put out is an integer
	72	* multiple of our period size */
	73	/* FIXME we actually need only one period. A ringbuffer would be
	74	* useful here. */
	75	while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
	76	num_samples--;
	77
	78	for (i = 0; i < num_samples; i++) {
	79	t = (double) i / (double) sample_rate;
	80	ag->pattern_data[i] = ag->amplitude *
	81	sin(2 * G_PI * frequency * t);
	82	}
	83
	84	ag->num_samples = num_samples;
85	break;
86	case PATTERN_TRIANGLE:
87	frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
88
89	while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
90	num_samples--;
91
92	for (i = 0; i < num_samples; i++) {
93	t = (double) i / (double) sample_rate;
94	ag->pattern_data[i] = (2 * ag->amplitude / G_PI) *
95	asin(sin(2 * G_PI * frequency * t));
96	}
97
98	ag->num_samples = num_samples;
99	break;
100	case PATTERN_SAWTOOTH:
101	frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
102
103	while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
104	num_samples--;
105
106	for (i = 0; i < num_samples; i++) {
107	t = (double) i / (double) sample_rate;
108	ag->pattern_data[i] = 2 * ag->amplitude *
109	((t * frequency) - floor(0.5f + t * frequency));
110	}
111
112	ag->num_samples = num_samples;
113	break;
114	}
115	}
116
117	static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
118	{
119	struct dev_context *devc;
120	uint64_t i, j;
121	uint8_t pat;
122
123	devc = sdi->priv;
124
125	switch (devc->logic_pattern) {
126	case PATTERN_SIGROK:
127	memset(devc->logic_data, 0x00, size);
128	for (i = 0; i < size; i += devc->logic_unitsize) {
129	for (j = 0; j < devc->logic_unitsize; j++) {
130	pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
131	devc->logic_data[i + j] = ~pat;
132	}
133	devc->step++;
134	}
135	break;
136	case PATTERN_RANDOM:
137	for (i = 0; i < size; i++)
138	devc->logic_data[i] = (uint8_t)(rand() & 0xff);
139	break;
140	case PATTERN_INC:
141	for (i = 0; i < size; i++) {
142	for (j = 0; j < devc->logic_unitsize; j++) {
143	devc->logic_data[i + j] = devc->step;
144	}
145	devc->step++;
146	}
147	break;
148	case PATTERN_ALL_LOW:
149	case PATTERN_ALL_HIGH:
150	/* These were set when the pattern mode was selected. */
151	break;
152	default:
153	sr_err("Unknown pattern: %d.", devc->logic_pattern);
154	break;
155	}
156	}
157
158	static void send_analog_packet(struct analog_gen *ag,
159	struct sr_dev_inst sdi, uint64_t analog_sent,
160	uint64_t analog_pos, uint64_t analog_todo)
161	{
162	struct sr_datafeed_packet packet;
163	struct dev_context *devc;
164	uint64_t sending_now, to_avg;
165	int ag_pattern_pos;
166	unsigned int i;
167
168	devc = sdi->priv;
169	packet.type = SR_DF_ANALOG;
170	packet.payload = &ag->packet;
171
172	if (!devc->avg) {
173	ag_pattern_pos = analog_pos % ag->num_samples;
174	sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
175	ag->packet.data = ag->pattern_data + ag_pattern_pos;
176	ag->packet.num_samples = sending_now;
177	sr_session_send(sdi, &packet);
178
179	/* Whichever channel group gets there first. */
180	analog_sent = MAX(analog_sent, sending_now);
181	} else {
182	ag_pattern_pos = analog_pos % ag->num_samples;
183	to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
184
185	for (i = 0; i < to_avg; i++) {
186	ag->avg_val = (ag->avg_val +
187	*(ag->pattern_data +
188	ag_pattern_pos + i)) / 2;
189	ag->num_avgs++;
190	/* Time to send averaged data? */
191	if (devc->avg_samples > 0 &&
192	ag->num_avgs >= devc->avg_samples)
193	goto do_send;
194	}
195
196	if (devc->avg_samples == 0) {
197	/* We're averaging all the samples, so wait with
198	* sending until the very end.
199	*/
200	*analog_sent = ag->num_avgs;
201	return;
202	}
203
204	do_send:
205	ag->packet.data = &ag->avg_val;
206	ag->packet.num_samples = 1;
207
208	sr_session_send(sdi, &packet);
209	*analog_sent = ag->num_avgs;
210
211	ag->num_avgs = 0;
212	ag->avg_val = 0.0f;
213	}
214	}
215
216	/* Callback handling data */
217	SR_PRIV int demo_prepare_data(int fd, int revents, void *cb_data)
218	{
219	struct sr_dev_inst *sdi;
220	struct dev_context *devc;
221	struct sr_datafeed_packet packet;
222	struct sr_datafeed_logic logic;
223	struct analog_gen *ag;
224	GHashTableIter iter;
225	void *value;
226	uint64_t samples_todo, logic_done, analog_done, analog_sent, sending_now;
227	int64_t elapsed_us, limit_us, todo_us;
228
229	(void)fd;
230	(void)revents;
231
232	sdi = cb_data;
233	devc = sdi->priv;
234
235	/* Just in case. */
236	if (devc->cur_samplerate <= 0
237	\|\| (devc->num_logic_channels <= 0
238	&& devc->num_analog_channels <= 0)) {
239	sdi->driver->dev_acquisition_stop(sdi);
240	return G_SOURCE_CONTINUE;
241	}
242
243	/* What time span should we send samples for? */
244	elapsed_us = g_get_monotonic_time() - devc->start_us;
245	limit_us = 1000 * devc->limit_msec;
246	if (limit_us > 0 && limit_us < elapsed_us)
247	todo_us = MAX(0, limit_us - devc->spent_us);
248	else
249	todo_us = MAX(0, elapsed_us - devc->spent_us);
250
251	/* How many samples are outstanding since the last round? */
252	samples_todo = (todo_us * devc->cur_samplerate + G_USEC_PER_SEC - 1)
253	/ G_USEC_PER_SEC;
254	if (devc->limit_samples > 0) {
255	if (devc->limit_samples < devc->sent_samples)
256	samples_todo = 0;
257	else if (devc->limit_samples - devc->sent_samples < samples_todo)
258	samples_todo = devc->limit_samples - devc->sent_samples;
259	}
260	/* Calculate the actual time covered by this run back from the sample
261	* count, rounded towards zero. This avoids getting stuck on a too-low
262	* time delta with no samples being sent due to round-off.
263	*/
264	todo_us = samples_todo * G_USEC_PER_SEC / devc->cur_samplerate;
265
266	logic_done = devc->num_logic_channels > 0 ? 0 : samples_todo;
267	analog_done = devc->num_analog_channels > 0 ? 0 : samples_todo;
268
269	while (logic_done < samples_todo \|\| analog_done < samples_todo) {
270	/* Logic */
271	if (logic_done < samples_todo) {
272	sending_now = MIN(samples_todo - logic_done,
273	LOGIC_BUFSIZE / devc->logic_unitsize);
274	logic_generator(sdi, sending_now * devc->logic_unitsize);
275	packet.type = SR_DF_LOGIC;
276	packet.payload = &logic;
277	logic.length = sending_now * devc->logic_unitsize;
278	logic.unitsize = devc->logic_unitsize;
279	logic.data = devc->logic_data;
280	sr_session_send(sdi, &packet);
281	logic_done += sending_now;
282	}
283
284	/* Analog, one channel at a time */
285	if (analog_done < samples_todo) {
286	analog_sent = 0;
287
288	g_hash_table_iter_init(&iter, devc->ch_ag);
289	while (g_hash_table_iter_next(&iter, NULL, &value)) {
290	send_analog_packet(value, sdi, &analog_sent,
291	devc->sent_samples + analog_done,
292	samples_todo - analog_done);
293	}
294	analog_done += analog_sent;
295	}
296	}
297	/* At this point, both logic_done and analog_done should be
298	* exactly equal to samples_todo, or else.
299	*/
300	if (logic_done != samples_todo \|\| analog_done != samples_todo) {
301	sr_err("BUG: Sample count mismatch.");
302	return G_SOURCE_REMOVE;
303	}
304	devc->sent_samples += samples_todo;
305	devc->spent_us += todo_us;
306
307	if ((devc->limit_samples > 0 && devc->sent_samples >= devc->limit_samples)
308	\|\| (limit_us > 0 && devc->spent_us >= limit_us)) {
309
310	/* If we're averaging everything - now is the time to send data */
311	if (devc->avg_samples == 0) {
312	g_hash_table_iter_init(&iter, devc->ch_ag);
313	while (g_hash_table_iter_next(&iter, NULL, &value)) {
314	ag = value;
315	packet.type = SR_DF_ANALOG;
316	packet.payload = &ag->packet;
317	ag->packet.data = &ag->avg_val;
318	ag->packet.num_samples = 1;
319	sr_session_send(sdi, &packet);
320	}
321	}
322	sr_dbg("Requested number of samples reached.");
323	sdi->driver->dev_acquisition_stop(sdi);
324	}
325
326	return G_SOURCE_CONTINUE;
327	}