feat: wireview firmware check + DFU flash, fault clearing, pin-imbalance gauge #19

Merged
Pakobbix merged 4 commits from feat/wireview-firmware-flash-faults into main 2026-10-05 18:40:35 +00:00
5 changed files with 234 additions and 0 deletions
Showing only changes of commit d9f5e34c80 - Show all commits

No files matched your search

+11
View File
@@ -196,6 +196,17 @@ export const api = {
), ),
/** WireView Pro II */ /** WireView Pro II */
/**
* Clear fault status and/or latched fault log.
* keepStatus/keepLog are 16-bit masks of bits to RETAIN; all other bits
* are cleared (0x0000 clears all, 0xFFFF keeps all).
*/
wireviewClearFault: (keepStatus: number, keepLog: number) =>
post<{ ok: boolean }>("/wireview/clear-fault", {
keep_status: keepStatus,
keep_log: keepLog,
}),
/** /**
* Firmware check: device firmware vs. the bundled image (verdict, * Firmware check: device firmware vs. the bundled image (verdict,
* dfu-util availability, flash state). * dfu-util availability, flash state).
@@ -51,9 +51,13 @@ function pluck(history: WireViewSample[], key: keyof WireViewSample): number[] {
function FaultBadge({ function FaultBadge({
label, label,
mask, mask,
onClear,
clearing,
}: { }: {
label: string; label: string;
mask: number; mask: number;
onClear?: () => void;
clearing?: boolean;
}) { }) {
const faults = decodeFaults(mask); const faults = decodeFaults(mask);
return ( return (
@@ -68,6 +72,17 @@ function FaultBadge({
<span className="text-xs text-zinc-500 uppercase tracking-wider"> <span className="text-xs text-zinc-500 uppercase tracking-wider">
{label} {label}
</span> </span>
<div className="flex items-center gap-2">
{mask !== 0 && onClear && (
<button
onClick={onClear}
disabled={clearing}
className="px-2 py-0.5 rounded text-[11px] font-medium bg-red-500/20 border border-red-500/50 text-red-200 hover:bg-red-500/30 disabled:opacity-50 disabled:cursor-not-allowed"
title={`Clear ${label.toLowerCase()}`}
>
{clearing ? "Clearing…" : "Clear"}
</button>
)}
<span <span
className={`text-xs font-mono ${ className={`text-xs font-mono ${
faults.length > 0 ? "text-red-400" : "text-zinc-600" faults.length > 0 ? "text-red-400" : "text-zinc-600"
@@ -76,6 +91,7 @@ function FaultBadge({
0x{mask.toString(16).toUpperCase().padStart(4, "0")} 0x{mask.toString(16).toUpperCase().padStart(4, "0")}
</span> </span>
</div> </div>
</div>
{faults.length > 0 ? ( {faults.length > 0 ? (
<div className="flex flex-wrap gap-1"> <div className="flex flex-wrap gap-1">
{faults.map((f) => ( {faults.map((f) => (
@@ -174,6 +190,7 @@ function InfoItem({
} }
export function WireViewPanel({ info, sample, history, flash }: Props) { export function WireViewPanel({ info, sample, history, flash }: Props) {
const [clearing, setClearing] = useState<"status" | "log" | null>(null);
const [firmware, setFirmware] = useState<WireViewFirmwareState | null>(null); const [firmware, setFirmware] = useState<WireViewFirmwareState | null>(null);
const [firmwareError, setFirmwareError] = useState<string | null>(null); const [firmwareError, setFirmwareError] = useState<string | null>(null);
const [confirming, setConfirming] = useState<null | "update" | "override">( const [confirming, setConfirming] = useState<null | "update" | "override">(
@@ -232,6 +249,26 @@ export function WireViewPanel({ info, sample, history, flash }: Props) {
} }
} }
async function handleClear(which: "status" | "log") {
setClearing(which);
try {
// Keep-mask semantics: 0x0000 clears, 0xFFFF keeps.
await api.wireviewClearFault(
which === "status" ? 0x0000 : 0xffff,
which === "log" ? 0x0000 : 0xffff,
);
toast.success(
which === "status" ? "Fault status cleared" : "Fault log cleared",
);
} catch (err) {
toast.error(
err instanceof Error ? err.message : "Failed to clear fault",
);
} finally {
setClearing(null);
}
}
if (!sample) { if (!sample) {
return ( return (
<div className="bg-zinc-900 rounded-lg p-10 text-center text-zinc-500 flex flex-col items-center gap-2"> <div className="bg-zinc-900 rounded-lg p-10 text-center text-zinc-500 flex flex-col items-center gap-2">
@@ -370,10 +407,14 @@ export function WireViewPanel({ info, sample, history, flash }: Props) {
<FaultBadge <FaultBadge
label="Fault Status" label="Fault Status"
mask={sample.fault_status} mask={sample.fault_status}
onClear={() => handleClear("status")}
clearing={clearing === "status"}
/> />
<FaultBadge <FaultBadge
label="Fault Log (latched)" label="Fault Log (latched)"
mask={sample.fault_log} mask={sample.fault_log}
onClear={() => handleClear("log")}
clearing={clearing === "log"}
/> />
</div> </div>
<div className="bg-zinc-900 rounded-lg p-4"> <div className="bg-zinc-900 rounded-lg p-4">
+48
View File
@@ -842,6 +842,14 @@ class ConfigUpdateRequest(BaseModel):
gpu_index: int = 0 gpu_index: int = 0
class WireViewClearFaultRequest(BaseModel):
"""16-bit masks of the fault bits to RETAIN; every other bit is cleared
(0x0000 clears all, 0xFFFF keeps all)."""
keep_status: int
keep_log: int
class FanCurvePoint(BaseModel): class FanCurvePoint(BaseModel):
temp_c: int temp_c: int
fan_pct: int fan_pct: int
@@ -1878,6 +1886,46 @@ async def api_wireview():
} }
@app.post("/api/wireview/clear-fault", tags=["WireView"], responses=R_AUTH)
async def api_wireview_clear_fault(req: WireViewClearFaultRequest):
"""Clear the WireView fault status and/or the latched fault log.
keep_status/keep_log are 16-bit masks of the bits to retain; all other
bits are cleared. Serial transport only — in hwmon mode the wireviewd
daemon owns the port and the masks are read-only from here.
"""
if not (0 <= req.keep_status <= 0xFFFF and 0 <= req.keep_log <= 0xFFFF):
raise HTTPException(
status_code=422,
detail="keep_status/keep_log must be 16-bit masks (0x0000-0xFFFF)",
)
wv = _state["wireview"]
device = wv["device"]
if device is None:
raise HTTPException(status_code=503, detail="No WireView connected")
if device.transport != "serial":
raise HTTPException(
status_code=501,
detail=(
"Fault clearing requires the serial transport "
"(wireviewd owns the port in hwmon mode)"
),
)
if not await _run(device.clear_faults, req.keep_status, req.keep_log):
raise HTTPException(
status_code=502, detail="Failed to send clear command to device"
)
# Re-read immediately so clients see the cleared masks without waiting
# for the next poll tick.
sample = await _run(device.read_sample)
if wv["device"] is device and sample is not None:
wv["last_sample"] = sample
await _broadcast(
wv["clients"], {"type": "sample", "info": wv["info"], "sample": sample}
)
return {"ok": True}
# ── WireView Pro II firmware (check + DFU flash) ───────────────────────────── # ── WireView Pro II firmware (check + DFU flash) ─────────────────────────────
+35
View File
@@ -18,6 +18,7 @@ Protocol notes (matches the firmware's DEVICE_STR_LEN=32 layout):
import logging import logging
import os import os
import struct import struct
import threading
import time import time
from typing import Any from typing import Any
@@ -58,6 +59,7 @@ CMD_READ_VENDOR_DATA = 0x01
CMD_READ_UID = 0x02 CMD_READ_UID = 0x02
CMD_READ_SENSOR_VALUES = 0x04 CMD_READ_SENSOR_VALUES = 0x04
CMD_READ_CONFIG = 0x05 CMD_READ_CONFIG = 0x05
CMD_CLEAR_FAULTS = 0x0E
CMD_SCREEN_CHANGE = 0x0C CMD_SCREEN_CHANGE = 0x0C
CMD_READ_BUILD_INFO = 0x0D CMD_READ_BUILD_INFO = 0x0D
# Top-level command (not a screen subcommand): restarts the device into its # Top-level command (not a screen subcommand): restarts the device into its
@@ -294,6 +296,11 @@ class WireViewSerialDevice:
self._uid = "" self._uid = ""
self._build = "" self._build = ""
self._config_version = -1 self._config_version = -1
# Serializes all port access: the poller, the clear-fault endpoint and
# the watchdog all open the port from thread-pool threads, and a second
# opener mid-transaction desyncs the stream (the device interleaves its
# welcome handshake into the other side's frame).
self._lock = threading.RLock()
# ── Identity ── # ── Identity ──
@@ -424,6 +431,21 @@ class WireViewSerialDevice:
return None return None
return parse_sensor_struct(buf) return parse_sensor_struct(buf)
def clear_faults(self, keep_status: int, keep_log: int) -> bool:
"""Clear fault status and/or the latched fault log.
keep_status/keep_log are 16-bit masks of the bits to RETAIN; every
other bit is cleared (0x0000 clears all, 0xFFFF keeps all). The
device answers no reply, so success means the command was written
to the port.
"""
if not self._connected:
return False
cmd = struct.pack(
"<BHH", CMD_CLEAR_FAULTS, keep_status & 0xFFFF, keep_log & 0xFFFF
)
return self._transaction(cmd, 0) is not None
def enter_bootloader(self) -> bool: def enter_bootloader(self) -> bool:
"""Restart the device into the STM32 DFU bootloader (0483:df11). """Restart the device into the STM32 DFU bootloader (0483:df11).
@@ -461,6 +483,10 @@ class WireViewSerialDevice:
def _read_welcome(self) -> str | None: def _read_welcome(self) -> str | None:
"""Assert RTS and read the NUL-terminated welcome string the device """Assert RTS and read the NUL-terminated welcome string the device
answers with. Null when nothing (or no terminator) arrives in time.""" answers with. Null when nothing (or no terminator) arrives in time."""
with self._lock:
return self._read_welcome_unlocked()
def _read_welcome_unlocked(self) -> str | None:
ser = self._open_port() ser = self._open_port()
if ser is None: if ser is None:
return None return None
@@ -498,6 +524,10 @@ class WireViewSerialDevice:
"""Open the port, send cmd, read exactly response_size bytes (one """Open the port, send cmd, read exactly response_size bytes (one
second budget), close the port. None when the port is unavailable second budget), close the port. None when the port is unavailable
or the reply is incomplete.""" or the reply is incomplete."""
with self._lock:
return self._transaction_unlocked(cmd, response_size)
def _transaction_unlocked(self, cmd: bytes, response_size: int) -> bytes | None:
ser = self._open_port() ser = self._open_port()
if ser is None: if ser is None:
return None return None
@@ -596,6 +626,11 @@ class WireViewHwmonDevice:
def close(self) -> None: def close(self) -> None:
self._connected = False self._connected = False
def clear_faults(self, keep_status: int, keep_log: int) -> bool:
"""Not supported: the wireviewd daemon owns the serial port in hwmon
mode, so the fault masks cannot be cleared from here."""
return False
def enter_bootloader(self) -> bool: def enter_bootloader(self) -> bool:
"""Not supported: the wireviewd daemon owns the serial port in hwmon """Not supported: the wireviewd daemon owns the serial port in hwmon
mode, and nvcurve does not speak the daemon protocol.""" mode, and nvcurve does not speak the daemon protocol."""
+99
View File
@@ -297,6 +297,10 @@ def test_hwmon_device():
dev = wv.WireViewHwmonDevice(p) dev = wv.WireViewHwmonDevice(p)
check("hwmon connect", dev.connect()) check("hwmon connect", dev.connect())
check("hwmon node exists", dev.node_exists()) check("hwmon node exists", dev.node_exists())
check(
"hwmon clear unsupported",
dev.clear_faults(0x0000, 0x0000) is False,
)
s = dev.read_sample() s = dev.read_sample()
check("hwmon sample", s is not None) check("hwmon sample", s is not None)
if s: if s:
@@ -456,6 +460,100 @@ def test_serial_device_protocol():
t.join(timeout=2) t.join(timeout=2)
def test_serial_clear_faults():
"""CMD_CLEAR_FAULTS sends 0x0E + two little-endian uint16 keep masks
(0x0000 clears, 0xFFFF keeps), matching the protocol table:
clear fault and log -> 0x0E 00 00 00 00
clear fault only, keep log -> 0x0E 00 00 FF FF
clear log only, keep fault -> 0x0E FF FF 00 00
"""
import pty
import queue
import threading
master, slave = pty.openpty()
slave_path = os.ttyname(slave)
received: queue.Queue = queue.Queue()
def run():
while True:
try:
cmd = os.read(master, 1)
except OSError:
return
if not cmd:
return
if cmd[0] == wv.CMD_CLEAR_FAULTS:
rest = b""
while len(rest) < 4:
try:
chunk = os.read(master, 4 - len(rest))
except OSError:
return
if not chunk:
return
rest += chunk
received.put(cmd + rest)
continue
resp = {
wv.CMD_READ_VENDOR_DATA: bytes([0xEF, 0x05, 1]),
wv.CMD_READ_CONFIG: bytes([0, 0, 1, 0]),
wv.CMD_READ_UID: bytes(12),
wv.CMD_READ_BUILD_INFO: _build_info_struct(
"WireView Pro II", "test"
),
}.get(cmd[0])
if resp:
try:
os.write(master, resp)
except OSError:
return
t = threading.Thread(target=run, daemon=True)
t.start()
try:
dev = wv.WireViewSerialDevice(slave_path)
check("clear: connect", dev.connect())
cases = [
("clear fault and log", 0x0000, 0x0000, bytes([0x0E, 0, 0, 0, 0])),
(
"clear fault only, keep log",
0x0000,
0xFFFF,
bytes([0x0E, 0, 0, 0xFF, 0xFF]),
),
(
"clear log only, keep fault",
0xFFFF,
0x0000,
bytes([0x0E, 0xFF, 0xFF, 0, 0]),
),
]
for name, keep_status, keep_log, expected in cases:
check(f"clear: {name} sent", dev.clear_faults(keep_status, keep_log))
try:
got = received.get(timeout=2)
except queue.Empty:
check(f"clear: {name} bytes", False)
continue
check(f"clear: {name} bytes", got == expected)
# Out-of-range masks are clamped to 16 bits, not sent verbatim.
check("clear: out-of-range sent", dev.clear_faults(0x1FFFF, 0x1FFFF))
try:
got = received.get(timeout=2)
check("clear: out-of-range clamped", got == bytes([0x0E, 0xFF, 0xFF, 0xFF, 0xFF]))
except queue.Empty:
check("clear: out-of-range clamped", False)
dev.close()
check("clear: rejected when disconnected", not dev.clear_faults(0, 0))
finally:
os.close(master)
t.join(timeout=2)
def test_serial_device_rejected_product(): def test_serial_device_rejected_product():
"""An unsupported product id is rejected and memoized via .rejected.""" """An unsupported product id is rejected and memoized via .rejected."""
responses = {wv.CMD_READ_VENDOR_DATA: bytes([0xEF, 0x07, 1])} responses = {wv.CMD_READ_VENDOR_DATA: bytes([0xEF, 0x07, 1])}
@@ -530,6 +628,7 @@ def main() -> int:
test_hwmon_device() test_hwmon_device()
test_hwmon_legacy_attrs() test_hwmon_legacy_attrs()
test_serial_device_protocol() test_serial_device_protocol()
test_serial_clear_faults()
test_serial_device_rejected_product() test_serial_device_rejected_product()
test_serial_device_no_response() test_serial_device_no_response()
test_serial_transport_missing_pyserial() test_serial_transport_missing_pyserial()