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

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2012 Uwe Hermann <uwe@hermann-uwe.de>
 * Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
 * Copyright (C) 2015 Matthieu Gaillet <matthieu@gaillet.be>
 *
 * 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 2 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 */

/*
 * Dream Tech International DTM0660 protocol parser.
 *
 * 6000 counts (5 5/6 digits)
 *
 *  - Package: QFP-64
 *  - Communication parameters: Unidirectional, 2400/8n1
 *  - The protocol is similar to FS9721 but with 15 bytes and reversed nibbles.
 */

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

#define LOG_PREFIX "dtm0660"

static int parse_digit(uint8_t b)
{
	switch (b) {
	case 0xeb:
		return 0;
	case 0x0a:
		return 1;
	case 0xad:
		return 2;
	case 0x8f:
		return 3;
	case 0x4e:
		return 4;
	case 0xc7:
		return 5;
	case 0xe7:
		return 6;
	case 0x8a:
		return 7;
	case 0xef:
		return 8;
	case 0xcf:
		return 9;
	default:
		sr_dbg("Invalid digit byte: 0x%02x.", b);
		return -1;
	}
}

static gboolean sync_nibbles_valid(const uint8_t *buf)
{
	int i;

	/* Check the synchronization nibbles, and make sure they all match. */
	for (i = 0; i < DTM0660_PACKET_SIZE; i++) {
		if (((buf[i] >> 4) & 0x0f) != (i + 1)) {
			sr_dbg("Sync nibble in byte %d (0x%02x) is invalid.",
			       i, buf[i]);
			return FALSE;
		}
	}

	return TRUE;
}

static gboolean flags_valid(const struct dtm0660_info *info)
{
	int count;

	/* Does the packet have more than one multiplier? */
	count = 0;
	count += (info->is_nano) ? 1 : 0;
	count += (info->is_micro) ? 1 : 0;
	count += (info->is_milli) ? 1 : 0;
	count += (info->is_kilo) ? 1 : 0;
	count += (info->is_mega) ? 1 : 0;
	if (count > 1) {
		sr_dbg("More than one multiplier detected in packet.");
		return FALSE;
	}

	/* Does the packet "measure" more than one type of value? */
	count = 0;
	count += (info->is_hz) ? 1 : 0;
	count += (info->is_ohm) ? 1 : 0;
	count += (info->is_farad) ? 1 : 0;
	count += (info->is_ampere) ? 1 : 0;
	count += (info->is_volt) ? 1 : 0;
	count += (info->is_percent) ? 1 : 0;
	if (count > 1) {
		sr_dbg("More than one measurement type detected in packet.");
		return FALSE;
	}

	/* Both AC and DC set? */
	if (info->is_ac && info->is_dc) {
		sr_dbg("Both AC and DC flags detected in packet.");
		return FALSE;
	}

	/* RS232 flag not set? */
	if (!info->is_rs232) {
		sr_dbg("No RS232 flag detected in packet.");
		return FALSE;
	}

	return TRUE;
}

