[libsigrok.git] / src / hardware / korad-kaxxxxp / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2015 Hannu Vuolasaho <vuokkosetae@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"

#define REQ_TIMEOUT_MS 500
#define DEVICE_PROCESSING_TIME_MS 80

SR_PRIV int korad_kaxxxxp_send_cmd(struct sr_serial_dev_inst *serial,
				const char *cmd)
{
	int ret;

	sr_dbg("Sending '%s'.", cmd);
	if ((ret = serial_write_blocking(serial, cmd, strlen(cmd), 0)) < 0) {
		sr_err("Error sending command: %d.", ret);
		return ret;
	}

	return ret;
}

SR_PRIV int korad_kaxxxxp_read_chars(struct sr_serial_dev_inst *serial,
				int count, char *buf)
{
	int ret, received, turns;

	received = 0;
	turns = 0;

	do {
		if ((ret = serial_read_blocking(serial, buf + received,
				count - received,
				serial_timeout(serial, count))) < 0) {
			sr_err("Error %d reading %d bytes from device.",
			       ret, count);
			return ret;
		}
		received += ret;
		turns++;
	} while ((received < count) && (turns < 100));

	buf[count] = 0;

	sr_spew("Received: '%s'.", buf);

	return ret;
}

static void give_device_time_to_process(struct dev_context *devc)
{
	int64_t sleeping_time;

	sleeping_time = devc->req_sent_at + (DEVICE_PROCESSING_TIME_MS * 1000);
	sleeping_time -= g_get_monotonic_time();

	if (sleeping_time > 0) {
		g_usleep(sleeping_time);
		sr_spew("Sleeping for processing %" PRIi64 " usec", sleeping_time);
	}
}

SR_PRIV int korad_kaxxxxp_set_value(struct sr_serial_dev_inst *serial,
				struct dev_context *devc)
{
	char msg[21];
	const char *cmd;
	float value;
	int ret;

	give_device_time_to_process(devc);

	msg[20] = 0;
	switch (devc->target) {
	case KAXXXXP_CURRENT:
	case KAXXXXP_VOLTAGE:
	case KAXXXXP_STATUS:
		sr_err("Can't set measurable parameter.");
		return SR_ERR;
	case KAXXXXP_CURRENT_MAX:
		cmd = "ISET1:%05.3f";
		value = devc->current_max;
		break;
	case KAXXXXP_VOLTAGE_MAX:
		cmd = "VSET1:%05.2f";
		value = devc->voltage_max;
		break;
	case KAXXXXP_OUTPUT:
		cmd = "OUT%01.0f";
		value = (devc->output_enabled) ? 1 : 0;
		break;
	case KAXXXXP_BEEP:
		cmd = "BEEP%01.0f";
		value = (devc->beep_enabled) ? 1 : 0;
		break;
	case KAXXXXP_OCP:
		cmd = "OCP%01.0f";
		value = (devc->ocp_enabled) ? 1 : 0;
		break;
	case KAXXXXP_OVP:
		cmd = "OVP%01.0f";
		value = (devc->ovp_enabled) ? 1 : 0;
		break;
	case KAXXXXP_SAVE:
		cmd = "SAV%01.0f";
		if (devc->program < 1 || devc->program > 5) {
			sr_err("Only programs 1-5 supported and %d isn't "
			       "between them.", devc->program);
			return SR_ERR;
		}
		value = devc->program;
		break;
	case KAXXXXP_RECALL:
		cmd = "RCL%01.0f";
		if (devc->program < 1 || devc->program > 5) {
			sr_err("Only programs 1-5 supported and %d isn't "
			       "between them.", devc->program);
			return SR_ERR;
		}
		value = devc->program;
		break;
	default:
		sr_err("Don't know how to set %d.", devc->target);
		return SR_ERR;
	}

	if (cmd)
		snprintf(msg, 20, cmd, value);

	ret = korad_kaxxxxp_send_cmd(serial, msg);
	devc->req_sent_at = g_get_monotonic_time();
	devc->reply_pending = FALSE;

