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

##
## This file is part of the libsigrokdecode project.
##
## Copyright (C) 2014 Jens Steinhauser <jens.steinhauser@gmail.com>
##
## 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, write to the Free Software
## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
##

import sigrokdecode as srd

class ChannelError(Exception):
    pass

regs = {
#   addr: ('name',        size)
    0x00: ('CONFIG',      1),
    0x01: ('EN_AA',       1),
    0x02: ('EN_RXADDR',   1),
    0x03: ('SETUP_AW',    1),
    0x04: ('SETUP_RETR',  1),
    0x05: ('RF_CH',       1),
    0x06: ('RF_SETUP',    1),
    0x07: ('STATUS',      1),
    0x08: ('OBSERVE_TX',  1),
    0x09: ('RPD',         1),
    0x0a: ('RX_ADDR_P0',  5),
    0x0b: ('RX_ADDR_P1',  5),
    0x0c: ('RX_ADDR_P2',  1),
    0x0d: ('RX_ADDR_P3',  1),
    0x0e: ('RX_ADDR_P4',  1),
    0x0f: ('RX_ADDR_P5',  1),
    0x10: ('TX_ADDR',     5),
    0x11: ('RX_PW_P0',    1),
    0x12: ('RX_PW_P1',    1),
    0x13: ('RX_PW_P2',    1),
    0x14: ('RX_PW_P3',    1),
    0x15: ('RX_PW_P4',    1),
    0x16: ('RX_PW_P5',    1),
    0x17: ('FIFO_STATUS', 1),
    0x1c: ('DYNPD',       1),
    0x1d: ('FEATURE',     1),
}

