[sigrok-devel] Python decoder: finding signal transition "in the future" without changing samplenum?

[sdbbs <sd...@br...>]

Typically, in a Python protocol decoder plugin for sigrok, we can find where a signal transition happened, by using self.wait, e.g:

```
# let's say our signal 0 is in "HIGH" level/state now, and self.samplenum is 0
# we want to find transition to low, so we use self.wait:

(mysig,) = self.wait({0: 'l'})

# after self.wait returns, self.samplenum is (say) at 1000, first sample location away from 0 which has a "LOW" level/state
```

However, as the example notes, self.wait also manipulates self.samplenum; and it is noted:

https://sigrok.org/wiki/Protocol_decoder_API/Queries

> self.samplenum is a special attribute that is read-only for the protocol decoder and should only be set by the libsigrokdecode backend. 


So, this is the problem I have:

Let's say, I'm at the (first) low bit, right after a transition from HIGH to LOW; let's say samplenum here ("now") is 1000.

If the next transition LOW to HIGH happens in less than 1000 samples duration, then I should decode (serial) bits - meaning I have to read sample-by-sample into an accumulator, find the average to determine final bit value (let's say a "bit" takes 10 samples in my signal data), and emit (PulseView) annotation for each bit, starting from "now" (samplenum=1000).

However, if the next transition LOW to HIGH happens in more than 1000 samples, then I should *not* decode bits - instead I should have a single annotation from "now" (samplenum 1000) to wherever the "next" transition is, and I should proceed in a different state (other than "decode bits") after the "next" transition happens.

Easiest for me, was to have a "CHECK NEXT STATE" state, as in:

```
if self.state == 'CHECK NEXT STATE':
     # we should be in low state here, - so we wait for a high transition
     (mysig,) = self.wait({0: 'h'})
     # we have a new samplenum here, for the transition; calc the duration
     runlen = (self.samplenum - self.run_start)
     # if runlen is >= 1000, declare SOMETHING ELSE state
     if runlen >= 1000:
         self.state = 'SOMETHING ELSE'
     else:
         self.state = 'DECODE BITS'
         # "rewind", so the state detection works:
         self.samplenum = self.run_start - 1
         self.run_start = self.samplenum
```

... which sorta makes sense in general; except, its impossible to "rewind" self.samplenum - as it is read only!


Right now, when I hit a situation where 'SOMETHING ELSE' should be declared, I just get a bunch of wrongly decoded bits in PulseView instead, because I do the 'DECODE BITS' explicitly each time - which I do not want.

I guess, I could still do the 'DECODE BITS' with the faulty bits, and once enough time (1000 samples) have passed, checked whether the state changes from last 'CHECK NEXT STATE' - and if it didn't, then erase all annotations added by the last 'DECODE BITS' ... but I cannot tell how to erase *only* those annotations !?

So, how is something like this - that is, "peeking"/finding signal transitions into the "future" from "now" (that is, current samplenum), without changing samplenum - meant to be handled in a Python protocol decoder for sigrok/pulseview?