X-Git-Url: https://sigrok.org/gitweb/?p=libsigrokdecode.git;a=blobdiff_plain;f=decoders%2Ftiming%2Fpd.py;h=17ef5f17ff6e2eff632ec5a9c866199214ae2b5e;hp=64ba5666667999d6e9a0c5e150a0265206aaa6ad;hb=d6d8a8a440ea2a81e6ddde33d16bc84d01cdb432;hpb=831e976a72a74dfa71548091b4fa401713d74052

diff --git a/decoders/timing/pd.py b/decoders/timing/pd.py
index 64ba566..17ef5f1 100644
--- a/decoders/timing/pd.py
+++ b/decoders/timing/pd.py
@@ -15,8 +15,7 @@
 ## GNU General Public License for more details.
 ##
 ## You should have received a copy of the GNU General Public License
-## along with this program; if not, write to the Free Software
-## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+## along with this program; if not, see <http://www.gnu.org/licenses/>.
 ##
 
 import sigrokdecode as srd
@@ -26,19 +25,19 @@ class SamplerateError(Exception):
     pass
 
 def normalize_time(t):
-    if t >= 1.0:
+    if abs(t) >= 1.0:
         return '%.3f s  (%.3f Hz)' % (t, (1/t))
-    elif t >= 0.001:
+    elif abs(t) >= 0.001:
         if 1/t/1000 < 1:
             return '%.3f ms (%.3f Hz)' % (t * 1000.0, (1/t))
         else:
             return '%.3f ms (%.3f kHz)' % (t * 1000.0, (1/t)/1000)
-    elif t >= 0.000001:
+    elif abs(t) >= 0.000001:
         if 1/t/1000/1000 < 1:
             return '%.3f μs (%.3f kHz)' % (t * 1000.0 * 1000.0, (1/t)/1000)
         else:
             return '%.3f μs (%.3f MHz)' % (t * 1000.0 * 1000.0, (1/t)/1000/1000)
-    elif t >= 0.000000001:
+    elif abs(t) >= 0.000000001:
         if 1/t/1000/1000/1000:
             return '%.3f ns (%.3f MHz)' % (t * 1000.0 * 1000.0 * 1000.0, (1/t)/1000/1000)
         else:
@@ -55,27 +54,36 @@ class Decoder(srd.Decoder):
     license = 'gplv2+'
     inputs = ['logic']
     outputs = ['timing']
+    tags = ['Clock/timing', 'Util']
     channels = (
         {'id': 'data', 'name': 'Data', 'desc': 'Data line'},
     )
     annotations = (
         ('time', 'Time'),
         ('average', 'Average'),
+        ('delta', 'Delta'),
     )
     annotation_rows = (
         ('time', 'Time', (0,)),
         ('average', 'Average', (1,)),
+        ('delta', 'Delta', (2,)),
     )
     options = (
         { 'id': 'avg_period', 'desc': 'Averaging period', 'default': 100 },
+        { 'id': 'edge', 'desc': 'Edges to check', 'default': 'any', 'values': ('any', 'rising', 'falling') },
+        { 'id': 'delta', 'desc': 'Show delta from last', 'default': 'no', 'values': ('yes', 'no') },
     )
 
     def __init__(self):
+        self.reset()
+
+    def reset(self):
         self.samplerate = None
-        self.oldpin = None
         self.last_samplenum = None
         self.last_n = deque()
         self.chunks = 0
+        self.level_changed = False
+        self.last_t = None
 
     def metadata(self, key, value):
         if key == srd.SRD_CONF_SAMPLERATE:
@@ -83,43 +91,38 @@ class Decoder(srd.Decoder):
 
     def start(self):
         self.out_ann = self.register(srd.OUTPUT_ANN)
-        self.initial_pins = [0]
+        self.edge = self.options['edge']
 
     def decode(self):
         if not self.samplerate:
             raise SamplerateError('Cannot decode without samplerate.')
         while True:
-            pin = self.wait({0: 'e'})
+            if self.edge == 'rising':
+                pin = self.wait({0: 'r'})
+            elif self.edge == 'falling':
+                pin = self.wait({0: 'f'})
+            else:
+                pin = self.wait({0: 'e'})
 
-            if self.oldpin is None:
-                self.oldpin = pin
+            if not self.last_samplenum:
                 self.last_samplenum = self.samplenum
                 continue
+            samples = self.samplenum - self.last_samplenum
+            t = samples / self.samplerate
 
-            if self.oldpin != pin:
-                samples = self.samplenum - self.last_samplenum
-                t = samples / self.samplerate
-                self.chunks += 1
-
-                # Don't insert the first chunk into the averaging as it is
-                # not complete probably.
-                if self.last_samplenum is None or self.chunks < 2:
-                    # Report the timing normalized.
-                    self.put(self.last_samplenum, self.samplenum, self.out_ann,
-                             [0, [normalize_time(t)]])
-                else:
-                    if t > 0:
-                        self.last_n.append(t)
+            if t > 0:
+                self.last_n.append(t)
+            if len(self.last_n) > self.options['avg_period']:
+                self.last_n.popleft()
 
-                    if len(self.last_n) > self.options['avg_period']:
-                        self.last_n.popleft()
+            self.put(self.last_samplenum, self.samplenum, self.out_ann,
+                     [0, [normalize_time(t)]])
+            if self.options['avg_period'] > 0:
+                self.put(self.last_samplenum, self.samplenum, self.out_ann,
+                         [1, [normalize_time(sum(self.last_n) / len(self.last_n))]])
+            if self.last_t and self.options['delta'] == 'yes':
+                self.put(self.last_samplenum, self.samplenum, self.out_ann,
+                         [2, [normalize_time(t - self.last_t)]])
 
-                    # Report the timing normalized.
-                    self.put(self.last_samplenum, self.samplenum, self.out_ann,
-                             [0, [normalize_time(t)]])
-                    self.put(self.last_samplenum, self.samplenum, self.out_ann,
-                             [1, [normalize_time(sum(self.last_n) / len(self.last_n))]])
-
-                # Store data for next round.
-                self.last_samplenum = self.samplenum
-                self.oldpin = pin
+            self.last_t = t
+            self.last_samplenum = self.samplenum