f8f745284f43351a229879fdd8301d62c2cd2003
[libsigrokdecode.git] / 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             mystring = 'Pulses(us)='
146             mystring += ','.join(str(int(int(x) * 1000000 / self.samplerate))
147                                  for x in self.pulse_lengths)
148             mystring += '\n'
149             self.put(self.samplenum - 10, self.samplenum, self.out_binary,
150                      [0, bytes([ord(c) for c in mystring])])
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         if state == '1':
156             dsamples = self.sample_high
157         else:
158             dsamples = self.sample_low
159         self.ss = start
160         self.es = start + samples
161         while samples > dsamples * 0.5:
162             if samples >= dsamples * 1.5: # More than one bit.
163                 self.es = self.ss + dsamples
164                 self.putx([5, [state]])
165                 self.decoded.append([self.ss, self.es, state])
166                 self.edge_count += 1
167             elif samples >= dsamples * 0.5 and samples < dsamples * 1.5: # Last bit.
168                 self.putx([5, [state]])
169                 self.decoded.append([self.ss, self.es, state])
170                 self.edge_count += 1
171             else:
172                 self.edge_count += 1
173             samples -= dsamples
174             self.ss += dsamples
175             self.es += dsamples
176
177             # Ensure 2nd row doesn't go past end of 1st row.
178             if self.es > self.samplenum:
179                 self.es = self.samplenum
180
181             if self.state == 'DECODE_TIMEOUT': # Five bits - reset.
182                 self.ss = self.decoded[0][0]
183                 self.es = self.decoded[len(self.decoded) - 1][1]
184                 self.dump_pulse_lengths()
185                 self.putp(self.decoded)
186                 self.decode_timeout()
187                 break
188
189     def lock_onto_preamble(self, samples, state): # Filters and recovers clock.
190         self.edge_count += 1
191         l2s = 5 # Max ratio of long to short pulses.
192
193         # Filter incoming pulses to remove random noise.
194         if self.state == 'DECODE_TIMEOUT':
195             self.preamble = []
196             self.edge_count == 0
197             self.word_first = self.samplenum
198             self.sample_first = self.samplenum - self.samplenumber_last
199             self.state = 'WAITING_FOR_PREAMBLE'
200             self.man_errors = 0
201
202         pre_detect = int(self.preamble_len) # Number of valid pulses to detect.
203         pre_samples = self.samplenum - self.samplenumber_last
204         if len(self.preamble) > 0:
205             if (pre_samples * l2s < self.preamble[-1][1] or
206                 self.preamble[-1][1] * l2s < pre_samples): # Garbage in.
207                 self.put(self.samplenum, self.samplenum,
208                          self.out_ann, [0, ['R']]) # Display resets.
209                 self.preamble = [] # Clear buffer.
210                 self.preamble.append([self.samplenumber_last,
211                                      pre_samples, state])
212                 self.edge_count == 0
213                 self.samplenumber_last = self.samplenum
214                 self.word_first = self.samplenum
215             else:
216                 self.preamble.append([self.samplenumber_last,
217                                      pre_samples, state])
218         else:
219             self.preamble.append([self.samplenumber_last,
220                                  pre_samples, state])
221
222         pre = self.preamble
223         if len(self.preamble) == pre_detect: # Have a valid series of pulses.
224             if self.preamble[0][2] == '1':
225                 self.sample_high = self.preamble[0][1] # Allows skewed pulses.
226                 self.sample_low = self.preamble[1][1]
227             else:
228                 self.sample_high = self.preamble[1][1]
229                 self.sample_low = self.preamble[0][1]
230
231             self.edge_count = 0
232
233             for i in range(len(self.preamble)):
234                 if i > 1:
235                     if (pre[i][1] > pre[i - 2][1] * 1.25 or
236                         pre[i][1] * 1.25 < pre[i - 2][1]): # Adjust ref width.
237                         if pre[i][2] == '1':
238                             self.sample_high = pre[i][1]
239                         else:
240                             self.sample_low = pre[i][1]
241
242                 # Display start of preamble.
243                 if self.decodeas == 'NRZ':
244                     self.decode_nrz(pre[i][0], pre[i][1], pre[i][2])
245                 if self.decodeas == 'Manchester':
246                     self.decode_manchester(pre[i][0], pre[i][1], pre[i][2])
247                 if self.decodeas == 'Diff Manchester':
248                     self.es = pre[i][0] + pre[i][1]
249                     self.decode_diff_manchester(pre[i][0], pre[i][1], pre[i][2])
250
251                 # Used to timeout signal.
252                 self.sample_first = int((self.sample_high + self.sample_low)/2)
253             self.insync = 1
254             self.state = 'DECODING'
255         self.lstate = state
256         self.lstate_1010 = state
257
258     def decode_diff_manchester(self, start, samples, state):
259         self.pulse_lengths.append(samples)
260
261         # Use different high and low widths to compensate skewed waveforms.
262         if state == '1':
263             dsamples = self.sample_high
264         else:
265             dsamples = self.sample_low
266
267         self.es = start + samples
268         p_length = round(samples / dsamples) # Find relative pulse length.
269
270         if self.edge_count == 0:
271             self.diff_man_trans = '1'  # Very first pulse must be a transition.
272             self.diff_man_len = 1      # Must also be a half pulse.
273             self.ss = start
274         elif self.edge_count % 2 == 1: # Time to make a decision.
275             if self.diffmanvar == '0': # Transition at self.ss is a zero.
276                 self.diff_man_trans = '0' if self.diff_man_trans == '1' else '1'
277             if self.diff_man_len == 1 and p_length == 1:
278                 self.putx([4, [self.diff_man_trans]])
279                 self.decoded.append([self.ss, self.es, self.diff_man_trans])
280                 self.diff_man_trans = '1'
281             elif self.diff_man_len == 1 and p_length == 2:
282                 self.es -= int(samples / 2)
283                 self.putx([4, [self.diff_man_trans]])
284                 self.decoded.append([self.ss, self.es, self.diff_man_trans])
285                 self.diff_man_trans = '0'
286                 self.edge_count += 1 # Add a virt edge to keep in sync with clk.
287             elif self.diff_man_len == 2 and p_length == 1:
288                 self.putx([4, [self.diff_man_trans]])
289                 self.decoded.append([self.ss, self.es, self.diff_man_trans])
290                 self.diff_man_trans = '1'
291             elif self.diff_man_len == 2 and p_length == 2: # Double illegal E E.
292                 self.es -= samples
293                 self.putx([4, ['E']])
294                 self.decoded.append([self.ss, self.es, 'E'])
295                 self.ss = self.es
296                 self.es += samples
297                 self.putx([4, ['E']])
298                 self.decoded.append([self.ss, self.es, 'E'])
299                 self.diff_man_trans = '1'
300             elif self.diff_man_len == 1 and p_length > 4:
301                 if self.state == 'DECODE_TIMEOUT':
302                     self.es = self.ss + 2 * self.sample_first
303                     self.putx([4, [self.diff_man_trans]]) # Write error.
304                     self.decoded.append([self.ss, self.es, self.diff_man_trans])
305                     self.ss = self.decoded[0][0]
306                     self.es = self.decoded[len(self.decoded) - 1][1]
307                     self.dump_pulse_lengths()
308                     if self.man_errors < self.max_errors:
309                         self.putp(self.decoded)
310                     else:
311                         error_message = 'Probably not Diff Manchester encoded'
312                         self.ss = self.word_first
313                         self.putx([1, [error_message]])
314                     self.decode_timeout()
315                 self.diff_man_trans = '1'
316             self.ss = self.es
317         self.diff_man_len = p_length # Save the previous length.
318         self.edge_count += 1
319
320     def decode_manchester_sim(self, start, samples, state,
321                               dsamples, half_time, lstate, ss, pream):
322         ook_bit = []
323         errors = 0
324         if self.edge_count == 0:
325             half_time += 1
326         if samples > 0.75 * dsamples and samples <= 1.5 * dsamples: # Long p.
327             half_time += 2
328             if half_time % 2 == 0: # Transition.
329                 es = start
330             else:
331                 es = start + int(samples / 2)
332             if ss == start:
333                 lstate = 'E'
334                 es = start + samples
335             if not (self.edge_count == 0 and pream == '1010'): # Skip first p.
336                 ook_bit = [ss, es, lstate]
337             lstate = state
338             ss = es
339         elif samples > 0.25 * dsamples and samples <= 0.75 * dsamples: # Short p.
340             half_time += 1
341             if (half_time % 2 == 0): # Transition.
342                 es = start + samples
343                 ook_bit = [ss, es, lstate]
344                 lstate = state
345                 ss = es
346             else: # 1st half.
347                 ss = start
348                 lstate = state
349         else: # Too long or too short - error.
350             errors = 1
351             if self.state != 'DECODE_TIMEOUT': # Error condition.
352                 lstate = 'E'
353                 es = ss + samples
354             else: # Assume final half bit buried in timeout pulse.
355                 es = ss + self.sample_first
356             ook_bit = [ss, es, lstate]
357             ss = es
358
359         return (half_time, lstate, ss, ook_bit, errors)
360
361     def decode_manchester(self, start, samples, state):
362         self.pulse_lengths.append(samples)
363
364         # Use different high and low widths to compensate skewed waveforms.
365         if state == '1':
366             dsamples = self.sample_high
367         else:
368             dsamples = self.sample_low
369
370         if self.preamble_val != '1010': # 1111 preamble is half clock T.
371             (self.half_time, self.lstate, self.ss_1111, ook_bit, errors) = (
372              self.decode_manchester_sim(start, samples, state, dsamples * 2,
373                                     self.half_time, self.lstate,
374                                     self.ss_1111, '1111'))
375             self.man_errors += errors
376             if ook_bit != []:
377                 self.decoded.append([ook_bit[0], ook_bit[1], ook_bit[2]])
378
379         if self.preamble_val != '1111': # 1010 preamble is clock T.
380             (self.half_time_1010, self.lstate_1010, self.ss_1010,
381              ook_bit, errors) = (
382               self.decode_manchester_sim(start, samples, state, dsamples,
383                                     self.half_time_1010, self.lstate_1010,
384                                     self.ss_1010, '1010'))
385             self.man_errors_1010 += errors
386             if ook_bit != []:
387                 self.decoded_1010.append([ook_bit[0], ook_bit[1], ook_bit[2]])
388
389         self.edge_count += 1
390
391         # Stream display and save ook_bit.
392         if ook_bit != []:
393             self.ss = ook_bit[0]
394             self.es = ook_bit[1]
395             if self.preamble_val == '1111':
396                 self.putx([2, [ook_bit[2]]])
397             if self.preamble_val == '1010':
398                 self.putx([3, [ook_bit[2]]])
399
400         if self.state == 'DECODE_TIMEOUT': # End of packet.
401             self.dump_pulse_lengths()
402
403             decoded = []
404             # If 1010 preamble has less errors use it.
405             if (self.preamble_val == '1010' or
406                 (self.man_errors_1010 < self.max_errors and
407                 self.man_errors_1010 < self.man_errors and
408                 len(self.decoded_1010) > 0)):
409                 decoded = self.decoded_1010
410                 man_errors = self.man_errors_1010
411                 d_row = 3
412             else:
413                 decoded = self.decoded
414                 man_errors = self.man_errors
415                 d_row = 2
416
417             if self.preamble_val == 'auto': # Display OOK packet.
418                 for i in range(len(decoded)):
419                     self.ss = decoded[i][0]
420                     self.es = decoded[i][1]
421                     self.putx([d_row, [decoded[i][2]]])
422
423             if (man_errors < self.max_errors and len(decoded) > 0):
424                 self.ss = decoded[0][0]
425                 self.es = decoded[len(decoded) - 1][1]
426                 self.putp(decoded)
427             else:
428                 error_message = 'Not Manchester encoded or wrong preamble'
429                 self.ss = self.word_first
430                 self.putx([1, [error_message]])
431
432             self.put(self.es, self.es, self.out_ann, [0, ['T']]) # Mark timeout.
433             self.decode_timeout()
434
435     def decode_timeout(self):
436         self.word_count = 0
437         self.samplenumber_last = None
438         self.edge_count = 0
439         self.man_errors = 0                     # Clear the bit error counters.
440         self.man_errors_1010 = 0
441         self.state = 'IDLE'
442         self.wait({0: 'e'})                     # Get rid of long pulse.
443         self.samplenumber_last = self.samplenum
444         self.word_first = self.samplenum
445         self.insync = 0                         # Preamble in sync flag
446         self.preamble = []                      # Preamble buffer
447         self.half_time = -1                     # Half time for man 1111
448         self.half_time_1010 = 0                 # Half time for man 1010
449         self.decoded = []                       # Decoded bits
450         self.decoded_1010 = []                  # Decoded bits for man 1010
451         self.pulse_lengths = []
452
453     def decode(self):
454         while True:
455             if self.edge_count == 0: # Waiting for a signal.
456                 pin = self.wait({0: 'e'})
457                 self.state = 'DECODING'
458             else:
459                 pin = self.wait([{0: 'e'}, {'skip': 5 * self.sample_first}])
460                 if self.matched[1] and not self.matched[0]: # No edges for 5 p's.
461                     self.state = 'DECODE_TIMEOUT'
462
463             if not self.samplenumber_last: # Set counters to start of signal.
464                 self.samplenumber_last = self.samplenum
465                 self.word_first = self.samplenum
466                 continue
467             samples = self.samplenum - self.samplenumber_last
468             if not self.sample_first: # Get number of samples for first pulse.
469                 self.sample_first = samples
470
471             pinstate = pin[0]
472             if self.state == 'DECODE_TIMEOUT': # No edge so flip the state.
473                 pinstate = int(not pinstate)
474             if self.invert == 'yes': # Invert signal.
475                 pinstate = int(not pinstate)
476             if pinstate:
477                 state = '0'
478             else:
479                 state = '1'
480
481             # No preamble filtering or checking and no skew correction.
482             if self.preamble_len == '0':
483                 self.sample_high = self.sample_first
484                 self.sample_low = self.sample_first
485                 self.insync = 0
486
487             if self.insync == 0:
488                 self.lock_onto_preamble(samples, state)
489             else:
490                 if self.decodeas == 'NRZ':
491                     self.decode_nrz(self.samplenumber_last, samples, state)
492                 if self.decodeas == 'Manchester':
493                     self.decode_manchester(self.samplenumber_last,
494                                            samples, state)
495                 if self.decodeas == 'Diff Manchester':
496                     self.decode_diff_manchester(self.samplenumber_last,
497                                                 samples, state)
498
499             self.samplenumber_last = self.samplenum