X-Git-Url: https://sigrok.org/gitweb/?p=libsigrokdecode.git;a=blobdiff_plain;f=decoders%2Fonewire%2Fonewire.py;h=85edaeb78ae2d211161462a8a7ed229eeb95a3c0;hp=0f9db4dac19dbfd81f487b15eb490adbf66fc1d0;hb=13329e2d81e17bd3aa1b48a5197f892f825abd2d;hpb=0bd62eb1ffc0b1611f88c2cbf8e59b4be183113b

diff --git a/decoders/onewire/onewire.py b/decoders/onewire/onewire.py
index 0f9db4d..85edaeb 100644
--- a/decoders/onewire/onewire.py
+++ b/decoders/onewire/onewire.py
@@ -23,9 +23,9 @@
 import sigrokdecode as srd
 
 # Annotation feed formats
-ANN_LINK     = 0
-ANN_NETWORK  = 1
-ANN_TRANSFER = 2
+ANN_LINK      = 0
+ANN_NETWORK   = 1
+ANN_TRANSPORT = 2
 
 class Decoder(srd.Decoder):
     api_version = 1
@@ -48,7 +48,7 @@ class Decoder(srd.Decoder):
     annotations = [
         ['Link', 'Link layer events (reset, presence, bit slots)'],
         ['Network', 'Network layer events (device addressing)'],
-        ['Transfer', 'Transfer layer events'],
+        ['Transport', 'Transport layer events'],
     ]
 
     def __init__(self, **kwargs):
@@ -61,16 +61,15 @@ class Decoder(srd.Decoder):
         self.lnk_present = 0
         self.lnk_bit     = 0
         # Network layer variables
-        self.net_state   = 'ROM COMMAND'
-        self.net_event   = 'NONE'
+        self.net_state   = 'IDLE'
         self.net_cnt     = 0
         self.net_search  = "P"
         self.net_data_p  = 0x0
         self.net_data_n  = 0x0
         self.net_data    = 0x0
+        self.net_rom     = 0x0000000000000000
         # Transport layer variables
-        self.trn_state   = 'WAIT FOR EVENT'
-        self.trn_event   = 'NONE'
+        self.trn_state   = 'IDLE'
 
     def start(self, metadata):
         self.samplerate = metadata['samplerate']
@@ -145,122 +144,145 @@ class Decoder(srd.Decoder):
 
             # Network layer
             
-            # Clear events.
-            self.net_event = "RESET"
             # State machine.
             if (self.lnk_event == "RESET"):
-                self.net_state = "ROM COMMAND"
+                self.net_state = "COMMAND"
                 self.net_search = "P"
                 self.net_cnt    = 0
