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;
216 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
218 /* Make sure the number of samples we put out is an integer
219 * multiple of our period size */
220 /* FIXME we actually need only one period. A ringbuffer would be
222 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
225 for (i = 0; i < num_samples; i++) {
226 t = (double) i / (double) sample_rate;
227 ag->pattern_data[i] = ag->amplitude *
228 sin(2 * PI * frequency * t);
231 ag->num_samples = num_samples;
233 case PATTERN_TRIANGLE:
234 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
236 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
239 for (i = 0; i < num_samples; i++) {
240 t = (double) i / (double) sample_rate;
241 ag->pattern_data[i] = (2 * ag->amplitude / PI) *
242 asin(sin(2 * PI * frequency * t));
245 ag->num_samples = num_samples;
247 case PATTERN_SAWTOOTH:
248 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
250 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
253 for (i = 0; i < num_samples; i++) {
254 t = (double) i / (double) sample_rate;
255 ag->pattern_data[i] = 2 * ag->amplitude *
256 ((t * frequency) - floor(0.5f + t * frequency));
259 ag->num_samples = num_samples;
264 static GSList *scan(struct sr_dev_driver *di, GSList *options)
266 struct drv_context *drvc;
267 struct dev_context *devc;
268 struct sr_dev_inst *sdi;
269 struct sr_channel *ch;
270 struct sr_channel_group *cg, *acg;
271 struct sr_config *src;
272 struct analog_gen *ag;
274 int num_logic_channels, num_analog_channels, pattern, i;
275 char channel_name[16];
279 num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
280 num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
281 for (l = options; l; l = l->next) {
284 case SR_CONF_NUM_LOGIC_CHANNELS:
285 num_logic_channels = g_variant_get_int32(src->data);
287 case SR_CONF_NUM_ANALOG_CHANNELS:
288 num_analog_channels = g_variant_get_int32(src->data);
295 sdi = g_malloc0(sizeof(struct sr_dev_inst));
296 sdi->status = SR_ST_ACTIVE;
297 sdi->model = g_strdup("Demo device");
300 devc = g_malloc(sizeof(struct dev_context));
301 devc->cur_samplerate = SR_KHZ(200);
302 devc->limit_samples = 0;
303 devc->limit_msec = 0;
305 devc->continuous = FALSE;
306 devc->num_logic_channels = num_logic_channels;
307 devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
308 devc->logic_pattern = PATTERN_SIGROK;
309 devc->num_analog_channels = num_analog_channels;
311 devc->avg_samples = 0;
313 /* Logic channels, all in one channel group. */
314 cg = g_malloc0(sizeof(struct sr_channel_group));
315 cg->name = g_strdup("Logic");
316 for (i = 0; i < num_logic_channels; i++) {
317 sprintf(channel_name, "D%d", i);
318 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
319 cg->channels = g_slist_append(cg->channels, ch);
321 sdi->channel_groups = g_slist_append(NULL, cg);
323 /* Analog channels, channel groups and pattern generators. */
325 /* An "Analog" channel group with all analog channels in it. */
326 acg = g_malloc0(sizeof(struct sr_channel_group));
327 acg->name = g_strdup("Analog");
328 sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
330 devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
331 for (i = 0; i < num_analog_channels; i++) {
332 snprintf(channel_name, 16, "A%d", i);
333 ch = sr_channel_new(sdi, i + num_logic_channels, SR_CHANNEL_ANALOG,
335 acg->channels = g_slist_append(acg->channels, ch);
337 /* Every analog channel gets its own channel group as well. */
338 cg = g_malloc0(sizeof(struct sr_channel_group));
339 cg->name = g_strdup(channel_name);
340 cg->channels = g_slist_append(NULL, ch);
341 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
343 /* Every channel gets a generator struct. */
344 ag = g_malloc(sizeof(struct analog_gen));
345 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
346 ag->packet.channels = cg->channels;
348 ag->packet.mqflags = 0;
349 ag->packet.unit = SR_UNIT_VOLT;
350 ag->packet.data = ag->pattern_data;
351 ag->pattern = pattern;
354 g_hash_table_insert(devc->ch_ag, ch, ag);
356 if (++pattern == ARRAY_SIZE(analog_pattern_str))
361 devices = g_slist_append(devices, sdi);
362 drvc->instances = g_slist_append(drvc->instances, sdi);
367 static GSList *dev_list(const struct sr_dev_driver *di)
369 return ((struct drv_context *)(di->priv))->instances;
372 static int dev_open(struct sr_dev_inst *sdi)
374 sdi->status = SR_ST_ACTIVE;
379 static int dev_close(struct sr_dev_inst *sdi)
381 sdi->status = SR_ST_INACTIVE;
386 static void clear_helper(void *priv)
388 struct dev_context *devc;
394 /* Analog generators. */
395 g_hash_table_iter_init(&iter, devc->ch_ag);
396 while (g_hash_table_iter_next(&iter, NULL, &value))
398 g_hash_table_unref(devc->ch_ag);
402 static int cleanup(const struct sr_dev_driver *di)
404 return std_dev_clear(di, clear_helper);
407 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
408 const struct sr_channel_group *cg)
410 struct dev_context *devc;
411 struct sr_channel *ch;
412 struct analog_gen *ag;
420 case SR_CONF_SAMPLERATE:
421 *data = g_variant_new_uint64(devc->cur_samplerate);
423 case SR_CONF_LIMIT_SAMPLES:
424 *data = g_variant_new_uint64(devc->limit_samples);
426 case SR_CONF_LIMIT_MSEC:
427 *data = g_variant_new_uint64(devc->limit_msec);
429 case SR_CONF_AVERAGING:
430 *data = g_variant_new_boolean(devc->avg);
432 case SR_CONF_AVG_SAMPLES:
433 *data = g_variant_new_uint64(devc->avg_samples);
435 case SR_CONF_PATTERN_MODE:
437 return SR_ERR_CHANNEL_GROUP;
438 /* Any channel in the group will do. */
439 ch = cg->channels->data;
440 if (ch->type == SR_CHANNEL_LOGIC) {
441 pattern = devc->logic_pattern;
442 *data = g_variant_new_string(logic_pattern_str[pattern]);
443 } else if (ch->type == SR_CHANNEL_ANALOG) {
444 ag = g_hash_table_lookup(devc->ch_ag, ch);
445 pattern = ag->pattern;
446 *data = g_variant_new_string(analog_pattern_str[pattern]);
450 case SR_CONF_AMPLITUDE:
452 return SR_ERR_CHANNEL_GROUP;
453 /* Any channel in the group will do. */
454 ch = cg->channels->data;
455 if (ch->type != SR_CHANNEL_ANALOG)
457 ag = g_hash_table_lookup(devc->ch_ag, ch);
458 *data = g_variant_new_double(ag->amplitude);
467 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
468 const struct sr_channel_group *cg)
470 struct dev_context *devc;
471 struct analog_gen *ag;
472 struct sr_channel *ch;
474 int logic_pattern, analog_pattern, ret;
480 if (sdi->status != SR_ST_ACTIVE)
481 return SR_ERR_DEV_CLOSED;
485 case SR_CONF_SAMPLERATE:
486 devc->cur_samplerate = g_variant_get_uint64(data);
488 case SR_CONF_LIMIT_SAMPLES:
489 devc->limit_msec = 0;
490 devc->limit_samples = g_variant_get_uint64(data);
492 case SR_CONF_LIMIT_MSEC:
493 devc->limit_msec = g_variant_get_uint64(data);
494 devc->limit_samples = 0;
496 case SR_CONF_AVERAGING:
497 devc->avg = g_variant_get_boolean(data);
498 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
500 case SR_CONF_AVG_SAMPLES:
501 devc->avg_samples = g_variant_get_uint64(data);
502 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
504 case SR_CONF_PATTERN_MODE:
506 return SR_ERR_CHANNEL_GROUP;
507 stropt = g_variant_get_string(data, NULL);
508 logic_pattern = analog_pattern = -1;
509 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
510 if (!strcmp(stropt, logic_pattern_str[i])) {
515 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
516 if (!strcmp(stropt, analog_pattern_str[i])) {
521 if (logic_pattern == -1 && analog_pattern == -1)
523 for (l = cg->channels; l; l = l->next) {
525 if (ch->type == SR_CHANNEL_LOGIC) {
526 if (logic_pattern == -1)
528 sr_dbg("Setting logic pattern to %s",
529 logic_pattern_str[logic_pattern]);
530 devc->logic_pattern = logic_pattern;
531 /* Might as well do this now, these are static. */
532 if (logic_pattern == PATTERN_ALL_LOW)
533 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
534 else if (logic_pattern == PATTERN_ALL_HIGH)
535 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
536 } else if (ch->type == SR_CHANNEL_ANALOG) {
537 if (analog_pattern == -1)
539 sr_dbg("Setting analog pattern for channel %s to %s",
540 ch->name, analog_pattern_str[analog_pattern]);
541 ag = g_hash_table_lookup(devc->ch_ag, ch);
542 ag->pattern = analog_pattern;
547 case SR_CONF_AMPLITUDE:
549 return SR_ERR_CHANNEL_GROUP;
550 for (l = cg->channels; l; l = l->next) {
552 if (ch->type != SR_CHANNEL_ANALOG)
554 ag = g_hash_table_lookup(devc->ch_ag, ch);
555 ag->amplitude = g_variant_get_double(data);
565 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
566 const struct sr_channel_group *cg)
568 struct sr_channel *ch;
572 if (key == SR_CONF_SCAN_OPTIONS) {
573 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
574 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
578 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
579 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
580 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
589 case SR_CONF_DEVICE_OPTIONS:
590 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
591 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
593 case SR_CONF_SAMPLERATE:
594 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
595 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
596 ARRAY_SIZE(samplerates), sizeof(uint64_t));
597 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
598 *data = g_variant_builder_end(&gvb);
604 /* Any channel in the group will do. */
605 ch = cg->channels->data;
607 case SR_CONF_DEVICE_OPTIONS:
608 if (ch->type == SR_CHANNEL_LOGIC)
609 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
610 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
612 else if (ch->type == SR_CHANNEL_ANALOG)
613 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
614 devopts_cg_analog, ARRAY_SIZE(devopts_cg_analog),
619 case SR_CONF_PATTERN_MODE:
620 if (ch->type == SR_CHANNEL_LOGIC)
621 *data = g_variant_new_strv(logic_pattern_str,
622 ARRAY_SIZE(logic_pattern_str));
623 else if (ch->type == SR_CHANNEL_ANALOG)
624 *data = g_variant_new_strv(analog_pattern_str,
625 ARRAY_SIZE(analog_pattern_str));
637 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
639 struct dev_context *devc;
645 switch (devc->logic_pattern) {
647 memset(devc->logic_data, 0x00, size);
648 for (i = 0; i < size; i += devc->logic_unitsize) {
649 for (j = 0; j < devc->logic_unitsize; j++) {
650 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
651 devc->logic_data[i + j] = ~pat;
657 for (i = 0; i < size; i++)
658 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
661 for (i = 0; i < size; i++) {
662 for (j = 0; j < devc->logic_unitsize; j++) {
663 devc->logic_data[i + j] = devc->step;
668 case PATTERN_ALL_LOW:
669 case PATTERN_ALL_HIGH:
670 /* These were set when the pattern mode was selected. */
673 sr_err("Unknown pattern: %d.", devc->logic_pattern);
678 static void send_analog_packet(struct analog_gen *ag,
679 struct sr_dev_inst *sdi,
680 uint64_t *analog_sent,
681 uint64_t analog_todo)
683 struct sr_datafeed_packet packet;
684 struct dev_context *devc;
685 uint64_t sending_now, to_avg;
690 packet.type = SR_DF_ANALOG;
691 packet.payload = &ag->packet;
694 ag_pattern_pos = devc->analog_counter % ag->num_samples;
695 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
696 ag->packet.data = ag->pattern_data + ag_pattern_pos;
697 ag->packet.num_samples = sending_now;
698 sr_session_send(sdi, &packet);
700 /* Whichever channel group gets there first. */
701 *analog_sent = MAX(*analog_sent, sending_now);
703 ag_pattern_pos = devc->analog_counter % ag->num_samples;
704 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
706 for (i = 0; i < to_avg; i++) {
707 ag->avg_val = (ag->avg_val +
709 ag_pattern_pos + i)) / 2;
711 /* Time to send averaged data? */
712 if (devc->avg_samples > 0 &&
713 ag->num_avgs >= devc->avg_samples)
717 if (devc->avg_samples == 0) {
718 /* We're averaging all the samples, so wait with
719 * sending until the very end.
721 *analog_sent = ag->num_avgs;
726 ag->packet.data = &ag->avg_val;
727 ag->packet.num_samples = 1;
729 sr_session_send(sdi, &packet);
730 *analog_sent = ag->num_avgs;
737 /* Callback handling data */
738 static int prepare_data(int fd, int revents, void *cb_data)
740 struct sr_dev_inst *sdi;
741 struct dev_context *devc;
742 struct sr_datafeed_packet packet;
743 struct sr_datafeed_logic logic;
744 struct analog_gen *ag;
747 uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
748 int64_t time, elapsed;
755 logic_todo = analog_todo = 0;
757 /* How many samples should we have sent by now? */
758 time = g_get_monotonic_time();
759 elapsed = time - devc->starttime;
760 expected_samplenum = elapsed * devc->cur_samplerate / (1000 * 1000);
762 /* But never more than the limit, if there is one. */
763 if (!devc->continuous)
764 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
766 /* Of those, how many do we still have to send? */
767 if (devc->num_logic_channels)
768 logic_todo = expected_samplenum - devc->logic_counter;
769 if (devc->num_analog_channels)
770 analog_todo = expected_samplenum - devc->analog_counter;
772 while (logic_todo || analog_todo) {
774 if (logic_todo > 0) {
775 sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
776 logic_generator(sdi, sending_now * devc->logic_unitsize);
777 packet.type = SR_DF_LOGIC;
778 packet.payload = &logic;
779 logic.length = sending_now * devc->logic_unitsize;
780 logic.unitsize = devc->logic_unitsize;
781 logic.data = devc->logic_data;
782 sr_session_send(sdi, &packet);
783 logic_todo -= sending_now;
784 devc->logic_counter += sending_now;
787 /* Analog, one channel at a time */
788 if (analog_todo > 0) {
791 g_hash_table_iter_init(&iter, devc->ch_ag);
792 while (g_hash_table_iter_next(&iter, NULL, &value)) {
793 send_analog_packet(value, sdi,
794 &analog_sent, analog_todo);
796 analog_todo -= analog_sent;
797 devc->analog_counter += analog_sent;
801 if (!devc->continuous
802 && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
803 && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
804 /* If we're averaging everything - now is the time to send data */
805 if (devc->avg_samples == 0) {
806 g_hash_table_iter_init(&iter, devc->ch_ag);
807 while (g_hash_table_iter_next(&iter, NULL, &value)) {
809 packet.type = SR_DF_ANALOG;
810 packet.payload = &ag->packet;
811 ag->packet.data = &ag->avg_val;
812 ag->packet.num_samples = 1;
813 sr_session_send(sdi, &packet);
817 sr_dbg("Requested number of samples reached.");
818 dev_acquisition_stop(sdi, cb_data);
825 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
827 struct dev_context *devc;
833 if (sdi->status != SR_ST_ACTIVE)
834 return SR_ERR_DEV_CLOSED;
837 devc->continuous = !devc->limit_samples;
838 devc->logic_counter = devc->analog_counter = 0;
841 * Setting two channels connected by a pipe is a remnant from when the
842 * demo driver generated data in a thread, and collected and sent the
843 * data in the main program loop.
844 * They are kept here because it provides a convenient way of setting
845 * up a timeout-based polling mechanism.
847 if (pipe(devc->pipe_fds)) {
848 sr_err("%s: pipe() failed", __func__);
852 g_hash_table_iter_init(&iter, devc->ch_ag);
853 while (g_hash_table_iter_next(&iter, NULL, &value))
854 generate_analog_pattern(value, devc->cur_samplerate);
856 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
857 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
859 /* Set channel encoding to binary (default is UTF-8). */
860 g_io_channel_set_encoding(devc->channel, NULL, NULL);
862 /* Make channels unbuffered. */
863 g_io_channel_set_buffered(devc->channel, FALSE);
865 sr_session_source_add_channel(sdi->session, devc->channel,
866 G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
868 /* Send header packet to the session bus. */
869 std_session_send_df_header(sdi, LOG_PREFIX);
871 /* We use this timestamp to decide how many more samples to send. */
872 devc->starttime = g_get_monotonic_time();
877 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
879 struct dev_context *devc;
880 struct sr_datafeed_packet packet;
885 sr_dbg("Stopping acquisition.");
887 sr_session_source_remove_channel(sdi->session, devc->channel);
888 g_io_channel_shutdown(devc->channel, FALSE, NULL);
889 g_io_channel_unref(devc->channel);
890 devc->channel = NULL;
892 /* Send last packet. */
893 packet.type = SR_DF_END;
894 sr_session_send(sdi, &packet);
899 SR_PRIV struct sr_dev_driver demo_driver_info = {
901 .longname = "Demo driver and pattern generator",
906 .dev_list = dev_list,
908 .config_get = config_get,
909 .config_set = config_set,
910 .config_list = config_list,
911 .dev_open = dev_open,
912 .dev_close = dev_close,
913 .dev_acquisition_start = dev_acquisition_start,
914 .dev_acquisition_stop = dev_acquisition_stop,