decoders/usb_power_delivery/pd.py

   1 ##
   2 ## This file is part of the libsigrokdecode project.
   3 ##
   4 ## Copyright (C) 2015 Google, Inc
   5 ## Copyright (C) 2018 davidanger <davidanger@163.com>
   6 ## Copyright (C) 2018 Peter Hazenberg <sigrok@haas-en-berg.nl>
   7 ##
   8 ## This program is free software; you can redistribute it and/or modify
   9 ## it under the terms of the GNU General Public License as published by
  10 ## the Free Software Foundation; either version 2 of the License, or
  11 ## (at your option) any later version.
  12 ##
  13 ## This program is distributed in the hope that it will be useful,
  14 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ## GNU General Public License for more details.
  17 ##
  18 ## You should have received a copy of the GNU General Public License
  19 ## along with this program; if not, see <http://www.gnu.org/licenses/>.
  20 ##
  21
  22 import sigrokdecode as srd
  23 import struct
  24 import zlib   # for crc32
  25
  26 # BMC encoding with a 600kHz datarate
  27 UI_US = 1000000/600000.0
  28
  29 # Threshold to discriminate half-1 from 0 in Binary Mark Conding
  30 THRESHOLD_US = (UI_US + 2 * UI_US) / 2
  31
  32 # Control Message type
  33 CTRL_TYPES = {
  34     0: 'reserved',
  35     1: 'GOOD CRC',
  36     2: 'GOTO MIN',
  37     3: 'ACCEPT',
  38     4: 'REJECT',
  39     5: 'PING',
  40     6: 'PS RDY',
  41     7: 'GET SOURCE CAP',
  42     8: 'GET SINK CAP',
  43     9: 'DR SWAP',
  44     10: 'PR SWAP',
  45     11: 'VCONN SWAP',
  46     12: 'WAIT',
  47     13: 'SOFT RESET',
  48     14: 'reserved',
  49     15: 'reserved',
  50     16: 'Not Supported',
  51     17: 'Get_Source_Cap_Extended',
  52     18: 'Get_Status',
  53     19: 'FR_Swap',
  54     20: 'Get_PPS_Status',
  55     21: 'Get_Country_Codes',
  56 }
  57
  58 # Data message type
  59 DATA_TYPES = {
  60     1: 'SOURCE CAP',
  61     2: 'REQUEST',
  62     3: 'BIST',
  63     4: 'SINK CAP',
  64     5: 'Battery_Status',
  65     6: 'Alert',
  66     7: 'Get_Country_Info',
  67     15: 'VDM'
  68 }
  69
  70 # 4b5b encoding of the symbols
  71 DEC4B5B = [
  72     0x10,   # Error      00000
  73     0x10,   # Error      00001
  74     0x10,   # Error      00010
  75     0x10,   # Error      00011
  76     0x10,   # Error      00100
  77     0x10,   # Error      00101
  78     0x13,   # Sync-3     00110
  79     0x14,   # RST-1      00111
  80     0x10,   # Error      01000
  81     0x01,   # 1 = 0001   01001
  82     0x04,   # 4 = 0100   01010
  83     0x05,   # 5 = 0101   01011
  84     0x10,   # Error      01100
  85     0x16,   # EOP        01101
  86     0x06,   # 6 = 0110   01110
  87     0x07,   # 7 = 0111   01111
  88     0x10,   # Error      10000
  89     0x12,   # Sync-2     10001
  90     0x08,   # 8 = 1000   10010
  91     0x09,   # 9 = 1001   10011
  92     0x02,   # 2 = 0010   10100
  93     0x03,   # 3 = 0011   10101
  94     0x0A,   # A = 1010   10110
  95     0x0B,   # B = 1011   10111
  96     0x11,   # Sync-1     11000
  97     0x15,   # RST-2      11001
  98     0x0C,   # C = 1100   11010
  99     0x0D,   # D = 1101   11011
 100     0x0E,   # E = 1110   11100
 101     0x0F,   # F = 1111   11101
 102     0x00,   # 0 = 0000   11110
 103     0x10,   # Error      11111
 104 ]
 105 SYM_ERR = 0x10
 106 SYNC1 = 0x11
 107 SYNC2 = 0x12
 108 SYNC3 = 0x13
 109 RST1 = 0x14
 110 RST2 = 0x15
 111 EOP = 0x16
 112 SYNC_CODES = [SYNC1, SYNC2, SYNC3]
 113 HRST_CODES = [RST1, RST1, RST1, RST2]
 114
 115 SOP_SEQUENCES = [
 116     (SYNC1, SYNC1, SYNC1, SYNC2),
 117     (SYNC1, SYNC1, SYNC3, SYNC3),
 118     (SYNC1, SYNC3, SYNC1, SYNC3),
 119     (SYNC1, RST2,  RST2,  SYNC3),
 120     (SYNC1, RST2,  SYNC3, SYNC2),
 121     (RST1,  SYNC1, RST1,  SYNC3),
 122     (RST1,  RST1,  RST1,   RST2),
 123 ]
 124 START_OF_PACKETS = {
 125     SOP_SEQUENCES[0]: 'SOP',
 126     SOP_SEQUENCES[1]: "SOP'",
 127     SOP_SEQUENCES[2]: 'SOP"',
 128     SOP_SEQUENCES[3]: "SOP' Debug",
 129     SOP_SEQUENCES[4]: 'SOP" Debug',
 130     SOP_SEQUENCES[5]: 'Cable Reset',
 131     SOP_SEQUENCES[6]: 'Hard Reset',
 132 }
 133
 134 SYM_NAME = [
 135     ['0x0', '0'],
 136     ['0x1', '1'],
 137     ['0x2', '2'],
 138     ['0x3', '3'],
 139     ['0x4', '4'],
 140     ['0x5', '5'],
 141     ['0x6', '6'],
 142     ['0x7', '7'],
 143     ['0x8', '8'],
 144     ['0x9', '9'],
 145     ['0xA', 'A'],
 146     ['0xB', 'B'],
 147     ['0xC', 'C'],
 148     ['0xD', 'D'],
 149     ['0xE', 'E'],
 150     ['0xF', 'F'],
 151     ['ERROR', 'X'],
 152     ['SYNC-1', 'S1'],
 153     ['SYNC-2', 'S2'],
 154     ['SYNC-3', 'S3'],
 155     ['RST-1', 'R1'],
 156     ['RST-2', 'R2'],
 157     ['EOP', '#'],
 158 ]
 159
 160 RDO_FLAGS = {
 161     (1 << 23): 'unchunked',
 162     (1 << 24): 'no_suspend',
 163     (1 << 25): 'comm_cap',
 164     (1 << 26): 'cap_mismatch',
 165     (1 << 27): 'give_back'
 166 }
 167
 168 BIST_MODES = {
 169         0: 'Receiver',
 170         1: 'Transmit',
 171         2: 'Counters',
 172         3: 'Carrier 0',
 173         4: 'Carrier 1',
 174         5: 'Carrier 2',
 175         6: 'Carrier 3',
 176         7: 'Eye',
 177 }
 178
 179 VDM_CMDS = {
 180         1: 'Disc Ident',
 181         2: 'Disc SVID',
 182         3: 'Disc Mode',
 183         4: 'Enter Mode',
 184         5: 'Exit Mode',
 185         6: 'Attention',
 186         # 16..31: SVID Specific Commands
 187         # DisplayPort Commands
 188         16: 'DP Status',
 189         17: 'DP Configure',
 190 }
 191 VDM_ACK = ['REQ', 'ACK', 'NAK', 'BSY']
 192
 193
 194 class SamplerateError(Exception):
 195     pass
 196
 197 class Decoder(srd.Decoder):
 198     api_version = 3
 199     id = 'usb_power_delivery'
 200     name = 'USB PD'
 201     longname = 'USB Power Delivery'
 202     desc = 'USB Power Delivery protocol.'
 203     license = 'gplv2+'
 204     inputs = ['logic']
 205     outputs = ['usb_pd']
 206     channels = (
 207         {'id': 'cc1', 'name': 'CC1', 'desc': 'Configuration Channel 1'},
 208     )
 209     optional_channels = (
 210         {'id': 'cc2', 'name': 'CC2', 'desc': 'Configuration Channel 2'},
 211     )
 212     options = (
 213         {'id': 'fulltext', 'desc': 'full text decoding of the packet',
 214          'default': 'no', 'values': ('yes', 'no')},
 215     )
 216     annotations = (
 217         ('type', 'Packet Type'),
 218         ('Preamble', 'Preamble'),
 219         ('SOP', 'Start of Packet'),
 220         ('Head', 'Header'),
 221         ('Data', 'Data'),
 222         ('CRC', 'Checksum'),
 223         ('EOP', 'End Of Packet'),
 224         ('Sym', '4b5b symbols'),
 225         ('warnings', 'Warnings'),
 226         ('src', 'Source Message'),
 227         ('snk', 'Sink Message'),
 228         ('payload', 'Payload'),
 229         ('text', 'Plain text'),
 230     )
 231     annotation_rows = (
 232        ('4B5B', 'symbols', (7, )),
 233        ('Phase', 'parts', (1, 2, 3, 4, 5, 6, )),
 234        ('payload', 'Payload', (11, )),
 235        ('type', 'Type', (0, 9, 10, )),
 236        ('warnings', 'Warnings', (8, )),
 237        ('text', 'Full text', (12, )),
 238     )
 239     binary = (
 240         ('raw-data', 'RAW binary data'),
 241     )
 242
 243     stored_pdos = {}
 244
 245
 246     def get_request(self, rdo):
 247         pos = (rdo >> 28) & 7
 248
 249         op_ma = ((rdo >> 10) & 0x3ff) * 0.01
 250         max_ma = (rdo & 0x3ff) * 0.01
 251
 252         mark = self.cap_mark[pos]
 253         if mark == 3:
 254             op_v = ((rdo >> 9) & 0x7ff) * 0.02
 255             op_a = (rdo & 0x3f) * 0.05
 256             t_settings = '%gV %gA' % (op_v, op_a)
 257         elif mark == 2:
 258             op_w = ((rdo >> 10) & 0x3ff) * 0.25
 259             mp_w = (rdo & 0x3ff) * 0.25
 260             t_settings = '%gW (operating) / %gW (max)' % (op_w, max_w)
 261         else:
 262             op_a = ((rdo >> 10) & 0x3ff) * 0.01
 263             max_a = (rdo & 0x3ff) * 0.01
 264             t_settings = '%gA (operating) / %gA (max)' % (op_a, max_a)
 265
 266         t_flags = ''
 267         for f in sorted(RDO_FLAGS.keys(), reverse = True):
 268             if rdo & f:
 269                 t_flags += ' [' + RDO_FLAGS[f] + ']'
 270
 271         if pos in self.stored_pdos.keys():
 272             t_pdo = '#%d: %s' % (pos, self.stored_pdos[pos])
 273         else:
 274             t_pdo = '#d' % (pos)
 275
 276         return '(PDO %s) %s%s' % (t_pdo, t_settings, t_flags)
 277
 278     def get_source_sink_cap(self, pdo, idx, source):
 279         t1 = (pdo >> 30) & 3
 280         self.cap_mark[idx] = t1
 281
 282         flags = {}
 283         if t1 == 0:
 284             t_name = 'Fixed'
 285             if source:
 286                 flags = {
 287                     (1 << 29): 'dual_role_power',
 288                     (1 << 28): 'suspend',
 289                     (1 << 27): 'unconstrained',
 290                     (1 << 26): 'comm_cap',
 291                     (1 << 25): 'dual_role_data',
 292                     (1 << 24): 'unchunked',
 293                 }
 294             else: #sink
 295                 flags = {
 296                     (1 << 29): 'dual_role_power',
 297                     (1 << 28): 'high_capability',
 298                     (1 << 27): 'unconstrained',
 299                     (1 << 26): 'comm_cap',
 300                     (1 << 25): 'dual_role_data',
 301                     (0b01 << 23): 'fr_swap default power',
 302                     (0b10 << 23): 'fr_swap 1.5 A',
 303                     (0b11 << 23): 'fr_swap 3.0 A',
 304                 }
 305             mv = ((pdo >> 10) & 0x3ff) * 0.05
 306             ma = ((pdo >>  0) & 0x3ff) * 0.01
 307             p = '%gV %gA (%gW)' % (mv, ma, mv*ma)
 308             self.stored_pdos[idx] = '%s %gV' % (t_name, mv)
 309         elif t1 == 1:
 310             t_name = 'Battery'
 311             flags = {} # No flags defined for Battery PDO in PD 3.0 spec
 312             minv = ((pdo >> 10) & 0x3ff) * 0.05
 313             maxv = ((pdo >> 20) & 0x3ff) * 0.05
 314             mw   = ((pdo >>  0) & 0x3ff) * 0.25
 315             p = '%g/%gV %gW' % (minv, maxv, mw)
 316             self.stored_pdos[idx] = '%s %g/%gV' % (t_name, minv, maxv)
 317         elif t1 == 2:
 318             t_name = 'Variable'
 319             flags = {} # No flags defined for Variable PDO in PD 3.0 spec
 320             minv = ((pdo >> 10) & 0x3ff) * 0.05
 321             maxv = ((pdo >> 20) & 0x3ff) * 0.05
 322             ma   = ((pdo >>  0) & 0x3ff) * 0.01
 323             p = '%g/%gV %gA' % (minv, maxv, ma)
 324             self.stored_pdos[idx] = '%s %g/%gV' % (t_name, minv, maxv)
 325         elif t1 == 3:
 326             t2 = (pdo >> 28) & 3
 327             if t2 == 0:
 328                 t_name = 'Programmable|PPS'
 329                 flags = {
 330                     (1 << 29): 'power_limited',
 331                 }
 332                 minv = ((pdo >> 8) & 0xff) * 0.1
 333                 maxv = ((pdo >> 17) & 0xff) * 0.1
 334                 ma = ((pdo >> 0) & 0xff) * 0.05
 335                 p = '%g/%gV %gA' % (minv, maxv, ma)
 336                 if (pdo >> 27) & 0x1:
 337                     p += ' [limited]'
 338                 self.stored_pdos[idx] = '%s %g/%gV' % (t_name, minv, maxv)
 339             else:
 340                 t_name = 'Reserved APDO: '+bin(t2)
 341                 p = '[raw: %s]' % (bin(pdo))
 342                 self.stored_pdos[idx] = '%s %s' % (t_name, p)
 343         t_flags = ''
 344         for f in sorted(flags.keys(), reverse = True):
 345             if pdo & f:
 346                 t_flags += ' [' + flags[f] + ']'
 347         return '[%s] %s%s' % (t_name, p, t_flags)
 348
 349     def get_vdm(self, idx, data):
 350         if idx == 0:    # VDM header
 351             vid = data >> 16
 352             struct = data & (1 << 15)
 353             txt = 'VDM'
 354             if struct:  # Structured VDM
 355                 cmd = data & 0x1f
 356                 src = data & (1 << 5)
 357                 ack = (data >> 6) & 3
 358                 pos = (data >> 8) & 7
 359                 ver = (data >> 13) & 3
 360                 txt = VDM_ACK[ack] + ' '
 361                 txt += VDM_CMDS[cmd] if cmd in VDM_CMDS else 'cmd?'
 362                 txt += ' pos %d' % (pos) if pos else ' '
 363             else:   # Unstructured VDM
 364                 txt = 'unstruct [%04x]' % (data & 0x7fff)
 365             txt += ' SVID:%04x' % (vid)
 366         else:   # VDM payload
 367             txt = 'VDO:%08x' % (data)
 368         return txt
 369
 370     def get_bist(self, idx, data):
 371         mode = data >> 28
 372         counter = data & 0xffff
 373         mode_name = BIST_MODES[mode] if mode in BIST_MODES else 'INVALID'
 374         if mode == 2:
 375             mode_name = 'Counter[= %d]' % (counter)
 376         # TODO check all 0 bits are 0 / emit warnings
 377         return 'mode %s' % (mode_name) if idx == 0 else 'invalid BRO'
 378
 379     def putpayload(self, s0, s1, idx):
 380         t = self.head_type()
 381         txt = '['+str(idx+1)+'] '
 382         if t == 2:
 383             txt += self.get_request(self.data[idx])
 384         elif t == 1 or t == 4:
 385             txt += self.get_source_sink_cap(self.data[idx], idx+1, t==1)
 386         elif t == 15:
 387             txt += self.get_vdm(idx, self.data[idx])
 388         elif t == 3:
 389             txt += self.get_bist(idx, self.data[idx])
 390         self.putx(s0, s1, [11, [txt, txt]])
 391         self.text += ' - ' + txt
 392
 393     def puthead(self):
 394         ann_type = 9 if self.head_power_role() else 10
 395         role = 'SRC' if self.head_power_role() else 'SNK'
 396         if self.head_data_role() != self.head_power_role():
 397             role += '/DFP' if self.head_data_role() else '/UFP'
 398         t = self.head_type()
 399         if self.head_count() == 0:
 400             shortm = CTRL_TYPES[t]
 401         else:
 402             shortm = DATA_TYPES[t] if t in DATA_TYPES else 'DAT???'
 403
 404         longm = '(r{:d}) {:s}[{:d}]: {:s}'.format(self.head_rev(), role, self.head_id(), shortm)
 405         self.putx(0, -1, [ann_type, [longm, shortm]])
 406         self.text += longm
 407
 408     def head_id(self):
 409         return (self.head >> 9) & 7
 410
 411     def head_power_role(self):
 412         return (self.head >> 8) & 1
 413
 414     def head_data_role(self):
 415         return (self.head >> 5) & 1
 416
 417     def head_rev(self):
 418         return ((self.head >> 6) & 3) + 1
 419
 420     def head_type(self):
 421         return self.head & 0xF
 422
 423     def head_count(self):
 424         return (self.head >> 12) & 7
 425
 426     def putx(self, s0, s1, data):
 427         self.put(self.edges[s0], self.edges[s1], self.out_ann, data)
 428
 429     def putwarn(self, longm, shortm):
 430         self.putx(0, -1, [8, [longm, shortm]])
 431
 432     def compute_crc32(self):
 433         bdata = struct.pack('<H'+'I'*len(self.data), self.head & 0xffff,
 434                             *tuple([d & 0xffffffff for d in self.data]))
 435         return zlib.crc32(bdata)
 436
 437     def rec_sym(self, i, sym):
 438         self.putx(i, i+5, [7, SYM_NAME[sym]])
 439
 440     def get_sym(self, i, rec=True):
 441         v = (self.bits[i] | (self.bits[i+1] << 1) | (self.bits[i+2] << 2) |
 442              (self.bits[i+3] << 3) | (self.bits[i+4] << 4))
 443         sym = DEC4B5B[v]
 444         if rec:
 445             self.rec_sym(i, sym)
 446         return sym
 447
 448     def get_short(self):
 449         i = self.idx
 450         # Check it's not a truncated packet
 451         if len(self.bits) - i <= 20:
 452             self.putwarn('Truncated', '!')
 453             return 0x0BAD
 454         k = [self.get_sym(i), self.get_sym(i+5),
 455              self.get_sym(i+10), self.get_sym(i+15)]
 456         # TODO check bad symbols
 457         val = k[0] | (k[1] << 4) | (k[2] << 8) | (k[3] << 12)
 458         self.idx += 20
 459         return val
 460
 461     def get_word(self):
 462         lo = self.get_short()
 463         hi = self.get_short()
 464         return lo | (hi << 16)
 465
 466     def find_corrupted_sop(self, k):
 467         # Start of packet are valid even if they have only 3 correct symbols
 468         # out of 4.
 469         for seq in SOP_SEQUENCES:
 470             if [k[i] == seq[i] for i in range(len(k))].count(True) >= 3:
 471                 return START_OF_PACKETS[seq]
 472         return None
 473
 474     def scan_eop(self):
 475         for i in range(len(self.bits) - 19):
 476             k = (self.get_sym(i, rec=False), self.get_sym(i+5, rec=False),
 477                  self.get_sym(i+10, rec=False), self.get_sym(i+15, rec=False))
 478             sym = START_OF_PACKETS.get(k, None)
 479             if not sym:
 480                 sym = self.find_corrupted_sop(k)
 481             # We have an interesting symbol sequence
 482             if sym:
 483                 # annotate the preamble
 484                 self.putx(0, i, [1, ['Preamble', '...']])
 485                 # annotate each symbol
 486                 self.rec_sym(i, k[0])
 487                 self.rec_sym(i+5, k[1])
 488                 self.rec_sym(i+10, k[2])
 489                 self.rec_sym(i+15, k[3])
 490                 if sym == 'Hard Reset':
 491                     self.text += 'HRST'
 492                     return -1   # Hard reset
 493                 elif sym == 'Cable Reset':
 494                     self.text += 'CRST'
 495                     return -1   # Cable reset
 496                 else:
 497                     self.putx(i, i+20, [2, [sym, 'S']])
 498                 return i+20
 499         self.putx(0, len(self.bits), [1, ['Junk???', 'XXX']])
 500         self.text += 'Junk???'
 501         self.putwarn('No start of packet found', 'XXX')
 502         return -1   # No Start Of Packet
 503
 504     def __init__(self):
 505         self.reset()
 506
 507     def reset(self):
 508         self.samplerate = None
 509         self.idx = 0
 510         self.packet_seq = 0
 511         self.previous = 0
 512         self.startsample = None
 513         self.bits = []
 514         self.edges = []
 515         self.bad = []
 516         self.half_one = False
 517         self.start_one = 0
 518         self.stored_pdos = {}
 519         self.cap_mark = [0, 0, 0, 0, 0, 0, 0, 0]
 520
 521     def metadata(self, key, value):
 522         if key == srd.SRD_CONF_SAMPLERATE:
 523             self.samplerate = value
 524             # 0 is 2 UI, space larger than 1.5x 0 is definitely wrong
 525             self.maxbit = self.us2samples(3 * UI_US)
 526             # duration threshold between half 1 and 0
 527             self.threshold = self.us2samples(THRESHOLD_US)
 528
 529     def start(self):
 530         self.out_python = self.register(srd.OUTPUT_PYTHON)
 531         self.out_ann = self.register(srd.OUTPUT_ANN)
 532         self.out_binary = self.register(srd.OUTPUT_BINARY)
 533         self.out_bitrate = self.register(
 534             srd.OUTPUT_META,
 535             meta=(int, 'Bitrate', 'Bitrate during the packet')
 536         )
 537
 538     def us2samples(self, us):
 539         return int(us * self.samplerate / 1000000)
 540
 541     def decode_packet(self):
 542         self.data = []
 543         self.idx = 0
 544         self.text = ''
 545
 546         if len(self.edges) < 50:
 547             return  # Not a real PD packet
 548
 549         self.packet_seq += 1
 550         tstamp = float(self.startsample) / self.samplerate
 551         self.text += '#%-4d (%8.6fms): ' % (self.packet_seq, tstamp*1000)
 552
 553         self.idx = self.scan_eop()
 554         if self.idx < 0:
 555             # Full text trace of the issue
 556             self.putx(0, self.idx, [12, [self.text, '...']])
 557             return  # No real packet: ABORT
 558
 559         # Packet header
 560         self.head = self.get_short()
 561         self.putx(self.idx-20, self.idx, [3, ['H:%04x' % (self.head), 'HD']])
 562         self.puthead()
 563
 564         # Decode data payload
 565         for i in range(self.head_count()):
 566             self.data.append(self.get_word())
 567             self.putx(self.idx-40, self.idx,
 568                       [4, ['[%d]%08x' % (i, self.data[i]), 'D%d' % (i)]])
 569             self.putpayload(self.idx-40, self.idx, i)
 570
 571         # CRC check
 572         self.crc = self.get_word()
 573         ccrc = self.compute_crc32()
 574         if self.crc != ccrc:
 575             self.putwarn('Bad CRC %08x != %08x' % (self.crc, ccrc), 'CRC!')
 576         self.putx(self.idx-40, self.idx, [5, ['CRC:%08x' % (self.crc), 'CRC']])
 577
 578         # End of Packet
 579         if len(self.bits) >= self.idx + 5 and self.get_sym(self.idx) == EOP:
 580             self.putx(self.idx, self.idx + 5, [6, ['EOP', 'E']])
 581             self.idx += 5
 582         else:
 583             self.putwarn('No EOP', 'EOP!')
 584         # Full text trace
 585         if self.options['fulltext'] == 'yes':
 586             self.putx(0, self.idx, [12, [self.text, '...']])
 587
 588         # Meta data for bitrate
 589         ss, es = self.edges[0], self.edges[-1]
 590         bitrate = self.samplerate*len(self.bits) / float(es - ss)
 591         self.put(es, ss, self.out_bitrate, int(bitrate))
 592         # Raw binary data (BMC decoded)
 593         self.put(es, ss, self.out_binary, [0, bytes(self.bits)])
 594
 595     def decode(self):
 596         if not self.samplerate:
 597             raise SamplerateError('Cannot decode without samplerate.')
 598         while True:
 599             pins = self.wait([{0: 'e'}, {1: 'e'}, {'skip': int(self.samplerate/1e3)}])
 600
 601             # First sample of the packet, just record the start date
 602             if not self.startsample:
 603                 self.startsample = self.samplenum
 604                 self.previous = self.samplenum
 605                 continue
 606
 607             diff = self.samplenum - self.previous
 608
 609             # Large idle: use it as the end of packet
 610             if diff > self.maxbit:
 611                 # the last edge of the packet
 612                 self.edges.append(self.previous)
 613                 # Export the packet
 614                 self.decode_packet()
 615                 # Reset for next packet
 616                 self.startsample = self.samplenum
 617                 self.bits = []
 618                 self.edges = []
 619                 self.bad = []
 620                 self.half_one = False
 621                 self.start_one = 0
 622             else:   # add the bit to the packet
 623                 is_zero = diff > self.threshold
 624                 if is_zero and not self.half_one:
 625                     self.bits.append(0)
 626                     self.edges.append(self.previous)
 627                 elif not is_zero and self.half_one:
 628                     self.bits.append(1)
 629                     self.edges.append(self.start_one)
 630                     self.half_one = False
 631                 elif not is_zero and not self.half_one:
 632                     self.half_one = True
 633                     self.start_one = self.previous
 634                 else:   # Invalid BMC sequence
 635                     self.bad.append((self.start_one, self.previous))
 636                     # TODO try to recover
 637                     self.bits.append(0)
 638                     self.edges.append(self.previous)
 639                     self.half_one = False
 640             self.previous = self.samplenum