2 * This file is part of the sigrok project.
4 * Copyright (C) 2012 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 <sigrokdecode.h> /* First, so we avoid a _POSIX_C_SOURCE warning. */
28 #include <sys/types.h>
32 #include <glib/gstdio.h>
34 #include "sigrok-cli.h"
37 #define DEFAULT_OUTPUT_FORMAT "bits:width=64"
39 extern struct sr_hwcap_option sr_hwcap_options
[];
41 static gboolean debug
= 0;
42 static uint64_t limit_samples
= 0;
43 static struct sr_output_format
*output_format
= NULL
;
44 static int default_output_format
= FALSE
;
45 static char *output_format_param
= NULL
;
46 static char *input_format_param
= NULL
;
47 static GData
*pd_ann_visible
= NULL
;
49 static gboolean opt_version
= FALSE
;
50 static gint opt_loglevel
= SR_LOG_WARN
; /* Show errors+warnings per default. */
51 static gboolean opt_list_devs
= FALSE
;
52 static gboolean opt_wait_trigger
= FALSE
;
53 static gchar
*opt_input_file
= NULL
;
54 static gchar
*opt_output_file
= NULL
;
55 static gchar
*opt_dev
= NULL
;
56 static gchar
*opt_probes
= NULL
;
57 static gchar
*opt_triggers
= NULL
;
58 static gchar
*opt_pds
= NULL
;
59 static gchar
*opt_pd_stack
= NULL
;
60 static gchar
*opt_input_format
= NULL
;
61 static gchar
*opt_format
= NULL
;
62 static gchar
*opt_time
= NULL
;
63 static gchar
*opt_samples
= NULL
;
64 static gchar
*opt_continuous
= NULL
;
66 static GOptionEntry optargs
[] = {
67 {"version", 'V', 0, G_OPTION_ARG_NONE
, &opt_version
, "Show version and support list", NULL
},
68 {"loglevel", 'l', 0, G_OPTION_ARG_INT
, &opt_loglevel
, "Select libsigrok loglevel", NULL
},
69 {"list-devices", 'D', 0, G_OPTION_ARG_NONE
, &opt_list_devs
, "List devices", NULL
},
70 {"input-file", 'i', 0, G_OPTION_ARG_FILENAME
, &opt_input_file
, "Load input from file", NULL
},
71 {"output-file", 'o', 0, G_OPTION_ARG_FILENAME
, &opt_output_file
, "Save output to file", NULL
},
72 {"device", 'd', 0, G_OPTION_ARG_STRING
, &opt_dev
, "Use device ID", NULL
},
73 {"probes", 'p', 0, G_OPTION_ARG_STRING
, &opt_probes
, "Probes to use", NULL
},
74 {"triggers", 't', 0, G_OPTION_ARG_STRING
, &opt_triggers
, "Trigger configuration", NULL
},
75 {"wait-trigger", 'w', 0, G_OPTION_ARG_NONE
, &opt_wait_trigger
, "Wait for trigger", NULL
},
76 {"protocol-decoders", 'a', 0, G_OPTION_ARG_STRING
, &opt_pds
, "Protocol decoder sequence", NULL
},
77 {"protocol-decoder-stack", 's', 0, G_OPTION_ARG_STRING
, &opt_pd_stack
, "Protocol decoder stack", NULL
},
78 {"input-format", 'I', 0, G_OPTION_ARG_STRING
, &opt_input_format
, "Input format", NULL
},
79 {"format", 'f', 0, G_OPTION_ARG_STRING
, &opt_format
, "Output format", NULL
},
80 {"time", 0, 0, G_OPTION_ARG_STRING
, &opt_time
, "How long to sample (ms)", NULL
},
81 {"samples", 0, 0, G_OPTION_ARG_STRING
, &opt_samples
, "Number of samples to acquire", NULL
},
82 {"continuous", 0, 0, G_OPTION_ARG_NONE
, &opt_continuous
, "Sample continuously", NULL
},
83 {NULL
, 0, 0, 0, NULL
, NULL
, NULL
}
86 static void show_version(void)
89 struct sr_dev_plugin
**plugins
;
90 struct sr_input_format
**inputs
;
91 struct sr_output_format
**outputs
;
92 struct srd_decoder
*dec
;
95 printf("sigrok-cli %s\n\n", VERSION
);
97 printf("Supported hardware drivers:\n");
98 plugins
= sr_hw_list();
99 for (i
= 0; plugins
[i
]; i
++) {
100 printf(" %-20s %s\n", plugins
[i
]->name
, plugins
[i
]->longname
);
104 printf("Supported input formats:\n");
105 inputs
= sr_input_list();
106 for (i
= 0; inputs
[i
]; i
++)
107 printf(" %-20s %s\n", inputs
[i
]->id
, inputs
[i
]->description
);
110 printf("Supported output formats:\n");
111 outputs
= sr_output_list();
112 for (i
= 0; outputs
[i
]; i
++)
113 printf(" %-20s %s\n", outputs
[i
]->id
, outputs
[i
]->description
);
116 if (srd_init(NULL
) == SRD_OK
) {
117 printf("Supported protocol decoders:\n");
118 srd_decoders_load_all();
119 for (l
= srd_decoders_list(); l
; l
= l
->next
) {
121 printf(" %-20s %s\n", dec
->id
, dec
->longname
);
129 static void print_dev_line(const struct sr_dev
*dev
)
131 const struct sr_dev_inst
*sdi
;
133 sr_dev_info_get(dev
, SR_DI_INST
, (const void **)&sdi
);
135 if (sdi
->vendor
&& sdi
->vendor
[0])
136 printf("%s ", sdi
->vendor
);
137 if (sdi
->model
&& sdi
->model
[0])
138 printf("%s ", sdi
->model
);
139 if (sdi
->version
&& sdi
->version
[0])
140 printf("%s ", sdi
->version
);
142 printf("with %d probes", g_slist_length(dev
->probes
));
146 static void show_dev_list(void)
148 struct sr_dev
*dev
, *demo_dev
;
153 devs
= sr_dev_list();
155 if (g_slist_length(devs
) == 0)
158 printf("The following devices were found:\nID Device\n");
160 for (l
= devs
; l
; l
= l
->next
) {
162 if (sr_dev_has_hwcap(dev
, SR_HWCAP_DEMO_DEV
)) {
166 printf("%-3d ", devcnt
++);
171 print_dev_line(demo_dev
);
175 static void show_dev_detail(void)
178 struct sr_hwcap_option
*hwo
;
179 const struct sr_samplerates
*samplerates
;
182 const char *charopts
, **stropts
;
184 dev
= parse_devstring(opt_dev
);
186 printf("No such device. Use -D to list all devices.\n");
192 if (sr_dev_info_get(dev
, SR_DI_TRIGGER_TYPES
,
193 (const void **)&charopts
) == SR_OK
) {
194 printf("Supported triggers: ");
196 printf("%c ", *charopts
);
202 title
= "Supported options:\n";
203 hwcaps
= dev
->plugin
->hwcap_get_all();
204 for (cap
= 0; hwcaps
[cap
]; cap
++) {
205 if (!(hwo
= sr_hw_hwcap_get(hwcaps
[cap
])))
213 if (hwo
->hwcap
== SR_HWCAP_PATTERN_MODE
) {
214 printf(" %s", hwo
->shortname
);
215 if (sr_dev_info_get(dev
, SR_DI_PATTERNMODES
,
216 (const void **)&stropts
) == SR_OK
) {
217 printf(" - supported modes:\n");
218 for (i
= 0; stropts
[i
]; i
++)
219 printf(" %s\n", stropts
[i
]);
223 } else if (hwo
->hwcap
== SR_HWCAP_SAMPLERATE
) {
224 printf(" %s", hwo
->shortname
);
225 /* Supported samplerates */
226 if (sr_dev_info_get(dev
, SR_DI_SAMPLERATES
,
227 (const void **)&samplerates
) != SR_OK
) {
232 if (samplerates
->step
) {
234 if (!(s
= sr_samplerate_string(samplerates
->low
)))
239 if (!(s
= sr_samplerate_string(samplerates
->high
)))
244 if (!(s
= sr_samplerate_string(samplerates
->step
)))
246 printf(" in steps of %s)\n", s
);
249 printf(" - supported samplerates:\n");
250 for (i
= 0; samplerates
->list
[i
]; i
++) {
251 printf(" %s\n", sr_samplerate_string(samplerates
->list
[i
]));
255 printf(" %s\n", hwo
->shortname
);
260 static void show_pd_detail(void)
263 struct srd_decoder
*dec
;
264 char **pdtokens
, **pdtok
, **ann
, *doc
;
266 pdtokens
= g_strsplit(opt_pds
, ",", -1);
267 for (pdtok
= pdtokens
; *pdtok
; pdtok
++) {
268 if (!(dec
= srd_decoder_get_by_id(*pdtok
))) {
269 printf("Protocol decoder %s not found.", *pdtok
);
272 printf("ID: %s\nName: %s\nLong name: %s\nDescription: %s\n",
273 dec
->id
, dec
->name
, dec
->longname
, dec
->desc
);
274 printf("License: %s\n", dec
->license
);
275 if (dec
->annotations
) {
276 printf("Annotations:\n");
277 for (l
= dec
->annotations
; l
; l
= l
->next
) {
279 printf("- %s\n %s\n", ann
[0], ann
[1]);
282 if ((doc
= srd_decoder_doc(dec
))) {
283 printf("Documentation:\n%s\n", doc
[0] == '\n' ? doc
+1 : doc
);
288 g_strfreev(pdtokens
);
292 static void datafeed_in(struct sr_dev
*dev
, struct sr_datafeed_packet
*packet
)
294 static struct sr_output
*o
= NULL
;
295 static int probelist
[SR_MAX_NUM_PROBES
] = { 0 };
296 static uint64_t received_samples
= 0;
297 static int unitsize
= 0;
298 static int triggered
= 0;
299 static FILE *outfile
= NULL
;
300 struct sr_probe
*probe
;
301 struct sr_datafeed_header
*header
;
302 struct sr_datafeed_logic
*logic
;
303 int num_enabled_probes
, sample_size
, ret
, i
;
304 uint64_t output_len
, filter_out_len
;
305 char *output_buf
, *filter_out
;
307 /* If the first packet to come in isn't a header, don't even try. */
308 if (packet
->type
!= SR_DF_HEADER
&& o
== NULL
)
312 switch (packet
->type
) {
314 g_message("cli: Received SR_DF_HEADER");
315 /* Initialize the output module. */
316 if (!(o
= g_try_malloc(sizeof(struct sr_output
)))) {
317 printf("Output module malloc failed.\n");
320 o
->format
= output_format
;
322 o
->param
= output_format_param
;
323 if (o
->format
->init
) {
324 if (o
->format
->init(o
) != SR_OK
) {
325 printf("Output format initialization failed.\n");
330 header
= packet
->payload
;
331 num_enabled_probes
= 0;
332 for (i
= 0; i
< header
->num_logic_probes
; i
++) {
333 probe
= g_slist_nth_data(dev
->probes
, i
);
335 probelist
[num_enabled_probes
++] = probe
->index
;
337 /* How many bytes we need to store num_enabled_probes bits */
338 unitsize
= (num_enabled_probes
+ 7) / 8;
341 if (opt_output_file
) {
342 if (default_output_format
) {
343 /* output file is in session format, which means we'll
344 * dump everything in the datastore as it comes in,
345 * and save from there after the session. */
347 ret
= sr_datastore_new(unitsize
, &(dev
->datastore
));
349 printf("Failed to create datastore.\n");
353 /* saving to a file in whatever format was set
354 * with --format, so all we need is a filehandle */
355 outfile
= g_fopen(opt_output_file
, "wb");
359 srd_session_start(num_enabled_probes
, unitsize
,
363 g_message("cli: Received SR_DF_END");
365 g_message("cli: double end!");
368 if (o
->format
->event
) {
369 o
->format
->event(o
, SR_DF_END
, &output_buf
, &output_len
);
372 fwrite(output_buf
, 1, output_len
, outfile
);
377 if (limit_samples
&& received_samples
< limit_samples
)
378 printf("Device only sent %" PRIu64
" samples.\n",
381 printf("Device stopped after %" PRIu64
" samples.\n",
384 if (outfile
&& outfile
!= stdout
)
390 g_message("cli: received SR_DF_TRIGGER");
391 if (o
->format
->event
)
392 o
->format
->event(o
, SR_DF_TRIGGER
, &output_buf
,
397 logic
= packet
->payload
;
398 sample_size
= logic
->unitsize
;
399 g_message("cli: received SR_DF_LOGIC, %"PRIu64
" bytes", logic
->length
);
403 /* not supporting anything but SR_DF_LOGIC for now */
405 if (sample_size
== -1 || logic
->length
== 0)
408 /* Don't store any samples until triggered. */
409 if (opt_wait_trigger
&& !triggered
)
412 if (limit_samples
&& received_samples
>= limit_samples
)
415 /* TODO: filters only support SR_DF_LOGIC */
416 ret
= sr_filter_probes(sample_size
, unitsize
, probelist
,
417 logic
->data
, logic
->length
,
418 &filter_out
, &filter_out_len
);
422 /* what comes out of the filter is guaranteed to be packed into the
423 * minimum size needed to support the number of samples at this sample
424 * size. however, the driver may have submitted too much -- cut off
425 * the buffer of the last packet according to the sample limit.
427 if (limit_samples
&& (received_samples
+ logic
->length
/ sample_size
>
428 limit_samples
* sample_size
))
429 filter_out_len
= limit_samples
* sample_size
- received_samples
;
432 sr_datastore_put(dev
->datastore
, filter_out
,
433 filter_out_len
, sample_size
, probelist
);
435 if (opt_output_file
&& default_output_format
)
436 /* saving to a session file, don't need to do anything else
437 * to this data for now. */
441 if (srd_session_feed(received_samples
, (uint8_t*)filter_out
,
442 filter_out_len
) != SRD_OK
)
446 if (o
->format
->data
&& packet
->type
== o
->format
->df_type
)
447 o
->format
->data(o
, filter_out
, filter_out_len
, &output_buf
, &output_len
);
449 fwrite(output_buf
, 1, output_len
, outfile
);
456 received_samples
+= logic
->length
/ sample_size
;
460 /* Register the given PDs for this session.
461 * Accepts a string of the form: "spi:sck=3:sdata=4,spi:sck=3:sdata=5"
462 * That will instantiate two SPI decoders on the clock but different data
465 static int register_pds(struct sr_dev
*dev
, const char *pdstring
)
467 GHashTable
*pd_opthash
;
468 struct srd_decoder_inst
*di
;
469 char **pdtokens
, **pdtok
, *pd_name
;
471 /* Avoid compiler warnings. */
474 g_datalist_init(&pd_ann_visible
);
475 pdtokens
= g_strsplit(pdstring
, ",", -1);
479 for (pdtok
= pdtokens
; *pdtok
; pdtok
++) {
480 if (!(pd_opthash
= parse_generic_arg(*pdtok
))) {
481 fprintf(stderr
, "Invalid protocol decoder option '%s'.\n", *pdtok
);
485 pd_name
= g_strdup(g_hash_table_lookup(pd_opthash
, "sigrok_key"));
486 g_hash_table_remove(pd_opthash
, "sigrok_key");
487 if (srd_decoder_load(pd_name
) != SRD_OK
) {
488 fprintf(stderr
, "Failed to load protocol decoder %s\n", pd_name
);
491 if (!(di
= srd_inst_new(pd_name
, pd_opthash
))) {
492 fprintf(stderr
, "Failed to instantiate protocol decoder %s\n", pd_name
);
495 g_datalist_set_data(&pd_ann_visible
, di
->inst_id
, pd_name
);
497 /* Any keys left in the options hash are probes, where the key
498 * is the probe name as specified in the decoder class, and the
499 * value is the probe number i.e. the order in which the PD's
500 * incoming samples are arranged. */
501 if (srd_inst_probes_set(di
, pd_opthash
) != SRD_OK
)
503 g_hash_table_destroy(pd_opthash
);
508 g_strfreev(pdtokens
);
510 g_hash_table_destroy(pd_opthash
);
517 void show_pd_annotation(struct srd_proto_data
*pdata
, void *user_data
)
522 /* 'user_data' is not used in this specific callback. */
525 if (pdata
->ann_format
!= 0) {
526 /* CLI only shows the default annotation format. */
530 if (!g_datalist_get_data(&pd_ann_visible
, pdata
->pdo
->di
->inst_id
)) {
531 /* Not in the list of PDs whose annotations we're showing. */
535 annotations
= pdata
->data
;
536 if (opt_loglevel
> SR_LOG_WARN
)
537 printf("%"PRIu64
"-%"PRIu64
" ", pdata
->start_sample
, pdata
->end_sample
);
538 printf("%s: ", pdata
->pdo
->proto_id
);
539 for (i
= 0; annotations
[i
]; i
++)
540 printf("\"%s\" ", annotations
[i
]);
545 static int select_probes(struct sr_dev
*dev
)
547 struct sr_probe
*probe
;
555 * This only works because a device by default initializes
556 * and enables all its probes.
558 max_probes
= g_slist_length(dev
->probes
);
559 probelist
= parse_probestring(max_probes
, opt_probes
);
564 for (i
= 0; i
< max_probes
; i
++) {
566 sr_dev_probe_name(dev
, i
+ 1, probelist
[i
]);
567 g_free(probelist
[i
]);
569 probe
= sr_dev_probe_find(dev
, i
+ 1);
570 probe
->enabled
= FALSE
;
579 * Return the input file format which the CLI tool should use.
581 * If the user specified -I / --input-format, use that one. Otherwise, try to
582 * autodetect the format as good as possible. Failing that, return NULL.
584 * @param filename The filename of the input file. Must not be NULL.
585 * @param opt The -I / --input-file option the user specified (or NULL).
587 * @return A pointer to the 'struct sr_input_format' that should be used,
588 * or NULL if no input format was selected or auto-detected.
590 static struct sr_input_format
*determine_input_file_format(
591 const char *filename
, const char *opt
)
594 struct sr_input_format
**inputs
;
596 /* If there are no input formats, return NULL right away. */
597 inputs
= sr_input_list();
599 fprintf(stderr
, "cli: %s: no supported input formats "
600 "available", __func__
);
604 /* If the user specified -I / --input-format, use that one. */
606 for (i
= 0; inputs
[i
]; i
++) {
607 if (strcasecmp(inputs
[i
]->id
, opt_input_format
))
609 printf("Using user-specified input file format"
610 " '%s'.\n", inputs
[i
]->id
);
614 /* The user specified an unknown input format, return NULL. */
615 fprintf(stderr
, "Error: Specified input file format '%s' is "
616 "unknown.\n", opt_input_format
);
620 /* Otherwise, try to find an input module that can handle this file. */
621 for (i
= 0; inputs
[i
]; i
++) {
622 if (inputs
[i
]->format_match(filename
))
626 /* Return NULL if no input module wanted to touch this. */
628 fprintf(stderr
, "Error: No matching input module found.\n");
632 printf("Using input file format '%s'.\n", inputs
[i
]->id
);
636 static void load_input_file_format(void)
640 struct sr_input_format
*input_format
;
642 input_format
= determine_input_file_format(opt_input_file
,
645 fprintf(stderr
, "Error: Couldn't detect input file format.\n");
649 if (stat(opt_input_file
, &st
) == -1) {
650 printf("Failed to load %s: %s\n", opt_input_file
,
655 /* Initialize the input module. */
656 if (!(in
= g_try_malloc(sizeof(struct sr_input
)))) {
657 printf("Failed to allocate input module.\n");
660 in
->format
= input_format
;
661 in
->param
= input_format_param
;
662 if (in
->format
->init
) {
663 if (in
->format
->init(in
) != SR_OK
) {
664 printf("Input format init failed.\n");
669 if (select_probes(in
->vdev
) > 0)
673 sr_session_datafeed_callback_add(datafeed_in
);
674 if (sr_session_dev_add(in
->vdev
) != SR_OK
) {
675 printf("Failed to use device.\n");
676 sr_session_destroy();
680 input_format
->loadfile(in
, opt_input_file
);
681 if (opt_output_file
&& default_output_format
) {
682 if (sr_session_save(opt_output_file
) != SR_OK
)
683 printf("Failed to save session.\n");
685 sr_session_destroy();
689 static void load_input_file(void)
692 if (sr_session_load(opt_input_file
) == SR_OK
) {
693 /* sigrok session file */
694 sr_session_datafeed_callback_add(datafeed_in
);
700 /* fall back on input modules */
701 load_input_file_format();
706 int num_real_devs(void)
713 devs
= sr_dev_list();
714 for (l
= devs
; l
; l
= l
->next
) {
716 if (!sr_dev_has_hwcap(dev
, SR_HWCAP_DEMO_DEV
))
723 static int set_dev_options(struct sr_dev
*dev
, GHashTable
*args
)
732 g_hash_table_iter_init(&iter
, args
);
733 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
735 for (i
= 0; sr_hwcap_options
[i
].hwcap
; i
++) {
736 if (strcmp(sr_hwcap_options
[i
].shortname
, key
))
738 if ((value
== NULL
) &&
739 (sr_hwcap_options
[i
].type
!= SR_T_BOOL
)) {
740 printf("Option '%s' needs a value.\n", (char *)key
);
744 switch (sr_hwcap_options
[i
].type
) {
746 ret
= sr_parse_sizestring(value
, &tmp_u64
);
749 ret
= dev
->plugin
->dev_config_set(dev
->plugin_index
,
750 sr_hwcap_options
[i
].hwcap
, &tmp_u64
);
753 ret
= dev
->plugin
->dev_config_set(dev
->plugin_index
,
754 sr_hwcap_options
[i
].hwcap
, value
);
760 tmp_bool
= sr_parse_boolstring(value
);
761 ret
= dev
->plugin
->dev_config_set(dev
->plugin_index
,
762 sr_hwcap_options
[i
].hwcap
,
763 GINT_TO_POINTER(tmp_bool
));
770 printf("Failed to set device option '%s'.\n", (char *)key
);
777 printf("Unknown device option '%s'.\n", (char *) key
);
785 static void run_session(void)
789 int num_devs
, max_probes
, i
;
791 char **probelist
, *devspec
;
795 devargs
= parse_generic_arg(opt_dev
);
796 devspec
= g_hash_table_lookup(devargs
, "sigrok_key");
797 dev
= parse_devstring(devspec
);
799 g_warning("Device not found.");
802 g_hash_table_remove(devargs
, "sigrok_key");
804 num_devs
= num_real_devs();
806 /* No device specified, but there is only one. */
808 dev
= parse_devstring("0");
809 } else if (num_devs
== 0) {
810 printf("No devices found.\n");
813 printf("%d devices found, please select one.\n", num_devs
);
819 sr_session_datafeed_callback_add(datafeed_in
);
821 if (sr_session_dev_add(dev
) != SR_OK
) {
822 printf("Failed to use device.\n");
823 sr_session_destroy();
828 if (set_dev_options(dev
, devargs
) != SR_OK
) {
829 sr_session_destroy();
832 g_hash_table_destroy(devargs
);
835 if (select_probes(dev
) != SR_OK
)
838 if (opt_continuous
) {
839 if (!sr_hw_has_hwcap(dev
->plugin
, SR_HWCAP_CONTINUOUS
)) {
840 printf("This device does not support continuous sampling.");
841 sr_session_destroy();
847 probelist
= sr_parse_triggerstring(dev
, opt_triggers
);
849 sr_session_destroy();
853 max_probes
= g_slist_length(dev
->probes
);
854 for (i
= 0; i
< max_probes
; i
++) {
856 sr_dev_trigger_set(dev
, i
+ 1, probelist
[i
]);
857 g_free(probelist
[i
]);
864 time_msec
= sr_parse_timestring(opt_time
);
865 if (time_msec
== 0) {
866 printf("Invalid time '%s'\n", opt_time
);
867 sr_session_destroy();
871 if (sr_hw_has_hwcap(dev
->plugin
, SR_HWCAP_LIMIT_MSEC
)) {
872 if (dev
->plugin
->dev_config_set(dev
->plugin_index
,
873 SR_HWCAP_LIMIT_MSEC
, &time_msec
) != SR_OK
) {
874 printf("Failed to configure time limit.\n");
875 sr_session_destroy();
880 /* time limit set, but device doesn't support this...
881 * convert to samples based on the samplerate.
884 if (sr_dev_has_hwcap(dev
, SR_HWCAP_SAMPLERATE
)) {
885 const uint64_t *samplerate
;
887 sr_dev_info_get(dev
, SR_DI_CUR_SAMPLERATE
,
888 (const void **)&samplerate
);
889 limit_samples
= (*samplerate
) * time_msec
/ (uint64_t)1000;
891 if (limit_samples
== 0) {
892 printf("Not enough time at this samplerate.\n");
893 sr_session_destroy();
897 if (dev
->plugin
->dev_config_set(dev
->plugin_index
,
898 SR_HWCAP_LIMIT_SAMPLES
, &limit_samples
) != SR_OK
) {
899 printf("Failed to configure time-based sample limit.\n");
900 sr_session_destroy();
907 if ((sr_parse_sizestring(opt_samples
, &limit_samples
) != SR_OK
)
908 || (dev
->plugin
->dev_config_set(dev
->plugin_index
,
909 SR_HWCAP_LIMIT_SAMPLES
, &limit_samples
) != SR_OK
)) {
910 printf("Failed to configure sample limit.\n");
911 sr_session_destroy();
916 if (dev
->plugin
->dev_config_set(dev
->plugin_index
,
917 SR_HWCAP_PROBECONFIG
, (char *)dev
->probes
) != SR_OK
) {
918 printf("Failed to configure probes.\n");
919 sr_session_destroy();
923 if (sr_session_start() != SR_OK
) {
924 printf("Failed to start session.\n");
925 sr_session_destroy();
937 if (opt_output_file
&& default_output_format
) {
938 if (sr_session_save(opt_output_file
) != SR_OK
)
939 printf("Failed to save session.\n");
941 sr_session_destroy();
945 static void logger(const gchar
*log_domain
, GLogLevelFlags log_level
,
946 const gchar
*message
, gpointer user_data
)
948 /* Avoid compiler warnings. */
953 * All messages, warnings, errors etc. go to stderr (not stdout) in
954 * order to not mess up the CLI tool data output, e.g. VCD output.
956 if (log_level
& (G_LOG_LEVEL_ERROR
| G_LOG_LEVEL_WARNING
)) {
957 fprintf(stderr
, "%s\n", message
);
960 if ((log_level
& G_LOG_LEVEL_MESSAGE
&& debug
== 1)
962 printf("%s\n", message
);
968 int main(int argc
, char **argv
)
970 GOptionContext
*context
;
975 struct sr_output_format
**outputs
;
976 struct srd_decoder_inst
*di_from
, *di_to
;
978 char *fmtspec
, **pds
;
980 g_log_set_default_handler(logger
, NULL
);
981 if (getenv("SIGROK_DEBUG"))
982 debug
= strtol(getenv("SIGROK_DEBUG"), NULL
, 10);
985 context
= g_option_context_new(NULL
);
986 g_option_context_add_main_entries(context
, optargs
, NULL
);
988 if (!g_option_context_parse(context
, &argc
, &argv
, &error
)) {
989 g_warning("%s", error
->message
);
993 /* Set the loglevel (amount of messages to output) for libsigrok. */
994 if (sr_log_loglevel_set(opt_loglevel
) != SR_OK
) {
995 fprintf(stderr
, "cli: %s: sr_log_loglevel_set(%d) failed\n",
996 __func__
, opt_loglevel
);
1000 /* Set the loglevel (amount of messages to output) for libsigrokdecode. */
1001 if (srd_log_loglevel_set(opt_loglevel
) != SRD_OK
) {
1002 fprintf(stderr
, "cli: %s: srd_log_loglevel_set(%d) failed\n",
1003 __func__
, opt_loglevel
);
1007 if (sr_init() != SR_OK
)
1011 if (srd_init(NULL
) != SRD_OK
) {
1012 printf("Failed to initialize sigrokdecode\n");
1015 if (register_pds(NULL
, opt_pds
) != 0) {
1016 printf("Failed to register protocol decoders\n");
1019 if (srd_register_callback(SRD_OUTPUT_ANN
,
1020 show_pd_annotation
, NULL
) != SRD_OK
) {
1021 printf("Failed to register protocol decoder callback\n");
1027 pds
= g_strsplit(opt_pd_stack
, ",", 0);
1028 if (g_strv_length(pds
) < 2) {
1029 printf("Specify at least two protocol decoders to stack.\n");
1033 if (!(di_from
= srd_inst_find_by_id(pds
[0]))) {
1034 printf("Cannot stack protocol decoder '%s': instance not found.\n", pds
[0]);
1037 for (i
= 1; pds
[i
]; i
++) {
1038 if (!(di_to
= srd_inst_find_by_id(pds
[i
]))) {
1039 printf("Cannot stack protocol decoder '%s': instance not found.\n", pds
[i
]);
1042 if ((ret
= srd_inst_stack(di_from
, di_to
) != SRD_OK
))
1045 /* Don't show annotation from this PD. Only the last PD in
1046 * the stack will be left on the annotation list.
1048 g_datalist_remove_data(&pd_ann_visible
, di_from
->inst_id
);
1056 opt_format
= DEFAULT_OUTPUT_FORMAT
;
1057 /* we'll need to remember this so when saving to a file
1058 * later, sigrok session format will be used.
1060 default_output_format
= TRUE
;
1062 fmtargs
= parse_generic_arg(opt_format
);
1063 fmtspec
= g_hash_table_lookup(fmtargs
, "sigrok_key");
1065 printf("Invalid output format.\n");
1068 outputs
= sr_output_list();
1069 for (i
= 0; outputs
[i
]; i
++) {
1070 if (strcmp(outputs
[i
]->id
, fmtspec
))
1072 g_hash_table_remove(fmtargs
, "sigrok_key");
1073 output_format
= outputs
[i
];
1074 g_hash_table_iter_init(&iter
, fmtargs
);
1075 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
1076 /* only supporting one parameter per output module
1077 * for now, and only its value */
1078 output_format_param
= g_strdup(value
);
1083 if (!output_format
) {
1084 printf("invalid output format %s\n", opt_format
);
1090 else if (opt_list_devs
)
1092 else if (opt_input_file
)
1094 else if (opt_samples
|| opt_time
|| opt_continuous
)
1101 printf("%s", g_option_context_get_help(context
, TRUE
, NULL
));
1106 g_option_context_free(context
);
1107 g_hash_table_destroy(fmtargs
);