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

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2017-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
 * 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 <stdlib.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);

static const struct {
	enum sr_mq mq;
	int (*set_mode)(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
} sr_mq_to_cmd_map[] = {
	{ SR_MQ_VOLTAGE, set_mq_volt },
	{ SR_MQ_CURRENT, set_mq_amp },
	{ SR_MQ_RESISTANCE, set_mq_ohm },
};

static int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
{
	if ((flags & SR_MQFLAG_AC) != SR_MQFLAG_AC &&
		(flags & SR_MQFLAG_DC) != SR_MQFLAG_DC)
		return SR_ERR_NA;

	return sr_scpi_send(scpi, "%s",
		((flags & SR_MQFLAG_AC) == SR_MQFLAG_AC) ? "F2" : "F1");
}

static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
{
	if ((flags & SR_MQFLAG_AC) != SR_MQFLAG_AC &&
		(flags & SR_MQFLAG_DC) != SR_MQFLAG_DC)
		return SR_ERR_NA;

	return sr_scpi_send(scpi, "%s", (flags & SR_MQFLAG_AC) ? "F6" : "F5");
}

static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
{
	return sr_scpi_send(scpi, "%s",
		(flags & SR_MQFLAG_FOUR_WIRE) ? "F4" : "F3");
}

SR_PRIV int hp_3478a_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 &&
		((devc->measurement_mq_flags & mq_flags) == mq_flags))
		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_mq_to_cmd_map[i].set_mode(scpi, mq_flags);
		if (ret != SR_OK)
			return ret;

		ret = hp_3478a_get_status_bytes(sdi);
		return ret;
	}

	return SR_ERR_NA;
}

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

	/* No need to send command if we're not changing the range. */
	if (devc->range_exp == range_exp)
		return SR_OK;

	/* -99 is a dummy exponent for auto ranging. */
	if (range_exp == -99)
		ret = sr_scpi_send(scpi, "RA");
	else
		ret = sr_scpi_send(scpi, "R%i", range_exp);
	if (ret != SR_OK)
		return ret;

	return hp_3478a_get_status_bytes(sdi);
}

static int parse_range_vdc(struct dev_context *devc, uint8_t range_byte)
{
	if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VDC_30MV) {
		devc->range_exp = -2;
		devc->enc_digits = devc->spec_digits - 2;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VDC_300MV) {
		devc->range_exp = -1;
		devc->enc_digits = devc->spec_digits - 3;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VDC_3V) {
		devc->range_exp = 0;
		devc->enc_digits = devc->spec_digits - 1;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VDC_30V) {
		devc->range_exp = 1;
		devc->enc_digits = devc->spec_digits - 2;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VDC_300V) {
		devc->range_exp = 2;
		devc->enc_digits = devc->spec_digits - 3;
	} else
		return SR_ERR_DATA;

	return SR_OK;
}

static int parse_range_vac(struct dev_context *devc, uint8_t range_byte)
{
	if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VAC_300MV) {
		devc->range_exp = -1;
		devc->enc_digits = devc->spec_digits - 3;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VAC_3V) {
		devc->range_exp = 0;
		devc->enc_digits = devc->spec_digits - 1;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VAC_30V) {
		devc->range_exp = 1;
		devc->enc_digits = devc->spec_digits - 2;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VAC_300V) {
		devc->range_exp = 2;
		devc->enc_digits = devc->spec_digits - 3;
	} else
		return SR_ERR_DATA;

	return SR_OK;
}

static int parse_range_a(struct dev_context *devc, uint8_t range_byte)
{
	if ((range_byte & SB1_RANGE_BLOCK) == RANGE_A_300MA) {
		devc->range_exp = -1;
		devc->enc_digits = devc->spec_digits - 3;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_A_3A) {
		devc->range_exp = 0;
		devc->enc_digits = devc->spec_digits - 1;
	} else
		return SR_ERR_DATA;

	return SR_OK;
}

static int parse_range_ohm(struct dev_context *devc, uint8_t range_byte)
{
	if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_30R) {
		devc->range_exp = 1;
		devc->enc_digits = devc->spec_digits - 2;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_300R) {
		devc->range_exp = 2;
		devc->enc_digits = devc->spec_digits - 3;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_3KR) {
		devc->range_exp = 3;
		devc->enc_digits = devc->spec_digits - 1;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_30KR) {
		devc->range_exp = 4;
		devc->enc_digits = devc->spec_digits - 2;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_300KR) {
		devc->range_exp = 5;
		devc->enc_digits = devc->spec_digits - 3;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_3MR) {
		devc->range_exp = 6;
		devc->enc_digits = devc->spec_digits - 1;
	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_30MR) {
		devc->range_exp = 7;
		devc->enc_digits = devc->spec_digits - 2;
	} else
		return SR_ERR_DATA;

	return SR_OK;
}

