trcc-linux 9.8.4__tar.gz → 9.8.6__tar.gz

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.8.4
+Version: 9.8.6
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.8.4"
+version = "9.8.6"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/__version__.py

@@ -1,4 +1,4 @@
 """TRCC Linux version information. History in doc/CHANGELOG.md."""
 
-__version__ = "9.8.4"
+__version__ = "9.8.6"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/adapters/device/bulk_lcd.py

@@ -55,16 +55,22 @@ _WRITE_CHUNK_SIZE = 16 * 1024
 # PM values that use raw RGB565 (cmd=3); everything else uses JPEG (cmd=2).
 _RGB565_PMS: set[int] = {32}
 
-# Bulk base FBL is 72 (480x480, hardcoded by USBLCDNew.exe).  C#
-# FormCZTVInit (myDeviceMode==2) overrides it only for this known PM set
-# (plus PM=1 with SUB 48/49); every other PM stays 480x480.  pm_to_fbl()
-# returns the PM itself for unrecognised values, which get_profile would
-# misread as a 320x320 panel — so unknown bulk PMs must clamp to FBL 72.
-# Mirrors legacy ``_bulk_resolution``. (#169)
+# Bulk base FBL is 72 (480x480, hardcoded by USBLCDNew.exe).  The C# resolves
+# every bulk panel through ``FormCZTVInit(fbl=72, m=2, pm, pmSub)``
+# (TRCC.decompiled.cs:742) — base 480x480, overridden ONLY for the PM values
+# its ``switch(pm)`` handles.  This set is exactly those values:
+#     case 5 → 50 (320x240)   case 7 → 64 (640x480)
+#     m==2 default: pm==32 → 100 (320x320);  pm==64 → 114 (1600x720);
+#     pm==65 → 192 (1920x462);  pm∈{9,11} → 224 (854x480);
+#     pm==10 → 224 (960x540);   pm==12 → 224 (800x480)
+# (PM=1 with SUB 48/49 is handled by the separate SUB guard in ``connect()``.)
+# EVERY other PM stays 480x480 — including PM=50 (a poll-byte "SPI mode 2"
+# value the GrandVision 360 reports, #176) and the 224/192-by-PM poll-byte
+# values (13-17, 63, 66, 68, 69) that HID/LY resolve via ``pm_to_fbl`` but
+# ``FormCZTVInit`` never maps on the bulk path.  Keep this set == FormCZTVInit's
+# branches; do not re-add poll-byte PMs, or bulk panels misread again. (#176/#169)
 _BULK_BASE_FBL = 72
-_BULK_KNOWN_PMS: frozenset[int] = frozenset(
-    {5, 7, 9, 10, 11, 12, 13, 14, 15, 16, 17, 32, 50, 63, 64, 65, 66, 68, 69}
-)
+_BULK_KNOWN_PMS: frozenset[int] = frozenset({5, 7, 9, 10, 11, 12, 32, 64, 65})
 
 
 @DeviceFactory.register(Wire.BULK)

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/adapters/diagnostics/debug_report.py

