[libsigrok.git] / src / hardware / brymen-dmm / parser.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2012 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 "protocol.h"

#define MAX_PACKET_LEN 22

/* Flags passed from the DMM. */
struct brymen_flags {
	gboolean is_low_batt, is_decibel, is_duty_cycle, is_hertz, is_amp;
	gboolean is_beep, is_ohm, is_fahrenheit, is_celsius, is_capacitance;
	gboolean is_diode, is_volt, is_dc, is_ac;
};

struct bm850_command {
	uint8_t dle;
	uint8_t stx;
	uint8_t cmd;
	uint8_t arg[2];
	uint8_t checksum;
	uint8_t dle2;
	uint8_t etx;
};

struct brymen_header {
	uint8_t dle;
	uint8_t stx;
	uint8_t cmd;
	uint8_t len;
};

struct brymen_tail {
	uint8_t checksum;
	uint8_t dle;
	uint8_t etx;
};

/*
 * We only have one command because we only support the BM-857. However, the
 * driver is easily extensible to support more models, as the protocols are
 * very similar.
 */
enum {
	BM_CMD_REQUEST_READING = 0x00,
};

static int bm_send_command(uint8_t command, uint8_t arg1, uint8_t arg2,
			   struct sr_serial_dev_inst *serial)
{
	struct bm850_command cmdout;
	int written;

	cmdout.dle = 0x10;
	cmdout.stx = 0x02;
	cmdout.cmd = command;
	cmdout.arg[0] = arg1;
	cmdout.arg[1] = arg2;
	cmdout.checksum = arg1 ^ arg2;
	cmdout.dle2 = 0x10;
	cmdout.etx = 0x03;

	/* TODO: How to compute the checksum? Hardware seems to ignore it. */

	/* Request reading. */
	written = serial_write_blocking(serial, &cmdout, sizeof(cmdout),
			serial_timeout(serial, sizeof(cmdout)));
	if (written != sizeof(cmdout))
		return SR_ERR;

	return SR_OK;
}

SR_PRIV int brymen_packet_request(struct sr_serial_dev_inst *serial)
{
	return bm_send_command(BM_CMD_REQUEST_READING, 0, 0, serial);
}

SR_PRIV int brymen_packet_length(const uint8_t *buf, int *len)
{
	struct brymen_header *hdr;
	int packet_len;
	size_t buflen;

	buflen = *len;
	hdr = (void *)buf;

	/* Did we receive a complete header yet? */
	if (buflen < sizeof(*hdr))
		return PACKET_NEED_MORE_DATA;

	if (hdr->dle != 0x10 || hdr->stx != 0x02)
		return PACKET_INVALID_HEADER;

	/* Our packet includes the header, the payload, and the tail. */
	packet_len = sizeof(*hdr) + hdr->len + sizeof(struct brymen_tail);

	/* In case we pick up an invalid header, limit our search. */
	if (packet_len > MAX_PACKET_LEN) {
		sr_spew("Header specifies an invalid payload length: %i.",
			hdr->len);
		return PACKET_INVALID_HEADER;
	}

	*len = packet_len;
	sr_spew("Expecting a %d-byte packet.", *len);
	return PACKET_HEADER_OK;
}

SR_PRIV gboolean brymen_packet_is_valid(const uint8_t *buf)
{
	struct brymen_header *hdr;
	struct brymen_tail *tail;
	int i;
	uint8_t chksum = 0;
	uint8_t *payload;

	payload = (uint8_t *)(buf + sizeof(struct brymen_header));

	hdr = (void *)buf;
	tail = (void *)(payload + hdr->len);

	for (i = 0; i< hdr->len; i++)
		chksum ^= payload[i];

	if (tail->checksum != chksum) {
		sr_dbg("Packet has invalid checksum 0x%.2x. Expected 0x%.2x.",
		       chksum, tail->checksum);
		return FALSE;
	}

	return TRUE;
}

