hardware/demo/demo.c

   1 /*
   2  * This file is part of the libsigrok 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 #include <math.h>
  27 #ifdef _WIN32
  28 #include <io.h>
  29 #include <fcntl.h>
  30 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
  31 #endif
  32 #include "libsigrok.h"
  33 #include "libsigrok-internal.h"
  34
  35 #define LOG_PREFIX "demo"
  36
  37 #define DEFAULT_NUM_LOGIC_PROBES     8
  38 #define DEFAULT_NUM_ANALOG_PROBES    4
  39
  40 /* The size in bytes of chunks to send through the session bus. */
  41 #define LOGIC_BUFSIZE        4096
  42 /* Size of the analog pattern space per channel. */
  43 #define ANALOG_BUFSIZE       4096
  44
  45 #define ANALOG_AMPLITUDE 25
  46 #define ANALOG_SAMPLES_PER_PERIOD 20
  47
  48 /* Logic patterns we can generate. */
  49 enum {
  50         /**
  51          * Spells "sigrok" across 8 probes using '0's (with '1's as
  52          * "background") when displayed using the 'bits' output format.
  53          * The pattern is repeasted every 8 probes, shifted to the right
  54          * in time by one bit.
  55          */
  56         PATTERN_SIGROK,
  57
  58         /** Pseudo-random values on all probes. */
  59         PATTERN_RANDOM,
  60
  61         /**
  62          * Incrementing number across 8 probes. The pattern is repeasted
  63          * every 8 probes, shifted to the right in time by one bit.
  64          */
  65         PATTERN_INC,
  66
  67         /** All probes have a low logic state. */
  68         PATTERN_ALL_LOW,
  69
  70         /** All probes have a high logic state. */
  71         PATTERN_ALL_HIGH,
  72 };
  73
  74 /* Analog patterns we can generate. */
  75 enum {
  76         /**
  77          * Square wave.
  78          */
  79         PATTERN_SQUARE,
  80         PATTERN_SINE,
  81         PATTERN_TRIANGLE,
  82         PATTERN_SAWTOOTH,
  83 };
  84
  85 static const char *logic_pattern_str[] = {
  86         "sigrok",
  87         "random",
  88         "incremental",
  89         "all-low",
  90         "all-high",
  91 };
  92
  93 static const char *analog_pattern_str[] = {
  94         "square",
  95         "sine",
  96         "triangle",
  97         "sawtooth",
  98 };
  99
 100 struct analog_gen {
 101         int pattern;
 102         float pattern_data[ANALOG_BUFSIZE];
 103         unsigned int num_samples;
 104         struct sr_datafeed_analog packet;
 105 };
 106
 107 /* Private, per-device-instance driver context. */
 108 struct dev_context {
 109         int pipe_fds[2];
 110         GIOChannel *channel;
 111         uint64_t cur_samplerate;
 112         uint64_t limit_samples;
 113         uint64_t limit_msec;
 114         uint64_t samples_counter;
 115         int64_t starttime;
 116         uint64_t step;
 117         /* Logic */
 118         int32_t num_logic_probes;
 119         unsigned int logic_unitsize;
 120         /* There is only ever one logic probe group, so its pattern goes here. */
 121         uint8_t logic_pattern;
 122         unsigned char logic_data[LOGIC_BUFSIZE];
 123         /* Analog */
 124         int32_t num_analog_probes;
 125         GSList *analog_probe_groups;
 126 };
 127
 128 static const int32_t scanopts[] = {
 129         SR_CONF_NUM_LOGIC_PROBES,
 130         SR_CONF_NUM_ANALOG_PROBES,
 131 };
 132
 133 static const int devopts[] = {
 134         SR_CONF_LOGIC_ANALYZER,
 135         SR_CONF_DEMO_DEV,
 136         SR_CONF_SAMPLERATE,
 137         SR_CONF_LIMIT_SAMPLES,
 138         SR_CONF_LIMIT_MSEC,
 139 };
 140
 141 static const int devopts_pg[] = {
 142         SR_CONF_PATTERN_MODE,
 143 };
 144
 145 static const uint64_t samplerates[] = {
 146         SR_HZ(1),
 147         SR_GHZ(1),
 148         SR_HZ(1),
 149 };
 150
 151 static uint8_t pattern_sigrok[] = {
 152         0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
 153         0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
 154         0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
 155         0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
 156         0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
 157         0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
 158         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 159         0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 160 };
 161
 162 SR_PRIV struct sr_dev_driver demo_driver_info;
 163 static struct sr_dev_driver *di = &demo_driver_info;
 164
 165 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
 166
 167
 168 static int dev_clear(void)
 169 {
 170         return std_dev_clear(di, NULL);
 171 }
 172
 173 static int init(struct sr_context *sr_ctx)
 174 {
 175         return std_init(sr_ctx, di, LOG_PREFIX);
 176 }
 177
 178 static void generate_analog_pattern(const struct sr_probe_group *probe_group, uint64_t sample_rate)
 179 {
 180         struct analog_gen *ag;
 181         double t, frequency;
 182         float value;
 183         unsigned int num_samples, i;
 184         int last_end;
 185
 186         ag = probe_group->priv;
 187         num_samples = ANALOG_BUFSIZE / sizeof(float);
 188
 189         sr_dbg("Generating %s pattern for probe group %s",
 190                analog_pattern_str[ag->pattern],
 191                probe_group->name);
 192
 193         switch (ag->pattern) {
 194         case PATTERN_SQUARE:
 195                 value = ANALOG_AMPLITUDE;
 196                 last_end = 0;
 197                 for (i = 0; i < num_samples; i++) {
 198                         if (i % 5 == 0)
 199                                 value = -value;
 200                         if (i % 10 == 0)
 201                                 last_end = i - 1;
 202                         ag->pattern_data[i] = value;
 203                 }
 204                 ag->num_samples = last_end;
 205                 break;
 206
 207         case PATTERN_SINE:
 208                 frequency = sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 209
 210                 /* Make sure the number of samples we put out is an integer
 211                  * multiple of our period size */
 212                 /* FIXME we actually need only one period. A ringbuffer would be
 213                  * usefull here.*/
 214                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 215                         num_samples--;
 216
 217                 for (i = 0; i < num_samples; i++) {
 218                         t = (double) i / (double) sample_rate;
 219                         ag->pattern_data[i] = ANALOG_AMPLITUDE *
 220                                                 sin(2 * M_PI * frequency * t);
 221                 }
 222
 223                 ag->num_samples = num_samples;
 224                 break;
 225
 226         case PATTERN_TRIANGLE:
 227                 frequency = sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 228
 229                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 230                         num_samples--;
 231
 232                 for (i = 0; i < num_samples; i++) {
 233                         t = (double) i / (double) sample_rate;
 234                         ag->pattern_data[i] = (2 * ANALOG_AMPLITUDE / M_PI) *
 235                                                 asin(sin(2 * M_PI * frequency * t));
 236                 }
 237
 238                 ag->num_samples = num_samples;
 239                 break;
 240
 241         case PATTERN_SAWTOOTH:
 242                 frequency = sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 243
 244                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 245                         num_samples--;
 246
 247                 for (i = 0; i < num_samples; i++) {
 248                         t = (double) i / (double) sample_rate;
 249                         ag->pattern_data[i] = 2 * ANALOG_AMPLITUDE *
 250                                                 ((t * frequency) - floor(0.5f + t * frequency));
 251                 }
 252
 253                 ag->num_samples = num_samples;
 254                 break;
 255         }
 256 }
 257
 258 static GSList *scan(GSList *options)
 259 {
 260         struct drv_context *drvc;
 261         struct dev_context *devc;
 262         struct sr_dev_inst *sdi;
 263         struct sr_probe *probe;
 264         struct sr_probe_group *pg;
 265         struct sr_config *src;
 266         struct analog_gen *ag;
 267         GSList *devices, *l;
 268         int num_logic_probes, num_analog_probes, i;
 269         char probe_name[16];
 270
 271         drvc = di->priv;
 272
 273         num_logic_probes = DEFAULT_NUM_LOGIC_PROBES;
 274         num_analog_probes = DEFAULT_NUM_ANALOG_PROBES;
 275         for (l = options; l; l = l->next) {
 276                 src = l->data;
 277                 switch (src->key) {
 278                 case SR_CONF_NUM_LOGIC_PROBES:
 279                         num_logic_probes = g_variant_get_int32(src->data);
 280                         break;
 281                 case SR_CONF_NUM_ANALOG_PROBES:
 282                         num_analog_probes = g_variant_get_int32(src->data);
 283                         break;
 284                 }
 285         }
 286
 287         devices = NULL;
 288         sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
 289         if (!sdi) {
 290                 sr_err("Device instance creation failed.");
 291                 return NULL;
 292         }
 293         sdi->driver = di;
 294
 295         if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
 296                 sr_err("Device context malloc failed.");
 297                 return NULL;
 298         }
 299         devc->cur_samplerate = SR_KHZ(200);
 300         devc->limit_samples = 0;
 301         devc->limit_msec = 0;
 302         devc->step = 0;
 303         devc->num_logic_probes = num_logic_probes;
 304         devc->logic_unitsize = (devc->num_logic_probes + 7) / 8;
 305         devc->logic_pattern = PATTERN_SIGROK;
 306         devc->num_analog_probes = num_analog_probes;
 307         devc->analog_probe_groups = NULL;
 308
 309         /* Logic probes, all in one probe group. */
 310         if (!(pg = g_try_malloc(sizeof(struct sr_probe_group))))
 311                 return NULL;
 312         pg->name = g_strdup("Logic");
 313         pg->probes = NULL;
 314         pg->priv = NULL;
 315         for (i = 0; i < num_logic_probes; i++) {
 316                 sprintf(probe_name, "D%d", i);
 317                 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name)))
 318                         return NULL;
 319                 sdi->probes = g_slist_append(sdi->probes, probe);
 320                 pg->probes = g_slist_append(pg->probes, probe);
 321         }
 322         sdi->probe_groups = g_slist_append(NULL, pg);
 323
 324         /* Analog probes, probe groups and pattern generators. */
 325         for (i = 0; i < num_analog_probes; i++) {
 326                 sprintf(probe_name, "A%d", i);
 327                 if (!(probe = sr_probe_new(i + num_logic_probes,
 328                                 SR_PROBE_ANALOG, TRUE, probe_name)))
 329                         return NULL;
 330                 sdi->probes = g_slist_append(sdi->probes, probe);
 331
 332                 /* Every analog probe gets its own probe group. */
 333                 if (!(pg = g_try_malloc(sizeof(struct sr_probe_group))))
 334                         return NULL;
 335                 pg->name = g_strdup(probe_name);
 336                 pg->probes = g_slist_append(NULL, probe);
 337
 338                 /* Every probe group gets a generator struct. */
 339                 if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
 340                         return NULL;
 341                 ag->packet.probes = pg->probes;
 342                 ag->packet.mq = 0;
 343                 ag->packet.mqflags = 0;
 344                 ag->packet.unit = SR_UNIT_VOLT;
 345                 ag->packet.data = ag->pattern_data;
 346                 ag->pattern = PATTERN_SINE;
 347                 pg->priv = ag;
 348
 349                 sdi->probe_groups = g_slist_append(sdi->probe_groups, pg);
 350                 devc->analog_probe_groups = g_slist_append(devc->analog_probe_groups, pg);
 351         }
 352
 353         sdi->priv = devc;
 354         devices = g_slist_append(devices, sdi);
 355         drvc->instances = g_slist_append(drvc->instances, sdi);
 356
 357         return devices;
 358 }
 359
 360 static GSList *dev_list(void)
 361 {
 362         return ((struct drv_context *)(di->priv))->instances;
 363 }
 364
 365 static int dev_open(struct sr_dev_inst *sdi)
 366 {
 367         sdi->status = SR_ST_ACTIVE;
 368
 369         return SR_OK;
 370 }
 371
 372 static int dev_close(struct sr_dev_inst *sdi)
 373 {
 374         sdi->status = SR_ST_INACTIVE;
 375
 376         return SR_OK;
 377 }
 378
 379 static int cleanup(void)
 380 {
 381         return dev_clear();
 382 }
 383
 384 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
 385                 const struct sr_probe_group *probe_group)
 386 {
 387         struct dev_context *devc;
 388         struct sr_probe *probe;
 389         struct analog_gen *ag;
 390         int pattern;
 391
 392         if (!sdi)
 393                 return SR_ERR_ARG;
 394
 395         devc = sdi->priv;
 396         switch (id) {
 397         case SR_CONF_SAMPLERATE:
 398                 *data = g_variant_new_uint64(devc->cur_samplerate);
 399                 break;
 400         case SR_CONF_LIMIT_SAMPLES:
 401                 *data = g_variant_new_uint64(devc->limit_samples);
 402                 break;
 403         case SR_CONF_LIMIT_MSEC:
 404                 *data = g_variant_new_uint64(devc->limit_msec);
 405                 break;
 406         case SR_CONF_PATTERN_MODE:
 407                 if (!probe_group)
 408                         return SR_ERR_PROBE_GROUP;
 409                 probe = probe_group->probes->data;
 410                 if (probe->type == SR_PROBE_LOGIC) {
 411                         pattern = devc->logic_pattern;
 412                         *data = g_variant_new_string(logic_pattern_str[pattern]);
 413                 } else if (probe->type == SR_PROBE_ANALOG) {
 414                         ag = probe_group->priv;
 415                         pattern = ag->pattern;
 416                         *data = g_variant_new_string(analog_pattern_str[pattern]);
 417                 } else
 418                         return SR_ERR_BUG;
 419                 break;
 420         case SR_CONF_NUM_LOGIC_PROBES:
 421                 *data = g_variant_new_int32(devc->num_logic_probes);
 422                 break;
 423         case SR_CONF_NUM_ANALOG_PROBES:
 424                 *data = g_variant_new_int32(devc->num_analog_probes);
 425                 break;
 426         default:
 427                 return SR_ERR_NA;
 428         }
 429
 430         return SR_OK;
 431 }
 432
 433 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 434                 const struct sr_probe_group *probe_group)
 435 {
 436         struct dev_context *devc;
 437         struct analog_gen *ag;
 438         struct sr_probe *probe;
 439         int pattern, ret;
 440         unsigned int i;
 441         const char *stropt;
 442
 443         devc = sdi->priv;
 444
 445         if (sdi->status != SR_ST_ACTIVE)
 446                 return SR_ERR_DEV_CLOSED;
 447
 448         ret = SR_OK;
 449         switch (id) {
 450         case SR_CONF_SAMPLERATE:
 451                 devc->cur_samplerate = g_variant_get_uint64(data);
 452                 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
 453                 break;
 454         case SR_CONF_LIMIT_SAMPLES:
 455                 devc->limit_msec = 0;
 456                 devc->limit_samples = g_variant_get_uint64(data);
 457                 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
 458                 break;
 459         case SR_CONF_LIMIT_MSEC:
 460                 devc->limit_msec = g_variant_get_uint64(data);
 461                 devc->limit_samples = 0;
 462                 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
 463                 break;
 464         case SR_CONF_PATTERN_MODE:
 465                 if (!probe_group)
 466                         return SR_ERR_PROBE_GROUP;
 467                 stropt = g_variant_get_string(data, NULL);
 468                 probe = probe_group->probes->data;
 469                 pattern = -1;
 470                 if (probe->type == SR_PROBE_LOGIC) {
 471                         for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
 472                                 if (!strcmp(stropt, logic_pattern_str[i])) {
 473                                         pattern = i;
 474                                         break;
 475                                 }
 476                         }
 477                         if (pattern == -1)
 478                                 return SR_ERR_ARG;
 479                         devc->logic_pattern = pattern;
 480
 481                         /* Might as well do this now, these are static. */
 482                         if (pattern == PATTERN_ALL_LOW)
 483                                 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
 484                         else if (pattern == PATTERN_ALL_HIGH)
 485                                 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
 486                         sr_dbg("Setting logic pattern to %s",
 487                                         logic_pattern_str[pattern]);
 488                 } else if (probe->type == SR_PROBE_ANALOG) {
 489                         for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
 490                                 if (!strcmp(stropt, analog_pattern_str[i])) {
 491                                         pattern = i;
 492                                         break;
 493                                 }
 494                         }
 495                         if (pattern == -1)
 496                                 return SR_ERR_ARG;
 497                         sr_dbg("Setting analog pattern for probe group %s to %s",
 498                                         probe_group->name,
 499                                         analog_pattern_str[pattern]);
 500                         ag = probe_group->priv;
 501                         ag->pattern = pattern;
 502                 } else
 503                         return SR_ERR_BUG;
 504                 break;
 505         default:
 506                 ret = SR_ERR_NA;
 507         }
 508
 509         return ret;
 510 }
 511
 512 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
 513                 const struct sr_probe_group *probe_group)
 514 {
 515         struct sr_probe *probe;
 516         GVariant *gvar;
 517         GVariantBuilder gvb;
 518
 519         (void)sdi;
 520
 521         if (key == SR_CONF_SCAN_OPTIONS) {
 522                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 523                                 scanopts, ARRAY_SIZE(scanopts), sizeof(int32_t));
 524                 return SR_OK;
 525         }
 526
 527         if (!sdi)
 528                 return SR_ERR_ARG;
 529
 530         if (!probe_group) {
 531                 switch (key) {
 532                 case SR_CONF_DEVICE_OPTIONS:
 533                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 534                                         devopts, ARRAY_SIZE(devopts), sizeof(int32_t));
 535                         break;
 536                 case SR_CONF_SAMPLERATE:
 537                         g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 538                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 539                                         ARRAY_SIZE(samplerates), sizeof(uint64_t));
 540                         g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 541                         *data = g_variant_builder_end(&gvb);
 542                         break;
 543                 default:
 544                         return SR_ERR_NA;
 545                 }
 546         } else {
 547                 probe = probe_group->probes->data;
 548                 switch (key) {
 549                 case SR_CONF_DEVICE_OPTIONS:
 550                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 551                                         devopts_pg, ARRAY_SIZE(devopts_pg), sizeof(int32_t));
 552                         break;
 553                 case SR_CONF_PATTERN_MODE:
 554                         if (probe->type == SR_PROBE_LOGIC)
 555                                 *data = g_variant_new_strv(logic_pattern_str,
 556                                                 ARRAY_SIZE(logic_pattern_str));
 557                         else if (probe->type == SR_PROBE_ANALOG)
 558                                 *data = g_variant_new_strv(analog_pattern_str,
 559                                                 ARRAY_SIZE(analog_pattern_str));
 560                         else
 561                                 return SR_ERR_BUG;
 562                         break;
 563                 default:
 564                         return SR_ERR_NA;
 565                 }
 566         }
 567
 568         return SR_OK;
 569 }
 570
 571 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
 572 {
 573         struct dev_context *devc;
 574         uint64_t i, j;
 575         uint8_t pat;
 576
 577         devc = sdi->priv;
 578
 579         switch (devc->logic_pattern) {
 580         case PATTERN_SIGROK:
 581                 memset(devc->logic_data, 0x00, size);
 582                 for (i = 0; i < size; i += devc->logic_unitsize) {
 583                         for (j = 0; j < devc->logic_unitsize; j++) {
 584                                 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
 585                                 devc->logic_data[i + j] = ~pat;
 586                         }
 587                         devc->step++;
 588                 }
 589                 break;
 590         case PATTERN_RANDOM:
 591                 for (i = 0; i < size; i++)
 592                         devc->logic_data[i] = (uint8_t)(rand() & 0xff);
 593                 break;
 594         case PATTERN_INC:
 595                 for (i = 0; i < size; i++) {
 596                         for (j = 0; j < devc->logic_unitsize; j++) {
 597                                 devc->logic_data[i + j] = devc->step;
 598                         }
 599                         devc->step++;
 600                 }
 601                 break;
 602         case PATTERN_ALL_LOW:
 603         case PATTERN_ALL_HIGH:
 604                 /* These were set when the pattern mode was selected. */
 605                 break;
 606         default:
 607                 sr_err("Unknown pattern: %d.", devc->logic_pattern);
 608                 break;
 609         }
 610 }
 611
 612 /* Callback handling data */
 613 static int prepare_data(int fd, int revents, void *cb_data)
 614 {
 615         struct sr_dev_inst *sdi;
 616         struct dev_context *devc;
 617         struct sr_datafeed_packet packet;
 618         struct sr_datafeed_logic logic;
 619         struct sr_probe_group *pg;
 620         struct analog_gen *ag;
 621         GSList *l;
 622         uint64_t samples_to_send, expected_samplenum, analog_samples, sending_now;
 623         int64_t time, elapsed;
 624
 625         (void)fd;
 626         (void)revents;
 627
 628         sdi = cb_data;
 629         devc = sdi->priv;
 630
 631         /* How many "virtual" samples should we have collected by now? */
 632         time = g_get_monotonic_time();
 633         elapsed = time - devc->starttime;
 634         expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
 635         /* Of those, how many do we still have to send? */
 636         samples_to_send = expected_samplenum - devc->samples_counter;
 637
 638         if (devc->limit_samples) {
 639                 samples_to_send = MIN(samples_to_send,
 640                                 devc->limit_samples - devc->samples_counter);
 641         }
 642
 643         while (samples_to_send > 0) {
 644                 sending_now = 0;
 645
 646                 /* Logic */
 647                 if (devc->num_logic_probes > 0) {
 648                         sending_now = MIN(samples_to_send,
 649                                         LOGIC_BUFSIZE / devc->logic_unitsize);
 650                         logic_generator(sdi, sending_now * devc->logic_unitsize);
 651                         packet.type = SR_DF_LOGIC;
 652                         packet.payload = &logic;
 653                         logic.length = sending_now * devc->logic_unitsize;
 654                         logic.unitsize = devc->logic_unitsize;
 655                         logic.data = devc->logic_data;
 656                         sr_session_send(sdi, &packet);
 657                 }
 658
 659                 /* Analog, one probe at a time */
 660                 if (devc->num_analog_probes > 0) {
 661                         sending_now = 0;
 662                         for (l = devc->analog_probe_groups; l; l = l->next) {
 663                                 pg = l->data;
 664                                 ag = pg->priv;
 665                                 packet.type = SR_DF_ANALOG;
 666                                 packet.payload = &ag->packet;
 667
 668                                 /* FIXME we should make sure we output a whole
 669                                  * period of data before we send out again the
 670                                  * beginning of our buffer. A ring buffer would
 671                                  * help here as well */
 672
 673                                 analog_samples = MIN(samples_to_send, ag->num_samples);
 674                                 /* Whichever probe group gets there first. */
 675                                 sending_now = MAX(sending_now, analog_samples);
 676                                 ag->packet.num_samples = analog_samples;
 677                                 sr_session_send(sdi, &packet);
 678                         }
 679                 }
 680
 681                 samples_to_send -= sending_now;
 682                 devc->samples_counter += sending_now;
 683         }
 684
 685         if (devc->limit_samples &&
 686                 devc->samples_counter >= devc->limit_samples) {
 687                 sr_info("Requested number of samples reached.");
 688                 dev_acquisition_stop(sdi, cb_data);
 689                 return TRUE;
 690         }
 691
 692         return TRUE;
 693 }
 694
 695 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 696 {
 697         GSList *l;
 698         struct dev_context *devc;
 699
 700         if (sdi->status != SR_ST_ACTIVE)
 701                 return SR_ERR_DEV_CLOSED;
 702
 703         /* TODO: don't start without a sample limit set */
 704         devc = sdi->priv;
 705         devc->samples_counter = 0;
 706
 707         /*
 708          * Setting two channels connected by a pipe is a remnant from when the
 709          * demo driver generated data in a thread, and collected and sent the
 710          * data in the main program loop.
 711          * They are kept here because it provides a convenient way of setting
 712          * up a timeout-based polling mechanism.
 713          */
 714         if (pipe(devc->pipe_fds)) {
 715                 sr_err("%s: pipe() failed", __func__);
 716                 return SR_ERR;
 717         }
 718
 719         for (l = devc->analog_probe_groups; l; l = l->next) {
 720                 generate_analog_pattern(l->data, devc->cur_samplerate);
 721         }
 722
 723         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 724
 725         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 726
 727         /* Set channel encoding to binary (default is UTF-8). */
 728         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 729
 730         /* Make channels to unbuffered. */
 731         g_io_channel_set_buffered(devc->channel, FALSE);
 732
 733         sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
 734                         40, prepare_data, (void *)sdi);
 735
 736         /* Send header packet to the session bus. */
 737         std_session_send_df_header(cb_data, LOG_PREFIX);
 738
 739         /* We use this timestamp to decide how many more samples to send. */
 740         devc->starttime = g_get_monotonic_time();
 741
 742         return SR_OK;
 743 }
 744
 745 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 746 {
 747         struct dev_context *devc;
 748         struct sr_datafeed_packet packet;
 749
 750         (void)cb_data;
 751
 752         devc = sdi->priv;
 753         sr_dbg("Stopping aquisition.");
 754
 755         sr_session_source_remove_channel(devc->channel);
 756         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 757         g_io_channel_unref(devc->channel);
 758         devc->channel = NULL;
 759
 760         /* Send last packet. */
 761         packet.type = SR_DF_END;
 762         sr_session_send(sdi, &packet);
 763
 764         return SR_OK;
 765 }
 766
 767 SR_PRIV struct sr_dev_driver demo_driver_info = {
 768         .name = "demo",
 769         .longname = "Demo driver and pattern generator",
 770         .api_version = 1,
 771         .init = init,
 772         .cleanup = cleanup,
 773         .scan = scan,
 774         .dev_list = dev_list,
 775         .dev_clear = dev_clear,
 776         .config_get = config_get,
 777         .config_set = config_set,
 778         .config_list = config_list,
 779         .dev_open = dev_open,
 780         .dev_close = dev_close,
 781         .dev_acquisition_start = dev_acquisition_start,
 782         .dev_acquisition_stop = dev_acquisition_stop,
 783         .priv = NULL,
 784 };