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