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