hardware/radioshack-dmm/api.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 <glib.h>
  22 #include "libsigrok.h"
  23 #include "libsigrok-internal.h"
  24 #include "radioshack-dmm.h"
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <fcntl.h>
  28 #include <string.h>
  29 #include <errno.h>
  30
  31 static const int hwopts[] = {
  32         SR_HWOPT_CONN,
  33         SR_HWOPT_SERIALCOMM,
  34         0,
  35 };
  36
  37 static const int hwcaps[] = {
  38         SR_HWCAP_MULTIMETER,
  39         SR_HWCAP_LIMIT_SAMPLES,
  40         SR_HWCAP_CONTINUOUS,
  41         0,
  42 };
  43
  44 static const char *probe_names[] = {
  45         "Probe",
  46         NULL,
  47 };
  48
  49 SR_PRIV struct sr_dev_driver radioshackdmm_driver_info;
  50 static struct sr_dev_driver *di = &radioshackdmm_driver_info;
  51
  52 static const struct radioshackdmm_profile supported_radioshackdmm[] = {
  53         { RADIOSHACK_22_812, "22-812", 100 },
  54 };
  55
  56 /* Properly close and free all devices. */
  57 static int clear_instances(void)
  58 {
  59         struct sr_dev_inst *sdi;
  60         struct drv_context *drvc;
  61         struct dev_context *devc;
  62         GSList *l;
  63
  64         if (!(drvc = di->priv))
  65                 return SR_OK;
  66
  67         drvc = di->priv;
  68         for (l = drvc->instances; l; l = l->next) {
  69                 if (!(sdi = l->data))
  70                         continue;
  71                 if (!(devc = sdi->priv))
  72                         continue;
  73                 sr_serial_dev_inst_free(devc->serial);
  74                 sr_dev_inst_free(sdi);
  75         }
  76         g_slist_free(drvc->instances);
  77         drvc->instances = NULL;
  78
  79         return SR_OK;
  80 }
  81
  82 static int hw_init(void)
  83 {
  84         struct drv_context *drvc;
  85
  86         if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
  87                 sr_err("Driver context malloc failed.");
  88                 return SR_ERR;
  89         }
  90
  91         di->priv = drvc;
  92
  93         return SR_OK;
  94 }
  95
  96 static int serial_readline(int fd, char **buf, size_t *buflen,
  97                            uint64_t timeout_ms)
  98 {
  99         uint64_t start;
 100         int maxlen, len;
 101
 102         timeout_ms *= 1000;
 103         start = g_get_monotonic_time();
 104
 105         maxlen = *buflen;
 106         *buflen = len = 0;
 107         while(1) {
 108                 len = maxlen - *buflen - 1;
 109                 if (len < 1)
 110                         break;
 111                 len = serial_read(fd, *buf + *buflen, 1);
 112                 if (len > 0) {
 113                         *buflen += len;
 114                         *(*buf + *buflen) = '\0';
 115                         if (*buflen > 0 && *(*buf + *buflen - 1) == '\r') {
 116                                 /* Strip LF and terminate. */
 117                                 *(*buf + --*buflen) = '\0';
 118                                 break;
 119                         }
 120                 }
 121                 if (g_get_monotonic_time() - start > timeout_ms)
 122                         /* Timeout */
 123                         break;
 124                 g_usleep(2000);
 125         }
 126
 127         return SR_OK;
 128 }
 129
 130 static GSList *rs_22_812_scan(const char *conn, const char *serialcomm)
 131 {
 132         struct sr_dev_inst *sdi;
 133         struct drv_context *drvc;
 134         struct dev_context *devc;
 135         struct sr_probe *probe;
 136         GSList *devices;
 137         int fd, retry;
 138         size_t len;
 139         char buf[128], *b;
 140
 141         if ((fd = serial_open(conn, O_RDONLY|O_NONBLOCK)) == -1) {
 142                 sr_err("Unable to open %s: %s.", conn, strerror(errno));
 143                 return NULL;
 144         }
 145         if (serial_set_paramstr(fd, serialcomm) != SR_OK) {
 146                 sr_err("Unable to set serial parameters.");
 147                 return NULL;
 148         }
 149
 150         sr_info("Probing port %s readonly.", conn);
 151
 152         drvc = di->priv;
 153         b = buf;
 154         retry = 0;
 155         devices = NULL;
 156         /* There's no way to get an ID from the multimeter. It just sends data
 157          * periodically, so the best we can do is check if the packets match the
 158          * expected format. */
 159         while (!devices && retry < 3)
 160         {
 161                 size_t i;
 162                 size_t good_packets = 0;
 163                 retry++;
 164                 serial_flush(fd);
 165
 166                 /* Let's get a bit of data and see if we can find a packet */
 167                 len = sizeof(buf);
 168                 serial_readline(fd, &b, &len, 250);
 169                 if( (len == 0) || (len < RS_22_812_PACKET_SIZE) ) {
 170                         /* Not enough data received, is the DMM connected ? */
 171                         continue;
 172                 }
 173
 174                 /* Let's treat our buffer like a stream, and find any
 175                  * valid packets */
 176                 for( i = 0; i < len - RS_22_812_PACKET_SIZE + 1;
 177                     /* don't increment i here */ )
 178                 {
 179                         const rs_22_812_packet *packet = (void *)(&buf[i]);
 180                         if( !rs_22_812_is_packet_valid(packet) ){
 181                                 i++;
 182                                 continue;
 183                         }
 184                         good_packets++;
 185                         i += RS_22_812_PACKET_SIZE;
 186                 }
 187
 188                 /* If we dropped more than two packets worth of data, something
 189                  * is wrong */
 190                 size_t dropped = len - (good_packets * RS_22_812_PACKET_SIZE);
 191                 if(dropped > 2 * RS_22_812_PACKET_SIZE)
 192                         continue;
 193
 194                 /* Let's see if we have anything good */
 195                 if (good_packets == 0)
 196                         continue;
 197
 198                 sr_info("Found RS 22-812 on port %s.", conn);
 199
 200                 if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "RadioShack",
 201                                             "22-812", "")))
 202                         return NULL;
 203                 if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
 204                         sr_err("Device context malloc failed.");
 205                         return NULL;
 206                 }
 207
 208                 /* devc->profile = RADIOSHACK_22_812; */
 209                 devc->serial = sr_serial_dev_inst_new(conn, -1);
 210                 devc->serialcomm = g_strdup(serialcomm);
 211
 212                 sdi->priv = devc;
 213                 sdi->driver = di;
 214                 if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
 215                         return NULL;
 216                 sdi->probes = g_slist_append(sdi->probes, probe);
 217                 drvc->instances = g_slist_append(drvc->instances, sdi);
 218                 devices = g_slist_append(devices, sdi);
 219                 break;
 220         }
 221         serial_close(fd);
 222
 223         return devices;
 224 }
 225
 226 static GSList *hw_scan(GSList *options)
 227 {
 228         struct sr_hwopt *opt;
 229         GSList *l, *devices;
 230         const char *conn, *serialcomm;
 231
 232         conn = serialcomm = NULL;
 233         for (l = options; l; l = l->next) {
 234                 opt = l->data;
 235                 switch (opt->hwopt) {
 236                 case SR_HWOPT_CONN:
 237                         conn = opt->value;
 238                         break;
 239                 case SR_HWOPT_SERIALCOMM:
 240                         serialcomm = opt->value;
 241                         break;
 242                 }
 243         }
 244         if (!conn)
 245                 return NULL;
 246
 247         if (serialcomm) {
 248                 /* Use the provided comm specs. */
 249                 devices = rs_22_812_scan(conn, serialcomm);
 250         } else {
 251                 /* Then try the default 4800 8n1 */
 252                 devices = rs_22_812_scan(conn, "4800/8n1");
 253         }
 254
 255         return devices;
 256 }
 257
 258 static GSList *hw_dev_list(void)
 259 {
 260         struct drv_context *drvc;
 261
 262         drvc = di->priv;
 263
 264         return drvc->instances;
 265 }
 266
 267 static int hw_dev_open(struct sr_dev_inst *sdi)
 268 {
 269         struct dev_context *devc;
 270
 271         if (!(devc = sdi->priv)) {
 272                 sr_err("sdi->priv was NULL.");
 273                 return SR_ERR_BUG;
 274         }
 275
 276         devc->serial->fd = serial_open(devc->serial->port, O_RDONLY);
 277         if (devc->serial->fd == -1) {
 278                 sr_err("Couldn't open serial port '%s'.",
 279                        devc->serial->port);
 280                 return SR_ERR;
 281         }
 282         if (serial_set_paramstr(devc->serial->fd, devc->serialcomm) != SR_OK) {
 283                 sr_err("Unable to set serial parameters.");
 284                 return SR_ERR;
 285         }
 286         sdi->status = SR_ST_ACTIVE;
 287
 288         return SR_OK;
 289 }
 290
 291 static int hw_dev_close(struct sr_dev_inst *sdi)
 292 {
 293         struct dev_context *devc;
 294
 295         if (!(devc = sdi->priv)) {
 296                 sr_err("sdi->priv was NULL.");
 297                 return SR_ERR_BUG;
 298         }
 299
 300         if (devc->serial && devc->serial->fd != -1) {
 301                 serial_close(devc->serial->fd);
 302                 devc->serial->fd = -1;
 303                 sdi->status = SR_ST_INACTIVE;
 304         }
 305
 306         return SR_OK;
 307 }
 308
 309 static int hw_cleanup(void)
 310 {
 311         clear_instances();
 312
 313         return SR_OK;
 314 }
 315
 316 static int hw_info_get(int info_id, const void **data,
 317        const struct sr_dev_inst *sdi)
 318 {
 319         (void)sdi; /* Does nothing. prevents "unused parameter" warning */
 320
 321         switch (info_id) {
 322         case SR_DI_HWOPTS:
 323                 *data = hwopts;
 324                 break;
 325         case SR_DI_HWCAPS:
 326                 *data = hwcaps;
 327                 break;
 328         case SR_DI_NUM_PROBES:
 329                 *data = GINT_TO_POINTER(1);
 330                 break;
 331         case SR_DI_PROBE_NAMES:
 332                 *data = probe_names;
 333                 break;
 334         default:
 335                 return SR_ERR_ARG;
 336         }
 337
 338         return SR_OK;
 339 }
 340
 341 static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
 342                 const void *value)
 343 {
 344         struct dev_context *devc;
 345
 346         if (sdi->status != SR_ST_ACTIVE)
 347                 return SR_ERR;
 348
 349         if (!(devc = sdi->priv)) {
 350                 sr_err("sdi->priv was NULL.");
 351                 return SR_ERR_BUG;
 352         }
 353
 354         switch (hwcap) {
 355         case SR_HWCAP_LIMIT_SAMPLES:
 356                 devc->limit_samples = *(const uint64_t *)value;
 357                 sr_dbg("Setting sample limit to %" PRIu64 ".",
 358                        devc->limit_samples);
 359                 break;
 360         default:
 361                 sr_err("Unknown capability: %d.", hwcap);
 362                 return SR_ERR;
 363                 break;
 364         }
 365
 366         return SR_OK;
 367 }
 368
 369 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 370                 void *cb_data)
 371 {
 372         struct sr_datafeed_packet packet;
 373         struct sr_datafeed_header header;
 374         struct sr_datafeed_meta_analog meta;
 375         struct dev_context *devc;
 376
 377         if (!(devc = sdi->priv)) {
 378                 sr_err("sdi->priv was NULL.");
 379                 return SR_ERR_BUG;
 380         }
 381
 382         sr_dbg("Starting acquisition.");
 383
 384         devc->cb_data = cb_data;
 385
 386         /* Reset the number of samples to take. If we've already collected our
 387          * quota, but we start a new session, and don't reset this, we'll just
 388          * quit without aquiring any new samples */
 389         devc->num_samples = 0;
 390
 391         /* Send header packet to the session bus. */
 392         sr_dbg("Sending SR_DF_HEADER.");
 393         packet.type = SR_DF_HEADER;
 394         packet.payload = (uint8_t *)&header;
 395         header.feed_version = 1;
 396         gettimeofday(&header.starttime, NULL);
 397         sr_session_send(devc->cb_data, &packet);
 398
 399         /* Send metadata about the SR_DF_ANALOG packets to come. */
 400         sr_dbg("Sending SR_DF_META_ANALOG.");
 401         packet.type = SR_DF_META_ANALOG;
 402         packet.payload = &meta;
 403         meta.num_probes = 1;
 404         sr_session_send(devc->cb_data, &packet);
 405
 406         /* Poll every 100ms, or whenever some data comes in. */
 407         sr_source_add(devc->serial->fd, G_IO_IN, 50,
 408                       radioshack_receive_data, (void *)sdi );
 409
 410         return SR_OK;
 411 }
 412
 413 static int hw_dev_acquisition_stop(const struct sr_dev_inst *sdi,
 414                 void *cb_data)
 415 {
 416         struct sr_datafeed_packet packet;
 417         struct dev_context *devc;
 418
 419         if (sdi->status != SR_ST_ACTIVE)
 420                 return SR_ERR;
 421
 422         if (!(devc = sdi->priv)) {
 423                 sr_err("sdi->priv was NULL.");
 424                 return SR_ERR_BUG;
 425         }
 426
 427         sr_dbg("Stopping acquisition.");
 428
 429         sr_source_remove(devc->serial->fd);
 430         hw_dev_close((struct sr_dev_inst *)sdi);
 431
 432         /* Send end packet to the session bus. */
 433         sr_dbg("Sending SR_DF_END.");
 434         packet.type = SR_DF_END;
 435         sr_session_send(cb_data, &packet);
 436
 437         return SR_OK;
 438 }
 439
 440 SR_PRIV struct sr_dev_driver radioshackdmm_driver_info = {
 441         .name = "radioshack-dmm",
 442         .longname = "Radioshack 22-812/22-039 DMMs",
 443         .api_version = 1,
 444         .init = hw_init,
 445         .cleanup = hw_cleanup,
 446         .scan = hw_scan,
 447         .dev_list = hw_dev_list,
 448         .dev_clear = clear_instances,
 449         .dev_open = hw_dev_open,
 450         .dev_close = hw_dev_close,
 451         .info_get = hw_info_get,
 452         .dev_config_set = hw_dev_config_set,
 453         .dev_acquisition_start = hw_dev_acquisition_start,
 454         .dev_acquisition_stop = hw_dev_acquisition_stop,
 455         .priv = NULL,
 456 };