static int parse_function_byte(struct dev_context *devc, uint8_t function_byte)
{
	/* Digits / Resolution (spec_digits must be set before range parsing) */
	if ((function_byte & SB1_DIGITS_BLOCK) == DIGITS_5_5)
		devc->spec_digits = 6;
	else if ((function_byte & SB1_DIGITS_BLOCK) == DIGITS_4_5)
		devc->spec_digits = 5;
	else if ((function_byte & SB1_DIGITS_BLOCK) == DIGITS_3_5)
		devc->spec_digits = 4;
	else
		return SR_ERR_DATA;

	/* Function + Range */
	devc->measurement_mq_flags = 0;
	devc->acquisition_mq_flags = 0;
	if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_VDC) {
		devc->measurement_mq = SR_MQ_VOLTAGE;
		devc->measurement_mq_flags |= SR_MQFLAG_DC;
		devc->acquisition_mq_flags |= SR_MQFLAG_DC;
		devc->measurement_unit = SR_UNIT_VOLT;
		parse_range_vdc(devc, function_byte);
	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_VAC) {
		devc->measurement_mq = SR_MQ_VOLTAGE;
		devc->measurement_mq_flags |= SR_MQFLAG_AC;
		devc->acquisition_mq_flags |= SR_MQFLAG_AC | SR_MQFLAG_RMS;
		devc->measurement_unit = SR_UNIT_VOLT;
		parse_range_vac(devc, function_byte);
	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_2WR) {
		devc->measurement_mq = SR_MQ_RESISTANCE;
		devc->measurement_unit = SR_UNIT_OHM;
		parse_range_ohm(devc, function_byte);
	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_4WR) {
		devc->measurement_mq = SR_MQ_RESISTANCE;
		devc->measurement_mq_flags |= SR_MQFLAG_FOUR_WIRE;
		devc->acquisition_mq_flags |= SR_MQFLAG_FOUR_WIRE;
		devc->measurement_unit = SR_UNIT_OHM;
		parse_range_ohm(devc, function_byte);
	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_ADC) {
		devc->measurement_mq = SR_MQ_CURRENT;
		devc->measurement_mq_flags |= SR_MQFLAG_DC;
		devc->acquisition_mq_flags |= SR_MQFLAG_DC;
		devc->measurement_unit = SR_UNIT_AMPERE;
		parse_range_a(devc, function_byte);
	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_AAC) {
		devc->measurement_mq = SR_MQ_CURRENT;
		devc->measurement_mq_flags |= SR_MQFLAG_AC;
		devc->acquisition_mq_flags |= SR_MQFLAG_AC | SR_MQFLAG_RMS;
		devc->measurement_unit = SR_UNIT_AMPERE;
		parse_range_a(devc, function_byte);
	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_EXR) {
		devc->measurement_mq = SR_MQ_RESISTANCE;
		devc->measurement_unit = SR_UNIT_OHM;
		parse_range_ohm(devc, function_byte);
	}

	return SR_OK;
}

static int parse_status_byte(struct dev_context *devc, uint8_t status_byte)
{
	devc->trigger = TRIGGER_UNDEFINED;

	/* External Trigger */
	if ((status_byte & STATUS_EXT_TRIGGER) == STATUS_EXT_TRIGGER)
		devc->trigger = TRIGGER_EXTERNAL;

	/* Cal RAM */
	if ((status_byte & STATUS_CAL_RAM) == STATUS_CAL_RAM)
		devc->calibration = TRUE;
	else
		devc->calibration = FALSE;

	/* Front/Rear terminals */
	if ((status_byte & STATUS_FRONT_TERMINAL) == STATUS_FRONT_TERMINAL)
		devc->terminal = TERMINAL_FRONT;
	else
		devc->terminal = TERMINAL_REAR;

	/* 50Hz / 60Hz */
	if ((status_byte & STATUS_50HZ) == STATUS_50HZ)
		devc->line = LINE_50HZ;
	else
		devc->line = LINE_60HZ;

	/* Auto-Zero */
	if ((status_byte & STATUS_AUTO_ZERO) == STATUS_AUTO_ZERO)
		devc->auto_zero = TRUE;
	else
		devc->auto_zero = FALSE;

	/* Auto-Range */
	if ((status_byte & STATUS_AUTO_RANGE) == STATUS_AUTO_RANGE) {
		devc->acquisition_mq_flags |= SR_MQFLAG_AUTORANGE;
		devc->range_exp = -99;
	} else
		devc->acquisition_mq_flags &= ~SR_MQFLAG_AUTORANGE;

	/* Internal trigger */
	if ((status_byte & STATUS_INT_TRIGGER) == STATUS_INT_TRIGGER)
		devc->trigger = TRIGGER_INTERNAL;

	return SR_OK;
}

