X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fdemo%2Fdemo.c;h=f1580a7dfc36f808ffa49d6053c041bb8a082c8e;hb=5b5ea7c6d25bb42de09b61d0a070d78252f2367b;hp=b8f36fbfd4e77c967c7994b016f799efe3861b4c;hpb=6239c175c1b967b577f760032d326322dd4c4576;p=libsigrok.git

diff --git a/hardware/demo/demo.c b/hardware/demo/demo.c
index b8f36fbf..f1580a7d 100644
--- a/hardware/demo/demo.c
+++ b/hardware/demo/demo.c
@@ -2,6 +2,7 @@
  * This file is part of the sigrok project.
  *
  * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
+ * Copyright (C) 2011 Olivier Fauchon <olivier@aixmarseille.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,114 +20,95 @@
  */
 
 #include <stdlib.h>
+#include <unistd.h>
 #include <string.h>
 #include <sigrok.h>
+#ifdef _WIN32
+#include <io.h>
+#include <fcntl.h>
+#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
+#endif
 #include "config.h"
 
-#define NUM_PROBES			8
-#define NUM_TRIGGER_STAGES		4
-#define TRIGGER_TYPES			"01"
+#define NUM_PROBES             8
+#define DEMONAME               "Demo device"
+/* size of chunks to send through the session bus */
+#define BUFSIZE                4096
 
-/* Software trigger implementation: positive values indicate trigger stage. */
-#define TRIGGER_FIRED			-1
+enum {
+	GENMODE_DEFAULT,
+	GENMODE_RANDOM,
+	GENMODE_INC,
+};
+
+GIOChannel *channels[2];
+
+struct databag {
+	int pipe_fds[2];
+	uint8_t sample_generator;
+	uint8_t thread_running;
+	uint64_t samples_counter;
+	int device_index;
+	int loop_sleep;
+	gpointer session_device_id;
+	GTimer *timer;
+};
 
 static int capabilities[] = {
 	HWCAP_LOGIC_ANALYZER,
-	HWCAP_SAMPLERATE,
+	HWCAP_PATTERN_MODE,
 	HWCAP_LIMIT_SAMPLES,
+	HWCAP_LIMIT_MSEC,
+	HWCAP_CONTINUOUS
 };
 
