static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { GSList *l; switch (key) { case SR_CONF_SCAN_OPTIONS: case SR_CONF_DEVICE_OPTIONS: break; case SR_CONF_SAMPLERATE: case SR_CONF_TRIGGER_SOURCE: case SR_CONF_TRIGGER_SLOPE: case SR_CONF_BUFFERSIZE: if (!sdi || cg) return SR_ERR_NA; break; case SR_CONF_VDIV: case SR_CONF_COUPLING: if (!sdi) return SR_ERR_NA; if (!cg) return SR_ERR_CHANNEL_GROUP; l = g_slist_find(sdi->channel_groups, cg); if (!l) return SR_ERR_ARG; break; default: return SR_ERR_NA; } switch (key) { case SR_CONF_SCAN_OPTIONS: return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, NO_OPTS, NO_OPTS); case SR_CONF_DEVICE_OPTIONS: if (!cg) return STD_CONFIG_LIST(key, data, sdi, cg, NO_OPTS, drvopts, devopts); *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg)); break; case SR_CONF_SAMPLERATE: *data = std_gvar_samplerates(ARRAY_AND_SIZE(samplerates)); break; case SR_CONF_TRIGGER_SOURCE: *data = g_variant_new_strv(ARRAY_AND_SIZE(trigger_sources)); break; case SR_CONF_TRIGGER_SLOPE: *data = g_variant_new_strv(ARRAY_AND_SIZE(trigger_slopes)); break; case SR_CONF_BUFFERSIZE: *data = std_gvar_array_u64(ARRAY_AND_SIZE(buffersizes)); break; case SR_CONF_VDIV: *data = std_gvar_tuple_array(ARRAY_AND_SIZE(vdivs)); break; case SR_CONF_COUPLING: *data = g_variant_new_strv(ARRAY_AND_SIZE(coupling)); break; } return SR_OK; }
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { int cg_type = CG_NONE; struct dev_context *devc = NULL; const struct scope_config *model = NULL; if (sdi) { devc = sdi->priv; if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID) return SR_ERR; model = devc->model_config; } switch (key) { case SR_CONF_SCAN_OPTIONS: *data = std_gvar_array_u32(ARRAY_AND_SIZE(scanopts)); break; case SR_CONF_DEVICE_OPTIONS: if (!cg) { if (model) *data = std_gvar_array_u32(*model->devopts, model->num_devopts); else *data = std_gvar_array_u32(ARRAY_AND_SIZE(drvopts)); } else if (cg_type == CG_ANALOG) { *data = std_gvar_array_u32(*model->devopts_cg_analog, model->num_devopts_cg_analog); } else { *data = std_gvar_array_u32(NULL, 0); } break; case SR_CONF_COUPLING: if (!cg) return SR_ERR_CHANNEL_GROUP; if (!model) return SR_ERR_ARG; *data = g_variant_new_strv(*model->coupling_options, model->num_coupling_options); break; case SR_CONF_TRIGGER_SOURCE: if (!model) return SR_ERR_ARG; *data = g_variant_new_strv(*model->trigger_sources, model->num_trigger_sources); break; case SR_CONF_TRIGGER_SLOPE: if (!model) return SR_ERR_ARG; *data = g_variant_new_strv(*model->trigger_slopes, model->num_trigger_slopes); break; case SR_CONF_TIMEBASE: if (!model) return SR_ERR_ARG; *data = std_gvar_tuple_array(*model->timebases, model->num_timebases); break; case SR_CONF_VDIV: if (!cg) return SR_ERR_CHANNEL_GROUP; if (!model) return SR_ERR_ARG; *data = std_gvar_tuple_array(*model->vdivs, model->num_vdivs); break; default: return SR_ERR_NA; } return SR_OK; }
static GSList *scan(struct sr_dev_driver *di, GSList *options) { struct sr_config default_serialcomm = { .key = SR_CONF_SERIALCOMM, .data = g_variant_new_string("9600/8n1"), }; struct sr_config default_modbusaddr = { .key = SR_CONF_MODBUSADDR, .data = g_variant_new_uint64(1), }; GSList *opts = options, *devices; if (!g_slist_find_custom(options, &default_serialcomm, config_compare)) opts = g_slist_prepend(opts, &default_serialcomm); if (!g_slist_find_custom(options, &default_modbusaddr, config_compare)) opts = g_slist_prepend(opts, &default_modbusaddr); devices = sr_modbus_scan(di->context, opts, probe_device); while (opts != options) opts = g_slist_delete_link(opts, opts); g_variant_unref(default_serialcomm.data); g_variant_unref(default_modbusaddr.data); return devices; } static int dev_open(struct sr_dev_inst *sdi) { struct sr_modbus_dev_inst *modbus = sdi->conn; if (sr_modbus_open(modbus) < 0) return SR_ERR; maynuo_m97_set_bit(modbus, PC1, 1); return SR_OK; } static int dev_close(struct sr_dev_inst *sdi) { struct dev_context *devc; struct sr_modbus_dev_inst *modbus; modbus = sdi->conn; if (!modbus) return SR_ERR_BUG; devc = sdi->priv; if (devc->expecting_registers) { /* Wait for the last data that was requested from the device. */ uint16_t registers[devc->expecting_registers]; sr_modbus_read_holding_registers(modbus, -1, devc->expecting_registers, registers); } maynuo_m97_set_bit(modbus, PC1, 0); return sr_modbus_close(modbus); } static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct dev_context *devc; struct sr_modbus_dev_inst *modbus; enum maynuo_m97_mode mode; int ret, ivalue; float fvalue; (void)cg; modbus = sdi->conn; devc = sdi->priv; ret = SR_OK; switch (key) { case SR_CONF_LIMIT_SAMPLES: case SR_CONF_LIMIT_MSEC: ret = sr_sw_limits_config_get(&devc->limits, key, data); break; case SR_CONF_ENABLED: if ((ret = maynuo_m97_get_bit(modbus, ISTATE, &ivalue)) == SR_OK) *data = g_variant_new_boolean(ivalue); break; case SR_CONF_REGULATION: if ((ret = maynuo_m97_get_bit(modbus, UNREG, &ivalue)) != SR_OK) break; if (ivalue) *data = g_variant_new_string("UR"); else if ((ret = maynuo_m97_get_mode(modbus, &mode)) == SR_OK) *data = g_variant_new_string(maynuo_m97_mode_to_str(mode)); break; case SR_CONF_VOLTAGE: if ((ret = maynuo_m97_get_float(modbus, U, &fvalue)) == SR_OK) *data = g_variant_new_double(fvalue); break; case SR_CONF_VOLTAGE_TARGET: if ((ret = maynuo_m97_get_float(modbus, UFIX, &fvalue)) == SR_OK) *data = g_variant_new_double(fvalue); break; case SR_CONF_CURRENT: if ((ret = maynuo_m97_get_float(modbus, I, &fvalue)) == SR_OK) *data = g_variant_new_double(fvalue); break; case SR_CONF_CURRENT_LIMIT: if ((ret = maynuo_m97_get_float(modbus, IFIX, &fvalue)) == SR_OK) *data = g_variant_new_double(fvalue); break; case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED: *data = g_variant_new_boolean(TRUE); break; case SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE: if ((ret = maynuo_m97_get_bit(modbus, UOVER, &ivalue)) == SR_OK) *data = g_variant_new_boolean(ivalue); break; case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD: if ((ret = maynuo_m97_get_float(modbus, UMAX, &fvalue)) == SR_OK) *data = g_variant_new_double(fvalue); break; case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED: *data = g_variant_new_boolean(TRUE); break; case SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE: if ((ret = maynuo_m97_get_bit(modbus, IOVER, &ivalue)) == SR_OK) *data = g_variant_new_boolean(ivalue); break; case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD: if ((ret = maynuo_m97_get_float(modbus, IMAX, &fvalue)) == SR_OK) *data = g_variant_new_double(fvalue); break; case SR_CONF_OVER_TEMPERATURE_PROTECTION: *data = g_variant_new_boolean(TRUE); break; case SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE: if ((ret = maynuo_m97_get_bit(modbus, HEAT, &ivalue)) == SR_OK) *data = g_variant_new_boolean(ivalue); break; default: return SR_ERR_NA; } return ret; } static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct dev_context *devc; struct sr_modbus_dev_inst *modbus; (void)cg; modbus = sdi->conn; devc = sdi->priv; switch (key) { case SR_CONF_LIMIT_SAMPLES: case SR_CONF_LIMIT_MSEC: return sr_sw_limits_config_set(&devc->limits, key, data); case SR_CONF_ENABLED: return maynuo_m97_set_input(modbus, g_variant_get_boolean(data)); case SR_CONF_VOLTAGE_TARGET: return maynuo_m97_set_float(modbus, UFIX, g_variant_get_double(data)); case SR_CONF_CURRENT_LIMIT: return maynuo_m97_set_float(modbus, IFIX, g_variant_get_double(data)); case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD: return maynuo_m97_set_float(modbus, UMAX, g_variant_get_double(data)); case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD: return maynuo_m97_set_float(modbus, IMAX, g_variant_get_double(data)); default: return SR_ERR_NA; } return SR_OK; } static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct dev_context *devc; devc = (sdi) ? sdi->priv : NULL; if (!cg) { return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts); } else { switch (key) { case SR_CONF_DEVICE_OPTIONS: *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg)); break; case SR_CONF_VOLTAGE_TARGET: if (!devc || !devc->model) return SR_ERR_ARG; *data = std_gvar_min_max_step(0.0, devc->model->max_voltage, 0.001); break; case SR_CONF_CURRENT_LIMIT: if (!devc || !devc->model) return SR_ERR_ARG; *data = std_gvar_min_max_step(0.0, devc->model->max_current, 0.0001); break; default: return SR_ERR_NA; } } return SR_OK; } static int dev_acquisition_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_source_add(sdi->session, modbus, G_IO_IN, 10, maynuo_m97_receive_data, (void *)sdi)) != SR_OK) return ret; sr_sw_limits_acquisition_start(&devc->limits); std_session_send_df_header(sdi); return maynuo_m97_capture_start(sdi); } static int dev_acquisition_stop(struct sr_dev_inst *sdi) { struct sr_modbus_dev_inst *modbus; std_session_send_df_end(sdi); modbus = sdi->conn; sr_modbus_source_remove(sdi->session, modbus); return SR_OK; } static struct sr_dev_driver maynuo_m97_driver_info = { .name = "maynuo-m97", .longname = "maynuo M97/M98 series", .api_version = 1, .init = std_init, .cleanup = std_cleanup, .scan = scan, .dev_list = std_dev_list, .dev_clear = std_dev_clear, .config_get = config_get, .config_set = config_set, .config_list = config_list, .dev_open = dev_open, .dev_close = dev_close, .dev_acquisition_start = dev_acquisition_start, .dev_acquisition_stop = dev_acquisition_stop, .context = NULL, }; SR_REGISTER_DEV_DRIVER(maynuo_m97_driver_info);
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { int cg_type = CG_NONE; struct dev_context *devc; const struct scope_config *model; devc = (sdi) ? sdi->priv : NULL; model = (devc) ? devc->model_config : NULL; if (!cg) { switch (key) { case SR_CONF_SCAN_OPTIONS: case SR_CONF_DEVICE_OPTIONS: return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts); case SR_CONF_TIMEBASE: *data = std_gvar_tuple_array(ARRAY_AND_SIZE(dlm_timebases)); return SR_OK; case SR_CONF_TRIGGER_SOURCE: if (!model) return SR_ERR_ARG; *data = g_variant_new_strv(*model->trigger_sources, model->num_trigger_sources); return SR_OK; case SR_CONF_TRIGGER_SLOPE: *data = g_variant_new_strv(ARRAY_AND_SIZE(dlm_trigger_slopes)); return SR_OK; case SR_CONF_NUM_HDIV: *data = g_variant_new_uint32(model->num_xdivs); return SR_OK; default: return SR_ERR_NA; } } if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID) return SR_ERR; switch (key) { case SR_CONF_DEVICE_OPTIONS: if (cg_type == CG_ANALOG) *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg_analog)); else if (cg_type == CG_DIGITAL) *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg_digital)); else *data = std_gvar_array_u32(NULL, 0); break; case SR_CONF_COUPLING: if (!cg) return SR_ERR_CHANNEL_GROUP; *data = g_variant_new_strv(*model->coupling_options, model->num_coupling_options); break; case SR_CONF_VDIV: if (!cg) return SR_ERR_CHANNEL_GROUP; *data = std_gvar_tuple_array(ARRAY_AND_SIZE(dlm_vdivs)); break; default: return SR_ERR_NA; } return SR_OK; }