struct iio_context * iio_create_context_from_uri(const char *uri)
{
#ifdef WITH_LOCAL_BACKEND
if (strcmp(uri, "local:") == 0) /* No address part */
return iio_create_local_context();
#endif
#ifdef WITH_XML_BACKEND
if (strncmp(uri, "xml:", sizeof("xml:") - 1) == 0)
return iio_create_xml_context(uri + sizeof("xml:") - 1);
#endif
#ifdef WITH_NETWORK_BACKEND
if (strncmp(uri, "ip:", sizeof("ip:") - 1) == 0)
return iio_create_network_context(uri+3);
#endif
#ifdef WITH_USB_BACKEND
if (strncmp(uri, "usb:", sizeof("usb:") - 1) == 0)
return usb_create_context_from_uri(uri);
#endif
#ifdef WITH_SERIAL_BACKEND
if (strncmp(uri, "serial:", sizeof("serial:") - 1) == 0)
return serial_create_context_from_uri(uri);
#endif
errno = ENOSYS;
return NULL;
}
static struct iio_context * get_context(Dialogs *data)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialogs.connect_net))) {
const char *hostname = gtk_entry_get_text(GTK_ENTRY(dialogs.net_ip));
if (!hostname[0])
hostname = NULL;
return iio_create_network_context(hostname);
} else {
return iio_create_local_context();
}
}
void dialogs_init(GtkBuilder *builder)
{
const char *name = NULL;
struct iio_context *ctx;
GtkWidget *tmp;
dialogs.builder = builder;
dialogs.about = GTK_WIDGET(gtk_builder_get_object(builder, "About_dialog"));
dialogs.connect = GTK_WIDGET(gtk_builder_get_object(builder, "connect_dialog"));
dialogs.connect_fru = GTK_WIDGET(gtk_builder_get_object(builder, "fru_info"));
dialogs.serial_num = GTK_WIDGET(gtk_builder_get_object(builder, "serial_number_popup"));
dialogs.connect_iio = GTK_WIDGET(gtk_builder_get_object(builder, "connect_iio_devices"));
dialogs.ctx_info = GTK_WIDGET(gtk_builder_get_object(builder, "connect_iio_ctx_info"));
dialogs.load_save_profile = GTK_WIDGET(gtk_builder_get_object(builder, "load_save_profile"));
dialogs.connect_net = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net"));
dialogs.net_ip = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net_IP"));
dialogs.ok_btn = GTK_WIDGET(gtk_builder_get_object(builder, "button3"));
dialogs.latest_version = GTK_WIDGET(gtk_builder_get_object(builder, "latest_version_popup"));
dialogs.ver_progress_window = GTK_WIDGET(gtk_builder_get_object(builder, "progress_window"));
dialogs.ver_progress_bar = GTK_WIDGET(gtk_builder_get_object(builder, "progressbar"));
gtk_builder_connect_signals(builder, &dialogs);
/* Bind some dialogs radio buttons to text/labels */
tmp = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net_label"));
serial_num = GTK_WIDGET(gtk_builder_get_object(builder, "serial_number"));
fru_date = GTK_WIDGET(gtk_builder_get_object(builder, "fru_date"));
fru_file_list = GTK_WIDGET(gtk_builder_get_object(builder, "FRU_files"));
g_object_bind_property(dialogs.connect_net, "active", tmp, "sensitive", 0);
g_object_bind_property(dialogs.connect_net, "active", dialogs.net_ip, "sensitive", 0);
/* Grey out the "local context" option if it is not available */
ctx = get_context_from_osc();
if (ctx)
name = iio_context_get_name(ctx);
if (!name || strcmp(name, "local")) {
ctx = iio_create_local_context();
if (ctx) {
iio_context_destroy(ctx);
} else {
GtkWidget *local = GTK_WIDGET(gtk_builder_get_object(
builder, "connect_local"));
gtk_widget_set_sensitive(local, false);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(dialogs.connect_net), true);
}
}
}
struct extra_ctx_info *iioc_ctx_open(void)
{
struct extra_ctx_info *ctx_info = (struct extra_ctx_info *)calloc(1, sizeof(*ctx_info));
if (!ctx_info) {
IIOC_DBG("Can not calloc memory for struct extra_ctx_info.\n");
return NULL;
}
ctx_info->ctx = iio_create_local_context();
if (!ctx_info->ctx) {
IIOC_DBG("iio_create_local_context error.\n");
return NULL;
}
ctx_info->nb_devices = iio_context_get_devices_count(ctx_info->ctx);
IIOC_DBG("There are %d devices in local.\n", ctx_info->nb_devices);
if (ctx_info->nb_devices == 0) {
IIOC_DBG("No device found.\n");
return NULL;
}
return ctx_info;
//for (i = 0; i < ctx_info->nb_devices; i++) {
// struct iio_device *dev = iio_context_get_device(ctx_info->ctx, i);
// char *dev_name = iio_device_get_name(dev);
// char *dev_id = iio_device_get_id(dev);
// unsigned int nb_channels = iio_device_get_channels_count(dev);
// unsigned int nb_attrs = iio_device_get_attrs_count(dev);
//
//
// IIOC_DBG("Device%d: %s - %s, Channels count: %d, attritubes count: %d, is_input_device: %s.\n", i, dev_id, dev_name, nb_channels, nb_attrs, dev_info->input_device ? "yes" : "no");
// for (j = 0; j < nb_channels; j++) {
// struct iio_channel *ch = iio_device_get_channel(dev, j);
// char *ch_id = iio_channel_get_id(ch);
// char *ch_name = iio_channel_get_name(ch);
// IIOC_DBG("\tCH%d: %s - %s.\n", j, ch_id, ch_name);
// struct extra_chn_info *info = calloc(1, sizeof(*info));
// info->dev = dev;
// iio_channel_set_data(ch, info);
// }
// for (k = 0; k < nb_attrs; k++) {
// char *attr_name = iio_device_get_attr(dev, k);
// IIOC_DBG("\t>> Attr%d: %s.\n", k, attr_name);
// }
//}
}
struct iio_context * iio_create_default_context(void)
{
#if NETWORK_BACKEND
char *hostname = getenv("IIOD_REMOTE");
if (hostname) {
/* If the environment variable is an empty string, we will
* discover the server using ZeroConf */
if (strlen(hostname) == 0)
hostname = NULL;
return iio_create_network_context(hostname);
}
#endif
return iio_create_local_context();
}
struct iio_context * iio_create_default_context(void)
{
char *hostname = getenv("IIOD_REMOTE");
if (hostname) {
struct iio_context *ctx;
ctx = iio_create_context_from_uri(hostname);
if (ctx)
return ctx;
#ifdef WITH_NETWORK_BACKEND
/* If the environment variable is an empty string, we will
* discover the server using ZeroConf */
if (strlen(hostname) == 0)
hostname = NULL;
return iio_create_network_context(hostname);
#endif
}
return iio_create_local_context();
}
int main(int argc, char **argv)
{
struct iio_context *ctx;
int c, option_index = 0, arg_index = 0;
enum backend backend = LOCAL;
unsigned int major, minor;
char git_tag[8];
int ret;
while ((c = getopt_long(argc, argv, "+hn:x:",
options, &option_index)) != -1) {
switch (c) {
case 'h':
usage();
return EXIT_SUCCESS;
case 'n':
if (backend != LOCAL) {
ERROR("-x and -n are mutually exclusive\n");
return EXIT_FAILURE;
}
backend = NETWORK;
arg_index += 2;
break;
case 'x':
if (backend != LOCAL) {
ERROR("-x and -n are mutually exclusive\n");
return EXIT_FAILURE;
}
backend = XML;
arg_index += 2;
break;
case '?':
return EXIT_FAILURE;
}
}
if (arg_index >= argc) {
fprintf(stderr, "Incorrect number of arguments.\n\n");
usage();
return EXIT_FAILURE;
}
iio_library_get_version(&major, &minor, git_tag);
INFO("Library version: %u.%u (git tag: %s)\n", major, minor, git_tag);
if (backend == XML)
ctx = iio_create_xml_context(argv[arg_index]);
else if (backend == NETWORK)
ctx = iio_create_network_context(argv[arg_index]);
else
ctx = iio_create_local_context();
if (!ctx) {
ERROR("Unable to create IIO context\n");
return EXIT_FAILURE;
}
INFO("IIO context created with %s backend.\n",
iio_context_get_name(ctx));
ret = iio_context_get_version(ctx, &major, &minor, git_tag);
if (!ret)
INFO("Backend version: %u.%u (git tag: %s)\n",
major, minor, git_tag);
else
ERROR("Unable to get backend version: %i\n", ret);
unsigned int nb_devices = iio_context_get_devices_count(ctx);
INFO("IIO context has %u devices:\n", nb_devices);
unsigned int i;
for (i = 0; i < nb_devices; i++) {
const struct iio_device *dev = iio_context_get_device(ctx, i);
const char *name = iio_device_get_name(dev);
INFO("\t%s: %s\n", iio_device_get_id(dev), name ? name : "" );
unsigned int nb_channels = iio_device_get_channels_count(dev);
INFO("\t\t%u channels found:\n", nb_channels);
unsigned int j;
for (j = 0; j < nb_channels; j++) {
struct iio_channel *ch = iio_device_get_channel(dev, j);
const char *type_name;
if (iio_channel_is_output(ch))
type_name = "output";
else
type_name = "input";
name = iio_channel_get_name(ch);
INFO("\t\t\t%s: %s (%s)\n",
iio_channel_get_id(ch),
name ? name : "", type_name);
unsigned int nb_attrs = iio_channel_get_attrs_count(ch);
if (!nb_attrs)
continue;
INFO("\t\t\t%u channel-specific attributes found:\n",
nb_attrs);
unsigned int k;
for (k = 0; k < nb_attrs; k++) {
const char *attr = iio_channel_get_attr(ch, k);
char buf[1024];
ret = (int) iio_channel_attr_read(ch,
attr, buf, 1024);
if (ret > 0)
INFO("\t\t\t\tattr %u: %s"
" value: %s\n", k,
attr, buf);
else if (ret == -ENOSYS)
INFO("\t\t\t\tattr %u: %s\n", k, attr);
else
ERROR("Unable to read attribute %s\n",
attr);
}
}
unsigned int nb_attrs = iio_device_get_attrs_count(dev);
if (!nb_attrs)
continue;
INFO("\t\t%u device-specific attributes found:\n", nb_attrs);
for (j = 0; j < nb_attrs; j++) {
const char *attr = iio_device_get_attr(dev, j);
char buf[1024];
ret = (int) iio_device_attr_read(dev,
attr, buf, 1024);
if (ret > 0)
INFO("\t\t\t\tattr %u: %s value: %s\n", j,
attr, buf);
else if (ret == -ENOSYS)
INFO("\t\t\t\tattr %u: %s\n", j, attr);
else
ERROR("Unable to read attribute: %s\n", attr);
}
}
iio_context_destroy(ctx);
return EXIT_SUCCESS;
}
