[libsigrok.git] / src / hardware / appa-55ii / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2013 Aurelien Jacobs <aurel@gnuage.org>
 *
 * 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 <string.h>
#include <math.h>
#include "protocol.h"

typedef enum {
    LIVE_DATA    = 0x00,
    LOG_METADATA = 0x11,
    LOG_DATA     = 0x14,
    LOG_START    = 0x18,
    LOG_END      = 0x19,
} packet_type;

static gboolean appa_55ii_checksum(const uint8_t *buf)
{
	int i, size, checksum;

	size = buf[3] + 4;
	checksum = 0;
	for (i = 0; i < size; i++)
		checksum += buf[i];

	return buf[size] == (checksum & 0xFF);
}

SR_PRIV gboolean appa_55ii_packet_valid(const uint8_t *buf)
{
	if (buf[0] == 0x55 && buf[1] == 0x55 && buf[3] <= 32
			&& appa_55ii_checksum(buf))
		return TRUE;

	return FALSE;
}

static uint64_t appa_55ii_flags(const uint8_t *buf)
{
	uint8_t disp_mode;
	uint64_t flags;

	disp_mode = buf[4 + 13];
	flags = 0;
	if ((disp_mode & 0xF0) == 0x20)
		flags |= SR_MQFLAG_HOLD;
	if ((disp_mode & 0x0C) == 0x04)
		flags |= SR_MQFLAG_MAX;
	if ((disp_mode & 0x0C) == 0x08)
		flags |= SR_MQFLAG_MIN;
	if ((disp_mode & 0x0C) == 0x0C)
		flags |= SR_MQFLAG_AVG;

	return flags;
}

static float appa_55ii_temp(const uint8_t *buf, int ch)
{
	const uint8_t *ptr;
	int16_t temp;
	uint8_t flags;

	ptr = buf + 4 + 14 + 3 * ch;
	temp = RL16(ptr);
	flags = ptr[2];

	if (flags & 0x60)
		return INFINITY;
	else if (flags & 1)
		return (float)temp / 10;
	else
		return (float)temp;
}

static void appa_55ii_live_data(struct sr_dev_inst *sdi, const uint8_t *buf)
{
	struct dev_context *devc;
	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 sr_channel *ch;
	float values[APPA_55II_NUM_CHANNELS], *val_ptr;
	int i;

	devc = sdi->priv;

	if (devc->data_source != DATA_SOURCE_LIVE)
		return;

	val_ptr = values;
	sr_analog_init(&analog, &encoding, &meaning, &spec, 0);
	analog.num_samples = 1;
	analog.meaning->mq = SR_MQ_TEMPERATURE;
	analog.meaning->unit = SR_UNIT_CELSIUS;
	analog.meaning->mqflags = appa_55ii_flags(buf);
	analog.data = values;

	for (i = 0; i < APPA_55II_NUM_CHANNELS; i++) {
		ch = g_slist_nth_data(sdi->channels, i);
		if (!ch->enabled)
			continue;
		analog.meaning->channels = g_slist_append(analog.meaning->channels, ch);
		*val_ptr++ = appa_55ii_temp(buf, i);
	}

	packet.type = SR_DF_ANALOG;
	packet.payload = &analog;
	sr_session_send(sdi, &packet);
	g_slist_free(analog.meaning->channels);

	sr_sw_limits_update_samples_read(&devc->limits, 1);
}

static void appa_55ii_log_metadata(struct sr_dev_inst *sdi, const uint8_t *buf)
{
	struct dev_context *devc;

	devc = sdi->priv;
	devc->num_log_records = (buf[5] << 8) + buf[4];
}

static void appa_55ii_log_data_parse(struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
	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 sr_channel *ch;
	float values[APPA_55II_NUM_CHANNELS], *val_ptr;
	const uint8_t *buf;
	int16_t temp;
	int offset, i;

	devc = sdi->priv;
	offset = 0;

	while (devc->log_buf_len >= 20 && devc->num_log_records > 0) {
		buf = devc->log_buf + offset;
		val_ptr = values;

		/* FIXME: Timestamp should be sent in the packet. */
		sr_dbg("Timestamp: %02d:%02d:%02d", buf[2], buf[3], buf[4]);

		sr_analog_init(&analog, &encoding, &meaning, &spec, 0);
		analog.num_samples = 1;
		analog.meaning->mq = SR_MQ_TEMPERATURE;
		analog.meaning->unit = SR_UNIT_CELSIUS;
		analog.data = values;

		for (i = 0; i < APPA_55II_NUM_CHANNELS; i++) {
			temp = RL16(buf + 12 + 2 * i);
			ch = g_slist_nth_data(sdi->channels, i);
			if (!ch->enabled)
				continue;
			analog.meaning->channels = g_slist_append(analog.meaning->channels, ch);
			*val_ptr++ = temp == 0x7FFF ? INFINITY : (float)temp / 10;
		}

		packet.type = SR_DF_ANALOG;
		packet.payload = &analog;
		sr_session_send(sdi, &packet);
		g_slist_free(analog.meaning->channels);

		sr_sw_limits_update_samples_read(&devc->limits, 1);
		devc->log_buf_len -= 20;
		offset += 20;
		devc->num_log_records--;
	}

	memmove(devc->log_buf, devc->log_buf + offset, devc->log_buf_len);
}

