X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fdemo%2Fdemo.c;h=ea5e0b53388dc1217f630ec559faa931ab0211ed;hb=0812c40e361c9a75f3b4ef318a57ce8ba0479fa1;hp=b317fefed275be6326a426fc22ca169cd83d20ea;hpb=c07f60e73dba95479c96650a94db77c3639639ce;p=libsigrok.git

diff --git a/hardware/demo/demo.c b/hardware/demo/demo.c
index b317fefe..ea5e0b53 100644
--- a/hardware/demo/demo.c
+++ b/hardware/demo/demo.c
@@ -23,6 +23,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
+#include <math.h>
 #ifdef _WIN32
 #include <io.h>
 #include <fcntl.h>
@@ -33,39 +34,55 @@
 
 #define LOG_PREFIX "demo"
 
-#define DEFAULT_NUM_LOGIC_PROBES     8
-#define DEFAULT_NUM_ANALOG_PROBES    4
+#define DEFAULT_NUM_LOGIC_CHANNELS     8
+#define DEFAULT_NUM_ANALOG_CHANNELS    4
 
-/* The size of chunks to send through the session bus. */
+/* The size in bytes of chunks to send through the session bus. */
 #define LOGIC_BUFSIZE        4096
+/* 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 {
 	/**
-	 * 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 repeated 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 repeated
+	 * 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,
 };
 
-static const char *pattern_strings[] = {
+/* Analog patterns we can generate. */
+enum {
+	/**
+	 * Square wave.
+	 */
+	PATTERN_SQUARE,
+	PATTERN_SINE,
+	PATTERN_TRIANGLE,
+	PATTERN_SAWTOOTH,
+};
+
+static const char *logic_pattern_str[] = {
 	"sigrok",
 	"random",
 	"incremental",
@@ -73,6 +90,20 @@ static const char *pattern_strings[] = {
 	"all-high",
 };
 
+static const char *analog_pattern_str[] = {
+	"square",
+	"sine",
+	"triangle",
+	"sawtooth",
+};
+
+struct analog_gen {
+	int pattern;
+	float pattern_data[ANALOG_BUFSIZE];
+	unsigned int num_samples;
+	struct sr_datafeed_analog packet;
+};
+
 /* Private, per-device-instance driver context. */
 struct dev_context {
 	int pipe_fds[2];
@@ -80,29 +111,36 @@ 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;
-	int32_t num_logic_probes;
+	/* Logic */
+	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];
-	int32_t num_analog_probes;
+	/* Analog */
+	int32_t num_analog_channels;
+	GSList *analog_channel_groups;
 };
 
-static const int32_t hwopts[] = {
-	SR_CONF_NUM_LOGIC_PROBES,
-	SR_CONF_NUM_ANALOG_PROBES,
+static const int32_t scanopts[] = {
+	SR_CONF_NUM_LOGIC_CHANNELS,
+	SR_CONF_NUM_ANALOG_CHANNELS,
 };
 
-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,
-	SR_CONF_CONTINUOUS,
+};
+
+static const int devopts_cg[] = {
+	SR_CONF_PATTERN_MODE,
 };
 
 static const uint64_t samplerates[] = {
@@ -128,14 +166,88 @@ 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)
+static int init(struct sr_context *sr_ctx)
 {
-	return std_dev_clear(di, NULL);
+	return std_init(sr_ctx, di, LOG_PREFIX);
 }
 
-static int init(struct sr_context *sr_ctx)
+static void generate_analog_pattern(const struct sr_channel_group *cg, uint64_t sample_rate)
 {
-	return std_init(sr_ctx, di, LOG_PREFIX);
+	struct analog_gen *ag;
+	double t, frequency;
+	float value;
+	unsigned int num_samples, i;
+	int last_end;
+
+	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 (ag->pattern) {
+	case PATTERN_SQUARE:
+		value = ANALOG_AMPLITUDE;
+		last_end = 0;
+		for (i = 0; i < num_samples; i++) {
+			if (i % 5 == 0)
+				value = -value;
+			if (i % 10 == 0)
+				last_end = i - 1;
+			ag->pattern_data[i] = value;
+		}
+		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;
+	}
 }
 
 static GSList *scan(GSList *options)
