2 * This file is part of the libsigrok project.
4 * Copyright (C) 2015 Aurelien Jacobs <aurel@gnuage.org>
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.
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.
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/>.
23 SR_PRIV int maynuo_m97_get_bit(struct sr_modbus_dev_inst *modbus,
24 enum maynuo_m97_coil address, int *value)
27 int ret = sr_modbus_read_coils(modbus, address, 1, &coil);
32 SR_PRIV int maynuo_m97_set_bit(struct sr_modbus_dev_inst *modbus,
33 enum maynuo_m97_coil address, int value)
35 return sr_modbus_write_coil(modbus, address, value);
38 SR_PRIV int maynuo_m97_get_float(struct sr_modbus_dev_inst *modbus,
39 enum maynuo_m97_register address, float *value)
41 uint16_t registers[2];
42 int ret = sr_modbus_read_holding_registers(modbus, address, 2, registers);
44 *value = RBFL(registers);
48 SR_PRIV int maynuo_m97_set_float(struct sr_modbus_dev_inst *modbus,
49 enum maynuo_m97_register address, float value)
51 uint16_t registers[2];
52 WBFL(registers, value);
53 return sr_modbus_write_multiple_registers(modbus, address, 2, registers);
57 static int maynuo_m97_cmd(struct sr_modbus_dev_inst *modbus,
58 enum maynuo_m97_mode cmd)
60 uint16_t registers[1];
62 return sr_modbus_write_multiple_registers(modbus, CMD, 1, registers);
65 SR_PRIV int maynuo_m97_get_mode(struct sr_modbus_dev_inst *modbus,
66 enum maynuo_m97_mode *mode)
68 uint16_t registers[1];
70 ret = sr_modbus_read_holding_registers(modbus, SETMODE, 1, registers);
71 *mode = RB16(registers) & 0xFF;
75 SR_PRIV int maynuo_m97_set_mode(struct sr_modbus_dev_inst *modbus,
76 enum maynuo_m97_mode mode)
78 return maynuo_m97_cmd(modbus, mode);
81 SR_PRIV int maynuo_m97_set_input(struct sr_modbus_dev_inst *modbus, int enable)
83 enum maynuo_m97_mode mode;
85 if ((ret = maynuo_m97_get_mode(modbus, &mode)) != SR_OK)
87 if ((ret = maynuo_m97_cmd(modbus, enable ? INPUT_ON : INPUT_OFF)) != SR_OK)
89 return maynuo_m97_set_mode(modbus, mode);
92 SR_PRIV int maynuo_m97_get_model_version(struct sr_modbus_dev_inst *modbus,
93 uint16_t *model, uint16_t *version)
95 uint16_t registers[2];
97 ret = sr_modbus_read_holding_registers(modbus, MODEL, 2, registers);
98 *model = RB16(registers+0);
99 *version = RB16(registers+1);
104 SR_PRIV const char *maynuo_m97_mode_to_str(enum maynuo_m97_mode 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";
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)
130 struct sr_datafeed_packet packet;
131 struct sr_datafeed_analog_old analog;
133 analog.channels = g_slist_append(NULL, ch);
134 analog.num_samples = 1;
135 analog.data = &value;
138 analog.mqflags = SR_MQFLAG_DC;
140 packet.type = SR_DF_ANALOG_OLD;
141 packet.payload = &analog;
142 sr_session_send(sdi, &packet);
143 g_slist_free(analog.channels);
146 SR_PRIV int maynuo_m97_capture_start(const struct sr_dev_inst *sdi)
148 struct dev_context *devc;
149 struct sr_modbus_dev_inst *modbus;
155 if ((ret = sr_modbus_read_holding_registers(modbus, U, 4, NULL)) == SR_OK)
156 devc->expecting_registers = 4;
160 SR_PRIV int maynuo_m97_receive_data(int fd, int revents, void *cb_data)
162 struct sr_dev_inst *sdi;
163 struct dev_context *devc;
164 struct sr_modbus_dev_inst *modbus;
165 struct sr_datafeed_packet packet;
166 uint16_t registers[4];
172 if (!(sdi = cb_data))
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);
183 maynuo_m97_session_send_value(sdi, sdi->channels->data,
185 SR_MQ_VOLTAGE, SR_UNIT_VOLT);
186 maynuo_m97_session_send_value(sdi, sdi->channels->next->data,
188 SR_MQ_CURRENT, SR_UNIT_AMPERE);
190 packet.type = SR_DF_FRAME_END;
191 sr_session_send(cb_data, &packet);
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);
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);
210 maynuo_m97_capture_start(sdi);