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

##
## This file is part of the libsigrokdecode project.
##
## Copyright (C) 2014 Uwe Hermann <uwe@hermann-uwe.de>
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## 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, see <http://www.gnu.org/licenses/>.
##

import sigrokdecode as srd
from .lists import *

class SamplerateError(Exception):
    pass

class Decoder(srd.Decoder):
    api_version = 3
    id = 'ir_rc5'
    name = 'IR RC-5'
    longname = 'IR RC-5'
    desc = 'RC-5 infrared remote control protocol.'
    license = 'gplv2+'
    inputs = ['logic']
    outputs = ['ir_rc5']
    channels = (
        {'id': 'ir', 'name': 'IR', 'desc': 'IR data line'},
    )
    options = (
        {'id': 'polarity', 'desc': 'Polarity', 'default': 'active-low',
            'values': ('active-low', 'active-high')},
        {'id': 'protocol', 'desc': 'Protocol type', 'default': 'standard',
            'values': ('standard', 'extended')},
    )
    annotations = (
        ('bit', 'Bit'),
        ('startbit1', 'Startbit 1'),
        ('startbit2', 'Startbit 2'),
        ('togglebit-0', 'Toggle bit 0'),
        ('togglebit-1', 'Toggle bit 1'),
        ('address', 'Address'),
        ('command', 'Command'),
    )
    annotation_rows = (
        ('bits', 'Bits', (0,)),
        ('fields', 'Fields', (1, 2, 3, 4, 5, 6)),
    )

    def __init__(self):
        self.reset()

    def reset(self):
        self.samplerate = None
        self.samplenum = None
        self.edges, self.bits, self.ss_es_bits = [], [], []
        self.state = 'IDLE'

    def start(self):
        self.out_ann = self.register(srd.OUTPUT_ANN)
        self.old_ir = 1 if self.options['polarity'] == 'active-low' else 0

    def metadata(self, key, value):
        if key == srd.SRD_CONF_SAMPLERATE:
            self.samplerate = value
            # One bit: 1.78ms (one half low, one half high).
            self.halfbit = int((self.samplerate * 0.00178) / 2.0)

    def putb(self, bit1, bit2, data):
        ss, es = self.ss_es_bits[bit1][0], self.ss_es_bits[bit2][1]
        self.put(ss, es, self.out_ann, data)

    def handle_bits(self):
        a, c, b = 0, 0, self.bits
        # Individual raw bits.
        for i in range(14):
            if i == 0:
                ss = max(0, self.bits[0][0] - self.halfbit)
            else:
                ss = self.ss_es_bits[i - 1][1]
            es = self.bits[i][0] + self.halfbit
            self.ss_es_bits.append([ss, es])
            self.putb(i, i, [0, ['%d' % self.bits[i][1]]])
        # Bits[0:0]: Startbit 1
        s = ['Startbit1: %d' % b[0][1], 'SB1: %d' % b[0][1], 'SB1', 'S1', 'S']
        self.putb(0, 0, [1, s])
        # Bits[1:1]: Startbit 2
        ann_idx = 2
        s = ['Startbit2: %d' % b[1][1], 'SB2: %d' % b[1][1], 'SB2', 'S2', 'S']
        if self.options['protocol'] == 'extended':
            s = ['CMD[6]#: %d' % b[1][1], 'C6#: %d' % b[1][1], 'C6#', 'C#', 'C']
            ann_idx = 6
        self.putb(1, 1, [ann_idx, s])
        # Bits[2:2]: Toggle bit
        s = ['Togglebit: %d' % b[2][1], 'Toggle: %d' % b[2][1],
             'TB: %d' % b[2][1], 'TB', 'T']
        self.putb(2, 2, [3 if b[2][1] == 0 else 4, s])
        # Bits[3:7]: Address (MSB-first)
        for i in range(5):
            a |= (b[3 + i][1] << (4 - i))
        x = system.get(a, ['Unknown', 'Unk'])
        s = ['Address: %d (%s)' % (a, x[0]), 'Addr: %d (%s)' % (a, x[1]),
             'Addr: %d' % a, 'A: %d' % a, 'A']
        self.putb(3, 7, [5, s])
        # Bits[8:13]: Command (MSB-first)
        for i in range(6):
            c |= (b[8 + i][1] << (5 - i))
        if self.options['protocol'] == 'extended':
            inverted_bit6 = 1 if b[1][1] == 0 else 0
            c |= (inverted_bit6 << 6)
        cmd_type = 'VCR' if x[1] in ('VCR1', 'VCR2') else 'TV'
        x = command[cmd_type].get(c, ['Unknown', 'Unk'])
        s = ['Command: %d (%s)' % (c, x[0]), 'Cmd: %d (%s)' % (c, x[1]),
             'Cmd: %d' % c, 'C: %d' % c, 'C']
        self.putb(8, 13, [6, s])

    def edge_type(self):
        # Categorize according to distance from last edge (short/long).
        distance = self.samplenum - self.edges[-1]
        s, l, margin = self.halfbit, self.halfbit * 2, int(self.halfbit / 2)
        if distance in range(l - margin, l + margin + 1):
            return 'l'
        elif distance in range(s - margin, s + margin + 1):
            return 's'
        else:
            return 'e' # Error, invalid edge distance.

    def reset_decoder_state(self):
        self.edges, self.bits, self.ss_es_bits = [], [], []
        self.state = 'IDLE'

    def decode(self):
        if not self.samplerate:
            raise SamplerateError('Cannot decode without samplerate.')
        while True:

            (self.ir,) = self.wait()

            # Wait for any edge (rising or falling).
            if self.old_ir == self.ir:
                continue

            # State machine.
            if self.state == 'IDLE':
                bit = 1
                self.edges.append(self.samplenum)
                self.bits.append([self.samplenum, bit])
                self.state = 'MID1'
                self.old_ir = self.ir
                continue
            edge = self.edge_type()
            if edge == 'e':
                self.reset_decoder_state() # Reset state machine upon errors.
                continue
            if self.state == 'MID1':
                self.state = 'START1' if edge == 's' else 'MID0'
                bit = None if edge == 's' else 0
            elif self.state == 'MID0':
                self.state = 'START0' if edge == 's' else 'MID1'
                bit = None if edge == 's' else 1
            elif self.state == 'START1':
                if edge == 's':
                    self.state = 'MID1'
                bit = 1 if edge == 's' else None
            elif self.state == 'START0':
                if edge == 's':
                    self.state = 'MID0'
                bit = 0 if edge == 's' else None

            self.edges.append(self.samplenum)
            if bit is not None:
                self.bits.append([self.samplenum, bit])

            if len(self.bits) == 14:
                self.handle_bits()
                self.reset_decoder_state()

            self.old_ir = self.ir