static int parse_value(const uint8_t *buf, float *result)
{
	int i, sign, intval = 0, digits[4];
	uint8_t digit_bytes[4];
	float floatval;

	/* Byte 1 contains sign in bit 0. */
	sign = ((buf[1] & (1 << 0)) != 0) ? -1 : 1;

	/*
	 * Bytes 1-8: Value (4 decimal digits, sign, decimal point)
	 *
	 * Over limit: "0L" (LCD), 0x00 0xeb 0x61 0x00 (digit bytes).
	 */

	/* Merge the two nibbles for a digit into one byte. */
	for (i = 0; i < 4; i++) {
		digit_bytes[i] = ((buf[1 + (i * 2)] & 0x0f) << 4);
		digit_bytes[i] |= (buf[1 + (i * 2) + 1] & 0x0f);

		/* Bit 4 in the byte is not part of the digit. */
		digit_bytes[i] &= ~(1 << 4);
	}

	/* Check for "OL". */
	if (digit_bytes[0] == 0x00 && digit_bytes[1] == 0xeb &&
	    digit_bytes[2] == 0x61 && digit_bytes[3] == 0x00) {
		sr_spew("Over limit.");
		*result = INFINITY;
		return SR_OK;
	}

	/* Parse the digits. */
	for (i = 0; i < 4; i++)
		digits[i] = parse_digit(digit_bytes[i]);
	sr_spew("Digits: %02x %02x %02x %02x (%d%d%d%d).",
		digit_bytes[0], digit_bytes[1], digit_bytes[2], digit_bytes[3],
		digits[0], digits[1], digits[2], digits[3]);

	/* Merge all digits into an integer value. */
	for (i = 0; i < 4; i++) {
		intval *= 10;
		intval += digits[i];
	}

	floatval = (float)intval;

	/* Decimal point position. */
	if ((buf[3] & 0x01) != 0) {
		floatval /= 1000;
		sr_spew("Decimal point after first digit.");
	} else if ((buf[5] & 0x01) != 0) {
		floatval /= 100;
		sr_spew("Decimal point after second digit.");
	} else if ((buf[7] & 0x01) != 0) {
		floatval /= 10;
		sr_spew("Decimal point after third digit.");
	} else {
		sr_spew("No decimal point in the number.");
	}

	/* Apply sign. */
	floatval *= sign;

	sr_spew("The display value is %f.", floatval);

	*result = floatval;

	return SR_OK;
}

static void parse_flags(const uint8_t *buf, struct dtm0660_info *info)
{
	/* Byte 0: LCD SEG1 */
	info->is_ac         = (buf[0] & (1 << 0)) != 0;
	info->is_dc         = (buf[0] & (1 << 1)) != 0;
	info->is_auto       = (buf[0] & (1 << 2)) != 0;
	info->is_rs232      = (buf[0] & (1 << 3)) != 0;

	/* Byte 1: LCD SEG2 */
	info->is_sign       = (buf[1] & (1 << 0)) != 0;

	/* Byte 9: LCD SEG10 */
	info->is_micro      = (buf[9] & (1 << 0)) != 0;
	info->is_nano       = (buf[9] & (1 << 1)) != 0;
	info->is_kilo       = (buf[9] & (1 << 2)) != 0;
	info->is_diode      = (buf[9] & (1 << 3)) != 0;

	/* Byte 10: LCD SEG11 */
	info->is_milli      = (buf[10] & (1 << 0)) != 0;
	info->is_percent    = (buf[10] & (1 << 1)) != 0;
	info->is_mega       = (buf[10] & (1 << 2)) != 0;
	info->is_beep       = (buf[10] & (1 << 3)) != 0;

	/* Byte 11: LCD SEG12 */
	info->is_farad      = (buf[11] & (1 << 0)) != 0;
	info->is_ohm        = (buf[11] & (1 << 1)) != 0;
	info->is_rel        = (buf[11] & (1 << 2)) != 0;
	info->is_hold       = (buf[11] & (1 << 3)) != 0;

	/* Byte 12: LCD SEG13 */
	info->is_ampere     = (buf[12] & (1 << 0)) != 0;
	info->is_volt       = (buf[12] & (1 << 1)) != 0;
	info->is_hz         = (buf[12] & (1 << 2)) != 0;
	info->is_bat        = (buf[12] & (1 << 3)) != 0;

	/* Byte 13: LCD SEG14 */
	info->is_degf       = (buf[13] & (1 << 0)) != 0;
	info->is_degc       = (buf[13] & (1 << 1)) != 0;
	info->is_c2c1_00    = (buf[13] & (1 << 2)) != 0;
	info->is_c2c1_01    = (buf[13] & (1 << 3)) != 0;

	/* Byte 14: LCD SEG15 */
	info->is_apo        = (buf[14] & (1 << 0)) != 0;
	info->is_min        = (buf[14] & (1 << 1)) != 0;
	info->is_minmax     = (buf[14] & (1 << 2)) != 0;
	info->is_max        = (buf[14] & (1 << 3)) != 0;
}

