From 2b6d43eb45ef2af34cbb65e004933968ffb4f451 Mon Sep 17 00:00:00 2001 From: Krzyszur Date: Wed, 30 Sep 2026 23:13:16 +0200 Subject: [PATCH 1/3] macOS: do not reset the box on connect On macOS/Linux the OS asserts DTR and RTS when the port is opened and pyserial then writes DTR before RTS, passing through RTS=1/DTR=0 - the USB-Serial-JTAG reset state. Every Connect restarted the box. Drop RTS before open and DTR right after it on posix; Windows is unchanged. Verified on macOS 27 / arm64 with box A4:CB:8F:C9:47:3C (fw 1.0.16, build 3ae273ec): connect keeps the box running, Reset & capture still restarts it. Co-Authored-By: Claude Opus 5.5 --- kota_tech/serialio/manager.py | 17 +++++++++++---- tests/test_manager.py | 40 +++++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 4 deletions(-) diff --git a/kota_tech/serialio/manager.py b/kota_tech/serialio/manager.py index 93095fd..18692a9 100644 --- a/kota_tech/serialio/manager.py +++ b/kota_tech/serialio/manager.py @@ -10,6 +10,7 @@ from __future__ import annotations import enum import queue +import sys import threading import time from collections.abc import Callable @@ -92,13 +93,21 @@ class SerialManager: ser = serial.serial_for_url( info.device, baudrate=self._baud, timeout=READ_TIMEOUT_S, do_not_open=True ) - # Deassert both lines before open. On USB-Serial-JTAG, RTS=1/DTR=0 - # holds the chip in reset and DTR=1 during reset selects download - # mode; pyserial would otherwise assert both on open (Windows). - ser.dtr = False + # On USB-Serial-JTAG, RTS=1/DTR=0 holds the chip in reset and DTR=1 + # during reset selects download mode. + # Windows: pyserial applies both lines atomically at open, so + # deassert both beforehand (it would otherwise assert both). + # macOS/Linux: the OS asserts both lines on open and pyserial then + # writes DTR before RTS, passing through RTS=1/DTR=0 and resetting + # the box on every connect. Drop RTS first, then DTR. + posix = sys.platform != "win32" + if not posix: + ser.dtr = False ser.rts = False try: ser.open() + if posix: + ser.dtr = False except (serial.SerialException, OSError): return None self._target.device = info.device # COM number / node may change diff --git a/tests/test_manager.py b/tests/test_manager.py index ad11fdf..8b832ba 100644 --- a/tests/test_manager.py +++ b/tests/test_manager.py @@ -86,6 +86,46 @@ def test_hard_reset_pushes_rts_via_dtr_write(monkeypatch): assert all(c[1] is False for c in ser.calls if c[0] == "dtr") +class _PosixOpenSerial: + """pyserial on macOS/Linux: the OS asserts both lines on open, then + pyserial writes the requested DTR, then RTS. Records every line state.""" + + def __init__(self, *args, **kwargs): + self.port = args[0] if args else "fake" + self.dtr = self.rts = True # pyserial defaults + self.states = [] + + def __setattr__(self, name, value): + object.__setattr__(self, name, value) + if name in ("dtr", "rts") and getattr(self, "is_open", False): + self.states.append((self.dtr, self.rts)) + + def open(self): + want_dtr, want_rts = self.dtr, self.rts + object.__setattr__(self, "dtr", True) + object.__setattr__(self, "rts", True) + self.is_open = True + self.states.append((True, True)) + self.dtr = want_dtr + self.rts = want_rts + + +def test_open_on_posix_never_passes_through_reset(monkeypatch): + monkeypatch.setattr(mgr_mod.sys, "platform", "darwin") + monkeypatch.setattr(mgr_mod, "find_port", lambda sn, dev: LOOP) + opened = [] + monkeypatch.setattr( + mgr_mod.serial, "serial_for_url", + lambda *a, **k: opened.append(_PosixOpenSerial(*a, **k)) or opened[-1], + ) + m = SerialManager(lambda ln: None, lambda s, d: None) + m._target = mgr_mod._Target(LOOP.device, None) + ser = m._open() + # (DTR, RTS) = (False, True) resets the chip on connect. + assert (False, True) not in ser.states + assert ser.states[-1] == (False, False) + + def test_waits_when_port_missing(monkeypatch): monkeypatch.setattr(mgr_mod, "find_port", lambda sn, dev: None) states, lines = [], [] From 66cb80410206242f4b8364c00a859b1562770981 Mon Sep 17 00:00:00 2001 From: Krzyszur Date: Wed, 30 Sep 2026 23:37:36 +0200 Subject: [PATCH 2/3] Checklist: verify that sensor data reaches InfluxDB New guided check "Sensor data in the database (InfluxDB)", also the last step of the Quick check on the green path. It queries InfluxDB (read token) for the newest point per measurement of the box and tells apart: sensor data arrives / status arrives without sensor data / offline now / never seen / check not possible. Polls every 30 s for up to 4 minutes. With a stopped RTC in the log it concludes that sensor readings are lost (stamped 1 Jan 2000): box A4:CB:8F:C9:47:3C sent only device_status and microphone. - service/influx.py: query, CSV parsing, classification (no new deps) - guides: new step type "influx" (host answers via influx_result) - Settings > InfluxDB access (or KOTA_INFLUX_TOKEN); token never logged - service status mapping for tech.influx.* findings Co-Authored-By: Claude Opus 5.5 --- README.md | 7 ++ docs/CHANGES-v0.10.md | 12 +++ kota_tech/diag/guides.py | 69 ++++++++++++- kota_tech/diag/guides.toml | 93 +++++++++++++++-- kota_tech/service/influx.py | 194 ++++++++++++++++++++++++++++++++++++ kota_tech/service/report.py | 2 + kota_tech/ui/guide_panel.py | 10 +- kota_tech/ui/main_window.py | 68 +++++++++++++ tests/test_guides.py | 92 +++++++++++++++++ tests/test_influx.py | 142 ++++++++++++++++++++++++++ tests/test_ui.py | 2 + 11 files changed, 676 insertions(+), 15 deletions(-) create mode 100644 kota_tech/service/influx.py create mode 100644 tests/test_influx.py diff --git a/README.md b/README.md index bf69946..e0908d5 100644 --- a/README.md +++ b/README.md @@ -50,6 +50,13 @@ Stare środowiska `venv-0.x` z poprzednich wersji można usunąć. Sesje, kopie zapasowe flash i ustawienia są w `~/KotaTechnicianTool` (Windows: `C:\Users\\KotaTechnicianTool`). +## Dane w InfluxDB + +Kontrola **Sensor data in the database (InfluxDB)** (Guided troubleshooting, także ostatni krok Quick check) +sprawdza online, czy do InfluxDB trafiają dane z czujników boxa, a nie tylko jego status. Wymaga internetu +na laptopie i jednorazowego ustawienia tokenu tylko do odczytu (od zespołu firmware): +**Settings > InfluxDB access...**. Tokenu nie zapisujemy w repozytorium. + ## Port sensorboxa - Windows: `COMx - Sensorbox (native USB) [MAC]` diff --git a/docs/CHANGES-v0.10.md b/docs/CHANGES-v0.10.md index 9b8ed13..501fce4 100644 --- a/docs/CHANGES-v0.10.md +++ b/docs/CHANGES-v0.10.md @@ -12,3 +12,15 @@ the firmware team should bump the version for the next build. - error_ids.csv updated from the firmware (E-CON-01). - Test that builds the main window (catches start-up errors). +- New check **Sensor data in the database (InfluxDB)** (Guided troubleshooting; also the last step of the + Quick check on the green path): queries InfluxDB online (read-only) for the box's newest points and tells + apart "sensor data arrives", "status arrives but sensor data does not", "offline now" and "never seen". + Polls every 30 s for up to 4 minutes. With a stopped RTC in the log it concludes that the sensor readings + are lost (they are stamped 1 Jan 2000) - found on box A4:CB:8F:C9:47:3C, which reported only + device_status and microphone. The result and the per-measurement times go into the report and the + service note. +- Settings > **InfluxDB access...**: address, organisation, bucket and a read token (or the + `KOTA_INFLUX_TOKEN` environment variable). Defaults: influx.kota-app.com, org `kota`, bucket `sensorbox`. + The token is never written to the session log or the service report. +- macOS: Connect no longer restarts the box (pyserial dropped DTR before RTS, passing through the + USB-Serial-JTAG reset state). Windows unchanged. diff --git a/kota_tech/diag/guides.py b/kota_tech/diag/guides.py index 6ae4839..fc1e835 100644 --- a/kota_tech/diag/guides.py +++ b/kota_tech/diag/guides.py @@ -4,7 +4,8 @@ GUI-independent. The runner is fed the same LogLines as the diagnostics engine, reads the engine's report to route and to skip questions the log already answers, asks the host to perform tool actions (board reset), and records every answer and conclusion in the engine so they appear in the -report and the session log. +report and the session log. "influx" steps ask the host to query InfluxDB +(on_action("influx")); the host answers with influx_result(). """ from __future__ import annotations @@ -24,7 +25,9 @@ GUIDES_PATH = Path(__file__).with_name("guides.toml") LED_ANSWERS = ["GREEN", "PURPLE", "RED", "BLUE", "WHITE", "YELLOW", "ORANGE", "CYAN", "OFF", "CYCLING"] LED_ANSWER_LABELS = {**{k: v[0] for k, v in LED.items()}, "CYCLING": "Keeps changing / goes dark every few seconds"} -STEP_TYPES = {"led", "question", "info", "wait", "route"} +STEP_TYPES = {"led", "question", "info", "wait", "route", "influx"} +# Results of an InfluxDB check (service.influx.OUTCOMES). +INFLUX_OUTCOMES = ("ok", "sensors_missing", "silent", "never", "unavailable") END_SEVERITY = {"ok": None, "info": Severity.INFO, "warning": Severity.WARNING, "error": Severity.ERROR, "critical": Severity.CRITICAL} @@ -58,9 +61,12 @@ class Step: skip_unless_feature: str | None = None skip_to: str | None = None show_qr: bool = False # show the Matter pairing QR next to the step text + outcomes: dict[str, str] = field(default_factory=dict) # influx result -> target + poll_s: float = 30.0 # influx: query again after this many seconds def targets(self) -> list[str]: t = [o.next for o in self.options] + list(self.route.values()) + list(self.routes.values()) + t += list(self.outcomes.values()) t += [x for x in (self.default, self.next, self.on_ok, self.on_fail, self.on_timeout, self.skip_to) if x] return t @@ -103,6 +109,7 @@ def load_guides(path: Path = GUIDES_PATH) -> dict[str, Guide]: on_ok=s.get("on_ok"), on_fail=s.get("on_fail"), on_timeout=s.get("on_timeout"), skip_if_finding=s.get("skip_if_finding"), skip_unless_feature=s.get("skip_unless_feature"), skip_to=s.get("skip_to"), show_qr=bool(s.get("show_qr", False)), + outcomes=dict(s.get("outcomes", {})), poll_s=float(s.get("poll_s", 30)), ) ends = {e["id"]: End(e["id"], e["severity"], e["title"], e["text"], tuple(e.get("actions", ()))) for e in g.get("end", [])} @@ -123,6 +130,10 @@ def _validate(guides: dict[str, Guide]) -> None: raise ValueError(f"{g.id}.{s.id}: unknown LED colours {set(s.route) - set(LED_ANSWERS)}") if s.type == "wait" and not (s.until or s.until_milestone or s.pass_on_timeout): raise ValueError(f"{g.id}.{s.id}: wait step needs until/until_milestone/pass_on_timeout") + if s.type == "influx" and set(INFLUX_OUTCOMES) - set(s.outcomes): + raise ValueError(f"{g.id}.{s.id}: influx step needs outcomes {set(INFLUX_OUTCOMES) - set(s.outcomes)}") + if set(s.outcomes) - set(INFLUX_OUTCOMES): + raise ValueError(f"{g.id}.{s.id}: unknown influx outcomes {set(s.outcomes) - set(INFLUX_OUTCOMES)}") if s.tool_action not in (None, "reset"): raise ValueError(f"{g.id}.{s.id}: unknown tool_action {s.tool_action!r}") for t in s.targets(): @@ -191,6 +202,10 @@ class GuideRunner: self._wait_started = 0.0 self._wait_boot = 0 self._wait_milestones: set[str] = set() + self._influx_pending = False + self._influx_next = 0.0 + self._influx_last: str | None = None + self._influx_noted = "" def start(self, guide_id: str) -> None: self.cancel() @@ -227,6 +242,28 @@ class GuideRunner: elif s.type == "wait": self._record(s, "technician skipped the wait") self._finish_wait("timeout") + elif s.type == "influx": + self._record(s, "technician skipped the InfluxDB check") + self._finish_influx(self._influx_last or "unavailable") + + def influx_result(self, outcome: str, summary: str, details: list[str] | tuple[str, ...] = ()) -> None: + """Result of the host's InfluxDB query for the current influx step.""" + s = self.step + if s is None or s.type != "influx" or not self._influx_pending: + return # stale answer: the technician moved on + self._influx_pending = False + self._influx_last = outcome + note = "InfluxDB: " + "; ".join([summary, *details]) + if note != self._influx_noted: # polls repeat the same answer + self._influx_noted = note + self.engine.note_technician(note) + self._on_log(f"InfluxDB check: {summary}") + waited = self._clock() - self._wait_started + if outcome in ("ok", "unavailable") or waited >= s.timeout_s: + self._finish_influx(outcome) + else: + self._influx_next = self._clock() + s.poll_s + self.note = f"{summary}. Checking again in {s.poll_s:.0f} s..." def back(self) -> None: # Never step back into a wait: re-entering it could restart the box. @@ -256,6 +293,11 @@ class GuideRunner: s = self.step if s is not None and s.type == "wait" and self._clock() - self._wait_started >= s.timeout_s: self._finish_wait("ok" if s.pass_on_timeout else "timeout") + elif s is not None and s.type == "influx" and not self._influx_pending: + if self._clock() - self._wait_started >= s.timeout_s: + self._finish_influx(self._influx_last or "unavailable") + elif self._clock() >= self._influx_next: + self._request_influx() # --------------------------------------------------------------- view def view(self) -> View: @@ -268,7 +310,7 @@ class GuideRunner: v.options = [(k, LED_ANSWER_LABELS[k]) for k in LED_ANSWERS if k in s.route] elif s.type == "question": v.options = [(str(i), o.label) for i, o in enumerate(s.options)] - elif s.type == "wait": + elif s.type in ("wait", "influx"): v.waiting = True v.remaining_s = max(0.0, s.timeout_s - (self._clock() - self._wait_started)) return v @@ -316,6 +358,27 @@ class GuideRunner: if s.until_milestone and not s.tool_action and s.until_milestone in self.engine.milestones: self._record(s, f"already reached: {s.until_milestone}") self._finish_wait("ok") + if s.type == "influx": + self._wait_started = self._clock() + self._influx_last = None + self._request_influx() + + def _request_influx(self) -> None: + self._influx_pending = True + if not self._on_action("influx"): + self._influx_pending = False + self._influx_last = "unavailable" + self._record(self.step, "InfluxDB check not possible from this computer") + self._finish_influx("unavailable") + + def _finish_influx(self, outcome: str) -> None: + s = self.step + self._influx_pending = False + target = s.outcomes.get(outcome) + if target is None: + return + self._push() + self._go(target) def _auto(self, s: Step, why: str, target: str | None) -> None: self._on_log(f"technician guide: {s.id}: {why}") diff --git a/kota_tech/diag/guides.toml b/kota_tech/diag/guides.toml index 0189ce6..a4a0a23 100644 --- a/kota_tech/diag/guides.toml +++ b/kota_tech/diag/guides.toml @@ -16,6 +16,9 @@ # counts as ok (used for "watch for N seconds"). # route automatic: first current root finding whose rule id is in # `routes` decides; otherwise `default`. +# influx the tool asks InfluxDB (online) whether this box's data arrives, +# again every `poll_s` until "ok" or `timeout_s`; `outcomes` maps +# ok / sensors_missing / silent / never / unavailable -> target. # Targets: "", "end:", "guide:". # Optional on any step: skip_if_finding / skip_unless_feature (+ skip_to). # Text placeholders: {expected_led} {failing_sensors} {top_finding} @@ -48,14 +51,7 @@ options = [ id = "green_route" type = "route" routes = { "rtc.clock_not_running" = "guide:clock", "mic.silent" = "guide:mic", "mic.disabled" = "guide:mic", "matter.not_commissioned" = "guide:network", "net.dns_fail" = "guide:network" } -default = "end:healthy" - -[[guide.end]] -id = "healthy" -severity = "ok" -title = "Box looks healthy" -text = "Green LED, firmware running and no problems in the log." -actions = ["If the customer still reports missing data, keep the tool connected for 5 minutes and check that 'Data uploaded to InfluxDB' gets ticked."] +default = "guide:influx" [[guide.end]] id = "hung" @@ -169,6 +165,7 @@ text = "Pairing, Internet time and the first upload all worked." actions = [ "The box may now download a firmware update (yellow, then orange LED, a few minutes). Do not switch it off.", "It should end green.", + "Then run the check 'Sensor data in the database' - the first upload may carry only the box status.", ] [[guide.end]] @@ -738,3 +735,83 @@ severity = "error" title = "Microphone records nothing" text = "Even loud noise next to the box gives no signal, although the switch is on." actions = ["Check the microphone board/cable (inside the case); replace the microphone if needed."] + +# ================================================================== influx +[[guide]] +id = "influx" +title = "Sensor data in the database (InfluxDB)" +summary = "Checks online that the sensor readings of this box reach InfluxDB, not only its status." +recommend = ["always"] +start = "check" + +[[guide.step]] +id = "check" +type = "influx" +text = "Checking in InfluxDB that this box's data arrives: device status, microphone and the sensors (AS7341, BME688, SEN66). Keep the box switched on and online. The tool checks again every 30 s for up to 4 minutes (the air sensor needs about 2 minutes after a restart). The laptop needs Internet for this check." +timeout_s = 240 +poll_s = 30 +outcomes = { ok = "end:data_ok", sensors_missing = "why", silent = "end:silent", never = "end:never", unavailable = "end:unavailable" } + +[[guide.step]] +id = "why" +type = "route" +routes = { "kota.rtc_stopped" = "end:sensors_clock", "rtc.clock_not_running" = "end:sensors_clock", "kota.rtc_not_ticking" = "end:sensors_clock", "kota.time_invalid" = "end:sensors_clock", "kota.rtc_read_failed" = "guide:rtc_i2c", "rtc.init_failed" = "guide:rtc_i2c", "sensor.init_failed" = "guide:sensors", "kota.sensor_missing" = "guide:sensors" } +default = "end:sensors_missing" + +[[guide.end]] +id = "data_ok" +severity = "ok" +title = "Box is healthy and its sensor data reaches InfluxDB" +text = "Status, microphone and all sensor readings of this box arrived in InfluxDB in the last 15 minutes." +actions = [] + +[[guide.end]] +id = "sensors_clock" +severity = "error" +title = "Sensor data is lost: the box clock (RTC) is not running" +text = "The box sends its status and microphone level with the Internet time, but the sensor readings are timestamped by the clock module. With the clock stopped they are stamped 1 Jan 2000 and do not show up in InfluxDB." +actions = [ + "Replace the RTC coin cell (inside the case), switch the box off and on, then run this check again.", + "If the Diagnosis tab still shows the clock not running with a new cell: replace the RTC module.", + "Save the session log for the firmware team.", +] + +[[guide.end]] +id = "sensors_missing" +severity = "error" +title = "Status arrives, sensor data does not" +text = "The box is online and InfluxDB receives its status, but readings of some sensors are missing (the list is in the technician notes of the report)." +actions = [ + "Check the Diagnosis tab for sensor errors; re-seat the cable of the missing sensor (inside the case).", + "If the log shows no sensor error: save the session log and send it to the firmware team.", +] + +[[guide.end]] +id = "silent" +severity = "warning" +title = "Box is not uploading right now" +text = "InfluxDB has older data from this box, but nothing from the last 15 minutes." +actions = [ + "Check that the box has Wi-Fi and Internet (Purple LED / no Internet check), then run this check again.", + "The technician notes of the report show when each kind of data arrived last - if the sensor data stopped long before the status, treat it like 'Status arrives, sensor data does not'.", +] + +[[guide.end]] +id = "never" +severity = "warning" +title = "No data from this box in InfluxDB" +text = "In the last 30 days InfluxDB received nothing from this box: it was never online, or its SD card has wrong database settings." +actions = [ + "Run the Purple LED / no Internet check.", + "If the box is online: re-provision the SD card with the current ENV.TXT (SD card tab).", +] + +[[guide.end]] +id = "unavailable" +severity = "info" +title = "Could not check InfluxDB" +text = "The tool could not query InfluxDB from this computer (no Internet on the laptop, InfluxDB access not set up, or the box MAC not known yet)." +actions = [ + "Settings > InfluxDB access: enter the read token from the firmware team.", + "Or check the box later in the service system (Stan w InfluxDB).", +] diff --git a/kota_tech/service/influx.py b/kota_tech/service/influx.py new file mode 100644 index 0000000..0cc18f9 --- /dev/null +++ b/kota_tech/service/influx.py @@ -0,0 +1,194 @@ +"""Does the box's data reach InfluxDB? (read-only query, InfluxDB 2.x) + +The box writes to the "sensorbox" bucket with the tag device=. device_status and microphone use the system time, the sensor +measurements (AS7341, BME688, SEN66) are timestamped from the box's RTC - +so a box can report its status while none of its sensor data arrives +(e.g. a stopped RTC stamps readings with 1 Jan 2000). + +The token must be a read token for the bucket. It comes from the +KOTA_INFLUX_TOKEN environment variable or the tool settings and is never +written to the session log or the service report. +""" + +from __future__ import annotations + +import csv +import datetime as dt +import io +import json +import urllib.error +import urllib.parse +import urllib.request +from dataclasses import dataclass, field + +DEFAULT_URL = "https://influx.kota-app.com" +DEFAULT_ORG = "kota" +DEFAULT_BUCKET = "sensorbox" +LOOKBACK = "-30d" +FRESH_MIN = 15 # like SEEN_OK_MIN in the service system +FUTURE_TOLERANCE_MIN = 10 # newer than now + this: the box clock is ahead +TIMEOUT_S = 20 + +# Sensor groups that every box must upload: name -> measurement prefixes. +SENSOR_GROUPS = { + "AS7341 (light)": ("as7341_",), + "BME688 (air)": ("bme688",), + "SEN66 (air quality)": ("sen66",), +} +STATUS = "device_status" +MIC = "microphone" + +OK = "ok" # all sensor groups arrive +SENSORS_MISSING = "sensors_missing" # status/microphone arrive, (some) sensor data does not +SILENT = "silent" # data exists, but nothing recent +NEVER = "never" # no data for this box in the lookback window +UNAVAILABLE = "unavailable" # no token / no Internet / query failed +OUTCOMES = (OK, SENSORS_MISSING, SILENT, NEVER, UNAVAILABLE) + + +@dataclass(frozen=True) +class InfluxConfig: + token: str + url: str = DEFAULT_URL + org: str = DEFAULT_ORG + bucket: str = DEFAULT_BUCKET + + +@dataclass +class InfluxCheck: + outcome: str + summary: str + latest: dict[str, dt.datetime] = field(default_factory=dict) # measurement -> newest point + missing: list[str] = field(default_factory=list) # sensor groups without fresh data + details: list[str] = field(default_factory=list) + + +def build_query(bucket: str, mac: str) -> str: + """Newest point per measurement of one box (future times included).""" + return "\n".join([ + f"from(bucket: {json.dumps(bucket)})", + f" |> range(start: {LOOKBACK}, stop: 2100-01-01T00:00:00Z)", + f" |> filter(fn: (r) => r.device == {json.dumps(mac)})", + " |> last()", + # Drop _value first: string and float fields cannot share a table. + ' |> keep(columns: ["_measurement", "_time"])', + ' |> group(columns: ["_measurement"])', + ' |> max(column: "_time")', + " |> group()", + ]) + + +def parse_time(value: str) -> dt.datetime: + """RFC 3339 from InfluxDB; nanoseconds are cut to microseconds.""" + value = value.strip().replace("Z", "+00:00") + if "." in value: + head, rest = value.split(".", 1) + frac, sign, tz = rest.partition("+") if "+" in rest else rest.partition("-") + value = f"{head}.{frac[:6]}{sign}{tz}" + return dt.datetime.fromisoformat(value) + + +def parse_csv(text: str) -> dict[str, dt.datetime]: + """Annotated/plain CSV from /api/v2/query -> {measurement: newest time}.""" + latest: dict[str, dt.datetime] = {} + header: list[str] | None = None + for row in csv.reader(io.StringIO(text)): + if not row or not any(row): + header = None # tables are separated by an empty line + continue + if row[0].startswith("#"): + continue + if header is None: + header = row + continue + rec = dict(zip(header, row)) + m, t = rec.get("_measurement"), rec.get("_time") + if m and t: + ts = parse_time(t) + if m not in latest or ts > latest[m]: + latest[m] = ts + return latest + + +def _ago(now: dt.datetime, t: dt.datetime) -> str: + minutes = (now - t).total_seconds() / 60 + if minutes < -1: + return f"{-minutes:.0f} min in the FUTURE" + if minutes < 90: + return f"{max(minutes, 0):.0f} min ago" + if minutes < 48 * 60: + return f"{minutes / 60:.0f} h ago" + return f"{minutes / 1440:.0f} days ago" + + +def classify(latest: dict[str, dt.datetime], now: dt.datetime, fresh_min: int = FRESH_MIN) -> InfluxCheck: + def newest(prefixes: tuple[str, ...]) -> dt.datetime | None: + times = [t for m, t in latest.items() if m.startswith(prefixes)] + return max(times) if times else None + + def fresh(t: dt.datetime | None) -> bool: + return t is not None and (now - t).total_seconds() <= fresh_min * 60 + + details = [] + for label, prefixes in (("Device status", (STATUS,)), ("Microphone", (MIC,)), + *SENSOR_GROUPS.items()): + t = newest(prefixes) + details.append(f"{label}: " + (f"{t:%Y-%m-%d %H:%M} UTC ({_ago(now, t)})" if t else "no data")) + if t is not None and (t - now).total_seconds() > FUTURE_TOLERANCE_MIN * 60: + details.append(f"{label}: timestamp is in the future - the box clock is wrong") + missing = [g for g, p in SENSOR_GROUPS.items() if not fresh(newest(p))] + status_t = max(filter(None, (newest((STATUS,)), newest((MIC,)))), default=None) + sensors_t = [newest(p) for p in SENSOR_GROUPS.values()] + lagging = status_t is not None and any(t is None or (status_t - t).total_seconds() > fresh_min * 60 + for t in sensors_t) + if lagging: + details.append("Sensor data stopped (or never started) while the status still arrived") + + if not latest: + return InfluxCheck(NEVER, f"No data from this box in InfluxDB in the last {LOOKBACK[1:]}", + latest, missing, details) + if not missing: + return InfluxCheck(OK, "Sensor data arrives in InfluxDB", latest, missing, details) + if fresh(status_t): + return InfluxCheck(SENSORS_MISSING, "Status arrives in InfluxDB, sensor data does not: " + + ", ".join(missing), latest, missing, details) + if lagging: + # Offline now, but the history already shows the fault. + return InfluxCheck(SENSORS_MISSING, f"Box is offline now (last status {_ago(now, status_t)}); " + "before that its status arrived without sensor data: " + ", ".join(missing), + latest, missing, details) + return InfluxCheck(SILENT, f"No recent data in InfluxDB (nothing in the last {fresh_min} min)", + latest, missing, details) + + +def query_latest(cfg: InfluxConfig, mac: str) -> dict[str, dt.datetime]: + url = cfg.url.rstrip("/") + "/api/v2/query?" + urllib.parse.urlencode({"org": cfg.org}) + req = urllib.request.Request(url, data=build_query(cfg.bucket, mac).encode(), method="POST", headers={ + "Authorization": f"Token {cfg.token}", + "Content-Type": "application/vnd.flux", + "Accept": "application/csv", + }) + with urllib.request.urlopen(req, timeout=TIMEOUT_S) as resp: + return parse_csv(resp.read().decode("utf-8")) + + +def check_device(cfg: InfluxConfig | None, mac: str, now: dt.datetime | None = None) -> InfluxCheck: + """Blocking; run it off the UI thread. Never raises.""" + mac = "".join(c for c in (mac or "") if c.isalnum()).upper() + if cfg is None or not cfg.token: + return InfluxCheck(UNAVAILABLE, "InfluxDB access is not set up (Settings > InfluxDB access)") + if len(mac) != 12: + return InfluxCheck(UNAVAILABLE, "The box MAC address is not known yet") + try: + latest = query_latest(cfg, mac) + except urllib.error.HTTPError as exc: + why = {401: "the token was rejected", 403: "the token has no read access", + 404: "organisation or bucket not found"}.get(exc.code, f"HTTP {exc.code}") + return InfluxCheck(UNAVAILABLE, f"InfluxDB query failed: {why}") + except (urllib.error.URLError, OSError) as exc: + reason = getattr(exc, "reason", exc) + return InfluxCheck(UNAVAILABLE, f"InfluxDB not reachable from this computer ({reason})") + except (ValueError, csv.Error) as exc: + return InfluxCheck(UNAVAILABLE, f"Unexpected InfluxDB answer ({exc})") + return classify(latest, now or dt.datetime.now(dt.timezone.utc)) diff --git a/kota_tech/service/report.py b/kota_tech/service/report.py index 2702ac7..5f3f47c 100644 --- a/kota_tech/service/report.py +++ b/kota_tech/service/report.py @@ -40,6 +40,8 @@ _STATUS_BY_RULE = [ ("tech.mic.mic_faulty", HARDWARE), ("tech.mic.mic_switch_faulty", HARDWARE), ("tech.white.sd_", HARDWARE), ("matter.", CONNECTIVITY), ("net.", CONNECTIVITY), ("wifi.", CONNECTIVITY), ("influx.", CONNECTIVITY), ("ota.", CONNECTIVITY), ("tech.network.", CONNECTIVITY), + ("tech.influx.sensors_clock", HARDWARE), ("tech.influx.silent", CONNECTIVITY), + ("tech.influx.never", CONNECTIVITY), ("tech.influx.", CHECK), # firmware 1.0.16+ (KOTA: lines, status, error IDs) ("reboot.crash", SOFTWARE), ("reboot.status_oom_watchdog", SOFTWARE), ("status.oom", SOFTWARE), ("kota.low_heap", SOFTWARE), diff --git a/kota_tech/ui/guide_panel.py b/kota_tech/ui/guide_panel.py index 289d90e..e812066 100644 --- a/kota_tech/ui/guide_panel.py +++ b/kota_tech/ui/guide_panel.py @@ -167,7 +167,8 @@ class GuidePanel(QWidget): self.wait_bar.setMaximum(int(total)) self.wait_bar.setValue(int(total - v.remaining_s)) m, s = divmod(int(v.remaining_s), 60) - self.wait_label.setText(f"Watching the live log... {m}:{s:02d} left") + doing = "Checking InfluxDB" if v.step.type == "influx" else "Watching the live log" + self.wait_label.setText(f"{doing}... {m}:{s:02d} left") self.note.setText(v.note) self.note.setVisible(bool(v.note)) self.back_btn.setEnabled(v.can_back) @@ -212,9 +213,10 @@ class GuidePanel(QWidget): self.options.addWidget(b) step_type = v.step.type if v.step else None self.continue_btn.setVisible(step_type == "info") - self.skip_btn.setVisible(step_type == "wait") - self.wait_bar.setVisible(step_type == "wait") - self.wait_label.setVisible(step_type == "wait") + waits = step_type in ("wait", "influx") + self.skip_btn.setVisible(waits) + self.wait_bar.setVisible(waits) + self.wait_label.setVisible(waits) self.end_box.setVisible(is_end) if is_end: e = v.end diff --git a/kota_tech/ui/main_window.py b/kota_tech/ui/main_window.py index 7ae146c..6d146c7 100644 --- a/kota_tech/ui/main_window.py +++ b/kota_tech/ui/main_window.py @@ -1,5 +1,7 @@ from __future__ import annotations +import os +import threading from pathlib import Path from PySide6.QtCore import QCoreApplication, QObject, QSettings, Qt, QTimer, QUrl, Signal @@ -7,10 +9,14 @@ from PySide6.QtGui import QColor, QDesktopServices, QFont, QGuiApplication, QTex from PySide6.QtWidgets import ( QCheckBox, QComboBox, + QDialog, + QDialogButtonBox, QFileDialog, + QFormLayout, QHBoxLayout, QInputDialog, QLabel, + QLineEdit, QMainWindow, QMessageBox, QPlainTextEdit, @@ -32,6 +38,7 @@ from ..serialio.commands import loggable from ..serialio.manager import SerialManager, State from ..serialio.ports import PortInfo, list_serial_ports from ..matter.payload import SetupPayload, payload_from_log +from ..service import influx from ..service.report import DEFAULT_BASE, normalize_mac, report_url from .cheatsheet import cheatsheet_html from .diag_panel import DiagnosticsPanel @@ -63,6 +70,7 @@ class _Bridge(QObject): line = Signal(object) state = Signal(object, str) + influx = Signal(object) # InfluxCheck from the query thread class SerialTab(QWidget): @@ -71,6 +79,7 @@ class SerialTab(QWidget): self._bridge = _Bridge() self._bridge.line.connect(self._on_line) self._bridge.state.connect(self._on_state) + self._bridge.influx.connect(self._on_influx) self._manager = SerialManager(self._bridge.line.emit, self._bridge.state.emit) self._session = SessionLog() self._ports: list[PortInfo] = [] @@ -377,8 +386,33 @@ class SerialTab(QWidget): if action == "reset" and self._manager.state == State.CONNECTED: self._manager.reset_board() return True + if action == "influx": + cfg = self.influx_config() + mac = self._engine.mac or (self._active_port.mac if self._active_port else "") or "" + if cfg is None: + self._runner.note = "InfluxDB access is not set up: Settings > InfluxDB access." + return False + threading.Thread(target=lambda: self._bridge.influx.emit(influx.check_device(cfg, mac)), + name="influx-check", daemon=True).start() + return True return False + def influx_config(self) -> influx.InfluxConfig | None: + """Read token: KOTA_INFLUX_TOKEN, else the tool settings. None when not set up.""" + token = os.environ.get("KOTA_INFLUX_TOKEN") or str(self._settings.value("influx/token", "")) + if not token: + return None + return influx.InfluxConfig( + token=token, + url=str(self._settings.value("influx/url", influx.DEFAULT_URL)), + org=str(self._settings.value("influx/org", influx.DEFAULT_ORG)), + bucket=str(self._settings.value("influx/bucket", influx.DEFAULT_BUCKET))) + + def _on_influx(self, check: influx.InfluxCheck) -> None: + self._runner.influx_result(check.outcome, check.summary, check.details) + self._diag_dirty = True + self.guide.refresh() + def _guide_log(self, text: str) -> None: # Technician answers go into the session log and the log view. line = host_event(text) @@ -447,6 +481,7 @@ class MainWindow(QMainWindow): self.setCentralWidget(tabs) settings_menu = self.menuBar().addMenu("Settings") settings_menu.addAction("Service system address...", self._edit_service_base) + settings_menu.addAction("InfluxDB access...", self._edit_influx) def _edit_service_base(self) -> None: st = self.serial_tab @@ -459,6 +494,39 @@ class MainWindow(QMainWindow): elif ok: QMessageBox.warning(self, "Service system address", "The address must start with https://") + def _edit_influx(self) -> None: + st = self.serial_tab._settings + dlg = QDialog(self) + dlg.setWindowTitle("InfluxDB access") + form = QFormLayout(dlg) + form.addRow(QLabel("Used by the check 'Sensor data in the database'. Ask the firmware team for a " + "read-only token for the bucket.", wordWrap=True)) + url = QLineEdit(str(st.value("influx/url", influx.DEFAULT_URL))) + org = QLineEdit(str(st.value("influx/org", influx.DEFAULT_ORG))) + bucket = QLineEdit(str(st.value("influx/bucket", influx.DEFAULT_BUCKET))) + token = QLineEdit(echoMode=QLineEdit.EchoMode.Password) + token.setPlaceholderText("stored - leave empty to keep" if st.value("influx/token", "") + else "paste the read token") + clear = QCheckBox("Remove the stored token") + for label, w in (("Address", url), ("Organisation", org), ("Bucket", bucket), ("Token", token), ("", clear)): + form.addRow(label, w) + buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel) + buttons.accepted.connect(dlg.accept) + buttons.rejected.connect(dlg.reject) + form.addRow(buttons) + if dlg.exec() != QDialog.DialogCode.Accepted: + return + if not url.text().strip().startswith("https://"): + QMessageBox.warning(self, "InfluxDB access", "The address must start with https://") + return + st.setValue("influx/url", url.text().strip()) + st.setValue("influx/org", org.text().strip() or influx.DEFAULT_ORG) + st.setValue("influx/bucket", bucket.text().strip() or influx.DEFAULT_BUCKET) + if clear.isChecked(): + st.remove("influx/token") + elif token.text().strip(): + st.setValue("influx/token", token.text().strip()) + def closeEvent(self, event): # noqa: N802 (Qt naming) self.serial_tab.shutdown() super().closeEvent(event) diff --git a/tests/test_guides.py b/tests/test_guides.py index ca2dc46..af230cf 100644 --- a/tests/test_guides.py +++ b/tests/test_guides.py @@ -242,3 +242,95 @@ def test_skip_wait_and_report_contains_technician_checks(rig): assert runner.end.id == "update_slow" text = engine.report().to_text() assert "Technician checks:" in text and "Update is taking very long" in text + + +# ------------------------------------------------------------ InfluxDB check +RTC_STOPPED = [*BOOT, "I (2945) KOTA: rtc running=0 time=2000-01-01T00:00:00"] + + +@pytest.fixture +def influx_rig(rig): + engine, runner, clock, actions, board, log = rig + return engine, runner, clock, actions, board + + +def test_influx_ok_ends_healthy(influx_rig): + engine, runner, clock, actions, board = influx_rig + runner.start("influx") + assert actions == ["influx"] and runner.view().waiting + runner.influx_result("ok", "Sensor data arrives in InfluxDB", ["Device status: 1 min ago"]) + assert runner.end.id == "data_ok" + assert any("InfluxDB: Sensor data arrives" in t for t in engine.technician) + + +def test_influx_polls_until_sensors_arrive(influx_rig): + engine, runner, clock, actions, board = influx_rig + runner.start("influx") + runner.influx_result("sensors_missing", "Status arrives, sensor data does not: SEN66") + assert runner.end is None and "Checking again" in runner.view().note + clock.t += 10 + runner.tick() + assert actions == ["influx"] # not yet + clock.t += 25 + runner.tick() + assert actions == ["influx", "influx"] # polled again after poll_s + runner.tick() + assert actions == ["influx", "influx"] # no second query while one is pending + runner.influx_result("ok", "Sensor data arrives in InfluxDB") + assert runner.end.id == "data_ok" + + +def test_influx_repeated_answer_is_noted_once(influx_rig): + engine, runner, clock, actions, board = influx_rig + runner.start("influx") + for _ in range(3): + runner.influx_result("silent", "No recent data in InfluxDB") + clock.t += 31 + runner.tick() + assert sum("InfluxDB:" in t for t in engine.technician) == 1 + + +def test_influx_sensors_missing_with_stopped_clock(influx_rig): + engine, runner, clock, actions, board = influx_rig + board(*RTC_STOPPED) + runner.start("influx") + runner.influx_result("sensors_missing", "Status arrives, sensor data does not") + clock.t += 300 # past timeout_s + runner.tick() + assert runner.end.id == "sensors_clock" + f = engine.findings["tech.influx.sensors_clock"] + assert f.severity == Severity.ERROR and f.active + + +def test_influx_sensors_missing_without_log_cause(influx_rig): + engine, runner, clock, actions, board = influx_rig + runner.start("influx") + clock.t += 250 + runner.influx_result("sensors_missing", "Status arrives, sensor data does not") + assert runner.end.id == "sensors_missing" + + +def test_influx_unavailable_and_stale_results(rig): + engine, runner, clock, actions, board, log = rig + runner._on_action = lambda a: False # no token / host cannot query + runner.start("influx") + assert runner.end.id == "unavailable" + runner.influx_result("ok", "late answer") # ignored: step already left + assert runner.end.id == "unavailable" + + +def test_influx_skip_uses_last_result(influx_rig): + engine, runner, clock, actions, board = influx_rig + runner.start("influx") + runner.influx_result("silent", "No recent data in InfluxDB") + runner.proceed() + assert runner.end.id == "silent" + + +def test_quick_check_green_ends_with_influx_check(influx_rig): + engine, runner, clock, actions, board = influx_rig + board(*BOOT) + runner.start("quick") + runner.answer("GREEN") + runner.answer("0") # heartbeat blinking + assert runner.guide.id == "influx" and actions == ["influx"] diff --git a/tests/test_influx.py b/tests/test_influx.py new file mode 100644 index 0000000..32029c2 --- /dev/null +++ b/tests/test_influx.py @@ -0,0 +1,142 @@ +"""InfluxDB check: query text, CSV parsing, classification, failures (no network).""" + +import datetime as dt +import urllib.error + +from kota_tech.diag.guides import INFLUX_OUTCOMES +from kota_tech.service import influx + +NOW = dt.datetime(2026, 9, 30, 12, 0, tzinfo=dt.timezone.utc) +UTC = dt.timezone.utc + +# Real answer shape of /api/v2/query (Accept: application/csv). +CSV = ( + ",result,table,_measurement,_time\r\n" + ",_result,0,as7341_adc,2026-09-30T11:55:01Z\r\n" + ",_result,0,bme688,2026-09-30T11:55:02.123456789Z\r\n" + ",_result,0,device_status,2026-09-30T11:58:00Z\r\n" + ",_result,0,microphone,2026-09-30T11:58:10Z\r\n" + ",_result,0,sen66,2026-09-30T11:56:00Z\r\n" + "\r\n" +) + + +def _t(minutes_ago): + return NOW - dt.timedelta(minutes=minutes_ago) + + +def test_outcomes_match_guide_runner(): + assert influx.OUTCOMES == INFLUX_OUTCOMES + + +def test_query_is_for_one_box_and_keeps_only_time(): + q = influx.build_query("sensorbox", "A4CB8FC9473C") + assert 'from(bucket: "sensorbox")' in q and 'r.device == "A4CB8FC9473C"' in q + # _value must be dropped before grouping (string and float fields clash -> HTTP 400) + assert q.index("keep(") < q.index("group(columns") + + +def test_parse_csv_newest_per_measurement(): + latest = influx.parse_csv(CSV) + assert latest["bme688"] == dt.datetime(2026, 9, 30, 11, 55, 2, 123456, tzinfo=UTC) + assert set(latest) == {"as7341_adc", "bme688", "device_status", "microphone", "sen66"} + assert influx.parse_csv("") == {} + + +def test_all_sensors_fresh_is_ok(): + c = influx.classify(influx.parse_csv(CSV), NOW) + assert c.outcome == influx.OK and not c.missing + + +def test_status_without_sensors_is_sensors_missing(): + # box A4CB8FC9473C: RTC stopped, only status and microphone ever arrived + c = influx.classify({"device_status": _t(1), "microphone": _t(1)}, NOW) + assert c.outcome == influx.SENSORS_MISSING + assert c.missing == list(influx.SENSOR_GROUPS) + assert any("never started" in d for d in c.details) + + +def test_one_sensor_missing(): + latest = {"device_status": _t(1), "as7341_adc": _t(2), "bme688": _t(2), "sen66": _t(300)} + c = influx.classify(latest, NOW) + assert c.outcome == influx.SENSORS_MISSING and c.missing == ["SEN66 (air quality)"] + + +def test_offline_box_whose_sensors_stopped_before_status(): + # box A4CB8FC946F8: status 29 h ago, sensors 21 days ago + latest = {"device_status": _t(29 * 60), "microphone": _t(29 * 60), + "as7341_adc": _t(21 * 1440), "bme688": _t(21 * 1440), "sen66": _t(21 * 1440)} + c = influx.classify(latest, NOW) + assert c.outcome == influx.SENSORS_MISSING and "offline now" in c.summary + assert any("stopped" in d for d in c.details) + assert any("21 days ago" in d for d in c.details) + + +def test_offline_box_with_complete_history_is_silent(): + # box A4CB8FC739EC: everything stopped together 11 days ago + latest = {"device_status": _t(11 * 1440), "microphone": _t(11 * 1440), + "as7341_adc": _t(11 * 1440 + 3), "bme688": _t(11 * 1440 + 3), "sen66": _t(11 * 1440 + 2)} + c = influx.classify(latest, NOW) + assert c.outcome == influx.SILENT + assert not any("stopped" in d for d in c.details) + + +def test_no_data_is_never(): + assert influx.classify({}, NOW).outcome == influx.NEVER + + +def test_future_timestamps_are_flagged(): + latest = {"device_status": _t(1), "microphone": _t(1), "as7341_adc": _t(-120), "bme688": _t(-120), + "sen66": _t(-120)} + c = influx.classify(latest, NOW) + assert any("future" in d for d in c.details) + + +def test_check_device_without_token_or_mac(): + assert influx.check_device(None, "A4CB8FC9473C").outcome == influx.UNAVAILABLE + cfg = influx.InfluxConfig("t") + assert influx.check_device(cfg, "").outcome == influx.UNAVAILABLE + + +def test_check_device_errors_never_raise(monkeypatch): + cfg = influx.InfluxConfig("secret-token") + + def rejected(*_a, **_k): + raise urllib.error.HTTPError("u", 401, "Unauthorized", {}, None) + + monkeypatch.setattr(influx.urllib.request, "urlopen", rejected) + c = influx.check_device(cfg, "a4:cb:8f:c9:47:3c") + assert c.outcome == influx.UNAVAILABLE and "rejected" in c.summary + assert "secret-token" not in c.summary + + def offline(*_a, **_k): + raise urllib.error.URLError("nodename nor servname provided") + + monkeypatch.setattr(influx.urllib.request, "urlopen", offline) + assert "not reachable" in influx.check_device(cfg, "A4CB8FC9473C").summary + + +def test_check_device_sends_token_header_and_normalized_mac(monkeypatch): + seen = {} + + class Resp: + def __enter__(self): + return self + + def __exit__(self, *a): + return False + + def read(self): + return CSV.encode() + + def fake_urlopen(req, timeout): + seen["req"] = req + return Resp() + + monkeypatch.setattr(influx.urllib.request, "urlopen", fake_urlopen) + c = influx.check_device(influx.InfluxConfig("tok"), "a4:cb:8f:c9:47:3c", now=NOW) + req = seen["req"] + assert c.outcome == influx.OK + assert req.get_header("Authorization") == "Token tok" + assert "tok" not in req.full_url and req.full_url.endswith("/api/v2/query?org=kota") + assert b'"A4CB8FC9473C"' in req.data diff --git a/tests/test_ui.py b/tests/test_ui.py index 0779e9d..3564ee1 100644 --- a/tests/test_ui.py +++ b/tests/test_ui.py @@ -15,5 +15,7 @@ def test_main_window_builds_with_all_tabs(): assert [tabs.tabText(i) for i in range(tabs.count())] == \ ["Quick start", "Serial monitor", "Flash firmware", "Wi-Fi (USB)", "SD card"] assert not w.wifi_tab.write_btn.isEnabled() # nothing connected, nothing typed + settings = [a.text() for m in w.menuBar().actions() for a in m.menu().actions()] + assert "InfluxDB access..." in settings w.serial_tab.shutdown() app.processEvents() From bb933ff748cf0c1969de7d328956b3f0bb9cb6e4 Mon Sep 17 00:00:00 2001 From: Krzyszur Date: Thu, 1 Oct 2026 00:02:18 +0200 Subject: [PATCH 3/3] Serial monitor redesign: Test box button, InfluxDB row in the checklist - Test box: restart + start-up capture + online InfluxDB check (data newer than the restart), with a status strip; checklist and findings are the main view, live log / guided troubleshooting / box details are tabs, rarely used actions in a More menu - light palette on all systems (macOS dark mode made the colours unreadable) - new rule influx.invalid_value: -inf from a silent microphone makes InfluxDB reject every upload (HTTP 400); guide end names it - exclusive serial port on macOS/Linux: two tool windows no longer split the log between them - InfluxDB check: `since` filter, neutral wording when nothing new arrives Co-Authored-By: Claude Opus 5.5 --- docs/CHANGES-v0.10.md | 15 ++ kota_tech/__main__.py | 29 ++++ kota_tech/diag/engine.py | 2 +- kota_tech/diag/guides.toml | 20 ++- kota_tech/diag/rules.toml | 16 ++- kota_tech/serialio/manager.py | 17 ++- kota_tech/service/influx.py | 20 ++- kota_tech/service/report.py | 4 +- kota_tech/ui/diag_panel.py | 74 +++++++--- kota_tech/ui/main_window.py | 251 +++++++++++++++++++++++++++------- tests/test_guides.py | 12 ++ tests/test_influx.py | 14 +- tests/test_ui.py | 31 +++++ 13 files changed, 422 insertions(+), 83 deletions(-) diff --git a/docs/CHANGES-v0.10.md b/docs/CHANGES-v0.10.md index 501fce4..78906b9 100644 --- a/docs/CHANGES-v0.10.md +++ b/docs/CHANGES-v0.10.md @@ -24,3 +24,18 @@ The token is never written to the session log or the service report. - macOS: Connect no longer restarts the box (pyserial dropped DTR before RTS, passing through the USB-Serial-JTAG reset state). Windows unchanged. +- **Serial monitor redesigned.** One green **Test box** button: restarts the box, records the start-up and + then checks InfluxDB online (data must be newer than the restart), about 4 minutes. A status strip shows + what the test is doing and its result. The test checklist (start-up steps + the new row + "Sensor data in InfluxDB (online check)") and the findings are the main view; the live log, guided + troubleshooting and box details (LED, firmware, self-report) are tabs on the right. Rarely used actions + moved to **More**. +- Light colour scheme on every system: with macOS dark mode the status colours were unreadable. + Larger log font on macOS. +- New finding **Box sends an invalid value (-inf/nan) - InfluxDB rejects all its data**: a silent microphone + makes the firmware upload `dbfs=-inf,db=-inf`; InfluxDB then refuses the whole upload (HTTP 400), so neither + the status nor the sensor data arrive (box A4:CB:8F:C9:47:3C). The InfluxDB check names it as the cause. +- The serial port is opened exclusively on macOS/Linux: a second tool window no longer steals half of the + log lines; it reports that the port is in use. +- Start-up step "Data uploaded to InfluxDB" renamed "Upload accepted by InfluxDB (box log)" - it comes + from the box's own log, the online row checks the database. diff --git a/kota_tech/__main__.py b/kota_tech/__main__.py index 6b93d27..1ee0f58 100644 --- a/kota_tech/__main__.py +++ b/kota_tech/__main__.py @@ -1,13 +1,42 @@ import sys +from PySide6.QtGui import QColor, QPalette from PySide6.QtWidgets import QApplication from .ui.main_window import MainWindow +def light_palette() -> QPalette: + """The same light look on every system. All status colours in the tool are + chosen for a light background; with macOS dark mode they were unreadable.""" + p = QPalette() + roles = { + QPalette.ColorRole.Window: "#f4f5f7", + QPalette.ColorRole.WindowText: "#1d1d1f", + QPalette.ColorRole.Base: "#ffffff", + QPalette.ColorRole.AlternateBase: "#f0f2f5", + QPalette.ColorRole.Text: "#1d1d1f", + QPalette.ColorRole.Button: "#e9ebef", + QPalette.ColorRole.ButtonText: "#1d1d1f", + QPalette.ColorRole.ToolTipBase: "#ffffe8", + QPalette.ColorRole.ToolTipText: "#1d1d1f", + QPalette.ColorRole.PlaceholderText: "#8a8a8a", + QPalette.ColorRole.Highlight: "#2e6da4", + QPalette.ColorRole.HighlightedText: "#ffffff", + QPalette.ColorRole.Link: "#1f5fa8", + QPalette.ColorRole.BrightText: "#ffffff", + } + for role, colour in roles.items(): + p.setColor(role, QColor(colour)) + for role in (QPalette.ColorRole.WindowText, QPalette.ColorRole.Text, QPalette.ColorRole.ButtonText): + p.setColor(QPalette.ColorGroup.Disabled, role, QColor("#9a9a9a")) + return p + + def main() -> int: app = QApplication(sys.argv) app.setStyle("Fusion") + app.setPalette(light_palette()) win = MainWindow() win.show() return app.exec() diff --git a/kota_tech/diag/engine.py b/kota_tech/diag/engine.py index d06c2af..d2c5229 100644 --- a/kota_tech/diag/engine.py +++ b/kota_tech/diag/engine.py @@ -73,7 +73,7 @@ MILESTONES = [ ("wifi_connected", "Connected to Wi-Fi", False), ("time_synced", "Clock set from the Internet", False), ("clock_verified", "Clock keeps time (RTC verified)", True), - ("data_uploaded", "Data uploaded to InfluxDB", False), + ("data_uploaded", "Upload accepted by InfluxDB (box log)", False), ("ota_registered", "Registered for firmware updates", False), ("ota_checked", "Checked for firmware updates", False), ("ota_update_started", "Firmware update started", True), diff --git a/kota_tech/diag/guides.toml b/kota_tech/diag/guides.toml index a4a0a23..ef0b61a 100644 --- a/kota_tech/diag/guides.toml +++ b/kota_tech/diag/guides.toml @@ -750,12 +750,18 @@ type = "influx" text = "Checking in InfluxDB that this box's data arrives: device status, microphone and the sensors (AS7341, BME688, SEN66). Keep the box switched on and online. The tool checks again every 30 s for up to 4 minutes (the air sensor needs about 2 minutes after a restart). The laptop needs Internet for this check." timeout_s = 240 poll_s = 30 -outcomes = { ok = "end:data_ok", sensors_missing = "why", silent = "end:silent", never = "end:never", unavailable = "end:unavailable" } +outcomes = { ok = "end:data_ok", sensors_missing = "why", silent = "why_silent", never = "why_silent", unavailable = "end:unavailable" } + +[[guide.step]] +id = "why_silent" +type = "route" +routes = { "influx.invalid_value" = "end:invalid_value" } +default = "end:silent" [[guide.step]] id = "why" type = "route" -routes = { "kota.rtc_stopped" = "end:sensors_clock", "rtc.clock_not_running" = "end:sensors_clock", "kota.rtc_not_ticking" = "end:sensors_clock", "kota.time_invalid" = "end:sensors_clock", "kota.rtc_read_failed" = "guide:rtc_i2c", "rtc.init_failed" = "guide:rtc_i2c", "sensor.init_failed" = "guide:sensors", "kota.sensor_missing" = "guide:sensors" } +routes = { "influx.invalid_value" = "end:invalid_value", "kota.rtc_stopped" = "end:sensors_clock", "rtc.clock_not_running" = "end:sensors_clock", "kota.rtc_not_ticking" = "end:sensors_clock", "kota.time_invalid" = "end:sensors_clock", "kota.rtc_read_failed" = "guide:rtc_i2c", "rtc.init_failed" = "guide:rtc_i2c", "sensor.init_failed" = "guide:sensors", "kota.sensor_missing" = "guide:sensors" } default = "end:sensors_missing" [[guide.end]] @@ -765,6 +771,16 @@ title = "Box is healthy and its sensor data reaches InfluxDB" text = "Status, microphone and all sensor readings of this box arrived in InfluxDB in the last 15 minutes." actions = [] +[[guide.end]] +id = "invalid_value" +severity = "critical" +title = "InfluxDB rejects every upload of this box (invalid value -inf)" +text = "The box is online and uploads, but one measurement carries -inf (the microphone records pure silence). InfluxDB refuses the whole upload with HTTP 400, so neither the status nor the sensor data arrive." +actions = [ + "Run the Microphone check: a working microphone (and its switch ON) avoids the -inf value.", + "Save the session log and send it to the firmware team: the firmware must skip invalid values.", +] + [[guide.end]] id = "sensors_clock" severity = "error" diff --git a/kota_tech/diag/rules.toml b/kota_tech/diag/rules.toml index 8bfb504..ec3c95b 100644 --- a/kota_tech/diag/rules.toml +++ b/kota_tech/diag/rules.toml @@ -280,6 +280,20 @@ severity = "warning" title = "InfluxDB refused some measurements (HTTP 400)" meaning = "A measurement was malformed and dropped (firmware issue, not a hardware fault)." actions = ["Save the session log and send it to the firmware team."] +explained_by = ["influx.invalid_value"] + +[[rule]] +id = "influx.invalid_value" +# Line protocol printed by SENSOR_GATHERER / INFLUX: "-inf"/"nan" are not valid +# numbers, and one bad line makes InfluxDB reject the whole upload. +pattern = '^(?:.*format: )?(?P[a-z0-9_]+),device=\S+ \S*=-?(?:inf|nan)\b' +severity = "critical" +title = "Box sends an invalid value (-inf/nan) - InfluxDB rejects all its data" +meaning = "A measurement contains -inf or nan (the microphone: pure silence gives -inf dB). InfluxDB refuses the whole upload with HTTP 400, so status and sensor data from this box are lost too. Firmware bug; a silent microphone triggers it." +actions = [ + "Check the microphone (Microphone check): a working microphone avoids the -inf value.", + "Save the session log and send it to the firmware team: invalid values must be skipped, not uploaded.", +] [[rule]] id = "influx.env_missing" @@ -713,7 +727,7 @@ actions = [ "Check the network has Internet (open a website on a phone on the same Wi-Fi).", "Check INFLUX_URL / INFLUX_TOKEN in ENV.TXT (re-provision the SD card).", ] -explained_by = ["kota.time_invalid", "influx.auth", "influx.not_found", "status.conn.1", "net.dns_fail", "net.tls_fail", "influx.server_error"] +explained_by = ["influx.invalid_value", "kota.time_invalid", "influx.auth", "influx.not_found", "status.conn.1", "net.dns_fail", "net.tls_fail", "influx.server_error"] [[rule]] id = "kota.low_heap" diff --git a/kota_tech/serialio/manager.py b/kota_tech/serialio/manager.py index 18692a9..a17b20a 100644 --- a/kota_tech/serialio/manager.py +++ b/kota_tech/serialio/manager.py @@ -51,6 +51,7 @@ class SerialManager: self._thread: threading.Thread | None = None self._stop = threading.Event() self._target: _Target | None = None + self._open_error = "" self.state = State.DISCONNECTED # ---- public API (any thread) ------------------------------------- @@ -89,9 +90,14 @@ class SerialManager: info = find_port(self._target.serial_number, self._target.device) if info is None: return None + posix = sys.platform != "win32" # serial_for_url also accepts test URLs such as "loop://". + # exclusive: a second tool window must not read the same port (on + # macOS/Linux both would get half of the lines). COM ports on Windows + # are always exclusive. ser = serial.serial_for_url( - info.device, baudrate=self._baud, timeout=READ_TIMEOUT_S, do_not_open=True + info.device, baudrate=self._baud, timeout=READ_TIMEOUT_S, do_not_open=True, + **({"exclusive": True} if posix else {}), ) # On USB-Serial-JTAG, RTS=1/DTR=0 holds the chip in reset and DTR=1 # during reset selects download mode. @@ -100,7 +106,6 @@ class SerialManager: # macOS/Linux: the OS asserts both lines on open and pyserial then # writes DTR before RTS, passing through RTS=1/DTR=0 and resetting # the box on every connect. Drop RTS first, then DTR. - posix = sys.platform != "win32" if not posix: ser.dtr = False ser.rts = False @@ -108,8 +113,12 @@ class SerialManager: ser.open() if posix: ser.dtr = False - except (serial.SerialException, OSError): + except (serial.SerialException, OSError) as exc: + busy = "exclusive" in str(exc).lower() or "busy" in str(exc).lower() or "access" in str(exc).lower() + self._open_error = ("The port is used by another program (another Technician Tool window?)" + if busy else "") return None + self._open_error = "" self._target.device = info.device # COM number / node may change return ser @@ -143,7 +152,7 @@ class SerialManager: ser = self._open() if ser is None: if not announced_wait: - self._set_state(State.WAITING, "Plug in / power on the sensorbox") + self._set_state(State.WAITING, self._open_error or "Plug in / power on the sensorbox") announced_wait = True self._drain_cmds(None) time.sleep(REOPEN_POLL_S) diff --git a/kota_tech/service/influx.py b/kota_tech/service/influx.py index 0cc18f9..6eb966f 100644 --- a/kota_tech/service/influx.py +++ b/kota_tech/service/influx.py @@ -28,6 +28,7 @@ DEFAULT_BUCKET = "sensorbox" LOOKBACK = "-30d" FRESH_MIN = 15 # like SEEN_OK_MIN in the service system FUTURE_TOLERANCE_MIN = 10 # newer than now + this: the box clock is ahead +SINCE_SLACK_S = 60 # clock difference box / laptop when counting "since the test started" TIMEOUT_S = 20 # Sensor groups that every box must upload: name -> measurement prefixes. @@ -122,13 +123,17 @@ def _ago(now: dt.datetime, t: dt.datetime) -> str: return f"{minutes / 1440:.0f} days ago" -def classify(latest: dict[str, dt.datetime], now: dt.datetime, fresh_min: int = FRESH_MIN) -> InfluxCheck: +def classify(latest: dict[str, dt.datetime], now: dt.datetime, fresh_min: int = FRESH_MIN, + since: dt.datetime | None = None) -> InfluxCheck: + """`since`: only data newer than this counts (the box was restarted then).""" def newest(prefixes: tuple[str, ...]) -> dt.datetime | None: times = [t for m, t in latest.items() if m.startswith(prefixes)] return max(times) if times else None def fresh(t: dt.datetime | None) -> bool: - return t is not None and (now - t).total_seconds() <= fresh_min * 60 + if t is None or (now - t).total_seconds() > fresh_min * 60: + return False + return since is None or (since - t).total_seconds() <= SINCE_SLACK_S details = [] for label, prefixes in (("Device status", (STATUS,)), ("Microphone", (MIC,)), @@ -155,9 +160,11 @@ def classify(latest: dict[str, dt.datetime], now: dt.datetime, fresh_min: int = + ", ".join(missing), latest, missing, details) if lagging: # Offline now, but the history already shows the fault. - return InfluxCheck(SENSORS_MISSING, f"Box is offline now (last status {_ago(now, status_t)}); " - "before that its status arrived without sensor data: " + ", ".join(missing), + return InfluxCheck(SENSORS_MISSING, f"Nothing new in InfluxDB (last status {_ago(now, status_t)}); " + "before that the status arrived without sensor data: " + ", ".join(missing), latest, missing, details) + if since is not None: + return InfluxCheck(SILENT, "No new data in InfluxDB since the test started", latest, missing, details) return InfluxCheck(SILENT, f"No recent data in InfluxDB (nothing in the last {fresh_min} min)", latest, missing, details) @@ -173,7 +180,8 @@ def query_latest(cfg: InfluxConfig, mac: str) -> dict[str, dt.datetime]: return parse_csv(resp.read().decode("utf-8")) -def check_device(cfg: InfluxConfig | None, mac: str, now: dt.datetime | None = None) -> InfluxCheck: +def check_device(cfg: InfluxConfig | None, mac: str, now: dt.datetime | None = None, + since: dt.datetime | None = None) -> InfluxCheck: """Blocking; run it off the UI thread. Never raises.""" mac = "".join(c for c in (mac or "") if c.isalnum()).upper() if cfg is None or not cfg.token: @@ -191,4 +199,4 @@ def check_device(cfg: InfluxConfig | None, mac: str, now: dt.datetime | None = N return InfluxCheck(UNAVAILABLE, f"InfluxDB not reachable from this computer ({reason})") except (ValueError, csv.Error) as exc: return InfluxCheck(UNAVAILABLE, f"Unexpected InfluxDB answer ({exc})") - return classify(latest, now or dt.datetime.now(dt.timezone.utc)) + return classify(latest, now or dt.datetime.now(dt.timezone.utc), since=since) diff --git a/kota_tech/service/report.py b/kota_tech/service/report.py index 5f3f47c..e9ba332 100644 --- a/kota_tech/service/report.py +++ b/kota_tech/service/report.py @@ -33,14 +33,14 @@ CONNECTIVITY = "Problem z łącznością" _STATUS_BY_RULE = [ ("reboot.brownout", POWER), ("reboot.power", POWER), ("tech.power.", POWER), ("sys.crash", SOFTWARE), ("reboot.watchdog", SOFTWARE), ("sys.out_of_resources", SOFTWARE), - ("influx.bad_request", SOFTWARE), ("ota.selfcheck_failed", SOFTWARE), ("tech.quick.hung", SOFTWARE), + ("influx.bad_request", SOFTWARE), ("influx.invalid_value", SOFTWARE), ("ota.selfcheck_failed", SOFTWARE), ("tech.quick.hung", SOFTWARE), ("rtc.init_failed", HARDWARE), ("rtc.lost_after_sync", HARDWARE), ("i2c.", HARDWARE), ("sensor.", HARDWARE), ("sd.", HARDWARE), ("sen66.", HARDWARE), ("bme688.", HARDWARE), ("as7341.", HARDWARE), ("mic.read_fail", HARDWARE), ("mic.silent", HARDWARE), ("tech.rtc_i2c.", HARDWARE), ("tech.sensors.", HARDWARE), ("tech.mic.mic_faulty", HARDWARE), ("tech.mic.mic_switch_faulty", HARDWARE), ("tech.white.sd_", HARDWARE), ("matter.", CONNECTIVITY), ("net.", CONNECTIVITY), ("wifi.", CONNECTIVITY), ("influx.", CONNECTIVITY), ("ota.", CONNECTIVITY), ("tech.network.", CONNECTIVITY), - ("tech.influx.sensors_clock", HARDWARE), ("tech.influx.silent", CONNECTIVITY), + ("tech.influx.invalid_value", SOFTWARE), ("tech.influx.sensors_clock", HARDWARE), ("tech.influx.silent", CONNECTIVITY), ("tech.influx.never", CONNECTIVITY), ("tech.influx.", CHECK), # firmware 1.0.16+ (KOTA: lines, status, error IDs) ("reboot.crash", SOFTWARE), ("reboot.status_oom_watchdog", SOFTWARE), ("status.oom", SOFTWARE), diff --git a/kota_tech/ui/diag_panel.py b/kota_tech/ui/diag_panel.py index 39116e7..12ea5b6 100644 --- a/kota_tech/ui/diag_panel.py +++ b/kota_tech/ui/diag_panel.py @@ -1,9 +1,11 @@ """Diagnostics side panel: renders a diag.engine.Report. -Layout: verdict banner, expected LED (colour + pattern + meaning when the -box reports it), firmware, the box's own self-report (KOTA lines), start-up -milestones, a findings tree (root causes; their consequences as children; -titles only) and a wrapped detail pane for the selected finding. +Layout: verdict banner, the test checklist (start-up milestones plus the +online InfluxDB check), a findings tree (root causes; their consequences as +children; titles only) and a wrapped detail pane for the selected finding. +`details` is a separate widget for the host to place: expected LED (colour + +pattern + meaning when the box reports it), firmware and the box's own +self-report (KOTA lines). """ from __future__ import annotations @@ -17,6 +19,7 @@ from PySide6.QtWidgets import ( QListWidget, QListWidgetItem, QPushButton, + QScrollArea, QSizePolicy, QSplitter, QTextBrowser, @@ -43,13 +46,19 @@ BANNER = { } _KEY = Qt.ItemDataRole.UserRole BOX_STATE = {"ok": ("#1b7a33", "✔"), "warn": ("#c77c02", "!"), "bad": ("#b03a2e", "✖"), "info": ("#2e6da4", "i")} +# Extra checklist rows (e.g. the InfluxDB check): state -> (mark, colour) +ROW_STATE = {"ok": ("✔", "#1b7a33"), "bad": ("✖", "#b03a2e"), "warn": ("!", "#a86400"), + "running": ("…", "#2e6da4"), "pending": ("○", "#6b6b6b"), "off": ("–", "#6b6b6b"), + "note": ("", "#444444")} def _heading(text: str) -> QLabel: lbl = QLabel(text) f = lbl.font() f.setBold(True) + f.setPointSize(f.pointSize() + 1) lbl.setFont(f) + lbl.setContentsMargins(0, 6, 0, 2) return lbl @@ -87,7 +96,14 @@ class DiagnosticsPanel(QWidget): self.milestones = QListWidget() self.milestones.setFrameShape(QFrame.Shape.NoFrame) self.milestones.setSelectionMode(QListWidget.SelectionMode.NoSelection) + self.milestones.setFocusPolicy(Qt.FocusPolicy.NoFocus) + self.milestones.setWordWrap(True) + self.milestones.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff) self.milestones.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Maximum) + self.milestones.setStyleSheet("QListWidget { background: transparent; } QListWidget::item { padding: 2px; }") + mf = self.milestones.font() + mf.setPointSize(mf.pointSize() + 1) + self.milestones.setFont(mf) self.tree = QTreeWidget() self.tree.setHeaderHidden(True) @@ -101,22 +117,31 @@ class DiagnosticsPanel(QWidget): findings.setSizes([220, 260]) lay = QVBoxLayout(self) - lay.setContentsMargins(4, 0, 0, 0) + lay.setContentsMargins(4, 0, 4, 0) lay.addWidget(self.verdict) - lay.addWidget(_heading("Status LED should be")) - lay.addLayout(led_row) - lay.addWidget(_heading("Firmware")) - lay.addWidget(self.firmware) - self.qr_btn = QPushButton("Matter pairing QR code...") - self.qr_btn.setToolTip("Show the box's Matter QR code on screen to scan with the phone") - lay.addWidget(self.qr_btn, 0, Qt.AlignmentFlag.AlignLeft) - lay.addWidget(self.box_title) - lay.addWidget(self.box) - lay.addWidget(_heading("Start-up progress (current boot)")) + lay.addWidget(_heading("Test checklist (current boot)")) lay.addWidget(self.milestones) lay.addWidget(_heading("Findings - root causes first; click one for details")) lay.addWidget(findings, 1) + # Box details: placed by the host (a separate tab). + inner = QWidget() + dl = QVBoxLayout(inner) + dl.addWidget(_heading("Status LED should be")) + dl.addLayout(led_row) + dl.addWidget(_heading("Firmware")) + dl.addWidget(self.firmware) + self.qr_btn = QPushButton("Matter pairing QR code...") + self.qr_btn.setToolTip("Show the box's Matter QR code on screen to scan with the phone") + dl.addWidget(self.qr_btn, 0, Qt.AlignmentFlag.AlignLeft) + dl.addWidget(self.box_title) + dl.addWidget(self.box) + dl.addStretch(1) + self.details = QScrollArea() + self.details.setWidgetResizable(True) + self.details.setFrameShape(QFrame.Shape.NoFrame) + self.details.setWidget(inner) + self._findings: dict[str, Finding] = {} self._selected: str | None = None # key -> expanded, chosen by the user; survives the rebuild on refresh. @@ -126,7 +151,8 @@ class DiagnosticsPanel(QWidget): self.tree.itemExpanded.connect(lambda it: self._remember(it, True)) # ------------------------------------------------------------------ - def show_report(self, r: Report) -> None: + def show_report(self, r: Report, extra_rows: list[tuple[str, str]] = ()) -> None: + """extra_rows: (state, text) appended to the checklist, state in ROW_STATE.""" bg, fg = BANNER.get(r.verdict_severity, BANNER[Severity.WARNING]) if r.lines == 0: bg, fg = "#e6e6e6", "#333333" @@ -161,10 +187,20 @@ class DiagnosticsPanel(QWidget): done = t is not None it = QListWidgetItem(("✔ " if done else "○ ") + label + (f" ({t / 1000:.1f} s)" if done else "")) - it.setForeground(QBrush(QColor("#1b7a33" if done else "#8a8a8a"))) + it.setForeground(QBrush(QColor("#1b7a33" if done else "#6b6b6b"))) self.milestones.addItem(it) - rows = min(max(self.milestones.count(), 1), 15) - self.milestones.setFixedHeight(rows * max(self.milestones.sizeHintForRow(0), 16) + 6) + for state, text in extra_rows: + mark, colour = ROW_STATE[state] + it = QListWidgetItem(f"{mark} {text}" if mark else text) + it.setForeground(QBrush(QColor(colour))) + if state != "note": + f = it.font() + f.setBold(True) + it.setFont(f) + it.setToolTip(text) + self.milestones.addItem(it) + height = sum(max(self.milestones.sizeHintForRow(i), 16) for i in range(self.milestones.count())) + self.milestones.setFixedHeight(min(max(height, 16), 560) + 6) self._fill_tree(r) diff --git a/kota_tech/ui/main_window.py b/kota_tech/ui/main_window.py index 6d146c7..88bbadd 100644 --- a/kota_tech/ui/main_window.py +++ b/kota_tech/ui/main_window.py @@ -1,7 +1,10 @@ from __future__ import annotations +import datetime as dt import os +import sys import threading +import time from pathlib import Path from PySide6.QtCore import QCoreApplication, QObject, QSettings, Qt, QTimer, QUrl, Signal @@ -18,12 +21,14 @@ from PySide6.QtWidgets import ( QLabel, QLineEdit, QMainWindow, + QMenu, QMessageBox, QPlainTextEdit, QPushButton, QSplitter, QTabWidget, QTextBrowser, + QToolButton, QVBoxLayout, QWidget, ) @@ -49,6 +54,13 @@ from .sd_tab import SdTab from .wifi_tab import WifiTab MAX_LINES = 20000 +TEST_INFLUX_AFTER_S = 30 # Test box: start the online check this long after the restart +INFLUX_ROW = "Sensor data in InfluxDB (online check)" +# test status strip: (background, text colour) +STRIP = {"idle": ("#eef1f4", "#333333"), "running": ("#dde9f7", "#123a63"), "ok": ("#d8f0dd", "#1b5e2a"), + "info": ("#dde9f7", "#123a63"), "warning": ("#fdebc8", "#6b4400"), "error": ("#f9dedc", "#8a2019"), + "critical": ("#f6d5d1", "#7b1e14")} +CLOUD_STATE = {"ok": "ok", "sensors_missing": "bad", "silent": "warn", "never": "warn", "unavailable": "off"} # "KOTA" = the firmware's structured diagnostic lines (1.0.16+) plus errors. LEVEL_FILTERS = {"All lines": None, "KOTA diagnostics + errors": "KOTA", "Warnings + errors": {"W", "E"}, "Errors only": {"E"}} @@ -65,6 +77,10 @@ COLORS = { } +def _esc(s: str) -> str: + return s.replace("&", "&").replace("<", "<").replace(">", ">") + + class _Bridge(QObject): """Marshals SerialManager callbacks (reader thread) onto the UI thread.""" @@ -90,82 +106,127 @@ class SerialTab(QWidget): self._line_listeners: list = [] # other tabs following the live log (Wi-Fi over USB) # --- controls - self.port_combo = QComboBox(minimumWidth=320) - self.all_ports = QCheckBox("Show all ports") - self.refresh_btn = QPushButton("Refresh") + self._settings = QSettings("KOTA", "TechnicianTool") + self.port_combo = QComboBox(minimumWidth=360) + self.refresh_btn = QPushButton("↻") + self.refresh_btn.setToolTip("Look for boxes again") + self.refresh_btn.setFixedWidth(40) + self.test_btn = QPushButton("▶ Test box") + self.test_btn.setToolTip("Restart the box, check its start-up and whether its sensor data reaches " + "InfluxDB (about 4 minutes)") + self.test_btn.setMinimumHeight(38) + self.test_btn.setStyleSheet( + "QPushButton { background:#1f7a3a; color:white; font-weight:bold; font-size:15px; " + "padding:4px 22px; border-radius:6px; border:none; }" + "QPushButton:hover { background:#25904a; } QPushButton:disabled { background:#9dbfa6; }") self.connect_btn = QPushButton("Connect") - self.reset_btn = QPushButton("Reset && capture") - self.reset_btn.setToolTip("Reboot the sensorbox and record the log from the first boot line") + self.connect_btn.setMinimumHeight(32) + + # Less frequent actions live in the "More" menu. + self.more_btn = QToolButton(text="More ▾") + self.more_btn.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup) + self.more_btn.setMinimumHeight(32) + menu = QMenu(self.more_btn) + self.reset_btn = menu.addAction("Reset && capture (restart the box, no online check)") + menu.addSeparator() + self.service_btn = menu.addAction("Service report...") + self.service_btn.setToolTip("Open this box's page in the KOTA service system with the diagnosis " + "filled in; check it and press Save there") + self.copy_btn = menu.addAction("Copy report") + self.save_btn = menu.addAction("Save log view as...") + self.folder_btn = menu.addAction("Open logs folder") + self.analyze_btn = menu.addAction("Analyze log file...") + menu.addSeparator() + self.auto_service = menu.addAction("Open service report on disconnect") + self.auto_service.setCheckable(True) + self.auto_service.setChecked(self._settings.value("service/auto", False, type=bool)) + self.auto_service.toggled.connect(lambda on: self._settings.setValue("service/auto", on)) + self.all_ports = menu.addAction("Show all serial ports") + self.all_ports.setCheckable(True) + self.more_btn.setMenu(menu) + self._active_port: PortInfo | None = None + + top = QHBoxLayout() + box_lbl = QLabel("Box:") + for w in (box_lbl, self.port_combo, self.refresh_btn): + top.addWidget(w) + top.addSpacing(12) + top.addWidget(self.test_btn) + top.addWidget(self.connect_btn) + top.addStretch(1) + top.addWidget(self.more_btn) + + # Test status strip (what the test is doing / its result). + self.test_status = QLabel(wordWrap=True) + self.test_status.setMargin(8) + tf = self.test_status.font() + tf.setPointSize(tf.pointSize() + 1) + self.test_status.setFont(tf) + + # --- live log (a tab on the right) self.filter_combo = QComboBox() self.filter_combo.addItems(LEVEL_FILTERS) self.clear_btn = QPushButton("Clear view") - self.save_btn = QPushButton("Save view as...") - self.folder_btn = QPushButton("Open logs folder") - self.analyze_btn = QPushButton("Analyze log file...") - self.analyze_btn.setToolTip("Load a saved session log or serial capture and diagnose it") - self.copy_btn = QPushButton("Copy report") - self.copy_btn.setToolTip("Copy the diagnosis as text (e.g. to send to the firmware team)") - self.service_btn = QPushButton("Service report...") - self.service_btn.setToolTip("Open this box's page in the KOTA service system with the diagnosis " - "filled in; check it and press Save there") - self._settings = QSettings("KOTA", "TechnicianTool") - self.auto_service = QCheckBox("Open service report on disconnect") - self.auto_service.setChecked(self._settings.value("service/auto", False, type=bool)) - self.auto_service.toggled.connect(lambda on: self._settings.setValue("service/auto", on)) - self._active_port: PortInfo | None = None - - row1 = QHBoxLayout() - for w in (QLabel("Port:"), self.port_combo, self.all_ports, self.refresh_btn, - self.connect_btn, self.reset_btn): - row1.addWidget(w) - row1.addStretch(1) - row2 = QHBoxLayout() - for w in (QLabel("Show:"), self.filter_combo, self.clear_btn, self.save_btn, self.folder_btn, - self.analyze_btn, self.copy_btn, self.service_btn, self.auto_service): - row2.addWidget(w) - row2.addStretch(1) - self.view = QPlainTextEdit(readOnly=True) self.view.setMaximumBlockCount(MAX_LINES) self.view.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap) mono = QFont("Menlo" if QFont("Menlo").exactMatch() else "Consolas") mono.setStyleHint(QFont.StyleHint.Monospace) - mono.setPointSize(10) + mono.setPointSize(12 if sys.platform == "darwin" else 10) self.view.setFont(mono) self.view.setStyleSheet("QPlainTextEdit { background:#1e1e1e; color:#d4d4d4; }") + log_page = QWidget() + ll = QVBoxLayout(log_page) + ll.setContentsMargins(0, 4, 0, 0) + lrow = QHBoxLayout() + for w in (QLabel("Show:"), self.filter_combo, self.clear_btn): + lrow.addWidget(w) + lrow.addStretch(1) + ll.addLayout(lrow) + ll.addWidget(self.view, 1) self.diag = DiagnosticsPanel() self.guide = GuidePanel(self._runner, self._engine, matter_payload=self.matter_payload) self.side_tabs = QTabWidget() - self.side_tabs.addTab(self.diag, "Diagnosis") + self.side_tabs.addTab(log_page, "Live log") self.side_tabs.addTab(self.guide, "Guided troubleshooting") + self.side_tabs.addTab(self.diag.details, "Box details") split = QSplitter(Qt.Orientation.Horizontal) - split.addWidget(self.view) + split.addWidget(self.diag) split.addWidget(self.side_tabs) - split.setStretchFactor(0, 3) - split.setStretchFactor(1, 2) - split.setSizes([700, 480]) + split.setStretchFactor(0, 1) + split.setStretchFactor(1, 1) + split.setSizes([560, 620]) self.status = QLabel() + self.status.setStyleSheet("color:#555") layout = QVBoxLayout(self) - layout.addLayout(row1) - layout.addLayout(row2) + layout.addLayout(top) + layout.addWidget(self.test_status) layout.addWidget(split, 1) layout.addWidget(self.status) # --- wiring self.refresh_btn.clicked.connect(self.refresh_ports) self.all_ports.toggled.connect(self.refresh_ports) + self.test_btn.clicked.connect(self._test_box) self.connect_btn.clicked.connect(self._toggle_connect) - self.reset_btn.clicked.connect(self._manager.reset_board) + self.reset_btn.triggered.connect(self._manager.reset_board) self.clear_btn.clicked.connect(self.view.clear) - self.save_btn.clicked.connect(self._save_view) - self.folder_btn.clicked.connect(self._open_folder) - self.analyze_btn.clicked.connect(self._analyze_file) - self.copy_btn.clicked.connect(self._copy_report) - self.service_btn.clicked.connect(lambda: self._open_service_report(auto=False)) + self.save_btn.triggered.connect(self._save_view) + self.folder_btn.triggered.connect(self._open_folder) + self.analyze_btn.triggered.connect(self._analyze_file) + self.copy_btn.triggered.connect(self._copy_report) + self.service_btn.triggered.connect(lambda: self._open_service_report(auto=False)) self.diag.qr_btn.clicked.connect(lambda: MatterQrDialog(self.matter_payload(), self).exec()) + # Test box state: None = no test; else monotonic start time. + self._test_t0: float | None = None + self._test_since: dt.datetime | None = None # UTC; InfluxDB data must be newer + self._influx_started = False + self._cloud: influx.InfluxCheck | None = None # last InfluxDB answer + self._cloud_checking = False + # Report refresh is throttled; lines can arrive at >100/s. self._diag_timer = QTimer(self, interval=400) self._diag_timer.timeout.connect(self._refresh_diag) @@ -221,8 +282,98 @@ class SerialTab(QWidget): self._diag_dirty = True self._session.start(port.mac or port.device) self._active_port = port + self._cloud, self._cloud_checking = None, False self._manager.connect(port) + # ---- Test box ---------------------------------------------------------- + def _test_box(self) -> None: + """Restart the box, record its start-up, then check InfluxDB online.""" + if self._manager.is_running: + self._counts = {"E": 0, "W": 0, "boots": 0} + self._engine.reset() + self._runner.cancel() + self._cloud, self._cloud_checking = None, False + self._manager.reset_board() + else: + port = self._selected_port() or next((p for p in self._ports if p.is_sensorbox), None) + if port is None: + QMessageBox.information(self, "Test box", "No sensorbox found. Check the USB cable (data cable) " + "and that the box's power switch is ON, then press ↻.") + return + self.connect_port(port, capture=True) + self._test_t0 = time.monotonic() + self._test_since = dt.datetime.now(dt.timezone.utc) + self._influx_started = False + self._test_end = None + self._diag_dirty = True + self._guide_log("Test box started: restarting the box and recording its start-up") + + def _tick_test(self) -> None: + if self._test_t0 is None: + return + self._diag_dirty = True # countdowns in the strip and the checklist + if not self._manager.is_running: + self._finish_test(None, "Box disconnected - test stopped.") + return + elapsed = time.monotonic() - self._test_t0 + if not self._influx_started and elapsed >= TEST_INFLUX_AFTER_S and self.is_connected: + self._influx_started = True + self._runner.start("influx") # polls, routes and records findings like a guided check + self.guide.refresh() + elif self._influx_started and (self._runner.end is not None or self._runner.guide is None): + self._finish_test(self._runner.end) + + def _finish_test(self, end, text: str = "") -> None: + self._test_t0 = None + self._test_since = None + self._test_end = end + self._test_text = text + self._guide_log("Test box finished: " + (end.title if end else text or "stopped")) + + def _cloud_rows(self) -> list[tuple[str, str]]: + in_check = self._runner.step is not None and self._runner.step.type == "influx" + if self.influx_config() is None: + return [("off", f"{INFLUX_ROW}: not set up - Settings > InfluxDB access")] + if in_check: + left = int(self._runner.view().remaining_s) + last = f" - last answer: {self._cloud.summary}" if self._cloud else "" + rows = [("running", f"{INFLUX_ROW}: checking... {left // 60}:{left % 60:02d} left{last}")] + elif self._cloud is not None: + rows = [(CLOUD_STATE.get(self._cloud.outcome, "warn"), f"{INFLUX_ROW}: {self._cloud.summary}")] + else: + when = (f"starts {TEST_INFLUX_AFTER_S} s after the restart" if self._test_t0 is not None + else "press Test box") + return [("pending", f"{INFLUX_ROW} - {when}")] + if self._cloud is not None: + rows += [("note", f" {d}") for d in self._cloud.details] + return rows + + def _update_test_strip(self) -> None: + if self._test_t0 is not None: + el = int(time.monotonic() - self._test_t0) + if self._influx_started: + doing = "checking that the data reaches InfluxDB - " + ( + self._runner.view().note or "waiting for the first answer") + else: + ms = self._engine.report().milestones + done = sum(t is not None for _, _, t in ms) + doing = f"recording the start-up ({done} of {len(ms)} checklist steps done)" + key, text = "running", f"Test running {el // 60}:{el % 60:02d} - {_esc(doing)}" + elif getattr(self, "_test_end", None) is not None: + e = self._test_end + key = e.severity + text = (f"Test finished: {_esc(e.title)}
{_esc(e.text)} " + "Details: Findings below and the Guided troubleshooting tab.") + elif getattr(self, "_test_text", ""): + key, text = "warning", f"{_esc(self._test_text)}" + else: + key = "idle" + text = ("Press ▶ Test box: the tool restarts the box, checks its start-up (sensors, SD card, " + "Wi-Fi, clock) and then whether its sensor data reaches InfluxDB. Takes about 4 minutes.") + bg, fg = STRIP[key] + self.test_status.setStyleSheet(f"QLabel {{ background:{bg}; color:{fg}; border-radius:6px; }}") + self.test_status.setText(text) + def matter_payload(self) -> SetupPayload: """Pairing payload reported by this box (KOTA: matter), from its log, or the defaults.""" return payload_from_log([self._engine.matter_advert] if self._engine.matter_advert else [], @@ -317,6 +468,7 @@ class SerialTab(QWidget): self._session.stop() self.connect_btn.setText("Disconnect" if running else "Connect") self.reset_btn.setEnabled(state == State.CONNECTED) + self.test_btn.setEnabled(state != State.WAITING) self.port_combo.setEnabled(not running) self.all_ports.setEnabled(not running) self.refresh_btn.setEnabled(not running) @@ -376,9 +528,11 @@ class SerialTab(QWidget): # ---- diagnostics ------------------------------------------------- def _refresh_diag(self) -> None: + self._tick_test() if self._diag_dirty: self._diag_dirty = False - self.diag.show_report(self._engine.report()) + self.diag.show_report(self._engine.report(), self._cloud_rows()) + self._update_test_strip() self.guide.refresh() # countdowns and timeouts need a steady tick # ---- guided troubleshooting hooks ------------------------------------ @@ -392,7 +546,9 @@ class SerialTab(QWidget): if cfg is None: self._runner.note = "InfluxDB access is not set up: Settings > InfluxDB access." return False - threading.Thread(target=lambda: self._bridge.influx.emit(influx.check_device(cfg, mac)), + since = self._test_since + self._cloud_checking = True + threading.Thread(target=lambda: self._bridge.influx.emit(influx.check_device(cfg, mac, since=since)), name="influx-check", daemon=True).start() return True return False @@ -409,6 +565,7 @@ class SerialTab(QWidget): bucket=str(self._settings.value("influx/bucket", influx.DEFAULT_BUCKET))) def _on_influx(self, check: influx.InfluxCheck) -> None: + self._cloud, self._cloud_checking = check, False self._runner.influx_result(check.outcome, check.summary, check.details) self._diag_dirty = True self.guide.refresh() diff --git a/tests/test_guides.py b/tests/test_guides.py index af230cf..076062a 100644 --- a/tests/test_guides.py +++ b/tests/test_guides.py @@ -334,3 +334,15 @@ def test_quick_check_green_ends_with_influx_check(influx_rig): runner.answer("GREEN") runner.answer("0") # heartbeat blinking assert runner.guide.id == "influx" and actions == ["influx"] + + +def test_influx_rejected_upload_is_named(influx_rig): + engine, runner, clock, actions, board = influx_rig + board(*BOOT, "microphone,device=A4CB8FC9473C dbfs=-inf,db=-inf 1790805114000000000", + "io,device=A4CB8FC9473C dbfs=-inf,db=-inf 1790805215000000000") # USB dropped characters + assert sum(k.startswith("influx.invalid_value") for k in engine.findings) == 1 + runner.start("influx") + runner.influx_result("silent", "No new data in InfluxDB since the test started") + clock.t += 300 + runner.tick() + assert runner.end.id == "invalid_value" diff --git a/tests/test_influx.py b/tests/test_influx.py index 32029c2..1d84d18 100644 --- a/tests/test_influx.py +++ b/tests/test_influx.py @@ -67,7 +67,7 @@ def test_offline_box_whose_sensors_stopped_before_status(): latest = {"device_status": _t(29 * 60), "microphone": _t(29 * 60), "as7341_adc": _t(21 * 1440), "bme688": _t(21 * 1440), "sen66": _t(21 * 1440)} c = influx.classify(latest, NOW) - assert c.outcome == influx.SENSORS_MISSING and "offline now" in c.summary + assert c.outcome == influx.SENSORS_MISSING and "Nothing new" in c.summary assert any("stopped" in d for d in c.details) assert any("21 days ago" in d for d in c.details) @@ -140,3 +140,15 @@ def test_check_device_sends_token_header_and_normalized_mac(monkeypatch): assert req.get_header("Authorization") == "Token tok" assert "tok" not in req.full_url and req.full_url.endswith("/api/v2/query?org=kota") assert b'"A4CB8FC9473C"' in req.data + + +def test_since_ignores_data_from_before_the_test(): + # healthy a few minutes ago, but nothing since the box was restarted by the test + latest = {"device_status": _t(5), "microphone": _t(5), "as7341_adc": _t(5), "bme688": _t(5), "sen66": _t(5)} + assert influx.classify(latest, NOW).outcome == influx.OK + c = influx.classify(latest, NOW, since=_t(2)) + assert c.outcome == influx.SILENT and "since the test started" in c.summary + latest.update(device_status=_t(0), microphone=_t(0)) + assert influx.classify(latest, NOW, since=_t(2)).outcome == influx.SENSORS_MISSING + latest.update(as7341_adc=_t(0), bme688=_t(0), sen66=_t(2.5)) # within the clock slack + assert influx.classify(latest, NOW, since=_t(2)).outcome == influx.OK diff --git a/tests/test_ui.py b/tests/test_ui.py index 3564ee1..9467b13 100644 --- a/tests/test_ui.py +++ b/tests/test_ui.py @@ -19,3 +19,34 @@ def test_main_window_builds_with_all_tabs(): assert "InfluxDB access..." in settings w.serial_tab.shutdown() app.processEvents() + + +def test_serial_tab_checklist_and_test_strip(): + from PySide6.QtWidgets import QApplication + + from kota_tech.core.logline import parse_line + from kota_tech.service import influx + from kota_tech.ui.main_window import INFLUX_ROW, MainWindow + app = QApplication.instance() or QApplication([]) + w = MainWindow() + st = w.serial_tab + assert st.test_btn.text().endswith("Test box") + assert [st.side_tabs.tabText(i) for i in range(st.side_tabs.count())] == \ + ["Live log", "Guided troubleshooting", "Box details"] + st.influx_config = lambda: None # no token (never touch real settings) + rows = st._cloud_rows() + assert rows[0][0] == "off" and "not set up" in rows[0][1] + st.influx_config = lambda: influx.InfluxConfig("t") # pretend access is set up + assert st._cloud_rows()[0] == ("pending", f"{INFLUX_ROW} - press Test box") + st._on_influx(influx.InfluxCheck(influx.SENSORS_MISSING, "Status arrives, sensor data does not", + details=["SEN66 (air quality): no data"])) + rows = st._cloud_rows() + assert rows[0][0] == "bad" and rows[1][0] == "note" + st._engine.feed(parse_line("ESP-ROM:esp32s3-20210327")) + st._diag_dirty = True + st._refresh_diag() + texts = [st.diag.milestones.item(i).text() for i in range(st.diag.milestones.count())] + assert any(INFLUX_ROW in t for t in texts) + assert "Test box" in st.test_status.text() + st.shutdown() + app.processEvents()