X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fhardware%2Fzketech-ebd-usb%2Fprotocol.c;h=e8df0100f3a5aa2a87f0473ea1e20e0a37636a2c;hb=fb28e72dfdea0d985e03795f1f058aa4621e7e55;hp=9751e910972c674116384c41e6b1941e73652247;hpb=ab3e9c8af67b5919dd7cfb3119081bfd5858cc81;p=libsigrok.git

diff --git a/src/hardware/zketech-ebd-usb/protocol.c b/src/hardware/zketech-ebd-usb/protocol.c
index 9751e910..e8df0100 100644
--- a/src/hardware/zketech-ebd-usb/protocol.c
+++ b/src/hardware/zketech-ebd-usb/protocol.c
@@ -26,8 +26,9 @@ static void log_buf(const char *message, uint8_t buf[], size_t count)
 {
 	char buffer[count * 2 + 1];
 
-	for (size_t j = 0; j < count; j++)
-		sprintf(&buffer[2 * j], "%02X", buf[j]);
+	for (size_t i = 0; i < count; i++) {
+		sprintf(&buffer[2 * i], "%02X", buf[i]);
+	}
 
 	buffer[count * 2] = 0;
 
@@ -35,7 +36,8 @@ static void log_buf(const char *message, uint8_t buf[], size_t count)
 }
 
 /* Send a command to the device. */
-static int send_cmd(struct sr_serial_dev_inst *serial, uint8_t buf[], size_t count)
+static int send_cmd(struct sr_serial_dev_inst *serial, uint8_t buf[],
+	size_t count)
 {
 	int ret;
 
@@ -46,7 +48,11 @@ static int send_cmd(struct sr_serial_dev_inst *serial, uint8_t buf[], size_t cou
 			sr_err("Error sending command: %d.", ret);
 			return ret;
 		}
-		g_usleep(10000); // wait between bytes to prevent data loss at the receiving side
+		/*
+		 * Wait between bytes to prevent data loss at the receiving
+		 * side.
+		 */
+		g_usleep(10000);
 	}
 
 	return (ret == (int)count) ? SR_OK : SR_ERR;