static void appa_55ii_log_data(struct sr_dev_inst *sdi, const uint8_t *buf)
{
	struct dev_context *devc;
	const uint8_t *ptr;
	unsigned int size;
	int s;

	devc = sdi->priv;
	if (devc->data_source != DATA_SOURCE_MEMORY)
		return;

	ptr = buf + 4;
	size = buf[3];
	while (size > 0) {
		s = MIN(size, sizeof(devc->log_buf) - devc->log_buf_len);
		memcpy(devc->log_buf + devc->log_buf_len, ptr, s);
		devc->log_buf_len += s;
		size -= s;
		ptr += s;

		appa_55ii_log_data_parse(sdi);
	}
}

static void appa_55ii_log_end(struct sr_dev_inst *sdi)
{
	struct dev_context *devc;

	devc = sdi->priv;
	if (devc->data_source != DATA_SOURCE_MEMORY)
		return;

	sdi->driver->dev_acquisition_stop(sdi);
}

static const uint8_t *appa_55ii_parse_data(struct sr_dev_inst *sdi,
		const uint8_t *buf, int len)
{
	if (len < 5)
		/* Need more data. */
		return NULL;

	if (buf[0] != 0x55 || buf[1] != 0x55)
		/* Try to re-synchronize on a packet start. */
		return buf + 1;

	if (len < 5 + buf[3])
		/* Need more data. */
		return NULL;

	if (!appa_55ii_checksum(buf))
		/* Skip broken packet. */
		return buf + 4 + buf[3] + 1;

	switch ((packet_type)buf[2]) {
	case LIVE_DATA:
		appa_55ii_live_data(sdi, buf);
		break;
	case LOG_METADATA:
		appa_55ii_log_metadata(sdi, buf);
		break;
	case LOG_DATA:
		appa_55ii_log_data(sdi, buf);
		break;
	case LOG_START:
		break;
	case LOG_END:
		appa_55ii_log_end(sdi);
		break;
	default:
		sr_warn("Invalid packet type: 0x%02x.", buf[2]);
		break;
	}

	return buf + 4 + buf[3] + 1;
}

SR_PRIV int appa_55ii_receive_data(int fd, int revents, void *cb_data)
{
	struct sr_dev_inst *sdi;
	struct dev_context *devc;
	struct sr_serial_dev_inst *serial;
	const uint8_t *ptr, *next_ptr, *end_ptr;
	int len;

	(void)fd;

	if (!(sdi = cb_data) || !(devc = sdi->priv) || revents != G_IO_IN)
		return TRUE;
	serial = sdi->conn;

	/* Try to get as much data as the buffer can hold. */
	len = sizeof(devc->buf) - devc->buf_len;
	len = serial_read_nonblocking(serial, devc->buf + devc->buf_len, len);
	if (len < 1) {
		sr_err("Serial port read error: %d.", len);
		return FALSE;
	}
	devc->buf_len += len;

	/* Now look for packets in that data. */
	ptr = devc->buf;
	end_ptr = ptr + devc->buf_len;
	while ((next_ptr = appa_55ii_parse_data(sdi, ptr, end_ptr - ptr)))
		ptr = next_ptr;

	/* If we have any data left, move it to the beginning of our buffer. */
	memmove(devc->buf, ptr, end_ptr - ptr);
	devc->buf_len -= ptr - devc->buf;

	/* If buffer is full and no valid packet was found, wipe buffer. */
	if (devc->buf_len >= sizeof(devc->buf)) {
		devc->buf_len = 0;
		return FALSE;
	}

	if (sr_sw_limits_check(&devc->limits)) {
		sdi->driver->dev_acquisition_stop(sdi);
		return TRUE;
	}

	return TRUE;
}
Commit	Line	Data
5e7a8e57 AJ	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2013 Aurelien Jacobs <aurel@gnuage.org>
	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
