]> sigrok.org Git - libsigrok.git/blame_incremental - src/hardware/demo/demo.c
projects / libsigrok.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Build: Set local include directories in Makefile.am
[libsigrok.git] / src / hardware / demo / demo.c
... / ...
CommitLineData
1/*
2 * This file is part of the libsigrok project.
3 *
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>
7 * Copyright (C) 2015 Bartosz Golaszewski <bgolaszewski@baylibre.com>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#include <stdlib.h>
25#include <unistd.h>
26#include <string.h>
27#include <math.h>
28#ifdef _WIN32
29#include <io.h>
30#include <fcntl.h>
31#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
32#endif
33#include <libsigrok/libsigrok.h>
34#include "libsigrok-internal.h"
35
36#define LOG_PREFIX "demo"
37
38#define DEFAULT_NUM_LOGIC_CHANNELS 8
39#define DEFAULT_NUM_ANALOG_CHANNELS 4
40
41/* The size in bytes of chunks to send through the session bus. */
42#define LOGIC_BUFSIZE 4096
43/* Size of the analog pattern space per channel. */
44#define ANALOG_BUFSIZE 4096
45
46#define DEFAULT_ANALOG_AMPLITUDE 25
47#define ANALOG_SAMPLES_PER_PERIOD 20
48
49/* Logic patterns we can generate. */
50enum {
51 /**
52 * Spells "sigrok" across 8 channels using '0's (with '1's as
53 * "background") when displayed using the 'bits' output format.
54 * The pattern is repeated every 8 channels, shifted to the right
55 * in time by one bit.
56 */
57 PATTERN_SIGROK,
58
59 /** Pseudo-random values on all channels. */
60 PATTERN_RANDOM,
61
62 /**
63 * Incrementing number across 8 channels. The pattern is repeated
64 * every 8 channels, shifted to the right in time by one bit.
65 */
66 PATTERN_INC,
67
68 /** All channels have a low logic state. */
69 PATTERN_ALL_LOW,
70
71 /** All channels have a high logic state. */
72 PATTERN_ALL_HIGH,
73};
74
75/* Analog patterns we can generate. */
76enum {
77 /**
78 * Square wave.
79 */
80 PATTERN_SQUARE,
81 PATTERN_SINE,
82 PATTERN_TRIANGLE,
83 PATTERN_SAWTOOTH,
84};
85
86static const char *logic_pattern_str[] = {
87 "sigrok",
88 "random",
89 "incremental",
90 "all-low",
91 "all-high",
92};
93
94static const char *analog_pattern_str[] = {
95 "square",
96 "sine",
97 "triangle",
98 "sawtooth",
99};
100
101struct analog_gen {
102 int pattern;
103 float amplitude;
104 float pattern_data[ANALOG_BUFSIZE];
105 unsigned int num_samples;
106 struct sr_datafeed_analog packet;
107 float avg_val; /* Average value */
108 unsigned num_avgs; /* Number of samples averaged */
109};
110
111/* Private, per-device-instance driver context. */
112struct dev_context {
113 int pipe_fds[2];
114 GIOChannel *channel;
115 uint64_t cur_samplerate;
116 gboolean continuous;
117 uint64_t limit_samples;
118 uint64_t limit_msec;
119 uint64_t logic_counter;
120 uint64_t analog_counter;
121 int64_t starttime;
122 uint64_t step;
123 /* Logic */
124 int32_t num_logic_channels;
125 unsigned int logic_unitsize;
126 /* There is only ever one logic channel group, so its pattern goes here. */
127 uint8_t logic_pattern;
128 unsigned char logic_data[LOGIC_BUFSIZE];
129 /* Analog */
130 int32_t num_analog_channels;
131 GHashTable *ch_ag;
132 gboolean avg; /* True if averaging is enabled */
133 uint64_t avg_samples;
134};
135
136static const uint32_t drvopts[] = {
137 SR_CONF_DEMO_DEV,
138 SR_CONF_LOGIC_ANALYZER,
139 SR_CONF_OSCILLOSCOPE,
140};
141
142static const uint32_t scanopts[] = {
143 SR_CONF_NUM_LOGIC_CHANNELS,
144 SR_CONF_NUM_ANALOG_CHANNELS,
145};
146
147static const uint32_t devopts[] = {
148 SR_CONF_CONTINUOUS | SR_CONF_SET,
149 SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
150 SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
151 SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
152 SR_CONF_AVERAGING | SR_CONF_GET | SR_CONF_SET,
153 SR_CONF_AVG_SAMPLES | SR_CONF_GET | SR_CONF_SET,
154};
155
156static const uint32_t devopts_cg_logic[] = {
157 SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
158};
159
160static const uint32_t devopts_cg_analog_group[] = {
161 SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
162};
163
164static const uint32_t devopts_cg_analog_channel[] = {
165 SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
166 SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
167};
168
169static const uint64_t samplerates[] = {
170 SR_HZ(1),
171 SR_GHZ(1),
172 SR_HZ(1),
173};
174
175static const uint8_t pattern_sigrok[] = {
176 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
177 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
178 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
179 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
180 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
181 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
182 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
183 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
184};
185
186SR_PRIV struct sr_dev_driver demo_driver_info;
187
188static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
189
190static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
191{
192 return std_init(sr_ctx, di, LOG_PREFIX);
193}
194
195static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
196{
197 double t, frequency;
198 float value;
199 unsigned int num_samples, i;
200 int last_end;
201
202 sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
203
204 num_samples = ANALOG_BUFSIZE / sizeof(float);
205
206 switch (ag->pattern) {
207 case PATTERN_SQUARE:
208 value = ag->amplitude;
209 last_end = 0;
210 for (i = 0; i < num_samples; i++) {
211 if (i % 5 == 0)
212 value = -value;
213 if (i % 10 == 0)
214 last_end = i;
215 ag->pattern_data[i] = value;
216 }
217 ag->num_samples = last_end;
218 break;
219 case PATTERN_SINE:
220 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
221
222 /* Make sure the number of samples we put out is an integer
223 * multiple of our period size */
224 /* FIXME we actually need only one period. A ringbuffer would be
225 * useful here. */
226 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
227 num_samples--;
228
229 for (i = 0; i < num_samples; i++) {
230 t = (double) i / (double) sample_rate;
231 ag->pattern_data[i] = ag->amplitude *
232 sin(2 * G_PI * frequency * t);
233 }
234
235 ag->num_samples = num_samples;
236 break;
237 case PATTERN_TRIANGLE:
238 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
239
240 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
241 num_samples--;
242
243 for (i = 0; i < num_samples; i++) {
244 t = (double) i / (double) sample_rate;
245 ag->pattern_data[i] = (2 * ag->amplitude / G_PI) *
246 asin(sin(2 * G_PI * frequency * t));
247 }
248
249 ag->num_samples = num_samples;
250 break;
251 case PATTERN_SAWTOOTH:
252 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
253
254 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
255 num_samples--;
256
257 for (i = 0; i < num_samples; i++) {
258 t = (double) i / (double) sample_rate;
259 ag->pattern_data[i] = 2 * ag->amplitude *
260 ((t * frequency) - floor(0.5f + t * frequency));
261 }
262
263 ag->num_samples = num_samples;
264 break;
265 }
266}
267
268static GSList *scan(struct sr_dev_driver *di, GSList *options)
269{
270 struct drv_context *drvc;
271 struct dev_context *devc;
272 struct sr_dev_inst *sdi;
273 struct sr_channel *ch;
274 struct sr_channel_group *cg, *acg;
275 struct sr_config *src;
276 struct analog_gen *ag;
277 GSList *devices, *l;
278 int num_logic_channels, num_analog_channels, pattern, i;
279 char channel_name[16];
280
281 drvc = di->context;
282
283 num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
284 num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
285 for (l = options; l; l = l->next) {
286 src = l->data;
287 switch (src->key) {
288 case SR_CONF_NUM_LOGIC_CHANNELS:
289 num_logic_channels = g_variant_get_int32(src->data);
290 break;
291 case SR_CONF_NUM_ANALOG_CHANNELS:
292 num_analog_channels = g_variant_get_int32(src->data);
293 break;
294 }
295 }
296
297 devices = NULL;
298
299 sdi = g_malloc0(sizeof(struct sr_dev_inst));
300 sdi->status = SR_ST_ACTIVE;
301 sdi->model = g_strdup("Demo device");
302 sdi->driver = di;
303
304 devc = g_malloc(sizeof(struct dev_context));
305 devc->cur_samplerate = SR_KHZ(200);
306 devc->limit_samples = 0;
307 devc->limit_msec = 0;
308 devc->step = 0;
309 devc->continuous = FALSE;
310 devc->num_logic_channels = num_logic_channels;
311 devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
312 devc->logic_pattern = PATTERN_SIGROK;
313 devc->num_analog_channels = num_analog_channels;
314 devc->avg = FALSE;
315 devc->avg_samples = 0;
316
317 /* Logic channels, all in one channel group. */
318 cg = g_malloc0(sizeof(struct sr_channel_group));
319 cg->name = g_strdup("Logic");
320 for (i = 0; i < num_logic_channels; i++) {
321 sprintf(channel_name, "D%d", i);
322 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
323 cg->channels = g_slist_append(cg->channels, ch);
324 }
325 sdi->channel_groups = g_slist_append(NULL, cg);
326
327 /* Analog channels, channel groups and pattern generators. */
328 pattern = 0;
329 /* An "Analog" channel group with all analog channels in it. */
330 acg = g_malloc0(sizeof(struct sr_channel_group));
331 acg->name = g_strdup("Analog");
332 sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
333
334 devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
335 for (i = 0; i < num_analog_channels; i++) {
336 snprintf(channel_name, 16, "A%d", i);
337 ch = sr_channel_new(sdi, i + num_logic_channels, SR_CHANNEL_ANALOG,
338 TRUE, channel_name);
339 acg->channels = g_slist_append(acg->channels, ch);
340
341 /* Every analog channel gets its own channel group as well. */
342 cg = g_malloc0(sizeof(struct sr_channel_group));
343 cg->name = g_strdup(channel_name);
344 cg->channels = g_slist_append(NULL, ch);
345 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
346
347 /* Every channel gets a generator struct. */
348 ag = g_malloc(sizeof(struct analog_gen));
349 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
350 ag->packet.channels = cg->channels;
351 ag->packet.mq = 0;
352 ag->packet.mqflags = 0;
353 ag->packet.unit = SR_UNIT_VOLT;
354 ag->packet.data = ag->pattern_data;
355 ag->pattern = pattern;
356 ag->avg_val = 0.0f;
357 ag->num_avgs = 0;
358 g_hash_table_insert(devc->ch_ag, ch, ag);
359
360 if (++pattern == ARRAY_SIZE(analog_pattern_str))
361 pattern = 0;
362 }
363
364 sdi->priv = devc;
365 devices = g_slist_append(devices, sdi);
366 drvc->instances = g_slist_append(drvc->instances, sdi);
367
368 return devices;
369}
370
371static GSList *dev_list(const struct sr_dev_driver *di)
372{
373 return ((struct drv_context *)(di->context))->instances;
374}
375
376static int dev_open(struct sr_dev_inst *sdi)
377{
378 sdi->status = SR_ST_ACTIVE;
379
380 return SR_OK;
381}
382
383static int dev_close(struct sr_dev_inst *sdi)
384{
385 sdi->status = SR_ST_INACTIVE;
386
387 return SR_OK;
388}
389
390static void clear_helper(void *priv)
391{
392 struct dev_context *devc;
393 GHashTableIter iter;
394 void *value;
395
396 devc = priv;
397
398 /* Analog generators. */
399 g_hash_table_iter_init(&iter, devc->ch_ag);
400 while (g_hash_table_iter_next(&iter, NULL, &value))
401 g_free(value);
402 g_hash_table_unref(devc->ch_ag);
403 g_free(devc);
404}
405
406static int cleanup(const struct sr_dev_driver *di)
407{
408 return std_dev_clear(di, clear_helper);
409}
410
411static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
412 const struct sr_channel_group *cg)
413{
414 struct dev_context *devc;
415 struct sr_channel *ch;
416 struct analog_gen *ag;
417 int pattern;
418
419 if (!sdi)
420 return SR_ERR_ARG;
421
422 devc = sdi->priv;
423 switch (key) {
424 case SR_CONF_SAMPLERATE:
425 *data = g_variant_new_uint64(devc->cur_samplerate);
426 break;
427 case SR_CONF_LIMIT_SAMPLES:
428 *data = g_variant_new_uint64(devc->limit_samples);
429 break;
430 case SR_CONF_LIMIT_MSEC:
431 *data = g_variant_new_uint64(devc->limit_msec);
432 break;
433 case SR_CONF_AVERAGING:
434 *data = g_variant_new_boolean(devc->avg);
435 break;
436 case SR_CONF_AVG_SAMPLES:
437 *data = g_variant_new_uint64(devc->avg_samples);
438 break;
439 case SR_CONF_PATTERN_MODE:
440 if (!cg)
441 return SR_ERR_CHANNEL_GROUP;
442 /* Any channel in the group will do. */
443 ch = cg->channels->data;
444 if (ch->type == SR_CHANNEL_LOGIC) {
445 pattern = devc->logic_pattern;
446 *data = g_variant_new_string(logic_pattern_str[pattern]);
447 } else if (ch->type == SR_CHANNEL_ANALOG) {
448 ag = g_hash_table_lookup(devc->ch_ag, ch);
449 pattern = ag->pattern;
450 *data = g_variant_new_string(analog_pattern_str[pattern]);
451 } else
452 return SR_ERR_BUG;
453 break;
454 case SR_CONF_AMPLITUDE:
455 if (!cg)
456 return SR_ERR_CHANNEL_GROUP;
457 /* Any channel in the group will do. */
458 ch = cg->channels->data;
459 if (ch->type != SR_CHANNEL_ANALOG)
460 return SR_ERR_ARG;
461 ag = g_hash_table_lookup(devc->ch_ag, ch);
462 *data = g_variant_new_double(ag->amplitude);
463 break;
464 default:
465 return SR_ERR_NA;
466 }
467
468 return SR_OK;
469}
470
471static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
472 const struct sr_channel_group *cg)
473{
474 struct dev_context *devc;
475 struct analog_gen *ag;
476 struct sr_channel *ch;
477 GSList *l;
478 int logic_pattern, analog_pattern, ret;
479 unsigned int i;
480 const char *stropt;
481
482 devc = sdi->priv;
483
484 if (sdi->status != SR_ST_ACTIVE)
485 return SR_ERR_DEV_CLOSED;
486
487 ret = SR_OK;
488 switch (key) {
489 case SR_CONF_SAMPLERATE:
490 devc->cur_samplerate = g_variant_get_uint64(data);
491 break;
492 case SR_CONF_LIMIT_SAMPLES:
493 devc->limit_msec = 0;
494 devc->limit_samples = g_variant_get_uint64(data);
495 break;
496 case SR_CONF_LIMIT_MSEC:
497 devc->limit_msec = g_variant_get_uint64(data);
498 devc->limit_samples = 0;
499 break;
500 case SR_CONF_AVERAGING:
501 devc->avg = g_variant_get_boolean(data);
502 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
503 break;
504 case SR_CONF_AVG_SAMPLES:
505 devc->avg_samples = g_variant_get_uint64(data);
506 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
507 break;
508 case SR_CONF_PATTERN_MODE:
509 if (!cg)
510 return SR_ERR_CHANNEL_GROUP;
511 stropt = g_variant_get_string(data, NULL);
512 logic_pattern = analog_pattern = -1;
513 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
514 if (!strcmp(stropt, logic_pattern_str[i])) {
515 logic_pattern = i;
516 break;
517 }
518 }
519 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
520 if (!strcmp(stropt, analog_pattern_str[i])) {
521 analog_pattern = i;
522 break;
523 }
524 }
525 if (logic_pattern == -1 && analog_pattern == -1)
526 return SR_ERR_ARG;
527 for (l = cg->channels; l; l = l->next) {
528 ch = l->data;
529 if (ch->type == SR_CHANNEL_LOGIC) {
530 if (logic_pattern == -1)
531 return SR_ERR_ARG;
532 sr_dbg("Setting logic pattern to %s",
533 logic_pattern_str[logic_pattern]);
534 devc->logic_pattern = logic_pattern;
535 /* Might as well do this now, these are static. */
536 if (logic_pattern == PATTERN_ALL_LOW)
537 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
538 else if (logic_pattern == PATTERN_ALL_HIGH)
539 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
540 } else if (ch->type == SR_CHANNEL_ANALOG) {
541 if (analog_pattern == -1)
542 return SR_ERR_ARG;
543 sr_dbg("Setting analog pattern for channel %s to %s",
544 ch->name, analog_pattern_str[analog_pattern]);
545 ag = g_hash_table_lookup(devc->ch_ag, ch);
546 ag->pattern = analog_pattern;
547 } else
548 return SR_ERR_BUG;
549 }
550 break;
551 case SR_CONF_AMPLITUDE:
552 if (!cg)
553 return SR_ERR_CHANNEL_GROUP;
554 for (l = cg->channels; l; l = l->next) {
555 ch = l->data;
556 if (ch->type != SR_CHANNEL_ANALOG)
557 return SR_ERR_ARG;
558 ag = g_hash_table_lookup(devc->ch_ag, ch);
559 ag->amplitude = g_variant_get_double(data);
560 }
561 break;
562 default:
563 ret = SR_ERR_NA;
564 }
565
566 return ret;
567}
568
569static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
570 const struct sr_channel_group *cg)
571{
572 struct sr_channel *ch;
573 GVariant *gvar;
574 GVariantBuilder gvb;
575
576 if (key == SR_CONF_SCAN_OPTIONS) {
577 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
578 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
579 return SR_OK;
580 }
581
582 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
583 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
584 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
585 return SR_OK;
586 }
587
588 if (!sdi)
589 return SR_ERR_ARG;
590
591 if (!cg) {
592 switch (key) {
593 case SR_CONF_DEVICE_OPTIONS:
594 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
595 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
596 break;
597 case SR_CONF_SAMPLERATE:
598 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
599 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
600 ARRAY_SIZE(samplerates), sizeof(uint64_t));
601 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
602 *data = g_variant_builder_end(&gvb);
603 break;
604 default:
605 return SR_ERR_NA;
606 }
607 } else {
608 ch = cg->channels->data;
609 switch (key) {
610 case SR_CONF_DEVICE_OPTIONS:
611 if (ch->type == SR_CHANNEL_LOGIC)
612 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
613 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
614 sizeof(uint32_t));
615 else if (ch->type == SR_CHANNEL_ANALOG) {
616 if (strcmp(cg->name, "Analog") == 0)
617 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
618 devopts_cg_analog_group, ARRAY_SIZE(devopts_cg_analog_group),
619 sizeof(uint32_t));
620 else
621 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
622 devopts_cg_analog_channel, ARRAY_SIZE(devopts_cg_analog_channel),
623 sizeof(uint32_t));
624 }
625 else
626 return SR_ERR_BUG;
627 break;
628 case SR_CONF_PATTERN_MODE:
629 /* The analog group (with all 4 channels) shall not have a pattern property. */
630 if (strcmp(cg->name, "Analog") == 0)
631 return SR_ERR_NA;
632
633 if (ch->type == SR_CHANNEL_LOGIC)
634 *data = g_variant_new_strv(logic_pattern_str,
635 ARRAY_SIZE(logic_pattern_str));
636 else if (ch->type == SR_CHANNEL_ANALOG)
637 *data = g_variant_new_strv(analog_pattern_str,
638 ARRAY_SIZE(analog_pattern_str));
639 else
640 return SR_ERR_BUG;
641 break;
642 default:
643 return SR_ERR_NA;
644 }
645 }
646
647 return SR_OK;
648}
649
650static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
651{
652 struct dev_context *devc;
653 uint64_t i, j;
654 uint8_t pat;
655
656 devc = sdi->priv;
657
658 switch (devc->logic_pattern) {
659 case PATTERN_SIGROK:
660 memset(devc->logic_data, 0x00, size);
661 for (i = 0; i < size; i += devc->logic_unitsize) {
662 for (j = 0; j < devc->logic_unitsize; j++) {
663 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
664 devc->logic_data[i + j] = ~pat;
665 }
666 devc->step++;
667 }
668 break;
669 case PATTERN_RANDOM:
670 for (i = 0; i < size; i++)
671 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
672 break;
673 case PATTERN_INC:
674 for (i = 0; i < size; i++) {
675 for (j = 0; j < devc->logic_unitsize; j++) {
676 devc->logic_data[i + j] = devc->step;
677 }
678 devc->step++;
679 }
680 break;
681 case PATTERN_ALL_LOW:
682 case PATTERN_ALL_HIGH:
683 /* These were set when the pattern mode was selected. */
684 break;
685 default:
686 sr_err("Unknown pattern: %d.", devc->logic_pattern);
687 break;
688 }
689}
690
691static void send_analog_packet(struct analog_gen *ag,
692 struct sr_dev_inst *sdi,
693 uint64_t *analog_sent,
694 uint64_t analog_todo)
695{
696 struct sr_datafeed_packet packet;
697 struct dev_context *devc;
698 uint64_t sending_now, to_avg;
699 int ag_pattern_pos;
700 unsigned int i;
701
702 devc = sdi->priv;
703 packet.type = SR_DF_ANALOG;
704 packet.payload = &ag->packet;
705
706 if (!devc->avg) {
707 ag_pattern_pos = devc->analog_counter % ag->num_samples;
708 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
709 ag->packet.data = ag->pattern_data + ag_pattern_pos;
710 ag->packet.num_samples = sending_now;
711 sr_session_send(sdi, &packet);
712
713 /* Whichever channel group gets there first. */
714 *analog_sent = MAX(*analog_sent, sending_now);
715 } else {
716 ag_pattern_pos = devc->analog_counter % ag->num_samples;
717 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
718
719 for (i = 0; i < to_avg; i++) {
720 ag->avg_val = (ag->avg_val +
721 *(ag->pattern_data +
722 ag_pattern_pos + i)) / 2;
723 ag->num_avgs++;
724 /* Time to send averaged data? */
725 if (devc->avg_samples > 0 &&
726 ag->num_avgs >= devc->avg_samples)
727 goto do_send;
728 }
729
730 if (devc->avg_samples == 0) {
731 /* We're averaging all the samples, so wait with
732 * sending until the very end.
733 */
734 *analog_sent = ag->num_avgs;
735 return;
736 }
737
738do_send:
739 ag->packet.data = &ag->avg_val;
740 ag->packet.num_samples = 1;
741
742 sr_session_send(sdi, &packet);
743 *analog_sent = ag->num_avgs;
744
745 ag->num_avgs = 0;
746 ag->avg_val = 0.0f;
747 }
748}
749
750/* Callback handling data */
751static int prepare_data(int fd, int revents, void *cb_data)
752{
753 struct sr_dev_inst *sdi;
754 struct dev_context *devc;
755 struct sr_datafeed_packet packet;
756 struct sr_datafeed_logic logic;
757 struct analog_gen *ag;
758 GHashTableIter iter;
759 void *value;
760 uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
761 int64_t time, elapsed;
762
763 (void)fd;
764 (void)revents;
765
766 sdi = cb_data;
767 devc = sdi->priv;
768 logic_todo = analog_todo = 0;
769
770 /* How many samples should we have sent by now? */
771 time = g_get_monotonic_time();
772 elapsed = time - devc->starttime;
773 expected_samplenum = elapsed * devc->cur_samplerate / (1000 * 1000);
774
775 /* But never more than the limit, if there is one. */
776 if (!devc->continuous)
777 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
778
779 /* Of those, how many do we still have to send? */
780 if (devc->num_logic_channels && (devc->logic_counter < devc->limit_samples))
781 logic_todo = expected_samplenum - devc->logic_counter;
782 if (devc->num_analog_channels && (devc->analog_counter < devc->limit_samples))
783 analog_todo = expected_samplenum - devc->analog_counter;
784
785 while (logic_todo || analog_todo) {
786 /* Logic */
787 if (logic_todo > 0) {
788 sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
789 logic_generator(sdi, sending_now * devc->logic_unitsize);
790 packet.type = SR_DF_LOGIC;
791 packet.payload = &logic;
792 logic.length = sending_now * devc->logic_unitsize;
793 logic.unitsize = devc->logic_unitsize;
794 logic.data = devc->logic_data;
795 sr_session_send(sdi, &packet);
796 logic_todo -= sending_now;
797 devc->logic_counter += sending_now;
798 }
799
800 /* Analog, one channel at a time */
801 if (analog_todo > 0) {
802 analog_sent = 0;
803
804 g_hash_table_iter_init(&iter, devc->ch_ag);
805 while (g_hash_table_iter_next(&iter, NULL, &value)) {
806 send_analog_packet(value, sdi,
807 &analog_sent, analog_todo);
808 }
809 analog_todo -= analog_sent;
810 devc->analog_counter += analog_sent;
811 }
812 }
813
814 if (!devc->continuous
815 && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
816 && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
817 /* If we're averaging everything - now is the time to send data */
818 if (devc->avg_samples == 0) {
819 g_hash_table_iter_init(&iter, devc->ch_ag);
820 while (g_hash_table_iter_next(&iter, NULL, &value)) {
821 ag = value;
822 packet.type = SR_DF_ANALOG;
823 packet.payload = &ag->packet;
824 ag->packet.data = &ag->avg_val;
825 ag->packet.num_samples = 1;
826 sr_session_send(sdi, &packet);
827 }
828 }
829
830 sr_dbg("Requested number of samples reached.");
831 dev_acquisition_stop(sdi, cb_data);
832 return TRUE;
833 }
834
835 return TRUE;
836}
837
838static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
839{
840 struct dev_context *devc;
841 GHashTableIter iter;
842 void *value;
843
844 (void)cb_data;
845
846 if (sdi->status != SR_ST_ACTIVE)
847 return SR_ERR_DEV_CLOSED;
848
849 devc = sdi->priv;
850 devc->continuous = !devc->limit_samples;
851 devc->logic_counter = devc->analog_counter = 0;
852
853 /*
854 * Setting two channels connected by a pipe is a remnant from when the
855 * demo driver generated data in a thread, and collected and sent the
856 * data in the main program loop.
857 * They are kept here because it provides a convenient way of setting
858 * up a timeout-based polling mechanism.
859 */
860 if (pipe(devc->pipe_fds)) {
861 sr_err("%s: pipe() failed", __func__);
862 return SR_ERR;
863 }
864
865 g_hash_table_iter_init(&iter, devc->ch_ag);
866 while (g_hash_table_iter_next(&iter, NULL, &value))
867 generate_analog_pattern(value, devc->cur_samplerate);
868
869 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
870 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
871
872 /* Set channel encoding to binary (default is UTF-8). */
873 g_io_channel_set_encoding(devc->channel, NULL, NULL);
874
875 /* Make channels unbuffered. */
876 g_io_channel_set_buffered(devc->channel, FALSE);
877
878 sr_session_source_add_channel(sdi->session, devc->channel,
879 G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
880
881 /* Send header packet to the session bus. */
882 std_session_send_df_header(sdi, LOG_PREFIX);
883
884 /* We use this timestamp to decide how many more samples to send. */
885 devc->starttime = g_get_monotonic_time();
886
887 return SR_OK;
888}
889
890static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
891{
892 struct dev_context *devc;
893 struct sr_datafeed_packet packet;
894
895 (void)cb_data;
896
897 devc = sdi->priv;
898 sr_dbg("Stopping acquisition.");
899
900 sr_session_source_remove_channel(sdi->session, devc->channel);
901 g_io_channel_shutdown(devc->channel, FALSE, NULL);
902 g_io_channel_unref(devc->channel);
903 devc->channel = NULL;
904 close(devc->pipe_fds[0]);
905 close(devc->pipe_fds[1]);
906
907 /* Send last packet. */
908 packet.type = SR_DF_END;
909 sr_session_send(sdi, &packet);
910
911 return SR_OK;
912}
913
914SR_PRIV struct sr_dev_driver demo_driver_info = {
915 .name = "demo",
916 .longname = "Demo driver and pattern generator",
917 .api_version = 1,
918 .init = init,
919 .cleanup = cleanup,
920 .scan = scan,
921 .dev_list = dev_list,
922 .dev_clear = NULL,
923 .config_get = config_get,
924 .config_set = config_set,
925 .config_list = config_list,
926 .dev_open = dev_open,
927 .dev_close = dev_close,
928 .dev_acquisition_start = dev_acquisition_start,
929 .dev_acquisition_stop = dev_acquisition_stop,
930 .context = NULL,
931};
Hardware access and backend lib