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

##
## This file is part of the libsigrokdecode project.
##
## Copyright (C) 2017 Kevin Redon <kingkevin@cuvoodoo.info>
##
## 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

class SamplerateError(Exception):
    pass

# Timing values in us for the signal at regular and overdrive speed.
timing = {
    'RSTL': {
        'min': {
            False: 480.0,
            True: 48.0,
        },
        'max': {
            False: 960.0,
            True: 80.0,
        },
    },
    'RSTH': {
        'min': {
            False: 480.0,
            True: 48.0,
        },
    },
    'PDH': {
        'min': {
            False: 15.0,
            True: 2.0,
        },
        'max': {
            False: 60.0,
            True: 6.0,
        },
    },
    'PDL': {
        'min': {
            False: 60.0,
            True: 8.0,
        },
        'max': {
            False: 240.0,
            True: 24.0,
        },
    },
    'SLOT': {
        'min': {
            False: 60.0,
            True: 6.0,
        },
        'max': {
            False: 120.0,
            True: 16.0,
        },
    },
    'REC': {
        'min': {
            False: 1.0,
            True: 1.0,
        },
    },
    'LOWR': {
        'min': {
            False: 1.0,
            True: 1.0,
        },
        'max': {
            False: 15.0,
            True: 2.0,
        },
    },
}

