2 * This file is part of the libsigrok project.
4 * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
5 * Copyright (C) 2011 Olivier Fauchon <olivier@aixmarseille.com>
6 * Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
7 * Copyright (C) 2015 Bartosz Golaszewski <bgolaszewski@baylibre.com>
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.
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.
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
28 #include <libsigrok/libsigrok.h>
29 #include "libsigrok-internal.h"
31 #define LOG_PREFIX "demo"
33 #define DEFAULT_NUM_LOGIC_CHANNELS 8
34 #define DEFAULT_NUM_ANALOG_CHANNELS 4
36 /* The size in bytes of chunks to send through the session bus. */
37 #define LOGIC_BUFSIZE 4096
38 /* Size of the analog pattern space per channel. */
39 #define ANALOG_BUFSIZE 4096
41 #define DEFAULT_ANALOG_AMPLITUDE 10
42 #define ANALOG_SAMPLES_PER_PERIOD 20
44 /* Logic patterns we can generate. */
47 * Spells "sigrok" across 8 channels using '0's (with '1's as
48 * "background") when displayed using the 'bits' output format.
49 * The pattern is repeated every 8 channels, shifted to the right
54 /** Pseudo-random values on all channels. */
58 * Incrementing number across 8 channels. The pattern is repeated
59 * every 8 channels, shifted to the right in time by one bit.
63 /** All channels have a low logic state. */
66 /** All channels have a high logic state. */
70 /* Analog patterns we can generate. */
81 static const char *logic_pattern_str[] = {
89 static const char *analog_pattern_str[] = {
99 float pattern_data[ANALOG_BUFSIZE];
100 unsigned int num_samples;
101 struct sr_datafeed_analog packet;
102 struct sr_analog_encoding encoding;
103 struct sr_analog_meaning meaning;
104 struct sr_analog_spec spec;
105 float avg_val; /* Average value */
106 unsigned num_avgs; /* Number of samples averaged */
109 /* Private, per-device-instance driver context. */
111 uint64_t cur_samplerate;
112 uint64_t limit_samples;
114 uint64_t sent_samples;
119 int32_t num_logic_channels;
120 unsigned int logic_unitsize;
121 /* There is only ever one logic channel group, so its pattern goes here. */
122 uint8_t logic_pattern;
123 unsigned char logic_data[LOGIC_BUFSIZE];
125 int32_t num_analog_channels;
127 gboolean avg; /* True if averaging is enabled */
128 uint64_t avg_samples;
131 static const uint32_t drvopts[] = {
133 SR_CONF_LOGIC_ANALYZER,
134 SR_CONF_OSCILLOSCOPE,
137 static const uint32_t scanopts[] = {
138 SR_CONF_NUM_LOGIC_CHANNELS,
139 SR_CONF_NUM_ANALOG_CHANNELS,
142 static const uint32_t devopts[] = {
144 SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
145 SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
146 SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
147 SR_CONF_AVERAGING | SR_CONF_GET | SR_CONF_SET,
148 SR_CONF_AVG_SAMPLES | SR_CONF_GET | SR_CONF_SET,
151 static const uint32_t devopts_cg_logic[] = {
152 SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
155 static const uint32_t devopts_cg_analog_group[] = {
156 SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
159 static const uint32_t devopts_cg_analog_channel[] = {
160 SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
161 SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
164 static const uint64_t samplerates[] = {
170 static const uint8_t pattern_sigrok[] = {
171 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
172 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
173 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
174 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
175 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
176 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
177 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
178 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
181 static int dev_acquisition_stop(struct sr_dev_inst *sdi);
183 static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
187 unsigned int num_samples, i;
190 sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
192 num_samples = ANALOG_BUFSIZE / sizeof(float);
194 switch (ag->pattern) {
196 value = ag->amplitude;
198 for (i = 0; i < num_samples; i++) {
203 ag->pattern_data[i] = value;
205 ag->num_samples = last_end;
208 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
210 /* Make sure the number of samples we put out is an integer
211 * multiple of our period size */
212 /* FIXME we actually need only one period. A ringbuffer would be
214 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
217 for (i = 0; i < num_samples; i++) {
218 t = (double) i / (double) sample_rate;
219 ag->pattern_data[i] = ag->amplitude *
220 sin(2 * G_PI * frequency * t);
223 ag->num_samples = num_samples;
225 case PATTERN_TRIANGLE:
226 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
228 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
231 for (i = 0; i < num_samples; i++) {
232 t = (double) i / (double) sample_rate;
233 ag->pattern_data[i] = (2 * ag->amplitude / G_PI) *
234 asin(sin(2 * G_PI * frequency * t));
237 ag->num_samples = num_samples;
239 case PATTERN_SAWTOOTH:
240 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
242 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
245 for (i = 0; i < num_samples; i++) {
246 t = (double) i / (double) sample_rate;
247 ag->pattern_data[i] = 2 * ag->amplitude *
248 ((t * frequency) - floor(0.5f + t * frequency));
251 ag->num_samples = num_samples;
256 static GSList *scan(struct sr_dev_driver *di, GSList *options)
258 struct dev_context *devc;
259 struct sr_dev_inst *sdi;
260 struct sr_channel *ch;
261 struct sr_channel_group *cg, *acg;
262 struct sr_config *src;
263 struct analog_gen *ag;
265 int num_logic_channels, num_analog_channels, pattern, i;
266 char channel_name[16];
268 num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
269 num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
270 for (l = options; l; l = l->next) {
273 case SR_CONF_NUM_LOGIC_CHANNELS:
274 num_logic_channels = g_variant_get_int32(src->data);
276 case SR_CONF_NUM_ANALOG_CHANNELS:
277 num_analog_channels = g_variant_get_int32(src->data);
282 sdi = g_malloc0(sizeof(struct sr_dev_inst));
283 sdi->status = SR_ST_INACTIVE;
284 sdi->model = g_strdup("Demo device");
286 devc = g_malloc0(sizeof(struct dev_context));
287 devc->cur_samplerate = SR_KHZ(200);
288 devc->num_logic_channels = num_logic_channels;
289 devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
290 devc->logic_pattern = PATTERN_SIGROK;
291 devc->num_analog_channels = num_analog_channels;
293 if (num_logic_channels > 0) {
294 /* Logic channels, all in one channel group. */
295 cg = g_malloc0(sizeof(struct sr_channel_group));
296 cg->name = g_strdup("Logic");
297 for (i = 0; i < num_logic_channels; i++) {
298 sprintf(channel_name, "D%d", i);
299 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
300 cg->channels = g_slist_append(cg->channels, ch);
302 sdi->channel_groups = g_slist_append(NULL, cg);
305 /* Analog channels, channel groups and pattern generators. */
306 if (num_analog_channels > 0) {
308 /* An "Analog" channel group with all analog channels in it. */
309 acg = g_malloc0(sizeof(struct sr_channel_group));
310 acg->name = g_strdup("Analog");
311 sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
313 devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
314 for (i = 0; i < num_analog_channels; i++) {
315 snprintf(channel_name, 16, "A%d", i);
316 ch = sr_channel_new(sdi, i + num_logic_channels, SR_CHANNEL_ANALOG,
318 acg->channels = g_slist_append(acg->channels, ch);
320 /* Every analog channel gets its own channel group as well. */
321 cg = g_malloc0(sizeof(struct sr_channel_group));
322 cg->name = g_strdup(channel_name);
323 cg->channels = g_slist_append(NULL, ch);
324 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
326 /* Every channel gets a generator struct. */
327 ag = g_malloc(sizeof(struct analog_gen));
328 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
329 sr_analog_init(&ag->packet, &ag->encoding, &ag->meaning, &ag->spec, 0);
330 ag->packet.meaning->channels = cg->channels;
331 ag->packet.meaning->mq = 0;
332 ag->packet.meaning->mqflags = 0;
333 ag->packet.meaning->unit = SR_UNIT_VOLT;
334 ag->packet.data = ag->pattern_data;
335 ag->pattern = pattern;
338 g_hash_table_insert(devc->ch_ag, ch, ag);
340 if (++pattern == ARRAY_SIZE(analog_pattern_str))
347 return std_scan_complete(di, g_slist_append(NULL, sdi));
350 static int dev_open(struct sr_dev_inst *sdi)
352 sdi->status = SR_ST_ACTIVE;
357 static int dev_close(struct sr_dev_inst *sdi)
359 sdi->status = SR_ST_INACTIVE;
364 static void clear_helper(void *priv)
366 struct dev_context *devc;
372 /* Analog generators. */
373 g_hash_table_iter_init(&iter, devc->ch_ag);
374 while (g_hash_table_iter_next(&iter, NULL, &value))
376 g_hash_table_unref(devc->ch_ag);
380 static int dev_clear(const struct sr_dev_driver *di)
382 return std_dev_clear(di, clear_helper);
385 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
386 const struct sr_channel_group *cg)
388 struct dev_context *devc;
389 struct sr_channel *ch;
390 struct analog_gen *ag;
398 case SR_CONF_SAMPLERATE:
399 *data = g_variant_new_uint64(devc->cur_samplerate);
401 case SR_CONF_LIMIT_SAMPLES:
402 *data = g_variant_new_uint64(devc->limit_samples);
404 case SR_CONF_LIMIT_MSEC:
405 *data = g_variant_new_uint64(devc->limit_msec);
407 case SR_CONF_AVERAGING:
408 *data = g_variant_new_boolean(devc->avg);
410 case SR_CONF_AVG_SAMPLES:
411 *data = g_variant_new_uint64(devc->avg_samples);
413 case SR_CONF_PATTERN_MODE:
415 return SR_ERR_CHANNEL_GROUP;
416 /* Any channel in the group will do. */
417 ch = cg->channels->data;
418 if (ch->type == SR_CHANNEL_LOGIC) {
419 pattern = devc->logic_pattern;
420 *data = g_variant_new_string(logic_pattern_str[pattern]);
421 } else if (ch->type == SR_CHANNEL_ANALOG) {
422 ag = g_hash_table_lookup(devc->ch_ag, ch);
423 pattern = ag->pattern;
424 *data = g_variant_new_string(analog_pattern_str[pattern]);
428 case SR_CONF_AMPLITUDE:
430 return SR_ERR_CHANNEL_GROUP;
431 /* Any channel in the group will do. */
432 ch = cg->channels->data;
433 if (ch->type != SR_CHANNEL_ANALOG)
435 ag = g_hash_table_lookup(devc->ch_ag, ch);
436 *data = g_variant_new_double(ag->amplitude);
445 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
446 const struct sr_channel_group *cg)
448 struct dev_context *devc;
449 struct analog_gen *ag;
450 struct sr_channel *ch;
452 int logic_pattern, analog_pattern, ret;
458 if (sdi->status != SR_ST_ACTIVE)
459 return SR_ERR_DEV_CLOSED;
463 case SR_CONF_SAMPLERATE:
464 devc->cur_samplerate = g_variant_get_uint64(data);
466 case SR_CONF_LIMIT_SAMPLES:
467 devc->limit_msec = 0;
468 devc->limit_samples = g_variant_get_uint64(data);
470 case SR_CONF_LIMIT_MSEC:
471 devc->limit_msec = g_variant_get_uint64(data);
472 devc->limit_samples = 0;
474 case SR_CONF_AVERAGING:
475 devc->avg = g_variant_get_boolean(data);
476 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
478 case SR_CONF_AVG_SAMPLES:
479 devc->avg_samples = g_variant_get_uint64(data);
480 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
482 case SR_CONF_PATTERN_MODE:
484 return SR_ERR_CHANNEL_GROUP;
485 stropt = g_variant_get_string(data, NULL);
486 logic_pattern = analog_pattern = -1;
487 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
488 if (!strcmp(stropt, logic_pattern_str[i])) {
493 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
494 if (!strcmp(stropt, analog_pattern_str[i])) {
499 if (logic_pattern == -1 && analog_pattern == -1)
501 for (l = cg->channels; l; l = l->next) {
503 if (ch->type == SR_CHANNEL_LOGIC) {
504 if (logic_pattern == -1)
506 sr_dbg("Setting logic pattern to %s",
507 logic_pattern_str[logic_pattern]);
508 devc->logic_pattern = logic_pattern;
509 /* Might as well do this now, these are static. */
510 if (logic_pattern == PATTERN_ALL_LOW)
511 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
512 else if (logic_pattern == PATTERN_ALL_HIGH)
513 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
514 } else if (ch->type == SR_CHANNEL_ANALOG) {
515 if (analog_pattern == -1)
517 sr_dbg("Setting analog pattern for channel %s to %s",
518 ch->name, analog_pattern_str[analog_pattern]);
519 ag = g_hash_table_lookup(devc->ch_ag, ch);
520 ag->pattern = analog_pattern;
525 case SR_CONF_AMPLITUDE:
527 return SR_ERR_CHANNEL_GROUP;
528 for (l = cg->channels; l; l = l->next) {
530 if (ch->type != SR_CHANNEL_ANALOG)
532 ag = g_hash_table_lookup(devc->ch_ag, ch);
533 ag->amplitude = g_variant_get_double(data);
543 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
544 const struct sr_channel_group *cg)
546 struct sr_channel *ch;
550 if (key == SR_CONF_SCAN_OPTIONS) {
551 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
552 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
556 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
557 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
558 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
567 case SR_CONF_DEVICE_OPTIONS:
568 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
569 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
571 case SR_CONF_SAMPLERATE:
572 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
573 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
574 ARRAY_SIZE(samplerates), sizeof(uint64_t));
575 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
576 *data = g_variant_builder_end(&gvb);
582 ch = cg->channels->data;
584 case SR_CONF_DEVICE_OPTIONS:
585 if (ch->type == SR_CHANNEL_LOGIC)
586 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
587 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
589 else if (ch->type == SR_CHANNEL_ANALOG) {
590 if (strcmp(cg->name, "Analog") == 0)
591 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
592 devopts_cg_analog_group, ARRAY_SIZE(devopts_cg_analog_group),
595 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
596 devopts_cg_analog_channel, ARRAY_SIZE(devopts_cg_analog_channel),
602 case SR_CONF_PATTERN_MODE:
603 /* The analog group (with all 4 channels) shall not have a pattern property. */
604 if (strcmp(cg->name, "Analog") == 0)
607 if (ch->type == SR_CHANNEL_LOGIC)
608 *data = g_variant_new_strv(logic_pattern_str,
609 ARRAY_SIZE(logic_pattern_str));
610 else if (ch->type == SR_CHANNEL_ANALOG)
611 *data = g_variant_new_strv(analog_pattern_str,
612 ARRAY_SIZE(analog_pattern_str));
624 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
626 struct dev_context *devc;
632 switch (devc->logic_pattern) {
634 memset(devc->logic_data, 0x00, size);
635 for (i = 0; i < size; i += devc->logic_unitsize) {
636 for (j = 0; j < devc->logic_unitsize; j++) {
637 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
638 devc->logic_data[i + j] = ~pat;
644 for (i = 0; i < size; i++)
645 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
648 for (i = 0; i < size; i++) {
649 for (j = 0; j < devc->logic_unitsize; j++) {
650 devc->logic_data[i + j] = devc->step;
655 case PATTERN_ALL_LOW:
656 case PATTERN_ALL_HIGH:
657 /* These were set when the pattern mode was selected. */
660 sr_err("Unknown pattern: %d.", devc->logic_pattern);
665 static void send_analog_packet(struct analog_gen *ag,
666 struct sr_dev_inst *sdi,
667 uint64_t *analog_sent,
669 uint64_t analog_todo)
671 struct sr_datafeed_packet packet;
672 struct dev_context *devc;
673 uint64_t sending_now, to_avg;
678 packet.type = SR_DF_ANALOG;
679 packet.payload = &ag->packet;
682 ag_pattern_pos = analog_pos % ag->num_samples;
683 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
684 ag->packet.data = ag->pattern_data + ag_pattern_pos;
685 ag->packet.num_samples = sending_now;
686 sr_session_send(sdi, &packet);
688 /* Whichever channel group gets there first. */
689 *analog_sent = MAX(*analog_sent, sending_now);
691 ag_pattern_pos = analog_pos % ag->num_samples;
692 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
694 for (i = 0; i < to_avg; i++) {
695 ag->avg_val = (ag->avg_val +
697 ag_pattern_pos + i)) / 2;
699 /* Time to send averaged data? */
700 if (devc->avg_samples > 0 &&
701 ag->num_avgs >= devc->avg_samples)
705 if (devc->avg_samples == 0) {
706 /* We're averaging all the samples, so wait with
707 * sending until the very end.
709 *analog_sent = ag->num_avgs;
714 ag->packet.data = &ag->avg_val;
715 ag->packet.num_samples = 1;
717 sr_session_send(sdi, &packet);
718 *analog_sent = ag->num_avgs;
725 /* Callback handling data */
726 static int prepare_data(int fd, int revents, void *cb_data)
728 struct sr_dev_inst *sdi;
729 struct dev_context *devc;
730 struct sr_datafeed_packet packet;
731 struct sr_datafeed_logic logic;
732 struct analog_gen *ag;
735 uint64_t samples_todo, logic_done, analog_done, analog_sent, sending_now;
736 int64_t elapsed_us, limit_us, todo_us;
745 if (devc->cur_samplerate <= 0
746 || (devc->num_logic_channels <= 0
747 && devc->num_analog_channels <= 0)) {
748 dev_acquisition_stop(sdi);
749 return G_SOURCE_CONTINUE;
752 /* What time span should we send samples for? */
753 elapsed_us = g_get_monotonic_time() - devc->start_us;
754 limit_us = 1000 * devc->limit_msec;
755 if (limit_us > 0 && limit_us < elapsed_us)
756 todo_us = MAX(0, limit_us - devc->spent_us);
758 todo_us = MAX(0, elapsed_us - devc->spent_us);
760 /* How many samples are outstanding since the last round? */
761 samples_todo = (todo_us * devc->cur_samplerate + G_USEC_PER_SEC - 1)
763 if (devc->limit_samples > 0) {
764 if (devc->limit_samples < devc->sent_samples)
766 else if (devc->limit_samples - devc->sent_samples < samples_todo)
767 samples_todo = devc->limit_samples - devc->sent_samples;
769 /* Calculate the actual time covered by this run back from the sample
770 * count, rounded towards zero. This avoids getting stuck on a too-low
771 * time delta with no samples being sent due to round-off.
773 todo_us = samples_todo * G_USEC_PER_SEC / devc->cur_samplerate;
775 logic_done = devc->num_logic_channels > 0 ? 0 : samples_todo;
776 analog_done = devc->num_analog_channels > 0 ? 0 : samples_todo;
778 while (logic_done < samples_todo || analog_done < samples_todo) {
780 if (logic_done < samples_todo) {
781 sending_now = MIN(samples_todo - logic_done,
782 LOGIC_BUFSIZE / devc->logic_unitsize);
783 logic_generator(sdi, sending_now * devc->logic_unitsize);
784 packet.type = SR_DF_LOGIC;
785 packet.payload = &logic;
786 logic.length = sending_now * devc->logic_unitsize;
787 logic.unitsize = devc->logic_unitsize;
788 logic.data = devc->logic_data;
789 sr_session_send(sdi, &packet);
790 logic_done += sending_now;
793 /* Analog, one channel at a time */
794 if (analog_done < samples_todo) {
797 g_hash_table_iter_init(&iter, devc->ch_ag);
798 while (g_hash_table_iter_next(&iter, NULL, &value)) {
799 send_analog_packet(value, sdi, &analog_sent,
800 devc->sent_samples + analog_done,
801 samples_todo - analog_done);
803 analog_done += analog_sent;
806 /* At this point, both logic_done and analog_done should be
807 * exactly equal to samples_todo, or else.
809 if (logic_done != samples_todo || analog_done != samples_todo) {
810 sr_err("BUG: Sample count mismatch.");
811 return G_SOURCE_REMOVE;
813 devc->sent_samples += samples_todo;
814 devc->spent_us += todo_us;
816 if ((devc->limit_samples > 0 && devc->sent_samples >= devc->limit_samples)
817 || (limit_us > 0 && devc->spent_us >= limit_us)) {
819 /* If we're averaging everything - now is the time to send data */
820 if (devc->avg_samples == 0) {
821 g_hash_table_iter_init(&iter, devc->ch_ag);
822 while (g_hash_table_iter_next(&iter, NULL, &value)) {
824 packet.type = SR_DF_ANALOG;
825 packet.payload = &ag->packet;
826 ag->packet.data = &ag->avg_val;
827 ag->packet.num_samples = 1;
828 sr_session_send(sdi, &packet);
831 sr_dbg("Requested number of samples reached.");
832 dev_acquisition_stop(sdi);
835 return G_SOURCE_CONTINUE;
838 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
840 struct dev_context *devc;
844 if (sdi->status != SR_ST_ACTIVE)
845 return SR_ERR_DEV_CLOSED;
848 devc->sent_samples = 0;
850 g_hash_table_iter_init(&iter, devc->ch_ag);
851 while (g_hash_table_iter_next(&iter, NULL, &value))
852 generate_analog_pattern(value, devc->cur_samplerate);
854 sr_session_source_add(sdi->session, -1, 0, 100,
855 prepare_data, (struct sr_dev_inst *)sdi);
857 std_session_send_df_header(sdi);
859 /* We use this timestamp to decide how many more samples to send. */
860 devc->start_us = g_get_monotonic_time();
866 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
868 sr_dbg("Stopping acquisition.");
869 sr_session_source_remove(sdi->session, -1);
870 std_session_send_df_end(sdi);
875 static struct sr_dev_driver demo_driver_info = {
877 .longname = "Demo driver and pattern generator",
880 .cleanup = std_cleanup,
882 .dev_list = std_dev_list,
883 .dev_clear = dev_clear,
884 .config_get = config_get,
885 .config_set = config_set,
886 .config_list = config_list,
887 .dev_open = dev_open,
888 .dev_close = dev_close,
889 .dev_acquisition_start = dev_acquisition_start,
890 .dev_acquisition_stop = dev_acquisition_stop,
893 SR_REGISTER_DEV_DRIVER(demo_driver_info);