[libsigrok.git] / src / hardware / hp-3457a / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2016 Alexandru Gagniuc <mr.nuke.me@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 <math.h>
#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);
/*
 * 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", 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[] = {
	{
		.type = REAR_TERMINALS,
		.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,
	}
};

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;
		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;
	}

	return SR_ERR_NA;
}

SR_PRIV const struct rear_card_info *hp_3457a_probe_rear_card(struct sr_scpi_dev_inst *scpi)
{
	size_t i;
	float card_fval;
	unsigned int card_id;
	const struct rear_card_info *rear_card = NULL;

	if (sr_scpi_get_float(scpi, "OPT?", &card_fval) != SR_OK)
		return NULL;

	card_id = (unsigned int)card_fval;

	for (i = 0; i < ARRAY_SIZE(rear_card_parameters); i++) {
		if (rear_card_parameters[i].card_id == card_id) {
			rear_card = rear_card_parameters + i;
			break;
		}
	}

	if (!rear_card)
		return NULL;

	sr_info("Found %s.", rear_card->name);

	return rear_card;
}

SR_PRIV int hp_3457a_set_nplc(const struct sr_dev_inst *sdi, float nplc)
{
	int ret;
	struct sr_scpi_dev_inst *scpi = sdi->conn;
	struct dev_context *devc = sdi->priv;

	if ((nplc < 1E-6) || (nplc > 100))
		return SR_ERR_ARG;

	/* Only need one digit of precision here. */
	ret = sr_scpi_send(scpi, "NPLC %.0E", nplc);

	/*
	 * The instrument only has a few valid NPLC setting, so get back the
	 * one which was selected.
	 */
	sr_scpi_get_float(scpi, "NPLC?", &devc->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)
{
	sr_scpi_send(scpi, "?");
	devc->acq_state = ACQ_TRIGGERED_MEASUREMENT;
}

static void request_hires(struct sr_scpi_dev_inst *scpi,
			  struct dev_context *devc)
{
	sr_scpi_send(scpi, "RMATH HIRES");
	devc->acq_state = ACQ_REQUESTED_HIRES;
}

