some white space changes, changed handling of normal/overdrive timing, annotations...

diff --git a/decoders/onewire/__init__.py b/decoders/onewire/__init__.py
index b58dde707e9020c2aed610fadda39aeb63758a7f..c43dabc4184dd9eb38471a82af7e78005f3d91f0 100644 (file)
--- a/decoders/onewire/__init__.py
+++ b/decoders/onewire/__init__.py
@@ -29,6 +29,13 @@ layered, the provided parser decodes the next layers:
 The higher layers (transport, presentation) are not decoded, since they are
 mostly device specific and it would take a lot of code to interpret them.
 
 The higher layers (transport, presentation) are not decoded, since they are
 mostly device specific and it would take a lot of code to interpret them.
 

+Sample rate:
+A high enough sample rate is required to properly detect all the elements of
+the protocol. A lower sample rate can be used if the master does not use
+overdrive communication speed. The next minimal values should be used:
+- overdrive     available:   2MHz minimum, 5MHz suggested
+- overdrive not available: 400kHz minimum, 1MHz suggested
+

 Probes:
 1-Wire requires a single signal, but some master implementations might have a
 separate signal use to deliver power to the bus during temperature conversion
 Probes:
 1-Wire requires a single signal, but some master implementations might have a
 separate signal use to deliver power to the bus during temperature conversion


@@ -60,10 +67,10 @@ If link layer annotations are shown, possible issues with sample rate and sample
 timing are also shown.
 
 TODO:
 timing are also shown.
 
 TODO:

-- fix annotations to have event duration instead of begin end time

 - add CRC checks for network layer
 - add transport layer code
 - review link layer code, to check for protocol correctness
 - add CRC checks for network layer
 - add transport layer code
 - review link layer code, to check for protocol correctness

+- define output protocol

 '''
 
 from .onewire import *
 '''
 
 from .onewire import *

diff --git a/decoders/onewire/onewire.py b/decoders/onewire/onewire.py
index b8e5041cb96310214a22c5767dbcbcc668831062..6e5344fea3dad2bf0079009fdfb2992681fd1383 100644 (file)
--- a/decoders/onewire/onewire.py
+++ b/decoders/onewire/onewire.py
@@ -81,6 +81,7 @@ class Decoder(srd.Decoder):
         self.lnk_rise    = 0
         self.net_beg     = 0
         self.net_end     = 0
         self.lnk_rise    = 0
         self.net_beg     = 0
         self.net_end     = 0

+        self.net_len     = 0

         # Network layer variables
         self.net_state   = 'IDLE'
         self.net_cnt     = 0
         # Network layer variables
         self.net_state   = 'IDLE'
         self.net_cnt     = 0


@@ -97,49 +98,85 @@ class Decoder(srd.Decoder):
         # check if samplerate is appropriate
         self.samplerate = metadata['samplerate']
         if (self.options['overdrive']):
         # check if samplerate is appropriate
         self.samplerate = metadata['samplerate']
         if (self.options['overdrive']):

-            self.put(0, 0, self.out_ann, [ANN_LINK, ['NOTE: Sample rate checks assume overdrive mode.']])
+            self.put(0, 0, self.out_ann, [ANN_LINK,
+              ['NOTE: Sample rate checks assume overdrive mode.']])

             if   (self.samplerate < 2000000):
             if   (self.samplerate < 2000000):

-                self.put(0, 0, self.out_ann, [ANN_LINK, ['ERROR: Sampling rate is too low must be above 2MHz for proper overdrive mode decoding.']])
+                self.put(0, 0, self.out_ann, [ANN_LINK,
+                  ['ERROR: Sampling rate is too low must be above 2MHz for proper overdrive mode decoding.']])

             elif (self.samplerate < 5000000):
             elif (self.samplerate < 5000000):

