X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;f=decoders%2Fcaliper%2Fpd.py;h=20a2a5555d01d735df723d0f0b8ef8c42ab80f92;hb=4f4e035397fa0770d47bf8b663e87651e0709511;hp=404e830ac1078ba2f37e85ab2972715b5631f429;hpb=b213c0461126495175aaa36fba85f50606594e39;p=libsigrokdecode.git

diff --git a/decoders/caliper/pd.py b/decoders/caliper/pd.py
index 404e830..20a2a55 100644
--- a/decoders/caliper/pd.py
+++ b/decoders/caliper/pd.py
@@ -22,6 +22,10 @@
 ## SOFTWARE.
 
 import sigrokdecode as srd
+from common.srdhelper import bitpack
+
+# Millimeters per inch.
+mm_per_inch = 25.4
 
 class Decoder(srd.Decoder):
     api_version = 3
@@ -62,10 +66,9 @@ class Decoder(srd.Decoder):
         self.reset()
 
     def reset(self):
-        self.ss_cmd, self.es_cmd = 0, 0
-        self.bits = 0
-        self.number = 0
-        self.flags = 0
+        self.ss, self.es = 0, 0
+        self.number_bits = []
+        self.flags_bits = []
 
     def start(self):
         self.out_ann = self.register(srd.OUTPUT_ANN)
@@ -73,89 +76,71 @@ class Decoder(srd.Decoder):
     def putg(self, ss, es, cls, data):
         self.put(ss, es, self.out_ann, [cls, data])
 
-    # Switch bit order of variable x, which is l bit long.
-    def bitr(self, x, l):
-        return int(bin(x)[2:].zfill(l)[::-1], 2)
-
     def decode(self):
-        last_measurement = None
+        last_sent = None
         timeout_ms = self.options['timeout_ms']
         want_unit = self.options['unit']
         show_all = self.options['changes'] == 'no'
-        snum_per_ms = self.samplerate / 1000
-        timeout_snum = timeout_ms * snum_per_ms
+        wait_cond = [{0: 'r'}]
+        if timeout_ms:
+            snum_per_ms = self.samplerate / 1000
+            timeout_snum = timeout_ms * snum_per_ms
+            wait_cond.append({'skip': round(timeout_snum)})
         while True:
-            clk, data = self.wait([{0: 'r'}, {'skip': round(snum_per_ms)}])
-
-            # Timeout after inactivity.
-            if timeout_ms > 0:
-                if self.samplenum > self.es_cmd + timeout_snum:
-                    if self.bits > 0:
-                        self.putg(self.ss_cmd, self.samplenum, 1, [
-                            'timeout with %s bits in buffer' % (self.bits),
-                            'timeout',
-                        ])
-                    self.reset()
-
-            # Do nothing if there was timeout without rising clock edge.
-            if self.matched == (False, True):
+            # Sample data at the rising clock edge. Optionally timeout
+            # after inactivity for a user specified period. Present the
+            # number of unprocessed bits to the user for diagnostics.
+            clk, data = self.wait(wait_cond)
+            if timeout_ms and not self.matched[0]:
+                if self.number_bits or self.flags_bits:
+                    count = len(self.number_bits) + len(self.flags_bits)
+                    self.putg(self.ss, self.samplenum, 1, [
+                        'timeout with {} bits in buffer'.format(count),
+                        'timeout ({} bits)'.format(count),
+                        'timeout',
+                    ])
+                self.reset()
                 continue
 
-            # Store position of last activity.
-            self.es_cmd = self.samplenum
-
-            # Store position of first bit.
-            if self.ss_cmd == 0:
-                self.ss_cmd = self.samplenum
-
-            # Shift in measured number.
-            if self.bits < 16:
-                self.number = (self.number << 1) | (data & 0b1)
-                self.bits += 1
+            # Store position of first bit and last activity.
+            # Shift in measured number and flag bits.
+            if not self.ss:
+                self.ss = self.samplenum
+            self.es = self.samplenum
+            if len(self.number_bits) < 16:
+                self.number_bits.append(data)
                 continue
-
-            # Shift in flag bits.
-            if self.bits < 24:
-                self.flags = (self.flags << 1) | (data & 0b1)
-                self.bits += 1
-                if self.bits < 24:
+            if len(self.flags_bits) < 8:
+                self.flags_bits.append(data)
+                if len(self.flags_bits) < 8:
                     continue
-                # We got last bit of data.
-                self.es_cmd = self.samplenum
-
-            # Do actual decoding.
 
-            negative = ((self.flags & 0b00001000) >> 3)
-            inch = (self.flags & 0b00000001)
-
-            number = self.bitr(self.number, 16)
-
-            if negative > 0:
+            # Get raw values from received data bits. Run the number
+            # conversion, controlled by flags and/or user specs.
+            negative = bool(self.flags_bits[4])
+            is_inch = bool(self.flags_bits[7])
+            number = bitpack(self.number_bits)
+            if negative:
                 number = -number
-
-            inchmm = 25.4 #how many mms in inch
-
-            if inch:
-                number = number / 2000
+            if is_inch:
+                number /= 2000
                 if want_unit == 'mm':
-                    number *= inchmm
-                    inch = 0
+                    number *= mm_per_inch
+                    is_inch = False
             else:
-                number = number / 100
+                number /= 100
                 if want_unit == 'inch':
-                    number = round(number / inchmm, 4)
-                    inch = 1
-
-            units = "in" if inch else "mm"
-
-            measurement = (str(number) + units)
-
-            if show_all or measurement != last_measurement:
-                self.putg(self.ss_cmd, self.es_cmd, 0, [
-                    measurement,
-                    str(number),
+                    number = round(number / mm_per_inch, 4)
+                    is_inch = True
+            unit = 'in' if is_inch else 'mm'
+
+            # Construct and emit an annotation.
+            if show_all or (number, unit) != last_sent:
+                self.putg(self.ss, self.es, 0, [
+                    '{number}{unit}'.format(**locals()),
+                    '{number}'.format(**locals()),
                 ])
-                last_measurement = measurement
+                last_sent = (number, unit)
 
-            # Prepare for next packet.
+            # Reset internal state for the start of the next packet.
             self.reset()