static void iio_combo_box_update_value(struct iio_widget *widget,
const char *src, size_t len)
{
int (*compare)(const char *, const char *);
GtkComboBox *combo_box;
GtkTreeIter iter;
GtkTreeModel *model;
char text2[1024], *item;
gchar **items_avail = NULL, **saveditems_avail;
gboolean has_iter;
ssize_t ret;
combo_box = GTK_COMBO_BOX(widget->widget);
model = gtk_combo_box_get_model(combo_box);
if (widget->attr_name_avail) {
if (widget->chn)
ret = iio_channel_attr_read(widget->chn,
widget->attr_name_avail, text2, sizeof(text2));
else
ret = iio_device_attr_read(widget->dev,
widget->attr_name_avail, text2, sizeof(text2));
if (ret < 0)
return;
/* may use gtk_combo_box_text_remove_all gtk3 only */
gtk_list_store_clear (GTK_LIST_STORE (model));
saveditems_avail = items_avail = g_strsplit (text2, " ", 0);
for (; NULL != *items_avail; items_avail++) {
if (*items_avail[0] == '\0')
continue;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget->widget),
*items_avail);
}
if (saveditems_avail)
g_strfreev(saveditems_avail);
}
if (widget->priv)
compare = widget->priv;
else
compare = strcmp;
has_iter = gtk_tree_model_get_iter_first(model, &iter);
while (has_iter) {
gtk_tree_model_get(model, &iter, 0, &item, -1);
if (compare (src, item) == 0) {
gtk_combo_box_set_active_iter(combo_box, &iter);
g_free(item);
break;
}
g_free(item);
has_iter = gtk_tree_model_iter_next(model, &iter);
}
}
static void iio_combo_box_update(struct iio_widget *widget)
{
ssize_t len;
char text[1024];
if (widget->chn)
len = iio_channel_attr_read(widget->chn,
widget->attr_name, text, sizeof(text));
else
len = iio_device_attr_read(widget->dev,
widget->attr_name, text, sizeof(text));
if (len > 0)
iio_combo_box_update_value(widget, text, len);
}
static void iio_toggle_button_update(struct iio_widget *widget)
{
char buf[0x100];
ssize_t ret;
if (widget->chn)
ret = iio_channel_attr_read(widget->chn,
widget->attr_name, buf, sizeof(buf));
else
ret = iio_device_attr_read(widget->dev,
widget->attr_name, buf, sizeof(buf));
if (ret > 0)
iio_toggle_button_update_value(widget, buf, ret);
else if (ret == -ENODEV)
gtk_widget_hide(widget->widget);
}
static void rssi_update_label(GtkWidget *label, bool is_tx)
{
char buf[1024];
int ret;
/* don't update if it is hidden (to quiet down SPI) */
if (!gtk_widget_is_drawable(GTK_WIDGET(label)))
return;
ret = iio_channel_attr_read(
iio_device_find_channel(dev, "voltage0", is_tx),
"rssi", buf, sizeof(buf));
if (ret > 0)
gtk_label_set_text(GTK_LABEL(label), buf);
else
gtk_label_set_text(GTK_LABEL(label), "<error>");
}
static void glb_settings_update_labels(void)
{
float rates[6];
char tmp[160], buf[1024];
ssize_t ret;
ret = iio_device_attr_read(dev, "ensm_mode", buf, sizeof(buf));
if (ret > 0)
gtk_label_set_text(GTK_LABEL(ensm_mode), buf);
else
gtk_label_set_text(GTK_LABEL(ensm_mode), "<error>");
ret = iio_device_attr_read(dev, "calib_mode", buf, sizeof(buf));
if (ret > 0)
gtk_label_set_text(GTK_LABEL(calib_mode), buf);
else
gtk_label_set_text(GTK_LABEL(calib_mode), "<error>");
ret = iio_device_attr_read(dev, "trx_rate_governor", buf, sizeof(buf));
if (ret > 0)
gtk_label_set_text(GTK_LABEL(trx_rate_governor), buf);
else
gtk_label_set_text(GTK_LABEL(trx_rate_governor), "<error>");
ret = iio_channel_attr_read(
iio_device_find_channel(dev, "voltage0", false),
"gain_control_mode", buf, sizeof(buf));
if (ret > 0)
gtk_label_set_text(GTK_LABEL(rx_gain_control_rx1), buf);
else
gtk_label_set_text(GTK_LABEL(rx_gain_control_rx1), "<error>");
if (is_2rx_2tx) {
ret = iio_channel_attr_read(
iio_device_find_channel(dev, "voltage1", false),
"gain_control_mode", buf, sizeof(buf));
if (ret > 0)
gtk_label_set_text(GTK_LABEL(rx_gain_control_rx2), buf);
else
gtk_label_set_text(GTK_LABEL(rx_gain_control_rx2), "<error>");
}
ret = iio_device_attr_read(dev, "rx_path_rates", buf, sizeof(buf));
if (ret > 0) {
sscanf(buf, "BBPLL:%f ADC:%f R2:%f R1:%f RF:%f RXSAMP:%f",
&rates[0], &rates[1], &rates[2], &rates[3], &rates[4],
&rates[5]);
sprintf(tmp, "BBPLL: %4.3f ADC: %4.3f R2: %4.3f R1: %4.3f RF: %4.3f RXSAMP: %4.3f",
rates[0] / 1e6, rates[1] / 1e6, rates[2] / 1e6,
rates[3] / 1e6, rates[4] / 1e6, rates[5] / 1e6);
gtk_label_set_text(GTK_LABEL(rx_path_rates), tmp);
} else {
gtk_label_set_text(GTK_LABEL(rx_path_rates), "<error>");
}
ret = iio_device_attr_read(dev, "tx_path_rates", buf, sizeof(buf));
if (ret > 0) {
sscanf(buf, "BBPLL:%f DAC:%f T2:%f T1:%f TF:%f TXSAMP:%f",
&rates[0], &rates[1], &rates[2], &rates[3], &rates[4],
&rates[5]);
sprintf(tmp, "BBPLL: %4.3f DAC: %4.3f T2: %4.3f T1: %4.3f TF: %4.3f TXSAMP: %4.3f",
rates[0] / 1e6, rates[1] / 1e6, rates[2] / 1e6,
rates[3] / 1e6, rates[4] / 1e6, rates[5] / 1e6);
gtk_label_set_text(GTK_LABEL(tx_path_rates), tmp);
} else {
gtk_label_set_text(GTK_LABEL(tx_path_rates), "<error>");
}
iio_widget_update(&rx_widgets[rx1_gain]);
if (is_2rx_2tx)
iio_widget_update(&rx_widgets[rx2_gain]);
}
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;
}
static void build_channel_list(void)
{
GtkTreeIter iter, iter2, iter3;
unsigned int enabled;
char *device, *device2;
gboolean first = FALSE, iter3_valid = FALSE, loop, loop2, all = FALSE;
char dev_ch[256];
loop = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (device_list_store), &iter);
gtk_list_store_clear(channel_list_store);
while (loop) {
gtk_tree_model_get(GTK_TREE_MODEL (device_list_store), &iter, 0, &device, 1, &enabled, -1);
if (enabled) {
struct iio_device *dev;
unsigned int i, nb_channels;
all = true;
/* is it already in the list? */
loop2 = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (channel_list_store), &iter2);
if (loop2) {
first = TRUE;
iter3 = iter2;
iter3_valid = TRUE;
}
while (loop2) {
gtk_tree_model_get(GTK_TREE_MODEL (channel_list_store), &iter2, 2, &device2, -1);
if (!strcmp(device, device2))
break;
if (strcmp(device, device2) >= 0) {
first = FALSE;
iter3 = iter2;
}
g_free(device2);
loop2 = gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter2);
}
/* it is, so skip the rest */
if (loop2) {
loop = gtk_tree_model_iter_next(GTK_TREE_MODEL (device_list_store), &iter);
continue;
}
dev = get_device(device);
if (!dev)
continue;
nb_channels = iio_device_get_channels_count(dev);
for (i = 0; i < nb_channels; i++) {
struct iio_channel *chn =
iio_device_get_channel(dev, i);
const char *name, *id, *devid;
char buf[1024], *scale;
/* Must be input */
if (iio_channel_is_output(chn))
continue;
/* find the name */
devid = iio_device_get_id(dev);
name = iio_channel_get_name(chn);
id = iio_channel_get_id(chn);
if (!name)
name = id;
/* Must have 'scale', or be a temperature, which doesn't need scale */
if (!strstr(name, "temp") &&
iio_channel_attr_read(chn, "scale", buf, sizeof(buf)) < 0)
continue;
if (iter3_valid) {
if (first) {
gtk_list_store_insert_before(channel_list_store, &iter2, &iter3);
first = FALSE;
} else if(gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter3))
gtk_list_store_insert_before(channel_list_store, &iter2, &iter3);
else
gtk_list_store_append(channel_list_store, &iter2);
} else {
gtk_list_store_append(channel_list_store, &iter2);
iter3_valid = TRUE;
}
scale = strdup(buf);
snprintf(dev_ch, sizeof(dev_ch), "%s:%s",
device, name);
gtk_list_store_set(channel_list_store, &iter2,
0, dev_ch, /* device & channel name */
1, 0, /* On/Off */
2, devid, /* device ID */
3, id, /* channel ID */
4, scale, /* scale */
-1);
iter3 = iter2;
}
} else {
loop2 = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (channel_list_store), &iter2);
while (loop2) {
gtk_tree_model_get(GTK_TREE_MODEL (channel_list_store), &iter2, 2, &device2, -1);
if (!strcmp(device, device2)) {
loop2 = gtk_list_store_remove(channel_list_store, &iter2);
continue;
}
loop2 = gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter2);
}
}
loop = gtk_tree_model_iter_next(GTK_TREE_MODEL (device_list_store), &iter);
}
gtk_tree_sortable_set_sort_column_id(
GTK_TREE_SORTABLE(GTK_TREE_MODEL(channel_list_store)),
0, GTK_SORT_ASCENDING);
if (all)
gtk_widget_show(select_all_channels);
else
gtk_widget_hide(select_all_channels);
}