-                self.put(0, 0, self.out_ann, [ANN_LINK, ['WARNING: Sampling rate is suggested to be above 5MHz for proper overdrive mode decoding.']])
+                self.put(0, 0, self.out_ann, [ANN_LINK,
+                  ['WARNING: Sampling rate is suggested to be above 5MHz for proper overdrive mode decoding.']])

         else:
         else:

-            self.put(0, 0, self.out_ann, [ANN_LINK, ['NOTE: Sample rate checks assume normal mode only.']])
+            self.put(0, 0, self.out_ann, [ANN_LINK,
+              ['NOTE: Sample rate checks assume normal mode only.']])

             if   (self.samplerate <  400000):
             if   (self.samplerate <  400000):

-                self.put(0, 0, self.out_ann, [ANN_LINK, ['ERROR: Sampling rate is too low must be above 400kHz for proper normal mode decoding.']])
+                self.put(0, 0, self.out_ann, [ANN_LINK,
+                  ['ERROR: Sampling rate is too low must be above 400kHz for proper normal mode decoding.']])

             elif (self.samplerate < 1000000):
             elif (self.samplerate < 1000000):

-                self.put(0, 0, self.out_ann, [ANN_LINK, ['WARNING: Sampling rate is suggested to be above 1MHz for proper normal mode decoding.']])
+                self.put(0, 0, self.out_ann, [ANN_LINK,
+                  ['WARNING: Sampling rate is suggested to be above 1MHz for proper normal mode decoding.']])

 
         # The default 1-Wire time base is 30us, this is used to calculate sampling times.
 
         # The default 1-Wire time base is 30us, this is used to calculate sampling times.

-        if (self.options['cnt_normal_bit']):      self.cnt_normal_bit      = self.options['cnt_normal_bit']
-        else:                                     self.cnt_normal_bit      = int(float(self.samplerate) * 0.000015) - 1 # 15ns
-        if (self.options['cnt_normal_presence']): self.cnt_normal_presence = self.options['cnt_normal_presence']
-        else:                                     self.cnt_normal_presence = int(float(self.samplerate) * 0.000075) - 1 # 75ns
-        if (self.options['cnt_normal_reset']):    self.cnt_normal_reset    = self.options['cnt_normal_reset']
-        else:                                     self.cnt_normal_reset    = int(float(self.samplerate) * 0.000480) - 1 # 480ns
-        if (self.options['cnt_overdrive_bit']):      self.cnt_overdrive_bit      = self.options['cnt_overdrive_bit']
-        else:                                        self.cnt_overdrive_bit      = int(float(self.samplerate) * 0.000002) - 1 # 2ns
-        if (self.options['cnt_overdrive_presence']): self.cnt_overdrive_presence = self.options['cnt_overdrive_presence']
-        else:                                        self.cnt_overdrive_presence = int(float(self.samplerate) * 0.000010) - 1 # 10ns
-        if (self.options['cnt_overdrive_reset']):    self.cnt_overdrive_reset    = self.options['cnt_overdrive_reset']
-        else:                                        self.cnt_overdrive_reset    = int(float(self.samplerate) * 0.000048) - 1 # 48ns
+        if (self.options['cnt_normal_bit']):
+            self.cnt_normal_bit = self.options['cnt_normal_bit']
+        else:
+            self.cnt_normal_bit = int(float(self.samplerate) * 0.000015) - 1 # 15ns
+        if (self.options['cnt_normal_presence']):
+            self.cnt_normal_presence = self.options['cnt_normal_presence']
+        else:
+            self.cnt_normal_presence = int(float(self.samplerate) * 0.000075) - 1 # 75ns
+        if (self.options['cnt_normal_reset']):
+            self.cnt_normal_reset = self.options['cnt_normal_reset']
+        else:
+            self.cnt_normal_reset = int(float(self.samplerate) * 0.000480) - 1 # 480ns
+        if (self.options['cnt_overdrive_bit']):
+            self.cnt_overdrive_bit = self.options['cnt_overdrive_bit']
+        else:
+            self.cnt_overdrive_bit = int(float(self.samplerate) * 0.000002) - 1 # 2ns
+        if (self.options['cnt_overdrive_presence']):
+            self.cnt_overdrive_presence = self.options['cnt_overdrive_presence']
+        else:
+            self.cnt_overdrive_presence = int(float(self.samplerate) * 0.000010) - 1 # 10ns
+        if (self.options['cnt_overdrive_reset']):
+            self.cnt_overdrive_reset = self.options['cnt_overdrive_reset']
+        else:
+            self.cnt_overdrive_reset = int(float(self.samplerate) * 0.000048) - 1 # 48ns
+
+        # calculating the slot size
+        self.cnt_normal_slot    = int(float(self.samplerate) * 0.000060) - 1 # 60ns
+        self.cnt_overdrive_slot = int(float(self.samplerate) * 0.000006) - 1 #  6ns
+
+        # organize values into lists
+        self.cnt_bit      = [self.cnt_normal_bit     , self.cnt_overdrive_bit     ]
+        self.cnt_presence = [self.cnt_normal_presence, self.cnt_overdrive_presence]
+        self.cnt_reset    = [self.cnt_normal_reset   , self.cnt_overdrive_reset   ]
+        self.cnt_slot     = [self.cnt_normal_slot    , self.cnt_overdrive_slot    ]

 
         # Check if sample times are in the allowed range
         time_min = float(self.cnt_normal_bit  ) / self.samplerate
         time_max = float(self.cnt_normal_bit+1) / self.samplerate
         if ( (time_min < 0.000005) or (time_max > 0.000015) ) :
 
         # Check if sample times are in the allowed range
         time_min = float(self.cnt_normal_bit  ) / self.samplerate
         time_max = float(self.cnt_normal_bit+1) / self.samplerate
         if ( (time_min < 0.000005) or (time_max > 0.000015) ) :

