2 * This file is part of the sigrok-cli project.
4 * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 #include "sigrok-cli.h"
23 #include <glib/gstdio.h>
25 static struct sr_output_format
*output_format
= NULL
;
26 static int default_output_format
= FALSE
;
27 static char *output_format_param
= NULL
;
28 static GByteArray
*savebuf
;
29 static uint64_t limit_samples
= 0;
30 static uint64_t limit_frames
= 0;
32 extern gchar
*opt_output_file
;
33 extern gchar
*opt_output_format
;
34 extern gchar
*opt_pds
;
35 extern gboolean opt_wait_trigger
;
36 extern gchar
*opt_time
;
37 extern gchar
*opt_samples
;
38 extern gchar
*opt_frames
;
39 extern gchar
*opt_continuous
;
40 extern gchar
*opt_config
;
41 extern gchar
*opt_triggers
;
43 extern struct srd_session
*srd_sess
;
47 static GArray
*get_enabled_logic_probes(const struct sr_dev_inst
*sdi
)
49 struct sr_probe
*probe
;
53 probes
= g_array_new(FALSE
, FALSE
, sizeof(int));
54 for (l
= sdi
->probes
; l
; l
= l
->next
) {
56 if (probe
->type
!= SR_PROBE_LOGIC
)
58 if (probe
->enabled
!= TRUE
)
60 g_array_append_val(probes
, probe
->index
);
66 static int set_limit_time(const struct sr_dev_inst
*sdi
)
72 if (!(time_msec
= sr_parse_timestring(opt_time
))) {
73 g_critical("Invalid time '%s'", opt_time
);
77 if (sr_dev_has_option(sdi
, SR_CONF_LIMIT_MSEC
)) {
78 gvar
= g_variant_new_uint64(time_msec
);
79 if (sr_config_set(sdi
, NULL
, SR_CONF_LIMIT_MSEC
, gvar
) != SR_OK
) {
80 g_critical("Failed to configure time limit.");
83 } else if (sr_dev_has_option(sdi
, SR_CONF_SAMPLERATE
)) {
84 /* Convert to samples based on the samplerate. */
85 sr_config_get(sdi
->driver
, sdi
, NULL
, SR_CONF_SAMPLERATE
, &gvar
);
86 samplerate
= g_variant_get_uint64(gvar
);
87 g_variant_unref(gvar
);
88 limit_samples
= (samplerate
) * time_msec
/ (uint64_t)1000;
89 if (limit_samples
== 0) {
90 g_critical("Not enough time at this samplerate.");
93 gvar
= g_variant_new_uint64(limit_samples
);
94 if (sr_config_set(sdi
, NULL
, SR_CONF_LIMIT_SAMPLES
, gvar
) != SR_OK
) {
95 g_critical("Failed to configure time-based sample limit.");
99 g_critical("This device does not support time limits.");
106 int setup_output_format(void)
111 struct sr_output_format
**outputs
;
115 if (opt_output_format
&& !strcmp(opt_output_format
, "sigrok")) {
116 /* Doesn't really exist as an output module - this is
117 * the session save mode. */
118 g_free(opt_output_format
);
119 opt_output_format
= NULL
;
122 if (!opt_output_format
) {
123 opt_output_format
= DEFAULT_OUTPUT_FORMAT
;
124 /* we'll need to remember this so when saving to a file
125 * later, sigrok session format will be used.
127 default_output_format
= TRUE
;
130 fmtargs
= parse_generic_arg(opt_output_format
, TRUE
);
131 fmtspec
= g_hash_table_lookup(fmtargs
, "sigrok_key");
133 g_critical("Invalid output format.");
136 outputs
= sr_output_list();
137 for (i
= 0; outputs
[i
]; i
++) {
138 if (strcmp(outputs
[i
]->id
, fmtspec
))
140 g_hash_table_remove(fmtargs
, "sigrok_key");
141 output_format
= outputs
[i
];
142 g_hash_table_iter_init(&iter
, fmtargs
);
143 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
144 /* only supporting one parameter per output module
145 * for now, and only its value */
146 output_format_param
= g_strdup(value
);
151 if (!output_format
) {
152 g_critical("Invalid output format %s.", opt_output_format
);
155 g_hash_table_destroy(fmtargs
);
160 void datafeed_in(const struct sr_dev_inst
*sdi
,
161 const struct sr_datafeed_packet
*packet
, void *cb_data
)
163 const struct sr_datafeed_meta
*meta
;
164 const struct sr_datafeed_logic
*logic
;
165 const struct sr_datafeed_analog
*analog
;
166 struct sr_config
*src
;
167 static struct sr_output
*o
= NULL
;
168 static GArray
*logic_probelist
= NULL
;
169 static uint64_t received_samples
= 0;
170 static int unitsize
= 0;
171 static int triggered
= 0;
172 static FILE *outfile
= NULL
;
175 int sample_size
, ret
;
176 uint64_t samplerate
, output_len
, filter_out_len
, end_sample
;
177 uint8_t *output_buf
, *filter_out
;
181 /* If the first packet to come in isn't a header, don't even try. */
182 if (packet
->type
!= SR_DF_HEADER
&& o
== NULL
)
186 switch (packet
->type
) {
188 g_debug("cli: Received SR_DF_HEADER");
189 /* Initialize the output module. */
190 if (!(o
= g_try_malloc(sizeof(struct sr_output
)))) {
191 g_critical("Output module malloc failed.");
194 o
->format
= output_format
;
195 o
->sdi
= (struct sr_dev_inst
*)sdi
;
196 o
->param
= output_format_param
;
197 if (o
->format
->init
) {
198 if (o
->format
->init(o
) != SR_OK
) {
199 g_critical("Output format initialization failed.");
204 /* Prepare non-stdout output. */
206 if (opt_output_file
) {
207 if (default_output_format
) {
208 /* output file is in session format, so we'll
209 * keep a copy of everything as it comes in
210 * and save from there after the session. */
212 savebuf
= g_byte_array_new();
214 /* saving to a file in whatever format was set
215 * with --format, so all we need is a filehandle */
216 outfile
= g_fopen(opt_output_file
, "wb");
220 /* Prepare for logic data. */
221 logic_probelist
= get_enabled_logic_probes(sdi
);
222 /* How many bytes we need to store the packed samples. */
223 unitsize
= (logic_probelist
->len
+ 7) / 8;
227 if (opt_pds
&& logic_probelist
->len
) {
228 if (sr_config_get(sdi
->driver
, sdi
, NULL
, SR_CONF_SAMPLERATE
,
230 samplerate
= g_variant_get_uint64(gvar
);
231 g_variant_unref(gvar
);
232 if (srd_session_metadata_set(srd_sess
, SRD_CONF_SAMPLERATE
,
233 g_variant_new_uint64(samplerate
)) != SRD_OK
) {
234 g_critical("Failed to configure decode session.");
238 if (srd_session_start(srd_sess
) != SRD_OK
) {
239 g_critical("Failed to start decode session.");
247 g_debug("cli: received SR_DF_META");
248 meta
= packet
->payload
;
249 for (l
= meta
->config
; l
; l
= l
->next
) {
252 case SR_CONF_SAMPLERATE
:
253 samplerate
= g_variant_get_uint64(src
->data
);
254 g_debug("cli: got samplerate %"PRIu64
" Hz", samplerate
);
257 if (srd_session_metadata_set(srd_sess
, SRD_CONF_SAMPLERATE
,
258 g_variant_new_uint64(samplerate
)) != SRD_OK
) {
259 g_critical("Failed to pass samplerate to decoder.");
264 case SR_CONF_SAMPLE_INTERVAL
:
265 samplerate
= g_variant_get_uint64(src
->data
);
266 g_debug("cli: got sample interval %"PRIu64
" ms", samplerate
);
269 /* Unknown metadata is not an error. */
276 g_debug("cli: received SR_DF_TRIGGER");
277 if (o
->format
->event
)
278 o
->format
->event(o
, SR_DF_TRIGGER
, &output_buf
,
284 logic
= packet
->payload
;
285 g_message("cli: received SR_DF_LOGIC, %"PRIu64
" bytes", logic
->length
);
286 sample_size
= logic
->unitsize
;
287 if (logic
->length
== 0)
290 /* Don't store any samples until triggered. */
291 if (opt_wait_trigger
&& !triggered
)
294 if (limit_samples
&& received_samples
>= limit_samples
)
297 ret
= sr_filter_probes(sample_size
, unitsize
, logic_probelist
,
298 logic
->data
, logic
->length
,
299 &filter_out
, &filter_out_len
);
304 * What comes out of the filter is guaranteed to be packed into the
305 * minimum size needed to support the number of samples at this sample
306 * size. however, the driver may have submitted too much. Cut off
307 * the buffer of the last packet according to the sample limit.
309 if (limit_samples
&& (received_samples
+ logic
->length
/ sample_size
>
310 limit_samples
* sample_size
))
311 filter_out_len
= limit_samples
* sample_size
- received_samples
;
313 if (opt_output_file
&& default_output_format
) {
314 /* Saving to a session file. */
315 g_byte_array_append(savebuf
, filter_out
, filter_out_len
);
319 end_sample
= received_samples
+ filter_out_len
/ unitsize
;
320 if (srd_session_send(srd_sess
, received_samples
, end_sample
,
321 (uint8_t*)filter_out
, filter_out_len
) != SRD_OK
)
326 if (o
->format
->data
&& packet
->type
== o
->format
->df_type
)
327 o
->format
->data(o
, filter_out
, filter_out_len
,
328 &output_buf
, &output_len
);
330 fwrite(output_buf
, 1, output_len
, outfile
);
338 received_samples
+= logic
->length
/ sample_size
;
342 analog
= packet
->payload
;
343 g_message("cli: received SR_DF_ANALOG, %d samples", analog
->num_samples
);
344 if (analog
->num_samples
== 0)
347 if (limit_samples
&& received_samples
>= limit_samples
)
350 if (o
->format
->data
&& packet
->type
== o
->format
->df_type
) {
351 o
->format
->data(o
, (const uint8_t *)analog
->data
,
352 analog
->num_samples
* sizeof(float),
353 &output_buf
, &output_len
);
355 fwrite(output_buf
, 1, output_len
, outfile
);
361 received_samples
+= analog
->num_samples
;
364 case SR_DF_FRAME_BEGIN
:
365 g_debug("cli: received SR_DF_FRAME_BEGIN");
366 if (o
->format
->event
) {
367 o
->format
->event(o
, SR_DF_FRAME_BEGIN
, &output_buf
,
370 fwrite(output_buf
, 1, output_len
, outfile
);
377 case SR_DF_FRAME_END
:
378 g_debug("cli: received SR_DF_FRAME_END");
379 if (o
->format
->event
) {
380 o
->format
->event(o
, SR_DF_FRAME_END
, &output_buf
,
383 fwrite(output_buf
, 1, output_len
, outfile
);
394 if (o
&& o
->format
->receive
) {
395 if (o
->format
->receive(o
, sdi
, packet
, &out
) == SR_OK
&& out
) {
396 fwrite(out
->str
, 1, out
->len
, outfile
);
398 g_string_free(out
, TRUE
);
402 /* SR_DF_END needs to be handled after the output module's receive()
403 * is called, so it can properly clean up that module etc. */
404 if (packet
->type
== SR_DF_END
) {
405 g_debug("cli: Received SR_DF_END");
407 if (o
->format
->event
) {
408 o
->format
->event(o
, SR_DF_END
, &output_buf
, &output_len
);
411 fwrite(output_buf
, 1, output_len
, outfile
);
417 if (limit_samples
&& received_samples
< limit_samples
)
418 g_warning("Device only sent %" PRIu64
" samples.",
422 g_warning("Device stopped after %" PRIu64
" samples.",
425 g_array_free(logic_probelist
, TRUE
);
427 if (o
->format
->cleanup
)
428 o
->format
->cleanup(o
);
432 if (outfile
&& outfile
!= stdout
)
435 if (opt_output_file
&& default_output_format
&& savebuf
->len
) {
436 if (sr_session_save(opt_output_file
, sdi
, savebuf
->data
,
437 unitsize
, savebuf
->len
/ unitsize
) != SR_OK
)
438 g_critical("Failed to save session.");
439 g_byte_array_free(savebuf
, TRUE
);
445 int set_dev_options(struct sr_dev_inst
*sdi
, GHashTable
*args
)
447 const struct sr_config_info
*srci
;
448 struct sr_probe_group
*pg
;
453 uint64_t tmp_u64
, p
, q
, low
, high
;
455 GVariant
*val
, *rational
[2], *range
[2];
457 g_hash_table_iter_init(&iter
, args
);
458 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
459 if (!(srci
= sr_config_info_name_get(key
))) {
460 g_critical("Unknown device option '%s'.", (char *) key
);
464 if ((value
== NULL
) &&
465 (srci
->datatype
!= SR_T_BOOL
)) {
466 g_critical("Option '%s' needs a value.", (char *)key
);
470 switch (srci
->datatype
) {
472 ret
= sr_parse_sizestring(value
, &tmp_u64
);
475 val
= g_variant_new_uint64(tmp_u64
);
478 val
= g_variant_new_string(value
);
484 tmp_bool
= sr_parse_boolstring(value
);
485 val
= g_variant_new_boolean(tmp_bool
);
488 tmp_double
= strtof(value
, NULL
);
489 val
= g_variant_new_double(tmp_double
);
491 case SR_T_RATIONAL_PERIOD
:
492 if ((ret
= sr_parse_period(value
, &p
, &q
)) != SR_OK
)
494 rational
[0] = g_variant_new_uint64(p
);
495 rational
[1] = g_variant_new_uint64(q
);
496 val
= g_variant_new_tuple(rational
, 2);
498 case SR_T_RATIONAL_VOLT
:
499 if ((ret
= sr_parse_voltage(value
, &p
, &q
)) != SR_OK
)
501 rational
[0] = g_variant_new_uint64(p
);
502 rational
[1] = g_variant_new_uint64(q
);
503 val
= g_variant_new_tuple(rational
, 2);
505 case SR_T_UINT64_RANGE
:
506 if (sscanf(value
, "%"PRIu64
"-%"PRIu64
, &low
, &high
) != 2) {
510 range
[0] = g_variant_new_uint64(low
);
511 range
[1] = g_variant_new_uint64(high
);
512 val
= g_variant_new_tuple(range
, 2);
519 pg
= select_probe_group(sdi
);
520 ret
= sr_config_set(sdi
, pg
, srci
->key
, val
);
523 g_critical("Failed to set device option '%s'.", (char *)key
);
531 void run_session(void)
536 struct sr_dev_inst
*sdi
;
540 devices
= device_scan();
542 g_critical("No devices found.");
545 if (g_slist_length(devices
) > 1) {
546 g_critical("sigrok-cli only supports one device for capturing.");
552 sr_session_datafeed_callback_add(datafeed_in
, NULL
);
554 if (sr_dev_open(sdi
) != SR_OK
) {
555 g_critical("Failed to open device.");
559 if (sr_session_dev_add(sdi
) != SR_OK
) {
560 g_critical("Failed to add device to session.");
561 sr_session_destroy();
566 if ((devargs
= parse_generic_arg(opt_config
, FALSE
))) {
567 if (set_dev_options(sdi
, devargs
) != SR_OK
)
569 g_hash_table_destroy(devargs
);
573 if (select_probes(sdi
) != SR_OK
) {
574 g_critical("Failed to set probes.");
575 sr_session_destroy();
580 if (!(triggerlist
= sr_parse_triggerstring(sdi
, opt_triggers
))) {
581 sr_session_destroy();
584 max_probes
= g_slist_length(sdi
->probes
);
585 for (i
= 0; i
< max_probes
; i
++) {
586 if (triggerlist
[i
]) {
587 sr_dev_trigger_set(sdi
, i
, triggerlist
[i
]);
588 g_free(triggerlist
[i
]);
594 if (opt_continuous
) {
595 if (!sr_dev_has_option(sdi
, SR_CONF_CONTINUOUS
)) {
596 g_critical("This device does not support continuous sampling.");
597 sr_session_destroy();
603 if (set_limit_time(sdi
) != SR_OK
) {
604 sr_session_destroy();
610 if ((sr_parse_sizestring(opt_samples
, &limit_samples
) != SR_OK
)) {
611 g_critical("Invalid sample limit '%s'.", opt_samples
);
612 sr_session_destroy();
615 gvar
= g_variant_new_uint64(limit_samples
);
616 if (sr_config_set(sdi
, NULL
, SR_CONF_LIMIT_SAMPLES
, gvar
) != SR_OK
) {
617 g_critical("Failed to configure sample limit.");
618 sr_session_destroy();
624 if ((sr_parse_sizestring(opt_frames
, &limit_frames
) != SR_OK
)) {
625 g_critical("Invalid sample limit '%s'.", opt_samples
);
626 sr_session_destroy();
629 gvar
= g_variant_new_uint64(limit_frames
);
630 if (sr_config_set(sdi
, NULL
, SR_CONF_LIMIT_FRAMES
, gvar
) != SR_OK
) {
631 g_critical("Failed to configure frame limit.");
632 sr_session_destroy();
637 if (sr_session_start() != SR_OK
) {
638 g_critical("Failed to start session.");
639 sr_session_destroy();
651 sr_session_datafeed_callback_remove_all();
652 sr_session_destroy();
653 g_slist_free(devices
);