]> 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
serial-dmm: Use g_malloc()/g_free().
[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 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
186
187static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
188{
189 return std_init(sr_ctx, di, LOG_PREFIX);
190}
191
192static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
193{
194 double t, frequency;
195 float value;
196 unsigned int num_samples, i;
197 int last_end;
198
199 sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
200
201 num_samples = ANALOG_BUFSIZE / sizeof(float);
202
203 switch (ag->pattern) {
204 case PATTERN_SQUARE:
205 value = ag->amplitude;
206 last_end = 0;
207 for (i = 0; i < num_samples; i++) {
208 if (i % 5 == 0)
209 value = -value;
210 if (i % 10 == 0)
211 last_end = i;
212 ag->pattern_data[i] = value;
213 }
214 ag->num_samples = last_end;
215 break;
216
217 case PATTERN_SINE:
218 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
219
220 /* Make sure the number of samples we put out is an integer
221 * multiple of our period size */
222 /* FIXME we actually need only one period. A ringbuffer would be
223 * usefull here.*/
224 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
225 num_samples--;
226
227 for (i = 0; i < num_samples; i++) {
228 t = (double) i / (double) sample_rate;
229 ag->pattern_data[i] = ag->amplitude *
230 sin(2 * M_PI * frequency * t);
231 }
232
233 ag->num_samples = num_samples;
234 break;
235
236 case PATTERN_TRIANGLE:
237 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
238
239 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
240 num_samples--;
241
242 for (i = 0; i < num_samples; i++) {
243 t = (double) i / (double) sample_rate;
244 ag->pattern_data[i] = (2 * ag->amplitude / M_PI) *
245 asin(sin(2 * M_PI * frequency * t));
246 }
247
248 ag->num_samples = num_samples;
249 break;
250
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->priv;
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->priv))->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 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
492 break;
493 case SR_CONF_LIMIT_SAMPLES:
494 devc->limit_msec = 0;
495 devc->limit_samples = g_variant_get_uint64(data);
496 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
497 break;
498 case SR_CONF_LIMIT_MSEC:
499 devc->limit_msec = g_variant_get_uint64(data);
500 devc->limit_samples = 0;
501 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
502 break;
503 case SR_CONF_AVERAGING:
504 devc->avg = g_variant_get_boolean(data);
505 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
506 break;
507 case SR_CONF_AVG_SAMPLES:
508 devc->avg_samples = g_variant_get_uint64(data);
509 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
510 break;
511 case SR_CONF_PATTERN_MODE:
512 if (!cg)
513 return SR_ERR_CHANNEL_GROUP;
514 stropt = g_variant_get_string(data, NULL);
515 logic_pattern = analog_pattern = -1;
516 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
517 if (!strcmp(stropt, logic_pattern_str[i])) {
518 logic_pattern = i;
519 break;
520 }
521 }
522 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
523 if (!strcmp(stropt, analog_pattern_str[i])) {
524 analog_pattern = i;
525 break;
526 }
527 }
528 if (logic_pattern == -1 && analog_pattern == -1)
529 return SR_ERR_ARG;
530 for (l = cg->channels; l; l = l->next) {
531 ch = l->data;
532 if (ch->type == SR_CHANNEL_LOGIC) {
533 if (logic_pattern == -1)
534 return SR_ERR_ARG;
535 sr_dbg("Setting logic pattern to %s",
536 logic_pattern_str[logic_pattern]);
537 devc->logic_pattern = logic_pattern;
538 /* Might as well do this now, these are static. */
539 if (logic_pattern == PATTERN_ALL_LOW)
540 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
541 else if (logic_pattern == PATTERN_ALL_HIGH)
542 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
543 } else if (ch->type == SR_CHANNEL_ANALOG) {
544 if (analog_pattern == -1)
545 return SR_ERR_ARG;
546 sr_dbg("Setting analog pattern for channel %s to %s",
547 ch->name, analog_pattern_str[analog_pattern]);
548 ag = g_hash_table_lookup(devc->ch_ag, ch);
549 ag->pattern = analog_pattern;
550 } else
551 return SR_ERR_BUG;
552 }
553 break;
554 case SR_CONF_AMPLITUDE:
555 if (!cg)
556 return SR_ERR_CHANNEL_GROUP;
557 for (l = cg->channels; l; l = l->next) {
558 ch = l->data;
559 if (ch->type != SR_CHANNEL_ANALOG)
560 return SR_ERR_ARG;
561 ag = g_hash_table_lookup(devc->ch_ag, ch);
562 ag->amplitude = g_variant_get_double(data);
563 }
564 break;
565 default:
566 ret = SR_ERR_NA;
567 }
568
569 return ret;
570}
571
572static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
573 const struct sr_channel_group *cg)
574{
575 struct sr_channel *ch;
576 GVariant *gvar;
577 GVariantBuilder gvb;
578
579 (void)sdi;
580
581 if (key == SR_CONF_SCAN_OPTIONS) {
582 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
583 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
584 return SR_OK;
585 }
586
587 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
588 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
589 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
590 return SR_OK;
591 }
592
593 if (!sdi)
594 return SR_ERR_ARG;
595
596 if (!cg) {
597 switch (key) {
598 case SR_CONF_DEVICE_OPTIONS:
599 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
600 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
601 break;
602 case SR_CONF_SAMPLERATE:
603 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
604 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
605 ARRAY_SIZE(samplerates), sizeof(uint64_t));
606 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
607 *data = g_variant_builder_end(&gvb);
608 break;
609 default:
610 return SR_ERR_NA;
611 }
612 } else {
613 /* Any channel in the group will do. */
614 ch = cg->channels->data;
615 switch (key) {
616 case SR_CONF_DEVICE_OPTIONS:
617 if (ch->type == SR_CHANNEL_LOGIC)
618 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
619 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
620 sizeof(uint32_t));
621 else if (ch->type == SR_CHANNEL_ANALOG)
622 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
623 devopts_cg_analog, ARRAY_SIZE(devopts_cg_analog),
624 sizeof(uint32_t));
625 else
626 return SR_ERR_BUG;
627 break;
628 case SR_CONF_PATTERN_MODE:
629 if (ch->type == SR_CHANNEL_LOGIC)
630 *data = g_variant_new_strv(logic_pattern_str,
631 ARRAY_SIZE(logic_pattern_str));
632 else if (ch->type == SR_CHANNEL_ANALOG)
633 *data = g_variant_new_strv(analog_pattern_str,
634 ARRAY_SIZE(analog_pattern_str));
635 else
636 return SR_ERR_BUG;
637 break;
638 default:
639 return SR_ERR_NA;
640 }
641 }
642
643 return SR_OK;
644}
645
646static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
647{
648 struct dev_context *devc;
649 uint64_t i, j;
650 uint8_t pat;
651
652 devc = sdi->priv;
653
654 switch (devc->logic_pattern) {
655 case PATTERN_SIGROK:
656 memset(devc->logic_data, 0x00, size);
657 for (i = 0; i < size; i += devc->logic_unitsize) {
658 for (j = 0; j < devc->logic_unitsize; j++) {
659 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
660 devc->logic_data[i + j] = ~pat;
661 }
662 devc->step++;
663 }
664 break;
665 case PATTERN_RANDOM:
666 for (i = 0; i < size; i++)
667 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
668 break;
669 case PATTERN_INC:
670 for (i = 0; i < size; i++) {
671 for (j = 0; j < devc->logic_unitsize; j++) {
672 devc->logic_data[i + j] = devc->step;
673 }
674 devc->step++;
675 }
676 break;
677 case PATTERN_ALL_LOW:
678 case PATTERN_ALL_HIGH:
679 /* These were set when the pattern mode was selected. */
680 break;
681 default:
682 sr_err("Unknown pattern: %d.", devc->logic_pattern);
683 break;
684 }
685}
686
687static void send_analog_packet(struct analog_gen *ag,
688 struct sr_dev_inst *sdi,
689 uint64_t *analog_sent,
690 uint64_t analog_todo)
691{
692 struct sr_datafeed_packet packet;
693 struct dev_context *devc;
694 uint64_t sending_now, to_avg;
695 int ag_pattern_pos;
696 unsigned int i;
697
698 devc = sdi->priv;
699 packet.type = SR_DF_ANALOG;
700 packet.payload = &ag->packet;
701
702 if (!devc->avg) {
703 ag_pattern_pos = devc->analog_counter % ag->num_samples;
704 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
705 ag->packet.data = ag->pattern_data + ag_pattern_pos;
706 ag->packet.num_samples = sending_now;
707 sr_session_send(sdi, &packet);
708
709 /* Whichever channel group gets there first. */
710 *analog_sent = MAX(*analog_sent, sending_now);
711 } else {
712 ag_pattern_pos = devc->analog_counter % ag->num_samples;
713 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
714
715 for (i = 0; i < to_avg; i++) {
716 ag->avg_val = (ag->avg_val +
717 *(ag->pattern_data +
718 ag_pattern_pos + i)) / 2;
719 ag->num_avgs++;
720 /* Time to send averaged data? */
721 if (devc->avg_samples > 0 &&
722 ag->num_avgs >= devc->avg_samples)
723 goto do_send;
724 }
725
726 if (devc->avg_samples == 0) {
727 /* We're averaging all the samples, so wait with
728 * sending until the very end.
729 */
730 *analog_sent = ag->num_avgs;
731 return;
732 }
733
734do_send:
735 ag->packet.data = &ag->avg_val;
736 ag->packet.num_samples = 1;
737
738 sr_session_send(sdi, &packet);
739 *analog_sent = ag->num_avgs;
740
741 ag->num_avgs = 0;
742 ag->avg_val = 0.0f;
743 }
744}
745
746/* Callback handling data */
747static int prepare_data(int fd, int revents, void *cb_data)
748{
749 struct sr_dev_inst *sdi;
750 struct dev_context *devc;
751 struct sr_datafeed_packet packet;
752 struct sr_datafeed_logic logic;
753 struct analog_gen *ag;
754 GHashTableIter iter;
755 void *value;
756 uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
757 int64_t time, elapsed;
758
759 (void)fd;
760 (void)revents;
761
762 sdi = cb_data;
763 devc = sdi->priv;
764 logic_todo = analog_todo = 0;
765
766 /* How many samples should we have sent by now? */
767 time = g_get_monotonic_time();
768 elapsed = time - devc->starttime;
769 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
770
771 /* But never more than the limit, if there is one. */
772 if (!devc->continuous)
773 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
774
775 /* Of those, how many do we still have to send? */
776 if (devc->num_logic_channels)
777 logic_todo = expected_samplenum - devc->logic_counter;
778 if (devc->num_analog_channels)
779 analog_todo = expected_samplenum - devc->analog_counter;
780
781 while (logic_todo || analog_todo) {
782 /* Logic */
783 if (logic_todo > 0) {
784 sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
785 logic_generator(sdi, sending_now * devc->logic_unitsize);
786 packet.type = SR_DF_LOGIC;
787 packet.payload = &logic;
788 logic.length = sending_now * devc->logic_unitsize;
789 logic.unitsize = devc->logic_unitsize;
790 logic.data = devc->logic_data;
791 sr_session_send(sdi, &packet);
792 logic_todo -= sending_now;
793 devc->logic_counter += sending_now;
794 }
795
796 /* Analog, one channel at a time */
797 if (analog_todo > 0) {
798 analog_sent = 0;
799
800 g_hash_table_iter_init(&iter, devc->ch_ag);
801 while (g_hash_table_iter_next(&iter, NULL, &value)) {
802 send_analog_packet(value, sdi,
803 &analog_sent, analog_todo);
804 }
805 analog_todo -= analog_sent;
806 devc->analog_counter += analog_sent;
807 }
808 }
809
810 if (!devc->continuous
811 && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
812 && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
813 /* If we're averaging everything - now is the time to send data */
814 if (devc->avg_samples == 0) {
815 g_hash_table_iter_init(&iter, devc->ch_ag);
816 while (g_hash_table_iter_next(&iter, NULL, &value)) {
817 ag = value;
818 packet.type = SR_DF_ANALOG;
819 packet.payload = &ag->packet;
820 ag->packet.data = &ag->avg_val;
821 ag->packet.num_samples = 1;
822 sr_session_send(sdi, &packet);
823 }
824 }
825
826 sr_dbg("Requested number of samples reached.");
827 dev_acquisition_stop(sdi, cb_data);
828 return TRUE;
829 }
830
831 return TRUE;
832}
833
834static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
835{
836 struct dev_context *devc;
837 GHashTableIter iter;
838 void *value;
839
840 (void)cb_data;
841
842 if (sdi->status != SR_ST_ACTIVE)
843 return SR_ERR_DEV_CLOSED;
844
845 devc = sdi->priv;
846 devc->continuous = !devc->limit_samples;
847 devc->logic_counter = devc->analog_counter = 0;
848
849 /*
850 * Setting two channels connected by a pipe is a remnant from when the
851 * demo driver generated data in a thread, and collected and sent the
852 * data in the main program loop.
853 * They are kept here because it provides a convenient way of setting
854 * up a timeout-based polling mechanism.
855 */
856 if (pipe(devc->pipe_fds)) {
857 sr_err("%s: pipe() failed", __func__);
858 return SR_ERR;
859 }
860
861 g_hash_table_iter_init(&iter, devc->ch_ag);
862 while (g_hash_table_iter_next(&iter, NULL, &value))
863 generate_analog_pattern(value, devc->cur_samplerate);
864
865 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
866 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
867
868 /* Set channel encoding to binary (default is UTF-8). */
869 g_io_channel_set_encoding(devc->channel, NULL, NULL);
870
871 /* Make channels unbuffered. */
872 g_io_channel_set_buffered(devc->channel, FALSE);
873
874 sr_session_source_add_channel(sdi->session, devc->channel,
875 G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
876
877 /* Send header packet to the session bus. */
878 std_session_send_df_header(sdi, LOG_PREFIX);
879
880 /* We use this timestamp to decide how many more samples to send. */
881 devc->starttime = g_get_monotonic_time();
882
883 return SR_OK;
884}
885
886static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
887{
888 struct dev_context *devc;
889 struct sr_datafeed_packet packet;
890
891 (void)cb_data;
892
893 devc = sdi->priv;
894 sr_dbg("Stopping acquisition.");
895
896 sr_session_source_remove_channel(sdi->session, devc->channel);
897 g_io_channel_shutdown(devc->channel, FALSE, NULL);
898 g_io_channel_unref(devc->channel);
899 devc->channel = NULL;
900
901 /* Send last packet. */
902 packet.type = SR_DF_END;
903 sr_session_send(sdi, &packet);
904
905 return SR_OK;
906}
907
908SR_PRIV struct sr_dev_driver demo_driver_info = {
909 .name = "demo",
910 .longname = "Demo driver and pattern generator",
911 .api_version = 1,
912 .init = init,
913 .cleanup = cleanup,
914 .scan = scan,
915 .dev_list = dev_list,
916 .dev_clear = NULL,
917 .config_get = config_get,
918 .config_set = config_set,
919 .config_list = config_list,
920 .dev_open = dev_open,
921 .dev_close = dev_close,
922 .dev_acquisition_start = dev_acquisition_start,
923 .dev_acquisition_stop = dev_acquisition_stop,
924 .priv = NULL,
925};
Hardware access and backend lib