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 probe 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_probe_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_pg[] = {
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 dev_clear(void)
171 return std_dev_clear(di, NULL);
174 static int init(struct sr_context *sr_ctx)
176 return std_init(sr_ctx, di, LOG_PREFIX);
179 static void generate_analog_pattern(const struct sr_probe_group *probe_group, uint64_t sample_rate)
181 struct analog_gen *ag;
184 unsigned int num_samples, i;
187 ag = probe_group->priv;
188 num_samples = ANALOG_BUFSIZE / sizeof(float);
190 sr_dbg("Generating %s pattern for probe group %s",
191 analog_pattern_str[ag->pattern],
194 switch (ag->pattern) {
196 value = ANALOG_AMPLITUDE;
198 for (i = 0; i < num_samples; i++) {
203 ag->pattern_data[i] = value;
205 ag->num_samples = last_end;
209 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
211 /* Make sure the number of samples we put out is an integer
212 * multiple of our period size */
213 /* FIXME we actually need only one period. A ringbuffer would be
215 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
218 for (i = 0; i < num_samples; i++) {
219 t = (double) i / (double) sample_rate;
220 ag->pattern_data[i] = ANALOG_AMPLITUDE *
221 sin(2 * M_PI * frequency * t);
224 ag->num_samples = num_samples;
227 case PATTERN_TRIANGLE:
228 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
230 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
233 for (i = 0; i < num_samples; i++) {
234 t = (double) i / (double) sample_rate;
235 ag->pattern_data[i] = (2 * ANALOG_AMPLITUDE / M_PI) *
236 asin(sin(2 * M_PI * frequency * t));
239 ag->num_samples = num_samples;
242 case PATTERN_SAWTOOTH:
243 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
245 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
248 for (i = 0; i < num_samples; i++) {
249 t = (double) i / (double) sample_rate;
250 ag->pattern_data[i] = 2 * ANALOG_AMPLITUDE *
251 ((t * frequency) - floor(0.5f + t * frequency));
254 ag->num_samples = num_samples;
259 static GSList *scan(GSList *options)
261 struct drv_context *drvc;
262 struct dev_context *devc;
263 struct sr_dev_inst *sdi;
264 struct sr_probe *probe;
265 struct sr_probe_group *pg;
266 struct sr_config *src;
267 struct analog_gen *ag;
269 int num_logic_probes, num_analog_probes, pattern, i;
274 num_logic_probes = DEFAULT_NUM_LOGIC_PROBES;
275 num_analog_probes = DEFAULT_NUM_ANALOG_PROBES;
276 for (l = options; l; l = l->next) {
279 case SR_CONF_NUM_LOGIC_PROBES:
280 num_logic_probes = g_variant_get_int32(src->data);
282 case SR_CONF_NUM_ANALOG_PROBES:
283 num_analog_probes = g_variant_get_int32(src->data);
289 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
291 sr_err("Device instance creation failed.");
296 if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
297 sr_err("Device context malloc failed.");
300 devc->cur_samplerate = SR_KHZ(200);
301 devc->limit_samples = 0;
302 devc->limit_msec = 0;
304 devc->num_logic_probes = num_logic_probes;
305 devc->logic_unitsize = (devc->num_logic_probes + 7) / 8;
306 devc->logic_pattern = PATTERN_SIGROK;
307 devc->num_analog_probes = num_analog_probes;
308 devc->analog_probe_groups = NULL;
310 /* Logic probes, all in one probe group. */
311 if (!(pg = g_try_malloc(sizeof(struct sr_probe_group))))
313 pg->name = g_strdup("Logic");
316 for (i = 0; i < num_logic_probes; i++) {
317 sprintf(probe_name, "D%d", i);
318 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name)))
320 sdi->probes = g_slist_append(sdi->probes, probe);
321 pg->probes = g_slist_append(pg->probes, probe);
323 sdi->probe_groups = g_slist_append(NULL, pg);
325 /* Analog probes, probe groups and pattern generators. */
328 for (i = 0; i < num_analog_probes; i++) {
329 sprintf(probe_name, "A%d", i);
330 if (!(probe = sr_probe_new(i + num_logic_probes,
331 SR_PROBE_ANALOG, TRUE, probe_name)))
333 sdi->probes = g_slist_append(sdi->probes, probe);
335 /* Every analog probe gets its own probe group. */
336 if (!(pg = g_try_malloc(sizeof(struct sr_probe_group))))
338 pg->name = g_strdup(probe_name);
339 pg->probes = g_slist_append(NULL, probe);
341 /* Every probe group gets a generator struct. */
342 if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
344 ag->packet.probes = pg->probes;
346 ag->packet.mqflags = 0;
347 ag->packet.unit = SR_UNIT_VOLT;
348 ag->packet.data = ag->pattern_data;
349 ag->pattern = pattern;
352 sdi->probe_groups = g_slist_append(sdi->probe_groups, pg);
353 devc->analog_probe_groups = g_slist_append(devc->analog_probe_groups, pg);
355 if (++pattern == ARRAY_SIZE(analog_pattern_str))
360 devices = g_slist_append(devices, sdi);
361 drvc->instances = g_slist_append(drvc->instances, sdi);
366 static GSList *dev_list(void)
368 return ((struct drv_context *)(di->priv))->instances;
371 static int dev_open(struct sr_dev_inst *sdi)
373 sdi->status = SR_ST_ACTIVE;
378 static int dev_close(struct sr_dev_inst *sdi)
380 sdi->status = SR_ST_INACTIVE;
385 static int cleanup(void)
390 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
391 const struct sr_probe_group *probe_group)
393 struct dev_context *devc;
394 struct sr_probe *probe;
395 struct analog_gen *ag;
403 case SR_CONF_SAMPLERATE:
404 *data = g_variant_new_uint64(devc->cur_samplerate);
406 case SR_CONF_LIMIT_SAMPLES:
407 *data = g_variant_new_uint64(devc->limit_samples);
409 case SR_CONF_LIMIT_MSEC:
410 *data = g_variant_new_uint64(devc->limit_msec);
412 case SR_CONF_PATTERN_MODE:
414 return SR_ERR_PROBE_GROUP;
415 probe = probe_group->probes->data;
416 if (probe->type == SR_PROBE_LOGIC) {
417 pattern = devc->logic_pattern;
418 *data = g_variant_new_string(logic_pattern_str[pattern]);
419 } else if (probe->type == SR_PROBE_ANALOG) {
420 ag = probe_group->priv;
421 pattern = ag->pattern;
422 *data = g_variant_new_string(analog_pattern_str[pattern]);
426 case SR_CONF_NUM_LOGIC_PROBES:
427 *data = g_variant_new_int32(devc->num_logic_probes);
429 case SR_CONF_NUM_ANALOG_PROBES:
430 *data = g_variant_new_int32(devc->num_analog_probes);
439 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
440 const struct sr_probe_group *probe_group)
442 struct dev_context *devc;
443 struct analog_gen *ag;
444 struct sr_probe *probe;
451 if (sdi->status != SR_ST_ACTIVE)
452 return SR_ERR_DEV_CLOSED;
456 case SR_CONF_SAMPLERATE:
457 devc->cur_samplerate = g_variant_get_uint64(data);
458 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
460 case SR_CONF_LIMIT_SAMPLES:
461 devc->limit_msec = 0;
462 devc->limit_samples = g_variant_get_uint64(data);
463 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
465 case SR_CONF_LIMIT_MSEC:
466 devc->limit_msec = g_variant_get_uint64(data);
467 devc->limit_samples = 0;
468 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
470 case SR_CONF_PATTERN_MODE:
472 return SR_ERR_PROBE_GROUP;
473 stropt = g_variant_get_string(data, NULL);
474 probe = probe_group->probes->data;
476 if (probe->type == SR_PROBE_LOGIC) {
477 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
478 if (!strcmp(stropt, logic_pattern_str[i])) {
485 devc->logic_pattern = pattern;
487 /* Might as well do this now, these are static. */
488 if (pattern == PATTERN_ALL_LOW)
489 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
490 else if (pattern == PATTERN_ALL_HIGH)
491 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
492 sr_dbg("Setting logic pattern to %s",
493 logic_pattern_str[pattern]);
494 } else if (probe->type == SR_PROBE_ANALOG) {
495 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
496 if (!strcmp(stropt, analog_pattern_str[i])) {
503 sr_dbg("Setting analog pattern for probe group %s to %s",
505 analog_pattern_str[pattern]);
506 ag = probe_group->priv;
507 ag->pattern = pattern;
518 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
519 const struct sr_probe_group *probe_group)
521 struct sr_probe *probe;
527 if (key == SR_CONF_SCAN_OPTIONS) {
528 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
529 scanopts, ARRAY_SIZE(scanopts), sizeof(int32_t));
538 case SR_CONF_DEVICE_OPTIONS:
539 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
540 devopts, ARRAY_SIZE(devopts), sizeof(int32_t));
542 case SR_CONF_SAMPLERATE:
543 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
544 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
545 ARRAY_SIZE(samplerates), sizeof(uint64_t));
546 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
547 *data = g_variant_builder_end(&gvb);
553 probe = probe_group->probes->data;
555 case SR_CONF_DEVICE_OPTIONS:
556 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
557 devopts_pg, ARRAY_SIZE(devopts_pg), sizeof(int32_t));
559 case SR_CONF_PATTERN_MODE:
560 if (probe->type == SR_PROBE_LOGIC)
561 *data = g_variant_new_strv(logic_pattern_str,
562 ARRAY_SIZE(logic_pattern_str));
563 else if (probe->type == SR_PROBE_ANALOG)
564 *data = g_variant_new_strv(analog_pattern_str,
565 ARRAY_SIZE(analog_pattern_str));
577 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
579 struct dev_context *devc;
585 switch (devc->logic_pattern) {
587 memset(devc->logic_data, 0x00, size);
588 for (i = 0; i < size; i += devc->logic_unitsize) {
589 for (j = 0; j < devc->logic_unitsize; j++) {
590 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
591 devc->logic_data[i + j] = ~pat;
597 for (i = 0; i < size; i++)
598 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
601 for (i = 0; i < size; i++) {
602 for (j = 0; j < devc->logic_unitsize; j++) {
603 devc->logic_data[i + j] = devc->step;
608 case PATTERN_ALL_LOW:
609 case PATTERN_ALL_HIGH:
610 /* These were set when the pattern mode was selected. */
613 sr_err("Unknown pattern: %d.", devc->logic_pattern);
618 /* Callback handling data */
619 static int prepare_data(int fd, int revents, void *cb_data)
621 struct sr_dev_inst *sdi;
622 struct dev_context *devc;
623 struct sr_datafeed_packet packet;
624 struct sr_datafeed_logic logic;
625 struct sr_probe_group *pg;
626 struct analog_gen *ag;
628 uint64_t logic_todo, analog_todo, expected_samplenum, analog_samples, sending_now;
629 int64_t time, elapsed;
637 /* How many "virtual" samples should we have collected by now? */
638 time = g_get_monotonic_time();
639 elapsed = time - devc->starttime;
640 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
642 /* Of those, how many do we still have to send? */
643 logic_todo = MIN(expected_samplenum, devc->limit_samples) - devc->logic_counter;
644 analog_todo = MIN(expected_samplenum, devc->limit_samples) - devc->analog_counter;
646 while (logic_todo || analog_todo) {
648 if (devc->num_logic_probes > 0 && logic_todo > 0) {
649 sending_now = MIN(logic_todo,
650 LOGIC_BUFSIZE / devc->logic_unitsize);
651 logic_generator(sdi, sending_now * devc->logic_unitsize);
652 packet.type = SR_DF_LOGIC;
653 packet.payload = &logic;
654 logic.length = sending_now * devc->logic_unitsize;
655 logic.unitsize = devc->logic_unitsize;
656 logic.data = devc->logic_data;
657 sr_session_send(sdi, &packet);
658 logic_todo -= sending_now;
659 devc->logic_counter += sending_now;
662 /* Analog, one probe at a time */
663 if (devc->num_analog_probes > 0 && analog_todo > 0) {
665 for (l = devc->analog_probe_groups; l; l = l->next) {
668 packet.type = SR_DF_ANALOG;
669 packet.payload = &ag->packet;
671 /* FIXME we should make sure we output a whole
672 * period of data before we send out again the
673 * beginning of our buffer. A ring buffer would
674 * help here as well */
676 analog_samples = MIN(analog_todo, ag->num_samples);
677 /* Whichever probe group gets there first. */
678 sending_now = MAX(sending_now, analog_samples);
679 ag->packet.num_samples = analog_samples;
680 sr_session_send(sdi, &packet);
682 analog_todo -= sending_now;
683 devc->analog_counter += sending_now;
687 if (devc->logic_counter >= devc->limit_samples &&
688 devc->analog_counter >= devc->limit_samples) {
689 sr_dbg("Requested number of samples reached.");
690 dev_acquisition_stop(sdi, cb_data);
697 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
700 struct dev_context *devc;
702 if (sdi->status != SR_ST_ACTIVE)
703 return SR_ERR_DEV_CLOSED;
706 if (devc->limit_samples == 0)
708 devc->logic_counter = devc->analog_counter = 0;
711 * Setting two channels connected by a pipe is a remnant from when the
712 * demo driver generated data in a thread, and collected and sent the
713 * data in the main program loop.
714 * They are kept here because it provides a convenient way of setting
715 * up a timeout-based polling mechanism.
717 if (pipe(devc->pipe_fds)) {
718 sr_err("%s: pipe() failed", __func__);
722 for (l = devc->analog_probe_groups; l; l = l->next) {
723 generate_analog_pattern(l->data, devc->cur_samplerate);
726 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
728 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
730 /* Set channel encoding to binary (default is UTF-8). */
731 g_io_channel_set_encoding(devc->channel, NULL, NULL);
733 /* Make channels to unbuffered. */
734 g_io_channel_set_buffered(devc->channel, FALSE);
736 sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
737 40, prepare_data, (void *)sdi);
739 /* Send header packet to the session bus. */
740 std_session_send_df_header(cb_data, LOG_PREFIX);
742 /* We use this timestamp to decide how many more samples to send. */
743 devc->starttime = g_get_monotonic_time();
748 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
750 struct dev_context *devc;
751 struct sr_datafeed_packet packet;
756 sr_dbg("Stopping aquisition.");
758 sr_session_source_remove_channel(devc->channel);
759 g_io_channel_shutdown(devc->channel, FALSE, NULL);
760 g_io_channel_unref(devc->channel);
761 devc->channel = NULL;
763 /* Send last packet. */
764 packet.type = SR_DF_END;
765 sr_session_send(sdi, &packet);
770 SR_PRIV struct sr_dev_driver demo_driver_info = {
772 .longname = "Demo driver and pattern generator",
777 .dev_list = dev_list,
778 .dev_clear = dev_clear,
779 .config_get = config_get,
780 .config_set = config_set,
781 .config_list = config_list,
782 .dev_open = dev_open,
783 .dev_close = dev_close,
784 .dev_acquisition_start = dev_acquisition_start,
785 .dev_acquisition_stop = dev_acquisition_stop,