[libsigrok.git] / src / dmm / bm25x.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2014 Janne Huttunen <jahuttun@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/>.
 */

/**
 * @file
 *
 * Brymen BM25x serial protocol parser.
 */

#include <config.h>
#include <math.h>
#include <libsigrok/libsigrok.h>
#include "libsigrok-internal.h"

#define LOG_PREFIX "brymen-bm25x"

#define MAX_DIGITS 4

SR_PRIV gboolean sr_brymen_bm25x_packet_valid(const uint8_t *buf)
{
	int i;

	if (buf[0] != 2)
		return FALSE;

	for (i = 1; i < BRYMEN_BM25X_PACKET_SIZE; i++)
		if ((buf[i] >> 4) != i)
			return FALSE;

	return TRUE;
}

static int decode_digit(int num, const uint8_t *buf)
{
	int val;

	val = (buf[3 + 2 * num] & 0xe) | ((buf[4 + 2 * num] << 4) & 0xf0);

	switch (val) {
	case 0xbe: return 0;
	case 0xa0: return 1;
	case 0xda: return 2;
	case 0xf8: return 3;
	case 0xe4: return 4;
	case 0x7c: return 5;
	case 0x7e: return 6;
	case 0xa8: return 7;
	case 0xfe: return 8;
	case 0xfc: return 9;
	case 0x00: return ' ';
	case 0x40: return '-';
	case 0x16: return 'L';
	case 0x1e: return 'C';
	case 0x4e: return 'F';
	case 0x5e: return 'E';
	case 0x62: return 'n';
	case 0x42: return 'r';
	default:
		sr_dbg("Unknown digit: 0x%02x.", val);
		return -1;
	}
}

static int decode_point(const uint8_t *buf)
{
	int i, p = 0;

	for (i = 1; i < MAX_DIGITS; i++) {
		if ((buf[11 - 2 * i] & 1) == 0)
			continue;
		if (p != 0) {
			sr_spew("Multiple decimal points found!");
			return -1;
		}
		p = i;
	}

	return p;
}

static int decode_scale(int point, int digits)
{
	int pos;

	pos = point ? point + digits - MAX_DIGITS : 0;

	if (pos < 0 || pos > 3) {
		sr_dbg("Invalid decimal point %d (%d digits).", point, digits);
		return 0;
	}
	return -pos;
}

static int decode_prefix(const uint8_t *buf)
{
	if (buf[11] & 2) return  6;
	if (buf[11] & 1) return  3;
	if (buf[13] & 1) return -3;
	if (buf[13] & 2) return -6;
	if (buf[12] & 1) return -9;

	return 0;
}

static float decode_value(const uint8_t *buf, int *exponent)
{
	float val = 0.0f;
	int i, digit;

	for (i = 0; i < MAX_DIGITS; i++) {
		digit = decode_digit(i, buf);
		if (i == 3 && (digit == 'C' || digit == 'F'))
			break;
		if (digit < 0 || digit > 9)
			goto special;
		val = 10.0 * val + digit;
	}

	*exponent = decode_scale(decode_point(buf), i);
	return val;

special:
	if (decode_digit(1, buf) == 0 && decode_digit(2, buf) == 'L')
		return INFINITY;

	return NAN;
}

SR_PRIV int sr_brymen_bm25x_parse(const uint8_t *buf, float *floatval,
				struct sr_datafeed_analog *analog, void *info)
{
	int exponent = 0;
	float val;

	(void)info;

	analog->meaning->mq = SR_MQ_GAIN;
	analog->meaning->unit = SR_UNIT_UNITLESS;
	analog->meaning->mqflags = 0;

	if (buf[1] & 8)
		analog->meaning->mqflags |= SR_MQFLAG_AUTORANGE;
	if (buf[1] & 4)
		analog->meaning->mqflags |= SR_MQFLAG_DC;
	if (buf[1] & 2)
		analog->meaning->mqflags |= SR_MQFLAG_AC;
	if (buf[1] & 1)
		analog->meaning->mqflags |= SR_MQFLAG_RELATIVE;
	if (buf[11] & 8)
		analog->meaning->mqflags |= SR_MQFLAG_HOLD;
	if (buf[13] & 8)
		analog->meaning->mqflags |= SR_MQFLAG_MAX;
	if (buf[14] & 8)
		analog->meaning->mqflags |= SR_MQFLAG_MIN;