Commit	Line	Data
	1	##
	2	## This file is part of the libsigrokdecode project.
	3	##
	4	## Copyright (C) 2014 Uwe Hermann <uwe@hermann-uwe.de>
	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 .lists import *
	22
	23	class SamplerateError(Exception):
	24	pass
	25
	26	class Decoder(srd.Decoder):
	27	api_version = 3
	28	id = 'ir_rc5'
	29	name = 'IR RC-5'
	30	longname = 'IR RC-5'
	31	desc = 'RC-5 infrared remote control protocol.'
	32	license = 'gplv2+'
	33	inputs = ['logic']
	34	outputs = ['ir_rc5']
	35	channels = (
	36	{'id': 'ir', 'name': 'IR', 'desc': 'IR data line'},
	37	)
	38	options = (
	39	{'id': 'polarity', 'desc': 'Polarity', 'default': 'active-low',
	40	'values': ('active-low', 'active-high')},
	41	{'id': 'protocol', 'desc': 'Protocol type', 'default': 'standard',
	42	'values': ('standard', 'extended')},
	43	)
	44	annotations = (
	45	('bit', 'Bit'),
	46	('startbit1', 'Startbit 1'),
	47	('startbit2', 'Startbit 2'),
	48	('togglebit-0', 'Toggle bit 0'),
	49	('togglebit-1', 'Toggle bit 1'),
	50	('address', 'Address'),
	51	('command', 'Command'),
	52	)
	53	annotation_rows = (
	54	('bits', 'Bits', (0,)),
	55	('fields', 'Fields', (1, 2, 3, 4, 5, 6)),
	56	)
	57
	58	def __init__(self):
	59	self.reset()
	60
	61	def reset(self):
	62	self.samplerate = None
	63	self.samplenum = None
	64	self.edges, self.bits, self.ss_es_bits = [], [], []
	65	self.state = 'IDLE'
	66
	67	def start(self):
	68	self.out_ann = self.register(srd.OUTPUT_ANN)
	69	self.old_ir = 1 if self.options['polarity'] == 'active-low' else 0
	70
	71	def metadata(self, key, value):
	72	if key == srd.SRD_CONF_SAMPLERATE:
	73	self.samplerate = value
	74	# One bit: 1.78ms (one half low, one half high).
	75	self.halfbit = int((self.samplerate * 0.00178) / 2.0)
	76
	77	def putb(self, bit1, bit2, data):
	78	ss, es = self.ss_es_bits[bit1][0], self.ss_es_bits[bit2][1]
	79	self.put(ss, es, self.out_ann, data)
	80
	81	def handle_bits(self):
	82	a, c, b = 0, 0, self.bits
	83	# Individual raw bits.
	84	for i in range(14):
	85	if i == 0:
	86	ss = max(0, self.bits[0][0] - self.halfbit)
	87	else:
	88	ss = self.ss_es_bits[i - 1][1]
	89	es = self.bits[i][0] + self.halfbit
	90	self.ss_es_bits.append([ss, es])
	91	self.putb(i, i, [0, ['%d' % self.bits[i][1]]])
	92	# Bits[0:0]: Startbit 1
	93	s = ['Startbit1: %d' % b[0][1], 'SB1: %d' % b[0][1], 'SB1', 'S1', 'S']
	94	self.putb(0, 0, [1, s])
	95	# Bits[1:1]: Startbit 2
	96	ann_idx = 2
	97	s = ['Startbit2: %d' % b[1][1], 'SB2: %d' % b[1][1], 'SB2', 'S2', 'S']
	98	if self.options['protocol'] == 'extended':
	99	s = ['CMD[6]#: %d' % b[1][1], 'C6#: %d' % b[1][1], 'C6#', 'C#', 'C']
	100	ann_idx = 6
	101	self.putb(1, 1, [ann_idx, s])
	102	# Bits[2:2]: Toggle bit
	103	s = ['Togglebit: %d' % b[2][1], 'Toggle: %d' % b[2][1],
	104	'TB: %d' % b[2][1], 'TB', 'T']
	105	self.putb(2, 2, [3 if b[2][1] == 0 else 4, s])
	106	# Bits[3:7]: Address (MSB-first)
	107	for i in range(5):
	108	a \|= (b[3 + i][1] << (4 - i))
	109	x = system.get(a, ['Unknown', 'Unk'])
	110	s = ['Address: %d (%s)' % (a, x[0]), 'Addr: %d (%s)' % (a, x[1]),
	111	'Addr: %d' % a, 'A: %d' % a, 'A']
	112	self.putb(3, 7, [5, s])
	113	# Bits[8:13]: Command (MSB-first)
	114	for i in range(6):
	115	c \|= (b[8 + i][1] << (5 - i))
	116	if self.options['protocol'] == 'extended':
	117	inverted_bit6 = 1 if b[1][1] == 0 else 0
	118	c \|= (inverted_bit6 << 6)
	119	cmd_type = 'VCR' if x[1] in ('VCR1', 'VCR2') else 'TV'
	120	x = command[cmd_type].get(c, ['Unknown', 'Unk'])
	121	s = ['Command: %d (%s)' % (c, x[0]), 'Cmd: %d (%s)' % (c, x[1]),
	122	'Cmd: %d' % c, 'C: %d' % c, 'C']
	123	self.putb(8, 13, [6, s])
	124
	125	def edge_type(self):
	126	# Categorize according to distance from last edge (short/long).
	127	distance = self.samplenum - self.edges[-1]
	128	s, l, margin = self.halfbit, self.halfbit * 2, int(self.halfbit / 2)
	129	if distance in range(l - margin, l + margin + 1):
	130	return 'l'
	131	elif distance in range(s - margin, s + margin + 1):
	132	return 's'
	133	else:
	134	return 'e' # Error, invalid edge distance.
	135
	136	def reset_decoder_state(self):
	137	self.edges, self.bits, self.ss_es_bits = [], [], []
	138	self.state = 'IDLE'
	139
	140	def decode(self):
	141	if not self.samplerate:
	142	raise SamplerateError('Cannot decode without samplerate.')
	143	while True:
	144
	145	(self.ir,) = self.wait()
	146
	147	# Wait for any edge (rising or falling).
	148	if self.old_ir == self.ir:
	149	continue
	150
	151	# State machine.
	152	if self.state == 'IDLE':
	153	bit = 1
	154	self.edges.append(self.samplenum)
	155	self.bits.append([self.samplenum, bit])
	156	self.state = 'MID1'
	157	self.old_ir = self.ir
	158	continue
	159	edge = self.edge_type()
	160	if edge == 'e':
	161	self.reset_decoder_state() # Reset state machine upon errors.
	162	continue
	163	if self.state == 'MID1':
	164	self.state = 'START1' if edge == 's' else 'MID0'
	165	bit = None if edge == 's' else 0
	166	elif self.state == 'MID0':
	167	self.state = 'START0' if edge == 's' else 'MID1'
	168	bit = None if edge == 's' else 1
	169	elif self.state == 'START1':
	170	if edge == 's':
	171	self.state = 'MID1'
	172	bit = 1 if edge == 's' else None
	173	elif self.state == 'START0':
	174	if edge == 's':
	175	self.state = 'MID0'
	176	bit = 0 if edge == 's' else None
	177
	178	self.edges.append(self.samplenum)
	179	if bit is not None:
	180	self.bits.append([self.samplenum, bit])
	181
	182	if len(self.bits) == 14:
	183	self.handle_bits()
	184	self.reset_decoder_state()
	185
	186	self.old_ir = self.ir