class Decoder(srd.Decoder):
    api_version = 2
    id = 'nrf24l01'
    name = 'nRF24L01(+)'
    longname = 'Nordic Semiconductor nRF24L01/nRF24L01+'
    desc = '2.4GHz transceiver chip.'
    license = 'gplv2+'
    inputs = ['spi']
    outputs = ['nrf24l01']
    annotations = (
        # Sent from the host to the chip.
        ('cmd', 'Commands sent to the device'),
        ('tx-data', 'Payload sent to the device'),

        # Returned by the chip.
        ('register', 'Registers read from the device'),
        ('rx-data', 'Payload read from the device'),

        ('warning', 'Warnings'),
    )
    ann_cmd = 0
    ann_tx = 1
    ann_reg = 2
    ann_rx = 3
    ann_warn = 4
    annotation_rows = (
        ('commands', 'Commands', (ann_cmd, ann_tx)),
        ('responses', 'Responses', (ann_reg, ann_rx)),
        ('warnings', 'Warnings', (ann_warn,)),
    )

    def __init__(self, **kwargs):
        self.next()
        self.requirements_met = True
        self.cs_was_released = False

    def start(self):
        self.out_ann = self.register(srd.OUTPUT_ANN)

    def warn(self, pos, msg):
        '''Put a warning message 'msg' at 'pos'.'''
        self.put(pos[0], pos[1], self.out_ann, [self.ann_warn, [msg]])

    def putp(self, pos, ann, msg):
        '''Put an annotation message 'msg' at 'pos'.'''
        self.put(pos[0], pos[1], self.out_ann, [ann, [msg]])

    def next(self):
        '''Resets the decoder after a complete command was decoded.'''
        # 'True' for the first byte after CS went low.
        self.first = True

        # The current command, and the minimum and maximum number
        # of data bytes to follow.
        self.cmd = None
        self.min = 0
        self.max = 0

        # Used to collect the bytes after the command byte
        # (and the start/end sample number).
        self.mb = []
        self.mb_s = -1
        self.mb_e = -1

    def mosi_bytes(self):
        '''Returns the collected MOSI bytes of a multi byte command.'''
        return [b[0] for b in self.mb]

    def miso_bytes(self):
        '''Returns the collected MISO bytes of a multi byte command.'''
        return [b[1] for b in self.mb]

    def decode_command(self, pos, b):
        '''Decodes the command byte 'b' at position 'pos' and prepares
        the decoding of the following data bytes.'''
        c = self.parse_command(b)
        if c is None:
            self.warn(pos, 'unknown command')
            return

        self.cmd, self.dat, self.min, self.max = c

        if self.cmd in ('W_REGISTER', 'ACTIVATE'):
            # Don't output anything now, the command is merged with
            # the data bytes following it.
            self.mb_s = pos[0]
        else:
            self.putp(pos, self.ann_cmd, self.format_command())

    def format_command(self):
        '''Returns the label for the current command.'''
        if self.cmd == 'R_REGISTER':
            reg = regs[self.dat][0] if self.dat in regs else 'unknown register'
            return 'Cmd R_REGISTER "{}"'.format(reg)
        else:
            return 'Cmd {}'.format(self.cmd)

    def parse_command(self, b):
        '''Parses the command byte.

        Returns a tuple consisting of:
        - the name of the command
        - additional data needed to dissect the following bytes
        - minimum number of following bytes
        - maximum number of following bytes
        '''

        if (b & 0xe0) in (0b00000000, 0b00100000):
            c = 'R_REGISTER' if not (b & 0xe0) else 'W_REGISTER'
            d = b & 0x1f
            m = regs[d][1] if d in regs else 1
            return (c, d, 1, m)
        if b == 0b01010000:
            # nRF24L01 only
            return ('ACTIVATE', None, 1, 1)
        if b == 0b01100001:
            return ('R_RX_PAYLOAD', None, 1, 32)
        if b == 0b01100000:
            return ('R_RX_PL_WID', None, 1, 1)
        if b == 0b10100000:
            return ('W_TX_PAYLOAD', None, 1, 32)
        if b == 0b10110000:
            return ('W_TX_PAYLOAD_NOACK', None, 1, 32)
        if (b & 0xf8) == 0b10101000:
            return ('W_ACK_PAYLOAD', b & 0x07, 1, 32)
        if b == 0b11100001:
            return ('FLUSH_TX', None, 0, 0)
        if b == 0b11100010:
            return ('FLUSH_RX', None, 0, 0)
        if b == 0b11100011:
            return ('REUSE_TX_PL', None, 0, 0)
        if b == 0b11111111:
            return ('NOP', None, 0, 0)

    def decode_register(self, pos, ann, regid, data):
        '''Decodes a register.

        pos   -- start and end sample numbers of the register
        ann   -- is the annotation number that is used to output the register.
        regid -- may be either an integer used as a key for the 'regs'
                 dictionary, or a string directly containing a register name.'
        data  -- is the register content.
        '''

        if type(regid) == int:
            # Get the name of the register.
            if regid not in regs:
                self.warn(pos, 'unknown register')
                return
            name = regs[regid][0]
        else:
            name = regid

        # Multi byte register come LSByte first.
        data = reversed(data)

        if self.cmd == 'W_REGISTER' and ann == self.ann_cmd:
            # The 'W_REGISTER' command is merged with the following byte(s).
            label = '{}: {}'.format(self.format_command(), name)
        else:
            label = 'Reg {}'.format(name)

        self.decode_mb_data(pos, ann, data, label, True)

    def decode_mb_data(self, pos, ann, data, label, always_hex):
        '''Decodes the data bytes 'data' of a multibyte command at position
        'pos'. The decoded data is prefixed with 'label'. If 'always_hex' is
        True, all bytes are decoded as hex codes, otherwise only non
        printable characters are escaped.'''

        if always_hex:
            def escape(b):
                return '{:02X}'.format(b)
        else:
            def escape(b):
                c = chr(b)
                if not str.isprintable(c):
                    return '\\x{:02X}'.format(b)
                return c

        data = ''.join([escape(b) for b in data])
        text = '{} = "{}"'.format(label, data)
        self.putp(pos, ann, text)

    def finish_command(self, pos):
        '''Decodes the remaining data bytes at position 'pos'.'''

        if self.cmd == 'R_REGISTER':
            self.decode_register(pos, self.ann_reg,
                                 self.dat, self.miso_bytes())
        elif self.cmd == 'W_REGISTER':
            self.decode_register(pos, self.ann_cmd,
                                 self.dat, self.mosi_bytes())
        elif self.cmd == 'R_RX_PAYLOAD':
            self.decode_mb_data(pos, self.ann_rx,
                                self.miso_bytes(), 'RX payload', False)
        elif (self.cmd == 'W_TX_PAYLOAD' or
              self.cmd == 'W_TX_PAYLOAD_NOACK'):
            self.decode_mb_data(pos, self.ann_tx,
                                self.mosi_bytes(), 'TX payload', False)
        elif self.cmd == 'W_ACK_PAYLOAD':
            lbl = 'ACK payload for pipe {}'.format(self.dat)
            self.decode_mb_data(pos, self.ann_tx,
                                self.mosi_bytes(), lbl, False)
        elif self.cmd == 'R_RX_PL_WID':
            msg = 'Payload width = {}'.format(self.mb[0][1])
            self.putp(pos, self.ann_reg, msg)
        elif self.cmd == 'ACTIVATE':
            self.putp(pos, self.ann_cmd, self.format_command())
            if self.mosi_bytes()[0] != 0x73:
                self.warn(pos, 'wrong data for "ACTIVATE" command')

    def decode(self, ss, es, data):
        if not self.requirements_met:
            return

        ptype, data1, data2 = data

        if ptype == 'CS-CHANGE':
            if data1 is None:
                if data2 is None:
                    self.requirements_met = False
                    raise ChannelError('CS# pin required.')
                elif data2 == 1:
                    self.cs_was_released = True

            if data1 == 0 and data2 == 1:
                # Rising edge, the complete command is transmitted, process
                # the bytes that were send after the command byte.
                if self.cmd:
                    # Check if we got the minimum number of data bytes
                    # after the command byte.
                    if len(self.mb) < self.min:
                        self.warn((ss, ss), 'missing data bytes')
                    elif self.mb:
                        self.finish_command((self.mb_s, self.mb_e))

                self.next()
                self.cs_was_released = True
        elif ptype == 'DATA' and self.cs_was_released:
            mosi, miso = data1, data2
            pos = (ss, es)

            if miso is None or mosi is None:
                self.requirements_met = False
                raise ChannelError('Both MISO and MOSI pins required.')

            if self.first:
                self.first = False
                # First MOSI byte is always the command.
                self.decode_command(pos, mosi)
                # First MISO byte is always the status register.
                self.decode_register(pos, self.ann_reg, 'STATUS', [miso])
            else:
                if not self.cmd or len(self.mb) >= self.max:
                    self.warn(pos, 'excess byte')
                else:
                    # Collect the bytes after the command byte.
                    if self.mb_s == -1:
                        self.mb_s = ss
                    self.mb_e = es
                    self.mb.append((mosi, miso))