-           self.put(0, 0, self.out_ann, [ANN_LINK, ['WARNING: The normal mode data sample time interval (%2.1fus-%2.1fus) should be inside (5.0us, 15.0us).' % (time_min*1000000, time_max*1000000)]])
+           self.put(0, 0, self.out_ann, [ANN_LINK,
+             ['WARNING: The normal mode data sample time interval (%2.1fus-%2.1fus) should be inside (5.0us, 15.0us).'
+               % (time_min*1000000, time_max*1000000)]])

         time_min = float(self.cnt_normal_presence  ) / self.samplerate
         time_max = float(self.cnt_normal_presence+1) / self.samplerate
         if ( (time_min < 0.0000681) or (time_max > 0.000075) ) :
         time_min = float(self.cnt_normal_presence  ) / self.samplerate
         time_max = float(self.cnt_normal_presence+1) / self.samplerate
         if ( (time_min < 0.0000681) or (time_max > 0.000075) ) :

-           self.put(0, 0, self.out_ann, [ANN_LINK, ['WARNING: The normal mode presence sample time interval (%2.1fus-%2.1fus) should be inside (68.1us, 75.0us).' % (time_min*1000000, time_max*1000000)]])
+           self.put(0, 0, self.out_ann, [ANN_LINK,
+             ['WARNING: The normal mode presence sample time interval (%2.1fus-%2.1fus) should be inside (68.1us, 75.0us).'
+               % (time_min*1000000, time_max*1000000)]])

         time_min = float(self.cnt_overdrive_bit  ) / self.samplerate
         time_max = float(self.cnt_overdrive_bit+1) / self.samplerate
         if ( (time_min < 0.000001) or (time_max > 0.000002) ) :
         time_min = float(self.cnt_overdrive_bit  ) / self.samplerate
         time_max = float(self.cnt_overdrive_bit+1) / self.samplerate
         if ( (time_min < 0.000001) or (time_max > 0.000002) ) :

