Files
hexapod-robot/2026-current/dongle/tools/dongle_flash.py
T

191 lines
6.1 KiB
Python
Raw Normal View History

"""Flash a .bin to the dongle's STM32F030 over the ROM UART bootloader (COM16).
First run unlocks (readout-unprotect = mass erase + drop RDP), then writes & verifies.
usage: dongle_flash.py firmware.bin [--port COM16]"""
import sys, time, serial
ACK, NACK = 0x79, 0x1F
FLASH = 0x08000000
def open_racing(port, open_timeout=20.0):
"""Keep retrying to open the port - wins the race against programs (e.g.
SignalRGB) that also grab CH340 COM ports on enumeration."""
t = time.time()
while True:
try:
return serial.Serial(port, 115200, parity=serial.PARITY_EVEN,
stopbits=1, bytesize=8, timeout=1.0)
except serial.SerialException:
if time.time() - t > open_timeout:
raise
time.sleep(0.02)
class BL:
def __init__(self, port):
self.port = port
self.s = open_racing(port)
def reopen(self):
self.s.close(); time.sleep(0.3)
self.s = open_racing(self.port)
def _wait_ack(self, what, tmo=3.0):
self.s.timeout = tmo
b = self.s.read(1)
self.s.timeout = 1.0
if b == bytes([ACK]):
return True
if b == bytes([NACK]):
raise RuntimeError("%s: NACK" % what)
raise RuntimeError("%s: no answer (%r)" % (what, b))
def _probe_get(self):
"""Already synced? A GET (0x00) ACKs and returns the command list."""
self.s.reset_input_buffer()
self.s.write(bytes([0x00, 0xFF])); time.sleep(0.15)
b = self.s.read(1)
if b == bytes([ACK]):
n = self.s.read(1)[0]; self.s.read(n + 1); self.s.read(1)
return True
return b == bytes([NACK])
def sync(self):
# autobaud (works once per power-up)
self.s.reset_input_buffer()
self.s.write(b"\x7f"); time.sleep(0.15)
b = self.s.read(1)
if b in (bytes([ACK]), bytes([NACK])):
return True
# already synced this power cycle?
if self._probe_get():
return True
raise RuntimeError("no bootloader sync (BOOT0 high? on USB power? replug it)")
def cmd(self, c):
self.s.write(bytes([c, c ^ 0xFF]))
return self._wait_ack("cmd 0x%02X" % c)
def get(self):
self.cmd(0x00)
n = self.s.read(1)[0]
data = self.s.read(n + 1)
self.s.read(1)
return data
def readable(self):
self.s.write(bytes([0x11, 0xEE]))
b = self.s.read(1)
if b == bytes([ACK]):
# send a dummy address so the bootloader doesn't hang mid-command
self._addr(FLASH); self.s.write(bytes([0, 0xFF])); self.s.read(1)
self.s.read(1)
return True
return False
def _addr(self, addr):
a = addr.to_bytes(4, "big")
self.s.write(a + bytes([a[0] ^ a[1] ^ a[2] ^ a[3]]))
self._wait_ack("address 0x%08X" % addr)
def unprotect(self):
"""Readout-unprotect: mass-erase + drop RDP to 0. Erases factory firmware."""
self.s.write(bytes([0x92, 0x6D]))
self._wait_ack("readout-unprotect start")
self._wait_ack("readout-unprotect erase", tmo=6.0)
time.sleep(1.0) # chip resets; BOOT0 still high -> bootloader again
self.reopen(); self.sync()
def mass_erase(self):
self.s.write(bytes([0x44, 0xBB]))
self._wait_ack("ext-erase start")
self.s.write(bytes([0xFF, 0xFF, 0x00])) # 0xFFFF = global mass erase, cksum 0
self._wait_ack("mass erase", tmo=8.0)
def write(self, addr, data):
self.cmd(0x31)
self._addr(addr)
n = len(data) - 1
cs = n
for b in data:
cs ^= b
self.s.write(bytes([n]) + data + bytes([cs]))
self._wait_ack("write @0x%08X" % addr, tmo=3.0)
def read(self, addr, n):
self.cmd(0x11)
self._addr(addr)
self.s.write(bytes([n - 1, (n - 1) ^ 0xFF]))
self._wait_ack("read @0x%08X" % addr)
return self.s.read(n)
def go(self, addr):
self.cmd(0x21)
self._addr(addr)
def main():
args = [a for a in sys.argv[1:] if not a.startswith("--")]
port = "COM16"
if "--port" in sys.argv:
port = sys.argv[sys.argv.index("--port") + 1]
data = open(args[0], "rb").read()
if len(data) % 4:
data += b"\xFF" * (4 - len(data) % 4)
print("firmware %s: %d bytes" % (args[0], len(data)))
bl = BL(port)
bl.sync()
time.sleep(0.1)
bl.s.reset_input_buffer()
print("sync ok")
# Safety gate: the ROM bootloader auto-baud can come back garbled after a
# software jump. Prove the link is solid (several clean GETs) BEFORE erasing,
# so a flaky link aborts without wiping a working firmware.
good = 0
for _ in range(8):
try:
d = bl.get()
if len(d) >= 2 and d[1:].count(0x44) and d[1:].count(0x31):
good += 1
except Exception:
pass
time.sleep(0.02)
if good < 8:
print("link not reliable (%d/8 clean) - aborting BEFORE erase." % good)
print("use the BOOT0 wire + a power-cycle for a clean ROM-bootloader link.")
return 2
print("link solid (%d/8)." % good)
# Erase. On an unlocked chip a mass-erase is enough; if it's still locked
# (factory RDP1) the erase NACKs, so fall back to readout-unprotect.
try:
bl.mass_erase()
print("mass-erased.")
except RuntimeError:
print("locked -> readout-unprotect (ERASES factory firmware)...")
bl.unprotect()
print("unlocked and erased.")
print("writing...")
for off in range(0, len(data), 256):
chunk = data[off:off + 256]
bl.write(FLASH + off, chunk)
print("verifying...")
bad = 0
for off in range(0, len(data), 256):
chunk = data[off:off + 256]
rb = bl.read(FLASH + off, len(chunk))
if rb != chunk:
bad += 1
print(" mismatch at +0x%X" % off)
if bad:
print("VERIFY FAILED (%d blocks)" % bad); return 1
print("verify OK. starting firmware...")
bl.go(FLASH)
return 0
if __name__ == "__main__":
sys.exit(main())