2 * This file is part of the sigrok project.
4 * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
5 * Copyright (C) 2011 Olivier Fauchon <olivier@aixmarseille.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
28 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
31 #include "sigrok-internal.h"
33 /* TODO: Number of probes should be configurable. */
36 #define DEMONAME "Demo device"
38 /* The size of chunks to send through the session bus. */
39 /* TODO: Should be configurable. */
42 /* Supported patterns which we can generate */
45 * Pattern which spells "sigrok" using '0's (with '1's as "background")
46 * when displayed using the 'bits' output format.
50 /** Pattern which consists of (pseudo-)random values on all probes. */
54 * Pattern which consists of incrementing numbers.
55 * TODO: Better description.
59 /** Pattern where all probes have a low logic state. */
62 /** Pattern where all probes have a high logic state. */
66 /* FIXME: Should not be global. */
67 GIOChannel *channels[2];
71 uint8_t sample_generator;
72 uint8_t thread_running;
73 uint64_t samples_counter;
75 gpointer session_data;
79 static int capabilities[] = {
80 SR_HWCAP_LOGIC_ANALYZER,
83 SR_HWCAP_PATTERN_MODE,
84 SR_HWCAP_LIMIT_SAMPLES,
89 static struct sr_samplerates samplerates = {
96 static const char *pattern_strings[] = {
105 static const char *probe_names[NUM_PROBES + 1] = {
117 static uint8_t pattern_sigrok[] = {
118 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
119 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
120 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
121 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
122 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
123 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
124 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
125 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
128 /* List of struct sr_device_instance, maintained by opendev()/closedev(). */
129 static GSList *device_instances = NULL;
130 static uint64_t cur_samplerate = SR_KHZ(200);
131 static uint64_t limit_samples = 0;
132 static uint64_t limit_msec = 0;
133 static int default_pattern = PATTERN_SIGROK;
134 static GThread *my_thread;
135 static int thread_running;
137 static void hw_stop_acquisition(int device_index, gpointer session_data);
139 static int hw_init(const char *deviceinfo)
141 struct sr_device_instance *sdi;
143 /* Avoid compiler warnings. */
146 sdi = sr_device_instance_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
148 sr_err("demo: %s: sr_device_instance_new failed", __func__);
152 device_instances = g_slist_append(device_instances, sdi);
157 static int hw_opendev(int device_index)
159 /* Avoid compiler warnings. */
162 /* Nothing needed so far. */
167 static int hw_closedev(int device_index)
169 /* Avoid compiler warnings. */
172 /* Nothing needed so far. */
177 static void hw_cleanup(void)
179 /* Nothing needed so far. */
182 static void *hw_get_device_info(int device_index, int device_info_id)
184 struct sr_device_instance *sdi;
187 if (!(sdi = sr_get_device_instance(device_instances, device_index))) {
188 sr_err("demo: %s: sdi was NULL", __func__);
192 switch (device_info_id) {
196 case SR_DI_NUM_PROBES:
197 info = GINT_TO_POINTER(NUM_PROBES);
199 case SR_DI_PROBE_NAMES:
202 case SR_DI_SAMPLERATES:
205 case SR_DI_CUR_SAMPLERATE:
206 info = &cur_samplerate;
208 case SR_DI_PATTERNMODES:
209 info = &pattern_strings;
216 static int hw_get_status(int device_index)
218 /* Avoid compiler warnings. */
224 static int *hw_get_capabilities(void)
229 static int hw_set_configuration(int device_index, int capability, void *value)
234 /* Avoid compiler warnings. */
237 if (capability == SR_HWCAP_PROBECONFIG) {
238 /* Nothing to do, but must be supported */
240 } else if (capability == SR_HWCAP_SAMPLERATE) {
241 cur_samplerate = *(uint64_t *)value;
242 sr_dbg("demo: %s: setting samplerate to %" PRIu64, __func__,
245 } else if (capability == SR_HWCAP_LIMIT_SAMPLES) {
246 limit_samples = *(uint64_t *)value;
247 sr_dbg("demo: %s: setting limit_samples to %" PRIu64, __func__,
250 } else if (capability == SR_HWCAP_LIMIT_MSEC) {
251 limit_msec = *(uint64_t *)value;
252 sr_dbg("demo: %s: setting limit_msec to %" PRIu64, __func__,
255 } else if (capability == SR_HWCAP_PATTERN_MODE) {
258 if (!strcmp(stropt, "sigrok")) {
259 default_pattern = PATTERN_SIGROK;
260 } else if (!strcmp(stropt, "random")) {
261 default_pattern = PATTERN_RANDOM;
262 } else if (!strcmp(stropt, "incremental")) {
263 default_pattern = PATTERN_INC;
264 } else if (!strcmp(stropt, "all-low")) {
265 default_pattern = PATTERN_ALL_LOW;
266 } else if (!strcmp(stropt, "all-high")) {
267 default_pattern = PATTERN_ALL_HIGH;
271 sr_dbg("demo: %s: setting pattern to %d", __func__,
280 static void samples_generator(uint8_t *buf, uint64_t size, void *data)
282 static uint64_t p = 0;
283 struct databag *mydata = data;
287 memset(buf, 0, size);
289 switch (mydata->sample_generator) {
290 case PATTERN_SIGROK: /* sigrok pattern */
291 for (i = 0; i < size; i++) {
292 *(buf + i) = ~(pattern_sigrok[p] >> 1);
297 case PATTERN_RANDOM: /* Random */
298 for (i = 0; i < size; i++)
299 *(buf + i) = (uint8_t)(rand() & 0xff);
301 case PATTERN_INC: /* Simple increment */
302 for (i = 0; i < size; i++)
305 case PATTERN_ALL_LOW: /* All probes are low */
306 memset(buf, 0x00, size);
308 case PATTERN_ALL_HIGH: /* All probes are high */
309 memset(buf, 0xff, size);
312 /* TODO: Error handling. */
317 /* Thread function */
318 static void thread_func(void *data)
320 struct databag *mydata = data;
321 uint8_t buf[BUFSIZE];
322 uint64_t nb_to_send = 0;
324 double time_cur, time_last, time_diff;
326 time_last = g_timer_elapsed(mydata->timer, NULL);
328 while (thread_running) {
330 time_cur = g_timer_elapsed(mydata->timer, NULL);
332 time_diff = time_cur - time_last;
333 time_last = time_cur;
335 nb_to_send = cur_samplerate * time_diff;
338 nb_to_send = MIN(nb_to_send,
339 limit_samples - mydata->samples_counter);
342 /* Make sure we don't overflow. */
343 nb_to_send = MIN(nb_to_send, BUFSIZE);
346 samples_generator(buf, nb_to_send, data);
347 mydata->samples_counter += nb_to_send;
349 g_io_channel_write_chars(channels[1], (gchar *)&buf,
350 nb_to_send, (gsize *)&bytes_written, NULL);
353 /* Check if we're done. */
354 if ((limit_msec && time_cur * 1000 > limit_msec) ||
355 (limit_samples && mydata->samples_counter >= limit_samples))
357 close(mydata->pipe_fds[1]);
365 /* Callback handling data */
366 static int receive_data(int fd, int revents, void *session_data)
368 struct sr_datafeed_packet packet;
369 struct sr_datafeed_logic logic;
370 static uint64_t samples_received = 0;
371 unsigned char c[BUFSIZE];
374 /* Avoid compiler warnings. */
379 g_io_channel_read_chars(channels[0],
380 (gchar *)&c, BUFSIZE, &z, NULL);
383 packet.type = SR_DF_LOGIC;
384 packet.payload = &logic;
388 sr_session_bus(session_data, &packet);
389 samples_received += z;
393 if (!thread_running && z <= 0) {
394 /* Make sure we don't receive more packets. */
395 g_io_channel_close(channels[0]);
397 /* Send last packet. */
398 packet.type = SR_DF_END;
399 sr_session_bus(session_data, &packet);
407 static int hw_start_acquisition(int device_index, gpointer session_data)
409 struct sr_datafeed_packet *packet;
410 struct sr_datafeed_header *header;
411 struct databag *mydata;
413 /* TODO: 'mydata' is never g_free()'d? */
414 if (!(mydata = g_try_malloc(sizeof(struct databag)))) {
415 sr_err("demo: %s: mydata malloc failed", __func__);
416 return SR_ERR_MALLOC;
419 mydata->sample_generator = default_pattern;
420 mydata->session_data = session_data;
421 mydata->device_index = device_index;
422 mydata->samples_counter = 0;
424 if (pipe(mydata->pipe_fds)) {
425 /* TODO: Better error message. */
426 sr_err("demo: %s: pipe() failed", __func__);
430 channels[0] = g_io_channel_unix_new(mydata->pipe_fds[0]);
431 channels[1] = g_io_channel_unix_new(mydata->pipe_fds[1]);
433 /* Set channel encoding to binary (default is UTF-8). */
434 g_io_channel_set_encoding(channels[0], NULL, NULL);
435 g_io_channel_set_encoding(channels[1], NULL, NULL);
437 /* Make channels to unbuffered. */
438 g_io_channel_set_buffered(channels[0], FALSE);
439 g_io_channel_set_buffered(channels[1], FALSE);
441 sr_source_add(mydata->pipe_fds[0], G_IO_IN | G_IO_ERR, 40,
442 receive_data, session_data);
444 /* Run the demo thread. */
446 /* This must to be done between g_thread_init() & g_thread_create(). */
447 mydata->timer = g_timer_new();
450 g_thread_create((GThreadFunc)thread_func, mydata, TRUE, NULL);
452 sr_err("demo: %s: g_thread_create failed", __func__);
453 return SR_ERR; /* TODO */
456 if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
457 sr_err("demo: %s: packet malloc failed", __func__);
458 return SR_ERR_MALLOC;
461 if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
462 sr_err("demo: %s: header malloc failed", __func__);
463 return SR_ERR_MALLOC;
466 packet->type = SR_DF_HEADER;
467 packet->payload = header;
468 header->feed_version = 1;
469 gettimeofday(&header->starttime, NULL);
470 header->samplerate = cur_samplerate;
471 header->num_logic_probes = NUM_PROBES;
472 header->num_analog_probes = 0;
473 sr_session_bus(session_data, packet);
480 static void hw_stop_acquisition(int device_index, gpointer session_data)
482 /* Avoid compiler warnings. */
486 /* Stop generate thread. */
490 struct sr_device_plugin demo_plugin_info = {
492 .longname = "Demo driver and pattern generator",
495 .cleanup = hw_cleanup,
496 .opendev = hw_opendev,
497 .closedev = hw_closedev,
498 .get_device_info = hw_get_device_info,
499 .get_status = hw_get_status,
500 .get_capabilities = hw_get_capabilities,
501 .set_configuration = hw_set_configuration,
502 .start_acquisition = hw_start_acquisition,
503 .stop_acquisition = hw_stop_acquisition,