[libsigrok.git] / src / hardware / korad-kdxxxxp / 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_kdxxxxp_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_kdxxxxp_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_kdxxxxp_set_value(struct sr_serial_dev_inst *serial,
				struct dev_context *devc)
{
	char msg[21], *cmd;
	float value;
	int ret;

	give_device_time_to_process(devc);

	msg[20] = 0;
	switch(devc->target){
	case KDXXXXP_CURRENT:
	case KDXXXXP_VOLTAGE:
	case KDXXXXP_STATUS:
		sr_err("Can't set measurable parameter.");
		return SR_ERR;
	case KDXXXXP_CURRENT_MAX:
		cmd = "ISET1:%05.3f";
		value = devc->current_max;
		break;
	case KDXXXXP_VOLTAGE_MAX:
		cmd = "VSET1:%05.2f";
		value = devc->voltage_max;
		break;
	case KDXXXXP_OUTPUT:
		cmd = "OUT%01.0f";
		value = (devc->output_enabled) ? 1 : 0;
		break;
	case KDXXXXP_BEEP:
		cmd = "BEEP%01.0f";
		value = (devc->beep_enabled) ? 1 : 0;
		break;
	case KDXXXXP_OCP:
		cmd = "OCP%01.0f";
		value = (devc->OCP_enabled) ? 1 : 0;
		break;
	case KDXXXXP_OVP:
		cmd = "OVP%01.0f";
		value = (devc->OVP_enabled) ? 1 : 0;
		break;
	case KDXXXXP_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 KDXXXXP_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_kdxxxxp_send_cmd(serial, msg);
	devc->req_sent_at = g_get_monotonic_time();
	devc->reply_pending = FALSE;

	return ret;
}

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

	give_device_time_to_process(devc);

	switch(devc->target){
	case KDXXXXP_CURRENT:
		/* Read current from device. */
		ret = korad_kdxxxxp_send_cmd(serial, "IOUT1?");
		break;
	case KDXXXXP_CURRENT_MAX:
		/* Read set current from device. */
		ret = korad_kdxxxxp_send_cmd(serial, "ISET1?");
		break;
	case KDXXXXP_VOLTAGE:
		/* Read voltage from device. */
		ret = korad_kdxxxxp_send_cmd(serial, "VOUT1?");
		break;
	case KDXXXXP_VOLTAGE_MAX:
		/* Read set voltage from device. */
		ret = korad_kdxxxxp_send_cmd(serial, "VSET1?");
		break;
	case KDXXXXP_STATUS:
	case KDXXXXP_OUTPUT:
		/* Read status from device. */
		ret = korad_kdxxxxp_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_kdxxxxp_get_all_values(struct sr_serial_dev_inst *serial,
				struct dev_context *devc)
{
	int ret;

	for (devc->target = KDXXXXP_CURRENT;
			devc->target <= KDXXXXP_STATUS; devc->target++) {
		if ((ret = korad_kdxxxxp_query_value(serial, devc)) < 0)
			return ret;
		if ((ret = korad_kdxxxxp_get_reply(serial, devc)) < 0)
			return ret;
	}

	return ret;
}

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

	target = NULL;
	count = 5;

	switch (devc->target) {
	case KDXXXXP_CURRENT:
		/* Read current from device. */
		target = &(devc->current);
		break;
	case KDXXXXP_CURRENT_MAX:
		/* Read set current from device. */
		target = &(devc->current_max);
		break;
	case KDXXXXP_VOLTAGE:
		/* Read voltage from device. */
		target = &(devc->voltage);
		break;
	case KDXXXXP_VOLTAGE_MAX:
		/* Read set voltage from device. */
		target = &(devc->voltage_max);
		break;
	case KDXXXXP_STATUS:
	case KDXXXXP_OUTPUT:
		/* Read status from device. */
		count = 1;
		break;
	default:
		sr_err("Don't know where to put repply %d.", devc->target);
	}

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

	devc->reply[count] = 0;

	if (target) {
		/* Handle the strange 'M' */
		if (devc->reply[0] == 'M') {
			for (i = 1; i < count; ++i) {
				devc->reply[i - 1] = devc->reply[i];
			}
			/* Get the last character */
			if (( i = korad_kdxxxxp_read_chars(serial, 1,
						&(devc->reply[count]))) < 0)
				return i;
		}
		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");
	}

	devc->reply_pending = FALSE;

	return ret;
}

static void next_measurement(struct dev_context *devc)
{
	switch (devc->target) {
	case KDXXXXP_CURRENT:
		devc->target = KDXXXXP_VOLTAGE;
		break;
	case KDXXXXP_CURRENT_MAX:
		devc->target = KDXXXXP_CURRENT;
		break;
	case KDXXXXP_VOLTAGE:
		devc->target = KDXXXXP_STATUS;
		break;
	case KDXXXXP_VOLTAGE_MAX:
		devc->target = KDXXXXP_CURRENT;
		break;
	/* Read back what was set */
	case KDXXXXP_BEEP:
	case KDXXXXP_OCP:
	case KDXXXXP_OVP:
	case KDXXXXP_OUTPUT:
		devc->target = KDXXXXP_STATUS;
		break;
	case KDXXXXP_STATUS:
		devc->target = KDXXXXP_CURRENT;
		break;
	default:
		devc->target = KDXXXXP_CURRENT;
	}
}

SR_PRIV int korad_kdxxxxp_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_old analog;
	int64_t t, elapsed_us;

