static void spin_button_save(struct iio_widget *widget, bool is_double)
{
gdouble freq, min;
gdouble scale = widget->priv ? *(gdouble *)widget->priv : 1.0;
freq = gtk_spin_button_get_value(GTK_SPIN_BUTTON (widget->widget));
min = gtk_adjustment_get_lower(gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(widget->widget)));
if (scale < 0 && min < 0)
freq = fabs(freq * scale);
else
freq *= scale;
if (widget->priv_convert_function)
freq = ((double (*)(double, bool))widget->priv_convert_function)(freq, false);
if (widget->chn) {
if (is_double)
iio_channel_attr_write_double(widget->chn,
widget->attr_name, freq);
else
iio_channel_attr_write_longlong(widget->chn,
widget->attr_name, (long long) freq);
} else {
if (is_double)
iio_device_attr_write_double(widget->dev,
widget->attr_name, freq);
else
iio_device_attr_write_longlong(widget->dev,
widget->attr_name, (long long) freq);
}
}
int main(int argc, char **argv)
{
unsigned int i, nb_channels;
unsigned int buffer_size = SAMPLES_PER_READ;
int c, option_index = 0, arg_index = 0, ip_index = 0;
struct iio_device *dev;
size_t sample_size;
while ((c = getopt_long(argc, argv, "+hn:t:b:s:",
options, &option_index)) != -1) {
switch (c) {
case 'h':
usage();
return EXIT_SUCCESS;
case 'n':
arg_index += 2;
ip_index = arg_index;
break;
case 't':
arg_index += 2;
trigger_name = argv[arg_index];
break;
case 'b':
arg_index += 2;
buffer_size = atoi(argv[arg_index]);
break;
case 's':
arg_index += 2;
num_samples = atoi(argv[arg_index]);
break;
case '?':
return EXIT_FAILURE;
}
}
if (arg_index + 1 >= argc) {
fprintf(stderr, "Incorrect number of arguments.\n\n");
usage();
return EXIT_FAILURE;
}
if (ip_index)
ctx = iio_create_network_context(argv[ip_index]);
else
ctx = iio_create_default_context();
if (!ctx) {
fprintf(stderr, "Unable to create IIO context\n");
return EXIT_FAILURE;
}
#ifndef _WIN32
set_handler(SIGHUP, &quit_all);
#endif
set_handler(SIGINT, &quit_all);
set_handler(SIGSEGV, &quit_all);
set_handler(SIGTERM, &quit_all);
dev = get_device(ctx, argv[arg_index + 1]);
if (!dev) {
iio_context_destroy(ctx);
return EXIT_FAILURE;
}
if (trigger_name) {
struct iio_device *trigger = get_device(ctx, trigger_name);
if (!trigger) {
iio_context_destroy(ctx);
return EXIT_FAILURE;
}
if (!iio_device_is_trigger(trigger)) {
fprintf(stderr, "Specified device is not a trigger\n");
iio_context_destroy(ctx);
return EXIT_FAILURE;
}
/* Fixed rate for now */
iio_device_attr_write_longlong(trigger, "frequency", 100);
iio_device_set_trigger(dev, trigger);
}
nb_channels = iio_device_get_channels_count(dev);
if (argc == arg_index + 2) {
/* Enable all channels */
for (i = 0; i < nb_channels; i++)
iio_channel_enable(iio_device_get_channel(dev, i));
} else {
for (i = 0; i < nb_channels; i++) {
unsigned int j;
struct iio_channel *ch = iio_device_get_channel(dev, i);
for (j = arg_index + 2; j < argc; j++) {
const char *n = iio_channel_get_name(ch);
if (!strcmp(argv[j], iio_channel_get_id(ch)) ||
(n && !strcmp(n, argv[j])))
iio_channel_enable(ch);
}
}
}
sample_size = iio_device_get_sample_size(dev);
buffer = iio_device_create_buffer(dev, buffer_size, false);
if (!buffer) {
fprintf(stderr, "Unable to allocate buffer\n");
iio_context_destroy(ctx);
return EXIT_FAILURE;
}
while (app_running) {
int ret = iio_buffer_refill(buffer);
if (ret < 0) {
fprintf(stderr, "Unable to refill buffer: %s\n",
strerror(-ret));
break;
}
/* If there are only the samples we requested, we don't need to
* demux */
if (iio_buffer_step(buffer) == sample_size) {
void *start = iio_buffer_start(buffer);
ptrdiff_t len = (intptr_t) iio_buffer_end(buffer) -
(intptr_t) start;
size_t read_len;
if (num_samples && len > num_samples * sample_size)
len = num_samples * sample_size;
for (read_len = len; len; ) {
ssize_t nb = fwrite(start, 1, len, stdout);
if (nb < 0) {
fprintf(stderr, "Unable to write data!\n");
goto err_destroy_buffer;
}
len -= nb;
start = (void *)((intptr_t) start + nb);
}
if (num_samples) {
num_samples -= read_len / sample_size;
if (!num_samples)
quit_all(EXIT_SUCCESS);
}
} else {
iio_buffer_foreach_sample(buffer, print_sample, NULL);
}
}
err_destroy_buffer:
iio_buffer_destroy(buffer);
iio_context_destroy(ctx);
return exit_code;
}
int main(int argc, char **argv)
{
unsigned int i, nb_channels;
unsigned int buffer_size = SAMPLES_PER_READ;
const char *arg_uri = NULL;
const char *arg_ip = NULL;
int c, option_index = 0;
struct iio_device *dev;
size_t sample_size;
int timeout = -1;
bool scan_for_context = false;
while ((c = getopt_long(argc, argv, "+hn:u:t:b:s:T:a",
options, &option_index)) != -1) {
switch (c) {
case 'h':
usage();
return EXIT_SUCCESS;
case 'n':
arg_ip = optarg;
break;
case 'u':
arg_uri = optarg;
break;
case 'a':
scan_for_context = true;
break;
case 't':
trigger_name = optarg;
break;
case 'b':
buffer_size = atoi(optarg);
break;
case 's':
num_samples = atoi(optarg);
break;
case 'T':
timeout = atoi(optarg);
break;
case '?':
return EXIT_FAILURE;
}
}
if (argc == optind) {
fprintf(stderr, "Incorrect number of arguments.\n\n");
usage();
return EXIT_FAILURE;
}
setup_sig_handler();
if (scan_for_context)
ctx = scan();
else if (arg_uri)
ctx = iio_create_context_from_uri(arg_uri);
else if (arg_ip)
ctx = iio_create_network_context(arg_ip);
else
ctx = iio_create_default_context();
if (!ctx) {
fprintf(stderr, "Unable to create IIO context\n");
return EXIT_FAILURE;
}
if (timeout >= 0)
iio_context_set_timeout(ctx, timeout);
dev = iio_context_find_device(ctx, argv[optind]);
if (!dev) {
fprintf(stderr, "Device %s not found\n", argv[optind]);
iio_context_destroy(ctx);
return EXIT_FAILURE;
}
if (trigger_name) {
struct iio_device *trigger = iio_context_find_device(
ctx, trigger_name);
if (!trigger) {
fprintf(stderr, "Trigger %s not found\n", trigger_name);
iio_context_destroy(ctx);
return EXIT_FAILURE;
}
if (!iio_device_is_trigger(trigger)) {
fprintf(stderr, "Specified device is not a trigger\n");
iio_context_destroy(ctx);
return EXIT_FAILURE;
}
/*
* Fixed rate for now. Try new ABI first,
* fail gracefully to remain compatible.
*/
if (iio_device_attr_write_longlong(trigger,
"sampling_frequency", DEFAULT_FREQ_HZ) < 0)
iio_device_attr_write_longlong(trigger,
"frequency", DEFAULT_FREQ_HZ);
iio_device_set_trigger(dev, trigger);
}
nb_channels = iio_device_get_channels_count(dev);
if (argc == optind + 1) {
/* Enable all channels */
for (i = 0; i < nb_channels; i++)
iio_channel_enable(iio_device_get_channel(dev, i));
} else {
for (i = 0; i < nb_channels; i++) {
unsigned int j;
struct iio_channel *ch = iio_device_get_channel(dev, i);
for (j = optind + 1; j < (unsigned int) argc; j++) {
const char *n = iio_channel_get_name(ch);
if (!strcmp(argv[j], iio_channel_get_id(ch)) ||
(n && !strcmp(n, argv[j])))
iio_channel_enable(ch);
}
}
}
sample_size = iio_device_get_sample_size(dev);
buffer = iio_device_create_buffer(dev, buffer_size, false);
if (!buffer) {
char buf[256];
iio_strerror(errno, buf, sizeof(buf));
fprintf(stderr, "Unable to allocate buffer: %s\n", buf);
iio_context_destroy(ctx);
return EXIT_FAILURE;
}
while (app_running) {
int ret = iio_buffer_refill(buffer);
if (ret < 0) {
if (app_running) {
char buf[256];
iio_strerror(-ret, buf, sizeof(buf));
fprintf(stderr, "Unable to refill buffer: %s\n", buf);
}
break;
}
/* If there are only the samples we requested, we don't need to
* demux */
if (iio_buffer_step(buffer) == sample_size) {
void *start = iio_buffer_start(buffer);
size_t read_len, len = (intptr_t) iio_buffer_end(buffer)
- (intptr_t) start;
if (num_samples && len > num_samples * sample_size)
len = num_samples * sample_size;
for (read_len = len; len; ) {
size_t nb = fwrite(start, 1, len, stdout);
if (!nb)
goto err_destroy_buffer;
len -= nb;
start = (void *)((intptr_t) start + nb);
}
if (num_samples) {
num_samples -= read_len / sample_size;
if (!num_samples)
quit_all(EXIT_SUCCESS);
}
} else {
iio_buffer_foreach_sample(buffer, print_sample, NULL);
}
}
err_destroy_buffer:
iio_buffer_destroy(buffer);
iio_context_destroy(ctx);
return exit_code;
}