434 lines
17 KiB
Python
Executable File
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)
|