[libsigrok.git] / src / hardware / rdtech-dps / api.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2018 James Churchill <pelrun@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include "protocol.h"

static const uint32_t scanopts[] = {
	SR_CONF_CONN,
	SR_CONF_SERIALCOMM,
	SR_CONF_MODBUSADDR,
};

static const uint32_t drvopts[] = {
	SR_CONF_POWER_SUPPLY,
};

static const uint32_t devopts[] = {
	SR_CONF_CONTINUOUS,
	SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
	SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
	SR_CONF_VOLTAGE | SR_CONF_GET,
	SR_CONF_VOLTAGE_TARGET | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
	SR_CONF_CURRENT | SR_CONF_GET,
	SR_CONF_CURRENT_LIMIT | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
	SR_CONF_ENABLED | SR_CONF_GET | SR_CONF_SET,
	SR_CONF_REGULATION | SR_CONF_GET,
	SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE | SR_CONF_GET,
	SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
	SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE | SR_CONF_GET,
	SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
};

/* Model ID, model name, max current, max voltage, max power */
static const struct rdtech_dps_model supported_models[] = {
	{ 3005, "DPS3005",  3, 50,  160 },
	{ 5005, "DPS5005",  5, 50,  250 },
	{ 5205, "DPH5005",  5, 50,  250 },
	{ 5015, "DPS5015", 15, 50,  750 },
	{ 5020, "DPS5020", 20, 50, 1000 },
	{ 8005, "DPS8005",  5, 80,  408 },
};

static struct sr_dev_driver rdtech_dps_driver_info;

static struct sr_dev_inst *probe_device(struct sr_modbus_dev_inst *modbus)
{
	const struct rdtech_dps_model *model = NULL;
	struct dev_context *devc;
	struct sr_dev_inst *sdi;
	uint16_t id, version;
	unsigned int i;

	int ret = rdtech_dps_get_model_version(modbus, &id, &version);
	if (ret != SR_OK)
		return NULL;
	for (i = 0; i < ARRAY_SIZE(supported_models); i++)
		if (id == supported_models[i].id) {
			model = &supported_models[i];
			break;
		}
	if (model == NULL) {
		sr_err("Unknown model: %d.", id);
		return NULL;
	}

	sdi = g_malloc0(sizeof(struct sr_dev_inst));
	sdi->status = SR_ST_INACTIVE;
	sdi->vendor = g_strdup("RDTech");
	sdi->model = g_strdup(model->name);
	sdi->version = g_strdup_printf("v%d", version);
	sdi->conn = modbus;
	sdi->driver = &rdtech_dps_driver_info;
	sdi->inst_type = SR_INST_MODBUS;

	sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "V");
	sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "I");
	sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "P");

	devc = g_malloc0(sizeof(struct dev_context));
	sr_sw_limits_init(&devc->limits);
	devc->model = model;
	devc->expecting_registers = 0;

	sdi->priv = devc;

	return sdi;
}

static int config_compare(gconstpointer a, gconstpointer b)
{
	const struct sr_config *ac = a, *bc = b;
	return ac->key != bc->key;
}

static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
	struct sr_config default_serialcomm = {
		.key = SR_CONF_SERIALCOMM,
		.data = g_variant_new_string("9600/8n1"),
	};
	struct sr_config default_modbusaddr = {
		.key = SR_CONF_MODBUSADDR,
		.data = g_variant_new_uint64(1),
	};
	GSList *opts = options, *devices;

	if (!g_slist_find_custom(options, &default_serialcomm, config_compare))
		opts = g_slist_prepend(opts, &default_serialcomm);
	if (!g_slist_find_custom(options, &default_modbusaddr, config_compare))
		opts = g_slist_prepend(opts, &default_modbusaddr);

	devices = sr_modbus_scan(di->context, opts, probe_device);

	while (opts != options)
		opts = g_slist_delete_link(opts, opts);
	g_variant_unref(default_serialcomm.data);
	g_variant_unref(default_modbusaddr.data);

	return devices;
}

static int dev_open(struct sr_dev_inst *sdi)
{
	struct sr_modbus_dev_inst *modbus = sdi->conn;

	if (sr_modbus_open(modbus) < 0)
		return SR_ERR;

	rdtech_dps_set_reg(modbus, REG_LOCK, 1);

	return SR_OK;
}

