parallel: symbolic names for pins and annotation classes

[libsigrokdecode.git] / decoders / parallel / pd.py

diff --git a/decoders/parallel/pd.py b/decoders/parallel/pd.py
index 364332a3688bba38ec09c5d88a1303b53cacbd98..dd356b4063e8d1ba09165c76be2e41b0cae5ed60 100644 (file)
--- a/decoders/parallel/pd.py
+++ b/decoders/parallel/pd.py
@@ -54,9 +54,18 @@ Packet:
    word <worditemcount> is 7, and so on.
 '''
 
-def channel_list(num_channels):
+NUM_CHANNELS = 8
+
+class Pin:
+    CLOCK = 0
+    DATA = range(1, NUM_CHANNELS + 1)
+
+class Ann:
+    ITEM, WORD = range(2)
+
+def channel_list():
     l = [{'id': 'clk', 'name': 'CLK', 'desc': 'Clock line'}]
-    for i in range(num_channels):
+    for i in range(NUM_CHANNELS):
         d = {'id': 'd%d' % i, 'name': 'D%d' % i, 'desc': 'Data line %d' % i}
         l.append(d)
     return tuple(l)
@@ -64,8 +73,6 @@ def channel_list(num_channels):
 class ChannelError(Exception):
     pass
 
-NUM_CHANNELS = 8
-
 class Decoder(srd.Decoder):
     api_version = 3
     id = 'parallel'
@@ -75,21 +82,23 @@ class Decoder(srd.Decoder):
     license = 'gplv2+'
     inputs = ['logic']
     outputs = ['parallel']
-    optional_channels = channel_list(NUM_CHANNELS)
+    tags = ['Util']
+    optional_channels = channel_list()
     options = (
         {'id': 'clock_edge', 'desc': 'Clock edge to sample on',
             'default': 'rising', 'values': ('rising', 'falling')},
-        {'id': 'wordsize', 'desc': 'Data wordsize', 'default': 0},
+        {'id': 'wordsize', 'desc': 'Data wordsize (# bus cycles)',
+            'default': 0},
         {'id': 'endianness', 'desc': 'Data endianness',
             'default': 'little', 'values': ('little', 'big')},
     )
     annotations = (
-        ('items', 'Items'),
-        ('words', 'Words'),
+        ('item', 'Item'),
+        ('word', 'Word'),
     )
     annotation_rows = (
-        ('items', 'Items', (0,)),
-        ('words', 'Words', (1,)),
+        ('items', 'Items', (Ann.ITEM,)),
+        ('words', 'Words', (Ann.WORD,)),
     )
 
     def __init__(self):
@@ -126,7 +135,7 @@ class Decoder(srd.Decoder):
         if self.saved_word is not None:
             if self.options['wordsize'] > 0:
                 self.es_word = self.samplenum
-                self.putw([1, ['%X' % self.saved_word]])
+                self.putw([Ann.WORD, [self.fmt_word.format(self.saved_word)]])
                 self.putpw(['WORD', self.saved_word])
             self.saved_word = None
 
@@ -142,7 +151,7 @@ class Decoder(srd.Decoder):
             # Output the saved item (from the last CLK edge to the current).
             self.es_item = self.samplenum
             self.putpb(['ITEM', self.saved_item])
-            self.putb([0, ['%X' % self.saved_item]])
+            self.putb([Ann.ITEM, [self.fmt_item.format(self.saved_item)]])
             self.ss_item = self.samplenum
             self.saved_item = item
 
@@ -176,23 +185,36 @@ class Decoder(srd.Decoder):
         if not has_channels:
             raise ChannelError('At least one channel has to be supplied.')
         max_connected = max(has_channels)
-        idx_strip = max_connected + 1
 
         # Determine .wait() conditions, depending on the presence of a
         # clock signal. Either inspect samples on the configured edge of
         # the clock, or inspect samples upon ANY edge of ANY of the pins
         # which provide input data.
-        if self.has_channel(0):
+        has_clock = self.has_channel(Pin.CLOCK)
+        if has_clock:
             edge = self.options['clock_edge'][0]
-            conds = {0: edge}
+            conds = [{Pin.CLOCK: edge}]
         else:
             conds = [{idx: 'e'} for idx in has_channels]
 
+        # Pre-determine which input data to strip off, the width of
+        # individual items and multiplexed words, as well as format
+        # strings here. This simplifies call sites which run in tight
+        # loops later.
+        idx_strip = max_connected + 1
+        num_item_bits = idx_strip - 1
+        num_word_items = self.options['wordsize']
+        num_word_bits = num_item_bits * num_word_items
+        num_digits = (num_item_bits + 3) // 4
+        self.fmt_item = "{{:0{}x}}".format(num_digits)
+        num_digits = (num_word_bits + 3) // 4
+        self.fmt_word = "{{:0{}x}}".format(num_digits)
+
         # Keep processing the input stream. Assume "always zero" for
         # not-connected input lines. Pass data bits (all inputs except
         # clock) to the handle_bits() method.
         while True:
             pins = self.wait(conds)
             bits = [0 if idx is None else pins[idx] for idx in idx_channels]
-            bits = bits[1:idx_strip]
-            self.handle_bits(bitpack(bits), len(bits))
+            item = bitpack(bits[Pin.DATA[0]:idx_strip])
+            self.handle_bits(item, num_item_bits)