src/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 uint32_t hmo_devopts[] = {
  49         SR_CONF_OSCILLOSCOPE,
  50         SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET,
  51         SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  52         SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  53         SR_CONF_NUM_TIMEBASE | SR_CONF_GET,
  54         SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  55         SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
  56         SR_CONF_SAMPLERATE | SR_CONF_GET,
  57 };
  58
  59 static const uint32_t hmo_analog_devopts[] = {
  60         SR_CONF_NUM_VDIV | SR_CONF_GET,
  61         SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  62         SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  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                 .devopts = &hmo_devopts,
 208                 .num_devopts = ARRAY_SIZE(hmo_devopts),
 209
 210                 .analog_devopts = &hmo_analog_devopts,
 211                 .num_analog_devopts = ARRAY_SIZE(hmo_analog_devopts),
 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                 .devopts = &hmo_devopts,
 238                 .num_devopts = ARRAY_SIZE(hmo_devopts),
 239
 240                 .analog_devopts = &hmo_analog_devopts,
 241                 .num_analog_devopts = ARRAY_SIZE(hmo_analog_devopts),
 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 (j == config->num_vdivs) {
 359                         sr_err("Could not determine array index for vertical div scale.");
 360                         return SR_ERR;
 361                 }
 362
 363                 g_snprintf(command, sizeof(command),
 364                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
 365                            i + 1);
 366
 367                 if (sr_scpi_get_float(scpi, command,
 368                                      &state->analog_channels[i].vertical_offset) != SR_OK)
 369                         return SR_ERR;
 370
 371                 g_snprintf(command, sizeof(command),
 372                            (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
 373                            i + 1);
 374
 375                 if (scope_state_get_array_option(scpi, command, config->coupling_options,
 376                                          &state->analog_channels[i].coupling) != SR_OK)
 377                         return SR_ERR;
 378         }
 379
 380         return SR_OK;
 381 }
 382
 383 static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi,
 384                                      struct scope_config *config,
 385                                      struct scope_state *state)
 386 {
 387         unsigned int i;
 388         char command[MAX_COMMAND_SIZE];
 389
 390         for (i = 0; i < config->digital_channels; ++i) {
 391                 g_snprintf(command, sizeof(command),
 392                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
 393                            i);
 394
 395                 if (sr_scpi_get_bool(scpi, command,
 396                                      &state->digital_channels[i]) != SR_OK)
 397                         return SR_ERR;
 398         }
 399
 400         for (i = 0; i < config->digital_pods; ++i) {
 401                 g_snprintf(command, sizeof(command),
 402                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
 403                            i + 1);
 404
 405                 if (sr_scpi_get_bool(scpi, command,
 406                                      &state->digital_pods[i]) != SR_OK)
 407                         return SR_ERR;
 408         }
 409
 410         return SR_OK;
 411 }
 412
 413 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
 414 {
 415         struct dev_context *devc;
 416         struct scope_state *state;
 417         struct scope_config *config;
 418
 419         int tmp;
 420         unsigned int i;
 421         float tmp_float;
 422         gboolean channel_found;
 423         char tmp_str[MAX_COMMAND_SIZE];
 424         char chan_name[20];
 425
 426         devc = sdi->priv;
 427         config = devc->model_config;
 428         state = devc->model_state;
 429         channel_found = FALSE;
 430
 431         for (i = 0; i < config->analog_channels; ++i) {
 432                 if (state->analog_channels[i].state) {
 433                         g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
 434                         g_snprintf(tmp_str, sizeof(tmp_str),
 435                                    (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 436                                    chan_name);
 437                         channel_found = TRUE;
 438                         break;
 439                 }
 440         }
 441
 442         if (!channel_found) {
 443                 for (i = 0; i < config->digital_pods; i++) {
 444                         if (state->digital_pods[i]) {
 445                                 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
 446                                 g_snprintf(tmp_str, sizeof(tmp_str),
 447                                            (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 448                                            chan_name);
 449                                 channel_found = TRUE;
 450                                 break;
 451                         }
 452                 }
 453         }
 454
 455         /* No channel is active, ask the instrument for the sample rate
 456          * in single shot mode */
 457         if (!channel_found) {
 458                 if (sr_scpi_get_float(sdi->conn,
 459                                       (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
 460                                       &tmp_float) != SR_OK)
 461                         return SR_ERR;
 462
 463                 state->sample_rate = tmp_float;
 464         } else {
 465                 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
 466                         return SR_ERR;
 467                 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
 468                                              (*config->timebases)[state->timebase][1]) *
 469                                             config->num_xdivs);
 470         }
 471
 472         return SR_OK;
 473 }
 474
 475 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
 476 {
 477         struct dev_context *devc;
 478         struct scope_state *state;
 479         struct scope_config *config;
 480         float tmp_float;
 481         unsigned int i;
 482
 483         devc = sdi->priv;
 484         config = devc->model_config;
 485         state = devc->model_state;
 486
 487         sr_info("Fetching scope state");
 488
 489         if (analog_channel_state_get(sdi->conn, config, state) != SR_OK)
 490                 return SR_ERR;
 491
 492         if (digital_channel_state_get(sdi->conn, config, state) != SR_OK)
 493                 return SR_ERR;
 494
 495         if (sr_scpi_get_float(sdi->conn,
 496                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 497                         &tmp_float) != SR_OK)
 498                 return SR_ERR;
 499
 500         for (i = 0; i < config->num_timebases; i++) {
 501                 if (tmp_float == ((float) (*config->timebases)[i][0] /
 502                                   (*config->timebases)[i][1])) {
 503                         state->timebase = i;
 504                         break;
 505                 }
 506         }
 507         if (i == config->num_timebases) {
 508                 sr_err("Could not determine array index for time base.");
 509                 return SR_ERR;
 510         }
 511
 512         if (sr_scpi_get_float(sdi->conn,
 513                         (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
 514                         &tmp_float) != SR_OK)
 515                 return SR_ERR;
 516         state->horiz_triggerpos = tmp_float /
 517                 (((double) (*config->timebases)[state->timebase][0] /
 518                   (*config->timebases)[state->timebase][1]) * config->num_xdivs);
 519         state->horiz_triggerpos -= 0.5;
 520         state->horiz_triggerpos *= -1;
 521
 522         if (scope_state_get_array_option(sdi->conn,
 523                         (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
 524                         config->trigger_sources, &state->trigger_source) != SR_OK)
 525                 return SR_ERR;
 526
 527         if (scope_state_get_array_option(sdi->conn,
 528                 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
 529                 config->trigger_slopes, &state->trigger_slope) != SR_OK)
 530                 return SR_ERR;
 531
 532         if (hmo_update_sample_rate(sdi) != SR_OK)
 533                 return SR_ERR;
 534
 535         sr_info("Fetching finished.");
 536
 537         scope_state_dump(config, state);
 538
 539         return SR_OK;
 540 }
 541
 542 static struct scope_state *scope_state_new(struct scope_config *config)
 543 {
 544         struct scope_state *state;
 545
 546         if (!(state = g_try_malloc0(sizeof(struct scope_state))))
 547                 return NULL;
 548
 549         if (!(state->analog_channels = g_try_malloc0_n(config->analog_channels,
 550                                     sizeof(struct analog_channel_state))))
 551             goto fail;
 552
 553         if (!(state->digital_channels = g_try_malloc0_n(
 554                         config->digital_channels, sizeof(gboolean))))
 555             goto fail;
 556
 557         if (!(state->digital_pods = g_try_malloc0_n(config->digital_pods,
 558                                                      sizeof(gboolean))))
 559             goto fail;
 560
 561         return state;
 562
 563 fail:
 564         if (state->analog_channels)
 565                 g_free(state->analog_channels);
 566         if (state->digital_channels)
 567                 g_free(state->digital_channels);
 568         if (state->digital_pods)
 569                 g_free(state->digital_pods);
 570         g_free(state);
 571
 572         return NULL;
 573 }
 574
 575 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
 576 {
 577         g_free(state->analog_channels);
 578         g_free(state->digital_channels);
 579         g_free(state->digital_pods);
 580         g_free(state);
 581 }
 582
 583 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
 584 {
 585         char tmp[25];
 586         int model_index;
 587         unsigned int i, j;
 588         struct sr_channel *ch;
 589         struct dev_context *devc;
 590
 591         devc = sdi->priv;
 592         model_index = -1;
 593
 594         /* Find the exact model. */
 595         for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
 596                 for (j = 0; scope_models[i].name[j]; j++) {
 597                         if (!strcmp(sdi->model, scope_models[i].name[j])) {
 598                                 model_index = i;
 599                                 break;
 600                         }
 601                 }
 602                 if (model_index != -1)
 603                         break;
 604         }
 605
 606         if (model_index == -1) {
 607                 sr_dbg("Unsupported HMO device.");
 608                 return SR_ERR_NA;
 609         }
 610
 611         devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 612                                         scope_models[model_index].analog_channels);
 613
 614         devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 615                                          scope_models[model_index].digital_pods);
 616
 617         /* Add analog channels. */
 618         for (i = 0; i < scope_models[model_index].analog_channels; i++) {
 619                 ch = sr_channel_new(i, SR_CHANNEL_ANALOG, TRUE,
 620                            (*scope_models[model_index].analog_names)[i]);
 621                 sdi->channels = g_slist_append(sdi->channels, ch);
 622
 623                 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 624
 625                 devc->analog_groups[i]->name = g_strdup(
 626                         (char *)(*scope_models[model_index].analog_names)[i]);
 627                 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
 628
 629                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 630                                                    devc->analog_groups[i]);
 631         }
 632
 633         /* Add digital channel groups. */
 634         for (i = 0; i < scope_models[model_index].digital_pods; ++i) {
 635                 g_snprintf(tmp, 25, "POD%d", i);
 636
 637                 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 638
 639                 devc->digital_groups[i]->name = g_strdup(tmp);
 640                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 641                                    devc->digital_groups[i < 8 ? 0 : 1]);
 642         }
 643
 644         /* Add digital channels. */
 645         for (i = 0; i < scope_models[model_index].digital_channels; i++) {
 646                 ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE,
 647                            (*scope_models[model_index].digital_names)[i]);
 648                 sdi->channels = g_slist_append(sdi->channels, ch);
 649
 650                 devc->digital_groups[i < 8 ? 0 : 1]->channels = g_slist_append(
 651                         devc->digital_groups[i < 8 ? 0 : 1]->channels, ch);
 652         }
 653
 654         devc->model_config = &scope_models[model_index];
 655         devc->frame_limit = 0;
 656
 657         if (!(devc->model_state = scope_state_new(devc->model_config)))
 658                 return SR_ERR_MALLOC;
 659
 660         return SR_OK;
 661 }
 662
 663 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
 664 {
 665         struct sr_channel *ch;
 666         struct sr_dev_inst *sdi;
 667         struct dev_context *devc;
 668         struct sr_datafeed_packet packet;
 669         GArray *data;
 670         struct sr_datafeed_analog analog;
 671         struct sr_datafeed_logic logic;
 672
 673         (void)fd;
 674
 675         data = NULL;
 676
 677         if (!(sdi = cb_data))
 678                 return TRUE;
 679
 680         if (!(devc = sdi->priv))
 681                 return TRUE;
 682
 683         if (revents == G_IO_IN) {
 684                 ch = devc->current_channel->data;
 685
 686                 switch (ch->type) {
 687                 case SR_CHANNEL_ANALOG:
 688                         if (sr_scpi_get_floatv(sdi->conn, NULL, &data) != SR_OK) {
 689                                 if (data)
 690                                         g_array_free(data, TRUE);
 691
 692                                 return TRUE;
 693                         }
 694
 695                         packet.type = SR_DF_FRAME_BEGIN;
 696                         sr_session_send(sdi, &packet);
 697
 698                         analog.channels = g_slist_append(NULL, ch);
 699                         analog.num_samples = data->len;
 700                         analog.data = (float *) data->data;
 701                         analog.mq = SR_MQ_VOLTAGE;
 702                         analog.unit = SR_UNIT_VOLT;
 703                         analog.mqflags = 0;
 704                         packet.type = SR_DF_ANALOG;
 705                         packet.payload = &analog;
 706                         sr_session_send(cb_data, &packet);
 707                         g_slist_free(analog.channels);
 708                         g_array_free(data, TRUE);
 709                         data = NULL;
 710                         break;
 711                 case SR_CHANNEL_LOGIC:
 712                         if (sr_scpi_get_uint8v(sdi->conn, NULL, &data) != SR_OK) {
 713                                 if (data)
 714                                         g_free(data);
 715                                 return TRUE;
 716                         }
 717
 718                         packet.type = SR_DF_FRAME_BEGIN;
 719                         sr_session_send(sdi, &packet);
 720
 721                         logic.length = data->len;
 722                         logic.unitsize = 1;
 723                         logic.data = data->data;
 724                         packet.type = SR_DF_LOGIC;
 725                         packet.payload = &logic;
 726                         sr_session_send(cb_data, &packet);
 727                         g_array_free(data, TRUE);
 728                         data = NULL;
 729                         break;
 730                 default:
 731                         sr_err("Invalid channel type.");
 732                         break;
 733                 }
 734
 735                 packet.type = SR_DF_FRAME_END;
 736                 sr_session_send(sdi, &packet);
 737
 738                 if (devc->current_channel->next) {
 739                         devc->current_channel = devc->current_channel->next;
 740                         hmo_request_data(sdi);
 741                 } else if (++devc->num_frames == devc->frame_limit) {
 742                         sdi->driver->dev_acquisition_stop(sdi, cb_data);
 743                 } else {
 744                         devc->current_channel = devc->enabled_channels;
 745                         hmo_request_data(sdi);
 746                 }
 747         }
 748
 749         return TRUE;
 750 }