src/hardware/fluke-dmm/protocol.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2012 Bert Vermeulen <bert@biot.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 <stdlib.h>
  22 #include <math.h>
  23 #include <string.h>
  24 #include <glib.h>
  25 #include <libsigrok/libsigrok.h>
  26 #include "libsigrok-internal.h"
  27 #include "protocol.h"
  28
  29 static void handle_qm_18x(const struct sr_dev_inst *sdi, char **tokens)
  30 {
  31         struct dev_context *devc;
  32         struct sr_datafeed_packet packet;
  33         struct sr_datafeed_analog analog;
  34         struct sr_analog_encoding encoding;
  35         struct sr_analog_meaning meaning;
  36         struct sr_analog_spec spec;
  37         float fvalue;
  38         char *e, *u;
  39         gboolean is_oor;
  40
  41         devc = sdi->priv;
  42
  43         if (strcmp(tokens[0], "QM") || !tokens[1])
  44                 return;
  45
  46         if ((e = strstr(tokens[1], "Out of range"))) {
  47                 is_oor = TRUE;
  48                 fvalue = -1;
  49                 while (*e && *e != '.')
  50                         e++;
  51         } else {
  52                 is_oor = FALSE;
  53                 /* Delimit the float, since sr_atof_ascii() wants only
  54                  * a valid float here. */
  55                 e = tokens[1];
  56                 while (*e && *e != ' ')
  57                         e++;
  58                 *e++ = '\0';
  59                 if (sr_atof_ascii(tokens[1], &fvalue) != SR_OK || fvalue == 0.0) {
  60                         /* Happens all the time, when switching modes. */
  61                         sr_dbg("Invalid float.");
  62                         return;
  63                 }
  64         }
  65         while (*e && *e == ' ')
  66                 e++;
  67
  68         /* TODO: Use proper 'digits' value for this device (and its modes). */
  69         sr_analog_init(&analog, &encoding, &meaning, &spec, 2);
  70         analog.data = &fvalue;
  71         analog.meaning->channels = sdi->channels;
  72         analog.num_samples = 1;
  73         if (is_oor)
  74                 fvalue = NAN;
  75         analog.meaning->mq = 0;
  76
  77         if ((u = strstr(e, "V DC")) || (u = strstr(e, "V AC"))) {
  78                 analog.meaning->mq = SR_MQ_VOLTAGE;
  79                 analog.meaning->unit = SR_UNIT_VOLT;
  80                 if (!is_oor && e[0] == 'm')
  81                         fvalue /= 1000;
  82                 /* This catches "V AC", "V DC" and "V AC+DC". */
  83                 if (strstr(u, "AC"))
  84                         analog.meaning->mqflags |= SR_MQFLAG_AC | SR_MQFLAG_RMS;
  85                 if (strstr(u, "DC"))
  86                         analog.meaning->mqflags |= SR_MQFLAG_DC;
  87         } else if ((u = strstr(e, "dBV")) || (u = strstr(e, "dBm"))) {
  88                 analog.meaning->mq = SR_MQ_VOLTAGE;
  89                 if (u[2] == 'm')
  90                         analog.meaning->unit = SR_UNIT_DECIBEL_MW;
  91                 else
  92                         analog.meaning->unit = SR_UNIT_DECIBEL_VOLT;
  93                 analog.meaning->mqflags |= SR_MQFLAG_AC | SR_MQFLAG_RMS;
  94         } else if ((u = strstr(e, "Ohms"))) {
  95                 analog.meaning->mq = SR_MQ_RESISTANCE;
  96                 analog.meaning->unit = SR_UNIT_OHM;
  97                 if (is_oor)
  98                         fvalue = INFINITY;
  99                 else if (e[0] == 'k')
 100                         fvalue *= 1000;
 101                 else if (e[0] == 'M')
 102                         fvalue *= 1000000;
 103         } else if (!strcmp(e, "nS")) {
 104                 analog.meaning->mq = SR_MQ_CONDUCTANCE;
 105                 analog.meaning->unit = SR_UNIT_SIEMENS;
 106                 *((float *)analog.data) /= 1e+9;
 107         } else if ((u = strstr(e, "Farads"))) {
 108                 analog.meaning->mq = SR_MQ_CAPACITANCE;
 109                 analog.meaning->unit = SR_UNIT_FARAD;
 110                 if (!is_oor) {
 111                         if (e[0] == 'm')
 112                                 fvalue /= 1e+3;
 113                         else if (e[0] == 'u')
 114                                 fvalue /= 1e+6;
 115                         else if (e[0] == 'n')
 116                                 fvalue /= 1e+9;
 117                 }
 118         } else if ((u = strstr(e, "Deg C")) || (u = strstr(e, "Deg F"))) {
 119                 analog.meaning->mq = SR_MQ_TEMPERATURE;
 120                 if (u[4] == 'C')
 121                         analog.meaning->unit = SR_UNIT_CELSIUS;
 122                 else
 123                         analog.meaning->unit = SR_UNIT_FAHRENHEIT;
 124         } else if ((u = strstr(e, "A AC")) || (u = strstr(e, "A DC"))) {
 125                 analog.meaning->mq = SR_MQ_CURRENT;
 126                 analog.meaning->unit = SR_UNIT_AMPERE;
 127                 /* This catches "A AC", "A DC" and "A AC+DC". */
 128                 if (strstr(u, "AC"))
 129                         analog.meaning->mqflags |= SR_MQFLAG_AC | SR_MQFLAG_RMS;
 130                 if (strstr(u, "DC"))
 131                         analog.meaning->mqflags |= SR_MQFLAG_DC;
 132                 if (!is_oor) {
 133                         if (e[0] == 'm')
 134                                 fvalue /= 1e+3;
 135                         else if (e[0] == 'u')
 136                                 fvalue /= 1e+6;
 137                 }
 138         } else if ((u = strstr(e, "Hz"))) {
 139                 analog.meaning->mq = SR_MQ_FREQUENCY;
 140                 analog.meaning->unit = SR_UNIT_HERTZ;
 141                 if (e[0] == 'k')
 142                         fvalue *= 1e+3;
 143         } else if (!strcmp(e, "%")) {
 144                 analog.meaning->mq = SR_MQ_DUTY_CYCLE;
 145                 analog.meaning->unit = SR_UNIT_PERCENTAGE;
 146         } else if ((u = strstr(e, "ms"))) {
 147                 analog.meaning->mq = SR_MQ_PULSE_WIDTH;
 148                 analog.meaning->unit = SR_UNIT_SECOND;
 149                 fvalue /= 1e+3;
 150         }
 151
 152         if (analog.meaning->mq != 0) {
 153                 /* Got a measurement. */
 154                 packet.type = SR_DF_ANALOG;
 155                 packet.payload = &analog;
 156                 sr_session_send(sdi, &packet);
 157                 sr_sw_limits_update_samples_read(&devc->limits, 1);
 158         }
 159 }
 160
 161 static void handle_qm_28x(const struct sr_dev_inst *sdi, char **tokens)
 162 {
 163         struct dev_context *devc;
 164         struct sr_datafeed_packet packet;
 165         struct sr_datafeed_analog analog;
 166         struct sr_analog_encoding encoding;
 167         struct sr_analog_meaning meaning;
 168         struct sr_analog_spec spec;
 169         float fvalue;
 170
 171         devc = sdi->priv;
 172
 173         if (!tokens[1])
 174                 return;
 175
 176         if (sr_atof_ascii(tokens[0], &fvalue) != SR_OK || fvalue == 0.0) {
 177                 sr_err("Invalid float '%s'.", tokens[0]);
 178                 return;
 179         }
 180
 181         /* TODO: Use proper 'digits' value for this device (and its modes). */
 182         sr_analog_init(&analog, &encoding, &meaning, &spec, 2);
 183         analog.data = &fvalue;
 184         analog.meaning->channels = sdi->channels;
 185         analog.num_samples = 1;
 186         analog.meaning->mq = 0;
 187
 188         if (!strcmp(tokens[1], "VAC") || !strcmp(tokens[1], "VDC")) {
 189                 analog.meaning->mq = SR_MQ_VOLTAGE;
 190                 analog.meaning->unit = SR_UNIT_VOLT;
 191                 if (!strcmp(tokens[2], "NORMAL")) {
 192                         if (tokens[1][1] == 'A') {
 193                                 analog.meaning->mqflags |= SR_MQFLAG_AC;
 194                                 analog.meaning->mqflags |= SR_MQFLAG_RMS;
 195                         } else
 196                                 analog.meaning->mqflags |= SR_MQFLAG_DC;
 197                 } else if (!strcmp(tokens[2], "OL") || !strcmp(tokens[2], "OL_MINUS")) {
 198                         fvalue = NAN;
 199                 } else
 200                         analog.meaning->mq = 0;
 201         } else if (!strcmp(tokens[1], "dBV") || !strcmp(tokens[1], "dBm")) {
 202                 analog.meaning->mq = SR_MQ_VOLTAGE;
 203                 if (tokens[1][2] == 'm')
 204                         analog.meaning->unit = SR_UNIT_DECIBEL_MW;
 205                 else
 206                         analog.meaning->unit = SR_UNIT_DECIBEL_VOLT;
 207                 analog.meaning->mqflags |= SR_MQFLAG_AC | SR_MQFLAG_RMS;
 208         } else if (!strcmp(tokens[1], "CEL") || !strcmp(tokens[1], "FAR")) {
 209                 if (!strcmp(tokens[2], "NORMAL")) {
 210                         analog.meaning->mq = SR_MQ_TEMPERATURE;
 211                         if (tokens[1][0] == 'C')
 212                                 analog.meaning->unit = SR_UNIT_CELSIUS;
 213                         else
 214                                 analog.meaning->unit = SR_UNIT_FAHRENHEIT;
 215                 }
 216         } else if (!strcmp(tokens[1], "OHM")) {
 217                 if (!strcmp(tokens[3], "NONE")) {
 218                         analog.meaning->mq = SR_MQ_RESISTANCE;
 219                         analog.meaning->unit = SR_UNIT_OHM;
 220                         if (!strcmp(tokens[2], "OL") || !strcmp(tokens[2], "OL_MINUS")) {
 221                                 fvalue = INFINITY;
 222                         } else if (strcmp(tokens[2], "NORMAL"))
 223                                 analog.meaning->mq = 0;
 224                 } else if (!strcmp(tokens[3], "OPEN_CIRCUIT")) {
 225                         analog.meaning->mq = SR_MQ_CONTINUITY;
 226                         analog.meaning->unit = SR_UNIT_BOOLEAN;
 227                         fvalue = 0.0;
 228                 } else if (!strcmp(tokens[3], "SHORT_CIRCUIT")) {
 229                         analog.meaning->mq = SR_MQ_CONTINUITY;
 230                         analog.meaning->unit = SR_UNIT_BOOLEAN;
 231                         fvalue = 1.0;
 232                 }
 233         } else if (!strcmp(tokens[1], "F")
 234                         && !strcmp(tokens[2], "NORMAL")
 235                         && !strcmp(tokens[3], "NONE")) {
 236                 analog.meaning->mq = SR_MQ_CAPACITANCE;
 237                 analog.meaning->unit = SR_UNIT_FARAD;
 238         } else if (!strcmp(tokens[1], "AAC") || !strcmp(tokens[1], "ADC")) {
 239                 analog.meaning->mq = SR_MQ_CURRENT;
 240                 analog.meaning->unit = SR_UNIT_AMPERE;
 241                 if (!strcmp(tokens[2], "NORMAL")) {
 242                         if (tokens[1][1] == 'A') {
 243                                 analog.meaning->mqflags |= SR_MQFLAG_AC;
 244                                 analog.meaning->mqflags |= SR_MQFLAG_RMS;
 245                         } else
 246                                 analog.meaning->mqflags |= SR_MQFLAG_DC;
 247                 } else if (!strcmp(tokens[2], "OL") || !strcmp(tokens[2], "OL_MINUS")) {
 248                         fvalue = NAN;
 249                 } else
 250                         analog.meaning->mq = 0;
 251         } else if (!strcmp(tokens[1], "Hz") && !strcmp(tokens[2], "NORMAL")) {
 252                 analog.meaning->mq = SR_MQ_FREQUENCY;
 253                 analog.meaning->unit = SR_UNIT_HERTZ;
 254         } else if (!strcmp(tokens[1], "PCT") && !strcmp(tokens[2], "NORMAL")) {
 255                 analog.meaning->mq = SR_MQ_DUTY_CYCLE;
 256                 analog.meaning->unit = SR_UNIT_PERCENTAGE;
 257         } else if (!strcmp(tokens[1], "S") && !strcmp(tokens[2], "NORMAL")) {
 258                 analog.meaning->mq = SR_MQ_PULSE_WIDTH;
 259                 analog.meaning->unit = SR_UNIT_SECOND;
 260         } else if (!strcmp(tokens[1], "SIE") && !strcmp(tokens[2], "NORMAL")) {
 261                 analog.meaning->mq = SR_MQ_CONDUCTANCE;
 262                 analog.meaning->unit = SR_UNIT_SIEMENS;
 263         }
 264
 265         if (analog.meaning->mq != 0) {
 266                 /* Got a measurement. */
 267                 packet.type = SR_DF_ANALOG;
 268                 packet.payload = &analog;
 269                 sr_session_send(sdi, &packet);
 270                 sr_sw_limits_update_samples_read(&devc->limits, 1);
 271         }
 272 }
 273
 274 static void handle_qm_19x_meta(const struct sr_dev_inst *sdi, char **tokens)
 275 {
 276         struct dev_context *devc;
 277         int meas_type, meas_unit, meas_char, i;
 278
 279         /* Make sure we have 7 valid tokens. */
 280         for (i = 0; tokens[i] && i < 7; i++);
 281         if (i != 7)
 282                 return;
 283
 284         if (strcmp(tokens[1], "1"))
 285                 /* Invalid measurement. */
 286                 return;
 287
 288         if (strcmp(tokens[2], "3"))
 289                 /* Only interested in input from the meter mode source. */
 290                 return;
 291
 292         devc = sdi->priv;
 293
 294         /* Measurement type 11 == absolute, 19 = relative */
 295         meas_type = strtol(tokens[0], NULL, 10);
 296         if (meas_type != 11 && meas_type != 19)
 297                 /* Device is in some mode we don't support. */
 298                 return;
 299
 300         /* We might get metadata for absolute and relative mode (if the device
 301          * is in relative mode). In that case, relative takes precedence. */
 302         if (meas_type == 11 && devc->meas_type == 19)
 303                 return;
 304
 305         meas_unit = strtol(tokens[3], NULL, 10);
 306         if (meas_unit == 0)
 307                 /* Device is turned off. Really. */
 308                 return;
 309         meas_char = strtol(tokens[4], NULL, 10);
 310
 311         devc->mq = 0;
 312         devc->unit = 0;
 313         devc->mqflags = 0;
 314
 315         switch (meas_unit) {
 316         case 1:
 317                 devc->mq = SR_MQ_VOLTAGE;
 318                 devc->unit = SR_UNIT_VOLT;
 319                 if (meas_char == 1)
 320                         devc->mqflags |= SR_MQFLAG_DC;
 321                 else if (meas_char == 2)
 322                         devc->mqflags |= SR_MQFLAG_AC;
 323                 else if (meas_char == 3)
 324                         devc->mqflags |= SR_MQFLAG_DC | SR_MQFLAG_AC;
 325                 else if (meas_char == 15)
 326                         devc->mqflags |= SR_MQFLAG_DIODE | SR_MQFLAG_DC;
 327                 break;
 328         case 2:
 329                 devc->mq = SR_MQ_CURRENT;
 330                 devc->unit = SR_UNIT_AMPERE;
 331                 if (meas_char == 1)
 332                         devc->mqflags |= SR_MQFLAG_DC;
 333                 else if (meas_char == 2)
 334                         devc->mqflags |= SR_MQFLAG_AC;
 335                 else if (meas_char == 3)
 336                         devc->mqflags |= SR_MQFLAG_DC | SR_MQFLAG_AC;
 337                 break;
 338         case 3:
 339                 if (meas_char == 1) {
 340                         devc->mq = SR_MQ_RESISTANCE;
 341                         devc->unit = SR_UNIT_OHM;
 342                 } else if (meas_char == 16) {
 343                         devc->mq = SR_MQ_CONTINUITY;
 344                         devc->unit = SR_UNIT_BOOLEAN;
 345                 }
 346                 break;
 347         case 12:
 348                 devc->mq = SR_MQ_TEMPERATURE;
 349                 devc->unit = SR_UNIT_CELSIUS;
 350                 break;
 351         case 13:
 352                 devc->mq = SR_MQ_TEMPERATURE;
 353                 devc->unit = SR_UNIT_FAHRENHEIT;
 354                 break;
 355         default:
 356                 sr_dbg("unknown unit: %d", meas_unit);
 357         }
 358         if (devc->mq == 0 && devc->unit == 0)
 359                 return;
 360
 361         /* If we got here, we know how to interpret the measurement. */
 362         devc->meas_type = meas_type;
 363         if (meas_type == 11)
 364                 /* Absolute meter reading. */
 365                 devc->is_relative = FALSE;
 366         else if (!strcmp(tokens[0], "19"))
 367                 /* Relative meter reading. */
 368                 devc->is_relative = TRUE;
 369
 370 }
 371
 372 static void handle_qm_19x_data(const struct sr_dev_inst *sdi, char **tokens)
 373 {
 374         struct dev_context *devc;
 375         struct sr_datafeed_packet packet;
 376         struct sr_datafeed_analog analog;
 377         struct sr_analog_encoding encoding;
 378         struct sr_analog_meaning meaning;
 379         struct sr_analog_spec spec;
 380         float fvalue;
 381
 382         if (!strcmp(tokens[0], "9.9E+37")) {
 383                 /* An invalid measurement shows up on the display as "OL", but
 384                  * comes through like this. Since comparing 38-digit floats
 385                  * is rather problematic, we'll cut through this here. */
 386                 fvalue = NAN;
 387         } else {
 388                 if (sr_atof_ascii(tokens[0], &fvalue) != SR_OK || fvalue == 0.0) {
 389                         sr_err("Invalid float '%s'.", tokens[0]);
 390                         return;
 391                 }
 392         }
 393
 394         devc = sdi->priv;
 395         if (devc->mq == 0 || devc->unit == 0)
 396                 /* Don't have valid metadata yet. */
 397                 return;
 398
 399         if (devc->mq == SR_MQ_RESISTANCE && isnan(fvalue))
 400                 fvalue = INFINITY;
 401         else if (devc->mq == SR_MQ_CONTINUITY) {
 402                 if (isnan(fvalue))
 403                         fvalue = 0.0;
 404                 else
 405                         fvalue = 1.0;
 406         }
 407
 408         /* TODO: Use proper 'digits' value for this device (and its modes). */
 409         sr_analog_init(&analog, &encoding, &meaning, &spec, 2);
 410         analog.meaning->channels = sdi->channels;
 411         analog.num_samples = 1;
 412         analog.data = &fvalue;
 413         analog.meaning->mq = devc->mq;
 414         analog.meaning->unit = devc->unit;
 415         analog.meaning->mqflags = 0;
 416         packet.type = SR_DF_ANALOG;
 417         packet.payload = &analog;
 418         sr_session_send(sdi, &packet);
 419
 420         sr_sw_limits_update_samples_read(&devc->limits, 1);
 421 }
 422
 423 static void handle_line(const struct sr_dev_inst *sdi)
 424 {
 425         struct dev_context *devc;
 426         struct sr_serial_dev_inst *serial;
 427         int num_tokens, n, i;
 428         char cmd[16], **tokens;
 429
 430         devc = sdi->priv;
 431         serial = sdi->conn;
 432         sr_spew("Received line '%s' (%d).", devc->buf, devc->buflen);
 433
 434         if (devc->buflen == 1) {
 435                 if (devc->buf[0] != '0') {
 436                         /* Not just a CMD_ACK from the query command. */
 437                         sr_dbg("Got CMD_ACK '%c'.", devc->buf[0]);
 438                         devc->expect_response = FALSE;
 439                 }
 440                 devc->buflen = 0;
 441                 return;
 442         }
 443
 444         tokens = g_strsplit(devc->buf, ",", 0);
 445         if (tokens[0]) {
 446                 if (devc->profile->model == FLUKE_187 || devc->profile->model == FLUKE_189) {
 447                         devc->expect_response = FALSE;
 448                         handle_qm_18x(sdi, tokens);
 449                 } else if (devc->profile->model == FLUKE_287 || devc->profile->model == FLUKE_289) {
 450                         devc->expect_response = FALSE;
 451                         handle_qm_28x(sdi, tokens);
 452                 } else if (devc->profile->model == FLUKE_190) {
 453                         devc->expect_response = FALSE;
 454                         for (num_tokens = 0; tokens[num_tokens]; num_tokens++);
 455                         if (num_tokens >= 7) {
 456                                 /* Response to QM: this is a comma-separated list of
 457                                  * fields with metadata about the measurement. This
 458                                  * format can return multiple sets of metadata,
 459                                  * split into sets of 7 tokens each. */
 460                                 devc->meas_type = 0;
 461                                 for (i = 0; i < num_tokens; i += 7)
 462                                         handle_qm_19x_meta(sdi, tokens + i);
 463                                 if (devc->meas_type) {
 464                                         /* Slip the request in now, before the main
 465                                          * timer loop asks for metadata again. */
 466                                         n = sprintf(cmd, "QM %d\r", devc->meas_type);
 467                                         if (serial_write_blocking(serial, cmd, n, SERIAL_WRITE_TIMEOUT_MS) < 0)
 468                                                 sr_err("Unable to send QM (measurement).");
 469                                 }
 470                         } else {
 471                                 /* Response to QM <n> measurement request. */
 472                                 handle_qm_19x_data(sdi, tokens);
 473                         }
 474                 }
 475         }
 476         g_strfreev(tokens);
 477         devc->buflen = 0;
 478 }
 479
 480 SR_PRIV int fluke_receive_data(int fd, int revents, void *cb_data)
 481 {
 482         struct sr_dev_inst *sdi;
 483         struct dev_context *devc;
 484         struct sr_serial_dev_inst *serial;
 485         int len;
 486         int64_t now, elapsed;
 487
 488         (void)fd;
 489
 490         if (!(sdi = cb_data))
 491                 return TRUE;
 492
 493         if (!(devc = sdi->priv))
 494                 return TRUE;
 495
 496         serial = sdi->conn;
 497         if (revents == G_IO_IN) {
 498                 /* Serial data arrived. */
 499                 while (FLUKEDMM_BUFSIZE - devc->buflen - 1 > 0) {
 500                         len = serial_read_nonblocking(serial, devc->buf + devc->buflen, 1);
 501                         if (len < 1)
 502                                 break;
 503                         devc->buflen++;
 504                         *(devc->buf + devc->buflen) = '\0';
 505                         if (*(devc->buf + devc->buflen - 1) == '\r') {
 506                                 *(devc->buf + --devc->buflen) = '\0';
 507                                 handle_line(sdi);
 508                                 break;
 509                         }
 510                 }
 511         }
 512
 513         if (sr_sw_limits_check(&devc->limits)) {
 514                 sr_dev_acquisition_stop(sdi);
 515                 return TRUE;
 516         }
 517
 518         now = g_get_monotonic_time() / 1000;
 519         elapsed = now - devc->cmd_sent_at;
 520         /* Send query command at poll_period interval, or after 1 second
 521          * has elapsed. This will make it easier to recover from any
 522          * out-of-sync or temporary disconnect issues. */
 523         if ((devc->expect_response == FALSE && elapsed > devc->profile->poll_period)
 524                         || elapsed > devc->profile->timeout) {
 525                 if (serial_write_blocking(serial, "QM\r", 3, SERIAL_WRITE_TIMEOUT_MS) < 0)
 526                         sr_err("Unable to send QM.");
 527                 devc->cmd_sent_at = now;
 528                 devc->expect_response = TRUE;
 529         }
 530
 531         return TRUE;
 532 }