X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fhardware%2Fkorad-kaxxxxp%2Fprotocol.c;h=bcda463379f4d2030ba9a9e5c05f68ab2c77da45;hb=8da30037cf8cf0fedb8e87cba9ca56189ed7df5f;hp=c01d3ca636089ba4b846e4703f16ddf224fdc524;hpb=16fc7ee29ffa196d29a20fddd81234792f88b12c;p=libsigrok.git

diff --git a/src/hardware/korad-kaxxxxp/protocol.c b/src/hardware/korad-kaxxxxp/protocol.c
index c01d3ca6..bcda4633 100644
--- a/src/hardware/korad-kaxxxxp/protocol.c
+++ b/src/hardware/korad-kaxxxxp/protocol.c
@@ -2,6 +2,7 @@
  * This file is part of the libsigrok project.
  *
  * Copyright (C) 2015 Hannu Vuolasaho <vuokkosetae@gmail.com>
+ * Copyright (C) 2018 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
@@ -78,51 +79,59 @@ static void give_device_time_to_process(struct dev_context *devc)
 }
 
 SR_PRIV int korad_kaxxxxp_set_value(struct sr_serial_dev_inst *serial,
-				struct dev_context *devc)
+				int target, struct dev_context *devc)
 {
-	char msg[21];
+	char *msg;
 	const char *cmd;
 	float value;
 	int ret;
 
+	g_mutex_lock(&devc->rw_mutex);
 	give_device_time_to_process(devc);
 
-	msg[20] = 0;
-	switch(devc->target){
+	switch (target) {
 	case KAXXXXP_CURRENT:
 	case KAXXXXP_VOLTAGE:
 	case KAXXXXP_STATUS:
-		sr_err("Can't set measurable parameter.");
+		sr_err("Can't set measurable parameter %d.", target);
+		g_mutex_unlock(&devc->rw_mutex);
 		return SR_ERR;
-	case KAXXXXP_CURRENT_MAX:
+	case KAXXXXP_CURRENT_LIMIT:
 		cmd = "ISET1:%05.3f";
-		value = devc->current_max;
+		value = devc->set_current_limit;
 		break;
-	case KAXXXXP_VOLTAGE_MAX:
+	case KAXXXXP_VOLTAGE_TARGET:
 		cmd = "VSET1:%05.2f";
-		value = devc->voltage_max;
+		value = devc->set_voltage_target;
 		break;
 	case KAXXXXP_OUTPUT:
 		cmd = "OUT%01.0f";
-		value = (devc->output_enabled) ? 1 : 0;
+		value = (devc->set_output_enabled) ? 1 : 0;
+		/* Set value back to recognize changes */
+		devc->output_enabled = devc->set_output_enabled;
 		break;
 	case KAXXXXP_BEEP:
 		cmd = "BEEP%01.0f";
-		value = (devc->beep_enabled) ? 1 : 0;
+		value = (devc->set_beep_enabled) ? 1 : 0;
 		break;
 	case KAXXXXP_OCP:
 		cmd = "OCP%01.0f";
-		value = (devc->ocp_enabled) ? 1 : 0;
+		value = (devc->set_ocp_enabled) ? 1 : 0;
+		/* Set value back to recognize changes */
+		devc->ocp_enabled = devc->set_ocp_enabled;
 		break;
 	case KAXXXXP_OVP:
 		cmd = "OVP%01.0f";
-		value = (devc->ovp_enabled) ? 1 : 0;
+		value = (devc->set_ovp_enabled) ? 1 : 0;
+		/* Set value back to recognize changes */
+		devc->ovp_enabled = devc->set_ovp_enabled;
 		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);
+			g_mutex_unlock(&devc->rw_mutex);
 			return SR_ERR;
 		}
 		value = devc->program;
@@ -132,139 +141,94 @@ SR_PRIV int korad_kaxxxxp_set_value(struct sr_serial_dev_inst *serial,
 		if (devc->program < 1 || devc->program > 5) {
 			sr_err("Only programs 1-5 supported and %d isn't "
 			       "between them.", devc->program);
+			g_mutex_unlock(&devc->rw_mutex);
 			return SR_ERR;
 		}
 		value = devc->program;
 		break;
 	default:
-		sr_err("Don't know how to set %d.", devc->target);
+		sr_err("Don't know how to set %d.", target);
+		g_mutex_unlock(&devc->rw_mutex);
 		return SR_ERR;
 	}
 
+	msg = g_malloc0(20 + 1);
 	if (cmd)
-		snprintf(msg, 20, cmd, value);
+		sr_snprintf_ascii(msg, 20, cmd, value);
 
 	ret = korad_kaxxxxp_send_cmd(serial, msg);
 	devc->req_sent_at = g_get_monotonic_time();
-	devc->reply_pending = FALSE;
+	g_free(msg);
+
+	g_mutex_unlock(&devc->rw_mutex);
 
 	return ret;
 }
 