class Decoder(srd.Decoder):
    api_version = 2
    id = 'onewire_link'
    name = '1-Wire link layer'
    longname = '1-Wire serial communication bus (link layer)'
    desc = 'Bidirectional, half-duplex, asynchronous serial bus.'
    license = 'gplv2+'
    inputs = ['logic']
    outputs = ['onewire_link']
    channels = (
        {'id': 'owr', 'name': 'OWR', 'desc': '1-Wire signal line'},
    )
    options = (
        {'id': 'overdrive', 'desc': 'Start in overdrive speed',
            'default': 'no', 'values': ('yes', 'no')},
    )
    annotations = (
        ('bit', 'Bit'),
        ('warnings', 'Warnings'),
        ('reset', 'Reset'),
        ('presence', 'Presence'),
        ('overdrive', 'Overdrive speed notifications'),
    )
    annotation_rows = (
        ('bits', 'Bits', (0, 2, 3)),
        ('info', 'Info', (4,)),
        ('warnings', 'Warnings', (1,)),
    )

    def __init__(self):
        self.samplerate = None
        self.samplenum = 0
        self.state = 'INITIAL'
        self.present = 0
        self.bit = 0
        self.bit_count = -1
        self.command = 0
        self.overdrive = False
        self.fall = 0
        self.rise = 0

    def start(self):
        self.out_python = self.register(srd.OUTPUT_PYTHON)
        self.out_ann = self.register(srd.OUTPUT_ANN)
        self.overdrive = (self.options['overdrive'] == 'yes')
        self.fall = 0
        self.rise = 0
        self.bit_count = -1

    def checks(self):
        # Check if samplerate is appropriate.
        if self.options['overdrive'] == 'yes':
            if self.samplerate < 2000000:
                self.putm([1, ['Sampling rate is too low. Must be above ' +
                               '2MHz for proper overdrive mode decoding.']])
            elif self.samplerate < 5000000:
                self.putm([1, ['Sampling rate is suggested to be above 5MHz ' +
                               'for proper overdrive mode decoding.']])
        else:
            if self.samplerate < 400000:
                self.putm([1, ['Sampling rate is too low. Must be above ' +
                               '400kHz for proper normal mode decoding.']])
            elif self.samplerate < 1000000:
                self.putm([1, ['Sampling rate is suggested to be above ' +
                               '1MHz for proper normal mode decoding.']])

    def metadata(self, key, value):
        if key != srd.SRD_CONF_SAMPLERATE:
            return
        self.samplerate = value

    def decode(self, ss, es, data):
        if not self.samplerate:
            raise SamplerateError('Cannot decode without samplerate.')
        for (self.samplenum, (owr,)) in data:
            if self.samplenum == 0:
                self.checks()

            # State machine.
            if self.state == 'INITIAL': # Unknown initial state.
                # Wait until we reach the idle high state.
                if owr == 0:
                    continue
                self.rise = self.samplenum
                self.state = 'IDLE'
            elif self.state == 'IDLE': # Idle high state.
                # Wait for falling edge.
                if owr != 0:
                    continue
                self.fall = self.samplenum
                # Get time since last rising edge.
                time = ((self.fall - self.rise) / self.samplerate) * 1000000.0
                if self.rise > 0 and \
                    time < timing['REC']['min'][self.overdrive]:
                    self.put(self.fall, self.rise, self.out_ann,
                        [1, ['Recovery time not long enough'
                        'Recovery too short',
                        'REC < ' + str(timing['REC']['min'][self.overdrive])]])
                # A reset pulse or slot can start on a falling edge.
                self.state = 'LOW'
                # TODO: Check minimum recovery time.
            elif self.state == 'LOW': # Reset pulse or slot.
                # Wait for rising edge.
                if owr == 0:
                    continue
                self.rise = self.samplenum
                # Detect reset or slot base on timing.
                time = ((self.rise - self.fall) / self.samplerate) * 1000000.0
                if time >= timing['RSTL']['min'][False]: # Normal reset pulse.
                    if time > timing['RSTL']['max'][False]:
                        self.put(self.fall, self.rise, self.out_ann,
                            [1, ['Too long reset pulse might mask interrupt ' +
                            'signalling by other devices',
                            'Reset pulse too long',
                            'RST > ' + str(timing['RSTL']['max'][False])]])
                    # Regular reset pulse clears overdrive speed.
                    if self.overdrive:
                        self.put(self.fall, self.rise, self.out_ann,
                            [4, ['Exiting overdrive mode', 'Overdrive off']])
                    self.overdrive = False
                    self.put(self.fall, self.rise, self.out_ann,
                        [2, ['Reset', 'Rst', 'R']])
                    self.state = 'PRESENCE DETECT HIGH'
                elif self.overdrive == True and \
                    time >= timing['RSTL']['min'][self.overdrive] and \
                    time < timing['RSTL']['max'][self.overdrive]:
                    # Overdrive reset pulse.
                    self.put(self.fall, self.rise, self.out_ann,
                        [2, ['Reset', 'Rst', 'R']])
                    self.state = 'PRESENCE DETECT HIGH'
                elif time < timing['SLOT']['max'][self.overdrive]:
                    # Read/write time slot.
                    if time < timing['LOWR']['min'][self.overdrive]:
                        self.put(self.fall, self.rise, self.out_ann,
                            [1, ['Low signal not long enough',
                            'Low too short',
                            'LOW < ' + str(timing['LOWR']['min'][self.overdrive])]])
                    if time < timing['LOWR']['max'][self.overdrive]:
                        self.bit = 1 # Short pulse is a 1 bit.
                    else:
                        self.bit = 0 # Long pulse is a 0 bit.
                    # Wait for end of slot.
                    self.state = 'SLOT'
                else:
                    # Timing outside of known states.
                    self.put(self.fall, self.rise, self.out_ann,
                        [1, ['Erroneous signal', 'Error', 'Err', 'E']])
                    self.state = 'IDLE'
            elif self.state == 'PRESENCE DETECT HIGH': # Wait for slave presence signal.
                # Calculate time since rising edge.
                time = ((self.samplenum - self.rise) / self.samplerate) * 1000000.0
                if owr != 0 and time < timing['PDH']['max'][self.overdrive]:
                    continue
                elif owr == 0: # Presence detected.
                    if time < timing['PDH']['min'][self.overdrive]:
                        self.put(self.rise, self.samplenum, self.out_ann,
                            [1, ['Presence detect signal is too early',
                            'Presence detect too early',
                            'PDH < ' + str(timing['PDH']['min'][self.overdrive])]])
                    self.fall = self.samplenum
                    self.state = 'PRESENCE DETECT LOW'
                else: # No presence detected.
                    self.put(self.rise, self.samplenum, self.out_ann,
                        [3, ['Presence: false', 'Presence', 'Pres', 'P']])
                    self.put(self.rise, self.samplenum, self.out_python,
                        ['RESET/PRESENCE', False])
                    self.state = 'IDLE'
            elif self.state == 'PRESENCE DETECT LOW': # Slave presence signalled.
                # Wait for end of presence signal (on rising edge).
                if owr == 0:
                    continue
                # Calculate time since start of presence signal.
                time = ((self.samplenum - self.fall) / self.samplerate) * 1000000.0
                if time < timing['PDL']['min'][self.overdrive]:
                    self.put(self.fall, self.samplenum, self.out_ann,
                        [1, ['Presence detect signal is too short',
                        'Presence detect too short',
                        'PDL < ' + str(timing['PDL']['min'][self.overdrive])]])
                elif time > timing['PDL']['max'][self.overdrive]:
                    self.put(self.fall, self.samplenum, self.out_ann,
                        [1, ['Presence detect signal is too long',
                        'Presence detect too long',
                        'PDL > ' + str(timing['PDL']['max'][self.overdrive])]])
                if time > timing['RSTH']['min'][self.overdrive]:
                    self.rise = self.samplenum
                # Wait for end of presence detect.
                self.state = 'PRESENCE DETECT'

            # End states (for additional checks).
            if self.state == 'SLOT': # Wait for end of time slot.
                # Calculate time since falling edge.
                time = ((self.samplenum - self.fall) / self.samplerate) * 1000000.0
                if owr != 0 and time < timing['SLOT']['min'][self.overdrive]:
                    continue
                elif owr == 0: # Low detected before end of slot.
                    # Warn about irregularity.
                    self.put(self.fall, self.samplenum, self.out_ann,
                        [1, ['Time slot not long enough',
                        'Slot too short',
                        'SLOT < ' + str(timing['SLOT']['min'][self.overdrive])]])
                    # Don't output invalid bit.
                    self.fall = self.samplenum
                    self.state = 'LOW'
                else: # End of time slot.
                    # Output bit.
                    self.put(self.fall, self.samplenum, self.out_ann,
                        [0, ['Bit: %d' % self.bit, '%d' % self.bit]])
                    self.put(self.fall, self.samplenum, self.out_python,
                        ['BIT', self.bit])
                    # Save command bits.
                    if self.bit_count >= 0:
                        self.command += (self.bit << self.bit_count)
                        self.bit_count += 1
                    # Check for overdrive ROM command.
                    if self.bit_count >= 8:
                        if self.command == 0x3c or self.command == 0x69:
                            self.overdrive = True
                            self.put(self.samplenum, self.samplenum,
                                self.out_ann,
                                [4, ['Entering overdrive mode', 'Overdrive on']])
                        self.bit_count = -1
                    self.state = 'IDLE'

            if self.state == 'PRESENCE DETECT':
                # Wait for end of presence detect.
                # Calculate time since falling edge.
                time = ((self.samplenum - self.rise) / self.samplerate) * 1000000.0
                if owr != 0 and time < timing['RSTH']['min'][self.overdrive]:
                    continue
                elif owr == 0: # Low detected before end of presence detect.
                    # Warn about irregularity.
                    self.put(self.fall, self.samplenum, self.out_ann,
                        [1, ['Presence detect not long enough',
                        'Presence detect too short',
                        'RTSH < ' + str(timing['RSTH']['min'][self.overdrive])]])
                    # Inform about presence detected.
                    self.put(self.rise, self.samplenum, self.out_ann,
                        [3, ['Slave presence detected', 'Slave present',
                        'Present', 'P']])
                    self.put(self.rise, self.samplenum, self.out_python,
                        ['RESET/PRESENCE', True])
                    self.fall = self.samplenum
                    self.state = 'LOW'
                else: # End of time slot.
                    # Inform about presence detected.
                    self.put(self.rise, self.samplenum, self.out_ann,
                        [3, ['Presence: true', 'Presence', 'Pres', 'P']])
                    self.put(self.rise, self.samplenum, self.out_python,
                        ['RESET/PRESENCE', True])
                    self.rise = self.samplenum
                    # Start counting the first 8 bits to get the ROM command.
                    self.bit_count = 0
                    self.command = 0
                    self.state = 'IDLE'
