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
29 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
31 #include "libsigrok.h"
32 #include "libsigrok-internal.h"
34 #define LOG_PREFIX "demo"
36 #define DEFAULT_NUM_LOGIC_PROBES 8
37 #define DEFAULT_NUM_ANALOG_PROBES 4
39 /* The size in bytes of chunks to send through the session bus. */
40 #define LOGIC_BUFSIZE 4096
41 /* Size of the analog pattern space per channel. */
42 #define ANALOG_BUFSIZE 4096
44 /* Patterns we can generate */
48 * Spells "sigrok" across 8 probes using '0's (with '1's as
49 * "background") when displayed using the 'bits' output format.
50 * The pattern is repeasted every 8 probes, shifted to the right
55 /** Pseudo-random values on all probes. */
59 * Incrementing number across 8 probes. The pattern is repeasted
60 * every 8 probes, shifted to the right in time by one bit.
64 /** All probes have a low logic state. */
67 /** All probes have a high logic state. */
77 static const char *logic_pattern_str[] = {
85 static const char *analog_pattern_str[] = {
91 float pattern_data[ANALOG_BUFSIZE];
92 unsigned int num_samples;
93 struct sr_datafeed_analog packet;
96 /* Private, per-device-instance driver context. */
100 uint64_t cur_samplerate;
101 uint64_t limit_samples;
103 uint64_t samples_counter;
107 int32_t num_logic_probes;
108 unsigned int logic_unitsize;
109 uint8_t logic_pattern;
110 unsigned char logic_data[LOGIC_BUFSIZE];
112 int32_t num_analog_probes;
113 GSList *analog_probe_groups;
116 static const int32_t hwopts[] = {
117 SR_CONF_NUM_LOGIC_PROBES,
118 SR_CONF_NUM_ANALOG_PROBES,
121 static const int hwcaps[] = {
122 SR_CONF_LOGIC_ANALYZER,
125 SR_CONF_PATTERN_MODE,
126 SR_CONF_LIMIT_SAMPLES,
130 static const uint64_t samplerates[] = {
136 static uint8_t pattern_sigrok[] = {
137 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
138 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
139 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
140 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
141 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
142 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
143 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
144 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
147 SR_PRIV struct sr_dev_driver demo_driver_info;
148 static struct sr_dev_driver *di = &demo_driver_info;
150 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
153 static int dev_clear(void)
155 return std_dev_clear(di, NULL);
158 static int init(struct sr_context *sr_ctx)
160 return std_init(sr_ctx, di, LOG_PREFIX);
163 static void set_analog_pattern(const struct sr_probe_group *probe_group, int pattern)
165 struct analog_gen *ag;
167 unsigned int num_samples, i;
170 ag = probe_group->priv;
171 ag->pattern = pattern;
175 num_samples = ANALOG_BUFSIZE / sizeof(float);
178 for (i = 0; i < num_samples; i++) {
183 ag->pattern_data[i] = value;
185 ag->num_samples = last_end;
190 static GSList *scan(GSList *options)
192 struct drv_context *drvc;
193 struct dev_context *devc;
194 struct sr_dev_inst *sdi;
195 struct sr_probe *probe;
196 struct sr_probe_group *pg;
197 struct sr_config *src;
198 struct analog_gen *ag;
200 int num_logic_probes, num_analog_probes, i;
205 num_logic_probes = DEFAULT_NUM_LOGIC_PROBES;
206 num_analog_probes = DEFAULT_NUM_ANALOG_PROBES;
207 for (l = options; l; l = l->next) {
210 case SR_CONF_NUM_LOGIC_PROBES:
211 num_logic_probes = g_variant_get_int32(src->data);
213 case SR_CONF_NUM_ANALOG_PROBES:
214 num_analog_probes = g_variant_get_int32(src->data);
220 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
222 sr_err("Device instance creation failed.");
227 if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
228 sr_err("Device context malloc failed.");
231 devc->cur_samplerate = SR_KHZ(200);
232 devc->limit_samples = 0;
233 devc->limit_msec = 0;
235 devc->num_logic_probes = num_logic_probes;
236 devc->logic_unitsize = (devc->num_logic_probes + 7) / 8;
237 devc->logic_pattern = PATTERN_SIGROK;
238 devc->num_analog_probes = num_analog_probes;
239 devc->analog_probe_groups = NULL;
241 /* Logic probes, all in one probe group. */
242 if (!(pg = g_try_malloc(sizeof(struct sr_probe_group))))
244 pg->name = g_strdup("Logic");
247 for (i = 0; i < num_logic_probes; i++) {
248 sprintf(probe_name, "D%d", i);
249 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name)))
251 sdi->probes = g_slist_append(sdi->probes, probe);
252 pg->probes = g_slist_append(pg->probes, probe);
254 sdi->probe_groups = g_slist_append(NULL, pg);
256 /* Analog probes, probe groups and pattern generators. */
257 for (i = 0; i < num_analog_probes; i++) {
258 sprintf(probe_name, "A%d", i);
259 if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, probe_name)))
261 sdi->probes = g_slist_append(sdi->probes, probe);
263 /* Every analog probe gets its own probe group. */
264 if (!(pg = g_try_malloc(sizeof(struct sr_probe_group))))
266 pg->name = g_strdup(probe_name);
267 pg->probes = g_slist_append(NULL, probe);
269 /* Every probe group gets a generator struct. */
270 if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
272 ag->packet.probes = pg->probes;
274 ag->packet.mqflags = 0;
275 ag->packet.unit = SR_UNIT_VOLT;
276 ag->packet.data = ag->pattern_data;
278 set_analog_pattern(pg, PATTERN_SQUARE);
280 sdi->probe_groups = g_slist_append(sdi->probe_groups, pg);
281 devc->analog_probe_groups = g_slist_append(devc->analog_probe_groups, pg);
285 devices = g_slist_append(devices, sdi);
286 drvc->instances = g_slist_append(drvc->instances, sdi);
291 static GSList *dev_list(void)
293 return ((struct drv_context *)(di->priv))->instances;
296 static int dev_open(struct sr_dev_inst *sdi)
298 sdi->status = SR_ST_ACTIVE;
303 static int dev_close(struct sr_dev_inst *sdi)
305 sdi->status = SR_ST_INACTIVE;
310 static int cleanup(void)
315 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
316 const struct sr_probe_group *probe_group)
318 struct dev_context *devc;
324 case SR_CONF_SAMPLERATE:
325 *data = g_variant_new_uint64(devc->cur_samplerate);
327 case SR_CONF_LIMIT_SAMPLES:
328 *data = g_variant_new_uint64(devc->limit_samples);
330 case SR_CONF_LIMIT_MSEC:
331 *data = g_variant_new_uint64(devc->limit_msec);
333 case SR_CONF_PATTERN_MODE:
334 *data = g_variant_new_string(logic_pattern_str[devc->logic_pattern]);
336 case SR_CONF_NUM_LOGIC_PROBES:
337 *data = g_variant_new_int32(devc->num_logic_probes);
339 case SR_CONF_NUM_ANALOG_PROBES:
340 *data = g_variant_new_int32(devc->num_analog_probes);
349 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
350 const struct sr_probe_group *probe_group)
352 struct dev_context *devc;
353 struct sr_probe_group *pg;
355 int logic_pattern, analog_pattern, ret;
361 if (sdi->status != SR_ST_ACTIVE)
362 return SR_ERR_DEV_CLOSED;
365 if (id == SR_CONF_SAMPLERATE) {
366 devc->cur_samplerate = g_variant_get_uint64(data);
367 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
369 } else if (id == SR_CONF_LIMIT_SAMPLES) {
370 devc->limit_msec = 0;
371 devc->limit_samples = g_variant_get_uint64(data);
372 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
374 } else if (id == SR_CONF_LIMIT_MSEC) {
375 /* TODO: convert to limit_samples */
376 devc->limit_msec = g_variant_get_uint64(data);
377 devc->limit_samples = 0;
378 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
380 } else if (id == SR_CONF_PATTERN_MODE) {
381 stropt = g_variant_get_string(data, NULL);
382 logic_pattern = analog_pattern = -1;
383 /* Is it a logic pattern? */
384 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
385 if (!strcmp(stropt, logic_pattern_str[i])) {
390 if (logic_pattern == -1) {
391 /* Is it an analog pattern? */
392 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
393 if (!strcmp(stropt, analog_pattern_str[i])) {
399 if (logic_pattern > -1) {
400 devc->logic_pattern = logic_pattern;
401 /* Might as well do this now. */
402 if (logic_pattern == PATTERN_ALL_LOW)
403 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
404 else if (logic_pattern == PATTERN_ALL_HIGH)
405 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
407 sr_dbg("Setting logic pattern to %s", logic_pattern_str[logic_pattern]);
408 } else if (analog_pattern > -1) {
409 sr_dbg("Setting analog pattern to %s", analog_pattern_str[analog_pattern]);
411 set_analog_pattern(probe_group, analog_pattern);
413 /* No probe group specified, apply pattern to all of them. */
414 for (l = sdi->probe_groups; l; l = l->next) {
416 set_analog_pattern(pg, analog_pattern);
430 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
431 const struct sr_probe_group *probe_group)
440 case SR_CONF_SCAN_OPTIONS:
441 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
442 hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
444 case SR_CONF_DEVICE_OPTIONS:
445 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
446 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
448 case SR_CONF_SAMPLERATE:
449 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
450 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
451 ARRAY_SIZE(samplerates), sizeof(uint64_t));
452 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
453 *data = g_variant_builder_end(&gvb);
455 case SR_CONF_PATTERN_MODE:
456 *data = g_variant_new_strv(logic_pattern_str, ARRAY_SIZE(logic_pattern_str));
465 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
467 struct dev_context *devc;
473 switch (devc->logic_pattern) {
475 memset(devc->logic_data, 0x00, size);
476 for (i = 0; i < size; i += devc->logic_unitsize) {
477 for (j = 0; j < devc->logic_unitsize; j++) {
478 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
479 devc->logic_data[i + j] = ~pat;
485 for (i = 0; i < size; i++)
486 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
489 for (i = 0; i < size; i++) {
490 for (j = 0; j < devc->logic_unitsize; j++) {
491 devc->logic_data[i + j] = devc->step;
496 case PATTERN_ALL_LOW:
497 case PATTERN_ALL_HIGH:
498 /* These were set when the pattern mode was selected. */
501 sr_err("Unknown pattern: %d.", devc->logic_pattern);
506 /* Callback handling data */
507 static int prepare_data(int fd, int revents, void *cb_data)
509 struct sr_dev_inst *sdi;
510 struct dev_context *devc;
511 struct sr_datafeed_packet packet;
512 struct sr_datafeed_logic logic;
513 struct sr_probe_group *pg;
514 struct analog_gen *ag;
516 uint64_t samples_to_send, expected_samplenum, analog_samples, sending_now;
517 int64_t time, elapsed;
525 /* How many "virtual" samples should we have collected by now? */
526 time = g_get_monotonic_time();
527 elapsed = time - devc->starttime;
528 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
529 /* Of those, how many do we still have to send? */
530 samples_to_send = expected_samplenum - devc->samples_counter;
532 if (devc->limit_samples) {
533 samples_to_send = MIN(samples_to_send,
534 devc->limit_samples - devc->samples_counter);
537 while (samples_to_send > 0) {
541 if (devc->num_logic_probes > 0) {
542 sending_now = MIN(samples_to_send,
543 LOGIC_BUFSIZE / devc->logic_unitsize);
544 logic_generator(sdi, sending_now * devc->logic_unitsize);
545 packet.type = SR_DF_LOGIC;
546 packet.payload = &logic;
547 logic.length = sending_now * devc->logic_unitsize;
548 logic.unitsize = devc->logic_unitsize;
549 logic.data = devc->logic_data;
550 sr_session_send(sdi, &packet);
553 /* Analog, one probe at a time */
554 if (devc->num_analog_probes > 0) {
556 for (l = devc->analog_probe_groups; l; l = l->next) {
559 packet.type = SR_DF_ANALOG;
560 packet.payload = &ag->packet;
561 analog_samples = MIN(samples_to_send, ag->num_samples);
562 /* Whichever probe group gets there first. */
563 sending_now = MAX(sending_now, analog_samples);
564 ag->packet.num_samples = analog_samples;
565 sr_session_send(sdi, &packet);
569 samples_to_send -= sending_now;
570 devc->samples_counter += sending_now;
573 if (devc->limit_samples &&
574 devc->samples_counter >= devc->limit_samples) {
575 sr_info("Requested number of samples reached.");
576 dev_acquisition_stop(sdi, cb_data);
583 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
585 struct dev_context *devc;
587 if (sdi->status != SR_ST_ACTIVE)
588 return SR_ERR_DEV_CLOSED;
590 /* TODO: don't start without a sample limit set */
592 devc->samples_counter = 0;
595 * Setting two channels connected by a pipe is a remnant from when the
596 * demo driver generated data in a thread, and collected and sent the
597 * data in the main program loop.
598 * They are kept here because it provides a convenient way of setting
599 * up a timeout-based polling mechanism.
601 if (pipe(devc->pipe_fds)) {
602 sr_err("%s: pipe() failed", __func__);
606 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
608 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
610 /* Set channel encoding to binary (default is UTF-8). */
611 g_io_channel_set_encoding(devc->channel, NULL, NULL);
613 /* Make channels to unbuffered. */
614 g_io_channel_set_buffered(devc->channel, FALSE);
616 sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
617 40, prepare_data, (void *)sdi);
619 /* Send header packet to the session bus. */
620 std_session_send_df_header(cb_data, LOG_PREFIX);
622 /* We use this timestamp to decide how many more samples to send. */
623 devc->starttime = g_get_monotonic_time();
628 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
630 struct dev_context *devc;
631 struct sr_datafeed_packet packet;
636 sr_dbg("Stopping aquisition.");
638 sr_session_source_remove_channel(devc->channel);
639 g_io_channel_shutdown(devc->channel, FALSE, NULL);
640 g_io_channel_unref(devc->channel);
641 devc->channel = NULL;
643 /* Send last packet. */
644 packet.type = SR_DF_END;
645 sr_session_send(sdi, &packet);
650 SR_PRIV struct sr_dev_driver demo_driver_info = {
652 .longname = "Demo driver and pattern generator",
657 .dev_list = dev_list,
658 .dev_clear = dev_clear,
659 .config_get = config_get,
660 .config_set = config_set,
661 .config_list = config_list,
662 .dev_open = dev_open,
663 .dev_close = dev_close,
664 .dev_acquisition_start = dev_acquisition_start,
665 .dev_acquisition_stop = dev_acquisition_stop,