[libsigrok.git] / src / hardware / itech-it8500 / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2020 Timo Kokkonen <tjko@iki.fi>
 *
 * 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 <string.h>
#include "protocol.h"

SR_PRIV uint8_t itech_it8500_checksum(const uint8_t *packet)
{
	const uint8_t *p;
	uint8_t checksum;
	size_t i;

	if (!packet)
		return 0xff;

	checksum = 0;
	p = packet;
	for (i = 0; i < IT8500_PACKET_LEN - 1; i++)
		checksum += *p++;

	return checksum;
}

SR_PRIV const char *itech_it8500_mode_to_string(enum itech_it8500_modes mode)
{
	switch (mode) {
	case CC:
		return "CC";
	case CV:
		return "CV";
	case CW:
		return "CW";
	case CR:
		return "CR";
	default:
		return "Unknown";
	}
}

SR_PRIV int itech_it8500_string_to_mode(const char *modename,
		enum itech_it8500_modes *mode)
{
	size_t i;
	const char *s;

	for (i = 0; i < IT8500_MODES; i++) {
		s = itech_it8500_mode_to_string(i);
		if (strncmp(modename, s, strlen(s)) == 0) {
			*mode = i;
			return SR_OK;
		}
	}

	return SR_ERR;
}

SR_PRIV int itech_it8500_send_cmd(struct sr_serial_dev_inst *serial,
		struct itech_it8500_cmd_packet *cmd,
		struct itech_it8500_cmd_packet **response)
{
	struct itech_it8500_cmd_packet *resp;
	uint8_t *cmd_buf, *resp_buf, checksum;
	int ret, read_len;

	if (!serial || !cmd || !response)
		return SR_ERR_ARG;

	cmd_buf = g_malloc0(IT8500_PACKET_LEN);
	resp_buf = g_malloc0(IT8500_PACKET_LEN);
	resp = g_malloc0(sizeof(*resp));
	if (!cmd_buf || !resp_buf || !resp)
		return SR_ERR_MALLOC;

	/*
	 * Construct request from: preamble, address, command, data,
	 * and checksum.
	 */
	cmd_buf[0] = IT8500_PREAMBLE;
	cmd_buf[1] = cmd->address;
	cmd_buf[2] = cmd->command;
	memcpy(&cmd_buf[3], cmd->data, IT8500_DATA_LEN);
	cmd_buf[IT8500_PACKET_LEN - 1] = itech_it8500_checksum(cmd_buf);

	sr_spew("%s: Sending command: %02x", __func__, cmd->command);
	ret = serial_write_blocking(serial, cmd_buf, IT8500_PACKET_LEN,
			serial_timeout(serial, IT8500_PACKET_LEN));
	if (ret < IT8500_PACKET_LEN) {
		sr_dbg("%s: Error sending command 0x%02x: %d", __func__,
			cmd->command, ret);
		ret = SR_ERR;
		goto error;
	}

	ret = SR_ERR;
	read_len = serial_read_blocking(serial, resp_buf, IT8500_PACKET_LEN,
			100);
	if (read_len < IT8500_PACKET_LEN) {
		sr_dbg("%s: Timeout waiting response to command: %d",
			__func__, read_len);
		goto error;
	}

	if (resp_buf[0] != IT8500_PREAMBLE) {
		sr_dbg("%s: Invalid packet received (first byte: %02x)",
			__func__, resp_buf[0]);
		goto error;
	}

	checksum = itech_it8500_checksum(resp_buf);
	if (resp_buf[IT8500_PACKET_LEN - 1] != checksum) {
		sr_dbg("%s: Invalid packet received: checksum mismatch",
			__func__);
		goto error;
	}

	resp->address = resp_buf[1];
	resp->command = resp_buf[2];
	memcpy(resp->data, &resp_buf[3], IT8500_DATA_LEN);
	sr_spew("%s: Response packet received: cmd=%02x", __func__,
		resp->command);

