Files
meshcore-repeater-observer/meshcore_repeater_observer.py
tthandClaude Opus 5.5 0da25dd15b
ci / test (push) Successful in 1m15s
meshcore-repeater-observer 0.1.0
Reads a MeshCore repeater's console over BLE or USB and publishes what it
hears: the `pktlog` raw-frame feed in the meshcoretomqtt format (community
analyzer with a JWT signed by the node's key, audience = broker hostname, or
an own broker without auth) and optionally stats, `nodes`, `rxlog` to a local
MQTT broker. Needs the observer build of meshcore-tth.

Tested on a XIAO with the observer build over USB and over BLE: feed in the
meshcoretomqtt format, packet hashes matching those of other observers.
Unit tests for the parsers, the packet transform, the Ed25519 signature
(checked against `cryptography`), the JWT and paho-mqtt 1.x/2.x; README
(Czech), AGENTS.md, CI, Renovate.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 00:20:03 +01:00

1394 lines
55 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""MeshCore repeater observer: reads a repeater's console over BLE or USB and
publishes what it hears to MQTT.
For a repeater running the observer build of the meshcore-tth fork (console
commands `pktlog`, `rxlog`, `nodes`): no second radio next to it is needed.
* `pktlog` raw frames -> observer feed in the meshcoretomqtt format: the
community analyzer (JWT signed with the node's own key) or your
own CoreScope broker (no auth)
* `rxlog`, `nodes`, `neighbors`, stats, `sensor read` -> local MQTT (optional)
Configuration: environment variables only (MC_*), see README.md.
MC_BLE_ADDR=AA:BB:CC:DD:EE:FF or MC_SERIAL_PORT=/dev/serial/by-id/...
MC_OBS_ENABLE=1 MC_OBS_IATA=PRG observer feed to mqtt1.meshcore.cz
MC_MQTT_HOST=localhost optional local MQTT copy + stats
BLE: pair once with the node's PIN (bluetoothctl pair/trust). USB is simpler
and keeps the node's BLE off.
"""
import sys
if {"-h", "--help"} & set(sys.argv[1:]):
print(__doc__.strip())
sys.exit(0)
import asyncio
import base64
import hashlib
import json
import logging
import os
import re
import time
from datetime import datetime, timezone
import paho.mqtt.client as mqtt
from bleak import BleakClient, BleakScanner
# Nordic UART Service (NUS) — stejné UUID jako Adafruit BLEUart v našem FW
NUS_SVC = "6e400001-b5a3-f393-e0a9-e50e24dcca9e"
NUS_RX = "6e400002-b5a3-f393-e0a9-e50e24dcca9e" # klient → zařízení (write)
NUS_TX = "6e400003-b5a3-f393-e0a9-e50e24dcca9e" # zařízení → klient (notify)
BLE_ADDR = os.environ.get("MC_BLE_ADDR", "")
BLE_NAME = os.environ.get("MC_BLE_NAME", "")
NODE = os.environ.get("MC_NODE", "repeater")
# Když je nastaven, jede se přes USB konzoli místo BLE. VŽDY /dev/serial/by-id/...
# podle sériového čísla — ttyACM* se po každém replugu přečísluje a mířil bys na
# jinou desku.
SERIAL_PORT = os.environ.get("MC_SERIAL_PORT", "")
INTERVAL = int(os.environ.get("MC_INTERVAL", "300")) # plný scrape (neighbors+stats+sensors)
NODES_INTERVAL = int(os.environ.get("MC_NODES_INTERVAL", "60")) # registr `nodes` (mění se pomalu)
RXLOG_INTERVAL = int(os.environ.get("MC_RXLOG_INTERVAL", "5")) # firehose `rxlog`+`pktlog` (drain přes cursor)
# Duty cycle: connect → drain → DISCONNECT → pauza. Starší FW s připojeným BLE
# klientem tiše zahazoval DIRECT pakety, které měl přeposlat (SoftDevice/LoRa
# koexistence, opraveno ve forku 21. 7. 2026 širším conn intervalem a TX retry).
# Pauza ale znamená, že se pktlog ring může mezitím přepsat (DROP v logu):
# na opraveném FW jde MC_BLE_OFF_INTERVAL zkrátit, nejlepší je USB.
OFF_INTERVAL = int(os.environ.get("MC_BLE_OFF_INTERVAL", "120")) # sekundy BEZ spojení mezi draity
# Lokální MQTT je volitelné: prázdný MC_MQTT_HOST = jen observer feed.
MQTT_HOST = os.environ.get("MC_MQTT_HOST", "")
MQTT_PORT = int(os.environ.get("MC_MQTT_PORT", "1883"))
# Mimo `meshcore/#`: tam poslouchá ingest CoreScope a tyhle dokumenty nejsou jeho formát.
MQTT_TOPIC = os.environ.get("MC_MQTT_TOPIC", f"repeater-observer/{NODE}")
MQTT_USER = os.environ.get("MC_MQTT_USER", "")
MQTT_PASS = os.environ.get("MC_MQTT_PASS", "")
MQTT_TLS = os.environ.get("MC_MQTT_TLS", "").lower() in ("1", "true", "yes")
CMD = os.environ.get("MC_CMD", "neighbors")
REPLY_WAIT = float(os.environ.get("MC_REPLY_WAIT", "12")) # tvrdý strop čtení odpovědi
FIRST_BYTE_WAIT = float(os.environ.get("MC_FIRST_BYTE_WAIT", "6")) # čekání na začátek odpovědi (BLE)
# --- Observer feed ----------------------------------------------------------
# Surové rámce z `pktlog` → broker ve formátu meshcoretomqtt
# (github.com/Cisien/meshcoretomqtt). Komunitní cluster: mqtt1.meshcore.cz,
# mqtt2.meshcore.website, mqtt.meshcore-analyzer.eu (WSS :443). Auth: JWT
# podepsaný Ed25519 klíčem uzlu, username `v1_<PUBKEY>`, AUDIENCE = HOSTNAME
# BROKERU (s audience analyzer.meshcore.cz broker odmítne: not authorised).
# Topicy `meshcore/<IATA>/<PUBKEY>/{packets,status}`. Vlastní CoreScope:
# MC_OBS_MQTT_HOST=<broker> MC_OBS_MQTT_PORT=1883 MC_OBS_TRANSPORT=tcp
# MC_OBS_TLS=0 MC_OBS_AUTH=none (klíč uzlu se pak vůbec nečte).
OBS_ENABLE = os.environ.get("MC_OBS_ENABLE", "").lower() in ("1", "true", "yes")
OBS_HOST = os.environ.get("MC_OBS_MQTT_HOST", "mqtt1.meshcore.cz")
OBS_PORT = int(os.environ.get("MC_OBS_MQTT_PORT", "443"))
OBS_TRANSPORT = os.environ.get("MC_OBS_TRANSPORT", "websockets") # websockets | tcp
OBS_TLS = os.environ.get("MC_OBS_TLS", "1").lower() in ("1", "true", "yes")
OBS_AUTH = os.environ.get("MC_OBS_AUTH", "token") # token (JWT) | none (vlastní broker)
OBS_AUDIENCE = os.environ.get("MC_OBS_AUDIENCE", "") or OBS_HOST
OBS_IATA = os.environ.get("MC_OBS_IATA", "") # povinné: letiště regionu, PRG/BRQ/OSR/…
OBS_OWNER = os.environ.get("MC_OBS_OWNER", "") # volitelné JWT claims
OBS_EMAIL = os.environ.get("MC_OBS_EMAIL", "")
OBS_MODEL = os.environ.get("MC_OBS_MODEL", "MeshCore repeater")
OBS_TOKEN_TTL = int(os.environ.get("MC_OBS_TOKEN_TTL", "3600"))
__version__ = "0.1.0"
OBS_CLIENT_VER = f"meshcore-repeater-observer {__version__}"
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("repeater-observer")
# --- Ed25519 podpis (čistý Python, orlp key layout) ---------------------------
# MeshCore FW používá orlp/ed25519: `get prv.key` vrací 64 B = (clamped scalar a
# ‖ sha512 prefix), NE 32B RFC-8032 seed — cryptography/pynacl s ním neumí.
# Podepisuje se 1× za hodinu (JWT refresh), takže pomalá čistá implementace
# bohatě stačí a venv nepotřebuje žádnou novou závislost. Matematika = RFC 8032
# (stejné rovnice jako orlp sign.c); ověřeno testem proti balíku cryptography.
_ED_Q = 2**255 - 19
_ED_L = 2**252 + 27742317777372353535851937790883648493
_ED_D = -121665 * pow(121666, _ED_Q - 2, _ED_Q) % _ED_Q
_ED_I = pow(2, (_ED_Q - 1) // 4, _ED_Q)
def _ed_recover_x(y):
xx = (y * y - 1) * pow(_ED_D * y * y + 1, _ED_Q - 2, _ED_Q) % _ED_Q
x = pow(xx, (_ED_Q + 3) // 8, _ED_Q)
if (x * x - xx) % _ED_Q:
x = x * _ED_I % _ED_Q
if x % 2:
x = _ED_Q - x
return x
_ED_BY = 4 * pow(5, _ED_Q - 2, _ED_Q) % _ED_Q
_ED_BX = _ed_recover_x(_ED_BY)
_ED_B = (_ED_BX, _ED_BY, 1, _ED_BX * _ED_BY % _ED_Q) # extended coordinates
def _ed_add(p, q):
x1, y1, z1, t1 = p
x2, y2, z2, t2 = q
a = (y1 - x1) * (y2 - x2) % _ED_Q
b = (y1 + x1) * (y2 + x2) % _ED_Q
c = 2 * t1 * t2 * _ED_D % _ED_Q
d = 2 * z1 * z2 % _ED_Q
e, f, g, h = b - a, d - c, d + c, b + a
return (e * f % _ED_Q, g * h % _ED_Q, f * g % _ED_Q, e * h % _ED_Q)
def _ed_mul(p, e):
q = (0, 1, 1, 0) # neutrální prvek
while e:
if e & 1:
q = _ed_add(q, p)
p = _ed_add(p, p)
e >>= 1
return q
def _ed_compress(p):
x, y, z, _ = p
zi = pow(z, _ED_Q - 2, _ED_Q)
x, y = x * zi % _ED_Q, y * zi % _ED_Q
return int.to_bytes(y | ((x & 1) << 255), 32, "little")
def ed25519_sign_orlp(msg: bytes, pub32: bytes, prv64: bytes) -> bytes:
a = int.from_bytes(prv64[:32], "little") # clamped scalar (z keygenu)
prefix = prv64[32:]
r = int.from_bytes(hashlib.sha512(prefix + msg).digest(), "little") % _ED_L
rb = _ed_compress(_ed_mul(_ED_B, r))
k = int.from_bytes(hashlib.sha512(rb + pub32 + msg).digest(), "little") % _ED_L
s = (r + k * a) % _ED_L
return rb + int.to_bytes(s, 32, "little")
def _b64url(data: bytes) -> str:
return base64.urlsafe_b64encode(data).rstrip(b"=").decode()
def make_auth_token(pub_hex: str, prv_hex: str) -> str:
"""JWT kompatibilní s meshcoretomqtt/auth_token.py: header {alg: Ed25519},
payload {publicKey, iat, exp, aud, [owner, email,] client}, podpis =
UPPERCASE HEX (ne base64url!) přes ASCII 'header.payload'."""
now = int(time.time())
payload = {"publicKey": pub_hex.upper(), "iat": now, "exp": now + OBS_TOKEN_TTL}
if OBS_AUDIENCE:
payload["aud"] = OBS_AUDIENCE
if OBS_TLS: # owner/email jen přes ověřené TLS (stejné pravidlo jako reference)
if OBS_OWNER:
payload["owner"] = OBS_OWNER
if OBS_EMAIL:
payload["email"] = OBS_EMAIL.lower()
payload["client"] = OBS_CLIENT_VER
head = _b64url(json.dumps({"alg": "Ed25519", "typ": "JWT"}, separators=(",", ":")).encode())
body = _b64url(json.dumps(payload, separators=(",", ":")).encode())
signing_input = f"{head}.{body}"
sig = ed25519_sign_orlp(signing_input.encode(), bytes.fromhex(pub_hex), bytes.fromhex(prv_hex))
return f"{signing_input}.{sig.hex().upper()}"
# --- MeshCore wire frame → meshcoretomqtt packet ------------------------------
PAYLOAD_TYPE_TRACE = 9
def parse_raw_frame(raw: bytes):
"""Wire frame: header | [4B transport codes] | path_len | path | payload.
Vrací (route, ptype, path_len_byte, payload), None na nesmyslnou délku."""
if len(raw) < 2:
return None
header = raw[0]
route = header & 0x03 # 0=trans-flood 1=flood 2=direct 3=trans-direct
ptype = (header >> 2) & 0x0F
i = 5 if route in (0, 3) else 1 # transport codes = 4 B navíc
if i >= len(raw):
return None
plb = raw[i]
i += 1 # bit-packed: (hash_size-1)<<6 | count
i += ((plb >> 6) + 1) * (plb & 63) # přeskoč path bajty
if i > len(raw):
return None
return route, ptype, plb, raw[i:]
def meshcore_packet_hash(ptype: int, path_len_byte: int, payload: bytes) -> str:
"""MeshCore SHA packet hash = SHA256(type ‖ [path_len u TRACE] ‖ payload)[:8]
(Packet::calculatePacketHash) — korelační klíč mezi observery na analyzeru."""
h = hashlib.sha256()
h.update(bytes([ptype]))
if ptype == PAYLOAD_TYPE_TRACE:
h.update(bytes([path_len_byte]))
h.update(payload)
return h.digest()[:8].hex().upper()
def obs_packet_json(rec):
"""pktlog záznam → meshcoretomqtt 'packets' JSON (viz bridge/message_parser.py
v Cisien/meshcoretomqtt — analyzer na tenhle tvar spoléhá). None = neparsovatelné."""
try:
raw = bytes.fromhex(rec["raw"])
except ValueError:
return None
parsed = parse_raw_frame(raw)
if not parsed:
return None
route, ptype, plb, payload = parsed
when = rec["when"]
# Záchytná síť pro záznamy zalogované DŘÍV, než observer hodiny srovnal (viz
# sync_clock): v ringu uzlu leží dál `when` z roku 2024 a přepsat je nejde.
# Rok 2025 jako podlaha, protože `VolatileRTCClock` startuje v květnu 2024.
if when < 1735689600:
when = int(time.time())
dt = datetime.fromtimestamp(when, tz=timezone.utc)
msg = {
"origin": OBS.name,
"origin_id": OBS.pub,
"timestamp": dt.isoformat(),
"type": "PACKET",
"direction": "rx",
"time": dt.strftime("%H:%M:%S"),
"date": f"{dt.day}/{dt.month}/{dt.year}",
"len": str(len(raw)),
"packet_type": str(ptype),
"route": "D" if route in (2, 3) else "F",
"payload_len": str(len(payload)),
"raw": rec["raw"].upper(),
"SNR": str(int(rec["snr"] / 4)), # FW loguje celé dB (trunc k nule jako C cast)
"RSSI": str(rec["rssi"]),
"score": None, # pktlog score nenese; reference ho má taky jen někdy
"duration": None,
"hash": meshcore_packet_hash(ptype, plb, payload),
}
# reference přidává "path" (= dest ← src hash bajty) jen u direct routed typů
if route in (2, 3) and ptype in (0, 1, 2, 8) and len(payload) >= 2:
msg["path"] = f"{payload[1]:02X} -> {payload[0]:02X}"
return msg
class Observer:
"""Druhý MQTT sink: komunitní broker (websockets+TLS, JWT auth). Identita
uzlu (jméno, pubkey, PRIVÁTNÍ KLÍČ) se čte z BLE konzole při init session;
klíč žije výhradně v RAM tohoto procesu. Token se obnovuje při každém
(re)connectu — broker spojení při expiraci tokenu utne a paho auto-reconnect
si přes on_disconnect řekne o čerstvý."""
def __init__(self):
self.name = self.pub = self._prv = None
self.fw_ver = self.radio = "unknown"
self.client = None
self.connected = False
self.published = 0
def topic(self, kind):
return f"meshcore/{OBS_IATA}/{self.pub}/{kind}"
def _status_json(self, status, stats=None):
msg = {
"status": status,
"timestamp": datetime.now(timezone.utc).isoformat(),
"origin": self.name,
"origin_id": self.pub,
"radio": self.radio,
"model": OBS_MODEL,
"firmware_version": self.fw_ver,
"client_version": OBS_CLIENT_VER,
}
if stats:
msg["stats"] = stats
return json.dumps(msg)
def _set_fresh_creds(self):
if OBS_AUTH != "token":
return # vlastní broker (např. CoreScope) jede bez autentizace
self.client.username_pw_set(f"v1_{self.pub}", make_auth_token(self.pub, self._prv))
def start(self, name, pub, prv, fw_ver, radio):
"""První BLE session: založ MQTT klienta. Další sessions jen osvěží jméno/verze."""
self.name, self.pub, self._prv = name, pub.upper(), prv
self.fw_ver, self.radio = fw_ver, radio
if self.client is not None:
return
c = mqtt_client(client_id=f"meshcore_{self.pub[:15]}", clean_session=True, transport=OBS_TRANSPORT)
if OBS_TRANSPORT == "websockets":
c.ws_set_options(path="/")
if OBS_TLS:
c.tls_set()
self.client = c
self._set_fresh_creds()
c.will_set(self.topic("status"), self._status_json("offline"), qos=0, retain=True)
def on_connect(cl, _ud, _fl, rc):
self.connected = rc == 0
if rc == 0:
log.info("observer: připojen k %s:%d (%s)", OBS_HOST, OBS_PORT, self.topic("packets"))
cl.publish(self.topic("status"), self._status_json("online"), qos=0, retain=False)
else:
log.error("observer: broker odmítl spojení rc=%d (expirovaný/vadný token?)", rc)
def on_disconnect(cl, _ud, rc):
self.connected = False
if rc != 0:
log.warning("observer: spojení ztraceno rc=%d — čerstvý token + reconnect", rc)
self._set_fresh_creds() # token mohl expirovat; před dalším CONNECTem obnov
c.on_connect = on_connect
c.on_disconnect = on_disconnect
c.reconnect_delay_set(min_delay=5, max_delay=120)
c.connect_async(OBS_HOST, OBS_PORT, keepalive=60)
c.loop_start()
def publish_packet(self, msg: dict) -> bool:
if not self.connected:
return False
self.client.publish(self.topic("packets"), json.dumps(msg), qos=0, retain=False)
self.published += 1
return True
def publish_status(self, stats=None):
if self.connected:
self.client.publish(self.topic("status"), self._status_json("online", stats), qos=0, retain=False)
OBS = Observer()
def mqtt_client(**kw):
"""paho 1.x i 2.x: od 2.0 je `callback_api_version` povinný. VERSION1 drží
signatury callbacků (on_connect s rc, on_disconnect bez reason properties),
se kterými tenhle kód počítá."""
api = getattr(mqtt, "CallbackAPIVersion", None)
if api is not None:
return mqtt.Client(api.VERSION1, **kw)
return mqtt.Client(**kw)
class NullMQTT:
"""Bez MC_MQTT_HOST: lokální kopie a stats se zahazují, feed jede dál."""
def publish(self, *_a, **_k):
return None
def make_mqtt():
if not MQTT_HOST:
return NullMQTT()
c = mqtt_client(client_id=f"repeater-observer-{NODE}", clean_session=True)
if MQTT_USER:
c.username_pw_set(MQTT_USER, MQTT_PASS)
if MQTT_TLS:
c.tls_set() # systémová CA; ověří i hostname
c.will_set(f"{MQTT_TOPIC}/status", "offline", qos=1, retain=True)
c.connect(MQTT_HOST, MQTT_PORT, keepalive=60)
c.loop_start()
c.publish(f"{MQTT_TOPIC}/status", "online", qos=1, retain=True)
return c
def parse_neighbours(text):
"""`hex:secs_ago:snr` řádky (nebo `-none-`) → seznam dictů."""
out = []
for raw in text.replace("\r", "\n").split("\n"):
line = raw.strip()
if not line or line == "-none-":
continue
if line.startswith("->"):
line = line[2:].strip()
parts = line.split(":")
if len(parts) != 3:
continue
pk, secs, snr = parts
if len(pk) < 4:
continue
try:
# konzolový `neighbors` vrací SNR jako int8_t × 4 (viz FW MyMesh.h) → děl 4 na dB
out.append({"pubkey_prefix": pk.lower(), "secs_ago": int(secs), "snr": round(float(snr) / 4.0, 2)})
except ValueError:
continue
return out
def _strip(line):
"""Zahoď konzolový prefix '-> ' a whitespace."""
line = line.strip()
if line.startswith("->"):
line = line[2:].strip()
return line
def parse_console_value(text):
"""CommonCLI `get ...` odpovídá '> hodnota'; `ver` odpovídá rovnou textem.
Vrať hodnotu za '>' pokud je, jinak první neprázdný řádek."""
first = None
for raw in text.replace("\r", "\n").split("\n"):
line = _strip(raw)
if not line:
continue
if line.startswith(">"):
return line[1:].strip()
if first is None:
first = line
return first
def parse_nodes(text):
"""`nodes` odpověď → (rows, next_offset, total).
Řádek uzlu: N,prefix,type,lat×1e6,lon×1e6,snr×4,rssi,age,pkt_hash,path,name
(pkt_hash = join key na rxlog kopie = všechny cesty advertu; path = reprezentativní,
direct 0-hop preferován; jméno = vše za 10. čárkou, může obsahovat čárky).
Trailer: E,next_offset,total.
"""
rows = []
nxt = total = None
for raw in text.replace("\r", "\n").split("\n"):
line = _strip(raw)
if not line:
continue
if line[0] == "N":
parts = line.split(",", 10) # 11 polí; parts[10] = name (zbytek, může mít čárky)
if len(parts) < 11:
continue
_, prefix, typ, lat, lon, snr, rssi, age, pkt_hash, path, name = parts
try:
ilat, ilon = int(lat), int(lon)
rows.append(
{
"prefix": prefix.lower(),
"type": int(typ),
"lat": ilat / 1e6 if ilat != 0 else None,
"lon": ilon / 1e6 if ilon != 0 else None,
"snr": round(int(snr) / 4.0, 2),
"rssi": int(rssi),
"age": int(age),
"pkt_hash": pkt_hash.lower(), # join key → rxlog kopie (všechny cesty advertu)
"path": path.lower(), # reprezentativní hop-hashe (direct 0-hop preferován)
"name": name,
}
)
except ValueError:
continue
elif line[0] == "E":
p = line.split(",")
if len(p) >= 3:
try:
nxt, total = int(p[1]), int(p[2])
except ValueError:
pass
return rows, nxt, total
def parse_rxlog(text):
"""`rxlog` odpověď → (records, last_seq, oldest_seq, newest_seq).
Řádek: R,seq,when,pkthash,hdr(hex),snr×4,rssi,path(hex).
Trailer: E,last_seq,oldest_seq,newest_seq.
"""
recs = []
last = oldest = newest = None
for raw in text.replace("\r", "\n").split("\n"):
line = _strip(raw)
if not line:
continue
if line[0] == "R":
p = line.split(",")
if len(p) < 8:
continue
try:
recs.append(
{
"seq": int(p[1]),
"when": int(p[2]),
"pkthash": p[3].lower(),
"hdr": int(p[4], 16), # syrový header byte
"snr": round(int(p[5]) / 4.0, 2),
"rssi": int(p[6]),
"path": p[7].lower(),
}
)
except ValueError:
continue
elif line[0] == "E":
p = line.split(",")
if len(p) >= 4:
try:
last, oldest, newest = int(p[1]), int(p[2]), int(p[3])
except ValueError:
pass
return recs, last, oldest, newest
def parse_pktlog(text):
"""`pktlog` odpověď → (records, last_seq, oldest_seq, newest_seq).
Řádek: P,seq,when,snr×4,rssi,raw(hex celého rámce).
Trailer: E,last_seq,oldest_seq,newest_seq (stejná sémantika jako rxlog).
"""
recs = []
last = oldest = newest = None
for raw in text.replace("\r", "\n").split("\n"):
line = _strip(raw)
if not line:
continue
if line[0] == "P":
p = line.split(",")
if len(p) < 6:
continue
try:
recs.append(
{
"seq": int(p[1]),
"when": int(p[2]),
"snr": int(p[3]), # ×4, transformace dělí až v obs_packet_json
"rssi": int(p[4]),
"raw": p[5],
}
)
except ValueError:
continue
elif line[0] == "E":
p = line.split(",")
if len(p) >= 4:
try:
last, oldest, newest = int(p[1]), int(p[2]), int(p[3])
except ValueError:
pass
return recs, last, oldest, newest
async def clear_stale_ble_connection():
"""BlueZ umí po výpadku uváznout s D-Bus stavem `Connected: yes`, i když spojení
je mrtvé — nový scan pak zařízení NIKDY nenajde (signatura přesně
"nenalezen ve scanu (mimo dosah?)", i na desce, co je fyzicky na místě a
zdravá). Incident 18. 8. 2026: observer takhle crash-loopoval 3h20m, než si
toho někdo všiml; ruční oprava byla `bluetoothctl disconnect <addr>`.
Bez BLE_ADDR (BLE_NAME režim) nemáme co disconnectnout — no-op. Bezpečné
volat i když spojení NENÍ zaseklé (disconnect na už odpojeném zařízení je
no-op na straně BlueZ), takže se volá na KAŽDÝ neúspěch cyklu, ne jen na
tenhle konkrétní."""
if not BLE_ADDR:
return
try:
proc = await asyncio.create_subprocess_exec(
"bluetoothctl",
"disconnect",
BLE_ADDR,
stdout=asyncio.subprocess.DEVNULL,
stderr=asyncio.subprocess.DEVNULL,
)
await asyncio.wait_for(proc.wait(), timeout=10)
except Exception as e:
log.warning("bluetoothctl disconnect (self-heal) selhal, pokracuju: %r", e)
async def find_device():
"""BlueZ potřebuje discovery PŘED connectem → vždy scan, vrať BLEDevice (ne adresu)."""
if BLE_ADDR:
d = await BleakScanner.find_device_by_address(BLE_ADDR, timeout=25)
else:
d = await BleakScanner.find_device_by_name(BLE_NAME, timeout=25)
if d is None:
raise RuntimeError(f"BLE {BLE_ADDR or BLE_NAME} nenalezen ve scanu (mimo dosah?)")
return d
def parse_json_reply(text):
"""Vytáhni JSON objekt z konzolové odpovědi (např. ' -> {...}'). {} když nic."""
m = re.search(r"\{.*\}", text, re.S)
if not m:
return {}
try:
return json.loads(m.group(0))
except Exception:
return {}
def parse_sensors(text):
"""`sensor read` → dict {name: value}. FW dekóduje živou CayenneLPP telemetrii na text
`temperature=23.4 humidity=46.1 voltage=4.02 …`. Tokenizuje na whitespace, bere key=value,
přeskočí '-> ' prefix i DEBUG (klíč s ':'). Num→float/int, nečíselné (gps) nech textem."""
out = {}
for tok in text.replace("\r", " ").replace("\n", " ").split():
if "=" not in tok:
continue
k, v = tok.split("=", 1)
k = k.strip()
v = v.strip()
if not k or ":" in k:
continue
try:
out[k] = int(v)
except ValueError:
try:
out[k] = round(float(v), 2)
except ValueError:
out[k] = v
return out
def parse_bot(text):
"""`bot` (kanálový bot v analyzer buildu) → countery do dictu. Na rozdíl od
STATS_CMDS nevrací JSON, ale prózu:
bot: chan 75, trigger '', cmds 'link,path,snr,heard,noise', ignore '(nikdo)',
cooldown 10000 ms/odesilatel + 2500 ms floor, replies 0, throttled 0,
ignored 0, last 0
Bereme JEN countery — konfigurace je build-time, takže by se na MQTT jen
opakovala. `cooldown … 10000 ms/odesilatel + 2500 ms floor` regexy nechytí,
protože číslo je tam PŘED klíčovým slovem.
Proč to tady vůbec je (7. 8. 2026): u „bot neodpověděl" se bez těchhle counterů
nedá odlišit „nesešel se trigger/cooldown" od „odpověď odešla a ztratila se po
cestě". Vlastní TX si uzel neloguje a v analyzeru je odpověď vidět jen tehdy,
když ji někdo zrepeatuje zpátky do slyšitelnosti observera — což u vzdáleného
tazatele nemusí nastat. Jediná jiná cesta ke counterům je sundat observer ze
sériové linky, čili díra ve feedu."""
if "DISABLED" in text:
return {"bot_enabled": 0}
out = {}
for k in ("replies", "throttled", "ignored", "last"):
m = re.search(rf"\b{k}\s+(\d+)", text)
if m:
out[f"bot_{k}"] = int(m.group(1))
if out:
out["bot_enabled"] = 1
return out
def parse_clock(text):
"""`clock` → (node_epoch, exact). None = neparsovatelné.
Dva formáty, protože `clock` ve FW epoch teprve dostává:
12:34 - 7/8/2026 UTC (upstream: JEN minuty)
12:34 - 7/8/2026 UTC (epoch 1786095587) (náš, přesný)
`exact` říká, který to byl — volající podle toho volí práh. U minutového
formátu totiž `sprintf("%02d:%02d")` sekundy ZAHODÍ, takže i u naprosto
správně nastaveného uzlu vyjde rozdíl proti hostiteli 0-59 s a práh musí
být nad 59 s, jinak by se čas nastavoval při každém scrape.
Den a měsíc jsou v FW `%d`, tedy BEZ vedoucí nuly (`7/8/2026`) — proto
regex a ne strptime s fixní šířkou."""
m = re.search(r"epoch\s+(\d+)", text)
if m:
return int(m.group(1)), True
m = re.search(r"\b(\d{1,2}):(\d{2})\s*-\s*(\d{1,2})/(\d{1,2})/(\d{4})", text)
if not m:
return None
hh, mm, day, mon, year = (int(g) for g in m.groups())
try:
dt = datetime(year, mon, day, hh, mm, tzinfo=timezone.utc)
except ValueError: # 31/2, hodina 25, … = rozsypaná odpověď
return None
return int(dt.timestamp()), False
# Nad kolik sekund rozdílu se čas přenastavuje. U minutového `clock` musí být
# práh nad 59 s (viz parse_clock); s epochem stačí pár sekund.
CLOCK_SKEW_COARSE = 120
CLOCK_SKEW_EXACT = 5
# konzolové příkazy repeateru vracející čistý JSON (dostupné lokálně = přes BLE)
STATS_CMDS = ("stats-packets", "stats-radio", "stats-core")
# příkazy, které běžící FW nezná (staré FW bez mesh-analyzeru) — přestaň je zkoušet
_unsupported: set[str] = set()
_unknown_hits: dict = {}
def fw_lacks(cmd, reply):
"""True, když `reply` je „Unknown command" už PODRUHÉ za sebou → `cmd` se
přestane zkoušet. Jeden výskyt nestačí: na slabém BLE linku může dorazit
pozdní odpověď na JINÝ příkaz (6. 10. 2026 si observer takhle zapsal, že FW
nezná `nodes`, a do restartu ho přestal číst). Platná odpověď počítadlo
nuluje."""
if "Unknown command" not in reply:
_unknown_hits.pop(cmd, None)
return False
_unknown_hits[cmd] = _unknown_hits.get(cmd, 0) + 1
if _unknown_hits[cmd] >= 2:
_unsupported.add(cmd)
return True
# rxlog/pktlog cursory přežívají reconnecty (module-global). Bez toho by se
# s BLE churnem resetovaly na 0 při KAŽDÉM spojení → re-čtení od začátku +
# falešný „drop". None = ještě nikdy nečteno (cold start).
RX_CURSOR = None
PKT_CURSOR = None
# Persistence cursorů (22. 7. 2026): restart procesu dřív = cold start = ztráta
# jednoho duty cyklu paketů (pktlog backlog se nepřehrává). S watchdogem cyklu
# (exit po 3 selháních → systemd restart) by se to dělo častěji, tak cursory
# přežívají na disku. Reboot UZLU vynuluje seq → guard v poll_* (cursor > newest
# = přehrát ring od 0). Limit: když uzel rebootne a seq stihne přerůst starý
# cursor ještě před prvním pollem, mezera se nepozná — vzácné, přijatelné.
CURSOR_FILE = os.environ.get("MC_CURSOR_FILE") or os.path.join(
os.environ.get("STATE_DIRECTORY", "."), "cursors.json"
) # systemd StateDirectory=
def load_cursors():
global RX_CURSOR, PKT_CURSOR
try:
with open(CURSOR_FILE) as f:
d = json.load(f)
RX_CURSOR, PKT_CURSOR = d.get("rx"), d.get("pkt")
log.info("cursory načteny (%s): rx=%s pkt=%s", CURSOR_FILE, RX_CURSOR, PKT_CURSOR)
except FileNotFoundError:
pass
except Exception as e:
log.warning("cursory: %s nečitelný (%s) — cold start", CURSOR_FILE, e)
def save_cursors():
try:
tmp = CURSOR_FILE + ".tmp"
with open(tmp, "w") as f:
json.dump({"rx": RX_CURSOR, "pkt": PKT_CURSOR}, f)
os.replace(tmp, CURSOR_FILE)
except Exception as e:
log.warning("cursory: zápis do %s selhal: %s", CURSOR_FILE, e)
def _paged_done(buf: bytearray) -> bool:
"""Stránkovaná odpověď (nodes/rxlog/pktlog) je kompletní, když poslední ukončený
řádek je trailer `E,...` — netřeba čekat na 1.2 s ticha (šetří ~1 s/stránku)."""
if not buf.endswith(b"\r\n"):
return False
tail = buf.rstrip().rsplit(b"\n", 1)[-1].lstrip()
if tail.startswith(b"->"): # jednořádková odpověď: trailer slepený s " -> " prefixem
tail = tail[2:].lstrip()
return tail.startswith(b"E,")
def make_query(client):
"""Vrať query(cmd) navázaný na klienta: pošli příkaz, čti dokud odpověď proudí
(ticho 1.2 s / strop REPLY_WAIT / volitelný `done` prediktor konce).
Sdílený notify buffer."""
buf = bytearray()
returned = [0] # kolik bajtů z buf už vrátila předchozí query()
def on_tx(_handle, data: bytearray):
buf.extend(data)
async def query(cmd, cap=REPLY_WAIT, done=None):
# Pozdní konec předchozí odpovědi. Na slabém linku (kolem −82 dBm)
# přijde část odpovědi až po 1.2 s ticha, kdy už query() vrátila
# začátek; bez tohohle by ten konec četl DALŠÍ příkaz jako svůj (6. 10.:
# `clock` dostal stats JSON, `nodes` dostal „Unknown command" od `bot`).
# Neukončený řádek = odpověď ještě běží, tak na ni chvíli počkej.
stale = len(buf) > returned[0] or (buf and not buf.endswith(b"\n"))
if stale:
last, quiet, waited = len(buf), 0.0, 0.0
while quiet < 0.6 and waited < FIRST_BYTE_WAIT:
await asyncio.sleep(0.15)
waited += 0.15
if len(buf) != last:
last = len(buf)
quiet = 0.0
else:
quiet += 0.15
log.debug("query(%s): zahozen pozdní konec předchozí odpovědi (%d B)", cmd, len(buf) - returned[0])
buf.clear()
payload = (cmd + "\r").encode()
for i in range(0, len(payload), 20): # 20B kousky (BLE MTU jistota)
await client.write_gatt_char(NUS_RX, payload[i : i + 20], response=False)
last, quiet, waited = -1, 0.0, 0.0
while waited < cap:
await asyncio.sleep(0.15)
waited += 0.15
if done and done(buf):
break
if len(buf) != last:
last = len(buf)
quiet = 0.0
else:
quiet += 0.15
# Ticho se počítá až od prvního bajtu. Přes slabý BLE link (kolem
# −82 dBm) přichází začátek odpovědi i po víc než 1.2 s;
# dřív se to četlo jako prázdná odpověď (clock '', 0 sousedů).
if quiet >= (1.2 if buf else FIRST_BYTE_WAIT):
break
returned[0] = len(buf)
return buf.decode(errors="replace")
return on_tx, query
def open_serial(port):
"""Otevři USB konzoli uzlu. DTR/RTS MUSÍ jít nahoru, jinak CDC mlčí (dock-quiet)."""
import serial # optional dep: BLE cesta pyserial nepotřebuje
s = serial.Serial(port, 115200, timeout=0)
s.dtr = True
s.rts = True
time.sleep(1.2) # firmware chvíli po otevření portu neodpovídá
s.reset_input_buffer()
return s
def make_serial_query(s):
"""Sériový protějšek make_query — stejná semantika (ticho 1.2 s / strop REPLY_WAIT /
volitelný `done` prediktor), takže VŠECHNY parsery a polly fungují bez úprav.
Dva rozdíly proti BLE:
- žádné 20B kouskování (to je limit BLE MTU, ne linky),
- konzole příkaz ECHUJE. Echo se zahazuje tady, na švu transportu, aby parsery
zůstaly pro oba transporty identické: parse_console_value() vrací první
neprefixovaný řádek, takže `ver` by jinak vrátilo "ver" místo verze.
"""
async def query(cmd, cap=REPLY_WAIT, done=None):
try:
s.reset_input_buffer()
except Exception:
pass
s.write((cmd + "\r\n").encode())
s.flush()
buf = bytearray()
last, quiet, waited = -1, 0.0, 0.0
while quiet < 1.2 and waited < cap:
await asyncio.sleep(0.15)
waited += 0.15
n = s.in_waiting
if n:
buf.extend(s.read(n))
if done and done(buf):
break
if len(buf) != last:
last = len(buf)
quiet = 0.0
else:
quiet += 0.15
lines = buf.decode(errors="replace").replace("\r", "\n").split("\n")
for i, ln in enumerate(lines): # zahoď první řádek == echo příkazu
if ln.strip() == cmd.strip():
del lines[i]
break
return "\n".join(lines)
return query
async def serial_session(mc):
"""Trvalé sériové spojení. Na rozdíl od BLE se USB konzole s rádiem nebije, takže
ŽÁDNÝ duty cycle: drain jede pořád a nedělá hluchá okna. U BLE právě ta okna stála
pktlog DROPy (64slotový PKTFEED nestačil na 120 s duty-off)."""
global T_NODES, T_FULL
s = open_serial(SERIAL_PORT)
query = make_serial_query(s)
log.info("sériová konzole otevřena: %s", SERIAL_PORT)
mc.publish(f"{MQTT_TOPIC}/serial", "connected", qos=1, retain=True)
obs_retry_at = 0.0
try:
while True:
now = time.monotonic()
# obs_init MUSÍ jít ze smyčky, ne před ni: sériová session je TRVALÁ,
# takže jeho "feed odložen do příští session" by tady znamenalo navždy
# (u BLE to spraví další duty cyklus). Děje se to po zapojení desky —
# konzole chvíli po bootu nic nevydá (4. 8. 2026: get public.key vrátil
# 0 znaků při uptime 16 s). Backoff, ať to nespamuje ERRORem každé 2 s.
if OBS_ENABLE and not OBS.pub and now >= obs_retry_at:
await obs_init(query)
obs_retry_at = now + 30
if now - T_FULL >= INTERVAL:
# jméno/verze/rádio osvěžit jako u BLE, kde to dělá každá session
if OBS_ENABLE and OBS.pub:
await obs_init(query)
await scrape_full(query, mc)
T_FULL = now
if now - T_NODES >= NODES_INTERVAL:
await poll_nodes(query, mc)
T_NODES = now
await poll_rxlog(query, mc)
await poll_pktlog(query, mc)
save_cursors() # restart procesu ≠ ztráta pozice v ringu
await asyncio.sleep(RXLOG_INTERVAL)
finally:
mc.publish(f"{MQTT_TOPIC}/serial", "disconnected", qos=1, retain=True)
try:
s.close()
except Exception:
pass
async def serial_main(mc):
"""Smyčka sériového transportu. Chybějící port NENÍ chyba — deska prostě ještě
není zapojená, tak se čeká tiše (jinak by to zaplavilo journal jako crashloop
BLE varianty). Proto se tady taky nikdy neexituje: unita zůstane `active` a chytí
desku v momentě, kdy ji zapojíš."""
log.info(
"observer běží: SERIAL %s → MQTT %s:%d %s | scrape %ds, nodes %ds, rxlog %ds",
SERIAL_PORT,
MQTT_HOST,
MQTT_PORT,
MQTT_TOPIC,
INTERVAL,
NODES_INTERVAL,
RXLOG_INTERVAL,
)
load_cursors()
waiting = False
while True:
if not os.path.exists(SERIAL_PORT):
if not waiting:
log.warning("port %s neexistuje — čekám na zapojení desky", SERIAL_PORT)
waiting = True
await asyncio.sleep(5)
continue
waiting = False
try:
await serial_session(mc)
except Exception as e:
log.error("sériové spojení: %r — retry za 15 s", e)
await asyncio.sleep(15)
async def obs_init(query):
"""Přečti identitu uzlu z konzole a nastartuj/aktualizuj observer sink.
prv.key NIKDY nelogovat a nikam neukládat — jde do RAM Observeru a tečka.
Při MC_OBS_AUTH=none (vlastní broker) se prv.key vůbec nečte."""
if not OBS_ENABLE:
return
pub = parse_console_value(await query("get public.key"))
name = parse_console_value(await query("get name"))
ver = parse_console_value(await query("ver"))
radio = parse_console_value(await query("get radio"))
if not pub or len(pub) != 64:
log.error(
"observer: konzole nevydala public.key (%s znaků) — feed odložen do příští session", len(pub) if pub else 0
)
return
prv = None
if OBS_AUTH == "token":
prv = parse_console_value(await query("get prv.key"))
if not prv or len(prv) != 128:
log.error(
"observer: konzole nevydala prv.key (%s znaků) — feed odložen do příští session", len(prv) if prv else 0
)
return
try:
bytes.fromhex(pub)
if prv:
bytes.fromhex(prv)
except ValueError:
log.error("observer: klíče nejsou validní hex — feed odložen")
return
if prv:
# self-check: pubkey odvozený ze scalar části prv.key MUSÍ sedět na public.key
# (odhalí zkomolený přenos konzolí i případnou změnu layoutu klíče ve FW)
derived = _ed_compress(_ed_mul(_ED_B, int.from_bytes(bytes.fromhex(prv)[:32], "little"))).hex().upper()
if derived != pub.upper():
log.error(
"observer: prv.key neodpovídá public.key (odvozeno %s…, konzole %s…) — feed odložen",
derived[:8],
pub.upper()[:8],
)
return
OBS.start(name or NODE, pub, prv, ver or "unknown", radio or "unknown")
async def scrape_bot(query):
"""`bot` countery → dict k přimíchání do stats. Uzel bez kanálového bota
(build bez bota, starší FW) příkaz nezná, tak se po druhém „Unknown command" přestane
zkoušet — stejně jako `nodes` výš."""
if "bot" in _unsupported:
return {}
reply = await query("bot")
if fw_lacks("bot", reply):
if "bot" in _unsupported:
log.info("FW nezná `bot` — countery kanálového bota přeskočeny (uzel bez bota)")
return {}
return parse_bot(reply)
# kolikrát tenhle proces hodiny uzlu srovnal (counter, ne příznak — viz níž)
_clock_sets = 0
async def sync_clock(query):
"""Hodiny uzlu → countery do stats, a když je uzel pozadu, srovnej je.
Proč to musí dělat observer: uzel bez GPS nemá čím. Automatické cesty jsou
v celém FW dvě — GPS (`MicroNMEALocationProvider`) a `BaseChatMesh`, který
repeater build vůbec nelinkuje — a `clock sync` po konzoli NEMŮŽE projít,
protože `simple_repeater/main.cpp` předává `sender_timestamp = 0` pro USB
i BLE (dělí jeden buffer), takže strážce `sender_timestamp > curr` nikdy
neprojde. Zbývá `time <epoch>`.
Bez tohohle běžel jeden náš uzel od nasazení 811 dní pozadu — `VolatileRTCClock` má
base_time zadrátovaný na 15. 5. 2024 a nikdo mu čas nikdy nenastavil. A to
není kosmetika: čas z RTC jde do KAŽDÉHO vysílaného advertu (`Mesh.cpp`) a
příjemce starý timestamp zahodí jako replay, takže se ze špatných hodin
stane zahozená odpověď.
Uzel s GPS si hodiny srovnává sám, takže tam z tohohle zůstane jen čtení.
Counter, ne příznak: bez `clock_set_count` se nepozná „srovnalo se to a drží"
od „nikdy to nejelo" — přesně ta lekce z `bot_replies`.
Uzel NAPŘED před hostitelem se odsud opravit nedá: `time` má strážce
`secs > curr` a jediná cesta dozadu je `clkreboot`, který REBOOTUJE — a
reboot vzdálené desky ji umí shodit z USB až do replugu. Takže jen WARNING
a nech to na člověku."""
global _clock_sets
if "clock" in _unsupported:
return {}
reply = await query("clock")
if fw_lacks("clock", reply):
if "clock" in _unsupported:
log.info("FW nezná `clock` — synchronizace hodin přeskočena")
return {}
parsed = parse_clock(reply)
if parsed is None:
log.warning("`clock` nedal čas: %r", reply.strip()[:120])
return {}
node, exact = parsed
now = int(time.time())
skew = now - node
out = {"clock_skew_secs": skew, "clock_set_count": _clock_sets}
if skew < 0:
log.warning(
"uzel má hodiny %d s NAPŘED (%s) — `time` to odmítne a srovnat "
"to jde jen `clkreboot`em, čili rebootem. Nechávám na tobě.",
-skew,
datetime.fromtimestamp(node, timezone.utc).isoformat(),
)
return out
if skew <= (CLOCK_SKEW_EXACT if exact else CLOCK_SKEW_COARSE):
return out
set_reply = await query(f"time {now}")
# „cannot go backwards" tady není chyba, jen závod: uzel se mezitím srovnal
# sám (GPS), nebo je čas hostitele o vlásek pozadu. Rozhodne další scrape.
if "OK" in set_reply:
_clock_sets += 1
out["clock_set_count"] = _clock_sets
log.info(
"hodiny uzlu srovnány: byl %s (%+d s), nastaveno %d — %s",
datetime.fromtimestamp(node, timezone.utc).isoformat(),
-skew,
now,
set_reply.strip()[:80],
)
else:
log.warning("`time %d` neprošlo: %r", now, set_reply.strip()[:120])
return out
async def scrape_full(query, mc):
"""Plný scrape (kompat): neighbors + stats + sensors → MQTT (jako dřív)."""
neighbours = parse_neighbours(await query(CMD))
stats = {}
for c in STATS_CMDS:
stats.update(parse_json_reply(await query(c)))
stats.update(await scrape_bot(query))
# Hodiny až za stats: `uptime_secs` ze `stats-core` je to, čím se dá zpětně
# dokázat, že uzel jel na base_time z konstruktoru (base + uptime == čas).
stats.update(await sync_clock(query))
sensors = parse_sensors(await query("sensor read"))
ts = int(time.time())
doc = {
"node": NODE,
"ts": ts,
"count": len(neighbours),
"neighbours": neighbours,
"stats": stats,
"sensors": sensors,
}
mc.publish(f"{MQTT_TOPIC}/neighbours", json.dumps(doc), qos=0, retain=False)
for n in neighbours:
mc.publish(
f"{MQTT_TOPIC}/neighbour/{n['pubkey_prefix']}",
json.dumps({**n, "node": NODE, "ts": ts}),
qos=0,
retain=False,
)
if stats:
mc.publish(f"{MQTT_TOPIC}/stats", json.dumps({"node": NODE, "ts": ts, **stats}), qos=0, retain=False)
if sensors:
mc.publish(f"{MQTT_TOPIC}/sensors", json.dumps({"node": NODE, "ts": ts, **sensors}), qos=0, retain=False)
mc.publish(f"{MQTT_TOPIC}/last_scrape", str(ts), qos=0, retain=False)
OBS.publish_status(stats or None) # observer status jede v rytmu plného scrape
log.info(
"full scrape: %d sousedů | stats: %s | senzory: %s", len(neighbours), stats or "(žádné)", sensors or "(žádné)"
)
async def poll_nodes(query, mc):
"""Přečti celý `nodes` registr (paged offset 0→total) → retained snapshot na MQTT."""
if "nodes" in _unsupported:
return
rows = []
offset = 0
for _ in range(50): # strop proti nekonečnu
reply = await query(f"nodes {offset}" if offset else "nodes", done=_paged_done)
if fw_lacks("nodes", reply):
if "nodes" in _unsupported:
log.info("FW nezná `nodes` — analyzer registr přeskočen (starý FW?)")
return
page, nxt, total = parse_nodes(reply)
rows.extend(page)
if nxt is None or total is None or nxt >= total or nxt == offset:
break
offset = nxt
ts = int(time.time())
mc.publish(
f"{MQTT_TOPIC}/nodes",
json.dumps({"node": NODE, "ts": ts, "count": len(rows), "nodes": rows}),
qos=0,
retain=True,
) # snapshot → retained (fresh konzument dostane hned)
log.info("nodes: %d slyšených repeaterů/roomů", len(rows))
async def poll_rxlog(query, mc):
"""Drain `rxlog` od uloženého RX_CURSOR (přežívá reconnect) → stream na MQTT.
Cold start (RX_CURSOR None): začni od toho co kruh drží, BEZ hlášení dropu (nic jsme
nezmeškali, jen startujeme). Warm: cursor+1 < oldest = kruh nám přepsal záznamy = drop."""
global RX_CURSOR
if "rxlog" in _unsupported:
return
# Strop na jeden poll: ~3 záznamy/stránku (160B reply cap) → až ~180 záznamů/cyklus.
# 20 nestačilo na denní bursty (advert + kopie od okolních repeaterů přijdou během
# sekund) — ring 96 pak přetékal po jednotkách záznamů, viz meshcore_rxlog_dropped_total.
for _ in range(60):
cur = 0 if RX_CURSOR is None else RX_CURSOR
reply = await query(f"rxlog {cur}", done=_paged_done)
if fw_lacks("rxlog", reply):
if "rxlog" in _unsupported:
log.info("FW nezná `rxlog` — analyzer firehose přeskočen (starý FW?)")
return
recs, last, oldest, newest = parse_rxlog(reply)
if last is None or oldest is None:
break # nečitelná / prázdná odpověď
if newest is not None and cur > newest:
log.warning(
"rxlog: cursor %d > newest %d — uzel rebootoval (seq reset), jedu od začátku ringu", cur, newest
)
RX_CURSOR = None # None = cold-start sémantika (bez falešného dropu)
continue
cold = RX_CURSOR is None
dropped = 0 if cold else (oldest - cur - 1 if cur + 1 < oldest else 0)
if recs or dropped:
ts = int(time.time())
mc.publish(
f"{MQTT_TOPIC}/rxlog",
json.dumps(
{
"node": NODE,
"ts": ts,
"records": recs,
"dropped": dropped,
"ring": {"oldest": oldest, "newest": newest},
}
),
qos=0,
retain=False,
)
if dropped:
log.warning(
"rxlog DROP: kruh přepsal %d záznamů (cursor %d < oldest %d) — poll rychleji / zvětši RXLOG_SIZE",
dropped,
cur,
oldest,
)
RX_CURSOR = last # posuň cursor (global → přežije reconnect)
if last <= cur or (newest is not None and last >= newest):
break # nic nového / dohnáno
async def poll_pktlog(query, mc):
"""Drain `pktlog` (surové rámce) → observer feed + lokální MQTT kopie.
Cold start (PKT_CURSOR None): NEpřehrávat backlog ringu — živý komunitní feed
nemá stát o restart-duplikáty se starými timestampy. Trailer prozradí newest
i bez čtení záznamů (cursor 2^32-1 nematchne nic), od něj se jede nově."""
global PKT_CURSOR
if not OBS_ENABLE or "pktlog" in _unsupported:
return
if PKT_CURSOR is None:
reply = await query("pktlog 4294967295", done=_paged_done)
if fw_lacks("pktlog", reply):
if "pktlog" in _unsupported:
log.info("FW nezná `pktlog` — observer feed přeskočen (starý FW?)")
return
_, _, _, newest = parse_pktlog(reply)
PKT_CURSOR = newest if newest is not None else 0
log.info("observer: pktlog cursor startuje na %d (backlog se nepřehrává)", PKT_CURSOR)
return
# plný rámec ≈ 550 B řádek → 1-3 záznamy/1000B stránku; 40 stránek bohatě
# pokryje 32-slotový ring i s rezervou na souběžný přítok
for _ in range(40):
cur = PKT_CURSOR
reply = await query(f"pktlog {cur}", done=_paged_done)
if fw_lacks("pktlog", reply):
return
recs, last, oldest, newest = parse_pktlog(reply)
if last is None or oldest is None:
break
if newest is not None and cur > newest:
log.warning("pktlog: cursor %d > newest %d — uzel rebootoval (seq reset), přehrávám ring od 0", cur, newest)
PKT_CURSOR = 0 # ring drží jen po-rebootové rámce → přehrát celý
continue
dropped = oldest - cur - 1 if (cur and cur + 1 < oldest) else 0
if dropped:
log.warning(
"pktlog DROP: kruh přepsal %d záznamů (cursor %d < oldest %d) — zvětši PKTFEED_SIZE / rychlejší poll",
dropped,
cur,
oldest,
)
for rec in recs:
msg = obs_packet_json(rec)
if msg is None:
log.warning(
"pktlog: neparsovatelný rámec seq=%s (%d B) — přeskočen",
rec.get("seq"),
len(rec.get("raw", "")) // 2,
)
continue
OBS.publish_packet(msg)
# lokální kopie stejného tvaru (pokud je MC_MQTT_HOST)
mc.publish(f"{MQTT_TOPIC}/packets", json.dumps(msg), qos=0, retain=False)
PKT_CURSOR = last
if last <= cur or (newest is not None and last >= newest):
break
T_NODES = 0.0 # cadence přežívá reconnecty (duty cycle se odpojuje každý průchod)
T_FULL = 0.0
async def session(client, mc):
"""Jeden drain průchod na jednom BLE spojení: rxlog+pktlog vždy, nodes/full scrape
podle cadence (NODES_INTERVAL/INTERVAL). Volající se po návratu ODPOJÍ (duty cycle),
viz OFF_INTERVAL — trvalé spojení blokovalo DIRECT forwarding repeateru."""
global T_NODES, T_FULL
on_tx, query = make_query(client)
await client.start_notify(NUS_TX, on_tx)
mc.publish(f"{MQTT_TOPIC}/ble", "connected", qos=1, retain=True)
try:
await obs_init(query) # identita pro observer feed (no-op bez MC_OBS_ENABLE)
now = time.monotonic()
if now - T_FULL >= INTERVAL:
await scrape_full(query, mc)
T_FULL = now
if now - T_NODES >= NODES_INTERVAL:
await poll_nodes(query, mc)
T_NODES = now
await poll_rxlog(query, mc)
await poll_pktlog(query, mc)
finally:
try:
await client.stop_notify(NUS_TX)
except Exception:
pass
def config_error():
"""Chyba konfigurace jako text, None = v pořádku."""
if not (SERIAL_PORT or BLE_ADDR or BLE_NAME):
return "set MC_SERIAL_PORT (USB) or MC_BLE_ADDR / MC_BLE_NAME (BLE)"
if OBS_ENABLE and not OBS_IATA:
return "MC_OBS_ENABLE=1 needs MC_OBS_IATA (the region's airport code, e.g. PRG)"
if not OBS_ENABLE and not MQTT_HOST:
return "nothing to publish to: set MC_OBS_ENABLE=1 and/or MC_MQTT_HOST"
return None
async def main():
err = config_error()
if err:
log.error("config: %s", err)
sys.exit(2)
mc = make_mqtt()
if SERIAL_PORT: # USB konzole místo BLE; BLE větev níž zůstává nedotčená
if OBS_ENABLE:
log.info(
"observer feed ZAPNUT: %s:%d (%s, TLS %s, auth %s) IATA=%s aud=%s",
OBS_HOST,
OBS_PORT,
OBS_TRANSPORT,
OBS_TLS,
OBS_AUTH,
OBS_IATA,
OBS_AUDIENCE,
)
await serial_main(mc)
return
log.info(
"observer běží: BLE %s → MQTT %s:%d %s | scrape %ds, nodes %ds, rxlog %ds",
BLE_ADDR or BLE_NAME,
MQTT_HOST,
MQTT_PORT,
MQTT_TOPIC,
INTERVAL,
NODES_INTERVAL,
RXLOG_INTERVAL,
)
if OBS_ENABLE:
log.info(
"observer feed ZAPNUT: %s:%d (%s, TLS %s, auth %s) IATA=%s aud=%s",
OBS_HOST,
OBS_PORT,
OBS_TRANSPORT,
OBS_TLS,
OBS_AUTH,
OBS_IATA,
OBS_AUDIENCE,
)
else:
log.info("observer feed vypnut (MC_OBS_ENABLE=1 pro zapnutí)")
# Watchdog cyklu (22. 7. 2026): scan i connect mají nominální timeouty, ale
# když USB churn (crash-loopující SDR na téže sběrnici jako BT dongle) zasekne
# bluetoothd, D-Bus volání pod bleakem nikdy neodpoví a smyčka visela navěky
# (pozorováno: poslední drain 10:53, pak 50+ min ticho). wait_for() task
# zruší i když D-Bus mlčí; po 3 selháních za sebou exit(1) → systemd
# Restart=on-failure nahodí čerstvý proces (nové D-Bus spojení).
cycle_timeout = int(os.environ.get("MC_CYCLE_TIMEOUT", "900"))
fails = 0
load_cursors() # restart procesu ≠ ztráta duty cyklu (viz CURSOR_FILE)
async def cycle():
dev = await find_device() # scan při každém (re)connectu → spolehlivé discovery
async with BleakClient(dev, timeout=30) as client:
log.info("BLE připojeno k %s", dev.address)
await session(client, mc)
while True:
try:
await asyncio.wait_for(cycle(), timeout=cycle_timeout)
fails = 0
save_cursors() # po úspěšném drainu — restart pak naváže, ne cold start
# duty cycle: odpojeno → repeater má volno na DIRECT forwarding
mc.publish(f"{MQTT_TOPIC}/ble", "disconnected", qos=1, retain=True)
log.info("drain hotov, BLE odpojeno na %d s (duty cycle)", OFF_INTERVAL)
await asyncio.sleep(OFF_INTERVAL)
except Exception as e:
fails += 1
log.error("BLE spojení (%d/3): %r — reconnect za 15 s", fails, e)
mc.publish(f"{MQTT_TOPIC}/ble", "disconnected", qos=1, retain=True)
await clear_stale_ble_connection()
if fails >= 3:
log.error("3 cykly za sebou selhaly — exit(1), systemd restartne s čerstvým D-Bus")
sys.exit(1)
await asyncio.sleep(15)
def cli():
try:
asyncio.run(main())
except KeyboardInterrupt:
pass
if __name__ == "__main__":
cli()