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/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_group[] = {
161 SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
164 static const uint32_t devopts_cg_analog_channel[] = {
165 SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
166 SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
169 static const uint64_t samplerates[] = {
175 static const uint8_t pattern_sigrok[] = {
176 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
177 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
178 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
179 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
180 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
181 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
182 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
183 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
186 SR_PRIV struct sr_dev_driver demo_driver_info;
188 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
190 static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
192 return std_init(sr_ctx, di, LOG_PREFIX);
195 static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
199 unsigned int num_samples, i;
202 sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
204 num_samples = ANALOG_BUFSIZE / sizeof(float);
206 switch (ag->pattern) {
208 value = ag->amplitude;
210 for (i = 0; i < num_samples; i++) {
215 ag->pattern_data[i] = value;
217 ag->num_samples = last_end;
220 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
222 /* Make sure the number of samples we put out is an integer
223 * multiple of our period size */
224 /* FIXME we actually need only one period. A ringbuffer would be
226 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
229 for (i = 0; i < num_samples; i++) {
230 t = (double) i / (double) sample_rate;
231 ag->pattern_data[i] = ag->amplitude *
232 sin(2 * G_PI * frequency * t);
235 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 / G_PI) *
246 asin(sin(2 * G_PI * frequency * t));
249 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->context))->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);
492 case SR_CONF_LIMIT_SAMPLES:
493 devc->limit_msec = 0;
494 devc->limit_samples = g_variant_get_uint64(data);
496 case SR_CONF_LIMIT_MSEC:
497 devc->limit_msec = g_variant_get_uint64(data);
498 devc->limit_samples = 0;
500 case SR_CONF_AVERAGING:
501 devc->avg = g_variant_get_boolean(data);
502 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
504 case SR_CONF_AVG_SAMPLES:
505 devc->avg_samples = g_variant_get_uint64(data);
506 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
508 case SR_CONF_PATTERN_MODE:
510 return SR_ERR_CHANNEL_GROUP;
511 stropt = g_variant_get_string(data, NULL);
512 logic_pattern = analog_pattern = -1;
513 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
514 if (!strcmp(stropt, logic_pattern_str[i])) {
519 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
520 if (!strcmp(stropt, analog_pattern_str[i])) {
525 if (logic_pattern == -1 && analog_pattern == -1)
527 for (l = cg->channels; l; l = l->next) {
529 if (ch->type == SR_CHANNEL_LOGIC) {
530 if (logic_pattern == -1)
532 sr_dbg("Setting logic pattern to %s",
533 logic_pattern_str[logic_pattern]);
534 devc->logic_pattern = logic_pattern;
535 /* Might as well do this now, these are static. */
536 if (logic_pattern == PATTERN_ALL_LOW)
537 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
538 else if (logic_pattern == PATTERN_ALL_HIGH)
539 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
540 } else if (ch->type == SR_CHANNEL_ANALOG) {
541 if (analog_pattern == -1)
543 sr_dbg("Setting analog pattern for channel %s to %s",
544 ch->name, analog_pattern_str[analog_pattern]);
545 ag = g_hash_table_lookup(devc->ch_ag, ch);
546 ag->pattern = analog_pattern;
551 case SR_CONF_AMPLITUDE:
553 return SR_ERR_CHANNEL_GROUP;
554 for (l = cg->channels; l; l = l->next) {
556 if (ch->type != SR_CHANNEL_ANALOG)
558 ag = g_hash_table_lookup(devc->ch_ag, ch);
559 ag->amplitude = g_variant_get_double(data);
569 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
570 const struct sr_channel_group *cg)
572 struct sr_channel *ch;
576 if (key == SR_CONF_SCAN_OPTIONS) {
577 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
578 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
582 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
583 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
584 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
593 case SR_CONF_DEVICE_OPTIONS:
594 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
595 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
597 case SR_CONF_SAMPLERATE:
598 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
599 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
600 ARRAY_SIZE(samplerates), sizeof(uint64_t));
601 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
602 *data = g_variant_builder_end(&gvb);
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_UINT32,
613 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
615 else if (ch->type == SR_CHANNEL_ANALOG) {
616 if (strcmp(cg->name, "Analog") == 0)
617 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
618 devopts_cg_analog_group, ARRAY_SIZE(devopts_cg_analog_group),
621 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
622 devopts_cg_analog_channel, ARRAY_SIZE(devopts_cg_analog_channel),
628 case SR_CONF_PATTERN_MODE:
629 /* The analog group (with all 4 channels) shall not have a pattern property. */
630 if (strcmp(cg->name, "Analog") == 0)
633 if (ch->type == SR_CHANNEL_LOGIC)
634 *data = g_variant_new_strv(logic_pattern_str,
635 ARRAY_SIZE(logic_pattern_str));
636 else if (ch->type == SR_CHANNEL_ANALOG)
637 *data = g_variant_new_strv(analog_pattern_str,
638 ARRAY_SIZE(analog_pattern_str));
650 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
652 struct dev_context *devc;
658 switch (devc->logic_pattern) {
660 memset(devc->logic_data, 0x00, size);
661 for (i = 0; i < size; i += devc->logic_unitsize) {
662 for (j = 0; j < devc->logic_unitsize; j++) {
663 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
664 devc->logic_data[i + j] = ~pat;
670 for (i = 0; i < size; i++)
671 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
674 for (i = 0; i < size; i++) {
675 for (j = 0; j < devc->logic_unitsize; j++) {
676 devc->logic_data[i + j] = devc->step;
681 case PATTERN_ALL_LOW:
682 case PATTERN_ALL_HIGH:
683 /* These were set when the pattern mode was selected. */
686 sr_err("Unknown pattern: %d.", devc->logic_pattern);
691 static void send_analog_packet(struct analog_gen *ag,
692 struct sr_dev_inst *sdi,
693 uint64_t *analog_sent,
694 uint64_t analog_todo)
696 struct sr_datafeed_packet packet;
697 struct dev_context *devc;
698 uint64_t sending_now, to_avg;
703 packet.type = SR_DF_ANALOG;
704 packet.payload = &ag->packet;
707 ag_pattern_pos = devc->analog_counter % ag->num_samples;
708 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
709 ag->packet.data = ag->pattern_data + ag_pattern_pos;
710 ag->packet.num_samples = sending_now;
711 sr_session_send(sdi, &packet);
713 /* Whichever channel group gets there first. */
714 *analog_sent = MAX(*analog_sent, sending_now);
716 ag_pattern_pos = devc->analog_counter % ag->num_samples;
717 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
719 for (i = 0; i < to_avg; i++) {
720 ag->avg_val = (ag->avg_val +
722 ag_pattern_pos + i)) / 2;
724 /* Time to send averaged data? */
725 if (devc->avg_samples > 0 &&
726 ag->num_avgs >= devc->avg_samples)
730 if (devc->avg_samples == 0) {
731 /* We're averaging all the samples, so wait with
732 * sending until the very end.
734 *analog_sent = ag->num_avgs;
739 ag->packet.data = &ag->avg_val;
740 ag->packet.num_samples = 1;
742 sr_session_send(sdi, &packet);
743 *analog_sent = ag->num_avgs;
750 /* Callback handling data */
751 static int prepare_data(int fd, int revents, void *cb_data)
753 struct sr_dev_inst *sdi;
754 struct dev_context *devc;
755 struct sr_datafeed_packet packet;
756 struct sr_datafeed_logic logic;
757 struct analog_gen *ag;
760 uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
761 int64_t time, elapsed;
768 logic_todo = analog_todo = 0;
770 /* How many samples should we have sent by now? */
771 time = g_get_monotonic_time();
772 elapsed = time - devc->starttime;
773 expected_samplenum = elapsed * devc->cur_samplerate / (1000 * 1000);
775 /* But never more than the limit, if there is one. */
776 if (!devc->continuous)
777 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
779 /* Of those, how many do we still have to send? */
780 if (devc->num_logic_channels && (devc->logic_counter < devc->limit_samples))
781 logic_todo = expected_samplenum - devc->logic_counter;
782 if (devc->num_analog_channels && (devc->analog_counter < devc->limit_samples))
783 analog_todo = expected_samplenum - devc->analog_counter;
785 while (logic_todo || analog_todo) {
787 if (logic_todo > 0) {
788 sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
789 logic_generator(sdi, sending_now * devc->logic_unitsize);
790 packet.type = SR_DF_LOGIC;
791 packet.payload = &logic;
792 logic.length = sending_now * devc->logic_unitsize;
793 logic.unitsize = devc->logic_unitsize;
794 logic.data = devc->logic_data;
795 sr_session_send(sdi, &packet);
796 logic_todo -= sending_now;
797 devc->logic_counter += sending_now;
800 /* Analog, one channel at a time */
801 if (analog_todo > 0) {
804 g_hash_table_iter_init(&iter, devc->ch_ag);
805 while (g_hash_table_iter_next(&iter, NULL, &value)) {
806 send_analog_packet(value, sdi,
807 &analog_sent, analog_todo);
809 analog_todo -= analog_sent;
810 devc->analog_counter += analog_sent;
814 if (!devc->continuous
815 && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
816 && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
817 /* If we're averaging everything - now is the time to send data */
818 if (devc->avg_samples == 0) {
819 g_hash_table_iter_init(&iter, devc->ch_ag);
820 while (g_hash_table_iter_next(&iter, NULL, &value)) {
822 packet.type = SR_DF_ANALOG;
823 packet.payload = &ag->packet;
824 ag->packet.data = &ag->avg_val;
825 ag->packet.num_samples = 1;
826 sr_session_send(sdi, &packet);
830 sr_dbg("Requested number of samples reached.");
831 dev_acquisition_stop(sdi, cb_data);
838 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
840 struct dev_context *devc;
846 if (sdi->status != SR_ST_ACTIVE)
847 return SR_ERR_DEV_CLOSED;
850 devc->continuous = !devc->limit_samples;
851 devc->logic_counter = devc->analog_counter = 0;
854 * Setting two channels connected by a pipe is a remnant from when the
855 * demo driver generated data in a thread, and collected and sent the
856 * data in the main program loop.
857 * They are kept here because it provides a convenient way of setting
858 * up a timeout-based polling mechanism.
860 if (pipe(devc->pipe_fds)) {
861 sr_err("%s: pipe() failed", __func__);
865 g_hash_table_iter_init(&iter, devc->ch_ag);
866 while (g_hash_table_iter_next(&iter, NULL, &value))
867 generate_analog_pattern(value, devc->cur_samplerate);
869 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
870 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
872 /* Set channel encoding to binary (default is UTF-8). */
873 g_io_channel_set_encoding(devc->channel, NULL, NULL);
875 /* Make channels unbuffered. */
876 g_io_channel_set_buffered(devc->channel, FALSE);
878 sr_session_source_add_channel(sdi->session, devc->channel,
879 G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
881 /* Send header packet to the session bus. */
882 std_session_send_df_header(sdi, LOG_PREFIX);
884 /* We use this timestamp to decide how many more samples to send. */
885 devc->starttime = g_get_monotonic_time();
890 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
892 struct dev_context *devc;
893 struct sr_datafeed_packet packet;
898 sr_dbg("Stopping acquisition.");
900 sr_session_source_remove_channel(sdi->session, devc->channel);
901 g_io_channel_shutdown(devc->channel, FALSE, NULL);
902 g_io_channel_unref(devc->channel);
903 devc->channel = NULL;
904 close(devc->pipe_fds[0]);
905 close(devc->pipe_fds[1]);
907 /* Send last packet. */
908 packet.type = SR_DF_END;
909 sr_session_send(sdi, &packet);
914 SR_PRIV struct sr_dev_driver demo_driver_info = {
916 .longname = "Demo driver and pattern generator",
921 .dev_list = dev_list,
923 .config_get = config_get,
924 .config_set = config_set,
925 .config_list = config_list,
926 .dev_open = dev_open,
927 .dev_close = dev_close,
928 .dev_acquisition_start = dev_acquisition_start,
929 .dev_acquisition_stop = dev_acquisition_stop,