hardware/agilent-dmm/api.c

   1 /*
   2  * This file is part of the sigrok 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 <glib.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <fcntl.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include "libsigrok.h"
  27 #include "libsigrok-internal.h"
  28 #include "agilent-dmm.h"
  29
  30 static const int hwopts[] = {
  31         SR_HWOPT_CONN,
  32         SR_HWOPT_SERIALCOMM,
  33         0,
  34 };
  35
  36 static const int hwcaps[] = {
  37         SR_HWCAP_MULTIMETER,
  38         SR_HWCAP_LIMIT_SAMPLES,
  39         SR_HWCAP_LIMIT_MSEC,
  40         SR_HWCAP_CONTINUOUS,
  41         0,
  42 };
  43
  44 static const char *probe_names[] = {
  45         "Probe",
  46         NULL,
  47 };
  48
  49 extern const struct agdmm_job agdmm_jobs_u123x[];
  50 extern const struct agdmm_recv agdmm_recvs_u123x[];
  51 extern const struct agdmm_job agdmm_jobs_u125x[];
  52 extern const struct agdmm_recv agdmm_recvs_u125x[];
  53
  54 /* This works on all the Agilent U12xxA series, although the
  55  * U127xA can apparently also run at 19200/8n1. */
  56 #define SERIALCOMM "9600/8n1"
  57
  58 static const struct agdmm_profile supported_agdmm[] = {
  59         { AGILENT_U1231A, "U1231A", agdmm_jobs_u123x, agdmm_recvs_u123x },
  60         { AGILENT_U1232A, "U1232A", agdmm_jobs_u123x, agdmm_recvs_u123x },
  61         { AGILENT_U1233A, "U1233A", agdmm_jobs_u123x, agdmm_recvs_u123x },
  62         { AGILENT_U1251A, "U1251A", agdmm_jobs_u125x, agdmm_recvs_u125x },
  63         { AGILENT_U1252A, "U1252A", agdmm_jobs_u125x, agdmm_recvs_u125x },
  64         { AGILENT_U1253A, "U1253A", agdmm_jobs_u125x, agdmm_recvs_u125x },
  65         { 0, NULL, NULL, NULL }
  66 };
  67
  68 SR_PRIV struct sr_dev_driver agdmm_driver_info;
  69 static struct sr_dev_driver *di = &agdmm_driver_info;
  70
  71 /* Properly close and free all devices. */
  72 static int clear_instances(void)
  73 {
  74         struct sr_dev_inst *sdi;
  75         struct drv_context *drvc;
  76         struct dev_context *devc;
  77         GSList *l;
  78
  79         if (!(drvc = di->priv))
  80                 return SR_OK;
  81
  82         drvc = di->priv;
  83         for (l = drvc->instances; l; l = l->next) {
  84                 if (!(sdi = l->data))
  85                         continue;
  86                 if (!(devc = sdi->priv))
  87                         continue;
  88                 sr_serial_dev_inst_free(devc->serial);
  89                 sr_dev_inst_free(sdi);
  90         }
  91         g_slist_free(drvc->instances);
  92         drvc->instances = NULL;
  93
  94         return SR_OK;
  95 }
  96
  97 static int hw_init(struct sr_context *sr_ctx)
  98 {
  99         struct drv_context *drvc;
 100
 101         if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
 102                 sr_err("Driver context malloc failed.");
 103                 return SR_ERR_MALLOC;
 104         }
 105
 106         di->priv = drvc;
 107
 108         return SR_OK;
 109 }
 110
 111 static GSList *hw_scan(GSList *options)
 112 {
 113         struct sr_dev_inst *sdi;
 114         struct drv_context *drvc;
 115         struct dev_context *devc;
 116         struct sr_hwopt *opt;
 117         struct sr_probe *probe;
 118         struct sr_serial_dev_inst *serial;
 119         GSList *l, *devices;
 120         int len, i;
 121         const char *conn, *serialcomm;
 122         char *buf, **tokens;
 123
 124         drvc = di->priv;
 125         drvc->instances = NULL;
 126
 127         devices = NULL;
 128         conn = serialcomm = NULL;
 129         for (l = options; l; l = l->next) {
 130                 opt = l->data;
 131                 switch (opt->hwopt) {
 132                 case SR_HWOPT_CONN:
 133                         conn = opt->value;
 134                         break;
 135                 case SR_HWOPT_SERIALCOMM:
 136                         serialcomm = opt->value;
 137                         break;
 138                 }
 139         }
 140         if (!conn)
 141                 return NULL;
 142         if (!serialcomm)
 143                 serialcomm = SERIALCOMM;
 144
 145         if (!(serial = sr_serial_dev_inst_new(conn, serialcomm)))
 146                 return NULL;
 147
 148         if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
 149                 return NULL;
 150
 151         serial_flush(serial);
 152         if (serial_write(serial, "*IDN?\r\n", 7) == -1) {
 153                 sr_err("Unable to send identification string: %s.",
 154                        strerror(errno));
 155                 return NULL;
 156         }
 157
 158         len = 128;
 159         if (!(buf = g_try_malloc(len))) {
 160                 sr_err("Serial buffer malloc failed.");
 161                 return NULL;
 162         }
 163         serial_readline(serial, &buf, &len, 150);
 164         if (!len)
 165                 return NULL;
 166
 167         tokens = g_strsplit(buf, ",", 4);
 168         if (!strcmp("Agilent Technologies", tokens[0])
 169                         && tokens[2] && tokens[3]) {
 170                 for (i = 0; supported_agdmm[i].model; i++) {
 171                         if (strcmp(supported_agdmm[i].modelname, tokens[1]))
 172                                 continue;
 173                         if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, tokens[0],
 174                                         tokens[1], tokens[3])))
 175                                 return NULL;
 176                         if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
 177                                 sr_err("Device context malloc failed.");
 178                                 return NULL;
 179                         }
 180                         devc->profile = &supported_agdmm[i];
 181                         devc->serial = serial;
 182                         devc->cur_mq = -1;
 183                         sdi->priv = devc;
 184                         sdi->driver = di;
 185                         if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
 186                                 return NULL;
 187                         sdi->probes = g_slist_append(sdi->probes, probe);
 188                         drvc->instances = g_slist_append(drvc->instances, sdi);
 189                         devices = g_slist_append(devices, sdi);
 190                         break;
 191                 }
 192         }
 193         g_strfreev(tokens);
 194         g_free(buf);
 195
 196         serial_close(serial);
 197         if (!devices)
 198                 sr_serial_dev_inst_free(serial);
 199
 200         return devices;
 201 }
 202
 203 static GSList *hw_dev_list(void)
 204 {
 205         struct drv_context *drvc;
 206
 207         drvc = di->priv;
 208
 209         return drvc->instances;
 210 }
 211
 212 static int hw_dev_open(struct sr_dev_inst *sdi)
 213 {
 214         struct dev_context *devc;
 215
 216         if (!(devc = sdi->priv)) {
 217                 sr_err("sdi->priv was NULL.");
 218                 return SR_ERR_BUG;
 219         }
 220
 221         if (serial_open(devc->serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
 222                 return SR_ERR;
 223
 224         sdi->status = SR_ST_ACTIVE;
 225
 226         return SR_OK;
 227 }
 228
 229 static int hw_dev_close(struct sr_dev_inst *sdi)
 230 {
 231         struct dev_context *devc;
 232
 233         if (!(devc = sdi->priv)) {
 234                 sr_err("sdi->priv was NULL.");
 235                 return SR_ERR_BUG;
 236         }
 237
 238         if (devc->serial && devc->serial->fd != -1) {
 239                 serial_close(devc->serial);
 240                 sdi->status = SR_ST_INACTIVE;
 241         }
 242
 243         return SR_OK;
 244 }
 245
 246 static int hw_cleanup(void)
 247 {
 248
 249         clear_instances();
 250
 251         return SR_OK;
 252 }
 253
 254 static int hw_info_get(int info_id, const void **data,
 255        const struct sr_dev_inst *sdi)
 256 {
 257
 258         (void)sdi;
 259
 260         switch (info_id) {
 261         case SR_DI_HWOPTS:
 262                 *data = hwopts;
 263                 break;
 264         case SR_DI_HWCAPS:
 265                 *data = hwcaps;
 266                 break;
 267         case SR_DI_NUM_PROBES:
 268                 *data = GINT_TO_POINTER(1);
 269                 break;
 270         case SR_DI_PROBE_NAMES:
 271                 *data = probe_names;
 272                 break;
 273         default:
 274                 return SR_ERR_ARG;
 275         }
 276
 277         return SR_OK;
 278 }
 279
 280 static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
 281                 const void *value)
 282 {
 283         struct dev_context *devc;
 284
 285         if (sdi->status != SR_ST_ACTIVE)
 286                 return SR_ERR;
 287
 288         if (!(devc = sdi->priv)) {
 289                 sr_err("sdi->priv was NULL.");
 290                 return SR_ERR_BUG;
 291         }
 292
 293         switch (hwcap) {
 294         case SR_HWCAP_LIMIT_MSEC:
 295                 /* TODO: not yet implemented */
 296                 if (*(const uint64_t *)value == 0) {
 297                         sr_err("LIMIT_MSEC can't be 0.");
 298                         return SR_ERR;
 299                 }
 300                 devc->limit_msec = *(const uint64_t *)value;
 301                 sr_dbg("Setting time limit to %" PRIu64 "ms.",
 302                        devc->limit_msec);
 303                 break;
 304         case SR_HWCAP_LIMIT_SAMPLES:
 305                 devc->limit_samples = *(const uint64_t *)value;
 306                 sr_dbg("Setting sample limit to %" PRIu64 ".",
 307                        devc->limit_samples);
 308                 break;
 309         default:
 310                 sr_err("Unknown capability: %d.", hwcap);
 311                 return SR_ERR;
 312                 break;
 313         }
 314
 315         return SR_OK;
 316 }
 317
 318 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 319                 void *cb_data)
 320 {
 321         struct sr_datafeed_packet packet;
 322         struct sr_datafeed_header header;
 323         struct sr_datafeed_meta_analog meta;
 324         struct dev_context *devc;
 325
 326         if (!(devc = sdi->priv)) {
 327                 sr_err("sdi->priv was NULL.");
 328                 return SR_ERR_BUG;
 329         }
 330
 331         sr_dbg("Starting acquisition.");
 332
 333         devc->cb_data = cb_data;
 334
 335         /* Send header packet to the session bus. */
 336         sr_dbg("Sending SR_DF_HEADER.");
 337         packet.type = SR_DF_HEADER;
 338         packet.payload = (uint8_t *)&header;
 339         header.feed_version = 1;
 340         gettimeofday(&header.starttime, NULL);
 341         sr_session_send(devc->cb_data, &packet);
 342
 343         /* Send metadata about the SR_DF_ANALOG packets to come. */
 344         sr_dbg("Sending SR_DF_META_ANALOG.");
 345         packet.type = SR_DF_META_ANALOG;
 346         packet.payload = &meta;
 347         meta.num_probes = 1;
 348         sr_session_send(devc->cb_data, &packet);
 349
 350         /* Poll every 100ms, or whenever some data comes in. */
 351         sr_source_add(devc->serial->fd, G_IO_IN, 100, agdmm_receive_data, (void *)sdi);
 352
 353         return SR_OK;
 354 }
 355
 356 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 357 {
 358         struct sr_datafeed_packet packet;
 359         struct dev_context *devc;
 360
 361         if (sdi->status != SR_ST_ACTIVE)
 362                 return SR_ERR;
 363
 364         if (!(devc = sdi->priv)) {
 365                 sr_err("sdi->priv was NULL.");
 366                 return SR_ERR_BUG;
 367         }
 368
 369         sr_dbg("Stopping acquisition.");
 370
 371         sr_source_remove(devc->serial->fd);
 372         hw_dev_close((struct sr_dev_inst *)sdi);
 373
 374         /* Send end packet to the session bus. */
 375         sr_dbg("Sending SR_DF_END.");
 376         packet.type = SR_DF_END;
 377         sr_session_send(cb_data, &packet);
 378
 379
 380         return SR_OK;
 381 }
 382
 383 SR_PRIV struct sr_dev_driver agdmm_driver_info = {
 384         .name = "agilent-dmm",
 385         .longname = "Agilent U12xx series DMMs",
 386         .api_version = 1,
 387         .init = hw_init,
 388         .cleanup = hw_cleanup,
 389         .scan = hw_scan,
 390         .dev_list = hw_dev_list,
 391         .dev_clear = clear_instances,
 392         .dev_open = hw_dev_open,
 393         .dev_close = hw_dev_close,
 394         .info_get = hw_info_get,
 395         .dev_config_set = hw_dev_config_set,
 396         .dev_acquisition_start = hw_dev_acquisition_start,
 397         .dev_acquisition_stop = hw_dev_acquisition_stop,
 398         .priv = NULL,
 399 };