static int dev_close(struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
	struct sr_modbus_dev_inst *modbus;

	modbus = sdi->conn;

	if (!modbus)
		return SR_ERR_BUG;

	devc = sdi->priv;

	if (devc->expecting_registers) {
		/* Wait for the last data that was requested from the device. */
		uint16_t registers[devc->expecting_registers];
		sr_modbus_read_holding_registers(modbus, -1,
			devc->expecting_registers, registers);
	}

	rdtech_dps_set_reg(modbus, REG_LOCK, 0);

	return sr_modbus_close(modbus);
}

static int config_get(uint32_t key, GVariant **data,
	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
	struct dev_context *devc;
	struct sr_modbus_dev_inst *modbus;
	int ret;
	uint16_t ivalue;

	(void)cg;

	modbus = sdi->conn;
	devc = sdi->priv;

	ret = SR_OK;
	switch (key) {
	case SR_CONF_LIMIT_SAMPLES:
	case SR_CONF_LIMIT_MSEC:
		ret = sr_sw_limits_config_get(&devc->limits, key, data);
		break;
	case SR_CONF_ENABLED:
		if ((ret = rdtech_dps_get_reg(modbus, REG_ENABLE, &ivalue)) == SR_OK)
			*data = g_variant_new_boolean(ivalue);
		break;
	case SR_CONF_REGULATION:
		if ((ret = rdtech_dps_get_reg(modbus, REG_CV_CC, &ivalue)) != SR_OK)
			break;
		if (ivalue == MODE_CC)
			*data = g_variant_new_string("CC");
		else
			*data = g_variant_new_string("CV");
		break;
	case SR_CONF_VOLTAGE:
		if ((ret = rdtech_dps_get_reg(modbus, REG_UOUT, &ivalue)) == SR_OK)
			*data = g_variant_new_double((float)ivalue / 100.0f);
		break;
	case SR_CONF_VOLTAGE_TARGET:
		if ((ret = rdtech_dps_get_reg(modbus, REG_USET, &ivalue)) == SR_OK)
			*data = g_variant_new_double((float)ivalue / 100.0f);
		break;
	case SR_CONF_CURRENT:
		if ((ret = rdtech_dps_get_reg(modbus, REG_IOUT, &ivalue)) == SR_OK)
			*data = g_variant_new_double((float)ivalue / 100.0f);
		break;
	case SR_CONF_CURRENT_LIMIT:
		if ((ret = rdtech_dps_get_reg(modbus, REG_ISET, &ivalue)) == SR_OK)
			*data = g_variant_new_double((float)ivalue / 1000.0f);
		break;
	case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
		*data = g_variant_new_boolean(TRUE);
		break;
	case SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE:
		if ((ret = rdtech_dps_get_reg(modbus, REG_PROTECT, &ivalue)) == SR_OK)
			*data = g_variant_new_boolean(ivalue == STATE_OVP);
		break;
	case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
		if ((ret = rdtech_dps_get_reg(modbus, PRE_OVPSET, &ivalue)) == SR_OK)
			*data = g_variant_new_double((float)ivalue / 100.0f);
		break;
	case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
		*data = g_variant_new_boolean(TRUE);
		break;
	case SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE:
		if ((ret = rdtech_dps_get_reg(modbus, REG_PROTECT, &ivalue)) == SR_OK)
			*data = g_variant_new_boolean(ivalue == STATE_OCP);
		break;
	case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
		if ((ret = rdtech_dps_get_reg(modbus, PRE_OCPSET, &ivalue)) == SR_OK)
			*data = g_variant_new_double((float)ivalue / 1000.0f);
		break;
	default:
		return SR_ERR_NA;
	}

	return ret;
}

