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 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);
187 static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
189 return std_init(sr_ctx, di, LOG_PREFIX);
192 static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
196 unsigned int num_samples, i;
199 sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
201 num_samples = ANALOG_BUFSIZE / sizeof(float);
203 switch (ag->pattern) {
205 value = ag->amplitude;
207 for (i = 0; i < num_samples; i++) {
212 ag->pattern_data[i] = value;
214 ag->num_samples = last_end;
218 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
220 /* Make sure the number of samples we put out is an integer
221 * multiple of our period size */
222 /* FIXME we actually need only one period. A ringbuffer would be
224 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
227 for (i = 0; i < num_samples; i++) {
228 t = (double) i / (double) sample_rate;
229 ag->pattern_data[i] = ag->amplitude *
230 sin(2 * M_PI * frequency * t);
233 ag->num_samples = num_samples;
236 case PATTERN_TRIANGLE:
237 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
239 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
242 for (i = 0; i < num_samples; i++) {
243 t = (double) i / (double) sample_rate;
244 ag->pattern_data[i] = (2 * ag->amplitude / M_PI) *
245 asin(sin(2 * M_PI * frequency * t));
248 ag->num_samples = num_samples;
251 case PATTERN_SAWTOOTH:
252 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
254 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
257 for (i = 0; i < num_samples; i++) {
258 t = (double) i / (double) sample_rate;
259 ag->pattern_data[i] = 2 * ag->amplitude *
260 ((t * frequency) - floor(0.5f + t * frequency));
263 ag->num_samples = num_samples;
268 static GSList *scan(struct sr_dev_driver *di, GSList *options)
270 struct drv_context *drvc;
271 struct dev_context *devc;
272 struct sr_dev_inst *sdi;
273 struct sr_channel *ch;
274 struct sr_channel_group *cg, *acg;
275 struct sr_config *src;
276 struct analog_gen *ag;
278 int num_logic_channels, num_analog_channels, pattern, i;
279 char channel_name[16];
283 num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
284 num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
285 for (l = options; l; l = l->next) {
288 case SR_CONF_NUM_LOGIC_CHANNELS:
289 num_logic_channels = g_variant_get_int32(src->data);
291 case SR_CONF_NUM_ANALOG_CHANNELS:
292 num_analog_channels = g_variant_get_int32(src->data);
299 sdi = g_malloc0(sizeof(struct sr_dev_inst));
300 sdi->status = SR_ST_ACTIVE;
301 sdi->model = g_strdup("Demo device");
304 devc = g_malloc(sizeof(struct dev_context));
305 devc->cur_samplerate = SR_KHZ(200);
306 devc->limit_samples = 0;
307 devc->limit_msec = 0;
309 devc->continuous = FALSE;
310 devc->num_logic_channels = num_logic_channels;
311 devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
312 devc->logic_pattern = PATTERN_SIGROK;
313 devc->num_analog_channels = num_analog_channels;
315 devc->avg_samples = 0;
317 /* Logic channels, all in one channel group. */
318 cg = g_malloc0(sizeof(struct sr_channel_group));
319 cg->name = g_strdup("Logic");
320 for (i = 0; i < num_logic_channels; i++) {
321 sprintf(channel_name, "D%d", i);
322 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
323 cg->channels = g_slist_append(cg->channels, ch);
325 sdi->channel_groups = g_slist_append(NULL, cg);
327 /* Analog channels, channel groups and pattern generators. */
329 /* An "Analog" channel group with all analog channels in it. */
330 acg = g_malloc0(sizeof(struct sr_channel_group));
331 acg->name = g_strdup("Analog");
332 sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
334 devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
335 for (i = 0; i < num_analog_channels; i++) {
336 snprintf(channel_name, 16, "A%d", i);
337 ch = sr_channel_new(sdi, i + num_logic_channels, SR_CHANNEL_ANALOG,
339 acg->channels = g_slist_append(acg->channels, ch);
341 /* Every analog channel gets its own channel group as well. */
342 cg = g_malloc0(sizeof(struct sr_channel_group));
343 cg->name = g_strdup(channel_name);
344 cg->channels = g_slist_append(NULL, ch);
345 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
347 /* Every channel gets a generator struct. */
348 ag = g_malloc(sizeof(struct analog_gen));
349 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
350 ag->packet.channels = cg->channels;
352 ag->packet.mqflags = 0;
353 ag->packet.unit = SR_UNIT_VOLT;
354 ag->packet.data = ag->pattern_data;
355 ag->pattern = pattern;
358 g_hash_table_insert(devc->ch_ag, ch, ag);
360 if (++pattern == ARRAY_SIZE(analog_pattern_str))
365 devices = g_slist_append(devices, sdi);
366 drvc->instances = g_slist_append(drvc->instances, sdi);
371 static GSList *dev_list(const struct sr_dev_driver *di)
373 return ((struct drv_context *)(di->priv))->instances;
376 static int dev_open(struct sr_dev_inst *sdi)
378 sdi->status = SR_ST_ACTIVE;
383 static int dev_close(struct sr_dev_inst *sdi)
385 sdi->status = SR_ST_INACTIVE;
390 static void clear_helper(void *priv)
392 struct dev_context *devc;
398 /* Analog generators. */
399 g_hash_table_iter_init(&iter, devc->ch_ag);
400 while (g_hash_table_iter_next(&iter, NULL, &value))
402 g_hash_table_unref(devc->ch_ag);
406 static int cleanup(const struct sr_dev_driver *di)
408 return std_dev_clear(di, clear_helper);
411 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
412 const struct sr_channel_group *cg)
414 struct dev_context *devc;
415 struct sr_channel *ch;
416 struct analog_gen *ag;
424 case SR_CONF_SAMPLERATE:
425 *data = g_variant_new_uint64(devc->cur_samplerate);
427 case SR_CONF_LIMIT_SAMPLES:
428 *data = g_variant_new_uint64(devc->limit_samples);
430 case SR_CONF_LIMIT_MSEC:
431 *data = g_variant_new_uint64(devc->limit_msec);
433 case SR_CONF_AVERAGING:
434 *data = g_variant_new_boolean(devc->avg);
436 case SR_CONF_AVG_SAMPLES:
437 *data = g_variant_new_uint64(devc->avg_samples);
439 case SR_CONF_PATTERN_MODE:
441 return SR_ERR_CHANNEL_GROUP;
442 /* Any channel in the group will do. */
443 ch = cg->channels->data;
444 if (ch->type == SR_CHANNEL_LOGIC) {
445 pattern = devc->logic_pattern;
446 *data = g_variant_new_string(logic_pattern_str[pattern]);
447 } else if (ch->type == SR_CHANNEL_ANALOG) {
448 ag = g_hash_table_lookup(devc->ch_ag, ch);
449 pattern = ag->pattern;
450 *data = g_variant_new_string(analog_pattern_str[pattern]);
454 case SR_CONF_AMPLITUDE:
456 return SR_ERR_CHANNEL_GROUP;
457 /* Any channel in the group will do. */
458 ch = cg->channels->data;
459 if (ch->type != SR_CHANNEL_ANALOG)
461 ag = g_hash_table_lookup(devc->ch_ag, ch);
462 *data = g_variant_new_double(ag->amplitude);
471 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
472 const struct sr_channel_group *cg)
474 struct dev_context *devc;
475 struct analog_gen *ag;
476 struct sr_channel *ch;
478 int logic_pattern, analog_pattern, ret;
484 if (sdi->status != SR_ST_ACTIVE)
485 return SR_ERR_DEV_CLOSED;
489 case SR_CONF_SAMPLERATE:
490 devc->cur_samplerate = g_variant_get_uint64(data);
491 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
493 case SR_CONF_LIMIT_SAMPLES:
494 devc->limit_msec = 0;
495 devc->limit_samples = g_variant_get_uint64(data);
496 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
498 case SR_CONF_LIMIT_MSEC:
499 devc->limit_msec = g_variant_get_uint64(data);
500 devc->limit_samples = 0;
501 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
503 case SR_CONF_AVERAGING:
504 devc->avg = g_variant_get_boolean(data);
505 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
507 case SR_CONF_AVG_SAMPLES:
508 devc->avg_samples = g_variant_get_uint64(data);
509 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
511 case SR_CONF_PATTERN_MODE:
513 return SR_ERR_CHANNEL_GROUP;
514 stropt = g_variant_get_string(data, NULL);
515 logic_pattern = analog_pattern = -1;
516 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
517 if (!strcmp(stropt, logic_pattern_str[i])) {
522 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
523 if (!strcmp(stropt, analog_pattern_str[i])) {
528 if (logic_pattern == -1 && analog_pattern == -1)
530 for (l = cg->channels; l; l = l->next) {
532 if (ch->type == SR_CHANNEL_LOGIC) {
533 if (logic_pattern == -1)
535 sr_dbg("Setting logic pattern to %s",
536 logic_pattern_str[logic_pattern]);
537 devc->logic_pattern = logic_pattern;
538 /* Might as well do this now, these are static. */
539 if (logic_pattern == PATTERN_ALL_LOW)
540 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
541 else if (logic_pattern == PATTERN_ALL_HIGH)
542 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
543 } else if (ch->type == SR_CHANNEL_ANALOG) {
544 if (analog_pattern == -1)
546 sr_dbg("Setting analog pattern for channel %s to %s",
547 ch->name, analog_pattern_str[analog_pattern]);
548 ag = g_hash_table_lookup(devc->ch_ag, ch);
549 ag->pattern = analog_pattern;
554 case SR_CONF_AMPLITUDE:
556 return SR_ERR_CHANNEL_GROUP;
557 for (l = cg->channels; l; l = l->next) {
559 if (ch->type != SR_CHANNEL_ANALOG)
561 ag = g_hash_table_lookup(devc->ch_ag, ch);
562 ag->amplitude = g_variant_get_double(data);
572 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
573 const struct sr_channel_group *cg)
575 struct sr_channel *ch;
581 if (key == SR_CONF_SCAN_OPTIONS) {
582 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
583 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
587 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
588 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
589 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
598 case SR_CONF_DEVICE_OPTIONS:
599 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
600 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
602 case SR_CONF_SAMPLERATE:
603 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
604 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
605 ARRAY_SIZE(samplerates), sizeof(uint64_t));
606 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
607 *data = g_variant_builder_end(&gvb);
613 /* Any channel in the group will do. */
614 ch = cg->channels->data;
616 case SR_CONF_DEVICE_OPTIONS:
617 if (ch->type == SR_CHANNEL_LOGIC)
618 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
619 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
621 else if (ch->type == SR_CHANNEL_ANALOG)
622 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
623 devopts_cg_analog, ARRAY_SIZE(devopts_cg_analog),
628 case SR_CONF_PATTERN_MODE:
629 if (ch->type == SR_CHANNEL_LOGIC)
630 *data = g_variant_new_strv(logic_pattern_str,
631 ARRAY_SIZE(logic_pattern_str));
632 else if (ch->type == SR_CHANNEL_ANALOG)
633 *data = g_variant_new_strv(analog_pattern_str,
634 ARRAY_SIZE(analog_pattern_str));
646 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
648 struct dev_context *devc;
654 switch (devc->logic_pattern) {
656 memset(devc->logic_data, 0x00, size);
657 for (i = 0; i < size; i += devc->logic_unitsize) {
658 for (j = 0; j < devc->logic_unitsize; j++) {
659 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
660 devc->logic_data[i + j] = ~pat;
666 for (i = 0; i < size; i++)
667 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
670 for (i = 0; i < size; i++) {
671 for (j = 0; j < devc->logic_unitsize; j++) {
672 devc->logic_data[i + j] = devc->step;
677 case PATTERN_ALL_LOW:
678 case PATTERN_ALL_HIGH:
679 /* These were set when the pattern mode was selected. */
682 sr_err("Unknown pattern: %d.", devc->logic_pattern);
687 static void send_analog_packet(struct analog_gen *ag,
688 struct sr_dev_inst *sdi,
689 uint64_t *analog_sent,
690 uint64_t analog_todo)
692 struct sr_datafeed_packet packet;
693 struct dev_context *devc;
694 uint64_t sending_now, to_avg;
699 packet.type = SR_DF_ANALOG;
700 packet.payload = &ag->packet;
703 ag_pattern_pos = devc->analog_counter % ag->num_samples;
704 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
705 ag->packet.data = ag->pattern_data + ag_pattern_pos;
706 ag->packet.num_samples = sending_now;
707 sr_session_send(sdi, &packet);
709 /* Whichever channel group gets there first. */
710 *analog_sent = MAX(*analog_sent, sending_now);
712 ag_pattern_pos = devc->analog_counter % ag->num_samples;
713 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
715 for (i = 0; i < to_avg; i++) {
716 ag->avg_val = (ag->avg_val +
718 ag_pattern_pos + i)) / 2;
720 /* Time to send averaged data? */
721 if (devc->avg_samples > 0 &&
722 ag->num_avgs >= devc->avg_samples)
726 if (devc->avg_samples == 0) {
727 /* We're averaging all the samples, so wait with
728 * sending until the very end.
730 *analog_sent = ag->num_avgs;
735 ag->packet.data = &ag->avg_val;
736 ag->packet.num_samples = 1;
738 sr_session_send(sdi, &packet);
739 *analog_sent = ag->num_avgs;
746 /* Callback handling data */
747 static int prepare_data(int fd, int revents, void *cb_data)
749 struct sr_dev_inst *sdi;
750 struct dev_context *devc;
751 struct sr_datafeed_packet packet;
752 struct sr_datafeed_logic logic;
753 struct analog_gen *ag;
756 uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
757 int64_t time, elapsed;
764 logic_todo = analog_todo = 0;
766 /* How many samples should we have sent by now? */
767 time = g_get_monotonic_time();
768 elapsed = time - devc->starttime;
769 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
771 /* But never more than the limit, if there is one. */
772 if (!devc->continuous)
773 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
775 /* Of those, how many do we still have to send? */
776 if (devc->num_logic_channels)
777 logic_todo = expected_samplenum - devc->logic_counter;
778 if (devc->num_analog_channels)
779 analog_todo = expected_samplenum - devc->analog_counter;
781 while (logic_todo || analog_todo) {
783 if (logic_todo > 0) {
784 sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
785 logic_generator(sdi, sending_now * devc->logic_unitsize);
786 packet.type = SR_DF_LOGIC;
787 packet.payload = &logic;
788 logic.length = sending_now * devc->logic_unitsize;
789 logic.unitsize = devc->logic_unitsize;
790 logic.data = devc->logic_data;
791 sr_session_send(sdi, &packet);
792 logic_todo -= sending_now;
793 devc->logic_counter += sending_now;
796 /* Analog, one channel at a time */
797 if (analog_todo > 0) {
800 g_hash_table_iter_init(&iter, devc->ch_ag);
801 while (g_hash_table_iter_next(&iter, NULL, &value)) {
802 send_analog_packet(value, sdi,
803 &analog_sent, analog_todo);
805 analog_todo -= analog_sent;
806 devc->analog_counter += analog_sent;
810 if (!devc->continuous
811 && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
812 && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
813 /* If we're averaging everything - now is the time to send data */
814 if (devc->avg_samples == 0) {
815 g_hash_table_iter_init(&iter, devc->ch_ag);
816 while (g_hash_table_iter_next(&iter, NULL, &value)) {
818 packet.type = SR_DF_ANALOG;
819 packet.payload = &ag->packet;
820 ag->packet.data = &ag->avg_val;
821 ag->packet.num_samples = 1;
822 sr_session_send(sdi, &packet);
826 sr_dbg("Requested number of samples reached.");
827 dev_acquisition_stop(sdi, cb_data);
834 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
836 struct dev_context *devc;
842 if (sdi->status != SR_ST_ACTIVE)
843 return SR_ERR_DEV_CLOSED;
846 devc->continuous = !devc->limit_samples;
847 devc->logic_counter = devc->analog_counter = 0;
850 * Setting two channels connected by a pipe is a remnant from when the
851 * demo driver generated data in a thread, and collected and sent the
852 * data in the main program loop.
853 * They are kept here because it provides a convenient way of setting
854 * up a timeout-based polling mechanism.
856 if (pipe(devc->pipe_fds)) {
857 sr_err("%s: pipe() failed", __func__);
861 g_hash_table_iter_init(&iter, devc->ch_ag);
862 while (g_hash_table_iter_next(&iter, NULL, &value))
863 generate_analog_pattern(value, devc->cur_samplerate);
865 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
866 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
868 /* Set channel encoding to binary (default is UTF-8). */
869 g_io_channel_set_encoding(devc->channel, NULL, NULL);
871 /* Make channels unbuffered. */
872 g_io_channel_set_buffered(devc->channel, FALSE);
874 sr_session_source_add_channel(sdi->session, devc->channel,
875 G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
877 /* Send header packet to the session bus. */
878 std_session_send_df_header(sdi, LOG_PREFIX);
880 /* We use this timestamp to decide how many more samples to send. */
881 devc->starttime = g_get_monotonic_time();
886 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
888 struct dev_context *devc;
889 struct sr_datafeed_packet packet;
894 sr_dbg("Stopping acquisition.");
896 sr_session_source_remove_channel(sdi->session, devc->channel);
897 g_io_channel_shutdown(devc->channel, FALSE, NULL);
898 g_io_channel_unref(devc->channel);
899 devc->channel = NULL;
901 /* Send last packet. */
902 packet.type = SR_DF_END;
903 sr_session_send(sdi, &packet);
908 SR_PRIV struct sr_dev_driver demo_driver_info = {
910 .longname = "Demo driver and pattern generator",
915 .dev_list = dev_list,
917 .config_get = config_get,
918 .config_set = config_set,
919 .config_list = config_list,
920 .dev_open = dev_open,
921 .dev_close = dev_close,
922 .dev_acquisition_start = dev_acquisition_start,
923 .dev_acquisition_stop = dev_acquisition_stop,