static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct dev_context *devc; gdouble low, high; (void)cg; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; if (!(devc = sdi->priv)) { sr_err("%s: sdi->priv was NULL", __func__); return SR_ERR_ARG; } switch (id) { case SR_CONF_SAMPLERATE: return zp_set_samplerate(devc, g_variant_get_uint64(data)); case SR_CONF_LIMIT_SAMPLES: return set_limit_samples(devc, g_variant_get_uint64(data)); case SR_CONF_CAPTURE_RATIO: return set_capture_ratio(devc, g_variant_get_uint64(data)); case SR_CONF_VOLTAGE_THRESHOLD: g_variant_get(data, "(dd)", &low, &high); return set_voltage_threshold(devc, (low + high) / 2.0); default: return SR_ERR_NA; } return SR_OK; }
static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct dev_context *devc; int ret; (void)cg; if (!sdi) return SR_ERR_ARG; if (sdi->status != SR_ST_ACTIVE) return SR_ERR; devc = sdi->priv; ret = SR_OK; switch (id) { case SR_CONF_SAMPLERATE: devc->cur_samplerate = g_variant_get_uint64(data); break; case SR_CONF_LIMIT_SAMPLES: devc->limit_samples = g_variant_get_uint64(data); break; default: ret = SR_ERR_NA; } return ret; }
static int config_set(int key, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_probe_group *probe_group) { uint64_t samplerate, limit_samples, capture_ratio; int ret; (void)probe_group; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; ret = SR_OK; switch (key) { case SR_CONF_LIMIT_SAMPLES: limit_samples = g_variant_get_uint64(data); ret = sl2_set_limit_samples(sdi, limit_samples); break; case SR_CONF_SAMPLERATE: samplerate = g_variant_get_uint64(data); ret = sl2_set_samplerate(sdi, samplerate); break; case SR_CONF_CAPTURE_RATIO: capture_ratio = g_variant_get_uint64(data); ret = sl2_set_capture_ratio(sdi, capture_ratio); 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; int idx; (void)cg; if (!sdi) return SR_ERR_ARG; devc = sdi->priv; switch (key) { case SR_CONF_SAMPLERATE: if ((idx = std_u64_idx(data, devc->samplerates, devc->num_samplerates)) < 0) return SR_ERR_ARG; devc->cur_samplerate = devc->samplerates[idx]; break; case SR_CONF_LIMIT_SAMPLES: devc->limit_samples = g_variant_get_uint64(data); break; case SR_CONF_CAPTURE_RATIO: devc->capture_ratio = g_variant_get_uint64(data); break; default: return SR_ERR_NA; } return SR_OK; }
static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_probe_group *probe_group) { struct session_vdev *vdev; (void)probe_group; vdev = sdi->priv; switch (id) { case SR_CONF_SAMPLERATE: vdev->samplerate = g_variant_get_uint64(data); sr_info("Setting samplerate to %" PRIu64 ".", vdev->samplerate); break; case SR_CONF_SESSIONFILE: vdev->sessionfile = g_strdup(g_variant_get_string(data, NULL)); sr_info("Setting sessionfile to '%s'.", vdev->sessionfile); break; case SR_CONF_CAPTUREFILE: vdev->capturefile = g_strdup(g_variant_get_string(data, NULL)); sr_info("Setting capturefile to '%s'.", vdev->capturefile); break; case SR_CONF_CAPTURE_UNITSIZE: vdev->unitsize = g_variant_get_uint64(data); break; case SR_CONF_CAPTURE_NUM_PROBES: vdev->num_probes = g_variant_get_uint64(data); break; default: return SR_ERR_NA; } return SR_OK; }
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; (void)cg; if (!sdi) return SR_ERR_ARG; devc = sdi->priv; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; switch (key) { case SR_CONF_SAMPLERATE: return lls_set_samplerate(sdi, g_variant_get_uint64(data)); case SR_CONF_CAPTURE_RATIO: devc->capture_ratio = g_variant_get_uint64(data); if (devc->capture_ratio > 100) return SR_ERR; break; default: return SR_ERR_NA; } return SR_OK; }
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; (void)cg; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; if (!(devc = sdi->priv)) { sr_err("sdi->priv was NULL."); return SR_ERR_BUG; } switch (key) { case SR_CONF_LIMIT_MSEC: /* TODO: not yet implemented */ devc->limit_msec = g_variant_get_uint64(data); break; case SR_CONF_LIMIT_SAMPLES: devc->limit_samples = g_variant_get_uint64(data); break; default: return SR_ERR_NA; } return SR_OK; }
static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi) { struct dev_context *devc; int ret; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; if (!(devc = sdi->priv)) { sr_err("sdi->priv was NULL."); return SR_ERR_BUG; } ret = SR_OK; switch (id) { case SR_CONF_LIMIT_SAMPLES: devc->limit_samples = g_variant_get_uint64(data); break; case SR_CONF_LIMIT_MSEC: devc->limit_msec = g_variant_get_uint64(data); break; default: ret = SR_ERR_NA; } return ret; }
static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_probe_group *probe_group) { struct dev_context *devc; (void)probe_group; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; devc = sdi->priv; switch (id) { case SR_CONF_LIMIT_SAMPLES: devc->limit_samples = g_variant_get_uint64(data); sr_dbg("Setting sample limit to %" PRIu64 ".", devc->limit_samples); break; case SR_CONF_LIMIT_MSEC: devc->limit_msec = g_variant_get_uint64(data); sr_dbg("Setting time limit to %" PRIu64 "ms.", devc->limit_msec); break; default: return SR_ERR_NA; } return SR_OK; }
static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct dev_context *devc; (void)cg; devc = sdi->priv; switch (id) { case SR_CONF_LIMIT_MSEC: if (g_variant_get_uint64(data) == 0) { sr_err("Time limit cannot be 0."); return SR_ERR; } devc->limit_msec = g_variant_get_uint64(data); sr_dbg("Setting time limit to %" PRIu64 "ms.", devc->limit_msec); break; case SR_CONF_LIMIT_SAMPLES: if (g_variant_get_uint64(data) == 0) { sr_err("Sample limit cannot be 0."); return SR_ERR; } devc->limit_samples = g_variant_get_uint64(data); sr_dbg("Setting sample limit to %" PRIu64 ".", devc->limit_samples); break; default: return SR_ERR_NA; } return SR_OK; }
static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi) { struct dev_context *devc; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; if (!(devc = sdi->priv)) { sr_err("sdi->priv was NULL."); return SR_ERR_BUG; } switch (id) { case SR_CONF_LIMIT_MSEC: /* TODO: not yet implemented */ if (g_variant_get_uint64(data) == 0) { sr_err("LIMIT_MSEC can't be 0."); return SR_ERR; } devc->limit_msec = g_variant_get_uint64(data);; sr_dbg("Setting time limit to %" PRIu64 "ms.", devc->limit_msec); break; case SR_CONF_LIMIT_SAMPLES: devc->limit_samples = g_variant_get_uint64(data); sr_dbg("Setting sample limit to %" PRIu64 ".", devc->limit_samples); break; default: return SR_ERR_NA; } return SR_OK; }
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; int ret; (void)cg; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; devc = sdi->priv; ret = SR_OK; switch (key) { case SR_CONF_LIMIT_SAMPLES: devc->limit_samples = g_variant_get_uint64(data); break; case SR_CONF_LIMIT_MSEC: devc->limit_msec = g_variant_get_uint64(data); break; case SR_CONF_ENABLED: ret = reloadpro_set_on_off(sdi, g_variant_get_boolean(data)); break; case SR_CONF_CURRENT_LIMIT: ret = reloadpro_set_current_limit(sdi, g_variant_get_double(data)); break; default: ret = SR_ERR_NA; } return ret; }
static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi) { struct session_vdev *vdev; vdev = sdi->priv; switch (id) { case SR_CONF_SAMPLERATE: vdev->samplerate = g_variant_get_uint64(data); sr_info("Setting samplerate to %" PRIu64 ".", vdev->samplerate); break; case SR_CONF_SESSIONFILE: vdev->sessionfile = g_strdup(g_variant_get_string(data, NULL)); sr_info("Setting sessionfile to '%s'.", vdev->sessionfile); break; case SR_CONF_CAPTUREFILE: vdev->capturefile = g_strdup(g_variant_get_string(data, NULL)); sr_info("Setting capturefile to '%s'.", vdev->capturefile); break; case SR_CONF_CAPTURE_UNITSIZE: vdev->unitsize = g_variant_get_uint64(data); break; case SR_CONF_LIMIT_SAMPLES: vdev->total_samples = g_variant_get_uint64(data); break; case SR_CONF_CAPTURE_NUM_PROBES: vdev->num_probes = g_variant_get_uint64(data); break; default: sr_err("Unknown capability: %d.", id); return SR_ERR; } return SR_OK; }
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; (void)cg; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; if (!(devc = sdi->priv)) return SR_ERR_BUG; switch (key) { case SR_CONF_SAMPLERATE: if (cv_set_samplerate(sdi, g_variant_get_uint64(data)) < 0) return SR_ERR; break; case SR_CONF_LIMIT_MSEC: if (g_variant_get_uint64(data) == 0) return SR_ERR_ARG; devc->limit_msec = g_variant_get_uint64(data); break; case SR_CONF_LIMIT_SAMPLES: if (g_variant_get_uint64(data) == 0) return SR_ERR_ARG; devc->limit_samples = g_variant_get_uint64(data); break; default: return SR_ERR_NA; } return SR_OK; }
static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_probe_group *probe_group) { int ret; const char *stropt; (void)probe_group; struct dev_context *const devc = sdi->priv; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; if (id == SR_CONF_SAMPLERATE) { devc->cur_samplerate = g_variant_get_uint64(data); sr_dbg("%s: setting samplerate to %" PRIu64, __func__, devc->cur_samplerate); ret = SR_OK; } else if (id == SR_CONF_LIMIT_SAMPLES) { devc->limit_msec = 0; devc->limit_samples = g_variant_get_uint64(data); sr_dbg("%s: setting limit_samples to %" PRIu64, __func__, devc->limit_samples); ret = SR_OK; } else if (id == SR_CONF_LIMIT_MSEC) { devc->limit_msec = g_variant_get_uint64(data); devc->limit_samples = 0; sr_dbg("%s: setting limit_msec to %" PRIu64, __func__, devc->limit_msec); ret = SR_OK; } else if (id == SR_CONF_PATTERN_MODE) { stropt = g_variant_get_string(data, NULL); ret = SR_OK; if (!strcmp(stropt, STR_PATTERN_SIGROK)) { devc->sample_generator = PATTERN_SIGROK; } else if (!strcmp(stropt, STR_PATTERN_RANDOM)) { devc->sample_generator = PATTERN_RANDOM; } else if (!strcmp(stropt, STR_PATTERN_INC)) { devc->sample_generator = PATTERN_INC; } else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) { devc->sample_generator = PATTERN_ALL_LOW; } else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) { devc->sample_generator = PATTERN_ALL_HIGH; } else { ret = SR_ERR; } sr_dbg("%s: setting pattern to %d", __func__, devc->sample_generator); } else { ret = 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; gdouble low, high; int ret; unsigned int i; (void)cg; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; devc = sdi->priv; ret = SR_OK; switch (key) { case SR_CONF_SAMPLERATE: devc->cur_samplerate = g_variant_get_uint64(data); break; case SR_CONF_LIMIT_SAMPLES: devc->limit_samples = g_variant_get_uint64(data); break; case SR_CONF_CAPTURE_RATIO: devc->capture_ratio = g_variant_get_uint64(data); if (devc->capture_ratio > 100) { devc->capture_ratio = 0; ret = SR_ERR; } else ret = SR_OK; break; case SR_CONF_VOLTAGE_THRESHOLD: g_variant_get(data, "(dd)", &low, &high); ret = SR_ERR_ARG; for (i = 0; i < ARRAY_SIZE(volt_thresholds); i++) { if (fabs(volt_thresholds[i].low - low) < 0.1 && fabs(volt_thresholds[i].high - high) < 0.1) { devc->selected_voltage_range = volt_thresholds[i].range; ret = SR_OK; break; } } break; default: ret = SR_ERR_NA; } return ret; }
guint64 xdp_entry_get_inode (XdgAppDbEntry *entry) { g_autoptr(GVariant) v = xdg_app_db_entry_get_data (entry); g_autoptr(GVariant) c = g_variant_get_child_value (v, 2); return g_variant_get_uint64 (c); }
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; const char *tmp_str; (void)cg; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; devc = sdi->priv; switch (key) { case SR_CONF_LIMIT_SAMPLES: devc->limit_samples = g_variant_get_uint64(data); break; case SR_CONF_DATA_SOURCE: tmp_str = g_variant_get_string(data, NULL); if (!strcmp(tmp_str, "Live")) devc->data_source = DATA_SOURCE_LIVE; else if (!strcmp(tmp_str, "Memory")) devc->data_source = DATA_SOURCE_MEMORY; else return SR_ERR; break; default: return SR_ERR_NA; } return SR_OK; }
static GString *gen_header(const struct sr_dev_inst *sdi, struct context *ctx) { struct sr_probe *probe; GSList *l; GString *s; GVariant *gvar; int num_enabled_probes; if (!ctx->samplerate && sr_config_get(sdi->driver, sdi, NULL, SR_CONF_SAMPLERATE, &gvar) == SR_OK) { ctx->samplerate = g_variant_get_uint64(gvar); g_variant_unref(gvar); } num_enabled_probes = 0; for (l = sdi->probes; l; l = l->next) { probe = l->data; if (probe->enabled) num_enabled_probes++; } s = g_string_sized_new(512); g_string_append_printf(s, ";Rate: %"PRIu64"\n", ctx->samplerate); g_string_append_printf(s, ";Channels: %d\n", num_enabled_probes); g_string_append_printf(s, ";EnabledChannels: -1\n"); g_string_append_printf(s, ";Compressed: true\n"); g_string_append_printf(s, ";CursorEnabled: false\n"); return s; }
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; (void)cg; if (!sdi) return SR_ERR_ARG; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; devc = sdi->priv; switch (key) { case SR_CONF_LIMIT_FRAMES: devc->frame_limit = g_variant_get_uint64(data); break; default: return SR_ERR_NA; } return SR_OK; }
static gdouble _tp_variant_convert_double (GVariant *variant, gboolean *valid) { *valid = TRUE; switch (g_variant_classify (variant)) { case G_VARIANT_CLASS_DOUBLE: return g_variant_get_double (variant); case G_VARIANT_CLASS_BYTE: return g_variant_get_byte (variant); case G_VARIANT_CLASS_UINT32: return g_variant_get_uint32 (variant); case G_VARIANT_CLASS_INT32: return g_variant_get_int32 (variant); case G_VARIANT_CLASS_INT64: return g_variant_get_int64 (variant); case G_VARIANT_CLASS_UINT64: return g_variant_get_uint64 (variant); default: break; } *valid = FALSE; return 0.0; }
static gint64 _tp_variant_convert_int64 (GVariant *variant, gboolean *valid) { guint64 u; *valid = TRUE; switch (g_variant_classify (variant)) { case G_VARIANT_CLASS_BYTE: return g_variant_get_byte (variant); case G_VARIANT_CLASS_UINT32: return g_variant_get_uint32 (variant); case G_VARIANT_CLASS_INT32: return g_variant_get_int32 (variant); case G_VARIANT_CLASS_INT64: return g_variant_get_int64 (variant); case G_VARIANT_CLASS_UINT64: u = g_variant_get_uint64 (variant); if (G_LIKELY (u <= G_MAXINT64)) return u; break; default: break; } *valid = FALSE; return 0; }
static gboolean iter_get_time (GVariant *variant, gulong attr_type, GckBuilder *builder) { time_t time; struct tm tm; gchar buf[20]; guint64 value; g_assert (variant != NULL); g_assert (builder != NULL); value = g_variant_get_uint64 (variant); if (value == 0) { gck_builder_add_empty (builder, attr_type); return TRUE; } time = value; if (!gmtime_r (&time, &tm)) g_return_val_if_reached (FALSE); if (!strftime (buf, sizeof (buf), "%Y%m%d%H%M%S00", &tm)) g_return_val_if_reached (FALSE); gck_builder_add_data (builder, attr_type, (const guchar *)buf, 16); return TRUE; }
static GString *gen_header(const struct sr_output *o) { struct context *ctx; GVariant *gvar; GString *header; int num_channels; char *samplerate_s; ctx = o->priv; if (ctx->samplerate == 0) { if (sr_config_get(o->sdi->driver, o->sdi, NULL, SR_CONF_SAMPLERATE, &gvar) == SR_OK) { ctx->samplerate = g_variant_get_uint64(gvar); g_variant_unref(gvar); } } header = g_string_sized_new(512); g_string_printf(header, "%s %s\n", PACKAGE_NAME, SR_PACKAGE_VERSION_STRING); num_channels = g_slist_length(o->sdi->channels); g_string_append_printf(header, "Acquisition with %d/%d channels", ctx->num_enabled_channels, num_channels); if (ctx->samplerate != 0) { samplerate_s = sr_samplerate_string(ctx->samplerate); g_string_append_printf(header, " at %s", samplerate_s); g_free(samplerate_s); } g_string_append_printf(header, "\n"); return header; }
/** * fu_util_print_metadata: **/ static void fu_util_print_metadata (GVariant *val) { GVariant *variant; const gchar *key; const gchar *type; guint i; _cleanup_variant_iter_free_ GVariantIter *iter = NULL; g_variant_get (val, "(a{sv})", &iter); while (g_variant_iter_next (iter, "{&sv}", &key, &variant)) { g_print ("%s", key); for (i = strlen (key); i < 15; i++) g_print (" "); type = g_variant_get_type_string (variant); if (g_strcmp0 (type, "s") == 0) { g_print ("%s\n", g_variant_get_string (variant, NULL)); } else if (g_strcmp0 (type, "b") == 0) { g_print ("%s\n", g_variant_get_boolean (variant) ? "True" : "False"); } else if (g_strcmp0 (type, "t") == 0) { g_print ("%" G_GUINT64_FORMAT "\n", g_variant_get_uint64 (variant)); } else { g_print ("???? [%s]\n", type); } g_variant_unref (variant); } }
/** * json_gvariant_serialize: * @variant: A #GVariant to convert * * Converts @variant to a JSON tree. * * Return value: (transfer full): A #JsonNode representing the root of the * JSON data structure obtained from @variant * * Since: 0.14 */ JsonNode * json_gvariant_serialize (GVariant *variant) { JsonNode *json_node = NULL; GVariantClass class; g_return_val_if_fail (variant != NULL, NULL); class = g_variant_classify (variant); if (! g_variant_is_container (variant)) { json_node = json_node_new (JSON_NODE_VALUE); switch (class) { case G_VARIANT_CLASS_BOOLEAN: json_node_set_boolean (json_node, g_variant_get_boolean (variant)); break; case G_VARIANT_CLASS_BYTE: json_node_set_int (json_node, g_variant_get_byte (variant)); break; case G_VARIANT_CLASS_INT16: json_node_set_int (json_node, g_variant_get_int16 (variant)); break; case G_VARIANT_CLASS_UINT16: json_node_set_int (json_node, g_variant_get_uint16 (variant)); break; case G_VARIANT_CLASS_INT32: json_node_set_int (json_node, g_variant_get_int32 (variant)); break; case G_VARIANT_CLASS_UINT32: json_node_set_int (json_node, g_variant_get_uint32 (variant)); break; case G_VARIANT_CLASS_INT64: json_node_set_int (json_node, g_variant_get_int64 (variant)); break; case G_VARIANT_CLASS_UINT64: json_node_set_int (json_node, g_variant_get_uint64 (variant)); break; case G_VARIANT_CLASS_HANDLE: json_node_set_int (json_node, g_variant_get_handle (variant)); break; case G_VARIANT_CLASS_DOUBLE: json_node_set_double (json_node, g_variant_get_double (variant)); break; case G_VARIANT_CLASS_STRING: case G_VARIANT_CLASS_OBJECT_PATH: case G_VARIANT_CLASS_SIGNATURE: json_node_set_string (json_node, g_variant_get_string (variant, NULL)); break; default: break; } }
QString DeviceOptions::print_samplerate(GVariant *const gvar) { char *const s = sr_samplerate_string( g_variant_get_uint64(gvar)); const QString qstring(s); g_free(s); return qstring; }
/** * Scan for Modbus devices which match a probing function. * * @param drvc The driver context doing the scan. * @param options The scan options to find devies. * @param probe_device The callback function that will be called for each * found device to validate whether this device matches * what we are scanning for. * * @return A list of the devices found or NULL if no devices were found. */ SR_PRIV GSList *sr_modbus_scan(struct drv_context *drvc, GSList *options, struct sr_dev_inst *(*probe_device)(struct sr_modbus_dev_inst *modbus)) { GSList *resources, *l, *devices; struct sr_dev_inst *sdi; const char *resource = NULL; const char *serialcomm = NULL; int modbusaddr = 1; gchar **res; unsigned int i; for (l = options; l; l = l->next) { struct sr_config *src = l->data; switch (src->key) { case SR_CONF_CONN: resource = g_variant_get_string(src->data, NULL); break; case SR_CONF_SERIALCOMM: serialcomm = g_variant_get_string(src->data, NULL); break; case SR_CONF_MODBUSADDR: modbusaddr = g_variant_get_uint64(src->data); break; } } devices = NULL; for (i = 0; i < modbus_devs_size; i++) { if ((resource && strcmp(resource, modbus_devs[i]->prefix)) || !modbus_devs[i]->scan) continue; resources = modbus_devs[i]->scan(modbusaddr); for (l = resources; l; l = l->next) { res = g_strsplit(l->data, ":", 2); if (res[0] && (sdi = sr_modbus_scan_resource(res[0], serialcomm ? serialcomm : res[1], modbusaddr, probe_device))) { devices = g_slist_append(devices, sdi); sdi->connection_id = g_strdup(l->data); } g_strfreev(res); } g_slist_free_full(resources, g_free); } if (!devices && resource) { sdi = sr_modbus_scan_resource(resource, serialcomm, modbusaddr, probe_device); if (sdi) devices = g_slist_append(NULL, sdi); } /* Tack a copy of the newly found devices onto the driver list. */ if (devices) drvc->instances = g_slist_concat(drvc->instances, g_slist_copy(devices)); return devices; }
static int config_set(int key, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_probe_group *probe_group) { struct dev_context *devc; const char *tmp_str; unsigned int i; (void)probe_group; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; if (!(devc = sdi->priv)) { sr_err("sdi->priv was NULL."); return SR_ERR_BUG; } switch (key) { case SR_CONF_LIMIT_SAMPLES: devc->limit_samples = g_variant_get_uint64(data); sr_dbg("Setting sample limit to %" PRIu64 ".", devc->limit_samples); break; case SR_CONF_LIMIT_MSEC: devc->limit_msec = g_variant_get_uint64(data); sr_dbg("Setting time limit to %" PRIu64 "ms.", devc->limit_msec); break; case SR_CONF_DATA_SOURCE: { tmp_str = g_variant_get_string(data, NULL); for (i = 0; i < ARRAY_SIZE(data_sources); i++) if (!strcmp(tmp_str, data_sources[i])) { devc->data_source = i; break; } if (i == ARRAY_SIZE(data_sources)) return SR_ERR; break; } default: return SR_ERR_NA; } return SR_OK; }
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; uint64_t tmp; int ret; (void)cg; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; devc = sdi->priv; ret = SR_OK; switch (key) { case SR_CONF_SAMPLERATE: ret = sigma_set_samplerate(sdi, g_variant_get_uint64(data)); break; case SR_CONF_LIMIT_MSEC: tmp = g_variant_get_uint64(data); if (tmp > 0) devc->limit_msec = g_variant_get_uint64(data); else ret = SR_ERR; break; case SR_CONF_LIMIT_SAMPLES: tmp = g_variant_get_uint64(data); devc->limit_msec = tmp * 1000 / devc->cur_samplerate; break; case SR_CONF_CAPTURE_RATIO: tmp = g_variant_get_uint64(data); if (tmp <= 100) devc->capture_ratio = tmp; else ret = SR_ERR; break; default: ret = SR_ERR_NA; } return ret; }