hardware/radioshack-dmm/protocol.c

   1 /*
   2  * This file is part of the sigrok project.
   3  *
   4  * Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
   5  * Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdlib.h>
  22 #include <math.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <glib.h>
  26 #include "libsigrok.h"
  27 #include "libsigrok-internal.h"
  28 #include "protocol.h"
  29
  30 /* Byte 1 of the packet, and the modes it represents */
  31 #define IND1_HZ         0x80
  32 #define IND1_OHM        0x40
  33 #define IND1_KILO       0x20
  34 #define IND1_MEGA       0x10
  35 #define IND1_FARAD      0x08
  36 #define IND1_AMP        0x04
  37 #define IND1_VOLT       0x02
  38 #define IND1_MILI       0x01
  39 /* Byte 2 of the packet, and the modes it represents */
  40 #define IND2_MICRO      0x80
  41 #define IND2_NANO       0x40
  42 #define IND2_DBM        0x20
  43 #define IND2_SEC        0x10
  44 #define IND2_DUTY       0x08
  45 #define IND2_HFE        0x04
  46 #define IND2_REL        0x02
  47 #define IND2_MIN        0x01
  48 /* Byte 7 of the packet, and the modes it represents */
  49 #define INFO_BEEP       0x80
  50 #define INFO_DIODE      0x30
  51 #define INFO_BAT        0x20
  52 #define INFO_HOLD       0x10
  53 #define INFO_NEG        0x08
  54 #define INFO_AC         0x04
  55 #define INFO_RS232      0x02
  56 #define INFO_AUTO       0x01
  57 /* Instead of a decimal point, digit 4 carries the MAX flag */
  58 #define DIG4_MAX        0x08
  59 /* Mask to remove the decimal point from a digit */
  60 #define DP_MASK         0x08
  61
  62 /* What the LCD values represent */
  63 #define LCD_0           0xd7
  64 #define LCD_1           0x50
  65 #define LCD_2           0xb5
  66 #define LCD_3           0xf1
  67 #define LCD_4           0x72
  68 #define LCD_5           0xe3
  69 #define LCD_6           0xe7
  70 #define LCD_7           0x51
  71 #define LCD_8           0xf7
  72 #define LCD_9           0xf3
  73
  74 #define LCD_C           0x87
  75 #define LCD_E
  76 #define LCD_F
  77 #define LCD_h           0x66
  78 #define LCD_H           0x76
  79 #define LCD_I
  80 #define LCD_n
  81 #define LCD_P           0x37
  82 #define LCD_r
  83
  84 enum {
  85         MODE_DC_V       = 0,
  86         MODE_AC_V       = 1,
  87         MODE_DC_UA      = 2,
  88         MODE_DC_MA      = 3,
  89         MODE_DC_A       = 4,
  90         MODE_AC_UA      = 5,
  91         MODE_AC_MA      = 6,
  92         MODE_AC_A       = 7,
  93         MODE_OHM        = 8,
  94         MODE_FARAD      = 9,
  95         MODE_HZ         = 10,
  96         MODE_VOLT_HZ    = 11,
  97         MODE_AMP_HZ     = 12,
  98         MODE_DUTY       = 13,
  99         MODE_VOLT_DUTY  = 14,
 100         MODE_AMP_DUTY   = 15,
 101         MODE_WIDTH      = 16,
 102         MODE_VOLT_WIDTH = 17,
 103         MODE_AMP_WIDTH  = 18,
 104         MODE_DIODE      = 19,
 105         MODE_CONT       = 20,
 106         MODE_HFE        = 21,
 107         MODE_LOGIC      = 22,
 108         MODE_DBM        = 23,
 109         // MODE_EF      = 24,
 110         MODE_TEMP       = 25,
 111         MODE_INVALID    = 26,
 112 };
 113
 114 enum {
 115         READ_ALL,
 116         READ_TEMP,
 117 };
 118
 119 static gboolean checksum_valid(const struct rs_22_812_packet *rs_packet)
 120 {
 121         uint8_t *raw;
 122         uint8_t sum = 0;
 123         int i;
 124
 125         raw = (void *)rs_packet;
 126
 127         for (i = 0; i < RS_22_812_PACKET_SIZE - 1; i++)
 128                 sum += raw[i];
 129
 130         /* This is just a funky constant added to the checksum. */
 131         sum += 57;
 132         sum -= rs_packet->checksum;
 133         return (sum == 0);
 134 }
 135
 136 static gboolean selection_good(const struct rs_22_812_packet *rs_packet)
 137 {
 138         int count;
 139
 140         /* Does the packet have more than one multiplier ? */
 141         count = 0;
 142         count += (rs_packet->indicatrix1 & IND1_KILO)  ? 1 : 0;
 143         count += (rs_packet->indicatrix1 & IND1_MEGA)  ? 1 : 0;
 144         count += (rs_packet->indicatrix1 & IND1_MILI)  ? 1 : 0;
 145         count += (rs_packet->indicatrix2 & IND2_MICRO) ? 1 : 0;
 146         count += (rs_packet->indicatrix2 & IND2_NANO)  ? 1 : 0;
 147         if (count > 1) {
 148                 sr_err("More than one multiplier detected in packet.");
 149                 return FALSE;
 150         }
 151
 152         /* Does the packet "measure" more than one type of value? */
 153         count = 0;
 154         count += (rs_packet->indicatrix1 & IND1_HZ)    ? 1 : 0;
 155         count += (rs_packet->indicatrix1 & IND1_OHM)   ? 1 : 0;
 156         count += (rs_packet->indicatrix1 & IND1_FARAD) ? 1 : 0;
 157         count += (rs_packet->indicatrix1 & IND1_AMP)   ? 1 : 0;
 158         count += (rs_packet->indicatrix1 & IND1_VOLT)  ? 1 : 0;
 159         count += (rs_packet->indicatrix2 & IND2_DBM)   ? 1 : 0;
 160         count += (rs_packet->indicatrix2 & IND2_SEC)   ? 1 : 0;
 161         count += (rs_packet->indicatrix2 & IND2_DUTY)  ? 1 : 0;
 162         count += (rs_packet->indicatrix2 & IND2_HFE)   ? 1 : 0;
 163         if (count > 1) {
 164                 sr_err("More than one measurement type detected in packet.");
 165                 return FALSE;
 166         }
 167
 168         return TRUE;
 169 }
 170
 171 /*
 172  * Since the 22-812 does not identify itself in any way, shape, or form,
 173  * we really don't know for sure who is sending the data. We must use every
 174  * possible check to filter out bad packets, especially since detection of the
 175  * 22-812 depends on how well we can filter the packets.
 176  */
 177 SR_PRIV gboolean rs_22_812_packet_valid(const struct rs_22_812_packet *rs_packet)
 178 {
 179         /*
 180          * Check for valid mode first, before calculating the checksum.
 181          * No point calculating the checksum, if we know we'll reject the packet
 182          * */
 183         if (!(rs_packet->mode < MODE_INVALID))
 184                 return FALSE;
 185
 186         if (!checksum_valid(rs_packet))
 187                 return FALSE;
 188
 189         if (!selection_good(rs_packet))
 190                 return FALSE;
 191
 192         return TRUE;
 193 }
 194
 195 static uint8_t decode_digit(uint8_t raw_digit)
 196 {
 197         /* Take out the decimal point, so we can use a simple switch(). */
 198         raw_digit &= ~DP_MASK;
 199
 200         switch (raw_digit) {
 201         case 0x00:
 202         case LCD_0:
 203                 return 0;
 204         case LCD_1:
 205                 return 1;
 206         case LCD_2:
 207                 return 2;
 208         case LCD_3:
 209                 return 3;
 210         case LCD_4:
 211                 return 4;
 212         case LCD_5:
 213                 return 5;
 214         case LCD_6:
 215                 return 6;
 216         case LCD_7:
 217                 return 7;
 218         case LCD_8:
 219                 return 8;
 220         case LCD_9:
 221                 return 9;
 222         default:
 223                 sr_err("Invalid digit byte: 0x%02x.", raw_digit);
 224                 return 0xff;
 225         }
 226 }
 227
 228 static double lcd_to_double(const struct rs_22_812_packet *rs_packet, int type)
 229 {
 230         double rawval, multiplier = 1;
 231         uint8_t digit, raw_digit;
 232         gboolean dp_reached = FALSE;
 233         int i, end;
 234
 235         /* end = 1: Don't parse last digit. end = 0: Parse all digits. */
 236         end = (type == READ_TEMP) ? 1 : 0;
 237
 238         /* We have 4 digits, and we start from the most significant. */
 239         for (i = 3; i >= end; i--) {
 240                 raw_digit = *(&(rs_packet->digit4) + i);
 241                 digit = decode_digit(raw_digit);
 242                 if (digit == 0xff) {
 243                         rawval = NAN;
 244                         break;
 245                 }
 246                 /*
 247                  * Digit 1 does not have a decimal point. Instead, the decimal
 248                  * point is used to indicate MAX, so we must avoid testing it.
 249                  */
 250                 if ((i < 3) && (raw_digit & DP_MASK))
 251                         dp_reached = TRUE;
 252                 if (dp_reached)
 253                         multiplier /= 10;
 254                 rawval = rawval * 10 + digit;
 255         }
 256         rawval *= multiplier;
 257         if (rs_packet->info & INFO_NEG)
 258                 rawval *= -1;
 259
 260         /* See if we need to multiply our raw value by anything. */
 261         if (rs_packet->indicatrix1 & IND2_NANO) {
 262                 rawval *= 1E-9;
 263         } else if (rs_packet->indicatrix2 & IND2_MICRO) {
 264                 rawval *= 1E-6;
 265         } else if (rs_packet->indicatrix1 & IND1_MILI) {
 266                 rawval *= 1E-3;
 267         } else if (rs_packet->indicatrix1 & IND1_KILO) {
 268                 rawval *= 1E3;
 269         } else if (rs_packet->indicatrix1 & IND1_MEGA) {
 270                 rawval *= 1E6;
 271         }
 272
 273         return rawval;
 274 }
 275
 276 static gboolean is_celsius(struct rs_22_812_packet *rs_packet)
 277 {
 278         return ((rs_packet->digit4 & ~DP_MASK) == LCD_C);
 279 }
 280
 281 static gboolean is_shortcirc(struct rs_22_812_packet *rs_packet)
 282 {
 283         return ((rs_packet->digit2 & ~DP_MASK) == LCD_h);
 284 }
 285
 286 static gboolean is_logic_high(struct rs_22_812_packet *rs_packet)
 287 {
 288         sr_spew("Digit 2: 0x%02x.", rs_packet->digit2 & ~DP_MASK);
 289         return ((rs_packet->digit2 & ~DP_MASK) == LCD_H);
 290 }
 291
 292 static void handle_packet(struct rs_22_812_packet *rs_packet,
 293                           struct dev_context *devc)
 294 {
 295         double rawval;
 296         struct sr_datafeed_packet packet;
 297         struct sr_datafeed_analog *analog;
 298
 299         rawval = lcd_to_double(rs_packet, READ_ALL);
 300
 301         /* TODO: Check malloc return value. */
 302         analog = g_try_malloc0(sizeof(struct sr_datafeed_analog));
 303         analog->num_samples = 1;
 304         /* TODO: Check malloc return value. */
 305         analog->data = g_try_malloc(sizeof(float));
 306         *analog->data = (float)rawval;
 307         analog->mq = -1;
 308
 309         switch (rs_packet->mode) {
 310         case MODE_DC_V:
 311                 analog->mq = SR_MQ_VOLTAGE;
 312                 analog->unit = SR_UNIT_VOLT;
 313                 analog->mqflags |= SR_MQFLAG_DC;
 314                 break;
 315         case MODE_AC_V:
 316                 analog->mq = SR_MQ_VOLTAGE;
 317                 analog->unit = SR_UNIT_VOLT;
 318                 analog->mqflags |= SR_MQFLAG_AC;
 319                 break;
 320         case MODE_DC_UA:
 321         case MODE_DC_MA:
 322         case MODE_DC_A:
 323                 analog->mq = SR_MQ_CURRENT;
 324                 analog->unit = SR_UNIT_AMPERE;
 325                 analog->mqflags |= SR_MQFLAG_DC;
 326                 break;
 327         case MODE_AC_UA:
 328         case MODE_AC_MA:
 329         case MODE_AC_A:
 330                 analog->mq = SR_MQ_CURRENT;
 331                 analog->unit = SR_UNIT_AMPERE;
 332                 analog->mqflags |= SR_MQFLAG_AC;
 333                 break;
 334         case MODE_OHM:
 335                 analog->mq = SR_MQ_RESISTANCE;
 336                 analog->unit = SR_UNIT_OHM;
 337                 break;
 338         case MODE_FARAD:
 339                 analog->mq = SR_MQ_CAPACITANCE;
 340                 analog->unit = SR_UNIT_FARAD;
 341                 break;
 342         case MODE_CONT:
 343                 analog->mq = SR_MQ_CONTINUITY;
 344                 analog->unit = SR_UNIT_BOOLEAN;
 345                 *analog->data = is_shortcirc(rs_packet);
 346                 break;
 347         case MODE_DIODE:
 348                 analog->mq = SR_MQ_VOLTAGE;
 349                 analog->unit = SR_UNIT_VOLT;
 350                 analog->mqflags |= SR_MQFLAG_DIODE | SR_MQFLAG_DC;
 351                 break;
 352         case MODE_HZ:
 353         case MODE_VOLT_HZ:
 354         case MODE_AMP_HZ:
 355                 analog->mq = SR_MQ_FREQUENCY;
 356                 analog->unit = SR_UNIT_HERTZ;
 357                 break;
 358         case MODE_LOGIC:
 359                 /*
 360                  * No matter whether or not we have an actual voltage reading,
 361                  * we are measuring voltage, so we set our MQ as VOLTAGE.
 362                  */
 363                 analog->mq = SR_MQ_VOLTAGE;
 364                 if (!isnan(rawval)) {
 365                         /* We have an actual voltage. */
 366                         analog->unit = SR_UNIT_VOLT;
 367                 } else {
 368                         /* We have either HI or LOW. */
 369                         analog->unit = SR_UNIT_BOOLEAN;
 370                         *analog->data = is_logic_high(rs_packet);
 371                 }
 372                 break;
 373         case MODE_HFE:
 374                 analog->mq = SR_MQ_GAIN;
 375                 analog->unit = SR_UNIT_UNITLESS;
 376                 break;
 377         case MODE_DUTY:
 378         case MODE_VOLT_DUTY:
 379         case MODE_AMP_DUTY:
 380                 analog->mq = SR_MQ_DUTY_CYCLE;
 381                 analog->unit = SR_UNIT_PERCENTAGE;
 382                 break;
 383         case MODE_WIDTH:
 384         case MODE_VOLT_WIDTH:
 385         case MODE_AMP_WIDTH:
 386                 analog->mq = SR_MQ_PULSE_WIDTH;
 387                 analog->unit = SR_UNIT_SECOND;
 388         case MODE_TEMP:
 389                 analog->mq = SR_MQ_TEMPERATURE;
 390                 /* We need to reparse. */
 391                 *analog->data = lcd_to_double(rs_packet, READ_TEMP);
 392                 analog->unit = is_celsius(rs_packet) ?
 393                                SR_UNIT_CELSIUS : SR_UNIT_FAHRENHEIT;
 394                 break;
 395         case MODE_DBM:
 396                 analog->mq = SR_MQ_POWER;
 397                 analog->unit = SR_UNIT_DECIBEL_MW;
 398                 analog->mqflags |= SR_MQFLAG_AC;
 399                 break;
 400         default:
 401                 sr_err("Unknown mode: %d.", rs_packet->mode);
 402                 break;
 403         }
 404
 405         if (rs_packet->info & INFO_HOLD)
 406                 analog->mqflags |= SR_MQFLAG_HOLD;
 407         if (rs_packet->digit4 & DIG4_MAX)
 408                 analog->mqflags |= SR_MQFLAG_MAX;
 409         if (rs_packet->indicatrix2 & IND2_MIN)
 410                 analog->mqflags |= SR_MQFLAG_MIN;
 411         if (rs_packet->info & INFO_AUTO)
 412                 analog->mqflags |= SR_MQFLAG_AUTORANGE;
 413
 414         if (analog->mq != -1) {
 415                 /* Got a measurement. */
 416                 sr_spew("Value: %f.", rawval);
 417                 packet.type = SR_DF_ANALOG;
 418                 packet.payload = analog;
 419                 sr_session_send(devc->cb_data, &packet);
 420                 devc->num_samples++;
 421         }
 422         g_free(analog->data);
 423         g_free(analog);
 424 }
 425
 426 static void handle_new_data(struct dev_context *devc)
 427 {
 428         int len;
 429         size_t i, offset = 0;
 430         struct rs_22_812_packet *rs_packet;
 431
 432         /* Try to get as much data as the buffer can hold. */
 433         len = RS_DMM_BUFSIZE - devc->buflen;
 434         len = serial_read(devc->serial, devc->buf + devc->buflen, len);
 435         if (len < 1) {
 436                 sr_err("Serial port read error.");
 437                 return;
 438         }
 439         devc->buflen += len;
 440
 441         /* Now look for packets in that data. */
 442         while ((devc->buflen - offset) >= RS_22_812_PACKET_SIZE) {
 443                 rs_packet = (void *)(devc->buf + offset);
 444                 if (rs_22_812_packet_valid(rs_packet)) {
 445                         handle_packet(rs_packet, devc);
 446                         offset += RS_22_812_PACKET_SIZE;
 447                 } else {
 448                         offset++;
 449                 }
 450         }
 451
 452         /* If we have any data left, move it to the beginning of our buffer. */
 453         for (i = 0; i < devc->buflen - offset; i++)
 454                 devc->buf[i] = devc->buf[offset + i];
 455         devc->buflen -= offset;
 456 }
 457
 458 SR_PRIV int radioshack_dmm_receive_data(int fd, int revents, void *cb_data)
 459 {
 460         struct sr_dev_inst *sdi;
 461         struct dev_context *devc;
 462
 463         (void)fd;
 464
 465         if (!(sdi = cb_data))
 466                 return TRUE;
 467
 468         if (!(devc = sdi->priv))
 469                 return TRUE;
 470
 471         if (revents == G_IO_IN) {
 472                 /* Serial data arrived. */
 473                 handle_new_data(devc);
 474         }
 475
 476         if (devc->num_samples >= devc->limit_samples) {
 477                 sdi->driver->dev_acquisition_stop(sdi, cb_data);
 478                 return TRUE;
 479         }
 480
 481         return TRUE;
 482 }