static int parse_srq_byte(uint8_t sqr_byte)
{
	(void)sqr_byte;

#if 0
	/* The ServiceReQuest register isn't used at the moment. */

	/* PON SRQ */
	if ((sqr_byte & SRQ_POWER_ON) == SRQ_POWER_ON)
		sr_spew("Power On SRQ or clear msg received");

	/* Cal failed SRQ */
	if ((sqr_byte & SRQ_CAL_FAILED) == SRQ_CAL_FAILED)
		sr_spew("CAL failed SRQ");

	/* Keyboard SRQ */
	if ((sqr_byte & SRQ_KEYBORD) == SRQ_KEYBORD)
		sr_spew("Keyboard SRQ");

	/* Hardware error SRQ */
	if ((sqr_byte & SRQ_HARDWARE_ERR) == SRQ_HARDWARE_ERR)
		sr_spew("Hardware error SRQ");

	/* Syntax error SRQ */
	if ((sqr_byte & SRQ_SYNTAX_ERR) == SRQ_SYNTAX_ERR)
		sr_spew("Syntax error SRQ");

	/* Every reading is available to the bus SRQ */
	if ((sqr_byte & SRQ_BUS_AVAIL) == SRQ_BUS_AVAIL)
		sr_spew("Every reading is available to the bus SRQ");
#endif

	return SR_OK;
}

static int parse_error_byte(uint8_t error_byte)
{
	int ret;

	ret = SR_OK;

	/* A/D link */
	if ((error_byte & ERROR_AD_LINK) == ERROR_AD_LINK) {
		sr_err("Failure in the A/D link");
		ret = SR_ERR;
	}

	/* A/D Self Test */
	if ((error_byte & ERROR_AD_SELF_TEST) == ERROR_AD_SELF_TEST) {
		sr_err("A/D has failed its internal Self Test");
		ret = SR_ERR;
	}

	/* A/D slope error */
	if ((error_byte & ERROR_AD_SLOPE) == ERROR_AD_SLOPE) {
		sr_err("There has been an A/D slope error");
		ret = SR_ERR;
	}

	/* ROM Selt Test */
	if ((error_byte & ERROR_ROM_SELF_TEST) == ERROR_ROM_SELF_TEST) {
		sr_err("The ROM Self Test has failed");
		ret = SR_ERR;
	}

	/* RAM Selt Test */
	if ((error_byte & ERROR_RAM_SELF_TEST) == ERROR_RAM_SELF_TEST) {
		sr_err("The RAM Self Test has failed");
		ret = SR_ERR;
	}

	/* Selt Test */
	if ((error_byte & ERROR_SELF_TEST) == ERROR_SELF_TEST) {
		sr_err("Self Test: Any of the CAL RAM locations have bad "
		       "checksums, or a range with a bad checksum is selected");
		ret = SR_ERR;
	}

	return ret;
}

SR_PRIV int hp_3478a_get_status_bytes(const struct sr_dev_inst *sdi)
{
	int ret;
	char *response;
	uint8_t function_byte, status_byte, srq_byte, error_byte;
	struct sr_scpi_dev_inst *scpi = sdi->conn;
	struct dev_context *devc = sdi->priv;

	ret = sr_scpi_get_string(scpi, "B", &response);
	if (ret != SR_OK)
		return ret;

	if (!response)
		return SR_ERR;

	function_byte = (uint8_t)response[0];
	status_byte = (uint8_t)response[1];
	srq_byte = (uint8_t)response[2];
	error_byte = (uint8_t)response[3];

	g_free(response);

	parse_function_byte(devc, function_byte);
	parse_status_byte(devc, status_byte);
	parse_srq_byte(srq_byte);
	ret = parse_error_byte(error_byte);

	return ret;
}

static void acq_send_measurement(struct sr_dev_inst *sdi)
{
	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;
	float f;

	devc = sdi->priv;

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

	sr_analog_init(&analog, &encoding, &meaning, &spec, devc->enc_digits);

	/* TODO: Implement NAN, depending on counts, range and value. */
	f = devc->measurement;
	analog.num_samples = 1;
	analog.data = &f;

	encoding.unitsize = sizeof(float);
	encoding.is_float = TRUE;
	encoding.digits = devc->enc_digits;

	meaning.mq = devc->measurement_mq;
	meaning.mqflags = devc->acquisition_mq_flags;
	meaning.unit = devc->measurement_unit;
	meaning.channels = sdi->channels;

	spec.spec_digits = devc->spec_digits;

	sr_session_send(sdi, &packet);
}