static int config_set(uint32_t key, GVariant *data,
	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
	struct dev_context *devc;
	struct sr_modbus_dev_inst *modbus;

	(void)cg;

	modbus = sdi->conn;
	devc = sdi->priv;

	switch (key) {
	case SR_CONF_LIMIT_SAMPLES:
	case SR_CONF_LIMIT_MSEC:
		return sr_sw_limits_config_set(&devc->limits, key, data);
	case SR_CONF_ENABLED:
		return rdtech_dps_set_reg(modbus, REG_ENABLE, g_variant_get_boolean(data));
	case SR_CONF_VOLTAGE_TARGET:
		return rdtech_dps_set_reg(modbus, REG_USET, g_variant_get_double(data) * 100);
	case SR_CONF_CURRENT_LIMIT:
		return rdtech_dps_set_reg(modbus, REG_ISET, g_variant_get_double(data) * 1000);
	case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
		return rdtech_dps_set_reg(modbus, PRE_OVPSET, g_variant_get_double(data) * 100);
	case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
		return rdtech_dps_set_reg(modbus, PRE_OCPSET, g_variant_get_double(data) * 1000);
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int config_list(uint32_t key, GVariant **data,
	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
	struct dev_context *devc;

	devc = (sdi) ? sdi->priv : NULL;

	switch (key) {
	case SR_CONF_SCAN_OPTIONS:
	case SR_CONF_DEVICE_OPTIONS:
		return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
	case SR_CONF_VOLTAGE_TARGET:
		*data = std_gvar_min_max_step(0.0, devc->model->max_voltage, 0.001);
		break;
	case SR_CONF_CURRENT_LIMIT:
		*data = std_gvar_min_max_step(0.0, devc->model->max_current, 0.0001);
		break;
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
	struct sr_modbus_dev_inst *modbus;
	int ret;

	modbus = sdi->conn;
	devc = sdi->priv;

	if ((ret = sr_modbus_source_add(sdi->session, modbus, G_IO_IN, 10,
			rdtech_dps_receive_data, (void *)sdi)) != SR_OK)
		return ret;

	sr_sw_limits_acquisition_start(&devc->limits);
	std_session_send_df_header(sdi);

	return rdtech_dps_capture_start(sdi);
}

static int dev_acquisition_stop(struct sr_dev_inst *sdi)
{
	struct sr_modbus_dev_inst *modbus;

	std_session_send_df_end(sdi);

	modbus = sdi->conn;
	sr_modbus_source_remove(sdi->session, modbus);

	return SR_OK;
}

static struct sr_dev_driver rdtech_dps_driver_info = {
	.name = "rdtech-dps",
	.longname = "RDTech DPS/DPH series power supply",
	.api_version = 1,
	.init = std_init,
	.cleanup = std_cleanup,
	.scan = scan,
	.dev_list = std_dev_list,
	.dev_clear = std_dev_clear,
	.config_get = config_get,
	.config_set = config_set,
	.config_list = config_list,
	.dev_open = dev_open,
	.dev_close = dev_close,
	.dev_acquisition_start = dev_acquisition_start,
	.dev_acquisition_stop = dev_acquisition_stop,
	.context = NULL,
};
SR_REGISTER_DEV_DRIVER(rdtech_dps_driver_info);
Commit	Line	Data
0549416e JC	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2018 James Churchill <pelrun@gmail.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 <config.h>
	21	#include "protocol.h"
	22
69b05583 JC	23	static const uint32_t scanopts[] = {
	24	SR_CONF_CONN,
	25	SR_CONF_SERIALCOMM,
	26	SR_CONF_MODBUSADDR,
	27	};
	28
	29	static const uint32_t drvopts[] = {
	30	SR_CONF_POWER_SUPPLY,
	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_VOLTAGE \| SR_CONF_GET,
	38	SR_CONF_VOLTAGE_TARGET \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	39	SR_CONF_CURRENT \| SR_CONF_GET,
	40	SR_CONF_CURRENT_LIMIT \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	41	SR_CONF_ENABLED \| SR_CONF_GET \| SR_CONF_SET,
	42	SR_CONF_REGULATION \| SR_CONF_GET,
	43	SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE \| SR_CONF_GET,
	44	SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD \| SR_CONF_GET \| SR_CONF_SET,
	45	SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE \| SR_CONF_GET,
	46	SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD \| SR_CONF_GET \| SR_CONF_SET,
	47	};
	48
	49	/* Model ID, model name, max current, max voltage, max power */
	50	static const struct rdtech_dps_model supported_models[] = {
	51	{ 3005, "DPS3005", 3, 50, 160 },
	52	{ 5005, "DPS5005", 5, 50, 250 },
	53	{ 5205, "DPH5005", 5, 50, 250 },
	54	{ 5015, "DPS5015", 15, 50, 750 },
	55	{ 5020, "DPS5020", 20, 50, 1000 },
	56	{ 8005, "DPS8005", 5, 80, 408 },
	57	};
	58
	59	static struct sr_dev_driver rdtech_dps_driver_info;
	60
	61	static struct sr_dev_inst probe_device(struct sr_modbus_dev_inst modbus)
0549416e	62	{
69b05583 JC	63	const struct rdtech_dps_model *model = NULL;
	64	struct dev_context *devc;
	65	struct sr_dev_inst *sdi;
	66	uint16_t id, version;
	67	unsigned int i;
	68
	69	int ret = rdtech_dps_get_model_version(modbus, &id, &version);
	70	if (ret != SR_OK)
	71	return NULL;
	72	for (i = 0; i < ARRAY_SIZE(supported_models); i++)
	73	if (id == supported_models[i].id) {
	74	model = &supported_models[i];
	75	break;
	76	}
	77	if (model == NULL) {
	78	sr_err("Unknown model: %d.", id);
	79	return NULL;
	80	}
	81
	82	sdi = g_malloc0(sizeof(struct sr_dev_inst));
	83	sdi->status = SR_ST_INACTIVE;
	84	sdi->vendor = g_strdup("RDTech");
	85	sdi->model = g_strdup(model->name);
	86	sdi->version = g_strdup_printf("v%d", version);
	87	sdi->conn = modbus;
	88	sdi->driver = &rdtech_dps_driver_info;
	89	sdi->inst_type = SR_INST_MODBUS;
0549416e	90
69b05583 JC	91	sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "V");
	92	sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "I");
	93	sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "P");
0549416e	94
69b05583 JC	95	devc = g_malloc0(sizeof(struct dev_context));
	96	sr_sw_limits_init(&devc->limits);
	97	devc->model = model;
	98	devc->expecting_registers = 0;
0549416e	99
69b05583 JC	100	sdi->priv = devc;
	101
	102	return sdi;
	103	}
	104
	105	static int config_compare(gconstpointer a, gconstpointer b)
	106	{
	107	const struct sr_config ac = a, bc = b;
	108	return ac->key != bc->key;
	109	}
	110
	111	static GSList scan(struct sr_dev_driver di, GSList *options)
	112	{
	113	struct sr_config default_serialcomm = {
	114	.key = SR_CONF_SERIALCOMM,
	115	.data = g_variant_new_string("9600/8n1"),
	116	};
	117	struct sr_config default_modbusaddr = {
	118	.key = SR_CONF_MODBUSADDR,
	119	.data = g_variant_new_uint64(1),
	120	};
	121	GSList opts = options, devices;
	122
	123	if (!g_slist_find_custom(options, &default_serialcomm, config_compare))
	124	opts = g_slist_prepend(opts, &default_serialcomm);
	125	if (!g_slist_find_custom(options, &default_modbusaddr, config_compare))
	126	opts = g_slist_prepend(opts, &default_modbusaddr);
	127
	128	devices = sr_modbus_scan(di->context, opts, probe_device);
	129
	130	while (opts != options)
	131	opts = g_slist_delete_link(opts, opts);
	132	g_variant_unref(default_serialcomm.data);
	133	g_variant_unref(default_modbusaddr.data);
0549416e JC	134
	135	return devices;
	136	}
	137
	138	static int dev_open(struct sr_dev_inst *sdi)
	139	{
69b05583 JC	140	struct sr_modbus_dev_inst *modbus = sdi->conn;
	141
	142	if (sr_modbus_open(modbus) < 0)
	143	return SR_ERR;
0549416e	144
69b05583	145	rdtech_dps_set_reg(modbus, REG_LOCK, 1);
0549416e JC	146
	147	return SR_OK;
	148	}
	149
	150	static int dev_close(struct sr_dev_inst *sdi)
	151	{
69b05583 JC	152	struct dev_context *devc;
69b05583 JC	153	struct sr_modbus_dev_inst *modbus;
0549416e	154
69b05583	155	modbus = sdi->conn;
0549416e	156
69b05583 JC	157	if (!modbus)
	158	return SR_ERR_BUG;
	159
	160	devc = sdi->priv;
	161
	162	if (devc->expecting_registers) {
	163	/* Wait for the last data that was requested from the device. */
	164	uint16_t registers[devc->expecting_registers];
	165	sr_modbus_read_holding_registers(modbus, -1,
	166	devc->expecting_registers, registers);
	167	}
	168
	169	rdtech_dps_set_reg(modbus, REG_LOCK, 0);
	170
	171	return sr_modbus_close(modbus);
0549416e JC	172	}
	173
	174	static int config_get(uint32_t key, GVariant **data,
	175	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	176	{
69b05583 JC	177	struct dev_context *devc;
69b05583 JC	178	struct sr_modbus_dev_inst *modbus;
0549416e	179	int ret;
69b05583	180	uint16_t ivalue;
0549416e	181
0549416e JC	182	(void)cg;
0549416e JC	183
69b05583 JC	184	modbus = sdi->conn;
	185	devc = sdi->priv;
	186
0549416e JC	187	ret = SR_OK;
0549416e JC	188	switch (key) {
69b05583 JC	189	case SR_CONF_LIMIT_SAMPLES:
	190	case SR_CONF_LIMIT_MSEC:
	191	ret = sr_sw_limits_config_get(&devc->limits, key, data);
	192	break;
	193	case SR_CONF_ENABLED:
	194	if ((ret = rdtech_dps_get_reg(modbus, REG_ENABLE, &ivalue)) == SR_OK)
	195	*data = g_variant_new_boolean(ivalue);
	196	break;
	197	case SR_CONF_REGULATION:
	198	if ((ret = rdtech_dps_get_reg(modbus, REG_CV_CC, &ivalue)) != SR_OK)
	199	break;
	200	if (ivalue == MODE_CC)
	201	*data = g_variant_new_string("CC");
	202	else
	203	*data = g_variant_new_string("CV");
	204	break;
	205	case SR_CONF_VOLTAGE:
	206	if ((ret = rdtech_dps_get_reg(modbus, REG_UOUT, &ivalue)) == SR_OK)
	207	*data = g_variant_new_double((float)ivalue / 100.0f);
	208	break;
	209	case SR_CONF_VOLTAGE_TARGET:
	210	if ((ret = rdtech_dps_get_reg(modbus, REG_USET, &ivalue)) == SR_OK)
	211	*data = g_variant_new_double((float)ivalue / 100.0f);
	212	break;
	213	case SR_CONF_CURRENT:
	214	if ((ret = rdtech_dps_get_reg(modbus, REG_IOUT, &ivalue)) == SR_OK)
	215	*data = g_variant_new_double((float)ivalue / 100.0f);
	216	break;
	217	case SR_CONF_CURRENT_LIMIT:
	218	if ((ret = rdtech_dps_get_reg(modbus, REG_ISET, &ivalue)) == SR_OK)
	219	*data = g_variant_new_double((float)ivalue / 1000.0f);
	220	break;
	221	case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
	222	*data = g_variant_new_boolean(TRUE);
	223	break;
	224	case SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE:
	225	if ((ret = rdtech_dps_get_reg(modbus, REG_PROTECT, &ivalue)) == SR_OK)
	226	*data = g_variant_new_boolean(ivalue == STATE_OVP);
	227	break;
	228	case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
	229	if ((ret = rdtech_dps_get_reg(modbus, PRE_OVPSET, &ivalue)) == SR_OK)
	230	*data = g_variant_new_double((float)ivalue / 100.0f);
	231	break;
	232	case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
	233	*data = g_variant_new_boolean(TRUE);
	234	break;
	235	case SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE:
	236	if ((ret = rdtech_dps_get_reg(modbus, REG_PROTECT, &ivalue)) == SR_OK)
	237	*data = g_variant_new_boolean(ivalue == STATE_OCP);
	238	break;
	239	case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
	240	if ((ret = rdtech_dps_get_reg(modbus, PRE_OCPSET, &ivalue)) == SR_OK)
	241	*data = g_variant_new_double((float)ivalue / 1000.0f);
	242	break;
0549416e JC	243	default:
	244	return SR_ERR_NA;
	245	}
	246
	247	return ret;
	248	}
	249
	250	static int config_set(uint32_t key, GVariant *data,
	251	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	252	{
69b05583 JC	253	struct dev_context *devc;
69b05583 JC	254	struct sr_modbus_dev_inst *modbus;
0549416e	255
0549416e JC	256	(void)cg;
0549416e JC	257
69b05583 JC	258	modbus = sdi->conn;
	259	devc = sdi->priv;
	260
0549416e	261	switch (key) {
69b05583 JC	262	case SR_CONF_LIMIT_SAMPLES:
	263	case SR_CONF_LIMIT_MSEC:
	264	return sr_sw_limits_config_set(&devc->limits, key, data);
	265	case SR_CONF_ENABLED:
	266	return rdtech_dps_set_reg(modbus, REG_ENABLE, g_variant_get_boolean(data));
	267	case SR_CONF_VOLTAGE_TARGET:
	268	return rdtech_dps_set_reg(modbus, REG_USET, g_variant_get_double(data) * 100);
	269	case SR_CONF_CURRENT_LIMIT:
	270	return rdtech_dps_set_reg(modbus, REG_ISET, g_variant_get_double(data) * 1000);
	271	case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
	272	return rdtech_dps_set_reg(modbus, PRE_OVPSET, g_variant_get_double(data) * 100);
	273	case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
	274	return rdtech_dps_set_reg(modbus, PRE_OCPSET, g_variant_get_double(data) * 1000);
0549416e	275	default:
69b05583	276	return SR_ERR_NA;
0549416e JC	277	}
0549416e JC	278
69b05583	279	return SR_OK;
0549416e JC	280	}
	281
	282	static int config_list(uint32_t key, GVariant **data,
	283	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	284	{
69b05583	285	struct dev_context *devc;
0549416e	286
69b05583	287	devc = (sdi) ? sdi->priv : NULL;
0549416e	288
0549416e	289	switch (key) {
69b05583 JC	290	case SR_CONF_SCAN_OPTIONS:
	291	case SR_CONF_DEVICE_OPTIONS:
	292	return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
	293	case SR_CONF_VOLTAGE_TARGET:
	294	*data = std_gvar_min_max_step(0.0, devc->model->max_voltage, 0.001);
	295	break;
	296	case SR_CONF_CURRENT_LIMIT:
	297	*data = std_gvar_min_max_step(0.0, devc->model->max_current, 0.0001);
	298	break;
0549416e JC	299	default:
	300	return SR_ERR_NA;
	301	}
	302
69b05583	303	return SR_OK;
0549416e JC	304	}
	305
	306	static int dev_acquisition_start(const struct sr_dev_inst *sdi)
	307	{
69b05583 JC	308	struct dev_context *devc;
	309	struct sr_modbus_dev_inst *modbus;
	310	int ret;
0549416e	311
69b05583 JC	312	modbus = sdi->conn;
69b05583 JC	313	devc = sdi->priv;
0549416e	314
69b05583 JC	315	if ((ret = sr_modbus_source_add(sdi->session, modbus, G_IO_IN, 10,
	316	rdtech_dps_receive_data, (void *)sdi)) != SR_OK)
	317	return ret;
	318
	319	sr_sw_limits_acquisition_start(&devc->limits);
	320	std_session_send_df_header(sdi);
	321
	322	return rdtech_dps_capture_start(sdi);
0549416e JC	323	}
	324
	325	static int dev_acquisition_stop(struct sr_dev_inst *sdi)
	326	{
69b05583	327	struct sr_modbus_dev_inst *modbus;
0549416e	328
69b05583 JC	329	std_session_send_df_end(sdi);
	330
	331	modbus = sdi->conn;
	332	sr_modbus_source_remove(sdi->session, modbus);
0549416e JC	333
	334	return SR_OK;
	335	}
	336
69b05583	337	static struct sr_dev_driver rdtech_dps_driver_info = {
0549416e	338	.name = "rdtech-dps",
69b05583	339	.longname = "RDTech DPS/DPH series power supply",
0549416e JC	340	.api_version = 1,
	341	.init = std_init,
	342	.cleanup = std_cleanup,
	343	.scan = scan,
	344	.dev_list = std_dev_list,
	345	.dev_clear = std_dev_clear,
	346	.config_get = config_get,
	347	.config_set = config_set,
	348	.config_list = config_list,
	349	.dev_open = dev_open,
	350	.dev_close = dev_close,
	351	.dev_acquisition_start = dev_acquisition_start,
	352	.dev_acquisition_stop = dev_acquisition_stop,
	353	.context = NULL,
	354	};
0549416e	355	SR_REGISTER_DEV_DRIVER(rdtech_dps_driver_info);