cec: Simplify a few code snippets.
[libsigrokdecode.git] / decoders / cec / pd.py
1 ##
2 ## This file is part of the libsigrokdecode project.
3 ##
4 ## Copyright (C) 2018 Jorge Solla Rubiales <jorgesolla@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, see <http://www.gnu.org/licenses/>.
18 ##
19
20 import sigrokdecode as srd
21 from .protocoldata import *
22
23 # Pulse types
24 class Pulse:
25     INVALID, START, ZERO, ONE = range(4)
26
27 # Protocol stats
28 class Stat:
29     WAIT_START, GET_BITS, WAIT_EOM, WAIT_ACK = range(4)
30
31 # Pulse times in milliseconds
32 timing = {
33     Pulse.START: {
34         'low': { 'min': 3.5, 'max': 3.9 },
35         'total': { 'min': 4.3, 'max': 4.7 }
36     },
37     Pulse.ZERO: {
38         'low': { 'min': 1.3, 'max': 1.7 },
39         'total': { 'min': 2.05, 'max': 2.75 }
40     },
41     Pulse.ONE: {
42         'low': { 'min': 0.4, 'max': 0.8 },
43         'total': { 'min': 2.05, 'max': 2.75 }
44     }
45 }
46
47 class ChannelError(Exception):
48     pass
49
50 class Decoder(srd.Decoder):
51     api_version = 3
52     id = 'cec'
53     name = 'CEC'
54     longname = 'HDMI-CEC'
55     desc = 'HDMI Consumer Electronics Control (CEC) protocol.'
56     license = 'gplv2+'
57     inputs = ['logic']
58     outputs = ['cec']
59     channels = (
60         {'id': 'cec', 'name': 'CEC', 'desc': 'CEC bus data'},
61     )
62     annotations = (
63         ('st', 'Start'),
64         ('eom-0', 'End of message'),
65         ('eom-1', 'Message continued'),
66         ('nack', 'ACK not set'),
67         ('ack', 'ACK set'),
68         ('bits', 'Bits'),
69         ('bytes', 'Bytes'),
70         ('frames', 'Frames'),
71         ('sections', 'Sections'),
72         ('warnings', 'Warnings')
73     )
74     annotation_rows = (
75         ('bits', 'Bits', (0, 1, 2, 3, 4, 5)),
76         ('bytes', 'Bytes', (6,)),
77         ('frames', 'Frames', (7,)),
78         ('sections', 'Sections', (8,)),
79         ('warnings', 'Warnings', (9,))
80     )
81
82     def __init__(self):
83         self.reset()
84
85     def precalculate(self):
86         # Restrict max length of ACK/NACK labels to 2 BIT pulses.
87         bit_time = timing[Pulse.ZERO]['total']['min'] * 2
88         self.max_ack_len_samples = round((bit_time / 1000) * self.samplerate)
89
90     def reset(self):
91         self.stat = Stat.WAIT_START
92         self.samplerate = None
93         self.fall_start = None
94         self.fall_end = None
95         self.rise = None
96         self.reset_frame_vars()
97
98     def reset_frame_vars(self):
99         self.eom = None
100         self.bit_count = 0
101         self.byte_count = 0
102         self.byte = 0
103         self.byte_start = None
104         self.frame_start = None
105         self.frame_end = None
106         self.is_nack = 0
107         self.cmd_bytes = []
108
109     def metadata(self, key, value):
110         if key == srd.SRD_CONF_SAMPLERATE:
111             self.samplerate = value
112             self.precalculate()
113
114     def set_stat(self, stat):
115         self.stat = stat
116
117     def handle_frame(self, is_nack):
118         if self.fall_start is None or self.fall_end is None:
119             return
120
121         i = 0
122         str = ''
123         while i < len(self.cmd_bytes):
124             str += '{:02x}'.format(self.cmd_bytes[i]['val'])
125             if i != (len(self.cmd_bytes) - 1):
126                 str += ':'
127             i += 1
128
129         self.put(self.frame_start, self.frame_end, self.out_ann, [7, [str]])
130
131         i = 0
132         operands = 0
133         str = ''
134         while i < len(self.cmd_bytes):
135             if i == 0: # Parse header
136                 (src, dst) = decode_header(self.cmd_bytes[i]['val'])
137                 str = 'HDR: ' + src + ', ' + dst
138             elif i == 1: # Parse opcode
139                 str += ' | OPC: ' + decode_opcode(self.cmd_bytes[i]['val'])
140             else: # Parse operands
141                 if operands == 0:
142                     str += ' | OPS: '
143                 operands += 1
144                 str += '0x{:02x}'.format(self.cmd_bytes[i]['val'])
145                 if i != len(self.cmd_bytes) - 1:
146                     str += ', '
147             i += 1
148
149         # Header only commands are PINGS
150         if i == 1:
151             str += ' | OPC: PING' if self.eom else ' | OPC: NONE. Aborted cmd'
152
153         # Add extra information (ack of the command from the destination)
154         str += ' | R: NACK' if is_nack else ' | R: ACK'
155
156         self.put(self.frame_start, self.frame_end, self.out_ann, [8, [str]])
157
158     def process(self):
159         zero_time = ((self.rise - self.fall_start) / self.samplerate) * 1000.0
160         total_time = ((self.fall_end - self.fall_start) / self.samplerate) * 1000.0
161         pulse = Pulse.INVALID
162
163         # VALIDATION: Identify pulse based on length of the low period
164         for key in timing:
165             if zero_time >= timing[key]['low']['min'] and zero_time <= timing[key]['low']['max']:
166                 pulse = key
167                 break
168
169         # VALIDATION: Invalid pulse
170         if pulse == Pulse.INVALID:
171             self.set_stat(Stat.WAIT_START)
172             self.put(self.fall_start, self.fall_end, self.out_ann, [9, ['Invalid pulse: Wrong timing']])
173             return
174
175         # VALIDATION: If waiting for start, discard everything else
176         if self.stat == Stat.WAIT_START and pulse != Pulse.START:
177             self.put(self.fall_start, self.fall_end, self.out_ann, [9, ['Expected START: BIT found']])
178             return
179
180         # VALIDATION: If waiting for ACK or EOM, only BIT pulses (0/1) are expected
181         if (self.stat == Stat.WAIT_ACK or self.stat == Stat.WAIT_EOM) and pulse == Pulse.START:
182             self.put(self.fall_start, self.fall_end, self.out_ann, [9, ['Expected BIT: START received)']])
183             self.set_stat(Stat.WAIT_START)
184
185         # VALIDATION: ACK bit pulse remains high till the next frame (if any): Validate only min time of the low period
186         if self.stat == Stat.WAIT_ACK and pulse != Pulse.START:
187             if total_time < timing[pulse]['total']['min']:
188                 pulse = Pulse.INVALID
189                 self.put(self.fall_start, self.fall_end, self.out_ann, [9, ['ACK pulse below minimun time']])
190                 self.set_stat(Stat.WAIT_START)
191                 return
192
193         # VALIDATION / PING FRAME DETECTION: Initiator doesn't sets the EOM = 1 but stops sending when ack doesn't arrive
194         if self.stat == Stat.GET_BITS and pulse == Pulse.START:
195             # Make sure we received a complete byte to consider it a valid ping
196             if self.bit_count == 0:
197                 self.handle_frame(self.is_nack)
198             else:
199                 self.put(self.frame_start, self.samplenum, self.out_ann, [9, ['ERROR: Incomplete byte received']])
200
201             # Set wait start so we receive next frame
202             self.set_stat(Stat.WAIT_START)
203
204         # VALIDATION: Check timing of the BIT (0/1) pulse in any other case (not waiting for ACK)
205         if self.stat != Stat.WAIT_ACK and pulse != Pulse.START:
206             if total_time < timing[pulse]['total']['min'] or total_time > timing[pulse]['total']['max']:
207                 self.put(self.fall_start, self.fall_end, self.out_ann, [9, ['Bit pulse exceeds total pulse timespan']])
208                 pulse = Pulse.INVALID
209                 self.set_stat(Stat.WAIT_START)
210                 return
211
212         if pulse == Pulse.ZERO:
213             bit = 0
214         elif pulse == Pulse.ONE:
215             bit = 1
216
217         # STATE: WAIT START
218         if self.stat == Stat.WAIT_START:
219             self.set_stat(Stat.GET_BITS)
220             self.reset_frame_vars()
221             self.put(self.fall_start, self.fall_end, self.out_ann, [0, ['ST']])
222
223         # STATE: GET BITS
224         elif self.stat == Stat.GET_BITS:
225             # Reset stats on first bit
226             if self.bit_count == 0:
227                 self.byte_start = self.fall_start
228                 self.byte = 0
229
230                 # If 1st byte of the datagram save its sample num
231                 if len(self.cmd_bytes) == 0:
232                     self.frame_start = self.fall_start
233
234             self.byte += (bit << (7 - self.bit_count))
235             self.bit_count += 1
236             self.put(self.fall_start, self.fall_end, self.out_ann, [5, [str(bit)]])
237
238             if self.bit_count == 8:
239                 self.bit_count = 0
240                 self.byte_count += 1
241                 self.set_stat(Stat.WAIT_EOM)
242                 self.put(self.byte_start, self.samplenum, self.out_ann, [6, ['0x{:02x}'.format(self.byte)]])
243                 self.cmd_bytes.append({'st': self.byte_start, 'ed': self.samplenum, 'val': self.byte})
244
245         # STATE: WAIT EOM
246         elif self.stat == Stat.WAIT_EOM:
247             self.eom = bit
248             self.frame_end = self.fall_end
249
250             a = [2, ['EOM=Y']] if self.eom else [1, ['EOM=N']]
251             self.put(self.fall_start, self.fall_end, self.out_ann, a)
252
253             self.set_stat(Stat.WAIT_ACK)
254
255         # STATE: WAIT ACK
256         elif self.stat == Stat.WAIT_ACK:
257             # If a frame with broadcast destination is being sent, the ACK is
258             # inverted: a 0 is considered a NACK, therefore we invert the value
259             # of the bit here, so we match the real meaning of it.
260             if (self.cmd_bytes[0]['val'] & 0x0F) == 0x0F:
261                 bit = ~bit & 0x01
262
263             if (self.fall_end - self.fall_start) > self.max_ack_len_samples:
264                 ann_end = self.fall_start + self.max_ack_len_samples
265             else:
266                 ann_end = self.fall_end
267
268             if bit:
269                 # Any NACK detected in the frame is enough to consider the
270                 # whole frame NACK'd.
271                 self.is_nack = 1
272                 self.put(self.fall_start, ann_end, self.out_ann, [3, ['NACK']])
273             else:
274                 self.put(self.fall_start, ann_end, self.out_ann, [4, ['ACK']])
275
276             # After ACK bit, wait for new datagram or continue reading current
277             # one based on EOM value.
278             if self.eom or self.is_nack:
279                 self.set_stat(Stat.WAIT_START)
280                 self.handle_frame(self.is_nack)
281             else:
282                 self.set_stat(Stat.GET_BITS)
283
284     def start(self):
285         self.out_ann = self.register(srd.OUTPUT_ANN)
286
287     def decode(self):
288         if not self.samplerate:
289             raise SamplerateError('Cannot decode without samplerate.')
290
291         # Wait for first falling edge.
292         self.wait({0: 'f'})
293         self.fall_end = self.samplenum
294
295         while True:
296             self.wait({0: 'r'})
297             self.rise = self.samplenum
298
299             if self.stat == Stat.WAIT_ACK:
300                 self.wait([{0: 'f'}, {'skip': self.max_ack_len_samples}])
301             else:
302                 self.wait([{0: 'f'}])
303
304             self.fall_start = self.fall_end
305             self.fall_end = self.samplenum
306             self.process()
307
308             # If there was a timeout while waiting for ACK: RESYNC.
309             # Note: This is an expected situation as no new falling edge will
310             # happen until next frame is transmitted.
311             if self.matched == (False, True):
312                 self.wait({0: 'f'})
313                 self.fall_end = self.samplenum