Commit	Line	Data
0e501c70 JS	1	##
	2	## This file is part of the libsigrokdecode project.
	3	##
	4	## Copyright (C) 2014 Jens Steinhauser <jens.steinhauser@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, write to the Free Software
	18	## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	19	##
	20
	21	import sigrokdecode as srd
	22
f04964c6	23	class ChannelError(Exception):
0e501c70 JS	24	pass
	25
	26	regs = {
	27	# addr: ('name', size)
	28	0x00: ('CONFIG', 1),
	29	0x01: ('EN_AA', 1),
	30	0x02: ('EN_RXADDR', 1),
	31	0x03: ('SETUP_AW', 1),
	32	0x04: ('SETUP_RETR', 1),
	33	0x05: ('RF_CH', 1),
	34	0x06: ('RF_SETUP', 1),
	35	0x07: ('STATUS', 1),
	36	0x08: ('OBSERVE_TX', 1),
	37	0x09: ('RPD', 1),
	38	0x0a: ('RX_ADDR_P0', 5),
	39	0x0b: ('RX_ADDR_P1', 5),
	40	0x0c: ('RX_ADDR_P2', 1),
	41	0x0d: ('RX_ADDR_P3', 1),
	42	0x0e: ('RX_ADDR_P4', 1),
	43	0x0f: ('RX_ADDR_P5', 1),
	44	0x10: ('TX_ADDR', 5),
	45	0x11: ('RX_PW_P0', 1),
	46	0x12: ('RX_PW_P1', 1),
	47	0x13: ('RX_PW_P2', 1),
	48	0x14: ('RX_PW_P3', 1),
	49	0x15: ('RX_PW_P4', 1),
	50	0x16: ('RX_PW_P5', 1),
	51	0x17: ('FIFO_STATUS', 1),
	52	0x1c: ('DYNPD', 1),
35b380b1	53	0x1d: ('FEATURE', 1),
0e501c70 JS	54	}
	55
	56	class Decoder(srd.Decoder):
	57	api_version = 2
	58	id = 'nrf24l01'
