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