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  *
   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.
  11  *
  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.
  16  *
  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
  20  */
  21
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include <string.h>
  25 #ifdef _WIN32
  26 #include <io.h>
  27 #include <fcntl.h>
  28 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
  29 #endif
  30 #include "libsigrok.h"
  31 #include "libsigrok-internal.h"
  32
  33 /* TODO: Number of probes should be configurable. */
  34 #define NUM_PROBES             8
  35
  36 #define DEMONAME               "Demo device"
  37
  38 /* The size of chunks to send through the session bus. */
  39 /* TODO: Should be configurable. */
  40 #define BUFSIZE                4096
  41
  42 /* Supported patterns which we can generate */
  43 enum {
  44         /**
  45          * Pattern which spells "sigrok" using '0's (with '1's as "background")
  46          * when displayed using the 'bits' output format.
  47          */
  48         PATTERN_SIGROK,
  49
  50         /** Pattern which consists of (pseudo-)random values on all probes. */
  51         PATTERN_RANDOM,
  52
  53         /**
  54          * Pattern which consists of incrementing numbers.
  55          * TODO: Better description.
  56          */
  57         PATTERN_INC,
  58
  59         /** Pattern where all probes have a low logic state. */
  60         PATTERN_ALL_LOW,
  61
  62         /** Pattern where all probes have a high logic state. */
  63         PATTERN_ALL_HIGH,
  64 };
  65
  66 /* FIXME: Should not be global. */
  67
  68 struct context {
  69         int pipe_fds[2];
  70         GIOChannel *channels[2];
  71         uint8_t sample_generator;
  72         uint8_t thread_running;
  73         uint64_t samples_counter;
  74         void *session_dev_id;
  75         GTimer *timer;
  76 };
  77
  78 static const int hwcaps[] = {
  79         SR_HWCAP_LOGIC_ANALYZER,
  80         SR_HWCAP_DEMO_DEV,
  81         SR_HWCAP_SAMPLERATE,
  82         SR_HWCAP_PATTERN_MODE,
  83         SR_HWCAP_LIMIT_SAMPLES,
  84         SR_HWCAP_LIMIT_MSEC,
  85         SR_HWCAP_CONTINUOUS,
  86 };
  87
  88 static const struct sr_samplerates samplerates = {
  89         SR_HZ(1),
  90         SR_GHZ(1),
  91         SR_HZ(1),
  92         NULL,
  93 };
  94
  95 static const char *pattern_strings[] = {
  96         "sigrok",
  97         "random",
  98         "incremental",
  99         "all-low",
 100         "all-high",
 101         NULL,
 102 };
 103
 104 /* We name the probes 0-7 on our demo driver. */
 105 static const char *probe_names[NUM_PROBES + 1] = {
 106         "0",
 107         "1",
 108         "2",
 109         "3",
 110         "4",
 111         "5",
 112         "6",
 113         "7",
 114         NULL,
 115 };
 116
 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,
 126 };
 127
 128 /* Private, per-device-instance driver context. */
 129 /* TODO: struct context as with the other drivers. */
 130
 131 /* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
 132 SR_PRIV struct sr_dev_driver demo_driver_info;
 133 static struct sr_dev_driver *ddi = &demo_driver_info;
 134 static uint64_t cur_samplerate = SR_KHZ(200);
 135 static uint64_t limit_samples = 0;
 136 static uint64_t limit_msec = 0;
 137 static int default_pattern = PATTERN_SIGROK;
 138 static GThread *my_thread;
 139 static int thread_running;
 140
 141 static int hw_dev_acquisition_stop(const struct sr_dev_inst *sdi,
 142                 void *cb_data);
 143
 144 static int hw_init(void)
 145 {
 146
 147         /* Nothing to do. */
 148
 149         return SR_OK;
 150 }
 151
 152 static GSList *hw_scan(GSList *options)
 153 {
 154         struct sr_dev_inst *sdi;
 155         struct sr_probe *probe;
 156         GSList *devices;
 157         int i;
 158
 159         (void)options;
 160         devices = NULL;
 161
 162         sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
 163         if (!sdi) {
 164                 sr_err("demo: %s: sr_dev_inst_new failed", __func__);
 165                 return 0;
 166         }
 167         sdi->driver = ddi;
 168
 169         for (i = 0; probe_names[i]; i++) {
 170                 if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
 171                                 probe_names[i])))
 172                         return NULL;
 173                 sdi->probes = g_slist_append(sdi->probes, probe);
 174         }
 175
 176         devices = g_slist_append(devices, sdi);
 177         ddi->instances = g_slist_append(ddi->instances, sdi);
 178
 179         return devices;
 180 }
 181
 182 static int hw_dev_open(struct sr_dev_inst *sdi)
 183 {
 184         /* Avoid compiler warnings. */
 185         (void)sdi;
 186
 187         /* Nothing needed so far. */
 188
 189         return SR_OK;
 190 }
 191
 192 static int hw_dev_close(struct sr_dev_inst *sdi)
 193 {
 194         /* Avoid compiler warnings. */
 195         (void)sdi;
 196
 197         /* Nothing needed so far. */
 198
 199         return SR_OK;
 200 }
 201
 202 static int hw_cleanup(void)
 203 {
 204         /* Nothing needed so far. */
 205         return SR_OK;
 206 }
 207
 208 static int hw_info_get(int info_id, const void **data,
 209        const struct sr_dev_inst *sdi)
 210 {
 211
 212         switch (info_id) {
 213         case SR_DI_INST:
 214                 *data = sdi;
 215                 break;
 216         case SR_DI_HWCAPS:
 217                 *data = hwcaps;
 218                 break;
 219         case SR_DI_NUM_PROBES:
 220                 *data = GINT_TO_POINTER(NUM_PROBES);
 221                 break;
 222         case SR_DI_PROBE_NAMES:
 223                 *data = probe_names;
 224                 break;
 225         case SR_DI_SAMPLERATES:
 226                 *data = &samplerates;
 227                 break;
 228         case SR_DI_CUR_SAMPLERATE:
 229                 *data = &cur_samplerate;
 230                 break;
 231         case SR_DI_PATTERNS:
 232                 *data = &pattern_strings;
 233                 break;
 234         default:
 235                 return SR_ERR_ARG;
 236         }
 237
 238         return SR_OK;
 239 }
 240
 241 static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
 242                 const void *value)
 243 {
 244         int ret;
 245         const char *stropt;
 246
 247         (void)sdi;
 248
 249         if (hwcap == SR_HWCAP_PROBECONFIG) {
 250                 /* Nothing to do, but must be supported */
 251                 ret = SR_OK;
 252         } else if (hwcap == SR_HWCAP_SAMPLERATE) {
 253                 cur_samplerate = *(const uint64_t *)value;
 254                 sr_dbg("demo: %s: setting samplerate to %" PRIu64, __func__,
 255                        cur_samplerate);
 256                 ret = SR_OK;
 257         } else if (hwcap == SR_HWCAP_LIMIT_SAMPLES) {
 258                 limit_msec = 0;
 259                 limit_samples = *(const uint64_t *)value;
 260                 sr_dbg("demo: %s: setting limit_samples to %" PRIu64, __func__,
 261                        limit_samples);
 262                 ret = SR_OK;
 263         } else if (hwcap == SR_HWCAP_LIMIT_MSEC) {
 264                 limit_msec = *(const uint64_t *)value;
 265                 limit_samples = 0;
 266                 sr_dbg("demo: %s: setting limit_msec to %" PRIu64, __func__,
 267                        limit_msec);
 268                 ret = SR_OK;
 269         } else if (hwcap == SR_HWCAP_PATTERN_MODE) {
 270                 stropt = value;
 271                 ret = SR_OK;
 272                 if (!strcmp(stropt, "sigrok")) {
 273                         default_pattern = PATTERN_SIGROK;
 274                 } else if (!strcmp(stropt, "random")) {
 275                         default_pattern = PATTERN_RANDOM;
 276                 } else if (!strcmp(stropt, "incremental")) {
 277                         default_pattern = PATTERN_INC;
 278                 } else if (!strcmp(stropt, "all-low")) {
 279                         default_pattern = PATTERN_ALL_LOW;
 280                 } else if (!strcmp(stropt, "all-high")) {
 281                         default_pattern = PATTERN_ALL_HIGH;
 282                 } else {
 283                         ret = SR_ERR;
 284                 }
 285                 sr_dbg("demo: %s: setting pattern to %d", __func__,
 286                        default_pattern);
 287         } else {
 288                 ret = SR_ERR;
 289         }
 290
 291         return ret;
 292 }
 293
 294 static void samples_generator(uint8_t *buf, uint64_t size, void *data)
 295 {
 296         static uint64_t p = 0;
 297         struct context *ctx = data;
 298         uint64_t i;
 299
 300         /* TODO: Needed? */
 301         memset(buf, 0, size);
 302
 303         switch (ctx->sample_generator) {
 304         case PATTERN_SIGROK: /* sigrok pattern */
 305                 for (i = 0; i < size; i++) {
 306                         *(buf + i) = ~(pattern_sigrok[p] >> 1);
 307                         if (++p == 64)
 308                                 p = 0;
 309                 }
 310                 break;
 311         case PATTERN_RANDOM: /* Random */
 312                 for (i = 0; i < size; i++)
 313                         *(buf + i) = (uint8_t)(rand() & 0xff);
 314                 break;
 315         case PATTERN_INC: /* Simple increment */
 316                 for (i = 0; i < size; i++)
 317                         *(buf + i) = i;
 318                 break;
 319         case PATTERN_ALL_LOW: /* All probes are low */
 320                 memset(buf, 0x00, size);
 321                 break;
 322         case PATTERN_ALL_HIGH: /* All probes are high */
 323                 memset(buf, 0xff, size);
 324                 break;
 325         default:
 326                 sr_err("demo: %s: unknown pattern %d", __func__,
 327                        ctx->sample_generator);
 328                 break;
 329         }
 330 }
 331
 332 /* Thread function */
 333 static void thread_func(void *data)
 334 {
 335         struct context *ctx = data;
 336         uint8_t buf[BUFSIZE];
 337         uint64_t nb_to_send = 0;
 338         int bytes_written;
 339         double time_cur, time_last, time_diff;
 340
 341         time_last = g_timer_elapsed(ctx->timer, NULL);
 342
 343         while (thread_running) {
 344                 /* Rate control */
 345                 time_cur = g_timer_elapsed(ctx->timer, NULL);
 346
 347                 time_diff = time_cur - time_last;
 348                 time_last = time_cur;
 349
 350                 nb_to_send = cur_samplerate * time_diff;
 351
 352                 if (limit_samples) {
 353                         nb_to_send = MIN(nb_to_send,
 354                                       limit_samples - ctx->samples_counter);
 355                 }
 356
 357                 /* Make sure we don't overflow. */
 358                 nb_to_send = MIN(nb_to_send, BUFSIZE);
 359
 360                 if (nb_to_send) {
 361                         samples_generator(buf, nb_to_send, data);
 362                         ctx->samples_counter += nb_to_send;
 363
 364                         g_io_channel_write_chars(ctx->channels[1], (gchar *)&buf,
 365                                 nb_to_send, (gsize *)&bytes_written, NULL);
 366                 }
 367
 368                 /* Check if we're done. */
 369                 if ((limit_msec && time_cur * 1000 > limit_msec) ||
 370                     (limit_samples && ctx->samples_counter >= limit_samples))
 371                 {
 372                         close(ctx->pipe_fds[1]);
 373                         thread_running = 0;
 374                 }
 375
 376                 g_usleep(10);
 377         }
 378 }
 379
 380 /* Callback handling data */
 381 static int receive_data(int fd, int revents, void *cb_data)
 382 {
 383         struct context *ctx = cb_data;
 384         struct sr_datafeed_packet packet;
 385         struct sr_datafeed_logic logic;
 386         static uint64_t samples_received = 0;
 387         unsigned char c[BUFSIZE];
 388         gsize z;
 389
 390         /* Avoid compiler warnings. */
 391         (void)fd;
 392         (void)revents;
 393
 394         do {
 395                 g_io_channel_read_chars(ctx->channels[0],
 396                                         (gchar *)&c, BUFSIZE, &z, NULL);
 397
 398                 if (z > 0) {
 399                         packet.type = SR_DF_LOGIC;
 400                         packet.payload = &logic;
 401                         logic.length = z;
 402                         logic.unitsize = 1;
 403                         logic.data = c;
 404                         sr_session_send(ctx->session_dev_id, &packet);
 405                         samples_received += z;
 406                 }
 407         } while (z > 0);
 408
 409         if (!thread_running && z <= 0) {
 410                 /* Make sure we don't receive more packets. */
 411                 g_io_channel_shutdown(ctx->channels[0], FALSE, NULL);
 412
 413                 /* Send last packet. */
 414                 packet.type = SR_DF_END;
 415                 sr_session_send(ctx->session_dev_id, &packet);
 416
 417                 return FALSE;
 418         }
 419
 420         return TRUE;
 421 }
 422
 423 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 424                 void *cb_data)
 425 {
 426         struct sr_datafeed_packet *packet;
 427         struct sr_datafeed_header *header;
 428         struct sr_datafeed_meta_logic meta;
 429         struct context *ctx;
 430
 431         (void)sdi;
 432
 433         /* TODO: 'ctx' is never g_free()'d? */
 434         if (!(ctx = g_try_malloc(sizeof(struct context)))) {
 435                 sr_err("demo: %s: ctx malloc failed", __func__);
 436                 return SR_ERR_MALLOC;
 437         }
 438
 439         ctx->sample_generator = default_pattern;
 440         ctx->session_dev_id = cb_data;
 441         ctx->samples_counter = 0;
 442
 443         if (pipe(ctx->pipe_fds)) {
 444                 /* TODO: Better error message. */
 445                 sr_err("demo: %s: pipe() failed", __func__);
 446                 return SR_ERR;
 447         }
 448
 449         ctx->channels[0] = g_io_channel_unix_new(ctx->pipe_fds[0]);
 450         ctx->channels[1] = g_io_channel_unix_new(ctx->pipe_fds[1]);
 451
 452         g_io_channel_set_flags(ctx->channels[0], G_IO_FLAG_NONBLOCK, NULL);
 453
 454         /* Set channel encoding to binary (default is UTF-8). */
 455         g_io_channel_set_encoding(ctx->channels[0], NULL, NULL);
 456         g_io_channel_set_encoding(ctx->channels[1], NULL, NULL);
 457
 458         /* Make channels to unbuffered. */
 459         g_io_channel_set_buffered(ctx->channels[0], FALSE);
 460         g_io_channel_set_buffered(ctx->channels[1], FALSE);
 461
 462         sr_session_source_add_channel(ctx->channels[0], G_IO_IN | G_IO_ERR,
 463                     40, receive_data, ctx);
 464
 465         /* Run the demo thread. */
 466         g_thread_init(NULL);
 467         /* This must to be done between g_thread_init() & g_thread_create(). */
 468         ctx->timer = g_timer_new();
 469         thread_running = 1;
 470         my_thread =
 471             g_thread_create((GThreadFunc)thread_func, ctx, TRUE, NULL);
 472         if (!my_thread) {
 473                 sr_err("demo: %s: g_thread_create failed", __func__);
 474                 return SR_ERR; /* TODO */
 475         }
 476
 477         if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
 478                 sr_err("demo: %s: packet malloc failed", __func__);
 479                 return SR_ERR_MALLOC;
 480         }
 481
 482         if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
 483                 sr_err("demo: %s: header malloc failed", __func__);
 484                 return SR_ERR_MALLOC;
 485         }
 486
 487         packet->type = SR_DF_HEADER;
 488         packet->payload = header;
 489         header->feed_version = 1;
 490         gettimeofday(&header->starttime, NULL);
 491         sr_session_send(ctx->session_dev_id, packet);
 492
 493         /* Send metadata about the SR_DF_LOGIC packets to come. */
 494         packet->type = SR_DF_META_LOGIC;
 495         packet->payload = &meta;
 496         meta.samplerate = cur_samplerate;
 497         meta.num_probes = NUM_PROBES;
 498         sr_session_send(ctx->session_dev_id, packet);
 499
 500         g_free(header);
 501         g_free(packet);
 502
 503         return SR_OK;
 504 }
 505
 506 static int hw_dev_acquisition_stop(const struct sr_dev_inst *sdi,
 507                 void *cb_data)
 508 {
 509         /* Avoid compiler warnings. */
 510         (void)sdi;
 511         (void)cb_data;
 512
 513         /* Stop generate thread. */
 514         thread_running = 0;
 515
 516         return SR_OK;
 517 }
 518
 519 SR_PRIV struct sr_dev_driver demo_driver_info = {
 520         .name = "demo",
 521         .longname = "Demo driver and pattern generator",
 522         .api_version = 1,
 523         .init = hw_init,
 524         .cleanup = hw_cleanup,
 525         .scan = hw_scan,
 526         .dev_open = hw_dev_open,
 527         .dev_close = hw_dev_close,
 528         .info_get = hw_info_get,
 529         .dev_config_set = hw_dev_config_set,
 530         .dev_acquisition_start = hw_dev_acquisition_start,
 531         .dev_acquisition_stop = hw_dev_acquisition_stop,
 532         .instances = NULL,
 533 };