- return ret == 0
-
- def decode(self, ss, es, data):
- if self.samplerate is None:
- raise Exception("Cannot decode without samplerate.")
- for (self.samplenum, pins) in data:
- self.ir = pins[0]
-
- # Wait for an "interesting" edge, but also record the other ones.
- if self.old_ir == self.ir:
- continue
- if self.ir != self.active:
+ return valid
+
+ def decode(self):
+ if not self.samplerate:
+ raise SamplerateError('Cannot decode without samplerate.')
+ self.calc_rate()
+
+ cd_count = None
+ if self.options['cd_freq']:
+ cd_count = int(self.samplerate / self.options['cd_freq']) + 1
+ prev_ir = None
+
+ if self.options['polarity'] == 'auto':
+ # Take sample 0 as reference.
+ curr_level, = self.wait({'skip': 0})
+ active = 1 - curr_level
+ else:
+ active = 0 if self.options['polarity'] == 'active-low' else 1
+ self.is_extended = self.options['extended'] == 'yes'
+ want_addr_len = 16 if self.is_extended else 8
+
+ while True:
+ # Detect changes in the presence of an active input signal.
+ # The decoder can either be fed an already filtered RX signal
+ # or optionally can detect the presence of a carrier. Periods
+ # of inactivity (signal changes slower than the carrier freq,
+ # if specified) pass on the most recently sampled level. This
+ # approach works for filtered and unfiltered input alike, and
+ # only slightly extends the active phase of input signals with
+ # carriers included by one period of the carrier frequency.
+ # IR based communication protocols can cope with this slight
+ # inaccuracy just fine by design. Enabling carrier detection
+ # on already filtered signals will keep the length of their
+ # active period, but will shift their signal changes by one
+ # carrier period before they get passed to decoding logic.
+ if cd_count:
+ (cur_ir,) = self.wait([{Pin.IR: 'e'}, {'skip': cd_count}])
+ if self.matched[0]:
+ cur_ir = active
+ if cur_ir == prev_ir:
+ continue
+ prev_ir = cur_ir
+ self.ir = cur_ir
+ else:
+ (self.ir,) = self.wait({Pin.IR: 'e'})
+
+ if self.ir != active:
+ # Save the location of the non-active edge (recessive),
+ # then wait for the next edge. Immediately process the
+ # end of the STOP bit which completes an IR frame.