static void handle_flags(struct sr_datafeed_analog *analog, float *floatval,
			 const struct dtm0660_info *info)
{
	/* Factors */
	if (info->is_nano)
		*floatval /= 1000000000;
	if (info->is_micro)
		*floatval /= 1000000;
	if (info->is_milli)
		*floatval /= 1000;
	if (info->is_kilo)
		*floatval *= 1000;
	if (info->is_mega)
		*floatval *= 1000000;

	/* Measurement modes */
	if (info->is_volt) {
		analog->meaning->mq = SR_MQ_VOLTAGE;
		analog->meaning->unit = SR_UNIT_VOLT;
	}
	if (info->is_ampere) {
		analog->meaning->mq = SR_MQ_CURRENT;
		analog->meaning->unit = SR_UNIT_AMPERE;
	}
	if (info->is_ohm) {
		analog->meaning->mq = SR_MQ_RESISTANCE;
		analog->meaning->unit = SR_UNIT_OHM;
	}
	if (info->is_hz) {
		analog->meaning->mq = SR_MQ_FREQUENCY;
		analog->meaning->unit = SR_UNIT_HERTZ;
	}
	if (info->is_farad) {
		analog->meaning->mq = SR_MQ_CAPACITANCE;
		analog->meaning->unit = SR_UNIT_FARAD;
	}
	if (info->is_beep) {
		analog->meaning->mq = SR_MQ_CONTINUITY;
		analog->meaning->unit = SR_UNIT_BOOLEAN;
		*floatval = (*floatval == INFINITY) ? 0.0 : 1.0;
	}
	if (info->is_diode) {
		analog->meaning->mq = SR_MQ_VOLTAGE;
		analog->meaning->unit = SR_UNIT_VOLT;
	}
	if (info->is_percent) {
		analog->meaning->mq = SR_MQ_DUTY_CYCLE;
		analog->meaning->unit = SR_UNIT_PERCENTAGE;
	}
	if (info->is_degc) {
		analog->meaning->mq = SR_MQ_TEMPERATURE;
		analog->meaning->unit = SR_UNIT_CELSIUS;
	}
	if (info->is_degf) {
		analog->meaning->mq = SR_MQ_TEMPERATURE;
		analog->meaning->unit = SR_UNIT_FAHRENHEIT;
	}

	/* Measurement related flags */
	if (info->is_ac)
		analog->meaning->mqflags |= SR_MQFLAG_AC;
	if (info->is_dc)
		analog->meaning->mqflags |= SR_MQFLAG_DC;
	if (info->is_auto)
		analog->meaning->mqflags |= SR_MQFLAG_AUTORANGE;
	if (info->is_diode)
		analog->meaning->mqflags |= SR_MQFLAG_DIODE;
	if (info->is_hold)
		analog->meaning->mqflags |= SR_MQFLAG_HOLD;
	if (info->is_rel)
		analog->meaning->mqflags |= SR_MQFLAG_RELATIVE;
	if (info->is_min)
		analog->meaning->mqflags |= SR_MQFLAG_MIN;
	if (info->is_max)
		analog->meaning->mqflags |= SR_MQFLAG_MAX;

	/* Other flags */
	if (info->is_rs232)
		sr_spew("RS232 enabled.");
	if (info->is_bat)
		sr_spew("Battery is low.");
	if (info->is_apo)
		sr_spew("Auto power-off mode is active.");
	if (info->is_minmax)
		sr_spew("Min/max mode active.");
	if (info->is_c2c1_00)
		sr_spew("User-defined LCD symbol 0 is active.");
	if (info->is_c2c1_01)
		sr_spew("User-defined LCD symbol 1 is active.");
}

SR_PRIV gboolean sr_dtm0660_packet_valid(const uint8_t *buf)
{
	struct dtm0660_info info;

	parse_flags(buf, &info);

	return (sync_nibbles_valid(buf) && flags_valid(&info));
}

/**
 * Parse a protocol packet.
 *
 * @param buf Buffer containing the 15-byte protocol packet. Must not be NULL.
 * @param floatval Pointer to a float variable. That variable will contain the
 *                 result value upon parsing success. Must not be NULL.
 * @param analog Pointer to a struct sr_datafeed_analog. The struct will be
 *               filled with data according to the protocol packet.
 *               Must not be NULL.
 * @param info Pointer to a struct dtm0660_info. The struct will be filled
 *             with data according to the protocol packet. Must not be NULL.
 *
 * @return SR_OK upon success, SR_ERR upon failure. Upon errors, the
 *         'analog' variable contents are undefined and should not be used.
 */