-SR_PRIV int korad_kaxxxxp_query_value(struct sr_serial_dev_inst *serial,
-				struct dev_context *devc)
+SR_PRIV int korad_kaxxxxp_get_value(struct sr_serial_dev_inst *serial,
+				int target, struct dev_context *devc)
 {
-	int ret;
+	int ret, count;
+	char reply[6];
+	float *value;
+	char status_byte;
 
+	g_mutex_lock(&devc->rw_mutex);
 	give_device_time_to_process(devc);
 
-	switch(devc->target){
+	value = NULL;
+	count = 5;
+
+	switch (target) {
 	case KAXXXXP_CURRENT:
 		/* Read current from device. */
 		ret = korad_kaxxxxp_send_cmd(serial, "IOUT1?");
+		value = &(devc->current);
 		break;
-	case KAXXXXP_CURRENT_MAX:
+	case KAXXXXP_CURRENT_LIMIT:
 		/* Read set current from device. */
 		ret = korad_kaxxxxp_send_cmd(serial, "ISET1?");
+		value = &(devc->current_limit);
 		break;
 	case KAXXXXP_VOLTAGE:
 		/* Read voltage from device. */
 		ret = korad_kaxxxxp_send_cmd(serial, "VOUT1?");
+		value = &(devc->voltage);
 		break;
-	case KAXXXXP_VOLTAGE_MAX:
+	case KAXXXXP_VOLTAGE_TARGET:
 		/* Read set voltage from device. */
 		ret = korad_kaxxxxp_send_cmd(serial, "VSET1?");
+		value = &(devc->voltage_target);
 		break;
 	case KAXXXXP_STATUS:
 	case KAXXXXP_OUTPUT:
+	case KAXXXXP_OCP:
+	case KAXXXXP_OVP:
 		/* Read status from device. */
 		ret = korad_kaxxxxp_send_cmd(serial, "STATUS?");
+		count = 1;
 		break;
 	default:
-		sr_err("Don't know how to query %d.", devc->target);
+		sr_err("Don't know how to query %d.", target);
+		g_mutex_unlock(&devc->rw_mutex);
 		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, i;
-	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, reply)) < 0) {
+		g_mutex_unlock(&devc->rw_mutex);
+		return ret;
 	}
 
-	if ((ret = korad_kaxxxxp_read_chars(serial, count, devc->reply)) < 0)
-		return ret;
+	reply[count] = 0;
 
-	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_kaxxxxp_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);
+	if (value) {
+		sr_atof_ascii((const char *)&reply, value);
+		sr_dbg("value: %f", *value);
 	} else {
 		/* We have status reply. */
-		status_byte = devc->reply[0];
+		status_byte = reply[0];
 		/* Constant current */
 		devc->cc_mode[0] = !(status_byte & (1 << 0)); /* Channel one */
 		devc->cc_mode[1] = !(status_byte & (1 << 1)); /* Channel two */
@@ -283,7 +247,7 @@ SR_PRIV int korad_kaxxxxp_get_reply(struct sr_serial_dev_inst *serial,
 		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.",
+			"and extra bit is %s.",
 			(status_byte & (1 << 0)) ? "voltage" : "current",
 			(status_byte & (1 << 1)) ? "voltage" : "current",
 			(status_byte & (1 << 2)) ? "parallel" : "series",
@@ -294,38 +258,44 @@ SR_PRIV int korad_kaxxxxp_get_reply(struct sr_serial_dev_inst *serial,
 			(status_byte & (1 << 7)) ? "true" : "false");
 	}
 
-	devc->reply_pending = FALSE;
+	/* Read the sixth byte from ISET? BUG workaround. */
+	if (target == KAXXXXP_CURRENT_LIMIT)
+		serial_read_blocking(serial, &status_byte, 1, 10);
+
+	g_mutex_unlock(&devc->rw_mutex);
+
+	return ret;
+}
+
+SR_PRIV int korad_kaxxxxp_get_all_values(struct sr_serial_dev_inst *serial,
+				struct dev_context *devc)
+{
+	int ret, target;
+
+	for (target = KAXXXXP_CURRENT;
+			target <= KAXXXXP_STATUS; target++) {
+		if ((ret = korad_kaxxxxp_get_value(serial, target, devc)) < 0)
+			return ret;
+	}
 
 	return ret;
 }
 
 static void next_measurement(struct dev_context *devc)
 {
-	switch (devc->target) {
+	switch (devc->acquisition_target) {
 	case KAXXXXP_CURRENT:
-		devc->target = KAXXXXP_VOLTAGE;
-		break;
-	case KAXXXXP_CURRENT_MAX:
-		devc->target = KAXXXXP_CURRENT;
+		devc->acquisition_target = KAXXXXP_VOLTAGE;
 		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;
+		devc->acquisition_target = KAXXXXP_STATUS;
 		break;
 	case KAXXXXP_STATUS:
-		devc->target = KAXXXXP_CURRENT;
+		devc->acquisition_target = KAXXXXP_CURRENT;
 		break;
 	default:
-		devc->target = KAXXXXP_CURRENT;
+		devc->acquisition_target = KAXXXXP_CURRENT;
+		sr_err("Invalid target for next acquisition.");
 	}
 }
 
@@ -335,10 +305,14 @@ SR_PRIV int korad_kaxxxxp_receive_data(int fd, int revents, void *cb_data)
 	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;
+	struct sr_datafeed_analog analog;
+	struct sr_analog_encoding encoding;
+	struct sr_analog_meaning meaning;
+	struct sr_analog_spec spec;
+	GSList *l;
 
 	(void)fd;
+	(void)revents;
 
 	if (!(sdi = cb_data))
 		return TRUE;
@@ -348,66 +322,43 @@ SR_PRIV int korad_kaxxxxp_receive_data(int fd, int revents, void *cb_data)
 
 	serial = sdi->conn;
 
-	if (revents == G_IO_IN) {
-		/* Get the value. */
-		korad_kaxxxxp_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 == KAXXXXP_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 == KAXXXXP_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_kaxxxxp_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;
-		}
+	/* Get the value. */
+	korad_kaxxxxp_get_value(serial, devc->acquisition_target, 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->acquisition_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 = SR_MQFLAG_DC;
+		analog.encoding->digits = 3;
+		analog.spec->spec_digits = 3;
+		analog.data = &devc->current;
+		sr_session_send(sdi, &packet);
+	} else if (devc->acquisition_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);
 
-	/* 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;
-		}
-
-	}
+	if (sr_sw_limits_check(&devc->limits))
+		sr_dev_acquisition_stop(sdi);
 
 	return TRUE;
 }