decoders/onewire_network/onewire_network.py

   1 ##
   2 ## This file is part of the sigrok project.
   3 ##
   4 ## Copyright (C) 2012 Iztok Jeras <iztok.jeras@gmail.com>
   5 ##
   6 ## This program is free software; you can redistribute it and/or modify
   7 ## it under the terms of the GNU General Public License as published by
   8 ## the Free Software Foundation; either version 2 of the License, or
   9 ## (at your option) any later version.
  10 ##
  11 ## This program is distributed in the hope that it will be useful,
  12 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ## GNU General Public License for more details.
  15 ##
  16 ## You should have received a copy of the GNU General Public License
  17 ## along with this program; if not, write to the Free Software
  18 ## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19 ##
  20
  21 # 1-Wire protocol decoder
  22
  23 import sigrokdecode as srd
  24
  25 # a dictionary of ROM commands and their names, next state
  26 command = {
  27     0x33: ["READ ROM"              , "GET ROM"   ],
  28     0x0f: ["CONDITIONAL READ ROM"  , "GET ROM"   ],
  29     0xcc: ["SKIP ROM"              , "TRANSPORT" ],
  30     0x55: ["MATCH ROM"             , "GET ROM"   ],
  31     0xf0: ["SEARCH ROM"            , "SEARCH ROM"],
  32     0xec: ["CONDITIONAL SEARCH ROM", "SEARCH ROM"],
  33     0x3c: ["OVERDRIVE SKIP ROM"    , "TRANSPORT" ],
  34     0x6d: ["OVERDRIVE MATCH ROM"   , "GET ROM"   ]
  35 }
  36
  37 class Decoder(srd.Decoder):
  38     api_version = 1
  39     id = 'onewire_network'
  40     name = '1-Wire network layer'
  41     longname = '1-Wire serial communication bus'
  42     desc = 'Bidirectional, half-duplex, asynchronous serial bus.'
  43     license = 'gplv2+'
  44     inputs = ['onewire_link']
  45     outputs = ['onewire_network']
  46     probes = []
  47     optional_probes = []
  48     options = {}
  49     annotations = [
  50         ['Network', 'Network layer events (device addressing)'],
  51     ]
  52
  53     def __init__(self, **kwargs):
  54         # Event timing variables
  55         self.net_beg = 0
  56         self.net_end = 0
  57         # Network layer variables
  58         self.state   = 'COMMAND'
  59         self.bit_cnt = 0
  60         self.search  = "P"
  61         self.data_p  = 0x0
  62         self.data_n  = 0x0
  63         self.data    = 0x0
  64         self.net_rom = 0x0000000000000000
  65
  66     def start(self, metadata):
  67         self.out_proto = self.add(srd.OUTPUT_PROTO, 'onewire_network')
  68         self.out_ann   = self.add(srd.OUTPUT_ANN  , 'onewire_network')
  69
  70     def report(self):
  71         pass
  72
  73     def decode(self, ss, es, data):
  74         [code, val] = data
  75
  76         # State machine.
  77         if (code == "RESET/PRESENCE"):
  78             self.search = "P"
  79             self.bit_cnt = 0
  80             self.put(ss, es, self.out_ann, [0, ['RESET/PRESENCE: %s' % ('True' if val else 'False')]])
  81             self.put(ss, es, self.out_proto, ['RESET/PRESENCE', val])
  82             self.state = "COMMAND"
  83         elif (code == "BIT"):
  84             if (self.state == "COMMAND"):
  85                 # Receiving and decoding a ROM command
  86                 if (self.onewire_collect(8, val, ss, es)):
  87                     if (self.data in command):
  88                         self.put(self.net_beg, self.net_end, self.out_ann, [0,
  89                           ['ROM COMMAND: 0x%02x \'%s\'' % (self.data, command[self.data][0])]])
  90                         self.state = command[self.data][1]
  91                     else:
  92                         self.put(self.net_beg, self.net_end, self.out_ann, [0,
  93                           ['ROM COMMAND: 0x%02x \'%s\'' % (self.data, 'UNRECOGNIZED')]])
  94                         self.state = "COMMAND ERROR"
  95             elif (self.state == "GET ROM"):
  96                 # A 64 bit device address is selected
  97                 # family code (1B) + serial number (6B) + CRC (1B)
  98                 if (self.onewire_collect(64, val, ss, es)):
  99                     self.net_rom = self.data & 0xffffffffffffffff
 100                     self.put(self.net_beg, self.net_end, self.out_ann, [0, ['ROM: 0x%016x' % self.net_rom]])
 101                     self.put(self.net_beg, self.net_end, self.out_proto, ['ROM', self.net_rom])
 102                     self.state = "TRANSPORT"
 103             elif (self.state == "SEARCH ROM"):
 104                 # A 64 bit device address is searched for
 105                 # family code (1B) + serial number (6B) + CRC (1B)
 106                 if (self.onewire_search(64, val, ss, es)):
 107                     self.net_rom = self.data & 0xffffffffffffffff
 108                     self.put(self.net_beg, self.net_end, self.out_ann, [0, ['ROM: 0x%016x' % self.net_rom]])
 109                     self.put(self.net_beg, self.net_end, self.out_proto, ['ROM', self.net_rom])
 110                     self.state = "TRANSPORT"
 111             elif (self.state == "TRANSPORT"):
 112                 # The transport layer is handled in byte sized units
 113                 if (self.onewire_collect(8, val, ss, es)):
 114                     self.put(self.net_beg, self.net_end, self.out_ann, [0, ['DATA: 0x%02x' % self.data]])
 115                     self.put(self.net_beg, self.net_end, self.out_proto, ['DATA', self.data])
 116             elif (self.state == "COMMAND ERROR"):
 117                 # Since the command is not recognized, print raw data
 118                 if (self.onewire_collect(8, val, ss, es)):
 119                     self.put(self.net_beg, self.net_end, self.out_ann, [0, ['ROM ERROR DATA: 0x%02x' % self.data]])
 120             else:
 121                 raise Exception('Invalid state: %s' % self.state)
 122
 123
 124     # Link/Network layer data collector
 125     def onewire_collect (self, length, val, ss, es):
 126         # Storing the sampe this sequence begins with
 127         if (self.bit_cnt == 1):
 128             self.net_beg = ss
 129         self.data = self.data & ~(1 << self.bit_cnt) | (val << self.bit_cnt)
 130         self.bit_cnt  = self.bit_cnt + 1
 131         # Storing the sampe this sequence ends with
 132         # In case the full length of the sequence is received, return 1
 133         if (self.bit_cnt == length):
 134             self.net_end  = es
 135             self.data = self.data & ((1<<length)-1)
 136             self.bit_cnt  = 0
 137             return (1)
 138         else:
 139             return (0)
 140
 141     # Link/Network layer search collector
 142     def onewire_search (self, length, val, ss, es):
 143         # Storing the sampe this sequence begins with
 144         if ((self.bit_cnt == 0) and (self.search == "P")):
 145             self.net_beg = ss
 146         # Master receives an original address bit
 147         if   (self.search == "P"):
 148           self.data_p = self.data_p & ~(1 << self.bit_cnt) | (val << self.bit_cnt)
 149           self.search = "N"
 150         # Master receives a complemented address bit
 151         elif (self.search == "N"):
 152           self.data_n = self.data_n & ~(1 << self.bit_cnt) | (val << self.bit_cnt)
 153           self.search = "D"
 154         # Master transmits an address bit
 155         elif (self.search == "D"):
 156           self.data   = self.data   & ~(1 << self.bit_cnt) | (val << self.bit_cnt)
 157           self.search = "P"
 158           self.bit_cnt    = self.bit_cnt + 1
 159         # Storing the sampe this sequence ends with
 160         # In case the full length of the sequence is received, return 1
 161         if (self.bit_cnt == length):
 162             self.net_end = es
 163             self.data_p = self.data_p & ((1<<length)-1)
 164             self.data_n = self.data_n & ((1<<length)-1)
 165             self.data   = self.data   & ((1<<length)-1)
 166             self.search = "P"
 167             self.bit_cnt    = 0
 168             return (1)
 169         else:
 170             return (0)