Commit	Line	Data
	1	##
	2	## This file is part of the libsigrokdecode project.
	3	##
	4	## Copyright (C) 2017 Kevin Redon <kingkevin@cuvoodoo.info>
	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
	22	class SamplerateError(Exception):
	23	pass
	24
	25	# Timing values in us for the signal at regular and overdrive speed.
	26	timing = {
	27	'RSTL': {
	28	'min': {
	29	False: 480.0,
	30	True: 48.0,
	31	},
	32	'max': {
	33	False: 960.0,
	34	True: 80.0,
	35	},
	36	},
	37	'RSTH': {
	38	'min': {
	39	False: 480.0,
	40	True: 48.0,
	41	},
	42	},
	43	'PDH': {
	44	'min': {
	45	False: 15.0,
	46	True: 2.0,
	47	},
	48	'max': {
	49	False: 60.0,
	50	True: 6.0,
	51	},
	52	},
	53	'PDL': {
	54	'min': {
	55	False: 60.0,
	56	True: 8.0,
	57	},
	58	'max': {
	59	False: 240.0,
	60	True: 24.0,
	61	},
	62	},
	63	'SLOT': {
	64	'min': {
	65	False: 60.0,
	66	True: 6.0,
	67	},
	68	'max': {
	69	False: 120.0,
	70	True: 16.0,
	71	},
	72	},
	73	'REC': {
	74	'min': {
	75	False: 1.0,
	76	True: 1.0,
	77	},
	78	},
	79	'LOWR': {
	80	'min': {
	81	False: 1.0,
	82	True: 1.0,
	83	},
	84	'max': {
	85	False: 15.0,
	86	True: 2.0,
	87	},
	88	},
	89	}
	90
	91	class Decoder(srd.Decoder):
	92	api_version = 2
	93	id = 'onewire_link'
	94	name = '1-Wire link layer'
	95	longname = '1-Wire serial communication bus (link layer)'
	96	desc = 'Bidirectional, half-duplex, asynchronous serial bus.'
	97	license = 'gplv2+'
	98	inputs = ['logic']
	99	outputs = ['onewire_link']
	100	channels = (
	101	{'id': 'owr', 'name': 'OWR', 'desc': '1-Wire signal line'},
	102	)
	103	options = (
	104	{'id': 'overdrive', 'desc': 'Start in overdrive speed',
	105	'default': 'no', 'values': ('yes', 'no')},
	106	)
	107	annotations = (
	108	('bit', 'Bit'),
	109	('warnings', 'Warnings'),
	110	('reset', 'Reset'),
	111	('presence', 'Presence'),
	112	('overdrive', 'Overdrive speed notifications'),
	113	)
	114	annotation_rows = (
	115	('bits', 'Bits', (0, 2, 3)),
	116	('info', 'Info', (4,)),
	117	('warnings', 'Warnings', (1,)),
	118	)
	119
	120	def __init__(self):
	121	self.samplerate = None
	122	self.samplenum = 0
	123	self.state = 'INITIAL'
	124	self.present = 0
	125	self.bit = 0
	126	self.bit_count = -1
	127	self.command = 0
	128	self.overdrive = False
	129	self.fall = 0
	130	self.rise = 0
	131
	132	def start(self):
	133	self.out_python = self.register(srd.OUTPUT_PYTHON)
	134	self.out_ann = self.register(srd.OUTPUT_ANN)
	135	self.overdrive = (self.options['overdrive'] == 'yes')
	136	self.fall = 0
	137	self.rise = 0
	138	self.bit_count = -1
	139
	140	def checks(self):
	141	# Check if samplerate is appropriate.
	142	if self.options['overdrive'] == 'yes':
	143	if self.samplerate < 2000000:
	144	self.putm([1, ['Sampling rate is too low. Must be above ' +
	145	'2MHz for proper overdrive mode decoding.']])
	146	elif self.samplerate < 5000000:
	147	self.putm([1, ['Sampling rate is suggested to be above 5MHz ' +
	148	'for proper overdrive mode decoding.']])
	149	else:
	150	if self.samplerate < 400000:
	151	self.putm([1, ['Sampling rate is too low. Must be above ' +
	152	'400kHz for proper normal mode decoding.']])
	153	elif self.samplerate < 1000000:
	154	self.putm([1, ['Sampling rate is suggested to be above ' +
	155	'1MHz for proper normal mode decoding.']])
	156
	157	def metadata(self, key, value):
	158	if key != srd.SRD_CONF_SAMPLERATE:
	159	return
	160	self.samplerate = value
	161
	162	def decode(self, ss, es, data):
	163	if not self.samplerate:
	164	raise SamplerateError('Cannot decode without samplerate.')
	165	for (self.samplenum, (owr,)) in data:
	166	if self.samplenum == 0:
	167	self.checks()
	168
	169	# State machine.
	170	if self.state == 'INITIAL': # Unknown initial state.
	171	# Wait until we reach the idle high state.
	172	if owr == 0:
	173	continue
	174	self.rise = self.samplenum
	175	self.state = 'IDLE'
	176	elif self.state == 'IDLE': # Idle high state.
	177	# Wait for falling edge.
	178	if owr != 0:
	179	continue
	180	self.fall = self.samplenum
	181	# Get time since last rising edge.
	182	time = ((self.fall - self.rise) / self.samplerate) * 1000000.0
	183	if self.rise > 0 and \
	184	time < timing['REC']['min'][self.overdrive]:
	185	self.put(self.fall, self.rise, self.out_ann,
	186	[1, ['Recovery time not long enough'
	187	'Recovery too short',
	188	'REC < ' + str(timing['REC']['min'][self.overdrive])]])
	189	# A reset pulse or slot can start on a falling edge.
	190	self.state = 'LOW'
	191	# TODO: Check minimum recovery time.
	192	elif self.state == 'LOW': # Reset pulse or slot.
	193	# Wait for rising edge.
	194	if owr == 0:
	195	continue
	196	self.rise = self.samplenum
	197	# Detect reset or slot base on timing.
	198	time = ((self.rise - self.fall) / self.samplerate) * 1000000.0
	199	if time >= timing['RSTL']['min'][False]: # Normal reset pulse.
	200	if time > timing['RSTL']['max'][False]:
	201	self.put(self.fall, self.rise, self.out_ann,
	202	[1, ['Too long reset pulse might mask interrupt ' +
	203	'signalling by other devices',
	204	'Reset pulse too long',
	205	'RST > ' + str(timing['RSTL']['max'][False])]])
	206	# Regular reset pulse clears overdrive speed.
	207	if self.overdrive:
	208	self.put(self.fall, self.rise, self.out_ann,
	209	[4, ['Exiting overdrive mode', 'Overdrive off']])
	210	self.overdrive = False
	211	self.put(self.fall, self.rise, self.out_ann,
	212	[2, ['Reset', 'Rst', 'R']])
	213	self.state = 'PRESENCE DETECT HIGH'
	214	elif self.overdrive == True and \
	215	time >= timing['RSTL']['min'][self.overdrive] and \
	216	time < timing['RSTL']['max'][self.overdrive]:
	217	# Overdrive reset pulse.
	218	self.put(self.fall, self.rise, self.out_ann,
	219	[2, ['Reset', 'Rst', 'R']])
	220	self.state = 'PRESENCE DETECT HIGH'
	221	elif time < timing['SLOT']['max'][self.overdrive]:
	222	# Read/write time slot.
	223	if time < timing['LOWR']['min'][self.overdrive]:
	224	self.put(self.fall, self.rise, self.out_ann,
	225	[1, ['Low signal not long enough',
	226	'Low too short',
	227	'LOW < ' + str(timing['LOWR']['min'][self.overdrive])]])
	228	if time < timing['LOWR']['max'][self.overdrive]:
	229	self.bit = 1 # Short pulse is a 1 bit.
	230	else:
	231	self.bit = 0 # Long pulse is a 0 bit.
	232	# Wait for end of slot.
	233	self.state = 'SLOT'
	234	else:
	235	# Timing outside of known states.
	236	self.put(self.fall, self.rise, self.out_ann,
	237	[1, ['Erroneous signal', 'Error', 'Err', 'E']])
	238	self.state = 'IDLE'
	239	elif self.state == 'PRESENCE DETECT HIGH': # Wait for slave presence signal.
	240	# Calculate time since rising edge.
	241	time = ((self.samplenum - self.rise) / self.samplerate) * 1000000.0
	242	if owr != 0 and time < timing['PDH']['max'][self.overdrive]:
	243	continue
	244	elif owr == 0: # Presence detected.
	245	if time < timing['PDH']['min'][self.overdrive]:
	246	self.put(self.rise, self.samplenum, self.out_ann,
	247	[1, ['Presence detect signal is too early',
	248	'Presence detect too early',
	249	'PDH < ' + str(timing['PDH']['min'][self.overdrive])]])
	250	self.fall = self.samplenum
	251	self.state = 'PRESENCE DETECT LOW'
	252	else: # No presence detected.
	253	self.put(self.rise, self.samplenum, self.out_ann,
	254	[3, ['Presence: false', 'Presence', 'Pres', 'P']])
	255	self.put(self.rise, self.samplenum, self.out_python,
	256	['RESET/PRESENCE', False])
	257	self.state = 'IDLE'
	258	elif self.state == 'PRESENCE DETECT LOW': # Slave presence signalled.
	259	# Wait for end of presence signal (on rising edge).
	260	if owr == 0:
	261	continue
	262	# Calculate time since start of presence signal.
	263	time = ((self.samplenum - self.fall) / self.samplerate) * 1000000.0
	264	if time < timing['PDL']['min'][self.overdrive]:
	265	self.put(self.fall, self.samplenum, self.out_ann,
	266	[1, ['Presence detect signal is too short',
	267	'Presence detect too short',
	268	'PDL < ' + str(timing['PDL']['min'][self.overdrive])]])
	269	elif time > timing['PDL']['max'][self.overdrive]:
	270	self.put(self.fall, self.samplenum, self.out_ann,
	271	[1, ['Presence detect signal is too long',
	272	'Presence detect too long',
	273	'PDL > ' + str(timing['PDL']['max'][self.overdrive])]])
	274	if time > timing['RSTH']['min'][self.overdrive]:
	275	self.rise = self.samplenum
	276	# Wait for end of presence detect.
	277	self.state = 'PRESENCE DETECT'
	278
	279	# End states (for additional checks).
	280	if self.state == 'SLOT': # Wait for end of time slot.
	281	# Calculate time since falling edge.
	282	time = ((self.samplenum - self.fall) / self.samplerate) * 1000000.0
	283	if owr != 0 and time < timing['SLOT']['min'][self.overdrive]:
	284	continue
	285	elif owr == 0: # Low detected before end of slot.
	286	# Warn about irregularity.
	287	self.put(self.fall, self.samplenum, self.out_ann,
	288	[1, ['Time slot not long enough',
	289	'Slot too short',
	290	'SLOT < ' + str(timing['SLOT']['min'][self.overdrive])]])
	291	# Don't output invalid bit.
	292	self.fall = self.samplenum
	293	self.state = 'LOW'
	294	else: # End of time slot.
	295	# Output bit.
	296	self.put(self.fall, self.samplenum, self.out_ann,
	297	[0, ['Bit: %d' % self.bit, '%d' % self.bit]])
	298	self.put(self.fall, self.samplenum, self.out_python,
	299	['BIT', self.bit])
	300	# Save command bits.
	301	if self.bit_count >= 0:
	302	self.command += (self.bit << self.bit_count)
	303	self.bit_count += 1
	304	# Check for overdrive ROM command.
	305	if self.bit_count >= 8:
	306	if self.command == 0x3c or self.command == 0x69:
	307	self.overdrive = True
	308	self.put(self.samplenum, self.samplenum,
	309	self.out_ann,
	310	[4, ['Entering overdrive mode', 'Overdrive on']])
	311	self.bit_count = -1
	312	self.state = 'IDLE'
	313
	314	if self.state == 'PRESENCE DETECT':
	315	# Wait for end of presence detect.
	316	# Calculate time since falling edge.
	317	time = ((self.samplenum - self.rise) / self.samplerate) * 1000000.0
	318	if owr != 0 and time < timing['RSTH']['min'][self.overdrive]:
	319	continue
	320	elif owr == 0: # Low detected before end of presence detect.
	321	# Warn about irregularity.
	322	self.put(self.fall, self.samplenum, self.out_ann,
	323	[1, ['Presence detect not long enough',
	324	'Presence detect too short',
	325	'RTSH < ' + str(timing['RSTH']['min'][self.overdrive])]])
	326	# Inform about presence detected.
	327	self.put(self.rise, self.samplenum, self.out_ann,
	328	[3, ['Slave presence detected', 'Slave present',
	329	'Present', 'P']])
	330	self.put(self.rise, self.samplenum, self.out_python,
	331	['RESET/PRESENCE', True])
	332	self.fall = self.samplenum
	333	self.state = 'LOW'
	334	else: # End of time slot.
	335	# Inform about presence detected.
	336	self.put(self.rise, self.samplenum, self.out_ann,
	337	[3, ['Presence: true', 'Presence', 'Pres', 'P']])
	338	self.put(self.rise, self.samplenum, self.out_python,
	339	['RESET/PRESENCE', True])
	340	self.rise = self.samplenum
	341	# Start counting the first 8 bits to get the ROM command.
	342	self.bit_count = 0
	343	self.command = 0
	344	self.state = 'IDLE'