35b380b1	59	name = 'nRF24L01(+)'
0e501c70	60	longname = 'Nordic Semiconductor nRF24L01/nRF24L01+'
35b380b1	61	desc = '2.4GHz transceiver chip.'
0e501c70 JS	62	license = 'gplv2+'
	63	inputs = ['spi']
	64	outputs = ['nrf24l01']
	65	annotations = (
35b380b1 UH	66	# Sent from the host to the chip.
	67	('cmd', 'Commands sent to the device'),
	68	('tx-data', 'Payload sent to the device'),
0e501c70	69
35b380b1 UH	70	# Returned by the chip.
	71	('register', 'Registers read from the device'),
	72	('rx-data', 'Payload read from the device'),
0e501c70 JS	73
	74	('warning', 'Warnings'),
	75	)
	76	ann_cmd = 0
	77	ann_tx = 1
	78	ann_reg = 2
	79	ann_rx = 3
	80	ann_warn = 4
	81	annotation_rows = (
	82	('commands', 'Commands', (ann_cmd, ann_tx)),
	83	('responses', 'Responses', (ann_reg, ann_rx)),
	84	('warnings', 'Warnings', (ann_warn,)),
	85	)
	86
	87	def __init__(self, **kwargs):
	88	self.next()
3cc4c4a9	89	self.requirements_met = True
22630a3d	90	self.cs_was_released = False
0e501c70 JS	91
	92	def start(self):
	93	self.out_ann = self.register(srd.OUTPUT_ANN)
	94
	95	def warn(self, pos, msg):
	96	'''Put a warning message 'msg' at 'pos'.'''
	97	self.put(pos[0], pos[1], self.out_ann, [self.ann_warn, [msg]])
	98
	99	def putp(self, pos, ann, msg):
	100	'''Put an annotation message 'msg' at 'pos'.'''
	101	self.put(pos[0], pos[1], self.out_ann, [ann, [msg]])
	102
	103	def next(self):
	104	'''Resets the decoder after a complete command was decoded.'''
35b380b1	105	# 'True' for the first byte after CS went low.
0e501c70 JS	106	self.first = True
0e501c70 JS	107
35b380b1 UH	108	# The current command, and the minimum and maximum number
35b380b1 UH	109	# of data bytes to follow.
0e501c70 JS	110	self.cmd = None
	111	self.min = 0
	112	self.max = 0
	113
35b380b1 UH	114	# Used to collect the bytes after the command byte
35b380b1 UH	115	# (and the start/end sample number).
0e501c70 JS	116	self.mb = []
	117	self.mb_s = -1
	118	self.mb_e = -1
	119
	120	def mosi_bytes(self):
	121	'''Returns the collected MOSI bytes of a multi byte command.'''
	122	return [b[0] for b in self.mb]
	123
	124	def miso_bytes(self):
	125	'''Returns the collected MISO bytes of a multi byte command.'''
	126	return [b[1] for b in self.mb]
	127
	128	def decode_command(self, pos, b):
	129	'''Decodes the command byte 'b' at position 'pos' and prepares
	130	the decoding of the following data bytes.'''
	131	c = self.parse_command(b)
35b380b1	132	if c is None:
0e501c70 JS	133	self.warn(pos, 'unknown command')
	134	return
	135
	136	self.cmd, self.dat, self.min, self.max = c
	137
	138	if self.cmd in ('W_REGISTER', 'ACTIVATE'):
