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 DEFAULT_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[] = {
103 float pattern_data[ANALOG_BUFSIZE];
104 unsigned int num_samples;
105 struct sr_datafeed_analog packet;
108 /* Private, per-device-instance driver context. */
112 uint64_t cur_samplerate;
114 uint64_t limit_samples;
116 uint64_t logic_counter;
117 uint64_t analog_counter;
121 int32_t num_logic_channels;
122 unsigned int logic_unitsize;
123 /* There is only ever one logic channel group, so its pattern goes here. */
124 uint8_t logic_pattern;
125 unsigned char logic_data[LOGIC_BUFSIZE];
127 int32_t num_analog_channels;
131 static const uint32_t scanopts[] = {
132 SR_CONF_NUM_LOGIC_CHANNELS,
133 SR_CONF_NUM_ANALOG_CHANNELS,
136 static const int devopts[] = {
137 SR_CONF_LOGIC_ANALYZER,
141 SR_CONF_LIMIT_SAMPLES,
145 static const int devopts_cg_logic[] = {
146 SR_CONF_PATTERN_MODE,
149 static const int devopts_cg_analog[] = {
150 SR_CONF_PATTERN_MODE,
154 static const uint64_t samplerates[] = {
160 static uint8_t pattern_sigrok[] = {
161 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
162 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
163 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
164 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
165 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
166 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
167 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
168 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
171 SR_PRIV struct sr_dev_driver demo_driver_info;
172 static struct sr_dev_driver *di = &demo_driver_info;
174 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
177 static int init(struct sr_context *sr_ctx)
179 return std_init(sr_ctx, di, LOG_PREFIX);
182 static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
186 unsigned int num_samples, i;
189 sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
191 num_samples = ANALOG_BUFSIZE / sizeof(float);
193 switch (ag->pattern) {
195 value = ag->amplitude;
197 for (i = 0; i < num_samples; i++) {
202 ag->pattern_data[i] = value;
204 ag->num_samples = last_end;
208 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
210 /* Make sure the number of samples we put out is an integer
211 * multiple of our period size */
212 /* FIXME we actually need only one period. A ringbuffer would be
214 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
217 for (i = 0; i < num_samples; i++) {
218 t = (double) i / (double) sample_rate;
219 ag->pattern_data[i] = ag->amplitude *
220 sin(2 * M_PI * frequency * t);
223 ag->num_samples = num_samples;
226 case PATTERN_TRIANGLE:
227 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
229 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
232 for (i = 0; i < num_samples; i++) {
233 t = (double) i / (double) sample_rate;
234 ag->pattern_data[i] = (2 * ag->amplitude / M_PI) *
235 asin(sin(2 * M_PI * frequency * t));
238 ag->num_samples = num_samples;
241 case PATTERN_SAWTOOTH:
242 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
244 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
247 for (i = 0; i < num_samples; i++) {
248 t = (double) i / (double) sample_rate;
249 ag->pattern_data[i] = 2 * ag->amplitude *
250 ((t * frequency) - floor(0.5f + t * frequency));
253 ag->num_samples = num_samples;
258 static GSList *scan(GSList *options)
260 struct drv_context *drvc;
261 struct dev_context *devc;
262 struct sr_dev_inst *sdi;
263 struct sr_channel *ch;
264 struct sr_channel_group *cg, *acg;
265 struct sr_config *src;
266 struct analog_gen *ag;
268 int num_logic_channels, num_analog_channels, pattern, i;
269 char channel_name[16];
273 num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
274 num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
275 for (l = options; l; l = l->next) {
278 case SR_CONF_NUM_LOGIC_CHANNELS:
279 num_logic_channels = g_variant_get_int32(src->data);
281 case SR_CONF_NUM_ANALOG_CHANNELS:
282 num_analog_channels = g_variant_get_int32(src->data);
288 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
290 sr_err("Device instance creation failed.");
295 devc = g_malloc(sizeof(struct dev_context));
296 devc->cur_samplerate = SR_KHZ(200);
297 devc->limit_samples = 0;
298 devc->limit_msec = 0;
300 devc->continuous = FALSE;
301 devc->num_logic_channels = num_logic_channels;
302 devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
303 devc->logic_pattern = PATTERN_SIGROK;
304 devc->num_analog_channels = num_analog_channels;
306 /* Logic channels, all in one channel group. */
307 cg = g_malloc0(sizeof(struct sr_channel_group));
308 cg->name = g_strdup("Logic");
309 for (i = 0; i < num_logic_channels; i++) {
310 sprintf(channel_name, "D%d", i);
311 if (!(ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, channel_name)))
313 sdi->channels = g_slist_append(sdi->channels, ch);
314 cg->channels = g_slist_append(cg->channels, ch);
316 sdi->channel_groups = g_slist_append(NULL, cg);
318 /* Analog channels, channel groups and pattern generators. */
320 /* An "Analog" channel group with all analog channels in it. */
321 acg = g_malloc0(sizeof(struct sr_channel_group));
322 acg->name = g_strdup("Analog");
323 sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
325 devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
326 for (i = 0; i < num_analog_channels; i++) {
327 snprintf(channel_name, 16, "A%d", i);
328 ch = sr_channel_new(i + num_logic_channels, SR_CHANNEL_ANALOG,
330 sdi->channels = g_slist_append(sdi->channels, ch);
331 acg->channels = g_slist_append(acg->channels, ch);
333 /* Every analog channel gets its own channel group as well. */
334 cg = g_malloc0(sizeof(struct sr_channel_group));
335 cg->name = g_strdup(channel_name);
336 cg->channels = g_slist_append(NULL, ch);
337 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
339 /* Every channel gets a generator struct. */
340 ag = g_malloc(sizeof(struct analog_gen));
341 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
342 ag->packet.channels = cg->channels;
344 ag->packet.mqflags = 0;
345 ag->packet.unit = SR_UNIT_VOLT;
346 ag->packet.data = ag->pattern_data;
347 ag->pattern = pattern;
348 g_hash_table_insert(devc->ch_ag, ch, ag);
350 if (++pattern == ARRAY_SIZE(analog_pattern_str))
355 devices = g_slist_append(devices, sdi);
356 drvc->instances = g_slist_append(drvc->instances, sdi);
361 static GSList *dev_list(void)
363 return ((struct drv_context *)(di->priv))->instances;
366 static int dev_open(struct sr_dev_inst *sdi)
368 sdi->status = SR_ST_ACTIVE;
373 static int dev_close(struct sr_dev_inst *sdi)
375 sdi->status = SR_ST_INACTIVE;
380 static void clear_helper(void *priv)
382 struct dev_context *devc;
388 /* Analog generators. */
389 g_hash_table_iter_init(&iter, devc->ch_ag);
390 while (g_hash_table_iter_next(&iter, NULL, &value))
392 g_hash_table_unref(devc->ch_ag);
396 static int cleanup(void)
398 return std_dev_clear(di, clear_helper);
401 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
402 const struct sr_channel_group *cg)
404 struct dev_context *devc;
405 struct sr_channel *ch;
406 struct analog_gen *ag;
414 case SR_CONF_SAMPLERATE:
415 *data = g_variant_new_uint64(devc->cur_samplerate);
417 case SR_CONF_LIMIT_SAMPLES:
418 *data = g_variant_new_uint64(devc->limit_samples);
420 case SR_CONF_LIMIT_MSEC:
421 *data = g_variant_new_uint64(devc->limit_msec);
423 case SR_CONF_PATTERN_MODE:
425 return SR_ERR_CHANNEL_GROUP;
426 /* Any channel in the group will do. */
427 ch = cg->channels->data;
428 if (ch->type == SR_CHANNEL_LOGIC) {
429 pattern = devc->logic_pattern;
430 *data = g_variant_new_string(logic_pattern_str[pattern]);
431 } else if (ch->type == SR_CHANNEL_ANALOG) {
432 ag = g_hash_table_lookup(devc->ch_ag, ch);
433 pattern = ag->pattern;
434 *data = g_variant_new_string(analog_pattern_str[pattern]);
438 case SR_CONF_NUM_LOGIC_CHANNELS:
439 *data = g_variant_new_int32(devc->num_logic_channels);
441 case SR_CONF_NUM_ANALOG_CHANNELS:
442 *data = g_variant_new_int32(devc->num_analog_channels);
444 case SR_CONF_AMPLITUDE:
446 return SR_ERR_CHANNEL_GROUP;
447 /* Any channel in the group will do. */
448 ch = cg->channels->data;
449 if (ch->type != SR_CHANNEL_ANALOG)
451 ag = g_hash_table_lookup(devc->ch_ag, ch);
452 *data = g_variant_new_double(ag->amplitude);
461 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
462 const struct sr_channel_group *cg)
464 struct dev_context *devc;
465 struct analog_gen *ag;
466 struct sr_channel *ch;
468 int logic_pattern, analog_pattern, ret;
474 if (sdi->status != SR_ST_ACTIVE)
475 return SR_ERR_DEV_CLOSED;
479 case SR_CONF_SAMPLERATE:
480 devc->cur_samplerate = g_variant_get_uint64(data);
481 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
483 case SR_CONF_LIMIT_SAMPLES:
484 devc->limit_msec = 0;
485 devc->limit_samples = g_variant_get_uint64(data);
486 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
488 case SR_CONF_LIMIT_MSEC:
489 devc->limit_msec = g_variant_get_uint64(data);
490 devc->limit_samples = 0;
491 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
493 case SR_CONF_PATTERN_MODE:
495 return SR_ERR_CHANNEL_GROUP;
496 stropt = g_variant_get_string(data, NULL);
497 ch = cg->channels->data;
498 logic_pattern = analog_pattern = -1;
499 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
500 if (!strcmp(stropt, logic_pattern_str[i])) {
505 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
506 if (!strcmp(stropt, analog_pattern_str[i])) {
511 if (logic_pattern == -1 && analog_pattern == -1)
513 for (l = cg->channels; l; l = l->next) {
515 if (ch->type == SR_CHANNEL_LOGIC) {
516 if (logic_pattern == -1)
518 sr_dbg("Setting logic pattern to %s",
519 logic_pattern_str[logic_pattern]);
520 devc->logic_pattern = logic_pattern;
521 /* Might as well do this now, these are static. */
522 if (logic_pattern == PATTERN_ALL_LOW)
523 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
524 else if (logic_pattern == PATTERN_ALL_HIGH)
525 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
526 } else if (ch->type == SR_CHANNEL_ANALOG) {
527 if (analog_pattern == -1)
529 sr_dbg("Setting analog pattern for channel %s to %s",
530 ch->name, analog_pattern_str[analog_pattern]);
531 ag = g_hash_table_lookup(devc->ch_ag, ch);
532 ag->pattern = analog_pattern;
537 case SR_CONF_AMPLITUDE:
539 return SR_ERR_CHANNEL_GROUP;
540 for (l = cg->channels; l; l = l->next) {
542 if (ch->type != SR_CHANNEL_ANALOG)
544 ag = g_hash_table_lookup(devc->ch_ag, ch);
545 ag->amplitude = g_variant_get_double(data);
555 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
556 const struct sr_channel_group *cg)
558 struct sr_channel *ch;
564 if (key == SR_CONF_SCAN_OPTIONS) {
565 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
566 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
575 case SR_CONF_DEVICE_OPTIONS:
576 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
577 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
579 case SR_CONF_SAMPLERATE:
580 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
581 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
582 ARRAY_SIZE(samplerates), sizeof(uint64_t));
583 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
584 *data = g_variant_builder_end(&gvb);
590 /* Any channel in the group will do. */
591 ch = cg->channels->data;
593 case SR_CONF_DEVICE_OPTIONS:
594 if (ch->type == SR_CHANNEL_LOGIC)
595 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
596 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
598 else if (ch->type == SR_CHANNEL_ANALOG)
599 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
600 devopts_cg_analog, ARRAY_SIZE(devopts_cg_analog),
605 case SR_CONF_PATTERN_MODE:
606 if (ch->type == SR_CHANNEL_LOGIC)
607 *data = g_variant_new_strv(logic_pattern_str,
608 ARRAY_SIZE(logic_pattern_str));
609 else if (ch->type == SR_CHANNEL_ANALOG)
610 *data = g_variant_new_strv(analog_pattern_str,
611 ARRAY_SIZE(analog_pattern_str));
623 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
625 struct dev_context *devc;
631 switch (devc->logic_pattern) {
633 memset(devc->logic_data, 0x00, size);
634 for (i = 0; i < size; i += devc->logic_unitsize) {
635 for (j = 0; j < devc->logic_unitsize; j++) {
636 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
637 devc->logic_data[i + j] = ~pat;
643 for (i = 0; i < size; i++)
644 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
647 for (i = 0; i < size; i++) {
648 for (j = 0; j < devc->logic_unitsize; j++) {
649 devc->logic_data[i + j] = devc->step;
654 case PATTERN_ALL_LOW:
655 case PATTERN_ALL_HIGH:
656 /* These were set when the pattern mode was selected. */
659 sr_err("Unknown pattern: %d.", devc->logic_pattern);
664 /* Callback handling data */
665 static int prepare_data(int fd, int revents, void *cb_data)
667 struct sr_dev_inst *sdi;
668 struct dev_context *devc;
669 struct sr_datafeed_packet packet;
670 struct sr_datafeed_logic logic;
671 struct analog_gen *ag;
674 uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
675 int64_t time, elapsed;
682 logic_todo = analog_todo = 0;
684 /* How many samples should we have sent by now? */
685 time = g_get_monotonic_time();
686 elapsed = time - devc->starttime;
687 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
689 /* But never more than the limit, if there is one. */
690 if (!devc->continuous)
691 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
693 /* Of those, how many do we still have to send? */
694 if (devc->num_logic_channels)
695 logic_todo = expected_samplenum - devc->logic_counter;
696 if (devc->num_analog_channels)
697 analog_todo = expected_samplenum - devc->analog_counter;
699 while (logic_todo || analog_todo) {
701 if (logic_todo > 0) {
702 sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
703 logic_generator(sdi, sending_now * devc->logic_unitsize);
704 packet.type = SR_DF_LOGIC;
705 packet.payload = &logic;
706 logic.length = sending_now * devc->logic_unitsize;
707 logic.unitsize = devc->logic_unitsize;
708 logic.data = devc->logic_data;
709 sr_session_send(sdi, &packet);
710 logic_todo -= sending_now;
711 devc->logic_counter += sending_now;
714 /* Analog, one channel at a time */
715 if (analog_todo > 0) {
718 g_hash_table_iter_init(&iter, devc->ch_ag);
719 while (g_hash_table_iter_next(&iter, NULL, &value)) {
721 packet.type = SR_DF_ANALOG;
722 packet.payload = &ag->packet;
724 /* FIXME we should make sure we output a whole
725 * period of data before we send out again the
726 * beginning of our buffer. A ring buffer would
727 * help here as well */
729 sending_now = MIN(analog_todo, ag->num_samples);
730 ag->packet.num_samples = sending_now;
731 sr_session_send(sdi, &packet);
733 /* Whichever channel group gets there first. */
734 analog_sent = MAX(analog_sent, sending_now);
736 analog_todo -= analog_sent;
737 devc->analog_counter += analog_sent;
741 if (!devc->continuous
742 && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
743 && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
744 sr_dbg("Requested number of samples reached.");
745 dev_acquisition_stop(sdi, cb_data);
752 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
754 struct dev_context *devc;
760 if (sdi->status != SR_ST_ACTIVE)
761 return SR_ERR_DEV_CLOSED;
764 devc->continuous = !devc->limit_samples;
765 devc->logic_counter = devc->analog_counter = 0;
768 * Setting two channels connected by a pipe is a remnant from when the
769 * demo driver generated data in a thread, and collected and sent the
770 * data in the main program loop.
771 * They are kept here because it provides a convenient way of setting
772 * up a timeout-based polling mechanism.
774 if (pipe(devc->pipe_fds)) {
775 sr_err("%s: pipe() failed", __func__);
779 g_hash_table_iter_init(&iter, devc->ch_ag);
780 while (g_hash_table_iter_next(&iter, NULL, &value))
781 generate_analog_pattern(value, devc->cur_samplerate);
783 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
784 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
786 /* Set channel encoding to binary (default is UTF-8). */
787 g_io_channel_set_encoding(devc->channel, NULL, NULL);
789 /* Make channels unbuffered. */
790 g_io_channel_set_buffered(devc->channel, FALSE);
792 sr_session_source_add_channel(sdi->session, devc->channel,
793 G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
795 /* Send header packet to the session bus. */
796 std_session_send_df_header(sdi, LOG_PREFIX);
798 /* We use this timestamp to decide how many more samples to send. */
799 devc->starttime = g_get_monotonic_time();
804 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
806 struct dev_context *devc;
807 struct sr_datafeed_packet packet;
812 sr_dbg("Stopping acquisition.");
814 sr_session_source_remove_channel(sdi->session, devc->channel);
815 g_io_channel_shutdown(devc->channel, FALSE, NULL);
816 g_io_channel_unref(devc->channel);
817 devc->channel = NULL;
819 /* Send last packet. */
820 packet.type = SR_DF_END;
821 sr_session_send(sdi, &packet);
826 SR_PRIV struct sr_dev_driver demo_driver_info = {
828 .longname = "Demo driver and pattern generator",
833 .dev_list = dev_list,
835 .config_get = config_get,
836 .config_set = config_set,
837 .config_list = config_list,
838 .dev_open = dev_open,
839 .dev_close = dev_close,
840 .dev_acquisition_start = dev_acquisition_start,
841 .dev_acquisition_stop = dev_acquisition_stop,