BlackMark
8e7cc86fb3
The window's per-poll cycle counts were hand-counted for a uint32_t countdown, but every default window fits uint24_t, whose decrement chain is one sbci shorter — so deployed loaders ran 9/10ths of their stated seconds (a 328P's 8 s was 7.2 s on the wire). No golden-asm pin can hold this: the loops compile in consumer context. pbwindow.py measures the behavior instead: it installs a real application beside the loader through the host tool's own plan_flash (surgery included), starts the simulator with the line idle, and reads the cycle of the first transmit — the application's banner, so that cycle is the window. Held at plus or minus 2 percent per chip (pureboot.window), red at -10.0 percent against the old constants, green with poll_cycles now counted for the narrow countdown (hardware 9, software 7; window_polls() solves narrow-first and adds the wide loop's cycle where the count forces uint32_t — a count narrow only at the wide cost stays wide, so the choice cannot oscillate). The autobaud window is its poll budget at the measured ten cycles a poll, gated the same way (pureboot.window.autobaud), and the README carries that arithmetic now. No version bump: timing-window precision is not meaningful behavior, v7 stays. The gate flushed out two runner gaps. The software bridge accepted any falling edge as a start bit, so the device's own TX-init glitch decoded as a stray byte; it re-samples mid-bit now and abandons a false start, as silicon does. And after avr_reset, the idle-line re-raise was silently dropped: ioport pin irqs are IRQ_FLAG_FILTERED and the irq's cached value survives the reset the port latch does not, so the device read the line stuck low, calibrate() measured reset-to-first-edge as one wrapping pulse, and the first knock after a reset could boot the application instead of locking — the intermittent autobaud failure. bridge_reset forces a real transition (0 then 1, no cycles between). The README's Autobaud column now carries each chip's worst configuration — autobaud with OSCCAL baked, on a USART's own pins where the chip has one (tinies: autobaud + OSCCAL) — the numbers the existing pureboot_autobaud_osccal[_on_usart0] matrix points already gate; sizes.py checks the column against exactly those targets. Tool sizes and window prose updated with it. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
72 lines
2.6 KiB
Python
72 lines
2.6 KiB
Python
"""Shared simavr harness for the pureboot tests: spawn the device runner,
|
|
hand out its pty, restart it from a flash dump (the power-fail path), and
|
|
keep its chatter out of undrained pipes."""
|
|
|
|
import os
|
|
import signal
|
|
import subprocess
|
|
|
|
|
|
class Device:
|
|
def __init__(self, binary, elf, mcu, hz, base_hex, page, baud, dump, reset_hex=None, resume=None, link=None,
|
|
window=False):
|
|
cmd = [binary]
|
|
if link:
|
|
cmd += ["-l", link]
|
|
if window:
|
|
cmd.append("-w") # report the first-transmit cycle, free-run idle
|
|
cmd += [elf, mcu, hz, base_hex, str(page), str(baud), dump]
|
|
if reset_hex is not None or resume is not None:
|
|
# Chips without a hardware boot section — the tinies and the
|
|
# m48s — reset to address 0 like silicon; the boot-sectioned
|
|
# megas re-vector to the loader base (BOOTRST).
|
|
patch = not mcu.startswith("atmega") or mcu.startswith("atmega48")
|
|
cmd.append(reset_hex if reset_hex is not None else ("0" if patch else base_hex))
|
|
if resume is not None:
|
|
cmd.append(resume)
|
|
self.log = open(dump + ".log", "a")
|
|
self.proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=self.log, text=True)
|
|
self.dump = dump
|
|
self.pty = None
|
|
for _ in range(50):
|
|
line = self.proc.stdout.readline()
|
|
if not line:
|
|
break
|
|
if line.startswith("PB_PTY"):
|
|
self.pty = line.split()[1]
|
|
break
|
|
if not self.pty:
|
|
self.stop()
|
|
raise RuntimeError("device did not report a pty")
|
|
|
|
def reset(self):
|
|
"""The external reset line: SIGUSR1 re-enters at the reset vector."""
|
|
self.proc.send_signal(signal.SIGUSR1)
|
|
|
|
def power_fail(self):
|
|
"""SIGTERM: the runner dumps its flash and exits — the image a
|
|
restart resumes from."""
|
|
self.stop()
|
|
return self.dump
|
|
|
|
def stop(self):
|
|
self.proc.terminate()
|
|
try:
|
|
self.proc.wait(timeout=5)
|
|
except subprocess.TimeoutExpired:
|
|
self.proc.kill()
|
|
self.log.close()
|
|
|
|
|
|
def run_tool(tool, pty, baud, *args, timeout=180):
|
|
result = subprocess.run(
|
|
[os.environ.get("PYTHON", "python3"), tool, "--port", pty, "--baud", str(baud), "--wait", "25", *args],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=timeout,
|
|
)
|
|
print(result.stdout, end="")
|
|
if result.returncode != 0:
|
|
raise RuntimeError(f"tool exited {result.returncode}: {result.stderr.strip()}")
|
|
return result.stdout
|