[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 putm(self, data):
        self.put(0, 0, self.out_ann, data)

    def putpfs(self, data):
        self.put(self.fall, self.samplenum, self.out_python, data)

    def putfs(self, data):
        self.put(self.fall, self.samplenum, self.out_ann, data)

    def putfr(self, data):
        self.put(self.fall, self.rise, self.out_ann, data)

    def putprs(self, data):
        self.put(self.rise, self.samplenum, self.out_python, data)

    def putrs(self, data):
        self.put(self.rise, self.samplenum, self.out_ann, data)

    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.putfr([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.putfr([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.putfr([4, ['Exiting overdrive mode', 'Overdrive off']])
                    self.overdrive = False
                    self.putfr([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.putfr([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.putfr([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.putfr([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.putrs([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.putrs([3, ['Presence: false', 'Presence', 'Pres', 'P']])
                    self.putprs(['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.putfs([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.putfs([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.putfs([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.putfs([0, ['Bit: %d' % self.bit, '%d' % self.bit]])
                    self.putpfs(['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.putfs([1, ['Presence detect not long enough',
                        'Presence detect too short',
                        'RTSH < ' + str(timing['RSTH']['min'][self.overdrive])]])
                    # Inform about presence detected.
                    self.putrs([3, ['Slave presence detected', 'Slave present',
                        'Present', 'P']])
                    self.putprs(['RESET/PRESENCE', True])
                    self.fall = self.samplenum
                    self.state = 'LOW'
                else: # End of time slot.
                    # Inform about presence detected.
                    self.putrs([3, ['Presence: true', 'Presence', 'Pres', 'P']])
                    self.putprs(['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
9cfb16e8	1	##
50bd5d25	2	## This file is part of the libsigrokdecode project.
9cfb16e8	3	##
548b39e7	4	## Copyright (C) 2017 Kevin Redon <kingkevin@cuvoodoo.info>
9cfb16e8 IJ	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
4539e9ca	17	## along with this program; if not, see <http://www.gnu.org/licenses/>.
9cfb16e8 IJ	18	##
9cfb16e8 IJ	19
9cfb16e8 IJ	20	import sigrokdecode as srd
9cfb16e8 IJ	21
21cda951 UH	22	class SamplerateError(Exception):
	23	pass
	24
548b39e7 KK	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
9cfb16e8	91	class Decoder(srd.Decoder):
548b39e7	92	api_version = 2
9cfb16e8 IJ	93	id = 'onewire_link'
9cfb16e8 IJ	94	name = '1-Wire link layer'
e7720d6c	95	longname = '1-Wire serial communication bus (link layer)'
9cfb16e8 IJ	96	desc = 'Bidirectional, half-duplex, asynchronous serial bus.'
	97	license = 'gplv2+'
	98	inputs = ['logic']
	99	outputs = ['onewire_link']
6a15597a	100	channels = (
3f302d51	101	{'id': 'owr', 'name': 'OWR', 'desc': '1-Wire signal line'},
da9bcbd9	102	)
84c1c0b5	103	options = (
548b39e7 KK	104	{'id': 'overdrive', 'desc': 'Start in overdrive speed',
548b39e7 KK	105	'default': 'no', 'values': ('yes', 'no')},
84c1c0b5	106	)
da9bcbd9 BV	107	annotations = (
	108	('bit', 'Bit'),
	109	('warnings', 'Warnings'),
	110	('reset', 'Reset'),
	111	('presence', 'Presence'),
548b39e7	112	('overdrive', 'Overdrive speed notifications'),
da9bcbd9	113	)
8e11415b UH	114	annotation_rows = (
	115	('bits', 'Bits', (0, 2, 3)),
	116	('info', 'Info', (4,)),
	117	('warnings', 'Warnings', (1,)),
	118	)
9cfb16e8	119
92b7b49f	120	def __init__(self):
f372d597	121	self.samplerate = None
548b39e7 KK	122	self.samplenum = 0
548b39e7 KK	123	self.state = 'INITIAL'
9cfb16e8	124	self.present = 0
e7720d6c	125	self.bit = 0
548b39e7	126	self.bit_count = -1
99f5f3b5	127	self.command = 0
548b39e7	128	self.overdrive = False
e7720d6c UH	129	self.fall = 0
e7720d6c UH	130	self.rise = 0
9cfb16e8	131
f372d597	132	def start(self):
c515eed7	133	self.out_python = self.register(srd.OUTPUT_PYTHON)
be465111	134	self.out_ann = self.register(srd.OUTPUT_ANN)
548b39e7 KK	135	self.overdrive = (self.options['overdrive'] == 'yes')
	136	self.fall = 0
	137	self.rise = 0
	138	self.bit_count = -1
d14e8033	139
64922f69 UH	140	def putm(self, data):
	141	self.put(0, 0, self.out_ann, data)
	142
	143	def putpfs(self, data):
	144	self.put(self.fall, self.samplenum, self.out_python, data)
	145
	146	def putfs(self, data):
	147	self.put(self.fall, self.samplenum, self.out_ann, data)
	148
	149	def putfr(self, data):
	150	self.put(self.fall, self.rise, self.out_ann, data)
	151
	152	def putprs(self, data):
	153	self.put(self.rise, self.samplenum, self.out_python, data)
	154
	155	def putrs(self, data):
	156	self.put(self.rise, self.samplenum, self.out_ann, data)
	157
3085037b	158	def checks(self):
e7720d6c	159	# Check if samplerate is appropriate.
01520fa9	160	if self.options['overdrive'] == 'yes':
e7720d6c	161	if self.samplerate < 2000000:
ddeb9b32 UH	162	self.putm([1, ['Sampling rate is too low. Must be above ' +
ddeb9b32 UH	163	'2MHz for proper overdrive mode decoding.']])
e7720d6c	164	elif self.samplerate < 5000000:
ddeb9b32 UH	165	self.putm([1, ['Sampling rate is suggested to be above 5MHz ' +
ddeb9b32 UH	166	'for proper overdrive mode decoding.']])
9cfb16e8	167	else:
e7720d6c	168	if self.samplerate < 400000:
ddeb9b32 UH	169	self.putm([1, ['Sampling rate is too low. Must be above ' +
ddeb9b32 UH	170	'400kHz for proper normal mode decoding.']])
3085037b	171	elif self.samplerate < 1000000:
ddeb9b32 UH	172	self.putm([1, ['Sampling rate is suggested to be above ' +
ddeb9b32 UH	173	'1MHz for proper normal mode decoding.']])
9cfb16e8	174
3085037b UH	175	def metadata(self, key, value):
	176	if key != srd.SRD_CONF_SAMPLERATE:
	177	return
	178	self.samplerate = value
	179
548b39e7	180	def decode(self, ss, es, data):
21cda951 UH	181	if not self.samplerate:
21cda951 UH	182	raise SamplerateError('Cannot decode without samplerate.')
548b39e7 KK	183	for (self.samplenum, (owr,)) in data:
	184	if self.samplenum == 0:
	185	self.checks()
	186
9cfb16e8	187	# State machine.
548b39e7 KK	188	if self.state == 'INITIAL': # Unknown initial state.
	189	# Wait until we reach the idle high state.
	190	if owr == 0:
	191	continue
	192	self.rise = self.samplenum
	193	self.state = 'IDLE'
	194	elif self.state == 'IDLE': # Idle high state.
	195	# Wait for falling edge.
	196	if owr != 0:
	197	continue
48b59746	198	self.fall = self.samplenum
548b39e7 KK	199	# Get time since last rising edge.
	200	time = ((self.fall - self.rise) / self.samplerate) * 1000000.0
	201	if self.rise > 0 and \
	202	time < timing['REC']['min'][self.overdrive]:
64922f69	203	self.putfr([1, ['Recovery time not long enough'
548b39e7 KK	204	'Recovery too short',
	205	'REC < ' + str(timing['REC']['min'][self.overdrive])]])
	206	# A reset pulse or slot can start on a falling edge.
	207	self.state = 'LOW'
	208	# TODO: Check minimum recovery time.
	209	elif self.state == 'LOW': # Reset pulse or slot.
	210	# Wait for rising edge.
48b59746	211	if owr == 0:
48b59746	212	continue
548b39e7 KK	213	self.rise = self.samplenum
	214	# Detect reset or slot base on timing.
	215	time = ((self.rise - self.fall) / self.samplerate) * 1000000.0
	216	if time >= timing['RSTL']['min'][False]: # Normal reset pulse.
	217	if time > timing['RSTL']['max'][False]:
64922f69	218	self.putfr([1, ['Too long reset pulse might mask interrupt ' +
548b39e7 KK	219	'signalling by other devices',
	220	'Reset pulse too long',
	221	'RST > ' + str(timing['RSTL']['max'][False])]])
	222	# Regular reset pulse clears overdrive speed.
48b59746	223	if self.overdrive:
64922f69	224	self.putfr([4, ['Exiting overdrive mode', 'Overdrive off']])
548b39e7	225	self.overdrive = False
64922f69	226	self.putfr([2, ['Reset', 'Rst', 'R']])
548b39e7 KK	227	self.state = 'PRESENCE DETECT HIGH'
	228	elif self.overdrive == True and \
	229	time >= timing['RSTL']['min'][self.overdrive] and \
	230	time < timing['RSTL']['max'][self.overdrive]:
	231	# Overdrive reset pulse.
64922f69	232	self.putfr([2, ['Reset', 'Rst', 'R']])
548b39e7 KK	233	self.state = 'PRESENCE DETECT HIGH'
	234	elif time < timing['SLOT']['max'][self.overdrive]:
	235	# Read/write time slot.
	236	if time < timing['LOWR']['min'][self.overdrive]:
64922f69	237	self.putfr([1, ['Low signal not long enough',
548b39e7 KK	238	'Low too short',
	239	'LOW < ' + str(timing['LOWR']['min'][self.overdrive])]])
	240	if time < timing['LOWR']['max'][self.overdrive]:
	241	self.bit = 1 # Short pulse is a 1 bit.
	242	else:
	243	self.bit = 0 # Long pulse is a 0 bit.
	244	# Wait for end of slot.
	245	self.state = 'SLOT'
48b59746	246	else:
548b39e7	247	# Timing outside of known states.
64922f69	248	self.putfr([1, ['Erroneous signal', 'Error', 'Err', 'E']])
548b39e7 KK	249	self.state = 'IDLE'
	250	elif self.state == 'PRESENCE DETECT HIGH': # Wait for slave presence signal.
	251	# Calculate time since rising edge.
	252	time = ((self.samplenum - self.rise) / self.samplerate) * 1000000.0
	253	if owr != 0 and time < timing['PDH']['max'][self.overdrive]:
	254	continue
	255	elif owr == 0: # Presence detected.
	256	if time < timing['PDH']['min'][self.overdrive]:
64922f69	257	self.putrs([1, ['Presence detect signal is too early',
548b39e7 KK	258	'Presence detect too early',
	259	'PDH < ' + str(timing['PDH']['min'][self.overdrive])]])
	260	self.fall = self.samplenum
	261	self.state = 'PRESENCE DETECT LOW'
	262	else: # No presence detected.
64922f69 UH	263	self.putrs([3, ['Presence: false', 'Presence', 'Pres', 'P']])
64922f69 UH	264	self.putprs(['RESET/PRESENCE', False])
548b39e7 KK	265	self.state = 'IDLE'
	266	elif self.state == 'PRESENCE DETECT LOW': # Slave presence signalled.
	267	# Wait for end of presence signal (on rising edge).
48b59746	268	if owr == 0:
48b59746	269	continue
548b39e7 KK	270	# Calculate time since start of presence signal.
	271	time = ((self.samplenum - self.fall) / self.samplerate) * 1000000.0
	272	if time < timing['PDL']['min'][self.overdrive]:
64922f69	273	self.putfs([1, ['Presence detect signal is too short',
548b39e7 KK	274	'Presence detect too short',
	275	'PDL < ' + str(timing['PDL']['min'][self.overdrive])]])
	276	elif time > timing['PDL']['max'][self.overdrive]:
64922f69	277	self.putfs([1, ['Presence detect signal is too long',
548b39e7 KK	278	'Presence detect too long',
	279	'PDL > ' + str(timing['PDL']['max'][self.overdrive])]])
	280	if time > timing['RSTH']['min'][self.overdrive]:
	281	self.rise = self.samplenum
	282	# Wait for end of presence detect.
	283	self.state = 'PRESENCE DETECT'
	284
	285	# End states (for additional checks).
	286	if self.state == 'SLOT': # Wait for end of time slot.
	287	# Calculate time since falling edge.
	288	time = ((self.samplenum - self.fall) / self.samplerate) * 1000000.0
	289	if owr != 0 and time < timing['SLOT']['min'][self.overdrive]:
	290	continue
	291	elif owr == 0: # Low detected before end of slot.
	292	# Warn about irregularity.
64922f69	293	self.putfs([1, ['Time slot not long enough',
548b39e7 KK	294	'Slot too short',
	295	'SLOT < ' + str(timing['SLOT']['min'][self.overdrive])]])
	296	# Don't output invalid bit.
	297	self.fall = self.samplenum
	298	self.state = 'LOW'
	299	else: # End of time slot.
	300	# Output bit.
64922f69 UH	301	self.putfs([0, ['Bit: %d' % self.bit, '%d' % self.bit]])
64922f69 UH	302	self.putpfs(['BIT', self.bit])
548b39e7 KK	303	# Save command bits.
	304	if self.bit_count >= 0:
	305	self.command += (self.bit << self.bit_count)
	306	self.bit_count += 1
	307	# Check for overdrive ROM command.
	308	if self.bit_count >= 8:
	309	if self.command == 0x3c or self.command == 0x69:
	310	self.overdrive = True
	311	self.put(self.samplenum, self.samplenum,
	312	self.out_ann,
	313	[4, ['Entering overdrive mode', 'Overdrive on']])
	314	self.bit_count = -1
	315	self.state = 'IDLE'
	316
	317	if self.state == 'PRESENCE DETECT':
	318	# Wait for end of presence detect.
	319	# Calculate time since falling edge.
	320	time = ((self.samplenum - self.rise) / self.samplerate) * 1000000.0
	321	if owr != 0 and time < timing['RSTH']['min'][self.overdrive]:
	322	continue
	323	elif owr == 0: # Low detected before end of presence detect.
	324	# Warn about irregularity.
64922f69	325	self.putfs([1, ['Presence detect not long enough',
548b39e7 KK	326	'Presence detect too short',
	327	'RTSH < ' + str(timing['RSTH']['min'][self.overdrive])]])
	328	# Inform about presence detected.
64922f69	329	self.putrs([3, ['Slave presence detected', 'Slave present',
548b39e7	330	'Present', 'P']])
64922f69	331	self.putprs(['RESET/PRESENCE', True])
548b39e7 KK	332	self.fall = self.samplenum
	333	self.state = 'LOW'
	334	else: # End of time slot.
	335	# Inform about presence detected.
64922f69 UH	336	self.putrs([3, ['Presence: true', 'Presence', 'Pres', 'P']])
64922f69 UH	337	self.putprs(['RESET/PRESENCE', True])
548b39e7 KK	338	self.rise = self.samplenum
	339	# Start counting the first 8 bits to get the ROM command.
	340	self.bit_count = 0
	341	self.command = 0
	342	self.state = 'IDLE'