static void request_range(struct sr_scpi_dev_inst *scpi,
			  struct dev_context *devc)
{
	sr_scpi_send(scpi, "RANGE?");
	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.
 *
 * Depending on the range and measurement, a reading may not have eight digits
 * of resolution. For example, on a 30V range:
 *    : 10.000000 V has 8 significant digits
 *    :  9.999999 V has 7 significant digits
 *    :  0.999999 V has 6 significant digits
 *
 * The number of significant digits is determined based on the range in which
 * the measurement was taken:
 *    1. By taking the base 10 logarithm of the range, and converting that to
 *       an integer, we can get the minimum reading which has a full resolution
 *       reading. Raising 10 to the integer power gives the full resolution.
 *       Ex: For 30 V range, a full resolution reading is 10.000000.
 *    2. A ratio is taken between the full resolution reading and the
 *       measurement. Since the full resolution reading is a power of 10,
 *       for every leading zero, this ratio will be slightly higher than a
 *       power of 10. For example, for 10 V full resolution:
 *          : 10.000000 V, ratio = 1.0000000
 *          :  9.999999 V, ratio = 1.0000001
 *          :  0.999999 V, ratio = 10.000001
 *    3. The ratio is rounded up to prevent loss of precision in the next step.
 *    4. The base 10 logarithm of the ratio is taken, then rounded up. This
 *       gives the number of leading zeroes in the measurement.
 *       For example, for 10 V full resolution:
 *          : 10.000000 V, ceil(1.0000000) =  1, log10 = 0.00; 0 leading zeroes
 *          :  9.999999 V, ceil(1.0000001) =  2, log10 = 0.30; 1 leading zero
 *          :  0.999999 V, ceil(10.000001) = 11, log10 = 1.04, 2 leading zeroes
 *    5. The number of leading zeroes is subtracted from the maximum number of
 *       significant digits, 8, at 7 1/2 digits resolution.
 *       For a 10 V full resolution reading, this gives:
 *          : 10.000000 V, 0 leading zeroes => 8 significant digits
 *          :  9.999999 V, 1 leading zero   => 7 significant digits
 *          :  0.999999 V, 2 leading zeroes => 6 significant digits
 *
 * Single precision floating point numbers can achieve about 16 million counts,
 * but in high resolution mode we can get as much as 30 million counts. As a
 * result, these calculations must be done with double precision
 * (the HP 3457A is a very precise instrument).
 */
static int calculate_num_zero_digits(double measurement, double range)
{
	int zero_digits;
	double min_full_res_reading, log10_range, full_res_ratio;

	log10_range = log10(range);
	min_full_res_reading = pow(10, (int)log10_range);
	if (measurement > min_full_res_reading) {
		zero_digits = 0;
	} else if (measurement == 0.0) {
		zero_digits = 0;
	} else {
		full_res_ratio = min_full_res_reading / measurement;
		zero_digits = ceil(log10(ceil(full_res_ratio)));
	}

	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;
	struct sr_analog_encoding encoding;
	struct sr_analog_meaning meaning;
	struct sr_analog_spec spec;
	struct dev_context *devc = sdi->priv;

	hires_measurement = devc->base_measurement;
	if (is_highres_enabled(devc))
		hires_measurement += devc->hires_register;

	/* Figure out how many of the digits are significant. */
	num_digits = is_highres_enabled(devc) ? 8 : 7;
	zero_digits = calculate_num_zero_digits(hires_measurement,
						devc->measurement_range);
	num_digits = num_digits - zero_digits;

	packet.type = SR_DF_ANALOG;
	packet.payload = &analog;

	sr_analog_init(&analog, &encoding, &meaning, &spec, num_digits);
	encoding.unitsize = sizeof(float);

	meaning.channels = g_slist_append(NULL, devc->current_channel);

	measurement_workaround = hires_measurement;
	analog.num_samples = 1;
	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 channel_context *chanc;
	struct sr_dev_inst *sdi;

	(void)fd;
	(void)revents;

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

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

	scpi = sdi->conn;

	switch (devc->acq_state) {
	case ACQ_TRIGGERED_MEASUREMENT:
		ret = sr_scpi_get_double(scpi, NULL, &devc->base_measurement);
		if (ret != SR_OK) {
			retrigger_measurement(scpi, devc);
			return TRUE;
		}

		if (is_highres_enabled(devc))
			request_hires(scpi, devc);
		else
			request_range(scpi, devc);

		break;
	case ACQ_REQUESTED_HIRES:
		ret = sr_scpi_get_double(scpi, NULL, &devc->hires_register);
		if (ret != SR_OK) {
			retrigger_measurement(scpi, devc);
			return TRUE;
		}
		request_range(scpi, devc);
		break;
	case ACQ_REQUESTED_RANGE:
		ret = sr_scpi_get_double(scpi, NULL, &devc->measurement_range);
		if (ret != SR_OK) {
			retrigger_measurement(scpi, devc);
			return TRUE;
		}
		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.");
			sdi->driver->dev_acquisition_stop(sdi);
			return FALSE;
		}
		devc->acq_state = ACQ_GOT_CHANNEL_SYNC;
		break;
	default:
		return FALSE;
	}

	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);
			sdi->driver->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);
		return FALSE;
	}

	/* Got more to go. */
	if (devc->acq_state == ACQ_GOT_MEASUREMENT) {
		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;
}
Commit	Line	Data
00b2a092 AG	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2016 Alexandru Gagniuc <mr.nuke.me@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>
db23af7f AG	21	#include <math.h>
db23af7f AG	22	#include <scpi.h>
00b2a092 AG	23	#include "protocol.h"
00b2a092 AG	24
2c04f943 AG	25	static int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
	26	static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
	27	static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
