]> 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
Constify a few arrays and variables.
[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.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[] = {
161 SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
162 SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
163};
164
165static const uint64_t samplerates[] = {
166 SR_HZ(1),
167 SR_GHZ(1),
168 SR_HZ(1),
169};
170
171static const uint8_t pattern_sigrok[] = {
172 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
173 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
174 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
175 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
176 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
177 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
178 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
179 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
180};
181
182SR_PRIV struct sr_dev_driver demo_driver_info;
183
184static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
185
186static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
187{
188 return std_init(sr_ctx, di, LOG_PREFIX);
189}
190
191static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
192{
193 double t, frequency;
194 float value;
195 unsigned int num_samples, i;
196 int last_end;
197
198 sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
199
200 num_samples = ANALOG_BUFSIZE / sizeof(float);
201
202 switch (ag->pattern) {
203 case PATTERN_SQUARE:
204 value = ag->amplitude;
205 last_end = 0;
206 for (i = 0; i < num_samples; i++) {
207 if (i % 5 == 0)
208 value = -value;
209 if (i % 10 == 0)
210 last_end = i;
211 ag->pattern_data[i] = value;
212 }
213 ag->num_samples = last_end;
214 break;
215
216 case PATTERN_SINE:
217 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
218
219 /* Make sure the number of samples we put out is an integer
220 * multiple of our period size */
221 /* FIXME we actually need only one period. A ringbuffer would be
222 * usefull here.*/
223 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
224 num_samples--;
225
226 for (i = 0; i < num_samples; i++) {
227 t = (double) i / (double) sample_rate;
228 ag->pattern_data[i] = ag->amplitude *
229 sin(2 * M_PI * frequency * t);
230 }
231
232 ag->num_samples = num_samples;
233 break;
234
235 case PATTERN_TRIANGLE:
236 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
237
238 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
239 num_samples--;
240
241 for (i = 0; i < num_samples; i++) {
242 t = (double) i / (double) sample_rate;
243 ag->pattern_data[i] = (2 * ag->amplitude / M_PI) *
244 asin(sin(2 * M_PI * frequency * t));
245 }
246
247 ag->num_samples = num_samples;
248 break;
249
250 case PATTERN_SAWTOOTH:
251 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
252
253 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
254 num_samples--;
255
256 for (i = 0; i < num_samples; i++) {
257 t = (double) i / (double) sample_rate;
258 ag->pattern_data[i] = 2 * ag->amplitude *
259 ((t * frequency) - floor(0.5f + t * frequency));
260 }
261
262 ag->num_samples = num_samples;
263 break;
264 }
265}
266
267static GSList *scan(struct sr_dev_driver *di, GSList *options)
268{
269 struct drv_context *drvc;
270 struct dev_context *devc;
271 struct sr_dev_inst *sdi;
272 struct sr_channel *ch;
273 struct sr_channel_group *cg, *acg;
274 struct sr_config *src;
275 struct analog_gen *ag;
276 GSList *devices, *l;
277 int num_logic_channels, num_analog_channels, pattern, i;
278 char channel_name[16];
279
280 drvc = di->priv;
281
282 num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
283 num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
284 for (l = options; l; l = l->next) {
285 src = l->data;
286 switch (src->key) {
287 case SR_CONF_NUM_LOGIC_CHANNELS:
288 num_logic_channels = g_variant_get_int32(src->data);
289 break;
290 case SR_CONF_NUM_ANALOG_CHANNELS:
291 num_analog_channels = g_variant_get_int32(src->data);
292 break;
293 }
294 }
295
296 devices = NULL;
297
298 sdi = g_malloc0(sizeof(struct sr_dev_inst));
299 sdi->status = SR_ST_ACTIVE;
300 sdi->model = g_strdup("Demo device");
301 sdi->driver = di;
302
303 devc = g_malloc(sizeof(struct dev_context));
304 devc->cur_samplerate = SR_KHZ(200);
305 devc->limit_samples = 0;
306 devc->limit_msec = 0;
307 devc->step = 0;
308 devc->continuous = FALSE;
309 devc->num_logic_channels = num_logic_channels;
310 devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
311 devc->logic_pattern = PATTERN_SIGROK;
312 devc->num_analog_channels = num_analog_channels;
313 devc->avg = FALSE;
314 devc->avg_samples = 0;
315
316 /* Logic channels, all in one channel group. */
317 cg = g_malloc0(sizeof(struct sr_channel_group));
318 cg->name = g_strdup("Logic");
319 for (i = 0; i < num_logic_channels; i++) {
320 sprintf(channel_name, "D%d", i);
321 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
322 cg->channels = g_slist_append(cg->channels, ch);
323 }
324 sdi->channel_groups = g_slist_append(NULL, cg);
325
326 /* Analog channels, channel groups and pattern generators. */
327 pattern = 0;
328 /* An "Analog" channel group with all analog channels in it. */
329 acg = g_malloc0(sizeof(struct sr_channel_group));
330 acg->name = g_strdup("Analog");
331 sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
332
333 devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
334 for (i = 0; i < num_analog_channels; i++) {
335 snprintf(channel_name, 16, "A%d", i);
336 ch = sr_channel_new(sdi, i + num_logic_channels, SR_CHANNEL_ANALOG,
337 TRUE, channel_name);
338 acg->channels = g_slist_append(acg->channels, ch);
339
340 /* Every analog channel gets its own channel group as well. */
341 cg = g_malloc0(sizeof(struct sr_channel_group));
342 cg->name = g_strdup(channel_name);
343 cg->channels = g_slist_append(NULL, ch);
344 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
345
346 /* Every channel gets a generator struct. */
347 ag = g_malloc(sizeof(struct analog_gen));
348 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
349 ag->packet.channels = cg->channels;
350 ag->packet.mq = 0;
351 ag->packet.mqflags = 0;
352 ag->packet.unit = SR_UNIT_VOLT;
353 ag->packet.data = ag->pattern_data;
354 ag->pattern = pattern;
355 ag->avg_val = 0.0f;
356 ag->num_avgs = 0;
357 g_hash_table_insert(devc->ch_ag, ch, ag);
358
359 if (++pattern == ARRAY_SIZE(analog_pattern_str))
360 pattern = 0;
361 }
362
363 sdi->priv = devc;
364 devices = g_slist_append(devices, sdi);
365 drvc->instances = g_slist_append(drvc->instances, sdi);
366
367 return devices;
368}
369
370static GSList *dev_list(const struct sr_dev_driver *di)
371{
372 return ((struct drv_context *)(di->priv))->instances;
373}
374
375static int dev_open(struct sr_dev_inst *sdi)
376{
377 sdi->status = SR_ST_ACTIVE;
378
379 return SR_OK;
380}
381
382static int dev_close(struct sr_dev_inst *sdi)
383{
384 sdi->status = SR_ST_INACTIVE;
385
386 return SR_OK;
387}
388
389static void clear_helper(void *priv)
390{
391 struct dev_context *devc;
392 GHashTableIter iter;
393 void *value;
394
395 devc = priv;
396
397 /* Analog generators. */
398 g_hash_table_iter_init(&iter, devc->ch_ag);
399 while (g_hash_table_iter_next(&iter, NULL, &value))
400 g_free(value);
401 g_hash_table_unref(devc->ch_ag);
402 g_free(devc);
403}
404
405static int cleanup(const struct sr_dev_driver *di)
406{
407 return std_dev_clear(di, clear_helper);
408}
409
410static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
411 const struct sr_channel_group *cg)
412{
413 struct dev_context *devc;
414 struct sr_channel *ch;
415 struct analog_gen *ag;
416 int pattern;
417
418 if (!sdi)
419 return SR_ERR_ARG;
420
421 devc = sdi->priv;
422 switch (key) {
423 case SR_CONF_SAMPLERATE:
424 *data = g_variant_new_uint64(devc->cur_samplerate);
425 break;
426 case SR_CONF_LIMIT_SAMPLES:
427 *data = g_variant_new_uint64(devc->limit_samples);
428 break;
429 case SR_CONF_LIMIT_MSEC:
430 *data = g_variant_new_uint64(devc->limit_msec);
431 break;
432 case SR_CONF_AVERAGING:
433 *data = g_variant_new_boolean(devc->avg);
434 break;
435 case SR_CONF_AVG_SAMPLES:
436 *data = g_variant_new_uint64(devc->avg_samples);
437 break;
438 case SR_CONF_PATTERN_MODE:
439 if (!cg)
440 return SR_ERR_CHANNEL_GROUP;
441 /* Any channel in the group will do. */
442 ch = cg->channels->data;
443 if (ch->type == SR_CHANNEL_LOGIC) {
444 pattern = devc->logic_pattern;
445 *data = g_variant_new_string(logic_pattern_str[pattern]);
446 } else if (ch->type == SR_CHANNEL_ANALOG) {
447 ag = g_hash_table_lookup(devc->ch_ag, ch);
448 pattern = ag->pattern;
449 *data = g_variant_new_string(analog_pattern_str[pattern]);
450 } else
451 return SR_ERR_BUG;
452 break;
453 case SR_CONF_AMPLITUDE:
454 if (!cg)
455 return SR_ERR_CHANNEL_GROUP;
456 /* Any channel in the group will do. */
457 ch = cg->channels->data;
458 if (ch->type != SR_CHANNEL_ANALOG)
459 return SR_ERR_ARG;
460 ag = g_hash_table_lookup(devc->ch_ag, ch);
461 *data = g_variant_new_double(ag->amplitude);
462 break;
463 default:
464 return SR_ERR_NA;
465 }
466
467 return SR_OK;
468}
469
470static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
471 const struct sr_channel_group *cg)
472{
473 struct dev_context *devc;
474 struct analog_gen *ag;
475 struct sr_channel *ch;
476 GSList *l;
477 int logic_pattern, analog_pattern, ret;
478 unsigned int i;
479 const char *stropt;
480
481 devc = sdi->priv;
482
483 if (sdi->status != SR_ST_ACTIVE)
484 return SR_ERR_DEV_CLOSED;
485
486 ret = SR_OK;
487 switch (key) {
488 case SR_CONF_SAMPLERATE:
489 devc->cur_samplerate = g_variant_get_uint64(data);
490 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
491 break;
492 case SR_CONF_LIMIT_SAMPLES:
493 devc->limit_msec = 0;
494 devc->limit_samples = g_variant_get_uint64(data);
495 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
496 break;
497 case SR_CONF_LIMIT_MSEC:
498 devc->limit_msec = g_variant_get_uint64(data);
499 devc->limit_samples = 0;
500 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
501 break;
502 case SR_CONF_AVERAGING:
503 devc->avg = g_variant_get_boolean(data);
504 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
505 break;
506 case SR_CONF_AVG_SAMPLES:
507 devc->avg_samples = g_variant_get_uint64(data);
508 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
509 break;
510 case SR_CONF_PATTERN_MODE:
511 if (!cg)
512 return SR_ERR_CHANNEL_GROUP;
513 stropt = g_variant_get_string(data, NULL);
514 logic_pattern = analog_pattern = -1;
515 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
516 if (!strcmp(stropt, logic_pattern_str[i])) {
517 logic_pattern = i;
518 break;
519 }
520 }
521 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
522 if (!strcmp(stropt, analog_pattern_str[i])) {
523 analog_pattern = i;
524 break;
525 }
526 }
527 if (logic_pattern == -1 && analog_pattern == -1)
528 return SR_ERR_ARG;
529 for (l = cg->channels; l; l = l->next) {
530 ch = l->data;
531 if (ch->type == SR_CHANNEL_LOGIC) {
532 if (logic_pattern == -1)
533 return SR_ERR_ARG;
534 sr_dbg("Setting logic pattern to %s",
535 logic_pattern_str[logic_pattern]);
536 devc->logic_pattern = logic_pattern;
537 /* Might as well do this now, these are static. */
538 if (logic_pattern == PATTERN_ALL_LOW)
539 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
540 else if (logic_pattern == PATTERN_ALL_HIGH)
541 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
542 } else if (ch->type == SR_CHANNEL_ANALOG) {
543 if (analog_pattern == -1)
544 return SR_ERR_ARG;
545 sr_dbg("Setting analog pattern for channel %s to %s",
546 ch->name, analog_pattern_str[analog_pattern]);
547 ag = g_hash_table_lookup(devc->ch_ag, ch);
548 ag->pattern = analog_pattern;
549 } else
550 return SR_ERR_BUG;
551 }
552 break;
553 case SR_CONF_AMPLITUDE:
554 if (!cg)
555 return SR_ERR_CHANNEL_GROUP;
556 for (l = cg->channels; l; l = l->next) {
557 ch = l->data;
558 if (ch->type != SR_CHANNEL_ANALOG)
559 return SR_ERR_ARG;
560 ag = g_hash_table_lookup(devc->ch_ag, ch);
561 ag->amplitude = g_variant_get_double(data);
562 }
563 break;
564 default:
565 ret = SR_ERR_NA;
566 }
567
568 return ret;
569}
570
571static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
572 const struct sr_channel_group *cg)
573{
574 struct sr_channel *ch;
575 GVariant *gvar;
576 GVariantBuilder gvb;
577
578 (void)sdi;
579
580 if (key == SR_CONF_SCAN_OPTIONS) {
581 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
582 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
583 return SR_OK;
584 }
585
586 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
587 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
588 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
589 return SR_OK;
590 }
591
592 if (!sdi)
593 return SR_ERR_ARG;
594
595 if (!cg) {
596 switch (key) {
597 case SR_CONF_DEVICE_OPTIONS:
598 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
599 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
600 break;
601 case SR_CONF_SAMPLERATE:
602 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
603 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
604 ARRAY_SIZE(samplerates), sizeof(uint64_t));
605 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
606 *data = g_variant_builder_end(&gvb);
607 break;
608 default:
609 return SR_ERR_NA;
610 }
611 } else {
612 /* Any channel in the group will do. */
613 ch = cg->channels->data;
614 switch (key) {
615 case SR_CONF_DEVICE_OPTIONS:
616 if (ch->type == SR_CHANNEL_LOGIC)
617 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
618 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
619 sizeof(uint32_t));
620 else if (ch->type == SR_CHANNEL_ANALOG)
621 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
622 devopts_cg_analog, ARRAY_SIZE(devopts_cg_analog),
623 sizeof(uint32_t));
624 else
625 return SR_ERR_BUG;
626 break;
627 case SR_CONF_PATTERN_MODE:
628 if (ch->type == SR_CHANNEL_LOGIC)
629 *data = g_variant_new_strv(logic_pattern_str,
630 ARRAY_SIZE(logic_pattern_str));
631 else if (ch->type == SR_CHANNEL_ANALOG)
632 *data = g_variant_new_strv(analog_pattern_str,
633 ARRAY_SIZE(analog_pattern_str));
634 else
635 return SR_ERR_BUG;
636 break;
637 default:
638 return SR_ERR_NA;
639 }
640 }
641
642 return SR_OK;
643}
644
645static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
646{
647 struct dev_context *devc;
648 uint64_t i, j;
649 uint8_t pat;
650
651 devc = sdi->priv;
652
653 switch (devc->logic_pattern) {
654 case PATTERN_SIGROK:
655 memset(devc->logic_data, 0x00, size);
656 for (i = 0; i < size; i += devc->logic_unitsize) {
657 for (j = 0; j < devc->logic_unitsize; j++) {
658 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
659 devc->logic_data[i + j] = ~pat;
660 }
661 devc->step++;
662 }
663 break;
664 case PATTERN_RANDOM:
665 for (i = 0; i < size; i++)
666 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
667 break;
668 case PATTERN_INC:
669 for (i = 0; i < size; i++) {
670 for (j = 0; j < devc->logic_unitsize; j++) {
671 devc->logic_data[i + j] = devc->step;
672 }
673 devc->step++;
674 }
675 break;
676 case PATTERN_ALL_LOW:
677 case PATTERN_ALL_HIGH:
678 /* These were set when the pattern mode was selected. */
679 break;
680 default:
681 sr_err("Unknown pattern: %d.", devc->logic_pattern);
682 break;
683 }
684}
685
686static void send_analog_packet(struct analog_gen *ag,
687 struct sr_dev_inst *sdi,
688 uint64_t *analog_sent,
689 uint64_t analog_todo)
690{
691 struct sr_datafeed_packet packet;
692 struct dev_context *devc;
693 uint64_t sending_now, to_avg;
694 int ag_pattern_pos;
695 unsigned int i;
696
697 devc = sdi->priv;
698 packet.type = SR_DF_ANALOG;
699 packet.payload = &ag->packet;
700
701 if (!devc->avg) {
702 ag_pattern_pos = devc->analog_counter % ag->num_samples;
703 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
704 ag->packet.data = ag->pattern_data + ag_pattern_pos;
705 ag->packet.num_samples = sending_now;
706 sr_session_send(sdi, &packet);
707
708 /* Whichever channel group gets there first. */
709 *analog_sent = MAX(*analog_sent, sending_now);
710 } else {
711 ag_pattern_pos = devc->analog_counter % ag->num_samples;
712 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
713
714 for (i = 0; i < to_avg; i++) {
715 ag->avg_val = (ag->avg_val +
716 *(ag->pattern_data +
717 ag_pattern_pos + i)) / 2;
718 ag->num_avgs++;
719 /* Time to send averaged data? */
720 if (devc->avg_samples > 0 &&
721 ag->num_avgs >= devc->avg_samples)
722 goto do_send;
723 }
724
725 if (devc->avg_samples == 0) {
726 /* We're averaging all the samples, so wait with
727 * sending until the very end.
728 */
729 *analog_sent = ag->num_avgs;
730 return;
731 }
732
733do_send:
734 ag->packet.data = &ag->avg_val;
735 ag->packet.num_samples = 1;
736
737 sr_session_send(sdi, &packet);
738 *analog_sent = ag->num_avgs;
739
740 ag->num_avgs = 0;
741 ag->avg_val = 0.0f;
742 }
743}
744
745/* Callback handling data */
746static int prepare_data(int fd, int revents, void *cb_data)
747{
748 struct sr_dev_inst *sdi;
749 struct dev_context *devc;
750 struct sr_datafeed_packet packet;
751 struct sr_datafeed_logic logic;
752 struct analog_gen *ag;
753 GHashTableIter iter;
754 void *value;
755 uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
756 int64_t time, elapsed;
757
758 (void)fd;
759 (void)revents;
760
761 sdi = cb_data;
762 devc = sdi->priv;
763 logic_todo = analog_todo = 0;
764
765 /* How many samples should we have sent by now? */
766 time = g_get_monotonic_time();
767 elapsed = time - devc->starttime;
768 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
769
770 /* But never more than the limit, if there is one. */
771 if (!devc->continuous)
772 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
773
774 /* Of those, how many do we still have to send? */
775 if (devc->num_logic_channels)
776 logic_todo = expected_samplenum - devc->logic_counter;
777 if (devc->num_analog_channels)
778 analog_todo = expected_samplenum - devc->analog_counter;
779
780 while (logic_todo || analog_todo) {
781 /* Logic */
782 if (logic_todo > 0) {
783 sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
784 logic_generator(sdi, sending_now * devc->logic_unitsize);
785 packet.type = SR_DF_LOGIC;
786 packet.payload = &logic;
787 logic.length = sending_now * devc->logic_unitsize;
788 logic.unitsize = devc->logic_unitsize;
789 logic.data = devc->logic_data;
790 sr_session_send(sdi, &packet);
791 logic_todo -= sending_now;
792 devc->logic_counter += sending_now;
793 }
794
795 /* Analog, one channel at a time */
796 if (analog_todo > 0) {
797 analog_sent = 0;
798
799 g_hash_table_iter_init(&iter, devc->ch_ag);
800 while (g_hash_table_iter_next(&iter, NULL, &value)) {
801 send_analog_packet(value, sdi,
802 &analog_sent, analog_todo);
803 }
804 analog_todo -= analog_sent;
805 devc->analog_counter += analog_sent;
806 }
807 }
808
809 if (!devc->continuous
810 && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
811 && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
812 /* If we're averaging everything - now is the time to send data */
813 if (devc->avg_samples == 0) {
814 g_hash_table_iter_init(&iter, devc->ch_ag);
815 while (g_hash_table_iter_next(&iter, NULL, &value)) {
816 ag = value;
817 packet.type = SR_DF_ANALOG;
818 packet.payload = &ag->packet;
819 ag->packet.data = &ag->avg_val;
820 ag->packet.num_samples = 1;
821 sr_session_send(sdi, &packet);
822 }
823 }
824
825 sr_dbg("Requested number of samples reached.");
826 dev_acquisition_stop(sdi, cb_data);
827 return TRUE;
828 }
829
830 return TRUE;
831}
832
833static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
834{
835 struct dev_context *devc;
836 GHashTableIter iter;
837 void *value;
838
839 (void)cb_data;
840
841 if (sdi->status != SR_ST_ACTIVE)
842 return SR_ERR_DEV_CLOSED;
843
844 devc = sdi->priv;
845 devc->continuous = !devc->limit_samples;
846 devc->logic_counter = devc->analog_counter = 0;
847
848 /*
849 * Setting two channels connected by a pipe is a remnant from when the
850 * demo driver generated data in a thread, and collected and sent the
851 * data in the main program loop.
852 * They are kept here because it provides a convenient way of setting
853 * up a timeout-based polling mechanism.
854 */
855 if (pipe(devc->pipe_fds)) {
856 sr_err("%s: pipe() failed", __func__);
857 return SR_ERR;
858 }
859
860 g_hash_table_iter_init(&iter, devc->ch_ag);
861 while (g_hash_table_iter_next(&iter, NULL, &value))
862 generate_analog_pattern(value, devc->cur_samplerate);
863
864 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
865 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
866
867 /* Set channel encoding to binary (default is UTF-8). */
868 g_io_channel_set_encoding(devc->channel, NULL, NULL);
869
870 /* Make channels unbuffered. */
871 g_io_channel_set_buffered(devc->channel, FALSE);
872
873 sr_session_source_add_channel(sdi->session, devc->channel,
874 G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
875
876 /* Send header packet to the session bus. */
877 std_session_send_df_header(sdi, LOG_PREFIX);
878
879 /* We use this timestamp to decide how many more samples to send. */
880 devc->starttime = g_get_monotonic_time();
881
882 return SR_OK;
883}
884
885static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
886{
887 struct dev_context *devc;
888 struct sr_datafeed_packet packet;
889
890 (void)cb_data;
891
892 devc = sdi->priv;
893 sr_dbg("Stopping acquisition.");
894
895 sr_session_source_remove_channel(sdi->session, devc->channel);
896 g_io_channel_shutdown(devc->channel, FALSE, NULL);
897 g_io_channel_unref(devc->channel);
898 devc->channel = NULL;
899
900 /* Send last packet. */
901 packet.type = SR_DF_END;
902 sr_session_send(sdi, &packet);
903
904 return SR_OK;
905}
906
907SR_PRIV struct sr_dev_driver demo_driver_info = {
908 .name = "demo",
909 .longname = "Demo driver and pattern generator",
910 .api_version = 1,
911 .init = init,
912 .cleanup = cleanup,
913 .scan = scan,
914 .dev_list = dev_list,
915 .dev_clear = NULL,
916 .config_get = config_get,
917 .config_set = config_set,
918 .config_list = config_list,
919 .dev_open = dev_open,
920 .dev_close = dev_close,
921 .dev_acquisition_start = dev_acquisition_start,
922 .dev_acquisition_stop = dev_acquisition_stop,
923 .priv = NULL,
924};
Hardware access and backend lib