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_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  64         SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  65         SR_CONF_NUM_HDIV | SR_CONF_GET,
  66         SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  67         SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
  68         SR_CONF_SAMPLERATE | SR_CONF_GET,
  69 };
  70
  71 static const uint32_t hmo_analog_devopts[] = {
  72         SR_CONF_NUM_VDIV | SR_CONF_GET,
  73         SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  74         SR_CONF_VDIV | 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         /* FIXME: this is wrong for TB > 1 second */
 368         tmp = sr_period_string((*config->timebases)[state->timebase][1] /
 369                                (*config->timebases)[state->timebase][0]);
 370         sr_info("Current timebase: %s", tmp);
 371         g_free(tmp);
 372
 373         tmp = sr_samplerate_string(state->sample_rate);
 374         sr_info("Current samplerate: %s", tmp);
 375         g_free(tmp);
 376
 377         sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
 378                 (*config->trigger_sources)[state->trigger_source],
 379                 (*config->trigger_slopes)[state->trigger_slope],
 380                 state->horiz_triggerpos);
 381 }
 382
 383 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
 384                 const char *command, const char *(*array)[], int *result)
 385 {
 386         char *tmp;
 387         unsigned int i;
 388
 389         if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK) {
 390                 g_free(tmp);
 391                 return SR_ERR;
 392         }
 393
 394         for (i = 0; (*array)[i]; i++) {
 395                 if (!g_strcmp0(tmp, (*array)[i])) {
 396                         *result = i;
 397                         g_free(tmp);
 398                         tmp = NULL;
 399                         break;
 400                 }
 401         }
 402
 403         if (tmp) {
 404                 g_free(tmp);
 405                 return SR_ERR;
 406         }
 407
 408         return SR_OK;
 409 }
 410
 411 /**
 412  * This function takes a value of the form "2.000E-03" and returns the index
 413  * of an array where a matching pair was found.
 414  *
 415  * @param value The string to be parsed.
 416  * @param array The array of s/f pairs.
 417  * @param array_len The number of pairs in the array.
 418  * @param result The index at which a matching pair was found.
 419  *
 420  * @return SR_ERR on any parsing error, SR_OK otherwise.
 421  */
 422 static int array_float_get(gchar *value, const uint64_t array[][2],
 423                 int array_len, unsigned int *result)
 424 {
 425         struct sr_rational rval;
 426         struct sr_rational aval;
 427
 428         if (sr_parse_rational(value, &rval) != SR_OK)
 429                 return SR_ERR;
 430
 431         for (int i = 0; i < array_len; i++) {
 432                 sr_rational_set(&aval, array[i][0], array[i][1]);
 433                 if (sr_rational_eq(&rval, &aval)) {
 434                         *result = i;
 435                         return SR_OK;
 436                 }
 437         }
 438
 439         return SR_ERR;
 440 }
 441
 442 static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi,
 443                                     const struct scope_config *config,
 444                                     struct scope_state *state)
 445 {
 446         unsigned int i, j;
 447         char command[MAX_COMMAND_SIZE];
 448         char *tmp_str;
 449
 450         for (i = 0; i < config->analog_channels; i++) {
 451                 g_snprintf(command, sizeof(command),
 452                            (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
 453                            i + 1);
 454
 455                 if (sr_scpi_get_bool(scpi, command,
 456                                      &state->analog_channels[i].state) != SR_OK)
 457                         return SR_ERR;
 458
 459                 g_snprintf(command, sizeof(command),
 460                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
 461                            i + 1);
 462
 463                 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
 464                         return SR_ERR;
 465
 466                 if (array_float_get(tmp_str, hmo_vdivs, ARRAY_SIZE(hmo_vdivs),
 467                                 &j) != SR_OK) {
 468                         g_free(tmp_str);
 469                         sr_err("Could not determine array index for vertical div scale.");
 470                         return SR_ERR;
 471                 }
 472
 473                 g_free(tmp_str);
 474                 state->analog_channels[i].vdiv = j;
 475
 476                 g_snprintf(command, sizeof(command),
 477                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
 478                            i + 1);
 479
 480                 if (sr_scpi_get_float(scpi, command,
 481                                      &state->analog_channels[i].vertical_offset) != SR_OK)
 482                         return SR_ERR;
 483
 484                 g_snprintf(command, sizeof(command),
 485                            (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
 486                            i + 1);
 487
 488                 if (scope_state_get_array_option(scpi, command, config->coupling_options,
 489                                          &state->analog_channels[i].coupling) != SR_OK)
 490                         return SR_ERR;
 491
 492                 g_snprintf(command, sizeof(command),
 493                            (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
 494                            i + 1);
 495
 496                 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
 497                         return SR_ERR;
 498
 499                 if (tmp_str[0] == 'A')
 500                         state->analog_channels[i].probe_unit = 'A';
 501                 else
 502                         state->analog_channels[i].probe_unit = 'V';
 503                 g_free(tmp_str);
 504         }
 505
 506         return SR_OK;
 507 }
 508
 509 static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi,
 510                                      const struct scope_config *config,
 511                                      struct scope_state *state)
 512 {
 513         unsigned int i;
 514         char command[MAX_COMMAND_SIZE];
 515
 516         for (i = 0; i < config->digital_channels; i++) {
 517                 g_snprintf(command, sizeof(command),
 518                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
 519                            i);
 520
 521                 if (sr_scpi_get_bool(scpi, command,
 522                                      &state->digital_channels[i]) != SR_OK)
 523                         return SR_ERR;
 524         }
 525
 526         for (i = 0; i < config->digital_pods; i++) {
 527                 g_snprintf(command, sizeof(command),
 528                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
 529                            i + 1);
 530
 531                 if (sr_scpi_get_bool(scpi, command,
 532                                      &state->digital_pods[i]) != SR_OK)
 533                         return SR_ERR;
 534         }
 535
 536         return SR_OK;
 537 }
 538
 539 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
 540 {
 541         struct dev_context *devc;
 542         struct scope_state *state;
 543         const struct scope_config *config;
 544
 545         int tmp;
 546         unsigned int i;
 547         float tmp_float;
 548         gboolean channel_found;
 549         char tmp_str[MAX_COMMAND_SIZE];
 550         char chan_name[20];
 551
 552         devc = sdi->priv;
 553         config = devc->model_config;
 554         state = devc->model_state;
 555         channel_found = FALSE;
 556
 557         for (i = 0; i < config->analog_channels; i++) {
 558                 if (state->analog_channels[i].state) {
 559                         g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
 560                         g_snprintf(tmp_str, sizeof(tmp_str),
 561                                    (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 562                                    chan_name);
 563                         channel_found = TRUE;
 564                         break;
 565                 }
 566         }
 567
 568         if (!channel_found) {
 569                 for (i = 0; i < config->digital_pods; i++) {
 570                         if (state->digital_pods[i]) {
 571                                 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
 572                                 g_snprintf(tmp_str, sizeof(tmp_str),
 573                                            (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 574                                            chan_name);
 575                                 channel_found = TRUE;
 576                                 break;
 577                         }
 578                 }
 579         }
 580
 581         /* No channel is active, ask the instrument for the sample rate
 582          * in single shot mode */
 583         if (!channel_found) {
 584                 if (sr_scpi_get_float(sdi->conn,
 585                                       (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
 586                                       &tmp_float) != SR_OK)
 587                         return SR_ERR;
 588
 589                 state->sample_rate = tmp_float;
 590         } else {
 591                 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
 592                         return SR_ERR;
 593                 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
 594                                              (*config->timebases)[state->timebase][1]) *
 595                                             config->num_xdivs);
 596         }
 597
 598         return SR_OK;
 599 }
 600
 601 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
 602 {
 603         struct dev_context *devc;
 604         struct scope_state *state;
 605         const struct scope_config *config;
 606         float tmp_float;
 607         unsigned int i;
 608         char *tmp_str;
 609
 610         devc = sdi->priv;
 611         config = devc->model_config;
 612         state = devc->model_state;
 613
 614         sr_info("Fetching scope state");
 615
 616         if (analog_channel_state_get(sdi->conn, config, state) != SR_OK)
 617                 return SR_ERR;
 618
 619         if (digital_channel_state_get(sdi->conn, config, state) != SR_OK)
 620                 return SR_ERR;
 621
 622         if (sr_scpi_get_float(sdi->conn,
 623                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 624                         &tmp_float) != SR_OK)
 625                 return SR_ERR;
 626
 627         if (sr_scpi_get_string(sdi->conn,
 628                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 629                         &tmp_str) != SR_OK)
 630                 return SR_ERR;
 631
 632         if (array_float_get(tmp_str, hmo_timebases, ARRAY_SIZE(hmo_timebases),
 633                         &i) != SR_OK) {
 634                 g_free(tmp_str);
 635                 sr_err("Could not determine array index for time base.");
 636                 return SR_ERR;
 637         }
 638         g_free(tmp_str);
 639
 640         state->timebase = i;
 641
 642         if (sr_scpi_get_float(sdi->conn,
 643                         (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
 644                         &tmp_float) != SR_OK)
 645                 return SR_ERR;
 646         state->horiz_triggerpos = tmp_float /
 647                 (((double) (*config->timebases)[state->timebase][0] /
 648                   (*config->timebases)[state->timebase][1]) * config->num_xdivs);
 649         state->horiz_triggerpos -= 0.5;
 650         state->horiz_triggerpos *= -1;
 651
 652         if (scope_state_get_array_option(sdi->conn,
 653                         (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
 654                         config->trigger_sources, &state->trigger_source) != SR_OK)
 655                 return SR_ERR;
 656
 657         if (scope_state_get_array_option(sdi->conn,
 658                 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
 659                 config->trigger_slopes, &state->trigger_slope) != SR_OK)
 660                 return SR_ERR;
 661
 662         if (hmo_update_sample_rate(sdi) != SR_OK)
 663                 return SR_ERR;
 664
 665         sr_info("Fetching finished.");
 666
 667         scope_state_dump(config, state);
 668
 669         return SR_OK;
 670 }
 671
 672 static struct scope_state *scope_state_new(const struct scope_config *config)
 673 {
 674         struct scope_state *state;
 675
 676         state = g_malloc0(sizeof(struct scope_state));
 677         state->analog_channels = g_malloc0_n(config->analog_channels,
 678                         sizeof(struct analog_channel_state));
 679         state->digital_channels = g_malloc0_n(
 680                         config->digital_channels, sizeof(gboolean));
 681         state->digital_pods = g_malloc0_n(config->digital_pods,
 682                         sizeof(gboolean));
 683
 684         return state;
 685 }
 686
 687 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
 688 {
 689         g_free(state->analog_channels);
 690         g_free(state->digital_channels);
 691         g_free(state->digital_pods);
 692         g_free(state);
 693 }
 694
 695 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
 696 {
 697         char tmp[25];
 698         int model_index;
 699         unsigned int i, j, group;
 700         struct sr_channel *ch;
 701         struct dev_context *devc;
 702
 703         devc = sdi->priv;
 704         model_index = -1;
 705
 706         /* Find the exact model. */
 707         for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
 708                 for (j = 0; scope_models[i].name[j]; j++) {
 709                         if (!strcmp(sdi->model, scope_models[i].name[j])) {
 710                                 model_index = i;
 711                                 break;
 712                         }
 713                 }
 714                 if (model_index != -1)
 715                         break;
 716         }
 717
 718         if (model_index == -1) {
 719                 sr_dbg("Unsupported HMO device.");
 720                 return SR_ERR_NA;
 721         }
 722
 723         devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 724                                         scope_models[model_index].analog_channels);
 725
 726         devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 727                                          scope_models[model_index].digital_pods);
 728
 729         /* Add analog channels. */
 730         for (i = 0; i < scope_models[model_index].analog_channels; i++) {
 731                 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
 732                            (*scope_models[model_index].analog_names)[i]);
 733
 734                 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 735
 736                 devc->analog_groups[i]->name = g_strdup(
 737                         (char *)(*scope_models[model_index].analog_names)[i]);
 738                 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
 739
 740                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 741                                                    devc->analog_groups[i]);
 742         }
 743
 744         /* Add digital channel groups. */
 745         for (i = 0; i < scope_models[model_index].digital_pods; i++) {
 746                 g_snprintf(tmp, 25, "POD%d", i);
 747
 748                 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 749
 750                 devc->digital_groups[i]->name = g_strdup(tmp);
 751                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 752                                    devc->digital_groups[i]);
 753         }
 754
 755         /* Add digital channels. */
 756         for (i = 0; i < scope_models[model_index].digital_channels; i++) {
 757                 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
 758                            (*scope_models[model_index].digital_names)[i]);
 759
 760                 group = i / 8;
 761                 devc->digital_groups[group]->channels = g_slist_append(
 762                         devc->digital_groups[group]->channels, ch);
 763         }
 764
 765         devc->model_config = &scope_models[model_index];
 766         devc->frame_limit = 0;
 767
 768         if (!(devc->model_state = scope_state_new(devc->model_config)))
 769                 return SR_ERR_MALLOC;
 770
 771         return SR_OK;
 772 }
 773
 774 /* Queue data of one channel group, for later submission. */
 775 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
 776                                   size_t group, GByteArray *pod_data)
 777 {
 778         size_t size;
 779         GByteArray *store;
 780         uint8_t *logic_data;
 781         size_t idx, logic_step;
 782
 783         /*
 784          * Upon first invocation, allocate the array which can hold the
 785          * combined logic data for all channels. Assume that each channel
 786          * will yield an identical number of samples per receive call.
 787          *
 788          * As a poor man's safety measure: (Silently) skip processing
 789          * for unexpected sample counts, and ignore samples for
 790          * unexpected channel groups. Don't bother with complicated
 791          * resize logic, considering that many models only support one
 792          * pod, and the most capable supported models have two pods of
 793          * identical size. We haven't yet seen any "odd" configuration.
 794          */
 795         if (!devc->logic_data) {
 796                 size = pod_data->len * devc->pod_count;
 797                 store = g_byte_array_sized_new(size);
 798                 memset(store->data, 0, size);
 799                 store = g_byte_array_set_size(store, size);
 800                 devc->logic_data = store;
 801         } else {
 802                 store = devc->logic_data;
 803                 size = store->len / devc->pod_count;
 804                 if (size != pod_data->len)
 805                         return;
 806                 if (group >= devc->pod_count)
 807                         return;
 808         }
 809
 810         /*
 811          * Fold the data of the most recently received channel group into
 812          * the storage, where data resides for all channels combined.
 813          */
 814         logic_data = store->data;
 815         logic_data += group;
 816         logic_step = devc->pod_count;
 817         for (idx = 0; idx < pod_data->len; idx++) {
 818                 *logic_data = pod_data->data[idx];
 819                 logic_data += logic_step;
 820         }
 821 }
 822
 823 /* Submit data for all channels, after the individual groups got collected. */
 824 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
 825                                    struct dev_context *devc)
 826 {
 827         struct sr_datafeed_packet packet;
 828         struct sr_datafeed_logic logic;
 829
 830         if (!devc->logic_data)
 831                 return;
 832
 833         logic.data = devc->logic_data->data;
 834         logic.length = devc->logic_data->len;
 835         logic.unitsize = devc->pod_count;
 836
 837         packet.type = SR_DF_LOGIC;
 838         packet.payload = &logic;
 839
 840         sr_session_send(sdi, &packet);
 841 }
 842
 843 /* Undo previous resource allocation. */
 844 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
 845 {
 846
 847         if (devc->logic_data) {
 848                 g_byte_array_free(devc->logic_data, TRUE);
 849                 devc->logic_data = NULL;
 850         }
 851         /*
 852          * Keep 'pod_count'! It's required when more frames will be
 853          * received, and does not harm when kept after acquisition.
 854          */
 855 }
 856
 857 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
 858 {
 859         struct sr_channel *ch;
 860         struct sr_dev_inst *sdi;
 861         struct dev_context *devc;
 862         struct scope_state *state;
 863         struct sr_datafeed_packet packet;
 864         GByteArray *data;
 865         struct sr_datafeed_analog analog;
 866         struct sr_analog_encoding encoding;
 867         struct sr_analog_meaning meaning;
 868         struct sr_analog_spec spec;
 869         struct sr_datafeed_logic logic;
 870         size_t group;
 871
 872         (void)fd;
 873         (void)revents;
 874
 875         data = NULL;
 876
 877         if (!(sdi = cb_data))
 878                 return TRUE;
 879
 880         if (!(devc = sdi->priv))
 881                 return TRUE;
 882
 883         /* Although this is correct in general, the USBTMC libusb implementation
 884          * currently does not generate an event prior to the first read. Often
 885          * it is ok to start reading just after the 50ms timeout. See bug #785.
 886         if (revents != G_IO_IN)
 887                 return TRUE;
 888         */
 889
 890         ch = devc->current_channel->data;
 891         state = devc->model_state;
 892
 893         /*
 894          * Send "frame begin" packet upon reception of data for the
 895          * first enabled channel.
 896          */
 897         if (devc->current_channel == devc->enabled_channels) {
 898                 packet.type = SR_DF_FRAME_BEGIN;
 899                 sr_session_send(sdi, &packet);
 900         }
 901
 902         /*
 903          * Pass on the received data of the channel(s).
 904          */
 905         switch (ch->type) {
 906         case SR_CHANNEL_ANALOG:
 907                 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
 908                         if (data)
 909                                 g_byte_array_free(data, TRUE);
 910
 911                         return TRUE;
 912                 }
 913
 914                 packet.type = SR_DF_ANALOG;
 915
 916                 analog.data = data->data;
 917                 analog.num_samples = data->len / sizeof(float);
 918                 analog.encoding = &encoding;
 919                 analog.meaning = &meaning;
 920                 analog.spec = &spec;
 921
 922                 encoding.unitsize = sizeof(float);
 923                 encoding.is_signed = TRUE;
 924                 encoding.is_float = TRUE;
 925 #ifdef WORDS_BIGENDIAN
 926                 encoding.is_bigendian = TRUE;
 927 #else
 928                 encoding.is_bigendian = FALSE;
 929 #endif
 930                 /* TODO: Use proper 'digits' value for this device (and its modes). */
 931                 encoding.digits = 2;
 932                 encoding.is_digits_decimal = FALSE;
 933                 encoding.scale.p = 1;
 934                 encoding.scale.q = 1;
 935                 encoding.offset.p = 0;
 936                 encoding.offset.q = 1;
 937                 if (state->analog_channels[ch->index].probe_unit == 'V') {
 938                         meaning.mq = SR_MQ_VOLTAGE;
 939                         meaning.unit = SR_UNIT_VOLT;
 940                 } else {
 941                         meaning.mq = SR_MQ_CURRENT;
 942                         meaning.unit = SR_UNIT_AMPERE;
 943                 }
 944                 meaning.mqflags = 0;
 945                 meaning.channels = g_slist_append(NULL, ch);
 946                 /* TODO: Use proper 'digits' value for this device (and its modes). */
 947                 spec.spec_digits = 2;
 948                 packet.payload = &analog;
 949                 sr_session_send(sdi, &packet);
 950                 g_slist_free(meaning.channels);
 951                 g_byte_array_free(data, TRUE);
 952                 data = NULL;
 953                 break;
 954         case SR_CHANNEL_LOGIC:
 955                 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
 956                         g_free(data);
 957                         return TRUE;
 958                 }
 959
 960                 /*
 961                  * If only data from the first pod is involved in the
 962                  * acquisition, then the raw input bytes can get passed
 963                  * forward for performance reasons. When the second pod
 964                  * is involved (either alone, or in combination with the
 965                  * first pod), then the received bytes need to be put
 966                  * into memory in such a layout that all channel groups
 967                  * get combined, and a unitsize larger than a single byte
 968                  * applies. The "queue" logic transparently copes with
 969                  * any such configuration. This works around the lack
 970                  * of support for "meaning" to logic data, which is used
 971                  * above for analog data.
 972                  */
 973                 if (devc->pod_count == 1) {
 974                         packet.type = SR_DF_LOGIC;
 975                         logic.data = data->data;
 976                         logic.length = data->len;
 977                         logic.unitsize = 1;
 978                         packet.payload = &logic;
 979                         sr_session_send(sdi, &packet);
 980                 } else {
 981                         group = ch->index / 8;
 982                         hmo_queue_logic_data(devc, group, data);
 983                 }
 984
 985                 g_byte_array_free(data, TRUE);
 986                 data = NULL;
 987                 break;
 988         default:
 989                 sr_err("Invalid channel type.");
 990                 break;
 991         }
 992
 993         /*
 994          * Advance to the next enabled channel. When data for all enabled
 995          * channels was received, then flush potentially queued logic data,
 996          * and send the "frame end" packet.
 997          */
 998         if (devc->current_channel->next) {
 999                 devc->current_channel = devc->current_channel->next;
1000                 hmo_request_data(sdi);
1001                 return TRUE;
1002         }
1003         hmo_send_logic_packet(sdi, devc);
1004
1005         /*
1006          * Release the logic data storage after each frame. This copes
1007          * with sample counts that differ in length per frame. -- Is
1008          * this a real constraint when acquiring multiple frames with
1009          * identical device settings?
1010          */
1011         hmo_cleanup_logic_data(devc);
1012
1013         packet.type = SR_DF_FRAME_END;
1014         sr_session_send(sdi, &packet);
1015
1016         /*
1017          * End of frame was reached. Stop acquisition after the specified
1018          * number of frames, or continue reception by starting over at
1019          * the first enabled channel.
1020          */
1021         if (++devc->num_frames == devc->frame_limit) {
1022                 sdi->driver->dev_acquisition_stop(sdi);
1023                 hmo_cleanup_logic_data(devc);
1024         } else {
1025                 devc->current_channel = devc->enabled_channels;
1026                 hmo_request_data(sdi);
1027         }
1028
1029         return TRUE;
1030 }