SR_PRIV int hp_3478a_receive_data(int fd, int revents, void *cb_data)
{
	struct sr_scpi_dev_inst *scpi;
	struct sr_dev_inst *sdi;
	struct dev_context *devc;
	char status_register;

	(void)fd;
	(void)revents;

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

	scpi = sdi->conn;

	/*
	 * TODO: Wait for SRQ from the DMM when a new measurement is available.
	 *       For now, we don't wait for a SRQ, but just do a SPoll and
	 *       check the Data Ready bit (0x01).
	 *       This is necessary, because (1) reading a value will block the
	 *       bus until a measurement is available and (2) when switching
	 *       ranges, there could be a timeout.
	 */
	if (sr_scpi_gpib_spoll(scpi, &status_register) != SR_OK)
		return FALSE;
	if (!(((uint8_t)status_register) & 0x01))
		return TRUE;

	/* Get a reading from the DMM. */
	if (sr_scpi_get_double(scpi, NULL, &devc->measurement) != SR_OK)
		return FALSE;

	/*
	 * This is necessary to get the actual range for the encoding digits.
	 * Must be called after reading the value, because it resets the
	 * status register!
	 */
	if (hp_3478a_get_status_bytes(sdi) != SR_OK)
		return FALSE;

	acq_send_measurement(sdi);
	sr_sw_limits_update_samples_read(&devc->limits, 1);

	if (sr_sw_limits_check(&devc->limits))
		sr_dev_acquisition_stop(sdi);

	return TRUE;
}
Commit	Line	Data
1d9eebf4 FS	1	/*
	2	* This file is part of the libsigrok project.
	3	*
d2c1730a	4	* Copyright (C) 2017-2018 Frank Stettner <frank-stettner@gmx.net>
1d9eebf4 FS	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>
d2c1730a FS	21	#include <math.h>
	22	#include <stdlib.h>
	23	#include "scpi.h"
1d9eebf4 FS	24	#include "protocol.h"
1d9eebf4 FS	25
d2c1730a FS	26	static int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
	27	static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
	28	static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
	29
	30	static const struct {
	31	enum sr_mq mq;
	32	int (set_mode)(struct sr_scpi_dev_inst scpi, enum sr_mqflag flags);
	33	} sr_mq_to_cmd_map[] = {
	34	{ SR_MQ_VOLTAGE, set_mq_volt },
	35	{ SR_MQ_CURRENT, set_mq_amp },
	36	{ SR_MQ_RESISTANCE, set_mq_ohm },
	37	};
	38
	39	static int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
	40	{
d2c1730a FS	41	if ((flags & SR_MQFLAG_AC) != SR_MQFLAG_AC &&
	42	(flags & SR_MQFLAG_DC) != SR_MQFLAG_DC)
	43	return SR_ERR_NA;
	44
04c4a677 UH	45	return sr_scpi_send(scpi, "%s",
04c4a677 UH	46	((flags & SR_MQFLAG_AC) == SR_MQFLAG_AC) ? "F2" : "F1");
d2c1730a FS	47	}
	48
	49	static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
	50	{
d2c1730a FS	51	if ((flags & SR_MQFLAG_AC) != SR_MQFLAG_AC &&
	52	(flags & SR_MQFLAG_DC) != SR_MQFLAG_DC)
	53	return SR_ERR_NA;
	54
04c4a677	55	return sr_scpi_send(scpi, "%s", (flags & SR_MQFLAG_AC) ? "F6" : "F5");
d2c1730a FS	56	}
	57
	58	static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
	59	{
04c4a677 UH	60	return sr_scpi_send(scpi, "%s",
04c4a677 UH	61	(flags & SR_MQFLAG_FOUR_WIRE) ? "F4" : "F3");
d2c1730a FS	62	}
	63
	64	SR_PRIV int hp_3478a_set_mq(const struct sr_dev_inst *sdi, enum sr_mq mq,
	65	enum sr_mqflag mq_flags)
	66	{
	67	int ret;
	68	size_t i;
	69	struct sr_scpi_dev_inst *scpi = sdi->conn;
	70	struct dev_context *devc = sdi->priv;
	71
	72	/* No need to send command if we're not changing measurement type. */
	73	if (devc->measurement_mq == mq &&
	74	((devc->measurement_mq_flags & mq_flags) == mq_flags))
	75	return SR_OK;
	76
	77	for (i = 0; i < ARRAY_SIZE(sr_mq_to_cmd_map); i++) {
	78	if (sr_mq_to_cmd_map[i].mq != mq)
	79	continue;
	80
	81	ret = sr_mq_to_cmd_map[i].set_mode(scpi, mq_flags);
	82	if (ret != SR_OK)
	83	return ret;
	84
	85	ret = hp_3478a_get_status_bytes(sdi);
	86	return ret;
	87	}
	88
	89	return SR_ERR_NA;
	90	}
	91
e5137b93 FS	92	SR_PRIV int hp_3478a_set_range(const struct sr_dev_inst *sdi, int range_exp)
	93	{
	94	int ret;
	95	struct sr_scpi_dev_inst *scpi = sdi->conn;
	96	struct dev_context *devc = sdi->priv;
	97
	98	/* No need to send command if we're not changing the range. */
	99	if (devc->range_exp == range_exp)
	100	return SR_OK;
	101
	102	/* -99 is a dummy exponent for auto ranging. */
	103	if (range_exp == -99)
	104	ret = sr_scpi_send(scpi, "RA");
	105	else
	106	ret = sr_scpi_send(scpi, "R%i", range_exp);
	107	if (ret != SR_OK)
	108	return ret;
	109
	110	return hp_3478a_get_status_bytes(sdi);
	111	}
	112
