X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fdemo%2Fdemo.c;h=4e760e35b1bf0070d71b2822280f0d3f072b3e8d;hb=104ed125532596a43f2d95d9a5d05bd6d51b9afa;hp=68bd4115b5fd60cf60126626d07df1a4f9c7a8b8;hpb=1c2d542df2bad5a719863d5c5cb38334c80e2ac6;p=libsigrok.git

diff --git a/hardware/demo/demo.c b/hardware/demo/demo.c
index 68bd4115..4e760e35 100644
--- a/hardware/demo/demo.c
+++ b/hardware/demo/demo.c
@@ -31,66 +31,91 @@
 #include "libsigrok.h"
 #include "libsigrok-internal.h"
 
-/* Message logging helpers with subsystem-specific prefix string. */
-#define LOG_PREFIX "demo: "
-#define sr_log(l, s, args...) sr_log(l, LOG_PREFIX s, ## args)
-#define sr_spew(s, args...) sr_spew(LOG_PREFIX s, ## args)
-#define sr_dbg(s, args...) sr_dbg(LOG_PREFIX s, ## args)
-#define sr_info(s, args...) sr_info(LOG_PREFIX s, ## args)
-#define sr_warn(s, args...) sr_warn(LOG_PREFIX s, ## args)
-#define sr_err(s, args...) sr_err(LOG_PREFIX s, ## args)
-
-/* TODO: Number of probes should be configurable. */
-#define NUM_PROBES             8
-
-#define DEMONAME               "Demo device"
-
-/* The size of chunks to send through the session bus. */
-/* TODO: Should be configurable. */
-#define BUFSIZE                4096
-
-#define STR_PATTERN_SIGROK   "sigrok"
-#define STR_PATTERN_RANDOM   "random"
-#define STR_PATTERN_INC      "incremental"
-#define STR_PATTERN_ALL_LOW  "all-low"
-#define STR_PATTERN_ALL_HIGH "all-high"
-
-/* Supported patterns which we can generate */
+#define LOG_PREFIX "demo"
+
+#define DEFAULT_NUM_LOGIC_PROBES     8
+#define DEFAULT_NUM_ANALOG_PROBES    4
+
+/* 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 */
 enum {
+	/* Logic */
 	/**
-	 * Pattern which spells "sigrok" using '0's (with '1's as "background")
-	 * when displayed using the 'bits' output format.
+	 * Spells "sigrok" across 8 probes 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
+	 * in time by one bit.
 	 */
 	PATTERN_SIGROK,
 
-	/** Pattern which consists of (pseudo-)random values on all probes. */
+	/** Pseudo-random values on all probes. */
 	PATTERN_RANDOM,
 
 	/**
-	 * Pattern which consists of incrementing numbers.
-	 * TODO: Better description.
+	 * Incrementing number across 8 probes. The pattern is repeasted
+	 * every 8 probes, shifted to the right in time by one bit.
 	 */
 	PATTERN_INC,
 
-	/** Pattern where all probes have a low logic state. */
+	/** All probes have a low logic state. */
 	PATTERN_ALL_LOW,
 
-	/** Pattern where all probes have a high logic state. */
+	/** All probes have a high logic state. */
 	PATTERN_ALL_HIGH,
+
+	/* Analog */
+	/**
+	 * Square wave.
+	 */
+	PATTERN_SQUARE,
+};
+
+static const char *logic_pattern_str[] = {
+	"sigrok",
+	"random",
+	"incremental",
+	"all-low",
+	"all-high",
+};
+
+static const char *analog_pattern_str[] = {
+	"square",
+};
+
+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 {
-	struct sr_dev_inst *sdi;
 	int pipe_fds[2];
 	GIOChannel *channel;
 	uint64_t cur_samplerate;
 	uint64_t limit_samples;
 	uint64_t limit_msec;
-	uint8_t sample_generator;
 	uint64_t samples_counter;
-	void *cb_data;
 	int64_t starttime;
+	uint64_t step;
+	/* Logic */
+	int32_t num_logic_probes;
+	unsigned int logic_unitsize;
+	uint8_t logic_pattern;
+	unsigned char logic_data[LOGIC_BUFSIZE];
+	/* Analog */
+	int32_t num_analog_probes;
+	GSList *analog_probe_groups;
+};
+
+static const int32_t hwopts[] = {
+	SR_CONF_NUM_LOGIC_PROBES,
+	SR_CONF_NUM_ANALOG_PROBES,
 };
 
 static const int hwcaps[] = {
@@ -100,7 +125,6 @@ static const int hwcaps[] = {
 	SR_CONF_PATTERN_MODE,
 	SR_CONF_LIMIT_SAMPLES,
 	SR_CONF_LIMIT_MSEC,
-	SR_CONF_CONTINUOUS,
 };
 
 static const uint64_t samplerates[] = {
@@ -109,20 +133,6 @@ static const uint64_t samplerates[] = {
 	SR_HZ(1),
 };
 
-static const char *pattern_strings[] = {
-	"sigrok",
-	"random",
-	"incremental",
-	"all-low",
-	"all-high",
-};
-
-/* We name the probes 0-7 on our demo driver. */
-static const char *probe_names[NUM_PROBES + 1] = {
-	"0", "1", "2", "3", "4", "5", "6", "7",
-	NULL,
-};
-
 static uint8_t pattern_sigrok[] = {
 	0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
 	0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
@@ -134,15 +144,12 @@ static uint8_t pattern_sigrok[] = {
 	0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-/* Private, per-device-instance driver context. */
-/* TODO: struct context as with the other drivers. */
-
-/* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
 SR_PRIV struct sr_dev_driver demo_driver_info;
 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);
@@ -153,50 +160,130 @@ 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)
+{
+	struct analog_gen *ag;
+	float value;
+	unsigned int num_samples, i;
+	int last_end;
+
+	ag = probe_group->priv;
+	ag->pattern = pattern;
+
+	switch (pattern) {
+	case PATTERN_SQUARE:
+		num_samples = ANALOG_BUFSIZE / sizeof(float);
+		value = 5.0;
+		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;
+	}
+}
+
 static GSList *scan(GSList *options)
 {
-	struct sr_dev_inst *sdi;
-	struct sr_probe *probe;
 	struct drv_context *drvc;
 	struct dev_context *devc;
-	GSList *devices;
-	int i;
-
-	(void)options;
+	struct sr_dev_inst *sdi;
+	struct sr_probe *probe;
+	struct sr_probe_group *pg;
+	struct sr_config *src;
+	struct analog_gen *ag;
+	GSList *devices, *l;
+	int num_logic_probes, num_analog_probes, i;
+	char probe_name[16];
 
 	drvc = di->priv;
 
-	devices = NULL;
+	num_logic_probes = DEFAULT_NUM_LOGIC_PROBES;
+	num_analog_probes = 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);
+			break;
+		case SR_CONF_NUM_ANALOG_PROBES:
+			num_analog_probes = g_variant_get_int32(src->data);
+			break;
+		}
+	}
 
-	sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
+	devices = NULL;
+	sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
 	if (!sdi) {
 		sr_err("Device instance creation failed.");
 		return NULL;
 	}
 	sdi->driver = di;
 
-	for (i = 0; probe_names[i]; i++) {
-		if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
-				probe_names[i])))
-			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;
 	}
-
-	devc->sdi = sdi;
 	devc->cur_samplerate = SR_KHZ(200);
 	devc->limit_samples = 0;
 	devc->limit_msec = 0;
-	devc->sample_generator = PATTERN_SIGROK;
+	devc->step = 0;
+	devc->num_logic_probes = num_logic_probes;
+	devc->logic_unitsize = (devc->num_logic_probes + 7) / 8;
+	devc->logic_pattern = PATTERN_SIGROK;
+	devc->num_analog_probes = num_analog_probes;
+	devc->analog_probe_groups = NULL;
+
+	/* Logic probes, all in one probe group. */
+	if (!(pg = g_try_malloc(sizeof(struct sr_probe_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)))
+			return NULL;
+		sdi->probes = g_slist_append(sdi->probes, probe);
+		pg->probes = g_slist_append(pg->probes, probe);
+	}
+	sdi->probe_groups = g_slist_append(NULL, pg);
+
+	/* 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)))
+			return NULL;
+		sdi->probes = g_slist_append(sdi->probes, probe);
+
+		/* Every analog probe gets its own probe group. */
+		if (!(pg = g_try_malloc(sizeof(struct sr_probe_group))))
+			return NULL;
+		pg->name = g_strdup(probe_name);
+		pg->probes = g_slist_append(NULL, probe);
+
+		/* Every probe group gets a generator struct. */
+		if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
+			return NULL;
+		ag->packet.probes = pg->probes;
+		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);
+
+		sdi->probe_groups = g_slist_append(sdi->probe_groups, pg);
+		devc->analog_probe_groups = g_slist_append(devc->analog_probe_groups, pg);
+	}
 
 	sdi->priv = devc;
+	devices = g_slist_append(devices, sdi);
+	drvc->instances = g_slist_append(drvc->instances, sdi);
 
 	return devices;
 }
@@ -225,10 +312,14 @@ static int cleanup(void)
 	return dev_clear();
 }
 