static int parse_value(const char *txt, size_t len, float *floatval)
{
	const char *txt_end;
	char c, buf[32], *dst;
	int ret;

	/*
	 * The input text is not NUL terminated, the checksum follows
	 * the value text field. Spaces may interfere with the text to
	 * number conversion, especially with exponent parsing. Copy the
	 * input data to a terminated text buffer and strip spaces in the
	 * process, before running ASCIIZ string operations.
	 */
	if (len >= sizeof(buf)) {
		sr_err("Insufficient text conversion buffer size.");
		return SR_ERR_BUG;
	}
	txt_end = txt + len;
	dst = &buf[0];
	while (txt < txt_end && *txt) {
		c = *txt++;
		if (c == ' ')
			continue;
		*dst++ = c;
	}
	*dst = '\0';

	/* Check for overflow, or get the number value. */
	if (strstr(buf, "+OL")) {
		*floatval = +INFINITY;
		return SR_OK;
	}
	if (strstr(buf, "-OL")) {
		*floatval = -INFINITY;
		return SR_OK;
	}
	if (strstr(buf, "OL")) {
		*floatval = INFINITY;
		return SR_OK;
	}
	ret = sr_atof_ascii(buf, floatval);
	if (ret != SR_OK)
		return ret;

	return SR_OK;
}

static void parse_flags(const uint8_t *bfunc, struct brymen_flags *info)
{
	info->is_low_batt	= (bfunc[3] & (1 << 7)) != 0;

	info->is_decibel	= (bfunc[1] & (1 << 5)) != 0;
	info->is_duty_cycle	= (bfunc[1] & (1 << 3)) != 0;
	info->is_hertz		= (bfunc[1] & (1 << 2)) != 0;
	info->is_amp		= (bfunc[1] & (1 << 1)) != 0;
	info->is_beep		= (bfunc[1] & (1 << 0)) != 0;

	info->is_ohm		= (bfunc[0] & (1 << 7)) != 0;
	info->is_fahrenheit	= (bfunc[0] & (1 << 6)) != 0;
	info->is_celsius	= (bfunc[0] & (1 << 5)) != 0;
	info->is_diode		= (bfunc[0] & (1 << 4)) != 0;
	info->is_capacitance	= (bfunc[0] & (1 << 3)) != 0;
	info->is_volt		= (bfunc[0] & (1 << 2)) != 0;
	info->is_dc		= (bfunc[0] & (1 << 1)) != 0;
	info->is_ac		= (bfunc[0] & (1 << 0)) != 0;
}

SR_PRIV int brymen_parse(const uint8_t *buf, float *floatval,
		struct sr_datafeed_analog *analog, void *info)
{
	struct brymen_flags flags;
	struct brymen_header *hdr;
	uint8_t *bfunc;
	const char *txt;
	int txtlen;
	int ret;

	(void)info;

	hdr = (void *)buf;
	bfunc = (uint8_t *)(buf + sizeof(struct brymen_header));
	txt = (const char *)&bfunc[4];
	txtlen = hdr->len - 4;
	sr_dbg("DMM bfunc: %02x %02x %02x %02x, text '%.*s'",
		bfunc[3], bfunc[2], bfunc[1], bfunc[0], txtlen, txt);

	memset(&flags, 0, sizeof(flags));
	parse_flags(bfunc, &flags);
	ret = parse_value(txt, txtlen, floatval);
	sr_dbg("floatval: %f, ret %d", *floatval, ret);
	if (ret != SR_OK)
		return SR_ERR;

	analog->meaning->mqflags = 0;
	if (flags.is_volt) {
		analog->meaning->mq = SR_MQ_VOLTAGE;
		analog->meaning->unit = SR_UNIT_VOLT;
	}
	if (flags.is_amp) {
		analog->meaning->mq = SR_MQ_CURRENT;
		analog->meaning->unit = SR_UNIT_AMPERE;
	}
	if (flags.is_ohm) {
		if (flags.is_beep)
			analog->meaning->mq = SR_MQ_CONTINUITY;
		else
			analog->meaning->mq = SR_MQ_RESISTANCE;
		analog->meaning->unit = SR_UNIT_OHM;
	}
	if (flags.is_hertz) {
		analog->meaning->mq = SR_MQ_FREQUENCY;
		analog->meaning->unit = SR_UNIT_HERTZ;
	}
	if (flags.is_duty_cycle) {
		analog->meaning->mq = SR_MQ_DUTY_CYCLE;
		analog->meaning->unit = SR_UNIT_PERCENTAGE;
	}
	if (flags.is_capacitance) {
		analog->meaning->mq = SR_MQ_CAPACITANCE;
		analog->meaning->unit = SR_UNIT_FARAD;
	}
	if (flags.is_fahrenheit) {
		analog->meaning->mq = SR_MQ_TEMPERATURE;
		analog->meaning->unit = SR_UNIT_FAHRENHEIT;
	}
	if (flags.is_celsius) {
		analog->meaning->mq = SR_MQ_TEMPERATURE;
		analog->meaning->unit = SR_UNIT_CELSIUS;
	}
	if (flags.is_capacitance) {
		analog->meaning->mq = SR_MQ_CAPACITANCE;
		analog->meaning->unit = SR_UNIT_FARAD;
	}

