Wi-Fi over USB tab for firmware with the USB console (v13)

Writes / reads / removes the box's Wi-Fi over the serial port with the
usb_console commands (kota ping, wifi set|get|clear, health) and follows
the box through the restart until it joins the network. The password is
sent hex-encoded and never logged.

firmware/ now holds merged-binary-v13.bin (build 3ae273ec) instead of the
previous 1.0.16 build; error_ids.csv synced with the firmware.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

kota_tech/ui/wifi_tab.py

@@ -0,0 +1,207 @@
+"""Wi-Fi over USB: read / write / remove the box's Wi-Fi without opening the case.
+
+Needs firmware with the USB console (usb_console, api=1). The job itself is
+serialio.commands.WifiFlow; this tab only collects the input and shows the
+steps. Lines arrive from the Serial monitor's connection (one port owner).
+"""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QFormLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QListWidget,
+    QListWidgetItem,
+    QMessageBox,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+from PySide6.QtGui import QBrush, QColor
+
+from ..core.logline import LogLine
+from ..serialio.commands import FlowEvent, WifiFlow, validate_wifi
+
+INTRO = (
+    "Stores the Wi-Fi name and password on the box's SD card over the USB cable - <b>no need to open the "
+    "case</b>. The box then restarts and uses this network instead of Matter. Needs firmware with USB commands "
+    "(<i>Flash firmware</i> tab, newest file). Only 2.4 GHz networks with a password (8-63 characters)."
+)
+MARK = {True: ("✔", "#1b7a33"), False: ("✖", "#b03a2e"), None: ("…", "#2e6da4")}
+
+
+class WifiTab(QWidget):
+    def __init__(self, serial_tab, parent: QWidget | None = None):
+        super().__init__(parent)
+        self.serial_tab = serial_tab
+        self._flow: WifiFlow | None = None
+
+        intro = QLabel(INTRO, wordWrap=True)
+
+        # 1. box
+        box = QGroupBox("1. Sensorbox")
+        self.box_state = QLabel(wordWrap=True)
+        self.connect_btn = QPushButton("Connect to the box")
+        self.connect_btn.clicked.connect(self._connect)
+        self.read_btn = QPushButton("Read current Wi-Fi settings")
+        self.read_btn.clicked.connect(lambda: self._run("read"))
+        bl = QVBoxLayout(box)
+        bl.addWidget(self.box_state)
+        brow = QHBoxLayout()
+        brow.addWidget(self.connect_btn)
+        brow.addWidget(self.read_btn)
+        brow.addStretch(1)
+        bl.addLayout(brow)
+
+        # 2. network
+        net = QGroupBox("2. Wi-Fi network for this box")
+        self.ssid = QLineEdit(placeholderText="network name (SSID), exactly as on the router")
+        self.password = QLineEdit(placeholderText="8-63 characters")
+        self.password.setEchoMode(QLineEdit.EchoMode.Password)
+        show = QCheckBox("Show password")
+        show.toggled.connect(lambda on: self.password.setEchoMode(
+            QLineEdit.EchoMode.Normal if on else QLineEdit.EchoMode.Password))
+        form = QFormLayout()
+        form.addRow("Network (SSID)", self.ssid)
+        prow = QHBoxLayout()
+        prow.addWidget(self.password, 1)
+        prow.addWidget(show)
+        form.addRow("Password", prow)
+        self.input_problem = QLabel(wordWrap=True)
+        self.input_problem.setStyleSheet("color:#b03a2e")
+        self.write_btn = QPushButton("Write to the box and connect")
+        self.write_btn.setMinimumHeight(34)
+        self.write_btn.clicked.connect(lambda: self._run("set"))
+        self.clear_btn = QPushButton("Remove Wi-Fi (back to Matter)")
+        self.clear_btn.clicked.connect(self._clear)
+        nl = QVBoxLayout(net)
+        nl.addLayout(form)
+        nl.addWidget(self.input_problem)
+        arow = QHBoxLayout()
+        arow.addWidget(self.write_btn)
+        arow.addWidget(self.clear_btn)
+        arow.addStretch(1)
+        nl.addLayout(arow)
+
+        # 3. progress
+        prog = QGroupBox("3. Progress")
+        self.steps = QListWidget()
+        self.steps.setSelectionMode(QListWidget.SelectionMode.NoSelection)
+        self.result = QLabel(wordWrap=True)
+        self.result.setMargin(8)
+        self.result.setVisible(False)
+        self.cancel_btn = QPushButton("Cancel")
+        self.cancel_btn.clicked.connect(self._cancel)
+        pl = QVBoxLayout(prog)
+        pl.addWidget(self.steps)
+        pl.addWidget(self.result)
+        pl.addWidget(self.cancel_btn, 0, Qt.AlignmentFlag.AlignLeft)
+
+        lay = QVBoxLayout(self)
+        lay.addWidget(intro)
+        lay.addWidget(box)
+        lay.addWidget(net)
+        lay.addWidget(prog, 1)
+
+        serial_tab.add_line_listener(self._on_line)
+        for w in (self.ssid, self.password):
+            w.textChanged.connect(self._update)
+        self._timer = QTimer(self, interval=500)
+        self._timer.timeout.connect(self._tick)
+        self._timer.start()
+        self._update()
+
+    # ------------------------------------------------------------ state
+    def showEvent(self, event):  # noqa: N802 - refresh when the tab is opened
+        self._update()
+        super().showEvent(event)
+
+    def _update(self) -> None:
+        connected = self.serial_tab.is_connected
+        busy = self._flow is not None and not self._flow.finished
+        port = self.serial_tab.active_port
+        eng = self.serial_tab.engine
+        if connected and port:
+            fw = eng.firmware.describe() if eng.firmware.elf_sha else "firmware not identified yet"
+            api = {None: "", 1: " - USB commands supported"}.get(eng.console_api, f" - USB commands api {eng.console_api}")
+            self.box_state.setText(f"Connected: <b>{port.label}</b><br><small>{fw}{api}</small>")
+        elif self.serial_tab.active_port:
+            self.box_state.setText("Waiting for the box... (it may be restarting)")
+        else:
+            self.box_state.setText("Not connected. Plug in the sensorbox (native USB) and press "
+                                   "<b>Connect to the box</b>.")
+        problems = validate_wifi(self.ssid.text(), self.password.text())
+        typed = bool(self.ssid.text() or self.password.text())
+        self.input_problem.setText(" ".join(problems) if typed else "")
+        self.connect_btn.setVisible(not self.serial_tab.active_port)
+        for w in (self.read_btn, self.clear_btn):
+            w.setEnabled(connected and not busy)
+        self.write_btn.setEnabled(connected and not busy and not problems)
+        self.ssid.setEnabled(not busy)
+        self.password.setEnabled(not busy)
+        self.cancel_btn.setVisible(busy)
+
+    def _tick(self) -> None:
+        if self._flow is not None:
+            self._flow.tick()
+        self._update()
+
+    # ------------------------------------------------------------ actions
+    def _connect(self) -> None:
+        if not self.serial_tab.connect_first_box():
+            QMessageBox.information(self, "Wi-Fi over USB", "No sensorbox found. Check the USB cable (data-capable) "
+                                    "and that the box is powered, then try again.")
+        self._update()
+
+    def _clear(self) -> None:
+        if QMessageBox.question(
+                self, "Remove Wi-Fi",
+                "Remove the Wi-Fi network from the box?\n\nThe box restarts and uses Matter again. If it was never "
+                "paired in Matter, it has no network until you pair it in the Matter app.",
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No) == QMessageBox.StandardButton.Yes:
+            self._run("clear")
+
+    def _run(self, action: str) -> None:
+        if action == "set" and QMessageBox.question(
+                self, "Write Wi-Fi",
+                f"Store network '{self.ssid.text()}' on the box?\n\nThe box restarts and connects to this Wi-Fi "
+                "instead of Matter (about 30 s).",
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No) != QMessageBox.StandardButton.Yes:
+            return
+        self.steps.clear()
+        self.result.setVisible(False)
+        self._flow = WifiFlow(action, self.serial_tab.send_command, self._on_event,
+                              ssid=self.ssid.text(), password=self.password.text())
+        self._flow.start()
+        self._update()
+
+    def _cancel(self) -> None:
+        if self._flow is not None:
+            self._flow.cancel()
+        self._update()
+
+    # ------------------------------------------------------------ events
+    def _on_line(self, line: LogLine) -> None:
+        if self._flow is not None:
+            self._flow.feed(line)
+
+    def _on_event(self, ev: FlowEvent) -> None:
+        mark, colour = MARK[ev.ok]
+        item = QListWidgetItem(f"{mark}  {ev.text}")
+        item.setForeground(QBrush(QColor(colour)))
+        self.steps.addItem(item)
+        self.steps.scrollToBottom()
+        if self._flow is not None and self._flow.finished or ev.ok is False:
+            ok = ev.ok is True
+            border, bg = ("#2e9e44", "#e3f4e7") if ok else ("#d9534f", "#f9e0df")
+            self.result.setStyleSheet(f"QLabel {{ border:2px solid {border}; background:{bg}; border-radius:6px; }}")
+            self.result.setText(("<b>Done.</b> " if ok else "<b>Not done.</b> ") + ev.text)
+            self.result.setVisible(True)
+            if ok and self._flow and self._flow.info and self._flow.info.ssid and not self.ssid.text():
+                self.ssid.setText(self._flow.info.ssid)       # read: prefill the stored network name
+        self._update()