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>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
30 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
32 #include "libsigrok.h"
33 #include "libsigrok-internal.h"
35 #define LOG_PREFIX "demo"
37 #define DEFAULT_NUM_LOGIC_CHANNELS 8
38 #define DEFAULT_NUM_ANALOG_CHANNELS 4
40 /* The size in bytes of chunks to send through the session bus. */
41 #define LOGIC_BUFSIZE 4096
42 /* Size of the analog pattern space per channel. */
43 #define ANALOG_BUFSIZE 4096
45 #define ANALOG_AMPLITUDE 25
46 #define ANALOG_SAMPLES_PER_PERIOD 20
48 /* Logic patterns we can generate. */
51 * Spells "sigrok" across 8 channels using '0's (with '1's as
52 * "background") when displayed using the 'bits' output format.
53 * The pattern is repeated every 8 channels, shifted to the right
58 /** Pseudo-random values on all channels. */
62 * Incrementing number across 8 channels. The pattern is repeated
63 * every 8 channels, shifted to the right in time by one bit.
67 /** All channels have a low logic state. */
70 /** All channels have a high logic state. */
74 /* Analog patterns we can generate. */
85 static const char *logic_pattern_str[] = {
93 static const char *analog_pattern_str[] = {
102 float pattern_data[ANALOG_BUFSIZE];
103 unsigned int num_samples;
104 struct sr_datafeed_analog packet;
107 /* Private, per-device-instance driver context. */
111 uint64_t cur_samplerate;
112 uint64_t limit_samples;
114 uint64_t logic_counter;
115 uint64_t analog_counter;
119 int32_t num_logic_channels;
120 unsigned int logic_unitsize;
121 /* There is only ever one logic channel group, so its pattern goes here. */
122 uint8_t logic_pattern;
123 unsigned char logic_data[LOGIC_BUFSIZE];
125 int32_t num_analog_channels;
126 GSList *analog_channel_groups;
129 static const int32_t scanopts[] = {
130 SR_CONF_NUM_LOGIC_CHANNELS,
131 SR_CONF_NUM_ANALOG_CHANNELS,
134 static const int devopts[] = {
135 SR_CONF_LOGIC_ANALYZER,
138 SR_CONF_LIMIT_SAMPLES,
142 static const int devopts_cg[] = {
143 SR_CONF_PATTERN_MODE,
146 static const uint64_t samplerates[] = {
152 static uint8_t pattern_sigrok[] = {
153 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
154 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
155 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
156 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
157 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
158 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
159 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
160 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
163 SR_PRIV struct sr_dev_driver demo_driver_info;
164 static struct sr_dev_driver *di = &demo_driver_info;
166 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
169 static int init(struct sr_context *sr_ctx)
171 return std_init(sr_ctx, di, LOG_PREFIX);
174 static void generate_analog_pattern(const struct sr_channel_group *cg, uint64_t sample_rate)
176 struct analog_gen *ag;
179 unsigned int num_samples, i;
183 num_samples = ANALOG_BUFSIZE / sizeof(float);
185 sr_dbg("Generating %s pattern for channel group %s",
186 analog_pattern_str[ag->pattern], cg->name);
188 switch (ag->pattern) {
190 value = ANALOG_AMPLITUDE;
192 for (i = 0; i < num_samples; i++) {
197 ag->pattern_data[i] = value;
199 ag->num_samples = last_end;
203 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
205 /* Make sure the number of samples we put out is an integer
206 * multiple of our period size */
207 /* FIXME we actually need only one period. A ringbuffer would be
209 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
212 for (i = 0; i < num_samples; i++) {
213 t = (double) i / (double) sample_rate;
214 ag->pattern_data[i] = ANALOG_AMPLITUDE *
215 sin(2 * M_PI * frequency * t);
218 ag->num_samples = num_samples;
221 case PATTERN_TRIANGLE:
222 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
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] = (2 * ANALOG_AMPLITUDE / M_PI) *
230 asin(sin(2 * M_PI * frequency * t));
233 ag->num_samples = num_samples;
236 case PATTERN_SAWTOOTH:
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 * ANALOG_AMPLITUDE *
245 ((t * frequency) - floor(0.5f + t * frequency));
248 ag->num_samples = num_samples;
253 static GSList *scan(GSList *options)
255 struct drv_context *drvc;
256 struct dev_context *devc;
257 struct sr_dev_inst *sdi;
258 struct sr_channel *ch;
259 struct sr_channel_group *cg;
260 struct sr_config *src;
261 struct analog_gen *ag;
263 int num_logic_channels, num_analog_channels, pattern, i;
264 char channel_name[16];
268 num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
269 num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
270 for (l = options; l; l = l->next) {
273 case SR_CONF_NUM_LOGIC_CHANNELS:
274 num_logic_channels = g_variant_get_int32(src->data);
276 case SR_CONF_NUM_ANALOG_CHANNELS:
277 num_analog_channels = g_variant_get_int32(src->data);
283 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
285 sr_err("Device instance creation failed.");
290 if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
291 sr_err("Device context malloc failed.");
294 devc->cur_samplerate = SR_KHZ(200);
295 devc->limit_samples = 0;
296 devc->limit_msec = 0;
298 devc->num_logic_channels = num_logic_channels;
299 devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
300 devc->logic_pattern = PATTERN_SIGROK;
301 devc->num_analog_channels = num_analog_channels;
302 devc->analog_channel_groups = NULL;
304 /* Logic channels, all in one channel group. */
305 if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
307 cg->name = g_strdup("Logic");
310 for (i = 0; i < num_logic_channels; i++) {
311 sprintf(channel_name, "D%d", i);
312 if (!(ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, channel_name)))
314 sdi->channels = g_slist_append(sdi->channels, ch);
315 cg->channels = g_slist_append(cg->channels, ch);
317 sdi->channel_groups = g_slist_append(NULL, cg);
319 /* Analog channels, channel groups and pattern generators. */
322 for (i = 0; i < num_analog_channels; i++) {
323 sprintf(channel_name, "A%d", i);
324 if (!(ch = sr_channel_new(i + num_logic_channels,
325 SR_CHANNEL_ANALOG, TRUE, channel_name)))
327 sdi->channels = g_slist_append(sdi->channels, ch);
329 /* Every analog channel gets its own channel group. */
330 if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
332 cg->name = g_strdup(channel_name);
333 cg->channels = g_slist_append(NULL, ch);
335 /* Every channel group gets a generator struct. */
336 if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
338 ag->packet.channels = cg->channels;
340 ag->packet.mqflags = 0;
341 ag->packet.unit = SR_UNIT_VOLT;
342 ag->packet.data = ag->pattern_data;
343 ag->pattern = pattern;
346 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
347 devc->analog_channel_groups = g_slist_append(devc->analog_channel_groups, cg);
349 if (++pattern == ARRAY_SIZE(analog_pattern_str))
354 devices = g_slist_append(devices, sdi);
355 drvc->instances = g_slist_append(drvc->instances, sdi);
360 static GSList *dev_list(void)
362 return ((struct drv_context *)(di->priv))->instances;
365 static int dev_open(struct sr_dev_inst *sdi)
367 sdi->status = SR_ST_ACTIVE;
372 static int dev_close(struct sr_dev_inst *sdi)
374 sdi->status = SR_ST_INACTIVE;
379 static int cleanup(void)
381 return std_dev_clear(di, NULL);
384 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
385 const struct sr_channel_group *cg)
387 struct dev_context *devc;
388 struct sr_channel *ch;
389 struct analog_gen *ag;
397 case SR_CONF_SAMPLERATE:
398 *data = g_variant_new_uint64(devc->cur_samplerate);
400 case SR_CONF_LIMIT_SAMPLES:
401 *data = g_variant_new_uint64(devc->limit_samples);
403 case SR_CONF_LIMIT_MSEC:
404 *data = g_variant_new_uint64(devc->limit_msec);
406 case SR_CONF_PATTERN_MODE:
408 return SR_ERR_CHANNEL_GROUP;
409 ch = cg->channels->data;
410 if (ch->type == SR_CHANNEL_LOGIC) {
411 pattern = devc->logic_pattern;
412 *data = g_variant_new_string(logic_pattern_str[pattern]);
413 } else if (ch->type == SR_CHANNEL_ANALOG) {
415 pattern = ag->pattern;
416 *data = g_variant_new_string(analog_pattern_str[pattern]);
420 case SR_CONF_NUM_LOGIC_CHANNELS:
421 *data = g_variant_new_int32(devc->num_logic_channels);
423 case SR_CONF_NUM_ANALOG_CHANNELS:
424 *data = g_variant_new_int32(devc->num_analog_channels);
433 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
434 const struct sr_channel_group *cg)
436 struct dev_context *devc;
437 struct analog_gen *ag;
438 struct sr_channel *ch;
445 if (sdi->status != SR_ST_ACTIVE)
446 return SR_ERR_DEV_CLOSED;
450 case SR_CONF_SAMPLERATE:
451 devc->cur_samplerate = g_variant_get_uint64(data);
452 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
454 case SR_CONF_LIMIT_SAMPLES:
455 devc->limit_msec = 0;
456 devc->limit_samples = g_variant_get_uint64(data);
457 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
459 case SR_CONF_LIMIT_MSEC:
460 devc->limit_msec = g_variant_get_uint64(data);
461 devc->limit_samples = 0;
462 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
464 case SR_CONF_PATTERN_MODE:
466 return SR_ERR_CHANNEL_GROUP;
467 stropt = g_variant_get_string(data, NULL);
468 ch = cg->channels->data;
470 if (ch->type == SR_CHANNEL_LOGIC) {
471 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
472 if (!strcmp(stropt, logic_pattern_str[i])) {
479 devc->logic_pattern = pattern;
481 /* Might as well do this now, these are static. */
482 if (pattern == PATTERN_ALL_LOW)
483 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
484 else if (pattern == PATTERN_ALL_HIGH)
485 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
486 sr_dbg("Setting logic pattern to %s",
487 logic_pattern_str[pattern]);
488 } else if (ch->type == SR_CHANNEL_ANALOG) {
489 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
490 if (!strcmp(stropt, analog_pattern_str[i])) {
497 sr_dbg("Setting analog pattern for channel group %s to %s",
498 cg->name, analog_pattern_str[pattern]);
500 ag->pattern = pattern;
511 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
512 const struct sr_channel_group *cg)
514 struct sr_channel *ch;
520 if (key == SR_CONF_SCAN_OPTIONS) {
521 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
522 scanopts, ARRAY_SIZE(scanopts), sizeof(int32_t));
531 case SR_CONF_DEVICE_OPTIONS:
532 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
533 devopts, ARRAY_SIZE(devopts), sizeof(int32_t));
535 case SR_CONF_SAMPLERATE:
536 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
537 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
538 ARRAY_SIZE(samplerates), sizeof(uint64_t));
539 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
540 *data = g_variant_builder_end(&gvb);
546 ch = cg->channels->data;
548 case SR_CONF_DEVICE_OPTIONS:
549 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
550 devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(int32_t));
552 case SR_CONF_PATTERN_MODE:
553 if (ch->type == SR_CHANNEL_LOGIC)
554 *data = g_variant_new_strv(logic_pattern_str,
555 ARRAY_SIZE(logic_pattern_str));
556 else if (ch->type == SR_CHANNEL_ANALOG)
557 *data = g_variant_new_strv(analog_pattern_str,
558 ARRAY_SIZE(analog_pattern_str));
570 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
572 struct dev_context *devc;
578 switch (devc->logic_pattern) {
580 memset(devc->logic_data, 0x00, size);
581 for (i = 0; i < size; i += devc->logic_unitsize) {
582 for (j = 0; j < devc->logic_unitsize; j++) {
583 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
584 devc->logic_data[i + j] = ~pat;
590 for (i = 0; i < size; i++)
591 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
594 for (i = 0; i < size; i++) {
595 for (j = 0; j < devc->logic_unitsize; j++) {
596 devc->logic_data[i + j] = devc->step;
601 case PATTERN_ALL_LOW:
602 case PATTERN_ALL_HIGH:
603 /* These were set when the pattern mode was selected. */
606 sr_err("Unknown pattern: %d.", devc->logic_pattern);
611 /* Callback handling data */
612 static int prepare_data(int fd, int revents, void *cb_data)
614 struct sr_dev_inst *sdi;
615 struct dev_context *devc;
616 struct sr_datafeed_packet packet;
617 struct sr_datafeed_logic logic;
618 struct sr_channel_group *cg;
619 struct analog_gen *ag;
621 uint64_t logic_todo, analog_todo, expected_samplenum, analog_samples, sending_now;
622 int64_t time, elapsed;
630 /* How many "virtual" samples should we have collected by now? */
631 time = g_get_monotonic_time();
632 elapsed = time - devc->starttime;
633 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
635 /* Of those, how many do we still have to send? */
636 logic_todo = MIN(expected_samplenum, devc->limit_samples) - devc->logic_counter;
637 analog_todo = MIN(expected_samplenum, devc->limit_samples) - devc->analog_counter;
639 while (logic_todo || analog_todo) {
641 if (devc->num_logic_channels > 0 && logic_todo > 0) {
642 sending_now = MIN(logic_todo,
643 LOGIC_BUFSIZE / devc->logic_unitsize);
644 logic_generator(sdi, sending_now * devc->logic_unitsize);
645 packet.type = SR_DF_LOGIC;
646 packet.payload = &logic;
647 logic.length = sending_now * devc->logic_unitsize;
648 logic.unitsize = devc->logic_unitsize;
649 logic.data = devc->logic_data;
650 sr_session_send(sdi, &packet);
651 logic_todo -= sending_now;
652 devc->logic_counter += sending_now;
655 /* Analog, one channel at a time */
656 if (devc->num_analog_channels > 0 && analog_todo > 0) {
658 for (l = devc->analog_channel_groups; l; l = l->next) {
661 packet.type = SR_DF_ANALOG;
662 packet.payload = &ag->packet;
664 /* FIXME we should make sure we output a whole
665 * period of data before we send out again the
666 * beginning of our buffer. A ring buffer would
667 * help here as well */
669 analog_samples = MIN(analog_todo, ag->num_samples);
670 /* Whichever channel group gets there first. */
671 sending_now = MAX(sending_now, analog_samples);
672 ag->packet.num_samples = analog_samples;
673 sr_session_send(sdi, &packet);
675 analog_todo -= sending_now;
676 devc->analog_counter += sending_now;
680 if (devc->logic_counter >= devc->limit_samples &&
681 devc->analog_counter >= devc->limit_samples) {
682 sr_dbg("Requested number of samples reached.");
683 dev_acquisition_stop(sdi, cb_data);
690 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
693 struct dev_context *devc;
695 if (sdi->status != SR_ST_ACTIVE)
696 return SR_ERR_DEV_CLOSED;
699 if (devc->limit_samples == 0)
701 devc->logic_counter = devc->analog_counter = 0;
704 * Setting two channels connected by a pipe is a remnant from when the
705 * demo driver generated data in a thread, and collected and sent the
706 * data in the main program loop.
707 * They are kept here because it provides a convenient way of setting
708 * up a timeout-based polling mechanism.
710 if (pipe(devc->pipe_fds)) {
711 sr_err("%s: pipe() failed", __func__);
715 for (l = devc->analog_channel_groups; l; l = l->next) {
716 generate_analog_pattern(l->data, devc->cur_samplerate);
719 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
721 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
723 /* Set channel encoding to binary (default is UTF-8). */
724 g_io_channel_set_encoding(devc->channel, NULL, NULL);
726 /* Make channels to unbuffered. */
727 g_io_channel_set_buffered(devc->channel, FALSE);
729 sr_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
730 40, prepare_data, (void *)sdi);
732 /* Send header packet to the session bus. */
733 std_session_send_df_header(cb_data, LOG_PREFIX);
735 /* We use this timestamp to decide how many more samples to send. */
736 devc->starttime = g_get_monotonic_time();
741 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
743 struct dev_context *devc;
744 struct sr_datafeed_packet packet;
749 sr_dbg("Stopping acquisition.");
751 sr_source_remove_channel(devc->channel);
752 g_io_channel_shutdown(devc->channel, FALSE, NULL);
753 g_io_channel_unref(devc->channel);
754 devc->channel = NULL;
756 /* Send last packet. */
757 packet.type = SR_DF_END;
758 sr_session_send(sdi, &packet);
763 SR_PRIV struct sr_dev_driver demo_driver_info = {
765 .longname = "Demo driver and pattern generator",
770 .dev_list = dev_list,
772 .config_get = config_get,
773 .config_set = config_set,
774 .config_list = config_list,
775 .dev_open = dev_open,
776 .dev_close = dev_close,
777 .dev_acquisition_start = dev_acquisition_start,
778 .dev_acquisition_stop = dev_acquisition_stop,