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, SR_PROBE_ANALOG, TRUE, probe_name)))
 328                         return NULL;
 329                 sdi->probes = g_slist_append(sdi->probes, probe);
 330
 331                 /* Every analog probe gets its own probe group. */
 332                 if (!(pg = g_try_malloc(sizeof(struct sr_probe_group))))
 333                         return NULL;
 334                 pg->name = g_strdup(probe_name);
 335                 pg->probes = g_slist_append(NULL, probe);
 336
 337                 /* Every probe group gets a generator struct. */
 338                 if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
 339                         return NULL;
 340                 ag->packet.probes = pg->probes;
 341                 ag->packet.mq = 0;
 342                 ag->packet.mqflags = 0;
 343                 ag->packet.unit = SR_UNIT_VOLT;
 344                 ag->packet.data = ag->pattern_data;
 345                 ag->pattern = PATTERN_SINE;
 346                 pg->priv = ag;
 347
 348                 sdi->probe_groups = g_slist_append(sdi->probe_groups, pg);
 349                 devc->analog_probe_groups = g_slist_append(devc->analog_probe_groups, pg);
 350         }
 351
 352         sdi->priv = devc;
 353         devices = g_slist_append(devices, sdi);
 354         drvc->instances = g_slist_append(drvc->instances, sdi);
 355
 356         return devices;
 357 }
 358
 359 static GSList *dev_list(void)
 360 {
 361         return ((struct drv_context *)(di->priv))->instances;
 362 }
 363
 364 static int dev_open(struct sr_dev_inst *sdi)
 365 {
 366         sdi->status = SR_ST_ACTIVE;
 367
 368         return SR_OK;
 369 }
 370
 371 static int dev_close(struct sr_dev_inst *sdi)
 372 {
 373         sdi->status = SR_ST_INACTIVE;
 374
 375         return SR_OK;
 376 }
 377
 378 static int cleanup(void)
 379 {
 380         return dev_clear();
 381 }
 382
 383 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
 384                 const struct sr_probe_group *probe_group)
 385 {
 386         struct dev_context *devc;
 387         struct sr_probe *probe;
 388         struct analog_gen *ag;
 389         int pattern;
 390
 391         if (!sdi)
 392                 return SR_ERR_ARG;
 393
 394         devc = sdi->priv;
 395         switch (id) {
 396         case SR_CONF_SAMPLERATE:
 397                 *data = g_variant_new_uint64(devc->cur_samplerate);
 398                 break;
 399         case SR_CONF_LIMIT_SAMPLES:
 400                 *data = g_variant_new_uint64(devc->limit_samples);
 401                 break;
 402         case SR_CONF_LIMIT_MSEC:
 403                 *data = g_variant_new_uint64(devc->limit_msec);
 404                 break;
 405         case SR_CONF_PATTERN_MODE:
 406                 if (!probe_group)
 407                         return SR_ERR_PROBE_GROUP;
 408                 probe = probe_group->probes->data;
 409                 if (probe->type == SR_PROBE_LOGIC) {
 410                         pattern = devc->logic_pattern;
 411                         *data = g_variant_new_string(logic_pattern_str[pattern]);
 412                 } else if (probe->type == SR_PROBE_ANALOG) {
 413                         ag = probe_group->priv;
 414                         pattern = ag->pattern;
 415                         *data = g_variant_new_string(analog_pattern_str[pattern]);
 416                 } else
 417                         return SR_ERR_BUG;
 418                 break;
 419         case SR_CONF_NUM_LOGIC_PROBES:
 420                 *data = g_variant_new_int32(devc->num_logic_probes);
 421                 break;
 422         case SR_CONF_NUM_ANALOG_PROBES:
 423                 *data = g_variant_new_int32(devc->num_analog_probes);
 424                 break;
 425         default:
 426                 return SR_ERR_NA;
 427         }
 428
 429         return SR_OK;
 430 }
 431
 432 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 433                 const struct sr_probe_group *probe_group)
 434 {
 435         struct dev_context *devc;
 436         struct analog_gen *ag;
 437         struct sr_probe *probe;
 438         int pattern, ret;
 439         unsigned int i;
 440         const char *stropt;
 441
 442         devc = sdi->priv;
 443
 444         if (sdi->status != SR_ST_ACTIVE)
 445                 return SR_ERR_DEV_CLOSED;
 446
 447         ret = SR_OK;
 448         switch (id) {
 449         case SR_CONF_SAMPLERATE:
 450                 devc->cur_samplerate = g_variant_get_uint64(data);
 451                 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
 452                 break;
 453         case SR_CONF_LIMIT_SAMPLES:
 454                 devc->limit_msec = 0;
 455                 devc->limit_samples = g_variant_get_uint64(data);
 456                 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
 457                 break;
 458         case SR_CONF_LIMIT_MSEC:
 459                 devc->limit_msec = g_variant_get_uint64(data);
 460                 devc->limit_samples = 0;
 461                 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
 462                 break;
 463         case SR_CONF_PATTERN_MODE:
 464                 if (!probe_group)
 465                         return SR_ERR_PROBE_GROUP;
 466                 stropt = g_variant_get_string(data, NULL);
 467                 probe = probe_group->probes->data;
 468                 pattern = -1;
 469                 if (probe->type == SR_PROBE_LOGIC) {
 470                         for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
 471                                 if (!strcmp(stropt, logic_pattern_str[i])) {
 472                                         pattern = i;
 473                                         break;
 474                                 }
 475                         }
 476                         if (pattern == -1)
 477                                 return SR_ERR_ARG;
 478                         devc->logic_pattern = pattern;
 479
 480                         /* Might as well do this now, these are static. */
 481                         if (pattern == PATTERN_ALL_LOW)
 482                                 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
 483                         else if (pattern == PATTERN_ALL_HIGH)
 484                                 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
 485                         sr_dbg("Setting logic pattern to %s",
 486                                         logic_pattern_str[pattern]);
 487                 } else if (probe->type == SR_PROBE_ANALOG) {
 488                         for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
 489                                 if (!strcmp(stropt, analog_pattern_str[i])) {
 490                                         pattern = i;
 491                                         break;
 492                                 }
 493                         }
 494                         if (pattern == -1)
 495                                 return SR_ERR_ARG;
 496                         sr_dbg("Setting analog pattern for probe group %s to %s",
 497                                         probe_group->name,
 498                                         analog_pattern_str[pattern]);
 499                         ag = probe_group->priv;
 500                         ag->pattern = pattern;
 501                 } else
 502                         return SR_ERR_BUG;
 503                 break;
 504         default:
 505                 ret = SR_ERR_NA;
 506         }
 507
 508         return ret;
 509 }
 510
 511 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
 512                 const struct sr_probe_group *probe_group)
 513 {
 514         struct sr_probe *probe;
 515         GVariant *gvar;
 516         GVariantBuilder gvb;
 517
 518         (void)sdi;
 519
 520         if (key == SR_CONF_SCAN_OPTIONS) {
 521                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 522                                 scanopts, ARRAY_SIZE(scanopts), sizeof(int32_t));
 523                 return SR_OK;
 524         }
 525
 526         if (!sdi)
 527                 return SR_ERR_ARG;
 528
 529         if (!probe_group) {
 530                 switch (key) {
 531                 case SR_CONF_DEVICE_OPTIONS:
 532                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 533                                         devopts, ARRAY_SIZE(devopts), sizeof(int32_t));
 534                         break;
 535                 case SR_CONF_SAMPLERATE:
 536                         g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 537                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 538                                         ARRAY_SIZE(samplerates), sizeof(uint64_t));
 539                         g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 540                         *data = g_variant_builder_end(&gvb);
 541                         break;
 542                 default:
 543                         return SR_ERR_NA;
 544                 }
 545         } else {
 546                 probe = probe_group->probes->data;
 547                 switch (key) {
 548                 case SR_CONF_DEVICE_OPTIONS:
 549                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 550                                         devopts_pg, ARRAY_SIZE(devopts_pg), sizeof(int32_t));
 551                         break;
 552                 case SR_CONF_PATTERN_MODE:
 553                         if (probe->type == SR_PROBE_LOGIC)
 554                                 *data = g_variant_new_strv(logic_pattern_str,
 555                                                 ARRAY_SIZE(logic_pattern_str));
 556                         else if (probe->type == SR_PROBE_ANALOG)
 557                                 *data = g_variant_new_strv(analog_pattern_str,
 558                                                 ARRAY_SIZE(analog_pattern_str));
 559                         else
 560                                 return SR_ERR_BUG;
 561                         break;
 562                 default:
 563                         return SR_ERR_NA;
 564                 }
 565         }
 566
 567         return SR_OK;
 568 }
 569
 570 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
 571 {
 572         struct dev_context *devc;
 573         uint64_t i, j;
 574         uint8_t pat;
 575
 576         devc = sdi->priv;
 577
 578         switch (devc->logic_pattern) {
 579         case PATTERN_SIGROK:
 580                 memset(devc->logic_data, 0x00, size);
 581                 for (i = 0; i < size; i += devc->logic_unitsize) {
 582                         for (j = 0; j < devc->logic_unitsize; j++) {
 583                                 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
 584                                 devc->logic_data[i + j] = ~pat;
 585                         }
 586                         devc->step++;
 587                 }
 588                 break;
 589         case PATTERN_RANDOM:
 590                 for (i = 0; i < size; i++)
 591                         devc->logic_data[i] = (uint8_t)(rand() & 0xff);
 592                 break;
 593         case PATTERN_INC:
 594                 for (i = 0; i < size; i++) {
 595                         for (j = 0; j < devc->logic_unitsize; j++) {
 596                                 devc->logic_data[i + j] = devc->step;
 597                         }
 598                         devc->step++;
 599                 }
 600                 break;
 601         case PATTERN_ALL_LOW:
 602         case PATTERN_ALL_HIGH:
 603                 /* These were set when the pattern mode was selected. */
 604                 break;
 605         default:
 606                 sr_err("Unknown pattern: %d.", devc->logic_pattern);
 607                 break;
 608         }
 609 }
 610
 611 /* Callback handling data */
 612 static int prepare_data(int fd, int revents, void *cb_data)
 613 {
 614         struct sr_dev_inst *sdi;
 615         struct dev_context *devc;
 616         struct sr_datafeed_packet packet;
 617         struct sr_datafeed_logic logic;
 618         struct sr_probe_group *pg;
 619         struct analog_gen *ag;
 620         GSList *l;
 621         uint64_t samples_to_send, expected_samplenum, analog_samples, sending_now;
 622         int64_t time, elapsed;
 623
 624         (void)fd;
 625         (void)revents;
 626
 627         sdi = cb_data;
 628         devc = sdi->priv;
 629
 630         /* How many "virtual" samples should we have collected by now? */
 631         time = g_get_monotonic_time();
 632         elapsed = time - devc->starttime;
 633         expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
 634         /* Of those, how many do we still have to send? */
 635         samples_to_send = expected_samplenum - devc->samples_counter;
 636
 637         if (devc->limit_samples) {
 638                 samples_to_send = MIN(samples_to_send,
 639                                 devc->limit_samples - devc->samples_counter);
 640         }
 641
 642         while (samples_to_send > 0) {
 643                 sending_now = 0;
 644
 645                 /* Logic */
 646                 if (devc->num_logic_probes > 0) {
 647                         sending_now = MIN(samples_to_send,
 648                                         LOGIC_BUFSIZE / devc->logic_unitsize);
 649                         logic_generator(sdi, sending_now * devc->logic_unitsize);
 650                         packet.type = SR_DF_LOGIC;
 651                         packet.payload = &logic;
 652                         logic.length = sending_now * devc->logic_unitsize;
 653                         logic.unitsize = devc->logic_unitsize;
 654                         logic.data = devc->logic_data;
 655                         sr_session_send(sdi, &packet);
 656                 }
 657
 658                 /* Analog, one probe at a time */
 659                 if (devc->num_analog_probes > 0) {
 660                         sending_now = 0;
 661                         for (l = devc->analog_probe_groups; l; l = l->next) {
 662                                 pg = l->data;
 663                                 ag = pg->priv;
 664                                 packet.type = SR_DF_ANALOG;
 665                                 packet.payload = &ag->packet;
 666
 667                                 /* FIXME we should make sure we output a whole
 668                                  * period of data before we send out again the
 669                                  * beginning of our buffer. A ring buffer would
 670                                  * help here as well */
 671
 672                                 analog_samples = MIN(samples_to_send, ag->num_samples);
 673                                 /* Whichever probe group gets there first. */
 674                                 sending_now = MAX(sending_now, analog_samples);
 675                                 ag->packet.num_samples = analog_samples;
 676                                 sr_session_send(sdi, &packet);
 677                         }
 678                 }
 679
 680                 samples_to_send -= sending_now;
 681                 devc->samples_counter += sending_now;
 682         }
 683
 684         if (devc->limit_samples &&
 685                 devc->samples_counter >= devc->limit_samples) {
 686                 sr_info("Requested number of samples reached.");
 687                 dev_acquisition_stop(sdi, cb_data);
 688                 return TRUE;
 689         }
 690
 691         return TRUE;
 692 }
 693
 694 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 695 {
 696         GSList *l;
 697         struct dev_context *devc;
 698
 699         if (sdi->status != SR_ST_ACTIVE)
 700                 return SR_ERR_DEV_CLOSED;
 701
 702         /* TODO: don't start without a sample limit set */
 703         devc = sdi->priv;
 704         devc->samples_counter = 0;
 705
 706         /*
 707          * Setting two channels connected by a pipe is a remnant from when the
 708          * demo driver generated data in a thread, and collected and sent the
 709          * data in the main program loop.
 710          * They are kept here because it provides a convenient way of setting
 711          * up a timeout-based polling mechanism.
 712          */
 713         if (pipe(devc->pipe_fds)) {
 714                 sr_err("%s: pipe() failed", __func__);
 715                 return SR_ERR;
 716         }
 717
 718         for (l = devc->analog_probe_groups; l; l = l->next) {
 719                 generate_analog_pattern(l->data, devc->cur_samplerate);
 720         }
 721
 722         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 723
 724         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 725
 726         /* Set channel encoding to binary (default is UTF-8). */
 727         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 728
 729         /* Make channels to unbuffered. */
 730         g_io_channel_set_buffered(devc->channel, FALSE);
 731
 732         sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
 733                         40, prepare_data, (void *)sdi);
 734
 735         /* Send header packet to the session bus. */
 736         std_session_send_df_header(cb_data, LOG_PREFIX);
 737
 738         /* We use this timestamp to decide how many more samples to send. */
 739         devc->starttime = g_get_monotonic_time();
 740
 741         return SR_OK;
 742 }
 743
 744 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 745 {
 746         struct dev_context *devc;
 747         struct sr_datafeed_packet packet;
 748
 749         (void)cb_data;
 750
 751         devc = sdi->priv;
 752         sr_dbg("Stopping aquisition.");
 753
 754         sr_session_source_remove_channel(devc->channel);
 755         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 756         g_io_channel_unref(devc->channel);
 757         devc->channel = NULL;
 758
 759         /* Send last packet. */
 760         packet.type = SR_DF_END;
 761         sr_session_send(sdi, &packet);
 762
 763         return SR_OK;
 764 }
 765
 766 SR_PRIV struct sr_dev_driver demo_driver_info = {
 767         .name = "demo",
 768         .longname = "Demo driver and pattern generator",
 769         .api_version = 1,
 770         .init = init,
 771         .cleanup = cleanup,
 772         .scan = scan,
 773         .dev_list = dev_list,
 774         .dev_clear = dev_clear,
 775         .config_get = config_get,
 776         .config_set = config_set,
 777         .config_list = config_list,
 778         .dev_open = dev_open,
 779         .dev_close = dev_close,
 780         .dev_acquisition_start = dev_acquisition_start,
 781         .dev_acquisition_stop = dev_acquisition_stop,
 782         .priv = NULL,
 783 };