6ec6c43b	20	#include <config.h>
81a9ab72 AJ	21	#include <string.h>
81a9ab72 AJ	22	#include <math.h>
5e7a8e57 AJ	23	#include "protocol.h"
5e7a8e57 AJ	24
81a9ab72 AJ	25	typedef enum {
	26	LIVE_DATA = 0x00,
	27	LOG_METADATA = 0x11,
	28	LOG_DATA = 0x14,
	29	LOG_START = 0x18,
	30	LOG_END = 0x19,
9ee78f23	31	} packet_type;
81a9ab72 AJ	32
	33	static gboolean appa_55ii_checksum(const uint8_t *buf)
	34	{
7574e58c BV	35	int i, size, checksum;
	36
	37	size = buf[3] + 4;
	38	checksum = 0;
	39	for (i = 0; i < size; i++)
81a9ab72	40	checksum += buf[i];
7574e58c	41
81a9ab72 AJ	42	return buf[size] == (checksum & 0xFF);
	43	}
	44
	45	SR_PRIV gboolean appa_55ii_packet_valid(const uint8_t *buf)
	46	{
	47	if (buf[0] == 0x55 && buf[1] == 0x55 && buf[3] <= 32
7574e58c	48	&& appa_55ii_checksum(buf))
81a9ab72	49	return TRUE;
7574e58c	50
81a9ab72 AJ	51	return FALSE;
	52	}
	53
	54	static uint64_t appa_55ii_flags(const uint8_t *buf)
	55	{
7574e58c BV	56	uint8_t disp_mode;
	57	uint64_t flags;
	58
	59	disp_mode = buf[4 + 13];
	60	flags = 0;
	61	if ((disp_mode & 0xF0) == 0x20)
	62	flags \|= SR_MQFLAG_HOLD;
	63	if ((disp_mode & 0x0C) == 0x04)
	64	flags \|= SR_MQFLAG_MAX;
	65	if ((disp_mode & 0x0C) == 0x08)
	66	flags \|= SR_MQFLAG_MIN;
	67	if ((disp_mode & 0x0C) == 0x0C)
	68	flags \|= SR_MQFLAG_AVG;
81a9ab72 AJ	69
	70	return flags;
	71	}
	72
