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

/*
 * This file is part of the sigrok 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 "protocol.h"
#include <stdlib.h>
#include <string.h>
#include <math.h>

/*
 * Flags passed from the DMM.
 */
struct brymen_flags {
	gboolean low_batt;
	gboolean decibel, duty_cycle, hertz, amp, beep, ohm, fahrenheit;
	gboolean celsius, capacitance, diode, volt, dc, 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 = {
		.dle = 0x10, .stx = 0x02,
		.cmd = command,
		.arg = {arg1, arg2},
		.checksum = arg1^arg2, .dle2 = 0x10, .etx = 0x03};
		int written;
		
		/* TODO: How do we compute the checksum? Hardware seems to ignore it */
		
		/* Request reading */
		written = serial_write(serial, &cmdout, 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;
	const int brymen_max_packet_len = 22;
	int packet_len;
	const size_t 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 > brymen_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;
	const uint8_t *payload = 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 *strbuf, const int len, float *floatval)
{
	int s, d;
	char str[32];

	if (strstr(strbuf, "OL")) {
		sr_dbg("Overlimit.");
		*floatval = INFINITY;
		return SR_OK;
	}

	memset(str, 0, sizeof(str));
	/* Spaces may interfere with strtod parsing the exponent. Strip them */
	for (s = 0, d = 0; s < len; s++)
		if (strbuf[s] != ' ')
			str[d++] = strbuf[s];
		/* YES, it's that simple !*/
		*floatval = strtod(str, NULL);

	return SR_OK;
}
static void parse_flags(const uint8_t *buf, struct brymen_flags *info)
{
	const uint8_t * bfunc = buf + sizeof(struct brymen_header);

	info->low_batt		= (bfunc[3] & (1 << 7)) != 0;

	info->decibel		= (bfunc[1] & (1 << 5)) != 0;
	info->duty_cycle	= (bfunc[1] & (1 << 3)) != 0;
	info->hertz		= (bfunc[1] & (1 << 2)) != 0;
	info->amp		= (bfunc[1] & (1 << 1)) != 0;
	info->beep		= (bfunc[1] & (1 << 0)) != 0;

	info->ohm		= (bfunc[0] & (1 << 7)) != 0;
	info->fahrenheit	= (bfunc[0] & (1 << 6)) != 0;
	info->celsius		= (bfunc[0] & (1 << 5)) != 0;
	info->diode		= (bfunc[0] & (1 << 4)) != 0;
	info->capacitance	= (bfunc[0] & (1 << 3)) != 0;
	info->volt		= (bfunc[0] & (1 << 2)) != 0;
	info->dc		= (bfunc[0] & (1 << 1)) != 0;
	info->ac		= (bfunc[0] & (1 << 0)) != 0;
}

SR_PRIV int sr_brymen_parse(const uint8_t *buf, float *floatval,
			    struct sr_datafeed_analog *analog, void *info)
{
	struct brymen_flags flags;
	struct brymen_header *hdr = (void*) buf;
	const uint8_t *bfunc = buf + sizeof(struct brymen_header);
	int asciilen;

	(void)info;
	analog->mqflags = 0;

	/* Give some debug info about the package */
	asciilen = hdr->len - 4;
	sr_dbg("DMM flags: %.2x %.2x %.2x %.2x",
	       bfunc[3], bfunc[2], bfunc[1], bfunc[0]);
	/* Value is an ASCII string */
	sr_dbg("DMM packet: \"%.*s\"", asciilen, bfunc + 4);

	parse_flags(buf, &flags);
	parse_value((const char*)(bfunc + 4), asciilen, floatval);

	if (flags.volt) {
		analog->mq = SR_MQ_VOLTAGE;
		analog->unit = SR_UNIT_VOLT;
	}
	if (flags.amp) {
		analog->mq = SR_MQ_CURRENT;
		analog->unit = SR_UNIT_AMPERE;
	}
	if (flags.ohm) {
		if (flags.beep)
			analog->mq = SR_MQ_CONTINUITY;
		else
			analog->mq = SR_MQ_RESISTANCE;
		analog->unit = SR_UNIT_OHM;
	}
	if (flags.hertz) {
		analog->mq = SR_MQ_FREQUENCY;
		analog->unit = SR_UNIT_HERTZ;
	}
	if (flags.duty_cycle) {
		analog->mq = SR_MQ_DUTY_CYCLE;
		analog->unit = SR_UNIT_PERCENTAGE;
	}
	if (flags.capacitance) {
		analog->mq = SR_MQ_CAPACITANCE;
		analog->unit = SR_UNIT_FARAD;
	}
	if (flags.fahrenheit) {
		analog->mq = SR_MQ_TEMPERATURE;
		analog->unit = SR_UNIT_FAHRENHEIT;
	}
	if (flags.celsius) {
		analog->mq = SR_MQ_TEMPERATURE;
		analog->unit = SR_UNIT_CELSIUS;
	}
	if (flags.capacitance) {
		analog->mq = SR_MQ_CAPACITANCE;
		analog->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.decibel && !flags.ohm) {
		analog->mq = SR_MQ_POWER;
		analog->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.diode)
		analog->mqflags |= SR_MQFLAG_DIODE;
	/* We can have both AC+DC in a single measurement */
	if (flags.ac)
		analog->mqflags |= SR_MQFLAG_AC;
	if (flags.dc)
		analog->mqflags |= SR_MQFLAG_DC;

