#!/usr/bin/env python3 # SPDX-License-Identifier: MIT """Legacy Nordic DFU (SDK ~11, dfu_version 0.5) over BLE pro Adafruit nRF52 bootloader. Generický BlueZ adaptér přes bleak (bez Nordic donglu). Fáze 1: připoj běžící APP, enable notify na 1531, zapiš 0x01 (buttonless) → reboot do bootloaderu. Fáze 2: reconnect na bootloader (advertuje 1530 DFU svc), proveď START/INIT/IMAGE(PRN)/VALIDATE/ACTIVATE. BLE DFU je flaky (dropnutá receipt notif → přenos spadne). Fáze 2 se proto auto-retryuje: po pádu pošle RESET (bootloader → čistý IDLE) a zkusí znovu. Použití: ble_dfu.py [phase1|phase2] phase1 JEN buttonless reboot do bootloaderu, pak skončí (flash si dodělá volající — po USB je to ~20 s místo minut po BLE) phase2 přeskočí fázi 1 (buttonless) — použij když uzel UŽ visí v bootloaderu (advertuje SCAP_DFU), např. po přerušeném DFU. Zotavení bez power-cycle. """ import asyncio import os import re import struct import sys import zipfile from bleak import BleakClient, BleakScanner DFU_SVC = "00001530-1212-efde-1523-785feabcd123" CP_UUID = "00001531-1212-efde-1523-785feabcd123" # control point (write+notify) PKT_UUID = "00001532-1212-efde-1523-785feabcd123" # packet (write-no-resp) # opcody START_DFU, INIT_DFU, RECEIVE_FW, VALIDATE, ACTIVATE_RESET, RESET, REPORT, PKT_RCPT_REQ = 1,2,3,4,5,6,7,8 RESP, PKT_RCPT = 0x10, 0x11 class Notif: def __init__(self): self.q = asyncio.Queue() def cb(self, _h, data): self.q.put_nowait(bytes(data)) async def wait(self, timeout=30): return await asyncio.wait_for(self.q.get(), timeout) def log(*a): print(*a, flush=True) async def expect_resp(nf, opcode, timeout=30): while True: d = await nf.wait(timeout) if d and d[0] == RESP and d[1] == opcode: if d[2] != 1: raise RuntimeError(f"DFU resp opcode {opcode} status {d[2]} (fail)") return d if d and d[0] == PKT_RCPT: continue # receipt, ignoruj tady log(" (neočekávaná notif:", d.hex(), ")") def mac_plus_one(mac): p = mac.upper().split(":") p[-1] = "%02X" % ((int(p[-1], 16) + 1) & 0xFF) return ":".join(p) async def find(mac, want_dfu=False, timeout=30): """Najdi zařízení. POZOR: běžící APP inzeruje DFU službu taky (kvůli buttonless), takže 'want_dfu' NESMÍ matchovat jen podle DFU svc -> spletl by si app s bootloaderem. Bootloader advertuje SCAP_DFU na MAC+1 (SenseCap na stožáru) NEBO AdaDFU na TÉŽE MAC (XIAO, novější SenseCap Solar). ADRESA JE POVINNÁ. Dřív stačil název obsahující "DFU" bez ohledu na adresu a bralo se prostě první zařízení ze skenu -- s víc deskami v bootloaderu najednou to sáhne na cizí. Stalo se: cíl CE:72:…:02, připojilo se FE:11:…:C4. Zachytilo se to jen proto, že se log četl ručně; o pár sekund později by START_DFU přepsal jinou desku.""" boot_mac = mac_plus_one(mac) log(f" scan (want_dfu={want_dfu}, mac={mac}, boot={boot_mac})...") devs = await BleakScanner.discover(timeout=timeout, return_adv=True) cand, rejected = [], [] for d, adv in devs.values(): addr = d.address.upper() has_dfu = DFU_SVC in [u.lower() for u in (adv.service_uuids or [])] name = (d.name or adv.local_name or "") if want_dfu: if not has_dfu: continue looks_like_dfu = "DFU" in name.upper() right_addr = addr in (boot_mac, mac.upper()) if looks_like_dfu and right_addr: cand.append((d, adv, 0)) elif looks_like_dfu: rejected.append(f"{addr} {name!r}") elif addr == mac.upper(): cand.append((d, adv, 1)) cand.sort(key=lambda x: x[2]) for d, adv, _ in cand: log(f" kandidát: {d.address} {d.name!r} dfu={DFU_SVC in [u.lower() for u in (adv.service_uuids or [])]}") if rejected: log(f" (v bootloaderu i CIZÍ desky, ignoruji: {', '.join(rejected)})") return cand[0][0] if cand else None async def connect_app(mac, tries=5): """Scan + connect s opakováním, jako to dělá ble_cli.py. Jediný pokus NESTAČÍ a stálo to 22. 8. 2026 hodinu na second-mast: BLE konzole (`ble_cli.py ver`) na tomtéž uzlu a z téhož hostu prošla bez zaváhání, kdežto DFU umřelo na `TimeoutError` z `local_disconnect_monitor_event.wait()`. Rozdíl NEBYL v uzlu, v bondu ani ve vzdálenosti (−64 dBm) — jen v tom, že ble_cli connect opakuje a tady se zkoušel jednou. Vypadá to jako mrtvá deska, a není. """ last = None for attempt in range(tries): try: dev = await BleakScanner.find_device_by_address(mac, timeout=25) if dev is None: # připojený peripheral přestane advertovat -- obvyklý důvod je # viset spojení na adaptéru raise RuntimeError("APP nenalezen ve scanu (už připojený?)") c = BleakClient(dev, timeout=30) await c.connect() return c except Exception as e: # noqa: BLE001 last = e log(f" [connect {attempt + 1}/{tries}] {type(e).__name__}: {str(e)[:60]}") await asyncio.sleep(4) raise RuntimeError(f"APP nenalezen ve scanu / connect selhal: {last}") async def phase1_buttonless(mac): log("== FÁZE 1: buttonless reboot do bootloaderu ==") c = await connect_app(mac) try: log(" připojen k APP, is_connected:", c.is_connected) svcs = [s.uuid.lower() for s in c.services] if DFU_SVC not in svcs: raise RuntimeError("APP nemá DFU službu 1530") nf = Notif() await c.start_notify(CP_UUID, nf.cb) # write-authorize vyžaduje notify enabled try: await c.write_gatt_char(CP_UUID, bytes([START_DFU]), response=True) except Exception as e: log(" (write 0x01 → disconnect, očekávané):", type(e).__name__) finally: # write 0x01 uzel odpojí sám, takže disconnect() tu obvykle jen uklízí try: await c.disconnect() except Exception: # noqa: BLE001 pass log(" APP odpojen, čekám na reboot bootloaderu...") await asyncio.sleep(4) class ImageDone(Exception): """Bootloader potvrdil celý image dřív, než smyčka došla na PRN práh.""" class ChunkTooBig(Exception): """Bootloader neodpověděl na první receipt -> nezvládá velké pakety.""" async def send_image(c, nf, pkt_char, data, prn=8, chunk=None): if chunk is None: mtu = getattr(c, "mtu_size", 23) or 23 chunk = max(20, mtu - 3) log(f" posílám image {len(data)} B, chunk {chunk} B, PRN {prn}") sent = 0 since_rcpt = 0 total = len(data) for off in range(0, total, chunk): piece = data[off:off+chunk] await c.write_gatt_char(pkt_char, piece, response=False) sent += len(piece) since_rcpt += 1 if prn and since_rcpt >= prn: since_rcpt = 0 # počkej na receipt [0x11, <4B received>] while True: try: d = await nf.wait(60) except asyncio.TimeoutError: # Ticho po PRVNÍ skupině = bootloader ty pakety vůbec # nepobral. Není to congestion, ale velikost: legacy DFU # (SDK 11) na některých bootloaderech bere jen 20 B, a když # BlueZ vyjedná MTU 247, posíláme 244 B a přenos umře pod # 48 kB. Pozorováno: XIAO nRF52840 (AdaDFU, MTU 247) padá, # SenseCap Solar (AdaDFU, MTU zůstane 23) i mast-three # (SCAP_DFU na MAC+1, MTU 247) jedou. Volající to zkusí # znovu s 20 B. if sent <= prn * chunk and chunk > 20: raise ChunkTooBig() raise if d and d[0] == PKT_RCPT: got = struct.unpack(" 3 else "" skip_phase1 = mode == "phase2" # `phase1` = jen prepni uzel do bootloaderu a skonci. Ma to smysl u desky, # ktera je zaroven na USB: BLE OTA trva jednotky az patnact minut podle MTU, # kdezto po USB je to ~20 s. BLE se tedy pouzije jen na to, na co USB nestaci # -- companion build nema textovou konzoli, takze `dfu` prikazem ho tam # neposles. Tuhle kombinaci pouziva tools/flash_node.sh. if mode == "phase1": await phase1_buttonless(mac) log("== uzel je v bootloaderu; flash dokonci volajici (napr. po USB) ==") return z = zipfile.ZipFile(zippath) fw_bin = z.read("firmware.bin") fw_dat = z.read("firmware.dat") log(f"firmware.bin {len(fw_bin)} B, firmware.dat {len(fw_dat)} B, cíl {mac}") # STALENESS GUARD. `pio run` builds firmware.zip, `pio run -t create_uf2` # builds firmware.uf2, and NEITHER refreshes the other. Flashing one board # from the .zip and another from the .uf2 then silently gives them different # firmware -- that is how x3 ended up 50 min behind the rest of the fleet, # missing a command the others had. firmware.elf is relinked by every build, # so it is the reference. elf = os.path.join(os.path.dirname(os.path.abspath(zippath)), "firmware.elf") if os.path.exists(elf) and os.path.getmtime(elf) > os.path.getmtime(zippath): sys.exit(f"CHYBA: {os.path.basename(zippath)} je STARŠÍ než firmware.elf — " f"nalil bys starý obraz.\n" f" Sprav: pio run -e && pio run -e -t create_uf2") # Put the version on the record BEFORE it lands on the board, not after. m = re.search(rb"v[0-9]+\.[0-9]+\.[0-9]+-tth[0-9a-f]+\+?", fw_bin) if m: log(f" verze v obrazu: {m.group(0).decode()}") if skip_phase1: log("== FÁZE 1 přeskočena (uzel už v bootloaderu) ==") else: await phase1_buttonless(mac) # BLE DFU je flaky — přenos občas spadne uprostřed (dropnutá receipt notif). # Auto-retry: po pádu vyresetuj bootloader do IDLE a zkus phase2 znovu. ATTEMPTS = 6 chunk = None # None = mtu-3; prepne se na 20 po ChunkTooBig for i in range(ATTEMPTS): try: await phase2_dfu(mac, fw_bin, fw_dat, chunk=chunk) return # hotovo except ChunkTooBig: # Tenhle bootloader nebere mtu-3 velke pakety. Nejde to zachranit # v behu -- START_DFU podruhe vrati status 2 (INVALID_STATE) -- # takze RESET, nove spojeni a znovu, natvrdo po 20 B. log("!! bootloader nezvlada velke pakety -> opakuji s 20 B") chunk = 20 await recover_to_bootloader(mac) except Exception as e: log(f"!! DFU pokus {i+1}/{ATTEMPTS} selhal: {type(e).__name__}: {str(e)[:80]}") if i == ATTEMPTS - 1: raise await recover_to_bootloader(mac) if {"-h", "--help"} & set(sys.argv[1:]): print(__doc__.strip()) sys.exit(0) asyncio.run(main())