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