]> sigrok.org Git - libsigrok.git/blobdiff - hardware/demo/demo.c
Replace 'probe' with 'channel' in most places.
[libsigrok.git] / hardware / demo / demo.c
index 4e760e35b1bf0070d71b2822280f0d3f072b3e8d..3c6585dd0086d81fad2a7e5957a5c2357a8ff171 100644 (file)
@@ -23,6 +23,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
+#include <math.h>
 #ifdef _WIN32
 #include <io.h>
 #include <fcntl.h>
 /* Size of the analog pattern space per channel. */
 #define ANALOG_BUFSIZE       4096
 
-/* Patterns we can generate */
+#define ANALOG_AMPLITUDE 25
+#define ANALOG_SAMPLES_PER_PERIOD 20
+
+/* Logic patterns we can generate. */
 enum {
-       /* Logic */
        /**
-        * Spells "sigrok" across 8 probes using '0's (with '1's as
+        * Spells "sigrok" across 8 channels using '0's (with '1's as
         * "background") when displayed using the 'bits' output format.
-        * The pattern is repeasted every 8 probes, shifted to the right
+        * The pattern is repeasted every 8 channels, shifted to the right
         * in time by one bit.
         */
        PATTERN_SIGROK,
 
-       /** Pseudo-random values on all probes. */
+       /** Pseudo-random values on all channels. */
        PATTERN_RANDOM,
 
        /**
-        * Incrementing number across 8 probes. The pattern is repeasted
-        * every 8 probes, shifted to the right in time by one bit.
+        * Incrementing number across 8 channels. The pattern is repeasted
+        * every 8 channels, shifted to the right in time by one bit.
         */
        PATTERN_INC,
 
-       /** All probes have a low logic state. */
+       /** All channels have a low logic state. */
        PATTERN_ALL_LOW,
 
-       /** All probes have a high logic state. */
+       /** All channels have a high logic state. */
        PATTERN_ALL_HIGH,
+};
 