-           self.put(0, 0, self.out_ann, [ANN_LINK, ['WARNING: The overdrive mode data sample time interval (%2.1fus-%2.1fus) should be inside (1.0us, 2.0us).' % (time_min*1000000, time_max*1000000)]])
+           self.put(0, 0, self.out_ann, [ANN_LINK,
+             ['WARNING: The overdrive mode data sample time interval (%2.1fus-%2.1fus) should be inside (1.0us, 2.0us).'
+               % (time_min*1000000, time_max*1000000)]])

         time_min = float(self.cnt_overdrive_presence  ) / self.samplerate
         time_max = float(self.cnt_overdrive_presence+1) / self.samplerate
         if ( (time_min < 0.0000073) or (time_max > 0.000010) ) :
         time_min = float(self.cnt_overdrive_presence  ) / self.samplerate
         time_max = float(self.cnt_overdrive_presence+1) / self.samplerate
         if ( (time_min < 0.0000073) or (time_max > 0.000010) ) :

-           self.put(0, 0, self.out_ann, [ANN_LINK, ['WARNING: The overdrive mode presence sample time interval (%2.1fus-%2.1fus) should be inside (7.3us, 10.0us).' % (time_min*1000000, time_max*1000000)]])
+           self.put(0, 0, self.out_ann, [ANN_LINK,
+             ['WARNING: The overdrive mode presence sample time interval (%2.1fus-%2.1fus) should be inside (7.3us, 10.0us).'
+               % (time_min*1000000, time_max*1000000)]])

 
     def report(self):
         pass
 
     def report(self):
         pass


@@ -161,14 +198,12 @@ class Decoder(srd.Decoder):
                     self.lnk_state = 'WAIT FOR DATA SAMPLE'
             elif self.lnk_state == 'WAIT FOR DATA SAMPLE':
                 # Sample data bit
                     self.lnk_state = 'WAIT FOR DATA SAMPLE'
             elif self.lnk_state == 'WAIT FOR DATA SAMPLE':
                 # Sample data bit

-                if (self.lnk_overdrive): cnt = self.cnt_overdrive_bit
-                else                   : cnt = self.cnt_normal_bit
-                if (self.samplenum - self.lnk_fall == cnt):
+                if (self.samplenum - self.lnk_fall == self.cnt_bit[self.lnk_overdrive]):

                     self.lnk_bit  = owr & 0x1
                     self.lnk_event = "DATA BIT"
                     if (self.lnk_bit):  self.lnk_state = 'WAIT FOR FALLING EDGE'
                     else             :  self.lnk_state = 'WAIT FOR RISING EDGE'
                     self.lnk_bit  = owr & 0x1
                     self.lnk_event = "DATA BIT"
                     if (self.lnk_bit):  self.lnk_state = 'WAIT FOR FALLING EDGE'
                     else             :  self.lnk_state = 'WAIT FOR RISING EDGE'

-                    self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_LINK, ['BIT: %01x' % self.lnk_bit]])
+                    self.put(self.lnk_fall, self.cnt_bit[self.lnk_overdrive], self.out_ann, [ANN_LINK, ['BIT: %01x' % self.lnk_bit]])

             elif self.lnk_state == 'WAIT FOR RISING EDGE':
                 # The end of a cycle is a rising edge.
                 if (owr == 1):
             elif self.lnk_state == 'WAIT FOR RISING EDGE':
                 # The end of a cycle is a rising edge.
                 if (owr == 1):


@@ -179,9 +214,9 @@ class Decoder(srd.Decoder):
                         # Send a reset event to the next protocol layer.
                         self.lnk_event = "RESET"
                         self.lnk_state = "WAIT FOR PRESENCE DETECT"
                         # Send a reset event to the next protocol layer.
                         self.lnk_event = "RESET"
                         self.lnk_state = "WAIT FOR PRESENCE DETECT"