	if (resp->command == CMD_RESPONSE) {
		if (resp->data[0] != STS_COMMAND_SUCCESSFUL) {
			sr_dbg("%s: Command (%02x) failed: status=%02x",
				__func__, cmd->command, resp->data[0]);
			goto error;
		}
	} else {
		if (resp->command != cmd->command) {
			sr_dbg("%s: Invalid response received: %02x"
				" (expected: %02x)",
				__func__, resp->command, cmd->command);
			goto error;
		}
	}

	if (*response)
		g_free(*response);
	*response = resp;
	resp = NULL;
	ret = SR_OK;

error:
	g_free(cmd_buf);
	g_free(resp_buf);
	g_free(resp);

	return ret;
}

SR_PRIV int itech_it8500_cmd(const struct sr_dev_inst *sdi,
		struct itech_it8500_cmd_packet *cmd,
		struct itech_it8500_cmd_packet **response)
{
	struct dev_context *devc;
	struct sr_serial_dev_inst *serial;
	int ret;

	if (!sdi)
		return SR_ERR_ARG;
	devc = sdi->priv;
	serial = sdi->conn;
	if (!devc || !serial)
		return SR_ERR_NA;

	g_mutex_lock(&devc->mutex);
	ret = itech_it8500_send_cmd(serial, cmd, response);
	g_mutex_unlock(&devc->mutex);

	return ret;
}

SR_PRIV void itech_it8500_status_change(const struct sr_dev_inst *sdi,
		uint8_t old_os, uint8_t new_os,
		uint16_t old_ds, uint16_t new_ds,
		enum itech_it8500_modes old_m, enum itech_it8500_modes new_m)
{
	gboolean old_bit, new_bit;
	const char *mode;

	/* Check it output status has changed. */
	old_bit = old_os & OS_OUT_FLAG;
	new_bit = new_os & OS_OUT_FLAG;
	if (old_bit != new_bit)
		sr_session_send_meta(sdi,
			SR_CONF_ENABLED,
			g_variant_new_boolean(new_bit));

	/* Check if OVP status has changed. */
	old_bit = old_ds & DS_OV_FLAG;
	new_bit = new_ds & DS_OV_FLAG;
	if (old_bit != new_bit)
		sr_session_send_meta(sdi,
			SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE,
			g_variant_new_boolean(new_bit));

	/* Check if OCP status has changed. */
	old_bit = old_ds & DS_OC_FLAG;
	new_bit = new_ds & DS_OC_FLAG;
	if (old_bit != new_bit)
		sr_session_send_meta(sdi,
			SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE,
			g_variant_new_boolean(new_bit));

	/* Check if OTP status has changed. */
	old_bit = old_ds & DS_OT_FLAG;
	new_bit = new_ds & DS_OT_FLAG;
	if (old_bit != new_bit)
		sr_session_send_meta(sdi,
			SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE,
			g_variant_new_boolean(new_bit));

	/* Check if operating mode has changed. */
	if (old_m != new_m) {
		mode = itech_it8500_mode_to_string(new_m);
		sr_session_send_meta(sdi, SR_CONF_REGULATION,
			g_variant_new_string(mode));
	}
}