@@ -17,22 +17,32 @@ whole report.  Reporters always get *something* useful to attach.
 """
 from __future__ import annotations
 
+import contextlib
 import json
 import logging
 import os
 import platform as py_platform
 import sys
+from collections import deque
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
 
+from ...core.errors import HandshakeError, TransportError
+from ...core.models import Kind, ProductInfo, Wire
 from ...core.ports import Platform
 from ...core.registry import find_product
+from ..device import DeviceFactory
 from ..infra.logging import tail_log
 from .health import HealthReport, run_health_checks
 
 log = logging.getLogger(__name__)
 
+# Marker for the connect-time handshake line ("BulkLcd handshake OK: PM=…",
+# "HidLcd handshake OK: …", etc.).  Scraped from the FULL log as a fallback
+# when a live probe can't run.
+_HANDSHAKE_LOG_MARKER = "handshake OK"
+
 
 @dataclass(frozen=True, slots=True)
 class DebugReport:
@@ -49,6 +59,7 @@ class DebugReport:
     settings_error: str = ""
     health: HealthReport = field(default_factory=HealthReport)
     log_tail: list[str] = field(default_factory=list)
+    handshake_log: list[str] = field(default_factory=list)
 
     def render_text(self) -> str:
         """Render the report as a single string for clipboard/file output."""
@@ -58,6 +69,9 @@ class DebugReport:
         sections.append(_render_kv("Platform", self.platform_info))
         sections.append(_render_kv("Paths", self.paths))
         sections.append(_render_devices(self.devices, self.devices_error))
+        handshake = _render_handshake_log(self.handshake_log)
+        if handshake:
+            sections.append(handshake)
         sections.append(_render_sensors(self.sensors, self.sensors_error))
         sections.append(_render_powercap(self.powercap))
         sections.append(_render_settings(self.settings_json, self.settings_error))
@@ -93,6 +107,7 @@ def build_debug_report(
     health = run_health_checks(platform)
     log_path = platform.paths().log_file()
     log_lines = tail_log(log_path, n_lines=log_tail_lines)
+    handshake_log = _scrape_handshake_lines(log_path)
 
     return DebugReport(
         timestamp=timestamp,
@@ -107,6 +122,7 @@ def build_debug_report(
         settings_error=settings_err,
         health=health,
         log_tail=log_lines,
+        handshake_log=handshake_log,
     )
 
 
@@ -160,17 +176,105 @@ def _collect_devices(
     rows: list[dict[str, str]] = []
     for info in infos:
         product = find_product(info.vid, info.pid)
-        rows.append({
+        row = {
             "key": info.key,
             "vid": f"{info.vid:04x}",
             "pid": f"{info.pid:04x}",
             "product": product.product if product else "(unregistered)",
             "vendor": product.vendor if product else "(unregistered)",
             "wire": product.wire.value if product else "(unknown)",
-        })
+        }
+        # Capture the live handshake so the report always carries the exact
+        # PM / SUB / fbl / resolution — the bytes that decide a panel's
+        # geometry.  Without this the report only has them if the connect-time
+        # log line survived in the tail, which on a long session it never does.
+        if product is not None:
+            handshake = _probe_handshake(platform, product)
+            if handshake is not None:
+                row.update({f"hs_{k}": v for k, v in handshake.items()})
+        rows.append(row)
     return rows, ""
 
 
+def _probe_handshake(
+    platform: Platform, product: ProductInfo,
+) -> dict[str, str] | None:
+    """Connect the device, capture its handshake bytes, then disconnect.
+
+    The device's PM / SUB / fbl / resolution decide its whole geometry, yet the
+    report otherwise loses them: the handshake fires once at connect (startup)
+    and its log line scrolls out of the tail on any real session.  A fresh live
+    probe captures the exact bytes every time — this is what lets us map a new
+    panel (e.g. the shared ``87ad:70db`` controller) without asking the reporter
+    for a byte their report can't produce.
+
+    Returns None — the caller falls back to the log scrape — when the device
+    can't be probed: an LED segment display (no frame handshake), the GUI /
+    daemon already holds the device (busy), a permission error, or a handshake
+    failure.  A diagnostic must never abort the report, so every failure is
+    swallowed into the fallback.
+    """
+    key = f"{product.vid:04x}:{product.pid:04x}"
+    log.info("_probe_handshake: %s wire=%s", key, product.wire.value)
+    if product.kind is not Kind.LCD:
+        log.info("_probe_handshake: %s is %s, not LCD — no frame handshake",
+                 key, product.kind.value)
+        return None
+    device = None
+    try:
+        cls = DeviceFactory.for_wire(product.wire)
+        if product.wire is Wire.SCSI:
+            transport = platform.open_scsi(product.vid, product.pid)
+        else:
+            transport = platform.open_bulk(product.vid, product.pid)
+        device = cls(product, transport)
+        result = device.connect()
+    except (OSError, HandshakeError, TransportError, RuntimeError) as e:
+        log.info("_probe_handshake: %s probe failed (%s: %s) — scraping log",
+                 key, type(e).__name__, e)
+        return None
+    finally:
+        if device is not None:
+            with contextlib.suppress(OSError, TransportError, RuntimeError):
+                device.disconnect()
+    handshake = {
+        "pm": str(result.pm_byte),
+        "sub": str(result.sub_byte),
+        "fbl": str(result.fbl) if result.fbl is not None else "?",
+        "resolution": f"{result.resolution[0]}x{result.resolution[1]}",
+        "raw": result.raw_response[:64].hex(),
+    }
+    log.info("_probe_handshake: %s → PM=%s SUB=%s fbl=%s resolution=%s",
+             key, handshake["pm"], handshake["sub"], handshake["fbl"],
+             handshake["resolution"])
+    return handshake
+
+
+def _scrape_handshake_lines(log_path: Path, keep: int = 6) -> list[str]:
+    """The most recent ``handshake OK`` lines from the FULL log (not the tail).
+
+    The fallback for :func:`_probe_handshake`: when a live probe can't run
+    (the GUI holds the device), the connect-time handshake line may still be
+    somewhere in the log — but earlier than the tail window.  Scans the whole
+    file keeping only the last *keep* matches, so it stays memory-bounded even
+    on a large log.
+    """
+    log.debug("_scrape_handshake_lines: %s (keep=%d)", log_path, keep)
+    if not log_path.is_file():
+        return []
+    recent: deque[str] = deque(maxlen=keep)
+    try:
+        with log_path.open("r", encoding="utf-8", errors="replace") as fh:
+            for line in fh:
+                if _HANDSHAKE_LOG_MARKER in line:
+                    recent.append(line.rstrip("\n"))
+    except OSError as e:
+        log.debug("_scrape_handshake_lines: read failed: %s", e)
+        return []
+    log.debug("_scrape_handshake_lines: found %d line(s)", len(recent))
+    return list(recent)
+
+
 def _collect_sensors(
     platform: Platform,
 ) -> tuple[list[dict[str, str]], str]:
@@ -276,11 +380,29 @@ def _render_devices(rows: list[dict[str, str]], error: str) -> str:
         return f"## Devices\n  Scan failed: {error}"
     if not rows:
         return "## Devices\n  No supported devices detected on USB"
-    body = "\n".join(
-        f"  {r['key']:14}  {r['product']:30}  wire={r['wire']}"
-        for r in rows
-    )
-    return f"## Devices ({len(rows)})\n{body}"
+    lines: list[str] = []
+    for r in rows:
+        lines.append(f"  {r['key']:14}  {r['product']:30}  wire={r['wire']}")
+        if "hs_resolution" in r:
+            lines.append(
+                f"    handshake: PM={r['hs_pm']} SUB={r['hs_sub']} "
+                f"fbl={r['hs_fbl']} resolution={r['hs_resolution']}"
+            )
+            lines.append(f"    raw[0:64]:  {r['hs_raw']}")
+        else:
+            lines.append(
+                "    handshake: (live probe unavailable — device busy or LED; "
+                "see Handshake-from-log below)"
+            )
+    return f"## Devices ({len(rows)})\n" + "\n".join(lines)
+
+
+def _render_handshake_log(lines: list[str]) -> str:
+    """The scraped-from-log handshake fallback section (omitted when empty)."""
+    if not lines:
+        return ""
+    body = "\n".join(f"  {line}" for line in lines)
+    return f"## Handshake (from log — fallback)\n{body}"
 
 
 def _render_sensors(rows: list[dict[str, str]], error: str) -> str:

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/adapters/infra/sysinfo_config.py

@@ -291,12 +291,24 @@ class SysInfoConfig:
                 (i, b) for i, b in enumerate(fan_panel.sensors)
                 if not b.sensor_id
             ]
-            leftover_fan_ids = sorted(
-                r.sensor_id for r in readings
-                if r.sensor_id.startswith("fan:")
-                and r.sensor_id.endswith(":rpm")
-                and r.sensor_id not in bound_fan_ids
-            )
+            # Spinning fans first, dead headers last.  A super-I/O chip
+            # exposes every fan header (fan1..fan6) whether or not a fan is
+            # plugged in, and label-less boards (nct6xxx etc.) give no way to
+            # tell which is the CPU/pump.  Binding in raw id order lands the
+            # CPU/GPU slots on disconnected headers reading 0 RPM while the
+            # real fans (a water pump + radiator fans sit on arbitrary
+            # headers, always spinning) fall off the end — the "fans not
+            # reporting" bug (#145).  Order by (is-idle, id) so live readings
+            # claim the visible slots; idle headers only backfill leftovers.
+            leftover_fan_ids = [
+                r.sensor_id for r in sorted(
+                    (r for r in readings
+                     if r.sensor_id.startswith("fan:")
+                     and r.sensor_id.endswith(":rpm")
+                     and r.sensor_id not in bound_fan_ids),
+                    key=lambda r: ((r.value or 0.0) <= 0.0, r.sensor_id),
+                )
+            ]
             for (slot_idx, binding), fan_id in zip(
                 unbound_slots, leftover_fan_ids, strict=False,
             ):

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/app.py

@@ -54,7 +54,7 @@ from .services.led_effects import LEDEffectEngine
 from .services.media import MediaService
 from .services.metrics_loop import MetricsLoop
 from .services.migration import LibraryMigration
-from .services.overlay import OverlayService
+from .services.overlay import OverlayService, resolve_overlay_elements
 from .services.quickstart import QuickstartService
 from .services.settings import Settings
 from .services.slideshow import SlideshowService
@@ -413,6 +413,34 @@ class App:
             )
         return self._renderer
 
+    def effective_overlay_elements(self, key: str) -> list[dict]:
+        """The ONE overlay layout actually on screen for ``key``.
+
+        The single source every per-element operation (flash, select, edit)
+        must address — resolved by the same precedence the renderer uses
+        (user > mask > theme, each REPLACES; see
+        ``resolve_overlay_elements``).  Addressing only the user layer was
+        the ``FlashOverlayElement 'N' not found`` bug: when a mask or theme
+        supplies the live layout the user layer is empty, so an id/index
+        resolved against it matched nothing on screen.
+        """
+        s = self.settings.for_device(key)
+        theme = self.active_themes.get(key)
+        theme_config = theme.config if theme is not None else {}
+        elements = resolve_overlay_elements(
+            theme_config, s.mask_overlay_elements, s.user_overlay_elements,
+        )
+        log.debug(
+            "effective_overlay_elements: key=%s → %d element(s) "
+            "[theme=%d mask=%s user=%d]",
+            key, len(elements),
+            len(theme_config.get("elements") or []),
+            None if s.mask_overlay_elements is None
+            else len(s.mask_overlay_elements),
+            len(s.user_overlay_elements),
+        )
+        return elements
+
     # ── Device lifecycle ──────────────────────────────────────────────
 
     def attach(self, vid: int, pid: int) -> Device:
@@ -498,6 +526,16 @@ class App:
         self.metrics_loop.stop()
         self.led_animation_loop.stop()
         self.stop_hotplug()
+        # Blank every panel before releasing it so it goes dark on shutdown
+        # instead of holding its last frame lit (#143).  Best-effort: the
+        # Command swallows a mid-unplug send, and any unexpected error here
+        # must not block device release below.
+        from .core.commands import SleepDevice
+        for key in list(self.devices):
+            try:
+                self.dispatch(SleepDevice(key=key))
+            except Exception:
+                log.exception("close: SleepDevice raised for %s", key)
         for key in list(self.devices):
             self.detach(key)
         self._send_scheduler.shutdown()

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/core/commands/__init__.py

@@ -19,6 +19,7 @@ from .device import (
     DisconnectDevice,
     DiscoverDevices,
     EnableOverlay,
+    EnsureConnected,
     FlashOverlayElement,
     LcdSnapshot,
     LoopVideo,
@@ -42,6 +43,7 @@ from .device import (
     SetOverlayBackground,
     SetOverlayConfig,
     SetSplitMode,
+    SleepDevice,
     StartScreencast,
     StopScreencast,
     StopVideo,
@@ -147,6 +149,7 @@ __all__ = [
     "EnableAutostart",
     "EnableLedTestMode",
     "EnableOverlay",
+    "EnsureConnected",
     "EnsureDataDownload",
     "ExportConfig",
     "ExportDcTheme",
@@ -234,6 +237,7 @@ __all__ = [
     "SetTempUnit",
     "SetTimeFormat",
     "SetWeekStart",
+    "SleepDevice",
     "StartScreencast",
     "StopScreencast",
     "StopVideo",

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/core/commands/device.py

@@ -236,6 +236,34 @@ class ConnectDevice(Command[ConnectResult]):
         )
 
 
+@dataclass(frozen=True, slots=True)
+class EnsureConnected(Command[ConnectResult]):
+    """Bring *key* up for a wire command only if it isn't already connected.
+
+    The idempotent counterpart to :class:`ConnectDevice`.  A stateless CLI
+    process holds no attached devices, so a wire command (``color``, ``play``,
+    ``load-theme`` …) dispatched from a fresh process would fail with "not
+    connected".  This attaches + handshakes once; when a daemon/GUI already
+    holds the device it is a pure no-op — unlike ``ConnectDevice`` it never
+    rebuilds the transport or re-handshakes a live device, so it is safe to
+    call before every wire command and once before a render/play loop without
+    disrupting an active stream.  (``ConnectDevice`` keeps its always-handshake
+    contract for the reconnect / dev-console inject-reply paths.)
+    """
+    key: str
+
+    def execute(self, app: App) -> ConnectResult:
+        existing = app.devices.get(self.key)
+        if existing is not None and existing.is_connected:
+            log.debug("EnsureConnected %s: already connected — no-op", self.key)
+            return ConnectResult(
+                ok=True, key=self.key,
+                message=f"{self.key} already connected",
+            )
+        log.info("EnsureConnected %s: not connected — attaching", self.key)
+        return app.dispatch(ConnectDevice(key=self.key))
+
+
 @dataclass(frozen=True, slots=True)
 class DeviceConnectionIssues(Command[ConnectionIssuesResult]):
     """Query devices that were found but failed to connect (with per-OS hints).