d2c1730a FS	113	static int parse_range_vdc(struct dev_context *devc, uint8_t range_byte)
d2c1730a FS	114	{
e5137b93 FS	115	if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VDC_30MV) {
e5137b93 FS	116	devc->range_exp = -2;
d2c1730a	117	devc->enc_digits = devc->spec_digits - 2;
e5137b93 FS	118	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VDC_300MV) {
e5137b93 FS	119	devc->range_exp = -1;
d2c1730a	120	devc->enc_digits = devc->spec_digits - 3;
e5137b93 FS	121	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VDC_3V) {
e5137b93 FS	122	devc->range_exp = 0;
d2c1730a	123	devc->enc_digits = devc->spec_digits - 1;
e5137b93 FS	124	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VDC_30V) {
e5137b93 FS	125	devc->range_exp = 1;
d2c1730a	126	devc->enc_digits = devc->spec_digits - 2;
e5137b93 FS	127	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VDC_300V) {
e5137b93 FS	128	devc->range_exp = 2;
d2c1730a	129	devc->enc_digits = devc->spec_digits - 3;
e5137b93	130	} else
d2c1730a	131	return SR_ERR_DATA;
d2c1730a FS	132
	133	return SR_OK;
	134	}
	135
	136	static int parse_range_vac(struct dev_context *devc, uint8_t range_byte)
	137	{
e5137b93 FS	138	if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VAC_300MV) {
e5137b93 FS	139	devc->range_exp = -1;
d2c1730a	140	devc->enc_digits = devc->spec_digits - 3;
e5137b93 FS	141	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VAC_3V) {
e5137b93 FS	142	devc->range_exp = 0;
d2c1730a	143	devc->enc_digits = devc->spec_digits - 1;
e5137b93 FS	144	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VAC_30V) {
e5137b93 FS	145	devc->range_exp = 1;
d2c1730a	146	devc->enc_digits = devc->spec_digits - 2;
e5137b93 FS	147	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_VAC_300V) {
e5137b93 FS	148	devc->range_exp = 2;
d2c1730a	149	devc->enc_digits = devc->spec_digits - 3;
e5137b93	150	} else
d2c1730a	151	return SR_ERR_DATA;
d2c1730a FS	152
	153	return SR_OK;
	154	}
	155
	156	static int parse_range_a(struct dev_context *devc, uint8_t range_byte)
	157	{
e5137b93 FS	158	if ((range_byte & SB1_RANGE_BLOCK) == RANGE_A_300MA) {
e5137b93 FS	159	devc->range_exp = -1;
d2c1730a	160	devc->enc_digits = devc->spec_digits - 3;
e5137b93 FS	161	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_A_3A) {
e5137b93 FS	162	devc->range_exp = 0;
d2c1730a	163	devc->enc_digits = devc->spec_digits - 1;
e5137b93	164	} else
d2c1730a	165	return SR_ERR_DATA;
d2c1730a FS	166
	167	return SR_OK;
	168	}
	169
	170	static int parse_range_ohm(struct dev_context *devc, uint8_t range_byte)
	171	{
e5137b93 FS	172	if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_30R) {
e5137b93 FS	173	devc->range_exp = 1;
d2c1730a	174	devc->enc_digits = devc->spec_digits - 2;
e5137b93 FS	175	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_300R) {
e5137b93 FS	176	devc->range_exp = 2;
d2c1730a	177	devc->enc_digits = devc->spec_digits - 3;
e5137b93 FS	178	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_3KR) {
e5137b93 FS	179	devc->range_exp = 3;
d2c1730a	180	devc->enc_digits = devc->spec_digits - 1;
e5137b93 FS	181	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_30KR) {
e5137b93 FS	182	devc->range_exp = 4;
d2c1730a	183	devc->enc_digits = devc->spec_digits - 2;
e5137b93 FS	184	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_300KR) {
e5137b93 FS	185	devc->range_exp = 5;
d2c1730a	186	devc->enc_digits = devc->spec_digits - 3;
e5137b93 FS	187	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_3MR) {
e5137b93 FS	188	devc->range_exp = 6;
d2c1730a	189	devc->enc_digits = devc->spec_digits - 1;
e5137b93 FS	190	} else if ((range_byte & SB1_RANGE_BLOCK) == RANGE_OHM_30MR) {
e5137b93 FS	191	devc->range_exp = 7;
d2c1730a	192	devc->enc_digits = devc->spec_digits - 2;
e5137b93	193	} else
d2c1730a	194	return SR_ERR_DATA;
d2c1730a FS	195
	196	return SR_OK;
	197	}
	198
	199	static int parse_function_byte(struct dev_context *devc, uint8_t function_byte)
	200	{
acc587ff	201	/* Digits / Resolution (spec_digits must be set before range parsing) */
94cf02d0	202	if ((function_byte & SB1_DIGITS_BLOCK) == DIGITS_5_5)
a575c90e	203	devc->spec_digits = 6;
94cf02d0	204	else if ((function_byte & SB1_DIGITS_BLOCK) == DIGITS_4_5)
a575c90e	205	devc->spec_digits = 5;
94cf02d0	206	else if ((function_byte & SB1_DIGITS_BLOCK) == DIGITS_3_5)
a575c90e	207	devc->spec_digits = 4;
94cf02d0 FS	208	else
94cf02d0 FS	209	return SR_ERR_DATA;
d2c1730a FS	210
d2c1730a FS	211	/* Function + Range */
acc587ff	212	devc->measurement_mq_flags = 0;
e5137b93	213	devc->acquisition_mq_flags = 0;
d2c1730a FS	214	if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_VDC) {
	215	devc->measurement_mq = SR_MQ_VOLTAGE;
	216	devc->measurement_mq_flags \|= SR_MQFLAG_DC;
e5137b93	217	devc->acquisition_mq_flags \|= SR_MQFLAG_DC;
d2c1730a FS	218	devc->measurement_unit = SR_UNIT_VOLT;
	219	parse_range_vdc(devc, function_byte);
	220	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_VAC) {
	221	devc->measurement_mq = SR_MQ_VOLTAGE;
e5137b93 FS	222	devc->measurement_mq_flags \|= SR_MQFLAG_AC;
e5137b93 FS	223	devc->acquisition_mq_flags \|= SR_MQFLAG_AC \| SR_MQFLAG_RMS;
d2c1730a FS	224	devc->measurement_unit = SR_UNIT_VOLT;
	225	parse_range_vac(devc, function_byte);
	226	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_2WR) {
	227	devc->measurement_mq = SR_MQ_RESISTANCE;
	228	devc->measurement_unit = SR_UNIT_OHM;
	229	parse_range_ohm(devc, function_byte);
	230	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_4WR) {
	231	devc->measurement_mq = SR_MQ_RESISTANCE;
	232	devc->measurement_mq_flags \|= SR_MQFLAG_FOUR_WIRE;
e5137b93	233	devc->acquisition_mq_flags \|= SR_MQFLAG_FOUR_WIRE;
d2c1730a FS	234	devc->measurement_unit = SR_UNIT_OHM;
	235	parse_range_ohm(devc, function_byte);
	236	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_ADC) {
	237	devc->measurement_mq = SR_MQ_CURRENT;
	238	devc->measurement_mq_flags \|= SR_MQFLAG_DC;
e5137b93	239	devc->acquisition_mq_flags \|= SR_MQFLAG_DC;
d2c1730a FS	240	devc->measurement_unit = SR_UNIT_AMPERE;
	241	parse_range_a(devc, function_byte);
	242	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_AAC) {
	243	devc->measurement_mq = SR_MQ_CURRENT;
e5137b93 FS	244	devc->measurement_mq_flags \|= SR_MQFLAG_AC;
e5137b93 FS	245	devc->acquisition_mq_flags \|= SR_MQFLAG_AC \| SR_MQFLAG_RMS;
d2c1730a FS	246	devc->measurement_unit = SR_UNIT_AMPERE;
	247	parse_range_a(devc, function_byte);
	248	} else if ((function_byte & SB1_FUNCTION_BLOCK) == FUNCTION_EXR) {
	249	devc->measurement_mq = SR_MQ_RESISTANCE;
	250	devc->measurement_unit = SR_UNIT_OHM;
	251	parse_range_ohm(devc, function_byte);
	252	}
	253
