[libsigrok.git] / src / hardware / maynuo-m97 / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2015 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 "protocol.h"

SR_PRIV int maynuo_m97_get_bit(struct sr_modbus_dev_inst *modbus,
		enum maynuo_m97_coil address, int *value)
{
	uint8_t coil;
	int ret = sr_modbus_read_coils(modbus, address, 1, &coil);
	*value = coil & 1;
	return ret;
}

SR_PRIV int maynuo_m97_set_bit(struct sr_modbus_dev_inst *modbus,
		enum maynuo_m97_coil address, int value)
{
	return sr_modbus_write_coil(modbus, address, value);
}

SR_PRIV int maynuo_m97_get_float(struct sr_modbus_dev_inst *modbus,
		enum maynuo_m97_register address, float *value)
{
	uint16_t registers[2];
	int ret = sr_modbus_read_holding_registers(modbus, address, 2, registers);
	if (ret == SR_OK)
		*value = RBFL(registers);
	return ret;
}

SR_PRIV int maynuo_m97_set_float(struct sr_modbus_dev_inst *modbus,
		enum maynuo_m97_register address, float value)
{
	uint16_t registers[2];
	WBFL(registers, value);
	return sr_modbus_write_multiple_registers(modbus, address, 2, registers);
}


static int maynuo_m97_cmd(struct sr_modbus_dev_inst *modbus,
		enum maynuo_m97_mode cmd)
{
	uint16_t registers[1];
	WB16(registers, cmd);
	return sr_modbus_write_multiple_registers(modbus, CMD, 1, registers);
}

SR_PRIV int maynuo_m97_get_mode(struct sr_modbus_dev_inst *modbus,
		enum maynuo_m97_mode *mode)
{
	uint16_t registers[1];
	int ret;
	ret = sr_modbus_read_holding_registers(modbus, SETMODE, 1, registers);
	*mode = RB16(registers) & 0xFF;
	return ret;
}

SR_PRIV int maynuo_m97_set_mode(struct sr_modbus_dev_inst *modbus,
		enum maynuo_m97_mode mode)
{
	return maynuo_m97_cmd(modbus, mode);
}

SR_PRIV int maynuo_m97_set_input(struct sr_modbus_dev_inst *modbus, int enable)
{
	enum maynuo_m97_mode mode;
	int ret;
	if ((ret = maynuo_m97_get_mode(modbus, &mode)) != SR_OK)
		return ret;
	if ((ret = maynuo_m97_cmd(modbus, enable ? INPUT_ON : INPUT_OFF)) != SR_OK)
		return ret;
	return maynuo_m97_set_mode(modbus, mode);
}

SR_PRIV int maynuo_m97_get_model_version(struct sr_modbus_dev_inst *modbus,
		uint16_t *model, uint16_t *version)
{
	uint16_t registers[2];
	int ret;
	ret = sr_modbus_read_holding_registers(modbus, MODEL, 2, registers);
	*model   = RB16(registers+0);
	*version = RB16(registers+1);
	return ret;
}


SR_PRIV const char *maynuo_m97_mode_to_str(enum maynuo_m97_mode mode)
{
	switch(mode) {
	case CC:             return "CC";
	case CV:             return "CV";
	case CW:             return "CP";
	case CR:             return "CR";
	case CC_SOFT_START:  return "CC Soft Start";
	case DYNAMIC:        return "Dynamic";
	case SHORT_CIRCUIT:  return "Short Circuit";
	case LIST:           return "List Mode";
	case CC_L_AND_UL:    return "CC Loading and Unloading";
	case CV_L_AND_UL:    return "CV Loading and Unloading";
	case CW_L_AND_UL:    return "CP Loading and Unloading";
	case CR_L_AND_UL:    return "CR Loading and Unloading";
	case CC_TO_CV:       return "CC + CV";
	case CR_TO_CV:       return "CR + CV";
	case BATTERY_TEST:   return "Battery Test";
	case CV_SOFT_START:  return "CV Soft Start";
	default:             return "UNKNOWN";
	}
}


