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 <config.h>
  21 #include <math.h>
  22 #include <stdlib.h>
  23 #include "scpi.h"
  24 #include "protocol.h"
  25
  26 static const char *hameg_scpi_dialect[] = {
  27         [SCPI_CMD_GET_DIG_DATA]             = ":FORM UINT,8;:POD%d:DATA?",
  28         [SCPI_CMD_GET_TIMEBASE]             = ":TIM:SCAL?",
  29         [SCPI_CMD_SET_TIMEBASE]             = ":TIM:SCAL %s",
  30         [SCPI_CMD_GET_COUPLING]             = ":CHAN%d:COUP?",
  31         [SCPI_CMD_SET_COUPLING]             = ":CHAN%d:COUP %s",
  32         [SCPI_CMD_GET_SAMPLE_RATE]          = ":ACQ:SRAT?",
  33         [SCPI_CMD_GET_SAMPLE_RATE_LIVE]     = ":%s:DATA:POINTS?",
  34         [SCPI_CMD_GET_ANALOG_DATA]          = ":FORM REAL,32;:CHAN%d:DATA?",
  35         [SCPI_CMD_GET_VERTICAL_DIV]         = ":CHAN%d:SCAL?",
  36         [SCPI_CMD_SET_VERTICAL_DIV]         = ":CHAN%d:SCAL %s",
  37         [SCPI_CMD_GET_DIG_POD_STATE]        = ":POD%d:STAT?",
  38         [SCPI_CMD_SET_DIG_POD_STATE]        = ":POD%d:STAT %d",
  39         [SCPI_CMD_GET_TRIGGER_SLOPE]        = ":TRIG:A:EDGE:SLOP?",
  40         [SCPI_CMD_SET_TRIGGER_SLOPE]        = ":TRIG:A:EDGE:SLOP %s",
  41         [SCPI_CMD_GET_TRIGGER_SOURCE]       = ":TRIG:A:SOUR?",
  42         [SCPI_CMD_SET_TRIGGER_SOURCE]       = ":TRIG:A:SOUR %s",
  43         [SCPI_CMD_GET_DIG_CHAN_STATE]       = ":LOG%d:STAT?",
  44         [SCPI_CMD_SET_DIG_CHAN_STATE]       = ":LOG%d:STAT %d",
  45         [SCPI_CMD_GET_VERTICAL_OFFSET]      = ":CHAN%d:POS?",
  46         [SCPI_CMD_GET_HORIZ_TRIGGERPOS]     = ":TIM:POS?",
  47         [SCPI_CMD_SET_HORIZ_TRIGGERPOS]     = ":TIM:POS %s",
  48         [SCPI_CMD_GET_ANALOG_CHAN_STATE]    = ":CHAN%d:STAT?",
  49         [SCPI_CMD_SET_ANALOG_CHAN_STATE]    = ":CHAN%d:STAT %d",
  50         [SCPI_CMD_GET_PROBE_UNIT]           = ":PROB%d:SET:ATT:UNIT?",
  51 };
  52
  53 static const uint32_t hmo_devopts[] = {
  54         SR_CONF_OSCILLOSCOPE,
  55         SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET,
  56         SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  57         SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  58         SR_CONF_NUM_HDIV | SR_CONF_GET,
  59         SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  60         SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
  61         SR_CONF_SAMPLERATE | SR_CONF_GET,
  62 };
  63
  64 static const uint32_t hmo_analog_devopts[] = {
  65         SR_CONF_NUM_VDIV | SR_CONF_GET,
  66         SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  67         SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  68 };
  69
  70 static const char *hmo_coupling_options[] = {
  71         "AC",
  72         "ACL",
  73         "DC",
  74         "DCL",
  75         "GND",
  76         NULL,
  77 };
  78
  79 static const char *scope_trigger_slopes[] = {
  80         "POS",
  81         "NEG",
  82         "EITH",
  83         NULL,
  84 };
  85
  86 static const char *hmo_compact2_trigger_sources[] = {
  87         "CH1",
  88         "CH2",
  89         "LINE",
  90         "EXT",
  91         "PATT",
  92         "BUS1",
  93         "BUS2",
  94         "D0",
  95         "D1",
  96         "D2",
  97         "D3",
  98         "D4",
  99         "D5",
 100         "D6",
 101         "D7",
 102         NULL,
 103 };
 104
 105 static const char *hmo_compact4_trigger_sources[] = {
 106         "CH1",
 107         "CH2",
 108         "CH3",
 109         "CH4",
 110         "LINE",
 111         "EXT",
 112         "PATT",
 113         "BUS1",
 114         "BUS2",
 115         "D0",
 116         "D1",
 117         "D2",
 118         "D3",
 119         "D4",
 120         "D5",
 121         "D6",
 122         "D7",
 123         NULL,
 124 };
 125
 126 static const uint64_t hmo_timebases[][2] = {
 127         /* nanoseconds */
 128         { 2, 1000000000 },
 129         { 5, 1000000000 },
 130         { 10, 1000000000 },
 131         { 20, 1000000000 },
 132         { 50, 1000000000 },
 133         { 100, 1000000000 },
 134         { 200, 1000000000 },
 135         { 500, 1000000000 },
 136         /* microseconds */
 137         { 1, 1000000 },
 138         { 2, 1000000 },
 139         { 5, 1000000 },
 140         { 10, 1000000 },
 141         { 20, 1000000 },
 142         { 50, 1000000 },
 143         { 100, 1000000 },
 144         { 200, 1000000 },
 145         { 500, 1000000 },
 146         /* milliseconds */
 147         { 1, 1000 },
 148         { 2, 1000 },
 149         { 5, 1000 },
 150         { 10, 1000 },
 151         { 20, 1000 },
 152         { 50, 1000 },
 153         { 100, 1000 },
 154         { 200, 1000 },
 155         { 500, 1000 },
 156         /* seconds */
 157         { 1, 1 },
 158         { 2, 1 },
 159         { 5, 1 },
 160         { 10, 1 },
 161         { 20, 1 },
 162         { 50, 1 },
 163 };
 164
 165 static const uint64_t hmo_vdivs[][2] = {
 166         /* millivolts */
 167         { 1, 1000 },
 168         { 2, 1000 },
 169         { 5, 1000 },
 170         { 10, 1000 },
 171         { 20, 1000 },
 172         { 50, 1000 },
 173         { 100, 1000 },
 174         { 200, 1000 },
 175         { 500, 1000 },
 176         /* volts */
 177         { 1, 1 },
 178         { 2, 1 },
 179         { 5, 1 },
 180         { 10, 1 },
 181         { 20, 1 },
 182         { 50, 1 },
 183 };
 184
 185 static const char *scope_analog_channel_names[] = {
 186         "CH1",
 187         "CH2",
 188         "CH3",
 189         "CH4",
 190 };
 191
 192 static const char *scope_digital_channel_names[] = {
 193         "D0",
 194         "D1",
 195         "D2",
 196         "D3",
 197         "D4",
 198         "D5",
 199         "D6",
 200         "D7",
 201         "D8",
 202         "D9",
 203         "D10",
 204         "D11",
 205         "D12",
 206         "D13",
 207         "D14",
 208         "D15",
 209 };
 210
 211 static const struct scope_config scope_models[] = {
 212         {
 213                 /* HMO2522/3032/3042/3052 support 16 digital channels but they're not supported yet. */
 214                 .name = {"HMO1002", "HMO722", "HMO1022", "HMO1522", "HMO2022", "HMO2522",
 215                                 "HMO3032", "HMO3042", "HMO3052", NULL},
 216                 .analog_channels = 2,
 217                 .digital_channels = 8,
 218                 .digital_pods = 1,
 219
 220                 .analog_names = &scope_analog_channel_names,
 221                 .digital_names = &scope_digital_channel_names,
 222
 223                 .devopts = &hmo_devopts,
 224                 .num_devopts = ARRAY_SIZE(hmo_devopts),
 225
 226                 .analog_devopts = &hmo_analog_devopts,
 227                 .num_analog_devopts = ARRAY_SIZE(hmo_analog_devopts),
 228
 229                 .coupling_options = &hmo_coupling_options,
 230                 .trigger_sources = &hmo_compact2_trigger_sources,
 231                 .trigger_slopes = &scope_trigger_slopes,
 232
 233                 .timebases = &hmo_timebases,
 234                 .num_timebases = ARRAY_SIZE(hmo_timebases),
 235
 236                 .vdivs = &hmo_vdivs,
 237                 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
 238
 239                 .num_xdivs = 12,
 240                 .num_ydivs = 8,
 241
 242                 .scpi_dialect = &hameg_scpi_dialect,
 243         },
 244         {
 245                 /* HMO2524/3034/3044/3054 support 16 digital channels but they're not supported yet. */
 246                 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", "HMO2524",
 247                                 "HMO3034", "HMO3044", "HMO3054", NULL},
 248                 .analog_channels = 4,
 249                 .digital_channels = 8,
 250                 .digital_pods = 1,
 251
 252                 .analog_names = &scope_analog_channel_names,
 253                 .digital_names = &scope_digital_channel_names,
 254
 255                 .devopts = &hmo_devopts,
 256                 .num_devopts = ARRAY_SIZE(hmo_devopts),
 257
 258                 .analog_devopts = &hmo_analog_devopts,
 259                 .num_analog_devopts = ARRAY_SIZE(hmo_analog_devopts),
 260
 261                 .coupling_options = &hmo_coupling_options,
 262                 .trigger_sources = &hmo_compact4_trigger_sources,
 263                 .trigger_slopes = &scope_trigger_slopes,
 264
 265                 .timebases = &hmo_timebases,
 266                 .num_timebases = ARRAY_SIZE(hmo_timebases),
 267
 268                 .vdivs = &hmo_vdivs,
 269                 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
 270
 271                 .num_xdivs = 12,
 272                 .num_ydivs = 8,
 273
 274                 .scpi_dialect = &hameg_scpi_dialect,
 275         },
 276 };
 277
 278 static void scope_state_dump(const struct scope_config *config,
 279                              struct scope_state *state)
 280 {
 281         unsigned int i;
 282         char *tmp;
 283
 284         for (i = 0; i < config->analog_channels; i++) {
 285                 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
 286                                              (*config->vdivs)[state->analog_channels[i].vdiv][1]);
 287                 sr_info("State of analog channel  %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
 288                         i + 1, state->analog_channels[i].state ? "On" : "Off",
 289                         (*config->coupling_options)[state->analog_channels[i].coupling],
 290                         tmp, state->analog_channels[i].vertical_offset);
 291         }
 292
 293         for (i = 0; i < config->digital_channels; i++) {
 294                 sr_info("State of digital channel %d -> %s", i,
 295                         state->digital_channels[i] ? "On" : "Off");
 296         }
 297
 298         for (i = 0; i < config->digital_pods; i++) {
 299                 sr_info("State of digital POD %d -> %s", i,
 300                         state->digital_pods[i] ? "On" : "Off");
 301         }
 302
 303         tmp = sr_period_string((*config->timebases)[state->timebase][0] *
 304                                (*config->timebases)[state->timebase][1]);
 305         sr_info("Current timebase: %s", tmp);
 306         g_free(tmp);
 307
 308         tmp = sr_samplerate_string(state->sample_rate);
 309         sr_info("Current samplerate: %s", tmp);
 310         g_free(tmp);
 311
 312         sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
 313                 (*config->trigger_sources)[state->trigger_source],
 314                 (*config->trigger_slopes)[state->trigger_slope],
 315                 state->horiz_triggerpos);
 316 }
 317
 318 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
 319                 const char *command, const char *(*array)[], int *result)
 320 {
 321         char *tmp;
 322         unsigned int i;
 323
 324         if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK) {
 325                 g_free(tmp);
 326                 return SR_ERR;
 327         }
 328
 329         for (i = 0; (*array)[i]; i++) {
 330                 if (!g_strcmp0(tmp, (*array)[i])) {
 331                         *result = i;
 332                         g_free(tmp);
 333                         tmp = NULL;
 334                         break;
 335                 }
 336         }
 337
 338         if (tmp) {
 339                 g_free(tmp);
 340                 return SR_ERR;
 341         }
 342
 343         return SR_OK;
 344 }
 345
 346 /**
 347  * This function takes a value of the form "2.000E-03" and returns the index
 348  * of an array where a matching pair was found.
 349  *
 350  * @param value The string to be parsed.
 351  * @param array The array of s/f pairs.
 352  * @param array_len The number of pairs in the array.
 353  * @param result The index at which a matching pair was found.
 354  *
 355  * @return SR_ERR on any parsing error, SR_OK otherwise.
 356  */
 357 static int array_float_get(gchar *value, const uint64_t array[][2],
 358                 int array_len, unsigned int *result)
 359 {
 360         struct sr_rational rval;
 361         struct sr_rational aval;
 362
 363         if (sr_parse_rational(value, &rval) != SR_OK)
 364                 return SR_ERR;
 365
 366         for (int i = 0; i < array_len; i++) {
 367                 sr_rational_set(&aval, array[i][0], array[i][1]);
 368                 if (sr_rational_eq(&rval, &aval)) {
 369                         *result = i;
 370                         return SR_OK;
 371                 }
 372         }
 373
 374         return SR_ERR;
 375 }
 376
 377 static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi,
 378                                     const struct scope_config *config,
 379                                     struct scope_state *state)
 380 {
 381         unsigned int i, j;
 382         char command[MAX_COMMAND_SIZE];
 383         char *tmp_str;
 384
 385         for (i = 0; i < config->analog_channels; i++) {
 386                 g_snprintf(command, sizeof(command),
 387                            (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
 388                            i + 1);
 389
 390                 if (sr_scpi_get_bool(scpi, command,
 391                                      &state->analog_channels[i].state) != SR_OK)
 392                         return SR_ERR;
 393
 394                 g_snprintf(command, sizeof(command),
 395                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
 396                            i + 1);
 397
 398                 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
 399                         return SR_ERR;
 400
 401                 if (array_float_get(tmp_str, hmo_vdivs, ARRAY_SIZE(hmo_vdivs),
 402                                 &j) != SR_OK) {
 403                         g_free(tmp_str);
 404                         sr_err("Could not determine array index for vertical div scale.");
 405                         return SR_ERR;
 406                 }
 407
 408                 g_free(tmp_str);
 409                 state->analog_channels[i].vdiv = j;
 410
 411                 g_snprintf(command, sizeof(command),
 412                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
 413                            i + 1);
 414
 415                 if (sr_scpi_get_float(scpi, command,
 416                                      &state->analog_channels[i].vertical_offset) != SR_OK)
 417                         return SR_ERR;
 418
 419                 g_snprintf(command, sizeof(command),
 420                            (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
 421                            i + 1);
 422
 423                 if (scope_state_get_array_option(scpi, command, config->coupling_options,
 424                                          &state->analog_channels[i].coupling) != SR_OK)
 425                         return SR_ERR;
 426
 427                 g_snprintf(command, sizeof(command),
 428                            (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
 429                            i + 1);
 430
 431                 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
 432                         return SR_ERR;
 433
 434                 if (tmp_str[0] == 'A')
 435                         state->analog_channels[i].probe_unit = 'A';
 436                 else
 437                         state->analog_channels[i].probe_unit = 'V';
 438                 g_free(tmp_str);
 439         }
 440
 441         return SR_OK;
 442 }
 443
 444 static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi,
 445                                      const struct scope_config *config,
 446                                      struct scope_state *state)
 447 {
 448         unsigned int i;
 449         char command[MAX_COMMAND_SIZE];
 450
 451         for (i = 0; i < config->digital_channels; i++) {
 452                 g_snprintf(command, sizeof(command),
 453                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
 454                            i);
 455
 456                 if (sr_scpi_get_bool(scpi, command,
 457                                      &state->digital_channels[i]) != SR_OK)
 458                         return SR_ERR;
 459         }
 460
 461         for (i = 0; i < config->digital_pods; i++) {
 462                 g_snprintf(command, sizeof(command),
 463                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
 464                            i + 1);
 465
 466                 if (sr_scpi_get_bool(scpi, command,
 467                                      &state->digital_pods[i]) != SR_OK)
 468                         return SR_ERR;
 469         }
 470
 471         return SR_OK;
 472 }
 473
 474 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
 475 {
 476         struct dev_context *devc;
 477         struct scope_state *state;
 478         const struct scope_config *config;
 479
 480         int tmp;
 481         unsigned int i;
 482         float tmp_float;
 483         gboolean channel_found;
 484         char tmp_str[MAX_COMMAND_SIZE];
 485         char chan_name[20];
 486
 487         devc = sdi->priv;
 488         config = devc->model_config;
 489         state = devc->model_state;
 490         channel_found = FALSE;
 491
 492         for (i = 0; i < config->analog_channels; i++) {
 493                 if (state->analog_channels[i].state) {
 494                         g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
 495                         g_snprintf(tmp_str, sizeof(tmp_str),
 496                                    (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 497                                    chan_name);
 498                         channel_found = TRUE;
 499                         break;
 500                 }
 501         }
 502
 503         if (!channel_found) {
 504                 for (i = 0; i < config->digital_pods; i++) {
 505                         if (state->digital_pods[i]) {
 506                                 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
 507                                 g_snprintf(tmp_str, sizeof(tmp_str),
 508                                            (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 509                                            chan_name);
 510                                 channel_found = TRUE;
 511                                 break;
 512                         }
 513                 }
 514         }
 515
 516         /* No channel is active, ask the instrument for the sample rate
 517          * in single shot mode */
 518         if (!channel_found) {
 519                 if (sr_scpi_get_float(sdi->conn,
 520                                       (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
 521                                       &tmp_float) != SR_OK)
 522                         return SR_ERR;
 523
 524                 state->sample_rate = tmp_float;
 525         } else {
 526                 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
 527                         return SR_ERR;
 528                 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
 529                                              (*config->timebases)[state->timebase][1]) *
 530                                             config->num_xdivs);
 531         }
 532
 533         return SR_OK;
 534 }
 535
 536 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
 537 {
 538         struct dev_context *devc;
 539         struct scope_state *state;
 540         const struct scope_config *config;
 541         float tmp_float;
 542         unsigned int i;
 543         char *tmp_str;
 544
 545         devc = sdi->priv;
 546         config = devc->model_config;
 547         state = devc->model_state;
 548
 549         sr_info("Fetching scope state");
 550
 551         if (analog_channel_state_get(sdi->conn, config, state) != SR_OK)
 552                 return SR_ERR;
 553
 554         if (digital_channel_state_get(sdi->conn, config, state) != SR_OK)
 555                 return SR_ERR;
 556
 557         if (sr_scpi_get_float(sdi->conn,
 558                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 559                         &tmp_float) != SR_OK)
 560                 return SR_ERR;
 561
 562         if (sr_scpi_get_string(sdi->conn,
 563                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 564                         &tmp_str) != SR_OK)
 565                 return SR_ERR;
 566
 567         if (array_float_get(tmp_str, hmo_timebases, ARRAY_SIZE(hmo_timebases),
 568                         &i) != SR_OK) {
 569                 g_free(tmp_str);
 570                 sr_err("Could not determine array index for time base.");
 571                 return SR_ERR;
 572         }
 573
 574         state->timebase = i;
 575
 576         if (sr_scpi_get_float(sdi->conn,
 577                         (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
 578                         &tmp_float) != SR_OK)
 579                 return SR_ERR;
 580         state->horiz_triggerpos = tmp_float /
 581                 (((double) (*config->timebases)[state->timebase][0] /
 582                   (*config->timebases)[state->timebase][1]) * config->num_xdivs);
 583         state->horiz_triggerpos -= 0.5;
 584         state->horiz_triggerpos *= -1;
 585
 586         if (scope_state_get_array_option(sdi->conn,
 587                         (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
 588                         config->trigger_sources, &state->trigger_source) != SR_OK)
 589                 return SR_ERR;
 590
 591         if (scope_state_get_array_option(sdi->conn,
 592                 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
 593                 config->trigger_slopes, &state->trigger_slope) != SR_OK)
 594                 return SR_ERR;
 595
 596         if (hmo_update_sample_rate(sdi) != SR_OK)
 597                 return SR_ERR;
 598
 599         sr_info("Fetching finished.");
 600
 601         scope_state_dump(config, state);
 602
 603         return SR_OK;
 604 }
 605
 606 static struct scope_state *scope_state_new(const struct scope_config *config)
 607 {
 608         struct scope_state *state;
 609
 610         state = g_malloc0(sizeof(struct scope_state));
 611         state->analog_channels = g_malloc0_n(config->analog_channels,
 612                         sizeof(struct analog_channel_state));
 613         state->digital_channels = g_malloc0_n(
 614                         config->digital_channels, sizeof(gboolean));
 615         state->digital_pods = g_malloc0_n(config->digital_pods,
 616                         sizeof(gboolean));
 617
 618         return state;
 619 }
 620
 621 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
 622 {
 623         g_free(state->analog_channels);
 624         g_free(state->digital_channels);
 625         g_free(state->digital_pods);
 626         g_free(state);
 627 }
 628
 629 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
 630 {
 631         char tmp[25];
 632         int model_index;
 633         unsigned int i, j;
 634         struct sr_channel *ch;
 635         struct dev_context *devc;
 636
 637         devc = sdi->priv;
 638         model_index = -1;
 639
 640         /* Find the exact model. */
 641         for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
 642                 for (j = 0; scope_models[i].name[j]; j++) {
 643                         if (!strcmp(sdi->model, scope_models[i].name[j])) {
 644                                 model_index = i;
 645                                 break;
 646                         }
 647                 }
 648                 if (model_index != -1)
 649                         break;
 650         }
 651
 652         if (model_index == -1) {
 653                 sr_dbg("Unsupported HMO device.");
 654                 return SR_ERR_NA;
 655         }
 656
 657         devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 658                                         scope_models[model_index].analog_channels);
 659
 660         devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 661                                          scope_models[model_index].digital_pods);
 662
 663         /* Add analog channels. */
 664         for (i = 0; i < scope_models[model_index].analog_channels; i++) {
 665                 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
 666                            (*scope_models[model_index].analog_names)[i]);
 667
 668                 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 669
 670                 devc->analog_groups[i]->name = g_strdup(
 671                         (char *)(*scope_models[model_index].analog_names)[i]);
 672                 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
 673
 674                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 675                                                    devc->analog_groups[i]);
 676         }
 677
 678         /* Add digital channel groups. */
 679         for (i = 0; i < scope_models[model_index].digital_pods; i++) {
 680                 g_snprintf(tmp, 25, "POD%d", i);
 681
 682                 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 683
 684                 devc->digital_groups[i]->name = g_strdup(tmp);
 685                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 686                                    devc->digital_groups[i < 8 ? 0 : 1]);
 687         }
 688
 689         /* Add digital channels. */
 690         for (i = 0; i < scope_models[model_index].digital_channels; i++) {
 691                 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
 692                            (*scope_models[model_index].digital_names)[i]);
 693
 694                 devc->digital_groups[i < 8 ? 0 : 1]->channels = g_slist_append(
 695                         devc->digital_groups[i < 8 ? 0 : 1]->channels, ch);
 696         }
 697
 698         devc->model_config = &scope_models[model_index];
 699         devc->frame_limit = 0;
 700
 701         if (!(devc->model_state = scope_state_new(devc->model_config)))
 702                 return SR_ERR_MALLOC;
 703
 704         return SR_OK;
 705 }
 706
 707 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
 708 {
 709         struct sr_channel *ch;
 710         struct sr_dev_inst *sdi;
 711         struct dev_context *devc;
 712         struct scope_state *state;
 713         struct sr_datafeed_packet packet;
 714         GByteArray *data;
 715         struct sr_datafeed_analog analog;
 716         struct sr_analog_encoding encoding;
 717         struct sr_analog_meaning meaning;
 718         struct sr_analog_spec spec;
 719         struct sr_datafeed_logic logic;
 720
 721         (void)fd;
 722         (void)revents;
 723
 724         data = NULL;
 725
 726         if (!(sdi = cb_data))
 727                 return TRUE;
 728
 729         if (!(devc = sdi->priv))
 730                 return TRUE;
 731
 732         /* Although this is correct in general, the USBTMC libusb implementation
 733          * currently does not generate an event prior to the first read. Often
 734          * it is ok to start reading just after the 50ms timeout. See bug #785.
 735         if (revents != G_IO_IN)
 736                 return TRUE;
 737         */
 738
 739         ch = devc->current_channel->data;
 740         state = devc->model_state;
 741
 742         switch (ch->type) {
 743         case SR_CHANNEL_ANALOG:
 744                 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
 745                         if (data)
 746                                 g_byte_array_free(data, TRUE);
 747
 748                         return TRUE;
 749                 }
 750
 751                 packet.type = SR_DF_FRAME_BEGIN;
 752                 sr_session_send(sdi, &packet);
 753
 754                 packet.type = SR_DF_ANALOG;
 755
 756                 analog.data = data->data;
 757                 analog.num_samples = data->len / sizeof(float);
 758                 analog.encoding = &encoding;
 759                 analog.meaning = &meaning;
 760                 analog.spec = &spec;
 761
 762                 encoding.unitsize = sizeof(float);
 763                 encoding.is_signed = TRUE;
 764                 encoding.is_float = TRUE;
 765                 encoding.is_bigendian = FALSE;
 766                 encoding.digits = 0;
 767                 encoding.is_digits_decimal = FALSE;
 768                 encoding.scale.p = 1;
 769                 encoding.scale.q = 1;
 770                 encoding.offset.p = 0;
 771                 encoding.offset.q = 1;
 772                 if (state->analog_channels[ch->index].probe_unit == 'V') {
 773                         meaning.mq = SR_MQ_VOLTAGE;
 774                         meaning.unit = SR_UNIT_VOLT;
 775                 } else {
 776                         meaning.mq = SR_MQ_CURRENT;
 777                         meaning.unit = SR_UNIT_AMPERE;
 778                 }
 779                 meaning.mqflags = 0;
 780                 meaning.channels = g_slist_append(NULL, ch);
 781                 spec.spec_digits = 0;
 782                 packet.payload = &analog;
 783                 sr_session_send(sdi, &packet);
 784                 g_slist_free(meaning.channels);
 785                 g_byte_array_free(data, TRUE);
 786                 data = NULL;
 787                 break;
 788         case SR_CHANNEL_LOGIC:
 789                 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
 790                         g_free(data);
 791                         return TRUE;
 792                 }
 793
 794                 packet.type = SR_DF_FRAME_BEGIN;
 795                 sr_session_send(sdi, &packet);
 796
 797                 logic.length = data->len;
 798                 logic.unitsize = 1;
 799                 logic.data = data->data;
 800                 packet.type = SR_DF_LOGIC;
 801                 packet.payload = &logic;
 802                 sr_session_send(sdi, &packet);
 803                 g_byte_array_free(data, TRUE);
 804                 data = NULL;
 805                 break;
 806         default:
 807                 sr_err("Invalid channel type.");
 808                 break;
 809         }
 810
 811         packet.type = SR_DF_FRAME_END;
 812         sr_session_send(sdi, &packet);
 813
 814         if (devc->current_channel->next) {
 815                 devc->current_channel = devc->current_channel->next;
 816                 hmo_request_data(sdi);
 817         } else if (++devc->num_frames == devc->frame_limit) {
 818                 sdi->driver->dev_acquisition_stop(sdi);
 819         } else {
 820                 devc->current_channel = devc->enabled_channels;
 821                 hmo_request_data(sdi);
 822         }
 823
 824         return TRUE;
 825 }