all decoders: introduce a reset() method

[libsigrokdecode.git] / decoders / ir_nec / pd.py

diff --git a/decoders/ir_nec/pd.py b/decoders/ir_nec/pd.py
index 94e232f0b743b8cef8a21d1307ee084f0e46af16..0362609dfb7d11ccd0dbb085c118a3e3caf2c3be 100644 (file)
--- a/decoders/ir_nec/pd.py
+++ b/decoders/ir_nec/pd.py
@@ -14,15 +14,17 @@
 ## GNU General Public License for more details.
 ##
 ## You should have received a copy of the GNU General Public License
-## along with this program; if not, write to the Free Software
-## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+## along with this program; if not, see <http://www.gnu.org/licenses/>.
 ##
 
 import sigrokdecode as srd
 from .lists import *
 
+class SamplerateError(Exception):
+    pass
+
 class Decoder(srd.Decoder):
-    api_version = 2
+    api_version = 3
     id = 'ir_nec'
     name = 'IR NEC'
     longname = 'IR NEC'
@@ -96,32 +98,38 @@ class Decoder(srd.Decoder):
                  [11, ['%s: %s' % (dev, btn[0]), '%s: %s' % (dev, btn[1]),
                  '%s' % btn[1]]])
 
-    def __init__(self, **kwargs):
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
         self.state = 'IDLE'
         self.ss_bit = self.ss_start = self.ss_other_edge = self.ss_remote = 0
-        self.data = self.count = self.active = self.old_ir = None
+        self.data = self.count = self.active = None
         self.addr = self.cmd = None
 
     def start(self):
         self.out_ann = self.register(srd.OUTPUT_ANN)
         self.active = 0 if self.options['polarity'] == 'active-low' else 1
-        self.old_ir = 1 if self.active == 0 else 0
 
     def metadata(self, key, value):
         if key == srd.SRD_CONF_SAMPLERATE:
             self.samplerate = value
-        self.margin = int(self.samplerate * 0.0001) - 1 # 0.1ms
+        self.tolerance = 0.05 # +/-5%
         self.lc = int(self.samplerate * 0.0135) - 1 # 13.5ms
         self.rc = int(self.samplerate * 0.01125) - 1 # 11.25ms
         self.dazero = int(self.samplerate * 0.001125) - 1 # 1.125ms
         self.daone = int(self.samplerate * 0.00225) - 1 # 2.25ms
         self.stop = int(self.samplerate * 0.000652) - 1 # 0.652ms
 
+    def compare_with_tolerance(self, measured, base):
+        return (measured >= base * (1 - self.tolerance)
+                and measured <= base * (1 + self.tolerance))
+
     def handle_bit(self, tick):
         ret = None
-        if tick in range(self.dazero - self.margin, self.dazero + self.margin):
+        if self.compare_with_tolerance(tick, self.dazero):
             ret = 0
-        elif tick in range(self.daone - self.margin, self.daone + self.margin):
+        elif self.compare_with_tolerance(tick, self.daone):
             ret = 1
         if ret in (0, 1):
             self.putb([0, ['%d' % ret]])
@@ -147,31 +155,29 @@ class Decoder(srd.Decoder):
         self.ss_bit = self.ss_start = self.samplenum
         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]
+    def decode(self):
+        if not self.samplerate:
+            raise SamplerateError('Cannot decode without samplerate.')
+        while True:
+            # Wait for any edge (rising or falling).
+            (self.ir,) = self.wait({0: 'e'})
 
-            # Wait for an "interesting" edge, but also record the other ones.
-            if self.old_ir == self.ir:
-                continue
             if self.ir != self.active:
+                # Save the non-active edge, then wait for the next edge.
                 self.ss_other_edge = self.samplenum
-                self.old_ir = self.ir
                 continue
 
             b = self.samplenum - self.ss_bit
 
             # State machine.
             if self.state == 'IDLE':
-                if b in range(self.lc - self.margin, self.lc + self.margin):
+                if self.compare_with_tolerance(b, self.lc):
                     self.putpause('Long')
                     self.putx([5, ['Leader code', 'Leader', 'LC', 'L']])
                     self.ss_remote = self.ss_start
                     self.data = self.count = 0
                     self.state = 'ADDRESS'
-                elif b in range(self.rc - self.margin, self.rc + self.margin):
+                elif self.compare_with_tolerance(b, self.rc):
                     self.putpause('Short')
                     self.putstop(self.samplenum)
                     self.samplenum += self.stop
@@ -199,8 +205,3 @@ class Decoder(srd.Decoder):
                 self.putremote()
                 self.ss_bit = self.ss_start = self.samplenum
                 self.state = 'IDLE'
-            else:
-                raise Exception('Invalid state: %s' % self.state)
-
-            self.old_ir = self.ir
-