srd: decoders: Metadata consistency fixes/updates.

[libsigrokdecode.git] / decoders / transitioncounter.py

diff --git a/decoders/transitioncounter.py b/decoders/transitioncounter.py
index d3fa73273223e426657edc9c295f9420ec9f9a44..40fa3a899041420269d91e4f156c8a3dc3c1697f 100644 (file)
--- a/decoders/transitioncounter.py
+++ b/decoders/transitioncounter.py
@@ -18,86 +18,83 @@
 ## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 ##
 
-import sigrok
-
-lastsample = None
-oldbit = None
-transitions = None
-rising = None
-falling = None
-
-def decode(sampledata):
-    """Counts the low->high and high->low transitions in the specified
-       channel(s) of the signal."""
-    global lastsample
-    global oldbit, transitions, rising, falling
-
-    # TODO: Don't hardcode the number of channels.
-    channels = 8
-
-    # FIXME: Get the data in the correct format in the first place.
-    inbuf = [ord(x) for x in sampledata['data']]
-
-    if lastsample == None:
-        oldbit = [0] * channels
-        transitions = [0] * channels
-        rising = [0] * channels
-        falling = [0] * channels
-
-        # Initial values.
-        lastsample = inbuf[0]
-        for i in range(channels):
-            oldbit[i] = (lastsample & (1 << i)) >> i
-
-    # TODO: Handle LAs with more/less than 8 channels.
-    for s in inbuf:
-        # Optimization: Skip identical bytes (no transitions).
-        if lastsample != s:
-            for i in range(channels):
-                curbit = (s & (1 << i)) >> i
+import sigrokdecode as srd
+
+class Decoder(srd.Decoder):
+    id = 'transitioncounter'
+    name = 'Transition counter'
+    longname = '...'
+    desc = 'Counts rising/falling edges in the signal.'
+    longdesc = '...'
+    author = 'Uwe Hermann'
+    email = 'uwe@hermann-uwe.de'
+    license = 'gplv2+'
+    inputs = ['logic']
+    outputs = ['transitioncounts']
+    probes = []
+    options = {}
+    annotations = []
+
+    def __init__(self, **kwargs):
+        self.channels = -1
+        self.lastsample = None
+
+    def start(self, metadata):
+        # self.out_proto = self.add(srd.OUTPUT_PROTO, 'transitioncounter')
+        self.out_ann = self.add(srd.OUTPUT_ANN, 'transitioncounter')
+
+    def report(self):
+        pass
+
+    def decode(self, timeoffset, duration, data):
+
+        for (samplenum, s) in data:
+
+            # ...
+            if self.channels == -1:
+                self.channels = len(s)
+                self.oldbit = [0] * self.channels
+                self.transitions = [0] * self.channels
+                self.rising = [0] * self.channels
+                self.falling = [0] * self.channels
+
+            # Optimization: Skip identical samples (no transitions).
+            if self.lastsample == s:
+                continue
+
+            # Upon the first sample, store the initial values.
+            if self.lastsample == None:
+                self.lastsample = s
+                for i in range(self.channels):
+                    self.oldbit[i] = self.lastsample[i]
+
+            # Iterate over all channels/probes in this sample.
+            # Count rising and falling edges for each channel.
+            for i in range(self.channels):
+                curbit = s[i]
                 # Optimization: Skip identical bits (no transitions).
-                if oldbit[i] == curbit:
+                if self.oldbit[i] == curbit:
                     continue
-                elif (oldbit[i] == 0 and curbit == 1):
-                    rising[i] += 1
-                elif (oldbit[i] == 1 and curbit == 0):
-                    falling[i] += 1
-                oldbit[i] = curbit
-
-            # Total number of transitions is the sum of rising and falling edges.
-            for i in range(channels):
-                transitions[i] = rising[i] + falling[i]
-
-            lastsample = s
-            print(transitions)
-
-    sigrok.put(sampledata)
-
-register = {
-    'id': 'transitioncounter',
-    'name': 'Transition counter',
-    'longname': '...',
-    'desc': 'Counts rising/falling edges in the signal.',
-    'longdesc': '...',
-    'author': 'Uwe Hermann',
-    'email': 'uwe@hermann-uwe.de',
-    'license': 'gplv2+',
-    'in': ['logic'],
-    'out': ['transitioncounts'],
-    'probes': [
-        # All probes.
-    ],
-    'options': {
-        # No options so far.
-    },
-    # 'start': start,
-    # 'report': report,
-}
-
-# Use psyco (if available) as it results in huge performance improvements.
-try:
-    import psyco
-    psyco.bind(decode)
-except ImportError:
-    pass
+                elif (self.oldbit[i] == 0 and curbit == 1):
+                    self.rising[i] += 1
+                elif (self.oldbit[i] == 1 and curbit == 0):
+                    self.falling[i] += 1
+                self.oldbit[i] = curbit
+
+            # Save the current sample as 'lastsample' for the next round.
+            self.lastsample = s
+
+        # Total number of transitions = rising + falling edges.
+        for i in range(self.channels):
+            self.transitions[i] = self.rising[i] + self.falling[i]
+
+        # TODO: Which output format?
+        # TODO: How to only output something after the last chunk of data?
+        outdata = []
+        for i in range(self.channels):
+            outdata += [[self.transitions[i], self.rising[i], self.falling[i]]]
+
+        if outdata != []:
+            # self.put(0, 0, self.out_proto, out_proto)
+            self.put(0, 0, self.out_ann, outdata)