	return ret;
}

SR_PRIV int korad_kaxxxxp_query_value(struct sr_serial_dev_inst *serial,
				struct dev_context *devc)
{
	int ret;

	give_device_time_to_process(devc);

	switch (devc->target) {
	case KAXXXXP_CURRENT:
		/* Read current from device. */
		ret = korad_kaxxxxp_send_cmd(serial, "IOUT1?");
		break;
	case KAXXXXP_CURRENT_MAX:
		/* Read set current from device. */
		ret = korad_kaxxxxp_send_cmd(serial, "ISET1?");
		break;
	case KAXXXXP_VOLTAGE:
		/* Read voltage from device. */
		ret = korad_kaxxxxp_send_cmd(serial, "VOUT1?");
		break;
	case KAXXXXP_VOLTAGE_MAX:
		/* Read set voltage from device. */
		ret = korad_kaxxxxp_send_cmd(serial, "VSET1?");
		break;
	case KAXXXXP_STATUS:
	case KAXXXXP_OUTPUT:
		/* Read status from device. */
		ret = korad_kaxxxxp_send_cmd(serial, "STATUS?");
		break;
	default:
		sr_err("Don't know how to query %d.", devc->target);
		return SR_ERR;
	}

	devc->req_sent_at = g_get_monotonic_time();
	devc->reply_pending = TRUE;

	return ret;
}

SR_PRIV int korad_kaxxxxp_get_all_values(struct sr_serial_dev_inst *serial,
				struct dev_context *devc)
{
	int ret;

	for (devc->target = KAXXXXP_CURRENT;
			devc->target <= KAXXXXP_STATUS; devc->target++) {
		if ((ret = korad_kaxxxxp_query_value(serial, devc)) < 0)
			return ret;
		if ((ret = korad_kaxxxxp_get_reply(serial, devc)) < 0)
			return ret;
	}

	return ret;
}

SR_PRIV int korad_kaxxxxp_get_reply(struct sr_serial_dev_inst *serial,
				struct dev_context *devc)
{
	double value;
	int count, ret;
	float *target;
	char status_byte;

	target = NULL;
	count = 5;

	switch (devc->target) {
	case KAXXXXP_CURRENT:
		/* Read current from device. */
		target = &(devc->current);
		break;
	case KAXXXXP_CURRENT_MAX:
		/* Read set current from device. */
		target = &(devc->current_max);
		break;
	case KAXXXXP_VOLTAGE:
		/* Read voltage from device. */
		target = &(devc->voltage);
		break;
	case KAXXXXP_VOLTAGE_MAX:
		/* Read set voltage from device. */
		target = &(devc->voltage_max);
		break;
	case KAXXXXP_STATUS:
	case KAXXXXP_OUTPUT:
		/* Read status from device. */
		count = 1;
		break;
	default:
		sr_err("Don't know where to put repply %d.", devc->target);
	}

	if ((ret = korad_kaxxxxp_read_chars(serial, count, devc->reply)) < 0)
		return ret;

	devc->reply[count] = 0;

