pycentauri 0.4.2__tar.gz → 0.5.0__tar.gz

{pycentauri-0.4.2 → pycentauri-0.5.0}/CHANGELOG.md

@@ -6,6 +6,72 @@ Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-06-17
+
+### Added
+- **Live print-parameter adjust (`Cmd 403` family).** All three payload
+  variants confirmed working against firmware V0.3.0-o:
+  - `Printer.set_print_speed(mode)` — sets the printer's speed mode.
+    Accepts a name (`"silent"`, `"balanced"`, `"sport"`, `"ludicrous"`)
+    or its canonical `PrintSpeedPct` value (`50`, `100`, `130`, `160`).
+    Only those four values are accepted by the firmware — arbitrary
+    intermediate percentages return `Ack=0` but are silently dropped,
+    and the mode change only takes effect while a print is actively
+    running. Names + values lifted directly from the printer's own
+    SPA i18n file at `/app/resources/www/assets/i18n/network-en.json`.
+  - `Printer.set_fan_speed(model=, auxiliary=, chamber=)` — set any
+    subset of the model / auxiliary / chamber fan (0..100% each).
+  - `Printer.set_temperatures(nozzle=, bed=, chamber=)` — heater
+    targets with safety caps (nozzle 0..300, bed 0..110, chamber 0..60).
+    `0` turns the heater off.
+- HTTP endpoints (only when launched with `--enable-control`):
+  `POST /print/speed`, `POST /print/fan`, `POST /print/temperature`.
+  Speed body: `{"mode": "silent|balanced|sport|ludicrous"}` (or the
+  integer equivalent).
+- Web UI `ADJUST` panel with three sections: a 4-button speed-mode
+  selector (the active mode pulses amber based on live status), per-fan
+  rows (model / aux / chamber, 0–100%), and per-heater rows with
+  per-row APPLY buttons and confirm prompts on high temps
+  (nozzle > 240 °C, bed > 85 °C).
+- Web UI auto-hydrates the fan/heater sliders + inputs from each status
+  push, so they always start at the printer's actual live values
+  instead of zero. Controls that are currently focused are skipped so
+  the live update doesn't yank a value out from under a drag/type.
+- Adaptive backup poll: 2-second cadence while the printer is actively
+  printing, 10-second cadence when idle/paused/done/errored. Switches
+  immediately on state transition. SSE remains the primary update
+  path; the poll is a safety net for Firefox's silent SSE stalls.
+- `sdcp.Cmd.CHANGE_PRINT_PARAMS = 403` enum entry, plus the previously-
+  unenumerated `GET_FILE_LIST = 258` and `GET_PRINT_HISTORY = 320` for
+  reference (no client methods yet — exposing those is queued for a
+  later release).
+- `Printer.PRINT_SPEED_MODES` class-level map exposing the canonical
+  `{mode_name: PrintSpeedPct}` table for callers that want to render
+  their own mode picker.
+
+### Fixed
+- **Footer rail no longer overlaps the ADJUST panel on tall pages.**
+  Removing the `min-height: 0` on `.console` lets the grid grow with
+  its content (instead of being constrained to the body's flex slot),
+  so the bottom rail reflows below the panel instead of hovering over
+  it.
+- **Web UI status now stays fresh in Firefox.** SSE remains the
+  primary push path, but the new adaptive backup poll runs in parallel
+  — Firefox occasionally drops the SSE stream silently and previously
+  required a manual refresh to update; the poll keeps the progress
+  bar, temps, fan readings, and ADJUST hydration live regardless.
+
+### Documentation
+- `docs/PROTOCOL.md` promotes Cmd 403 (all three payload variants) to
+  the confirmed-working table, documents the four canonical
+  `PrintSpeedPct` values, captures the printer's internal architecture
+  as observed via SSH on OpenCentauri V0.3.0-o (the `app` binary
+  embeds a Klipper-derived motion stack rather than running it as a
+  separate process, which explains why an `app` crash kills any
+  active print), adds the log-line signal table for filament cycles
+  (`feed state change`, `M729`, etc.), and the recorded touchscreen
+  tap-event sequence for the Goodix `gt9xxnew_ts` driver.
+
 ## [0.4.2] - 2026-04-22
 
 ### Changed

{pycentauri-0.4.2 → pycentauri-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycentauri
-Version: 0.4.2
+Version: 0.5.0
 Summary: Local-network toolkit for Elegoo Centauri Carbon 3D printers: async Python client, CLI, MCP server, REST/SSE HTTP server, web UI, and RTSP bridge
 Project-URL: Homepage, https://github.com/bjan/pycentauri
 Project-URL: Repository, https://github.com/bjan/pycentauri

{pycentauri-0.4.2 → pycentauri-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pycentauri"
-version = "0.4.2"
+version = "0.5.0"
 description = "Local-network toolkit for Elegoo Centauri Carbon 3D printers: async Python client, CLI, MCP server, REST/SSE HTTP server, web UI, and RTSP bridge"
 readme = "README.md"
 license = "Apache-2.0"

{pycentauri-0.4.2 → pycentauri-0.5.0}/src/pycentauri/__init__.py

@@ -25,4 +25,4 @@ __all__ = [
     "discover",
 ]
 
-__version__ = "0.4.2"
+__version__ = "0.5.0"

{pycentauri-0.4.2 → pycentauri-0.5.0}/src/pycentauri/client.py

@@ -14,7 +14,7 @@ import contextlib
 import logging
 from collections.abc import AsyncIterator
 from types import TracebackType
-from typing import Any
+from typing import Any, ClassVar
 
 import websockets
 from typing_extensions import Self
@@ -249,6 +249,110 @@ class Printer:
         mid = await self.wait_for_mainboard()
         return await self._request(sdcp.Cmd.STOP_PRINT, None, mid)
 
+    #: Canonical ``PrintSpeedPct`` values the Centauri Carbon firmware
+    #: actually responds to. Confirmed by reading the printer's own SPA
+    #: i18n file at ``/app/resources/www/assets/i18n/network-en.json``:
+    #: the speed control there is a discrete 4-option list, not a slider.
+    #: Arbitrary intermediate values (e.g. 120, 145, 200) reach the
+    #: firmware (``Ack=0``) but are silently dropped.
+    PRINT_SPEED_MODES: ClassVar[dict[str, int]] = {
+        "silent": 50,
+        "balanced": 100,
+        "sport": 130,
+        "ludicrous": 160,
+    }
+
+    async def set_print_speed(self, mode: str | int) -> sdcp.ParsedMessage:
+        """Set the print-speed mode.
+
+        Pass either a mode name (``"silent"``, ``"balanced"``, ``"sport"``,
+        ``"ludicrous"``) or its corresponding ``PrintSpeedPct`` value
+        (50, 100, 130, 160). Only those four values are accepted by the
+        firmware — anything else returns ``Ack=0`` but does nothing.
+
+        Only takes effect while a print is actively running; sending it
+        at idle is a no-op even with a canonical value.
+        """
+        self._require_control("set_print_speed")
+        if isinstance(mode, str):
+            key = mode.strip().lower()
+            if key not in self.PRINT_SPEED_MODES:
+                raise ValueError(
+                    f"unknown print mode {mode!r}; expected one of {sorted(self.PRINT_SPEED_MODES)}"
+                )
+            value = self.PRINT_SPEED_MODES[key]
+        else:
+            value = int(mode)
+            if value not in self.PRINT_SPEED_MODES.values():
+                raise ValueError(
+                    f"PrintSpeedPct {value} not in firmware-accepted "
+                    f"set {sorted(self.PRINT_SPEED_MODES.values())}"
+                )
+        mid = await self.wait_for_mainboard()
+        return await self._request(sdcp.Cmd.CHANGE_PRINT_PARAMS, {"PrintSpeedPct": value}, mid)
+
+    async def set_fan_speed(
+        self,
+        *,
+        model: int | None = None,
+        auxiliary: int | None = None,
+        chamber: int | None = None,
+    ) -> sdcp.ParsedMessage:
+        """Set fan speeds (each 0..100, optional; only sets the ones supplied).
+
+        ``chamber`` is the chamber/box fan (firmware key ``BoxFan``). Verified
+        working on V0.3.0-o via ``Cmd 403 {"TargetFanSpeed": {...}}``.
+        """
+        self._require_control("set_fan_speed")
+        speeds: dict[str, int] = {}
+        for label, key, val in (
+            ("model", "ModelFan", model),
+            ("auxiliary", "AuxiliaryFan", auxiliary),
+            ("chamber", "BoxFan", chamber),
+        ):
+            if val is None:
+                continue
+            if not 0 <= int(val) <= 100:
+                raise ValueError(f"fan {label} speed {val} must be 0..100")
+            speeds[key] = int(val)
+        if not speeds:
+            raise ValueError("at least one fan speed must be specified")
+        mid = await self.wait_for_mainboard()
+        return await self._request(sdcp.Cmd.CHANGE_PRINT_PARAMS, {"TargetFanSpeed": speeds}, mid)
+
+    async def set_temperatures(
+        self,
+        *,
+        nozzle: float | None = None,
+        bed: float | None = None,
+        chamber: float | None = None,
+    ) -> sdcp.ParsedMessage:
+        """Set heater target temperatures in °C (each optional).
+
+        Passing 0 turns the corresponding heater off. Verified working on
+        V0.3.0-o via ``Cmd 403 {"TempTargetNozzle/Hotbed/Box": N}``.
+
+        Safety caps: nozzle 0..300, bed 0..110, chamber 0..60. Pycentauri
+        won't issue values outside those bounds even if the firmware
+        would accept them.
+        """
+        self._require_control("set_temperatures")
+        targets: dict[str, float] = {}
+        for label, key, val, lo, hi in (
+            ("nozzle", "TempTargetNozzle", nozzle, 0, 300),
+            ("bed", "TempTargetHotbed", bed, 0, 110),
+            ("chamber", "TempTargetBox", chamber, 0, 60),
+        ):
+            if val is None:
+                continue
+            if not lo <= float(val) <= hi:
+                raise ValueError(f"{label} target {val}°C out of safe range {lo}..{hi}")
+            targets[key] = float(val)
+        if not targets:
+            raise ValueError("at least one temperature target must be specified")
+        mid = await self.wait_for_mainboard()
+        return await self._request(sdcp.Cmd.CHANGE_PRINT_PARAMS, targets, mid)
+
     # --- lifecycle -------------------------------------------------------------
 
     async def close(self) -> None:

{pycentauri-0.4.2 → pycentauri-0.5.0}/src/pycentauri/sdcp.py

@@ -35,7 +35,17 @@ class Cmd(IntEnum):
     PAUSE_PRINT = 129
     STOP_PRINT = 130
     RESUME_PRINT = 131
+    GET_FILE_LIST = 258
+    GET_PRINT_HISTORY = 320
     GET_CANVAS_STATUS = 324
+    # Cmd 403 is overloaded — the payload shape dispatches:
+    # {"PrintSpeedPct": N}                            → set print speed
+    # {"TargetFanSpeed": {"ModelFan":...,"BoxFan":...,"AuxiliaryFan":...}}
+    #                                                 → set fan speeds
+    # {"TempTargetNozzle": N, "TempTargetHotbed": N, "TempTargetBox": N}
+    #                                                 → set heater targets
+    # Confirmed live against firmware V0.3.0-o on 2026-06-03.
+    CHANGE_PRINT_PARAMS = 403
     SUBSCRIBE = 512
 
 

{pycentauri-0.4.2 → pycentauri-0.5.0}/src/pycentauri/server.py

@@ -20,6 +20,8 @@ Surfaces (register with ``centauri server``):
 * ``GET /events/status`` — Server-Sent Events stream of live status pushes
 * ``POST /print/{start,pause,resume,stop}`` — only registered when the
   server is launched with ``--enable-control``.
+* ``POST /print/{speed,fan,temperature}`` — runtime adjust of print speed,
+  fan speeds, and heater targets. Same ``--enable-control`` gate.
 """
 
 from __future__ import annotations
@@ -224,6 +226,30 @@ class StartPrintBody(BaseModel):
     timelapse: bool = False
 
 
+class PrintSpeedBody(BaseModel):
+    """Print-speed mode. Firmware accepts only 4 discrete values."""
+
+    mode: str | int = Field(
+        ...,
+        description=(
+            "Mode name ('silent'|'balanced'|'sport'|'ludicrous') or "
+            "the corresponding PrintSpeedPct value (50|100|130|160)."
+        ),
+    )
+
+
+class FanSpeedBody(BaseModel):
+    model: int | None = Field(None, ge=0, le=100)
+    auxiliary: int | None = Field(None, ge=0, le=100)
+    chamber: int | None = Field(None, ge=0, le=100)
+
+
+class TemperatureBody(BaseModel):
+    nozzle: float | None = Field(None, ge=0, le=300)
+    bed: float | None = Field(None, ge=0, le=110)
+    chamber: float | None = Field(None, ge=0, le=60)
+
+
 # --- Dependency helpers -----------------------------------------------------
 
 
@@ -566,6 +592,48 @@ def create_app(
             raise HTTPException(status_code=502, detail=str(err)) from err
         return {"ok": True, "response": result.inner}
 
+    @app.post("/print/speed", tags=["control"])
+    async def set_speed(
+        body: PrintSpeedBody, manager: PrinterManager = Depends(require_control)
+    ) -> dict[str, Any]:
+        try:
+            result = await manager.printer.set_print_speed(body.mode)
+        except ValueError as err:
+            raise HTTPException(status_code=400, detail=str(err)) from err
+        except PrinterError as err:
+            raise HTTPException(status_code=502, detail=str(err)) from err
+        return {"ok": True, "response": result.inner}
+
+    @app.post("/print/fan", tags=["control"])
+    async def set_fan(
+        body: FanSpeedBody, manager: PrinterManager = Depends(require_control)
+    ) -> dict[str, Any]:
+        try:
+            result = await manager.printer.set_fan_speed(
+                model=body.model,
+                auxiliary=body.auxiliary,
+                chamber=body.chamber,
+            )
+        except ValueError as err:
+            raise HTTPException(status_code=400, detail=str(err)) from err
+        except PrinterError as err:
+            raise HTTPException(status_code=502, detail=str(err)) from err
+        return {"ok": True, "response": result.inner}
+
+    @app.post("/print/temperature", tags=["control"])
+    async def set_temperature(
+        body: TemperatureBody, manager: PrinterManager = Depends(require_control)
+    ) -> dict[str, Any]:
+        try:
+            result = await manager.printer.set_temperatures(
+                nozzle=body.nozzle, bed=body.bed, chamber=body.chamber
+            )
+        except ValueError as err:
+            raise HTTPException(status_code=400, detail=str(err)) from err
+        except PrinterError as err:
+            raise HTTPException(status_code=502, detail=str(err)) from err
+        return {"ok": True, "response": result.inner}
+
     return app
 
 

{pycentauri-0.4.2 → pycentauri-0.5.0}/src/pycentauri/web/app.js

@@ -1,6 +1,7 @@
 // pycentauri web console
 // Consumes /api/info, /status, /events/status (SSE), /attributes.
-// Posts to /print/{pause,resume,stop} when --enable-control is on.
+// Posts to /print/{pause,resume,stop} and /print/{speed,fan,temperature}
+// when --enable-control is on.
 
 const $ = (id) => document.getElementById(id);
 
@@ -86,7 +87,10 @@ async function loadInfo() {
     $("mainboard").textContent = info.mainboard_id || "—";
     $("mainboard").title = info.mainboard_id || "";
 
-    if (info.enable_control) $("controls").hidden = false;
+    if (info.enable_control) {
+      $("controls").hidden = false;
+      $("adjust").hidden = false;
+    }
 
     try {
       const attrs = await (await fetch("/attributes")).json();
@@ -151,6 +155,11 @@ function renderStatus(raw) {
 
   // Speed %
   $("speed").textContent = (pi.PrintSpeedPct != null) ? `${pi.PrintSpeedPct}%` : "—";
+  reflectSpeedMode(pi.PrintSpeedPct);
+
+  // Hydrate ADJUST controls from live values + retune poll cadence.
+  hydrateAdjust(raw);
+  noteStatusForPoll(pstatus);
 
   // Temperatures
   const noz  = raw.TempOfNozzle, nozT = raw.TempTargetNozzle;
@@ -208,15 +217,17 @@ function connectSSE() {
   try { src = new EventSource("/events/status"); }
   catch (_) {
     setStatusPill("warn", "SSE N/A");
-    setInterval(pollOnce, 3000);
     return;
   }
   src.addEventListener("status", (ev) => {
     try { renderStatus(JSON.parse(ev.data)); } catch (_) {}
   });
+  // SSE in Firefox is prone to silent stalls — the connection appears
+  // open but no events arrive. `onerror` fires once and the browser's
+  // auto-reconnect doesn't always kick in. The pollOnce safety net in
+  // main() compensates regardless; here we just surface the wait state.
   src.onerror = () => {
     setStatusPill("warn", "LINK WAIT");
-    setTimeout(pollOnce, 2000);
   };
 }
 
@@ -270,6 +281,166 @@ function wireControls() {
   });
 }
 
+// ---------------------------------------------------------------------------
+// Live adjust (Cmd 403 family) — print speed, fan, temperature
+
+function setAdjMsg(text, kind) {
+  const el = $("adj-msg");
+  el.classList.remove("ok", "warn", "err");
+  if (kind) el.classList.add(kind);
+  el.textContent = text || "";
+}
+
+// Two-way bind a slider/number pair sharing a base id (`${base}` for number,
+// `${base}-slider` for slider). Returns a getter for the current value.
+function bindPair(base) {
+  const num = $(`adj-${base}`);
+  const slider = $(`adj-${base}-slider`);
+  if (!num || !slider) return () => 0;
+  const clamp = (v) =>
+    Math.max(+num.min, Math.min(+num.max, Number.isFinite(+v) ? +v : 0));
+  slider.addEventListener("input", () => { num.value = String(clamp(slider.value)); });
+  num.addEventListener("input", () => { slider.value = String(clamp(num.value)); });
+  return () => clamp(num.value);
+}
+
+const ADJUST_TARGETS = {
+  "fan-model": {
+    label: "MODEL FAN",
+    path: "/print/fan",
+    build: (g) => ({ model: g("fan-model") }),
+  },
+  "fan-aux": {
+    label: "AUX FAN",
+    path: "/print/fan",
+    build: (g) => ({ auxiliary: g("fan-aux") }),
+  },
+  "fan-chamber": {
+    label: "CHAMBER FAN",
+    path: "/print/fan",
+    build: (g) => ({ chamber: g("fan-chamber") }),
+  },
+  "temp-nozzle": {
+    label: "NOZZLE TEMP",
+    path: "/print/temperature",
+    build: (g) => ({ nozzle: g("temp-nozzle") }),
+    confirm: (g) => g("temp-nozzle") > 240
+      ? `Set nozzle target to ${g("temp-nozzle")}°C ? High-temp; check filament rating.`
+      : null,
+  },
+  "temp-bed": {
+    label: "BED TEMP",
+    path: "/print/temperature",
+    build: (g) => ({ bed: g("temp-bed") }),
+    confirm: (g) => g("temp-bed") > 85
+      ? `Set bed target to ${g("temp-bed")}°C ? High-temp; check bed adhesive.`
+      : null,
+  },
+  "temp-chamber": {
+    label: "CHAMBER TEMP",
+    path: "/print/temperature",
+    build: (g) => ({ chamber: g("temp-chamber") }),
+  },
+};
+
+async function applyAdjust(target, getters) {
+  const spec = ADJUST_TARGETS[target];
+  if (!spec) return;
+  const get = (k) => getters[k] ? getters[k]() : 0;
+  const confirmMsg = spec.confirm ? spec.confirm(get) : null;
+  if (confirmMsg && !confirm(confirmMsg)) return;
+
+  setAdjMsg(`» ${spec.label}…`);
+  const btns = document.querySelectorAll("#adjust .kbd-btn");
+  for (const b of btns) b.disabled = true;
+
+  try {
+    const r = await fetch(spec.path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(spec.build(get)),
+    });
+    if (!r.ok) throw new Error(`HTTP ${r.status} — ${await r.text()}`);
+    setAdjMsg(`✓ ${spec.label} acknowledged`, "ok");
+  } catch (e) {
+    setAdjMsg(`✗ ${spec.label}: ${e.message}`, "err");
+  } finally {
+    setTimeout(() => { for (const b of btns) b.disabled = false; }, 600);
+  }
+}
+
+// Hydrate the ADJUST sliders/inputs from a status push. Skips any control
+// that currently has focus (so a live SSE update doesn't yank a value out
+// from under the user mid-drag or mid-type).
+function hydrateAdjust(raw) {
+  if (!$("adjust")) return;
+  const fans = raw.CurrentFanSpeed || {};
+  const targets = [
+    ["fan-model",    fans.ModelFan],
+    ["fan-aux",      fans.AuxiliaryFan],
+    ["fan-chamber",  fans.BoxFan],
+    ["temp-nozzle",  raw.TempTargetNozzle],
+    ["temp-bed",     raw.TempTargetHotbed],
+    ["temp-chamber", raw.TempTargetBox],
+  ];
+  for (const [base, v] of targets) {
+    if (v == null) continue;
+    const num = $(`adj-${base}`);
+    const slider = $(`adj-${base}-slider`);
+    if (!num || !slider) continue;
+    if (document.activeElement === num || document.activeElement === slider) continue;
+    const rounded = String(Math.round(+v));
+    num.value = rounded;
+    slider.value = rounded;
+  }
+}
+
+async function applySpeedMode(mode) {
+  setAdjMsg(`» SPEED MODE → ${mode.toUpperCase()}…`);
+  const btns = document.querySelectorAll("#adjust .kbd-btn");
+  for (const b of btns) b.disabled = true;
+  try {
+    const r = await fetch("/print/speed", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ mode }),
+    });
+    if (!r.ok) throw new Error(`HTTP ${r.status} — ${await r.text()}`);
+    setAdjMsg(`✓ SPEED MODE → ${mode.toUpperCase()} acknowledged · only effective mid-print`, "ok");
+  } catch (e) {
+    setAdjMsg(`✗ SPEED MODE: ${e.message}`, "err");
+  } finally {
+    setTimeout(() => { for (const b of btns) b.disabled = false; }, 600);
+  }
+}
+
+// Visually highlight the mode that matches the live PrintSpeedPct.
+function reflectSpeedMode(pct) {
+  if (pct == null) return;
+  for (const btn of document.querySelectorAll("#adj-speed-modes .adj-mode")) {
+    const v = { silent: 50, balanced: 100, sport: 130, ludicrous: 160 }[btn.dataset.mode];
+    btn.classList.toggle("active", +pct === v);
+  }
+}
+
+function wireAdjust() {
+  if (!$("adjust")) return;
+  const getters = {
+    "fan-model":     bindPair("fan-model"),
+    "fan-aux":       bindPair("fan-aux"),
+    "fan-chamber":   bindPair("fan-chamber"),
+    "temp-nozzle":   bindPair("temp-nozzle"),
+    "temp-bed":      bindPair("temp-bed"),
+    "temp-chamber":  bindPair("temp-chamber"),
+  };
+  for (const btn of document.querySelectorAll("#adjust .adj-apply")) {
+    btn.addEventListener("click", () => applyAdjust(btn.dataset.target, getters));
+  }
+  for (const btn of document.querySelectorAll("#adj-speed-modes .adj-mode")) {
+    btn.addEventListener("click", () => applySpeedMode(btn.dataset.mode));
+  }
+}
+
 // ---------------------------------------------------------------------------
 // RTSP bridge
 
@@ -405,8 +576,41 @@ function wireWebcamKeepalive() {
 
 // ---------------------------------------------------------------------------
 
+// Adaptive backup poll. SSE is the primary update path; this poll keeps
+// the UI alive when SSE silently stalls (Firefox in particular). Rate
+// follows the printer's state: fast while actively printing, slow when
+// idle/paused/done/errored, so we're not hammering the firmware at
+// 2 Hz when nothing is happening.
+const IDLE_STATUSES = new Set([0, 6, 8, 9, 14]); // idle, paused, stopped, completed, error
+const POLL_FAST_MS = 2000;
+const POLL_SLOW_MS = 10000;
+let pollTimer = null;
+let lastPrintStatus = null;
+
+function pollIntervalMs() {
+  return (lastPrintStatus != null && !IDLE_STATUSES.has(lastPrintStatus))
+    ? POLL_FAST_MS : POLL_SLOW_MS;
+}
+
+function schedulePoll() {
+  if (pollTimer) clearTimeout(pollTimer);
+  pollTimer = setTimeout(async () => {
+    await pollOnce();
+    schedulePoll();
+  }, pollIntervalMs());
+}
+
+function noteStatusForPoll(pstatus) {
+  const prev = lastPrintStatus;
+  lastPrintStatus = pstatus;
+  const wasActive = prev != null && !IDLE_STATUSES.has(prev);
+  const nowActive = pstatus != null && !IDLE_STATUSES.has(pstatus);
+  if (wasActive !== nowActive) schedulePoll(); // retune immediately
+}
+
 (async function main() {
   wireControls();
+  wireAdjust();
   wireRtsp();
   wireWebcamKeepalive();
   await loadInfo();
@@ -416,4 +620,5 @@ function wireWebcamKeepalive() {
   setInterval(loadInfo, 60000);
   // RTSP state changes are external, poll occasionally.
   setInterval(loadRtsp, 8000);
+  schedulePoll();
 })();

{pycentauri-0.4.2 → pycentauri-0.5.0}/src/pycentauri/web/index.html

@@ -111,6 +111,85 @@
         </div>
         <div class="ctrl-msg" id="ctrl-msg" aria-live="polite"></div>
       </div>
+
+      <!-- Live-adjust panel (Cmd 403 family) -->
+      <div class="panel adjust" id="adjust" hidden>
+        <header class="panel-header">
+          <span class="panel-tag">ADJUST</span>
+          <span class="panel-rule"></span>
+          <span class="panel-idx">07</span>
+        </header>
+
+        <div class="adj-sub">SPEED MODE · ACTIVE PRINT ONLY</div>
+        <div class="adj-modes" id="adj-speed-modes">
+          <button class="kbd-btn adj-mode" data-mode="silent"    type="button">
+            <span class="kbd-key">50%</span><span class="kbd-label">SILENT</span>
+          </button>
+          <button class="kbd-btn adj-mode" data-mode="balanced"  type="button">
+            <span class="kbd-key">100%</span><span class="kbd-label">BALANCED</span>
+          </button>
+          <button class="kbd-btn adj-mode" data-mode="sport"     type="button">
+            <span class="kbd-key">130%</span><span class="kbd-label">SPORT</span>
+          </button>
+          <button class="kbd-btn adj-mode" data-mode="ludicrous" type="button">
+            <span class="kbd-key">160%</span><span class="kbd-label">LUDICROUS</span>
+          </button>
+        </div>
+
+        <div class="adj-sub">FANS · 0–100%</div>
+        <div class="adj-row">
+          <label class="adj-lbl" for="adj-fan-model">MODEL</label>
+          <input type="range" id="adj-fan-model-slider" min="0" max="100" step="1" value="0">
+          <input type="number" id="adj-fan-model" min="0" max="100" step="1" value="0">
+          <button class="kbd-btn adj-apply" data-target="fan-model" type="button">
+            <span class="kbd-label">APPLY</span>
+          </button>
+        </div>
+        <div class="adj-row">
+          <label class="adj-lbl" for="adj-fan-aux">AUX</label>
+          <input type="range" id="adj-fan-aux-slider" min="0" max="100" step="1" value="0">
+          <input type="number" id="adj-fan-aux" min="0" max="100" step="1" value="0">
+          <button class="kbd-btn adj-apply" data-target="fan-aux" type="button">
+            <span class="kbd-label">APPLY</span>
+          </button>
+        </div>
+        <div class="adj-row">
+          <label class="adj-lbl" for="adj-fan-chamber">CHAMBER</label>
+          <input type="range" id="adj-fan-chamber-slider" min="0" max="100" step="1" value="0">
+          <input type="number" id="adj-fan-chamber" min="0" max="100" step="1" value="0">
+          <button class="kbd-btn adj-apply" data-target="fan-chamber" type="button">
+            <span class="kbd-label">APPLY</span>
+          </button>
+        </div>
+
+        <div class="adj-sub">HEATERS · 0 = OFF</div>
+        <div class="adj-row">
+          <label class="adj-lbl" for="adj-temp-nozzle">NOZZLE <span class="adj-unit">°C</span></label>
+          <input type="range" id="adj-temp-nozzle-slider" min="0" max="300" step="5" value="0">
+          <input type="number" id="adj-temp-nozzle" min="0" max="300" step="1" value="0">
+          <button class="kbd-btn adj-apply" data-target="temp-nozzle" type="button">
+            <span class="kbd-label">APPLY</span>
+          </button>
+        </div>
+        <div class="adj-row">
+          <label class="adj-lbl" for="adj-temp-bed">BED <span class="adj-unit">°C</span></label>
+          <input type="range" id="adj-temp-bed-slider" min="0" max="110" step="5" value="0">
+          <input type="number" id="adj-temp-bed" min="0" max="110" step="1" value="0">
+          <button class="kbd-btn adj-apply" data-target="temp-bed" type="button">
+            <span class="kbd-label">APPLY</span>
+          </button>
+        </div>
+        <div class="adj-row">
+          <label class="adj-lbl" for="adj-temp-chamber">CHAMBER <span class="adj-unit">°C</span></label>
+          <input type="range" id="adj-temp-chamber-slider" min="0" max="60" step="1" value="0">
+          <input type="number" id="adj-temp-chamber" min="0" max="60" step="1" value="0">
+          <button class="kbd-btn adj-apply" data-target="temp-chamber" type="button">
+            <span class="kbd-label">APPLY</span>
+          </button>
+        </div>
+
+        <div class="ctrl-msg" id="adj-msg" aria-live="polite"></div>
+      </div>
     </section>
 
     <!-- RIGHT column — instruments -->

{pycentauri-0.4.2 → pycentauri-0.5.0}/src/pycentauri/web/styles.css

@@ -162,7 +162,6 @@ body {
   background: var(--rule-soft);
   position: relative;
   z-index: 1;
-  min-height: 0;
 }
 
 .viewport-col,
@@ -711,6 +710,124 @@ body {
 .ctrl-msg.warn { border-left-color: var(--warn);   color: var(--warn); }
 .ctrl-msg.err  { border-left-color: var(--danger); color: var(--danger); }
 
+/* ---- Adjust panel (Cmd 403 family) ------------------------ */
+
+.panel.adjust { padding-bottom: 14px; }
+
+.adj-row {
+  display: grid;
+  grid-template-columns: 90px 1fr 64px auto;
+  gap: 8px;
+  align-items: center;
+  margin-top: 8px;
+}
+
+.adj-lbl {
+  font-family: var(--f-label);
+  font-size: 11px;
+  font-weight: 600;
+  letter-spacing: 0.18em;
+  color: var(--fg-dim);
+}
+.adj-lbl .adj-unit {
+  color: var(--fg-faint);
+  margin-left: 4px;
+  font-weight: 400;
+}
+
+.adj-sub {
+  margin: 16px 0 -2px;
+  padding-bottom: 4px;
+  border-bottom: 1px dashed var(--rule);
+  font-family: var(--f-label);
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.22em;
+  color: var(--amber-deep);
+}
+
+.adj-row input[type="range"] {
+  -webkit-appearance: none;
+  appearance: none;
+  width: 100%;
+  height: 4px;
+  background: var(--bg-inset);
+  border: 1px solid var(--rule);
+  border-radius: 0;
+  outline: none;
+}
+.adj-row input[type="range"]::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  appearance: none;
+  width: 12px;
+  height: 18px;
+  background: var(--amber);
+  border: 1px solid var(--amber-deep);
+  cursor: pointer;
+  border-radius: 0;
+}
+.adj-row input[type="range"]::-moz-range-thumb {
+  width: 12px;
+  height: 18px;
+  background: var(--amber);
+  border: 1px solid var(--amber-deep);
+  cursor: pointer;
+  border-radius: 0;
+}
+
+.adj-row input[type="number"] {
+  background: var(--bg-inset);
+  border: 1px solid var(--rule);
+  color: var(--fg);
+  font-family: var(--f-mono);
+  font-size: 13px;
+  text-align: right;
+  padding: 6px 8px;
+  width: 100%;
+  border-radius: 0;
+  outline: none;
+  -moz-appearance: textfield;
+}
+.adj-row input[type="number"]::-webkit-outer-spin-button,
+.adj-row input[type="number"]::-webkit-inner-spin-button {
+  -webkit-appearance: none;
+  margin: 0;
+}
+.adj-row input[type="number"]:focus,
+.adj-row input[type="range"]:focus {
+  border-color: var(--amber);
+}
+
+.adj-row .adj-apply {
+  padding: 8px 10px;
+  border-bottom-width: 2px;
+}
+.adj-row .adj-apply .kbd-label {
+  font-size: 11px;
+  letter-spacing: 0.18em;
+}
+
+#adj-msg { margin-top: 14px; }
+
+.adj-modes {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: 6px;
+  margin-top: 8px;
+}
+.adj-modes .adj-mode {
+  padding: 10px 6px;
+  border-bottom-width: 2px;
+}
+.adj-modes .adj-mode .kbd-key { font-size: 10px; color: var(--fg-faint); }
+.adj-modes .adj-mode .kbd-label { font-size: 10.5px; letter-spacing: 0.14em; }
+.adj-modes .adj-mode.active {
+  border-color: var(--amber);
+  color: var(--amber);
+  background: #1a1812;
+}
+.adj-modes .adj-mode.active .kbd-key { color: var(--amber-deep); }
+
 /* ---- RTSP panel ------------------------------------------- */
 
 .rtsp-panel { padding-bottom: 14px; }

{pycentauri-0.4.2 → pycentauri-0.5.0}/tests/test_client.py

@@ -247,3 +247,66 @@ async def test_control_enabled_sends_commands(monkeypatch: pytest.MonkeyPatch) -
 
         cmds = [m["Data"]["Cmd"] for m in server.received]
         assert int(Cmd.PAUSE_PRINT) in cmds
+
+
+async def test_adjust_methods_round_trip(monkeypatch: pytest.MonkeyPatch) -> None:
+    async with _fake_printer() as server:
+        monkeypatch.setattr("pycentauri.client.WS_PORT", server.port)
+        async with await Printer.connect("127.0.0.1", enable_control=True) as printer:
+            await asyncio.wait_for(printer.wait_for_mainboard(), timeout=2)
+
+            await asyncio.wait_for(printer.set_print_speed("sport"), timeout=3)
+            await asyncio.wait_for(printer.set_print_speed(100), timeout=3)
+            await asyncio.wait_for(printer.set_fan_speed(model=50, chamber=25), timeout=3)
+            await asyncio.wait_for(printer.set_temperatures(nozzle=210, bed=60), timeout=3)
+
+        sent = [m["Data"] for m in server.received if m["Data"]["Cmd"] == 403]
+        assert len(sent) == 4
+        speed_named, speed_int, fan, temp = sent
+        assert speed_named["Data"] == {"PrintSpeedPct": 130}
+        assert speed_int["Data"] == {"PrintSpeedPct": 100}
+        assert fan["Data"] == {"TargetFanSpeed": {"ModelFan": 50, "BoxFan": 25}}
+        assert temp["Data"] == {"TempTargetNozzle": 210.0, "TempTargetHotbed": 60.0}
+
+
+async def test_adjust_validation_rejects_out_of_range(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    async with _fake_printer() as server:
+        monkeypatch.setattr("pycentauri.client.WS_PORT", server.port)
+        async with await Printer.connect("127.0.0.1", enable_control=True) as printer:
+            await asyncio.wait_for(printer.wait_for_mainboard(), timeout=2)
+
+            import pytest as _pt
+
+            with _pt.raises(ValueError):
+                await printer.set_print_speed(120)  # not a canonical mode value
+            with _pt.raises(ValueError):
+                await printer.set_print_speed("turbo")  # unknown mode name
+            with _pt.raises(ValueError):
+                await printer.set_fan_speed(model=150)
+            with _pt.raises(ValueError):
+                await printer.set_temperatures(nozzle=400)
+            with _pt.raises(ValueError):
+                await printer.set_fan_speed()
+            with _pt.raises(ValueError):
+                await printer.set_temperatures()
+
+
+async def test_adjust_disabled_without_control(monkeypatch: pytest.MonkeyPatch) -> None:
+    from pycentauri.client import ControlDisabledError
+
+    async with _fake_printer() as server:
+        monkeypatch.setattr("pycentauri.client.WS_PORT", server.port)
+        async with await Printer.connect("127.0.0.1") as printer:
+            await asyncio.wait_for(printer.wait_for_mainboard(), timeout=2)
+            for call in (
+                lambda: printer.set_print_speed(100),
+                lambda: printer.set_fan_speed(model=50),
+                lambda: printer.set_temperatures(nozzle=200),
+            ):
+                try:
+                    await call()
+                except ControlDisabledError:
+                    continue
+                raise AssertionError("expected ControlDisabledError")

{pycentauri-0.4.2 → pycentauri-0.5.0}/tests/test_server.py

@@ -97,6 +97,59 @@ async def test_control_endpoints_registered_when_enabled(monkeypatch: pytest.Mon
     await server.stop()
 
 
+async def test_adjust_endpoints_registered_when_enabled(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    server = _FakePrinter()
+    await server.start()
+    monkeypatch.setattr("pycentauri.client.WS_PORT", server.port)
+
+    app = server_module.create_app("127.0.0.1", enable_control=True, mainboard_id=MAINBOARD)
+    async with app.router.lifespan_context(app), await _asgi_client(app) as client:
+        r = await client.post("/print/speed", json={"mode": "sport"})
+        assert r.status_code == 200
+        assert r.json()["ok"] is True
+
+        r = await client.post("/print/fan", json={"model": 30, "chamber": 50})
+        assert r.status_code == 200
+
+        r = await client.post("/print/temperature", json={"nozzle": 200, "bed": 55})
+        assert r.status_code == 200
+
+        # No-target → 400 from the library
+        r = await client.post("/print/fan", json={})
+        assert r.status_code == 400
+
+        # Pydantic-level bounds (≥0, ≤100) → 422
+        r = await client.post("/print/fan", json={"model": 150})
+        assert r.status_code == 422
+
+    from pycentauri.sdcp import Cmd as _Cmd
+
+    sent = [m["Data"] for m in server.received if m["Data"]["Cmd"] == int(_Cmd.CHANGE_PRINT_PARAMS)]
+    assert len(sent) == 3
+    speed, fan, temp = sent
+    assert speed["Data"] == {"PrintSpeedPct": 130}
+    assert fan["Data"] == {"TargetFanSpeed": {"ModelFan": 30, "BoxFan": 50}}
+    assert temp["Data"] == {"TempTargetNozzle": 200.0, "TempTargetHotbed": 55.0}
+    await server.stop()
+
+
+async def test_adjust_endpoints_404_without_control(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    server = _FakePrinter()
+    await server.start()
+    monkeypatch.setattr("pycentauri.client.WS_PORT", server.port)
+
+    app = server_module.create_app("127.0.0.1", mainboard_id=MAINBOARD)
+    async with app.router.lifespan_context(app), await _asgi_client(app) as client:
+        for path in ("/print/speed", "/print/fan", "/print/temperature"):
+            r = await client.post(path, json={})
+            assert r.status_code == 404, path
+    await server.stop()
+
+
 async def test_rtsp_disabled_by_default(monkeypatch: pytest.MonkeyPatch) -> None:
     server = _FakePrinter()
     await server.start()