SR_PRIV int itech_it8500_get_status(const struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
	struct itech_it8500_cmd_packet *cmd;
	struct itech_it8500_cmd_packet *resp;
	double voltage, current, power;
	uint8_t operation_state;
	uint16_t demand_state;
	enum itech_it8500_modes mode;
	gboolean load_on;
	const uint8_t *p;
	int ret;

	if (!sdi)
		return SR_ERR_ARG;

	devc = sdi->priv;
	if (!devc)
		return SR_ERR_NA;

	cmd = g_malloc0(sizeof(*cmd));
	if (!cmd)
		return SR_ERR_MALLOC;
	cmd->address = devc->address;
	cmd->command = CMD_GET_STATE;
	resp = NULL;

	ret = itech_it8500_cmd(sdi, cmd, &resp);
	if (ret == SR_OK) {
		p = resp->data;
		voltage = read_u32le_inc(&p) / 1000.0;
		current = read_u32le_inc(&p) / 10000.0;
		power = read_u32le_inc(&p) / 1000.0;
		operation_state = read_u8_inc(&p);
		demand_state = read_u16le_inc(&p);

		if (demand_state & DS_CC_MODE_FLAG)
			mode = CC;
		else if (demand_state & DS_CV_MODE_FLAG)
			mode = CV;
		else if (demand_state & DS_CW_MODE_FLAG)
			mode = CW;
		else if (demand_state & DS_CR_MODE_FLAG)
			mode = CR;
		else
			mode = CC;
		load_on = operation_state & OS_OUT_FLAG;

		sr_dbg("Load status: V=%.4f, I=%.4f, P=%.3f, State=%s, "
			"Mode=%s (op=0x%02x, demand=0x%04x)",
			voltage, current, power, (load_on ? "ON": "OFF"),
			itech_it8500_mode_to_string(mode),
			operation_state, demand_state);

		/* Check for status change only after scan() has completed. */
		if (sdi->model) {
			itech_it8500_status_change(sdi, devc->operation_state,
				operation_state, devc->demand_state,
				demand_state, devc->mode, mode);
		}
		devc->voltage = voltage;
		devc->current = current;
		devc->power = power;
		devc->operation_state = operation_state;
		devc->demand_state = demand_state;
		devc->mode = mode;
		devc->load_on = load_on;
	}

	g_free(cmd);
	g_free(resp);

	return ret;
}

SR_PRIV int itech_it8500_get_int(const struct sr_dev_inst *sdi,
		enum itech_it8500_command command, int *result)
{
	struct dev_context *devc;
	struct itech_it8500_cmd_packet *cmd;
	struct itech_it8500_cmd_packet *resp;
	int ret;

	if (!sdi || !result)
		return SR_ERR_ARG;

	devc = sdi->priv;
	cmd = g_malloc0(sizeof(*cmd));
	if (!cmd)
		return SR_ERR_MALLOC;
	cmd->address = devc->address;
	cmd->command = command;
	resp = NULL;

	ret = itech_it8500_cmd(sdi, cmd, &resp);
	if (ret == SR_OK)
		*result = RL32(&resp->data[0]);

	g_free(cmd);
	g_free(resp);

	return ret;
}

SR_PRIV void itech_it8500_channel_send_value(const struct sr_dev_inst *sdi,
		struct sr_channel *ch, double value, enum sr_mq mq,
		enum sr_mqflag mqflags, enum sr_unit unit, int digits)
{
	struct sr_datafeed_packet packet;
	struct sr_datafeed_analog analog;
	struct sr_analog_encoding encoding;
	struct sr_analog_meaning meaning;
	struct sr_analog_spec spec;
	double val;

	val = value;
	sr_analog_init(&analog, &encoding, &meaning, &spec, digits);
	analog.meaning->channels = g_slist_append(NULL, ch);
	analog.num_samples = 1;
	analog.data = &val;
	analog.encoding->unitsize = sizeof(val);
	analog.encoding->is_float = TRUE;
	analog.meaning->mq = mq;
	analog.meaning->unit = unit;
	analog.meaning->mqflags = mqflags;

	packet.type = SR_DF_ANALOG;
	packet.payload = &analog;
	sr_session_send(sdi, &packet);
	g_slist_free(analog.meaning->channels);
}

SR_PRIV int itech_it8500_receive_data(int fd, int revents, void *cb_data)
{
	struct sr_dev_inst *sdi;
	struct dev_context *devc;
	GSList *l;

	(void)fd;
	(void)revents;

	if (!(sdi = cb_data))
		return TRUE;

	if (!(devc = sdi->priv))
		return TRUE;

	if (itech_it8500_get_status(sdi) != SR_OK)
		return TRUE;

	std_session_send_df_frame_begin(sdi);

	l = g_slist_nth(sdi->channels, 0);
	itech_it8500_channel_send_value(sdi, l->data, devc->voltage,
		SR_MQ_VOLTAGE, SR_MQFLAG_DC, SR_UNIT_VOLT, 5);

	l = g_slist_nth(sdi->channels, 1);
	itech_it8500_channel_send_value(sdi, l->data, devc->current,
		SR_MQ_CURRENT, SR_MQFLAG_DC, SR_UNIT_AMPERE, 5);

	l = g_slist_nth(sdi->channels, 2);
	itech_it8500_channel_send_value(sdi, l->data, devc->power,
		SR_MQ_POWER, 0, SR_UNIT_WATT, 5);

	std_session_send_df_frame_end(sdi);

	sr_sw_limits_update_samples_read(&devc->limits, 1);
	if (sr_sw_limits_check(&devc->limits))
		sr_dev_acquisition_stop(sdi);

	return TRUE;
}
Commit	Line	Data
c16effae TK	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2020 Timo Kokkonen <tjko@iki.fi>
	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>