	(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_kdxxxxp_get_reply(serial, devc);

		/* Send the value forward. */
		packet.type = SR_DF_ANALOG_OLD;
		packet.payload = &analog;
		analog.channels = sdi->channels;
		analog.num_samples = 1;
		if (devc->target == KDXXXXP_CURRENT) {
			analog.mq = SR_MQ_CURRENT;
			analog.unit = SR_UNIT_AMPERE;
			analog.mqflags = 0;
			analog.data = &devc->current;
			sr_session_send(sdi, &packet);
		}
		if (devc->target == KDXXXXP_VOLTAGE) {
			analog.mq = SR_MQ_VOLTAGE;
			analog.unit = SR_UNIT_VOLT;
			analog.mqflags = SR_MQFLAG_DC;
			analog.data = &devc->voltage;
			sr_session_send(sdi, &packet);
			devc->num_samples++;
		}
		next_measurement(devc);
	} else {
		/* Time out */
		if (!devc->reply_pending) {
			if (korad_kdxxxxp_query_value(serial, devc) < 0)
				return TRUE;
			devc->req_sent_at = g_get_monotonic_time();
			devc->reply_pending = TRUE;
		}
	}

	if (devc->limit_samples && (devc->num_samples >= devc->limit_samples)) {
		sr_info("Requested number of samples reached.");
		sdi->driver->dev_acquisition_stop(sdi, cb_data);
		return TRUE;
	}