-static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
+static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
+		const struct sr_probe_group *probe_group)
 {
-	struct dev_context *const devc = sdi->priv;
+	struct dev_context *devc;
 
+	(void)probe_group;
+
+	devc = sdi->priv;
 	switch (id) {
 	case SR_CONF_SAMPLERATE:
 		*data = g_variant_new_uint64(devc->cur_samplerate);
@@ -240,23 +331,13 @@ 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:
-		switch (devc->sample_generator) {
-		case PATTERN_SIGROK:
-			*data = g_variant_new_string(STR_PATTERN_SIGROK);
-			break;
-		case PATTERN_RANDOM:
-			*data = g_variant_new_string(STR_PATTERN_RANDOM);
-			break;
-		case PATTERN_INC:
-			*data = g_variant_new_string(STR_PATTERN_INC);
-			break;
-		case PATTERN_ALL_LOW:
-			*data = g_variant_new_string(STR_PATTERN_ALL_LOW);
-			break;
-		case PATTERN_ALL_HIGH:
-			*data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
-			break;
-		}
+		*data = g_variant_new_string(logic_pattern_str[devc->logic_pattern]);
+		break;
+	case SR_CONF_NUM_LOGIC_PROBES:
+		*data = g_variant_new_int32(devc->num_logic_probes);
+		break;
+	case SR_CONF_NUM_ANALOG_PROBES:
+		*data = g_variant_new_int32(devc->num_analog_probes);
 		break;
 	default:
 		return SR_ERR_NA;
@@ -265,51 +346,80 @@ static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
 	return SR_OK;
 }
 
-static int config_set(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)
 {
-	int ret;
+	struct dev_context *devc;
+	struct sr_probe_group *pg;
+	GSList *l;
+	int logic_pattern, analog_pattern, ret;
+	unsigned int i;
 	const char *stropt;
 
-	struct dev_context *const devc = sdi->priv;
+	devc = sdi->priv;
 
 	if (sdi->status != SR_ST_ACTIVE)
 		return SR_ERR_DEV_CLOSED;
 
+	ret = SR_ERR;
 	if (id == SR_CONF_SAMPLERATE) {
 		devc->cur_samplerate = g_variant_get_uint64(data);
-		sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
-		       devc->cur_samplerate);
+		sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
 		ret = SR_OK;
 	} else if (id == SR_CONF_LIMIT_SAMPLES) {
 		devc->limit_msec = 0;
 		devc->limit_samples = g_variant_get_uint64(data);
-		sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
-		       devc->limit_samples);
+		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 */
 		devc->limit_msec = g_variant_get_uint64(data);
 		devc->limit_samples = 0;
-		sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
-		       devc->limit_msec);
+		sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
 		ret = SR_OK;
 	} else if (id == SR_CONF_PATTERN_MODE) {
 		stropt = g_variant_get_string(data, NULL);
-		ret = SR_OK;
-		if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
-			devc->sample_generator = PATTERN_SIGROK;
-		} else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
-			devc->sample_generator = PATTERN_RANDOM;
-		} else if (!strcmp(stropt, STR_PATTERN_INC)) {
-			devc->sample_generator = PATTERN_INC;
-		} else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
-			devc->sample_generator = PATTERN_ALL_LOW;
-		} else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
-			devc->sample_generator = PATTERN_ALL_HIGH;
+		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;
+					break;
+				}
+			}
+		}
+		if (logic_pattern > -1) {
+			devc->logic_pattern = logic_pattern;
+			/* Might as well do this now. */
+			if (logic_pattern == PATTERN_ALL_LOW)
+				memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
+			else if (logic_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);
+				}
+				ret = SR_OK;
+			}
 		} else {
 			ret = SR_ERR;
 		}