-            elif (self.lnk_event == "DATA BIT"):
-                if (self.net_state == "ROM COMMAND"):
-                    if (self.collect_data(8)):
-#                        self.put(self.lnk_fall, self.samplenum,
-#                                 self.out_proto, ['ROM COMMAND', self.net_data])
-                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: 0x%02x' % self.net_data]])
-                        if   (self.net_data == 0x33):
-                            # READ ROM
-                            self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'READ ROM\'']])
-                            self.net_state = "ADDRESS"
-                        elif (self.net_data == 0x0f):
-                            # READ ROM TODO
-                            self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'READ ROM ???\'']])
-                            self.net_state = "ADDRESS"
-                        elif (self.net_data == 0xcc):
-                            # SKIP ROM
-                            self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'SKIP ROM\'']])
-                            self.net_state = "CONTROL COMMAND"
-                        elif (self.net_data == 0x55):
-                            # MATCH ROM
-                            self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'MATCH ROM\'']])
-                            self.net_state = "ADDRESS"
-                        elif (self.net_data == 0xf0):
-                            # SEARCH ROM
-                            self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'SEARCH ROM\'']])
-                            self.net_state = "SEARCH"
-                        elif (self.net_data == 0x3c):
-                            # OVERDRIVE SKIP ROM
-                            self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'OVERDRIVE SKIP ROM\'']])
-                            self.net_state = "CONTROL COMMAND"
-                        elif (self.net_data == 0x69):
-                            # OVERDRIVE MATCH ROM
-                            self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'OVERDRIVE MATCH ROM\'']])
-                            self.net_state = "ADDRESS"
-                elif (self.net_state == "ADDRESS"):
-                    # family code (1B) + serial number (6B) + CRC (1B)
-                    if (self.collect_data((1+6+1)*8)):
-                        self.net_address = self.net_data & 0xffffffffffffffff
-                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM: 0x%016x' % self.net_address]])
-                        self.net_state = "CONTROL COMMAND"
-                elif (self.net_state == "SEARCH"):
-                    # family code (1B) + serial number (6B) + CRC (1B)
-                    if (self.collect_search((1+6+1)*8)):
-                        self.net_address = self.net_data & 0xffffffffffffffff
-                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM: 0x%016x' % self.net_address]])
-                        self.net_state = "CONTROL COMMAND"
-                elif (self.net_state == "CONTROL COMMAND"):
-                    if (self.collect_data(8)):
-#                        self.put(self.lnk_fall, self.samplenum,
-#                                 self.out_proto, ['LNK: COMMAND', self.net_data])
-                        self.put(self.lnk_fall, self.samplenum, self.out_ann,
-                                 [ANN_TRANSFER, ['TRANSFER: FUNCTION COMMAND: 0x' + hex(self.net_data)]])
-                        if   (self.net_data == 0x48):
-                            # COPY SCRATCHPAD
-                            self.net_state = "TODO"
-                        elif (self.net_data == 0x4e):
-                            # WRITE SCRATCHPAD
-                            self.net_state = "TODO"
-                        elif (self.net_data == 0xbe):
-                            # READ SCRATCHPAD
-                            self.net_state = "TODO"
-                        elif (self.net_data == 0xb8):
-                            # RECALL E2
-                            self.net_state = "TODO"
-                        elif (self.net_data == 0xb4):
-                            # READ POWER SUPPLY
-                            self.net_state = "TODO"
-                        else:
-                            # unsupported commands
-                            self.net_state = "UNDEFINED"
-                elif (self.net_state == "UNDEFINED"):
-                    pass
-                else:
-                    raise Exception('Invalid net_state: %s' % self.net_state)
-            elif (self.lnk_event != "NONE"):
-                raise Exception('Invalid lnk_event: %s' % self.lnk_event)
+            elif (self.net_state == "IDLE"):
+                pass
+            elif (self.net_state == "DONE"):
+                self.trn_state = "COMMAND"
+                self.net_state = "IDLE"
+            elif (self.net_state == "COMMAND"):
+                if (self.collect_data(8)):
+#                    self.put(self.lnk_fall, self.samplenum,
+#                             self.out_proto, ['ROM COMMAND', self.net_data])
+                    self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: 0x%02x' % self.net_data]])
+                    if   (self.net_data == 0x33):
+                        # READ ROM
+                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'READ ROM\'']])
+                        self.net_state = "GET ROM"
+                    elif (self.net_data == 0x0f):
+                        # CONDITIONAL READ ROM
+                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'CONDITIONAL READ ROM\'']])
+                        self.net_state = "GET ROM"
+                    elif (self.net_data == 0xcc):
+                        # SKIP ROM
+                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'SKIP ROM\'']])
+                        self.net_state = "DONE"
+                    elif (self.net_data == 0x55):
+                        # MATCH ROM
+                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'MATCH ROM\'']])
+                        self.net_state = "GET ROM"
+                    elif (self.net_data == 0xf0):
+                        # SEARCH ROM
+                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'SEARCH ROM\'']])
+                        self.net_state = "SEARCH ROM"
+                    elif (self.net_data == 0xec):
+                        # CONDITIONAL SEARCH ROM
+                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'CONDITIONAL SEARCH ROM\'']])
+                        self.net_state = "SEARCH ROM"
+                    elif (self.net_data == 0x3c):
+                        # OVERDRIVE SKIP ROM
+                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'OVERDRIVE SKIP ROM\'']])
+                        self.net_state = "DONE"
+                    elif (self.net_data == 0x69):
+                        # OVERDRIVE MATCH ROM
+                        self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM COMMAND: \'OVERDRIVE MATCH ROM\'']])
+                        self.net_state = "GET ROM"
+            elif (self.net_state == "GET ROM"):
+                # family code (1B) + serial number (6B) + CRC (1B)
+                if (self.collect_data(64)):
+                    self.net_rom = self.net_data & 0xffffffffffffffff
+                    self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM: 0x%016x' % self.net_rom]])
+                    self.net_state = "DONE"
+            elif (self.net_state == "SEARCH ROM"):
+                # family code (1B) + serial number (6B) + CRC (1B)
+                if (self.collect_search(64)):
+                    self.net_rom = self.net_data & 0xffffffffffffffff
+                    self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK, ['ROM: 0x%016x' % self.net_rom]])
+                    self.net_state = "DONE"
+            else:
+                raise Exception('Invalid net_state: %s' % self.net_state)
 