@@ -143,24 +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_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_CHANNELS;
+	num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
 	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);
+		case SR_CONF_NUM_LOGIC_CHANNELS:
+			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);
+		case SR_CONF_NUM_ANALOG_CHANNELS:
+			num_analog_channels = g_variant_get_int32(src->data);
 			break;
 		}
 	}
@@ -173,23 +287,6 @@ static GSList *scan(GSList *options)
 	}
 	sdi->driver = di;
 
-	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)))
-			return NULL;
-		sdi->probes = g_slist_append(sdi->probes, probe);
-	}
-
-	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)))
-			return NULL;
-		sdi->probes = g_slist_append(sdi->probes, probe);
-	}
-
-	devices = g_slist_append(devices, sdi);
-	drvc->instances = g_slist_append(drvc->instances, sdi);
-
 	if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
 		sr_err("Device context malloc failed.");
 		return NULL;
@@ -198,12 +295,64 @@ 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->num_analog_channels = num_analog_channels;
+	devc->analog_channel_groups = NULL;
+
+	/* Logic channels, all in one channel group. */
+	if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
+		return NULL;
+	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_channel_new(i, SR_CHANNEL_LOGIC, TRUE, channel_name)))
+			return NULL;
+		sdi->channels = g_slist_append(sdi->channels, ch);
+		cg->channels = g_slist_append(cg->channels, ch);
+	}
+	sdi->channel_groups = g_slist_append(NULL, cg);
+
+	/* Analog channels, channel groups and pattern generators. */
+
+	pattern = 0;
+	for (i = 0; i < num_analog_channels; i++) {
+		sprintf(channel_name, "A%d", i);
+		if (!(ch = sr_channel_new(i + num_logic_channels,
+				SR_CHANNEL_ANALOG, TRUE, channel_name)))
+			return NULL;
+		sdi->channels = g_slist_append(sdi->channels, ch);
+
+		/* Every analog channel gets its own channel group. */
+		if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
+			return NULL;
+		cg->name = g_strdup(channel_name);
+		cg->channels = g_slist_append(NULL, ch);
+
+		/* Every channel group gets a generator struct. */
+		if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
+			return NULL;
+		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;
+		ag->pattern = pattern;
+		cg->priv = ag;
+
+		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;
+	devices = g_slist_append(devices, sdi);
+	drvc->instances = g_slist_append(drvc->instances, sdi);
 
 	return devices;
 }
@@ -229,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) {
@@ -251,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(pattern_strings[devc->logic_pattern]);
+		if (!cg)
+			return SR_ERR_CHANNEL_GROUP;
+		ch = cg->channels->data;
+		if (ch->type == SR_CHANNEL_LOGIC) {
+			pattern = devc->logic_pattern;
+			*data = g_variant_new_string(logic_pattern_str[pattern]);
+		} else if (ch->type == SR_CHANNEL_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);
+	case SR_CONF_NUM_LOGIC_CHANNELS:
+		*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);
+	case SR_CONF_NUM_ANALOG_CHANNELS:
+		*data = g_variant_new_int32(devc->num_analog_channels);
 		break;
 	default:
 		return SR_ERR_NA;
@@ -267,49 +431,77 @@ 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 analog_gen *ag;
+	struct sr_channel *ch;
+	int pattern, ret;
 	unsigned int i;
-	int ret;
 	const char *stropt;
 
-	(void)probe_group;
-	struct dev_context *const devc = sdi->priv;
+	devc = sdi->priv;
 
 	if (sdi->status != SR_ST_ACTIVE)
 		return SR_ERR_DEV_CLOSED;
 
