Files

434 lines
17 KiB
Python
Executable File

#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Otisk XIAO desek na USB: co na které z nich BĚŽÍ, a jestli se to změnilo.
tools/board_probe.py --all
tools/board_probe.py --all --compare <soubor s predchozim otiskem>
tools/board_probe.py --all --compare <soubor> --expect-changed <serial>
Vzniklo 1. 9. 2026 poté, co `pio run -t upload --upload-port <x4>` ohlásil
FAILED a obraz přistál na **x2**, desce, která na té příkazové řádce nebyla.
Poznat to šlo až po hodině: x2 přestal odpovídat konzoli i companion protokolu
a vypadal jako zaseklý, přitom na něm normálně běžel KISS modem, který ani
jedno z toho nemá. Tři replugy nepomohly a pomoct nemohly.
Otisk je proto přes VŠECHNY protokoly, které na těch deskách jezdí, ne jen přes
ten, který zrovna čekáme:
text MeshCore repeater/analyzer `ver` -> v1.17.1-tth...
companion MeshCore companion_radio CMD_DEVICE_QUERY (bez textové konzole)
kiss examples/kiss_modem SetHardware GetVersion (0x11 -> 0x91)
modem openhop_modem port `XIAO-Wio-SX1262`, mlčí na vše
bootloader UF2 port bez "Studio" / se "Sense"
`modem` a `bootloader` se poznají podle JMÉNA portu, ne podle idProduct: obojí
drží 0044 a AGENTS.md čte 0044 jako bootloader, což pro openhop_modem neplatí.
"""
import argparse
import glob
import multiprocessing
import os
import re
import struct
import sys
import time
try:
import serial
except ImportError:
sys.exit("chybi pyserial")
# Kolik sekund nejvys smi trvat otisk CELE sbernice.
# Musi pokryt PLNY cyklus jedne desky: settle 0,9 + text 1,2 + companion 1,5 +
# KISS 1,2 + GetDeviceName 1,2 = ~6 s (zmereno 2. 9. 2026 na x4: 6,4 s, tri behy
# za sebou stejne). S kratsim deadlinem se posledni protokol nestihne a deska se
# oznaci jako "visi", i kdyz normalne odpovida -- presne to se stalo KISS modemu
# na x4 pri BOARD_PROBE_DEADLINE=6.
PROBE_DEADLINE = float(os.environ.get("BOARD_PROBE_DEADLINE", "12"))
def usb_boards():
"""[(serial, port, board, state_hint)] pro kazdou desku flotily na USB.
Typ desky i rezim se poznaji z JMENA portu, protoze idProduct lze -- 0044
drzi jak UF2 bootloader XIAO, tak openhop_modem, coz je aplikace. A na
T1000-E je to jmeno primo obracene, nez by clovek cekal:
Seeed_Studio_XIAO_nRF52840_<sn> XIAO, aplikace (MeshCore build)
Seeed_XIAO_nRF52840_Sense_<sn> XIAO, bootloader
Seeed_XIAO-Wio-SX1262_<sn> XIAO, openhop_modem (APLIKACE, ne boot)
Seeed_Studio_T1000-E-BOOT_<sn> T1000-E, APLIKACE <- "-BOOT" ma aplikace!
Seeed_Studio_T1000-E_<sn> T1000-E, bootloader (+ UF2 disk T1000-E)
"""
pats = [
# (regex na jmeno portu, deska, stav)
(r"Seeed_Studio_T1000-E-BOOT_", "t1000e", "app"),
(r"Seeed_Studio_T1000-E_", "t1000e", "boot"),
(r"Seeed_XIAO-Wio-SX1262_", "xiao", "modem"),
(r"Seeed_Studio_XIAO_nRF52840_", "xiao", "app"),
(r"Seeed_XIAO_nRF52840", "xiao", "boot"),
(r"Wio|TRACKER", "wio-l1", "app"),
]
out = []
for port in sorted(glob.glob("/dev/serial/by-id/*")):
name = os.path.basename(port)
m = re.search(r"_([0-9A-F]{16})-if00", name)
if not m:
continue # ESP32 a spol. -- neni to nase nRF52 flotila
for rx, board, state in pats:
if re.search(rx, name):
out.append((m.group(1), port, board, state))
break
return out
def port_busy(dev):
"""Drzi ten port jiny proces? Vrati jeho pid, nebo None.
Sahat na port, ktery uz nekdo ma otevreny, neni jen zbytecne -- je to
SKODLIVE. 2. 9. 2026 tenhle probe otevrel port, na kterem openHop drzel KISS
spojeni; demon zahlasil "multiple access on port", oznacil link za degradovany
a nakonec si RADIO VYPNUL (`Radio is disabled`) a nesl si to v repeater.db,
takze to neresil ani restart kontejneru. Kontrola stavu nesmi rozbit to, co
kontroluje.
Ctou se /proc/*/fd, takze to nepotrebuje root ani lsof; cizi procesy pod jinym
UID neuvidime, ale docker tady bezi pod nasim (--user $(id -u)), takze ten ano.
"""
try:
real = os.path.realpath(dev)
except OSError:
return None
me = os.getpid()
for pid in os.listdir("/proc"):
if not pid.isdigit() or int(pid) == me:
continue
d = f"/proc/{pid}/fd"
try:
entries = os.listdir(d)
except OSError:
continue
for fd in entries:
try:
if os.path.realpath(f"{d}/{fd}") == real:
return pid
except OSError:
continue
return None
def _open(port):
s = serial.Serial(port, 115200, timeout=0)
s.dtr = True
s.rts = True
time.sleep(0.9)
s.reset_input_buffer()
return s
def _drain(s, w):
buf, t = b"", time.time()
while time.time() - t < w:
try:
d = s.read(8192)
except Exception:
# "device reports readiness to read but returned no data" -- deska
# se odpojila uprostred cteni. Vracime, co uz mame; neni to duvod
# shodit cely otisk.
break
if d:
buf += d
else:
time.sleep(0.02)
return buf
def _kiss_frame(raw, resp_code):
"""Vrat KISS ramec zacinajici 0xC0, jehoz treti bajt je `resp_code`.
Bez tohohle se raw[1]/raw[2] cetly z offsetu 0, tedy z toho, co v bufferu
zbylo po predchozim protokolu -- a odpoved se dala minout i kdyz prisla.
"""
i = -1
while True:
i = raw.find(bytes([0xC0]), i + 1)
if i < 0:
return raw
fr = raw[i:]
if len(fr) > 4 and fr[1] == 0x06 and fr[2] == resp_code:
return fr
def probe(port):
"""('text'|'companion'|'kiss'|'nic', verze) -- zkusí protokoly po řadě."""
try:
s = _open(port)
except Exception as e:
return ("nedostupny", type(e).__name__)
try:
# Prvni prikaz po otevreni portu se casto ztrati, proto to prazdne CRLF.
s.write(b"\r\n")
time.sleep(0.4)
s.reset_input_buffer()
s.write(b"ver\r\n")
txt = _drain(s, 1.2).decode(errors="replace")
m = re.search(r"(v\d+\.\d+\.\d+-tth[0-9a-f]+\+?)", txt)
if m:
return ("text", m.group(1))
s.reset_input_buffer()
s.write(b"<" + struct.pack("<H", 2) + bytes([22, 10])) # CMD_DEVICE_QUERY
s.flush()
raw = _drain(s, 1.5)
# Rámec se hleda podle CELE hlavicky, ne podle prvniho '>' v bufferu.
# Driv stacilo, aby za '>' byly dva bajty a neprazdny zbytek, a vratilo se
# ("companion", "?") -- takze opozdena radka textove konzole nebo
# MESH_DEBUG_PRINTLN se ctla jako companion ramec. flash_node.sh pak
# porovnal "?" s ocekavanou verzi a oznamil "FLASH SE NEAPLIKOVAL" na
# desce, na ktere bezel spravny firmware -- presne ta trida falesne
# diagnozy, kvuli ktere tenhle nastroj vznikl.
#
# Prohledavaji se VSECHNY vyskyty '>' a uzna se jen plnohodnotny
# RESP_DEVICE_INFO (kod 13, aspon 80 B, delka souhlasi s tim, co dorazilo).
i = -1
while True:
i = raw.find(b">", i + 1)
if i < 0:
break
if len(raw) < i + 3:
continue
ln = struct.unpack("<H", raw[i + 1:i + 3])[0]
fr = raw[i + 3:i + 3 + ln]
if len(fr) == ln and ln >= 80 and fr[0] == 13: # RESP_DEVICE_INFO
return ("companion", fr[60:80].split(b"\0")[0].decode(errors="replace"))
s.reset_input_buffer()
s.write(bytes([0xC0, 0x06, 0x11, 0xC0])) # KISS GetVersion
raw = _drain(s, 1.2)
# Kotvit na ZACATEK KISS ramce (0xC0), ne na offset 0: pred odpovedi muze
# lezet zbytek predchoziho vystupu a raw[1]/raw[2] by pak cetly cizi bajty.
raw = _kiss_frame(raw, 0x91)
if len(raw) > 4 and raw[1] == 0x06 and raw[2] == 0x91:
# GetVersion (0x11) vrací verzi KISS PROTOKOLU, ne našeho buildu --
# ta je k nerozeznání mezi dvěma různými firmwary. Stampovaná verze
# jede v GetDeviceName (0x16), viz KissModem::handleGetDeviceName.
s.reset_input_buffer()
s.write(bytes([0xC0, 0x06, 0x16, 0xC0])) # KISS GetDeviceName
nm = _kiss_frame(_drain(s, 1.2), 0x96)
if len(nm) > 4 and nm[1] == 0x06 and nm[2] == 0x96:
txt = nm[3:-1].decode(errors="replace")
m = re.search(r"(v\d+\.\d+\.\d+-tth[0-9a-f]+\+?)", txt)
if m:
return ("kiss", m.group(1))
return ("kiss", txt.strip() or "?")
# Starší KISS build bez stampované verze v GetDeviceName.
return ("kiss", "proto" + ".".join(str(b) for b in raw[3:-1]))
return ("nic", "-")
finally:
try:
s.close()
except Exception:
pass
def _probe_one(sn, port, board, state):
"""Otisk jedne desky. Bezi ve VLASTNIM PROCESU (viz fingerprint)."""
if state in ("boot", "modem"):
# Bootloader nemluvi nasim protokolem a openhop_modem nemluvi vubec;
# ptat se jich je jen ztrata casu (a u boot i riziko, ze to vypada
# jako zaseknuta deska).
return (sn, f"{board}/{state}", "-")
busy = port_busy(port)
if busy:
return (sn, f"{board}/obsazeny", f"drzi pid {busy} -- nesaham")
kind, ver = probe(port)
return (sn, f"{board}/{kind}", ver)
def _worker(i, sn, port, board, state, q):
try:
q.put((i,) + _probe_one(sn, port, board, state))
except Exception as e: # nikdy nenech potomka umrit potichu
q.put((i, sn, f"{board}/chyba", type(e).__name__))
def fingerprint():
"""Otisk cele sbernice. Paralelne -- porty jsou nezavisle a serazovat je za
sebe se necetlo: pet desek po ~9 s (settle + tri protokoly, u mlcicich desek
plny timeout) delalo pres dve minuty, coz je na kontrolu spoustenou PRED a PO
kazdym flashem moc. Poradi vysledku je dane vstupem, ne dobehem.
KAZDA DESKA VE VLASTNIM PROCESU, ne ve vlakne. Puvodni verze mela daemon
vlakna a tvrdy deadline, jenze `serial.Serial()` umi na nereagujici desce
viset v open(2) UVNITR C kodu, ktery NEPOUSTI GIL -- takze jedna zaseklá
deska zmrazila i vsechny ostatni probe vlakna a ta pak deadline nestihla.
Projev: 2. 9. 2026 hlasil x4 (zdravy KISS modem, sam o sobe 6,4 s)
"visi neodpovida v case" pri deadline 12 s, zatimco cely beh trval 42 s.
Diagnoza "deska neodpovida" na desce, ktera odpovida, je horsi nez zadna.
Proces se da terminate() i uprostred blokujiciho open(2), takze deadline
plati doopravdy a zbytek flotily se otiskne v normalnim case.
"visi" u T1000-E NENI diagnoza desky. Obe karty (B3F160.., B612AE..) visi
v serial.Serial() open(2) i pres 60 s, kazda samostatne ve vlastnim procesu
(zmereno 2. 9. 2026) -- pyserial se z nich otisk proste nedozvi a zvysovani
deadlinu s tim nic neudela. Deska pritom muze byt uplne v poradku; na
T1000-E se pta textova konzole primo, ne tenhle nastroj."""
boards = usb_boards()
rows = [None] * len(boards)
if not boards:
return []
ctx = multiprocessing.get_context("fork") # fork: potomek zdedi uz nactene moduly
q = ctx.Queue()
procs = []
for i, (sn, port, b, st) in enumerate(boards):
p = ctx.Process(target=_worker, args=(i, sn, port, b, st, q), daemon=True)
p.start()
procs.append(p)
deadline = time.time() + PROBE_DEADLINE
got = 0
while got < len(boards) and time.time() < deadline:
try:
i, sn, kind, ver = q.get(timeout=max(0.05, deadline - time.time()))
except Exception:
break
rows[i] = (sn, kind, ver)
got += 1
for p in procs:
if p.is_alive():
p.terminate() # utne i blokujici open(2)
for p in procs:
p.join(timeout=1.0)
# SIGKILL na to, co terminate() neslozilo. main() konci `os._exit`, ktery
# obchazi atexit handler multiprocessingu -- prezivsi potomek by tedy zustal
# bezet A DRZET SERIOVY PORT, takze dalsi beh (flash_node.sh pousti probe
# tretkrat za flash) by tu desku ohlasil jako `obsazeny drzi pid <n>`:
# nastroj obvinujici vlastni pozustatky.
for p in procs:
if p.is_alive():
p.kill()
for p in procs:
p.join(timeout=0.5)
for i, (sn, _, board, _) in enumerate(boards):
if rows[i] is None:
rows[i] = (sn, f"{board}/visi", "neodpovida v case")
return [r for r in rows if r]
def _parse_pairs(path):
"""[(serial, (kind, verze))] z otisku. Verze muze obsahovat mezery (starsi
KISS build vraci "Seeed Xiao-nrf52"), takze split(None, 2) -- split() na tri
pole by zbytek utnul a porovnani by hlasilo ZMENU tam, kde se nic nezmenilo.
Radek s PRAZDNOU verzi se NEZAHAZUJE. Driv to filtroval `len(p) >= 3`, takze
deska, u ktere probe verzi nevyplnil, z predchoziho otisku zmizela a pak se
ohlasila jako "ZMIZELA z USB" -- falesny poplach o desce, ktera tam celou dobu
byla.
"""
out = []
for line in open(path):
if not line.strip():
continue
p = line.split(None, 2)
if len(p) < 2:
continue
out.append((p[0], (p[1], p[2].strip() if len(p) > 2 else "")))
return out
def _parse(path):
return [(sn, k, v) for sn, (k, v) in _parse_pairs(path)]
def fmt(rows):
return "\n".join(f"{sn} {kind} {str(ver).strip()}" for sn, kind, ver in rows)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--all", action="store_true")
ap.add_argument("--compare", help="soubor s predchozim otiskem")
ap.add_argument("--now", help="soubor s AKTUALNIM otiskem (jinak se sbernice"
" otiskne znovu)")
ap.add_argument("--expect-changed", help="seriak, ktery se zmenit MA")
a = ap.parse_args()
# --now existuje proto, aby volajici, ktery uz otisk ma, nemusel platit dalsi
# probe (az PROBE_DEADLINE) -- a hlavne aby verdikt o zmenach a jeho vlastni
# kontrola verze vychazely z TEHOZ vzorku sbernice, ne ze dvou ruznych.
rows = _parse(a.now) if a.now else fingerprint()
now = {sn: (k, v) for sn, k, v in rows}
if not a.compare:
print(fmt(rows))
return 0
prev = dict(_parse_pairs(a.compare))
bad = False
for sn in sorted(set(prev) | set(now)):
was, is_ = prev.get(sn), now.get(sn)
tag = ""
if was != is_:
# Poradi je zamerne: deska, ktera ZMIZELA, neni uspech ani kdyz je to
# cil. Po flashi se to na tehle lavici stava bezne a hlaska "zmeneno
# (cil)" by to zakryla -- pritom se z desky nedá precist, co na ni je,
# takze flash NENI overeny. Chce to replug a spustit znovu.
if is_ is None:
tag = " <- ZMIZELA z USB (po flashi bezne) -- replug a spust znovu"
bad = True
elif was is None:
tag = " <- NOVA deska na sbernici"
elif (a.expect_changed
and sn.endswith(a.expect_changed.upper())
and len([x for x in set(prev) | set(now)
if x.endswith(a.expect_changed.upper())]) == 1):
tag = " <- zmeneno (cil)"
else:
tag = " <- !!! ZMENENO, PRESTOZE TO NEBYL CIL !!!"
bad = True
print(f" {sn} {was[0] if was else '-':10s} {was[1] if was else '-':22s}"
f" -> {is_[0] if is_ else '-':10s} {is_[1] if is_ else '-':22s}{tag}")
if a.expect_changed:
want = a.expect_changed.upper()
hits = [x for x in sorted(set(prev) | set(now)) if x.endswith(want)]
if len(hits) > 1:
# Kratky suffix umi sednout na vic seriaku; driv se vzal jeden podle
# poradi ve slovniku, takze "zmeneno (cil)" mohlo omluvit ZMENU NA JINE
# DESCE.
print(f"\n{a.expect_changed} sedi na {len(hits)} desky ({', '.join(hits)})"
f" -- upresni seriove cislo, jinak nejde rict, ktera se zmenit mela.")
bad = True
elif not hits:
# Driv: cil chybel v obou otiscich -> smycka ho nikdy nenavstivila,
# `bad` zustalo False a beh skoncil "ok, zmenil se jen cil". Otisk,
# ve kterem cil nikdy nikdo nevidel, neni uspech.
print(f"\nCIL {a.expect_changed} NENI V ZADNEM z otisku -- neni z ceho"
f" rict, ze se zmenil. Sedi to seriove cislo?")
bad = True
elif prev.get(hits[0]) == now.get(hits[0]):
print(f"\nCIL {a.expect_changed} SE NEZMENIL -- flash se neaplikoval,"
f" i kdyby nastroj hlasil uspech.")
bad = True
print("\nVERDIKT:", "PROBLEM (viz vys)" if bad else "ok, zmenil se jen cil")
return 1 if bad else 0
if __name__ == "__main__":
rc = main()
# os._exit misto sys.exit: vlakno, ktere visi v serial.Serial() open(2),
# drzi otevreny file descriptor a interpret na nej pri uklidu ceka -- otisk
# se vypsal za par sekund, ale proces dobihal jeste ~30 s (a pod `timeout`
# se tvaril jako zaseknuty). Vysledek uz je venku, uklizet nemame co.
sys.stdout.flush()
sys.stderr.flush()
os._exit(rc)