hardware/hameg-hmo/protocol.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2013 poljar (Damir Jelić) <poljarinho@gmail.com>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "protocol.h"
  21
  22 static const char *manufacturers[] = {
  23         "HAMEG",
  24 };
  25
  26 static const char *hameg_scpi_dialect[] = {
  27         [SCPI_CMD_GET_DIG_DATA]             = ":POD%d:DATA?",
  28         [SCPI_CMD_GET_TIMEBASE]             = ":TIM:SCAL?",
  29         [SCPI_CMD_SET_TIMEBASE]             = ":TIM:SCAL %E",
  30         [SCPI_CMD_GET_COUPLING]             = ":CHAN%d:COUP?",
  31         [SCPI_CMD_SET_COUPLING]             = ":CHAN%d:COUP %s",
  32         [SCPI_CMD_GET_ANALOG_DATA]          = ":CHAN%d:DATA?",
  33         [SCPI_CMD_GET_VERTICAL_DIV]         = ":CHAN%d:SCAL?",
  34         [SCPI_CMD_SET_VERTICAL_DIV]         = ":CHAN%d:SCAL %E",
  35         [SCPI_CMD_GET_DIG_POD_STATE]        = ":POD%d:STAT?",
  36         [SCPI_CMD_SET_DIG_POD_STATE]        = ":POD%d:STAT %d",
  37         [SCPI_CMD_GET_TRIGGER_SLOPE]        = ":TRIG:A:EDGE:SLOP?",
  38         [SCPI_CMD_SET_TRIGGER_SLOPE]        = ":TRIG:A:EDGE:SLOP %s",
  39         [SCPI_CMD_GET_TRIGGER_SOURCE]       = ":TRIG:A:SOUR?",
  40         [SCPI_CMD_SET_TRIGGER_SOURCE]       = ":TRIG:A:SOUR %s",
  41         [SCPI_CMD_GET_DIG_CHAN_STATE]       = ":LOG%d:STAT?",
  42         [SCPI_CMD_SET_DIG_CHAN_STATE]       = ":LOG%d:STAT %d",
  43         [SCPI_CMD_GET_VERTICAL_OFFSET]      = ":CHAN%d:POS?",
  44         [SCPI_CMD_GET_HORIZ_TRIGGERPOS]     = ":TIM:POS?",
  45         [SCPI_CMD_SET_HORIZ_TRIGGERPOS]     = ":TIM:POS %E",
  46         [SCPI_CMD_GET_ANALOG_CHAN_STATE]    = ":CHAN%d:STAT?",
  47         [SCPI_CMD_SET_ANALOG_CHAN_STATE]    = ":CHAN%d:STAT %d",
  48 };
  49
  50 static const int32_t hmo_hwcaps[] = {
  51         SR_CONF_OSCILLOSCOPE,
  52         SR_CONF_TRIGGER_SOURCE,
  53         SR_CONF_TIMEBASE,
  54         SR_CONF_NUM_TIMEBASE,
  55         SR_CONF_TRIGGER_SLOPE,
  56         SR_CONF_HORIZ_TRIGGERPOS,
  57 };
  58
  59 static const int32_t hmo_analog_caps[] = {
  60         SR_CONF_NUM_VDIV,
  61         SR_CONF_COUPLING,
  62         SR_CONF_VDIV,
  63 };
  64
  65 static const char *hmo_coupling_options[] = {
  66         "AC",
  67         "ACL",
  68         "DC",
  69         "GND",
  70         NULL,
  71 };
  72
  73 static const char *scope_trigger_slopes[] = {
  74         "POS",
  75         "NEG",
  76         NULL,
  77 };
  78
  79 static const char *hmo_compact2_trigger_sources[] = {
  80         "CH1",
  81         "CH2",
  82         "LINE",
  83         "EXT",
  84         "D0",
  85         "D1",
  86         "D2",
  87         "D3",
  88         "D4",
  89         "D5",
  90         "D6",
  91         "D7",
  92         NULL,
  93 };
  94
  95 static const char *hmo_compact4_trigger_sources[] = {
  96         "CH1",
  97         "CH2",
  98         "CH3",
  99         "CH4",
 100         "LINE",
 101         "EXT",
 102         "D0",
 103         "D1",
 104         "D2",
 105         "D3",
 106         "D4",
 107         "D5",
 108         "D6",
 109         "D7",
 110         NULL,
 111 };
 112
 113 static const uint64_t hmo_timebases[][2] = {
 114         /* nanoseconds */
 115         { 2, 1000000000 },
 116         { 5, 1000000000 },
 117         { 10, 1000000000 },
 118         { 20, 1000000000 },
 119         { 50, 1000000000 },
 120         { 100, 1000000000 },
 121         { 200, 1000000000 },
 122         { 500, 1000000000 },
 123         /* microseconds */
 124         { 1, 1000000 },
 125         { 2, 1000000 },
 126         { 5, 1000000 },
 127         { 10, 1000000 },
 128         { 20, 1000000 },
 129         { 50, 1000000 },
 130         { 100, 1000000 },
 131         { 200, 1000000 },
 132         { 500, 1000000 },
 133         /* milliseconds */
 134         { 1, 1000 },
 135         { 2, 1000 },
 136         { 5, 1000 },
 137         { 10, 1000 },
 138         { 20, 1000 },
 139         { 50, 1000 },
 140         { 100, 1000 },
 141         { 200, 1000 },
 142         { 500, 1000 },
 143         /* seconds */
 144         { 1, 1 },
 145         { 2, 1 },
 146         { 5, 1 },
 147         { 10, 1 },
 148         { 20, 1 },
 149         { 50, 1 },
 150 };
 151
 152 static const uint64_t hmo_vdivs[][2] = {
 153         /* millivolts */
 154         { 1, 1000 },
 155         { 2, 1000 },
 156         { 5, 1000 },
 157         { 10, 1000 },
 158         { 20, 1000 },
 159         { 50, 1000 },
 160         { 100, 1000 },
 161         { 200, 1000 },
 162         { 500, 1000 },
 163         /* volts */
 164         { 1, 1 },
 165         { 2, 1 },
 166         { 5, 1 },
 167         { 10, 1 },
 168 };
 169
 170 static const char *scope_analog_probe_names[] = {
 171         "CH1",
 172         "CH2",
 173         "CH3",
 174         "CH4",
 175 };
 176
 177 static const char *scope_digital_probe_names[] = {
 178         "D0",
 179         "D1",
 180         "D2",
 181         "D3",
 182         "D4",
 183         "D5",
 184         "D6",
 185         "D7",
 186         "D8",
 187         "D9",
 188         "D10",
 189         "D11",
 190         "D12",
 191         "D13",
 192         "D14",
 193         "D15",
 194 };
 195
 196 static struct scope_config scope_models[] = {
 197         {
 198                 .name = {"HMO722", "HMO1022", "HMO1522", "HMO2022", NULL},
 199                 .analog_channels = 2,
 200                 .digital_channels = 8,
 201                 .digital_pods = 1,
 202
 203                 .analog_names = &scope_analog_probe_names,
 204                 .digital_names = &scope_digital_probe_names,
 205
 206                 .hw_caps = &hmo_hwcaps,
 207                 .num_hwcaps = ARRAY_SIZE(hmo_hwcaps),
 208
 209                 .analog_hwcaps = &hmo_analog_caps,
 210                 .num_analog_hwcaps = ARRAY_SIZE(hmo_analog_caps),
 211
 212                 .coupling_options = &hmo_coupling_options,
 213                 .trigger_sources = &hmo_compact2_trigger_sources,
 214                 .trigger_slopes = &scope_trigger_slopes,
 215
 216                 .timebases = &hmo_timebases,
 217                 .num_timebases = ARRAY_SIZE(hmo_timebases),
 218
 219                 .vdivs = &hmo_vdivs,
 220                 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
 221
 222                 .num_xdivs = 12,
 223                 .num_ydivs = 8,
 224
 225                 .scpi_dialect = &hameg_scpi_dialect,
 226         },
 227         {
 228                 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
 229                 .analog_channels = 4,
 230                 .digital_channels = 8,
 231                 .digital_pods = 1,
 232
 233                 .analog_names = &scope_analog_probe_names,
 234                 .digital_names = &scope_digital_probe_names,
 235
 236                 .hw_caps = &hmo_hwcaps,
 237                 .num_hwcaps = ARRAY_SIZE(hmo_hwcaps),
 238
 239                 .analog_hwcaps = &hmo_analog_caps,
 240                 .num_analog_hwcaps = ARRAY_SIZE(hmo_analog_caps),
 241
 242                 .coupling_options = &hmo_coupling_options,
 243                 .trigger_sources = &hmo_compact4_trigger_sources,
 244                 .trigger_slopes = &scope_trigger_slopes,
 245
 246                 .timebases = &hmo_timebases,
 247                 .num_timebases = ARRAY_SIZE(hmo_timebases),
 248
 249                 .vdivs = &hmo_vdivs,
 250                 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
 251
 252                 .num_xdivs = 12,
 253                 .num_ydivs = 8,
 254
 255                 .scpi_dialect = &hameg_scpi_dialect,
 256         },
 257 };
 258
 259 static int check_manufacturer(const char *manufacturer)
 260 {
 261         unsigned int i;
 262
 263         for (i = 0; i < ARRAY_SIZE(manufacturers); ++i)
 264                 if (!strcmp(manufacturer, manufacturers[i]))
 265                         return SR_OK;
 266
 267         return SR_ERR;
 268 }
 269
 270 static void scope_state_dump(struct scope_config *config,
 271                              struct scope_state *state)
 272 {
 273         unsigned int i;
 274
 275         for (i = 0; i < config->analog_channels; ++i) {
 276                 sr_info("State of analog channel %d -> %s : %s %.3eV %.3e offset", i + 1,
 277                         state->analog_channels[i].state ? "On" : "Off",
 278                         (*config->coupling_options)[state->analog_channels[i].coupling],
 279                         state->analog_channels[i].vdiv, state->analog_channels[i].vertical_offset);
 280         }
 281
 282         for (i = 0; i < config->digital_channels; ++i) {
 283                 sr_info("State of digital channel %d -> %s", i,
 284                         state->digital_channels[i] ? "On" : "Off");
 285         }
 286
 287         for (i = 0; i < config->digital_pods; ++i) {
 288                 sr_info("State of digital POD %d -> %s", i,
 289                         state->digital_pods[i] ? "On" : "Off");
 290         }
 291
 292         sr_info("Current timebase: %.2es", state->timebase);
 293         sr_info("Current trigger: %s (source), %s (slope) %.2e (offset)",
 294                 (*config->trigger_sources)[state->trigger_source],
 295                 (*config->trigger_slopes)[state->trigger_slope],
 296                 state->horiz_triggerpos);
 297 }
 298
 299 static int scope_state_get_array_option(struct sr_serial_dev_inst *serial,
 300                 const char *command, const char *(*array)[], int *result)
 301 {
 302         char *tmp;
 303         unsigned int i;
 304
 305         if (sr_scpi_get_string(serial, command, &tmp) != SR_OK) {
 306                 g_free(tmp);
 307                 return SR_ERR;
 308         }
 309
 310         for (i = 0; (*array)[i]; ++i) {
 311                 if (!g_strcmp0(tmp, (*array)[i])) {
 312                         *result = i;
 313                         g_free(tmp);
 314                         tmp = NULL;
 315                         break;
 316                 }
 317         }
 318
 319         if (tmp) {
 320                 g_free(tmp);
 321                 return SR_ERR;
 322         }
 323
 324         return SR_OK;
 325 }
 326
 327 static int analog_channel_state_get(struct sr_serial_dev_inst *serial,
 328                                     struct scope_config *config,
 329                                     struct scope_state *state)
 330 {
 331         unsigned int i;
 332         char command[MAX_COMMAND_SIZE];
 333
 334         for (i = 0; i < config->analog_channels; ++i) {
 335                 g_snprintf(command, sizeof(command),
 336                            (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
 337                            i + 1);
 338
 339                 if (sr_scpi_get_bool(serial, command,
 340                                      &state->analog_channels[i].state) != SR_OK)
 341                         return SR_ERR;
 342
 343                 g_snprintf(command, sizeof(command),
 344                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
 345                            i + 1);
 346
 347                 if (sr_scpi_get_float(serial, command,
 348                                      &state->analog_channels[i].vdiv) != SR_OK)
 349                         return SR_ERR;
 350
 351                 g_snprintf(command, sizeof(command),
 352                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
 353                            i + 1);
 354
 355                 if (sr_scpi_get_float(serial, command,
 356                                      &state->analog_channels[i].vertical_offset) != SR_OK)
 357                         return SR_ERR;
 358
 359                 g_snprintf(command, sizeof(command),
 360                            (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
 361                            i + 1);
 362
 363                 if (scope_state_get_array_option(serial, command, config->coupling_options,
 364                                          &state->analog_channels[i].coupling) != SR_OK)
 365                         return SR_ERR;
 366         }
 367
 368         return SR_OK;
 369 }
 370
 371 static int digital_channel_state_get(struct sr_serial_dev_inst *serial,
 372                                      struct scope_config *config,
 373                                      struct scope_state *state)
 374 {
 375         unsigned int i;
 376         char command[MAX_COMMAND_SIZE];
 377
 378         for (i = 0; i < config->digital_channels; ++i) {
 379                 g_snprintf(command, sizeof(command),
 380                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
 381                            i);
 382
 383                 if (sr_scpi_get_bool(serial, command,
 384                                      &state->digital_channels[i]) != SR_OK)
 385                         return SR_ERR;
 386         }
 387
 388         for (i = 0; i < config->digital_pods; ++i) {
 389                 g_snprintf(command, sizeof(command),
 390                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
 391                            i + 1);
 392
 393                 if (sr_scpi_get_bool(serial, command,
 394                                      &state->digital_pods[i]) != SR_OK)
 395                         return SR_ERR;
 396         }
 397
 398         return SR_OK;
 399 }
 400
 401 SR_PRIV int scope_state_get(struct sr_dev_inst *sdi)
 402 {
 403         struct dev_context *devc;
 404         struct scope_state *state;
 405         struct scope_config *config;
 406
 407         devc = sdi->priv;
 408         config = devc->model_config;
 409         state = devc->model_state;
 410
 411         if (analog_channel_state_get(sdi->conn, config, state) != SR_OK)
 412                 return SR_ERR;
 413
 414         if (digital_channel_state_get(sdi->conn, config, state) != SR_OK)
 415                 return SR_ERR;
 416
 417         /* TODO: Check if value is sensible. */
 418         if (sr_scpi_get_float(sdi->conn,
 419                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 420                         &state->timebase) != SR_OK)
 421                 return SR_ERR;
 422
 423         if (sr_scpi_get_float(sdi->conn,
 424                         (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
 425                         &state->horiz_triggerpos) != SR_OK)
 426                 return SR_ERR;
 427
 428         if (scope_state_get_array_option(sdi->conn,
 429                         (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
 430                         config->trigger_sources, &state->trigger_source) != SR_OK)
 431                 return SR_ERR;
 432
 433         if (scope_state_get_array_option(sdi->conn,
 434                 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
 435                 config->trigger_slopes, &state->trigger_slope) != SR_OK)
 436                 return SR_ERR;
 437
 438         scope_state_dump(config, state);
 439
 440         return SR_OK;
 441 }
 442
 443 SR_PRIV struct scope_state *scope_state_new(struct scope_config *config)
 444 {
 445         struct scope_state *state;
 446
 447         if (!(state = g_try_malloc0(sizeof(struct scope_state))))
 448                 return NULL;
 449
 450         if (!(state->analog_channels = g_try_malloc0_n(config->analog_channels,
 451                                     sizeof(struct analog_channel_state))))
 452             goto fail;
 453
 454         if (!(state->digital_channels = g_try_malloc0_n(
 455                         config->digital_channels, sizeof(gboolean))))
 456             goto fail;
 457
 458         if (!(state->digital_pods = g_try_malloc0_n(config->digital_pods,
 459                                                      sizeof(gboolean))))
 460             goto fail;
 461
 462         return state;
 463
 464 fail:
 465         if (state->analog_channels)
 466                 g_free(state->analog_channels);
 467         if (state->digital_channels)
 468                 g_free(state->digital_channels);
 469         if (state->digital_pods)
 470                 g_free(state->digital_pods);
 471         g_free(state);
 472
 473         return NULL;
 474 }
 475
 476 SR_PRIV void scope_state_free(struct scope_state *state)
 477 {
 478         g_free(state->analog_channels);
 479         g_free(state->digital_channels);
 480         g_free(state->digital_pods);
 481         g_free(state);
 482 }
 483
 484 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
 485 {
 486         char tmp[25];
 487         int model_index;
 488         unsigned int i, j;
 489         struct sr_probe *probe;
 490         struct dev_context *devc;
 491
 492         devc = sdi->priv;
 493         model_index = -1;
 494
 495         /* Find the exact model. */
 496         for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
 497                 for (j = 0; scope_models[i].name[j]; j++) {
 498                         if (!strcmp(sdi->model, scope_models[i].name[j])) {
 499                                 model_index = i;
 500                                 break;
 501                         }
 502                 }
 503                 if (model_index != -1)
 504                         break;
 505         }
 506
 507         if (model_index == -1) {
 508                 sr_dbg("Unsupported HMO device.");
 509                 return SR_ERR_NA;
 510         }
 511
 512         if (!(devc->analog_groups = g_try_malloc0(sizeof(struct sr_probe_group) *
 513                                                   scope_models[model_index].analog_channels)))
 514                         return SR_ERR_MALLOC;
 515
 516         if (!(devc->digital_groups = g_try_malloc0(sizeof(struct sr_probe_group) *
 517                                                    scope_models[model_index].digital_pods)))
 518                         return SR_ERR_MALLOC;
 519
 520         /* Add analog channels. */
 521         for (i = 0; i < scope_models[model_index].analog_channels; i++) {
 522                 if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
 523                            (*scope_models[model_index].analog_names)[i])))
 524                         return SR_ERR_MALLOC;
 525                 sdi->probes = g_slist_append(sdi->probes, probe);
 526
 527                 devc->analog_groups[i].name =
 528                         (char *)(*scope_models[model_index].analog_names)[i];
 529                 devc->analog_groups[i].probes = g_slist_append(NULL, probe);
 530
 531                 sdi->probe_groups = g_slist_append(sdi->probe_groups,
 532                                                    &devc->analog_groups[i]);
 533         }
 534
 535         /* Add digital probe groups. */
 536         for (i = 0; i < scope_models[model_index].digital_pods; ++i) {
 537                 g_snprintf(tmp, 25, "POD%d", i);
 538                 devc->digital_groups[i].name = g_strdup(tmp);
 539                 sdi->probe_groups = g_slist_append(sdi->probe_groups,
 540                                    &devc->digital_groups[i < 8 ? 0 : 1]);
 541         }
 542
 543         /* Add digital channels. */
 544         for (i = 0; i < scope_models[model_index].digital_channels; i++) {
 545                 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
 546                            (*scope_models[model_index].digital_names)[i])))
 547                         return SR_ERR_MALLOC;
 548                 sdi->probes = g_slist_append(sdi->probes, probe);
 549
 550                 devc->digital_groups[i < 8 ? 0 : 1].probes = g_slist_append(
 551                         devc->digital_groups[i < 8 ? 0 : 1].probes, probe);
 552         }
 553
 554         devc->model_config = &scope_models[model_index];
 555         devc->frame_limit = 0;
 556
 557         if (!(devc->model_state = scope_state_new(devc->model_config)))
 558                 return SR_ERR_MALLOC;
 559
 560         return SR_OK;
 561 }
 562
 563 SR_PRIV struct sr_dev_inst *hameg_probe_serial_device(const char *serial_device,
 564                                                       const char *serial_options)
 565 {
 566         struct sr_dev_inst *sdi;
 567         struct dev_context *devc;
 568         struct sr_scpi_hw_info *hw_info;
 569         struct sr_serial_dev_inst *serial;
 570
 571         sdi = NULL;
 572         devc = NULL;
 573         serial = NULL;
 574         hw_info = NULL;
 575
 576         if (!(serial = sr_serial_dev_inst_new(serial_device, serial_options)))
 577                 goto fail;
 578
 579         sr_info("Probing %s.", serial_device);
 580         if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
 581                 goto fail;
 582
 583         if (sr_scpi_get_hw_id(serial, &hw_info) != SR_OK) {
 584                 sr_info("Couldn't get IDN response.");
 585                 goto fail;
 586         }
 587
 588         if (check_manufacturer(hw_info->manufacturer) != SR_OK)
 589                 goto fail;
 590
 591         if (!(sdi = sr_dev_inst_new(0, SR_ST_ACTIVE,
 592                                     hw_info->manufacturer, hw_info->model,
 593                                     hw_info->firmware_version))) {
 594                 goto fail;
 595         }
 596         sr_scpi_hw_info_free(hw_info);
 597         hw_info = NULL;
 598
 599         if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
 600                 goto fail;
 601
 602         sdi->driver = di;
 603         sdi->priv = devc;
 604         sdi->inst_type = SR_INST_SERIAL;
 605         sdi->conn = serial;
 606
 607         if (hmo_init_device(sdi) != SR_OK)
 608                 goto fail;
 609
 610         return sdi;
 611
 612 fail:
 613         if (hw_info)
 614                 sr_scpi_hw_info_free(hw_info);
 615         if (serial)
 616                 sr_serial_dev_inst_free(serial);
 617         if (sdi)
 618                 sr_dev_inst_free(sdi);
 619         if (devc)
 620                 g_free(devc);
 621
 622         return NULL;
 623 }
 624
 625 SR_PRIV int hameg_hmo_receive_data(int fd, int revents, void *cb_data)
 626 {
 627         struct sr_probe *probe;
 628         struct sr_dev_inst *sdi;
 629         struct dev_context *devc;
 630         struct sr_datafeed_packet packet;
 631         GArray *data;
 632         struct sr_datafeed_analog analog;
 633         struct sr_datafeed_logic logic;
 634
 635         (void)fd;
 636
 637         if (!(sdi = cb_data))
 638                 return TRUE;
 639
 640         if (!(devc = sdi->priv))
 641                 return TRUE;
 642
 643         if (revents == G_IO_IN) {
 644                 probe = devc->current_probe->data;
 645
 646                 switch (probe->type) {
 647                 case SR_PROBE_ANALOG:
 648                         if (sr_scpi_get_floatv(sdi->conn, NULL, &data) != SR_OK) {
 649                                 if (data)
 650                                         g_array_free(data, TRUE);
 651
 652                                 return TRUE;
 653                         }
 654
 655                         packet.type = SR_DF_FRAME_BEGIN;
 656                         sr_session_send(sdi, &packet);
 657
 658                         analog.probes = g_slist_append(NULL, probe);
 659                         analog.num_samples = data->len;
 660                         analog.data = (float *) data->data;
 661                         analog.mq = SR_MQ_VOLTAGE;
 662                         analog.unit = SR_UNIT_VOLT;
 663                         analog.mqflags = 0;
 664                         packet.type = SR_DF_ANALOG;
 665                         packet.payload = &analog;
 666                         sr_session_send(cb_data, &packet);
 667                         g_slist_free(analog.probes);
 668                         g_array_free(data, TRUE);
 669                         break;
 670                 case SR_PROBE_LOGIC:
 671                         if (sr_scpi_get_uint8v(sdi->conn, NULL, &data) != SR_OK) {
 672                                 if (data)
 673                                         g_free(data);
 674                                 return TRUE;
 675                         }
 676
 677                         packet.type = SR_DF_FRAME_BEGIN;
 678                         sr_session_send(sdi, &packet);
 679
 680                         logic.length = data->len;
 681                         logic.unitsize = 1;
 682                         logic.data = data->data;
 683                         packet.type = SR_DF_LOGIC;
 684                         packet.payload = &logic;
 685                         sr_session_send(cb_data, &packet);
 686                         g_array_free(data, TRUE);
 687                         break;
 688                 default:
 689                         sr_err("Invalid probe type.");
 690                         break;
 691                 }
 692
 693                 packet.type = SR_DF_FRAME_END;
 694                 sr_session_send(sdi, &packet);
 695
 696                 if (devc->current_probe->next) {
 697                         devc->current_probe = devc->current_probe->next;
 698                         hmo_request_data(sdi);
 699                 } else if (++devc->num_frames == devc->frame_limit) {
 700                         packet.type = SR_DF_END;
 701                         sr_session_send(sdi, &packet);
 702                         sdi->driver->dev_acquisition_stop(sdi, cb_data);
 703                 } else {
 704                         devc->current_probe = devc->enabled_probes;
 705                         hmo_request_data(sdi);
 706                 }
 707         }
 708
 709         return TRUE;
 710 }