X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fhardware%2Fhp-3457a%2Fprotocol.c;h=f0197290f3b6d0e4825194335309d8a1a0df8d42;hb=7f0463840ab5d6a85daaa76850558d2b71e596cf;hp=320d8d0abfe114c657ebbf627809365b8a80c9dc;hpb=db23af7fc26c9a69d500d806b060c131361e9565;p=libsigrok.git

diff --git a/src/hardware/hp-3457a/protocol.c b/src/hardware/hp-3457a/protocol.c
index 320d8d0a..f0197290 100644
--- a/src/hardware/hp-3457a/protocol.c
+++ b/src/hardware/hp-3457a/protocol.c
@@ -22,23 +22,27 @@
 #include <scpi.h>
 #include "protocol.h"
 
+static int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
+static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
+static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
+
 /*
- * Currently, only DC voltage and current are supported, as switching to AC or
- * AC+DC requires mq flags, which is not yet implemented.
- * Four-wire resistance measurements are not implemented (See "OHMF" command).
  * The source for the frequency measurement can be either AC voltage, AC+DC
  * voltage, AC current, or AC+DC current. Configuring this is not yet
  * supported. For details, see "FSOURCE" command.
+ * The set_mode function is optional and can be set to NULL, but in that case
+ * a cmd string must be provided.
  */
 static const struct {
 	enum sr_mq mq;
 	enum sr_unit unit;
 	const char *cmd;
+	int (*set_mode)(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
 } sr_mq_to_cmd_map[] = {
-	{ SR_MQ_VOLTAGE, SR_UNIT_VOLT, "DCV" },
-	{ SR_MQ_CURRENT, SR_UNIT_AMPERE, "DCI" },
-	{ SR_MQ_RESISTANCE, SR_UNIT_OHM, "OHM" },
-	{ SR_MQ_FREQUENCY, SR_UNIT_HERTZ, "FREQ" },
+	{ SR_MQ_VOLTAGE, SR_UNIT_VOLT, "DCV", set_mq_volt },
+	{ SR_MQ_CURRENT, SR_UNIT_AMPERE, "DCI", set_mq_amp },
+	{ SR_MQ_RESISTANCE, SR_UNIT_OHM, "OHM", set_mq_ohm },
+	{ SR_MQ_FREQUENCY, SR_UNIT_HERTZ, "FREQ", NULL },
 };
 
 static const struct rear_card_info rear_card_parameters[] = {
@@ -47,32 +51,83 @@ static const struct rear_card_info rear_card_parameters[] = {
 		.card_id = 0,
 		.name = "Rear terminals",
 		.cg_name = "rear",
+		.num_channels = 1,
 	}, {
 		.type = HP_44491A,
 		.card_id = 44491,
 		.name = "44491A Armature Relay Multiplexer",
 		.cg_name = "44491a",
+		.num_channels = 14,
 	}, {
 		.type = HP_44492A,
 		.card_id = 44492,
 		.name = "44492A Reed Relay Multiplexer",
 		.cg_name = "44492a",
+		.num_channels = 10,
 	}
 };
 
-SR_PRIV int hp_3457a_set_mq(const struct sr_dev_inst *sdi, enum sr_mq mq)
+static int send_mq_ac_dc(struct sr_scpi_dev_inst *scpi, const char *mode,
+			 enum sr_mqflag flags)
+{
+	const char *ac_flag, *dc_flag;
+
+	if (flags & ~(SR_MQFLAG_AC | SR_MQFLAG_DC))
+		return SR_ERR_NA;
+
+	ac_flag = (flags & SR_MQFLAG_AC) ? "AC" : "";
+	dc_flag = "";
+	/* Must specify DC measurement when AC flag is not given. */
+	if ((flags & SR_MQFLAG_DC) || !(flags & SR_MQFLAG_AC))
+		dc_flag = "DC";
+
+	return sr_scpi_send(scpi, "%s%s%s", ac_flag, dc_flag, mode);
+}
+
+static int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
+{
+	return send_mq_ac_dc(scpi, "V", flags);
+}
+
+static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
+{
+	return send_mq_ac_dc(scpi, "I", flags);
+}
+
+static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
+{
+	const char *ohm_flag;
+
+	if (flags & ~(SR_MQFLAG_FOUR_WIRE))
+		return SR_ERR_NA;
+
+	ohm_flag = (flags & SR_MQFLAG_FOUR_WIRE) ? "F" : "";
+	return sr_scpi_send(scpi, "OHM%s", ohm_flag);
+}
+
+SR_PRIV int hp_3457a_set_mq(const struct sr_dev_inst *sdi, enum sr_mq mq,
+			    enum sr_mqflag mq_flags)
 {
 	int ret;
 	size_t i;
 	struct sr_scpi_dev_inst *scpi = sdi->conn;
 	struct dev_context *devc = sdi->priv;
 
+	/* No need to send command if we're not changing measurement type. */
+	if (devc->measurement_mq == mq)
+		return SR_OK;
+
 	for (i = 0; i < ARRAY_SIZE(sr_mq_to_cmd_map); i++) {
 		if (sr_mq_to_cmd_map[i].mq != mq)
 			continue;
-		ret = sr_scpi_send(scpi, sr_mq_to_cmd_map[i].cmd);
+		if (sr_mq_to_cmd_map[i].set_mode) {
+			ret = sr_mq_to_cmd_map[i].set_mode(scpi, mq_flags);
+		} else {
+			ret = sr_scpi_send(scpi, sr_mq_to_cmd_map[i].cmd);
+		}
 		if (ret == SR_OK) {
 			devc->measurement_mq = sr_mq_to_cmd_map[i].mq;
+			devc->measurement_mq_flags = mq_flags;
 			devc->measurement_unit = sr_mq_to_cmd_map[i].unit;
 		}
 		return ret;
@@ -129,12 +184,59 @@ SR_PRIV int hp_3457a_set_nplc(const struct sr_dev_inst *sdi, float nplc)
 	return ret;
 }
 
+SR_PRIV int hp_3457a_select_input(const struct sr_dev_inst *sdi,
+				  enum channel_conn loc)
+{
+	int ret;
+	struct sr_scpi_dev_inst *scpi = sdi->conn;
+	struct dev_context *devc = sdi->priv;
+
+	if (devc->input_loc == loc)
+		return SR_OK;
+
+	ret = sr_scpi_send(scpi, "TERM %s", (loc == CONN_FRONT) ? "FRONT": "REAR");
+	if (ret == SR_OK)
+		devc->input_loc = loc;
+
+	return ret;
+}
+
+SR_PRIV int hp_3457a_send_scan_list(const struct sr_dev_inst *sdi,
+				    unsigned int *channels, size_t len)
+{
+	size_t i;
+	char chan[16], list_str[64] = "";
+
+	for (i = 0; i < len; i++) {
+		g_snprintf(chan, sizeof(chan), ",%u", channels[i]);
+		g_strlcat(list_str, chan, sizeof(list_str));
+	}
+
+	return sr_scpi_send(sdi->conn, "SLIST %s", list_str);
+}
+
 /* HIRES register only contains valid data with 10 or more powerline cycles. */
 static int is_highres_enabled(struct dev_context *devc)
 {
 	return (devc->nplc >= 10.0);
 }
 
+static void activate_next_channel(struct dev_context *devc)
+{
+	GSList *list_elem;
+	struct sr_channel *chan;
+
+	list_elem = g_slist_find(devc->active_channels, devc->current_channel);
+	if (list_elem)
+		list_elem = list_elem->next;
+	if (!list_elem)
+		list_elem = devc->active_channels;
+
+	chan = list_elem->data;
+
+	devc->current_channel = chan;
+}
+
 static void retrigger_measurement(struct sr_scpi_dev_inst *scpi,
 				  struct dev_context *devc)
 {
@@ -156,6 +258,13 @@ static void request_range(struct sr_scpi_dev_inst *scpi,
 	devc->acq_state = ACQ_REQUESTED_RANGE;
 }
 
+static void request_current_channel(struct sr_scpi_dev_inst *scpi,
+				    struct dev_context *devc)
+{
+	sr_scpi_send(scpi, "CHAN?");
+	devc->acq_state = ACQ_REQUESTED_CHANNEL_SYNC;
+}
+
 /*
  * Calculate the number of leading zeroes in the measurement.
  *
@@ -216,9 +325,17 @@ static int calculate_num_zero_digits(double measurement, double range)
 	return zero_digits;
 }
 
+/*
+ * Until the output modules understand double precision data, we need to send
+ * the measurement as floats instead of doubles, hence, the dance with
+ * measurement_workaround double to float conversion.
+ * See bug #779 for details.
+ * The workaround should be removed once the output modules are fixed.
+ */
 static void acq_send_measurement(struct sr_dev_inst *sdi)
 {
 	double hires_measurement;
+	float measurement_workaround;
 	int zero_digits, num_digits;
 	struct sr_datafeed_packet packet;
 	struct sr_datafeed_analog analog;
@@ -241,25 +358,38 @@ static void acq_send_measurement(struct sr_dev_inst *sdi)
 	packet.payload = &analog;
 
 	sr_analog_init(&analog, &encoding, &meaning, &spec, num_digits);
-	encoding.unitsize = sizeof(double);
+	encoding.unitsize = sizeof(float);
 
-	meaning.channels = sdi->channels;
+	meaning.channels = g_slist_append(NULL, devc->current_channel);
 
+	measurement_workaround = hires_measurement;
 	analog.num_samples = 1;
-	analog.data = &hires_measurement;
+	analog.data = &measurement_workaround;
 
 	meaning.mq = devc->measurement_mq;
+	meaning.mqflags = devc->measurement_mq_flags;
 	meaning.unit = devc->measurement_unit;
 
 	sr_session_send(sdi, &packet);
+
+	g_slist_free(meaning.channels);
 }
 
+/*
+ * The scan-advance channel sync -- call to request_current_channel() -- is not
+ * necessarily needed. It is done in case we have a communication error and the
+ * DMM advances the channel without having sent the reading. The DMM only
+ * advances the channel when it thinks it sent the reading over HP-IB. Thus, on
+ * most errors we can retrigger the measurement and still be in sync. This
+ * check is done to make sure we don't fall out of sync due to obscure errors.
+ */
 SR_PRIV int hp_3457a_receive_data(int fd, int revents, void *cb_data)
 {
 	int ret;
 	struct sr_scpi_dev_inst *scpi;
 	struct dev_context *devc;
-	struct sr_dev_inst *sdi = cb_data;
+	struct channel_context *chanc;
+	struct sr_dev_inst *sdi;
 
 	(void)fd;
 	(void)revents;
@@ -302,23 +432,53 @@ SR_PRIV int hp_3457a_receive_data(int fd, int revents, void *cb_data)
 		}
 		devc->acq_state = ACQ_GOT_MEASUREMENT;
 		break;
+	case ACQ_REQUESTED_CHANNEL_SYNC:
+		ret = sr_scpi_get_double(scpi, NULL, &devc->last_channel_sync);
+		if (ret != SR_OK) {
+			sr_err("Cannot check channel synchronization.");
+			sr_dev_acquisition_stop(sdi);
+			return FALSE;
+		}
+		devc->acq_state = ACQ_GOT_CHANNEL_SYNC;
+		break;
 	default:
 		return FALSE;
 	}
 
-	if (devc->acq_state == ACQ_GOT_MEASUREMENT)
+	if (devc->acq_state == ACQ_GOT_MEASUREMENT) {
 		acq_send_measurement(sdi);
+		devc->num_samples++;
+	}
+
+	if (devc->acq_state == ACQ_GOT_CHANNEL_SYNC) {
+		chanc = devc->current_channel->priv;
+		if (chanc->index != devc->last_channel_sync) {
+			sr_err("Current channel and scan advance out of sync.");
+			sr_err("Expected channel %u, but device says %u",
+			       chanc->index,
+			       (unsigned int)devc->last_channel_sync);
+			sr_dev_acquisition_stop(sdi);
+			return FALSE;
+		}
+		/* All is good. Back to business. */
+		retrigger_measurement(scpi, devc);
+	}
 
 	if (devc->limit_samples && (devc->num_samples >= devc->limit_samples)) {
-		sdi->driver->dev_acquisition_stop(sdi, cb_data);
+		sr_dev_acquisition_stop(sdi);
 		return FALSE;
 	}
 
 	/* Got more to go. */
 	if (devc->acq_state == ACQ_GOT_MEASUREMENT) {
-		/* Retrigger */
-		devc->num_samples++;
-		retrigger_measurement(scpi, devc);
+		activate_next_channel(devc);
+		/* Retrigger, or check if scan-advance is in sync. */
+		if (((devc->num_samples % 10) == 9)
+		   && (devc->num_active_channels > 1)) {
+			request_current_channel(scpi, devc);
+		} else {
+			retrigger_measurement(scpi, devc);
+		}
 	}
 
 	return TRUE;