	if (flags.low_batt)
		sr_info("Low battery!");

	return SR_OK;
}
Commit	Line	Data
601fb67c AG	1	/*
	2	* This file is part of the sigrok 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 "protocol.h"
	21	#include <stdlib.h>
	22	#include <string.h>
	23	#include <math.h>
	24
	25	/*
	26	* Flags passed from the DMM.
	27	*/
	28	struct brymen_flags {
	29	gboolean low_batt;
	30	gboolean decibel, duty_cycle, hertz, amp, beep, ohm, fahrenheit;
	31	gboolean celsius, capacitance, diode, volt, dc, ac;
	32	};
	33
	34	struct bm850_command {
	35	uint8_t dle;
	36	uint8_t stx;
	37	uint8_t cmd;
	38	uint8_t arg[2];
	39	uint8_t checksum;
	40	uint8_t dle2;
	41	uint8_t etx;
	42	};
	43
	44	struct brymen_header {
	45	uint8_t dle;
	46	uint8_t stx;
	47	uint8_t cmd;
	48	uint8_t len;
	49	};
	50
	51	struct brymen_tail {
	52	uint8_t checksum;
	53	uint8_t dle;
	54	uint8_t etx;
	55	};
	56
	57	/*
	58	* We only have one command because we only support the BM-857. However, the
	59	* driver is easily extensible to support more models, as the protocols are very
	60	* similar.
	61	*/
	62	enum {
	63	BM_CMD_REQUEST_READING = 0x00,
	64	};
65
66
67	static int bm_send_command(uint8_t command, uint8_t arg1, uint8_t arg2,
68	struct sr_serial_dev_inst *serial)
69	{
70	struct bm850_command cmdout = {
71	.dle = 0x10, .stx = 0x02,
72	.cmd = command,
73	.arg = {arg1, arg2},
74	.checksum = arg1^arg2, .dle2 = 0x10, .etx = 0x03};
75	int written;
76
77	/* TODO: How do we compute the checksum? Hardware seems to ignore it */
78
79	/* Request reading */
80	written = serial_write(serial, &cmdout, sizeof(cmdout));
81	if(written != sizeof(cmdout))
82	return SR_ERR;
83
84	return SR_OK;
85	}
86
87	SR_PRIV int brymen_packet_request(struct sr_serial_dev_inst *serial)
88	{
89	return bm_send_command(BM_CMD_REQUEST_READING, 0, 0, serial);
90	}
91
92	SR_PRIV int brymen_packet_length(const uint8_t buf, int len)
93	{
94	struct brymen_header *hdr;
95	const int brymen_max_packet_len = 22;
96	int packet_len;
97	const size_t buflen = *len;
98
99	hdr = (void*)buf;
100
101	/* Did we receive a complete header yet? */
102	if (buflen < sizeof(*hdr) )
103	return PACKET_NEED_MORE_DATA;
104
105	if (hdr->dle != 0x10 \|\| hdr->stx != 0x02)
106	return PACKET_INVALID_HEADER;
107
108	/* Our packet includes the header, the payload, and the tail */
109	packet_len = sizeof(*hdr) + hdr->len + sizeof(struct brymen_tail);
110
111	/* In case we pick up an invalid header, limit our search */
112	if (packet_len > brymen_max_packet_len) {
113	sr_spew("Header specifies an invalid payload length: %i.",
114	hdr->len);
115	return PACKET_INVALID_HEADER;
116	}
117
118	*len = packet_len;
119	sr_spew("Expecting a %d-byte packet.", *len);
120	return PACKET_HEADER_OK;
121	}
122
123	SR_PRIV gboolean brymen_packet_is_valid(const uint8_t *buf)
124	{
125	struct brymen_header *hdr;
126	struct brymen_tail *tail;
127	int i;
128	uint8_t chksum = 0;
129	const uint8_t *payload = buf + sizeof(struct brymen_header);
130
131	hdr = (void*)buf;
132	tail = (void*)(payload + hdr->len);
133
134	for (i = 0; i< hdr->len; i++)
135	chksum ^= payload[i];
136
137	if (tail->checksum != chksum) {
138	sr_dbg("Packet has invalid checksum 0x%.2x. Expected 0x%.2x",
139	chksum, tail->checksum);
140	return FALSE;
141	}
142
143	return TRUE;
144	}
145
146	static int parse_value(const char strbuf, const int len, float floatval)
147	{
148	int s, d;
149	char str[32];
150
151	if (strstr(strbuf, "OL")) {
152	sr_dbg("Overlimit.");
153	*floatval = INFINITY;
154	return SR_OK;
155	}
156
157	memset(str, 0, sizeof(str));
158	/* Spaces may interfere with strtod parsing the exponent. Strip them */
159	for (s = 0, d = 0; s < len; s++)
160	if (strbuf[s] != ' ')
161	str[d++] = strbuf[s];
162	/* YES, it's that simple !*/
163	*floatval = strtod(str, NULL);
164
165	return SR_OK;
166	}
167	static void parse_flags(const uint8_t buf, struct brymen_flags info)
168	{
169	const uint8_t * bfunc = buf + sizeof(struct brymen_header);
170
171	info->low_batt = (bfunc[3] & (1 << 7)) != 0;
172
173	info->decibel = (bfunc[1] & (1 << 5)) != 0;
174	info->duty_cycle = (bfunc[1] & (1 << 3)) != 0;
175	info->hertz = (bfunc[1] & (1 << 2)) != 0;
176	info->amp = (bfunc[1] & (1 << 1)) != 0;
177	info->beep = (bfunc[1] & (1 << 0)) != 0;
178
179	info->ohm = (bfunc[0] & (1 << 7)) != 0;
180	info->fahrenheit = (bfunc[0] & (1 << 6)) != 0;
181	info->celsius = (bfunc[0] & (1 << 5)) != 0;
182	info->diode = (bfunc[0] & (1 << 4)) != 0;
183	info->capacitance = (bfunc[0] & (1 << 3)) != 0;
184	info->volt = (bfunc[0] & (1 << 2)) != 0;
185	info->dc = (bfunc[0] & (1 << 1)) != 0;
186	info->ac = (bfunc[0] & (1 << 0)) != 0;
187	}
188
189	SR_PRIV int sr_brymen_parse(const uint8_t buf, float floatval,
190	struct sr_datafeed_analog analog, void info)
191	{
192	struct brymen_flags flags;
193	struct brymen_header hdr = (void) buf;
194	const uint8_t *bfunc = buf + sizeof(struct brymen_header);
195	int asciilen;
196
197	(void)info;
198	analog->mqflags = 0;
199
200	/* Give some debug info about the package */
201	asciilen = hdr->len - 4;
202	sr_dbg("DMM flags: %.2x %.2x %.2x %.2x",
203	bfunc[3], bfunc[2], bfunc[1], bfunc[0]);
204	/* Value is an ASCII string */
205	sr_dbg("DMM packet: \"%.*s\"", asciilen, bfunc + 4);
206
207	parse_flags(buf, &flags);
208	parse_value((const char*)(bfunc + 4), asciilen, floatval);
209
210	if (flags.volt) {
211	analog->mq = SR_MQ_VOLTAGE;
212	analog->unit = SR_UNIT_VOLT;
213	}
214	if (flags.amp) {
215	analog->mq = SR_MQ_CURRENT;
216	analog->unit = SR_UNIT_AMPERE;
217	}
218	if (flags.ohm) {
219	if (flags.beep)
220	analog->mq = SR_MQ_CONTINUITY;
221	else
222	analog->mq = SR_MQ_RESISTANCE;
223	analog->unit = SR_UNIT_OHM;
224	}
225	if (flags.hertz) {
226	analog->mq = SR_MQ_FREQUENCY;
227	analog->unit = SR_UNIT_HERTZ;
228	}
229	if (flags.duty_cycle) {
230	analog->mq = SR_MQ_DUTY_CYCLE;
231	analog->unit = SR_UNIT_PERCENTAGE;
232	}
233	if (flags.capacitance) {
234	analog->mq = SR_MQ_CAPACITANCE;
235	analog->unit = SR_UNIT_FARAD;
236	}
237	if (flags.fahrenheit) {
238	analog->mq = SR_MQ_TEMPERATURE;
239	analog->unit = SR_UNIT_FAHRENHEIT;
240	}
241	if (flags.celsius) {
242	analog->mq = SR_MQ_TEMPERATURE;
243	analog->unit = SR_UNIT_CELSIUS;
244	}
245	if (flags.capacitance) {
246	analog->mq = SR_MQ_CAPACITANCE;
247	analog->unit = SR_UNIT_FARAD;
248	}
249	/*
250	* The high-end brymen models have a configurable reference impedance.
251	* When the reference impedance is changed, the DMM sends one packet
252	* with the value of the new reference impedance. Both decibel and ohm
253	* flags are set in this case, so we must be careful to correctly
254	* identify the value as ohm, not dBmW
255	*/
256	if (flags.decibel && !flags.ohm) {
257	analog->mq = SR_MQ_POWER;
258	analog->unit = SR_UNIT_DECIBEL_MW;
259	/*
260	* For some reason, dBm measurements are sent by the multimeter
261	* with a value three orders of magnitude smaller than the
262	* displayed value.
263	* */
264	floatval = 1000;
265	}
266
267	if (flags.diode)
268	analog->mqflags \|= SR_MQFLAG_DIODE;
269	/* We can have both AC+DC in a single measurement */
270	if (flags.ac)
271	analog->mqflags \|= SR_MQFLAG_AC;
272	if (flags.dc)
273	analog->mqflags \|= SR_MQFLAG_DC;
274
275	if (flags.low_batt)
276	sr_info("Low battery!");
277
278	return SR_OK;
279	}