src/hardware/rdtech-dps/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2018 James Churchill <pelrun@gmail.com>
   5  * Copyright (C) 2019 Frank Stettner <frank-stettner@gmx.net>
   6  * Copyright (C) 2021 Gerhard Sittig <gerhard.sittig@gmx.net>
   7  *
   8  * This program is free software: you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "config.h"
  23
  24 #include <string.h>
  25
  26 #include "protocol.h"
  27
  28 static const uint32_t scanopts[] = {
  29         SR_CONF_CONN,
  30         SR_CONF_SERIALCOMM,
  31         SR_CONF_MODBUSADDR,
  32 };
  33
  34 static const uint32_t drvopts[] = {
  35         SR_CONF_POWER_SUPPLY,
  36 };
  37
  38 static const uint32_t devopts[] = {
  39         SR_CONF_CONTINUOUS,
  40         SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
  41         SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
  42         SR_CONF_VOLTAGE | SR_CONF_GET,
  43         SR_CONF_VOLTAGE_TARGET | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  44         SR_CONF_CURRENT | SR_CONF_GET,
  45         SR_CONF_CURRENT_LIMIT | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  46         SR_CONF_ENABLED | SR_CONF_GET | SR_CONF_SET,
  47         SR_CONF_REGULATION | SR_CONF_GET,
  48         SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE | SR_CONF_GET,
  49         SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
  50         SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE | SR_CONF_GET,
  51         SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
  52 };
  53
  54 static const uint32_t devopts_w_range[] = {
  55         SR_CONF_CONTINUOUS,
  56         SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
  57         SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
  58         SR_CONF_VOLTAGE | SR_CONF_GET,
  59         SR_CONF_VOLTAGE_TARGET | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  60         SR_CONF_CURRENT | SR_CONF_GET,
  61         SR_CONF_CURRENT_LIMIT | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  62         SR_CONF_ENABLED | SR_CONF_GET | SR_CONF_SET,
  63         SR_CONF_REGULATION | SR_CONF_GET,
  64         SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE | SR_CONF_GET,
  65         SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
  66         SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE | SR_CONF_GET,
  67         SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
  68         SR_CONF_RANGE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  69 };
  70
  71 /* Range name, max current/voltage/power, current/voltage digits. */
  72 static struct rdtech_dps_range ranges_dps3005[] = {
  73         {  "5A",  5, 30,  160, 3, 2 }
  74 };
  75
  76 static struct rdtech_dps_range ranges_dps5005[] = {
  77         {  "5A",  5, 50,  250, 3, 2 }
  78 };
  79
  80 static struct rdtech_dps_range ranges_dps5015[] = {
  81         { "15A", 15, 50,  750, 2, 2 }
  82 };
  83
  84 static struct rdtech_dps_range ranges_dps5020[] = {
  85         { "20A", 20, 50, 1000, 2, 2 }
  86 };
  87
  88 static struct rdtech_dps_range ranges_dps8005[] = {
  89         {  "5A",  5, 80,  408, 3, 2 }
  90 };
  91
  92 static struct rdtech_dps_range ranges_rd6006[] = {
  93         {  "6A",  6, 60,  360, 3, 2 }
  94 };
  95
  96 static struct rdtech_dps_range ranges_rd6006p[] = {
  97         {  "6A",  6, 60,  360, 4, 3 }
  98 };
  99
 100 static struct rdtech_dps_range ranges_rd6012[] = {
 101         { "12A", 12, 60,  720, 2, 2 }
 102 };
 103
 104 /*
 105  * RD6012P supports multiple current ranges with differing resolution.
 106  * Up to 6A with 4 digits (when RTU reg 20 == 0), up to 12A with 3 digits
 107  * (when RTU reg 20 == 1).
 108  */
 109 static struct rdtech_dps_range ranges_rd6012p[] = {
 110         {  "6A",  6, 60,  360, 4, 3 },
 111         { "12A", 12, 60,  720, 3, 3 }
 112 };
 113
 114 static struct rdtech_dps_range ranges_rd6018[] = {
 115         { "18A", 18, 60, 1080, 2, 2 }
 116 };
 117
 118 static struct rdtech_dps_range ranges_rd6024[] = {
 119         { "24A", 24, 60, 1440, 2, 2 }
 120 };
 121
 122 /* Model ID, model name, model dependent ranges. */
 123 static const struct rdtech_dps_model supported_models[] = {
 124         { MODEL_DPS, 3005, "DPS3005", ARRAY_AND_SIZE(ranges_dps3005) },
 125         { MODEL_DPS, 5005, "DPS5005", ARRAY_AND_SIZE(ranges_dps5005) },
 126         { MODEL_DPS, 5205, "DPH5005", ARRAY_AND_SIZE(ranges_dps5005) },
 127         { MODEL_DPS, 5015, "DPS5015", ARRAY_AND_SIZE(ranges_dps5015) },
 128         { MODEL_DPS, 5020, "DPS5020", ARRAY_AND_SIZE(ranges_dps5020) },
 129         { MODEL_DPS, 8005, "DPS8005", ARRAY_AND_SIZE(ranges_dps8005) },
 130         /*
 131          * Specs for models RD60nn taken from the 2020.12.2 instruction manual,
 132          * specs for RD6006P from the 2021.2.26 (english) manual,
 133          * specs for RD6012P from the 2021.10.26 (english) manual,
 134          * and specs for RD6024P from the 2021.1.7 (english) manual.
 135          */
 136         { MODEL_RD, 60061, "RD6006" , ARRAY_AND_SIZE(ranges_rd6006)  },
 137         { MODEL_RD, 60062, "RD6006" , ARRAY_AND_SIZE(ranges_rd6006)  },
 138         { MODEL_RD, 60065, "RD6006P", ARRAY_AND_SIZE(ranges_rd6006p) },
 139         { MODEL_RD, 60121, "RD6012" , ARRAY_AND_SIZE(ranges_rd6012)  },
 140         { MODEL_RD, 60125, "RD6012P", ARRAY_AND_SIZE(ranges_rd6012p) },
 141         { MODEL_RD, 60181, "RD6018" , ARRAY_AND_SIZE(ranges_rd6018)  },
 142         { MODEL_RD, 60241, "RD6024" , ARRAY_AND_SIZE(ranges_rd6024)  },
 143 };
 144
 145 static struct sr_dev_driver rdtech_dps_driver_info;
 146 static struct sr_dev_driver rdtech_rd_driver_info;
 147
 148 static struct sr_dev_inst *probe_device(struct sr_modbus_dev_inst *modbus,
 149         enum rdtech_dps_model_type model_type)
 150 {
 151         static const char *type_prefix[] = {
 152                 [MODEL_DPS] = "DPS",
 153                 [MODEL_RD]  = "RD",
 154         };
 155
 156         uint16_t id, version;
 157         uint32_t serno;
 158         int ret;
 159         const struct rdtech_dps_model *model, *supported;
 160         size_t i;
 161         struct sr_dev_inst *sdi;
 162         struct dev_context *devc;
 163
 164         ret = rdtech_dps_get_model_version(modbus,
 165                 model_type, &id, &version, &serno);
 166         sr_dbg("probe: ret %d, type %s, model %u, vers %u, snr %u.",
 167                 ret, type_prefix[model_type], id, version, serno);
 168         if (ret != SR_OK)
 169                 return NULL;
 170         model = NULL;
 171         for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
 172                 supported = &supported_models[i];
 173                 if (model_type != supported->model_type)
 174                         continue;
 175                 if (id != supported->id)
 176                         continue;
 177                 model = supported;
 178                 break;
 179         }
 180         if (!model) {
 181                 sr_err("Unknown model: %s%u.", type_prefix[model_type], id);
 182                 return NULL;
 183         }
 184
 185         sdi = g_malloc0(sizeof(*sdi));
 186         sdi->status = SR_ST_INACTIVE;
 187         sdi->vendor = g_strdup("RDTech");
 188         switch (model_type) {
 189         case MODEL_DPS:
 190                 sdi->model = g_strdup(model->name);
 191                 sdi->version = g_strdup_printf("v%u", version);
 192                 sdi->driver = &rdtech_dps_driver_info;
 193                 break;
 194         case MODEL_RD:
 195                 sdi->model = g_strdup(model->name);
 196                 sdi->version = g_strdup_printf("v%u.%u",
 197                         version / 100, version % 100);
 198                 if (serno)
 199                         sdi->serial_num = g_strdup_printf("%u", serno);
 200                 sdi->driver = &rdtech_rd_driver_info;
 201                 break;
 202         default:
 203                 sr_err("Programming error, unhandled DPS/DPH/RD device type.");
 204                 g_free(sdi->vendor);
 205                 g_free(sdi);
 206                 return NULL;
 207         }
 208         sdi->conn = modbus;
 209         sdi->inst_type = SR_INST_MODBUS;
 210
 211         sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "V");
 212         sr_channel_new(sdi, 1, SR_CHANNEL_ANALOG, TRUE, "I");
 213         sr_channel_new(sdi, 2, SR_CHANNEL_ANALOG, TRUE, "P");
 214
 215         devc = g_malloc0(sizeof(*devc));
 216         sr_sw_limits_init(&devc->limits);
 217         devc->model = model;
 218         sdi->priv = devc;
 219         ret = rdtech_dps_update_range(sdi);
 220         if (ret != SR_OK)
 221                 return NULL;
 222
 223         return sdi;
 224 }
 225
 226 static struct sr_dev_inst *probe_device_dps(struct sr_modbus_dev_inst *modbus)
 227 {
 228         return probe_device(modbus, MODEL_DPS);
 229 }
 230
 231 static struct sr_dev_inst *probe_device_rd(struct sr_modbus_dev_inst *modbus)
 232 {
 233         return probe_device(modbus, MODEL_RD);
 234 }
 235
 236 static int config_compare(gconstpointer a, gconstpointer b)
 237 {
 238         const struct sr_config *ac = a, *bc = b;
 239         return ac->key != bc->key;
 240 }
 241
 242 static GSList *scan(struct sr_dev_driver *di, GSList *options,
 243         enum rdtech_dps_model_type model_type)
 244 {
 245         static const char *default_serialcomm_dps = "9600/8n1";
 246         static const char *default_serialcomm_rd = "115200/8n1";
 247
 248         struct sr_config default_serialcomm = {
 249                 .key = SR_CONF_SERIALCOMM,
 250                 .data = NULL,
 251         };
 252         struct sr_config default_modbusaddr = {
 253                 .key = SR_CONF_MODBUSADDR,
 254                 .data = g_variant_new_uint64(1),
 255         };
 256         GSList *opts, *devices;
 257         const char *serialcomm;
 258         struct sr_dev_inst *(*probe_func)(struct sr_modbus_dev_inst *modbus);
 259
 260         /* TODO See why di->context isn't available yet at this time. */
 261         serialcomm = NULL;
 262         probe_func = NULL;
 263         if (di->context == &rdtech_dps_driver_info || model_type == MODEL_DPS) {
 264                 serialcomm = default_serialcomm_dps;
 265                 probe_func = probe_device_dps;
 266         }
 267         if (di->context == &rdtech_rd_driver_info || model_type == MODEL_RD) {
 268                 serialcomm = default_serialcomm_rd;
 269                 probe_func = probe_device_rd;
 270         }
 271         if (!probe_func)
 272                 return NULL;
 273         if (serialcomm && *serialcomm)
 274                 default_serialcomm.data = g_variant_new_string(serialcomm);
 275
 276         opts = options;
 277         if (!g_slist_find_custom(options, &default_serialcomm, config_compare))
 278                 opts = g_slist_prepend(opts, &default_serialcomm);
 279         if (!g_slist_find_custom(options, &default_modbusaddr, config_compare))
 280                 opts = g_slist_prepend(opts, &default_modbusaddr);
 281
 282         devices = sr_modbus_scan(di->context, opts, probe_func);
 283
 284         while (opts != options)
 285                 opts = g_slist_delete_link(opts, opts);
 286         g_variant_unref(default_serialcomm.data);
 287         g_variant_unref(default_modbusaddr.data);
 288
 289         return devices;
 290 }
 291
 292 static GSList *scan_dps(struct sr_dev_driver *di, GSList *options)
 293 {
 294         return scan(di, options, MODEL_DPS);
 295 }
 296
 297 static GSList *scan_rd(struct sr_dev_driver *di, GSList *options)
 298 {
 299         return scan(di, options, MODEL_RD);
 300 }
 301
 302 static int dev_open(struct sr_dev_inst *sdi)
 303 {
 304         struct sr_modbus_dev_inst *modbus;
 305         struct rdtech_dps_state state;
 306         int ret;
 307
 308         modbus = sdi->conn;
 309         if (sr_modbus_open(modbus) < 0)
 310                 return SR_ERR;
 311
 312         memset(&state, 0, sizeof(state));
 313         state.lock = TRUE;
 314         state.mask |= STATE_LOCK;
 315         ret = rdtech_dps_set_state(sdi, &state);
 316         if (ret != SR_OK)
 317                 return ret;
 318
 319         return SR_OK;
 320 }
 321
 322 static int dev_close(struct sr_dev_inst *sdi)
 323 {
 324         struct sr_modbus_dev_inst *modbus;
 325         struct rdtech_dps_state state;
 326
 327         modbus = sdi->conn;
 328         if (!modbus)
 329                 return SR_ERR_BUG;
 330
 331         memset(&state, 0, sizeof(state));
 332         state.lock = FALSE;
 333         state.mask |= STATE_LOCK;
 334         (void)rdtech_dps_set_state(sdi, &state);
 335
 336         return sr_modbus_close(modbus);
 337 }
 338
 339 static int config_get(uint32_t key, GVariant **data,
 340         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 341 {
 342         struct dev_context *devc;
 343         struct rdtech_dps_state state;
 344         int ret;
 345         const char *cc_text;
 346
 347         (void)cg;
 348
 349         devc = sdi->priv;
 350
 351         ret = SR_OK;
 352         switch (key) {
 353         case SR_CONF_LIMIT_SAMPLES:
 354         case SR_CONF_LIMIT_MSEC:
 355                 ret = sr_sw_limits_config_get(&devc->limits, key, data);
 356                 break;
 357         case SR_CONF_ENABLED:
 358                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 359                 if (ret != SR_OK)
 360                         return ret;
 361                 if (!(state.mask & STATE_OUTPUT_ENABLED))
 362                         return SR_ERR_DATA;
 363                 *data = g_variant_new_boolean(state.output_enabled);
 364                 break;
 365         case SR_CONF_REGULATION:
 366                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 367                 if (ret != SR_OK)
 368                         return ret;
 369                 if (!(state.mask & STATE_REGULATION_CC))
 370                         return SR_ERR_DATA;
 371                 cc_text = state.regulation_cc ? "CC" : "CV";
 372                 *data = g_variant_new_string(cc_text);
 373                 break;
 374         case SR_CONF_VOLTAGE:
 375                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 376                 if (ret != SR_OK)
 377                         return ret;
 378                 if (!(state.mask & STATE_VOLTAGE))
 379                         return SR_ERR_DATA;
 380                 *data = g_variant_new_double(state.voltage);
 381                 break;
 382         case SR_CONF_VOLTAGE_TARGET:
 383                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 384                 if (ret != SR_OK)
 385                         return ret;
 386                 if (!(state.mask & STATE_VOLTAGE_TARGET))
 387                         return SR_ERR_DATA;
 388                 *data = g_variant_new_double(state.voltage_target);
 389                 break;
 390         case SR_CONF_CURRENT:
 391                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 392                 if (ret != SR_OK)
 393                         return ret;
 394                 if (!(state.mask & STATE_CURRENT))
 395                         return SR_ERR_DATA;
 396                 *data = g_variant_new_double(state.current);
 397                 break;
 398         case SR_CONF_CURRENT_LIMIT:
 399                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 400                 if (ret != SR_OK)
 401                         return ret;
 402                 if (!(state.mask & STATE_CURRENT_LIMIT))
 403                         return SR_ERR_DATA;
 404                 *data = g_variant_new_double(state.current_limit);
 405                 break;
 406         case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
 407                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 408                 if (ret != SR_OK)
 409                         return ret;
 410                 if (!(state.mask & STATE_PROTECT_ENABLED))
 411                         return SR_ERR_DATA;
 412                 *data = g_variant_new_boolean(state.protect_enabled);
 413                 break;
 414         case SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE:
 415                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 416                 if (ret != SR_OK)
 417                         return ret;
 418                 if (!(state.mask & STATE_PROTECT_OVP))
 419                         return SR_ERR_DATA;
 420                 *data = g_variant_new_boolean(state.protect_ovp);
 421                 break;
 422         case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
 423                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 424                 if (ret != SR_OK)
 425                         return ret;
 426                 if (!(state.mask & STATE_OUTPUT_ENABLED))
 427                         return SR_ERR_DATA;
 428                 *data = g_variant_new_double(state.ovp_threshold);
 429                 break;
 430         case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
 431                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 432                 if (ret != SR_OK)
 433                         return ret;
 434                 if (!(state.mask & STATE_PROTECT_ENABLED))
 435                         return SR_ERR_DATA;
 436                 *data = g_variant_new_boolean(state.protect_enabled);
 437                 break;
 438         case SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE:
 439                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 440                 if (ret != SR_OK)
 441                         return ret;
 442                 if (!(state.mask & STATE_PROTECT_OCP))
 443                         return SR_ERR_DATA;
 444                 *data = g_variant_new_boolean(state.protect_ocp);
 445                 break;
 446         case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
 447                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 448                 if (ret != SR_OK)
 449                         return ret;
 450                 if (!(state.mask & STATE_OCP_THRESHOLD))
 451                         return SR_ERR_DATA;
 452                 *data = g_variant_new_double(state.ocp_threshold);
 453                 break;
 454         case SR_CONF_RANGE:
 455                 ret = rdtech_dps_get_state(sdi, &state, ST_CTX_CONFIG);
 456                 if (ret != SR_OK)
 457                         return ret;
 458                 if (!(state.mask & STATE_RANGE))
 459                         return SR_ERR_DATA;
 460                 *data = g_variant_new_string(
 461                         devc->model->ranges[state.range].range_str);
 462                 break;
 463         default:
 464                 return SR_ERR_NA;
 465         }
 466
 467         return ret;
 468 }
 469
 470 static int config_set(uint32_t key, GVariant *data,
 471         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 472 {
 473         struct dev_context *devc;
 474         struct rdtech_dps_state state;
 475         const char *range_str;
 476         size_t i;
 477
 478         (void)cg;
 479
 480         devc = sdi->priv;
 481         memset(&state, 0, sizeof(state));
 482
 483         switch (key) {
 484         case SR_CONF_LIMIT_SAMPLES:
 485         case SR_CONF_LIMIT_MSEC:
 486                 return sr_sw_limits_config_set(&devc->limits, key, data);
 487         case SR_CONF_ENABLED:
 488                 state.output_enabled = g_variant_get_boolean(data);
 489                 state.mask |= STATE_OUTPUT_ENABLED;
 490                 return rdtech_dps_set_state(sdi, &state);
 491         case SR_CONF_VOLTAGE_TARGET:
 492                 state.voltage_target = g_variant_get_double(data);
 493                 state.mask |= STATE_VOLTAGE_TARGET;
 494                 return rdtech_dps_set_state(sdi, &state);
 495         case SR_CONF_CURRENT_LIMIT:
 496                 state.current_limit = g_variant_get_double(data);
 497                 state.mask |= STATE_CURRENT_LIMIT;
 498                 return rdtech_dps_set_state(sdi, &state);
 499         case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
 500                 state.ovp_threshold = g_variant_get_double(data);
 501                 state.mask |= STATE_OVP_THRESHOLD;
 502                 return rdtech_dps_set_state(sdi, &state);
 503         case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
 504                 state.ocp_threshold = g_variant_get_double(data);
 505                 state.mask |= STATE_OCP_THRESHOLD;
 506                 return rdtech_dps_set_state(sdi, &state);
 507         case SR_CONF_RANGE:
 508                 range_str = g_variant_get_string(data, NULL);
 509                 for (i = 0; i < devc->model->n_ranges; ++i) {
 510                         if (g_strcmp0(devc->model->ranges[i].range_str, range_str)
 511                                         == 0) {
 512                                 state.range = i;
 513                                 state.mask |= STATE_RANGE;
 514                                 return rdtech_dps_set_state(sdi, &state);
 515                         }
 516                 }
 517                 return SR_ERR_NA;
 518         default:
 519                 return SR_ERR_NA;
 520         }
 521
 522         return SR_OK;
 523 }
 524
 525 static int config_list(uint32_t key, GVariant **data,
 526         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 527 {
 528         struct dev_context *devc;
 529         struct rdtech_dps_range *range;
 530         GVariantBuilder gvb;
 531         size_t i;
 532
 533         devc = (sdi) ? sdi->priv : NULL;
 534
 535         switch (key) {
 536         case SR_CONF_SCAN_OPTIONS:
 537         case SR_CONF_DEVICE_OPTIONS:
 538                 if (devc && (devc->model->n_ranges > 1))
 539                         return STD_CONFIG_LIST(key, data, sdi, cg, scanopts,
 540                                 drvopts, devopts_w_range);
 541                 else
 542                         return STD_CONFIG_LIST(key, data, sdi, cg, scanopts,
 543                                 drvopts, devopts);
 544         case SR_CONF_VOLTAGE_TARGET:
 545                 rdtech_dps_update_range(sdi);
 546                 range = &devc->model->ranges[devc->curr_range];
 547                 *data = std_gvar_min_max_step(0.0, range->max_voltage,
 548                         1 / devc->voltage_multiplier);
 549                 break;
 550         case SR_CONF_CURRENT_LIMIT:
 551                 rdtech_dps_update_range(sdi);
 552                 range = &devc->model->ranges[devc->curr_range];
 553                 *data = std_gvar_min_max_step(0.0, range->max_current,
 554                         1 / devc->current_multiplier);
 555                 break;
 556         case SR_CONF_RANGE:
 557                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 558                 for (i = 0; i < devc->model->n_ranges; ++i)
 559                         g_variant_builder_add(&gvb, "s",
 560                                 devc->model->ranges[i].range_str);
 561                 *data = g_variant_builder_end(&gvb);
 562                 break;
 563         default:
 564                 return SR_ERR_NA;
 565         }
 566
 567         return SR_OK;
 568 }
 569
 570 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 571 {
 572         struct dev_context *devc;
 573         struct sr_modbus_dev_inst *modbus;
 574         int ret;
 575
 576         modbus = sdi->conn;
 577         devc = sdi->priv;
 578
 579         /* Seed internal state from current data. */
 580         ret = rdtech_dps_seed_receive(sdi);
 581         if (ret != SR_OK)
 582                 return ret;
 583
 584         /* Register the periodic data reception callback. */
 585         ret = sr_modbus_source_add(sdi->session, modbus, G_IO_IN, 10,
 586                         rdtech_dps_receive_data, (void *)sdi);
 587         if (ret != SR_OK)
 588                 return ret;
 589
 590         sr_sw_limits_acquisition_start(&devc->limits);
 591         std_session_send_df_header(sdi);
 592
 593         return SR_OK;
 594 }
 595
 596 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
 597 {
 598         struct sr_modbus_dev_inst *modbus;
 599
 600         std_session_send_df_end(sdi);
 601
 602         modbus = sdi->conn;
 603         sr_modbus_source_remove(sdi->session, modbus);
 604
 605         return SR_OK;
 606 }
 607
 608 static struct sr_dev_driver rdtech_dps_driver_info = {
 609         .name = "rdtech-dps",
 610         .longname = "RDTech DPS/DPH series power supply",
 611         .api_version = 1,
 612         .init = std_init,
 613         .cleanup = std_cleanup,
 614         .scan = scan_dps,
 615         .dev_list = std_dev_list,
 616         .dev_clear = std_dev_clear,
 617         .config_get = config_get,
 618         .config_set = config_set,
 619         .config_list = config_list,
 620         .dev_open = dev_open,
 621         .dev_close = dev_close,
 622         .dev_acquisition_start = dev_acquisition_start,
 623         .dev_acquisition_stop = dev_acquisition_stop,
 624         .context = NULL,
 625 };
 626 SR_REGISTER_DEV_DRIVER(rdtech_dps_driver_info);
 627
 628 static struct sr_dev_driver rdtech_rd_driver_info = {
 629         .name = "rdtech-rd",
 630         .longname = "RDTech RD series power supply",
 631         .api_version = 1,
 632         .init = std_init,
 633         .cleanup = std_cleanup,
 634         .scan = scan_rd,
 635         .dev_list = std_dev_list,
 636         .dev_clear = std_dev_clear,
 637         .config_get = config_get,
 638         .config_set = config_set,
 639         .config_list = config_list,
 640         .dev_open = dev_open,
 641         .dev_close = dev_close,
 642         .dev_acquisition_start = dev_acquisition_start,
 643         .dev_acquisition_stop = dev_acquisition_stop,
 644         .context = NULL,
 645 };
 646 SR_REGISTER_DEV_DRIVER(rdtech_rd_driver_info);