-       /* Analog */
+/* Analog patterns we can generate. */
+enum {
        /**
         * Square wave.
         */
        PATTERN_SQUARE,
+       PATTERN_SINE,
+       PATTERN_TRIANGLE,
+       PATTERN_SAWTOOTH,
 };
 
 static const char *logic_pattern_str[] = {
@@ -84,6 +92,9 @@ static const char *logic_pattern_str[] = {
 
 static const char *analog_pattern_str[] = {
        "square",
+       "sine",
+       "triangle",
+       "sawtooth",
 };
 
 struct analog_gen {
@@ -100,33 +111,38 @@ struct dev_context {
        uint64_t cur_samplerate;
        uint64_t limit_samples;
        uint64_t limit_msec;
-       uint64_t samples_counter;
+       uint64_t logic_counter;
+       uint64_t analog_counter;
        int64_t starttime;
        uint64_t step;
        /* Logic */
-       int32_t num_logic_probes;
+       int32_t num_logic_channels;
        unsigned int logic_unitsize;
+       /* There is only ever one logic channel group, so its pattern goes here. */
        uint8_t logic_pattern;
        unsigned char logic_data[LOGIC_BUFSIZE];
        /* Analog */
-       int32_t num_analog_probes;
-       GSList *analog_probe_groups;
+       int32_t num_analog_channels;
+       GSList *analog_channel_groups;
 };
 
-static const int32_t hwopts[] = {
+static const int32_t scanopts[] = {
        SR_CONF_NUM_LOGIC_PROBES,
        SR_CONF_NUM_ANALOG_PROBES,
 };
 
-static const int hwcaps[] = {
+static const int devopts[] = {
        SR_CONF_LOGIC_ANALYZER,
        SR_CONF_DEMO_DEV,
        SR_CONF_SAMPLERATE,
-       SR_CONF_PATTERN_MODE,
        SR_CONF_LIMIT_SAMPLES,
        SR_CONF_LIMIT_MSEC,
 };
 
+static const int devopts_cg[] = {
+       SR_CONF_PATTERN_MODE,
+};
+
 static const uint64_t samplerates[] = {
        SR_HZ(1),
        SR_GHZ(1),
@@ -150,30 +166,28 @@ static struct sr_dev_driver *di = &demo_driver_info;
 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
 
 
-static int dev_clear(void)
-{
-       return std_dev_clear(di, NULL);
-}
-
 static int init(struct sr_context *sr_ctx)
 {
        return std_init(sr_ctx, di, LOG_PREFIX);
 }
 
-static void set_analog_pattern(const struct sr_probe_group *probe_group, int pattern)
+static void generate_analog_pattern(const struct sr_channel_group *cg, uint64_t sample_rate)
 {
        struct analog_gen *ag;
+       double t, frequency;
        float value;
        unsigned int num_samples, i;
        int last_end;
 
-       ag = probe_group->priv;
-       ag->pattern = pattern;
+       ag = cg->priv;
+       num_samples = ANALOG_BUFSIZE / sizeof(float);
+
+       sr_dbg("Generating %s pattern for channel group %s",
+              analog_pattern_str[ag->pattern], cg->name);
 
-       switch (pattern) {
+       switch (ag->pattern) {
        case PATTERN_SQUARE:
-               num_samples = ANALOG_BUFSIZE / sizeof(float);
-               value = 5.0;
+               value = ANALOG_AMPLITUDE;
                last_end = 0;
                for (i = 0; i < num_samples; i++) {
                        if (i % 5 == 0)
@@ -184,6 +198,55 @@ static void set_analog_pattern(const struct sr_probe_group *probe_group, int pat
                }
                ag->num_samples = last_end;
                break;
+
+       case PATTERN_SINE:
+               frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
+
+               /* Make sure the number of samples we put out is an integer
+                * multiple of our period size */
+               /* FIXME we actually need only one period. A ringbuffer would be
+                * usefull here.*/
+               while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
+                       num_samples--;
+
+               for (i = 0; i < num_samples; i++) {
+                       t = (double) i / (double) sample_rate;
+                       ag->pattern_data[i] = ANALOG_AMPLITUDE *
+                                               sin(2 * M_PI * frequency * t);
+               }
+
+               ag->num_samples = num_samples;
+               break;
+
+       case PATTERN_TRIANGLE:
+               frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
+
+               while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
+                       num_samples--;
+
+               for (i = 0; i < num_samples; i++) {
+                       t = (double) i / (double) sample_rate;
+                       ag->pattern_data[i] = (2 * ANALOG_AMPLITUDE / M_PI) *
+                                               asin(sin(2 * M_PI * frequency * t));
+               }
+
+               ag->num_samples = num_samples;
+               break;
+
+       case PATTERN_SAWTOOTH:
+               frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
+
+               while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
+                       num_samples--;
+
+               for (i = 0; i < num_samples; i++) {
+                       t = (double) i / (double) sample_rate;
+                       ag->pattern_data[i] = 2 * ANALOG_AMPLITUDE *
+                                               ((t * frequency) - floor(0.5f + t * frequency));
+               }
+
+               ag->num_samples = num_samples;
+               break;
        }
 }
 
@@ -192,26 +255,26 @@ static GSList *scan(GSList *options)
        struct drv_context *drvc;
        struct dev_context *devc;
        struct sr_dev_inst *sdi;
-       struct sr_probe *probe;
-       struct sr_probe_group *pg;
+       struct sr_channel *ch;
+       struct sr_channel_group *cg;
        struct sr_config *src;
        struct analog_gen *ag;
        GSList *devices, *l;
-       int num_logic_probes, num_analog_probes, i;
-       char probe_name[16];
+       int num_logic_channels, num_analog_channels, pattern, i;
+       char channel_name[16];
 
        drvc = di->priv;
 
-       num_logic_probes = DEFAULT_NUM_LOGIC_PROBES;
-       num_analog_probes = DEFAULT_NUM_ANALOG_PROBES;
+       num_logic_channels = DEFAULT_NUM_LOGIC_PROBES;
+       num_analog_channels = DEFAULT_NUM_ANALOG_PROBES;
        for (l = options; l; l = l->next) {
                src = l->data;
                switch (src->key) {
                case SR_CONF_NUM_LOGIC_PROBES:
-                       num_logic_probes = g_variant_get_int32(src->data);
+                       num_logic_channels = g_variant_get_int32(src->data);
                        break;
                case SR_CONF_NUM_ANALOG_PROBES:
-                       num_analog_probes = g_variant_get_int32(src->data);
+                       num_analog_channels = g_variant_get_int32(src->data);
                        break;
                }
        }
@@ -232,53 +295,59 @@ static GSList *scan(GSList *options)
        devc->limit_samples = 0;
        devc->limit_msec = 0;
        devc->step = 0;
-       devc->num_logic_probes = num_logic_probes;
-       devc->logic_unitsize = (devc->num_logic_probes + 7) / 8;
+       devc->num_logic_channels = num_logic_channels;
+       devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
        devc->logic_pattern = PATTERN_SIGROK;
-       devc->num_analog_probes = num_analog_probes;
-       devc->analog_probe_groups = NULL;
+       devc->num_analog_channels = num_analog_channels;
+       devc->analog_channel_groups = NULL;
 
-       /* Logic probes, all in one probe group. */
-       if (!(pg = g_try_malloc(sizeof(struct sr_probe_group))))
+       /* Logic channels, all in one channel group. */
+       if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
                return NULL;
-       pg->name = g_strdup("Logic");
-       pg->probes = NULL;
-       pg->priv = NULL;
-       for (i = 0; i < num_logic_probes; i++) {
-               sprintf(probe_name, "D%d", i);
-               if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name)))
+       cg->name = g_strdup("Logic");
+       cg->channels = NULL;
+       cg->priv = NULL;
+       for (i = 0; i < num_logic_channels; i++) {
+               sprintf(channel_name, "D%d", i);
+               if (!(ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name)))
                        return NULL;
-               sdi->probes = g_slist_append(sdi->probes, probe);
-               pg->probes = g_slist_append(pg->probes, probe);
+               sdi->channels = g_slist_append(sdi->channels, ch);
+               cg->channels = g_slist_append(cg->channels, ch);
        }
-       sdi->probe_groups = g_slist_append(NULL, pg);
+       sdi->channel_groups = g_slist_append(NULL, cg);
+
+       /* Analog channels, channel groups and pattern generators. */
 
-       /* Analog probes, probe groups and pattern generators. */
-       for (i = 0; i < num_analog_probes; i++) {
-               sprintf(probe_name, "A%d", i);
-               if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, probe_name)))
+       pattern = 0;
+       for (i = 0; i < num_analog_channels; i++) {
+               sprintf(channel_name, "A%d", i);
+               if (!(ch = sr_probe_new(i + num_logic_channels,
+                               SR_PROBE_ANALOG, TRUE, channel_name)))
                        return NULL;
-               sdi->probes = g_slist_append(sdi->probes, probe);
+               sdi->channels = g_slist_append(sdi->channels, ch);
 
-               /* Every analog probe gets its own probe group. */
-               if (!(pg = g_try_malloc(sizeof(struct sr_probe_group))))
+               /* Every analog channel gets its own channel group. */
+               if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
                        return NULL;
-               pg->name = g_strdup(probe_name);
-               pg->probes = g_slist_append(NULL, probe);
+               cg->name = g_strdup(channel_name);
+               cg->channels = g_slist_append(NULL, ch);
 
-               /* Every probe group gets a generator struct. */
+               /* Every channel group gets a generator struct. */
                if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
                        return NULL;
-               ag->packet.probes = pg->probes;
+               ag->packet.channels = cg->channels;
                ag->packet.mq = 0;
                ag->packet.mqflags = 0;
                ag->packet.unit = SR_UNIT_VOLT;
                ag->packet.data = ag->pattern_data;
-               pg->priv = ag;
-               set_analog_pattern(pg, PATTERN_SQUARE);
+               ag->pattern = pattern;
+               cg->priv = ag;
 
-               sdi->probe_groups = g_slist_append(sdi->probe_groups, pg);
-               devc->analog_probe_groups = g_slist_append(devc->analog_probe_groups, pg);
+               sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
+               devc->analog_channel_groups = g_slist_append(devc->analog_channel_groups, cg);
+
+               if (++pattern == ARRAY_SIZE(analog_pattern_str))
+                       pattern = 0;
        }
 
        sdi->priv = devc;
@@ -309,15 +378,19 @@ static int dev_close(struct sr_dev_inst *sdi)
 
 static int cleanup(void)
 {
-       return dev_clear();
+       return std_dev_clear(di, NULL);
 }
 
 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
-               const struct sr_probe_group *probe_group)
+               const struct sr_channel_group *cg)
 {
        struct dev_context *devc;
+       struct sr_channel *ch;
+       struct analog_gen *ag;
+       int pattern;
 
-       (void)probe_group;
+       if (!sdi)
+               return SR_ERR_ARG;
 
        devc = sdi->priv;
        switch (id) {
@@ -331,13 +404,24 @@ static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
                *data = g_variant_new_uint64(devc->limit_msec);
                break;
        case SR_CONF_PATTERN_MODE:
-               *data = g_variant_new_string(logic_pattern_str[devc->logic_pattern]);
+               if (!cg)
+                       return SR_ERR_CHANNEL_GROUP;
+               ch = cg->channels->data;
+               if (ch->type == SR_PROBE_LOGIC) {
+                       pattern = devc->logic_pattern;
+                       *data = g_variant_new_string(logic_pattern_str[pattern]);
+               } else if (ch->type == SR_PROBE_ANALOG) {
+                       ag = cg->priv;
+                       pattern = ag->pattern;
+                       *data = g_variant_new_string(analog_pattern_str[pattern]);
+               } else
+                       return SR_ERR_BUG;
                break;
        case SR_CONF_NUM_LOGIC_PROBES:
-               *data = g_variant_new_int32(devc->num_logic_probes);
+               *data = g_variant_new_int32(devc->num_logic_channels);
                break;
        case SR_CONF_NUM_ANALOG_PROBES:
-               *data = g_variant_new_int32(devc->num_analog_probes);
+               *data = g_variant_new_int32(devc->num_analog_channels);
                break;
        default:
                return SR_ERR_NA;
@@ -347,12 +431,12 @@ static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
 }
 
 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
-               const struct sr_probe_group *probe_group)
+               const struct sr_channel_group *cg)
 {
        struct dev_context *devc;
-       struct sr_probe_group *pg;
-       GSList *l;
-       int logic_pattern, analog_pattern, ret;
+       struct analog_gen *ag;
+       struct sr_channel *ch;
+       int pattern, ret;
        unsigned int i;
        const char *stropt;
 
@@ -361,66 +445,63 @@ static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
        if (sdi->status != SR_ST_ACTIVE)
                return SR_ERR_DEV_CLOSED;
 
-       ret = SR_ERR;
-       if (id == SR_CONF_SAMPLERATE) {
+       ret = SR_OK;
+       switch (id) {
+       case SR_CONF_SAMPLERATE:
                devc->cur_samplerate = g_variant_get_uint64(data);
                sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
-               ret = SR_OK;
-       } else if (id == SR_CONF_LIMIT_SAMPLES) {
+               break;
+       case SR_CONF_LIMIT_SAMPLES:
                devc->limit_msec = 0;
                devc->limit_samples = g_variant_get_uint64(data);
                sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
-               ret = SR_OK;
-       } else if (id == SR_CONF_LIMIT_MSEC) {
-               /* TODO: convert to limit_samples */
+               break;
+       case SR_CONF_LIMIT_MSEC:
                devc->limit_msec = g_variant_get_uint64(data);
                devc->limit_samples = 0;
                sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
-               ret = SR_OK;
-       } else if (id == SR_CONF_PATTERN_MODE) {
+               break;
+       case SR_CONF_PATTERN_MODE:
+               if (!cg)
+                       return SR_ERR_CHANNEL_GROUP;
                stropt = g_variant_get_string(data, NULL);
-               logic_pattern = analog_pattern = -1;
-               /* Is it a logic pattern? */
-               for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
-                       if (!strcmp(stropt, logic_pattern_str[i])) {
-                               logic_pattern = i;
-                               break;
-                       }
-               }
-               if (logic_pattern == -1) {
-                       /* Is it an analog pattern? */
-                       for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
-                               if (!strcmp(stropt, analog_pattern_str[i])) {
-                                       analog_pattern = i;
+               ch = cg->channels->data;
+               pattern = -1;
+               if (ch->type == SR_PROBE_LOGIC) {
+                       for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
+                               if (!strcmp(stropt, logic_pattern_str[i])) {
+                                       pattern = i;
                                        break;
                                }
                        }
-               }
-               if (logic_pattern > -1) {
-                       devc->logic_pattern = logic_pattern;
-                       /* Might as well do this now. */
-                       if (logic_pattern == PATTERN_ALL_LOW)
+                       if (pattern == -1)
+                               return SR_ERR_ARG;
+                       devc->logic_pattern = pattern;
+
+                       /* Might as well do this now, these are static. */
+                       if (pattern == PATTERN_ALL_LOW)
                                memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
-                       else if (logic_pattern == PATTERN_ALL_HIGH)
+                       else if (pattern == PATTERN_ALL_HIGH)
                                memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
-                       ret = SR_OK;
-                       sr_dbg("Setting logic pattern to %s", logic_pattern_str[logic_pattern]);
-               } else if (analog_pattern > -1) {
-                       sr_dbg("Setting analog pattern to %s", analog_pattern_str[analog_pattern]);
-                       if (probe_group)
-                               set_analog_pattern(probe_group, analog_pattern);
-                       else {
-                               /* No probe group specified, apply pattern to all of them. */
-                               for (l = sdi->probe_groups; l; l = l->next) {
-                                       pg = l->data;
-                                       set_analog_pattern(pg, analog_pattern);
+                       sr_dbg("Setting logic pattern to %s",
+                                       logic_pattern_str[pattern]);
+               } else if (ch->type == SR_PROBE_ANALOG) {
+                       for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
+                               if (!strcmp(stropt, analog_pattern_str[i])) {
+                                       pattern = i;
+                                       break;
                                }
-                               ret = SR_OK;
                        }
-               } else {
-                       ret = SR_ERR;
-               }
-       } else {
+                       if (pattern == -1)
+                               return SR_ERR_ARG;
+                       sr_dbg("Setting analog pattern for channel group %s to %s",
+                                       cg->name, analog_pattern_str[pattern]);
+                       ag = cg->priv;
+                       ag->pattern = pattern;
+               } else
+                       return SR_ERR_BUG;
+               break;
+       default:
                ret = SR_ERR_NA;
        }
 
@@ -428,35 +509,59 @@ static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 }
 
 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
-               const struct sr_probe_group *probe_group)
+               const struct sr_channel_group *cg)
 {
+       struct sr_channel *ch;
        GVariant *gvar;
        GVariantBuilder gvb;
 
        (void)sdi;
-       (void)probe_group;
 
-       switch (key) {
-       case SR_CONF_SCAN_OPTIONS:
-               *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
-                               hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
-               break;
-       case SR_CONF_DEVICE_OPTIONS:
+       if (key == SR_CONF_SCAN_OPTIONS) {
                *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
-                               hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
-               break;
-       case SR_CONF_SAMPLERATE:
-               g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
-               gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
-                               ARRAY_SIZE(samplerates), sizeof(uint64_t));
-               g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
-               *data = g_variant_builder_end(&gvb);
-               break;
-       case SR_CONF_PATTERN_MODE:
-               *data = g_variant_new_strv(logic_pattern_str, ARRAY_SIZE(logic_pattern_str));
-               break;
-       default:
-               return SR_ERR_NA;
+                               scanopts, ARRAY_SIZE(scanopts), sizeof(int32_t));
+               return SR_OK;
+       }
+
+       if (!sdi)
+               return SR_ERR_ARG;
+
+       if (!cg) {
+               switch (key) {
+               case SR_CONF_DEVICE_OPTIONS:
+                       *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
+                                       devopts, ARRAY_SIZE(devopts), sizeof(int32_t));
+                       break;
+               case SR_CONF_SAMPLERATE:
+                       g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
+                       gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
+                                       ARRAY_SIZE(samplerates), sizeof(uint64_t));
+                       g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
+                       *data = g_variant_builder_end(&gvb);
+                       break;
+               default:
+                       return SR_ERR_NA;
+               }
+       } else {
+               ch = cg->channels->data;
+               switch (key) {
+               case SR_CONF_DEVICE_OPTIONS:
+                       *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
+                                       devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(int32_t));
+                       break;
+               case SR_CONF_PATTERN_MODE:
+                       if (ch->type == SR_PROBE_LOGIC)
+                               *data = g_variant_new_strv(logic_pattern_str,
+                                               ARRAY_SIZE(logic_pattern_str));
+                       else if (ch->type == SR_PROBE_ANALOG)
+                               *data = g_variant_new_strv(analog_pattern_str,
+                                               ARRAY_SIZE(analog_pattern_str));
+                       else
+                               return SR_ERR_BUG;
+                       break;
+               default:
+                       return SR_ERR_NA;
+               }
        }
 
        return SR_OK;