db23af7f	28	/*
db23af7f AG	29	* The source for the frequency measurement can be either AC voltage, AC+DC
	30	* voltage, AC current, or AC+DC current. Configuring this is not yet
	31	* supported. For details, see "FSOURCE" command.
2c04f943 AG	32	* The set_mode function is optional and can be set to NULL, but in that case
2c04f943 AG	33	* a cmd string must be provided.
db23af7f AG	34	*/
	35	static const struct {
	36	enum sr_mq mq;
	37	enum sr_unit unit;
	38	const char *cmd;
2c04f943	39	int (set_mode)(struct sr_scpi_dev_inst scpi, enum sr_mqflag flags);
db23af7f	40	} sr_mq_to_cmd_map[] = {
2c04f943 AG	41	{ SR_MQ_VOLTAGE, SR_UNIT_VOLT, "DCV", set_mq_volt },
	42	{ SR_MQ_CURRENT, SR_UNIT_AMPERE, "DCI", set_mq_amp },
	43	{ SR_MQ_RESISTANCE, SR_UNIT_OHM, "OHM", set_mq_ohm },
	44	{ SR_MQ_FREQUENCY, SR_UNIT_HERTZ, "FREQ", NULL },
db23af7f AG	45	};
	46
	47	static const struct rear_card_info rear_card_parameters[] = {
	48	{
	49	.type = REAR_TERMINALS,
	50	.card_id = 0,
	51	.name = "Rear terminals",
	52	.cg_name = "rear",
9a093be9	53	.num_channels = 1,
db23af7f AG	54	}, {
	55	.type = HP_44491A,
	56	.card_id = 44491,
	57	.name = "44491A Armature Relay Multiplexer",
	58	.cg_name = "44491a",
9a093be9	59	.num_channels = 14,
db23af7f AG	60	}, {
	61	.type = HP_44492A,
	62	.card_id = 44492,
	63	.name = "44492A Reed Relay Multiplexer",
	64	.cg_name = "44492a",
9a093be9	65	.num_channels = 10,
db23af7f AG	66	}
	67	};
	68
2c04f943 AG	69	static int send_mq_ac_dc(struct sr_scpi_dev_inst scpi, const char mode,
	70	enum sr_mqflag flags)
	71	{
	72	const char ac_flag, dc_flag;
	73
	74	if (flags & ~(SR_MQFLAG_AC \| SR_MQFLAG_DC))
	75	return SR_ERR_NA;
	76
	77	ac_flag = (flags & SR_MQFLAG_AC) ? "AC" : "";
	78	dc_flag = "";
	79	/* Must specify DC measurement when AC flag is not given. */
	80	if ((flags & SR_MQFLAG_DC) \|\| !(flags & SR_MQFLAG_AC))
	81	dc_flag = "DC";
	82
	83	return sr_scpi_send(scpi, "%s%s%s", ac_flag, dc_flag, mode);
	84	}
	85
	86	static int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
	87	{
	88	return send_mq_ac_dc(scpi, "V", flags);
	89	}
	90
	91	static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
	92	{
	93	return send_mq_ac_dc(scpi, "I", flags);
	94	}
	95
	96	static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
	97	{
	98	const char *ohm_flag;
	99
	100	if (flags & ~(SR_MQFLAG_FOUR_WIRE))
	101	return SR_ERR_NA;
	102
	103	ohm_flag = (flags & SR_MQFLAG_FOUR_WIRE) ? "F" : "";
	104	return sr_scpi_send(scpi, "OHM%s", ohm_flag);
	105	}
	106
	107	SR_PRIV int hp_3457a_set_mq(const struct sr_dev_inst *sdi, enum sr_mq mq,
	108	enum sr_mqflag mq_flags)