	if (target) {
		value = g_ascii_strtod(devc->reply, NULL);
		*target = (float)value;
		sr_dbg("value: %f",value);
	} else {
		/* We have status reply. */
		status_byte = devc->reply[0];
		/* Constant current */
		devc->cc_mode[0] = !(status_byte & (1 << 0)); /* Channel one */
		devc->cc_mode[1] = !(status_byte & (1 << 1)); /* Channel two */
		/*
		 * Tracking
		 * status_byte & ((1 << 2) | (1 << 3))
		 * 00 independent 01 series 11 parallel
		 */
		devc->beep_enabled = (1 << 4);
		devc->ocp_enabled = (status_byte & (1 << 5));
		devc->output_enabled = (status_byte & (1 << 6));
		/* Velleman LABPS3005 quirk */
		if (devc->output_enabled)
			devc->ovp_enabled = (status_byte & (1 << 7));
		sr_dbg("Status: 0x%02x", status_byte);
		sr_spew("Status: CH1: constant %s CH2: constant %s. "
			"Tracking would be %s. Device is "
			"%s and %s. Buttons are %s. Output is %s "
			"and extra byte is %s.",
			(status_byte & (1 << 0)) ? "voltage" : "current",
			(status_byte & (1 << 1)) ? "voltage" : "current",
			(status_byte & (1 << 2)) ? "parallel" : "series",
			(status_byte & (1 << 3)) ? "tracking" : "independent",
			(status_byte & (1 << 4)) ? "beeping" : "silent",
			(status_byte & (1 << 5)) ? "locked" : "unlocked",
			(status_byte & (1 << 6)) ? "enabled" : "disabled",
			(status_byte & (1 << 7)) ? "true" : "false");
	}
	/* Read the sixth byte from ISET? BUG workaround. */
	if (devc->target == KAXXXXP_CURRENT_MAX)
		serial_read_blocking(serial, &status_byte, 1, 10);
	devc->reply_pending = FALSE;

	return ret;
}

static void next_measurement(struct dev_context *devc)
{
	switch (devc->target) {
	case KAXXXXP_CURRENT:
		devc->target = KAXXXXP_VOLTAGE;
		break;
	case KAXXXXP_CURRENT_MAX:
		devc->target = KAXXXXP_CURRENT;
		break;
	case KAXXXXP_VOLTAGE:
		devc->target = KAXXXXP_STATUS;
		break;
	case KAXXXXP_VOLTAGE_MAX:
		devc->target = KAXXXXP_CURRENT;
		break;
	/* Read back what was set. */
	case KAXXXXP_BEEP:
	case KAXXXXP_OCP:
	case KAXXXXP_OVP:
	case KAXXXXP_OUTPUT:
		devc->target = KAXXXXP_STATUS;
		break;
	case KAXXXXP_STATUS:
		devc->target = KAXXXXP_CURRENT;
		break;
	default:
		devc->target = KAXXXXP_CURRENT;
	}
}

