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",  // AC with 50 Ohm termination (152x, 202x, 30xx, 1202)
  72         "ACL", // AC with 1 MOhm termination
  73         "DC",  // DC with 50 Ohm termination
  74         "DCL", // DC with 1 MOhm termination
  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         g_free(tmp_str);
 574
 575         state->timebase = i;
 576
 577         if (sr_scpi_get_float(sdi->conn,
 578                         (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
 579                         &tmp_float) != SR_OK)
 580                 return SR_ERR;
 581         state->horiz_triggerpos = tmp_float /
 582                 (((double) (*config->timebases)[state->timebase][0] /
 583                   (*config->timebases)[state->timebase][1]) * config->num_xdivs);
 584         state->horiz_triggerpos -= 0.5;
 585         state->horiz_triggerpos *= -1;
 586
 587         if (scope_state_get_array_option(sdi->conn,
 588                         (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
 589                         config->trigger_sources, &state->trigger_source) != SR_OK)
 590                 return SR_ERR;
 591
 592         if (scope_state_get_array_option(sdi->conn,
 593                 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
 594                 config->trigger_slopes, &state->trigger_slope) != SR_OK)
 595                 return SR_ERR;
 596
 597         if (hmo_update_sample_rate(sdi) != SR_OK)
 598                 return SR_ERR;
 599
 600         sr_info("Fetching finished.");
 601
 602         scope_state_dump(config, state);
 603
 604         return SR_OK;
 605 }
 606
 607 static struct scope_state *scope_state_new(const struct scope_config *config)
 608 {
 609         struct scope_state *state;
 610
 611         state = g_malloc0(sizeof(struct scope_state));
 612         state->analog_channels = g_malloc0_n(config->analog_channels,
 613                         sizeof(struct analog_channel_state));
 614         state->digital_channels = g_malloc0_n(
 615                         config->digital_channels, sizeof(gboolean));
 616         state->digital_pods = g_malloc0_n(config->digital_pods,
 617                         sizeof(gboolean));
 618
 619         return state;
 620 }
 621
 622 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
 623 {
 624         g_free(state->analog_channels);
 625         g_free(state->digital_channels);
 626         g_free(state->digital_pods);
 627         g_free(state);
 628 }
 629
 630 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
 631 {
 632         char tmp[25];
 633         int model_index;
 634         unsigned int i, j;
 635         struct sr_channel *ch;
 636         struct dev_context *devc;
 637
 638         devc = sdi->priv;
 639         model_index = -1;
 640
 641         /* Find the exact model. */
 642         for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
 643                 for (j = 0; scope_models[i].name[j]; j++) {
 644                         if (!strcmp(sdi->model, scope_models[i].name[j])) {
 645                                 model_index = i;
 646                                 break;
 647                         }
 648                 }
 649                 if (model_index != -1)
 650                         break;
 651         }
 652
 653         if (model_index == -1) {
 654                 sr_dbg("Unsupported HMO device.");
 655                 return SR_ERR_NA;
 656         }
 657
 658         devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 659                                         scope_models[model_index].analog_channels);
 660
 661         devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 662                                          scope_models[model_index].digital_pods);
 663
 664         /* Add analog channels. */
 665         for (i = 0; i < scope_models[model_index].analog_channels; i++) {
 666                 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
 667                            (*scope_models[model_index].analog_names)[i]);
 668
 669                 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 670
 671                 devc->analog_groups[i]->name = g_strdup(
 672                         (char *)(*scope_models[model_index].analog_names)[i]);
 673                 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
 674
 675                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 676                                                    devc->analog_groups[i]);
 677         }
 678
 679         /* Add digital channel groups. */
 680         for (i = 0; i < scope_models[model_index].digital_pods; i++) {
 681                 g_snprintf(tmp, 25, "POD%d", i);
 682
 683                 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 684
 685                 devc->digital_groups[i]->name = g_strdup(tmp);
 686                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 687                                    devc->digital_groups[i < 8 ? 0 : 1]);
 688         }
 689
 690         /* Add digital channels. */
 691         for (i = 0; i < scope_models[model_index].digital_channels; i++) {
 692                 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
 693                            (*scope_models[model_index].digital_names)[i]);
 694
 695                 devc->digital_groups[i < 8 ? 0 : 1]->channels = g_slist_append(
 696                         devc->digital_groups[i < 8 ? 0 : 1]->channels, ch);
 697         }
 698
 699         devc->model_config = &scope_models[model_index];
 700         devc->frame_limit = 0;
 701
 702         if (!(devc->model_state = scope_state_new(devc->model_config)))
 703                 return SR_ERR_MALLOC;
 704
 705         return SR_OK;
 706 }
 707
 708 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
 709 {
 710         struct sr_channel *ch;
 711         struct sr_dev_inst *sdi;
 712         struct dev_context *devc;
 713         struct scope_state *state;
 714         struct sr_datafeed_packet packet;
 715         GByteArray *data;
 716         struct sr_datafeed_analog analog;
 717         struct sr_analog_encoding encoding;
 718         struct sr_analog_meaning meaning;
 719         struct sr_analog_spec spec;
 720         struct sr_datafeed_logic logic;
 721
 722         (void)fd;
 723         (void)revents;
 724
 725         data = NULL;
 726
 727         if (!(sdi = cb_data))
 728                 return TRUE;
 729
 730         if (!(devc = sdi->priv))
 731                 return TRUE;
 732
 733         /* Although this is correct in general, the USBTMC libusb implementation
 734          * currently does not generate an event prior to the first read. Often
 735          * it is ok to start reading just after the 50ms timeout. See bug #785.
 736         if (revents != G_IO_IN)
 737                 return TRUE;
 738         */
 739
 740         ch = devc->current_channel->data;
 741         state = devc->model_state;
 742
 743         switch (ch->type) {
 744         case SR_CHANNEL_ANALOG:
 745                 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
 746                         if (data)
 747                                 g_byte_array_free(data, TRUE);
 748
 749                         return TRUE;
 750                 }
 751
 752                 packet.type = SR_DF_FRAME_BEGIN;
 753                 sr_session_send(sdi, &packet);
 754
 755                 packet.type = SR_DF_ANALOG;
 756
 757                 analog.data = data->data;
 758                 analog.num_samples = data->len / sizeof(float);
 759                 analog.encoding = &encoding;
 760                 analog.meaning = &meaning;
 761                 analog.spec = &spec;
 762
 763                 encoding.unitsize = sizeof(float);
 764                 encoding.is_signed = TRUE;
 765                 encoding.is_float = TRUE;
 766                 encoding.is_bigendian = FALSE;
 767                 encoding.digits = 0;
 768                 encoding.is_digits_decimal = FALSE;
 769                 encoding.scale.p = 1;
 770                 encoding.scale.q = 1;
 771                 encoding.offset.p = 0;
 772                 encoding.offset.q = 1;
 773                 if (state->analog_channels[ch->index].probe_unit == 'V') {
 774                         meaning.mq = SR_MQ_VOLTAGE;
 775                         meaning.unit = SR_UNIT_VOLT;
 776                 } else {
 777                         meaning.mq = SR_MQ_CURRENT;
 778                         meaning.unit = SR_UNIT_AMPERE;
 779                 }
 780                 meaning.mqflags = 0;
 781                 meaning.channels = g_slist_append(NULL, ch);
 782                 spec.spec_digits = 0;
 783                 packet.payload = &analog;
 784                 sr_session_send(sdi, &packet);
 785                 g_slist_free(meaning.channels);
 786                 g_byte_array_free(data, TRUE);
 787                 data = NULL;
 788                 break;
 789         case SR_CHANNEL_LOGIC:
 790                 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
 791                         g_free(data);
 792                         return TRUE;
 793                 }
 794
 795                 packet.type = SR_DF_FRAME_BEGIN;
 796                 sr_session_send(sdi, &packet);
 797
 798                 logic.length = data->len;
 799                 logic.unitsize = 1;
 800                 logic.data = data->data;
 801                 packet.type = SR_DF_LOGIC;
 802                 packet.payload = &logic;
 803                 sr_session_send(sdi, &packet);
 804                 g_byte_array_free(data, TRUE);
 805                 data = NULL;
 806                 break;
 807         default:
 808                 sr_err("Invalid channel type.");
 809                 break;
 810         }
 811
 812         packet.type = SR_DF_FRAME_END;
 813         sr_session_send(sdi, &packet);
 814
 815         if (devc->current_channel->next) {
 816                 devc->current_channel = devc->current_channel->next;
 817                 hmo_request_data(sdi);
 818         } else if (++devc->num_frames == devc->frame_limit) {
 819                 sdi->driver->dev_acquisition_stop(sdi);
 820         } else {
 821                 devc->current_channel = devc->enabled_channels;
 822                 hmo_request_data(sdi);
 823         }
 824
 825         return TRUE;
 826 }