db23af7f AG	109	{
	110	int ret;
	111	size_t i;
	112	struct sr_scpi_dev_inst *scpi = sdi->conn;
	113	struct dev_context *devc = sdi->priv;
	114
9a093be9 AG	115	/* No need to send command if we're not changing measurement type. */
	116	if (devc->measurement_mq == mq)
	117	return SR_OK;
	118
db23af7f AG	119	for (i = 0; i < ARRAY_SIZE(sr_mq_to_cmd_map); i++) {
	120	if (sr_mq_to_cmd_map[i].mq != mq)
	121	continue;
2c04f943 AG	122	if (sr_mq_to_cmd_map[i].set_mode) {
	123	ret = sr_mq_to_cmd_map[i].set_mode(scpi, mq_flags);
	124	} else {
	125	ret = sr_scpi_send(scpi, sr_mq_to_cmd_map[i].cmd);
	126	}
db23af7f AG	127	if (ret == SR_OK) {
db23af7f AG	128	devc->measurement_mq = sr_mq_to_cmd_map[i].mq;
2c04f943	129	devc->measurement_mq_flags = mq_flags;
db23af7f AG	130	devc->measurement_unit = sr_mq_to_cmd_map[i].unit;
	131	}
	132	return ret;
	133	}
	134
	135	return SR_ERR_NA;
	136	}
	137
	138	SR_PRIV const struct rear_card_info hp_3457a_probe_rear_card(struct sr_scpi_dev_inst scpi)
	139	{
	140	size_t i;
	141	float card_fval;
	142	unsigned int card_id;
	143	const struct rear_card_info *rear_card = NULL;
	144
	145	if (sr_scpi_get_float(scpi, "OPT?", &card_fval) != SR_OK)
	146	return NULL;
	147
	148	card_id = (unsigned int)card_fval;
	149
	150	for (i = 0; i < ARRAY_SIZE(rear_card_parameters); i++) {
	151	if (rear_card_parameters[i].card_id == card_id) {
	152	rear_card = rear_card_parameters + i;
	153	break;
	154	}
	155	}
	156
	157	if (!rear_card)
	158	return NULL;
	159
	160	sr_info("Found %s.", rear_card->name);
	161
	162	return rear_card;
	163	}
	164
	165	SR_PRIV int hp_3457a_set_nplc(const struct sr_dev_inst *sdi, float nplc)
	166	{
	167	int ret;
	168	struct sr_scpi_dev_inst *scpi = sdi->conn;
	169	struct dev_context *devc = sdi->priv;
	170
	171	if ((nplc < 1E-6) \|\| (nplc > 100))
	172	return SR_ERR_ARG;
	173
	174	/* Only need one digit of precision here. */
	175	ret = sr_scpi_send(scpi, "NPLC %.0E", nplc);
	176
	177	/*
	178	* The instrument only has a few valid NPLC setting, so get back the
	179	* one which was selected.
	180	*/
	181	sr_scpi_get_float(scpi, "NPLC?", &devc->nplc);
	182
	183	return ret;
	184	}
	185
9a093be9 AG	186	SR_PRIV int hp_3457a_select_input(const struct sr_dev_inst *sdi,
	187	enum channel_conn loc)
	188	{
	189	int ret;
	190	struct sr_scpi_dev_inst *scpi = sdi->conn;
	191	struct dev_context *devc = sdi->priv;
	192
	193	if (devc->input_loc == loc)
	194	return SR_OK;
	195
	196	ret = sr_scpi_send(scpi, "TERM %s", (loc == CONN_FRONT) ? "FRONT": "REAR");
	197	if (ret == SR_OK)
	198	devc->input_loc = loc;
	199
	200	return ret;
	201	}
	202
	203	SR_PRIV int hp_3457a_send_scan_list(const struct sr_dev_inst *sdi,
	204	unsigned int *channels, size_t len)
	205	{
	206	size_t i;
	207	char chan[16], list_str[64] = "";
	208
	209	for (i = 0; i < len; i++) {
	210	g_snprintf(chan, sizeof(chan), ",%u", channels[i]);
	211	g_strlcat(list_str, chan, sizeof(list_str));
	212	}
	213
	214	return sr_scpi_send(sdi->conn, "SLIST %s", list_str);
	215	}
	216
