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

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2018 James Churchill <pelrun@gmail.com>
 * Copyright (C) 2019 Frank Stettner <frank-stettner@gmx.net>
 *
 * 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;

	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(sdi, REG_LOCK, 1);

	return SR_OK;
}

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

	modbus = sdi->conn;
	if (!modbus)
		return SR_ERR_BUG;

	rdtech_dps_set_reg(sdi, 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;
	int ret;
	uint16_t ivalue;

	(void)cg;

	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(sdi, REG_ENABLE, &ivalue)) == SR_OK)
			*data = g_variant_new_boolean(ivalue);
		break;
	case SR_CONF_REGULATION:
		if ((ret = rdtech_dps_get_reg(sdi, REG_CV_CC, &ivalue)) != SR_OK)
			break;
		*data = g_variant_new_string((ivalue == MODE_CC) ? "CC" : "CV");
		break;
	case SR_CONF_VOLTAGE:
		if ((ret = rdtech_dps_get_reg(sdi, 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(sdi, 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(sdi, 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(sdi, 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(sdi, 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(sdi, 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(sdi, 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(sdi, 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;

	(void)cg;

	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(sdi, REG_ENABLE, g_variant_get_boolean(data));
	case SR_CONF_VOLTAGE_TARGET:
		return rdtech_dps_set_reg(sdi, REG_USET, g_variant_get_double(data) * 100);
	case SR_CONF_CURRENT_LIMIT:
		return rdtech_dps_set_reg(sdi, REG_ISET, g_variant_get_double(data) * 1000);
	case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
		return rdtech_dps_set_reg(sdi, PRE_OVPSET, g_variant_get_double(data) * 100);
	case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
		return rdtech_dps_set_reg(sdi, 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 SR_OK;
}

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>
7c0891b0	5	* Copyright (C) 2019 Frank Stettner <frank-stettner@gmx.net>
0549416e JC	6	*
	7	* This program is free software: you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation, either version 3 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
	21	#include <config.h>
	22	#include "protocol.h"
	23
69b05583 JC	24	static const uint32_t scanopts[] = {
	25	SR_CONF_CONN,
	26	SR_CONF_SERIALCOMM,
	27	SR_CONF_MODBUSADDR,
	28	};
	29
	30	static const uint32_t drvopts[] = {
	31	SR_CONF_POWER_SUPPLY,
	32	};
	33
	34	static const uint32_t devopts[] = {
	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_VOLTAGE \| SR_CONF_GET,
	39	SR_CONF_VOLTAGE_TARGET \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	40	SR_CONF_CURRENT \| SR_CONF_GET,
	41	SR_CONF_CURRENT_LIMIT \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	42	SR_CONF_ENABLED \| SR_CONF_GET \| SR_CONF_SET,
	43	SR_CONF_REGULATION \| SR_CONF_GET,
	44	SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE \| SR_CONF_GET,
	45	SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD \| SR_CONF_GET \| SR_CONF_SET,
	46	SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE \| SR_CONF_GET,
	47	SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD \| SR_CONF_GET \| SR_CONF_SET,
	48	};
	49
	50	/* Model ID, model name, max current, max voltage, max power */
	51	static const struct rdtech_dps_model supported_models[] = {
	52	{ 3005, "DPS3005", 3, 50, 160 },
	53	{ 5005, "DPS5005", 5, 50, 250 },
	54	{ 5205, "DPH5005", 5, 50, 250 },
	55	{ 5015, "DPS5015", 15, 50, 750 },
	56	{ 5020, "DPS5020", 20, 50, 1000 },
	57	{ 8005, "DPS8005", 5, 80, 408 },
	58	};
	59
	60	static struct sr_dev_driver rdtech_dps_driver_info;
	61
	62	static struct sr_dev_inst probe_device(struct sr_modbus_dev_inst modbus)
0549416e	63	{
69b05583 JC	64	const struct rdtech_dps_model *model = NULL;
	65	struct dev_context *devc;
	66	struct sr_dev_inst *sdi;
	67	uint16_t id, version;
	68	unsigned int i;
	69
	70	int ret = rdtech_dps_get_model_version(modbus, &id, &version);
	71	if (ret != SR_OK)
	72	return NULL;
	73	for (i = 0; i < ARRAY_SIZE(supported_models); i++)
	74	if (id == supported_models[i].id) {
	75	model = &supported_models[i];
	76	break;
	77	}
	78	if (model == NULL) {
	79	sr_err("Unknown model: %d.", id);
	80	return NULL;
	81	}
	82
	83	sdi = g_malloc0(sizeof(struct sr_dev_inst));
	84	sdi->status = SR_ST_INACTIVE;
	85	sdi->vendor = g_strdup("RDTech");
	86	sdi->model = g_strdup(model->name);
	87	sdi->version = g_strdup_printf("v%d", version);
	88	sdi->conn = modbus;
	89	sdi->driver = &rdtech_dps_driver_info;
	90	sdi->inst_type = SR_INST_MODBUS;
0549416e	91
69b05583 JC	92	sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "V");
	93	sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "I");
	94	sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "P");
0549416e	95
69b05583 JC	96	devc = g_malloc0(sizeof(struct dev_context));
	97	sr_sw_limits_init(&devc->limits);
	98	devc->model = model;
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
7c0891b0	145	rdtech_dps_set_reg(sdi, REG_LOCK, 1);
0549416e JC	146
	147	return SR_OK;
	148	}
	149
	150	static int dev_close(struct sr_dev_inst *sdi)
	151	{
69b05583	152	struct sr_modbus_dev_inst *modbus;
0549416e	153
69b05583	154	modbus = sdi->conn;
69b05583 JC	155	if (!modbus)
	156	return SR_ERR_BUG;
	157
7c0891b0	158	rdtech_dps_set_reg(sdi, REG_LOCK, 0);
69b05583 JC	159
69b05583 JC	160	return sr_modbus_close(modbus);
0549416e JC	161	}
	162
	163	static int config_get(uint32_t key, GVariant **data,
	164	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	165	{
69b05583	166	struct dev_context *devc;
0549416e	167	int ret;
69b05583	168	uint16_t ivalue;
0549416e	169
0549416e JC	170	(void)cg;
0549416e JC	171
69b05583 JC	172	devc = sdi->priv;
69b05583 JC	173
0549416e JC	174	ret = SR_OK;
0549416e JC	175	switch (key) {
69b05583 JC	176	case SR_CONF_LIMIT_SAMPLES:
	177	case SR_CONF_LIMIT_MSEC:
	178	ret = sr_sw_limits_config_get(&devc->limits, key, data);
	179	break;
	180	case SR_CONF_ENABLED:
7c0891b0	181	if ((ret = rdtech_dps_get_reg(sdi, REG_ENABLE, &ivalue)) == SR_OK)
69b05583 JC	182	*data = g_variant_new_boolean(ivalue);
	183	break;
	184	case SR_CONF_REGULATION:
7c0891b0	185	if ((ret = rdtech_dps_get_reg(sdi, REG_CV_CC, &ivalue)) != SR_OK)
69b05583	186	break;
66d2cc3a	187	*data = g_variant_new_string((ivalue == MODE_CC) ? "CC" : "CV");
69b05583 JC	188	break;
69b05583 JC	189	case SR_CONF_VOLTAGE:
7c0891b0	190	if ((ret = rdtech_dps_get_reg(sdi, REG_UOUT, &ivalue)) == SR_OK)
69b05583 JC	191	*data = g_variant_new_double((float)ivalue / 100.0f);
	192	break;
	193	case SR_CONF_VOLTAGE_TARGET:
7c0891b0	194	if ((ret = rdtech_dps_get_reg(sdi, REG_USET, &ivalue)) == SR_OK)
69b05583 JC	195	*data = g_variant_new_double((float)ivalue / 100.0f);
	196	break;
	197	case SR_CONF_CURRENT:
7c0891b0	198	if ((ret = rdtech_dps_get_reg(sdi, REG_IOUT, &ivalue)) == SR_OK)
69b05583 JC	199	*data = g_variant_new_double((float)ivalue / 100.0f);
	200	break;
	201	case SR_CONF_CURRENT_LIMIT:
7c0891b0	202	if ((ret = rdtech_dps_get_reg(sdi, REG_ISET, &ivalue)) == SR_OK)
69b05583 JC	203	*data = g_variant_new_double((float)ivalue / 1000.0f);
	204	break;
	205	case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
	206	*data = g_variant_new_boolean(TRUE);
	207	break;
	208	case SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE:
7c0891b0	209	if ((ret = rdtech_dps_get_reg(sdi, REG_PROTECT, &ivalue)) == SR_OK)
69b05583 JC	210	*data = g_variant_new_boolean(ivalue == STATE_OVP);
	211	break;
	212	case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
7c0891b0	213	if ((ret = rdtech_dps_get_reg(sdi, PRE_OVPSET, &ivalue)) == SR_OK)
69b05583 JC	214	*data = g_variant_new_double((float)ivalue / 100.0f);
	215	break;
	216	case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
	217	*data = g_variant_new_boolean(TRUE);
	218	break;
	219	case SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE:
7c0891b0	220	if ((ret = rdtech_dps_get_reg(sdi, REG_PROTECT, &ivalue)) == SR_OK)
69b05583 JC	221	*data = g_variant_new_boolean(ivalue == STATE_OCP);
	222	break;
	223	case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
7c0891b0	224	if ((ret = rdtech_dps_get_reg(sdi, PRE_OCPSET, &ivalue)) == SR_OK)
69b05583 JC	225	*data = g_variant_new_double((float)ivalue / 1000.0f);
69b05583 JC	226	break;
0549416e JC	227	default:
	228	return SR_ERR_NA;
	229	}
	230
	231	return ret;
	232	}
	233
	234	static int config_set(uint32_t key, GVariant *data,
	235	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	236	{
69b05583	237	struct dev_context *devc;
0549416e	238
0549416e JC	239	(void)cg;
0549416e JC	240
69b05583 JC	241	devc = sdi->priv;
69b05583 JC	242
0549416e	243	switch (key) {
69b05583 JC	244	case SR_CONF_LIMIT_SAMPLES:
	245	case SR_CONF_LIMIT_MSEC:
	246	return sr_sw_limits_config_set(&devc->limits, key, data);
	247	case SR_CONF_ENABLED:
7c0891b0	248	return rdtech_dps_set_reg(sdi, REG_ENABLE, g_variant_get_boolean(data));
69b05583	249	case SR_CONF_VOLTAGE_TARGET:
7c0891b0	250	return rdtech_dps_set_reg(sdi, REG_USET, g_variant_get_double(data) * 100);
69b05583	251	case SR_CONF_CURRENT_LIMIT:
7c0891b0	252	return rdtech_dps_set_reg(sdi, REG_ISET, g_variant_get_double(data) * 1000);
69b05583	253	case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
7c0891b0	254	return rdtech_dps_set_reg(sdi, PRE_OVPSET, g_variant_get_double(data) * 100);
69b05583	255	case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
7c0891b0	256	return rdtech_dps_set_reg(sdi, PRE_OCPSET, g_variant_get_double(data) * 1000);
0549416e	257	default:
69b05583	258	return SR_ERR_NA;
0549416e JC	259	}
0549416e JC	260
69b05583	261	return SR_OK;
0549416e JC	262	}
	263
	264	static int config_list(uint32_t key, GVariant **data,
	265	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	266	{
69b05583	267	struct dev_context *devc;
0549416e	268
69b05583	269	devc = (sdi) ? sdi->priv : NULL;
0549416e	270
0549416e	271	switch (key) {
69b05583 JC	272	case SR_CONF_SCAN_OPTIONS:
	273	case SR_CONF_DEVICE_OPTIONS:
	274	return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
	275	case SR_CONF_VOLTAGE_TARGET:
	276	*data = std_gvar_min_max_step(0.0, devc->model->max_voltage, 0.001);
	277	break;
	278	case SR_CONF_CURRENT_LIMIT:
	279	*data = std_gvar_min_max_step(0.0, devc->model->max_current, 0.0001);
	280	break;
0549416e JC	281	default:
	282	return SR_ERR_NA;
	283	}
	284
69b05583	285	return SR_OK;
0549416e JC	286	}
	287
	288	static int dev_acquisition_start(const struct sr_dev_inst *sdi)
	289	{
69b05583 JC	290	struct dev_context *devc;
	291	struct sr_modbus_dev_inst *modbus;
	292	int ret;
0549416e	293
69b05583 JC	294	modbus = sdi->conn;
69b05583 JC	295	devc = sdi->priv;
0549416e	296
69b05583 JC	297	if ((ret = sr_modbus_source_add(sdi->session, modbus, G_IO_IN, 10,
	298	rdtech_dps_receive_data, (void *)sdi)) != SR_OK)
	299	return ret;
	300
	301	sr_sw_limits_acquisition_start(&devc->limits);
	302	std_session_send_df_header(sdi);
	303
7c0891b0	304	return SR_OK;
0549416e JC	305	}
	306
	307	static int dev_acquisition_stop(struct sr_dev_inst *sdi)
	308	{
69b05583	309	struct sr_modbus_dev_inst *modbus;
0549416e	310
69b05583 JC	311	std_session_send_df_end(sdi);
	312
	313	modbus = sdi->conn;
	314	sr_modbus_source_remove(sdi->session, modbus);
0549416e JC	315
	316	return SR_OK;
	317	}
	318
69b05583	319	static struct sr_dev_driver rdtech_dps_driver_info = {
0549416e	320	.name = "rdtech-dps",
69b05583	321	.longname = "RDTech DPS/DPH series power supply",
0549416e JC	322	.api_version = 1,
	323	.init = std_init,
	324	.cleanup = std_cleanup,
	325	.scan = scan,
	326	.dev_list = std_dev_list,
	327	.dev_clear = std_dev_clear,
	328	.config_get = config_get,
	329	.config_set = config_set,
	330	.config_list = config_list,
	331	.dev_open = dev_open,
	332	.dev_close = dev_close,
	333	.dev_acquisition_start = dev_acquisition_start,
	334	.dev_acquisition_stop = dev_acquisition_stop,
	335	.context = NULL,
	336	};
0549416e	337	SR_REGISTER_DEV_DRIVER(rdtech_dps_driver_info);