ci / test (push) Successful in 1m15s
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>
1394 lines
55 KiB
Python
1394 lines
55 KiB
Python
#!/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()
|