* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include "sigrok-cli.h"
#include "config.h"
#include <glib.h>
#include <glib/gstdio.h>
-#include <libsigrok/libsigrok.h>
-#ifdef HAVE_SRD
-#include <libsigrokdecode/libsigrokdecode.h> /* First, so we avoid a _POSIX_C_SOURCE warning. */
-#endif
-#include "sigrok-cli.h"
+#include <string.h>
+#include <stdlib.h>
static struct sr_output_format *output_format = NULL;
static int default_output_format = FALSE;
extern struct srd_session *srd_sess;
#endif
-
-static GArray *get_enabled_logic_probes(const struct sr_dev_inst *sdi)
-{
- struct sr_probe *probe;
- GArray *probes;
- GSList *l;
-
- probes = g_array_new(FALSE, FALSE, sizeof(int));
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
- continue;
- if (probe->enabled != TRUE)
- continue;
- g_array_append_val(probes, probe->index);
- }
-
- return probes;
-}
-
static int set_limit_time(const struct sr_dev_inst *sdi)
{
GVariant *gvar;
const struct sr_datafeed_analog *analog;
struct sr_config *src;
static struct sr_output *o = NULL;
- static GArray *logic_probelist = NULL;
static uint64_t received_samples = 0;
- static int unitsize = 0;
static int triggered = 0;
static FILE *outfile = NULL;
GSList *l;
GString *out;
- int sample_size, ret;
- uint64_t samplerate, output_len, filter_out_len, end_sample;
- uint8_t *output_buf, *filter_out;
+ uint64_t samplerate;
+ uint64_t end_sample;
+ uint64_t output_len, input_len;
+ uint8_t *output_buf;
(void) cb_data;
if (packet->type != SR_DF_HEADER && o == NULL)
return;
- sample_size = -1;
switch (packet->type) {
case SR_DF_HEADER:
g_debug("cli: Received SR_DF_HEADER");
outfile = g_fopen(opt_output_file, "wb");
}
}
-
- /* Prepare for logic data. */
- logic_probelist = get_enabled_logic_probes(sdi);
- /* How many bytes we need to store the packed samples. */
- unitsize = (logic_probelist->len + 7) / 8;
+ received_samples = 0;
#ifdef HAVE_SRD
- GVariant *gvar;
- if (opt_pds && logic_probelist->len) {
+ if (opt_pds) {
+ GVariant *gvar;
if (sr_config_get(sdi->driver, sdi, NULL, SR_CONF_SAMPLERATE,
&gvar) == SR_OK) {
samplerate = g_variant_get_uint64(gvar);
case SR_DF_LOGIC:
logic = packet->payload;
g_message("cli: received SR_DF_LOGIC, %"PRIu64" bytes", logic->length);
- sample_size = logic->unitsize;
if (logic->length == 0)
break;
if (limit_samples && received_samples >= limit_samples)
break;
- ret = sr_filter_probes(sample_size, unitsize, logic_probelist,
- logic->data, logic->length,
- &filter_out, &filter_out_len);
- if (ret != SR_OK)
- break;
-
- /*
- * 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
- * the buffer of the last packet according to the sample limit.
- */
- if (limit_samples && (received_samples + logic->length / sample_size >
- limit_samples * sample_size))
- filter_out_len = limit_samples * sample_size - received_samples;
+ end_sample = received_samples + logic->length / logic->unitsize;
+ /* Cut off last packet according to the sample limit. */
+ if (limit_samples && end_sample > limit_samples)
+ end_sample = limit_samples;
+ input_len = (end_sample - received_samples) * logic->unitsize;
if (opt_output_file && default_output_format) {
/* Saving to a session file. */
- g_byte_array_append(savebuf, filter_out, filter_out_len);
+ g_byte_array_append(savebuf, logic->data, input_len);
} else {
if (opt_pds) {
#ifdef HAVE_SRD
- 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)
+ logic->data, input_len) != SRD_OK)
sr_session_stop();
#endif
} else {
output_len = 0;
if (o->format->data && packet->type == o->format->df_type)
- o->format->data(o, filter_out, filter_out_len,
+ o->format->data(o, logic->data, input_len,
&output_buf, &output_len);
if (output_len) {
fwrite(output_buf, 1, output_len, outfile);
}
}
}
- g_free(filter_out);
- received_samples += logic->length / sample_size;
+ received_samples = end_sample;
break;
case SR_DF_ANALOG:
g_warning("Device stopped after %" PRIu64 " samples.",
received_samples);
- g_array_free(logic_probelist, TRUE);
-
if (o->format->cleanup)
o->format->cleanup(o);
g_free(o);
if (outfile && outfile != stdout)
fclose(outfile);
- if (opt_output_file && default_output_format && savebuf->len) {
+ if (opt_output_file && default_output_format && savebuf->len
+ && received_samples > 0) {
if (sr_session_save(opt_output_file, sdi, savebuf->data,
- unitsize, savebuf->len / unitsize) != SR_OK)
+ savebuf->len / received_samples,
+ received_samples) != SR_OK)
g_critical("Failed to save session.");
- g_byte_array_free(savebuf, FALSE);
+ g_byte_array_free(savebuf, TRUE);
}
}
}
-int set_dev_options(struct sr_dev_inst *sdi, GHashTable *args)
+int opt_to_gvar(char *key, char *value, struct sr_config *src)
{
const struct sr_config_info *srci;
- struct sr_probe_group *pg;
- GHashTableIter iter;
- gpointer key, value;
- int ret;
double tmp_double;
uint64_t tmp_u64, p, q, low, high;
+ GVariant *rational[2], *range[2];
gboolean tmp_bool;
- GVariant *val, *rational[2], *range[2];
+ int ret;
- g_hash_table_iter_init(&iter, args);
- while (g_hash_table_iter_next(&iter, &key, &value)) {
- if (!(srci = sr_config_info_name_get(key))) {
- g_critical("Unknown device option '%s'.", (char *) key);
- return SR_ERR;
- }
+ if (!(srci = sr_config_info_name_get(key))) {
+ g_critical("Unknown device option '%s'.", (char *) key);
+ return -1;
+ }
+ src->key = srci->key;
- if ((value == NULL) &&
- (srci->datatype != SR_T_BOOL)) {
- g_critical("Option '%s' needs a value.", (char *)key);
- return SR_ERR;
- }
- val = NULL;
- switch (srci->datatype) {
- case SR_T_UINT64:
- ret = sr_parse_sizestring(value, &tmp_u64);
- if (ret != SR_OK)
- break;
- val = g_variant_new_uint64(tmp_u64);
- break;
- case SR_T_CHAR:
- val = g_variant_new_string(value);
- break;
- case SR_T_BOOL:
- if (!value)
- tmp_bool = TRUE;
- else
- tmp_bool = sr_parse_boolstring(value);
- val = g_variant_new_boolean(tmp_bool);
+ if ((value == NULL) &&
+ (srci->datatype != SR_T_BOOL)) {
+ g_critical("Option '%s' needs a value.", (char *)key);
+ return -1;
+ }
+
+ ret = 0;
+ switch (srci->datatype) {
+ case SR_T_UINT64:
+ ret = sr_parse_sizestring(value, &tmp_u64);
+ if (ret != 0)
break;
- case SR_T_FLOAT:
- tmp_double = strtof(value, NULL);
- val = g_variant_new_double(tmp_double);
+ src->data = g_variant_new_uint64(tmp_u64);
+ break;
+ case SR_T_INT32:
+ ret = sr_parse_sizestring(value, &tmp_u64);
+ if (ret != 0)
break;
- case SR_T_RATIONAL_PERIOD:
- if ((ret = sr_parse_period(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);
+ src->data = g_variant_new_int32(tmp_u64);
+ break;
+ case SR_T_CHAR:
+ src->data = g_variant_new_string(value);
+ break;
+ case SR_T_BOOL:
+ if (!value)
+ tmp_bool = TRUE;
+ else
+ tmp_bool = sr_parse_boolstring(value);
+ src->data = g_variant_new_boolean(tmp_bool);
+ break;
+ case SR_T_FLOAT:
+ tmp_double = strtof(value, NULL);
+ src->data = g_variant_new_double(tmp_double);
+ break;
+ case SR_T_RATIONAL_PERIOD:
+ if ((ret = sr_parse_period(value, &p, &q)) != SR_OK)
break;
- case SR_T_RATIONAL_VOLT:
- 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);
+ rational[0] = g_variant_new_uint64(p);
+ rational[1] = g_variant_new_uint64(q);
+ src->data = g_variant_new_tuple(rational, 2);
+ break;
+ case SR_T_RATIONAL_VOLT:
+ if ((ret = sr_parse_voltage(value, &p, &q)) != SR_OK)
break;
- case SR_T_UINT64_RANGE:
- if (sscanf(value, "%"PRIu64"-%"PRIu64, &low, &high) != 2) {
- ret = SR_ERR;
- break;
- } else {
- range[0] = g_variant_new_uint64(low);
- range[1] = g_variant_new_uint64(high);
- val = g_variant_new_tuple(range, 2);
- }
+ rational[0] = g_variant_new_uint64(p);
+ rational[1] = g_variant_new_uint64(q);
+ src->data = g_variant_new_tuple(rational, 2);
+ break;
+ case SR_T_UINT64_RANGE:
+ if (sscanf(value, "%"PRIu64"-%"PRIu64, &low, &high) != 2) {
+ ret = -1;
break;
- default:
- ret = SR_ERR;
- }
- if (val) {
- pg = select_probe_group(sdi);
- ret = sr_config_set(sdi, pg, srci->key, val);
+ } else {
+ range[0] = g_variant_new_uint64(low);
+ range[1] = g_variant_new_uint64(high);
+ src->data = g_variant_new_tuple(range, 2);
}
+ break;
+ default:
+ ret = -1;
+ }
+
+ return ret;
+}
+
+int set_dev_options(struct sr_dev_inst *sdi, GHashTable *args)
+{
+ struct sr_config src;
+ struct sr_probe_group *pg;
+ GHashTableIter iter;
+ gpointer key, value;
+ int ret;
+
+ g_hash_table_iter_init(&iter, args);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ if ((ret = opt_to_gvar(key, value, &src)) != 0)
+ return ret;
+ pg = select_probe_group(sdi);
+ ret = sr_config_set(sdi, pg, src.key, src.data);
if (ret != SR_OK) {
g_critical("Failed to set device option '%s'.", (char *)key);
return ret;
GHashTable *devargs;
GVariant *gvar;
struct sr_dev_inst *sdi;
+ uint64_t min_samples, max_samples;
int max_probes, i;
char **triggerlist;
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.");
projects / sigrok-cli.git / blobdiff