+            # Transport layer
+            
+            # State machine.
+            if (self.lnk_event == "RESET"):
+                self.trn_state = "IDLE"
+            elif (self.trn_state == "IDLE"):
+                pass
+            elif (self.trn_state == "COMMAND"):
+                if (self.collect_data(8)):
+#                    self.put(self.lnk_fall, self.samplenum, self.out_proto, ['FUNCTION COMMAND', self.net_data])
+                    self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK  , ['FUNCTION COMMAND: 0x%02x' % self.net_data]])
+                    self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_TRANSPORT, ['FUNCTION COMMAND: 0x%02x' % self.net_data]])
+                    if   (self.net_data == 0x48):
+                        # COPY SCRATCHPAD
+                        self.trn_state = "TODO"
+                    elif (self.net_data == 0x4e):
+                        # WRITE SCRATCHPAD
+                        self.trn_state = "TODO"
+                    elif (self.net_data == 0xbe):
+                        # READ SCRATCHPAD
+                        self.trn_state = "TODO"
+                    elif (self.net_data == 0xb8):
+                        # RECALL E2
+                        self.trn_state = "TODO"
+                    elif (self.net_data == 0xb4):
+                        # READ POWER SUPPLY
+                        self.trn_state = "TODO"
+                    else:
+                        # unsupported commands
+                        self.trn_state = "TODO"
+            elif (self.trn_state == "TODO"):
+                if (self.collect_data(8)):
+                    self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK  , ['TRANSPORT DATA: 0x%02x' % self.net_data]])
+                    self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_TRANSPORT, ['TRANSPORT DATA: 0x%02x' % self.net_data]])
+#                self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_NETWORK  , ['TODO unsupported transport state: %s' % self.trn_state]])
+#                self.put(self.lnk_fall, self.samplenum, self.out_ann, [ANN_TRANSPORT, ['TODO unsupported transport state: %s' % self.trn_state]])
+                pass
+            else:
+                raise Exception('Invalid trn_state: %s' % self.trn_state)
 
     # Link/Network layer data collector
     def collect_data (self, length):
-        #print ("DEBUG: BIT=%d t0=%d t+=%d" % (self.lnk_bit, self.lnk_fall, self.samplenum))
-        self.net_data = self.net_data & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
-        self.net_cnt  = self.net_cnt + 1
-        if (self.net_cnt == length):
-            self.net_data = self.net_data & ((1<<length)-1)
-            self.net_cnt  = 0
-            return (1)
+        if (self.lnk_event == "DATA BIT"):
+            #print ("DEBUG: BIT=%d t0=%d t+=%d" % (self.lnk_bit, self.lnk_fall, self.samplenum))
+            self.net_data = self.net_data & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
+            self.net_cnt  = self.net_cnt + 1
+            if (self.net_cnt == length):
+                self.net_data = self.net_data & ((1<<length)-1)
+                self.net_cnt  = 0
+                return (1)
+            else:
+                return (0)
         else:
             return (0)
 
     # Link/Network layer search collector
     def collect_search (self, length):
-        #print ("DEBUG: SEARCH=%s BIT=%d t0=%d t+=%d" % (self.net_search, self.lnk_bit, self.lnk_fall, self.samplenum))
-        if   (self.net_search == "P"):
-          self.net_data_p = self.net_data_p & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
-          self.net_search = "N"
-        elif (self.net_search == "N"):
-          self.net_data_n = self.net_data_n & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
-          self.net_search = "D"
-        elif (self.net_search == "D"):
-          self.net_data   = self.net_data   & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
-          self.net_search = "P"
-          self.net_cnt    = self.net_cnt + 1
-        if (self.net_cnt == length):
-            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_search = "P"
-            self.net_cnt    = 0
-            return (1)
+        if (self.lnk_event == "DATA BIT"):
+            #print ("DEBUG: SEARCH=%s BIT=%d t0=%d t+=%d" % (self.net_search, self.lnk_bit, self.lnk_fall, self.samplenum))
+            if   (self.net_search == "P"):
+              self.net_data_p = self.net_data_p & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
+              self.net_search = "N"
+            elif (self.net_search == "N"):
+              self.net_data_n = self.net_data_n & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
+              self.net_search = "D"
+            elif (self.net_search == "D"):
+              self.net_data   = self.net_data   & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt)
+              self.net_search = "P"
+              self.net_cnt    = self.net_cnt + 1
+            if (self.net_cnt == length):
+                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_search = "P"
+                self.net_cnt    = 0
+                return (1)
+            else:
+                return (0)
         else:
             return (0)