Use new trigger API.

diff --git a/parsers.c b/parsers.c
index 3df04e2a5da487803faf2459a0a3b8fd2711ab07..63a5acd424715b0d313827e9b6d622b7dd7429e2 100644 (file)
--- a/parsers.c
+++ b/parsers.c
@@ -153,6 +153,113 @@ range_fail:
        return channellist;
 }
 
+int parse_trigger_match(char c)
+{
+       int match;
+
+       if (c == '0')
+               match = SR_TRIGGER_ZERO;
+       else if (c == '1')
+               match = SR_TRIGGER_ONE;
+       else if (c == 'r')
+               match = SR_TRIGGER_RISING;
+       else if (c == 'f')
+               match = SR_TRIGGER_FALLING;
+       else if (c == 'e')
+               match = SR_TRIGGER_EDGE;
+       else if (c == 'o')
+               match = SR_TRIGGER_OVER;
+       else if (c == 'u')
+               match = SR_TRIGGER_UNDER;
+       else
+               match = 0;
+
+       return match;
+}
+
+int parse_triggerstring(const struct sr_dev_inst *sdi, const char *s)
+{
+       struct sr_channel *ch;
+       struct sr_trigger *trigger;
+       struct sr_trigger_stage *stage;
+       GVariant *gvar;
+       GSList *l;
+       gsize num_matches;
+       gboolean found_match, error;
+       const int32_t *matches;
+       int32_t match;
+       unsigned int j;
+       int t, i;
+       char **tokens, *sep;
+
+       if (sr_config_list(sdi->driver, sdi, NULL, SR_CONF_TRIGGER_MATCH,
+                       &gvar) != SR_OK) {
+               g_critical("Device doesn't support any triggers.");
+               return FALSE;
+       }
+       matches = g_variant_get_fixed_array(gvar, &num_matches, sizeof(int32_t));
+
+       trigger = sr_trigger_new(NULL);
+       error = FALSE;
+       tokens = g_strsplit(s, ",", -1);
+       for (i = 0; tokens[i]; i++) {
+               if (!(sep = strchr(tokens[i], '='))) {
+                       g_critical("Invalid trigger '%s'.", tokens[i]);
+                       error = TRUE;
+                       break;
+               }
+               *sep++ = 0;
+               ch = NULL;
+               for (l = sdi->channels; l; l = l->next) {
+                       ch = l->data;
+                       if (ch->enabled && !strcmp(ch->name, tokens[i]))
+                               break;
+                       ch = NULL;
+               }
+               if (!ch) {
+                       g_critical("Invalid channel '%s'.", tokens[i]);
+                       error = TRUE;
+                       break;
+               }
+               for (t = 0; sep[t]; t++) {
+                       if (!(match = parse_trigger_match(sep[t]))) {
+                               g_critical("Invalid trigger match '%c'.", sep[t]);
+                               error = TRUE;
+                               break;
+                       }
+                       found_match = FALSE;
+                       for (j = 0; j < num_matches; j++) {
+                               if (matches[j] == match) {
+                                       found_match = TRUE;
+                                       break;
+                               }
+                       }
+                       if (!found_match) {
+                               g_critical("Trigger match '%c' not supported by device.", sep[t]);
+                               error = TRUE;
+                               break;
+                       }
+                       /* Make sure this ends up in the right stage, creating
+                        * them as needed. */
+                       while (!(stage = g_slist_nth_data(trigger->stages, t)))
+                               sr_trigger_stage_new(trigger);
+                       if (sr_trigger_match_add(stage, ch, match, 0) != SR_OK) {
+                               error = TRUE;
+                               break;
+                       }
+               }
+       }
+       g_strfreev(tokens);
+       g_variant_unref(gvar);
+
+       if (error)
+               sr_trigger_free(trigger);
+       else
+               error = sr_session_trigger_set(trigger) != SR_OK;
+
+       return !error;
+}
+
 GHashTable *parse_generic_arg(const char *arg, gboolean sep_first)
 {
        GHashTable *hash;

diff --git a/session.c b/session.c
index 7d927b26423f436453ef80c2cdf19b4232370b44..27fa262135d757dec7235c89e546bc1d975ae3d0 100644 (file)
--- a/session.c
+++ b/session.c
@@ -457,8 +457,6 @@ void run_session(void)
        GVariant *gvar;
        struct sr_dev_inst *sdi;
        uint64_t min_samples, max_samples;
-       int max_channels, i;
-       char **triggerlist;
 
        devices = device_scan();
        if (!devices) {
@@ -500,18 +498,10 @@ void run_session(void)
        }
 
        if (opt_triggers) {
-               if (!(triggerlist = sr_parse_triggerstring(sdi, opt_triggers))) {
+               if (!parse_triggerstring(sdi, opt_triggers)) {
                        sr_session_destroy();
                        return;
                }
-               max_channels = g_slist_length(sdi->channels);
-               for (i = 0; i < max_channels; i++) {
-                       if (triggerlist[i]) {
-                               sr_dev_trigger_set(sdi, i, triggerlist[i]);
-                               g_free(triggerlist[i]);
-                       }
-               }
-               g_free(triggerlist);
        }
 
        if (opt_continuous) {

diff --git a/show.c b/show.c
index a10af0e685114829edecf97a54d5d48dff4a2ec9..bece7e641b957ea94bd2bb4ad9d1a538780660ad 100644 (file)
--- a/show.c
+++ b/show.c
@@ -208,11 +208,11 @@ void show_dev_detail(void)
        double dlow, dhigh, dcur_low, dcur_high;
        const uint64_t *uint64, p, q, low, high;
        uint64_t cur_low, cur_high;
-       const int32_t *opts;
+       const int32_t *int32, *opts;
        unsigned int num_devices, o, i;
        char *tmp_str;
-       char *s;
-       const char *charopts, **stropts;
+       char *s, c;
+       const char **stropts;
 
        if (!(devices = device_scan())) {
                g_critical("No devices found.");
@@ -284,20 +284,43 @@ void show_dev_detail(void)
                if (!(srci = sr_config_info_get(opts[o])))
                        continue;
 
-               if (srci->key == SR_CONF_TRIGGER_TYPE) {
+               if (srci->key == SR_CONF_TRIGGER_MATCH) {
                        if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
-                                       &gvar) != SR_OK) {
+                                       &gvar_list) != SR_OK) {
                                printf("\n");
                                continue;
                        }
-                       charopts = g_variant_get_string(gvar, NULL);
+                       int32 = g_variant_get_fixed_array(gvar_list,
+                                       &num_elements, sizeof(int32_t));
                        printf("    Supported triggers: ");
-                       while (*charopts) {
-                               printf("%c ", *charopts);
-                               charopts++;
+                       for (i = 0; i < num_elements; i++) {
+                               switch(int32[i]) {
+                               case SR_TRIGGER_ZERO:
+                                       c = '0';
+                                       break;
+                               case SR_TRIGGER_ONE:
+                                       c = '1';
+                                       break;
+                               case SR_TRIGGER_RISING:
+                                       c = 'r';
+                                       break;
+                               case SR_TRIGGER_FALLING:
+                                       c = 'f';
+                                       break;
+                               case SR_TRIGGER_EDGE:
+                                       c = 'e';
+                                       break;
+                               case SR_TRIGGER_OVER:
+                                       c = 'o';
+                                       break;
+                               case SR_TRIGGER_UNDER:
+                                       c = 'u';
+                                       break;
+                               }
+                               printf("%c ", c);
                        }
                        printf("\n");
-                       g_variant_unref(gvar);
+                       g_variant_unref(gvar_list);
 
                } else if (srci->key == SR_CONF_LIMIT_SAMPLES) {
                        /* If implemented in config_list(), this denotes the

diff --git a/sigrok-cli.h b/sigrok-cli.h
index 03e3136738f4e0059e8020b78cea3d5d8fc04889..2416b95f54e32d60b6ab22126a4a36cfc68579d3 100644 (file)
--- a/sigrok-cli.h
+++ b/sigrok-cli.h
@@ -70,6 +70,7 @@ void map_pd_channels(struct sr_dev_inst *sdi);
 /* parsers.c */
 struct sr_channel *find_channel(GSList *channellist, const char *channelname);
 GSList *parse_channelstring(struct sr_dev_inst *sdi, const char *channelstring);
+int parse_triggerstring(const struct sr_dev_inst *sdi, const char *s);
 GHashTable *parse_generic_arg(const char *arg, gboolean sep_first);
 int canon_cmp(const char *str1, const char *str2);