pycentauri 0.6.1__tar.gz → 0.6.2__tar.gz

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

@@ -6,6 +6,34 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycentauri
-Version: 0.6.1
+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,10 +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.
-- **Canvas filament switches reset the speed mode.** Every mid-print
-  switch silently drops the printer back to balanced. pycentauri
-  detects the switch ending and re-applies whatever mode was active
-  before it (needs `--enable-control`).
+- **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.1 → pycentauri-0.6.2}/README.md

@@ -357,10 +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.
-- **Canvas filament switches reset the speed mode.** Every mid-print
-  switch silently drops the printer back to balanced. pycentauri
-  detects the switch ending and re-applies whatever mode was active
-  before it (needs `--enable-control`).
+- **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.1 → pycentauri-0.6.2}/pyproject.toml

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

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

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

@@ -40,11 +40,21 @@ log = logging.getLogger(__name__)
 MQTT_PORT = 1883
 CC2_USERNAME = "elegoo"
 PING_INTERVAL_S = 30.0
-# A speed mode must hold this long before it becomes the restore baseline —
-# the firmware resets speed_mode several seconds BEFORE the head parks for a
-# filament switch (observed 2026-07-05: reset at T-6s), and without the hold
-# that transient poisons the baseline.
-BASELINE_HOLD_S = 15.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
@@ -270,14 +280,13 @@ 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 restore across Canvas filament switches: the firmware
-        # resets speed_mode to balanced (1) on every mid-print switch
-        # (verified 2026-07-05 — mode stays 1 after the switch completes).
-        self._speed_mode_during_print: int | None = None
-        self._speed_mode_to_restore: int | None = None
-        self._restore_task: asyncio.Task[None] | None = None
-        self._mode_candidate: int | None = None
-        self._mode_candidate_since: float = 0.0
+        # 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
@@ -448,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:
@@ -463,12 +480,10 @@ class CC2Printer(Printer):
                     f"{sorted(self.PRINT_SPEED_MODES.values())}"
                 )
         result = await self._cc2_request(1031, {"mode": value})
