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