f21b6983	21	#include <string.h>
c16effae TK	22	#include "protocol.h"
c16effae TK	23
f21b6983 TK	24	SR_PRIV uint8_t itech_it8500_checksum(const uint8_t *packet)
	25	{
	26	const uint8_t *p;
	27	uint8_t checksum;
	28	size_t i;
	29
	30	if (!packet)
	31	return 0xff;
	32
	33	checksum = 0;
	34	p = packet;
	35	for (i = 0; i < IT8500_PACKET_LEN - 1; i++)
	36	checksum += *p++;
	37
	38	return checksum;
	39	}
	40
	41	SR_PRIV const char *itech_it8500_mode_to_string(enum itech_it8500_modes mode)
	42	{
	43	switch (mode) {
	44	case CC:
	45	return "CC";
	46	case CV:
	47	return "CV";
	48	case CW:
	49	return "CW";
	50	case CR:
	51	return "CR";
	52	default:
	53	return "Unknown";
	54	}
	55	}
	56
	57	SR_PRIV int itech_it8500_string_to_mode(const char *modename,
	58	enum itech_it8500_modes *mode)
	59	{
	60	size_t i;
	61	const char *s;
	62
	63	for (i = 0; i < IT8500_MODES; i++) {
	64	s = itech_it8500_mode_to_string(i);
	65	if (strncmp(modename, s, strlen(s)) == 0) {
	66	*mode = i;
	67	return SR_OK;
	68	}
	69	}
	70
	71	return SR_ERR;
	72	}
	73
	74	SR_PRIV int itech_it8500_send_cmd(struct sr_serial_dev_inst *serial,
	75	struct itech_it8500_cmd_packet *cmd,
	76	struct itech_it8500_cmd_packet **response)
	77	{
	78	struct itech_it8500_cmd_packet *resp;
	79	uint8_t cmd_buf, resp_buf, checksum;
	80	int ret, read_len;
	81
	82	if (!serial \|\| !cmd \|\| !response)
	83	return SR_ERR_ARG;
	84
	85	cmd_buf = g_malloc0(IT8500_PACKET_LEN);
	86	resp_buf = g_malloc0(IT8500_PACKET_LEN);
	87	resp = g_malloc0(sizeof(*resp));
88	if (!cmd_buf \|\| !resp_buf \|\| !resp)
89	return SR_ERR_MALLOC;
90
91	/*
92	* Construct request from: preamble, address, command, data,
93	* and checksum.
94	*/
95	cmd_buf[0] = IT8500_PREAMBLE;
96	cmd_buf[1] = cmd->address;
97	cmd_buf[2] = cmd->command;
98	memcpy(&cmd_buf[3], cmd->data, IT8500_DATA_LEN);
99	cmd_buf[IT8500_PACKET_LEN - 1] = itech_it8500_checksum(cmd_buf);
100
101	sr_spew("%s: Sending command: %02x", __func__, cmd->command);
102	ret = serial_write_blocking(serial, cmd_buf, IT8500_PACKET_LEN,
103	serial_timeout(serial, IT8500_PACKET_LEN));
104	if (ret < IT8500_PACKET_LEN) {
105	sr_dbg("%s: Error sending command 0x%02x: %d", __func__,
106	cmd->command, ret);
107	ret = SR_ERR;
108	goto error;
109	}
110
111	ret = SR_ERR;
112	read_len = serial_read_blocking(serial, resp_buf, IT8500_PACKET_LEN,
113	100);
114	if (read_len < IT8500_PACKET_LEN) {
115	sr_dbg("%s: Timeout waiting response to command: %d",
116	__func__, read_len);
117	goto error;
118	}
119
120	if (resp_buf[0] != IT8500_PREAMBLE) {
121	sr_dbg("%s: Invalid packet received (first byte: %02x)",
122	__func__, resp_buf[0]);
123	goto error;
124	}
125
126	checksum = itech_it8500_checksum(resp_buf);
127	if (resp_buf[IT8500_PACKET_LEN - 1] != checksum) {
128	sr_dbg("%s: Invalid packet received: checksum mismatch",
129	__func__);
130	goto error;
131	}
132
133	resp->address = resp_buf[1];
134	resp->command = resp_buf[2];
135	memcpy(resp->data, &resp_buf[3], IT8500_DATA_LEN);
136	sr_spew("%s: Response packet received: cmd=%02x", __func__,
137	resp->command);
138
139	if (resp->command == CMD_RESPONSE) {
8c8fff47	140	if (resp->data[0] != STS_COMMAND_SUCCESSFUL) {
f21b6983 TK	141	sr_dbg("%s: Command (%02x) failed: status=%02x",
	142	__func__, cmd->command, resp->data[0]);
	143	goto error;
	144	}
	145	} else {
	146	if (resp->command != cmd->command) {
	147	sr_dbg("%s: Invalid response received: %02x"
	148	" (expected: %02x)",
	149	__func__, resp->command, cmd->command);
	150	goto error;
	151	}
	152	}
	153
	154	if (*response)
	155	g_free(*response);
	156	*response = resp;
	157	resp = NULL;
	158	ret = SR_OK;
	159
	160	error:
	161	g_free(cmd_buf);
	162	g_free(resp_buf);
	163	g_free(resp);
	164
	165	return ret;
	166	}
	167
	168	SR_PRIV int itech_it8500_cmd(const struct sr_dev_inst *sdi,
	169	struct itech_it8500_cmd_packet *cmd,
	170	struct itech_it8500_cmd_packet **response)
	171	{
	172	struct dev_context *devc;
	173	struct sr_serial_dev_inst *serial;
	174	int ret;
	175
	176	if (!sdi)
	177	return SR_ERR_ARG;
	178	devc = sdi->priv;
	179	serial = sdi->conn;
	180	if (!devc \|\| !serial)
	181	return SR_ERR_NA;
	182
	183	g_mutex_lock(&devc->mutex);
	184	ret = itech_it8500_send_cmd(serial, cmd, response);
	185	g_mutex_unlock(&devc->mutex);
	186
	187	return ret;
	188	}
	189
	190	SR_PRIV void itech_it8500_status_change(const struct sr_dev_inst *sdi,
	191	uint8_t old_os, uint8_t new_os,
	192	uint16_t old_ds, uint16_t new_ds,
	193	enum itech_it8500_modes old_m, enum itech_it8500_modes new_m)
	194	{
92cd8514	195	gboolean old_bit, new_bit;
f21b6983	196	const char *mode;
f21b6983 TK	197
f21b6983 TK	198	/* Check it output status has changed. */
92cd8514 GS	199	old_bit = old_os & OS_OUT_FLAG;
	200	new_bit = new_os & OS_OUT_FLAG;
	201	if (old_bit != new_bit)
f21b6983 TK	202	sr_session_send_meta(sdi,
f21b6983 TK	203	SR_CONF_ENABLED,
92cd8514	204	g_variant_new_boolean(new_bit));
f21b6983 TK	205
f21b6983 TK	206	/* Check if OVP status has changed. */
92cd8514 GS	207	old_bit = old_ds & DS_OV_FLAG;
	208	new_bit = new_ds & DS_OV_FLAG;
	209	if (old_bit != new_bit)
f21b6983 TK	210	sr_session_send_meta(sdi,
f21b6983 TK	211	SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE,
92cd8514	212	g_variant_new_boolean(new_bit));
f21b6983 TK	213
f21b6983 TK	214	/* Check if OCP status has changed. */
92cd8514 GS	215	old_bit = old_ds & DS_OC_FLAG;
	216	new_bit = new_ds & DS_OC_FLAG;
	217	if (old_bit != new_bit)
f21b6983 TK	218	sr_session_send_meta(sdi,
f21b6983 TK	219	SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE,
92cd8514	220	g_variant_new_boolean(new_bit));
f21b6983 TK	221
f21b6983 TK	222	/* Check if OTP status has changed. */
92cd8514 GS	223	old_bit = old_ds & DS_OT_FLAG;
	224	new_bit = new_ds & DS_OT_FLAG;
	225	if (old_bit != new_bit)
f21b6983 TK	226	sr_session_send_meta(sdi,
f21b6983 TK	227	SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE,
92cd8514	228	g_variant_new_boolean(new_bit));
f21b6983 TK	229
	230	/* Check if operating mode has changed. */
	231	if (old_m != new_m) {
	232	mode = itech_it8500_mode_to_string(new_m);
	233	sr_session_send_meta(sdi, SR_CONF_REGULATION,
	234	g_variant_new_string(mode));
	235	}
	236	}
	237
	238	SR_PRIV int itech_it8500_get_status(const struct sr_dev_inst *sdi)
	239	{
	240	struct dev_context *devc;
	241	struct itech_it8500_cmd_packet *cmd;
	242	struct itech_it8500_cmd_packet *resp;
	243	double voltage, current, power;
	244	uint8_t operation_state;
	245	uint16_t demand_state;
	246	enum itech_it8500_modes mode;
	247	gboolean load_on;
	248	const uint8_t *p;
	249	int ret;
	250
	251	if (!sdi)
	252	return SR_ERR_ARG;
	253
	254	devc = sdi->priv;
	255	if (!devc)
	256	return SR_ERR_NA;
	257
	258	cmd = g_malloc0(sizeof(*cmd));
	259	if (!cmd)
	260	return SR_ERR_MALLOC;
	261	cmd->address = devc->address;
	262	cmd->command = CMD_GET_STATE;
	263	resp = NULL;
	264
	265	ret = itech_it8500_cmd(sdi, cmd, &resp);
	266	if (ret == SR_OK) {
	267	p = resp->data;
	268	voltage = read_u32le_inc(&p) / 1000.0;
	269	current = read_u32le_inc(&p) / 10000.0;
	270	power = read_u32le_inc(&p) / 1000.0;
	271	operation_state = read_u8_inc(&p);
	272	demand_state = read_u16le_inc(&p);
	273
	274	if (demand_state & DS_CC_MODE_FLAG)
	275	mode = CC;
	276	else if (demand_state & DS_CV_MODE_FLAG)
	277	mode = CV;
	278	else if (demand_state & DS_CW_MODE_FLAG)
	279	mode = CW;
	280	else if (demand_state & DS_CR_MODE_FLAG)
	281	mode = CR;
	282	else
	283	mode = CC;
	284	load_on = operation_state & OS_OUT_FLAG;
	285
	286	sr_dbg("Load status: V=%.4f, I=%.4f, P=%.3f, State=%s, "
	287	"Mode=%s (op=0x%02x, demand=0x%04x)",
	288	voltage, current, power, (load_on ? "ON": "OFF"),
	289	itech_it8500_mode_to_string(mode),
	290	operation_state, demand_state);
	291
	292	/* Check for status change only after scan() has completed. */
293	if (sdi->model) {
294	itech_it8500_status_change(sdi, devc->operation_state,
295	operation_state, devc->demand_state,
296	demand_state, devc->mode, mode);
297	}
298	devc->voltage = voltage;
299	devc->current = current;
300	devc->power = power;
301	devc->operation_state = operation_state;
302	devc->demand_state = demand_state;
303	devc->mode = mode;
304	devc->load_on = load_on;
305	}
306
307	g_free(cmd);
308	g_free(resp);
309
310	return ret;
311	}
312
313	SR_PRIV int itech_it8500_get_int(const struct sr_dev_inst *sdi,
314	enum itech_it8500_command command, int *result)
315	{
316	struct dev_context *devc;
317	struct itech_it8500_cmd_packet *cmd;
318	struct itech_it8500_cmd_packet *resp;
319	int ret;
320
321	if (!sdi \|\| !result)
322	return SR_ERR_ARG;
323
324	devc = sdi->priv;
325	cmd = g_malloc0(sizeof(*cmd));
326	if (!cmd)
327	return SR_ERR_MALLOC;
328	cmd->address = devc->address;
329	cmd->command = command;
330	resp = NULL;
331
332	ret = itech_it8500_cmd(sdi, cmd, &resp);
333	if (ret == SR_OK)
334	*result = RL32(&resp->data[0]);
335
336	g_free(cmd);
337	g_free(resp);
338
339	return ret;
340	}
341
342	SR_PRIV void itech_it8500_channel_send_value(const struct sr_dev_inst *sdi,
343	struct sr_channel *ch, double value, enum sr_mq mq,
24be1e05	344	enum sr_mqflag mqflags, enum sr_unit unit, int digits)
f21b6983 TK	345	{
	346	struct sr_datafeed_packet packet;
	347	struct sr_datafeed_analog analog;
	348	struct sr_analog_encoding encoding;
	349	struct sr_analog_meaning meaning;
	350	struct sr_analog_spec spec;
	351	double val;
	352
	353	val = value;
	354	sr_analog_init(&analog, &encoding, &meaning, &spec, digits);
	355	analog.meaning->channels = g_slist_append(NULL, ch);
	356	analog.num_samples = 1;
	357	analog.data = &val;
	358	analog.encoding->unitsize = sizeof(val);
	359	analog.encoding->is_float = TRUE;
	360	analog.meaning->mq = mq;
	361	analog.meaning->unit = unit;
24be1e05	362	analog.meaning->mqflags = mqflags;
f21b6983 TK	363
	364	packet.type = SR_DF_ANALOG;
	365	packet.payload = &analog;
	366	sr_session_send(sdi, &packet);
	367	g_slist_free(analog.meaning->channels);
	368	}
	369