35b380b1 UH	139	# Don't output anything now, the command is merged with
35b380b1 UH	140	# the data bytes following it.
0e501c70 JS	141	self.mb_s = pos[0]
	142	else:
	143	self.putp(pos, self.ann_cmd, self.format_command())
	144
	145	def format_command(self):
	146	'''Returns the label for the current command.'''
	147	if self.cmd == 'R_REGISTER':
	148	reg = regs[self.dat][0] if self.dat in regs else 'unknown register'
8aeedf9e	149	return 'Cmd R_REGISTER "{}"'.format(reg)
0e501c70	150	else:
8aeedf9e	151	return 'Cmd {}'.format(self.cmd)
0e501c70 JS	152
	153	def parse_command(self, b):
	154	'''Parses the command byte.
	155
	156	Returns a tuple consisting of:
	157	- the name of the command
	158	- additional data needed to dissect the following bytes
	159	- minimum number of following bytes
	160	- maximum number of following bytes
	161	'''
	162
	163	if (b & 0xe0) in (0b00000000, 0b00100000):
	164	c = 'R_REGISTER' if not (b & 0xe0) else 'W_REGISTER'
	165	d = b & 0x1f
	166	m = regs[d][1] if d in regs else 1
	167	return (c, d, 1, m)
	168	if b == 0b01010000:
	169	# nRF24L01 only
	170	return ('ACTIVATE', None, 1, 1)
	171	if b == 0b01100001:
	172	return ('R_RX_PAYLOAD', None, 1, 32)
	173	if b == 0b01100000:
	174	return ('R_RX_PL_WID', None, 1, 1)
	175	if b == 0b10100000:
	176	return ('W_TX_PAYLOAD', None, 1, 32)
	177	if b == 0b10110000:
	178	return ('W_TX_PAYLOAD_NOACK', None, 1, 32)
	179	if (b & 0xf8) == 0b10101000:
	180	return ('W_ACK_PAYLOAD', b & 0x07, 1, 32)
	181	if b == 0b11100001:
	182	return ('FLUSH_TX', None, 0, 0)
	183	if b == 0b11100010:
	184	return ('FLUSH_RX', None, 0, 0)
	185	if b == 0b11100011:
	186	return ('REUSE_TX_PL', None, 0, 0)
	187	if b == 0b11111111:
	188	return ('NOP', None, 0, 0)
	189
	190	def decode_register(self, pos, ann, regid, data):
	191	'''Decodes a register.
	192
	193	pos -- start and end sample numbers of the register
	194	ann -- is the annotation number that is used to output the register.
	195	regid -- may be either an integer used as a key for the 'regs'
	196	dictionary, or a string directly containing a register name.'
	197	data -- is the register content.
	198	'''
	199
	200	if type(regid) == int:
35b380b1	201	# Get the name of the register.
0e501c70 JS	202	if regid not in regs:
	203	self.warn(pos, 'unknown register')
	204	return
0e501c70 JS	205	name = regs[regid][0]
	206	else:
	207	name = regid
	208
35b380b1	209	# Multi byte register come LSByte first.
0e501c70 JS	210	data = reversed(data)
	211
	212	if self.cmd == 'W_REGISTER' and ann == self.ann_cmd:
35b380b1	213	# The 'W_REGISTER' command is merged with the following byte(s).
0e501c70 JS	214	label = '{}: {}'.format(self.format_command(), name)
0e501c70 JS	215	else:
8aeedf9e	216	label = 'Reg {}'.format(name)
0e501c70	217
8aeedf9e	218	self.decode_mb_data(pos, ann, data, label, True)
0e501c70	219
8aeedf9e	220	def decode_mb_data(self, pos, ann, data, label, always_hex):
0e501c70	221	'''Decodes the data bytes 'data' of a multibyte command at position
8aeedf9e JS	222	'pos'. The decoded data is prefixed with 'label'. If 'always_hex' is
	223	True, all bytes are decoded as hex codes, otherwise only non
	224	printable characters are escaped.'''
	225
	226	if always_hex:
	227	def escape(b):
	228	return '{:02X}'.format(b)
	229	else:
	230	def escape(b):
	231	c = chr(b)
	232	if not str.isprintable(c):
	233	return '\\x{:02X}'.format(b)
	234	return c