-		sr_dbg("%s: setting pattern to %d",
-			__func__, devc->sample_generator);
 	} else {
 		ret = SR_ERR_NA;
 	}
@@ -317,14 +427,20 @@ static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
 	return ret;
 }
 
-static int config_list(int key, 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)
 {
 	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:
 		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 				hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
@@ -337,7 +453,7 @@ static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
 		*data = g_variant_builder_end(&gvb);
 		break;
 	case SR_CONF_PATTERN_MODE:
-		*data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
+		*data = g_variant_new_strv(logic_pattern_str, ARRAY_SIZE(logic_pattern_str));
 		break;
 	default:
 		return SR_ERR_NA;
@@ -346,55 +462,66 @@ static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
 	return SR_OK;
 }
 
-static void samples_generator(uint8_t *buf, uint64_t size,
-			      struct dev_context *devc)
+static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
 {
-	static uint64_t p = 0;
-	uint64_t i;
-
-	/* TODO: Needed? */
-	memset(buf, 0, size);
-
-	switch (devc->sample_generator) {
-	case PATTERN_SIGROK: /* sigrok pattern */
-		for (i = 0; i < size; i++) {
-			*(buf + i) = ~(pattern_sigrok[
-				p++ % sizeof(pattern_sigrok)] >> 1);
+	struct dev_context *devc;
+	uint64_t i, j;
+	uint8_t pat;
+
+	devc = sdi->priv;
+
+	switch (devc->logic_pattern) {
+	case PATTERN_SIGROK:
+		memset(devc->logic_data, 0x00, size);
+		for (i = 0; i < size; i += devc->logic_unitsize) {
+			for (j = 0; j < devc->logic_unitsize; j++) {
+				pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
+				devc->logic_data[i + j] = ~pat;
+			}
+			devc->step++;
 		}
 		break;
-	case PATTERN_RANDOM: /* Random */
+	case PATTERN_RANDOM:
 		for (i = 0; i < size; i++)
-			*(buf + i) = (uint8_t)(rand() & 0xff);
+			devc->logic_data[i] = (uint8_t)(rand() & 0xff);
 		break;
-	case PATTERN_INC: /* Simple increment */
-		for (i = 0; i < size; i++)
-			*(buf + i) = p++;
-		break;
-	case PATTERN_ALL_LOW: /* All probes are low */
-		memset(buf, 0x00, size);
+	case PATTERN_INC:
+		for (i = 0; i < size; i++) {
+			for (j = 0; j < devc->logic_unitsize; j++) {
+				devc->logic_data[i + j] = devc->step;
+			}
+			devc->step++;
+		}
 		break;
-	case PATTERN_ALL_HIGH: /* All probes are high */
-		memset(buf, 0xff, size);
+	case PATTERN_ALL_LOW:
+	case PATTERN_ALL_HIGH:
+		/* These were set when the pattern mode was selected. */
 		break;
 	default:
-		sr_err("Unknown pattern: %d.", devc->sample_generator);
+		sr_err("Unknown pattern: %d.", devc->logic_pattern);
 		break;
 	}
 }
 
 /* Callback handling data */
-static int receive_data(int fd, int revents, void *cb_data)
+static int prepare_data(int fd, int revents, void *cb_data)
 {
-	struct dev_context *devc = cb_data;
+	struct sr_dev_inst *sdi;
+	struct dev_context *devc;
 	struct sr_datafeed_packet packet;
 	struct sr_datafeed_logic logic;
-	uint8_t buf[BUFSIZE];
-	static uint64_t samples_to_send, expected_samplenum, sending_now;
+	struct sr_probe_group *pg;
+	struct analog_gen *ag;
+	GSList *l;
+	uint64_t samples_to_send, expected_samplenum, analog_samples, sending_now;
 	int64_t time, elapsed;
 
 	(void)fd;
 	(void)revents;
 
+	sdi = cb_data;
+	devc = sdi->priv;
+
 	/* How many "virtual" samples should we have collected by now? */
 	time = g_get_monotonic_time();
 	elapsed = time - devc->starttime;
@@ -404,27 +531,49 @@ static int receive_data(int fd, int revents, void *cb_data)
 
 	if (devc->limit_samples) {
 		samples_to_send = MIN(samples_to_send,
-				 devc->limit_samples - devc->samples_counter);
+				devc->limit_samples - devc->samples_counter);
 	}
 
 	while (samples_to_send > 0) {
-		sending_now = MIN(samples_to_send, sizeof(buf));
+		sending_now = 0;
+
+		/* Logic */
+		if (devc->num_logic_probes > 0) {
+			sending_now = MIN(samples_to_send,
+					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);
+		}
+
+		/* Analog, one probe at a time */
+		if (devc->num_analog_probes > 0) {
+			sending_now = 0;
+			for (l = devc->analog_probe_groups; l; l = l->next) {
+				pg = l->data;
+				ag = pg->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. */
+				sending_now = MAX(sending_now, analog_samples);
+				ag->packet.num_samples = analog_samples;
+				sr_session_send(sdi, &packet);
+			}
+		}
+
 		samples_to_send -= sending_now;
-		samples_generator(buf, sending_now, devc);
-
-		packet.type = SR_DF_LOGIC;
-		packet.payload = &logic;
-		logic.length = sending_now;
-		logic.unitsize = 1;
-		logic.data = buf;
-		sr_session_send(devc->cb_data, &packet);
 		devc->samples_counter += sending_now;
 	}
 
 	if (devc->limit_samples &&
 		devc->samples_counter >= devc->limit_samples) {
 		sr_info("Requested number of samples reached.");
-		dev_acquisition_stop(devc->sdi, cb_data);
+		dev_acquisition_stop(sdi, cb_data);
 		return TRUE;
 	}
 
@@ -433,12 +582,13 @@ static int receive_data(int fd, int revents, void *cb_data)
 
 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 {
-	struct dev_context *const devc = sdi->priv;
+	struct dev_context *devc;
 
 	if (sdi->status != SR_ST_ACTIVE)
 		return SR_ERR_DEV_CLOSED;
 
-	devc->cb_data = cb_data;
+	/* TODO: don't start without a sample limit set */
+	devc = sdi->priv;
 	devc->samples_counter = 0;
 
 	/*
@@ -449,7 +599,6 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 	 * up a timeout-based polling mechanism.
 	 */
 	if (pipe(devc->pipe_fds)) {
-		/* TODO: Better error message. */
 		sr_err("%s: pipe() failed", __func__);
 		return SR_ERR;
 	}
@@ -465,7 +614,7 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 	g_io_channel_set_buffered(devc->channel, FALSE);
 
 	sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
-		    40, receive_data, devc);
+			40, prepare_data, (void *)sdi);
 
 	/* Send header packet to the session bus. */
 	std_session_send_df_header(cb_data, LOG_PREFIX);
@@ -478,11 +627,12 @@ 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;
 
+	devc = sdi->priv;
 	sr_dbg("Stopping aquisition.");
 
 	sr_session_source_remove_channel(devc->channel);
@@ -492,7 +642,7 @@ static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 
 	/* Send last packet. */
 	packet.type = SR_DF_END;
-	sr_session_send(devc->cb_data, &packet);
+	sr_session_send(sdi, &packet);
 
 	return SR_OK;
 }