2 * This file is part of the libsigrok project.
4 * Copyright (C) 2020 Timo Kokkonen <tjko@iki.fi>
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/>.
24 #define MIN_SAMPLE_RATE SR_HZ(1)
25 #define MAX_SAMPLE_RATE SR_HZ(60)
26 #define DEFAULT_SAMPLE_RATE SR_HZ(10)
28 static const uint32_t scanopts[] = {
33 static const uint32_t drvopts[] = {
34 SR_CONF_ELECTRONIC_LOAD,
37 static const uint32_t devopts[] = {
39 SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
40 SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
41 SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
44 static const uint32_t devopts_cg[] = {
45 SR_CONF_ENABLED | SR_CONF_GET | SR_CONF_SET,
46 SR_CONF_REGULATION | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
47 SR_CONF_VOLTAGE | SR_CONF_GET,
48 SR_CONF_VOLTAGE_TARGET | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
49 SR_CONF_CURRENT | SR_CONF_GET,
50 SR_CONF_CURRENT_LIMIT | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
51 SR_CONF_POWER | SR_CONF_GET,
52 SR_CONF_POWER_TARGET | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
53 SR_CONF_RESISTANCE_TARGET | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
54 SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED | SR_CONF_GET,
55 SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE | SR_CONF_GET,
56 SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
57 SR_CONF_OVER_CURRENT_PROTECTION_ENABLED | SR_CONF_GET,
58 SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE | SR_CONF_GET,
59 SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
60 SR_CONF_UNDER_VOLTAGE_CONDITION | SR_CONF_GET,
61 SR_CONF_UNDER_VOLTAGE_CONDITION_ACTIVE | SR_CONF_GET,
62 SR_CONF_UNDER_VOLTAGE_CONDITION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
63 SR_CONF_OVER_TEMPERATURE_PROTECTION | SR_CONF_GET,
64 SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE | SR_CONF_GET,
67 static const uint64_t samplerates[] = {
80 static const char *default_serial_parameters[] = {
81 "9600/8n1", /* Factory default. */
88 static struct sr_dev_driver itech_it8500_driver_info;
90 static GSList *scan(struct sr_dev_driver *di, GSList *options)
92 struct sr_dev_inst *sdi;
93 struct sr_config *conf;
94 struct sr_serial_dev_inst *serial;
95 struct sr_channel_group *cg;
96 struct sr_channel *ch;
97 struct dev_context *devc;
98 const char *custom_serial_parameters[2];
99 const char **serial_parameters;
100 const char *conn, *serialcomm;
102 struct itech_it8500_cmd_packet *cmd, *response;
103 uint8_t fw_major, fw_minor;
105 char *unit_model, *unit_serial, *unit_barcode;
106 double max_i, max_v, min_v, max_p, max_r, min_r;
107 uint64_t max_samplerate;
112 cmd = g_malloc0(sizeof(*cmd));
113 devc = g_malloc0(sizeof(*devc));
114 sdi = g_malloc0(sizeof(*sdi));
115 if (!cmd || !devc || !sdi)
124 * Use a list of typical parameters for serial communication by
125 * default. Prefer user specified parameters when available.
126 * Lack of a user specified serial port is fatal.
130 serial_parameters = default_serial_parameters;
131 for (l = options; l; l = l->next) {
135 conn = g_variant_get_string(conf->data, NULL);
137 case SR_CONF_SERIALCOMM:
138 serialcomm = g_variant_get_string(conf->data, NULL);
139 custom_serial_parameters[0] = serialcomm;
140 custom_serial_parameters[1] = NULL;
141 serial_parameters = custom_serial_parameters;
149 * Try different serial parameters in the list
150 * until we get a response (or none at all).
152 sr_info("Probing serial port: %s", conn);
153 for (i = 0; (serialcomm = serial_parameters[i]); i++) {
154 serial = sr_serial_dev_inst_new(conn, serialcomm);
155 if (serial_open(serial, SERIAL_RDWR) != SR_OK)
157 serial_flush(serial);
159 cmd->address = 0xff; /* Use "broadcast" address. */
160 cmd->command = CMD_GET_MODEL_INFO;
161 if (itech_it8500_send_cmd(serial, cmd, &response) == SR_OK)
164 serial_close(serial);
165 sr_serial_dev_inst_free(serial);
172 * The "dense" response string consists of several fields. Grab
173 * integer data before putting terminators in their place to
174 * grab text strings afterwards. Order is important here.
176 devc->address = response->address;
177 fw_major = response->data[6];
178 fw_minor = response->data[5];
179 response->data[5] = 0;
180 unit_model = g_strdup((const char *)&response->data[0]);
181 response->data[17] = 0;
182 unit_serial = g_strdup((const char *)&response->data[7]);
183 sr_info("Model name: %s (v%x.%02x)", unit_model, fw_major, fw_minor);
184 sr_info("Address: %d", devc->address);
185 sr_info("Serial number: %s", unit_serial);
187 sdi->status = SR_ST_INACTIVE;
189 sdi->inst_type = SR_INST_SERIAL;
190 sdi->driver = &itech_it8500_driver_info;
192 g_mutex_init(&devc->mutex);
195 * Calculate maxium "safe" sample rate based on serial connection
198 max_samplerate = serial->comm_params.bit_rate * 15 / 9600;
199 if (max_samplerate < 15)
201 if (max_samplerate > MAX_SAMPLE_RATE)
202 max_samplerate = MAX_SAMPLE_RATE;
203 devc->max_sample_rate_idx = 0;
204 for (u = 0; u < ARRAY_SIZE(samplerates); u++) {
205 if (samplerates[u] > max_samplerate)
207 devc->max_sample_rate_idx = u;
209 devc->sample_rate = DEFAULT_SAMPLE_RATE;
212 * Get full serial number (barcode).
214 cmd->address = devc->address;
215 cmd->command = CMD_GET_BARCODE_INFO;
216 if (itech_it8500_send_cmd(serial, cmd, &response) == SR_OK) {
217 unit_barcode = g_malloc0(IT8500_DATA_LEN + 1);
218 memcpy(unit_barcode, response->data, IT8500_DATA_LEN);
219 sr_info("Barcode: %s", response->data);
220 g_free(unit_barcode);
224 * Query unit capabilities.
226 cmd->command = CMD_GET_LOAD_LIMITS;
227 if (itech_it8500_send_cmd(serial, cmd, &response) != SR_OK)
230 max_i = read_u32le_inc(&p) / 10000.0;
231 max_v = read_u32le_inc(&p) / 1000.0;
232 min_v = read_u32le_inc(&p) / 1000.0;
233 max_p = read_u32le_inc(&p) / 1000.0;
234 max_r = read_u32le_inc(&p) / 1000.0;
235 min_r = read_u16le_inc(&p) / 1000.0;
236 sr_info("Max current: %.0f A", max_i);
237 sr_info("Max power: %.0f W", max_p);
238 sr_info("Voltage range: %.1f - %.1f V", min_v, max_v);
239 sr_info("Resistance range: %.2f - %.2f Ohm", min_r, max_r);
242 * Get current status of the unit.
244 if ((ret = itech_it8500_get_status(sdi)) != SR_OK) {
245 sr_err("Failed to get unit status: %d", ret);
248 sr_info("Mode: %s", itech_it8500_mode_to_string(devc->mode));
249 sr_info("State: %s", devc->load_on ? "ON" : "OFF");
250 sr_info("Default sample rate: %" PRIu64 " Hz", devc->sample_rate);
251 sr_info("Maximum sample rate: %" PRIu64 " Hz",
252 samplerates[devc->max_sample_rate_idx]);
255 * Populate data structures.
258 devc->fw_ver_major = fw_major;
259 devc->fw_ver_minor = fw_minor;
260 snprintf(devc->model, sizeof(devc->model), "%s", unit_model);
261 devc->max_current = max_i;
262 devc->min_voltage = min_v;
263 devc->max_voltage = max_v;
264 devc->max_power = max_p;
265 devc->min_resistance = min_r;
266 devc->max_resistance = max_r;
268 sdi->vendor = g_strdup("ITECH");
269 sdi->model = unit_model;
270 sdi->version = g_strdup_printf("%x.%02x", fw_major, fw_minor);
271 sdi->serial_num = unit_serial;
273 cg = sr_channel_group_new(sdi, "1", NULL);
274 ch = sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "V1");
275 cg->channels = g_slist_append(cg->channels, ch);
276 ch = sr_channel_new(sdi, 1, SR_CHANNEL_ANALOG, TRUE, "I1");
277 cg->channels = g_slist_append(cg->channels, ch);
278 ch = sr_channel_new(sdi, 2, SR_CHANNEL_ANALOG, TRUE, "P1");
279 cg->channels = g_slist_append(cg->channels, ch);
283 serial_close(serial);
285 return std_scan_complete(di, g_slist_append(NULL, sdi));
295 serial_close(serial);
296 sr_serial_dev_inst_free(serial);
302 static int config_get(uint32_t key, GVariant **data,
303 const struct sr_dev_inst *sdi,
304 const struct sr_channel_group *cg)
306 struct dev_context *devc;
307 const struct sr_key_info *kinfo;
318 kinfo = sr_key_info_get(SR_KEY_CONFIG, key);
322 case SR_CONF_LIMIT_SAMPLES:
323 case SR_CONF_LIMIT_MSEC:
324 ret = sr_sw_limits_config_get(&devc->limits, key, data);
326 case SR_CONF_SAMPLERATE:
327 *data = g_variant_new_uint64(devc->sample_rate);
329 case SR_CONF_ENABLED:
330 ret = itech_it8500_get_status(sdi);
333 *data = g_variant_new_boolean(devc->load_on);
335 case SR_CONF_REGULATION:
336 ret = itech_it8500_get_status(sdi);
339 mode = itech_it8500_mode_to_string(devc->mode);
340 *data = g_variant_new_string(mode);
342 case SR_CONF_VOLTAGE:
343 ret = itech_it8500_get_status(sdi);
346 *data = g_variant_new_double(devc->voltage);
348 case SR_CONF_VOLTAGE_TARGET:
349 ret = itech_it8500_get_int(sdi, CMD_GET_CV_VOLTAGE, &ival);
352 *data = g_variant_new_double((double)ival / 1000.0);
354 case SR_CONF_CURRENT:
355 ret = itech_it8500_get_status(sdi);
358 *data = g_variant_new_double(devc->current);
360 case SR_CONF_CURRENT_LIMIT:
361 ret = itech_it8500_get_int(sdi, CMD_GET_CC_CURRENT, &ival);
364 *data = g_variant_new_double((double)ival / 10000.0);
367 ret = itech_it8500_get_status(sdi);
370 *data = g_variant_new_double(devc->power);
372 case SR_CONF_POWER_TARGET:
373 ret = itech_it8500_get_int(sdi, CMD_GET_CW_POWER, &ival);
376 *data = g_variant_new_double((double)ival / 1000.0);
378 case SR_CONF_RESISTANCE_TARGET:
379 ret = itech_it8500_get_int(sdi, CMD_GET_CR_RESISTANCE, &ival);
382 *data = g_variant_new_double((double)ival / 1000.0);
384 case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
385 *data = g_variant_new_boolean(TRUE);
387 case SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE:
388 ret = itech_it8500_get_status(sdi);
391 bval = devc->demand_state & DS_OV_FLAG;
392 *data = g_variant_new_boolean(bval);
394 case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
395 ret = itech_it8500_get_int(sdi, CMD_GET_MAX_VOLTAGE, &ival);
398 *data = g_variant_new_double((double)ival / 1000.0);
400 case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
401 *data = g_variant_new_boolean(TRUE);
403 case SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE:
404 ret = itech_it8500_get_status(sdi);
407 bval = devc->demand_state & DS_OC_FLAG;
408 *data = g_variant_new_boolean(bval);
410 case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
411 ret = itech_it8500_get_int(sdi, CMD_GET_MAX_CURRENT, &ival);
414 *data = g_variant_new_double((double)ival / 10000.0);
416 case SR_CONF_OVER_TEMPERATURE_PROTECTION:
417 *data = g_variant_new_boolean(TRUE);
419 case SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE:
420 ret = itech_it8500_get_status(sdi);
423 bval = devc->demand_state & DS_OT_FLAG;
424 *data = g_variant_new_boolean(bval);
426 /* Hardware doesn't support under voltage reporting. */
427 case SR_CONF_UNDER_VOLTAGE_CONDITION:
428 case SR_CONF_UNDER_VOLTAGE_CONDITION_ACTIVE:
429 *data = g_variant_new_boolean(FALSE);
431 case SR_CONF_UNDER_VOLTAGE_CONDITION_THRESHOLD:
432 *data = g_variant_new_double(0.0);
435 sr_dbg("%s: Unsupported key: %u (%s)", __func__, key,
436 kinfo ? kinfo->name : "unknown");
444 static int config_set(uint32_t key, GVariant *data,
445 const struct sr_dev_inst *sdi,
446 const struct sr_channel_group *cg)
448 struct dev_context *devc;
449 struct itech_it8500_cmd_packet *cmd, *response;
450 const struct sr_key_info *kinfo;
451 enum itech_it8500_modes mode;
461 cmd = g_malloc0(sizeof(*cmd));
463 return SR_ERR_MALLOC;
469 kinfo = sr_key_info_get(SR_KEY_CONFIG, key);
472 case SR_CONF_LIMIT_MSEC:
473 case SR_CONF_LIMIT_SAMPLES:
474 ret = sr_sw_limits_config_set(&devc->limits, key, data);
476 case SR_CONF_SAMPLERATE:
477 new_sr = g_variant_get_uint64(data);
478 if (new_sr < MIN_SAMPLE_RATE) {
479 ret = SR_ERR_SAMPLERATE;
482 if (new_sr > samplerates[devc->max_sample_rate_idx]) {
483 ret = SR_ERR_SAMPLERATE;
486 devc->sample_rate = new_sr;
488 case SR_CONF_ENABLED:
489 cmd->command = CMD_LOAD_ON_OFF;
490 cmd->data[0] = g_variant_get_boolean(data);
492 case SR_CONF_REGULATION:
493 s = g_variant_get_string(data, NULL);
494 if (itech_it8500_string_to_mode(s, &mode) != SR_OK) {
498 cmd->command = CMD_SET_MODE;
501 case SR_CONF_VOLTAGE_TARGET:
502 cmd->command = CMD_SET_CV_VOLTAGE;
503 ivalue = g_variant_get_double(data) * 1000.0;
504 WL32(&cmd->data[0], ivalue);
506 case SR_CONF_CURRENT_LIMIT:
507 cmd->command = CMD_SET_CC_CURRENT;
508 ivalue = g_variant_get_double(data) * 10000.0;
509 WL32(&cmd->data[0], ivalue);
511 case SR_CONF_POWER_TARGET:
512 cmd->command = CMD_SET_CW_POWER;
513 ivalue = g_variant_get_double(data) * 1000.0;
514 WL32(&cmd->data[0], ivalue);
516 case SR_CONF_RESISTANCE_TARGET:
517 cmd->command = CMD_SET_CR_RESISTANCE;
518 ivalue = g_variant_get_double(data) * 1000.0;
519 WL32(&cmd->data[0], ivalue);
521 case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
522 cmd->command = CMD_SET_MAX_VOLTAGE;
523 ivalue = g_variant_get_double(data) * 1000.0;
524 WL32(&cmd->data[0], ivalue);
526 case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
527 cmd->command = CMD_SET_MAX_CURRENT;
528 ivalue = g_variant_get_double(data) * 10000.0;
529 WL32(&cmd->data[0], ivalue);
532 sr_dbg("%s: Unsupported key: %u (%s)", __func__, key,
533 kinfo ? kinfo->name : "unknown");
538 if (ret == SR_OK && cmd->command) {
539 cmd->address = devc->address;
540 ret = itech_it8500_cmd(sdi, cmd, &response);
549 static int config_list(uint32_t key, GVariant **data,
550 const struct sr_dev_inst *sdi,
551 const struct sr_channel_group *cg)
553 const struct dev_context *devc;
554 const struct sr_key_info *kinfo;
557 devc = sdi ? sdi->priv : NULL;
562 return STD_CONFIG_LIST(key, data, sdi, cg,
563 scanopts, drvopts, devopts);
565 kinfo = sr_key_info_get(SR_KEY_CONFIG, key);
568 case SR_CONF_DEVICE_OPTIONS:
569 *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg));
571 case SR_CONF_SAMPLERATE:
572 *data = std_gvar_samplerates_steps(samplerates,
573 1 + devc->max_sample_rate_idx);
575 case SR_CONF_REGULATION:
576 b = g_variant_builder_new(G_VARIANT_TYPE("as"));
577 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CC));
578 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CV));
579 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CW));
580 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CR));
581 *data = g_variant_new("as", b);
582 g_variant_builder_unref(b);
584 case SR_CONF_VOLTAGE_TARGET:
587 *data = std_gvar_min_max_step(devc->min_voltage,
588 devc->max_voltage, 0.01);
590 case SR_CONF_CURRENT_LIMIT:
593 *data = std_gvar_min_max_step(0.0, devc->max_current, 0.001);
595 case SR_CONF_POWER_TARGET:
598 *data = std_gvar_min_max_step(0.0, devc->max_power, 0.01);
600 case SR_CONF_RESISTANCE_TARGET:
603 *data = std_gvar_min_max_step(devc->min_resistance,
604 devc->max_resistance, 0.01);
608 sr_dbg("%s: Unsupported key: %u (%s)", __func__, key,
609 kinfo ? kinfo->name : "unknown");
616 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
618 struct dev_context *devc;
619 struct sr_serial_dev_inst *serial;
628 ret = serial_source_add(sdi->session, serial,
629 G_IO_IN, (1000.0 / devc->sample_rate),
630 itech_it8500_receive_data, (void *)sdi);
632 sr_sw_limits_acquisition_start(&devc->limits);
633 std_session_send_df_header(sdi);
639 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
641 struct sr_serial_dev_inst *serial;
648 std_session_send_df_end(sdi);
649 serial_source_remove(sdi->session, serial);
654 static int dev_open(struct sr_dev_inst *sdi)
656 struct dev_context *devc;
657 struct itech_it8500_cmd_packet *cmd, *response;
664 ret = std_serial_dev_open(sdi);
666 /* Request the unit to enter remote control mode. */
668 cmd = g_malloc0(sizeof(*cmd));
670 cmd->address = devc->address;
671 cmd->command = CMD_SET_REMOTE_MODE;
673 res = itech_it8500_cmd(sdi, cmd, &response);
675 sr_dbg("Failed to set unit to remote mode");
684 static int dev_close(struct sr_dev_inst *sdi)
686 struct dev_context *devc;
687 struct itech_it8500_cmd_packet *cmd, *response;
695 cmd = g_malloc0(sizeof(*cmd));
697 /* Request the unit to enter local control mode. */
698 cmd->address = devc->address;
699 cmd->command = CMD_SET_REMOTE_MODE;
701 ret = itech_it8500_cmd(sdi, cmd, &response);
703 sr_dbg("Failed to set unit back to local mode: %d",
710 return std_serial_dev_close(sdi);
713 static void dev_clear_callback(void *priv)
715 struct dev_context *devc;
721 g_mutex_clear(&devc->mutex);
724 static int dev_clear(const struct sr_dev_driver *di)
726 return std_dev_clear_with_callback(di, dev_clear_callback);
729 static struct sr_dev_driver itech_it8500_driver_info = {
730 .name = "itech-it8500",
731 .longname = "ITECH IT8500 series",
734 .cleanup = std_cleanup,
736 .dev_list = std_dev_list,
737 .dev_clear = dev_clear,
738 .config_get = config_get,
739 .config_set = config_set,
740 .config_list = config_list,
741 .dev_open = dev_open,
742 .dev_close = dev_close,
743 .dev_acquisition_start = dev_acquisition_start,
744 .dev_acquisition_stop = dev_acquisition_stop,
747 SR_REGISTER_DEV_DRIVER(itech_it8500_driver_info);