SR_PRIV int korad_kaxxxxp_receive_data(int fd, int revents, void *cb_data)
{
	struct sr_dev_inst *sdi;
	struct dev_context *devc;
	struct sr_serial_dev_inst *serial;
	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;
	uint64_t elapsed_us;
	GSList *l;

	(void)fd;

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

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

	serial = sdi->conn;

	if (revents == G_IO_IN) {
		/* Get the value. */
		korad_kaxxxxp_get_reply(serial, devc);

		/* Note: digits/spec_digits will be overridden later. */
		sr_analog_init(&analog, &encoding, &meaning, &spec, 0);

		/* Send the value forward. */
		packet.type = SR_DF_ANALOG;
		packet.payload = &analog;
		analog.num_samples = 1;
		l = g_slist_copy(sdi->channels);
		if (devc->target == KAXXXXP_CURRENT) {
			l = g_slist_remove_link(l, g_slist_nth(l, 0));
			analog.meaning->channels = l;
			analog.meaning->mq = SR_MQ_CURRENT;
			analog.meaning->unit = SR_UNIT_AMPERE;
			analog.meaning->mqflags = 0;
			analog.encoding->digits = 3;
			analog.spec->spec_digits = 3;
			analog.data = &devc->current;
			sr_session_send(sdi, &packet);
		}
		else if (devc->target == KAXXXXP_VOLTAGE) {
			l = g_slist_remove_link(l, g_slist_nth(l, 1));
			analog.meaning->channels = l;
			analog.meaning->mq = SR_MQ_VOLTAGE;
			analog.meaning->unit = SR_UNIT_VOLT;
			analog.meaning->mqflags = SR_MQFLAG_DC;
			analog.encoding->digits = 2;
			analog.spec->spec_digits = 2;
			analog.data = &devc->voltage;
			sr_session_send(sdi, &packet);
			sr_sw_limits_update_samples_read(&devc->limits, 1);
		}
		next_measurement(devc);
	} else {
		/* Time out */
		if (!devc->reply_pending) {
			if (korad_kaxxxxp_query_value(serial, devc) < 0)
				return TRUE;
			devc->req_sent_at = g_get_monotonic_time();
			devc->reply_pending = TRUE;
		}
	}

	if (sr_sw_limits_check(&devc->limits)) {
		sr_dev_acquisition_stop(sdi);
		return TRUE;
	}

	/* Request next packet, if required. */
	if (sdi->status == SR_ST_ACTIVE) {
		if (devc->reply_pending) {
			elapsed_us = g_get_monotonic_time() - devc->req_sent_at;
			if (elapsed_us > (REQ_TIMEOUT_MS * 1000))
				devc->reply_pending = FALSE;
			return TRUE;
		}

	}

	return TRUE;
}
Commit	Line	Data
	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2015 Hannu Vuolasaho <vuokkosetae@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
	23	#define REQ_TIMEOUT_MS 500
	24	#define DEVICE_PROCESSING_TIME_MS 80
	25
	26	SR_PRIV int korad_kaxxxxp_send_cmd(struct sr_serial_dev_inst *serial,
	27	const char *cmd)
	28	{
	29	int ret;
	30
	31	sr_dbg("Sending '%s'.", cmd);
	32	if ((ret = serial_write_blocking(serial, cmd, strlen(cmd), 0)) < 0) {
	33	sr_err("Error sending command: %d.", ret);
	34	return ret;
	35	}
	36
	37	return ret;
	38	}
	39
	40	SR_PRIV int korad_kaxxxxp_read_chars(struct sr_serial_dev_inst *serial,
	41	int count, char *buf)
	42	{
	43	int ret, received, turns;
	44
	45	received = 0;
	46	turns = 0;
	47
	48	do {
	49	if ((ret = serial_read_blocking(serial, buf + received,
	50	count - received,
	51	serial_timeout(serial, count))) < 0) {
	52	sr_err("Error %d reading %d bytes from device.",
	53	ret, count);
	54	return ret;
	55	}
	56	received += ret;
	57	turns++;
	58	} while ((received < count) && (turns < 100));
	59
	60	buf[count] = 0;
	61
	62	sr_spew("Received: '%s'.", buf);
	63
	64	return ret;
	65	}
	66
	67	static void give_device_time_to_process(struct dev_context *devc)
	68	{
	69	int64_t sleeping_time;
	70
	71	sleeping_time = devc->req_sent_at + (DEVICE_PROCESSING_TIME_MS * 1000);
	72	sleeping_time -= g_get_monotonic_time();
	73
	74	if (sleeping_time > 0) {
	75	g_usleep(sleeping_time);
	76	sr_spew("Sleeping for processing %" PRIi64 " usec", sleeping_time);
	77	}
	78	}
	79
	80	SR_PRIV int korad_kaxxxxp_set_value(struct sr_serial_dev_inst *serial,
	81	struct dev_context *devc)
	82	{
	83	char msg[21];
	84	const char *cmd;
	85	float value;
	86	int ret;
	87
	88	give_device_time_to_process(devc);
	89
	90	msg[20] = 0;
	91	switch (devc->target) {
	92	case KAXXXXP_CURRENT:
	93	case KAXXXXP_VOLTAGE:
	94	case KAXXXXP_STATUS:
	95	sr_err("Can't set measurable parameter.");
	96	return SR_ERR;
	97	case KAXXXXP_CURRENT_MAX:
	98	cmd = "ISET1:%05.3f";
	99	value = devc->current_max;
	100	break;
	101	case KAXXXXP_VOLTAGE_MAX:
	102	cmd = "VSET1:%05.2f";
	103	value = devc->voltage_max;
	104	break;
	105	case KAXXXXP_OUTPUT:
	106	cmd = "OUT%01.0f";
	107	value = (devc->output_enabled) ? 1 : 0;
	108	break;
	109	case KAXXXXP_BEEP:
	110	cmd = "BEEP%01.0f";
	111	value = (devc->beep_enabled) ? 1 : 0;
	112	break;
	113	case KAXXXXP_OCP:
	114	cmd = "OCP%01.0f";
	115	value = (devc->ocp_enabled) ? 1 : 0;
	116	break;
	117	case KAXXXXP_OVP:
	118	cmd = "OVP%01.0f";
	119	value = (devc->ovp_enabled) ? 1 : 0;
	120	break;
	121	case KAXXXXP_SAVE:
	122	cmd = "SAV%01.0f";
	123	if (devc->program < 1 \|\| devc->program > 5) {
	124	sr_err("Only programs 1-5 supported and %d isn't "
	125	"between them.", devc->program);
	126	return SR_ERR;
	127	}
	128	value = devc->program;
	129	break;
	130	case KAXXXXP_RECALL:
	131	cmd = "RCL%01.0f";
	132	if (devc->program < 1 \|\| devc->program > 5) {
	133	sr_err("Only programs 1-5 supported and %d isn't "
	134	"between them.", devc->program);
	135	return SR_ERR;
	136	}
	137	value = devc->program;
	138	break;
	139	default:
	140	sr_err("Don't know how to set %d.", devc->target);
	141	return SR_ERR;
	142	}
	143
	144	if (cmd)
	145	snprintf(msg, 20, cmd, value);
	146
	147	ret = korad_kaxxxxp_send_cmd(serial, msg);
	148	devc->req_sent_at = g_get_monotonic_time();
	149	devc->reply_pending = FALSE;
	150
	151	return ret;
	152	}
	153
	154	SR_PRIV int korad_kaxxxxp_query_value(struct sr_serial_dev_inst *serial,
	155	struct dev_context *devc)
	156	{
	157	int ret;
	158
	159	give_device_time_to_process(devc);
	160
	161	switch (devc->target) {
	162	case KAXXXXP_CURRENT:
	163	/* Read current from device. */
	164	ret = korad_kaxxxxp_send_cmd(serial, "IOUT1?");
	165	break;
	166	case KAXXXXP_CURRENT_MAX:
	167	/* Read set current from device. */
	168	ret = korad_kaxxxxp_send_cmd(serial, "ISET1?");
	169	break;
	170	case KAXXXXP_VOLTAGE:
	171	/* Read voltage from device. */
	172	ret = korad_kaxxxxp_send_cmd(serial, "VOUT1?");
	173	break;
	174	case KAXXXXP_VOLTAGE_MAX:
	175	/* Read set voltage from device. */
	176	ret = korad_kaxxxxp_send_cmd(serial, "VSET1?");
	177	break;
	178	case KAXXXXP_STATUS:
	179	case KAXXXXP_OUTPUT:
	180	/* Read status from device. */
	181	ret = korad_kaxxxxp_send_cmd(serial, "STATUS?");
	182	break;
	183	default:
	184	sr_err("Don't know how to query %d.", devc->target);
	185	return SR_ERR;
	186	}
	187
	188	devc->req_sent_at = g_get_monotonic_time();
	189	devc->reply_pending = TRUE;
	190
	191	return ret;
	192	}
	193
	194	SR_PRIV int korad_kaxxxxp_get_all_values(struct sr_serial_dev_inst *serial,
	195	struct dev_context *devc)
	196	{
	197	int ret;
	198
	199	for (devc->target = KAXXXXP_CURRENT;
	200	devc->target <= KAXXXXP_STATUS; devc->target++) {
	201	if ((ret = korad_kaxxxxp_query_value(serial, devc)) < 0)
	202	return ret;
	203	if ((ret = korad_kaxxxxp_get_reply(serial, devc)) < 0)
	204	return ret;
	205	}
	206
	207	return ret;
	208	}
	209
	210	SR_PRIV int korad_kaxxxxp_get_reply(struct sr_serial_dev_inst *serial,
	211	struct dev_context *devc)
	212	{
	213	double value;
	214	int count, ret;
	215	float *target;
	216	char status_byte;
	217
	218	target = NULL;
	219	count = 5;
	220
	221	switch (devc->target) {
	222	case KAXXXXP_CURRENT:
	223	/* Read current from device. */
	224	target = &(devc->current);
	225	break;
	226	case KAXXXXP_CURRENT_MAX:
	227	/* Read set current from device. */
	228	target = &(devc->current_max);
	229	break;
	230	case KAXXXXP_VOLTAGE:
	231	/* Read voltage from device. */
	232	target = &(devc->voltage);
	233	break;
	234	case KAXXXXP_VOLTAGE_MAX:
	235	/* Read set voltage from device. */
	236	target = &(devc->voltage_max);
	237	break;
	238	case KAXXXXP_STATUS:
	239	case KAXXXXP_OUTPUT:
	240	/* Read status from device. */
	241	count = 1;
	242	break;
	243	default:
	244	sr_err("Don't know where to put repply %d.", devc->target);
	245	}
	246
	247	if ((ret = korad_kaxxxxp_read_chars(serial, count, devc->reply)) < 0)
	248	return ret;
	249
	250	devc->reply[count] = 0;
	251
	252	if (target) {
	253	value = g_ascii_strtod(devc->reply, NULL);
	254	*target = (float)value;
	255	sr_dbg("value: %f",value);
	256	} else {
	257	/* We have status reply. */
	258	status_byte = devc->reply[0];
	259	/* Constant current */
	260	devc->cc_mode[0] = !(status_byte & (1 << 0)); /* Channel one */
	261	devc->cc_mode[1] = !(status_byte & (1 << 1)); /* Channel two */
	262	/*
	263	* Tracking
	264	* status_byte & ((1 << 2) \| (1 << 3))
	265	* 00 independent 01 series 11 parallel
	266	*/
	267	devc->beep_enabled = (1 << 4);
	268	devc->ocp_enabled = (status_byte & (1 << 5));
	269	devc->output_enabled = (status_byte & (1 << 6));
	270	/* Velleman LABPS3005 quirk */
	271	if (devc->output_enabled)
	272	devc->ovp_enabled = (status_byte & (1 << 7));
	273	sr_dbg("Status: 0x%02x", status_byte);
	274	sr_spew("Status: CH1: constant %s CH2: constant %s. "
	275	"Tracking would be %s. Device is "
	276	"%s and %s. Buttons are %s. Output is %s "
	277	"and extra byte is %s.",
	278	(status_byte & (1 << 0)) ? "voltage" : "current",
	279	(status_byte & (1 << 1)) ? "voltage" : "current",
	280	(status_byte & (1 << 2)) ? "parallel" : "series",
	281	(status_byte & (1 << 3)) ? "tracking" : "independent",
	282	(status_byte & (1 << 4)) ? "beeping" : "silent",
	283	(status_byte & (1 << 5)) ? "locked" : "unlocked",
	284	(status_byte & (1 << 6)) ? "enabled" : "disabled",
	285	(status_byte & (1 << 7)) ? "true" : "false");
	286	}
	287	/* Read the sixth byte from ISET? BUG workaround. */
	288	if (devc->target == KAXXXXP_CURRENT_MAX)
	289	serial_read_blocking(serial, &status_byte, 1, 10);
	290	devc->reply_pending = FALSE;
	291
	292	return ret;
	293	}
	294
	295	static void next_measurement(struct dev_context *devc)
	296	{
	297	switch (devc->target) {
	298	case KAXXXXP_CURRENT:
	299	devc->target = KAXXXXP_VOLTAGE;
	300	break;
	301	case KAXXXXP_CURRENT_MAX:
	302	devc->target = KAXXXXP_CURRENT;
	303	break;
	304	case KAXXXXP_VOLTAGE:
	305	devc->target = KAXXXXP_STATUS;
	306	break;
	307	case KAXXXXP_VOLTAGE_MAX:
	308	devc->target = KAXXXXP_CURRENT;
	309	break;
	310	/* Read back what was set. */
	311	case KAXXXXP_BEEP:
	312	case KAXXXXP_OCP:
	313	case KAXXXXP_OVP:
	314	case KAXXXXP_OUTPUT:
	315	devc->target = KAXXXXP_STATUS;
	316	break;
	317	case KAXXXXP_STATUS:
	318	devc->target = KAXXXXP_CURRENT;
	319	break;
	320	default:
	321	devc->target = KAXXXXP_CURRENT;
	322	}
	323	}
	324
	325	SR_PRIV int korad_kaxxxxp_receive_data(int fd, int revents, void *cb_data)
	326	{
	327	struct sr_dev_inst *sdi;
	328	struct dev_context *devc;
	329	struct sr_serial_dev_inst *serial;
	330	struct sr_datafeed_packet packet;
	331	struct sr_datafeed_analog analog;
	332	struct sr_analog_encoding encoding;
	333	struct sr_analog_meaning meaning;
	334	struct sr_analog_spec spec;
	335	uint64_t elapsed_us;
	336	GSList *l;
	337
	338	(void)fd;
	339
	340	if (!(sdi = cb_data))
	341	return TRUE;
	342
	343	if (!(devc = sdi->priv))
	344	return TRUE;
	345
	346	serial = sdi->conn;
	347
	348	if (revents == G_IO_IN) {
	349	/* Get the value. */
	350	korad_kaxxxxp_get_reply(serial, devc);
	351
	352	/* Note: digits/spec_digits will be overridden later. */
	353	sr_analog_init(&analog, &encoding, &meaning, &spec, 0);
	354
	355	/* Send the value forward. */
	356	packet.type = SR_DF_ANALOG;
	357	packet.payload = &analog;
	358	analog.num_samples = 1;
	359	l = g_slist_copy(sdi->channels);
	360	if (devc->target == KAXXXXP_CURRENT) {
	361	l = g_slist_remove_link(l, g_slist_nth(l, 0));
	362	analog.meaning->channels = l;
	363	analog.meaning->mq = SR_MQ_CURRENT;
	364	analog.meaning->unit = SR_UNIT_AMPERE;
	365	analog.meaning->mqflags = 0;
	366	analog.encoding->digits = 3;
	367	analog.spec->spec_digits = 3;
	368	analog.data = &devc->current;
	369	sr_session_send(sdi, &packet);
	370	}
	371	else if (devc->target == KAXXXXP_VOLTAGE) {
	372	l = g_slist_remove_link(l, g_slist_nth(l, 1));
	373	analog.meaning->channels = l;
	374	analog.meaning->mq = SR_MQ_VOLTAGE;
	375	analog.meaning->unit = SR_UNIT_VOLT;
	376	analog.meaning->mqflags = SR_MQFLAG_DC;
	377	analog.encoding->digits = 2;
	378	analog.spec->spec_digits = 2;
	379	analog.data = &devc->voltage;
	380	sr_session_send(sdi, &packet);
	381	sr_sw_limits_update_samples_read(&devc->limits, 1);
	382	}
	383	next_measurement(devc);
	384	} else {
	385	/* Time out */
	386	if (!devc->reply_pending) {
	387	if (korad_kaxxxxp_query_value(serial, devc) < 0)
	388	return TRUE;
	389	devc->req_sent_at = g_get_monotonic_time();
	390	devc->reply_pending = TRUE;
	391	}
	392	}
	393
	394	if (sr_sw_limits_check(&devc->limits)) {
	395	sr_dev_acquisition_stop(sdi);
	396	return TRUE;
	397	}
	398
	399	/* Request next packet, if required. */
	400	if (sdi->status == SR_ST_ACTIVE) {
	401	if (devc->reply_pending) {
	402	elapsed_us = g_get_monotonic_time() - devc->req_sent_at;
	403	if (elapsed_us > (REQ_TIMEOUT_MS * 1000))
	404	devc->reply_pending = FALSE;
	405	return TRUE;
	406	}
	407
	408	}
	409
	410	return TRUE;
	411	}