@@ -72,10 +78,10 @@ static void encode_value(float current, uint8_t *hi, uint8_t *lo, float divisor)
 /* Send updated configuration values to the load. */
 static int send_cfg(struct sr_serial_dev_inst *serial, struct dev_context *devc)
 {
-	uint8_t send[] = { 0xfa, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8 };
+	uint8_t send[] = {0xfa, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8};
 
 	encode_value(devc->current_limit, &send[2], &send[3], 1000.0);
-	encode_value(devc->voltage_limit, &send[4], &send[5], 100.0);
+	encode_value(devc->uvc_threshold, &send[4], &send[5], 100.0);
 
 	send[8] = send[1] ^ send[2] ^ send[3] ^ send[4] ^ send[5] ^ send[6] ^ send[7];
 
@@ -89,19 +95,18 @@ SR_PRIV int ebd_init(struct sr_serial_dev_inst *serial, struct dev_context *devc
 
 	(void)devc;
 
-	int ret = send_cmd(serial, init, 10);
-
-	return ret;
+	return send_cmd(serial, init, 10);
 }
 
 /* Start the load functionality. */
-SR_PRIV int ebd_loadstart(struct sr_serial_dev_inst *serial, struct dev_context *devc)
+SR_PRIV int ebd_loadstart(struct sr_serial_dev_inst *serial,
+	struct dev_context *devc)
 {
-	uint8_t start[] = { 0xfa, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf8 };
 	int ret;
+	uint8_t start[] = { 0xfa, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf8 };
 
 	encode_value(devc->current_limit, &start[2], &start[3], 1000.0);
-	encode_value(devc->voltage_limit, &start[4], &start[5], 100.0);
+	encode_value(devc->uvc_threshold, &start[4], &start[5], 100.0);
 
 	start[8] = start[1] ^ start[2] ^ start[3] ^ start[4] ^ start[5] ^ start[6] ^ start[7];
 
@@ -111,7 +116,7 @@ SR_PRIV int ebd_loadstart(struct sr_serial_dev_inst *serial, struct dev_context
 		return ret;
 
 	sr_dbg("current limit: %.03f", devc->current_limit);
-	sr_dbg("under-voltage threshold: %.02f", devc->voltage_limit);
+	sr_dbg("under-voltage threshold: %.02f", devc->uvc_threshold);
 	if (ebd_current_is0(devc))
 		return SR_OK;
 
@@ -119,42 +124,46 @@ SR_PRIV int ebd_loadstart(struct sr_serial_dev_inst *serial, struct dev_context
 }
 
 /* Toggle the load functionality. */
-SR_PRIV int ebd_loadtoggle(struct sr_serial_dev_inst *serial, struct dev_context *devc)
+SR_PRIV int ebd_loadtoggle(struct sr_serial_dev_inst *serial,
+	struct dev_context *devc)
 {
-	int ret;
 	uint8_t toggle[] = { 0xfa, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xF8 };
 
-	(void) devc;
+	(void)devc;
 
 	sr_info("Toggling load");
-	ret = send_cmd(serial, toggle, 10);
-
-	return ret;
+	return send_cmd(serial, toggle, 10);
 }
 
 /* Stop the drive. */
 SR_PRIV int ebd_stop(struct sr_serial_dev_inst *serial, struct dev_context *devc)
 {
 	uint8_t stop[] = { 0xfa, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xF8 };
-	int ret;
-
-	(void) devc;
 
-	ret = send_cmd(serial, stop, 10);
+	(void)devc;
 
-	return ret;
+	return send_cmd(serial, stop, 10);
 }
 
-/** Receive a complete message
- *  @param[in] serial Serial port from which to read the packet
- *  @param[in] length Buffer length
- *  @param[out] buf Buffer to write packet to
- *  @return packet length (0 = timeout, -1 = error)
+/**
+ * Receive a complete message.
+ *
+ * @param[in] serial Serial port from which to read the packet
+ * @param[in] length Buffer length
+ * @param[out] buf Buffer to write packet to
+ *
+ * @return packet length (0 = timeout, -1 = error)
  */
-SR_PRIV int ebd_read_message(struct sr_serial_dev_inst *serial, int length, uint8_t *buf)
+SR_PRIV int ebd_read_message(struct sr_serial_dev_inst *serial, size_t length,
+	uint8_t *buf)
 {
-	// check parameters
-	if (NULL == serial) {
+	int ret;
+	gboolean message_complete;
+	size_t turn, max_turns;
+	size_t message_length;
+
+	/* Check parameters. */
+	if (serial == NULL) {
 		sr_err("Serial device to receive packet missing.");
 		return -1;
 	}
@@ -162,56 +171,61 @@ SR_PRIV int ebd_read_message(struct sr_serial_dev_inst *serial, int length, uint
 		sr_err("Packet buffer not large enough.");
 		return -1;
 	}
-	if (NULL == buf) {
+	if (buf == NULL) {
 		sr_err("Packet buffer missing.");
 		return -1;
 	}
 
-	int ret;
-	gboolean message_complete = FALSE;
-	int message_length = 0;
-	unsigned int turn = 0;
-	const unsigned int TURNS = 200;
+	message_complete = FALSE;
+	turn = 0;
+	max_turns = 200;
+	message_length = 0;
 	buf[message_length] = 0;
-	// try to read data
-	while (!message_complete && turn < TURNS) {
-		// wait for header byte
+
+	/* Try to read data. */
+	while (!message_complete && turn < max_turns) {
+		/* Wait for header byte. */
 		message_length = 0;
-		while (MSG_FRAME_BEGIN != buf[0] && turn < TURNS) {
-			ret = serial_read_blocking(serial, &buf[0], 1,  serial_timeout(serial, 1));
+		while ((buf[0] != MSG_FRAME_BEGIN) && (turn < max_turns)) {
+			ret = serial_read_blocking(serial, &buf[0], 1, serial_timeout(serial, 1));
 			if (ret < 0) {
 				sr_err("Error %d reading byte.", ret);
 				return ret;
-			} else if (1 == ret) {
-				if (MSG_FRAME_BEGIN != buf[message_length]) {
-					sr_warn("Not frame begin byte %02x received", buf[message_length]);
+			} else if (ret == 1) {
+				if (buf[message_length] != MSG_FRAME_BEGIN) {
+					sr_warn("Not frame begin byte %02x received",
+						buf[message_length]);
 				} else {
-					sr_dbg("Message header received: %02x", buf[message_length]);
+					sr_dbg("Message header received: %02x",
+						buf[message_length]);
 					message_length += ret;
 				}
 			}
 			turn++;
 		}
-		// read until end byte
-		while (MSG_FRAME_END !=  buf[message_length - 1] && message_length < length && turn < TURNS) {
-			ret = serial_read_blocking(serial, &buf[message_length], 1,  serial_timeout(serial, 1));
+		/* Read until end byte. */
+		while ((buf[message_length - 1] != MSG_FRAME_END)
+			&& (message_length < length) && (turn < max_turns)) {
+
+			ret = serial_read_blocking(serial, &buf[message_length], 1, serial_timeout(serial, 1));
 			if (ret < 0) {
 				sr_err("Error %d reading byte.", ret);
 				return ret;
-			} else if (1 == ret) {
-				if (MSG_FRAME_BEGIN == buf[message_length]) {
+			} else if (ret == 1) {
+				if (buf[message_length] == MSG_FRAME_BEGIN) {
 					sr_warn("Frame begin before end received");
 					message_length = 1;
 				} else {
-					sr_dbg("Message data received: %02x", buf[message_length]);
+					sr_dbg("Message data received: %02x",
+						buf[message_length]);
 					message_length += ret;
 				}
 			}
 			turn++;
 		}
-		// verify frame
-		if (turn < TURNS) {
-			if (MSG_FRAME_END == buf[message_length - 1]) {
+		/* Verify frame. */
+		if (turn < max_turns) {
+			if (buf[message_length - 1] == MSG_FRAME_END) {
 				message_complete = TRUE;
 				sr_dbg("Message end received");
 			} else {
@@ -224,7 +238,7 @@ SR_PRIV int ebd_read_message(struct sr_serial_dev_inst *serial, int length, uint
 
 	if (message_complete && message_length > 2) {
 		ret = message_length;
-	} else if (turn >= TURNS) {
+	} else if (turn >= max_turns) {
 		ret = 0;
 	} else {
 		ret = -1;
@@ -233,7 +247,7 @@ SR_PRIV int ebd_read_message(struct sr_serial_dev_inst *serial, int length, uint
 }
 
 static void ebd_send_value(const struct sr_dev_inst *sdi, struct sr_channel *ch,
-		float value, enum sr_mq mq, enum sr_unit unit, int digits)
+	float value, enum sr_mq mq, enum sr_unit unit, int digits)
 {
 	struct sr_datafeed_packet packet;
 	struct sr_datafeed_analog analog;
@@ -260,12 +274,11 @@ SR_PRIV int ebd_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;
-	float voltage, voltage_dp, voltage_dm, current, current_limit, voltage_limit;
+	float current, current_limit;
+	float voltage, voltage_dp, voltage_dm, uvc_threshold;
+	uint8_t reply[MSG_MAX_LEN];
+	int ret, i;
+	uint8_t checksum;
 
 	(void)revents;
 	(void)fd;
@@ -278,83 +291,82 @@ SR_PRIV int ebd_receive_data(int fd, int revents, void *cb_data)
 
 	serial = sdi->conn;
 	current_limit = devc->current_limit;
-	voltage_limit = devc->voltage_limit;
+	uvc_threshold = devc->uvc_threshold;
 
-	uint8_t reply[MSG_MAX_LEN];
-	int ret = ebd_read_message(serial, MSG_MAX_LEN, reply);
+	ret = ebd_read_message(serial, MSG_MAX_LEN, reply);
 
 	/* Tests for correct message. */
-	if (-1 == ret) {
+	if (ret == -1) {
 		sr_err("Can't receive messages");
 		return SR_ERR;
-	} else if (0 == ret) {
+	} else if (ret == 0) {
 		sr_err("No messages received");
 		devc->running = FALSE;
 		return 0;
-	} else if (ret != 19 || (reply[1] != 0x00 && reply[1] != 0x0a && reply[1] != 0x64 && reply[1] != 0x6e)) {
+	} else if ((ret != 19) ||
+		((reply[1] != 0x00) && (reply[1] != 0x0a) && (reply[1] != 0x64) && (reply[1] != 0x6e))) {
+
 		sr_info("Not measurement message received");
 		return ret;
 	}
 
 	/* Verify checksum */
-	uint8_t checksum = 0;
-	for (int i = 1; i < ret - 1; i++) {
+	checksum = 0;
+	for (i = 1; i < ret - 1; i++) {
 		checksum ^= reply[i];
 	}
-	if (0 != checksum) {
+	if (checksum != 0) {
 		sr_warn("Invalid checksum");
-		return ret; /* Don't exit on wrong checksum, the device can recover */
+		/* Don't exit on wrong checksum, the device can recover */
+		return ret;
 	}
 
 	devc->running = TRUE;
-	if (0x00 == reply[1] || 0x64 == reply[1]) {
+	if ((reply[1] == 0x00) || (reply[1] == 0x64))
 		devc->load_activated = FALSE;
-	} else if (0x0a == reply[1] || 0x6e == reply[1]) {
+	else if ((reply[1] == 0x0a) || (reply[1] == 0x6e))
 		devc->load_activated = TRUE;
-	}
 
 	/* Calculate values. */
 	current = decode_value(reply[2], reply[3], 10000.0);
 	voltage = decode_value(reply[4], reply[5], 1000.0);
 	voltage_dp = decode_value(reply[6], reply[7], 1000.0);
 	voltage_dm = decode_value(reply[8], reply[9], 1000.0);
-	if (0x0a == reply[1]) {
+	if (reply[1] == 0x0a) {
 		current_limit = decode_value(reply[10], reply[11], 1000.0);
-		voltage_limit = decode_value(reply[12], reply[13], 100.0);
+		uvc_threshold = decode_value(reply[12], reply[13], 100.0);
 	}
 
 	sr_dbg("VBUS current %.04f A", current);
 	sr_dbg("VBUS voltage %.03f V", voltage);
 	sr_dbg("D+ voltage %.03f V", voltage_dp);
 	sr_dbg("D- voltage %.03f V", voltage_dm);
-	if (0x0a == reply[1]) {
+	if (reply[1] == 0x0a) {
 		sr_dbg("Current limit %.03f A", current_limit);
-		sr_dbg("Voltage limit %.03f A", voltage_limit);
+		sr_dbg("UVC threshold %.03f V", uvc_threshold);
 	}
 
-	// update load state
+	/* Update load state. */
 	if (devc->load_activated && ebd_current_is0(devc)) {
 		ebd_loadtoggle(serial, devc);
 	} else if (!devc->load_activated && !ebd_current_is0(devc)) {
 		ebd_loadstart(serial, devc);
-	} else if (devc->load_activated && (current_limit != devc->current_limit || voltage_limit != devc->voltage_limit)) {
-		sr_dbg("Adjusting limit from %.03f A %.03f V to %.03f A %.03f V", current_limit, voltage_limit, devc->current_limit, devc->voltage_limit);
+	} else if (devc->load_activated &&
+		((current_limit != devc->current_limit) || (uvc_threshold != devc->uvc_threshold))) {
+
+		sr_dbg("Adjusting limit from %.03f A %.03f V to %.03f A %.03f V",
+			current_limit, uvc_threshold, devc->current_limit,
+			devc->uvc_threshold);
 		send_cfg(serial, devc);
 	}
 
 	/* Begin frame. */
 	std_session_send_df_frame_begin(sdi);
 
-	sr_analog_init(&analog, &encoding, &meaning, &spec, 4);
-
-	packet.type = SR_DF_ANALOG;
-	packet.payload = &analog;
-	analog.num_samples = 1;
-
 	/* Values */
-	ebd_send_value(sdi, sdi->channels->data, current,
+	ebd_send_value(sdi, sdi->channels->data, voltage,
 		SR_MQ_VOLTAGE, SR_UNIT_VOLT, 3);
-	ebd_send_value(sdi, sdi->channels->next->data, voltage,
+	ebd_send_value(sdi, sdi->channels->next->data, current,
 		SR_MQ_CURRENT, SR_UNIT_AMPERE, 4);
 	ebd_send_value(sdi, sdi->channels->next->next->data, voltage_dp,
 		SR_MQ_VOLTAGE, SR_UNIT_VOLT, 3);
@@ -427,7 +439,7 @@ SR_PRIV int ebd_set_current_limit(const struct sr_dev_inst *sdi, float current)
 	return ret;
 }
 
-SR_PRIV int ebd_get_voltage_limit(const struct sr_dev_inst *sdi, float *voltage)
+SR_PRIV int ebd_get_uvc_threshold(const struct sr_dev_inst *sdi, float *voltage)
 {
 	struct dev_context *devc;
 
@@ -435,13 +447,13 @@ SR_PRIV int ebd_get_voltage_limit(const struct sr_dev_inst *sdi, float *voltage)
 		return SR_ERR;
 
 	g_mutex_lock(&devc->rw_mutex);
-	*voltage = devc->voltage_limit;
+	*voltage = devc->uvc_threshold;
 	g_mutex_unlock(&devc->rw_mutex);
 
 	return SR_OK;
 }
 
-SR_PRIV int ebd_set_voltage_limit(const struct sr_dev_inst *sdi, float voltage)
+SR_PRIV int ebd_set_uvc_threshold(const struct sr_dev_inst *sdi, float voltage)
 {
 	struct dev_context *devc;
 	int ret;
@@ -450,15 +462,15 @@ SR_PRIV int ebd_set_voltage_limit(const struct sr_dev_inst *sdi, float voltage)
 		return SR_ERR;
 
 	g_mutex_lock(&devc->rw_mutex);
-	devc->voltage_limit = voltage;
+	devc->uvc_threshold = voltage;
 
 	if (!devc->running) {
-		sr_dbg("Setting voltage limit later.");
+		sr_dbg("Setting uvc threshold later.");
 		g_mutex_unlock(&devc->rw_mutex);
 		return SR_OK;
 	}
 
-	sr_dbg("Setting voltage limit to %fV.", voltage);
+	sr_dbg("Setting uvc threshold to %fV.", voltage);
 
 	if (devc->load_activated) {
 		if (ebd_current_is0(devc)) {