c16effae TK	370	SR_PRIV int itech_it8500_receive_data(int fd, int revents, void *cb_data)
c16effae TK	371	{
f21b6983	372	struct sr_dev_inst *sdi;
c16effae	373	struct dev_context *devc;
f21b6983	374	GSList *l;
c16effae TK	375
c16effae TK	376	(void)fd;
f21b6983	377	(void)revents;
c16effae TK	378
	379	if (!(sdi = cb_data))
	380	return TRUE;
	381
	382	if (!(devc = sdi->priv))
	383	return TRUE;
	384
f21b6983 TK	385	if (itech_it8500_get_status(sdi) != SR_OK)
	386	return TRUE;
	387
	388	std_session_send_df_frame_begin(sdi);
	389
	390	l = g_slist_nth(sdi->channels, 0);
	391	itech_it8500_channel_send_value(sdi, l->data, devc->voltage,
24be1e05	392	SR_MQ_VOLTAGE, SR_MQFLAG_DC, SR_UNIT_VOLT, 5);
f21b6983 TK	393
	394	l = g_slist_nth(sdi->channels, 1);
	395	itech_it8500_channel_send_value(sdi, l->data, devc->current,
24be1e05	396	SR_MQ_CURRENT, SR_MQFLAG_DC, SR_UNIT_AMPERE, 5);
f21b6983 TK	397
	398	l = g_slist_nth(sdi->channels, 2);
	399	itech_it8500_channel_send_value(sdi, l->data, devc->power,
24be1e05	400	SR_MQ_POWER, 0, SR_UNIT_WATT, 5);
f21b6983 TK	401
	402	std_session_send_df_frame_end(sdi);
	403
	404	sr_sw_limits_update_samples_read(&devc->limits, 1);
	405	if (sr_sw_limits_check(&devc->limits))
	406	sr_dev_acquisition_stop(sdi);
c16effae TK	407
	408	return TRUE;
	409	}