BlackMark
e7f6cd3ee8
Pins move the image for exactly one reason — a bit-banged link on a USART's own
pins has to release that USART — and the matrix said outright that they were no
axis, so the tightest configuration in the space was one nothing built. Not
subtly, either: the 1284's slot ends at flash end, so that build does not merely
exceed the size test's limit, it fails to link. pureboot_{sw,autobaud}_on_usart
{0,1} are gate points in both matrix modes now, and the exhaustive sweep carries
the pins across its whole cross product. The hand-measured table is the gate's
output: 506 B of 512 for the 1284 autobaud on USART0's pins, 504 on USART1's.
pureboot.mute drives the defect itself — an application hands over with USART0
still enabled and the loader on those pins must still answer. Reaching that
needed the runner to know an enabled USART owns its TxD, which simavr does not
model at all: it wires a USART through IRQs and never takes the pin from the
port. It also brings UCSRnB up with TXEN already set where silicon clears the
register, so the runner restores the reset value for the USART it models — the
mute must come from the application, not from power-on. The fixture stays
silent, since nothing is listening on the USART it brings up.
test_handshake.py, written where no gate could run it, is pureboot.handshake.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
106 lines
3.1 KiB
Python
106 lines
3.1 KiB
Python
#!/usr/bin/env python3
|
|
"""Host-tool activation handshake: it must not hang on a flooding target.
|
|
|
|
`_handshake` drains the line after it sees a prompt, to absorb a real loader's
|
|
trailing bytes before it asks for the identity. That drain must be bounded: a
|
|
target that never falls quiet — a board stuck in a reset loop presents exactly
|
|
this, ~60 reboots/s of UART-reset garbage in which a stray 0x2b reads as a
|
|
prompt — otherwise spins the tool forever. Regression for that hang, plus a
|
|
control that a well-behaved loader still connects.
|
|
|
|
Stdlib only, no device: host-tool logic, so it runs on every chip's preset
|
|
beside pureboot.planner.
|
|
"""
|
|
import importlib.util
|
|
import pathlib
|
|
import threading
|
|
import time
|
|
|
|
PB = pathlib.Path(__file__).resolve().parents[1] / "pureboot" / "pureboot.py"
|
|
_spec = importlib.util.spec_from_file_location("pureboot", PB)
|
|
pb = importlib.util.module_from_spec(_spec)
|
|
_spec.loader.exec_module(pb)
|
|
|
|
P = F = 0
|
|
|
|
|
|
def check(name, ok):
|
|
global P, F
|
|
P, F = P + (1 if ok else 0), F + (0 if ok else 1)
|
|
print(f" [{'PASS' if ok else 'FAIL'}] {name}")
|
|
|
|
|
|
class FloodPort:
|
|
"""A line that never falls quiet: read_available always returns bytes, and
|
|
they contain a prompt. No identity ever completes."""
|
|
|
|
def flush_input(self):
|
|
pass
|
|
|
|
def write(self, data):
|
|
pass
|
|
|
|
def read_available(self, wait):
|
|
time.sleep(0.01) # a real read waits; keep the busy loop off a core
|
|
return b"+\x00\xff"
|
|
|
|
def read_exact(self, count, timeout):
|
|
raise pb.Error("no identity")
|
|
|
|
|
|
class LoaderPort:
|
|
"""A well-behaved pureboot 5: one prompt to the knock, then quiet, then the
|
|
slim identity (version 5 + m328p signature) and a closing prompt."""
|
|
|
|
def __init__(self):
|
|
self.reads = self.exacts = 0
|
|
|
|
def flush_input(self):
|
|
pass
|
|
|
|
def write(self, data):
|
|
pass
|
|
|
|
def read_available(self, wait):
|
|
self.reads += 1
|
|
return b"+" if self.reads == 1 else b"" # prompt once, then settle quiet
|
|
|
|
def read_exact(self, count, timeout):
|
|
self.exacts += 1
|
|
return b"\x05\x1e\x95\x0f" if self.exacts == 1 else b"+" # identity, then prompt
|
|
|
|
|
|
def terminates(port, wait, budget):
|
|
"""Run connect_autobaud in a thread; True if it returns/raises within
|
|
`budget` seconds rather than hanging."""
|
|
done = threading.Event()
|
|
|
|
def run():
|
|
try:
|
|
pb.Loader(port).connect_autobaud(wait)
|
|
except Exception:
|
|
pass
|
|
finally:
|
|
done.set()
|
|
|
|
threading.Thread(target=run, daemon=True).start()
|
|
return done.wait(budget)
|
|
|
|
|
|
def main():
|
|
# the hang: a flooding target must not spin the drain forever. With wait=0.5
|
|
# the whole handshake has to give up well inside a few seconds.
|
|
check("flooding target: handshake terminates, drain is bounded",
|
|
terminates(FloodPort(), wait=0.5, budget=4.0))
|
|
|
|
# the control: a real loader still connects and reads identity.
|
|
info = pb.Loader(LoaderPort()).connect_autobaud(2.0)
|
|
check("well-behaved loader still connects (version 5)", info.version == 5)
|
|
|
|
print(f"\n {P} passed, {F} failed")
|
|
return 1 if F else 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|