SR_PRIV int sr_dtm0660_parse(const uint8_t *buf, float *floatval,
			     struct sr_datafeed_analog *analog, void *info)
{
	int ret;
	struct dtm0660_info *info_local;

	info_local = (struct dtm0660_info *)info;

	if ((ret = parse_value(buf, floatval)) != SR_OK) {
		sr_dbg("Error parsing value: %d.", ret);
		return ret;
	}

	parse_flags(buf, info_local);
	handle_flags(analog, floatval, info_local);

	return SR_OK;
}
Commit	Line	Data
eed3dec8 MG	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2012 Uwe Hermann <uwe@hermann-uwe.de>
	5	* Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
	6	* Copyright (C) 2015 Matthieu Gaillet <matthieu@gaillet.be>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	/*
	24	* Dream Tech International DTM0660 protocol parser.
	25	*
	26	* 6000 counts (5 5/6 digits)
	27	*
	28	* - Package: QFP-64
	29	* - Communication parameters: Unidirectional, 2400/8n1
	30	* - The protocol is similar to FS9721 but with 15 bytes and reversed nibbles.
	31	*/
	32
	33	#include <config.h>
	34	#include <string.h>
	35	#include <ctype.h>
	36	#include <math.h>
	37	#include <glib.h>
	38	#include <libsigrok/libsigrok.h>
	39	#include "libsigrok-internal.h"
	40
	41	#define LOG_PREFIX "dtm0660"
	42
	43	static int parse_digit(uint8_t b)
	44	{
	45	switch (b) {
	46	case 0xeb:
	47	return 0;
	48	case 0x0a:
	49	return 1;
	50	case 0xad:
	51	return 2;
	52	case 0x8f:
	53	return 3;
	54	case 0x4e:
	55	return 4;
	56	case 0xc7:
	57	return 5;
	58	case 0xe7:
	59	return 6;
	60	case 0x8a:
	61	return 7;
	62	case 0xef:
	63	return 8;
	64	case 0xcf:
65	return 9;
66	default:
67	sr_dbg("Invalid digit byte: 0x%02x.", b);
68	return -1;
69	}
70	}
71
72	static gboolean sync_nibbles_valid(const uint8_t *buf)
73	{
74	int i;
75
76	/* Check the synchronization nibbles, and make sure they all match. */
77	for (i = 0; i < DTM0660_PACKET_SIZE; i++) {
78	if (((buf[i] >> 4) & 0x0f) != (i + 1)) {
79	sr_dbg("Sync nibble in byte %d (0x%02x) is invalid.",
80	i, buf[i]);
81	return FALSE;
82	}
83	}
84
85	return TRUE;
86	}
87
88	static gboolean flags_valid(const struct dtm0660_info *info)
89	{
90	int count;
91
92	/* Does the packet have more than one multiplier? */
93	count = 0;
94	count += (info->is_nano) ? 1 : 0;
95	count += (info->is_micro) ? 1 : 0;
96	count += (info->is_milli) ? 1 : 0;
97	count += (info->is_kilo) ? 1 : 0;
98	count += (info->is_mega) ? 1 : 0;
99	if (count > 1) {
100	sr_dbg("More than one multiplier detected in packet.");
101	return FALSE;
102	}
103
104	/* Does the packet "measure" more than one type of value? */
105	count = 0;
106	count += (info->is_hz) ? 1 : 0;
107	count += (info->is_ohm) ? 1 : 0;
108	count += (info->is_farad) ? 1 : 0;
109	count += (info->is_ampere) ? 1 : 0;
110	count += (info->is_volt) ? 1 : 0;
111	count += (info->is_percent) ? 1 : 0;
112	if (count > 1) {
113	sr_dbg("More than one measurement type detected in packet.");
114	return FALSE;
115	}
116
117	/* Both AC and DC set? */
118	if (info->is_ac && info->is_dc) {
119	sr_dbg("Both AC and DC flags detected in packet.");
120	return FALSE;
121	}
122
123	/* RS232 flag not set? */
124	if (!info->is_rs232) {
125	sr_dbg("No RS232 flag detected in packet.");
126	return FALSE;
127	}
128
129	return TRUE;
130	}
131
132	static int parse_value(const uint8_t buf, float result)
133	{
134	int i, sign, intval = 0, digits[4];
135	uint8_t digit_bytes[4];
136	float floatval;
137
138	/* Byte 1 contains sign in bit 0. */
139	sign = ((buf[1] & (1 << 0)) != 0) ? -1 : 1;
140
141	/*
142	* Bytes 1-8: Value (4 decimal digits, sign, decimal point)
143	*
144	* Over limit: "0L" (LCD), 0x00 0xeb 0x61 0x00 (digit bytes).
145	*/
146
147	/* Merge the two nibbles for a digit into one byte. */
148	for (i = 0; i < 4; i++) {
149	digit_bytes[i] = ((buf[1 + (i * 2)] & 0x0f) << 4);
150	digit_bytes[i] \|= (buf[1 + (i * 2) + 1] & 0x0f);
151
152	/* Bit 4 in the byte is not part of the digit. */
153	digit_bytes[i] &= ~(1 << 4);
154	}
155
156	/* Check for "OL". */
157	if (digit_bytes[0] == 0x00 && digit_bytes[1] == 0xeb &&
158	digit_bytes[2] == 0x61 && digit_bytes[3] == 0x00) {
159	sr_spew("Over limit.");
160	*result = INFINITY;
161	return SR_OK;
162	}
163
164	/* Parse the digits. */
165	for (i = 0; i < 4; i++)
166	digits[i] = parse_digit(digit_bytes[i]);
167	sr_spew("Digits: %02x %02x %02x %02x (%d%d%d%d).",
168	digit_bytes[0], digit_bytes[1], digit_bytes[2], digit_bytes[3],
169	digits[0], digits[1], digits[2], digits[3]);
170
171	/* Merge all digits into an integer value. */
172	for (i = 0; i < 4; i++) {
173	intval *= 10;
174	intval += digits[i];
175	}
176
177	floatval = (float)intval;
178
179	/* Decimal point position. */
180	if ((buf[3] & 0x01) != 0) {
181	floatval /= 1000;
182	sr_spew("Decimal point after first digit.");
183	} else if ((buf[5] & 0x01) != 0) {
184	floatval /= 100;
185	sr_spew("Decimal point after second digit.");
186	} else if ((buf[7] & 0x01) != 0) {
187	floatval /= 10;
188	sr_spew("Decimal point after third digit.");
189	} else {
190	sr_spew("No decimal point in the number.");
191	}
192
193	/* Apply sign. */
194	floatval *= sign;
195
196	sr_spew("The display value is %f.", floatval);
197
198	*result = floatval;
199
200	return SR_OK;
201	}
202
203	static void parse_flags(const uint8_t buf, struct dtm0660_info info)
204	{
205	/* Byte 0: LCD SEG1 */
206	info->is_ac = (buf[0] & (1 << 0)) != 0;
207	info->is_dc = (buf[0] & (1 << 1)) != 0;
208	info->is_auto = (buf[0] & (1 << 2)) != 0;
209	info->is_rs232 = (buf[0] & (1 << 3)) != 0;
210
211	/* Byte 1: LCD SEG2 */
212	info->is_sign = (buf[1] & (1 << 0)) != 0;
213
214	/* Byte 9: LCD SEG10 */
215	info->is_micro = (buf[9] & (1 << 0)) != 0;
216	info->is_nano = (buf[9] & (1 << 1)) != 0;
217	info->is_kilo = (buf[9] & (1 << 2)) != 0;
218	info->is_diode = (buf[9] & (1 << 3)) != 0;
219
220	/* Byte 10: LCD SEG11 */
221	info->is_milli = (buf[10] & (1 << 0)) != 0;
222	info->is_percent = (buf[10] & (1 << 1)) != 0;
223	info->is_mega = (buf[10] & (1 << 2)) != 0;
224	info->is_beep = (buf[10] & (1 << 3)) != 0;
225
226	/* Byte 11: LCD SEG12 */
227	info->is_farad = (buf[11] & (1 << 0)) != 0;
228	info->is_ohm = (buf[11] & (1 << 1)) != 0;
229	info->is_rel = (buf[11] & (1 << 2)) != 0;
230	info->is_hold = (buf[11] & (1 << 3)) != 0;
231
232	/* Byte 12: LCD SEG13 */
233	info->is_ampere = (buf[12] & (1 << 0)) != 0;
234	info->is_volt = (buf[12] & (1 << 1)) != 0;
235	info->is_hz = (buf[12] & (1 << 2)) != 0;
236	info->is_bat = (buf[12] & (1 << 3)) != 0;
237
238	/* Byte 13: LCD SEG14 */
239	info->is_degf = (buf[13] & (1 << 0)) != 0;
240	info->is_degc = (buf[13] & (1 << 1)) != 0;
241	info->is_c2c1_00 = (buf[13] & (1 << 2)) != 0;
242	info->is_c2c1_01 = (buf[13] & (1 << 3)) != 0;
243
244	/* Byte 14: LCD SEG15 */
245	info->is_apo = (buf[14] & (1 << 0)) != 0;
246	info->is_min = (buf[14] & (1 << 1)) != 0;
247	info->is_minmax = (buf[14] & (1 << 2)) != 0;
248	info->is_max = (buf[14] & (1 << 3)) != 0;
249	}
250
b02bb45f	251	static void handle_flags(struct sr_datafeed_analog analog, float floatval,
eed3dec8 MG	252	const struct dtm0660_info *info)
	253	{
	254	/* Factors */
	255	if (info->is_nano)
	256	*floatval /= 1000000000;
	257	if (info->is_micro)
	258	*floatval /= 1000000;
	259	if (info->is_milli)
	260	*floatval /= 1000;
	261	if (info->is_kilo)
	262	floatval = 1000;
	263	if (info->is_mega)
	264	floatval = 1000000;
	265
	266	/* Measurement modes */
	267	if (info->is_volt) {
b02bb45f UH	268	analog->meaning->mq = SR_MQ_VOLTAGE;
b02bb45f UH	269	analog->meaning->unit = SR_UNIT_VOLT;
eed3dec8 MG	270	}
eed3dec8 MG	271	if (info->is_ampere) {
b02bb45f UH	272	analog->meaning->mq = SR_MQ_CURRENT;
b02bb45f UH	273	analog->meaning->unit = SR_UNIT_AMPERE;
eed3dec8 MG	274	}
eed3dec8 MG	275	if (info->is_ohm) {
b02bb45f UH	276	analog->meaning->mq = SR_MQ_RESISTANCE;
b02bb45f UH	277	analog->meaning->unit = SR_UNIT_OHM;
eed3dec8 MG	278	}
eed3dec8 MG	279	if (info->is_hz) {
b02bb45f UH	280	analog->meaning->mq = SR_MQ_FREQUENCY;
b02bb45f UH	281	analog->meaning->unit = SR_UNIT_HERTZ;
eed3dec8 MG	282	}
eed3dec8 MG	283	if (info->is_farad) {
b02bb45f UH	284	analog->meaning->mq = SR_MQ_CAPACITANCE;
b02bb45f UH	285	analog->meaning->unit = SR_UNIT_FARAD;
eed3dec8 MG	286	}
eed3dec8 MG	287	if (info->is_beep) {
b02bb45f UH	288	analog->meaning->mq = SR_MQ_CONTINUITY;
b02bb45f UH	289	analog->meaning->unit = SR_UNIT_BOOLEAN;
eed3dec8 MG	290	floatval = (floatval == INFINITY) ? 0.0 : 1.0;
	291	}
	292	if (info->is_diode) {
b02bb45f UH	293	analog->meaning->mq = SR_MQ_VOLTAGE;
b02bb45f UH	294	analog->meaning->unit = SR_UNIT_VOLT;
eed3dec8 MG	295	}
eed3dec8 MG	296	if (info->is_percent) {
b02bb45f UH	297	analog->meaning->mq = SR_MQ_DUTY_CYCLE;
b02bb45f UH	298	analog->meaning->unit = SR_UNIT_PERCENTAGE;
eed3dec8 MG	299	}
eed3dec8 MG	300	if (info->is_degc) {
b02bb45f UH	301	analog->meaning->mq = SR_MQ_TEMPERATURE;
b02bb45f UH	302	analog->meaning->unit = SR_UNIT_CELSIUS;
eed3dec8 MG	303	}
eed3dec8 MG	304	if (info->is_degf) {
b02bb45f UH	305	analog->meaning->mq = SR_MQ_TEMPERATURE;
b02bb45f UH	306	analog->meaning->unit = SR_UNIT_FAHRENHEIT;
eed3dec8 MG	307	}
	308
	309	/* Measurement related flags */
	310	if (info->is_ac)
b02bb45f	311	analog->meaning->mqflags \|= SR_MQFLAG_AC;
eed3dec8	312	if (info->is_dc)
b02bb45f	313	analog->meaning->mqflags \|= SR_MQFLAG_DC;
eed3dec8	314	if (info->is_auto)
b02bb45f	315	analog->meaning->mqflags \|= SR_MQFLAG_AUTORANGE;
eed3dec8	316	if (info->is_diode)
b02bb45f	317	analog->meaning->mqflags \|= SR_MQFLAG_DIODE;
eed3dec8	318	if (info->is_hold)
b02bb45f	319	analog->meaning->mqflags \|= SR_MQFLAG_HOLD;
eed3dec8	320	if (info->is_rel)
b02bb45f	321	analog->meaning->mqflags \|= SR_MQFLAG_RELATIVE;
eed3dec8	322	if (info->is_min)
b02bb45f	323	analog->meaning->mqflags \|= SR_MQFLAG_MIN;
eed3dec8	324	if (info->is_max)
b02bb45f	325	analog->meaning->mqflags \|= SR_MQFLAG_MAX;
eed3dec8 MG	326
	327	/* Other flags */
	328	if (info->is_rs232)
	329	sr_spew("RS232 enabled.");
	330	if (info->is_bat)
	331	sr_spew("Battery is low.");
	332	if (info->is_apo)
	333	sr_spew("Auto power-off mode is active.");
	334	if (info->is_minmax)
	335	sr_spew("Min/max mode active.");
	336	if (info->is_c2c1_00)
	337	sr_spew("User-defined LCD symbol 0 is active.");
	338	if (info->is_c2c1_01)
	339	sr_spew("User-defined LCD symbol 1 is active.");
	340	}
	341
	342	SR_PRIV gboolean sr_dtm0660_packet_valid(const uint8_t *buf)
	343	{
	344	struct dtm0660_info info;
	345
	346	parse_flags(buf, &info);
	347
	348	return (sync_nibbles_valid(buf) && flags_valid(&info));
	349	}
	350
	351	/**
	352	* Parse a protocol packet.
	353	*
	354	* @param buf Buffer containing the 15-byte protocol packet. Must not be NULL.
	355	* @param floatval Pointer to a float variable. That variable will contain the
	356	* result value upon parsing success. Must not be NULL.
b02bb45f	357	* @param analog Pointer to a struct sr_datafeed_analog. The struct will be
eed3dec8 MG	358	* filled with data according to the protocol packet.
	359	* Must not be NULL.
	360	* @param info Pointer to a struct dtm0660_info. The struct will be filled
	361	* with data according to the protocol packet. Must not be NULL.
	362	*
	363	* @return SR_OK upon success, SR_ERR upon failure. Upon errors, the
	364	* 'analog' variable contents are undefined and should not be used.
	365	*/
	366	SR_PRIV int sr_dtm0660_parse(const uint8_t buf, float floatval,
b02bb45f	367	struct sr_datafeed_analog analog, void info)
eed3dec8 MG	368	{
	369	int ret;
	370	struct dtm0660_info *info_local;
	371
	372	info_local = (struct dtm0660_info *)info;
	373
	374	if ((ret = parse_value(buf, floatval)) != SR_OK) {
	375	sr_dbg("Error parsing value: %d.", ret);
	376	return ret;
	377	}
	378
	379	parse_flags(buf, info_local);
	380	handle_flags(analog, floatval, info_local);
	381
	382	return SR_OK;
	383	}