	if (buf[14] & 4) {
		analog->meaning->mq = SR_MQ_VOLTAGE;
		analog->meaning->unit = SR_UNIT_VOLT;
		if ((analog->meaning->mqflags & (SR_MQFLAG_DC | SR_MQFLAG_AC)) == 0)
			analog->meaning->mqflags |= SR_MQFLAG_DIODE | SR_MQFLAG_DC;
	}
	if (buf[14] & 2) {
		analog->meaning->mq = SR_MQ_CURRENT;
		analog->meaning->unit = SR_UNIT_AMPERE;
	}
	if (buf[12] & 4) {
		analog->meaning->mq = SR_MQ_RESISTANCE;
		analog->meaning->unit = SR_UNIT_OHM;
	}
	if (buf[13] & 4) {
		analog->meaning->mq = SR_MQ_CAPACITANCE;
		analog->meaning->unit = SR_UNIT_FARAD;
	}
	if (buf[12] & 2) {
		analog->meaning->mq = SR_MQ_FREQUENCY;
		analog->meaning->unit = SR_UNIT_HERTZ;
	}

	if (decode_digit(3, buf) == 'C') {
		analog->meaning->mq = SR_MQ_TEMPERATURE;
		analog->meaning->unit = SR_UNIT_CELSIUS;
	}
	if (decode_digit(3, buf) == 'F') {
		analog->meaning->mq = SR_MQ_TEMPERATURE;
		analog->meaning->unit = SR_UNIT_FAHRENHEIT;
	}

	val = decode_value(buf, &exponent);
	exponent += decode_prefix(buf);
	val *= powf(10, exponent);

	if (buf[3] & 1)
		val = -val;

	*floatval = val;
	analog->encoding->digits = -exponent;
	analog->spec->spec_digits = -exponent;