	if (devc->limit_msec) {
		t = (g_get_monotonic_time() - devc->starttime) / 1000;
		if (t > (int64_t)devc->limit_msec) {
			sr_info("Requested time limit reached.");
			sdi->driver->dev_acquisition_stop(sdi, cb_data);
			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
e75ee7de HV	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
d7083042 HV	23	#define REQ_TIMEOUT_MS 500
	24	#define DEVICE_PROCESSING_TIME_MS 80
	25
	26	SR_PRIV int korad_kdxxxxp_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_kdxxxxp_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);
ef2bcf11	76	sr_spew("Sleeping for processing %" PRIi64 " usec", sleeping_time);
d7083042 HV	77	}
	78	}
	79
	80	SR_PRIV int korad_kdxxxxp_set_value(struct sr_serial_dev_inst *serial,
	81	struct dev_context *devc)
	82	{
	83	char msg[21], *cmd;
	84	float value;
	85	int ret;
	86
	87	give_device_time_to_process(devc);
	88
	89	msg[20] = 0;
	90	switch(devc->target){
	91	case KDXXXXP_CURRENT:
	92	case KDXXXXP_VOLTAGE:
	93	case KDXXXXP_STATUS:
	94	sr_err("Can't set measurable parameter.");
	95	return SR_ERR;
	96	case KDXXXXP_CURRENT_MAX:
	97	cmd = "ISET1:%05.3f";
	98	value = devc->current_max;
	99	break;
	100	case KDXXXXP_VOLTAGE_MAX:
	101	cmd = "VSET1:%05.2f";
	102	value = devc->voltage_max;
	103	break;
	104	case KDXXXXP_OUTPUT:
	105	cmd = "OUT%01.0f";
	106	value = (devc->output_enabled) ? 1 : 0;
	107	break;
	108	case KDXXXXP_BEEP:
	109	cmd = "BEEP%01.0f";
	110	value = (devc->beep_enabled) ? 1 : 0;
	111	break;
c40ed60f HV	112	case KDXXXXP_OCP:
	113	cmd = "OCP%01.0f";
	114	value = (devc->OCP_enabled) ? 1 : 0;
	115	break;
	116	case KDXXXXP_OVP:
	117	cmd = "OVP%01.0f";
	118	value = (devc->OVP_enabled) ? 1 : 0;
	119	break;
d7083042 HV	120	case KDXXXXP_SAVE:
	121	cmd = "SAV%01.0f";
	122	if (devc->program < 1 \|\| devc->program > 5) {
	123	sr_err("Only programs 1-5 supported and %d isn't "
	124	"between them.", devc->program);
	125	return SR_ERR;
	126	}
	127	value = devc->program;
	128	break;
	129	case KDXXXXP_RECALL:
	130	cmd = "RCL%01.0f";
	131	if (devc->program < 1 \|\| devc->program > 5) {
	132	sr_err("Only programs 1-5 supported and %d isn't "
	133	"between them.", devc->program);
	134	return SR_ERR;
	135	}
	136	value = devc->program;
	137	break;
	138	default:
	139	sr_err("Don't know how to set %d.", devc->target);
	140	return SR_ERR;
	141	}
	142
	143	if (cmd)
	144	snprintf(msg, 20, cmd, value);
	145
	146	ret = korad_kdxxxxp_send_cmd(serial, msg);
	147	devc->req_sent_at = g_get_monotonic_time();
	148	devc->reply_pending = FALSE;
	149
	150	return ret;
	151	}
	152
	153	SR_PRIV int korad_kdxxxxp_query_value(struct sr_serial_dev_inst *serial,
	154	struct dev_context *devc)
	155	{
	156	int ret;
	157
	158	give_device_time_to_process(devc);
	159
	160	switch(devc->target){
	161	case KDXXXXP_CURRENT:
	162	/* Read current from device. */
	163	ret = korad_kdxxxxp_send_cmd(serial, "IOUT1?");
	164	break;
	165	case KDXXXXP_CURRENT_MAX:
	166	/* Read set current from device. */
	167	ret = korad_kdxxxxp_send_cmd(serial, "ISET1?");
	168	break;
	169	case KDXXXXP_VOLTAGE:
	170	/* Read voltage from device. */
	171	ret = korad_kdxxxxp_send_cmd(serial, "VOUT1?");
	172	break;
	173	case KDXXXXP_VOLTAGE_MAX:
	174	/* Read set voltage from device. */
	175	ret = korad_kdxxxxp_send_cmd(serial, "VSET1?");
	176	break;
	177	case KDXXXXP_STATUS:
	178	case KDXXXXP_OUTPUT:
	179	/* Read status from device. */
	180	ret = korad_kdxxxxp_send_cmd(serial, "STATUS?");
	181	break;
	182	default:
	183	sr_err("Don't know how to query %d.", devc->target);
184	return SR_ERR;
185	}
186
187	devc->req_sent_at = g_get_monotonic_time();
188	devc->reply_pending = TRUE;
189
190	return ret;
191	}
192
193	SR_PRIV int korad_kdxxxxp_get_all_values(struct sr_serial_dev_inst *serial,
194	struct dev_context *devc)
195	{
196	int ret;
197
198	for (devc->target = KDXXXXP_CURRENT;
199	devc->target <= KDXXXXP_STATUS; devc->target++) {
200	if ((ret = korad_kdxxxxp_query_value(serial, devc)) < 0)
201	return ret;
202	if ((ret = korad_kdxxxxp_get_reply(serial, devc)) < 0)
203	return ret;
204	}
205
206	return ret;
207	}
208
209	SR_PRIV int korad_kdxxxxp_get_reply(struct sr_serial_dev_inst *serial,
210	struct dev_context *devc)
211	{
212	double value;
b16d975a	213	int count, ret, i;
d7083042 HV	214	float *target;
	215	char status_byte;
	216
	217	target = NULL;
	218	count = 5;
	219
	220	switch (devc->target) {
	221	case KDXXXXP_CURRENT:
	222	/* Read current from device. */
	223	target = &(devc->current);
	224	break;
	225	case KDXXXXP_CURRENT_MAX:
	226	/* Read set current from device. */
	227	target = &(devc->current_max);
	228	break;
	229	case KDXXXXP_VOLTAGE:
	230	/* Read voltage from device. */
	231	target = &(devc->voltage);
	232	break;
	233	case KDXXXXP_VOLTAGE_MAX:
	234	/* Read set voltage from device. */
	235	target = &(devc->voltage_max);
	236	break;
	237	case KDXXXXP_STATUS:
	238	case KDXXXXP_OUTPUT:
	239	/* Read status from device. */
	240	count = 1;
	241	break;
	242	default:
	243	sr_err("Don't know where to put repply %d.", devc->target);
	244	}
	245
	246	if ((ret = korad_kdxxxxp_read_chars(serial, count, devc->reply)) < 0)
	247	return ret;
	248
	249	devc->reply[count] = 0;
	250
	251	if (target) {
b16d975a HV	252	/* Handle the strange 'M' */
	253	if (devc->reply[0] == 'M') {
	254	for (i = 1; i < count; ++i) {
	255	devc->reply[i - 1] = devc->reply[i];
	256	}
	257	/* Get the last character */
	258	if (( i = korad_kdxxxxp_read_chars(serial, 1,
	259	&(devc->reply[count]))) < 0)
	260	return i;
	261	}
d7083042 HV	262	value = g_ascii_strtod(devc->reply, NULL);
	263	*target = (float)value;
	264	sr_dbg("value: %f",value);
	265	} else {
	266	/* We have status reply. */
	267	status_byte = devc->reply[0];
	268	/* Constant current */
	269	devc->cc_mode[0] = !(status_byte & (1 << 0)); /* Channel one */
	270	devc->cc_mode[1] = !(status_byte & (1 << 1)); /* Channel two */
	271	/*
	272	* Tracking
	273	* status_byte & ((1 << 2) \| (1 << 3))
	274	* 00 independent 01 series 11 parallel
	275	*/
	276	devc->beep_enabled = (1 << 4);
c40ed60f	277	devc->OCP_enabled = (status_byte & (1 << 5));
d7083042	278	devc->output_enabled = (status_byte & (1 << 6));
c40ed60f HV	279	/* Velleman LABPS3005 quirk */
	280	if (devc->output_enabled)
	281	devc->OVP_enabled = (status_byte & (1 << 7));
d7083042	282	sr_dbg("Status: 0x%02x", status_byte);
c40ed60f HV	283	sr_spew("Status: CH1: constant %s CH2: constant %s. "
	284	"Tracking would be %s. Device is "
	285	"%s and %s. Buttons are %s. Output is %s "
	286	"and extra byte is %s.",
d7083042 HV	287	(status_byte & (1 << 0)) ? "voltage" : "current",
d7083042 HV	288	(status_byte & (1 << 1)) ? "voltage" : "current",
c40ed60f	289	(status_byte & (1 << 2)) ? "parallel" : "series",
d7083042 HV	290	(status_byte & (1 << 3)) ? "tracking" : "independent",
	291	(status_byte & (1 << 4)) ? "beeping" : "silent",
	292	(status_byte & (1 << 5)) ? "locked" : "unlocked",
c40ed60f HV	293	(status_byte & (1 << 6)) ? "enabled" : "disabled",
c40ed60f HV	294	(status_byte & (1 << 7)) ? "true" : "false");
d7083042 HV	295	}
	296
	297	devc->reply_pending = FALSE;
	298
	299	return ret;
	300	}
	301
	302	static void next_measurement(struct dev_context *devc)
	303	{
	304	switch (devc->target) {
	305	case KDXXXXP_CURRENT:
	306	devc->target = KDXXXXP_VOLTAGE;
	307	break;
	308	case KDXXXXP_CURRENT_MAX:
	309	devc->target = KDXXXXP_CURRENT;
	310	break;
	311	case KDXXXXP_VOLTAGE:
	312	devc->target = KDXXXXP_STATUS;
	313	break;
	314	case KDXXXXP_VOLTAGE_MAX:
	315	devc->target = KDXXXXP_CURRENT;
	316	break;
c40ed60f HV	317	/* Read back what was set */
	318	case KDXXXXP_BEEP:
	319	case KDXXXXP_OCP:
	320	case KDXXXXP_OVP:
d7083042 HV	321	case KDXXXXP_OUTPUT:
	322	devc->target = KDXXXXP_STATUS;
	323	break;
	324	case KDXXXXP_STATUS:
	325	devc->target = KDXXXXP_CURRENT;
	326	break;
	327	default:
	328	devc->target = KDXXXXP_CURRENT;
	329	}
	330	}
	331
