pycentauri 0.6.0__tar.gz → 0.6.2__tar.gz

{pycentauri-0.6.0 → pycentauri-0.6.2}/CHANGELOG.md

@@ -6,6 +6,53 @@ Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.6.2] - 2026-07-05
+
+### Changed
+- **CC2 speed-mode persistence redesigned as pin-and-enforce.** The
+  0.6.1 snapshot-per-switch restore lost an arms race with the
+  firmware: after eight consecutive successful restores, a reset
+  arriving outside the covered window (late after a restore, or
+  mid-print with no switch at all — observed 2026-07-05 ~15:00)
+  poisoned the baseline and silently disabled every restore after it.
+  The firmware only ever resets TO balanced, so the model is now: the
+  mode you set is pinned (immediately via pycentauri; after holding
+  15 s when set from the touchscreen, since a non-balanced mode can
+  only come from a human), and any disagreement lasting 12 s while
+  printing is re-applied, at most every 30 s. One consequence,
+  deliberate: while a mode is pinned, selecting *balanced* from the
+  touchscreen is indistinguishable from a firmware reset and will be
+  reverted — switch to balanced through pycentauri instead, which
+  re-pins. Pins clear when the print ends, and ``speed auto`` (CLI),
+  ``{"mode": "auto"}`` (HTTP), or the web UI's Auto button release the
+  pin explicitly, returning speed control to the printer.
+- Root cause fully mapped (wire captures, 2026-07-05): every reset is
+  a **service operation** — full filament switches, plus brief nozzle
+  wipe / purge operations at the chute that are too short to register
+  as "switching" — and a human's touchscreen tap is byte-identical to
+  a firmware reset on the wire, so balanced-from-touchscreen cannot be
+  auto-detected while a pin is active. Use Auto or set balanced via
+  pycentauri instead.
+
+## [0.6.1] - 2026-07-05
+
+### Fixed
+- **CC2: the user's speed mode now survives Canvas filament switches.**
+  The firmware resets `speed_mode` to balanced on every mid-print
+  switch and leaves it there (verified 2026-07-05: mode stayed reset
+  after the switch completed). `CC2Printer` now snapshots the mode in
+  effect when a switch begins and re-applies it once printing resumes —
+  regardless of whether the mode was set via pycentauri or the
+  touchscreen. Requires `enable_control`; read-only sessions log the
+  reset instead. The restore baseline is debounced (a mode must hold
+  15 s to count) because the firmware fires its reset several seconds
+  *before* the head parks — without the debounce, that transient
+  poisoned the snapshot. Verified across two hands-free switch cycles
+  with journal-logged restores ~3 s after each resume.
+- `centauri server` now surfaces pycentauri's own log lines (speed-mode
+  restores, reconnects) in its output — previously only uvicorn's
+  loggers were configured and library INFO logs were invisible.
+
 ## [0.6.0] - 2026-07-05
 
 ### Added