db23af7f AG	217	/* HIRES register only contains valid data with 10 or more powerline cycles. */
	218	static int is_highres_enabled(struct dev_context *devc)
	219	{
	220	return (devc->nplc >= 10.0);
	221	}
	222
9a093be9 AG	223	static void activate_next_channel(struct dev_context *devc)
	224	{
	225	GSList *list_elem;
	226	struct sr_channel *chan;
	227
	228	list_elem = g_slist_find(devc->active_channels, devc->current_channel);
	229	if (list_elem)
	230	list_elem = list_elem->next;
	231	if (!list_elem)
	232	list_elem = devc->active_channels;
	233
	234	chan = list_elem->data;
	235
	236	devc->current_channel = chan;
	237	}
	238
db23af7f AG	239	static void retrigger_measurement(struct sr_scpi_dev_inst *scpi,
	240	struct dev_context *devc)
	241	{
	242	sr_scpi_send(scpi, "?");
	243	devc->acq_state = ACQ_TRIGGERED_MEASUREMENT;
	244	}
	245
	246	static void request_hires(struct sr_scpi_dev_inst *scpi,
	247	struct dev_context *devc)
	248	{
	249	sr_scpi_send(scpi, "RMATH HIRES");
	250	devc->acq_state = ACQ_REQUESTED_HIRES;
	251	}
	252
	253	static void request_range(struct sr_scpi_dev_inst *scpi,
	254	struct dev_context *devc)
	255	{
	256	sr_scpi_send(scpi, "RANGE?");
	257	devc->acq_state = ACQ_REQUESTED_RANGE;
	258	}
	259
9a093be9 AG	260	static void request_current_channel(struct sr_scpi_dev_inst *scpi,
	261	struct dev_context *devc)
	262	{
	263	sr_scpi_send(scpi, "CHAN?");
	264	devc->acq_state = ACQ_REQUESTED_CHANNEL_SYNC;
	265	}
	266
db23af7f AG	267	/*
	268	* Calculate the number of leading zeroes in the measurement.
	269	*
	270	* Depending on the range and measurement, a reading may not have eight digits
	271	* of resolution. For example, on a 30V range:
	272	* : 10.000000 V has 8 significant digits
	273	* : 9.999999 V has 7 significant digits
	274	* : 0.999999 V has 6 significant digits
	275	*
	276	* The number of significant digits is determined based on the range in which
	277	* the measurement was taken:
	278	* 1. By taking the base 10 logarithm of the range, and converting that to
	279	* an integer, we can get the minimum reading which has a full resolution
	280	* reading. Raising 10 to the integer power gives the full resolution.
	281	* Ex: For 30 V range, a full resolution reading is 10.000000.
	282	* 2. A ratio is taken between the full resolution reading and the
	283	* measurement. Since the full resolution reading is a power of 10,
	284	* for every leading zero, this ratio will be slightly higher than a
	285	* power of 10. For example, for 10 V full resolution:
	286	* : 10.000000 V, ratio = 1.0000000
	287	* : 9.999999 V, ratio = 1.0000001
	288	* : 0.999999 V, ratio = 10.000001
	289	* 3. The ratio is rounded up to prevent loss of precision in the next step.
	290	* 4. The base 10 logarithm of the ratio is taken, then rounded up. This
	291	* gives the number of leading zeroes in the measurement.
	292	* For example, for 10 V full resolution:
	293	* : 10.000000 V, ceil(1.0000000) = 1, log10 = 0.00; 0 leading zeroes
	294	* : 9.999999 V, ceil(1.0000001) = 2, log10 = 0.30; 1 leading zero
	295	* : 0.999999 V, ceil(10.000001) = 11, log10 = 1.04, 2 leading zeroes
	296	* 5. The number of leading zeroes is subtracted from the maximum number of
	297	* significant digits, 8, at 7 1/2 digits resolution.
	298	* For a 10 V full resolution reading, this gives:
	299	* : 10.000000 V, 0 leading zeroes => 8 significant digits
	300	* : 9.999999 V, 1 leading zero => 7 significant digits
	301	* : 0.999999 V, 2 leading zeroes => 6 significant digits
	302	*
	303	* Single precision floating point numbers can achieve about 16 million counts,
	304	* but in high resolution mode we can get as much as 30 million counts. As a
	305	* result, these calculations must be done with double precision
	306	* (the HP 3457A is a very precise instrument).
	307	*/
	308	static int calculate_num_zero_digits(double measurement, double range)
	309	{
	310	int zero_digits;
	311	double min_full_res_reading, log10_range, full_res_ratio;
	312
	313	log10_range = log10(range);
	314	min_full_res_reading = pow(10, (int)log10_range);
	315	if (measurement > min_full_res_reading) {
	316	zero_digits = 0;
	317	} else if (measurement == 0.0) {
	318	zero_digits = 0;
	319	} else {
	320	full_res_ratio = min_full_res_reading / measurement;
	321	zero_digits = ceil(log10(ceil(full_res_ratio)));
	322	}
	323
	324	return zero_digits;
	325	}
	326
