/*
- * This file is part of the sigrok project.
+ * This file is part of the sigrok-cli project.
*
* Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
*
#include "config.h"
#ifdef HAVE_SRD
-#include <sigrokdecode.h> /* First, so we avoid a _POSIX_C_SOURCE warning. */
+#include <libsigrokdecode/libsigrokdecode.h> /* First, so we avoid a _POSIX_C_SOURCE warning. */
#endif
#include <stdio.h>
#include <stdlib.h>
static int default_output_format = FALSE;
static char *output_format_param = NULL;
#ifdef HAVE_SRD
+static struct srd_session *srd_sess = NULL;
static GHashTable *pd_ann_visible = NULL;
#endif
static GByteArray *savebuf;
static gboolean opt_version = FALSE;
static gint opt_loglevel = SR_LOG_WARN; /* Show errors+warnings per default. */
-static gboolean opt_list_devs = FALSE;
+static gboolean opt_scan_devs = FALSE;
static gboolean opt_wait_trigger = FALSE;
static gchar *opt_input_file = NULL;
static gchar *opt_output_file = NULL;
static gchar *opt_drv = NULL;
-static gchar *opt_dev = NULL;
+static gchar *opt_config = NULL;
static gchar *opt_probes = NULL;
static gchar *opt_triggers = NULL;
static gchar *opt_pds = NULL;
{"version", 'V', 0, G_OPTION_ARG_NONE, &opt_version,
"Show version and support list", NULL},
{"loglevel", 'l', 0, G_OPTION_ARG_INT, &opt_loglevel,
- "Set libsigrok/libsigrokdecode loglevel", NULL},
- {"list-devices", 'D', 0, G_OPTION_ARG_NONE, &opt_list_devs,
- "Scan for devices", NULL},
- {"driver", 0, 0, G_OPTION_ARG_STRING, &opt_drv,
- "Use only this driver", NULL},
- {"device", 'd', 0, G_OPTION_ARG_STRING, &opt_dev,
- "Use specified device", NULL},
+ "Set loglevel (5 is most verbose)", NULL},
+ {"driver", 'd', 0, G_OPTION_ARG_STRING, &opt_drv,
+ "The driver to use", NULL},
+ {"config", 'c', 0, G_OPTION_ARG_STRING, &opt_config,
+ "Specify device configuration options", NULL},
{"input-file", 'i', 0, G_OPTION_ARG_FILENAME, &opt_input_file,
"Load input from file", NULL},
{"input-format", 'I', 0, G_OPTION_ARG_STRING, &opt_input_format,
{"wait-trigger", 'w', 0, G_OPTION_ARG_NONE, &opt_wait_trigger,
"Wait for trigger", NULL},
#ifdef HAVE_SRD
- {"protocol-decoders", 'a', 0, G_OPTION_ARG_STRING, &opt_pds,
+ {"protocol-decoders", 'P', 0, G_OPTION_ARG_STRING, &opt_pds,
"Protocol decoders to run", NULL},
- {"protocol-decoder-stack", 's', 0, G_OPTION_ARG_STRING, &opt_pd_stack,
+ {"protocol-decoder-stack", 'S', 0, G_OPTION_ARG_STRING, &opt_pd_stack,
"Protocol decoder stack", NULL},
{"protocol-decoder-annotations", 'A', 0, G_OPTION_ARG_STRING, &opt_pd_annotations,
"Protocol decoder annotation(s) to show", NULL},
#endif
+ {"scan", 0, 0, G_OPTION_ARG_NONE, &opt_scan_devs,
+ "Scan for devices", NULL},
{"show", 0, 0, G_OPTION_ARG_NONE, &opt_show,
"Show device detail", NULL},
{"time", 0, 0, G_OPTION_ARG_STRING, &opt_time,
}
if (!driver) {
g_critical("Driver %s not found.", drvname);
+ g_hash_table_destroy(drvargs);
+ g_free(drvname);
return NULL;
}
g_free(drvname);
if (sr_driver_init(sr_ctx, driver) != SR_OK) {
g_critical("Failed to initialize driver.");
+ g_hash_table_destroy(drvargs);
return NULL;
}
drvopts = NULL;
- if (g_hash_table_size(drvargs) > 0)
- if (!(drvopts = hash_to_hwopt(drvargs)))
+ if (g_hash_table_size(drvargs) > 0) {
+ if (!(drvopts = hash_to_hwopt(drvargs))) {
/* Unknown options, already logged. */
+ g_hash_table_destroy(drvargs);
return NULL;
+ }
+ }
+ g_hash_table_destroy(drvargs);
devices = sr_driver_scan(driver, drvopts);
g_slist_free_full(drvopts, (GDestroyNotify)free_drvopts);
} else {
outputs = sr_output_list();
for (i = 0; outputs[i]; i++)
printf(" %-20s %s\n", outputs[i]->id, outputs[i]->description);
+ printf(" %-20s %s\n", "sigrok", "Default file output format");
printf("\n");
#ifdef HAVE_SRD
{
struct sr_probe *probe;
GSList *l;
+ GString *s;
+ GVariant *gvar;
+ s = g_string_sized_new(128);
+ g_string_assign(s, sdi->driver->name);
+ if (sr_config_get(sdi->driver, SR_CONF_CONN, &gvar, sdi) == SR_OK) {
+ g_string_append(s, ":conn=");
+ g_string_append(s, g_variant_get_string(gvar, NULL));
+ g_variant_unref(gvar);
+ }
+ g_string_append(s, " - ");
if (sdi->vendor && sdi->vendor[0])
- printf("%s ", sdi->vendor);
+ g_string_append_printf(s, "%s ", sdi->vendor);
if (sdi->model && sdi->model[0])
- printf("%s ", sdi->model);
+ g_string_append_printf(s, "%s ", sdi->model);
if (sdi->version && sdi->version[0])
- printf("%s ", sdi->version);
+ g_string_append_printf(s, "%s ", sdi->version);
if (sdi->probes) {
if (g_slist_length(sdi->probes) == 1) {
probe = sdi->probes->data;
- printf("with 1 probe: %s", probe->name);
+ g_string_append_printf(s, "with 1 probe: %s", probe->name);
} else {
- printf("with %d probes:", g_slist_length(sdi->probes));
+ g_string_append_printf(s, "with %d probes:", g_slist_length(sdi->probes));
for (l = sdi->probes; l; l = l->next) {
probe = l->data;
- printf(" %s", probe->name);
+ g_string_append_printf(s, " %s", probe->name);
}
}
}
- printf("\n");
+ g_string_append_printf(s, "\n");
+ printf("%s", s->str);
+ g_string_free(s, TRUE);
+
}
static void show_dev_list(void)
GSList *devices;
GVariant *gvar_opts, *gvar_dict, *gvar_list, *gvar;
gsize num_opts, num_elements;
- const uint64_t *int64;
- const int32_t *opts, *int32;
- unsigned int num_devices, tmp_bool, o, i;
+ const uint64_t *uint64, p, q, low, high;
+ uint64_t cur_low, cur_high;
+ const int32_t *opts;
+ unsigned int num_devices, o, i;
+ char *tmp_str;
char *s;
const char *charopts, **stropts;
num_devices = g_slist_length(devices);
if (num_devices > 1) {
- g_critical("%d devices found. Use --list-devices to show them, "
- "and --device to select one.", num_devices);
+ g_critical("%d devices found. Use --scan to show them, "
+ "and select one to show.", num_devices);
return;
}
sdi = devices->data;
print_dev_line(sdi);
- /* This properly opens and initializes the device, so we can get
- * current settings. */
- sr_session_new();
- if (sr_session_dev_add(sdi) != SR_OK) {
- g_critical("Failed to use device.");
+ if (sr_dev_open(sdi) != SR_OK) {
+ g_critical("Failed to open device.");
return;
}
/* Driver supports no device instance options. */
return;
- printf("Supported device options:\n");
+ printf("Supported configuration options:\n");
opts = g_variant_get_fixed_array(gvar_opts, &num_opts, sizeof(int32_t));
for (o = 0; o < num_opts; o++) {
if (!(srci = sr_config_info_get(opts[o])))
}
if ((gvar_list = g_variant_lookup_value(gvar_dict,
"samplerates", G_VARIANT_TYPE("at")))) {
- int64 = g_variant_get_fixed_array(gvar_list,
+ uint64 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(uint64_t));
printf(" - supported samplerates:\n");
- for (i = 0; i < num_elements; i++)
- printf(" %s\n", sr_samplerate_string(int64[i]));
- } if ((gvar_list = g_variant_lookup_value(gvar_dict,
+ for (i = 0; i < num_elements; i++) {
+ if (!(s = sr_samplerate_string(uint64[i])))
+ continue;
+ printf(" %s\n", s);
+ g_free(s);
+ }
+ g_variant_unref(gvar_list);
+ } else if ((gvar_list = g_variant_lookup_value(gvar_dict,
"samplerate-steps", G_VARIANT_TYPE("at")))) {
- int64 = g_variant_get_fixed_array(gvar_list,
+ uint64 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(uint64_t));
/* low */
- if (!(s = sr_samplerate_string(int64[0])))
+ if (!(s = sr_samplerate_string(uint64[0])))
continue;
printf(" (%s", s);
g_free(s);
/* high */
- if (!(s = sr_samplerate_string(int64[1])))
+ if (!(s = sr_samplerate_string(uint64[1])))
continue;
printf(" - %s", s);
g_free(s);
/* step */
- if (!(s = sr_samplerate_string(int64[2])))
+ if (!(s = sr_samplerate_string(uint64[2])))
continue;
printf(" in steps of %s)\n", s);
g_free(s);
printf("\n");
continue;
}
- int64 = g_variant_get_fixed_array(gvar_list,
+ uint64 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(uint64_t));
printf(" - supported buffer sizes:\n");
for (i = 0; i < num_elements; i++)
- printf(" %"PRIu64"\n", int64[i]);
+ printf(" %"PRIu64"\n", uint64[i]);
g_variant_unref(gvar_list);
} else if (srci->key == SR_CONF_TIMEBASE) {
continue;
}
printf(" - supported time bases:\n");
- int32 = g_variant_get_fixed_array(gvar_list,
- &num_elements, sizeof(int32_t));
- for (i = 0; i < num_elements / 2; i++)
- printf(" %s\n", sr_period_string(
- int32[i * 2] * int32[i * 2 + 1]));
+ num_elements = g_variant_n_children(gvar_list);
+ for (i = 0; i < num_elements; i++) {
+ gvar = g_variant_get_child_value(gvar_list, i);
+ g_variant_get(gvar, "(tt)", &p, &q);
+ s = sr_period_string(p * q);
+ printf(" %s\n", s);
+ g_free(s);
+ }
g_variant_unref(gvar_list);
- } else if (srci->key == SR_CONF_TRIGGER_SOURCE) {
- /* Supported trigger sources */
+ } else if (srci->key == SR_CONF_VDIV) {
+ /* Supported volts/div values */
printf(" %s", srci->id);
- if (sr_config_list(sdi->driver, SR_CONF_TRIGGER_SOURCE,
- &gvar, sdi) != SR_OK) {
+ if (sr_config_list(sdi->driver, SR_CONF_VDIV,
+ &gvar_list, sdi) != SR_OK) {
printf("\n");
continue;
}
- printf(" - supported trigger sources:\n");
- stropts = g_variant_get_strv(gvar, &num_elements);
- for (i = 0; i < num_elements; i++)
- printf(" %s\n", stropts[i]);
- g_variant_unref(gvar);
+ printf(" - supported volts/div:\n");
+ num_elements = g_variant_n_children(gvar_list);
+ for (i = 0; i < num_elements; i++) {
+ gvar = g_variant_get_child_value(gvar_list, i);
+ g_variant_get(gvar, "(tt)", &p, &q);
+ s = sr_voltage_string(p, q);
+ printf(" %s\n", s);
+ g_free(s);
+ }
+ g_variant_unref(gvar_list);
- } else if (srci->key == SR_CONF_FILTER) {
- /* Supported filters */
- printf(" %s", srci->id);
- if (sr_config_list(sdi->driver, SR_CONF_FILTER,
+ } else if (srci->datatype == SR_T_CHAR) {
+ printf(" %s: ", srci->id);
+ if (sr_config_get(sdi->driver, srci->key,
+ &gvar, sdi) == SR_OK) {
+ tmp_str = g_strdup(g_variant_get_string(gvar, NULL));
+ g_variant_unref(gvar);
+ } else
+ tmp_str = NULL;
+
+ if (sr_config_list(sdi->driver, srci->key,
&gvar, sdi) != SR_OK) {
printf("\n");
continue;
}
- printf(" - supported filter targets:\n");
+
stropts = g_variant_get_strv(gvar, &num_elements);
- for (i = 0; i < num_elements; i++)
- printf(" %s\n", stropts[i]);
+ for (i = 0; i < num_elements; i++) {
+ if (i)
+ printf(", ");
+ printf("%s", stropts[i]);
+ if (tmp_str && !strcmp(tmp_str, stropts[i]))
+ printf(" (current)");
+ }
+ printf("\n");
+ g_free(stropts);
+ g_free(tmp_str);
g_variant_unref(gvar);
- } else if (srci->key == SR_CONF_VDIV) {
- /* Supported volts/div values */
- printf(" %s", srci->id);
- if (sr_config_list(sdi->driver, SR_CONF_VDIV,
+ } else if (srci->datatype == SR_T_UINT64_RANGE) {
+ printf(" %s: ", srci->id);
+ if (sr_config_list(sdi->driver, srci->key,
&gvar_list, sdi) != SR_OK) {
printf("\n");
continue;
}
- printf(" - supported volts/div:\n");
- int32 = g_variant_get_fixed_array(gvar_list,
- &num_elements, sizeof(int32_t));
- for (i = 0; i < num_elements / 2; i++)
- printf(" %s\n", sr_period_string(
- int32[i * 2] * int32[i * 2 + 1]));
- g_variant_unref(gvar_list);
- } else if (srci->key == SR_CONF_COUPLING) {
- /* Supported coupling settings */
- printf(" %s", srci->id);
- if (sr_config_list(sdi->driver, SR_CONF_COUPLING,
- &gvar, sdi) != SR_OK) {
- printf("\n");
- continue;
+ if (sr_config_get(sdi->driver, srci->key, &gvar, sdi) == SR_OK) {
+ g_variant_get(gvar, "(tt)", &cur_low, &cur_high);
+ g_variant_unref(gvar);
+ } else {
+ cur_low = 0;
+ cur_high = 0;
}
- printf(" - supported coupling options:\n");
- stropts = g_variant_get_strv(gvar, &num_elements);
- for (i = 0; i < num_elements; i++)
- printf(" %s\n", stropts[i]);
- g_variant_unref(gvar);
- } else if (srci->key == SR_CONF_DATALOG) {
- /* TODO test */
- /* Turning on/off internal data logging. */
- printf(" %s\t(on/off", srci->id);
- if (sr_config_get(sdi->driver, SR_CONF_DATALOG,
- &gvar, sdi) == SR_OK) {
- tmp_bool = g_variant_get_boolean(gvar);
- printf(", currently %s", tmp_bool ? "on" : "off");
+ num_elements = g_variant_n_children(gvar_list);
+ for (i = 0; i < num_elements; i++) {
+ gvar = g_variant_get_child_value(gvar_list, i);
+ g_variant_get(gvar, "(tt)", &low, &high);
g_variant_unref(gvar);
+ if (i)
+ printf(", ");
+ printf("%"PRIu64"-%"PRIu64, low, high);
+ if (low == cur_low && high == cur_high)
+ printf(" (current)");
}
- printf(")\n");
+ printf("\n");
+ g_variant_unref(gvar_list);
+
+ } else if (srci->datatype == SR_T_BOOL) {
+ printf(" %s: ", srci->id);
+ if (sr_config_get(sdi->driver, srci->key,
+ &gvar, sdi) == SR_OK) {
+ if (g_variant_get_boolean(gvar))
+ printf("on (current), off\n");
+ else
+ printf("on, off (current)\n");
+ g_variant_unref(gvar);
+ } else
+ printf("on, off\n");
+
} else {
+
/* Everything else */
printf(" %s\n", srci->id);
}
}
g_variant_unref(gvar_opts);
- sr_session_destroy();
+ sr_dev_close(sdi);
+ g_slist_free(devices);
}
}
static void datafeed_in(const struct sr_dev_inst *sdi,
- const struct sr_datafeed_packet *packet)
+ const struct sr_datafeed_packet *packet, void *cb_data)
{
const struct sr_datafeed_meta *meta;
const struct sr_datafeed_logic *logic;
static FILE *outfile = NULL;
GSList *l;
GString *out;
- GVariant *gvar;
int sample_size, ret;
- uint64_t samplerate, output_len, filter_out_len;
+ uint64_t samplerate, output_len, filter_out_len, end_sample;
uint8_t *output_buf, *filter_out;
+ (void) cb_data;
+
/* If the first packet to come in isn't a header, don't even try. */
if (packet->type != SR_DF_HEADER && o == NULL)
return;
unitsize = (logic_probelist->len + 7) / 8;
#ifdef HAVE_SRD
+ GVariant *gvar;
if (opt_pds && logic_probelist->len) {
if (sr_config_get(sdi->driver, SR_CONF_SAMPLERATE,
- &gvar, sdi) != SR_OK) {
- g_critical("Unable to initialize protocol "
- "decoders: no samplerate found.");
+ &gvar, sdi) == SR_OK) {
+ samplerate = g_variant_get_uint64(gvar);
+ g_variant_unref(gvar);
+ if (srd_session_metadata_set(srd_sess, SRD_CONF_SAMPLERATE,
+ g_variant_new_uint64(samplerate)) != SRD_OK) {
+ g_critical("Failed to configure decode session.");
+ break;
+ }
+ }
+ if (srd_session_start(srd_sess) != SRD_OK) {
+ g_critical("Failed to start decode session.");
break;
}
- samplerate = g_variant_get_uint64(gvar);
- g_variant_unref(gvar);
- srd_session_start(logic_probelist->len, unitsize, samplerate);
}
#endif
break;
case SR_CONF_SAMPLERATE:
samplerate = g_variant_get_uint64(src->data);
g_debug("cli: got samplerate %"PRIu64" Hz", samplerate);
+#ifdef HAVE_SRD
+ if (opt_pds) {
+ if (srd_session_metadata_set(srd_sess, SRD_CONF_SAMPLERATE,
+ g_variant_new_uint64(samplerate)) != SRD_OK) {
+ g_critical("Failed to pass samplerate to decoder.");
+ }
+ }
+#endif
break;
case SR_CONF_SAMPLE_INTERVAL:
samplerate = g_variant_get_uint64(src->data);
if (ret != SR_OK)
break;
- /* What comes out of the filter is guaranteed to be packed into the
+ /*
+ * What comes out of the filter is guaranteed to be packed into the
* minimum size needed to support the number of samples at this sample
- * size. however, the driver may have submitted too much -- cut off
+ * size. however, the driver may have submitted too much. Cut off
* the buffer of the last packet according to the sample limit.
*/
if (limit_samples && (received_samples + logic->length / sample_size >
} else {
if (opt_pds) {
#ifdef HAVE_SRD
- if (srd_session_send(received_samples, (uint8_t*)filter_out,
- filter_out_len) != SRD_OK)
+ end_sample = received_samples + filter_out_len / unitsize;
+ if (srd_session_send(srd_sess, received_samples, end_sample,
+ (uint8_t*)filter_out, filter_out_len) != SRD_OK)
sr_session_stop();
#endif
} else {
break;
}
- if (o && o->format->recv) {
- out = o->format->recv(o, sdi, packet);
- if (out && out->len) {
+ if (o && o->format->receive) {
+ if (o->format->receive(o, sdi, packet, &out) == SR_OK && out) {
fwrite(out->str, 1, out->len, outfile);
fflush(outfile);
+ g_string_free(out, TRUE);
}
}
- /* SR_DF_END needs to be handled after the output module's recv()
+ /* SR_DF_END needs to be handled after the output module's receive()
* is called, so it can properly clean up that module etc. */
if (packet->type == SR_DF_END) {
g_debug("cli: Received SR_DF_END");
if (outfile && outfile != stdout)
fclose(outfile);
- if (opt_output_file && default_output_format) {
+ if (opt_output_file && default_output_format && savebuf->len) {
if (sr_session_save(opt_output_file, sdi, savebuf->data,
unitsize, savebuf->len / unitsize) != SR_OK)
g_critical("Failed to save session.");
if (g_variant_is_of_type(o->def, G_VARIANT_TYPE_STRING)) {
gvar = g_variant_new_string(val_str);
} else if (g_variant_is_of_type(o->def, G_VARIANT_TYPE_INT64)) {
- val_int = strtoll(val_str, &conv, 10);
+ val_int = strtoll(val_str, &conv, 0);
if (!conv || conv == val_str) {
g_critical("Protocol decoder '%s' option '%s' "
"requires a number.", dec->name, o->id);
(GDestroyNotify)g_variant_unref);
all_probes = g_slist_copy(dec->probes);
- all_probes = g_slist_concat(all_probes, dec->opt_probes);
+ all_probes = g_slist_concat(all_probes, g_slist_copy(dec->opt_probes));
for (l = all_probes; l; l = l->next) {
p = l->data;
if (!(val_str = g_hash_table_lookup(hash, p->id)))
break;
}
- if (!(di = srd_inst_new(pd_name, options))) {
+ if (!(di = srd_inst_new(srd_sess, pd_name, options))) {
g_critical("Failed to instantiate protocol decoder %s.", pd_name);
ret = 1;
break;
/* First PD goes at the bottom of the stack. */
ids = g_strsplit(pds[0], ":", 0);
- if (!(di_from = srd_inst_find_by_id(ids[0]))) {
+ if (!(di_from = srd_inst_find_by_id(srd_sess, ids[0]))) {
g_strfreev(ids);
g_critical("Cannot stack protocol decoder '%s': "
"instance not found.", pds[0]);
/* Every subsequent PD goes on top. */
for (i = 1; pds[i]; i++) {
ids = g_strsplit(pds[i], ":", 0);
- if (!(di_to = srd_inst_find_by_id(ids[0]))) {
+ if (!(di_to = srd_inst_find_by_id(srd_sess, ids[0]))) {
g_strfreev(ids);
g_critical("Cannot stack protocol decoder '%s': "
"instance not found.", pds[i]);
return 1;
}
g_strfreev(ids);
- if ((ret = srd_inst_stack(di_from, di_to)) != SRD_OK)
+ if ((ret = srd_inst_stack(srd_sess, di_from, di_to)) != SRD_OK)
return 1;
/* Don't show annotation from this PD. Only the last PD in
int i;
char *fmtspec;
+ if (opt_output_format && !strcmp(opt_output_format, "sigrok")) {
+ /* Doesn't really exist as an output module - this is
+ * the session save mode. */
+ g_free(opt_output_format);
+ opt_output_format = NULL;
+ }
+
if (!opt_output_format) {
opt_output_format = DEFAULT_OUTPUT_FORMAT;
/* we'll need to remember this so when saving to a file
return;
sr_session_new();
- sr_session_datafeed_callback_add(datafeed_in);
+ sr_session_datafeed_callback_add(datafeed_in, NULL);
if (sr_session_dev_add(in->sdi) != SR_OK) {
g_critical("Failed to use device.");
sr_session_destroy();
if (sr_session_load(opt_input_file) == SR_OK) {
/* sigrok session file */
- sr_session_datafeed_callback_add(datafeed_in);
+ sr_session_datafeed_callback_add(datafeed_in, NULL);
sr_session_start();
sr_session_run();
sr_session_stop();
GHashTableIter iter;
gpointer key, value;
int ret;
- float tmp_float;
- uint64_t tmp_u64;
- struct sr_rational tmp_rat;
+ double tmp_double;
+ uint64_t tmp_u64, p, q, low, high;
gboolean tmp_bool;
- void *val;
+ GVariant *val, *rational[2], *range[2];
g_hash_table_iter_init(&iter, args);
while (g_hash_table_iter_next(&iter, &key, &value)) {
ret = sr_parse_sizestring(value, &tmp_u64);
if (ret != SR_OK)
break;
- val = &tmp_u64;
+ val = g_variant_new_uint64(tmp_u64);
break;
case SR_T_CHAR:
- val = value;
+ val = g_variant_new_string(value);
break;
case SR_T_BOOL:
if (!value)
tmp_bool = TRUE;
else
tmp_bool = sr_parse_boolstring(value);
- val = &tmp_bool;
+ val = g_variant_new_boolean(tmp_bool);
break;
case SR_T_FLOAT:
- tmp_float = strtof(value, NULL);
- val = &tmp_float;
+ tmp_double = strtof(value, NULL);
+ val = g_variant_new_double(tmp_double);
break;
case SR_T_RATIONAL_PERIOD:
- if ((ret = sr_parse_period(value, &tmp_rat)) != SR_OK)
+ if ((ret = sr_parse_period(value, &p, &q)) != SR_OK)
break;
- val = &tmp_rat;
+ rational[0] = g_variant_new_uint64(p);
+ rational[1] = g_variant_new_uint64(q);
+ val = g_variant_new_tuple(rational, 2);
break;
case SR_T_RATIONAL_VOLT:
- if ((ret = sr_parse_voltage(value, &tmp_rat)) != SR_OK)
+ if ((ret = sr_parse_voltage(value, &p, &q)) != SR_OK)
+ break;
+ rational[0] = g_variant_new_uint64(p);
+ rational[1] = g_variant_new_uint64(q);
+ val = g_variant_new_tuple(rational, 2);
+ break;
+ case SR_T_UINT64_RANGE:
+ if (sscanf(value, "%"PRIu64"-%"PRIu64, &low, &high) != 2) {
+ ret = SR_ERR;
break;
- val = &tmp_rat;
+ } else {
+ range[0] = g_variant_new_uint64(low);
+ range[1] = g_variant_new_uint64(high);
+ val = g_variant_new_tuple(range, 2);
+ }
break;
default:
ret = SR_ERR;
GSList *devices;
GHashTable *devargs;
- if (!opt_dev) {
+ if (!opt_config) {
g_critical("No setting specified.");
return;
}
- if (!(devargs = parse_generic_arg(opt_dev, FALSE)))
+ if (!(devargs = parse_generic_arg(opt_config, FALSE)))
return;
if (!(devices = device_scan())) {
}
sdi = devices->data;
- sr_session_new();
- if (sr_session_dev_add(sdi) != SR_OK) {
- g_critical("Failed to use device.");
+ if (sr_dev_open(sdi) != SR_OK) {
+ g_critical("Failed to open device.");
return;
}
set_dev_options(sdi, devargs);
- sr_session_destroy();
+ sr_dev_close(sdi);
g_slist_free(devices);
g_hash_table_destroy(devargs);
sdi = devices->data;
sr_session_new();
- sr_session_datafeed_callback_add(datafeed_in);
+ 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 use device.");
+ g_critical("Failed to add device to session.");
sr_session_destroy();
return;
}
- if (opt_dev) {
- if ((devargs = parse_generic_arg(opt_dev, FALSE))) {
+ 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);
sr_session_destroy();
return;
}
+ gvar = g_variant_new_uint64(limit_frames);
if (sr_config_set(sdi, SR_CONF_LIMIT_FRAMES, gvar) != SR_OK) {
g_critical("Failed to configure frame limit.");
sr_session_destroy();
if (opt_continuous)
clear_anykey();
+ sr_session_datafeed_callback_remove_all();
sr_session_destroy();
g_slist_free(devices);
fprintf(stderr, "%s\n", message);
fflush(stderr);
}
+
+ if (log_level & (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL))
+ exit(1);
+
}
int main(int argc, char **argv)
{
- int ret = 1;
GOptionContext *context;
GError *error;
+ int ret;
+ char *help;
g_log_set_default_handler(logger, NULL);
- error = NULL;
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, optargs, NULL);
+ ret = 1;
+ error = NULL;
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_critical("%s", error->message);
goto done;
if (opt_pds) {
if (srd_init(NULL) != SRD_OK)
goto done;
+ if (srd_session_new(&srd_sess) != SRD_OK) {
+ g_critical("Failed to create new decode session.");
+ goto done;
+ }
if (register_pds(NULL, opt_pds) != 0)
goto done;
- if (srd_pd_output_callback_add(SRD_OUTPUT_ANN,
+ if (srd_pd_output_callback_add(srd_sess, SRD_OUTPUT_ANN,
show_pd_annotations, NULL) != SRD_OK)
goto done;
if (setup_pd_stack() != 0)
if (opt_version)
show_version();
- else if (opt_list_devs)
+ else if (opt_scan_devs)
show_dev_list();
#ifdef HAVE_SRD
else if (opt_pds && opt_show)
set_options();
else if (opt_samples || opt_time || opt_frames || opt_continuous)
run_session();
- else
- printf("%s", g_option_context_get_help(context, TRUE, NULL));
+ else {
+ help = g_option_context_get_help(context, TRUE, NULL);
+ printf("%s", help);
+ g_free(help);
+ }
#ifdef HAVE_SRD
if (opt_pds)
projects / sigrok-cli.git / blobdiff