e75ee7de HV	332	SR_PRIV int korad_kdxxxxp_receive_data(int fd, int revents, void *cb_data)
e75ee7de HV	333	{
d7083042	334	struct sr_dev_inst *sdi;
e75ee7de	335	struct dev_context *devc;
d7083042 HV	336	struct sr_serial_dev_inst *serial;
d7083042 HV	337	struct sr_datafeed_packet packet;
5faebab2	338	struct sr_datafeed_analog_old analog;
d7083042	339	int64_t t, elapsed_us;
e75ee7de HV	340
	341	(void)fd;
	342
	343	if (!(sdi = cb_data))
	344	return TRUE;
	345
	346	if (!(devc = sdi->priv))
	347	return TRUE;
	348
d7083042 HV	349	serial = sdi->conn;
d7083042 HV	350
e75ee7de	351	if (revents == G_IO_IN) {
d7083042 HV	352	/* Get the value. */
	353	korad_kdxxxxp_get_reply(serial, devc);
	354
	355	/* Send the value forward. */
5faebab2	356	packet.type = SR_DF_ANALOG_OLD;
d7083042 HV	357	packet.payload = &analog;
	358	analog.channels = sdi->channels;
	359	analog.num_samples = 1;
	360	if (devc->target == KDXXXXP_CURRENT) {
	361	analog.mq = SR_MQ_CURRENT;
	362	analog.unit = SR_UNIT_AMPERE;
	363	analog.mqflags = 0;
	364	analog.data = &devc->current;
	365	sr_session_send(sdi, &packet);
	366	}
	367	if (devc->target == KDXXXXP_VOLTAGE) {
	368	analog.mq = SR_MQ_VOLTAGE;
	369	analog.unit = SR_UNIT_VOLT;
	370	analog.mqflags = SR_MQFLAG_DC;
	371	analog.data = &devc->voltage;
	372	sr_session_send(sdi, &packet);
	373	devc->num_samples++;
	374	}
	375	next_measurement(devc);
	376	} else {
	377	/* Time out */
	378	if (!devc->reply_pending) {
	379	if (korad_kdxxxxp_query_value(serial, devc) < 0)
	380	return TRUE;
	381	devc->req_sent_at = g_get_monotonic_time();
	382	devc->reply_pending = TRUE;
	383	}
	384	}
	385
	386	if (devc->limit_samples && (devc->num_samples >= devc->limit_samples)) {
	387	sr_info("Requested number of samples reached.");
	388	sdi->driver->dev_acquisition_stop(sdi, cb_data);
	389	return TRUE;
	390	}
	391
	392	if (devc->limit_msec) {
	393	t = (g_get_monotonic_time() - devc->starttime) / 1000;
	394	if (t > (int64_t)devc->limit_msec) {
	395	sr_info("Requested time limit reached.");
	396	sdi->driver->dev_acquisition_stop(sdi, cb_data);
	397	return TRUE;
	398	}
	399	}
	400
	401	/* Request next packet, if required. */
	402	if (sdi->status == SR_ST_ACTIVE) {
	403	if (devc->reply_pending) {
	404	elapsed_us = g_get_monotonic_time() - devc->req_sent_at;
	405	if (elapsed_us > (REQ_TIMEOUT_MS * 1000))
	406	devc->reply_pending = FALSE;
	407	return TRUE;
	408	}
	409
e75ee7de HV	410	}
	411
	412	return TRUE;
	413	}