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 *hameg_scpi_dialect[] = {
  23         [SCPI_CMD_GET_DIG_DATA]             = ":POD%d:DATA?",
  24         [SCPI_CMD_GET_TIMEBASE]             = ":TIM:SCAL?",
  25         [SCPI_CMD_SET_TIMEBASE]             = ":TIM:SCAL %s",
  26         [SCPI_CMD_GET_COUPLING]             = ":CHAN%d:COUP?",
  27         [SCPI_CMD_SET_COUPLING]             = ":CHAN%d:COUP %s",
  28         [SCPI_CMD_GET_SAMPLE_RATE]          = ":ACQ:SRAT?",
  29         [SCPI_CMD_GET_SAMPLE_RATE_LIVE]     = ":%s:DATA:POINTS?",
  30         [SCPI_CMD_GET_ANALOG_DATA]          = ":CHAN%d:DATA?",
  31         [SCPI_CMD_GET_VERTICAL_DIV]         = ":CHAN%d:SCAL?",
  32         [SCPI_CMD_SET_VERTICAL_DIV]         = ":CHAN%d:SCAL %s",
  33         [SCPI_CMD_GET_DIG_POD_STATE]        = ":POD%d:STAT?",
  34         [SCPI_CMD_SET_DIG_POD_STATE]        = ":POD%d:STAT %d",
  35         [SCPI_CMD_GET_TRIGGER_SLOPE]        = ":TRIG:A:EDGE:SLOP?",
  36         [SCPI_CMD_SET_TRIGGER_SLOPE]        = ":TRIG:A:EDGE:SLOP %s",
  37         [SCPI_CMD_GET_TRIGGER_SOURCE]       = ":TRIG:A:SOUR?",
  38         [SCPI_CMD_SET_TRIGGER_SOURCE]       = ":TRIG:A:SOUR %s",
  39         [SCPI_CMD_GET_DIG_CHAN_STATE]       = ":LOG%d:STAT?",
  40         [SCPI_CMD_SET_DIG_CHAN_STATE]       = ":LOG%d:STAT %d",
  41         [SCPI_CMD_GET_VERTICAL_OFFSET]      = ":CHAN%d:POS?",
  42         [SCPI_CMD_GET_HORIZ_TRIGGERPOS]     = ":TIM:POS?",
  43         [SCPI_CMD_SET_HORIZ_TRIGGERPOS]     = ":TIM:POS %s",
  44         [SCPI_CMD_GET_ANALOG_CHAN_STATE]    = ":CHAN%d:STAT?",
  45         [SCPI_CMD_SET_ANALOG_CHAN_STATE]    = ":CHAN%d:STAT %d",
  46 };
  47
  48 static const int32_t hmo_hwcaps[] = {
  49         SR_CONF_OSCILLOSCOPE,
  50         SR_CONF_TRIGGER_SOURCE,
  51         SR_CONF_TIMEBASE,
  52         SR_CONF_NUM_TIMEBASE,
  53         SR_CONF_TRIGGER_SLOPE,
  54         SR_CONF_HORIZ_TRIGGERPOS,
  55         SR_CONF_SAMPLERATE,
  56         SR_CONF_LIMIT_FRAMES,
  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         "DCL",
  70         "GND",
  71         NULL,
  72 };
  73
  74 static const char *scope_trigger_slopes[] = {
  75         "POS",
  76         "NEG",
  77         NULL,
  78 };
  79
  80 static const char *hmo_compact2_trigger_sources[] = {
  81         "CH1",
  82         "CH2",
  83         "LINE",
  84         "EXT",
  85         "D0",
  86         "D1",
  87         "D2",
  88         "D3",
  89         "D4",
  90         "D5",
  91         "D6",
  92         "D7",
  93         NULL,
  94 };
  95
  96 static const char *hmo_compact4_trigger_sources[] = {
  97         "CH1",
  98         "CH2",
  99         "CH3",
 100         "CH4",
 101         "LINE",
 102         "EXT",
 103         "D0",
 104         "D1",
 105         "D2",
 106         "D3",
 107         "D4",
 108         "D5",
 109         "D6",
 110         "D7",
 111         NULL,
 112 };
 113
 114 static const uint64_t hmo_timebases[][2] = {
 115         /* nanoseconds */
 116         { 2, 1000000000 },
 117         { 5, 1000000000 },
 118         { 10, 1000000000 },
 119         { 20, 1000000000 },
 120         { 50, 1000000000 },
 121         { 100, 1000000000 },
 122         { 200, 1000000000 },
 123         { 500, 1000000000 },
 124         /* microseconds */
 125         { 1, 1000000 },
 126         { 2, 1000000 },
 127         { 5, 1000000 },
 128         { 10, 1000000 },
 129         { 20, 1000000 },
 130         { 50, 1000000 },
 131         { 100, 1000000 },
 132         { 200, 1000000 },
 133         { 500, 1000000 },
 134         /* milliseconds */
 135         { 1, 1000 },
 136         { 2, 1000 },
 137         { 5, 1000 },
 138         { 10, 1000 },
 139         { 20, 1000 },
 140         { 50, 1000 },
 141         { 100, 1000 },
 142         { 200, 1000 },
 143         { 500, 1000 },
 144         /* seconds */
 145         { 1, 1 },
 146         { 2, 1 },
 147         { 5, 1 },
 148         { 10, 1 },
 149         { 20, 1 },
 150         { 50, 1 },
 151 };
 152
 153 static const uint64_t hmo_vdivs[][2] = {
 154         /* millivolts */
 155         { 1, 1000 },
 156         { 2, 1000 },
 157         { 5, 1000 },
 158         { 10, 1000 },
 159         { 20, 1000 },
 160         { 50, 1000 },
 161         { 100, 1000 },
 162         { 200, 1000 },
 163         { 500, 1000 },
 164         /* volts */
 165         { 1, 1 },
 166         { 2, 1 },
 167         { 5, 1 },
 168         { 10, 1 },
 169 };
 170
 171 static const char *scope_analog_channel_names[] = {
 172         "CH1",
 173         "CH2",
 174         "CH3",
 175         "CH4",
 176 };
 177
 178 static const char *scope_digital_channel_names[] = {
 179         "D0",
 180         "D1",
 181         "D2",
 182         "D3",
 183         "D4",
 184         "D5",
 185         "D6",
 186         "D7",
 187         "D8",
 188         "D9",
 189         "D10",
 190         "D11",
 191         "D12",
 192         "D13",
 193         "D14",
 194         "D15",
 195 };
 196
 197 static struct scope_config scope_models[] = {
 198         {
 199                 .name = {"HMO722", "HMO1022", "HMO1522", "HMO2022", NULL},
 200                 .analog_channels = 2,
 201                 .digital_channels = 8,
 202                 .digital_pods = 1,
 203
 204                 .analog_names = &scope_analog_channel_names,
 205                 .digital_names = &scope_digital_channel_names,
 206
 207                 .hw_caps = &hmo_hwcaps,
 208                 .num_hwcaps = ARRAY_SIZE(hmo_hwcaps),
 209
 210                 .analog_hwcaps = &hmo_analog_caps,
 211                 .num_analog_hwcaps = ARRAY_SIZE(hmo_analog_caps),
 212
 213                 .coupling_options = &hmo_coupling_options,
 214                 .trigger_sources = &hmo_compact2_trigger_sources,
 215                 .trigger_slopes = &scope_trigger_slopes,
 216
 217                 .timebases = &hmo_timebases,
 218                 .num_timebases = ARRAY_SIZE(hmo_timebases),
 219
 220                 .vdivs = &hmo_vdivs,
 221                 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
 222
 223                 .num_xdivs = 12,
 224                 .num_ydivs = 8,
 225
 226                 .scpi_dialect = &hameg_scpi_dialect,
 227         },
 228         {
 229                 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
 230                 .analog_channels = 4,
 231                 .digital_channels = 8,
 232                 .digital_pods = 1,
 233
 234                 .analog_names = &scope_analog_channel_names,
 235                 .digital_names = &scope_digital_channel_names,
 236
 237                 .hw_caps = &hmo_hwcaps,
 238                 .num_hwcaps = ARRAY_SIZE(hmo_hwcaps),
 239
 240                 .analog_hwcaps = &hmo_analog_caps,
 241                 .num_analog_hwcaps = ARRAY_SIZE(hmo_analog_caps),
 242
 243                 .coupling_options = &hmo_coupling_options,
 244                 .trigger_sources = &hmo_compact4_trigger_sources,
 245                 .trigger_slopes = &scope_trigger_slopes,
 246
 247                 .timebases = &hmo_timebases,
 248                 .num_timebases = ARRAY_SIZE(hmo_timebases),
 249
 250                 .vdivs = &hmo_vdivs,
 251                 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
 252
 253                 .num_xdivs = 12,
 254                 .num_ydivs = 8,
 255
 256                 .scpi_dialect = &hameg_scpi_dialect,
 257         },
 258 };
 259
 260 static void scope_state_dump(struct scope_config *config,
 261                              struct scope_state *state)
 262 {
 263         unsigned int i;
 264         char *tmp;
 265
 266         for (i = 0; i < config->analog_channels; ++i) {
 267                 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
 268                                              (*config->vdivs)[state->analog_channels[i].vdiv][1]);
 269                 sr_info("State of analog channel  %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
 270                         i + 1, state->analog_channels[i].state ? "On" : "Off",
 271                         (*config->coupling_options)[state->analog_channels[i].coupling],
 272                         tmp, state->analog_channels[i].vertical_offset);
 273         }
 274
 275         for (i = 0; i < config->digital_channels; ++i) {
 276                 sr_info("State of digital channel %d -> %s", i,
 277                         state->digital_channels[i] ? "On" : "Off");
 278         }
 279
 280         for (i = 0; i < config->digital_pods; ++i) {
 281                 sr_info("State of digital POD %d -> %s", i,
 282                         state->digital_pods[i] ? "On" : "Off");
 283         }
 284
 285         tmp = sr_period_string((*config->timebases)[state->timebase][0] *
 286                                (*config->timebases)[state->timebase][1]);
 287         sr_info("Current timebase: %s", tmp);
 288         g_free(tmp);
 289
 290         tmp = sr_samplerate_string(state->sample_rate);
 291         sr_info("Current samplerate: %s", tmp);
 292         g_free(tmp);
 293
 294         sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
 295                 (*config->trigger_sources)[state->trigger_source],
 296                 (*config->trigger_slopes)[state->trigger_slope],
 297                 state->horiz_triggerpos);
 298 }
 299
 300 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
 301                 const char *command, const char *(*array)[], int *result)
 302 {
 303         char *tmp;
 304         unsigned int i;
 305
 306         if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK) {
 307                 g_free(tmp);
 308                 return SR_ERR;
 309         }
 310
 311         for (i = 0; (*array)[i]; ++i) {
 312                 if (!g_strcmp0(tmp, (*array)[i])) {
 313                         *result = i;
 314                         g_free(tmp);
 315                         tmp = NULL;
 316                         break;
 317                 }
 318         }
 319
 320         if (tmp) {
 321                 g_free(tmp);
 322                 return SR_ERR;
 323         }
 324
 325         return SR_OK;
 326 }
 327
 328 static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi,
 329                                     struct scope_config *config,
 330                                     struct scope_state *state)
 331 {
 332         unsigned int i, j;
 333         float tmp_float;
 334         char command[MAX_COMMAND_SIZE];
 335
 336         for (i = 0; i < config->analog_channels; ++i) {
 337                 g_snprintf(command, sizeof(command),
 338                            (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
 339                            i + 1);
 340
 341                 if (sr_scpi_get_bool(scpi, command,
 342                                      &state->analog_channels[i].state) != SR_OK)
 343                         return SR_ERR;
 344
 345                 g_snprintf(command, sizeof(command),
 346                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
 347                            i + 1);
 348
 349                 if (sr_scpi_get_float(scpi, command, &tmp_float) != SR_OK)
 350                         return SR_ERR;
 351                 for (j = 0; j < config->num_vdivs; j++) {
 352                         if (tmp_float == ((float) (*config->vdivs)[j][0] /
 353                                           (*config->vdivs)[j][1])) {
 354                                 state->analog_channels[i].vdiv = j;
 355                                 break;
 356                         }
 357                 }
 358                 if (i == config->num_vdivs)
 359                         return SR_ERR;
 360
 361                 g_snprintf(command, sizeof(command),
 362                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
 363                            i + 1);
 364
 365                 if (sr_scpi_get_float(scpi, command,
 366                                      &state->analog_channels[i].vertical_offset) != SR_OK)
 367                         return SR_ERR;
 368
 369                 g_snprintf(command, sizeof(command),
 370                            (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
 371                            i + 1);
 372
 373                 if (scope_state_get_array_option(scpi, command, config->coupling_options,
 374                                          &state->analog_channels[i].coupling) != SR_OK)
 375                         return SR_ERR;
 376         }
 377
 378         return SR_OK;
 379 }
 380
 381 static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi,
 382                                      struct scope_config *config,
 383                                      struct scope_state *state)
 384 {
 385         unsigned int i;
 386         char command[MAX_COMMAND_SIZE];
 387
 388         for (i = 0; i < config->digital_channels; ++i) {
 389                 g_snprintf(command, sizeof(command),
 390                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
 391                            i);
 392
 393                 if (sr_scpi_get_bool(scpi, command,
 394                                      &state->digital_channels[i]) != SR_OK)
 395                         return SR_ERR;
 396         }
 397
 398         for (i = 0; i < config->digital_pods; ++i) {
 399                 g_snprintf(command, sizeof(command),
 400                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
 401                            i + 1);
 402
 403                 if (sr_scpi_get_bool(scpi, command,
 404                                      &state->digital_pods[i]) != SR_OK)
 405                         return SR_ERR;
 406         }
 407
 408         return SR_OK;
 409 }
 410
 411 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
 412 {
 413         struct dev_context *devc;
 414         struct scope_state *state;
 415         struct scope_config *config;
 416
 417         int tmp;
 418         unsigned int i;
 419         float tmp_float;
 420         gboolean channel_found;
 421         char tmp_str[MAX_COMMAND_SIZE];
 422         char chan_name[20];
 423
 424         devc = sdi->priv;
 425         config = devc->model_config;
 426         state = devc->model_state;
 427         channel_found = FALSE;
 428
 429         for (i = 0; i < config->analog_channels; ++i) {
 430                 if (state->analog_channels[i].state) {
 431                         g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
 432                         g_snprintf(tmp_str, sizeof(tmp_str),
 433                                    (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 434                                    chan_name);
 435                         channel_found = TRUE;
 436                         break;
 437                 }
 438         }
 439
 440         if (!channel_found) {
 441                 for (i = 0; i < config->digital_pods; i++) {
 442                         if (state->digital_pods[i]) {
 443                                 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
 444                                 g_snprintf(tmp_str, sizeof(tmp_str),
 445                                            (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 446                                            chan_name);
 447                                 channel_found = TRUE;
 448                                 break;
 449                         }
 450                 }
 451         }
 452
 453         /* No channel is active, ask the instrument for the sample rate
 454          * in single shot mode */
 455         if (!channel_found) {
 456                 if (sr_scpi_get_float(sdi->conn,
 457                                       (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
 458                                       &tmp_float) != SR_OK)
 459                         return SR_ERR;
 460
 461                 state->sample_rate = tmp_float;
 462         } else {
 463                 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
 464                         return SR_ERR;
 465                 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
 466                                              (*config->timebases)[state->timebase][1]) *
 467                                             config->num_xdivs);
 468         }
 469
 470         return SR_OK;
 471 }
 472
 473 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
 474 {
 475         struct dev_context *devc;
 476         struct scope_state *state;
 477         struct scope_config *config;
 478         float tmp_float;
 479         unsigned int i;
 480
 481         devc = sdi->priv;
 482         config = devc->model_config;
 483         state = devc->model_state;
 484
 485         sr_info("Fetching scope state");
 486
 487         if (analog_channel_state_get(sdi->conn, config, state) != SR_OK)
 488                 return SR_ERR;
 489
 490         if (digital_channel_state_get(sdi->conn, config, state) != SR_OK)
 491                 return SR_ERR;
 492
 493         if (sr_scpi_get_float(sdi->conn,
 494                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 495                         &tmp_float) != SR_OK)
 496                 return SR_ERR;
 497
 498         for (i = 0; i < config->num_timebases; i++) {
 499                 if (tmp_float == ((float) (*config->timebases)[i][0] /
 500                                   (*config->timebases)[i][1])) {
 501                         state->timebase = i;
 502                         break;
 503                 }
 504         }
 505         if (i == config->num_timebases)
 506                 return SR_ERR;
 507
 508         if (sr_scpi_get_float(sdi->conn,
 509                         (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
 510                         &tmp_float) != SR_OK)
 511                 return SR_ERR;
 512         state->horiz_triggerpos = tmp_float /
 513                 (((double) (*config->timebases)[state->timebase][0] /
 514                   (*config->timebases)[state->timebase][1]) * config->num_xdivs);
 515         state->horiz_triggerpos -= 0.5;
 516         state->horiz_triggerpos *= -1;
 517
 518         if (scope_state_get_array_option(sdi->conn,
 519                         (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
 520                         config->trigger_sources, &state->trigger_source) != SR_OK)
 521                 return SR_ERR;
 522
 523         if (scope_state_get_array_option(sdi->conn,
 524                 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
 525                 config->trigger_slopes, &state->trigger_slope) != SR_OK)
 526                 return SR_ERR;
 527
 528         if (hmo_update_sample_rate(sdi) != SR_OK)
 529                 return SR_ERR;
 530
 531         sr_info("Fetching finished.");
 532
 533         scope_state_dump(config, state);
 534
 535         return SR_OK;
 536 }
 537
 538 static struct scope_state *scope_state_new(struct scope_config *config)
 539 {
 540         struct scope_state *state;
 541
 542         if (!(state = g_try_malloc0(sizeof(struct scope_state))))
 543                 return NULL;
 544
 545         if (!(state->analog_channels = g_try_malloc0_n(config->analog_channels,
 546                                     sizeof(struct analog_channel_state))))
 547             goto fail;
 548
 549         if (!(state->digital_channels = g_try_malloc0_n(
 550                         config->digital_channels, sizeof(gboolean))))
 551             goto fail;
 552
 553         if (!(state->digital_pods = g_try_malloc0_n(config->digital_pods,
 554                                                      sizeof(gboolean))))
 555             goto fail;
 556
 557         return state;
 558
 559 fail:
 560         if (state->analog_channels)
 561                 g_free(state->analog_channels);
 562         if (state->digital_channels)
 563                 g_free(state->digital_channels);
 564         if (state->digital_pods)
 565                 g_free(state->digital_pods);
 566         g_free(state);
 567
 568         return NULL;
 569 }
 570
 571 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
 572 {
 573         g_free(state->analog_channels);
 574         g_free(state->digital_channels);
 575         g_free(state->digital_pods);
 576         g_free(state);
 577 }
 578
 579 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
 580 {
 581         char tmp[25];
 582         int model_index;
 583         unsigned int i, j;
 584         struct sr_channel *ch;
 585         struct dev_context *devc;
 586
 587         devc = sdi->priv;
 588         model_index = -1;
 589
 590         /* Find the exact model. */
 591         for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
 592                 for (j = 0; scope_models[i].name[j]; j++) {
 593                         if (!strcmp(sdi->model, scope_models[i].name[j])) {
 594                                 model_index = i;
 595                                 break;
 596                         }
 597                 }
 598                 if (model_index != -1)
 599                         break;
 600         }
 601
 602         if (model_index == -1) {
 603                 sr_dbg("Unsupported HMO device.");
 604                 return SR_ERR_NA;
 605         }
 606
 607         if (!(devc->analog_groups = g_try_malloc0(sizeof(struct sr_channel_group) *
 608                                                   scope_models[model_index].analog_channels)))
 609                         return SR_ERR_MALLOC;
 610
 611         if (!(devc->digital_groups = g_try_malloc0(sizeof(struct sr_channel_group) *
 612                                                    scope_models[model_index].digital_pods)))
 613                         return SR_ERR_MALLOC;
 614
 615         /* Add analog channels. */
 616         for (i = 0; i < scope_models[model_index].analog_channels; i++) {
 617                 if (!(ch = sr_channel_new(i, SR_CHANNEL_ANALOG, TRUE,
 618                            (*scope_models[model_index].analog_names)[i])))
 619                         return SR_ERR_MALLOC;
 620                 sdi->channels = g_slist_append(sdi->channels, ch);
 621
 622                 devc->analog_groups[i].name =
 623                         (char *)(*scope_models[model_index].analog_names)[i];
 624                 devc->analog_groups[i].channels = g_slist_append(NULL, ch);
 625
 626                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 627                                                    &devc->analog_groups[i]);
 628         }
 629
 630         /* Add digital channel groups. */
 631         for (i = 0; i < scope_models[model_index].digital_pods; ++i) {
 632                 g_snprintf(tmp, 25, "POD%d", i);
 633                 devc->digital_groups[i].name = g_strdup(tmp);
 634                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 635                                    &devc->digital_groups[i < 8 ? 0 : 1]);
 636         }
 637
 638         /* Add digital channels. */
 639         for (i = 0; i < scope_models[model_index].digital_channels; i++) {
 640                 if (!(ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE,
 641                            (*scope_models[model_index].digital_names)[i])))
 642                         return SR_ERR_MALLOC;
 643                 sdi->channels = g_slist_append(sdi->channels, ch);
 644
 645                 devc->digital_groups[i < 8 ? 0 : 1].channels = g_slist_append(
 646                         devc->digital_groups[i < 8 ? 0 : 1].channels, ch);
 647         }
 648
 649         devc->model_config = &scope_models[model_index];
 650         devc->frame_limit = 0;
 651
 652         if (!(devc->model_state = scope_state_new(devc->model_config)))
 653                 return SR_ERR_MALLOC;
 654
 655         return SR_OK;
 656 }
 657
 658 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
 659 {
 660         struct sr_channel *ch;
 661         struct sr_dev_inst *sdi;
 662         struct dev_context *devc;
 663         struct sr_datafeed_packet packet;
 664         GArray *data;
 665         struct sr_datafeed_analog analog;
 666         struct sr_datafeed_logic logic;
 667
 668         (void)fd;
 669
 670         if (!(sdi = cb_data))
 671                 return TRUE;
 672
 673         if (!(devc = sdi->priv))
 674                 return TRUE;
 675
 676         if (revents == G_IO_IN) {
 677                 ch = devc->current_channel->data;
 678
 679                 switch (ch->type) {
 680                 case SR_CHANNEL_ANALOG:
 681                         if (sr_scpi_get_floatv(sdi->conn, NULL, &data) != SR_OK) {
 682                                 if (data)
 683                                         g_array_free(data, TRUE);
 684
 685                                 return TRUE;
 686                         }
 687
 688                         packet.type = SR_DF_FRAME_BEGIN;
 689                         sr_session_send(sdi, &packet);
 690
 691                         analog.channels = g_slist_append(NULL, ch);
 692                         analog.num_samples = data->len;
 693                         analog.data = (float *) data->data;
 694                         analog.mq = SR_MQ_VOLTAGE;
 695                         analog.unit = SR_UNIT_VOLT;
 696                         analog.mqflags = 0;
 697                         packet.type = SR_DF_ANALOG;
 698                         packet.payload = &analog;
 699                         sr_session_send(cb_data, &packet);
 700                         g_slist_free(analog.channels);
 701                         g_array_free(data, TRUE);
 702                         break;
 703                 case SR_CHANNEL_LOGIC:
 704                         if (sr_scpi_get_uint8v(sdi->conn, NULL, &data) != SR_OK) {
 705                                 if (data)
 706                                         g_free(data);
 707                                 return TRUE;
 708                         }
 709
 710                         packet.type = SR_DF_FRAME_BEGIN;
 711                         sr_session_send(sdi, &packet);
 712
 713                         logic.length = data->len;
 714                         logic.unitsize = 1;
 715                         logic.data = data->data;
 716                         packet.type = SR_DF_LOGIC;
 717                         packet.payload = &logic;
 718                         sr_session_send(cb_data, &packet);
 719                         g_array_free(data, TRUE);
 720                         break;
 721                 default:
 722                         sr_err("Invalid channel type.");
 723                         break;
 724                 }
 725
 726                 packet.type = SR_DF_FRAME_END;
 727                 sr_session_send(sdi, &packet);
 728
 729                 if (devc->current_channel->next) {
 730                         devc->current_channel = devc->current_channel->next;
 731                         hmo_request_data(sdi);
 732                 } else if (++devc->num_frames == devc->frame_limit) {
 733                         sdi->driver->dev_acquisition_stop(sdi, cb_data);
 734                 } else {
 735                         devc->current_channel = devc->enabled_channels;
 736                         hmo_request_data(sdi);
 737                 }
 738         }
 739
 740         return TRUE;
 741 }