-	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 limit_samples to %" PRIu64, devc->limit_samples);
-		ret = SR_OK;
-	} else if (id == SR_CONF_LIMIT_MSEC) {
+		sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
+		break;
+	case SR_CONF_LIMIT_MSEC:
 		devc->limit_msec = g_variant_get_uint64(data);
 		devc->limit_samples = 0;
-		sr_dbg("Setting limit_msec to %" PRIu64, devc->limit_msec);
-		ret = SR_OK;
-	} else if (id == SR_CONF_PATTERN_MODE) {
+		sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
+		break;
+	case SR_CONF_PATTERN_MODE:
+		if (!cg)
+			return SR_ERR_CHANNEL_GROUP;
 		stropt = g_variant_get_string(data, NULL);
-		ret = SR_ERR;
-		for (i = 0; i < ARRAY_SIZE(pattern_strings); i++) {
-			if (!strcmp(stropt, pattern_strings[i])) {
-				devc->logic_pattern = i;
-				ret = SR_OK;
-				break;
+		ch = cg->channels->data;
+		pattern = -1;
+		if (ch->type == SR_CHANNEL_LOGIC) {
+			for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
+				if (!strcmp(stropt, logic_pattern_str[i])) {
+					pattern = i;
+					break;
+				}
 			}
-		}
-		/* Might as well do this now. */
-		if (i == PATTERN_ALL_LOW)
-			memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
-		else if (i == PATTERN_ALL_HIGH)
-			memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
-		sr_dbg("Setting pattern to %s", pattern_strings[i]);
-	} else {
+			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 (pattern == PATTERN_ALL_HIGH)
+				memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
+			sr_dbg("Setting logic pattern to %s",
+					logic_pattern_str[pattern]);
+		} else if (ch->type == SR_CHANNEL_ANALOG) {
+			for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
+				if (!strcmp(stropt, analog_pattern_str[i])) {
+					pattern = i;
+					break;
+				}
+			}
+			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;
 	}
 
@@ -317,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(pattern_strings, ARRAY_SIZE(pattern_strings));
-		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_CHANNEL_LOGIC)
+				*data = g_variant_new_strv(logic_pattern_str,
+						ARRAY_SIZE(logic_pattern_str));
+			else if (ch->type == SR_CHANNEL_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;
@@ -399,7 +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;
-	uint64_t samples_to_send, expected_samplenum, sending_now;
+	struct sr_channel_group *cg;
+	struct analog_gen *ag;
+	GSList *l;
+	uint64_t logic_todo, analog_todo, expected_samplenum, analog_samples, sending_now;
 	int64_t time, elapsed;
 
 	(void)fd;
@@ -412,32 +631,55 @@ 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 = MIN(samples_to_send, LOGIC_BUFSIZE / devc->logic_unitsize);
-		samples_to_send -= sending_now;
+	/* 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 */
-		logic_generator(sdi, sending_now * devc->logic_unitsize);
-		packet.type = SR_DF_LOGIC;
-		packet.payload = &logic;
-		logic.length = sending_now * devc->logic_unitsize;
-		logic.unitsize = devc->logic_unitsize;
-		logic.data = devc->logic_data;
-		sr_session_send(sdi, &packet);
-		devc->samples_counter += sending_now;
+		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;
+			packet.payload = &logic;
+			logic.length = sending_now * devc->logic_unitsize;
+			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 channel at a time */
+		if (devc->num_analog_channels > 0 && analog_todo > 0) {
+			sending_now = 0;
+			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;
+
+				/* 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;
+		}
 	}
 
-	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;
 	}
@@ -447,13 +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;
 
 	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
@@ -467,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);
@@ -477,7 +726,7 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 	/* Make channels to unbuffered. */
 	g_io_channel_set_buffered(devc->channel, FALSE);
 
-	sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
+	sr_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
 			40, prepare_data, (void *)sdi);
 
 	/* Send header packet to the session bus. */
@@ -491,14 +740,15 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 
 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 {
-	struct dev_context *const devc = sdi->priv;
+	struct dev_context *devc;
 	struct sr_datafeed_packet packet;
 
 	(void)cb_data;
 
-	sr_dbg("Stopping aquisition.");
+	devc = sdi->priv;
+	sr_dbg("Stopping acquisition.");
 
-	sr_session_source_remove_channel(devc->channel);
+	sr_source_remove_channel(devc->channel);
 	g_io_channel_shutdown(devc->channel, FALSE, NULL);
 	g_io_channel_unref(devc->channel);
 	devc->channel = NULL;
@@ -518,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,