static int set_limit_time(const struct sr_dev_inst *sdi)
{
GVariant *gvar;
uint64_t time_msec;
uint64_t samplerate;
if (!(time_msec = sr_parse_timestring(opt_time))) {
g_critical("Invalid time '%s'", opt_time);
return SR_ERR;
}
if (sr_dev_has_option(sdi, SR_CONF_LIMIT_MSEC)) {
gvar = g_variant_new_uint64(time_msec);
if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_MSEC, gvar) != SR_OK) {
g_critical("Failed to configure time limit.");
return SR_ERR;
}
} else if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) {
/* Convert to samples based on the samplerate. */
sr_config_get(sdi->driver, sdi, NULL, SR_CONF_SAMPLERATE, &gvar);
samplerate = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
limit_samples = (samplerate) * time_msec / (uint64_t)1000;
if (limit_samples == 0) {
g_critical("Not enough time at this samplerate.");
return SR_ERR;
}
gvar = g_variant_new_uint64(limit_samples);
if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_SAMPLES, gvar) != SR_OK) {
g_critical("Failed to configure time-based sample limit.");
return SR_ERR;
}
} else {
g_critical("This device does not support time limits.");
return SR_ERR;
}
return SR_OK;
}
/**
* Save a session to the specified file.
*
* @param session The session to save to the specified file. Must not be NULL.
* @param filename The name of the filename to save the session as.
* Must not be NULL.
* @param sdi The device instance from which the data was captured.
* @param buf The data to be saved.
* @param unitsize The number of bytes per sample.
* @param units The number of samples.
*
* @retval SR_OK Success
* @retval SR_ERR_ARG Invalid arguments
* @retval SR_ERR Other errors
*
* @since 0.2.0
*/
SR_API int sr_session_save(struct sr_session *session, const char *filename,
const struct sr_dev_inst *sdi, unsigned char *buf, int unitsize,
int units)
{
struct sr_channel *ch;
GSList *l;
GVariant *gvar;
uint64_t samplerate;
int cnt, ret;
char **channel_names;
samplerate = 0;
if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) {
if (sr_config_get(sdi->driver, sdi, NULL,
SR_CONF_SAMPLERATE, &gvar) == SR_OK) {
samplerate = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
}
}
channel_names = g_malloc0(sizeof(char *) * (g_slist_length(sdi->channels) + 1));
cnt = 0;
for (l = sdi->channels; l; l = l->next) {
ch = l->data;
if (ch->type != SR_CHANNEL_LOGIC)
continue;
if (ch->enabled != TRUE)
continue;
if (!ch->name)
continue;
/* Just borrowing the ptr. */
channel_names[cnt++] = ch->name;
}
if ((ret = sr_session_save_init(session, filename, samplerate,
channel_names)) != SR_OK)
return ret;
ret = sr_session_append(session, filename, buf, unitsize, units);
return ret;
}
void run_session(void)
{
GSList *devices;
GHashTable *devargs;
GVariant *gvar;
struct sr_dev_inst *sdi;
uint64_t min_samples, max_samples;
devices = device_scan();
if (!devices) {
g_critical("No devices found.");
return;
}
if (g_slist_length(devices) > 1) {
g_critical("sigrok-cli only supports one device for capturing.");
return;
}
sdi = devices->data;
sr_session_new();
sr_session_datafeed_callback_add(datafeed_in, NULL);
if (sr_dev_open(sdi) != SR_OK) {
g_critical("Failed to open device.");
return;
}
if (sr_session_dev_add(sdi) != SR_OK) {
g_critical("Failed to add device to session.");
sr_session_destroy();
return;
}
if (opt_config) {
if ((devargs = parse_generic_arg(opt_config, FALSE))) {
if (set_dev_options(sdi, devargs) != SR_OK)
return;
g_hash_table_destroy(devargs);
}
}
if (select_channels(sdi) != SR_OK) {
g_critical("Failed to set channels.");
sr_session_destroy();
return;
}
if (opt_triggers) {
if (!parse_triggerstring(sdi, opt_triggers)) {
sr_session_destroy();
return;
}
}
if (opt_continuous) {
if (!sr_dev_has_option(sdi, SR_CONF_CONTINUOUS)) {
g_critical("This device does not support continuous sampling.");
sr_session_destroy();
return;
}
}
if (opt_time) {
if (set_limit_time(sdi) != SR_OK) {
sr_session_destroy();
return;
}
}
if (opt_samples) {
if ((sr_parse_sizestring(opt_samples, &limit_samples) != SR_OK)) {
g_critical("Invalid sample limit '%s'.", opt_samples);
sr_session_destroy();
return;
}
if (sr_config_list(sdi->driver, sdi, NULL,
SR_CONF_LIMIT_SAMPLES, &gvar) == SR_OK) {
/* The device has no compression, or compression is turned
* off, and publishes its sample memory size. */
g_variant_get(gvar, "(tt)", &min_samples, &max_samples);
g_variant_unref(gvar);
if (limit_samples < min_samples) {
g_critical("The device stores at least %"PRIu64
" samples with the current settings.", min_samples);
}
if (limit_samples > max_samples) {
g_critical("The device can store only %"PRIu64
" samples with the current settings.", max_samples);
}
}
gvar = g_variant_new_uint64(limit_samples);
if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_SAMPLES, gvar) != 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)) {
g_critical("Invalid sample limit '%s'.", opt_samples);
sr_session_destroy();
return;
}
gvar = g_variant_new_uint64(limit_frames);
if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_FRAMES, gvar) != SR_OK) {
g_critical("Failed to configure frame limit.");
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();
sr_session_datafeed_callback_remove_all();
sr_session_destroy();
g_slist_free(devices);
}
