src/hardware/scpi-dmm/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2018 Gerhard Sittig <gerhard.sittig@gmx.net>
   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 <string.h>
  21 #include "protocol.h"
  22
  23 static struct sr_dev_driver scpi_dmm_driver_info;
  24
  25 static const uint32_t scanopts[] = {
  26         SR_CONF_CONN,
  27 };
  28
  29 static const uint32_t drvopts[] = {
  30         SR_CONF_MULTIMETER,
  31 };
  32
  33 static const uint32_t devopts[] = {
  34         SR_CONF_CONTINUOUS,
  35         SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
  36         SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
  37         SR_CONF_MEASURED_QUANTITY | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  38 };
  39
  40 static const struct scpi_command cmdset_agilent[] = {
  41         { DMM_CMD_SETUP_REMOTE, "\n", },
  42         { DMM_CMD_SETUP_FUNC, "CONF:%s", },
  43         { DMM_CMD_QUERY_FUNC, "CONF?", },
  44         { DMM_CMD_START_ACQ, "MEAS", },
  45         { DMM_CMD_STOP_ACQ, "ABORT", },
  46         { DMM_CMD_QUERY_VALUE, "READ?", },
  47         { DMM_CMD_QUERY_PREC, "CONF?", },
  48         ALL_ZERO,
  49 };
  50
  51 static const struct mqopt_item mqopts_agilent_5digit[] = {
  52         { SR_MQ_VOLTAGE, SR_MQFLAG_DC, "VOLT:DC", "VOLT ", NO_DFLT_PREC, },
  53         { SR_MQ_VOLTAGE, SR_MQFLAG_AC, "VOLT:AC", "VOLT:AC ", NO_DFLT_PREC, },
  54         { SR_MQ_CURRENT, SR_MQFLAG_DC, "CURR:DC", "CURR ", NO_DFLT_PREC, },
  55         { SR_MQ_CURRENT, SR_MQFLAG_AC, "CURR:AC", "CURR:AC ", NO_DFLT_PREC, },
  56         { SR_MQ_RESISTANCE, 0, "RES", "RES ", NO_DFLT_PREC, },
  57         { SR_MQ_RESISTANCE, SR_MQFLAG_FOUR_WIRE, "FRES", "FRES ", NO_DFLT_PREC, },
  58         { SR_MQ_CONTINUITY, 0, "CONT", "CONT", -1, },
  59         { SR_MQ_CAPACITANCE, 0, "CAP", "CAP ", NO_DFLT_PREC, },
  60         { SR_MQ_VOLTAGE, SR_MQFLAG_DC | SR_MQFLAG_DIODE, "DIOD", "DIOD", -4, },
  61         { SR_MQ_TEMPERATURE, 0, "TEMP", "TEMP ", NO_DFLT_PREC, },
  62         { SR_MQ_FREQUENCY, 0, "FREQ", "FREQ ", NO_DFLT_PREC, },
  63 };
  64
  65 SR_PRIV const struct scpi_dmm_model models[] = {
  66         {
  67                 "Agilent", "34405A",
  68                 1, 5, cmdset_agilent, ARRAY_AND_SIZE(mqopts_agilent_5digit),
  69                 scpi_dmm_get_meas_agilent,
  70         },
  71 };
  72
  73 static const struct scpi_dmm_model *is_compatible(const char *vendor, const char *model)
  74 {
  75         size_t i;
  76         const struct scpi_dmm_model *entry;
  77
  78         for (i = 0; i < ARRAY_SIZE(models); i++) {
  79                 entry = &models[i];
  80                 if (!entry->vendor || !entry->model)
  81                         continue;
  82                 if (strcmp(vendor, entry->vendor) != 0)
  83                         continue;
  84                 if (strcmp(model, entry->model) != 0)
  85                         continue;
  86                 return entry;
  87         }
  88
  89         return NULL;
  90 }
  91
  92 static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
  93 {
  94         struct sr_scpi_hw_info *hw_info;
  95         int ret;
  96         const char *vendor;
  97         const struct scpi_dmm_model *model;
  98         struct sr_dev_inst *sdi;
  99         struct dev_context *devc;
 100         size_t i;
 101         gchar *channel_name;
 102
 103         ret = sr_scpi_get_hw_id(scpi, &hw_info);
 104         scpi_dmm_cmd_delay(scpi);
 105         if (ret != SR_OK) {
 106                 sr_info("Could not get IDN response.");
 107                 return NULL;
 108         }
 109         vendor = sr_vendor_alias(hw_info->manufacturer);
 110         model = is_compatible(vendor, hw_info->model);
 111         if (!model) {
 112                 sr_scpi_hw_info_free(hw_info);
 113                 return NULL;
 114         }
 115
 116         sdi = g_malloc0(sizeof(*sdi));
 117         sdi->vendor = g_strdup(hw_info->manufacturer);
 118         sdi->model = g_strdup(hw_info->model);
 119         sdi->version = g_strdup(hw_info->firmware_version);
 120         sdi->serial_num = g_strdup(hw_info->serial_number);
 121         sdi->conn = scpi;
 122         sdi->driver = &scpi_dmm_driver_info;
 123         sdi->inst_type = SR_INST_SCPI;
 124         sr_scpi_hw_info_free(hw_info);
 125
 126         devc = g_malloc0(sizeof(*devc));
 127         sdi->priv = devc;
 128         devc->num_channels = model->num_channels;
 129         devc->cmdset = model->cmdset;
 130         devc->model = model;
 131
 132         for (i = 0; i < devc->num_channels; i++) {
 133                 channel_name = g_strdup_printf("P%zu", i + 1);
 134                 sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, channel_name);
 135         }
 136
 137         return sdi;
 138 }
 139
 140 static GSList *scan(struct sr_dev_driver *di, GSList *options)
 141 {
 142         return sr_scpi_scan(di->context, options, probe_device);
 143 }
 144
 145 static int dev_open(struct sr_dev_inst *sdi)
 146 {
 147         struct sr_scpi_dev_inst *scpi;
 148         int ret;
 149
 150         scpi = sdi->conn;
 151         ret = sr_scpi_open(scpi);
 152         if (ret < 0) {
 153                 sr_err("Failed to open SCPI device: %s.", sr_strerror(ret));
 154                 return SR_ERR;
 155         }
 156
 157         return SR_OK;
 158 }
 159
 160 static int dev_close(struct sr_dev_inst *sdi)
 161 {
 162         struct sr_scpi_dev_inst *scpi;
 163
 164         scpi = sdi->conn;
 165         if (!scpi)
 166                 return SR_ERR_BUG;
 167
 168         sr_dbg("DIAG: sdi->status %d.", sdi->status - SR_ST_NOT_FOUND);
 169         if (sdi->status <= SR_ST_INACTIVE)
 170                 return SR_OK;
 171
 172         return sr_scpi_close(scpi);
 173 }
 174
 175 static int config_get(uint32_t key, GVariant **data,
 176         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 177 {
 178         struct dev_context *devc;
 179         enum sr_mq mq;
 180         enum sr_mqflag mqflag;
 181         GVariant *arr[2];
 182         int ret;
 183
 184         (void)cg;
 185
 186         devc = sdi->priv;
 187
 188         switch (key) {
 189         case SR_CONF_LIMIT_SAMPLES:
 190         case SR_CONF_LIMIT_MSEC:
 191                 return sr_sw_limits_config_get(&devc->limits, key, data);
 192         case SR_CONF_MEASURED_QUANTITY:
 193                 ret = scpi_dmm_get_mq(sdi, &mq, &mqflag, NULL);
 194                 if (ret != SR_OK)
 195                         return ret;
 196                 arr[0] = g_variant_new_uint32(mq);
 197                 arr[1] = g_variant_new_uint64(mqflag);
 198                 *data = g_variant_new_tuple(arr, ARRAY_SIZE(arr));
 199                 return SR_OK;
 200         default:
 201                 return SR_ERR_NA;
 202         }
 203 }
 204
 205 static int config_set(uint32_t key, GVariant *data,
 206         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 207 {
 208         struct dev_context *devc;
 209         enum sr_mq mq;
 210         enum sr_mqflag mqflag;
 211         GVariant *tuple_child;
 212
 213         (void)cg;
 214
 215         devc = sdi->priv;
 216
 217         switch (key) {
 218         case SR_CONF_LIMIT_SAMPLES:
 219         case SR_CONF_LIMIT_MSEC:
 220                 return sr_sw_limits_config_set(&devc->limits, key, data);
 221         case SR_CONF_MEASURED_QUANTITY:
 222                 tuple_child = g_variant_get_child_value(data, 0);
 223                 mq = g_variant_get_uint32(tuple_child);
 224                 tuple_child = g_variant_get_child_value(data, 1);
 225                 mqflag = g_variant_get_uint64(tuple_child);
 226                 g_variant_unref(tuple_child);
 227                 return scpi_dmm_set_mq(sdi, mq, mqflag);
 228         default:
 229                 return SR_ERR_NA;
 230         }
 231 }
 232
 233 static int config_list(uint32_t key, GVariant **data,
 234         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 235 {
 236         struct dev_context *devc;
 237         GVariant *gvar, *arr[2];
 238         GVariantBuilder gvb;
 239         size_t i;
 240
 241         (void)cg;
 242
 243         devc = sdi ? sdi->priv : NULL;
 244
 245         switch (key) {
 246         case SR_CONF_SCAN_OPTIONS:
 247         case SR_CONF_DEVICE_OPTIONS:
 248                 return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
 249         case SR_CONF_MEASURED_QUANTITY:
 250                 /* TODO Use std_gvar_measured_quantities() when available. */
 251                 if (!devc)
 252                         return SR_ERR_ARG;
 253                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 254                 for (i = 0; i < devc->model->mqopt_size; i++) {
 255                         arr[0] = g_variant_new_uint32(devc->model->mqopts[i].mq);
 256                         arr[1] = g_variant_new_uint64(devc->model->mqopts[i].mqflag);
 257                         gvar = g_variant_new_tuple(arr, ARRAY_SIZE(arr));
 258                         g_variant_builder_add_value(&gvb, gvar);
 259                 }
 260                 *data = g_variant_builder_end(&gvb);
 261                 return SR_OK;
 262         default:
 263                 (void)devc;
 264                 return SR_ERR_NA;
 265         }
 266 }
 267
 268 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 269 {
 270         struct sr_scpi_dev_inst *scpi;
 271         struct dev_context *devc;
 272         int ret;
 273         const char *command;
 274
 275         scpi = sdi->conn;
 276         devc = sdi->priv;
 277
 278         ret = scpi_dmm_get_mq(sdi, &devc->start_acq_mq.curr_mq,
 279                 &devc->start_acq_mq.curr_mqflag, NULL);
 280         if (ret != SR_OK)
 281                 return ret;
 282
 283         command = sr_scpi_cmd_get(devc->cmdset, DMM_CMD_START_ACQ);
 284         if (command && *command) {
 285                 ret = sr_scpi_send(scpi, command);
 286                 scpi_dmm_cmd_delay(scpi);
 287                 if (ret != SR_OK)
 288                         return ret;
 289         }
 290
 291         sr_sw_limits_acquisition_start(&devc->limits);
 292         ret = std_session_send_df_header(sdi);
 293         if (ret != SR_OK)
 294                 return ret;
 295
 296         ret = sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 10,
 297                 scpi_dmm_receive_data, (void *)sdi);
 298         if (ret != SR_OK)
 299                 return ret;
 300
 301         return SR_OK;
 302 }
 303
 304 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
 305 {
 306         struct sr_scpi_dev_inst *scpi;
 307         struct dev_context *devc;
 308         const char *command;
 309
 310         scpi = sdi->conn;
 311         devc = sdi->priv;
 312
 313         command = sr_scpi_cmd_get(devc->cmdset, DMM_CMD_STOP_ACQ);
 314         if (command && *command) {
 315                 (void)sr_scpi_send(scpi, command);
 316                 scpi_dmm_cmd_delay(scpi);
 317         }
 318         sr_scpi_source_remove(sdi->session, scpi);
 319
 320         std_session_send_df_end(sdi);
 321
 322         return SR_OK;
 323 }
 324
 325 static struct sr_dev_driver scpi_dmm_driver_info = {
 326         .name = "scpi-dmm",
 327         .longname = "SCPI DMM",
 328         .api_version = 1,
 329         .init = std_init,
 330         .cleanup = std_cleanup,
 331         .scan = scan,
 332         .dev_list = std_dev_list,
 333         .dev_clear = std_dev_clear,
 334         .config_get = config_get,
 335         .config_set = config_set,
 336         .config_list = config_list,
 337         .dev_open = dev_open,
 338         .dev_close = dev_close,
 339         .dev_acquisition_start = dev_acquisition_start,
 340         .dev_acquisition_stop = dev_acquisition_stop,
 341         .context = NULL,
 342 };
 343 SR_REGISTER_DEV_DRIVER(scpi_dmm_driver_info);