@@ -357,6 +385,44 @@ class SendColor(Command[SendResult]):
                      if ok else "Send returned False"),
         )
 
+@dataclass(frozen=True, slots=True)
+class SleepDevice(Command[SendResult]):
+    """Blank a connected panel so it goes dark on shutdown / quit (#143).
+
+    The unified "turn the screen off" action every surface dispatches — the
+    GUI/daemon shutdown hook (``App.close``), ``trcc display sleep`` (CLI),
+    and the ``/sleep`` API route all send this one Command.  Mirrors the C#
+    exit path (stop streaming + close the device) but adds an explicit dark
+    frame first, so the panel visibly clears instead of holding its last
+    image until the firmware idle-sleeps.
+
+    Composes the existing wire paths rather than duplicating them: LCD →
+    :class:`SendColor` (a solid-black frame via
+    ``DisplayService.build_solid_color_frame``); LED → :class:`SetLedColors`
+    with ``global_on=False`` (an all-off payload).  Best-effort by design —
+    a device mid-unplug returns ``ok=False`` instead of raising, so it can
+    never abort ``App.close`` mid-shutdown.
+    """
+    key: str
+
+    def execute(self, app: App) -> SendResult:
+        log.info("SleepDevice: key=%s", self.key)
+        device = app.devices.get(self.key)
+        if device is None or not device.is_connected:
+            log.info("SleepDevice %s: not connected — nothing to blank",
+                     self.key)
+            return SendResult(ok=False, key=self.key, bytes_sent=0,
+                              message=f"{self.key} not connected")
+        if device.is_led:
+            from .led import SetLedColors
+            result = SetLedColors(
+                key=self.key, colors=[(0, 0, 0)], global_on=False,
+            ).execute(app)
+            return SendResult(ok=result.ok, key=self.key, bytes_sent=0,
+                              message=result.message)
+        return SendColor(key=self.key, r=0, g=0, b=0).execute(app)
+
+
 @dataclass(frozen=True, slots=True)
 class SendImage(Command[SendResult]):
     """Push an image file to the LCD without staging it as a theme.
@@ -1535,16 +1601,20 @@ class FlashOverlayElement(Command[OverlayElementResult]):
     duration_ms: int = 1500
 
     def execute(self, app: App) -> OverlayElementResult:
-        elements = app.settings.for_device(self.key).user_overlay_elements
-        for e in elements:
-            if e.id == self.element_id:
+        # Resolve against the EFFECTIVE layout on screen (user > mask >
+        # theme), not just the user layer — a mask/theme supplies the live
+        # elements while the user layer is empty, so a user-only lookup
+        # never matched them (the "element 'N' not found" flash bug).
+        for e in app.effective_overlay_elements(self.key):
+            if e.get("id") == self.element_id:
                 app.events.publish(OverlayChanged(
                     key=self.key, enabled=True,
                     flash_element_id=self.element_id,
                     flash_duration_ms=self.duration_ms,
                 ))
                 return OverlayElementResult(
-                    ok=True, key=self.key, element=_element_to_entry(e),
+                    ok=True, key=self.key,
+                    element=_element_to_entry(OverlayElement.from_dict(e)),
                     message=f"Flashing overlay element {self.element_id} "
                             f"for {self.duration_ms}ms",
                 )

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/core/protocol.py

@@ -322,3 +322,35 @@ def wire_rotation(profile: DeviceProfile, orientation: int, pm: int = 0) -> int:
     log.debug("wire_rotation: %dx%d jpeg=%s pm=%d base=%d orient=%d → %d°",
               w, h, profile.jpeg, pm, base, orientation, angle)
     return angle
+
+
+def wire_angle(
+    profile: DeviceProfile, orientation: int, portrait_content: bool,
+) -> int:
+    """The single wire-frame rotation a device gets at a user *orientation*.
+
+    Collapses ``DisplayService.build_frame``'s three-way selection into one
+    pure decision so the render path and any auditor share it (DRY):
+
+      * non-widescreen rotate panels → :func:`wire_rotation` (``base − orient``)
+      * widescreen JPEG rotate panels → :func:`resolve_encode_angle` (the
+        hardware-verified #169 per-resolution encode table)
+      * squares / non-rotate panels → user orientation only (``360 − orient``)
+
+    A portrait-content theme on a rotate panel is pre-rotated at compose time
+    (``post_rotate``) and opts out by passing ``portrait_content=True``.
+    """
+    wire_rotate_panel = (
+        profile.rotate and not portrait_content and not profile.widescreen
+    )
+    fold_into_encode = (
+        profile.rotate and not portrait_content
+        and profile.widescreen and profile.jpeg
+    )
+    if wire_rotate_panel:
+        return wire_rotation(profile, orientation)
+    if fold_into_encode:
+        return resolve_encode_angle(profile, orientation)
+    if orientation and not portrait_content:
+        return (360 - orientation) % 360
+    return 0

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/core/registry.py

@@ -51,8 +51,11 @@ ALL_DEVICES: dict[tuple[int, int], ProductInfo] = {
         vid=0x0416, pid=0x5406,
         vendor="Winbond",
         product="LCD Display",
-        wire=Wire.SCSI, kind=Kind.LCD,
-        device_type=1, fbl=100,
+        # Elite Vision 360 ARGB (#212): enumerates vendor-specific with two BULK
+        # endpoints, never a /dev/sg* node — it is a BULK device, not SCSI.  Its
+        # PM/resolution table already lives in _BULK_VARIANTS (variants.py).
+        wire=Wire.BULK, kind=Kind.LCD,
+        device_type=4, fbl=100,
         native_resolution=(320, 320),
         orientations=(0, 90, 180, 270),
     ),

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/services/_dc.py

@@ -44,26 +44,27 @@ _MODE_DATE = 3
 _MODE_CUSTOM = 4
 
 
-# Metric VALUE slots render the BARE INTEGER — never the unit.  The Windows
-# app strips the unit off every sensor value before drawing it on the panel
-# (TRCC.cs: val.Replace("℃"/"℉"/"MHz"/"%"/"RPM","") → Convert.ToInt32 →
-# DrawString) because the unit is part of the theme's background artwork, not
-# the overlay.  Baking "°C"/"%"/"MHz" into the format double-prints the unit
-# on top of the baked-in glyph (#150/#203 diagnosis).  Label slots keep their
-# text; only the value slots are bare.
+# Metric VALUE slots carry their unit in the format so it renders DYNAMICALLY —
+# matching the C# flag-template reader (case 220), which sets every value
+# element's ``myModeSub = 1`` → ``UCXiTongXianShiSubTimer`` draws number + unit.
+# The unit is our decorator (``_draw_metric`` swaps °C→°F on the global toggle
+# and button0 can hide it), NOT a baked glyph: a baked "°C" is static and reads
+# wrong the moment the user picks Fahrenheit, so the unit must be drawn.  (The
+# earlier #150/#203 "render bare" was wrong for these masks — the art's unit
+# glyph is decoration; the functional unit is drawn, per the C#.)
 _SLOT_MAP: list[tuple[str, str | None, str, str]] = [
     ("custom_text",       None,               "",      ""),
-    ("cpu_temp",          "cpu:temp",         "CPU",   "{value:.0f}"),
+    ("cpu_temp",          "cpu:temp",         "CPU",   "{value:.0f}°C"),
     ("cpu_temp_label",    None,               "CPU",   ""),
-    ("cpu_freq",          "cpu:freq",         "CPU",   "{value:.0f}"),
+    ("cpu_freq",          "cpu:freq",         "CPU",   "{value:.0f} MHz"),
     ("cpu_freq_label",    None,               "CPU",   ""),
-    ("cpu_usage",         "cpu:usage",        "CPU",   "{value:.0f}"),
+    ("cpu_usage",         "cpu:usage",        "CPU",   "{value:.0f}%"),
     ("cpu_usage_label",   None,               "CPU",   ""),
-    ("gpu_temp",          "gpu:primary:temp", "GPU",   "{value:.0f}"),
+    ("gpu_temp",          "gpu:primary:temp", "GPU",   "{value:.0f}°C"),
     ("gpu_temp_label",    None,               "GPU",   ""),
-    ("gpu_clock",         "gpu:primary:clock","GPU",   "{value:.0f}"),
+    ("gpu_clock",         "gpu:primary:clock","GPU",   "{value:.0f} MHz"),
     ("gpu_clock_label",   None,               "GPU",   ""),
-    ("gpu_usage",         "gpu:primary:usage","GPU",   "{value:.0f}"),
+    ("gpu_usage",         "gpu:primary:usage","GPU",   "{value:.0f}%"),
     ("gpu_usage_label",   None,               "GPU",   ""),
 ]
 

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/services/display.py

@@ -37,8 +37,7 @@ from ..core.ports import Renderer
 from ..core.protocol import (
     DeviceProfile,
     get_profile,
-    resolve_encode_angle,
-    wire_rotation,
+    wire_angle,
 )
 from ._clock import compute_clock
 from .media import MediaService
@@ -382,26 +381,9 @@ class DisplayService:
         #    the per-resolution encode TABLE (resolve_encode_angle) — the
         #    hardware-verified #169 path, unchanged.
         #  * Squares + non-rotate panels: user orientation only.
-        wire_rotate_panel = (
-            resolved_profile.rotate and not portrait
-            and not resolved_profile.widescreen
-        )
-        fold_into_encode = (
-            resolved_profile.rotate and not portrait
-            and resolved_profile.widescreen and resolved_profile.jpeg
-        )
-        if wire_rotate_panel:
-            angle = wire_rotation(resolved_profile, s.orientation)
-        elif fold_into_encode:
-            angle = resolve_encode_angle(resolved_profile, s.orientation)
-        elif s.orientation and not portrait:
-            angle = 360 - s.orientation
-        else:
-            angle = 0
+        angle = wire_angle(resolved_profile, s.orientation, portrait)
         if angle % 360:
-            log.debug("build_frame %s: wire rotate %d° "
-                      "(wire_panel=%s widescreen=%s)",
-                      info.key, angle, wire_rotate_panel, fold_into_encode)
+            log.debug("build_frame %s: wire rotate %d°", info.key, angle)
             surface = self._r.rotate(composite, angle)
         else:
             surface = composite

{trcc_linux-9.8.4 → trcc_linux-9.8.6}/src/trcc/ui/api/display.py

@@ -49,6 +49,7 @@ from ...core.commands import (
     SetOverlayConfig,
     SetSlideshow,
     SetSplitMode,
+    SleepDevice,
     StartScreencast,
     StopScreencast,
     StopVideo,
@@ -768,6 +769,19 @@ def send_color(key: str, body: ColorRequest, request: Request) -> SendResponse:
     return to_send_response(result)
 
 
+@router.post("/sleep", response_model=SendResponse)
+def sleep(key: str, request: Request) -> SendResponse:
+    """Blank the panel so it goes dark — the shutdown / turn-off action.
+
+    Sends a solid-black frame (LCD) or an all-off payload (LED), the same
+    Command the GUI + daemon fire at PC shutdown.
+    """
+    log.info("api POST /devices/{key}/display/sleep: key=%s", key)
+    result = request.app.state.trcc.dispatch(SleepDevice(key=key))
+    http_error_if_failed(result)
+    return to_send_response(result)
+
+
 @router.post("/reset", response_model=SendResponse)
 def reset(key: str, request: Request) -> SendResponse:
     """Reset the display — stop any active video, then send a solid red frame.