[libsigrok.git] / hardware / colead-slm / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2012 Bert Vermeulen <bert@biot.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 <stdlib.h>
#include <glib.h>
#include "libsigrok.h"
#include "libsigrok-internal.h"
#include "protocol.h"
#include <errno.h>
#include <string.h>


static void process_packet(const struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
	struct sr_datafeed_packet packet;
	struct sr_datafeed_analog analog;
	GString *dbg;
	float fvalue;
	int checksum, mode, i;

	devc = sdi->priv;
	if (sr_log_loglevel_get() >= SR_LOG_SPEW) {
		dbg = g_string_sized_new(128);
		g_string_printf(dbg, "received packet:");
		for (i = 0; i < 10; i++)
			g_string_append_printf(dbg, " %.2x", (devc->buf)[i]);
		sr_spew("%s", dbg->str);
		g_string_free(dbg, TRUE);
	}

	if (devc->buf[0] != 0x08 || devc->buf[1] != 0x04) {
		sr_dbg("invalid packet header.");
		return;
	}

	if (devc->buf[8] != 0x01) {
		sr_dbg("invalid measurement.");
		return;
	}

	checksum = 0;
	for (i = 0; i < 9; i++)
		checksum += devc->buf[i];
	if ((checksum & 0xff) != devc->buf[9]) {
		sr_dbg("invalid packet checksum.");
		return;
	}

	fvalue = 0.0;
	for (i = 3; i < 8; i++) {
		if (devc->buf[i] > 0x09)
			continue;
		fvalue *= 10;
		fvalue += devc->buf[i];
	}
	fvalue /= 10;

	memset(&analog, 0, sizeof(struct sr_datafeed_analog));
	analog.mq = SR_MQ_SOUND_PRESSURE_LEVEL;
	analog.unit = SR_UNIT_DECIBEL_SPL;
	analog.num_samples = 1;
	analog.data = &fvalue;

	/* High nibble should only have 0x01 or 0x02. */
	mode = (devc->buf[2] >> 4) & 0x0f;
	if (mode == 0x02)
		analog.mqflags |= SR_MQFLAG_HOLD;
	else if (mode != 0x01) {
		sr_dbg("unknown measurement mode 0x%.2x", mode);
		return;
	}

	/* Low nibble has 14 combinations of direct/long-term average,
	 * time scale of that average, frequency weighting, and time
	 * weighting. */
	mode = devc->buf[2] & 0x0f;
	switch (mode) {
		case 0x0:
			analog.mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_A \
					| SR_MQFLAG_SPL_TIME_WEIGHT_F;
			break;
		case 0x1:
			analog.mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_A \
					| SR_MQFLAG_SPL_TIME_WEIGHT_S;
			break;
		case 0x2:
			analog.mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_C \
					| SR_MQFLAG_SPL_TIME_WEIGHT_F;
			break;
		case 0x3:
			analog.mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_C \
					| SR_MQFLAG_SPL_TIME_WEIGHT_S;
			break;
		case 0x4:
			analog.mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_FLAT \
					| SR_MQFLAG_SPL_TIME_WEIGHT_F;
			break;
		case 0x5:
			analog.mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_FLAT \
					| SR_MQFLAG_SPL_TIME_WEIGHT_S;
			break;
		case 0x6:
			analog.mqflags |= SR_MQFLAG_SPL_PCT_OVER_ALARM \
					| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
					| SR_MQFLAG_SPL_TIME_WEIGHT_F;
			break;
		case 0x7:
			analog.mqflags |= SR_MQFLAG_SPL_PCT_OVER_ALARM \
					| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
					| SR_MQFLAG_SPL_TIME_WEIGHT_S;
			break;
		case 0x8:
			/* 10-second mean, but we don't have MQ flags to express it. */
			analog.mqflags |= SR_MQFLAG_SPL_LAT \
					| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
					| SR_MQFLAG_SPL_TIME_WEIGHT_F;
			break;
		case 0x9:
			/* Mean over a time period between 11 seconds and 24 hours.
			 * Which is so silly that there's no point in expressing
			 * either this or the previous case.  */
			analog.mqflags |= SR_MQFLAG_SPL_LAT \
					| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
					| SR_MQFLAG_SPL_TIME_WEIGHT_F;
			break;
		case 0xa:
			/* 10-second mean. */
			analog.mqflags |= SR_MQFLAG_SPL_LAT \
					| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
					| SR_MQFLAG_SPL_TIME_WEIGHT_S;
			break;
		case 0xb:
			/* Mean over a time period between 11 seconds and 24 hours. */
			analog.mqflags |= SR_MQFLAG_SPL_LAT \
					| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
					| SR_MQFLAG_SPL_TIME_WEIGHT_S;
			break;
		case 0xc:
			/* Internal calibration on 1kHz sine at 94dB, not useful
			 * to anything but the device. */
			analog.mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_FLAT;
			break;
		case 0xd:
			/* Internal calibration on 1kHz sine at 94dB, not useful
			 * to anything but the device. */
			analog.mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_FLAT;
			break;
		default:
			sr_dbg("unknown configuration 0x%.2x", mode);
			return;
			break;
	}

	packet.type = SR_DF_ANALOG;
	packet.payload = &analog;
	sr_session_send(devc->cb_data, &packet);

	devc->num_samples++;

}

