]>
Commit | Line | Data |
---|---|---|
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 |