-                        self.put(self.lnk_fall, self.samplenum, self.out_proto, ['RESET'])
-                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_LINK     , ['RESET']])
-                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK  , ['RESET']])
+                        self.put(self.lnk_fall, self.lnk_rise, self.out_proto, ['RESET'])
+                        self.put(self.lnk_fall, self.lnk_rise, self.out_ann, [ANN_LINK     , ['RESET']])
+                        self.put(self.lnk_fall, self.lnk_rise, self.out_ann, [ANN_NETWORK  , ['RESET']])

                         # Reset the timer.
                         self.lnk_fall = self.samplenum
                     elif ((self.samplenum - self.lnk_fall > self.cnt_overdrive_reset) and (self.lnk_overdrive)):
                         # Reset the timer.
                         self.lnk_fall = self.samplenum
                     elif ((self.samplenum - self.lnk_fall > self.cnt_overdrive_reset) and (self.lnk_overdrive)):


@@ -190,9 +225,9 @@ class Decoder(srd.Decoder):
                         # Send a reset event to the next protocol layer.
                         self.lnk_event = "RESET"
                         self.lnk_state = "WAIT FOR PRESENCE DETECT"
                         # Send a reset event to the next protocol layer.
                         self.lnk_event = "RESET"
                         self.lnk_state = "WAIT FOR PRESENCE DETECT"

-                        self.put(self.lnk_fall, self.samplenum, self.out_proto, ['RESET OVERDRIVE'])
-                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_LINK     , ['RESET OVERDRIVE']])
-                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK  , ['RESET OVERDRIVE']])
+                        self.put(self.lnk_fall, self.lnk_rise, self.out_proto, ['RESET OVERDRIVE'])
+                        self.put(self.lnk_fall, self.lnk_rise, self.out_ann, [ANN_LINK     , ['RESET OVERDRIVE']])
+                        self.put(self.lnk_fall, self.lnk_rise, self.out_ann, [ANN_NETWORK  , ['RESET OVERDRIVE']])

                         # Reset the timer.
                         self.lnk_fall = self.samplenum
                     # Otherwise this is assumed to be a data bit.
                         # Reset the timer.
                         self.lnk_fall = self.samplenum
                     # Otherwise this is assumed to be a data bit.


@@ -200,9 +235,7 @@ class Decoder(srd.Decoder):
                         self.lnk_state = "WAIT FOR FALLING EDGE"
             elif self.lnk_state == 'WAIT FOR PRESENCE DETECT':
                 # Sample presence status
                         self.lnk_state = "WAIT FOR FALLING EDGE"
             elif self.lnk_state == 'WAIT FOR PRESENCE DETECT':
                 # Sample presence status

-                if (self.lnk_overdrive): cnt = self.cnt_overdrive_presence
-                else                   : cnt = self.cnt_normal_presence
-                if (self.samplenum - self.lnk_rise == cnt):
+                if (self.samplenum - self.lnk_rise == self.cnt_presence[self.lnk_overdrive]):

                     self.lnk_present = owr & 0x1
                     # Save the sample number for the falling edge.
                     if not (self.lnk_present) :  self.lnk_fall = self.samplenum
                     self.lnk_present = owr & 0x1
                     # Save the sample number for the falling edge.
                     if not (self.lnk_present) :  self.lnk_fall = self.samplenum


@@ -211,8 +244,8 @@ class Decoder(srd.Decoder):
                     if (self.lnk_present) :  self.lnk_state = 'WAIT FOR FALLING EDGE'
                     else                  :  self.lnk_state = 'WAIT FOR RISING EDGE'
                     present_str = "False" if self.lnk_present else "True"
                     if (self.lnk_present) :  self.lnk_state = 'WAIT FOR FALLING EDGE'
                     else                  :  self.lnk_state = 'WAIT FOR RISING EDGE'
                     present_str = "False" if self.lnk_present else "True"

