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 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
  27                                   size_t group, GByteArray *pod_data);
  28 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
  29                                    struct dev_context *devc);
  30 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc);
  31
  32 static const char *hameg_scpi_dialect[] = {
  33         [SCPI_CMD_GET_DIG_DATA]             = ":FORM UINT,8;:POD%d:DATA?",
  34         [SCPI_CMD_GET_TIMEBASE]             = ":TIM:SCAL?",
  35         [SCPI_CMD_SET_TIMEBASE]             = ":TIM:SCAL %s",
  36         [SCPI_CMD_GET_COUPLING]             = ":CHAN%d:COUP?",
  37         [SCPI_CMD_SET_COUPLING]             = ":CHAN%d:COUP %s",
  38         [SCPI_CMD_GET_SAMPLE_RATE]          = ":ACQ:SRAT?",
  39         [SCPI_CMD_GET_SAMPLE_RATE_LIVE]     = ":%s:DATA:POINTS?",
  40         [SCPI_CMD_GET_ANALOG_DATA]          = ":FORM:BORD %s;" \
  41                                               ":FORM REAL,32;:CHAN%d:DATA?",
  42         [SCPI_CMD_GET_VERTICAL_DIV]         = ":CHAN%d:SCAL?",
  43         [SCPI_CMD_SET_VERTICAL_DIV]         = ":CHAN%d:SCAL %s",
  44         [SCPI_CMD_GET_DIG_POD_STATE]        = ":POD%d:STAT?",
  45         [SCPI_CMD_SET_DIG_POD_STATE]        = ":POD%d:STAT %d",
  46         [SCPI_CMD_GET_TRIGGER_SLOPE]        = ":TRIG:A:EDGE:SLOP?",
  47         [SCPI_CMD_SET_TRIGGER_SLOPE]        = ":TRIG:A:EDGE:SLOP %s",
  48         [SCPI_CMD_GET_TRIGGER_SOURCE]       = ":TRIG:A:SOUR?",
  49         [SCPI_CMD_SET_TRIGGER_SOURCE]       = ":TRIG:A:SOUR %s",
  50         [SCPI_CMD_GET_DIG_CHAN_STATE]       = ":LOG%d:STAT?",
  51         [SCPI_CMD_SET_DIG_CHAN_STATE]       = ":LOG%d:STAT %d",
  52         [SCPI_CMD_GET_VERTICAL_OFFSET]      = ":CHAN%d:POS?",
  53         [SCPI_CMD_GET_HORIZ_TRIGGERPOS]     = ":TIM:POS?",
  54         [SCPI_CMD_SET_HORIZ_TRIGGERPOS]     = ":TIM:POS %s",
  55         [SCPI_CMD_GET_ANALOG_CHAN_STATE]    = ":CHAN%d:STAT?",
  56         [SCPI_CMD_SET_ANALOG_CHAN_STATE]    = ":CHAN%d:STAT %d",
  57         [SCPI_CMD_GET_PROBE_UNIT]           = ":PROB%d:SET:ATT:UNIT?",
  58 };
  59
  60 static const uint32_t hmo_devopts[] = {
  61         SR_CONF_OSCILLOSCOPE,
  62         SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET,
  63         SR_CONF_SAMPLERATE | SR_CONF_GET,
  64         SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  65         SR_CONF_NUM_HDIV | SR_CONF_GET,
  66         SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
  67         SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  68         SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  69 };
  70
  71 static const uint32_t hmo_analog_devopts[] = {
  72         SR_CONF_NUM_VDIV | SR_CONF_GET,
  73         SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  74         SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  75 };
  76
  77 static const char *hmo_coupling_options[] = {
  78         "AC",  // AC with 50 Ohm termination (152x, 202x, 30xx, 1202)
  79         "ACL", // AC with 1 MOhm termination
  80         "DC",  // DC with 50 Ohm termination
  81         "DCL", // DC with 1 MOhm termination
  82         "GND",
  83         NULL,
  84 };
  85
  86 static const char *scope_trigger_slopes[] = {
  87         "POS",
  88         "NEG",
  89         "EITH",
  90         NULL,
  91 };
  92
  93 static const char *hmo_compact2_trigger_sources[] = {
  94         "CH1",
  95         "CH2",
  96         "LINE",
  97         "EXT",
  98         "PATT",
  99         "BUS1",
 100         "BUS2",
 101         "D0",
 102         "D1",
 103         "D2",
 104         "D3",
 105         "D4",
 106         "D5",
 107         "D6",
 108         "D7",
 109         NULL,
 110 };
 111
 112 static const char *hmo_compact4_trigger_sources[] = {
 113         "CH1",
 114         "CH2",
 115         "CH3",
 116         "CH4",
 117         "LINE",
 118         "EXT",
 119         "PATT",
 120         "BUS1",
 121         "BUS2",
 122         "D0",
 123         "D1",
 124         "D2",
 125         "D3",
 126         "D4",
 127         "D5",
 128         "D6",
 129         "D7",
 130         NULL,
 131 };
 132
 133 static const char *hmo_compact4_dig16_trigger_sources[] = {
 134         "CH1",
 135         "CH2",
 136         "CH3",
 137         "CH4",
 138         "LINE",
 139         "EXT",
 140         "PATT",
 141         "BUS1",
 142         "BUS2",
 143         "D0",
 144         "D1",
 145         "D2",
 146         "D3",
 147         "D4",
 148         "D5",
 149         "D6",
 150         "D7",
 151         "D8",
 152         "D9",
 153         "D10",
 154         "D11",
 155         "D12",
 156         "D13",
 157         "D14",
 158         "D15",
 159         NULL,
 160 };
 161
 162 static const uint64_t hmo_timebases[][2] = {
 163         /* nanoseconds */
 164         { 2, 1000000000 },
 165         { 5, 1000000000 },
 166         { 10, 1000000000 },
 167         { 20, 1000000000 },
 168         { 50, 1000000000 },
 169         { 100, 1000000000 },
 170         { 200, 1000000000 },
 171         { 500, 1000000000 },
 172         /* microseconds */
 173         { 1, 1000000 },
 174         { 2, 1000000 },
 175         { 5, 1000000 },
 176         { 10, 1000000 },
 177         { 20, 1000000 },
 178         { 50, 1000000 },
 179         { 100, 1000000 },
 180         { 200, 1000000 },
 181         { 500, 1000000 },
 182         /* milliseconds */
 183         { 1, 1000 },
 184         { 2, 1000 },
 185         { 5, 1000 },
 186         { 10, 1000 },
 187         { 20, 1000 },
 188         { 50, 1000 },
 189         { 100, 1000 },
 190         { 200, 1000 },
 191         { 500, 1000 },
 192         /* seconds */
 193         { 1, 1 },
 194         { 2, 1 },
 195         { 5, 1 },
 196         { 10, 1 },
 197         { 20, 1 },
 198         { 50, 1 },
 199 };
 200
 201 static const uint64_t hmo_vdivs[][2] = {
 202         /* millivolts */
 203         { 1, 1000 },
 204         { 2, 1000 },
 205         { 5, 1000 },
 206         { 10, 1000 },
 207         { 20, 1000 },
 208         { 50, 1000 },
 209         { 100, 1000 },
 210         { 200, 1000 },
 211         { 500, 1000 },
 212         /* volts */
 213         { 1, 1 },
 214         { 2, 1 },
 215         { 5, 1 },
 216         { 10, 1 },
 217         { 20, 1 },
 218         { 50, 1 },
 219 };
 220
 221 static const char *scope_analog_channel_names[] = {
 222         "CH1",
 223         "CH2",
 224         "CH3",
 225         "CH4",
 226 };
 227
 228 static const char *scope_digital_channel_names[] = {
 229         "D0",
 230         "D1",
 231         "D2",
 232         "D3",
 233         "D4",
 234         "D5",
 235         "D6",
 236         "D7",
 237         "D8",
 238         "D9",
 239         "D10",
 240         "D11",
 241         "D12",
 242         "D13",
 243         "D14",
 244         "D15",
 245 };
 246
 247 static const struct scope_config scope_models[] = {
 248         {
 249                 /* HMO2522/3032/3042/3052 support 16 digital channels but they're not supported yet. */
 250                 .name = {"HMO1002", "HMO722", "HMO1022", "HMO1522", "HMO2022", "HMO2522",
 251                                 "HMO3032", "HMO3042", "HMO3052", NULL},
 252                 .analog_channels = 2,
 253                 .digital_channels = 8,
 254                 .digital_pods = 1,
 255
 256                 .analog_names = &scope_analog_channel_names,
 257                 .digital_names = &scope_digital_channel_names,
 258
 259                 .devopts = &hmo_devopts,
 260                 .num_devopts = ARRAY_SIZE(hmo_devopts),
 261
 262                 .analog_devopts = &hmo_analog_devopts,
 263                 .num_analog_devopts = ARRAY_SIZE(hmo_analog_devopts),
 264
 265                 .coupling_options = &hmo_coupling_options,
 266                 .trigger_sources = &hmo_compact2_trigger_sources,
 267                 .trigger_slopes = &scope_trigger_slopes,
 268
 269                 .timebases = &hmo_timebases,
 270                 .num_timebases = ARRAY_SIZE(hmo_timebases),
 271
 272                 .vdivs = &hmo_vdivs,
 273                 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
 274
 275                 .num_xdivs = 12,
 276                 .num_ydivs = 8,
 277
 278                 .scpi_dialect = &hameg_scpi_dialect,
 279         },
 280         {
 281                 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
 282                 .analog_channels = 4,
 283                 .digital_channels = 8,
 284                 .digital_pods = 1,
 285
 286                 .analog_names = &scope_analog_channel_names,
 287                 .digital_names = &scope_digital_channel_names,
 288
 289                 .devopts = &hmo_devopts,
 290                 .num_devopts = ARRAY_SIZE(hmo_devopts),
 291
 292                 .analog_devopts = &hmo_analog_devopts,
 293                 .num_analog_devopts = ARRAY_SIZE(hmo_analog_devopts),
 294
 295                 .coupling_options = &hmo_coupling_options,
 296                 .trigger_sources = &hmo_compact4_trigger_sources,
 297                 .trigger_slopes = &scope_trigger_slopes,
 298
 299                 .timebases = &hmo_timebases,
 300                 .num_timebases = ARRAY_SIZE(hmo_timebases),
 301
 302                 .vdivs = &hmo_vdivs,
 303                 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
 304
 305                 .num_xdivs = 12,
 306                 .num_ydivs = 8,
 307
 308                 .scpi_dialect = &hameg_scpi_dialect,
 309         },
 310         {
 311                 .name = {"HMO2524", "HMO3034", "HMO3044", "HMO3054", NULL},
 312                 .analog_channels = 4,
 313                 .digital_channels = 16,
 314                 .digital_pods = 2,
 315
 316                 .analog_names = &scope_analog_channel_names,
 317                 .digital_names = &scope_digital_channel_names,
 318
 319                 .devopts = &hmo_devopts,
 320                 .num_devopts = ARRAY_SIZE(hmo_devopts),
 321
 322                 .analog_devopts = &hmo_analog_devopts,
 323                 .num_analog_devopts = ARRAY_SIZE(hmo_analog_devopts),
 324
 325                 .coupling_options = &hmo_coupling_options,
 326                 .trigger_sources = &hmo_compact4_dig16_trigger_sources,
 327                 .trigger_slopes = &scope_trigger_slopes,
 328
 329                 .timebases = &hmo_timebases,
 330                 .num_timebases = ARRAY_SIZE(hmo_timebases),
 331
 332                 .vdivs = &hmo_vdivs,
 333                 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
 334
 335                 .num_xdivs = 12,
 336                 .num_ydivs = 8,
 337
 338                 .scpi_dialect = &hameg_scpi_dialect,
 339         },
 340 };
 341
 342 static void scope_state_dump(const struct scope_config *config,
 343                              struct scope_state *state)
 344 {
 345         unsigned int i;
 346         char *tmp;
 347
 348         for (i = 0; i < config->analog_channels; i++) {
 349                 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
 350                                              (*config->vdivs)[state->analog_channels[i].vdiv][1]);
 351                 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
 352                         i + 1, state->analog_channels[i].state ? "On" : "Off",
 353                         (*config->coupling_options)[state->analog_channels[i].coupling],
 354                         tmp, state->analog_channels[i].vertical_offset);
 355         }
 356
 357         for (i = 0; i < config->digital_channels; i++) {
 358                 sr_info("State of digital channel %d -> %s", i,
 359                         state->digital_channels[i] ? "On" : "Off");
 360         }
 361
 362         for (i = 0; i < config->digital_pods; i++) {
 363                 sr_info("State of digital POD %d -> %s", i,
 364                         state->digital_pods[i] ? "On" : "Off");
 365         }
 366
 367         tmp = sr_period_string((*config->timebases)[state->timebase][0],
 368                                (*config->timebases)[state->timebase][1]);
 369         sr_info("Current timebase: %s", tmp);
 370         g_free(tmp);
 371
 372         tmp = sr_samplerate_string(state->sample_rate);
 373         sr_info("Current samplerate: %s", tmp);
 374         g_free(tmp);
 375
 376         sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
 377                 (*config->trigger_sources)[state->trigger_source],
 378                 (*config->trigger_slopes)[state->trigger_slope],
 379                 state->horiz_triggerpos);
 380 }
 381
 382 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
 383                 const char *command, const char *(*array)[], int *result)
 384 {
 385         char *tmp;
 386         unsigned int i;
 387
 388         if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK) {
 389                 g_free(tmp);
 390                 return SR_ERR;
 391         }
 392
 393         for (i = 0; (*array)[i]; i++) {
 394                 if (!g_strcmp0(tmp, (*array)[i])) {
 395                         *result = i;
 396                         g_free(tmp);
 397                         tmp = NULL;
 398                         break;
 399                 }
 400         }
 401
 402         if (tmp) {
 403                 g_free(tmp);
 404                 return SR_ERR;
 405         }
 406
 407         return SR_OK;
 408 }
 409
 410 /**
 411  * This function takes a value of the form "2.000E-03" and returns the index
 412  * of an array where a matching pair was found.
 413  *
 414  * @param value The string to be parsed.
 415  * @param array The array of s/f pairs.
 416  * @param array_len The number of pairs in the array.
 417  * @param result The index at which a matching pair was found.
 418  *
 419  * @return SR_ERR on any parsing error, SR_OK otherwise.
 420  */
 421 static int array_float_get(gchar *value, const uint64_t array[][2],
 422                 int array_len, unsigned int *result)
 423 {
 424         struct sr_rational rval;
 425         struct sr_rational aval;
 426
 427         if (sr_parse_rational(value, &rval) != SR_OK)
 428                 return SR_ERR;
 429
 430         for (int i = 0; i < array_len; i++) {
 431                 sr_rational_set(&aval, array[i][0], array[i][1]);
 432                 if (sr_rational_eq(&rval, &aval)) {
 433                         *result = i;
 434                         return SR_OK;
 435                 }
 436         }
 437
 438         return SR_ERR;
 439 }
 440
 441 static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi,
 442                                     const struct scope_config *config,
 443                                     struct scope_state *state)
 444 {
 445         unsigned int i, j;
 446         char command[MAX_COMMAND_SIZE];
 447         char *tmp_str;
 448
 449         for (i = 0; i < config->analog_channels; i++) {
 450                 g_snprintf(command, sizeof(command),
 451                            (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
 452                            i + 1);
 453
 454                 if (sr_scpi_get_bool(scpi, command,
 455                                      &state->analog_channels[i].state) != SR_OK)
 456                         return SR_ERR;
 457
 458                 g_snprintf(command, sizeof(command),
 459                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
 460                            i + 1);
 461
 462                 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
 463                         return SR_ERR;
 464
 465                 if (array_float_get(tmp_str, hmo_vdivs, ARRAY_SIZE(hmo_vdivs),
 466                                 &j) != SR_OK) {
 467                         g_free(tmp_str);
 468                         sr_err("Could not determine array index for vertical div scale.");
 469                         return SR_ERR;
 470                 }
 471
 472                 g_free(tmp_str);
 473                 state->analog_channels[i].vdiv = j;
 474
 475                 g_snprintf(command, sizeof(command),
 476                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
 477                            i + 1);
 478
 479                 if (sr_scpi_get_float(scpi, command,
 480                                      &state->analog_channels[i].vertical_offset) != SR_OK)
 481                         return SR_ERR;
 482
 483                 g_snprintf(command, sizeof(command),
 484                            (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
 485                            i + 1);
 486
 487                 if (scope_state_get_array_option(scpi, command, config->coupling_options,
 488                                          &state->analog_channels[i].coupling) != SR_OK)
 489                         return SR_ERR;
 490
 491                 g_snprintf(command, sizeof(command),
 492                            (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
 493                            i + 1);
 494
 495                 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
 496                         return SR_ERR;
 497
 498                 if (tmp_str[0] == 'A')
 499                         state->analog_channels[i].probe_unit = 'A';
 500                 else
 501                         state->analog_channels[i].probe_unit = 'V';
 502                 g_free(tmp_str);
 503         }
 504
 505         return SR_OK;
 506 }
 507
 508 static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi,
 509                                      const struct scope_config *config,
 510                                      struct scope_state *state)
 511 {
 512         unsigned int i;
 513         char command[MAX_COMMAND_SIZE];
 514
 515         for (i = 0; i < config->digital_channels; i++) {
 516                 g_snprintf(command, sizeof(command),
 517                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
 518                            i);
 519
 520                 if (sr_scpi_get_bool(scpi, command,
 521                                      &state->digital_channels[i]) != SR_OK)
 522                         return SR_ERR;
 523         }
 524
 525         for (i = 0; i < config->digital_pods; i++) {
 526                 g_snprintf(command, sizeof(command),
 527                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
 528                            i + 1);
 529
 530                 if (sr_scpi_get_bool(scpi, command,
 531                                      &state->digital_pods[i]) != SR_OK)
 532                         return SR_ERR;
 533         }
 534
 535         return SR_OK;
 536 }
 537
 538 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
 539 {
 540         struct dev_context *devc;
 541         struct scope_state *state;
 542         const struct scope_config *config;
 543
 544         int tmp;
 545         unsigned int i;
 546         float tmp_float;
 547         gboolean channel_found;
 548         char tmp_str[MAX_COMMAND_SIZE];
 549         char chan_name[20];
 550
 551         devc = sdi->priv;
 552         config = devc->model_config;
 553         state = devc->model_state;
 554         channel_found = FALSE;
 555
 556         for (i = 0; i < config->analog_channels; i++) {
 557                 if (state->analog_channels[i].state) {
 558                         g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
 559                         g_snprintf(tmp_str, sizeof(tmp_str),
 560                                    (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 561                                    chan_name);
 562                         channel_found = TRUE;
 563                         break;
 564                 }
 565         }
 566
 567         if (!channel_found) {
 568                 for (i = 0; i < config->digital_pods; i++) {
 569                         if (state->digital_pods[i]) {
 570                                 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
 571                                 g_snprintf(tmp_str, sizeof(tmp_str),
 572                                            (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 573                                            chan_name);
 574                                 channel_found = TRUE;
 575                                 break;
 576                         }
 577                 }
 578         }
 579
 580         /* No channel is active, ask the instrument for the sample rate
 581          * in single shot mode */
 582         if (!channel_found) {
 583                 if (sr_scpi_get_float(sdi->conn,
 584                                       (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
 585                                       &tmp_float) != SR_OK)
 586                         return SR_ERR;
 587
 588                 state->sample_rate = tmp_float;
 589         } else {
 590                 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
 591                         return SR_ERR;
 592                 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
 593                                              (*config->timebases)[state->timebase][1]) *
 594                                             config->num_xdivs);
 595         }
 596
 597         return SR_OK;
 598 }
 599
 600 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
 601 {
 602         struct dev_context *devc;
 603         struct scope_state *state;
 604         const struct scope_config *config;
 605         float tmp_float;
 606         unsigned int i;
 607         char *tmp_str;
 608
 609         devc = sdi->priv;
 610         config = devc->model_config;
 611         state = devc->model_state;
 612
 613         sr_info("Fetching scope state");
 614
 615         if (analog_channel_state_get(sdi->conn, config, state) != SR_OK)
 616                 return SR_ERR;
 617
 618         if (digital_channel_state_get(sdi->conn, config, state) != SR_OK)
 619                 return SR_ERR;
 620
 621         if (sr_scpi_get_float(sdi->conn,
 622                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 623                         &tmp_float) != SR_OK)
 624                 return SR_ERR;
 625
 626         if (sr_scpi_get_string(sdi->conn,
 627                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 628                         &tmp_str) != SR_OK)
 629                 return SR_ERR;
 630
 631         if (array_float_get(tmp_str, hmo_timebases, ARRAY_SIZE(hmo_timebases),
 632                         &i) != SR_OK) {
 633                 g_free(tmp_str);
 634                 sr_err("Could not determine array index for time base.");
 635                 return SR_ERR;
 636         }
 637         g_free(tmp_str);
 638
 639         state->timebase = i;
 640
 641         if (sr_scpi_get_float(sdi->conn,
 642                         (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
 643                         &tmp_float) != SR_OK)
 644                 return SR_ERR;
 645         state->horiz_triggerpos = tmp_float /
 646                 (((double) (*config->timebases)[state->timebase][0] /
 647                   (*config->timebases)[state->timebase][1]) * config->num_xdivs);
 648         state->horiz_triggerpos -= 0.5;
 649         state->horiz_triggerpos *= -1;
 650
 651         if (scope_state_get_array_option(sdi->conn,
 652                         (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
 653                         config->trigger_sources, &state->trigger_source) != SR_OK)
 654                 return SR_ERR;
 655
 656         if (scope_state_get_array_option(sdi->conn,
 657                 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
 658                 config->trigger_slopes, &state->trigger_slope) != SR_OK)
 659                 return SR_ERR;
 660
 661         if (hmo_update_sample_rate(sdi) != SR_OK)
 662                 return SR_ERR;
 663
 664         sr_info("Fetching finished.");
 665
 666         scope_state_dump(config, state);
 667
 668         return SR_OK;
 669 }
 670
 671 static struct scope_state *scope_state_new(const struct scope_config *config)
 672 {
 673         struct scope_state *state;
 674
 675         state = g_malloc0(sizeof(struct scope_state));
 676         state->analog_channels = g_malloc0_n(config->analog_channels,
 677                         sizeof(struct analog_channel_state));
 678         state->digital_channels = g_malloc0_n(
 679                         config->digital_channels, sizeof(gboolean));
 680         state->digital_pods = g_malloc0_n(config->digital_pods,
 681                         sizeof(gboolean));
 682
 683         return state;
 684 }
 685
 686 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
 687 {
 688         g_free(state->analog_channels);
 689         g_free(state->digital_channels);
 690         g_free(state->digital_pods);
 691         g_free(state);
 692 }
 693
 694 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
 695 {
 696         char tmp[25];
 697         int model_index;
 698         unsigned int i, j, group;
 699         struct sr_channel *ch;
 700         struct dev_context *devc;
 701
 702         devc = sdi->priv;
 703         model_index = -1;
 704
 705         /* Find the exact model. */
 706         for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
 707                 for (j = 0; scope_models[i].name[j]; j++) {
 708                         if (!strcmp(sdi->model, scope_models[i].name[j])) {
 709                                 model_index = i;
 710                                 break;
 711                         }
 712                 }
 713                 if (model_index != -1)
 714                         break;
 715         }
 716
 717         if (model_index == -1) {
 718                 sr_dbg("Unsupported HMO device.");
 719                 return SR_ERR_NA;
 720         }
 721
 722         devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 723                                         scope_models[model_index].analog_channels);
 724
 725         devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 726                                          scope_models[model_index].digital_pods);
 727
 728         /* Add analog channels. */
 729         for (i = 0; i < scope_models[model_index].analog_channels; i++) {
 730                 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
 731                            (*scope_models[model_index].analog_names)[i]);
 732
 733                 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 734
 735                 devc->analog_groups[i]->name = g_strdup(
 736                         (char *)(*scope_models[model_index].analog_names)[i]);
 737                 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
 738
 739                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 740                                                    devc->analog_groups[i]);
 741         }
 742
 743         /* Add digital channel groups. */
 744         for (i = 0; i < scope_models[model_index].digital_pods; i++) {
 745                 g_snprintf(tmp, 25, "POD%d", i);
 746
 747                 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 748
 749                 devc->digital_groups[i]->name = g_strdup(tmp);
 750                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 751                                    devc->digital_groups[i]);
 752         }
 753
 754         /* Add digital channels. */
 755         for (i = 0; i < scope_models[model_index].digital_channels; i++) {
 756                 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
 757                            (*scope_models[model_index].digital_names)[i]);
 758
 759                 group = i / 8;
 760                 devc->digital_groups[group]->channels = g_slist_append(
 761                         devc->digital_groups[group]->channels, ch);
 762         }
 763
 764         devc->model_config = &scope_models[model_index];
 765         devc->frame_limit = 0;
 766
 767         if (!(devc->model_state = scope_state_new(devc->model_config)))
 768                 return SR_ERR_MALLOC;
 769
 770         return SR_OK;
 771 }
 772
 773 /* Queue data of one channel group, for later submission. */
 774 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
 775                                   size_t group, GByteArray *pod_data)
 776 {
 777         size_t size;
 778         GByteArray *store;
 779         uint8_t *logic_data;
 780         size_t idx, logic_step;
 781
 782         /*
 783          * Upon first invocation, allocate the array which can hold the
 784          * combined logic data for all channels. Assume that each channel
 785          * will yield an identical number of samples per receive call.
 786          *
 787          * As a poor man's safety measure: (Silently) skip processing
 788          * for unexpected sample counts, and ignore samples for
 789          * unexpected channel groups. Don't bother with complicated
 790          * resize logic, considering that many models only support one
 791          * pod, and the most capable supported models have two pods of
 792          * identical size. We haven't yet seen any "odd" configuration.
 793          */
 794         if (!devc->logic_data) {
 795                 size = pod_data->len * devc->pod_count;
 796                 store = g_byte_array_sized_new(size);
 797                 memset(store->data, 0, size);
 798                 store = g_byte_array_set_size(store, size);
 799                 devc->logic_data = store;
 800         } else {
 801                 store = devc->logic_data;
 802                 size = store->len / devc->pod_count;
 803                 if (size != pod_data->len)
 804                         return;
 805                 if (group >= devc->pod_count)
 806                         return;
 807         }
 808
 809         /*
 810          * Fold the data of the most recently received channel group into
 811          * the storage, where data resides for all channels combined.
 812          */
 813         logic_data = store->data;
 814         logic_data += group;
 815         logic_step = devc->pod_count;
 816         for (idx = 0; idx < pod_data->len; idx++) {
 817                 *logic_data = pod_data->data[idx];
 818                 logic_data += logic_step;
 819         }
 820 }
 821
 822 /* Submit data for all channels, after the individual groups got collected. */
 823 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
 824                                    struct dev_context *devc)
 825 {
 826         struct sr_datafeed_packet packet;
 827         struct sr_datafeed_logic logic;
 828
 829         if (!devc->logic_data)
 830                 return;
 831
 832         logic.data = devc->logic_data->data;
 833         logic.length = devc->logic_data->len;
 834         logic.unitsize = devc->pod_count;
 835
 836         packet.type = SR_DF_LOGIC;
 837         packet.payload = &logic;
 838
 839         sr_session_send(sdi, &packet);
 840 }
 841
 842 /* Undo previous resource allocation. */
 843 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
 844 {
 845
 846         if (devc->logic_data) {
 847                 g_byte_array_free(devc->logic_data, TRUE);
 848                 devc->logic_data = NULL;
 849         }
 850         /*
 851          * Keep 'pod_count'! It's required when more frames will be
 852          * received, and does not harm when kept after acquisition.
 853          */
 854 }
 855
 856 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
 857 {
 858         struct sr_channel *ch;
 859         struct sr_dev_inst *sdi;
 860         struct dev_context *devc;
 861         struct scope_state *state;
 862         struct sr_datafeed_packet packet;
 863         GByteArray *data;
 864         struct sr_datafeed_analog analog;
 865         struct sr_analog_encoding encoding;
 866         struct sr_analog_meaning meaning;
 867         struct sr_analog_spec spec;
 868         struct sr_datafeed_logic logic;
 869         size_t group;
 870
 871         (void)fd;
 872         (void)revents;
 873
 874         data = NULL;
 875
 876         if (!(sdi = cb_data))
 877                 return TRUE;
 878
 879         if (!(devc = sdi->priv))
 880                 return TRUE;
 881
 882         /* Although this is correct in general, the USBTMC libusb implementation
 883          * currently does not generate an event prior to the first read. Often
 884          * it is ok to start reading just after the 50ms timeout. See bug #785.
 885         if (revents != G_IO_IN)
 886                 return TRUE;
 887         */
 888
 889         ch = devc->current_channel->data;
 890         state = devc->model_state;
 891
 892         /*
 893          * Send "frame begin" packet upon reception of data for the
 894          * first enabled channel.
 895          */
 896         if (devc->current_channel == devc->enabled_channels) {
 897                 packet.type = SR_DF_FRAME_BEGIN;
 898                 sr_session_send(sdi, &packet);
 899         }
 900
 901         /*
 902          * Pass on the received data of the channel(s).
 903          */
 904         switch (ch->type) {
 905         case SR_CHANNEL_ANALOG:
 906                 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
 907                         if (data)
 908                                 g_byte_array_free(data, TRUE);
 909
 910                         return TRUE;
 911                 }
 912
 913                 packet.type = SR_DF_ANALOG;
 914
 915                 analog.data = data->data;
 916                 analog.num_samples = data->len / sizeof(float);
 917                 analog.encoding = &encoding;
 918                 analog.meaning = &meaning;
 919                 analog.spec = &spec;
 920
 921                 encoding.unitsize = sizeof(float);
 922                 encoding.is_signed = TRUE;
 923                 encoding.is_float = TRUE;
 924 #ifdef WORDS_BIGENDIAN
 925                 encoding.is_bigendian = TRUE;
 926 #else
 927                 encoding.is_bigendian = FALSE;
 928 #endif
 929                 /* TODO: Use proper 'digits' value for this device (and its modes). */
 930                 encoding.digits = 2;
 931                 encoding.is_digits_decimal = FALSE;
 932                 encoding.scale.p = 1;
 933                 encoding.scale.q = 1;
 934                 encoding.offset.p = 0;
 935                 encoding.offset.q = 1;
 936                 if (state->analog_channels[ch->index].probe_unit == 'V') {
 937                         meaning.mq = SR_MQ_VOLTAGE;
 938                         meaning.unit = SR_UNIT_VOLT;
 939                 } else {
 940                         meaning.mq = SR_MQ_CURRENT;
 941                         meaning.unit = SR_UNIT_AMPERE;
 942                 }
 943                 meaning.mqflags = 0;
 944                 meaning.channels = g_slist_append(NULL, ch);
 945                 /* TODO: Use proper 'digits' value for this device (and its modes). */
 946                 spec.spec_digits = 2;
 947                 packet.payload = &analog;
 948                 sr_session_send(sdi, &packet);
 949                 g_slist_free(meaning.channels);
 950                 g_byte_array_free(data, TRUE);
 951                 data = NULL;
 952                 break;
 953         case SR_CHANNEL_LOGIC:
 954                 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
 955                         g_free(data);
 956                         return TRUE;
 957                 }
 958
 959                 /*
 960                  * If only data from the first pod is involved in the
 961                  * acquisition, then the raw input bytes can get passed
 962                  * forward for performance reasons. When the second pod
 963                  * is involved (either alone, or in combination with the
 964                  * first pod), then the received bytes need to be put
 965                  * into memory in such a layout that all channel groups
 966                  * get combined, and a unitsize larger than a single byte
 967                  * applies. The "queue" logic transparently copes with
 968                  * any such configuration. This works around the lack
 969                  * of support for "meaning" to logic data, which is used
 970                  * above for analog data.
 971                  */
 972                 if (devc->pod_count == 1) {
 973                         packet.type = SR_DF_LOGIC;
 974                         logic.data = data->data;
 975                         logic.length = data->len;
 976                         logic.unitsize = 1;
 977                         packet.payload = &logic;
 978                         sr_session_send(sdi, &packet);
 979                 } else {
 980                         group = ch->index / 8;
 981                         hmo_queue_logic_data(devc, group, data);
 982                 }
 983
 984                 g_byte_array_free(data, TRUE);
 985                 data = NULL;
 986                 break;
 987         default:
 988                 sr_err("Invalid channel type.");
 989                 break;
 990         }
 991
 992         /*
 993          * Advance to the next enabled channel. When data for all enabled
 994          * channels was received, then flush potentially queued logic data,
 995          * and send the "frame end" packet.
 996          */
 997         if (devc->current_channel->next) {
 998                 devc->current_channel = devc->current_channel->next;
 999                 hmo_request_data(sdi);
1000                 return TRUE;
1001         }
1002         hmo_send_logic_packet(sdi, devc);
1003
1004         /*
1005          * Release the logic data storage after each frame. This copes
1006          * with sample counts that differ in length per frame. -- Is
1007          * this a real constraint when acquiring multiple frames with
1008          * identical device settings?
1009          */
1010         hmo_cleanup_logic_data(devc);
1011
1012         packet.type = SR_DF_FRAME_END;
1013         sr_session_send(sdi, &packet);
1014
1015         /*
1016          * End of frame was reached. Stop acquisition after the specified
1017          * number of frames, or continue reception by starting over at
1018          * the first enabled channel.
1019          */
1020         if (++devc->num_frames == devc->frame_limit) {
1021                 sdi->driver->dev_acquisition_stop(sdi);
1022                 hmo_cleanup_logic_data(devc);
1023         } else {
1024                 devc->current_channel = devc->enabled_channels;
1025                 hmo_request_data(sdi);
1026         }
1027
1028         return TRUE;
1029 }