2026-11-14 23:14:16 +01:00
|
|
|
"""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
|
|
|
|
|
|
|
|
|
|
|
2026-11-14 23:21:18 +01:00
|
|
|
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)
|
|
|
|
|
|
|
|
|
|
|
2026-11-14 23:14:16 +01:00
|
|
|
class BL:
|
|
|
|
|
def __init__(self, port):
|
|
|
|
|
self.port = port
|
2026-11-14 23:21:18 +01:00
|
|
|
self.s = open_racing(port)
|
2026-11-14 23:14:16 +01:00
|
|
|
|
|
|
|
|
def reopen(self):
|
|
|
|
|
self.s.close(); time.sleep(0.3)
|
2026-11-14 23:21:18 +01:00
|
|
|
self.s = open_racing(self.port)
|
2026-11-14 23:14:16 +01:00
|
|
|
|
|
|
|
|
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")
|
|
|
|
|
|
2026-11-14 23:21:18 +01:00
|
|
|
# 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)
|
|
|
|
|
|
2026-11-14 23:14:16 +01:00
|
|
|
# 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())
|