]>
Commit | Line | Data |
---|---|---|
c16effae TK |
1 | /* |
2 | * This file is part of the libsigrok project. | |
3 | * | |
4 | * Copyright (C) 2020 Timo Kokkonen <tjko@iki.fi> | |
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 <config.h> | |
f21b6983 | 21 | #include <string.h> |
c16effae TK |
22 | #include "protocol.h" |
23 | ||
f21b6983 TK |
24 | SR_PRIV uint8_t itech_it8500_checksum(const uint8_t *packet) |
25 | { | |
26 | const uint8_t *p; | |
27 | uint8_t checksum; | |
28 | size_t i; | |
29 | ||
30 | if (!packet) | |
31 | return 0xff; | |
32 | ||
33 | checksum = 0; | |
34 | p = packet; | |
35 | for (i = 0; i < IT8500_PACKET_LEN - 1; i++) | |
36 | checksum += *p++; | |
37 | ||
38 | return checksum; | |
39 | } | |
40 | ||
41 | SR_PRIV const char *itech_it8500_mode_to_string(enum itech_it8500_modes mode) | |
42 | { | |
43 | switch (mode) { | |
44 | case CC: | |
45 | return "CC"; | |
46 | case CV: | |
47 | return "CV"; | |
48 | case CW: | |
49 | return "CW"; | |
50 | case CR: | |
51 | return "CR"; | |
52 | default: | |
53 | return "Unknown"; | |
54 | } | |
55 | } | |
56 | ||
57 | SR_PRIV int itech_it8500_string_to_mode(const char *modename, | |
58 | enum itech_it8500_modes *mode) | |
59 | { | |
60 | size_t i; | |
61 | const char *s; | |
62 | ||
63 | for (i = 0; i < IT8500_MODES; i++) { | |
64 | s = itech_it8500_mode_to_string(i); | |
65 | if (strncmp(modename, s, strlen(s)) == 0) { | |
66 | *mode = i; | |
67 | return SR_OK; | |
68 | } | |
69 | } | |
70 | ||
71 | return SR_ERR; | |
72 | } | |
73 | ||
74 | SR_PRIV int itech_it8500_send_cmd(struct sr_serial_dev_inst *serial, | |
75 | struct itech_it8500_cmd_packet *cmd, | |
76 | struct itech_it8500_cmd_packet **response) | |
77 | { | |
78 | struct itech_it8500_cmd_packet *resp; | |
79 | uint8_t *cmd_buf, *resp_buf, checksum; | |
80 | int ret, read_len; | |
81 | ||
82 | if (!serial || !cmd || !response) | |
83 | return SR_ERR_ARG; | |
84 | ||
85 | cmd_buf = g_malloc0(IT8500_PACKET_LEN); | |
86 | resp_buf = g_malloc0(IT8500_PACKET_LEN); | |
87 | resp = g_malloc0(sizeof(*resp)); | |
88 | if (!cmd_buf || !resp_buf || !resp) | |
89 | return SR_ERR_MALLOC; | |
90 | ||
91 | /* | |
92 | * Construct request from: preamble, address, command, data, | |
93 | * and checksum. | |
94 | */ | |
95 | cmd_buf[0] = IT8500_PREAMBLE; | |
96 | cmd_buf[1] = cmd->address; | |
97 | cmd_buf[2] = cmd->command; | |
98 | memcpy(&cmd_buf[3], cmd->data, IT8500_DATA_LEN); | |
99 | cmd_buf[IT8500_PACKET_LEN - 1] = itech_it8500_checksum(cmd_buf); | |
100 | ||
101 | sr_spew("%s: Sending command: %02x", __func__, cmd->command); | |
102 | ret = serial_write_blocking(serial, cmd_buf, IT8500_PACKET_LEN, | |
103 | serial_timeout(serial, IT8500_PACKET_LEN)); | |
104 | if (ret < IT8500_PACKET_LEN) { | |
105 | sr_dbg("%s: Error sending command 0x%02x: %d", __func__, | |
106 | cmd->command, ret); | |
107 | ret = SR_ERR; | |
108 | goto error; | |
109 | } | |
110 | ||
111 | ret = SR_ERR; | |
112 | read_len = serial_read_blocking(serial, resp_buf, IT8500_PACKET_LEN, | |
113 | 100); | |
114 | if (read_len < IT8500_PACKET_LEN) { | |
115 | sr_dbg("%s: Timeout waiting response to command: %d", | |
116 | __func__, read_len); | |
117 | goto error; | |
118 | } | |
119 | ||
120 | if (resp_buf[0] != IT8500_PREAMBLE) { | |
121 | sr_dbg("%s: Invalid packet received (first byte: %02x)", | |
122 | __func__, resp_buf[0]); | |
123 | goto error; | |
124 | } | |
125 | ||
126 | checksum = itech_it8500_checksum(resp_buf); | |
127 | if (resp_buf[IT8500_PACKET_LEN - 1] != checksum) { | |
128 | sr_dbg("%s: Invalid packet received: checksum mismatch", | |
129 | __func__); | |
130 | goto error; | |
131 | } | |
132 | ||
133 | resp->address = resp_buf[1]; | |
134 | resp->command = resp_buf[2]; | |
135 | memcpy(resp->data, &resp_buf[3], IT8500_DATA_LEN); | |
136 | sr_spew("%s: Response packet received: cmd=%02x", __func__, | |
137 | resp->command); | |
138 | ||
139 | if (resp->command == CMD_RESPONSE) { | |
8c8fff47 | 140 | if (resp->data[0] != STS_COMMAND_SUCCESSFUL) { |
f21b6983 TK |
141 | sr_dbg("%s: Command (%02x) failed: status=%02x", |
142 | __func__, cmd->command, resp->data[0]); | |
143 | goto error; | |
144 | } | |
145 | } else { | |
146 | if (resp->command != cmd->command) { | |
147 | sr_dbg("%s: Invalid response received: %02x" | |
148 | " (expected: %02x)", | |
149 | __func__, resp->command, cmd->command); | |
150 | goto error; | |
151 | } | |
152 | } | |
153 | ||
154 | if (*response) | |
155 | g_free(*response); | |
156 | *response = resp; | |
157 | resp = NULL; | |
158 | ret = SR_OK; | |
159 | ||
160 | error: | |
161 | g_free(cmd_buf); | |
162 | g_free(resp_buf); | |
163 | g_free(resp); | |
164 | ||
165 | return ret; | |
166 | } | |
167 | ||
168 | SR_PRIV int itech_it8500_cmd(const struct sr_dev_inst *sdi, | |
169 | struct itech_it8500_cmd_packet *cmd, | |
170 | struct itech_it8500_cmd_packet **response) | |
171 | { | |
172 | struct dev_context *devc; | |
173 | struct sr_serial_dev_inst *serial; | |
174 | int ret; | |
175 | ||
176 | if (!sdi) | |
177 | return SR_ERR_ARG; | |
178 | devc = sdi->priv; | |
179 | serial = sdi->conn; | |
180 | if (!devc || !serial) | |
181 | return SR_ERR_NA; | |
182 | ||
183 | g_mutex_lock(&devc->mutex); | |
184 | ret = itech_it8500_send_cmd(serial, cmd, response); | |
185 | g_mutex_unlock(&devc->mutex); | |
186 | ||
187 | return ret; | |
188 | } | |
189 | ||
190 | SR_PRIV void itech_it8500_status_change(const struct sr_dev_inst *sdi, | |
191 | uint8_t old_os, uint8_t new_os, | |
192 | uint16_t old_ds, uint16_t new_ds, | |
193 | enum itech_it8500_modes old_m, enum itech_it8500_modes new_m) | |
194 | { | |
92cd8514 | 195 | gboolean old_bit, new_bit; |
f21b6983 | 196 | const char *mode; |
f21b6983 TK |
197 | |
198 | /* Check it output status has changed. */ | |
92cd8514 GS |
199 | old_bit = old_os & OS_OUT_FLAG; |
200 | new_bit = new_os & OS_OUT_FLAG; | |
201 | if (old_bit != new_bit) | |
f21b6983 TK |
202 | sr_session_send_meta(sdi, |
203 | SR_CONF_ENABLED, | |
92cd8514 | 204 | g_variant_new_boolean(new_bit)); |
f21b6983 TK |
205 | |
206 | /* Check if OVP status has changed. */ | |
92cd8514 GS |
207 | old_bit = old_ds & DS_OV_FLAG; |
208 | new_bit = new_ds & DS_OV_FLAG; | |
209 | if (old_bit != new_bit) | |
f21b6983 TK |
210 | sr_session_send_meta(sdi, |
211 | SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE, | |
92cd8514 | 212 | g_variant_new_boolean(new_bit)); |
f21b6983 TK |
213 | |
214 | /* Check if OCP status has changed. */ | |
92cd8514 GS |
215 | old_bit = old_ds & DS_OC_FLAG; |
216 | new_bit = new_ds & DS_OC_FLAG; | |
217 | if (old_bit != new_bit) | |
f21b6983 TK |
218 | sr_session_send_meta(sdi, |
219 | SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE, | |
92cd8514 | 220 | g_variant_new_boolean(new_bit)); |
f21b6983 TK |
221 | |
222 | /* Check if OTP status has changed. */ | |
92cd8514 GS |
223 | old_bit = old_ds & DS_OT_FLAG; |
224 | new_bit = new_ds & DS_OT_FLAG; | |
225 | if (old_bit != new_bit) | |
f21b6983 TK |
226 | sr_session_send_meta(sdi, |
227 | SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE, | |
92cd8514 | 228 | g_variant_new_boolean(new_bit)); |
f21b6983 TK |
229 | |
230 | /* Check if operating mode has changed. */ | |
231 | if (old_m != new_m) { | |
232 | mode = itech_it8500_mode_to_string(new_m); | |
233 | sr_session_send_meta(sdi, SR_CONF_REGULATION, | |
234 | g_variant_new_string(mode)); | |
235 | } | |
236 | } | |
237 | ||
238 | SR_PRIV int itech_it8500_get_status(const struct sr_dev_inst *sdi) | |
239 | { | |
240 | struct dev_context *devc; | |
241 | struct itech_it8500_cmd_packet *cmd; | |
242 | struct itech_it8500_cmd_packet *resp; | |
243 | double voltage, current, power; | |
244 | uint8_t operation_state; | |
245 | uint16_t demand_state; | |
246 | enum itech_it8500_modes mode; | |
247 | gboolean load_on; | |
248 | const uint8_t *p; | |
249 | int ret; | |
250 | ||
251 | if (!sdi) | |
252 | return SR_ERR_ARG; | |
253 | ||
254 | devc = sdi->priv; | |
255 | if (!devc) | |
256 | return SR_ERR_NA; | |
257 | ||
258 | cmd = g_malloc0(sizeof(*cmd)); | |
259 | if (!cmd) | |
260 | return SR_ERR_MALLOC; | |
261 | cmd->address = devc->address; | |
262 | cmd->command = CMD_GET_STATE; | |
263 | resp = NULL; | |
264 | ||
265 | ret = itech_it8500_cmd(sdi, cmd, &resp); | |
266 | if (ret == SR_OK) { | |
267 | p = resp->data; | |
268 | voltage = read_u32le_inc(&p) / 1000.0; | |
269 | current = read_u32le_inc(&p) / 10000.0; | |
270 | power = read_u32le_inc(&p) / 1000.0; | |
271 | operation_state = read_u8_inc(&p); | |
272 | demand_state = read_u16le_inc(&p); | |
273 | ||
274 | if (demand_state & DS_CC_MODE_FLAG) | |
275 | mode = CC; | |
276 | else if (demand_state & DS_CV_MODE_FLAG) | |
277 | mode = CV; | |
278 | else if (demand_state & DS_CW_MODE_FLAG) | |
279 | mode = CW; | |
280 | else if (demand_state & DS_CR_MODE_FLAG) | |
281 | mode = CR; | |
282 | else | |
283 | mode = CC; | |
284 | load_on = operation_state & OS_OUT_FLAG; | |
285 | ||
286 | sr_dbg("Load status: V=%.4f, I=%.4f, P=%.3f, State=%s, " | |
287 | "Mode=%s (op=0x%02x, demand=0x%04x)", | |
288 | voltage, current, power, (load_on ? "ON": "OFF"), | |
289 | itech_it8500_mode_to_string(mode), | |
290 | operation_state, demand_state); | |
291 | ||
292 | /* Check for status change only after scan() has completed. */ | |
293 | if (sdi->model) { | |
294 | itech_it8500_status_change(sdi, devc->operation_state, | |
295 | operation_state, devc->demand_state, | |
296 | demand_state, devc->mode, mode); | |
297 | } | |
298 | devc->voltage = voltage; | |
299 | devc->current = current; | |
300 | devc->power = power; | |
301 | devc->operation_state = operation_state; | |
302 | devc->demand_state = demand_state; | |
303 | devc->mode = mode; | |
304 | devc->load_on = load_on; | |
305 | } | |
306 | ||
307 | g_free(cmd); | |
308 | g_free(resp); | |
309 | ||
310 | return ret; | |
311 | } | |
312 | ||
313 | SR_PRIV int itech_it8500_get_int(const struct sr_dev_inst *sdi, | |
314 | enum itech_it8500_command command, int *result) | |
315 | { | |
316 | struct dev_context *devc; | |
317 | struct itech_it8500_cmd_packet *cmd; | |
318 | struct itech_it8500_cmd_packet *resp; | |
319 | int ret; | |
320 | ||
321 | if (!sdi || !result) | |
322 | return SR_ERR_ARG; | |
323 | ||
324 | devc = sdi->priv; | |
325 | cmd = g_malloc0(sizeof(*cmd)); | |
326 | if (!cmd) | |
327 | return SR_ERR_MALLOC; | |
328 | cmd->address = devc->address; | |
329 | cmd->command = command; | |
330 | resp = NULL; | |
331 | ||
332 | ret = itech_it8500_cmd(sdi, cmd, &resp); | |
333 | if (ret == SR_OK) | |
334 | *result = RL32(&resp->data[0]); | |
335 | ||
336 | g_free(cmd); | |
337 | g_free(resp); | |
338 | ||
339 | return ret; | |
340 | } | |
341 | ||
342 | SR_PRIV void itech_it8500_channel_send_value(const struct sr_dev_inst *sdi, | |
343 | struct sr_channel *ch, double value, enum sr_mq mq, | |
24be1e05 | 344 | enum sr_mqflag mqflags, enum sr_unit unit, int digits) |
f21b6983 TK |
345 | { |
346 | struct sr_datafeed_packet packet; | |
347 | struct sr_datafeed_analog analog; | |
348 | struct sr_analog_encoding encoding; | |
349 | struct sr_analog_meaning meaning; | |
350 | struct sr_analog_spec spec; | |
351 | double val; | |
352 | ||
353 | val = value; | |
354 | sr_analog_init(&analog, &encoding, &meaning, &spec, digits); | |
355 | analog.meaning->channels = g_slist_append(NULL, ch); | |
356 | analog.num_samples = 1; | |
357 | analog.data = &val; | |
358 | analog.encoding->unitsize = sizeof(val); | |
359 | analog.encoding->is_float = TRUE; | |
360 | analog.meaning->mq = mq; | |
361 | analog.meaning->unit = unit; | |
24be1e05 | 362 | analog.meaning->mqflags = mqflags; |
f21b6983 TK |
363 | |
364 | packet.type = SR_DF_ANALOG; | |
365 | packet.payload = &analog; | |
366 | sr_session_send(sdi, &packet); | |
367 | g_slist_free(analog.meaning->channels); | |
368 | } | |
369 | ||
c16effae TK |
370 | SR_PRIV int itech_it8500_receive_data(int fd, int revents, void *cb_data) |
371 | { | |
f21b6983 | 372 | struct sr_dev_inst *sdi; |
c16effae | 373 | struct dev_context *devc; |
f21b6983 | 374 | GSList *l; |
c16effae TK |
375 | |
376 | (void)fd; | |
f21b6983 | 377 | (void)revents; |
c16effae TK |
378 | |
379 | if (!(sdi = cb_data)) | |
380 | return TRUE; | |
381 | ||
382 | if (!(devc = sdi->priv)) | |
383 | return TRUE; | |
384 | ||
f21b6983 TK |
385 | if (itech_it8500_get_status(sdi) != SR_OK) |
386 | return TRUE; | |
387 | ||
388 | std_session_send_df_frame_begin(sdi); | |
389 | ||
390 | l = g_slist_nth(sdi->channels, 0); | |
391 | itech_it8500_channel_send_value(sdi, l->data, devc->voltage, | |
24be1e05 | 392 | SR_MQ_VOLTAGE, SR_MQFLAG_DC, SR_UNIT_VOLT, 5); |
f21b6983 TK |
393 | |
394 | l = g_slist_nth(sdi->channels, 1); | |
395 | itech_it8500_channel_send_value(sdi, l->data, devc->current, | |
24be1e05 | 396 | SR_MQ_CURRENT, SR_MQFLAG_DC, SR_UNIT_AMPERE, 5); |
f21b6983 TK |
397 | |
398 | l = g_slist_nth(sdi->channels, 2); | |
399 | itech_it8500_channel_send_value(sdi, l->data, devc->power, | |
24be1e05 | 400 | SR_MQ_POWER, 0, SR_UNIT_WATT, 5); |
f21b6983 TK |
401 | |
402 | std_session_send_df_frame_end(sdi); | |
403 | ||
404 | sr_sw_limits_update_samples_read(&devc->limits, 1); | |
405 | if (sr_sw_limits_check(&devc->limits)) | |
406 | sr_dev_acquisition_stop(sdi); | |
c16effae TK |
407 | |
408 | return TRUE; | |
409 | } |