-                    self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_LINK   , ['PRESENCE: ' + present_str]])
-                    self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['PRESENCE: ' + present_str]])
+                    self.put(self.samplenum, 0, self.out_ann, [ANN_LINK   , ['PRESENCE: ' + present_str]])
+                    self.put(self.samplenum, 0, self.out_ann, [ANN_NETWORK, ['PRESENCE: ' + present_str]])

             else:
                 raise Exception('Invalid lnk_state: %d' % self.lnk_state)
 
             else:
                 raise Exception('Invalid lnk_state: %d' % self.lnk_state)
 


@@ -228,7 +261,8 @@ class Decoder(srd.Decoder):
             elif (self.net_state == "COMMAND"):
                 # Receiving and decoding a ROM command
                 if (self.onewire_collect(8)):
             elif (self.net_state == "COMMAND"):
                 # Receiving and decoding a ROM command
                 if (self.onewire_collect(8)):

-                    self.put(self.net_beg, self.net_end, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: 0x%02x \'%s\'' % (self.net_data, rom_command[self.net_data])]])
+                    self.put(self.net_beg, self.net_len, self.out_ann, [ANN_NETWORK,
+                      ['ROM COMMAND: 0x%02x \'%s\'' % (self.net_data, rom_command[self.net_data])]])

                     if   (self.net_data == 0x33):  # READ ROM
                         self.net_state = "GET ROM"
                     elif (self.net_data == 0x0f):  # CONDITIONAL READ ROM
                     if   (self.net_data == 0x33):  # READ ROM
                         self.net_state = "GET ROM"
                     elif (self.net_data == 0x0f):  # CONDITIONAL READ ROM


@@ -252,21 +286,21 @@ class Decoder(srd.Decoder):
                 # family code (1B) + serial number (6B) + CRC (1B)
                 if (self.onewire_collect(64)):
                     self.net_rom = self.net_data & 0xffffffffffffffff
                 # family code (1B) + serial number (6B) + CRC (1B)
                 if (self.onewire_collect(64)):
                     self.net_rom = self.net_data & 0xffffffffffffffff

-                    self.put(self.net_beg, self.net_end, self.out_ann, [ANN_NETWORK, ['ROM: 0x%016x' % self.net_rom]])
+                    self.put(self.net_beg, self.net_len, self.out_ann, [ANN_NETWORK, ['ROM: 0x%016x' % self.net_rom]])

                     self.net_state = "TRANSPORT"
             elif (self.net_state == "SEARCH ROM"):
                 # A 64 bit device address is searched for
                 # family code (1B) + serial number (6B) + CRC (1B)
                 if (self.onewire_search(64)):
                     self.net_rom = self.net_data & 0xffffffffffffffff
                     self.net_state = "TRANSPORT"
             elif (self.net_state == "SEARCH ROM"):
                 # A 64 bit device address is searched for
                 # family code (1B) + serial number (6B) + CRC (1B)
                 if (self.onewire_search(64)):
                     self.net_rom = self.net_data & 0xffffffffffffffff

-                    self.put(self.net_beg, self.net_end, self.out_ann, [ANN_NETWORK, ['ROM: 0x%016x' % self.net_rom]])
+                    self.put(self.net_beg, self.net_len, self.out_ann, [ANN_NETWORK, ['ROM: 0x%016x' % self.net_rom]])

                     self.net_state = "TRANSPORT"
             elif (self.net_state == "TRANSPORT"):
                 # The transport layer is handled in byte sized units
                 if (self.onewire_collect(8)):
                     self.net_state = "TRANSPORT"
             elif (self.net_state == "TRANSPORT"):
                 # The transport layer is handled in byte sized units
                 if (self.onewire_collect(8)):