d2c1730a FS	254	return SR_OK;
	255	}
	256
	257	static int parse_status_byte(struct dev_context *devc, uint8_t status_byte)
	258	{
	259	devc->trigger = TRIGGER_UNDEFINED;
	260
	261	/* External Trigger */
	262	if ((status_byte & STATUS_EXT_TRIGGER) == STATUS_EXT_TRIGGER)
	263	devc->trigger = TRIGGER_EXTERNAL;
	264
	265	/* Cal RAM */
	266	if ((status_byte & STATUS_CAL_RAM) == STATUS_CAL_RAM)
	267	devc->calibration = TRUE;
	268	else
	269	devc->calibration = FALSE;
	270
	271	/* Front/Rear terminals */
	272	if ((status_byte & STATUS_FRONT_TERMINAL) == STATUS_FRONT_TERMINAL)
	273	devc->terminal = TERMINAL_FRONT;
	274	else
	275	devc->terminal = TERMINAL_REAR;
	276
	277	/* 50Hz / 60Hz */
	278	if ((status_byte & STATUS_50HZ) == STATUS_50HZ)
	279	devc->line = LINE_50HZ;
	280	else
	281	devc->line = LINE_60HZ;
	282
	283	/* Auto-Zero */
	284	if ((status_byte & STATUS_AUTO_ZERO) == STATUS_AUTO_ZERO)
	285	devc->auto_zero = TRUE;
	286	else
	287	devc->auto_zero = FALSE;
	288
	289	/* Auto-Range */
e5137b93 FS	290	if ((status_byte & STATUS_AUTO_RANGE) == STATUS_AUTO_RANGE) {
	291	devc->acquisition_mq_flags \|= SR_MQFLAG_AUTORANGE;
	292	devc->range_exp = -99;
	293	} else
	294	devc->acquisition_mq_flags &= ~SR_MQFLAG_AUTORANGE;
d2c1730a FS	295
	296	/* Internal trigger */
	297	if ((status_byte & STATUS_INT_TRIGGER) == STATUS_INT_TRIGGER)
	298	devc->trigger = TRIGGER_INTERNAL;
	299
	300	return SR_OK;
	301	}
	302
	303	static int parse_srq_byte(uint8_t sqr_byte)
	304	{
	305	(void)sqr_byte;
	306
	307	#if 0
	308	/* The ServiceReQuest register isn't used at the moment. */
	309
	310	/* PON SRQ */
	311	if ((sqr_byte & SRQ_POWER_ON) == SRQ_POWER_ON)
6ddedf5b	312	sr_spew("Power On SRQ or clear msg received");
d2c1730a FS	313
	314	/* Cal failed SRQ */
	315	if ((sqr_byte & SRQ_CAL_FAILED) == SRQ_CAL_FAILED)
6ddedf5b	316	sr_spew("CAL failed SRQ");
d2c1730a FS	317
	318	/* Keyboard SRQ */
	319	if ((sqr_byte & SRQ_KEYBORD) == SRQ_KEYBORD)
6ddedf5b	320	sr_spew("Keyboard SRQ");
d2c1730a FS	321
	322	/* Hardware error SRQ */
	323	if ((sqr_byte & SRQ_HARDWARE_ERR) == SRQ_HARDWARE_ERR)
6ddedf5b	324	sr_spew("Hardware error SRQ");
d2c1730a FS	325
	326	/* Syntax error SRQ */
	327	if ((sqr_byte & SRQ_SYNTAX_ERR) == SRQ_SYNTAX_ERR)
6ddedf5b	328	sr_spew("Syntax error SRQ");
d2c1730a FS	329
	330	/* Every reading is available to the bus SRQ */
	331	if ((sqr_byte & SRQ_BUS_AVAIL) == SRQ_BUS_AVAIL)
6ddedf5b	332	sr_spew("Every reading is available to the bus SRQ");
d2c1730a FS	333	#endif
	334
	335	return SR_OK;
	336	}
	337
	338	static int parse_error_byte(uint8_t error_byte)
	339	{
	340	int ret;
	341
	342	ret = SR_OK;
	343
	344	/* A/D link */
	345	if ((error_byte & ERROR_AD_LINK) == ERROR_AD_LINK) {
6ddedf5b	346	sr_err("Failure in the A/D link");
d2c1730a FS	347	ret = SR_ERR;
	348	}
	349
	350	/* A/D Self Test */
	351	if ((error_byte & ERROR_AD_SELF_TEST) == ERROR_AD_SELF_TEST) {
6ddedf5b	352	sr_err("A/D has failed its internal Self Test");
d2c1730a FS	353	ret = SR_ERR;
	354	}
	355
	356	/* A/D slope error */
	357	if ((error_byte & ERROR_AD_SLOPE) == ERROR_AD_SLOPE) {
6ddedf5b	358	sr_err("There has been an A/D slope error");
d2c1730a FS	359	ret = SR_ERR;
	360	}
	361
	362	/* ROM Selt Test */
	363	if ((error_byte & ERROR_ROM_SELF_TEST) == ERROR_ROM_SELF_TEST) {
6ddedf5b	364	sr_err("The ROM Self Test has failed");
d2c1730a FS	365	ret = SR_ERR;
	366	}
	367
	368	/* RAM Selt Test */
	369	if ((error_byte & ERROR_RAM_SELF_TEST) == ERROR_RAM_SELF_TEST) {
6ddedf5b	370	sr_err("The RAM Self Test has failed");
d2c1730a FS	371	ret = SR_ERR;
	372	}
	373
	374	/* Selt Test */
	375	if ((error_byte & ERROR_SELF_TEST) == ERROR_SELF_TEST) {
6ddedf5b UH	376	sr_err("Self Test: Any of the CAL RAM locations have bad "
6ddedf5b UH	377	"checksums, or a range with a bad checksum is selected");
d2c1730a FS	378	ret = SR_ERR;
	379	}
	380
	381	return ret;
	382	}
	383
	384	SR_PRIV int hp_3478a_get_status_bytes(const struct sr_dev_inst *sdi)
	385	{
	386	int ret;
	387	char *response;
	388	uint8_t function_byte, status_byte, srq_byte, error_byte;
	389	struct sr_scpi_dev_inst *scpi = sdi->conn;
	390	struct dev_context *devc = sdi->priv;
	391
	392	ret = sr_scpi_get_string(scpi, "B", &response);
	393	if (ret != SR_OK)
	394	return ret;
	395
	396	if (!response)
	397	return SR_ERR;
	398
	399	function_byte = (uint8_t)response[0];
	400	status_byte = (uint8_t)response[1];
	401	srq_byte = (uint8_t)response[2];
	402	error_byte = (uint8_t)response[3];
	403
	404	g_free(response);
	405
	406	parse_function_byte(devc, function_byte);
	407	parse_status_byte(devc, status_byte);
	408	parse_srq_byte(srq_byte);
	409	ret = parse_error_byte(error_byte);
	410
	411	return ret;
	412	}
	413
	414	static void acq_send_measurement(struct sr_dev_inst *sdi)
	415	{
	416	struct sr_datafeed_packet packet;
	417	struct sr_datafeed_analog analog;
	418	struct sr_analog_encoding encoding;
	419	struct sr_analog_meaning meaning;
	420	struct sr_analog_spec spec;
	421	struct dev_context *devc;
	422	float f;
	423
	424	devc = sdi->priv;
	425
	426	packet.type = SR_DF_ANALOG;
	427	packet.payload = &analog;
	428
	429	sr_analog_init(&analog, &encoding, &meaning, &spec, devc->enc_digits);
	430
	431	/* TODO: Implement NAN, depending on counts, range and value. */
	432	f = devc->measurement;
	433	analog.num_samples = 1;
	434	analog.data = &f;
	435
	436	encoding.unitsize = sizeof(float);
	437	encoding.is_float = TRUE;
	438	encoding.digits = devc->enc_digits;
	439
	440	meaning.mq = devc->measurement_mq;
e5137b93	441	meaning.mqflags = devc->acquisition_mq_flags;
d2c1730a FS	442	meaning.unit = devc->measurement_unit;
	443	meaning.channels = sdi->channels;
	444
	445	spec.spec_digits = devc->spec_digits;
	446
	447	sr_session_send(sdi, &packet);
	448	}
	449
