2 * This file is part of the libsigrok project.
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>
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.
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.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
31 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
33 #include "libsigrok.h"
34 #include "libsigrok-internal.h"
36 #define LOG_PREFIX "demo"
38 #define DEFAULT_NUM_LOGIC_CHANNELS 8
39 #define DEFAULT_NUM_ANALOG_CHANNELS 4
41 /* The size in bytes of chunks to send through the session bus. */
42 #define LOGIC_BUFSIZE 4096
43 /* Size of the analog pattern space per channel. */
44 #define ANALOG_BUFSIZE 4096
46 #define DEFAULT_ANALOG_AMPLITUDE 25
47 #define ANALOG_SAMPLES_PER_PERIOD 20
49 /* Logic patterns we can generate. */
52 * Spells "sigrok" across 8 channels using '0's (with '1's as
53 * "background") when displayed using the 'bits' output format.
54 * The pattern is repeated every 8 channels, shifted to the right
59 /** Pseudo-random values on all channels. */
63 * Incrementing number across 8 channels. The pattern is repeated
64 * every 8 channels, shifted to the right in time by one bit.
68 /** All channels have a low logic state. */
71 /** All channels have a high logic state. */
75 /* Analog patterns we can generate. */
86 static const char *logic_pattern_str[] = {
94 static const char *analog_pattern_str[] = {
104 float pattern_data[ANALOG_BUFSIZE];
105 unsigned int num_samples;
106 struct sr_datafeed_analog packet;
107 float avg_val; /* Average value */
108 unsigned num_avgs; /* Number of samples averaged */
111 /* Private, per-device-instance driver context. */
115 uint64_t cur_samplerate;
117 uint64_t limit_samples;
119 uint64_t logic_counter;
120 uint64_t analog_counter;
124 int32_t num_logic_channels;
125 unsigned int logic_unitsize;
126 /* There is only ever one logic channel group, so its pattern goes here. */
127 uint8_t logic_pattern;
128 unsigned char logic_data[LOGIC_BUFSIZE];
130 int32_t num_analog_channels;
132 gboolean avg; /* True if averaging is enabled */
133 uint64_t avg_samples;
136 static const uint32_t drvopts[] = {
138 SR_CONF_LOGIC_ANALYZER,
139 SR_CONF_OSCILLOSCOPE,
142 static const uint32_t scanopts[] = {
143 SR_CONF_NUM_LOGIC_CHANNELS,
144 SR_CONF_NUM_ANALOG_CHANNELS,
147 static const uint32_t devopts[] = {
148 SR_CONF_CONTINUOUS | SR_CONF_SET,
149 SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
150 SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
151 SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
152 SR_CONF_AVERAGING | SR_CONF_GET | SR_CONF_SET,
153 SR_CONF_AVG_SAMPLES | SR_CONF_GET | SR_CONF_SET,
156 static const uint32_t devopts_cg_logic[] = {
157 SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
160 static const uint32_t devopts_cg_analog[] = {
161 SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
162 SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
165 static const uint64_t samplerates[] = {
171 static const uint8_t pattern_sigrok[] = {
172 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
173 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
174 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
175 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
176 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
177 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
178 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
179 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
182 SR_PRIV struct sr_dev_driver demo_driver_info;
184 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
186 static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
188 return std_init(sr_ctx, di, LOG_PREFIX);
191 static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
195 unsigned int num_samples, i;
198 sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
200 num_samples = ANALOG_BUFSIZE / sizeof(float);
202 switch (ag->pattern) {
204 value = ag->amplitude;
206 for (i = 0; i < num_samples; i++) {
211 ag->pattern_data[i] = value;
213 ag->num_samples = last_end;
217 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
219 /* Make sure the number of samples we put out is an integer
220 * multiple of our period size */
221 /* FIXME we actually need only one period. A ringbuffer would be
223 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
226 for (i = 0; i < num_samples; i++) {
227 t = (double) i / (double) sample_rate;
228 ag->pattern_data[i] = ag->amplitude *
229 sin(2 * M_PI * frequency * t);
232 ag->num_samples = num_samples;
235 case PATTERN_TRIANGLE:
236 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
238 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
241 for (i = 0; i < num_samples; i++) {
242 t = (double) i / (double) sample_rate;
243 ag->pattern_data[i] = (2 * ag->amplitude / M_PI) *
244 asin(sin(2 * M_PI * frequency * t));
247 ag->num_samples = num_samples;
250 case PATTERN_SAWTOOTH:
251 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
253 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
256 for (i = 0; i < num_samples; i++) {
257 t = (double) i / (double) sample_rate;
258 ag->pattern_data[i] = 2 * ag->amplitude *
259 ((t * frequency) - floor(0.5f + t * frequency));
262 ag->num_samples = num_samples;
267 static GSList *scan(struct sr_dev_driver *di, GSList *options)
269 struct drv_context *drvc;
270 struct dev_context *devc;
271 struct sr_dev_inst *sdi;
272 struct sr_channel *ch;
273 struct sr_channel_group *cg, *acg;
274 struct sr_config *src;
275 struct analog_gen *ag;
277 int num_logic_channels, num_analog_channels, pattern, i;
278 char channel_name[16];
282 num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
283 num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
284 for (l = options; l; l = l->next) {
287 case SR_CONF_NUM_LOGIC_CHANNELS:
288 num_logic_channels = g_variant_get_int32(src->data);
290 case SR_CONF_NUM_ANALOG_CHANNELS:
291 num_analog_channels = g_variant_get_int32(src->data);
298 sdi = g_malloc0(sizeof(struct sr_dev_inst));
299 sdi->status = SR_ST_ACTIVE;
300 sdi->model = g_strdup("Demo device");
303 devc = g_malloc(sizeof(struct dev_context));
304 devc->cur_samplerate = SR_KHZ(200);
305 devc->limit_samples = 0;
306 devc->limit_msec = 0;
308 devc->continuous = FALSE;
309 devc->num_logic_channels = num_logic_channels;
310 devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
311 devc->logic_pattern = PATTERN_SIGROK;
312 devc->num_analog_channels = num_analog_channels;
314 devc->avg_samples = 0;
316 /* Logic channels, all in one channel group. */
317 cg = g_malloc0(sizeof(struct sr_channel_group));
318 cg->name = g_strdup("Logic");
319 for (i = 0; i < num_logic_channels; i++) {
320 sprintf(channel_name, "D%d", i);
321 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
322 cg->channels = g_slist_append(cg->channels, ch);
324 sdi->channel_groups = g_slist_append(NULL, cg);
326 /* Analog channels, channel groups and pattern generators. */
328 /* An "Analog" channel group with all analog channels in it. */
329 acg = g_malloc0(sizeof(struct sr_channel_group));
330 acg->name = g_strdup("Analog");
331 sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
333 devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
334 for (i = 0; i < num_analog_channels; i++) {
335 snprintf(channel_name, 16, "A%d", i);
336 ch = sr_channel_new(sdi, i + num_logic_channels, SR_CHANNEL_ANALOG,
338 acg->channels = g_slist_append(acg->channels, ch);
340 /* Every analog channel gets its own channel group as well. */
341 cg = g_malloc0(sizeof(struct sr_channel_group));
342 cg->name = g_strdup(channel_name);
343 cg->channels = g_slist_append(NULL, ch);
344 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
346 /* Every channel gets a generator struct. */
347 ag = g_malloc(sizeof(struct analog_gen));
348 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
349 ag->packet.channels = cg->channels;
351 ag->packet.mqflags = 0;
352 ag->packet.unit = SR_UNIT_VOLT;
353 ag->packet.data = ag->pattern_data;
354 ag->pattern = pattern;
357 g_hash_table_insert(devc->ch_ag, ch, ag);
359 if (++pattern == ARRAY_SIZE(analog_pattern_str))
364 devices = g_slist_append(devices, sdi);
365 drvc->instances = g_slist_append(drvc->instances, sdi);
370 static GSList *dev_list(const struct sr_dev_driver *di)
372 return ((struct drv_context *)(di->priv))->instances;
375 static int dev_open(struct sr_dev_inst *sdi)
377 sdi->status = SR_ST_ACTIVE;
382 static int dev_close(struct sr_dev_inst *sdi)
384 sdi->status = SR_ST_INACTIVE;
389 static void clear_helper(void *priv)
391 struct dev_context *devc;
397 /* Analog generators. */
398 g_hash_table_iter_init(&iter, devc->ch_ag);
399 while (g_hash_table_iter_next(&iter, NULL, &value))
401 g_hash_table_unref(devc->ch_ag);
405 static int cleanup(const struct sr_dev_driver *di)
407 return std_dev_clear(di, clear_helper);
410 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
411 const struct sr_channel_group *cg)
413 struct dev_context *devc;
414 struct sr_channel *ch;
415 struct analog_gen *ag;
423 case SR_CONF_SAMPLERATE:
424 *data = g_variant_new_uint64(devc->cur_samplerate);
426 case SR_CONF_LIMIT_SAMPLES:
427 *data = g_variant_new_uint64(devc->limit_samples);
429 case SR_CONF_LIMIT_MSEC:
430 *data = g_variant_new_uint64(devc->limit_msec);
432 case SR_CONF_AVERAGING:
433 *data = g_variant_new_boolean(devc->avg);
435 case SR_CONF_AVG_SAMPLES:
436 *data = g_variant_new_uint64(devc->avg_samples);
438 case SR_CONF_PATTERN_MODE:
440 return SR_ERR_CHANNEL_GROUP;
441 /* Any channel in the group will do. */
442 ch = cg->channels->data;
443 if (ch->type == SR_CHANNEL_LOGIC) {
444 pattern = devc->logic_pattern;
445 *data = g_variant_new_string(logic_pattern_str[pattern]);
446 } else if (ch->type == SR_CHANNEL_ANALOG) {
447 ag = g_hash_table_lookup(devc->ch_ag, ch);
448 pattern = ag->pattern;
449 *data = g_variant_new_string(analog_pattern_str[pattern]);
453 case SR_CONF_AMPLITUDE:
455 return SR_ERR_CHANNEL_GROUP;
456 /* Any channel in the group will do. */
457 ch = cg->channels->data;
458 if (ch->type != SR_CHANNEL_ANALOG)
460 ag = g_hash_table_lookup(devc->ch_ag, ch);
461 *data = g_variant_new_double(ag->amplitude);
470 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
471 const struct sr_channel_group *cg)
473 struct dev_context *devc;
474 struct analog_gen *ag;
475 struct sr_channel *ch;
477 int logic_pattern, analog_pattern, ret;
483 if (sdi->status != SR_ST_ACTIVE)
484 return SR_ERR_DEV_CLOSED;
488 case SR_CONF_SAMPLERATE:
489 devc->cur_samplerate = g_variant_get_uint64(data);
491 case SR_CONF_LIMIT_SAMPLES:
492 devc->limit_msec = 0;
493 devc->limit_samples = g_variant_get_uint64(data);
495 case SR_CONF_LIMIT_MSEC:
496 devc->limit_msec = g_variant_get_uint64(data);
497 devc->limit_samples = 0;
499 case SR_CONF_AVERAGING:
500 devc->avg = g_variant_get_boolean(data);
501 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
503 case SR_CONF_AVG_SAMPLES:
504 devc->avg_samples = g_variant_get_uint64(data);
505 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
507 case SR_CONF_PATTERN_MODE:
509 return SR_ERR_CHANNEL_GROUP;
510 stropt = g_variant_get_string(data, NULL);
511 logic_pattern = analog_pattern = -1;
512 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
513 if (!strcmp(stropt, logic_pattern_str[i])) {
518 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
519 if (!strcmp(stropt, analog_pattern_str[i])) {
524 if (logic_pattern == -1 && analog_pattern == -1)
526 for (l = cg->channels; l; l = l->next) {
528 if (ch->type == SR_CHANNEL_LOGIC) {
529 if (logic_pattern == -1)
531 sr_dbg("Setting logic pattern to %s",
532 logic_pattern_str[logic_pattern]);
533 devc->logic_pattern = logic_pattern;
534 /* Might as well do this now, these are static. */
535 if (logic_pattern == PATTERN_ALL_LOW)
536 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
537 else if (logic_pattern == PATTERN_ALL_HIGH)
538 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
539 } else if (ch->type == SR_CHANNEL_ANALOG) {
540 if (analog_pattern == -1)
542 sr_dbg("Setting analog pattern for channel %s to %s",
543 ch->name, analog_pattern_str[analog_pattern]);
544 ag = g_hash_table_lookup(devc->ch_ag, ch);
545 ag->pattern = analog_pattern;
550 case SR_CONF_AMPLITUDE:
552 return SR_ERR_CHANNEL_GROUP;
553 for (l = cg->channels; l; l = l->next) {
555 if (ch->type != SR_CHANNEL_ANALOG)
557 ag = g_hash_table_lookup(devc->ch_ag, ch);
558 ag->amplitude = g_variant_get_double(data);
568 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
569 const struct sr_channel_group *cg)
571 struct sr_channel *ch;
575 if (key == SR_CONF_SCAN_OPTIONS) {
576 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
577 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
581 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
582 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
583 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
592 case SR_CONF_DEVICE_OPTIONS:
593 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
594 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
596 case SR_CONF_SAMPLERATE:
597 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
598 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
599 ARRAY_SIZE(samplerates), sizeof(uint64_t));
600 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
601 *data = g_variant_builder_end(&gvb);
607 /* Any channel in the group will do. */
608 ch = cg->channels->data;
610 case SR_CONF_DEVICE_OPTIONS:
611 if (ch->type == SR_CHANNEL_LOGIC)
612 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
613 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
615 else if (ch->type == SR_CHANNEL_ANALOG)
616 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
617 devopts_cg_analog, ARRAY_SIZE(devopts_cg_analog),
622 case SR_CONF_PATTERN_MODE:
623 if (ch->type == SR_CHANNEL_LOGIC)
624 *data = g_variant_new_strv(logic_pattern_str,
625 ARRAY_SIZE(logic_pattern_str));
626 else if (ch->type == SR_CHANNEL_ANALOG)
627 *data = g_variant_new_strv(analog_pattern_str,
628 ARRAY_SIZE(analog_pattern_str));
640 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
642 struct dev_context *devc;
648 switch (devc->logic_pattern) {
650 memset(devc->logic_data, 0x00, size);
651 for (i = 0; i < size; i += devc->logic_unitsize) {
652 for (j = 0; j < devc->logic_unitsize; j++) {
653 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
654 devc->logic_data[i + j] = ~pat;
660 for (i = 0; i < size; i++)
661 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
664 for (i = 0; i < size; i++) {
665 for (j = 0; j < devc->logic_unitsize; j++) {
666 devc->logic_data[i + j] = devc->step;
671 case PATTERN_ALL_LOW:
672 case PATTERN_ALL_HIGH:
673 /* These were set when the pattern mode was selected. */
676 sr_err("Unknown pattern: %d.", devc->logic_pattern);
681 static void send_analog_packet(struct analog_gen *ag,
682 struct sr_dev_inst *sdi,
683 uint64_t *analog_sent,
684 uint64_t analog_todo)
686 struct sr_datafeed_packet packet;
687 struct dev_context *devc;
688 uint64_t sending_now, to_avg;
693 packet.type = SR_DF_ANALOG;
694 packet.payload = &ag->packet;
697 ag_pattern_pos = devc->analog_counter % ag->num_samples;
698 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
699 ag->packet.data = ag->pattern_data + ag_pattern_pos;
700 ag->packet.num_samples = sending_now;
701 sr_session_send(sdi, &packet);
703 /* Whichever channel group gets there first. */
704 *analog_sent = MAX(*analog_sent, sending_now);
706 ag_pattern_pos = devc->analog_counter % ag->num_samples;
707 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
709 for (i = 0; i < to_avg; i++) {
710 ag->avg_val = (ag->avg_val +
712 ag_pattern_pos + i)) / 2;
714 /* Time to send averaged data? */
715 if (devc->avg_samples > 0 &&
716 ag->num_avgs >= devc->avg_samples)
720 if (devc->avg_samples == 0) {
721 /* We're averaging all the samples, so wait with
722 * sending until the very end.
724 *analog_sent = ag->num_avgs;
729 ag->packet.data = &ag->avg_val;
730 ag->packet.num_samples = 1;
732 sr_session_send(sdi, &packet);
733 *analog_sent = ag->num_avgs;
740 /* Callback handling data */
741 static int prepare_data(int fd, int revents, void *cb_data)
743 struct sr_dev_inst *sdi;
744 struct dev_context *devc;
745 struct sr_datafeed_packet packet;
746 struct sr_datafeed_logic logic;
747 struct analog_gen *ag;
750 uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
751 int64_t time, elapsed;
758 logic_todo = analog_todo = 0;
760 /* How many samples should we have sent by now? */
761 time = g_get_monotonic_time();
762 elapsed = time - devc->starttime;
763 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
765 /* But never more than the limit, if there is one. */
766 if (!devc->continuous)
767 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
769 /* Of those, how many do we still have to send? */
770 if (devc->num_logic_channels)
771 logic_todo = expected_samplenum - devc->logic_counter;
772 if (devc->num_analog_channels)
773 analog_todo = expected_samplenum - devc->analog_counter;
775 while (logic_todo || analog_todo) {
777 if (logic_todo > 0) {
778 sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
779 logic_generator(sdi, sending_now * devc->logic_unitsize);
780 packet.type = SR_DF_LOGIC;
781 packet.payload = &logic;
782 logic.length = sending_now * devc->logic_unitsize;
783 logic.unitsize = devc->logic_unitsize;
784 logic.data = devc->logic_data;
785 sr_session_send(sdi, &packet);
786 logic_todo -= sending_now;
787 devc->logic_counter += sending_now;
790 /* Analog, one channel at a time */
791 if (analog_todo > 0) {
794 g_hash_table_iter_init(&iter, devc->ch_ag);
795 while (g_hash_table_iter_next(&iter, NULL, &value)) {
796 send_analog_packet(value, sdi,
797 &analog_sent, analog_todo);
799 analog_todo -= analog_sent;
800 devc->analog_counter += analog_sent;
804 if (!devc->continuous
805 && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
806 && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
807 /* If we're averaging everything - now is the time to send data */
808 if (devc->avg_samples == 0) {
809 g_hash_table_iter_init(&iter, devc->ch_ag);
810 while (g_hash_table_iter_next(&iter, NULL, &value)) {
812 packet.type = SR_DF_ANALOG;
813 packet.payload = &ag->packet;
814 ag->packet.data = &ag->avg_val;
815 ag->packet.num_samples = 1;
816 sr_session_send(sdi, &packet);
820 sr_dbg("Requested number of samples reached.");
821 dev_acquisition_stop(sdi, cb_data);
828 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
830 struct dev_context *devc;
836 if (sdi->status != SR_ST_ACTIVE)
837 return SR_ERR_DEV_CLOSED;
840 devc->continuous = !devc->limit_samples;
841 devc->logic_counter = devc->analog_counter = 0;
844 * Setting two channels connected by a pipe is a remnant from when the
845 * demo driver generated data in a thread, and collected and sent the
846 * data in the main program loop.
847 * They are kept here because it provides a convenient way of setting
848 * up a timeout-based polling mechanism.
850 if (pipe(devc->pipe_fds)) {
851 sr_err("%s: pipe() failed", __func__);
855 g_hash_table_iter_init(&iter, devc->ch_ag);
856 while (g_hash_table_iter_next(&iter, NULL, &value))
857 generate_analog_pattern(value, devc->cur_samplerate);
859 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
860 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
862 /* Set channel encoding to binary (default is UTF-8). */
863 g_io_channel_set_encoding(devc->channel, NULL, NULL);
865 /* Make channels unbuffered. */
866 g_io_channel_set_buffered(devc->channel, FALSE);
868 sr_session_source_add_channel(sdi->session, devc->channel,
869 G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
871 /* Send header packet to the session bus. */
872 std_session_send_df_header(sdi, LOG_PREFIX);
874 /* We use this timestamp to decide how many more samples to send. */
875 devc->starttime = g_get_monotonic_time();
880 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
882 struct dev_context *devc;
883 struct sr_datafeed_packet packet;
888 sr_dbg("Stopping acquisition.");
890 sr_session_source_remove_channel(sdi->session, devc->channel);
891 g_io_channel_shutdown(devc->channel, FALSE, NULL);
892 g_io_channel_unref(devc->channel);
893 devc->channel = NULL;
895 /* Send last packet. */
896 packet.type = SR_DF_END;
897 sr_session_send(sdi, &packet);
902 SR_PRIV struct sr_dev_driver demo_driver_info = {
904 .longname = "Demo driver and pattern generator",
909 .dev_list = dev_list,
911 .config_get = config_get,
912 .config_set = config_set,
913 .config_list = config_list,
914 .dev_open = dev_open,
915 .dev_close = dev_close,
916 .dev_acquisition_start = dev_acquisition_start,
917 .dev_acquisition_stop = dev_acquisition_stop,