decoders/ook/pd.py

   1 ##
   2 ## This file is part of the libsigrokdecode project.
   3 ##
   4 ## Copyright (C) 2018 Steve R <steversig@virginmedia.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, see <http://www.gnu.org/licenses/>.
  18 ##
  19
  20 import sigrokdecode as srd
  21
  22 '''
  23 OUTPUT_PYTHON format:
  24 Samples:    The Samples array is sent when a DECODE_TIMEOUT occurs.
  25 [<start>, <finish>, <state>]
  26 <start> is the sample number of the start of the decoded bit. This may not line
  27 up with the pulses that were converted into the decoded bit particularly for
  28 Manchester encoding.
  29 <finish> is the sample number of the end of the decoded bit.
  30 <state> is a single character string which is the state of the decoded bit.
  31 This can be
  32 '0'   zero or low
  33 '1'   one or high
  34 'E'   Error or invalid. This can be caused by missing transitions or the wrong
  35 pulse lengths according to the rules for the particular encoding. In some cases
  36 this is intentional (Oregon 1 preamble) and is part of the sync pattern. In
  37 other cases the signal could simply be broken.
  38
  39 If there are more than self.max_errors (default 5) in decoding then the
  40 OUTPUT_PYTHON is not sent as the data is assumed to be worthless.
  41 There also needs to be a low for five times the preamble period at the end of
  42 each set of pulses to trigger a DECODE_TIMEOUT and get the OUTPUT_PYTHON sent.
  43 '''
  44
  45 class SamplerateError(Exception):
  46     pass
  47
  48 class Decoder(srd.Decoder):
  49     api_version = 3
  50     id = 'ook'
  51     name = 'OOK'
  52     longname = 'On-off keying'
  53     desc = 'On-off keying protocol.'
  54     license = 'gplv2+'
  55     inputs = ['logic']
  56     outputs = ['ook']
  57     channels = (
  58         {'id': 'data', 'name': 'Data', 'desc': 'Data line'},
  59     )
  60     annotations = (
  61         ('frame', 'Frame'),
  62         ('info', 'Info'),
  63         ('1111', '1111'),
  64         ('1010', '1010'),
  65         ('diffman', 'Diff Man'),
  66         ('nrz', 'NRZ'),
  67     )
  68     annotation_rows = (
  69         ('frame', 'Framing',(0,)),
  70         ('info', 'Info', (1,)),
  71         ('man1111', 'Man 1111', (2,)),
  72         ('man1010', 'Man 1010', (3,)),
  73         ('diffman', 'Diff Man', (4,)),
  74         ('nrz', 'NRZ', (5,)),
  75     )
  76     binary = (
  77         ('pulse-lengths', 'Pulse lengths'),
  78     )
  79     options = (
  80         {'id': 'invert', 'desc': 'Invert data', 'default': 'no',
  81          'values': ('no', 'yes')},
  82         {'id': 'decodeas', 'desc': 'Decode type', 'default': 'Manchester',
  83          'values': ('NRZ', 'Manchester', 'Diff Manchester')},
  84         {'id': 'preamble', 'desc': 'Preamble', 'default': 'auto',
  85          'values': ('auto', '1010', '1111')},
  86         {'id': 'preamlen', 'desc': 'Filter length', 'default': '7',
  87          'values': ('0', '3', '4', '5', '6', '7', '8', '9', '10')},
  88         {'id': 'diffmanvar', 'desc': 'Transition at start', 'default': '1',
  89          'values': ('1', '0')},
  90     )
  91
  92     def __init__(self):
  93         self.reset()
  94
  95     def reset(self):
  96         self.samplerate = None
  97         self.ss = self.es = -1
  98         self.ss_1111 = self.ss_1010 = -1
  99         self.samplenumber_last = None
 100         self.sample_first = None
 101         self.sample_high = 0
 102         self.sample_low = 0
 103         self.edge_count = 0
 104         self.word_first = None
 105         self.word_count = 0
 106         self.state = 'IDLE'
 107         self.lstate = None
 108         self.lstate_1010 = None
 109         self.insync = 0                 # Preamble in sync flag
 110         self.man_errors = 0
 111         self.man_errors_1010 = 0
 112         self.preamble = []              # Preamble buffer
 113         self.half_time = -1             # Half time for man 1111
 114         self.half_time_1010 = 0         # Half time for man 1010
 115         self.pulse_lengths = []         # Pulse lengths
 116         self.decoded = []               # Decoded stream
 117         self.decoded_1010 = []          # Decoded stream
 118         self.diff_man_trans = '0'       # Transition
 119         self.diff_man_len = 1           # Length of pulse in half clock periods
 120         self.max_errors = 5             # Max number of errors to output OOK
 121
 122     def metadata(self, key, value):
 123         if key == srd.SRD_CONF_SAMPLERATE:
 124             self.samplerate = value
 125
 126     def start(self):
 127         self.out_ann = self.register(srd.OUTPUT_ANN)
 128         self.out_python = self.register(srd.OUTPUT_PYTHON)
 129         self.out_binary = self.register(srd.OUTPUT_BINARY)
 130         self.invert = self.options['invert']
 131         self.decodeas = self.options['decodeas']
 132         self.preamble_val = self.options['preamble']
 133         self.preamble_len = self.options['preamlen']
 134         self.diffmanvar = self.options['diffmanvar']
 135
 136     def putx(self, data):
 137         self.put(self.ss, self.es, self.out_ann, data)
 138
 139     def putp(self, data):
 140         self.put(self.ss, self.es, self.out_python, data)
 141
 142     def dump_pulse_lengths(self):
 143         if self.samplerate:
 144             self.pulse_lengths[-1] = self.sample_first # Fix final pulse length.
 145             s = 'Pulses(us)='
 146             s += ','.join(str(int(int(x) * 1000000 / self.samplerate))
 147                           for x in self.pulse_lengths)
 148             s += '\n'
 149             self.put(self.samplenum - 10, self.samplenum, self.out_binary,
 150                      [0, bytes([ord(c) for c in s])])
 151
 152     def decode_nrz(self, start, samples, state):
 153         self.pulse_lengths.append(samples)
 154         # Use different high and low widths to compensate skewed waveforms.
 155         dsamples = self.sample_high if state == '1' else self.sample_low
 156         self.ss, self.es = start, start + samples
 157         while samples > dsamples * 0.5:
 158             if samples >= dsamples * 1.5: # More than one bit.
 159                 self.es = self.ss + dsamples
 160                 self.putx([5, [state]])
 161                 self.decoded.append([self.ss, self.es, state])
 162                 self.edge_count += 1
 163             elif samples >= dsamples * 0.5 and samples < dsamples * 1.5: # Last bit.
 164                 self.putx([5, [state]])
 165                 self.decoded.append([self.ss, self.es, state])
 166                 self.edge_count += 1
 167             else:
 168                 self.edge_count += 1
 169             samples -= dsamples
 170             self.ss += dsamples
 171             self.es += dsamples
 172
 173             # Ensure 2nd row doesn't go past end of 1st row.
 174             if self.es > self.samplenum:
 175                 self.es = self.samplenum
 176
 177             if self.state == 'DECODE_TIMEOUT': # Five bits - reset.
 178                 self.ss = self.decoded[0][0]
 179                 self.es = self.decoded[len(self.decoded) - 1][1]
 180                 self.dump_pulse_lengths()
 181                 self.putp(self.decoded)
 182                 self.decode_timeout()
 183                 break
 184
 185     def lock_onto_preamble(self, samples, state): # Filters and recovers clock.
 186         self.edge_count += 1
 187         l2s = 5 # Max ratio of long to short pulses.
 188
 189         # Filter incoming pulses to remove random noise.
 190         if self.state == 'DECODE_TIMEOUT':
 191             self.preamble = []
 192             self.edge_count == 0
 193             self.word_first = self.samplenum
 194             self.sample_first = self.samplenum - self.samplenumber_last
 195             self.state = 'WAITING_FOR_PREAMBLE'
 196             self.man_errors = 0
 197
 198         pre_detect = int(self.preamble_len) # Number of valid pulses to detect.
 199         pre_samples = self.samplenum - self.samplenumber_last
 200         if len(self.preamble) > 0:
 201             if (pre_samples * l2s < self.preamble[-1][1] or
 202                 self.preamble[-1][1] * l2s < pre_samples): # Garbage in.
 203                 self.put(self.samplenum, self.samplenum,
 204                          self.out_ann, [0, ['R']]) # Display resets.
 205                 self.preamble = [] # Clear buffer.
 206                 self.preamble.append([self.samplenumber_last,
 207                                      pre_samples, state])
 208                 self.edge_count == 0
 209                 self.samplenumber_last = self.samplenum
 210                 self.word_first = self.samplenum
 211             else:
 212                 self.preamble.append([self.samplenumber_last,
 213                                      pre_samples, state])
 214         else:
 215             self.preamble.append([self.samplenumber_last,
 216                                  pre_samples, state])
 217
 218         pre = self.preamble
 219         if len(self.preamble) == pre_detect: # Have a valid series of pulses.
 220             if self.preamble[0][2] == '1':
 221                 self.sample_high = self.preamble[0][1] # Allows skewed pulses.
 222                 self.sample_low = self.preamble[1][1]
 223             else:
 224                 self.sample_high = self.preamble[1][1]
 225                 self.sample_low = self.preamble[0][1]
 226
 227             self.edge_count = 0
 228
 229             for i in range(len(self.preamble)):
 230                 if i > 1:
 231                     if (pre[i][1] > pre[i - 2][1] * 1.25 or
 232                         pre[i][1] * 1.25 < pre[i - 2][1]): # Adjust ref width.
 233                         if pre[i][2] == '1':
 234                             self.sample_high = pre[i][1]
 235                         else:
 236                             self.sample_low = pre[i][1]
 237
 238                 # Display start of preamble.
 239                 if self.decodeas == 'NRZ':
 240                     self.decode_nrz(pre[i][0], pre[i][1], pre[i][2])
 241                 if self.decodeas == 'Manchester':
 242                     self.decode_manchester(pre[i][0], pre[i][1], pre[i][2])
 243                 if self.decodeas == 'Diff Manchester':
 244                     self.es = pre[i][0] + pre[i][1]
 245                     self.decode_diff_manchester(pre[i][0], pre[i][1], pre[i][2])
 246
 247                 # Used to timeout signal.
 248                 self.sample_first = int((self.sample_high + self.sample_low)/2)
 249             self.insync = 1
 250             self.state = 'DECODING'
 251         self.lstate = state
 252         self.lstate_1010 = state
 253
 254     def decode_diff_manchester(self, start, samples, state):
 255         self.pulse_lengths.append(samples)
 256
 257         # Use different high and low widths to compensate skewed waveforms.
 258         dsamples = self.sample_high if state == '1' else self.sample_low
 259
 260         self.es = start + samples
 261         p_length = round(samples / dsamples) # Find relative pulse length.
 262
 263         if self.edge_count == 0:
 264             self.diff_man_trans = '1'  # Very first pulse must be a transition.
 265             self.diff_man_len = 1      # Must also be a half pulse.
 266             self.ss = start
 267         elif self.edge_count % 2 == 1: # Time to make a decision.
 268             if self.diffmanvar == '0': # Transition at self.ss is a zero.
 269                 self.diff_man_trans = '0' if self.diff_man_trans == '1' else '1'
 270             if self.diff_man_len == 1 and p_length == 1:
 271                 self.putx([4, [self.diff_man_trans]])
 272                 self.decoded.append([self.ss, self.es, self.diff_man_trans])
 273                 self.diff_man_trans = '1'
 274             elif self.diff_man_len == 1 and p_length == 2:
 275                 self.es -= int(samples / 2)
 276                 self.putx([4, [self.diff_man_trans]])
 277                 self.decoded.append([self.ss, self.es, self.diff_man_trans])
 278                 self.diff_man_trans = '0'
 279                 self.edge_count += 1 # Add a virt edge to keep in sync with clk.
 280             elif self.diff_man_len == 2 and p_length == 1:
 281                 self.putx([4, [self.diff_man_trans]])
 282                 self.decoded.append([self.ss, self.es, self.diff_man_trans])
 283                 self.diff_man_trans = '1'
 284             elif self.diff_man_len == 2 and p_length == 2: # Double illegal E E.
 285                 self.es -= samples
 286                 self.putx([4, ['E']])
 287                 self.decoded.append([self.ss, self.es, 'E'])
 288                 self.ss = self.es
 289                 self.es += samples
 290                 self.putx([4, ['E']])
 291                 self.decoded.append([self.ss, self.es, 'E'])
 292                 self.diff_man_trans = '1'
 293             elif self.diff_man_len == 1 and p_length > 4:
 294                 if self.state == 'DECODE_TIMEOUT':
 295                     self.es = self.ss + 2 * self.sample_first
 296                     self.putx([4, [self.diff_man_trans]]) # Write error.
 297                     self.decoded.append([self.ss, self.es, self.diff_man_trans])
 298                     self.ss = self.decoded[0][0]
 299                     self.es = self.decoded[len(self.decoded) - 1][1]
 300                     self.dump_pulse_lengths()
 301                     if self.man_errors < self.max_errors:
 302                         self.putp(self.decoded)
 303                     else:
 304                         error_message = 'Probably not Diff Manchester encoded'
 305                         self.ss = self.word_first
 306                         self.putx([1, [error_message]])
 307                     self.decode_timeout()
 308                 self.diff_man_trans = '1'
 309             self.ss = self.es
 310         self.diff_man_len = p_length # Save the previous length.
 311         self.edge_count += 1
 312
 313     def decode_manchester_sim(self, start, samples, state,
 314                               dsamples, half_time, lstate, ss, pream):
 315         ook_bit = []
 316         errors = 0
 317         if self.edge_count == 0:
 318             half_time += 1
 319         if samples > 0.75 * dsamples and samples <= 1.5 * dsamples: # Long p.
 320             half_time += 2
 321             if half_time % 2 == 0: # Transition.
 322                 es = start
 323             else:
 324                 es = start + int(samples / 2)
 325             if ss == start:
 326                 lstate = 'E'
 327                 es = start + samples
 328             if not (self.edge_count == 0 and pream == '1010'): # Skip first p.
 329                 ook_bit = [ss, es, lstate]
 330             lstate = state
 331             ss = es
 332         elif samples > 0.25 * dsamples and samples <= 0.75 * dsamples: # Short p.
 333             half_time += 1
 334             if (half_time % 2 == 0): # Transition.
 335                 es = start + samples
 336                 ook_bit = [ss, es, lstate]
 337                 lstate = state
 338                 ss = es
 339             else: # 1st half.
 340                 ss = start
 341                 lstate = state
 342         else: # Too long or too short - error.
 343             errors = 1
 344             if self.state != 'DECODE_TIMEOUT': # Error condition.
 345                 lstate = 'E'
 346                 es = ss + samples
 347             else: # Assume final half bit buried in timeout pulse.
 348                 es = ss + self.sample_first
 349             ook_bit = [ss, es, lstate]
 350             ss = es
 351
 352         return (half_time, lstate, ss, ook_bit, errors)
 353
 354     def decode_manchester(self, start, samples, state):
 355         self.pulse_lengths.append(samples)
 356
 357         # Use different high and low widths to compensate skewed waveforms.
 358         dsamples = self.sample_high if state == '1' else self.sample_low
 359
 360         if self.preamble_val != '1010': # 1111 preamble is half clock T.
 361             (self.half_time, self.lstate, self.ss_1111, ook_bit, errors) = (
 362              self.decode_manchester_sim(start, samples, state, dsamples * 2,
 363                                     self.half_time, self.lstate,
 364                                     self.ss_1111, '1111'))
 365             self.man_errors += errors
 366             if ook_bit != []:
 367                 self.decoded.append([ook_bit[0], ook_bit[1], ook_bit[2]])
 368
 369         if self.preamble_val != '1111': # 1010 preamble is clock T.
 370             (self.half_time_1010, self.lstate_1010, self.ss_1010,
 371              ook_bit, errors) = (
 372               self.decode_manchester_sim(start, samples, state, dsamples,
 373                                     self.half_time_1010, self.lstate_1010,
 374                                     self.ss_1010, '1010'))
 375             self.man_errors_1010 += errors
 376             if ook_bit != []:
 377                 self.decoded_1010.append([ook_bit[0], ook_bit[1], ook_bit[2]])
 378
 379         self.edge_count += 1
 380
 381         # Stream display and save ook_bit.
 382         if ook_bit != []:
 383             self.ss, self.es = ook_bit[0], ook_bit[1]
 384             if self.preamble_val == '1111':
 385                 self.putx([2, [ook_bit[2]]])
 386             if self.preamble_val == '1010':
 387                 self.putx([3, [ook_bit[2]]])
 388
 389         if self.state == 'DECODE_TIMEOUT': # End of packet.
 390             self.dump_pulse_lengths()
 391
 392             decoded = []
 393             # If 1010 preamble has less errors use it.
 394             if (self.preamble_val == '1010' or
 395                 (self.man_errors_1010 < self.max_errors and
 396                 self.man_errors_1010 < self.man_errors and
 397                 len(self.decoded_1010) > 0)):
 398                 decoded = self.decoded_1010
 399                 man_errors = self.man_errors_1010
 400                 d_row = 3
 401             else:
 402                 decoded = self.decoded
 403                 man_errors = self.man_errors
 404                 d_row = 2
 405
 406             if self.preamble_val == 'auto': # Display OOK packet.
 407                 for i in range(len(decoded)):
 408                     self.ss, self.es = decoded[i][0], decoded[i][1]
 409                     self.putx([d_row, [decoded[i][2]]])
 410
 411             if (man_errors < self.max_errors and len(decoded) > 0):
 412                 self.ss, self.es = decoded[0][0], decoded[len(decoded) - 1][1]
 413                 self.putp(decoded)
 414             else:
 415                 error_message = 'Not Manchester encoded or wrong preamble'
 416                 self.ss = self.word_first
 417                 self.putx([1, [error_message]])
 418
 419             self.put(self.es, self.es, self.out_ann, [0, ['T']]) # Mark timeout.
 420             self.decode_timeout()
 421
 422     def decode_timeout(self):
 423         self.word_count = 0
 424         self.samplenumber_last = None
 425         self.edge_count = 0
 426         self.man_errors = 0                     # Clear the bit error counters.
 427         self.man_errors_1010 = 0
 428         self.state = 'IDLE'
 429         self.wait({0: 'e'})                     # Get rid of long pulse.
 430         self.samplenumber_last = self.samplenum
 431         self.word_first = self.samplenum
 432         self.insync = 0                         # Preamble in sync flag
 433         self.preamble = []                      # Preamble buffer
 434         self.half_time = -1                     # Half time for man 1111
 435         self.half_time_1010 = 0                 # Half time for man 1010
 436         self.decoded = []                       # Decoded bits
 437         self.decoded_1010 = []                  # Decoded bits for man 1010
 438         self.pulse_lengths = []
 439
 440     def decode(self):
 441         while True:
 442             if self.edge_count == 0: # Waiting for a signal.
 443                 pin = self.wait({0: 'e'})
 444                 self.state = 'DECODING'
 445             else:
 446                 pin = self.wait([{0: 'e'}, {'skip': 5 * self.sample_first}])
 447                 if self.matched[1] and not self.matched[0]: # No edges for 5 p's.
 448                     self.state = 'DECODE_TIMEOUT'
 449
 450             if not self.samplenumber_last: # Set counters to start of signal.
 451                 self.samplenumber_last = self.samplenum
 452                 self.word_first = self.samplenum
 453                 continue
 454             samples = self.samplenum - self.samplenumber_last
 455             if not self.sample_first: # Get number of samples for first pulse.
 456                 self.sample_first = samples
 457
 458             pinstate = pin[0]
 459             if self.state == 'DECODE_TIMEOUT': # No edge so flip the state.
 460                 pinstate = int(not pinstate)
 461             if self.invert == 'yes': # Invert signal.
 462                 pinstate = int(not pinstate)
 463             state = '0' if pinstate else '1'
 464
 465             # No preamble filtering or checking and no skew correction.
 466             if self.preamble_len == '0':
 467                 self.sample_high = self.sample_first
 468                 self.sample_low = self.sample_first
 469                 self.insync = 0
 470
 471             if self.insync == 0:
 472                 self.lock_onto_preamble(samples, state)
 473             else:
 474                 if self.decodeas == 'NRZ':
 475                     self.decode_nrz(self.samplenumber_last, samples, state)
 476                 if self.decodeas == 'Manchester':
 477                     self.decode_manchester(self.samplenumber_last,
 478                                            samples, state)
 479                 if self.decodeas == 'Diff Manchester':
 480                     self.decode_diff_manchester(self.samplenumber_last,
 481                                                 samples, state)
 482
 483             self.samplenumber_last = self.samplenum