1d9eebf4 FS	450	SR_PRIV int hp_3478a_receive_data(int fd, int revents, void *cb_data)
1d9eebf4 FS	451	{
d2c1730a FS	452	struct sr_scpi_dev_inst *scpi;
d2c1730a FS	453	struct sr_dev_inst *sdi;
1d9eebf4	454	struct dev_context *devc;
02d4db35	455	char status_register;
1d9eebf4 FS	456
1d9eebf4 FS	457	(void)fd;
d2c1730a	458	(void)revents;
1d9eebf4	459
d2c1730a	460	if (!(sdi = cb_data) \|\| !(devc = sdi->priv))
1d9eebf4 FS	461	return TRUE;
1d9eebf4 FS	462
d2c1730a	463	scpi = sdi->conn;
1d9eebf4	464
d2c1730a	465	/*
02d4db35 FS	466	* TODO: Wait for SRQ from the DMM when a new measurement is available.
	467	* For now, we don't wait for a SRQ, but just do a SPoll and
	468	* check the Data Ready bit (0x01).
	469	* This is necessary, because (1) reading a value will block the
	470	* bus until a measurement is available and (2) when switching
	471	* ranges, there could be a timeout.
d2c1730a	472	*/
02d4db35 FS	473	if (sr_scpi_gpib_spoll(scpi, &status_register) != SR_OK)
	474	return FALSE;
	475	if (!(((uint8_t)status_register) & 0x01))
	476	return TRUE;
	477
	478	/* Get a reading from the DMM. */
	479	if (sr_scpi_get_double(scpi, NULL, &devc->measurement) != SR_OK)
d2c1730a FS	480	return FALSE;
	481
	482	/*
02d4db35 FS	483	* This is necessary to get the actual range for the encoding digits.
	484	* Must be called after reading the value, because it resets the
	485	* status register!
d2c1730a	486	*/
02d4db35	487	if (hp_3478a_get_status_bytes(sdi) != SR_OK)
d2c1730a FS	488	return FALSE;
	489
	490	acq_send_measurement(sdi);
	491	sr_sw_limits_update_samples_read(&devc->limits, 1);
	492
	493	if (sr_sw_limits_check(&devc->limits))
	494	sr_dev_acquisition_stop(sdi);
1d9eebf4 FS	495
	496	return TRUE;
	497	}