@@ -510,10 +615,10 @@ static int prepare_data(int fd, int revents, void *cb_data)
        struct dev_context *devc;
        struct sr_datafeed_packet packet;
        struct sr_datafeed_logic logic;
-       struct sr_probe_group *pg;
+       struct sr_channel_group *cg;
        struct analog_gen *ag;
        GSList *l;
-       uint64_t samples_to_send, expected_samplenum, analog_samples, sending_now;
+       uint64_t logic_todo, analog_todo, expected_samplenum, analog_samples, sending_now;
        int64_t time, elapsed;
 
        (void)fd;
@@ -526,20 +631,15 @@ static int prepare_data(int fd, int revents, void *cb_data)
        time = g_get_monotonic_time();
        elapsed = time - devc->starttime;
        expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
-       /* Of those, how many do we still have to send? */
-       samples_to_send = expected_samplenum - devc->samples_counter;
-
-       if (devc->limit_samples) {
-               samples_to_send = MIN(samples_to_send,
-                               devc->limit_samples - devc->samples_counter);
-       }
 
-       while (samples_to_send > 0) {
-               sending_now = 0;
+       /* Of those, how many do we still have to send? */
+       logic_todo = MIN(expected_samplenum, devc->limit_samples) - devc->logic_counter;
+       analog_todo = MIN(expected_samplenum, devc->limit_samples) - devc->analog_counter;
 
+       while (logic_todo || analog_todo) {
                /* Logic */
-               if (devc->num_logic_probes > 0) {
-                       sending_now = MIN(samples_to_send,
+               if (devc->num_logic_channels > 0 && logic_todo > 0) {
+                       sending_now = MIN(logic_todo,
                                        LOGIC_BUFSIZE / devc->logic_unitsize);
                        logic_generator(sdi, sending_now * devc->logic_unitsize);
                        packet.type = SR_DF_LOGIC;
@@ -548,31 +648,38 @@ static int prepare_data(int fd, int revents, void *cb_data)
                        logic.unitsize = devc->logic_unitsize;
                        logic.data = devc->logic_data;
                        sr_session_send(sdi, &packet);
+                       logic_todo -= sending_now;
+                       devc->logic_counter += sending_now;
                }
 
-               /* Analog, one probe at a time */
-               if (devc->num_analog_probes > 0) {
+               /* Analog, one channel at a time */
+               if (devc->num_analog_channels > 0 && analog_todo > 0) {
                        sending_now = 0;
-                       for (l = devc->analog_probe_groups; l; l = l->next) {
-                               pg = l->data;
-                               ag = pg->priv;
+                       for (l = devc->analog_channel_groups; l; l = l->next) {
+                               cg = l->data;
+                               ag = cg->priv;
                                packet.type = SR_DF_ANALOG;
                                packet.payload = &ag->packet;
-                               analog_samples = MIN(samples_to_send, ag->num_samples);
-                               /* Whichever probe group gets there first. */
+
+                               /* FIXME we should make sure we output a whole
+                                * period of data before we send out again the
+                                * beginning of our buffer. A ring buffer would
+                                * help here as well */
+
+                               analog_samples = MIN(analog_todo, ag->num_samples);
+                               /* Whichever channel group gets there first. */
                                sending_now = MAX(sending_now, analog_samples);
                                ag->packet.num_samples = analog_samples;
                                sr_session_send(sdi, &packet);
                        }
+                       analog_todo -= sending_now;
+                       devc->analog_counter += sending_now;
                }
-
-               samples_to_send -= sending_now;
-               devc->samples_counter += sending_now;
        }
 
-       if (devc->limit_samples &&
-               devc->samples_counter >= devc->limit_samples) {
-               sr_info("Requested number of samples reached.");
+       if (devc->logic_counter >= devc->limit_samples &&
+                       devc->analog_counter >= devc->limit_samples) {
+               sr_dbg("Requested number of samples reached.");
                dev_acquisition_stop(sdi, cb_data);
                return TRUE;
        }
@@ -582,14 +689,16 @@ static int prepare_data(int fd, int revents, void *cb_data)
 
 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 {
+       GSList *l;
        struct dev_context *devc;
 
        if (sdi->status != SR_ST_ACTIVE)
                return SR_ERR_DEV_CLOSED;
 
-       /* TODO: don't start without a sample limit set */
        devc = sdi->priv;
-       devc->samples_counter = 0;
+       if (devc->limit_samples == 0)
+               return SR_ERR;
+       devc->logic_counter = devc->analog_counter = 0;
 
        /*
         * Setting two channels connected by a pipe is a remnant from when the
@@ -603,6 +712,10 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
                return SR_ERR;
        }
 
+       for (l = devc->analog_channel_groups; l; l = l->next) {
+               generate_analog_pattern(l->data, devc->cur_samplerate);
+       }
+
        devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 
        g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
@@ -633,7 +746,7 @@ static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
        (void)cb_data;
 
        devc = sdi->priv;
-       sr_dbg("Stopping aquisition.");
+       sr_dbg("Stopping acquisition.");
 
        sr_session_source_remove_channel(devc->channel);
        g_io_channel_shutdown(devc->channel, FALSE, NULL);
@@ -655,7 +768,7 @@ SR_PRIV struct sr_dev_driver demo_driver_info = {
        .cleanup = cleanup,
        .scan = scan,
        .dev_list = dev_list,
-       .dev_clear = dev_clear,
+       .dev_clear = NULL,
        .config_get = config_get,
        .config_set = config_set,
        .config_list = config_list,