-                    self.put(self.net_beg, self.net_end, self.out_ann, [ANN_NETWORK  , ['TRANSPORT: 0x%02x' % self.net_data]])
-                    self.put(self.net_beg, self.net_end, self.out_ann, [ANN_TRANSPORT, ['TRANSPORT: 0x%02x' % self.net_data]])
-                    self.put(self.net_beg, self.net_end, self.out_proto, ['transfer', self.net_data])
+                    self.put(self.net_beg, self.net_len, self.out_ann, [ANN_NETWORK  , ['TRANSPORT: 0x%02x' % self.net_data]])
+                    self.put(self.net_beg, self.net_len, self.out_ann, [ANN_TRANSPORT, ['TRANSPORT: 0x%02x' % self.net_data]])
+                    self.put(self.net_beg, self.net_len, self.out_proto, ['transfer', self.net_data])

                     # TODO: Sending translort layer data to 1-Wire device models
             else:
                 raise Exception('Invalid net_state: %s' % self.net_state)
                     # TODO: Sending translort layer data to 1-Wire device models
             else:
                 raise Exception('Invalid net_state: %s' % self.net_state)


@@ -277,13 +311,14 @@ class Decoder(srd.Decoder):
         if (self.lnk_event == "DATA BIT"):
             # Storing the sampe this sequence begins with
             if (self.net_cnt == 1):
         if (self.lnk_event == "DATA BIT"):
             # Storing the sampe this sequence begins with
             if (self.net_cnt == 1):

-                self.net_beg  = self.samplenum
+                self.net_beg = self.lnk_fall

             self.net_data = self.net_data & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
             self.net_cnt  = self.net_cnt + 1
             # Storing the sampe this sequence ends with
             # In case the full length of the sequence is received, return 1
             if (self.net_cnt == length):
             self.net_data = self.net_data & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
             self.net_cnt  = self.net_cnt + 1
             # Storing the sampe this sequence ends with
             # In case the full length of the sequence is received, return 1
             if (self.net_cnt == length):

-                self.net_end  = self.samplenum
+                self.net_end  = self.lnk_fall + self.cnt_slot[self.lnk_overdrive]
+                self.net_len  = self.net_end - self.net_beg

                 self.net_data = self.net_data & ((1<<length)-1)
                 self.net_cnt  = 0
                 return (1)
                 self.net_data = self.net_data & ((1<<length)-1)
                 self.net_cnt  = 0
                 return (1)


@@ -297,7 +332,7 @@ class Decoder(srd.Decoder):
         if (self.lnk_event == "DATA BIT"):
             # Storing the sampe this sequence begins with
             if ((self.net_cnt == 0) and (self.net_search == "P")):
         if (self.lnk_event == "DATA BIT"):
             # Storing the sampe this sequence begins with
             if ((self.net_cnt == 0) and (self.net_search == "P")):

-                self.net_beg  = self.samplenum
+                self.net_beg  = self.lnk_fall

             # Master receives an original address bit
             if   (self.net_search == "P"):
               self.net_data_p = self.net_data_p & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
             # Master receives an original address bit
             if   (self.net_search == "P"):
               self.net_data_p = self.net_data_p & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)


@@ -314,7 +349,8 @@ class Decoder(srd.Decoder):
             # Storing the sampe this sequence ends with
             # In case the full length of the sequence is received, return 1
             if (self.net_cnt == length):
             # Storing the sampe this sequence ends with
             # In case the full length of the sequence is received, return 1
             if (self.net_cnt == length):

-                self.net_end  = self.samplenum
+                self.net_end    = self.lnk_fall + self.cnt_slot[self.lnk_overdrive]
+                self.net_len    = self.net_end - self.net_beg

                 self.net_data_p = self.net_data_p & ((1<<length)-1)
                 self.net_data_n = self.net_data_n & ((1<<length)-1)
                 self.net_data   = self.net_data   & ((1<<length)-1)
                 self.net_data_p = self.net_data_p & ((1<<length)-1)
                 self.net_data_n = self.net_data_n & ((1<<length)-1)
                 self.net_data   = self.net_data   & ((1<<length)-1)