-        # The user's explicit choice supersedes any pending post-switch
-        # restore and becomes the new baseline.
-        self._speed_mode_during_print = value
-        self._mode_candidate = None
-        if self._speed_mode_to_restore is not None:
-            self._speed_mode_to_restore = 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(
@@ -534,7 +549,7 @@ class CC2Printer(Printer):
         if self._closed:
             return
         self._closed = True
-        for task in (self._ping_task, self._restore_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):
@@ -657,73 +672,83 @@ class CC2Printer(Printer):
             log.exception("failed to handle CC2 status push")
 
     def _track_speed_mode(self, payload: dict[str, Any]) -> None:
-        """Restore the speed mode after a Canvas filament switch.
-
-        The firmware resets ``speed_mode`` to balanced on every mid-print
-        filament switch (verified 2026-07-05). We snapshot the mode in
-        effect when a switch starts (print_status 27) and re-apply it once
-        printing resumes, so the user's selection — made from any surface,
-        including the touchscreen — survives the switch. Requires
-        ``enable_control``; read-only sessions just log the reset.
+        """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 == 27:
-            if self._speed_mode_to_restore is None and self._speed_mode_during_print is not None:
-                self._speed_mode_to_restore = self._speed_mode_during_print
+        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
-        want = self._speed_mode_to_restore
-        if want is not None:
-            self._speed_mode_to_restore = None
-            if want != speed_mode:
-                if self.enable_control:
-                    self._restore_task = asyncio.create_task(
-                        self._restore_speed_mode(want),
-                        name=f"pycentauri-cc2-speedrestore-{self.host}",
-                    )
-                else:
-                    log.warning(
-                        "filament switch reset speed_mode %d -> %d; "
-                        "enable_control is off so it will not be restored",
-                        want,
-                        speed_mode,
-                    )
-                return
-        # Track the running mode, but not while a restore is in flight —
-        # the firmware still reports the reset value for a poll or two.
-        if self._restore_task is not None and not self._restore_task.done():
+
+        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._speed_mode_during_print is None:
-            # Bootstrap: first observation is the baseline.
-            self._speed_mode_during_print = speed_mode
+        if self._mismatch_since is None:
+            self._mismatch_since = now
             return
-        if speed_mode == self._speed_mode_during_print:
-            self._mode_candidate = None
+        if now - self._mismatch_since < ENFORCE_AFTER_S:
             return
-        # Debounce: a changed mode must hold BASELINE_HOLD_S before it
-        # becomes the restore baseline, so the firmware's pre-switch reset
-        # (which fires seconds before the head parks) never gets adopted.
-        now = self._now()
-        if speed_mode != self._mode_candidate:
-            self._mode_candidate = speed_mode
-            self._mode_candidate_since = now
-        elif now - self._mode_candidate_since >= BASELINE_HOLD_S:
-            self._speed_mode_during_print = speed_mode
-            self._mode_candidate = None
-
-    async def _restore_speed_mode(self, mode: int) -> None:
-        await asyncio.sleep(2.0)  # let the firmware settle after the switch
+        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("restored speed_mode %d after filament switch", mode)
+            log.info("re-applied pinned speed_mode %d", mode)
         except Exception:
-            log.warning(
-                "could not restore speed_mode %d after filament switch", mode, exc_info=True
-            )
+            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"

{pycentauri-0.6.1 → 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.1 → 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.1 → 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.1 → pycentauri-0.6.2}/tests/test_cc2_mapping.py

@@ -272,90 +272,138 @@ def test_canvas_parse_survives_malformed_payloads() -> None:
     assert CanvasStatus.from_payload({"canvas_info": {"canvas_list": "bogus"}}).tray_count == 0
 
 
-# --- speed-mode restore across filament switches -------------------------------
+# --- 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 = False) -> Any:
+def _printer(enable_control: bool = True) -> Any:
     from pycentauri.cc2 import CC2Printer
 
-    return CC2Printer("127.0.0.1", access_code="x", enable_control=enable_control)
+    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 test_switch_snapshots_and_flags_restore(monkeypatch: Any) -> None:
-    p = _printer(enable_control=False)
-    # Printing at sport (2)
-    p._track_speed_mode(_payload(13, 2))
-    assert p._speed_mode_during_print == 2
-    # Switch begins — snapshot taken
-    p._track_speed_mode(_payload(27, 1))
-    assert p._speed_mode_to_restore == 2
-    # Switch ends with the firmware reset to balanced; control off → no
-    # restore task, but the pending snapshot is consumed.
-    p._track_speed_mode(_payload(13, 1))
-    assert p._speed_mode_to_restore is None
+def _tick(p: Any, dt: float, status: int, mode: int) -> None:
+    p._clock[0] += dt
+    p._track_speed_mode(_payload(status, mode))
 
 
-def test_no_restore_when_mode_survives_switch() -> None:
+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._track_speed_mode(_payload(13, 3))
-    p._track_speed_mode(_payload(27, 3))
-    assert p._speed_mode_to_restore == 3
-    # Firmware kept the mode: nothing to do, baseline continues
-    p._track_speed_mode(_payload(13, 3))
-    assert p._speed_mode_to_restore is None
-    assert p._speed_mode_during_print == 3
+    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_snapshot_not_overwritten_mid_switch() -> None:
+def test_balanced_is_never_learned_as_pin_while_pinned() -> None:
     p = _printer()
-    p._track_speed_mode(_payload(13, 2))
-    p._track_speed_mode(_payload(27, 1))
-    p._track_speed_mode(_payload(27, 1))  # more switch polls
-    assert p._speed_mode_to_restore == 2
+    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_idle_states_do_not_touch_tracking() -> None:
+def test_no_pin_means_no_enforcement() -> None:
     p = _printer()
-    p._track_speed_mode(_payload(13, 2))
-    p._track_speed_mode(_payload(0, 1))  # idle
-    p._track_speed_mode(_payload(6, 1))  # paused
-    assert p._speed_mode_during_print == 2
-    assert p._speed_mode_to_restore is None
+    _tick(p, 0, 13, 1)
+    _tick(p, 60, 13, 1)
+    assert p._fired == []
 
 
-def test_pre_switch_reset_does_not_poison_baseline() -> None:
-    """Replicates the live trace from 2026-07-05 14:10: the firmware
-    resets speed_mode ~6 s BEFORE the head parks for the switch."""
+def test_print_end_clears_pin() -> None:
     p = _printer()
-    t = [0.0]
-    p._now = lambda: t[0]
-    p._track_speed_mode(_payload(13, 2))  # printing at sport (bootstrap)
-    t[0] = 120.0
-    p._track_speed_mode(_payload(13, 2))  # still sport
-    # Pre-switch reset: mode drops while status is still 13
-    t[0] = 126.0
-    p._track_speed_mode(_payload(13, 1))
-    t[0] = 129.0
-    p._track_speed_mode(_payload(13, 1))  # held only 3 s — not promoted
-    assert p._speed_mode_during_print == 2
-    # Head parks, switch state
-    t[0] = 132.0
-    p._track_speed_mode(_payload(27, 1))
-    assert p._speed_mode_to_restore == 2  # snapshot is the REAL baseline
-
-
-def test_sustained_mode_change_becomes_baseline() -> None:
+    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()
-    t = [0.0]
-    p._now = lambda: t[0]
-    p._track_speed_mode(_payload(13, 1))  # bootstrap balanced
-    t[0] = 10.0
-    p._track_speed_mode(_payload(13, 3))  # user sets ludicrous on screen
-    assert p._speed_mode_during_print == 1  # not yet promoted
-    t[0] = 26.0
-    p._track_speed_mode(_payload(13, 3))  # held 16 s → promoted
-    assert p._speed_mode_during_print == 3
+    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 == []