ba7dd8bb	73	static float appa_55ii_temp(const uint8_t *buf, int ch)
81a9ab72	74	{
7574e58c BV	75	const uint8_t *ptr;
	76	int16_t temp;
	77	uint8_t flags;
	78
ba7dd8bb	79	ptr = buf + 4 + 14 + 3 * ch;
7574e58c BV	80	temp = RL16(ptr);
	81	flags = ptr[2];
	82
	83	if (flags & 0x60)
	84	return INFINITY;
	85	else if (flags & 1)
	86	return (float)temp / 10;
	87	else
	88	return (float)temp;
81a9ab72 AJ	89	}
	90
	91	static void appa_55ii_live_data(struct sr_dev_inst sdi, const uint8_t buf)
	92	{
76b4d4f4	93	struct dev_context *devc;
81a9ab72	94	struct sr_datafeed_packet packet;
0417ada0 UH	95	struct sr_datafeed_analog analog;
	96	struct sr_analog_encoding encoding;
	97	struct sr_analog_meaning meaning;
	98	struct sr_analog_spec spec;
ba7dd8bb	99	struct sr_channel *ch;
3f239f08	100	float values[APPA_55II_NUM_CHANNELS], *val_ptr;
81a9ab72 AJ	101	int i;
81a9ab72 AJ	102
76b4d4f4 UH	103	devc = sdi->priv;
76b4d4f4 UH	104
81a9ab72 AJ	105	if (devc->data_source != DATA_SOURCE_LIVE)
	106	return;
	107
7574e58c	108	val_ptr = values;
0417ada0	109	sr_analog_init(&analog, &encoding, &meaning, &spec, 0);
81a9ab72	110	analog.num_samples = 1;
0417ada0 UH	111	analog.meaning->mq = SR_MQ_TEMPERATURE;
	112	analog.meaning->unit = SR_UNIT_CELSIUS;
	113	analog.meaning->mqflags = appa_55ii_flags(buf);
81a9ab72 AJ	114	analog.data = values;
81a9ab72 AJ	115
3f239f08	116	for (i = 0; i < APPA_55II_NUM_CHANNELS; i++) {
ba7dd8bb UH	117	ch = g_slist_nth_data(sdi->channels, i);
ba7dd8bb UH	118	if (!ch->enabled)
81a9ab72	119	continue;
0417ada0	120	analog.meaning->channels = g_slist_append(analog.meaning->channels, ch);
81a9ab72 AJ	121	*val_ptr++ = appa_55ii_temp(buf, i);
	122	}
	123
0417ada0	124	packet.type = SR_DF_ANALOG;
81a9ab72	125	packet.payload = &analog;
695dc859	126	sr_session_send(sdi, &packet);
0417ada0	127	g_slist_free(analog.meaning->channels);
81a9ab72	128
e2492a33	129	sr_sw_limits_update_samples_read(&devc->limits, 1);
81a9ab72 AJ	130	}
	131
	132	static void appa_55ii_log_metadata(struct sr_dev_inst sdi, const uint8_t buf)
	133	{
7574e58c BV	134	struct dev_context *devc;
	135
	136	devc = sdi->priv;
81a9ab72 AJ	137	devc->num_log_records = (buf[5] << 8) + buf[4];
	138	}
	139
	140	static void appa_55ii_log_data_parse(struct sr_dev_inst *sdi)
	141	{
7574e58c BV	142	struct dev_context *devc;
7574e58c BV	143	struct sr_datafeed_packet packet;
0417ada0 UH	144	struct sr_datafeed_analog analog;
	145	struct sr_analog_encoding encoding;
	146	struct sr_analog_meaning meaning;
	147	struct sr_analog_spec spec;
ba7dd8bb	148	struct sr_channel *ch;
3f239f08	149	float values[APPA_55II_NUM_CHANNELS], *val_ptr;
7574e58c BV	150	const uint8_t *buf;
	151	int16_t temp;
	152	int offset, i;
	153
	154	devc = sdi->priv;
	155	offset = 0;
81a9ab72 AJ	156
81a9ab72 AJ	157	while (devc->log_buf_len >= 20 && devc->num_log_records > 0) {
7574e58c BV	158	buf = devc->log_buf + offset;
7574e58c BV	159	val_ptr = values;
81a9ab72	160
76b4d4f4	161	/* FIXME: Timestamp should be sent in the packet. */
81a9ab72 AJ	162	sr_dbg("Timestamp: %02d:%02d:%02d", buf[2], buf[3], buf[4]);
81a9ab72 AJ	163
0417ada0	164	sr_analog_init(&analog, &encoding, &meaning, &spec, 0);
81a9ab72	165	analog.num_samples = 1;
0417ada0 UH	166	analog.meaning->mq = SR_MQ_TEMPERATURE;
0417ada0 UH	167	analog.meaning->unit = SR_UNIT_CELSIUS;
81a9ab72 AJ	168	analog.data = values;
81a9ab72 AJ	169
3f239f08	170	for (i = 0; i < APPA_55II_NUM_CHANNELS; i++) {
7574e58c	171	temp = RL16(buf + 12 + 2 * i);
ba7dd8bb UH	172	ch = g_slist_nth_data(sdi->channels, i);
ba7dd8bb UH	173	if (!ch->enabled)
81a9ab72	174	continue;
0417ada0	175	analog.meaning->channels = g_slist_append(analog.meaning->channels, ch);
81a9ab72 AJ	176	*val_ptr++ = temp == 0x7FFF ? INFINITY : (float)temp / 10;
	177	}
	178
0417ada0	179	packet.type = SR_DF_ANALOG;
81a9ab72	180	packet.payload = &analog;
695dc859	181	sr_session_send(sdi, &packet);
0417ada0	182	g_slist_free(analog.meaning->channels);
81a9ab72	183
e2492a33	184	sr_sw_limits_update_samples_read(&devc->limits, 1);
81a9ab72 AJ	185	devc->log_buf_len -= 20;
	186	offset += 20;
	187	devc->num_log_records--;
	188	}
	189
	190	memmove(devc->log_buf, devc->log_buf + offset, devc->log_buf_len);
	191	}
	192
	193	static void appa_55ii_log_data(struct sr_dev_inst sdi, const uint8_t buf)
	194	{
7574e58c BV	195	struct dev_context *devc;
	196	const uint8_t *ptr;
	197	unsigned int size;
	198	int s;
81a9ab72	199
7574e58c	200	devc = sdi->priv;
81a9ab72 AJ	201	if (devc->data_source != DATA_SOURCE_MEMORY)
	202	return;
	203
76b4d4f4	204	ptr = buf + 4;
7574e58c	205	size = buf[3];
81a9ab72	206	while (size > 0) {
7574e58c	207	s = MIN(size, sizeof(devc->log_buf) - devc->log_buf_len);
81a9ab72 AJ	208	memcpy(devc->log_buf + devc->log_buf_len, ptr, s);
	209	devc->log_buf_len += s;
	210	size -= s;
	211	ptr += s;
	212
	213	appa_55ii_log_data_parse(sdi);
	214	}
	215	}
	216
	217	static void appa_55ii_log_end(struct sr_dev_inst *sdi)
	218	{
7574e58c	219	struct dev_context *devc;
81a9ab72	220
7574e58c	221	devc = sdi->priv;
81a9ab72 AJ	222	if (devc->data_source != DATA_SOURCE_MEMORY)
	223	return;
	224
695dc859	225	sdi->driver->dev_acquisition_stop(sdi);
81a9ab72 AJ	226	}
	227
	228	static const uint8_t appa_55ii_parse_data(struct sr_dev_inst sdi,
7574e58c	229	const uint8_t *buf, int len)
81a9ab72 AJ	230	{
81a9ab72 AJ	231	if (len < 5)
7574e58c BV	232	/* Need more data. */
7574e58c BV	233	return NULL;
81a9ab72 AJ	234
81a9ab72 AJ	235	if (buf[0] != 0x55 \|\| buf[1] != 0x55)
7574e58c BV	236	/* Try to re-synchronize on a packet start. */
7574e58c BV	237	return buf + 1;
81a9ab72	238
7574e58c BV	239	if (len < 5 + buf[3])
	240	/* Need more data. */
	241	return NULL;
81a9ab72 AJ	242
81a9ab72 AJ	243	if (!appa_55ii_checksum(buf))
7574e58c BV	244	/* Skip broken packet. */
7574e58c BV	245	return buf + 4 + buf[3] + 1;
81a9ab72	246
9ee78f23	247	switch ((packet_type)buf[2]) {
7574e58c BV	248	case LIVE_DATA:
	249	appa_55ii_live_data(sdi, buf);
	250	break;
	251	case LOG_METADATA:
	252	appa_55ii_log_metadata(sdi, buf);
	253	break;
	254	case LOG_DATA:
	255	appa_55ii_log_data(sdi, buf);
	256	break;
	257	case LOG_START:
	258	break;
	259	case LOG_END:
	260	appa_55ii_log_end(sdi);
	261	break;
76b4d4f4 UH	262	default:
	263	sr_warn("Invalid packet type: 0x%02x.", buf[2]);
	264	break;
81a9ab72 AJ	265	}
	266
	267	return buf + 4 + buf[3] + 1;
	268	}
	269
