hardware/demo/demo.c

   1 /*
   2  * This file is part of the sigrok project.
   3  *
   4  * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
   5  * Copyright (C) 2011 Olivier Fauchon <olivier@aixmarseille.com>
   6  * Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  21  */
  22
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #ifdef _WIN32
  27 #include <io.h>
  28 #include <fcntl.h>
  29 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
  30 #endif
  31 #include "libsigrok.h"
  32 #include "libsigrok-internal.h"
  33
  34 /* Message logging helpers with driver-specific prefix string. */
  35 #define DRIVER_LOG_DOMAIN "demo: "
  36 #define sr_log(l, s, args...) sr_log(l, DRIVER_LOG_DOMAIN s, ## args)
  37 #define sr_spew(s, args...) sr_spew(DRIVER_LOG_DOMAIN s, ## args)
  38 #define sr_dbg(s, args...) sr_dbg(DRIVER_LOG_DOMAIN s, ## args)
  39 #define sr_info(s, args...) sr_info(DRIVER_LOG_DOMAIN s, ## args)
  40 #define sr_warn(s, args...) sr_warn(DRIVER_LOG_DOMAIN s, ## args)
  41 #define sr_err(s, args...) sr_err(DRIVER_LOG_DOMAIN s, ## args)
  42
  43 /* TODO: Number of probes should be configurable. */
  44 #define NUM_PROBES             8
  45
  46 #define DEMONAME               "Demo device"
  47
  48 /* The size of chunks to send through the session bus. */
  49 /* TODO: Should be configurable. */
  50 #define BUFSIZE                4096
  51
  52 #define STR_PATTERN_SIGROK   "sigrok"
  53 #define STR_PATTERN_RANDOM   "random"
  54 #define STR_PATTERN_INC      "incremental"
  55 #define STR_PATTERN_ALL_LOW  "all-low"
  56 #define STR_PATTERN_ALL_HIGH "all-high"
  57
  58 /* Supported patterns which we can generate */
  59 enum {
  60         /**
  61          * Pattern which spells "sigrok" using '0's (with '1's as "background")
  62          * when displayed using the 'bits' output format.
  63          */
  64         PATTERN_SIGROK,
  65
  66         /** Pattern which consists of (pseudo-)random values on all probes. */
  67         PATTERN_RANDOM,
  68
  69         /**
  70          * Pattern which consists of incrementing numbers.
  71          * TODO: Better description.
  72          */
  73         PATTERN_INC,
  74
  75         /** Pattern where all probes have a low logic state. */
  76         PATTERN_ALL_LOW,
  77
  78         /** Pattern where all probes have a high logic state. */
  79         PATTERN_ALL_HIGH,
  80 };
  81
  82 /* Private, per-device-instance driver context. */
  83 struct dev_context {
  84         struct sr_dev_inst *sdi;
  85         int pipe_fds[2];
  86         GIOChannel *channel;
  87         uint8_t sample_generator;
  88         uint64_t samples_counter;
  89         void *cb_data;
  90         int64_t starttime;
  91 };
  92
  93 static const int hwcaps[] = {
  94         SR_CONF_LOGIC_ANALYZER,
  95         SR_CONF_DEMO_DEV,
  96         SR_CONF_SAMPLERATE,
  97         SR_CONF_PATTERN_MODE,
  98         SR_CONF_LIMIT_SAMPLES,
  99         SR_CONF_LIMIT_MSEC,
 100         SR_CONF_CONTINUOUS,
 101 };
 102
 103 static const uint64_t samplerates[] = {
 104         SR_HZ(1),
 105         SR_GHZ(1),
 106         SR_HZ(1),
 107 };
 108
 109 static const char *pattern_strings[] = {
 110         "sigrok",
 111         "random",
 112         "incremental",
 113         "all-low",
 114         "all-high",
 115 };
 116
 117 /* We name the probes 0-7 on our demo driver. */
 118 static const char *probe_names[NUM_PROBES + 1] = {
 119         "0", "1", "2", "3", "4", "5", "6", "7",
 120         NULL,
 121 };
 122
 123 static uint8_t pattern_sigrok[] = {
 124         0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
 125         0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
 126         0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
 127         0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
 128         0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
 129         0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
 130         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 131         0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 132 };
 133
 134 /* Private, per-device-instance driver context. */
 135 /* TODO: struct context as with the other drivers. */
 136
 137 /* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
 138 SR_PRIV struct sr_dev_driver demo_driver_info;
 139 static struct sr_dev_driver *di = &demo_driver_info;
 140 static uint64_t cur_samplerate = SR_KHZ(200);
 141 static uint64_t limit_samples = 0;
 142 static uint64_t limit_msec = 0;
 143 static int default_pattern = PATTERN_SIGROK;
 144
 145 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
 146
 147 static int clear_instances(void)
 148 {
 149         /* Nothing needed so far. */
 150
 151         return SR_OK;
 152 }
 153
 154 static int hw_init(struct sr_context *sr_ctx)
 155 {
 156         return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
 157 }
 158
 159 static GSList *hw_scan(GSList *options)
 160 {
 161         struct sr_dev_inst *sdi;
 162         struct sr_probe *probe;
 163         struct drv_context *drvc;
 164         struct dev_context *devc;
 165         GSList *devices;
 166         int i;
 167
 168         (void)options;
 169
 170         drvc = di->priv;
 171
 172         devices = NULL;
 173
 174         sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
 175         if (!sdi) {
 176                 sr_err("%s: sr_dev_inst_new failed", __func__);
 177                 return 0;
 178         }
 179         sdi->driver = di;
 180
 181         for (i = 0; probe_names[i]; i++) {
 182                 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
 183                                 probe_names[i])))
 184                         return NULL;
 185                 sdi->probes = g_slist_append(sdi->probes, probe);
 186         }
 187
 188         devices = g_slist_append(devices, sdi);
 189         drvc->instances = g_slist_append(drvc->instances, sdi);
 190
 191         /* TODO: 'devc' is never g_free()'d? */
 192         if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
 193                 sr_err("%s: devc malloc failed", __func__);
 194                 return SR_ERR_MALLOC;
 195         }
 196
 197         devc->sdi = sdi;
 198
 199         sdi->priv = devc;
 200
 201         return devices;
 202 }
 203
 204 static GSList *hw_dev_list(void)
 205 {
 206         return ((struct drv_context *)(di->priv))->instances;
 207 }
 208
 209 static int hw_dev_open(struct sr_dev_inst *sdi)
 210 {
 211         (void)sdi;
 212
 213         /* Nothing needed so far. */
 214
 215         return SR_OK;
 216 }
 217
 218 static int hw_dev_close(struct sr_dev_inst *sdi)
 219 {
 220         (void)sdi;
 221
 222         /* Nothing needed so far. */
 223
 224         return SR_OK;
 225 }
 226
 227 static int hw_cleanup(void)
 228 {
 229         /* Nothing needed so far. */
 230         return SR_OK;
 231 }
 232
 233 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
 234 {
 235         (void)sdi;
 236
 237         switch (id) {
 238         case SR_CONF_SAMPLERATE:
 239                 *data = g_variant_new_uint64(cur_samplerate);
 240                 break;
 241         case SR_CONF_LIMIT_SAMPLES:
 242                 *data = g_variant_new_uint64(limit_samples);
 243                 break;
 244         case SR_CONF_LIMIT_MSEC:
 245                 *data = g_variant_new_uint64(limit_msec);
 246                 break;
 247         case SR_CONF_PATTERN_MODE:
 248                 switch (default_pattern) {
 249                 case PATTERN_SIGROK:
 250                         *data = g_variant_new_string(STR_PATTERN_SIGROK);
 251                         break;
 252                 case PATTERN_RANDOM:
 253                         *data = g_variant_new_string(STR_PATTERN_RANDOM);
 254                         break;
 255                 case PATTERN_INC:
 256                         *data = g_variant_new_string(STR_PATTERN_INC);
 257                         break;
 258                 case PATTERN_ALL_LOW:
 259                         *data = g_variant_new_string(STR_PATTERN_ALL_LOW);
 260                         break;
 261                 case PATTERN_ALL_HIGH:
 262                         *data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
 263                         break;
 264                 }
 265                 break;
 266         default:
 267                 return SR_ERR_ARG;
 268         }
 269
 270         return SR_OK;
 271 }
 272
 273 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
 274 {
 275         int ret;
 276         const char *stropt;
 277
 278         (void)sdi;
 279
 280         if (id == SR_CONF_SAMPLERATE) {
 281                 cur_samplerate = g_variant_get_uint64(data);
 282                 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
 283                        cur_samplerate);
 284                 ret = SR_OK;
 285         } else if (id == SR_CONF_LIMIT_SAMPLES) {
 286                 limit_msec = 0;
 287                 limit_samples = g_variant_get_uint64(data);
 288                 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
 289                        limit_samples);
 290                 ret = SR_OK;
 291         } else if (id == SR_CONF_LIMIT_MSEC) {
 292                 limit_msec = g_variant_get_uint64(data);
 293                 limit_samples = 0;
 294                 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
 295                        limit_msec);
 296                 ret = SR_OK;
 297         } else if (id == SR_CONF_PATTERN_MODE) {
 298                 stropt = g_variant_get_string(data, NULL);
 299                 ret = SR_OK;
 300                 if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
 301                         default_pattern = PATTERN_SIGROK;
 302                 } else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
 303                         default_pattern = PATTERN_RANDOM;
 304                 } else if (!strcmp(stropt, STR_PATTERN_INC)) {
 305                         default_pattern = PATTERN_INC;
 306                 } else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
 307                         default_pattern = PATTERN_ALL_LOW;
 308                 } else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
 309                         default_pattern = PATTERN_ALL_HIGH;
 310                 } else {
 311                         ret = SR_ERR;
 312                 }
 313                 sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
 314         } else {
 315                 ret = SR_ERR;
 316         }
 317
 318         return ret;
 319 }
 320
 321 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
 322 {
 323         GVariant *gvar;
 324         GVariantBuilder gvb;
 325
 326         (void)sdi;
 327
 328         switch (key) {
 329         case SR_CONF_DEVICE_OPTIONS:
 330                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 331                                 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
 332                 break;
 333         case SR_CONF_SAMPLERATE:
 334                 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 335                 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 336                                 ARRAY_SIZE(samplerates), sizeof(uint64_t));
 337                 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 338                 *data = g_variant_builder_end(&gvb);
 339                 break;
 340         case SR_CONF_PATTERN_MODE:
 341                 *data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
 342                 break;
 343         default:
 344                 return SR_ERR_ARG;
 345         }
 346
 347         return SR_OK;
 348 }
 349
 350 static void samples_generator(uint8_t *buf, uint64_t size,
 351                               struct dev_context *devc)
 352 {
 353         static uint64_t p = 0;
 354         uint64_t i;
 355
 356         /* TODO: Needed? */
 357         memset(buf, 0, size);
 358
 359         switch (devc->sample_generator) {
 360         case PATTERN_SIGROK: /* sigrok pattern */
 361                 for (i = 0; i < size; i++) {
 362                         *(buf + i) = ~(pattern_sigrok[
 363                                 p++ % sizeof(pattern_sigrok)] >> 1);
 364                 }
 365                 break;
 366         case PATTERN_RANDOM: /* Random */
 367                 for (i = 0; i < size; i++)
 368                         *(buf + i) = (uint8_t)(rand() & 0xff);
 369                 break;
 370         case PATTERN_INC: /* Simple increment */
 371                 for (i = 0; i < size; i++)
 372                         *(buf + i) = p++;
 373                 break;
 374         case PATTERN_ALL_LOW: /* All probes are low */
 375                 memset(buf, 0x00, size);
 376                 break;
 377         case PATTERN_ALL_HIGH: /* All probes are high */
 378                 memset(buf, 0xff, size);
 379                 break;
 380         default:
 381                 sr_err("Unknown pattern: %d.", devc->sample_generator);
 382                 break;
 383         }
 384 }
 385
 386 /* Callback handling data */
 387 static int receive_data(int fd, int revents, void *cb_data)
 388 {
 389         struct dev_context *devc = cb_data;
 390         struct sr_datafeed_packet packet;
 391         struct sr_datafeed_logic logic;
 392         uint8_t buf[BUFSIZE];
 393         static uint64_t samples_to_send, expected_samplenum, sending_now;
 394         int64_t time, elapsed;
 395
 396         (void)fd;
 397         (void)revents;
 398
 399         /* How many "virtual" samples should we have collected by now? */
 400         time = g_get_monotonic_time();
 401         elapsed = time - devc->starttime;
 402         expected_samplenum = elapsed * cur_samplerate / 1000000;
 403         /* Of those, how many do we still have to send? */
 404         samples_to_send = expected_samplenum - devc->samples_counter;
 405
 406         if (limit_samples) {
 407                 samples_to_send = MIN(samples_to_send,
 408                                  limit_samples - devc->samples_counter);
 409         }
 410
 411         while (samples_to_send > 0) {
 412                 sending_now = MIN(samples_to_send, sizeof(buf));
 413                 samples_to_send -= sending_now;
 414                 samples_generator(buf, sending_now, devc);
 415
 416                 packet.type = SR_DF_LOGIC;
 417                 packet.payload = &logic;
 418                 logic.length = sending_now;
 419                 logic.unitsize = 1;
 420                 logic.data = buf;
 421                 sr_session_send(devc->cb_data, &packet);
 422                 devc->samples_counter += sending_now;
 423         }
 424
 425         if (limit_samples && devc->samples_counter >= limit_samples) {
 426                 sr_info("Requested number of samples reached.");
 427                 hw_dev_acquisition_stop(devc->sdi, cb_data);
 428                 return TRUE;
 429         }
 430
 431         return TRUE;
 432 }
 433
 434 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 435                 void *cb_data)
 436 {
 437         struct dev_context *const devc = sdi->priv;
 438
 439         devc->sample_generator = default_pattern;
 440         devc->cb_data = cb_data;
 441         devc->samples_counter = 0;
 442
 443         /*
 444          * Setting two channels connected by a pipe is a remnant from when the
 445          * demo driver generated data in a thread, and collected and sent the
 446          * data in the main program loop.
 447          * They are kept here because it provides a convenient way of setting
 448          * up a timeout-based polling mechanism.
 449          */
 450         if (pipe(devc->pipe_fds)) {
 451                 /* TODO: Better error message. */
 452                 sr_err("%s: pipe() failed", __func__);
 453                 return SR_ERR;
 454         }
 455
 456         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 457
 458         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 459
 460         /* Set channel encoding to binary (default is UTF-8). */
 461         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 462
 463         /* Make channels to unbuffered. */
 464         g_io_channel_set_buffered(devc->channel, FALSE);
 465
 466         sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
 467                     40, receive_data, devc);
 468
 469         /* Send header packet to the session bus. */
 470         std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
 471
 472         /* We use this timestamp to decide how many more samples to send. */
 473         devc->starttime = g_get_monotonic_time();
 474
 475         return SR_OK;
 476 }
 477
 478 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 479 {
 480         struct dev_context *const devc = sdi->priv;
 481         struct sr_datafeed_packet packet;
 482
 483         (void)cb_data;
 484
 485         sr_dbg("Stopping aquisition.");
 486
 487         sr_session_source_remove_channel(devc->channel);
 488         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 489
 490         /* Send last packet. */
 491         packet.type = SR_DF_END;
 492         sr_session_send(devc->cb_data, &packet);
 493
 494         return SR_OK;
 495 }
 496
 497 SR_PRIV struct sr_dev_driver demo_driver_info = {
 498         .name = "demo",
 499         .longname = "Demo driver and pattern generator",
 500         .api_version = 1,
 501         .init = hw_init,
 502         .cleanup = hw_cleanup,
 503         .scan = hw_scan,
 504         .dev_list = hw_dev_list,
 505         .dev_clear = clear_instances,
 506         .config_get = config_get,
 507         .config_set = config_set,
 508         .config_list = config_list,
 509         .dev_open = hw_dev_open,
 510         .dev_close = hw_dev_close,
 511         .dev_acquisition_start = hw_dev_acquisition_start,
 512         .dev_acquisition_stop = hw_dev_acquisition_stop,
 513         .priv = NULL,
 514 };