SR_PRIV int colead_slm_receive_data(int fd, int revents, void *cb_data)
{
	const struct sr_dev_inst *sdi;
	struct dev_context *devc;
	int len;
	char buf[128];

	if (!(sdi = cb_data))
		return TRUE;

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

	if (revents != G_IO_IN)
		/* Timeout event. */
		return TRUE;

	if (devc->state == IDLE) {
		if (serial_read(fd, buf, 128) != 1 || buf[0] != 0x10)
			/* Nothing there, or caught the tail end of a previous packet,
			 * or some garbage. Unless it's a single "data ready" byte,
			 * we don't want it. */
			return TRUE;
		/* Got 0x10, "measurement ready". */
		if (serial_write(fd, "\x20", 1) == -1)
			sr_err("unable to send command: %s", strerror(errno));
		else {
			devc->state = COMMAND_SENT;
			devc->buflen = 0;
		}
	} else {
		len = serial_read(fd, devc->buf + devc->buflen, 10 - devc->buflen);
		if (len < 1)
			return TRUE;
		devc->buflen += len;
		if (devc->buflen > 10) {
			sr_dbg("buffer overrun");
			devc->state = IDLE;
			return TRUE;
		}
		if (devc->buflen == 10) {
			/* If we got here, we're sure the device sent a "data ready"
			 * notification, we asked for data, and got it. */
			process_packet(sdi);
			devc->state = IDLE;
		}
	}

	return TRUE;
}
Commit	Line	Data
4d729ddc BV	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2012 Bert Vermeulen <bert@biot.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 <stdlib.h>
	21	#include <glib.h>
	22	#include "libsigrok.h"
	23	#include "libsigrok-internal.h"
	24	#include "protocol.h"
