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_PROBES 8
38 #define DEFAULT_NUM_ANALOG_PROBES 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 probes using '0's (with '1's as
52 * "background") when displayed using the 'bits' output format.
53 * The pattern is repeasted every 8 probes, shifted to the right
58 /** Pseudo-random values on all probes. */
62 * Incrementing number across 8 probes. The pattern is repeasted
63 * every 8 probes, shifted to the right in time by one bit.
67 /** All probes have a low logic state. */
70 /** All probes 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_probes;
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_probes;
126 GSList *analog_channel_groups;
129 static const int32_t scanopts[] = {
130 SR_CONF_NUM_LOGIC_PROBES,
131 SR_CONF_NUM_ANALOG_PROBES,
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 *channel_group, uint64_t sample_rate)
176 struct analog_gen *ag;
179 unsigned int num_samples, i;
182 ag = channel_group->priv;
183 num_samples = ANALOG_BUFSIZE / sizeof(float);
185 sr_dbg("Generating %s pattern for channel group %s",
186 analog_pattern_str[ag->pattern],
187 channel_group->name);
189 switch (ag->pattern) {
191 value = ANALOG_AMPLITUDE;
193 for (i = 0; i < num_samples; i++) {
198 ag->pattern_data[i] = value;
200 ag->num_samples = last_end;
204 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
206 /* Make sure the number of samples we put out is an integer
207 * multiple of our period size */
208 /* FIXME we actually need only one period. A ringbuffer would be
210 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
213 for (i = 0; i < num_samples; i++) {
214 t = (double) i / (double) sample_rate;
215 ag->pattern_data[i] = ANALOG_AMPLITUDE *
216 sin(2 * M_PI * frequency * t);
219 ag->num_samples = num_samples;
222 case PATTERN_TRIANGLE:
223 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
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] = (2 * ANALOG_AMPLITUDE / M_PI) *
231 asin(sin(2 * M_PI * frequency * t));
234 ag->num_samples = num_samples;
237 case PATTERN_SAWTOOTH:
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 * ANALOG_AMPLITUDE *
246 ((t * frequency) - floor(0.5f + t * frequency));
249 ag->num_samples = num_samples;
254 static GSList *scan(GSList *options)
256 struct drv_context *drvc;
257 struct dev_context *devc;
258 struct sr_dev_inst *sdi;
259 struct sr_probe *probe;
260 struct sr_channel_group *cg;
261 struct sr_config *src;
262 struct analog_gen *ag;
264 int num_logic_probes, num_analog_probes, pattern, i;
269 num_logic_probes = DEFAULT_NUM_LOGIC_PROBES;
270 num_analog_probes = DEFAULT_NUM_ANALOG_PROBES;
271 for (l = options; l; l = l->next) {
274 case SR_CONF_NUM_LOGIC_PROBES:
275 num_logic_probes = g_variant_get_int32(src->data);
277 case SR_CONF_NUM_ANALOG_PROBES:
278 num_analog_probes = g_variant_get_int32(src->data);
284 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
286 sr_err("Device instance creation failed.");
291 if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
292 sr_err("Device context malloc failed.");
295 devc->cur_samplerate = SR_KHZ(200);
296 devc->limit_samples = 0;
297 devc->limit_msec = 0;
299 devc->num_logic_probes = num_logic_probes;
300 devc->logic_unitsize = (devc->num_logic_probes + 7) / 8;
301 devc->logic_pattern = PATTERN_SIGROK;
302 devc->num_analog_probes = num_analog_probes;
303 devc->analog_channel_groups = NULL;
305 /* Logic probes, all in one channel group. */
306 if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
308 cg->name = g_strdup("Logic");
311 for (i = 0; i < num_logic_probes; i++) {
312 sprintf(probe_name, "D%d", i);
313 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name)))
315 sdi->probes = g_slist_append(sdi->probes, probe);
316 cg->channels = g_slist_append(cg->channels, probe);
318 sdi->channel_groups = g_slist_append(NULL, cg);
320 /* Analog probes, channel groups and pattern generators. */
323 for (i = 0; i < num_analog_probes; i++) {
324 sprintf(probe_name, "A%d", i);
325 if (!(probe = sr_probe_new(i + num_logic_probes,
326 SR_PROBE_ANALOG, TRUE, probe_name)))
328 sdi->probes = g_slist_append(sdi->probes, probe);
330 /* Every analog probe gets its own channel group. */
331 if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
333 cg->name = g_strdup(probe_name);
334 cg->channels = g_slist_append(NULL, probe);
336 /* Every channel group gets a generator struct. */
337 if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
339 ag->packet.probes = cg->channels;
341 ag->packet.mqflags = 0;
342 ag->packet.unit = SR_UNIT_VOLT;
343 ag->packet.data = ag->pattern_data;
344 ag->pattern = pattern;
347 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
348 devc->analog_channel_groups = g_slist_append(devc->analog_channel_groups, cg);
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 int cleanup(void)
382 return std_dev_clear(di, NULL);
385 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
386 const struct sr_channel_group *channel_group)
388 struct dev_context *devc;
389 struct sr_probe *probe;
390 struct analog_gen *ag;
398 case SR_CONF_SAMPLERATE:
399 *data = g_variant_new_uint64(devc->cur_samplerate);
401 case SR_CONF_LIMIT_SAMPLES:
402 *data = g_variant_new_uint64(devc->limit_samples);
404 case SR_CONF_LIMIT_MSEC:
405 *data = g_variant_new_uint64(devc->limit_msec);
407 case SR_CONF_PATTERN_MODE:
409 return SR_ERR_CHANNEL_GROUP;
410 probe = channel_group->channels->data;
411 if (probe->type == SR_PROBE_LOGIC) {
412 pattern = devc->logic_pattern;
413 *data = g_variant_new_string(logic_pattern_str[pattern]);
414 } else if (probe->type == SR_PROBE_ANALOG) {
415 ag = channel_group->priv;
416 pattern = ag->pattern;
417 *data = g_variant_new_string(analog_pattern_str[pattern]);
421 case SR_CONF_NUM_LOGIC_PROBES:
422 *data = g_variant_new_int32(devc->num_logic_probes);
424 case SR_CONF_NUM_ANALOG_PROBES:
425 *data = g_variant_new_int32(devc->num_analog_probes);
434 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
435 const struct sr_channel_group *channel_group)
437 struct dev_context *devc;
438 struct analog_gen *ag;
439 struct sr_probe *probe;
446 if (sdi->status != SR_ST_ACTIVE)
447 return SR_ERR_DEV_CLOSED;
451 case SR_CONF_SAMPLERATE:
452 devc->cur_samplerate = g_variant_get_uint64(data);
453 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
455 case SR_CONF_LIMIT_SAMPLES:
456 devc->limit_msec = 0;
457 devc->limit_samples = g_variant_get_uint64(data);
458 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
460 case SR_CONF_LIMIT_MSEC:
461 devc->limit_msec = g_variant_get_uint64(data);
462 devc->limit_samples = 0;
463 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
465 case SR_CONF_PATTERN_MODE:
467 return SR_ERR_CHANNEL_GROUP;
468 stropt = g_variant_get_string(data, NULL);
469 probe = channel_group->channels->data;
471 if (probe->type == SR_PROBE_LOGIC) {
472 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
473 if (!strcmp(stropt, logic_pattern_str[i])) {
480 devc->logic_pattern = pattern;
482 /* Might as well do this now, these are static. */
483 if (pattern == PATTERN_ALL_LOW)
484 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
485 else if (pattern == PATTERN_ALL_HIGH)
486 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
487 sr_dbg("Setting logic pattern to %s",
488 logic_pattern_str[pattern]);
489 } else if (probe->type == SR_PROBE_ANALOG) {
490 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
491 if (!strcmp(stropt, analog_pattern_str[i])) {
498 sr_dbg("Setting analog pattern for channel group %s to %s",
500 analog_pattern_str[pattern]);
501 ag = channel_group->priv;
502 ag->pattern = pattern;
513 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
514 const struct sr_channel_group *channel_group)
516 struct sr_probe *probe;
522 if (key == SR_CONF_SCAN_OPTIONS) {
523 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
524 scanopts, ARRAY_SIZE(scanopts), sizeof(int32_t));
531 if (!channel_group) {
533 case SR_CONF_DEVICE_OPTIONS:
534 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
535 devopts, ARRAY_SIZE(devopts), sizeof(int32_t));
537 case SR_CONF_SAMPLERATE:
538 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
539 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
540 ARRAY_SIZE(samplerates), sizeof(uint64_t));
541 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
542 *data = g_variant_builder_end(&gvb);
548 probe = channel_group->channels->data;
550 case SR_CONF_DEVICE_OPTIONS:
551 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
552 devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(int32_t));
554 case SR_CONF_PATTERN_MODE:
555 if (probe->type == SR_PROBE_LOGIC)
556 *data = g_variant_new_strv(logic_pattern_str,
557 ARRAY_SIZE(logic_pattern_str));
558 else if (probe->type == SR_PROBE_ANALOG)
559 *data = g_variant_new_strv(analog_pattern_str,
560 ARRAY_SIZE(analog_pattern_str));
572 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
574 struct dev_context *devc;
580 switch (devc->logic_pattern) {
582 memset(devc->logic_data, 0x00, size);
583 for (i = 0; i < size; i += devc->logic_unitsize) {
584 for (j = 0; j < devc->logic_unitsize; j++) {
585 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
586 devc->logic_data[i + j] = ~pat;
592 for (i = 0; i < size; i++)
593 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
596 for (i = 0; i < size; i++) {
597 for (j = 0; j < devc->logic_unitsize; j++) {
598 devc->logic_data[i + j] = devc->step;
603 case PATTERN_ALL_LOW:
604 case PATTERN_ALL_HIGH:
605 /* These were set when the pattern mode was selected. */
608 sr_err("Unknown pattern: %d.", devc->logic_pattern);
613 /* Callback handling data */
614 static int prepare_data(int fd, int revents, void *cb_data)
616 struct sr_dev_inst *sdi;
617 struct dev_context *devc;
618 struct sr_datafeed_packet packet;
619 struct sr_datafeed_logic logic;
620 struct sr_channel_group *cg;
621 struct analog_gen *ag;
623 uint64_t logic_todo, analog_todo, expected_samplenum, analog_samples, sending_now;
624 int64_t time, elapsed;
632 /* How many "virtual" samples should we have collected by now? */
633 time = g_get_monotonic_time();
634 elapsed = time - devc->starttime;
635 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
637 /* Of those, how many do we still have to send? */
638 logic_todo = MIN(expected_samplenum, devc->limit_samples) - devc->logic_counter;
639 analog_todo = MIN(expected_samplenum, devc->limit_samples) - devc->analog_counter;
641 while (logic_todo || analog_todo) {
643 if (devc->num_logic_probes > 0 && logic_todo > 0) {
644 sending_now = MIN(logic_todo,
645 LOGIC_BUFSIZE / devc->logic_unitsize);
646 logic_generator(sdi, sending_now * devc->logic_unitsize);
647 packet.type = SR_DF_LOGIC;
648 packet.payload = &logic;
649 logic.length = sending_now * devc->logic_unitsize;
650 logic.unitsize = devc->logic_unitsize;
651 logic.data = devc->logic_data;
652 sr_session_send(sdi, &packet);
653 logic_todo -= sending_now;
654 devc->logic_counter += sending_now;
657 /* Analog, one probe at a time */
658 if (devc->num_analog_probes > 0 && analog_todo > 0) {
660 for (l = devc->analog_channel_groups; l; l = l->next) {
663 packet.type = SR_DF_ANALOG;
664 packet.payload = &ag->packet;
666 /* FIXME we should make sure we output a whole
667 * period of data before we send out again the
668 * beginning of our buffer. A ring buffer would
669 * help here as well */
671 analog_samples = MIN(analog_todo, ag->num_samples);
672 /* Whichever channel group gets there first. */
673 sending_now = MAX(sending_now, analog_samples);
674 ag->packet.num_samples = analog_samples;
675 sr_session_send(sdi, &packet);
677 analog_todo -= sending_now;
678 devc->analog_counter += sending_now;
682 if (devc->logic_counter >= devc->limit_samples &&
683 devc->analog_counter >= devc->limit_samples) {
684 sr_dbg("Requested number of samples reached.");
685 dev_acquisition_stop(sdi, cb_data);
692 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
695 struct dev_context *devc;
697 if (sdi->status != SR_ST_ACTIVE)
698 return SR_ERR_DEV_CLOSED;
701 if (devc->limit_samples == 0)
703 devc->logic_counter = devc->analog_counter = 0;
706 * Setting two channels connected by a pipe is a remnant from when the
707 * demo driver generated data in a thread, and collected and sent the
708 * data in the main program loop.
709 * They are kept here because it provides a convenient way of setting
710 * up a timeout-based polling mechanism.
712 if (pipe(devc->pipe_fds)) {
713 sr_err("%s: pipe() failed", __func__);
717 for (l = devc->analog_channel_groups; l; l = l->next) {
718 generate_analog_pattern(l->data, devc->cur_samplerate);
721 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
723 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
725 /* Set channel encoding to binary (default is UTF-8). */
726 g_io_channel_set_encoding(devc->channel, NULL, NULL);
728 /* Make channels to unbuffered. */
729 g_io_channel_set_buffered(devc->channel, FALSE);
731 sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
732 40, prepare_data, (void *)sdi);
734 /* Send header packet to the session bus. */
735 std_session_send_df_header(cb_data, LOG_PREFIX);
737 /* We use this timestamp to decide how many more samples to send. */
738 devc->starttime = g_get_monotonic_time();
743 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
745 struct dev_context *devc;
746 struct sr_datafeed_packet packet;
751 sr_dbg("Stopping acquisition.");
753 sr_session_source_remove_channel(devc->channel);
754 g_io_channel_shutdown(devc->channel, FALSE, NULL);
755 g_io_channel_unref(devc->channel);
756 devc->channel = NULL;
758 /* Send last packet. */
759 packet.type = SR_DF_END;
760 sr_session_send(sdi, &packet);
765 SR_PRIV struct sr_dev_driver demo_driver_info = {
767 .longname = "Demo driver and pattern generator",
772 .dev_list = dev_list,
774 .config_get = config_get,
775 .config_set = config_set,
776 .config_list = config_list,
777 .dev_open = dev_open,
778 .dev_close = dev_close,
779 .dev_acquisition_start = dev_acquisition_start,
780 .dev_acquisition_stop = dev_acquisition_stop,