-/* Random selection of samplerates this "device" shall support. */
-static uint64_t supported_samplerates[] = {
-	KHZ(100),
-	KHZ(500),
-	MHZ(1),
-	MHZ(2),
-	MHZ(12),
-	MHZ(24),
-	0,
+static const char *patternmodes[] = {
+	"random",
+	"incremental",
+	NULL,
 };
 
-static struct samplerates samplerates = {
-	KHZ(100),
-	MHZ(24),
-	0,
-	supported_samplerates,
+static uint8_t genmode_default[] = {
+	0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
+	0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
+	0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
+	0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
+	0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
+	0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-/* TODO: All of these should go in a device-specific struct. */
+/* List of struct sigrok_device_instance, maintained by opendev()/closedev(). */
+static GSList *device_instances = NULL;
 static uint64_t cur_samplerate = 0;
 static uint64_t limit_samples = 0;
-// static uint8_t probe_mask = 0;
-// static uint8_t trigger_mask[NUM_TRIGGER_STAGES] = { 0 };
-// static uint8_t trigger_value[NUM_TRIGGER_STAGES] = { 0 };
-// static uint8_t trigger_buffer[NUM_TRIGGER_STAGES] = { 0 };
-
-// static int trigger_stage = TRIGGER_FIRED;
+static uint64_t limit_msec = 0;
+static int default_genmode = GENMODE_DEFAULT;
+static GThread *my_thread;
+static int thread_running;
 
-static int hw_set_configuration(int device_index, int capability, void *value);
 static void hw_stop_acquisition(int device_index, gpointer session_device_id);
 
-#if 0
-static int configure_probes(GSList *probes)
+static int hw_init(char *deviceinfo)
 {
-	struct probe *probe;
-	GSList *l;
-	int probe_bit, stage, i;
-	char *tc;
-
-	probe_mask = 0;
-	for (i = 0; i < NUM_TRIGGER_STAGES; i++) {
-		trigger_mask[i] = 0;
-		trigger_value[i] = 0;
-	}
-
-	stage = -1;
-	for (l = probes; l; l = l->next) {
-		probe = (struct probe *)l->data;
-		if (!(probe->enabled))
-			continue;
-		probe_bit = 1 << (probe->index - 1);
-		probe_mask |= probe_bit;
-		if (!(probe->trigger))
-			continue;
-
-		stage = 0;
-		for (tc = probe->trigger; *tc; tc++) {
-			trigger_mask[stage] |= probe_bit;
-			if (*tc == '1')
-				trigger_value[stage] |= probe_bit;
-			stage++;
-			if (stage > NUM_TRIGGER_STAGES)
-				return SIGROK_ERR;
-		}
-	}
+	struct sigrok_device_instance *sdi;
 
-	if (stage == -1)
-		/*
-		 * We didn't configure any triggers, make sure acquisition
-		 * doesn't wait for any.
-		 */
-		trigger_stage = TRIGGER_FIRED;
-	else
-		trigger_stage = 0;
+	/* Avoid compiler warnings. */
+	deviceinfo = deviceinfo;
 
-	return SIGROK_OK;
-}
-#endif
+	sdi = sigrok_device_instance_new(0, ST_ACTIVE, DEMONAME, NULL, NULL);
+	if (!sdi)
+		return 0;
 
-static int hw_init(char *deviceinfo)
-{
-	/* Avoid compiler warning. */
-	deviceinfo = deviceinfo;
+	device_instances = g_slist_append(device_instances, sdi);
 
-	/* Nothing needed so far. */
-	return 1; /* FIXME? */
+	return 1;
 }
 
 static int hw_opendev(int device_index)
 {
-	/* Avoid compiler warning. */
+	/* Avoid compiler warnings. */
 	device_index = device_index;
 
 	/* Nothing needed so far. */
@@ -135,7 +117,7 @@ static int hw_opendev(int device_index)
 
 static void hw_closedev(int device_index)
 {
-	/* Avoid compiler warning. */
+	/* Avoid compiler warnings. */
 	device_index = device_index;
 
 	/* Nothing needed so far. */
@@ -148,28 +130,25 @@ static void hw_cleanup(void)
 
 static void *hw_get_device_info(int device_index, int device_info_id)
 {
+	struct sigrok_device_instance *sdi;
 	void *info = NULL;
 
-	/* Avoid compiler warning. */
-	device_index = device_index;
+	if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
+		return NULL;
 
 	switch (device_info_id) {
 	case DI_INSTANCE:
-		/// info = sdi;
-		/* TODO */
+		info = sdi;
 		break;
 	case DI_NUM_PROBES:
 		info = GINT_TO_POINTER(NUM_PROBES);
 		break;
-	case DI_SAMPLERATES:
-		info = &samplerates;
-		break;
-	case DI_TRIGGER_TYPES:
-		info = TRIGGER_TYPES;
-		break;
 	case DI_CUR_SAMPLERATE:
 		info = &cur_samplerate;
 		break;
+	case DI_PATTERNMODES:
+		info = &patternmodes;
+		break;
 	}
 
 	return info;
@@ -177,10 +156,10 @@ static void *hw_get_device_info(int device_index, int device_info_id)
 
 static int hw_get_status(int device_index)
 {
-	/* Avoid compiler warning. */
+	/* Avoid compiler warnings. */
 	device_index = device_index;
 
-	return 0; /* FIXME */
+	return ST_ACTIVE;
 }
 
 static int *hw_get_capabilities(void)
@@ -191,19 +170,34 @@ static int *hw_get_capabilities(void)
 static int hw_set_configuration(int device_index, int capability, void *value)
 {
 	int ret;
+	uint64_t *tmp_u64;
+	char *stropt;
 
-	/* Avoid compiler warning. */
+	/* Avoid compiler warnings. */
 	device_index = device_index;
 
-	if (capability == HWCAP_SAMPLERATE) {
-		cur_samplerate = *(uint64_t *)value;
+	if (capability == HWCAP_PROBECONFIG) {
+		/* Nothing to do. */
 		ret = SIGROK_OK;
-	} else if (capability == HWCAP_PROBECONFIG) {
-		// ret = configure_probes((GSList *) value);
-		ret = SIGROK_ERR;
 	} else if (capability == HWCAP_LIMIT_SAMPLES) {
-		limit_samples = strtoull(value, NULL, 10);
+		tmp_u64 = value;
+		limit_samples = *tmp_u64;
 		ret = SIGROK_OK;
+	} else if (capability == HWCAP_LIMIT_MSEC) {
+		tmp_u64 = value;
+		limit_msec = *tmp_u64;
+		ret = SIGROK_OK;
+	} else if (capability == HWCAP_PATTERN_MODE) {
+		stropt = value;
+		if (!strcmp(stropt, "random")) {
+			default_genmode = GENMODE_RANDOM;
+			ret = SIGROK_OK;
+		} else if (!strcmp(stropt, "incremental")) {
+			default_genmode = GENMODE_INC;
+			ret = SIGROK_OK;
+		} else {
+			ret = SIGROK_ERR;
+		}
 	} else {
 		ret = SIGROK_ERR;
 	}
@@ -211,24 +205,144 @@ static int hw_set_configuration(int device_index, int capability, void *value)
 	return ret;
 }
 
+static void samples_generator(uint8_t *buf, uint64_t size, void *data)
+{
+	struct databag *mydata = data;
+	uint64_t p, i;
+
+	memset(buf, 0, size);
+
+	switch (mydata->sample_generator) {
+	case GENMODE_DEFAULT:
+		p = 0;
+		for (i = 0; i < size; i++) {
+			*(buf + i) = ~(genmode_default[p] >> 1);
+			if (++p == 64)
+				p = 0;
+		}
+		break;
+	case GENMODE_RANDOM: /* Random */
+		for (i = 0; i < size; i++)
+			*(buf + i) = (uint8_t)(rand() & 0xff);
+		break;
+	case GENMODE_INC: /* Simple increment */
+		for (i = 0; i < size; i++)
+			*(buf + i) = i;
+		break;
+	}
+}
+
+/* Thread function */
+static void thread_func(void *data)
+{
+	struct databag *mydata = data;
+	uint8_t buf[BUFSIZE];
+	uint64_t nb_to_send = 0;
+	int bytes_written;
+	unsigned int msec_elapsed;
+
+	while (thread_running) {
+		if (limit_samples)
+			nb_to_send = limit_samples - mydata->samples_counter;
+		else
+			nb_to_send = BUFSIZE;  /* Continuous mode */
+
+		if (limit_msec) {
+			msec_elapsed = g_timer_elapsed(mydata->timer, NULL) * 1000;
+			if (msec_elapsed > limit_msec)
+				nb_to_send = 0;
+		}
+
+		if (nb_to_send == 0) {
+			close(mydata->pipe_fds[1]);
+			thread_running = 0;
+			hw_stop_acquisition(mydata->device_index,
+					    mydata->session_device_id);
+		} else if (nb_to_send > BUFSIZE) {
+			nb_to_send = BUFSIZE;
+		}
+
+		samples_generator(buf, nb_to_send, data);
+		mydata->samples_counter += nb_to_send;
+
+		g_io_channel_write_chars(channels[1], (gchar *)&buf,
+				nb_to_send, (gsize *)&bytes_written, NULL);
+
+		g_usleep(mydata->loop_sleep);
+	}
+}
+
+/* Callback handling data */
+static int receive_data(int fd, int revents, void *user_data)
+{
+	struct datafeed_packet packet;
+	char c[BUFSIZE];
+	uint64_t z;
+
+	/* Avoid compiler warnings. */
+	fd = fd;
+	revents = revents;
+
+	g_io_channel_read_chars(channels[0], (gchar *)&c, BUFSIZE, &z, NULL);
+
+	if (z > 0) {
+		packet.type = DF_LOGIC;
+		packet.length = z;
+		packet.unitsize = 1;
+		packet.payload = c;
+		session_bus(user_data, &packet);
+	}
+	return TRUE;
+}
+
 static int hw_start_acquisition(int device_index, gpointer session_device_id)
 {
 	struct datafeed_packet *packet;
 	struct datafeed_header *header;
-	unsigned char *buf;
+	struct databag *mydata;
 
-	/* Avoid compiler warning. */
-	device_index = device_index;
+	mydata = malloc(sizeof(struct databag));
+	if (!mydata)
+		return SIGROK_ERR_MALLOC;
+
+	mydata->sample_generator = default_genmode;
+	mydata->session_device_id = session_device_id;
+	mydata->device_index = device_index;
+	mydata->samples_counter = 0;
+	mydata->loop_sleep = 100000;
+
+	if (pipe(mydata->pipe_fds))
+		return SIGROK_ERR;
+
+	channels[0] = g_io_channel_unix_new(mydata->pipe_fds[0]);
+	channels[1] = g_io_channel_unix_new(mydata->pipe_fds[1]);
+
+	/* Set channel encoding to binary (default is UTF-8). */
+	g_io_channel_set_encoding(channels[0], NULL, NULL);
+	g_io_channel_set_encoding(channels[1], NULL, NULL);
+
+	/* Make channels to unbuffered. */
+	g_io_channel_set_buffered(channels[0], FALSE);
+	g_io_channel_set_buffered(channels[1], FALSE);
+
+	source_add(mydata->pipe_fds[0], G_IO_IN | G_IO_ERR, 40, receive_data,
+		   session_device_id);
+
+	/* Run the demo thread. */
+	g_thread_init(NULL);
+	if (limit_msec)
+		mydata->timer = g_timer_new();
+	thread_running = 1;
+	my_thread =
+	    g_thread_create((GThreadFunc)thread_func, mydata, TRUE, NULL);
+	if (!my_thread)
+		return SIGROK_ERR;
 
 	packet = malloc(sizeof(struct datafeed_packet));
 	header = malloc(sizeof(struct datafeed_header));
-	buf = malloc(2048);
-	if (!packet || !header || !buf)
+	if (!packet || !header)
 		return SIGROK_ERR_MALLOC;
 
-	/* FIXME */
-	memset(buf, 0x55, 2048);
-
 	packet->type = DF_HEADER;
 	packet->length = sizeof(struct datafeed_header);
 	packet->payload = (unsigned char *)header;
@@ -236,7 +350,8 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 	gettimeofday(&header->starttime, NULL);
 	header->samplerate = cur_samplerate;
 	header->protocol_id = PROTO_RAW;
-	header->num_probes = NUM_PROBES;
+	header->num_logic_probes = NUM_PROBES;
+	header->num_analog_probes = 0;
 	session_bus(session_device_id, packet);
 	free(header);
 	free(packet);
@@ -244,76 +359,16 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 	return SIGROK_OK;
 }
 
-#if 0
-void receive_transfer(struct libusb_transfer *transfer)
-{
-	static int num_samples = 0;
-	static int empty_transfer_count = 0;
-	struct datafeed_packet packet;
-	void *user_data;
-	int cur_buflen, trigger_offset, i;
-	unsigned char *cur_buf, *new_buf;
-
-	g_message("receive_transfer(): status %d received %d bytes",
-		  transfer->status, transfer->actual_length);
-
-	/* Save incoming transfer before reusing the transfer struct. */
-	cur_buf = transfer->buffer;
-	cur_buflen = transfer->actual_length;
-	user_data = transfer->user_data;
-
-	/* Fire off a new request. */
-	new_buf = g_malloc(4096);
-	transfer->buffer = new_buf;
-	transfer->length = 4096;
-	if (libusb_submit_transfer(transfer) != 0) {
-		/* TODO: Stop session? */
-		g_warning("eek");
-	}
-
-	trigger_offset = 0;
-	if (trigger_stage >= 0) {
-		for (i = 0; i < cur_buflen; i++) {
-			trigger_helper(i, cur_buf, &packet, user_data,
-				       &trigger_offset);
-		}
-	}
-
-	if (trigger_stage == TRIGGER_FIRED) {
-		/* Send the incoming transfer to the session bus. */
-		packet.type = DF_LOGIC8;
-		packet.length = cur_buflen - trigger_offset;
-		packet.payload = cur_buf + trigger_offset;
-		session_bus(user_data, &packet);
-		free(cur_buf);
-
-		num_samples += cur_buflen;
-		if ((unsigned int)num_samples > limit_samples) {
-			hw_stop_acquisition(-1, user_data);
-		}
-	} else {
-		/*
-		 * TODO: Buffer pre-trigger data in capture
-		 * ratio-sized buffer.
-		 */
-	}
-}
-#endif
-
-/* This stops acquisition on ALL devices, ignoring device_index. */
 static void hw_stop_acquisition(int device_index, gpointer session_device_id)
 {
 	struct datafeed_packet packet;
 
-	/* QUICK HACK */
+	/* Avoid compiler warnings. */
 	device_index = device_index;
 
+	/* Send last packet. */
 	packet.type = DF_END;
 	session_bus(session_device_id, &packet);
-
-	/// receive_transfer(NULL);
-
-	/* TODO: Need to cancel and free any queued up transfers. */
 }
 
 struct device_plugin demo_plugin_info = {