	/*
	 * The high-end Brymen models have a configurable reference impedance.
	 * When the reference impedance is changed, the DMM sends one packet
	 * with the value of the new reference impedance. Both decibel and ohm
	 * flags are set in this case, so we must be careful to correctly
	 * identify the value as ohm, not dBmW.
	 */
	if (flags.is_decibel && !flags.is_ohm) {
		analog->meaning->mq = SR_MQ_POWER;
		analog->meaning->unit = SR_UNIT_DECIBEL_MW;
		/*
		 * For some reason, dBm measurements are sent by the multimeter
		 * with a value three orders of magnitude smaller than the
		 * displayed value.
		 */
		*floatval *= 1000;
	}

	if (flags.is_diode)
		analog->meaning->mqflags |= SR_MQFLAG_DIODE | SR_MQFLAG_DC;
	/* We can have both AC+DC in a single measurement. */
	if (flags.is_ac)
		analog->meaning->mqflags |= SR_MQFLAG_AC;
	if (flags.is_dc)
		analog->meaning->mqflags |= SR_MQFLAG_DC;

	if (flags.is_low_batt)
		sr_warn("Low battery!");

	return SR_OK;
}
Commit	Line	Data
	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2012 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>
	21	#include "protocol.h"
	22
	23	#define MAX_PACKET_LEN 22
	24
	25	/* Flags passed from the DMM. */
	26	struct brymen_flags {
	27	gboolean is_low_batt, is_decibel, is_duty_cycle, is_hertz, is_amp;
	28	gboolean is_beep, is_ohm, is_fahrenheit, is_celsius, is_capacitance;
	29	gboolean is_diode, is_volt, is_dc, is_ac;
	30	};
	31
	32	struct bm850_command {
	33	uint8_t dle;
	34	uint8_t stx;
	35	uint8_t cmd;
	36	uint8_t arg[2];
	37	uint8_t checksum;
	38	uint8_t dle2;
	39	uint8_t etx;
	40	};
	41
	42	struct brymen_header {
	43	uint8_t dle;
	44	uint8_t stx;
	45	uint8_t cmd;
	46	uint8_t len;
	47	};
	48
	49	struct brymen_tail {
	50	uint8_t checksum;
	51	uint8_t dle;
	52	uint8_t etx;
	53	};
	54
	55	/*
	56	* We only have one command because we only support the BM-857. However, the
	57	* driver is easily extensible to support more models, as the protocols are
	58	* very similar.
	59	*/
	60	enum {
	61	BM_CMD_REQUEST_READING = 0x00,
	62	};
	63
	64	static int bm_send_command(uint8_t command, uint8_t arg1, uint8_t arg2,
	65	struct sr_serial_dev_inst *serial)
	66	{
	67	struct bm850_command cmdout;
	68	int written;
	69
	70	cmdout.dle = 0x10;
	71	cmdout.stx = 0x02;
	72	cmdout.cmd = command;
	73	cmdout.arg[0] = arg1;
	74	cmdout.arg[1] = arg2;
	75	cmdout.checksum = arg1 ^ arg2;
	76	cmdout.dle2 = 0x10;
	77	cmdout.etx = 0x03;
	78
	79	/* TODO: How to compute the checksum? Hardware seems to ignore it. */
	80
	81	/* Request reading. */
	82	written = serial_write_blocking(serial, &cmdout, sizeof(cmdout),
	83	serial_timeout(serial, sizeof(cmdout)));
	84	if (written != sizeof(cmdout))
	85	return SR_ERR;
	86
	87	return SR_OK;
	88	}
	89
	90	SR_PRIV int brymen_packet_request(struct sr_serial_dev_inst *serial)
	91	{
	92	return bm_send_command(BM_CMD_REQUEST_READING, 0, 0, serial);
	93	}
	94
	95	SR_PRIV int brymen_packet_length(const uint8_t buf, int len)
	96	{
	97	struct brymen_header *hdr;
	98	int packet_len;
	99	size_t buflen;
	100
	101	buflen = *len;
	102	hdr = (void *)buf;
	103
	104	/* Did we receive a complete header yet? */
	105	if (buflen < sizeof(*hdr))
	106	return PACKET_NEED_MORE_DATA;
	107
	108	if (hdr->dle != 0x10 \|\| hdr->stx != 0x02)
	109	return PACKET_INVALID_HEADER;
	110
	111	/* Our packet includes the header, the payload, and the tail. */
	112	packet_len = sizeof(*hdr) + hdr->len + sizeof(struct brymen_tail);
	113
	114	/* In case we pick up an invalid header, limit our search. */
	115	if (packet_len > MAX_PACKET_LEN) {
	116	sr_spew("Header specifies an invalid payload length: %i.",
	117	hdr->len);
	118	return PACKET_INVALID_HEADER;
	119	}
	120
	121	*len = packet_len;
	122	sr_spew("Expecting a %d-byte packet.", *len);
	123	return PACKET_HEADER_OK;
	124	}
	125
	126	SR_PRIV gboolean brymen_packet_is_valid(const uint8_t *buf)
	127	{
	128	struct brymen_header *hdr;
	129	struct brymen_tail *tail;
	130	int i;
	131	uint8_t chksum = 0;
	132	uint8_t *payload;
	133
	134	payload = (uint8_t *)(buf + sizeof(struct brymen_header));
	135
	136	hdr = (void *)buf;
	137	tail = (void *)(payload + hdr->len);
	138
	139	for (i = 0; i< hdr->len; i++)
	140	chksum ^= payload[i];
	141
	142	if (tail->checksum != chksum) {
	143	sr_dbg("Packet has invalid checksum 0x%.2x. Expected 0x%.2x.",
	144	chksum, tail->checksum);
	145	return FALSE;
	146	}
	147
	148	return TRUE;
	149	}
	150
	151	static int parse_value(const char txt, size_t len, float floatval)
	152	{
	153	const char *txt_end;
	154	char c, buf[32], *dst;
	155	int ret;
	156
	157	/*
	158	* The input text is not NUL terminated, the checksum follows
	159	* the value text field. Spaces may interfere with the text to
	160	* number conversion, especially with exponent parsing. Copy the
	161	* input data to a terminated text buffer and strip spaces in the
	162	* process, before running ASCIIZ string operations.
	163	*/
	164	if (len >= sizeof(buf)) {
	165	sr_err("Insufficient text conversion buffer size.");
	166	return SR_ERR_BUG;
	167	}
	168	txt_end = txt + len;
	169	dst = &buf[0];
	170	while (txt < txt_end && *txt) {
	171	c = *txt++;
	172	if (c == ' ')
	173	continue;
	174	*dst++ = c;
	175	}
	176	*dst = '\0';
	177
	178	/* Check for overflow, or get the number value. */
	179	if (strstr(buf, "+OL")) {
	180	*floatval = +INFINITY;
	181	return SR_OK;
	182	}
	183	if (strstr(buf, "-OL")) {
	184	*floatval = -INFINITY;
	185	return SR_OK;
	186	}
	187	if (strstr(buf, "OL")) {
	188	*floatval = INFINITY;
	189	return SR_OK;
	190	}
	191	ret = sr_atof_ascii(buf, floatval);
	192	if (ret != SR_OK)
	193	return ret;
	194
	195	return SR_OK;
	196	}
	197
	198	static void parse_flags(const uint8_t bfunc, struct brymen_flags info)
	199	{
	200	info->is_low_batt = (bfunc[3] & (1 << 7)) != 0;
	201
	202	info->is_decibel = (bfunc[1] & (1 << 5)) != 0;
	203	info->is_duty_cycle = (bfunc[1] & (1 << 3)) != 0;
	204	info->is_hertz = (bfunc[1] & (1 << 2)) != 0;
	205	info->is_amp = (bfunc[1] & (1 << 1)) != 0;
	206	info->is_beep = (bfunc[1] & (1 << 0)) != 0;
	207
	208	info->is_ohm = (bfunc[0] & (1 << 7)) != 0;
	209	info->is_fahrenheit = (bfunc[0] & (1 << 6)) != 0;
	210	info->is_celsius = (bfunc[0] & (1 << 5)) != 0;
	211	info->is_diode = (bfunc[0] & (1 << 4)) != 0;
	212	info->is_capacitance = (bfunc[0] & (1 << 3)) != 0;
	213	info->is_volt = (bfunc[0] & (1 << 2)) != 0;
	214	info->is_dc = (bfunc[0] & (1 << 1)) != 0;
	215	info->is_ac = (bfunc[0] & (1 << 0)) != 0;
	216	}
	217
	218	SR_PRIV int brymen_parse(const uint8_t buf, float floatval,
	219	struct sr_datafeed_analog analog, void info)
	220	{
	221	struct brymen_flags flags;
	222	struct brymen_header *hdr;
	223	uint8_t *bfunc;
	224	const char *txt;
	225	int txtlen;
	226	int ret;
	227
	228	(void)info;
	229
	230	hdr = (void *)buf;
	231	bfunc = (uint8_t *)(buf + sizeof(struct brymen_header));
	232	txt = (const char *)&bfunc[4];
	233	txtlen = hdr->len - 4;
	234	sr_dbg("DMM bfunc: %02x %02x %02x %02x, text '%.*s'",
	235	bfunc[3], bfunc[2], bfunc[1], bfunc[0], txtlen, txt);
	236
	237	memset(&flags, 0, sizeof(flags));
	238	parse_flags(bfunc, &flags);
	239	ret = parse_value(txt, txtlen, floatval);
	240	sr_dbg("floatval: %f, ret %d", *floatval, ret);
	241	if (ret != SR_OK)
	242	return SR_ERR;
	243
	244	analog->meaning->mqflags = 0;
	245	if (flags.is_volt) {
	246	analog->meaning->mq = SR_MQ_VOLTAGE;
	247	analog->meaning->unit = SR_UNIT_VOLT;
	248	}
	249	if (flags.is_amp) {
	250	analog->meaning->mq = SR_MQ_CURRENT;
	251	analog->meaning->unit = SR_UNIT_AMPERE;
	252	}
	253	if (flags.is_ohm) {
	254	if (flags.is_beep)
	255	analog->meaning->mq = SR_MQ_CONTINUITY;
	256	else
	257	analog->meaning->mq = SR_MQ_RESISTANCE;
	258	analog->meaning->unit = SR_UNIT_OHM;
	259	}
	260	if (flags.is_hertz) {
	261	analog->meaning->mq = SR_MQ_FREQUENCY;
	262	analog->meaning->unit = SR_UNIT_HERTZ;
	263	}
	264	if (flags.is_duty_cycle) {
	265	analog->meaning->mq = SR_MQ_DUTY_CYCLE;
	266	analog->meaning->unit = SR_UNIT_PERCENTAGE;
	267	}
	268	if (flags.is_capacitance) {
	269	analog->meaning->mq = SR_MQ_CAPACITANCE;
	270	analog->meaning->unit = SR_UNIT_FARAD;
	271	}
	272	if (flags.is_fahrenheit) {
	273	analog->meaning->mq = SR_MQ_TEMPERATURE;
	274	analog->meaning->unit = SR_UNIT_FAHRENHEIT;
	275	}
	276	if (flags.is_celsius) {
	277	analog->meaning->mq = SR_MQ_TEMPERATURE;
	278	analog->meaning->unit = SR_UNIT_CELSIUS;
	279	}
	280	if (flags.is_capacitance) {
	281	analog->meaning->mq = SR_MQ_CAPACITANCE;
	282	analog->meaning->unit = SR_UNIT_FARAD;
	283	}
	284
	285	/*
	286	* The high-end Brymen models have a configurable reference impedance.
	287	* When the reference impedance is changed, the DMM sends one packet
	288	* with the value of the new reference impedance. Both decibel and ohm
	289	* flags are set in this case, so we must be careful to correctly
	290	* identify the value as ohm, not dBmW.
	291	*/
	292	if (flags.is_decibel && !flags.is_ohm) {
	293	analog->meaning->mq = SR_MQ_POWER;
	294	analog->meaning->unit = SR_UNIT_DECIBEL_MW;
	295	/*
	296	* For some reason, dBm measurements are sent by the multimeter
	297	* with a value three orders of magnitude smaller than the
	298	* displayed value.
	299	*/
	300	floatval = 1000;
	301	}
	302
	303	if (flags.is_diode)
	304	analog->meaning->mqflags \|= SR_MQFLAG_DIODE \| SR_MQFLAG_DC;
	305	/* We can have both AC+DC in a single measurement. */
	306	if (flags.is_ac)
	307	analog->meaning->mqflags \|= SR_MQFLAG_AC;
	308	if (flags.is_dc)
	309	analog->meaning->mqflags \|= SR_MQFLAG_DC;
	310
	311	if (flags.is_low_batt)
	312	sr_warn("Low battery!");
	313
	314	return SR_OK;
	315	}