5e7a8e57 AJ	270	SR_PRIV int appa_55ii_receive_data(int fd, int revents, void *cb_data)
5e7a8e57 AJ	271	{
81a9ab72	272	struct sr_dev_inst *sdi;
5e7a8e57	273	struct dev_context *devc;
81a9ab72 AJ	274	struct sr_serial_dev_inst *serial;
	275	const uint8_t ptr, next_ptr, *end_ptr;
	276	int len;
5e7a8e57 AJ	277
	278	(void)fd;
	279
81a9ab72	280	if (!(sdi = cb_data) \|\| !(devc = sdi->priv) \|\| revents != G_IO_IN)
5e7a8e57	281	return TRUE;
81a9ab72 AJ	282	serial = sdi->conn;
	283
	284	/* Try to get as much data as the buffer can hold. */
	285	len = sizeof(devc->buf) - devc->buf_len;
25dd0831	286	len = serial_read_nonblocking(serial, devc->buf + devc->buf_len, len);
81a9ab72 AJ	287	if (len < 1) {
	288	sr_err("Serial port read error: %d.", len);
	289	return FALSE;
	290	}
	291	devc->buf_len += len;
	292
	293	/* Now look for packets in that data. */
	294	ptr = devc->buf;
	295	end_ptr = ptr + devc->buf_len;
	296	while ((next_ptr = appa_55ii_parse_data(sdi, ptr, end_ptr - ptr)))
	297	ptr = next_ptr;
5e7a8e57	298
81a9ab72 AJ	299	/* If we have any data left, move it to the beginning of our buffer. */
	300	memmove(devc->buf, ptr, end_ptr - ptr);
	301	devc->buf_len -= ptr - devc->buf;
	302
	303	/* If buffer is full and no valid packet was found, wipe buffer. */
	304	if (devc->buf_len >= sizeof(devc->buf)) {
	305	devc->buf_len = 0;
	306	return FALSE;
	307	}
	308
e2492a33	309	if (sr_sw_limits_check(&devc->limits)) {
695dc859	310	sdi->driver->dev_acquisition_stop(sdi);
5e7a8e57	311	return TRUE;
81a9ab72	312	}
5e7a8e57	313
5e7a8e57 AJ	314	return TRUE;
5e7a8e57 AJ	315	}