static void maynuo_m97_session_send_value(const struct sr_dev_inst *sdi, struct sr_channel *ch, float value, enum sr_mq mq, enum sr_unit unit)
{
	struct sr_datafeed_packet packet;
	struct sr_datafeed_analog analog;

	analog.channels = g_slist_append(NULL, ch);
	analog.num_samples = 1;
	analog.data = &value;
	analog.mq = mq;
	analog.unit = unit;
	analog.mqflags = SR_MQFLAG_DC;

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

SR_PRIV int maynuo_m97_capture_start(const struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
	struct sr_modbus_dev_inst *modbus;
	int ret;

	modbus = sdi->conn;
	devc = sdi->priv;

	if ((ret = sr_modbus_read_holding_registers(modbus, U, 4, NULL)) == SR_OK)
		devc->expecting_registers = 4;
	return ret;
}

SR_PRIV int maynuo_m97_receive_data(int fd, int revents, void *cb_data)
{
	struct sr_dev_inst *sdi;
	struct dev_context *devc;
	struct sr_modbus_dev_inst *modbus;
	struct sr_datafeed_packet packet;
	uint16_t registers[4];
	int64_t t;

	(void)fd;
	(void)revents;

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

	modbus = sdi->conn;
	devc = sdi->priv;

	devc->expecting_registers = 0;
	if (sr_modbus_read_holding_registers(modbus, -1, 4, registers) == SR_OK) {
		packet.type = SR_DF_FRAME_BEGIN;
		sr_session_send(cb_data, &packet);

		maynuo_m97_session_send_value(sdi, sdi->channels->data,
		                              RBFL(registers + 0),
		                              SR_MQ_VOLTAGE, SR_UNIT_VOLT);
		maynuo_m97_session_send_value(sdi, sdi->channels->next->data,
		                              RBFL(registers + 2),
		                              SR_MQ_CURRENT, SR_UNIT_AMPERE);

		packet.type = SR_DF_FRAME_END;
		sr_session_send(cb_data, &packet);
		devc->num_samples++;
	}

	if (devc->limit_samples && (devc->num_samples >= devc->limit_samples)) {
		sr_info("Requested number of samples reached.");
		sdi->driver->dev_acquisition_stop(sdi, cb_data);
		return TRUE;
	}

	if (devc->limit_msec) {
		t = (g_get_monotonic_time() - devc->starttime) / 1000;
		if (t > (int64_t)devc->limit_msec) {
			sr_info("Requested time limit reached.");
			sdi->driver->dev_acquisition_stop(sdi, cb_data);
			return TRUE;
		}
	}

	maynuo_m97_capture_start(sdi);
	return TRUE;
}
Commit	Line	Data
e1ccfb19 AJ	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2015 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>
e1ccfb19 AJ	21	#include "protocol.h"
e1ccfb19 AJ	22
ffb580cf AJ	23	SR_PRIV int maynuo_m97_get_bit(struct sr_modbus_dev_inst *modbus,
	24	enum maynuo_m97_coil address, int *value)
	25	{
	26	uint8_t coil;
	27	int ret = sr_modbus_read_coils(modbus, address, 1, &coil);
	28	*value = coil & 1;
	29	return ret;
	30	}
	31
	32	SR_PRIV int maynuo_m97_set_bit(struct sr_modbus_dev_inst *modbus,
	33	enum maynuo_m97_coil address, int value)
	34	{
	35	return sr_modbus_write_coil(modbus, address, value);
	36	}
	37
	38	SR_PRIV int maynuo_m97_get_float(struct sr_modbus_dev_inst *modbus,
	39	enum maynuo_m97_register address, float *value)
	40	{
	41	uint16_t registers[2];
	42	int ret = sr_modbus_read_holding_registers(modbus, address, 2, registers);
	43	if (ret == SR_OK)
	44	*value = RBFL(registers);
	45	return ret;
	46	}
	47
	48	SR_PRIV int maynuo_m97_set_float(struct sr_modbus_dev_inst *modbus,
	49	enum maynuo_m97_register address, float value)
	50	{
	51	uint16_t registers[2];
	52	WBFL(registers, value);
	53	return sr_modbus_write_multiple_registers(modbus, address, 2, registers);
	54	}
	55
	56
	57	static int maynuo_m97_cmd(struct sr_modbus_dev_inst *modbus,
	58	enum maynuo_m97_mode cmd)
	59	{
	60	uint16_t registers[1];
	61	WB16(registers, cmd);
	62	return sr_modbus_write_multiple_registers(modbus, CMD, 1, registers);
	63	}
	64
	65	SR_PRIV int maynuo_m97_get_mode(struct sr_modbus_dev_inst *modbus,
	66	enum maynuo_m97_mode *mode)
	67	{
	68	uint16_t registers[1];
	69	int ret;
	70	ret = sr_modbus_read_holding_registers(modbus, SETMODE, 1, registers);
	71	*mode = RB16(registers) & 0xFF;
	72	return ret;
	73	}
	74
	75	SR_PRIV int maynuo_m97_set_mode(struct sr_modbus_dev_inst *modbus,
	76	enum maynuo_m97_mode mode)
	77	{
	78	return maynuo_m97_cmd(modbus, mode);
	79	}
	80
	81	SR_PRIV int maynuo_m97_set_input(struct sr_modbus_dev_inst *modbus, int enable)
	82	{
	83	enum maynuo_m97_mode mode;
	84	int ret;
	85	if ((ret = maynuo_m97_get_mode(modbus, &mode)) != SR_OK)
	86	return ret;
87	if ((ret = maynuo_m97_cmd(modbus, enable ? INPUT_ON : INPUT_OFF)) != SR_OK)
88	return ret;
89	return maynuo_m97_set_mode(modbus, mode);
90	}
91
92	SR_PRIV int maynuo_m97_get_model_version(struct sr_modbus_dev_inst *modbus,
93	uint16_t model, uint16_t version)
94	{
95	uint16_t registers[2];
96	int ret;
97	ret = sr_modbus_read_holding_registers(modbus, MODEL, 2, registers);
98	*model = RB16(registers+0);
99	*version = RB16(registers+1);
100	return ret;
101	}
102
103
104	SR_PRIV const char *maynuo_m97_mode_to_str(enum maynuo_m97_mode mode)
105	{
106	switch(mode) {
107	case CC: return "CC";
108	case CV: return "CV";
109	case CW: return "CP";
110	case CR: return "CR";
111	case CC_SOFT_START: return "CC Soft Start";
112	case DYNAMIC: return "Dynamic";
113	case SHORT_CIRCUIT: return "Short Circuit";
114	case LIST: return "List Mode";
115	case CC_L_AND_UL: return "CC Loading and Unloading";
116	case CV_L_AND_UL: return "CV Loading and Unloading";
117	case CW_L_AND_UL: return "CP Loading and Unloading";
118	case CR_L_AND_UL: return "CR Loading and Unloading";
119	case CC_TO_CV: return "CC + CV";
120	case CR_TO_CV: return "CR + CV";
121	case BATTERY_TEST: return "Battery Test";
122	case CV_SOFT_START: return "CV Soft Start";
123	default: return "UNKNOWN";
124	}
125	}
126
127
128	static void maynuo_m97_session_send_value(const struct sr_dev_inst sdi, struct sr_channel ch, float value, enum sr_mq mq, enum sr_unit unit)
129	{
130	struct sr_datafeed_packet packet;
131	struct sr_datafeed_analog analog;
132
133	analog.channels = g_slist_append(NULL, ch);
134	analog.num_samples = 1;
135	analog.data = &value;
136	analog.mq = mq;
137	analog.unit = unit;
138	analog.mqflags = SR_MQFLAG_DC;
139
140	packet.type = SR_DF_ANALOG;
141	packet.payload = &analog;
142	sr_session_send(sdi, &packet);
143	g_slist_free(analog.channels);
144	}
145
146	SR_PRIV int maynuo_m97_capture_start(const struct sr_dev_inst *sdi)
147	{
148	struct dev_context *devc;
149	struct sr_modbus_dev_inst *modbus;
150	int ret;
151
152	modbus = sdi->conn;
153	devc = sdi->priv;
154
155	if ((ret = sr_modbus_read_holding_registers(modbus, U, 4, NULL)) == SR_OK)
156	devc->expecting_registers = 4;
157	return ret;
158	}
159
e1ccfb19 AJ	160	SR_PRIV int maynuo_m97_receive_data(int fd, int revents, void *cb_data)
e1ccfb19 AJ	161	{
ffb580cf	162	struct sr_dev_inst *sdi;
e1ccfb19	163	struct dev_context *devc;
ffb580cf AJ	164	struct sr_modbus_dev_inst *modbus;
	165	struct sr_datafeed_packet packet;
	166	uint16_t registers[4];
	167	int64_t t;
e1ccfb19 AJ	168
e1ccfb19 AJ	169	(void)fd;
ffb580cf	170	(void)revents;
e1ccfb19 AJ	171
	172	if (!(sdi = cb_data))
	173	return TRUE;
	174
ffb580cf AJ	175	modbus = sdi->conn;
	176	devc = sdi->priv;
	177
	178	devc->expecting_registers = 0;
	179	if (sr_modbus_read_holding_registers(modbus, -1, 4, registers) == SR_OK) {
	180	packet.type = SR_DF_FRAME_BEGIN;
	181	sr_session_send(cb_data, &packet);
	182
	183	maynuo_m97_session_send_value(sdi, sdi->channels->data,
	184	RBFL(registers + 0),
	185	SR_MQ_VOLTAGE, SR_UNIT_VOLT);
	186	maynuo_m97_session_send_value(sdi, sdi->channels->next->data,
	187	RBFL(registers + 2),
	188	SR_MQ_CURRENT, SR_UNIT_AMPERE);
	189
	190	packet.type = SR_DF_FRAME_END;
	191	sr_session_send(cb_data, &packet);
	192	devc->num_samples++;
	193	}
	194
	195	if (devc->limit_samples && (devc->num_samples >= devc->limit_samples)) {
	196	sr_info("Requested number of samples reached.");
	197	sdi->driver->dev_acquisition_stop(sdi, cb_data);
e1ccfb19	198	return TRUE;
ffb580cf	199	}
e1ccfb19	200
ffb580cf AJ	201	if (devc->limit_msec) {
	202	t = (g_get_monotonic_time() - devc->starttime) / 1000;
	203	if (t > (int64_t)devc->limit_msec) {
	204	sr_info("Requested time limit reached.");
	205	sdi->driver->dev_acquisition_stop(sdi, cb_data);
	206	return TRUE;
	207	}
e1ccfb19 AJ	208	}
e1ccfb19 AJ	209
ffb580cf	210	maynuo_m97_capture_start(sdi);
e1ccfb19 AJ	211	return TRUE;
e1ccfb19 AJ	212	}