{pycentauri-0.6.0 → pycentauri-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycentauri
-Version: 0.6.0
+Version: 0.6.2
 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
@@ -407,6 +407,14 @@ reports code 27 the entire time the head is parked there mid-print.
   cooldown of a few seconds during which the broker silently drops
   responses. pycentauri's polling cadence stays under it; your scripts
   should too.
+- **The firmware keeps resetting the speed mode to balanced.** Around
+  every Canvas filament switch (starting seconds *before* the head
+  parks), and occasionally mid-print with no switch at all. pycentauri
+  pins the mode you set and re-applies it whenever the printer drifts
+  from it for more than ~12 s while printing (needs
+  `--enable-control`). Caveat: while a mode is pinned, picking
+  *balanced* on the touchscreen looks identical to a firmware reset
+  and will be reverted — set balanced through pycentauri instead.
 - **Registrations expire without an app-level PING.** The printer
   forgets a registered client after several quiet minutes and silently
   stops answering that session's requests — the MQTT connection itself

{pycentauri-0.6.0 → pycentauri-0.6.2}/README.md

@@ -357,6 +357,14 @@ reports code 27 the entire time the head is parked there mid-print.
   cooldown of a few seconds during which the broker silently drops
   responses. pycentauri's polling cadence stays under it; your scripts
   should too.
+- **The firmware keeps resetting the speed mode to balanced.** Around
+  every Canvas filament switch (starting seconds *before* the head
+  parks), and occasionally mid-print with no switch at all. pycentauri
+  pins the mode you set and re-applies it whenever the printer drifts
+  from it for more than ~12 s while printing (needs
+  `--enable-control`). Caveat: while a mode is pinned, picking
+  *balanced* on the touchscreen looks identical to a firmware reset
+  and will be reverted — set balanced through pycentauri instead.
 - **Registrations expire without an app-level PING.** The printer
   forgets a registered client after several quiet minutes and silently
   stops answering that session's requests — the MQTT connection itself

{pycentauri-0.6.0 → pycentauri-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pycentauri"
-version = "0.6.0"
+version = "0.6.2"
 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.6.0 → pycentauri-0.6.2}/src/pycentauri/__init__.py

@@ -39,4 +39,4 @@ __all__ = [
     "discover",
 ]
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"

{pycentauri-0.6.0 → pycentauri-0.6.2}/src/pycentauri/cc2.py

@@ -17,6 +17,7 @@ import contextlib
 import json
 import logging
 import random
+import time
 from collections.abc import AsyncIterator
 from typing import Any, ClassVar
 
@@ -39,6 +40,21 @@ log = logging.getLogger(__name__)
 MQTT_PORT = 1883
 CC2_USERNAME = "elegoo"
 PING_INTERVAL_S = 30.0
+# Speed-mode pinning. The firmware only ever resets speed_mode TO balanced
+# (1) — before filament switches (observed at T-6..10s before the head
+# parks), sometimes again after a restore, and occasionally mid-print with
+# no switch at all (observed 2026-07-05 ~15:00). A snapshot-per-switch
+# design lost that arms race, so instead the mode a user selects is PINNED
+# and enforced: a disagreement lasting ENFORCE_AFTER_S while printing gets
+# re-applied, at most once per ENFORCE_MIN_INTERVAL_S. A sustained
+# non-balanced mode from the touchscreen (held PIN_LEARN_S) adopts the pin,
+# since the firmware never resets to a non-balanced mode.
+# PIN_LEARN_S must be SHORTER than ENFORCE_AFTER_S: a touchscreen change to
+# a non-balanced mode has to be adopted as the new pin before enforcement
+# would revert it, or screen users could never override a pinned mode.
+PIN_LEARN_S = 8.0
+ENFORCE_AFTER_S = 12.0
+ENFORCE_MIN_INTERVAL_S = 30.0
 # Lifecycle commands (start/pause/stop/resume) are answered only after the
 # firmware finishes the mechanical sequence — a resume reheats and unparks
 # before responding, easily exceeding the default 15 s request timeout
@@ -264,6 +280,14 @@ class CC2Printer(Printer):
         self._last_full_result: dict[str, Any] | None = None
         self._connect_error: str | None = None
         self._ping_task: asyncio.Task[None] | None = None
+        # Speed-mode pinning (see module constants for the rationale).
+        self._pinned_mode: int | None = None
+        self._pin_candidate: int | None = None
+        self._pin_candidate_since: float = 0.0
+        self._mismatch_since: float | None = None
+        self._last_enforce: float = float("-inf")
+        self._enforce_task: asyncio.Task[None] | None = None
+        self._now = time.monotonic  # overridable for tests
 
     @classmethod
     async def connect(
@@ -352,6 +376,7 @@ class CC2Printer(Printer):
         result = await self._cc2_request(1002, {}, timeout=timeout)
         self._last_full_result = result
         payload = _cc2_status_to_cc1(result)
+        self._track_speed_mode(payload)
         st = Status.from_payload(payload)
         self._latest_status = st
         self._latest_status_event.set()
@@ -432,6 +457,14 @@ class CC2Printer(Printer):
 
     async def set_print_speed(self, mode: str | int) -> sdcp.ParsedMessage:
         self._require_control("set_print_speed")
+        if isinstance(mode, str) and mode.strip().lower() == "auto":
+            # Release the pin: stop enforcing and let the printer (and its
+            # touchscreen) own the speed mode again. No wire command needed.
+            self._pinned_mode = None
+            self._pin_candidate = None
+            self._mismatch_since = None
+            log.info("speed-mode pin released (auto)")
+            return self._wrap_result(1031, {"error_code": 0, "pin": "released"})
         if isinstance(mode, str):
             key = mode.strip().lower()
             if key not in self.PRINT_SPEED_MODES:
@@ -447,6 +480,10 @@ class CC2Printer(Printer):
                     f"{sorted(self.PRINT_SPEED_MODES.values())}"
                 )
         result = await self._cc2_request(1031, {"mode": value})
+        # An explicit choice through pycentauri pins the mode.
+        self._pinned_mode = value
+        self._pin_candidate = None
+        self._mismatch_since = None
         return self._wrap_result(1031, result)
 
     async def set_fan_speed(
@@ -512,10 +549,11 @@ class CC2Printer(Printer):
         if self._closed:
             return
         self._closed = True
-        if self._ping_task is not None and not self._ping_task.done():
-            self._ping_task.cancel()
-            with contextlib.suppress(asyncio.CancelledError, Exception):
-                await self._ping_task
+        for task in (self._ping_task, self._enforce_task):
+            if task is not None and not task.done():
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError, Exception):
+                    await task
         if self._mqtt is not None:
             self._mqtt.disconnect()  # flush DISCONNECT before stopping the loop
             self._mqtt.loop_stop()
@@ -623,6 +661,7 @@ class CC2Printer(Printer):
                 return
             _deep_merge(self._last_full_result, result)
             payload = _cc2_status_to_cc1(self._last_full_result)
+            self._track_speed_mode(payload)
             st = Status.from_payload(payload)
             self._latest_status = st
             self._latest_status_event.set()
@@ -632,6 +671,85 @@ class CC2Printer(Printer):
         except Exception:
             log.exception("failed to handle CC2 status push")
 
+    def _track_speed_mode(self, payload: dict[str, Any]) -> None:
+        """Pin-and-enforce the user's speed mode (runs on the asyncio loop).
+
+        The firmware resets ``speed_mode`` to balanced around filament
+        switches and occasionally mid-print. Whatever mode the user set —
+        through pycentauri (pins immediately) or the touchscreen (pins
+        after holding ``PIN_LEARN_S``) — is re-applied whenever the
+        printer disagrees for ``ENFORCE_AFTER_S`` while printing. Only
+        non-balanced modes are learned from the wire, because a flip to
+        balanced is indistinguishable from a firmware reset.
+        """
+        print_status = payload.get("PrintInfo", {}).get("Status")
+        speed_mode = payload.get("_cc2", {}).get("speed_mode")
+        if not isinstance(speed_mode, int) or print_status is None:
+            return
+        if print_status in (0, 8, 9, 14):
+            # Print over (idle/stopped/completed/error): the pin dies with it.
+            self._pinned_mode = None
+            self._pin_candidate = None
+            self._mismatch_since = None
+            return
+        if print_status != 13:
+            # Switching filament, pausing, etc. — never learn or enforce
+            # here, and a mismatch clock from before doesn't carry across.
+            self._mismatch_since = None
+            return
+
+        now = self._now()
+
+        # Learn a pin from the wire: only non-balanced modes qualify.
+        if speed_mode != 1 and speed_mode != self._pinned_mode:
+            if self._pin_candidate == speed_mode:
+                if now - self._pin_candidate_since >= PIN_LEARN_S:
+                    self._pinned_mode = speed_mode
+                    self._pin_candidate = None
+                    self._mismatch_since = None
+            else:
+                self._pin_candidate = speed_mode
+                self._pin_candidate_since = now
+        elif speed_mode == self._pinned_mode:
+            self._pin_candidate = None
+
+        # Enforce the pin.
+        if self._pinned_mode is None or speed_mode == self._pinned_mode:
+            self._mismatch_since = None
+            return
+        if self._mismatch_since is None:
+            self._mismatch_since = now
+            return
+        if now - self._mismatch_since < ENFORCE_AFTER_S:
+            return
+        if self._enforce_task is not None and not self._enforce_task.done():
+            return
+        if now - self._last_enforce < ENFORCE_MIN_INTERVAL_S:
+            return
+        self._last_enforce = now
+        if self.enable_control:
+            self._launch_enforce(self._pinned_mode)
+        else:
+            log.warning(
+                "speed_mode drifted to %d but pin is %d; enable_control is off "
+                "so it will not be re-applied",
+                speed_mode,
+                self._pinned_mode,
+            )
+
+    def _launch_enforce(self, mode: int) -> None:
+        self._enforce_task = asyncio.create_task(
+            self._apply_pinned_mode(mode),
+            name=f"pycentauri-cc2-speedpin-{self.host}",
+        )
+
+    async def _apply_pinned_mode(self, mode: int) -> None:
+        try:
+            await self._cc2_request(1031, {"mode": mode})
+            log.info("re-applied pinned speed_mode %d", mode)
+        except Exception:
+            log.warning("could not re-apply pinned speed_mode %d", mode, exc_info=True)
+
     def _publish_register(self) -> None:
         topic = f"elegoo/{self._serial_number}/api_register"
         payload = json.dumps({"client_id": self._client_id, "request_id": self._request_id_prefix})

{pycentauri-0.6.0 → pycentauri-0.6.2}/src/pycentauri/cli.py

@@ -378,7 +378,8 @@ def cmd_speed(
         str,
         typer.Argument(
             help="Speed mode: silent | balanced | sport | ludicrous "
-            "(or the integer 50 | 100 | 130 | 160).",
+            "(or the integer 50 | 100 | 130 | 160). On a CC2, 'auto' "
+            "releases the speed pin and stops enforcing a mode.",
         ),
     ],
     host: HostOpt = None,

{pycentauri-0.6.0 → pycentauri-0.6.2}/src/pycentauri/server.py

@@ -747,6 +747,11 @@ def run(
     """
     import uvicorn
 
+    # Surface pycentauri's own log lines (reconnects, speed-mode restores)
+    # in the journal — uvicorn only configures its own loggers, and the
+    # root logger's lastResort handler hides INFO.
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s:%(name)s: %(message)s")
+
     app = create_app(
         host,
         enable_control=enable_control,

{pycentauri-0.6.0 → pycentauri-0.6.2}/src/pycentauri/web/index.html

@@ -79,6 +79,10 @@
           <button class="btn adj-mode" data-mode="ludicrous" type="button">
             <small>160%</small> Ludicrous
           </button>
+          <button class="btn adj-mode" data-mode="auto" type="button"
+                  title="Release the speed pin (CC2): stop enforcing a mode and let the printer/touchscreen own it.">
+            <small>CC2</small> Auto
+          </button>
         </div>
 
         <div class="adj-sub">Fans</div>

{pycentauri-0.6.0 → pycentauri-0.6.2}/src/pycentauri/web/styles.css

@@ -467,7 +467,7 @@ body {
 
 .adj-modes {
   display: grid;
-  grid-template-columns: repeat(4, 1fr);
+  grid-template-columns: repeat(5, 1fr);
   gap: 4px;
   margin-top: 6px;
 }

{pycentauri-0.6.0 → pycentauri-0.6.2}/tests/test_cc2_mapping.py

@@ -270,3 +270,140 @@ def test_canvas_parse_survives_malformed_payloads() -> None:
         == 0
     )
     assert CanvasStatus.from_payload({"canvas_info": {"canvas_list": "bogus"}}).tray_count == 0
+
+
+# --- speed-mode pin & enforce ---------------------------------------------
+
+
+def _payload(status: int, mode: int) -> dict[str, Any]:
+    return {"PrintInfo": {"Status": status}, "_cc2": {"speed_mode": mode}}
+
+
+def _printer(enable_control: bool = True) -> Any:
+    from pycentauri.cc2 import CC2Printer
+
+    p = CC2Printer("127.0.0.1", access_code="x", enable_control=enable_control)
+    p._fired: list[int] = []
+    p._launch_enforce = p._fired.append  # record instead of spawning tasks
+    t = [0.0]
+    p._clock = t
+    p._now = lambda: t[0]
+    return p
+
+
+def _tick(p: Any, dt: float, status: int, mode: int) -> None:
+    p._clock[0] += dt
+    p._track_speed_mode(_payload(status, mode))
+
+
+def test_api_set_pins_immediately_and_enforces_after_grace() -> None:
+    p = _printer()
+    p._pinned_mode = 2  # what set_print_speed() records
+    _tick(p, 0, 13, 2)
+    assert p._fired == []
+    # Firmware resets to balanced mid-print; not enforced until it holds 12 s
+    _tick(p, 5, 13, 1)
+    _tick(p, 5, 13, 1)
+    assert p._fired == []
+    _tick(p, 5, 13, 1)  # mismatch has now persisted 10 s... (first at t=10)
+    _tick(p, 5, 13, 1)  # 15 s since mismatch start -> fires
+    assert p._fired == [2]
+
+
+def test_pre_switch_reset_window_never_fires() -> None:
+    """The 6-10 s balanced window before the head parks stays untouched."""
+    p = _printer()
+    p._pinned_mode = 2
+    _tick(p, 0, 13, 2)
+    _tick(p, 3, 13, 1)  # pre-switch reset
+    _tick(p, 3, 13, 1)  # 6 s in
+    _tick(p, 3, 27, 1)  # head parks -> mismatch clock cleared
+    _tick(p, 60, 27, 1)  # switch runs
+    assert p._fired == []
+    # Resume: reset persists, enforcement kicks in after the grace period
+    _tick(p, 5, 13, 1)
+    _tick(p, 13, 13, 1)
+    assert p._fired == [2]
+
+
+def test_screen_change_to_nonbalanced_becomes_pin() -> None:
+    p = _printer()
+    _tick(p, 0, 13, 1)  # printing at balanced, nothing pinned
+    _tick(p, 5, 13, 3)  # user picks ludicrous on the touchscreen
+    assert p._pinned_mode is None
+    _tick(p, 16, 13, 3)  # held > PIN_LEARN_S -> adopted
+    assert p._pinned_mode == 3
+    assert p._fired == []
+
+
+def test_balanced_is_never_learned_as_pin_while_pinned() -> None:
+    p = _printer()
+    p._pinned_mode = 2
+    _tick(p, 0, 13, 2)
+    # Sustained balanced (reset or screen tap) never displaces the pin...
+    _tick(p, 10, 13, 1)
+    _tick(p, 30, 13, 1)
+    assert p._pinned_mode == 2
+    # ...and enforcement fired for it
+    assert p._fired == [2]
+
+
+def test_no_pin_means_no_enforcement() -> None:
+    p = _printer()
+    _tick(p, 0, 13, 1)
+    _tick(p, 60, 13, 1)
+    assert p._fired == []
+
+
+def test_print_end_clears_pin() -> None:
+    p = _printer()
+    p._pinned_mode = 2
+    _tick(p, 0, 13, 2)
+    _tick(p, 5, 9, 1)  # completed
+    assert p._pinned_mode is None
+    _tick(p, 5, 13, 1)  # a new print at balanced: nothing enforced
+    _tick(p, 60, 13, 1)
+    assert p._fired == []
+
+
+def test_enforce_rate_limited() -> None:
+    p = _printer()
+    p._pinned_mode = 2
+    _tick(p, 0, 13, 2)
+    _tick(p, 5, 13, 1)
+    _tick(p, 13, 13, 1)  # fires (mismatch held 13 s)
+    _tick(p, 5, 13, 1)  # still mismatched, but inside the 30 s cooldown
+    _tick(p, 5, 13, 1)
+    assert p._fired == [2]
+    _tick(p, 30, 13, 1)  # cooldown over -> fires again
+    assert p._fired == [2, 2]
+
+
+def test_screen_override_beats_enforcement() -> None:
+    """A touchscreen change to a non-balanced mode must be learned BEFORE
+    enforcement of the old pin would revert it (PIN_LEARN_S < ENFORCE_AFTER_S)."""
+    p = _printer()
+    p._pinned_mode = 1  # balanced pinned via the API
+    _tick(p, 0, 13, 1)
+    _tick(p, 2, 13, 2)  # user picks sport on the screen (mismatch clock starts)
+    _tick(p, 5, 13, 2)  # 5 s held
+    _tick(p, 4, 13, 2)  # 9 s held: learned as the new pin, before 12 s enforcement
+    assert p._pinned_mode == 2
+    assert p._fired == []
+
+
+def test_auto_releases_pin() -> None:
+    import asyncio
+
+    p = _printer()
+    p._pinned_mode = 2
+
+    async def run() -> None:
+        result = await p.set_print_speed("auto")
+        assert result.inner["pin"] == "released"
+
+    asyncio.run(run())
+    assert p._pinned_mode is None
+    _tick(p, 0, 13, 1)
+    _tick(p, 60, 13, 1)  # balanced persists, nothing enforced
+    assert p._fired == []