625430bf AG	327	/*
	328	* Until the output modules understand double precision data, we need to send
	329	* the measurement as floats instead of doubles, hence, the dance with
	330	* measurement_workaround double to float conversion.
	331	* See bug #779 for details.
	332	* The workaround should be removed once the output modules are fixed.
	333	*/
db23af7f AG	334	static void acq_send_measurement(struct sr_dev_inst *sdi)
	335	{
	336	double hires_measurement;
625430bf	337	float measurement_workaround;
db23af7f AG	338	int zero_digits, num_digits;
	339	struct sr_datafeed_packet packet;
	340	struct sr_datafeed_analog analog;
	341	struct sr_analog_encoding encoding;
	342	struct sr_analog_meaning meaning;
	343	struct sr_analog_spec spec;
	344	struct dev_context *devc = sdi->priv;
	345
	346	hires_measurement = devc->base_measurement;
	347	if (is_highres_enabled(devc))
	348	hires_measurement += devc->hires_register;
	349
	350	/* Figure out how many of the digits are significant. */
	351	num_digits = is_highres_enabled(devc) ? 8 : 7;
	352	zero_digits = calculate_num_zero_digits(hires_measurement,
	353	devc->measurement_range);
	354	num_digits = num_digits - zero_digits;
	355
	356	packet.type = SR_DF_ANALOG;
	357	packet.payload = &analog;
	358
	359	sr_analog_init(&analog, &encoding, &meaning, &spec, num_digits);
625430bf	360	encoding.unitsize = sizeof(float);
db23af7f	361
9a093be9	362	meaning.channels = g_slist_append(NULL, devc->current_channel);
db23af7f	363
625430bf	364	measurement_workaround = hires_measurement;
db23af7f	365	analog.num_samples = 1;
625430bf	366	analog.data = &measurement_workaround;
db23af7f AG	367
db23af7f AG	368	meaning.mq = devc->measurement_mq;
2c04f943	369	meaning.mqflags = devc->measurement_mq_flags;
db23af7f AG	370	meaning.unit = devc->measurement_unit;
	371
	372	sr_session_send(sdi, &packet);
9a093be9 AG	373
9a093be9 AG	374	g_slist_free(meaning.channels);
db23af7f AG	375	}
db23af7f AG	376
9a093be9 AG	377	/*
	378	* The scan-advance channel sync -- call to request_current_channel() -- is not
	379	* necessarily needed. It is done in case we have a communication error and the
	380	* DMM advances the channel without having sent the reading. The DMM only
	381	* advances the channel when it thinks it sent the reading over HP-IB. Thus, on
	382	* most errors we can retrigger the measurement and still be in sync. This
	383	* check is done to make sure we don't fall out of sync due to obscure errors.
	384	*/