0e501c70 JS	235
	236	data = ''.join([escape(b) for b in data])
	237	text = '{} = "{}"'.format(label, data)
	238	self.putp(pos, ann, text)
	239
	240	def finish_command(self, pos):
	241	'''Decodes the remaining data bytes at position 'pos'.'''
	242
	243	if self.cmd == 'R_REGISTER':
	244	self.decode_register(pos, self.ann_reg,
35b380b1	245	self.dat, self.miso_bytes())
0e501c70 JS	246	elif self.cmd == 'W_REGISTER':
0e501c70 JS	247	self.decode_register(pos, self.ann_cmd,
35b380b1	248	self.dat, self.mosi_bytes())
0e501c70 JS	249	elif self.cmd == 'R_RX_PAYLOAD':
	250	self.decode_mb_data(pos, self.ann_rx,
	251	self.miso_bytes(), 'RX payload', False)
	252	elif (self.cmd == 'W_TX_PAYLOAD' or
	253	self.cmd == 'W_TX_PAYLOAD_NOACK'):
	254	self.decode_mb_data(pos, self.ann_tx,
	255	self.mosi_bytes(), 'TX payload', False)
	256	elif self.cmd == 'W_ACK_PAYLOAD':
	257	lbl = 'ACK payload for pipe {}'.format(self.dat)
	258	self.decode_mb_data(pos, self.ann_tx,
	259	self.mosi_bytes(), lbl, False)
	260	elif self.cmd == 'R_RX_PL_WID':
	261	msg = 'Payload width = {}'.format(self.mb[0][1])
	262	self.putp(pos, self.ann_reg, msg)
	263	elif self.cmd == 'ACTIVATE':
	264	self.putp(pos, self.ann_cmd, self.format_command())
	265	if self.mosi_bytes()[0] != 0x73:
	266	self.warn(pos, 'wrong data for "ACTIVATE" command')
	267
	268	def decode(self, ss, es, data):
3cc4c4a9 JS	269	if not self.requirements_met:
	270	return
	271
0e501c70 JS	272	ptype, data1, data2 = data
	273
	274	if ptype == 'CS-CHANGE':
8a110ab1 JS	275	if data1 is None:
8a110ab1 JS	276	if data2 is None:
3cc4c4a9 JS	277	self.requirements_met = False
3cc4c4a9 JS	278	raise ChannelError('CS# pin required.')
22630a3d JS	279	elif data2 == 1:
22630a3d JS	280	self.cs_was_released = True
3cc4c4a9	281
0e501c70	282	if data1 == 0 and data2 == 1:
35b380b1 UH	283	# Rising edge, the complete command is transmitted, process
35b380b1 UH	284	# the bytes that were send after the command byte.
0e501c70	285	if self.cmd:
35b380b1 UH	286	# Check if we got the minimum number of data bytes
35b380b1 UH	287	# after the command byte.
0e501c70 JS	288	if len(self.mb) < self.min:
	289	self.warn((ss, ss), 'missing data bytes')
	290	elif self.mb:
	291	self.finish_command((self.mb_s, self.mb_e))
	292
	293	self.next()
22630a3d JS	294	self.cs_was_released = True
22630a3d JS	295	elif ptype == 'DATA' and self.cs_was_released:
35b380b1	296	mosi, miso = data1, data2
0e501c70 JS	297	pos = (ss, es)
0e501c70 JS	298
35b380b1	299	if miso is None or mosi is None:
3cc4c4a9	300	self.requirements_met = False
f04964c6	301	raise ChannelError('Both MISO and MOSI pins required.')
0e501c70 JS	302
	303	if self.first:
	304	self.first = False
35b380b1	305	# First MOSI byte is always the command.
0e501c70	306	self.decode_command(pos, mosi)
35b380b1	307	# First MISO byte is always the status register.
0e501c70 JS	308	self.decode_register(pos, self.ann_reg, 'STATUS', [miso])
	309	else:
	310	if not self.cmd or len(self.mb) >= self.max:
	311	self.warn(pos, 'excess byte')
	312	else:
35b380b1	313	# Collect the bytes after the command byte.
0e501c70 JS	314	if self.mb_s == -1:
	315	self.mb_s = ss
	316	self.mb_e = es
	317	self.mb.append((mosi, miso))