a8d09e13 BV	25	#include <errno.h>
	26	#include <string.h>
	27
	28
	29	static void process_packet(const struct sr_dev_inst *sdi)
	30	{
	31	struct dev_context *devc;
	32	struct sr_datafeed_packet packet;
	33	struct sr_datafeed_analog analog;
	34	GString *dbg;
	35	float fvalue;
	36	int checksum, mode, i;
	37
	38	devc = sdi->priv;
	39	if (sr_log_loglevel_get() >= SR_LOG_SPEW) {
	40	dbg = g_string_sized_new(128);
	41	g_string_printf(dbg, "received packet:");
	42	for (i = 0; i < 10; i++)
	43	g_string_append_printf(dbg, " %.2x", (devc->buf)[i]);
	44	sr_spew("%s", dbg->str);
	45	g_string_free(dbg, TRUE);
	46	}
	47
	48	if (devc->buf[0] != 0x08 \|\| devc->buf[1] != 0x04) {
	49	sr_dbg("invalid packet header.");
	50	return;
	51	}
	52
	53	if (devc->buf[8] != 0x01) {
	54	sr_dbg("invalid measurement.");
	55	return;
	56	}
	57
	58	checksum = 0;
	59	for (i = 0; i < 9; i++)
	60	checksum += devc->buf[i];
	61	if ((checksum & 0xff) != devc->buf[9]) {
	62	sr_dbg("invalid packet checksum.");
	63	return;
	64	}
	65
	66	fvalue = 0.0;
	67	for (i = 3; i < 8; i++) {
	68	if (devc->buf[i] > 0x09)
	69	continue;
	70	fvalue *= 10;
	71	fvalue += devc->buf[i];
	72	}
	73	fvalue /= 10;
	74
	75	memset(&analog, 0, sizeof(struct sr_datafeed_analog));
	76	analog.mq = SR_MQ_SOUND_PRESSURE_LEVEL;
	77	analog.unit = SR_UNIT_DECIBEL_SPL;
	78	analog.num_samples = 1;
	79	analog.data = &fvalue;
	80
	81	/* High nibble should only have 0x01 or 0x02. */
	82	mode = (devc->buf[2] >> 4) & 0x0f;
	83	if (mode == 0x02)
	84	analog.mqflags \|= SR_MQFLAG_HOLD;
	85	else if (mode != 0x01) {
	86	sr_dbg("unknown measurement mode 0x%.2x", mode);
	87	return;
	88	}
89
90	/* Low nibble has 14 combinations of direct/long-term average,
91	* time scale of that average, frequency weighting, and time
92	* weighting. */
93	mode = devc->buf[2] & 0x0f;
94	switch (mode) {
95	case 0x0:
96	analog.mqflags \|= SR_MQFLAG_SPL_FREQ_WEIGHT_A \
97	\| SR_MQFLAG_SPL_TIME_WEIGHT_F;
98	break;
99	case 0x1:
100	analog.mqflags \|= SR_MQFLAG_SPL_FREQ_WEIGHT_A \
101	\| SR_MQFLAG_SPL_TIME_WEIGHT_S;
102	break;
103	case 0x2:
104	analog.mqflags \|= SR_MQFLAG_SPL_FREQ_WEIGHT_C \
105	\| SR_MQFLAG_SPL_TIME_WEIGHT_F;
106	break;
107	case 0x3:
108	analog.mqflags \|= SR_MQFLAG_SPL_FREQ_WEIGHT_C \
109	\| SR_MQFLAG_SPL_TIME_WEIGHT_S;
110	break;
111	case 0x4:
112	analog.mqflags \|= SR_MQFLAG_SPL_FREQ_WEIGHT_FLAT \
113	\| SR_MQFLAG_SPL_TIME_WEIGHT_F;
114	break;
115	case 0x5:
116	analog.mqflags \|= SR_MQFLAG_SPL_FREQ_WEIGHT_FLAT \
117	\| SR_MQFLAG_SPL_TIME_WEIGHT_S;
118	break;
119	case 0x6:
120	analog.mqflags \|= SR_MQFLAG_SPL_PCT_OVER_ALARM \
121	\| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
122	\| SR_MQFLAG_SPL_TIME_WEIGHT_F;
123	break;
124	case 0x7:
125	analog.mqflags \|= SR_MQFLAG_SPL_PCT_OVER_ALARM \
126	\| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
127	\| SR_MQFLAG_SPL_TIME_WEIGHT_S;
128	break;
129	case 0x8:
130	/* 10-second mean, but we don't have MQ flags to express it. */
131	analog.mqflags \|= SR_MQFLAG_SPL_LAT \
132	\| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
133	\| SR_MQFLAG_SPL_TIME_WEIGHT_F;
134	break;
135	case 0x9:
136	/* Mean over a time period between 11 seconds and 24 hours.
137	* Which is so silly that there's no point in expressing
138	* either this or the previous case. */
139	analog.mqflags \|= SR_MQFLAG_SPL_LAT \
140	\| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
141	\| SR_MQFLAG_SPL_TIME_WEIGHT_F;
142	break;
143	case 0xa:
144	/* 10-second mean. */
145	analog.mqflags \|= SR_MQFLAG_SPL_LAT \
146	\| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
147	\| SR_MQFLAG_SPL_TIME_WEIGHT_S;
148	break;
149	case 0xb:
150	/* Mean over a time period between 11 seconds and 24 hours. */
151	analog.mqflags \|= SR_MQFLAG_SPL_LAT \
152	\| SR_MQFLAG_SPL_FREQ_WEIGHT_A \
153	\| SR_MQFLAG_SPL_TIME_WEIGHT_S;
154	break;
155	case 0xc:
156	/* Internal calibration on 1kHz sine at 94dB, not useful
157	* to anything but the device. */
158	analog.mqflags \|= SR_MQFLAG_SPL_FREQ_WEIGHT_FLAT;
159	break;
160	case 0xd:
161	/* Internal calibration on 1kHz sine at 94dB, not useful
162	* to anything but the device. */
163	analog.mqflags \|= SR_MQFLAG_SPL_FREQ_WEIGHT_FLAT;
164	break;
165	default:
166	sr_dbg("unknown configuration 0x%.2x", mode);
167	return;
168	break;
169	}
170
171	packet.type = SR_DF_ANALOG;
172	packet.payload = &analog;
173	sr_session_send(devc->cb_data, &packet);
174
175	devc->num_samples++;
176
177	}
4d729ddc BV	178
	179	SR_PRIV int colead_slm_receive_data(int fd, int revents, void *cb_data)
	180	{
	181	const struct sr_dev_inst *sdi;
	182	struct dev_context *devc;
a8d09e13 BV	183	int len;
a8d09e13 BV	184	char buf[128];
4d729ddc BV	185
	186	if (!(sdi = cb_data))
	187	return TRUE;
	188
	189	if (!(devc = sdi->priv))
	190	return TRUE;
	191
a8d09e13 BV	192	if (revents != G_IO_IN)
	193	/* Timeout event. */
	194	return TRUE;
	195
	196	if (devc->state == IDLE) {
	197	if (serial_read(fd, buf, 128) != 1 \|\| buf[0] != 0x10)
	198	/* Nothing there, or caught the tail end of a previous packet,
	199	* or some garbage. Unless it's a single "data ready" byte,
	200	* we don't want it. */
	201	return TRUE;
	202	/* Got 0x10, "measurement ready". */
	203	if (serial_write(fd, "\x20", 1) == -1)
	204	sr_err("unable to send command: %s", strerror(errno));
	205	else {
	206	devc->state = COMMAND_SENT;
	207	devc->buflen = 0;
	208	}
	209	} else {
	210	len = serial_read(fd, devc->buf + devc->buflen, 10 - devc->buflen);
	211	if (len < 1)
	212	return TRUE;
	213	devc->buflen += len;
	214	if (devc->buflen > 10) {
	215	sr_dbg("buffer overrun");
	216	devc->state = IDLE;
	217	return TRUE;
	218	}
	219	if (devc->buflen == 10) {
	220	/* If we got here, we're sure the device sent a "data ready"
	221	* notification, we asked for data, and got it. */
	222	process_packet(sdi);
	223	devc->state = IDLE;
	224	}
4d729ddc BV	225	}
	226
	227	return TRUE;
	228	}
a8d09e13	229