static void dev_selected(GtkComboBox *devbox, GObject *parent)
{
GtkTreeModel *devlist = gtk_combo_box_get_model(devbox);
GtkEntry *timesamples = g_object_get_data(parent, "timesamples");
GtkComboBox *timeunit = g_object_get_data(parent, "timeunit");
GtkTreeIter iter;
const gchar *name;
GtkCheckMenuItem *menuitem;
struct sr_dev *dev;
if (!gtk_combo_box_get_active_iter(devbox, &iter)) {
g_object_set_data(parent, "dev", NULL);
return;
}
gtk_tree_model_get(devlist, &iter, 0, &name, 1, &dev,
2, &menuitem, -1);
gtk_check_menu_item_set_active(menuitem, TRUE);
sr_session_dev_remove_all();
if (sr_session_dev_add(dev) != SR_OK) {
g_critical("Failed to use device.");
sr_session_destroy();
dev = NULL;
}
g_object_set_data(parent, "dev", dev);
/*
* Grey out the time unless the device is valid,
* and it supports sample limiting
*/
const gboolean limit_samples = dev &&
sr_driver_hwcap_exists(dev->driver,
SR_HWCAP_LIMIT_SAMPLES);
gtk_widget_set_sensitive((GtkWidget*)timesamples, limit_samples);
gtk_widget_set_sensitive((GtkWidget*)timeunit, limit_samples);
}
static void capture_run(GtkAction *action, GObject *parent)
{
(void)action;
struct sr_dev *dev = g_object_get_data(G_OBJECT(parent), "dev");
GtkEntry *timesamples = g_object_get_data(parent, "timesamples");
GtkComboBox *timeunit = g_object_get_data(parent, "timeunit");
gint i = gtk_combo_box_get_active(timeunit);
guint64 time_msec = 0;
guint64 limit_samples = 0;
switch (i) {
case 0: /* Samples */
sr_parse_sizestring(gtk_entry_get_text(timesamples),
&limit_samples);
break;
case 1: /* Milliseconds */
time_msec = strtoull(gtk_entry_get_text(timesamples), NULL, 10);
break;
case 2: /* Seconds */
time_msec = strtoull(gtk_entry_get_text(timesamples), NULL, 10)
* 1000;
break;
}
if (time_msec) {
if (sr_driver_hwcap_exists(dev->driver, SR_HWCAP_LIMIT_MSEC)) {
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_MSEC,
&time_msec) != SR_OK) {
g_critical("Failed to configure time limit.");
sr_session_destroy();
return;
}
} else {
/* time limit set, but device doesn't support this...
* convert to samples based on the samplerate.
*/
limit_samples = 0;
if (sr_dev_has_hwcap(dev, SR_HWCAP_SAMPLERATE)) {
guint64 tmp_u64;
tmp_u64 = *((uint64_t *)dev->driver->dev_info_get(
dev->driver_index,
SR_DI_CUR_SAMPLERATE));
limit_samples = tmp_u64 * time_msec / (uint64_t) 1000;
}
if (limit_samples == 0) {
g_critical("Not enough time at this samplerate.");
return;
}
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES,
&limit_samples) != SR_OK) {
g_critical("Failed to configure time-based sample limit.");
return;
}
}
}
if (limit_samples) {
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES,
&limit_samples) != SR_OK) {
g_critical("Failed to configure sample limit.");
return;
}
}
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_PROBECONFIG, (char *)dev->probes) != SR_OK) {
printf("Failed to configure probes.\n");
sr_session_destroy();
return;
}
if (sr_session_start() != SR_OK) {
g_critical("Failed to start session.");
return;
}
sr_session_run();
}
static void run_session(void)
{
struct sr_dev *dev;
GHashTable *devargs;
int num_devs, max_probes, i;
uint64_t time_msec;
char **probelist, *devspec;
devargs = NULL;
if (opt_dev) {
devargs = parse_generic_arg(opt_dev);
devspec = g_hash_table_lookup(devargs, "sigrok_key");
dev = parse_devstring(devspec);
if (!dev) {
g_critical("Device not found.");
return;
}
g_hash_table_remove(devargs, "sigrok_key");
} else {
num_devs = num_real_devs();
if (num_devs == 1) {
/* No device specified, but there is only one. */
devargs = NULL;
dev = parse_devstring("0");
} else if (num_devs == 0) {
g_critical("No devices found.");
return;
} else {
g_critical("%d devices found, please select one.", num_devs);
return;
}
}
sr_session_new();
sr_session_datafeed_callback_add(datafeed_in);
if (sr_session_dev_add(dev) != SR_OK) {
g_critical("Failed to use device.");
sr_session_destroy();
return;
}
if (devargs) {
if (set_dev_options(dev, devargs) != SR_OK) {
sr_session_destroy();
return;
}
g_hash_table_destroy(devargs);
}
if (select_probes(dev) != SR_OK)
return;
if (opt_continuous) {
if (!sr_driver_hwcap_exists(dev->driver, SR_HWCAP_CONTINUOUS)) {
g_critical("This device does not support continuous sampling.");
sr_session_destroy();
return;
}
}
if (opt_triggers) {
probelist = sr_parse_triggerstring(dev, opt_triggers);
if (!probelist) {
sr_session_destroy();
return;
}
max_probes = g_slist_length(dev->probes);
for (i = 0; i < max_probes; i++) {
if (probelist[i]) {
sr_dev_trigger_set(dev, i + 1, probelist[i]);
g_free(probelist[i]);
}
}
g_free(probelist);
}
if (opt_time) {
time_msec = sr_parse_timestring(opt_time);
if (time_msec == 0) {
g_critical("Invalid time '%s'", opt_time);
sr_session_destroy();
return;
}
if (sr_driver_hwcap_exists(dev->driver, SR_HWCAP_LIMIT_MSEC)) {
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_MSEC, &time_msec) != SR_OK) {
g_critical("Failed to configure time limit.");
sr_session_destroy();
return;
}
}
else {
/* time limit set, but device doesn't support this...
* convert to samples based on the samplerate.
*/
limit_samples = 0;
if (sr_dev_has_hwcap(dev, SR_HWCAP_SAMPLERATE)) {
const uint64_t *samplerate;
sr_dev_info_get(dev, SR_DI_CUR_SAMPLERATE,
(const void **)&samplerate);
limit_samples = (*samplerate) * time_msec / (uint64_t)1000;
}
if (limit_samples == 0) {
g_critical("Not enough time at this samplerate.");
sr_session_destroy();
return;
}
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK) {
g_critical("Failed to configure time-based sample limit.");
sr_session_destroy();
return;
}
}
}
if (opt_samples) {
if ((sr_parse_sizestring(opt_samples, &limit_samples) != SR_OK)
|| (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK)) {
g_critical("Failed to configure sample limit.");
sr_session_destroy();
return;
}
}
if (opt_frames) {
if ((sr_parse_sizestring(opt_frames, &limit_frames) != SR_OK)
|| (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_FRAMES, &limit_frames) != SR_OK)) {
printf("Failed to configure frame limit.\n");
sr_session_destroy();
return;
}
}
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_PROBECONFIG, (char *)dev->probes) != SR_OK) {
g_critical("Failed to configure probes.");
sr_session_destroy();
return;
}
if (sr_session_start() != SR_OK) {
g_critical("Failed to start session.");
sr_session_destroy();
return;
}
if (opt_continuous)
add_anykey();
sr_session_run();
if (opt_continuous)
clear_anykey();
if (opt_output_file && default_output_format) {
if (sr_session_save(opt_output_file) != SR_OK)
g_critical("Failed to save session.");
}
sr_session_destroy();
}
