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;
183 static struct sr_dev_driver *di = &demo_driver_info;
185 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
188 static int init(struct sr_context *sr_ctx)
190 return std_init(sr_ctx, di, LOG_PREFIX);
193 static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
197 unsigned int num_samples, i;
200 sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
202 num_samples = ANALOG_BUFSIZE / sizeof(float);
204 switch (ag->pattern) {
206 value = ag->amplitude;
208 for (i = 0; i < num_samples; i++) {
213 ag->pattern_data[i] = value;
215 ag->num_samples = last_end;
219 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
221 /* Make sure the number of samples we put out is an integer
222 * multiple of our period size */
223 /* FIXME we actually need only one period. A ringbuffer would be
225 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
228 for (i = 0; i < num_samples; i++) {
229 t = (double) i / (double) sample_rate;
230 ag->pattern_data[i] = ag->amplitude *
231 sin(2 * M_PI * frequency * t);
234 ag->num_samples = num_samples;
237 case PATTERN_TRIANGLE:
238 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
240 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
243 for (i = 0; i < num_samples; i++) {
244 t = (double) i / (double) sample_rate;
245 ag->pattern_data[i] = (2 * ag->amplitude / M_PI) *
246 asin(sin(2 * M_PI * frequency * t));
249 ag->num_samples = num_samples;
252 case PATTERN_SAWTOOTH:
253 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
255 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
258 for (i = 0; i < num_samples; i++) {
259 t = (double) i / (double) sample_rate;
260 ag->pattern_data[i] = 2 * ag->amplitude *
261 ((t * frequency) - floor(0.5f + t * frequency));
264 ag->num_samples = num_samples;
269 static GSList *scan(GSList *options)
271 struct drv_context *drvc;
272 struct dev_context *devc;
273 struct sr_dev_inst *sdi;
274 struct sr_channel *ch;
275 struct sr_channel_group *cg, *acg;
276 struct sr_config *src;
277 struct analog_gen *ag;
279 int num_logic_channels, num_analog_channels, pattern, i;
280 char channel_name[16];
284 num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
285 num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
286 for (l = options; l; l = l->next) {
289 case SR_CONF_NUM_LOGIC_CHANNELS:
290 num_logic_channels = g_variant_get_int32(src->data);
292 case SR_CONF_NUM_ANALOG_CHANNELS:
293 num_analog_channels = g_variant_get_int32(src->data);
300 sdi = g_malloc0(sizeof(struct sr_dev_inst));
301 sdi->status = SR_ST_ACTIVE;
302 sdi->model = g_strdup("Demo device");
305 devc = g_malloc(sizeof(struct dev_context));
306 devc->cur_samplerate = SR_KHZ(200);
307 devc->limit_samples = 0;
308 devc->limit_msec = 0;
310 devc->continuous = FALSE;
311 devc->num_logic_channels = num_logic_channels;
312 devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
313 devc->logic_pattern = PATTERN_SIGROK;
314 devc->num_analog_channels = num_analog_channels;
316 devc->avg_samples = 0;
318 /* Logic channels, all in one channel group. */
319 cg = g_malloc0(sizeof(struct sr_channel_group));
320 cg->name = g_strdup("Logic");
321 for (i = 0; i < num_logic_channels; i++) {
322 sprintf(channel_name, "D%d", i);
323 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
324 cg->channels = g_slist_append(cg->channels, ch);
326 sdi->channel_groups = g_slist_append(NULL, cg);
328 /* Analog channels, channel groups and pattern generators. */
330 /* An "Analog" channel group with all analog channels in it. */
331 acg = g_malloc0(sizeof(struct sr_channel_group));
332 acg->name = g_strdup("Analog");
333 sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
335 devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
336 for (i = 0; i < num_analog_channels; i++) {
337 snprintf(channel_name, 16, "A%d", i);
338 ch = sr_channel_new(sdi, i + num_logic_channels, SR_CHANNEL_ANALOG,
340 acg->channels = g_slist_append(acg->channels, ch);
342 /* Every analog channel gets its own channel group as well. */
343 cg = g_malloc0(sizeof(struct sr_channel_group));
344 cg->name = g_strdup(channel_name);
345 cg->channels = g_slist_append(NULL, ch);
346 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
348 /* Every channel gets a generator struct. */
349 ag = g_malloc(sizeof(struct analog_gen));
350 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
351 ag->packet.channels = cg->channels;
353 ag->packet.mqflags = 0;
354 ag->packet.unit = SR_UNIT_VOLT;
355 ag->packet.data = ag->pattern_data;
356 ag->pattern = pattern;
359 g_hash_table_insert(devc->ch_ag, ch, ag);
361 if (++pattern == ARRAY_SIZE(analog_pattern_str))
366 devices = g_slist_append(devices, sdi);
367 drvc->instances = g_slist_append(drvc->instances, sdi);
372 static GSList *dev_list(void)
374 return ((struct drv_context *)(di->priv))->instances;
377 static int dev_open(struct sr_dev_inst *sdi)
379 sdi->status = SR_ST_ACTIVE;
384 static int dev_close(struct sr_dev_inst *sdi)
386 sdi->status = SR_ST_INACTIVE;
391 static void clear_helper(void *priv)
393 struct dev_context *devc;
399 /* Analog generators. */
400 g_hash_table_iter_init(&iter, devc->ch_ag);
401 while (g_hash_table_iter_next(&iter, NULL, &value))
403 g_hash_table_unref(devc->ch_ag);
407 static int cleanup(void)
409 return std_dev_clear(di, clear_helper);
412 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
413 const struct sr_channel_group *cg)
415 struct dev_context *devc;
416 struct sr_channel *ch;
417 struct analog_gen *ag;
425 case SR_CONF_SAMPLERATE:
426 *data = g_variant_new_uint64(devc->cur_samplerate);
428 case SR_CONF_LIMIT_SAMPLES:
429 *data = g_variant_new_uint64(devc->limit_samples);
431 case SR_CONF_LIMIT_MSEC:
432 *data = g_variant_new_uint64(devc->limit_msec);
434 case SR_CONF_AVERAGING:
435 *data = g_variant_new_boolean(devc->avg);
437 case SR_CONF_AVG_SAMPLES:
438 *data = g_variant_new_uint64(devc->avg_samples);
440 case SR_CONF_PATTERN_MODE:
442 return SR_ERR_CHANNEL_GROUP;
443 /* Any channel in the group will do. */
444 ch = cg->channels->data;
445 if (ch->type == SR_CHANNEL_LOGIC) {
446 pattern = devc->logic_pattern;
447 *data = g_variant_new_string(logic_pattern_str[pattern]);
448 } else if (ch->type == SR_CHANNEL_ANALOG) {
449 ag = g_hash_table_lookup(devc->ch_ag, ch);
450 pattern = ag->pattern;
451 *data = g_variant_new_string(analog_pattern_str[pattern]);
455 case SR_CONF_AMPLITUDE:
457 return SR_ERR_CHANNEL_GROUP;
458 /* Any channel in the group will do. */
459 ch = cg->channels->data;
460 if (ch->type != SR_CHANNEL_ANALOG)
462 ag = g_hash_table_lookup(devc->ch_ag, ch);
463 *data = g_variant_new_double(ag->amplitude);
472 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
473 const struct sr_channel_group *cg)
475 struct dev_context *devc;
476 struct analog_gen *ag;
477 struct sr_channel *ch;
479 int logic_pattern, analog_pattern, ret;
485 if (sdi->status != SR_ST_ACTIVE)
486 return SR_ERR_DEV_CLOSED;
490 case SR_CONF_SAMPLERATE:
491 devc->cur_samplerate = g_variant_get_uint64(data);
492 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
494 case SR_CONF_LIMIT_SAMPLES:
495 devc->limit_msec = 0;
496 devc->limit_samples = g_variant_get_uint64(data);
497 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
499 case SR_CONF_LIMIT_MSEC:
500 devc->limit_msec = g_variant_get_uint64(data);
501 devc->limit_samples = 0;
502 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
504 case SR_CONF_AVERAGING:
505 devc->avg = g_variant_get_boolean(data);
506 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
508 case SR_CONF_AVG_SAMPLES:
509 devc->avg_samples = g_variant_get_uint64(data);
510 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
512 case SR_CONF_PATTERN_MODE:
514 return SR_ERR_CHANNEL_GROUP;
515 stropt = g_variant_get_string(data, NULL);
516 logic_pattern = analog_pattern = -1;
517 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
518 if (!strcmp(stropt, logic_pattern_str[i])) {
523 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
524 if (!strcmp(stropt, analog_pattern_str[i])) {
529 if (logic_pattern == -1 && analog_pattern == -1)
531 for (l = cg->channels; l; l = l->next) {
533 if (ch->type == SR_CHANNEL_LOGIC) {
534 if (logic_pattern == -1)
536 sr_dbg("Setting logic pattern to %s",
537 logic_pattern_str[logic_pattern]);
538 devc->logic_pattern = logic_pattern;
539 /* Might as well do this now, these are static. */
540 if (logic_pattern == PATTERN_ALL_LOW)
541 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
542 else if (logic_pattern == PATTERN_ALL_HIGH)
543 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
544 } else if (ch->type == SR_CHANNEL_ANALOG) {
545 if (analog_pattern == -1)
547 sr_dbg("Setting analog pattern for channel %s to %s",
548 ch->name, analog_pattern_str[analog_pattern]);
549 ag = g_hash_table_lookup(devc->ch_ag, ch);
550 ag->pattern = analog_pattern;
555 case SR_CONF_AMPLITUDE:
557 return SR_ERR_CHANNEL_GROUP;
558 for (l = cg->channels; l; l = l->next) {
560 if (ch->type != SR_CHANNEL_ANALOG)
562 ag = g_hash_table_lookup(devc->ch_ag, ch);
563 ag->amplitude = g_variant_get_double(data);
573 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
574 const struct sr_channel_group *cg)
576 struct sr_channel *ch;
582 if (key == SR_CONF_SCAN_OPTIONS) {
583 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
584 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
588 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
589 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
590 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
599 case SR_CONF_DEVICE_OPTIONS:
600 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
601 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
603 case SR_CONF_SAMPLERATE:
604 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
605 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
606 ARRAY_SIZE(samplerates), sizeof(uint64_t));
607 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
608 *data = g_variant_builder_end(&gvb);
614 /* Any channel in the group will do. */
615 ch = cg->channels->data;
617 case SR_CONF_DEVICE_OPTIONS:
618 if (ch->type == SR_CHANNEL_LOGIC)
619 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
620 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
622 else if (ch->type == SR_CHANNEL_ANALOG)
623 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
624 devopts_cg_analog, ARRAY_SIZE(devopts_cg_analog),
629 case SR_CONF_PATTERN_MODE:
630 if (ch->type == SR_CHANNEL_LOGIC)
631 *data = g_variant_new_strv(logic_pattern_str,
632 ARRAY_SIZE(logic_pattern_str));
633 else if (ch->type == SR_CHANNEL_ANALOG)
634 *data = g_variant_new_strv(analog_pattern_str,
635 ARRAY_SIZE(analog_pattern_str));
647 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
649 struct dev_context *devc;
655 switch (devc->logic_pattern) {
657 memset(devc->logic_data, 0x00, size);
658 for (i = 0; i < size; i += devc->logic_unitsize) {
659 for (j = 0; j < devc->logic_unitsize; j++) {
660 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
661 devc->logic_data[i + j] = ~pat;
667 for (i = 0; i < size; i++)
668 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
671 for (i = 0; i < size; i++) {
672 for (j = 0; j < devc->logic_unitsize; j++) {
673 devc->logic_data[i + j] = devc->step;
678 case PATTERN_ALL_LOW:
679 case PATTERN_ALL_HIGH:
680 /* These were set when the pattern mode was selected. */
683 sr_err("Unknown pattern: %d.", devc->logic_pattern);
688 static void send_analog_packet(struct analog_gen *ag,
689 struct sr_dev_inst *sdi,
690 uint64_t *analog_sent,
691 uint64_t analog_todo)
693 struct sr_datafeed_packet packet;
694 struct dev_context *devc;
695 uint64_t sending_now, to_avg;
700 packet.type = SR_DF_ANALOG;
701 packet.payload = &ag->packet;
704 ag_pattern_pos = devc->analog_counter % ag->num_samples;
705 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
706 ag->packet.data = ag->pattern_data + ag_pattern_pos;
707 ag->packet.num_samples = sending_now;
708 sr_session_send(sdi, &packet);
710 /* Whichever channel group gets there first. */
711 *analog_sent = MAX(*analog_sent, sending_now);
713 ag_pattern_pos = devc->analog_counter % ag->num_samples;
714 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
716 for (i = 0; i < to_avg; i++) {
717 ag->avg_val = (ag->avg_val +
719 ag_pattern_pos + i)) / 2;
721 /* Time to send averaged data? */
722 if (devc->avg_samples > 0 &&
723 ag->num_avgs >= devc->avg_samples)
727 if (devc->avg_samples == 0) {
728 /* We're averaging all the samples, so wait with
729 * sending until the very end.
731 *analog_sent = ag->num_avgs;
736 ag->packet.data = &ag->avg_val;
737 ag->packet.num_samples = 1;
739 sr_session_send(sdi, &packet);
740 *analog_sent = ag->num_avgs;
747 /* Callback handling data */
748 static int prepare_data(int fd, int revents, void *cb_data)
750 struct sr_dev_inst *sdi;
751 struct dev_context *devc;
752 struct sr_datafeed_packet packet;
753 struct sr_datafeed_logic logic;
754 struct analog_gen *ag;
757 uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
758 int64_t time, elapsed;
765 logic_todo = analog_todo = 0;
767 /* How many samples should we have sent by now? */
768 time = g_get_monotonic_time();
769 elapsed = time - devc->starttime;
770 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
772 /* But never more than the limit, if there is one. */
773 if (!devc->continuous)
774 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
776 /* Of those, how many do we still have to send? */
777 if (devc->num_logic_channels)
778 logic_todo = expected_samplenum - devc->logic_counter;
779 if (devc->num_analog_channels)
780 analog_todo = expected_samplenum - devc->analog_counter;
782 while (logic_todo || analog_todo) {
784 if (logic_todo > 0) {
785 sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
786 logic_generator(sdi, sending_now * devc->logic_unitsize);
787 packet.type = SR_DF_LOGIC;
788 packet.payload = &logic;
789 logic.length = sending_now * devc->logic_unitsize;
790 logic.unitsize = devc->logic_unitsize;
791 logic.data = devc->logic_data;
792 sr_session_send(sdi, &packet);
793 logic_todo -= sending_now;
794 devc->logic_counter += sending_now;
797 /* Analog, one channel at a time */
798 if (analog_todo > 0) {
801 g_hash_table_iter_init(&iter, devc->ch_ag);
802 while (g_hash_table_iter_next(&iter, NULL, &value)) {
803 send_analog_packet(value, sdi,
804 &analog_sent, analog_todo);
806 analog_todo -= analog_sent;
807 devc->analog_counter += analog_sent;
811 if (!devc->continuous
812 && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
813 && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
814 /* If we're averaging everything - now is the time to send data */
815 if (devc->avg_samples == 0) {
816 g_hash_table_iter_init(&iter, devc->ch_ag);
817 while (g_hash_table_iter_next(&iter, NULL, &value)) {
819 packet.type = SR_DF_ANALOG;
820 packet.payload = &ag->packet;
821 ag->packet.data = &ag->avg_val;
822 ag->packet.num_samples = 1;
823 sr_session_send(sdi, &packet);
827 sr_dbg("Requested number of samples reached.");
828 dev_acquisition_stop(sdi, cb_data);
835 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
837 struct dev_context *devc;
843 if (sdi->status != SR_ST_ACTIVE)
844 return SR_ERR_DEV_CLOSED;
847 devc->continuous = !devc->limit_samples;
848 devc->logic_counter = devc->analog_counter = 0;
851 * Setting two channels connected by a pipe is a remnant from when the
852 * demo driver generated data in a thread, and collected and sent the
853 * data in the main program loop.
854 * They are kept here because it provides a convenient way of setting
855 * up a timeout-based polling mechanism.
857 if (pipe(devc->pipe_fds)) {
858 sr_err("%s: pipe() failed", __func__);
862 g_hash_table_iter_init(&iter, devc->ch_ag);
863 while (g_hash_table_iter_next(&iter, NULL, &value))
864 generate_analog_pattern(value, devc->cur_samplerate);
866 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
867 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
869 /* Set channel encoding to binary (default is UTF-8). */
870 g_io_channel_set_encoding(devc->channel, NULL, NULL);
872 /* Make channels unbuffered. */
873 g_io_channel_set_buffered(devc->channel, FALSE);
875 sr_session_source_add_channel(sdi->session, devc->channel,
876 G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
878 /* Send header packet to the session bus. */
879 std_session_send_df_header(sdi, LOG_PREFIX);
881 /* We use this timestamp to decide how many more samples to send. */
882 devc->starttime = g_get_monotonic_time();
887 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
889 struct dev_context *devc;
890 struct sr_datafeed_packet packet;
895 sr_dbg("Stopping acquisition.");
897 sr_session_source_remove_channel(sdi->session, devc->channel);
898 g_io_channel_shutdown(devc->channel, FALSE, NULL);
899 g_io_channel_unref(devc->channel);
900 devc->channel = NULL;
902 /* Send last packet. */
903 packet.type = SR_DF_END;
904 sr_session_send(sdi, &packet);
909 SR_PRIV struct sr_dev_driver demo_driver_info = {
911 .longname = "Demo driver and pattern generator",
916 .dev_list = dev_list,
918 .config_get = config_get,
919 .config_set = config_set,
920 .config_list = config_list,
921 .dev_open = dev_open,
922 .dev_close = dev_close,
923 .dev_acquisition_start = dev_acquisition_start,
924 .dev_acquisition_stop = dev_acquisition_stop,