00b2a092 AG	385	SR_PRIV int hp_3457a_receive_data(int fd, int revents, void *cb_data)
00b2a092 AG	386	{
db23af7f AG	387	int ret;
db23af7f AG	388	struct sr_scpi_dev_inst *scpi;
00b2a092	389	struct dev_context *devc;
9a093be9	390	struct channel_context *chanc;
695dc859	391	struct sr_dev_inst *sdi;
00b2a092 AG	392
00b2a092 AG	393	(void)fd;
db23af7f	394	(void)revents;
00b2a092 AG	395
	396	if (!(sdi = cb_data))
	397	return TRUE;
	398
	399	if (!(devc = sdi->priv))
	400	return TRUE;
	401
db23af7f AG	402	scpi = sdi->conn;
	403
	404	switch (devc->acq_state) {
	405	case ACQ_TRIGGERED_MEASUREMENT:
	406	ret = sr_scpi_get_double(scpi, NULL, &devc->base_measurement);
	407	if (ret != SR_OK) {
	408	retrigger_measurement(scpi, devc);
	409	return TRUE;
	410	}
	411
	412	if (is_highres_enabled(devc))
	413	request_hires(scpi, devc);
	414	else
	415	request_range(scpi, devc);
	416
	417	break;
	418	case ACQ_REQUESTED_HIRES:
	419	ret = sr_scpi_get_double(scpi, NULL, &devc->hires_register);
	420	if (ret != SR_OK) {
	421	retrigger_measurement(scpi, devc);
	422	return TRUE;
	423	}
	424	request_range(scpi, devc);
	425	break;
	426	case ACQ_REQUESTED_RANGE:
	427	ret = sr_scpi_get_double(scpi, NULL, &devc->measurement_range);
	428	if (ret != SR_OK) {
	429	retrigger_measurement(scpi, devc);
	430	return TRUE;
	431	}
	432	devc->acq_state = ACQ_GOT_MEASUREMENT;
	433	break;
9a093be9 AG	434	case ACQ_REQUESTED_CHANNEL_SYNC:
	435	ret = sr_scpi_get_double(scpi, NULL, &devc->last_channel_sync);
	436	if (ret != SR_OK) {
	437	sr_err("Cannot check channel synchronization.");
695dc859	438	sdi->driver->dev_acquisition_stop(sdi);
9a093be9 AG	439	return FALSE;
	440	}
	441	devc->acq_state = ACQ_GOT_CHANNEL_SYNC;
	442	break;
db23af7f AG	443	default:
	444	return FALSE;
	445	}
	446
e2626373	447	if (devc->acq_state == ACQ_GOT_MEASUREMENT) {
db23af7f	448	acq_send_measurement(sdi);
e2626373 AG	449	devc->num_samples++;
e2626373 AG	450	}
db23af7f	451
9a093be9 AG	452	if (devc->acq_state == ACQ_GOT_CHANNEL_SYNC) {
	453	chanc = devc->current_channel->priv;
	454	if (chanc->index != devc->last_channel_sync) {
	455	sr_err("Current channel and scan advance out of sync.");
	456	sr_err("Expected channel %u, but device says %u",
	457	chanc->index,
	458	(unsigned int)devc->last_channel_sync);
695dc859	459	sdi->driver->dev_acquisition_stop(sdi);
9a093be9 AG	460	return FALSE;
	461	}
	462	/* All is good. Back to business. */
	463	retrigger_measurement(scpi, devc);
	464	}
	465
db23af7f	466	if (devc->limit_samples && (devc->num_samples >= devc->limit_samples)) {
695dc859	467	sdi->driver->dev_acquisition_stop(sdi);
db23af7f AG	468	return FALSE;
	469	}
	470
	471	/* Got more to go. */
	472	if (devc->acq_state == ACQ_GOT_MEASUREMENT) {
9a093be9 AG	473	activate_next_channel(devc);
	474	/* Retrigger, or check if scan-advance is in sync. */
	475	if (((devc->num_samples % 10) == 9)
	476	&& (devc->num_active_channels > 1)) {
	477	request_current_channel(scpi, devc);
	478	} else {
	479	retrigger_measurement(scpi, devc);
	480	}
00b2a092 AG	481	}
	482
	483	return TRUE;
	484	}