	return SR_OK;
}
Commit	Line	Data
	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2014 Janne Huttunen <jahuttun@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	/**
	21	* @file
	22	*
	23	* Brymen BM25x serial protocol parser.
	24	*/
	25
	26	#include <config.h>
	27	#include <math.h>
	28	#include <libsigrok/libsigrok.h>
	29	#include "libsigrok-internal.h"
	30
	31	#define LOG_PREFIX "brymen-bm25x"
	32
	33	#define MAX_DIGITS 4
	34
	35	SR_PRIV gboolean sr_brymen_bm25x_packet_valid(const uint8_t *buf)
	36	{
	37	int i;
	38
	39	if (buf[0] != 2)
	40	return FALSE;
	41
	42	for (i = 1; i < BRYMEN_BM25X_PACKET_SIZE; i++)
	43	if ((buf[i] >> 4) != i)
	44	return FALSE;
	45
	46	return TRUE;
	47	}
	48
	49	static int decode_digit(int num, const uint8_t *buf)
	50	{
	51	int val;
	52
	53	val = (buf[3 + 2 * num] & 0xe) \| ((buf[4 + 2 * num] << 4) & 0xf0);
	54
	55	switch (val) {
	56	case 0xbe: return 0;
	57	case 0xa0: return 1;
	58	case 0xda: return 2;
	59	case 0xf8: return 3;
	60	case 0xe4: return 4;
	61	case 0x7c: return 5;
	62	case 0x7e: return 6;
	63	case 0xa8: return 7;
	64	case 0xfe: return 8;
	65	case 0xfc: return 9;
	66	case 0x00: return ' ';
	67	case 0x40: return '-';
	68	case 0x16: return 'L';
	69	case 0x1e: return 'C';
	70	case 0x4e: return 'F';
	71	case 0x5e: return 'E';
	72	case 0x62: return 'n';
	73	case 0x42: return 'r';
	74	default:
	75	sr_dbg("Unknown digit: 0x%02x.", val);
	76	return -1;
	77	}
	78	}
	79
	80	static int decode_point(const uint8_t *buf)
	81	{
	82	int i, p = 0;
	83
	84	for (i = 1; i < MAX_DIGITS; i++) {
	85	if ((buf[11 - 2 * i] & 1) == 0)
	86	continue;
	87	if (p != 0) {
	88	sr_spew("Multiple decimal points found!");
	89	return -1;
	90	}
	91	p = i;
	92	}
	93
	94	return p;
	95	}
	96
	97	static int decode_scale(int point, int digits)
	98	{
	99	int pos;
	100
	101	pos = point ? point + digits - MAX_DIGITS : 0;
	102
	103	if (pos < 0 \|\| pos > 3) {
	104	sr_dbg("Invalid decimal point %d (%d digits).", point, digits);
	105	return 0;
	106	}
	107	return -pos;
	108	}
	109
	110	static int decode_prefix(const uint8_t *buf)
	111	{
	112	if (buf[11] & 2) return 6;
	113	if (buf[11] & 1) return 3;
	114	if (buf[13] & 1) return -3;
	115	if (buf[13] & 2) return -6;
	116	if (buf[12] & 1) return -9;
	117
	118	return 0;
	119	}
	120
	121	static float decode_value(const uint8_t buf, int exponent)
	122	{
	123	float val = 0.0f;
	124	int i, digit;
	125
	126	for (i = 0; i < MAX_DIGITS; i++) {
	127	digit = decode_digit(i, buf);
	128	if (i == 3 && (digit == 'C' \|\| digit == 'F'))
	129	break;
	130	if (digit < 0 \|\| digit > 9)
	131	goto special;
	132	val = 10.0 * val + digit;
	133	}
	134
	135	*exponent = decode_scale(decode_point(buf), i);
	136	return val;
	137
	138	special:
	139	if (decode_digit(1, buf) == 0 && decode_digit(2, buf) == 'L')
	140	return INFINITY;
	141
	142	return NAN;
	143	}
	144
	145	SR_PRIV int sr_brymen_bm25x_parse(const uint8_t buf, float floatval,
	146	struct sr_datafeed_analog analog, void info)
	147	{
	148	int exponent = 0;
	149	float val;
	150
	151	(void)info;
	152
	153	analog->meaning->mq = SR_MQ_GAIN;
	154	analog->meaning->unit = SR_UNIT_UNITLESS;
	155	analog->meaning->mqflags = 0;
	156
	157	if (buf[1] & 8)
	158	analog->meaning->mqflags \|= SR_MQFLAG_AUTORANGE;
	159	if (buf[1] & 4)
	160	analog->meaning->mqflags \|= SR_MQFLAG_DC;
	161	if (buf[1] & 2)
	162	analog->meaning->mqflags \|= SR_MQFLAG_AC;
	163	if (buf[1] & 1)
	164	analog->meaning->mqflags \|= SR_MQFLAG_RELATIVE;
	165	if (buf[11] & 8)
	166	analog->meaning->mqflags \|= SR_MQFLAG_HOLD;
	167	if (buf[13] & 8)
	168	analog->meaning->mqflags \|= SR_MQFLAG_MAX;
	169	if (buf[14] & 8)
	170	analog->meaning->mqflags \|= SR_MQFLAG_MIN;
	171
	172	if (buf[14] & 4) {
	173	analog->meaning->mq = SR_MQ_VOLTAGE;
	174	analog->meaning->unit = SR_UNIT_VOLT;
	175	if ((analog->meaning->mqflags & (SR_MQFLAG_DC \| SR_MQFLAG_AC)) == 0)
	176	analog->meaning->mqflags \|= SR_MQFLAG_DIODE \| SR_MQFLAG_DC;
	177	}
	178	if (buf[14] & 2) {
	179	analog->meaning->mq = SR_MQ_CURRENT;
	180	analog->meaning->unit = SR_UNIT_AMPERE;
	181	}
	182	if (buf[12] & 4) {
	183	analog->meaning->mq = SR_MQ_RESISTANCE;
	184	analog->meaning->unit = SR_UNIT_OHM;
	185	}
	186	if (buf[13] & 4) {
	187	analog->meaning->mq = SR_MQ_CAPACITANCE;
	188	analog->meaning->unit = SR_UNIT_FARAD;
	189	}
	190	if (buf[12] & 2) {
	191	analog->meaning->mq = SR_MQ_FREQUENCY;
	192	analog->meaning->unit = SR_UNIT_HERTZ;
	193	}
	194
	195	if (decode_digit(3, buf) == 'C') {
	196	analog->meaning->mq = SR_MQ_TEMPERATURE;
	197	analog->meaning->unit = SR_UNIT_CELSIUS;
	198	}
	199	if (decode_digit(3, buf) == 'F') {
	200	analog->meaning->mq = SR_MQ_TEMPERATURE;
	201	analog->meaning->unit = SR_UNIT_FAHRENHEIT;
	202	}
	203
	204	val = decode_value(buf, &exponent);
	205	exponent += decode_prefix(buf);
	206	val *= powf(10, exponent);
	207
	208	if (buf[3] & 1)
	209	val = -val;
	210
	211	*floatval = val;
	212	analog->encoding->digits = -exponent;
	213	analog->spec->spec_digits = -exponent;
	214
	215	return SR_OK;
	216	}