trcc-linux 5.0.2__tar.gz → 5.0.4__tar.gz

{trcc_linux-5.0.2 → trcc_linux-5.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 5.0.2
+Version: 5.0.4
 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-5.0.2 → trcc_linux-5.0.4}/pyproject.toml

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

{trcc_linux-5.0.2 → trcc_linux-5.0.4}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "5.0.2"
+__version__ = "5.0.4"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -195,3 +195,15 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 #          30ms→150ms matching C# 10-tick counter, remove redundant 30ms USB
 #          cooldown sleep, skip USB sends when colors unchanged (static mode).
 #          Sensor poll interval 0.9s→2.0s. 2319 tests.
+# 5.0.3  - Fix LED wire remap skipped: LEDService.initialize() never called
+#          protocol.handshake(), so style info was never cached and wire remap
+#          was silently skipped — colors sent to wrong physical LED positions.
+#          Affects all LED devices (#19 Phantom Spirit EVO, #15 PA120).
+#          Fix SCSI byte order: remove 240x320 from big-endian set (C# FBL 50
+#          uses little-endian, not SPIMode=2). Add SCSI handshake to trcc report
+#          (FBL byte + resolution) for resolution diagnostics (#17). 2352 tests.
+# 5.0.4  - Fix HID Type 2 frame header: was sending all-zero 16-byte prefix,
+#          device firmware expects DA DB DC DD magic + command type (0x02) +
+#          mode flags matching C# FormCZTV.ImageTo565() mode 3. Without the
+#          magic, firmware rejects frames — causing USB disconnect (#16) or
+#          stuck-on-logo (#28). 2353 tests.

{trcc_linux-5.0.2 → trcc_linux-5.0.4}/src/trcc/adapters/device/bulk.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 import logging
 import struct
 
+from trcc.adapters.device.frame import FrameDevice
 from trcc.core.models import HandshakeResult, fbl_to_resolution, pm_to_fbl
 
 log = logging.getLogger(__name__)
@@ -61,7 +62,7 @@ _FRAME_HEADER_SIZE = 64
 _WRITE_CHUNK_SIZE = 16 * 1024  # 16 KiB per USB bulk write
 
 
-class BulkDevice:
+class BulkDevice(FrameDevice):
     """USB bulk device handler for USBLCDNew-type LCDs (87AD:70DB etc.).
 
     Uses pyusb for raw bulk endpoint I/O.  The kernel must not have

{trcc_linux-5.0.2 → trcc_linux-5.0.4}/src/trcc/adapters/device/factory.py

@@ -32,6 +32,21 @@ from trcc.core.models import (
 
 log = logging.getLogger(__name__)
 
+# Errno 16 = EBUSY — device interface claimed by another process (e.g. GUI).
+_ERRNO_EBUSY = 16
+
+
+def _is_ebusy(exc: Exception) -> bool:
+    """Check if exception is a USB EBUSY (device in use by another process)."""
+    # Walk the exception chain — EBUSY may be wrapped in RuntimeError
+    cur: Optional[BaseException] = exc
+    while cur is not None:
+        if getattr(cur, "errno", None) == _ERRNO_EBUSY:
+            return True
+        cur = cur.__cause__
+    return False
+
+
 # =========================================================================
 # DeviceProtocol ABC — the contract both SCSI and HID implement
 # =========================================================================
@@ -53,6 +68,9 @@ class DeviceProtocol(ABC):
         self.on_send_complete: Optional[Callable[[bool], None]] = None
         self.on_error: Optional[Callable[[str], None]] = None
         self.on_state_changed: Optional[Callable[[str, object], None]] = None
+        # Handshake state — common to all protocols
+        self._handshake_result: Optional[HandshakeResult] = None
+        self._last_error: Optional[Exception] = None
 
     @abstractmethod
     def send_image(self, image_data: bytes, width: int, height: int) -> bool:
@@ -99,13 +117,59 @@ class DeviceProtocol(ABC):
         """
         return False
 
-    @abstractmethod
     def handshake(self) -> Optional[HandshakeResult]:
-        """Perform device handshake and return capabilities.
+        """Template Method: perform handshake, cache result, handle errors.
 
-        Returns HandshakeResult with resolution, model_id, etc.
-        Returns None if handshake fails or device is unresponsive.
+        Subclasses implement _do_handshake() with protocol-specific logic.
         """
+        try:
+            result = self._do_handshake()
+            self._handshake_result = result
+            if result:
+                self._cache_handshake(result)
+            return result
+        except Exception as e:
+            if _is_ebusy(e):
+                log.warning("%s in use by another process",
+                            self._handshake_label)
+            else:
+                log.exception("%s handshake failed", self._handshake_label)
+            self._last_error = e
+            self._notify_error(f"{self._handshake_label} handshake failed: {e}")
+            return None
+
+    @abstractmethod
+    def _do_handshake(self) -> Optional[HandshakeResult]:
+        """Protocol-specific handshake logic. Called by handshake()."""
+
+    @property
+    def _handshake_label(self) -> str:
+        """Human-readable label for error messages (e.g. 'HID 0416:5302')."""
+        return self.protocol_name
+
+    @property
+    def handshake_info(self) -> Optional[HandshakeResult]:
+        """Cached handshake result (None if not yet handshaked)."""
+        return self._handshake_result
+
+    @property
+    def last_error(self) -> Optional[Exception]:
+        """Last exception from handshake."""
+        return self._last_error
+
+    def _cache_handshake(self, result: HandshakeResult) -> None:
+        """Save handshake result so `trcc report` can read it while GUI runs."""
+        try:
+            from trcc.conf import save_last_handshake
+            save_last_handshake({
+                "protocol": self.protocol_name,
+                "model_id": result.model_id,
+                "resolution": list(result.resolution) if result.resolution else None,
+                "serial": result.serial,
+                "raw": result.raw_response.hex() if result.raw_response else "",
+            })
+        except Exception:
+            log.debug("Failed to cache handshake result", exc_info=True)
 
     @property
     def is_led(self) -> bool:
@@ -142,7 +206,7 @@ class ScsiProtocol(DeviceProtocol):
         super().__init__()
         self._path = device_path
 
-    def handshake(self) -> Optional[HandshakeResult]:
+    def _do_handshake(self) -> Optional[HandshakeResult]:
         """Poll SCSI device to discover FBL → resolution."""
         from .scsi import ScsiDevice
         dev = ScsiDevice(self._path)
@@ -205,51 +269,36 @@ class HidProtocol(DeviceProtocol):
         self._pid = pid
         self._device_type = device_type
         self._transport = None
-        self._handshake_info = None
-        self._last_error: Optional[Exception] = None
-
-    def handshake(self) -> Optional[HandshakeResult]:
-        """Perform HID LCD handshake and return HidHandshakeInfo.
-
-        Opens transport if needed.  Returns hid_device.HidHandshakeInfo with
-        PM, SUB, FBL, resolution, and raw_response for debugging.
-        """
-        try:
-            if self._transport is None:
-                log.debug("Opening HID transport: %04X:%04X (type %d)", self._vid, self._pid, self._device_type)
-                self._transport = self._create_transport()
-                self._transport.open()
-                self._notify_state_changed("transport_open", True)
 
-            from .hid import HidDeviceType2, HidDeviceType3
-            if self._device_type == 2:
-                handler = HidDeviceType2(self._transport)
-            elif self._device_type == 3:
-                handler = HidDeviceType3(self._transport)
-            else:
-                log.warning("Unknown HID device type: %d", self._device_type)
-                return None
-
-            self._handshake_info = handler.handshake()
-            if self._handshake_info:
-                log.info("HID handshake OK: PM=%s, FBL=%s, resolution=%s",
-                         self._handshake_info.mode_byte_1, self._handshake_info.fbl,
-                         self._handshake_info.resolution)
-            else:
-                log.warning("HID handshake returned None")
-            self._notify_state_changed("handshake_complete", True)
-            return self._handshake_info
-        except Exception as e:
-            log.exception("HID handshake failed for %04X:%04X type %d",
-                          self._vid, self._pid, self._device_type)
-            self._last_error = e
-            self._notify_error(f"HID handshake failed: {e}")
+    def _do_handshake(self) -> Optional[HandshakeResult]:
+        """Open HID transport and perform type-specific handshake."""
+        if self._transport is None:
+            log.debug("Opening HID transport: %04X:%04X (type %d)", self._vid, self._pid, self._device_type)
+            self._transport = self._create_transport()
+            self._transport.open()
+            self._notify_state_changed("transport_open", True)
+
+        from .hid import HidDeviceType2, HidDeviceType3
+        if self._device_type == 2:
+            handler = HidDeviceType2(self._transport)
+        elif self._device_type == 3:
+            handler = HidDeviceType3(self._transport)
+        else:
+            log.warning("Unknown HID device type: %d", self._device_type)
             return None
 
+        result = handler.handshake()
+        if result:
+            log.info("HID handshake OK: PM=%s, FBL=%s, resolution=%s",
+                     result.mode_byte_1, result.fbl, result.resolution)
+        else:
+            log.warning("HID handshake returned None")
+        self._notify_state_changed("handshake_complete", True)
+        return result
+
     @property
-    def last_error(self) -> Optional[Exception]:
-        """Last exception from handshake (None if no error or not yet attempted)."""
-        return self._last_error
+    def _handshake_label(self) -> str:
+        return f"HID {self._vid:04X}:{self._pid:04X} type {self._device_type}"
 
     def send_image(self, image_data: bytes, width: int, height: int) -> bool:
         try:
@@ -336,8 +385,6 @@ class LedProtocol(DeviceProtocol):
         self._pid = pid
         self._transport = None
         self._sender = None
-        self._handshake_info = None
-        self._last_error: Optional[Exception] = None
 
     def send_image(self, image_data: bytes, width: int, height: int) -> bool:
         """No-op — LED devices don't display images."""
@@ -374,10 +421,10 @@ class LedProtocol(DeviceProtocol):
             from .led import LedPacketBuilder, remap_led_colors
 
             # Remap logical LED order → physical wire order (per-style).
-            if self._handshake_info and self._handshake_info.style:
-                led_colors = remap_led_colors(
-                    led_colors, self._handshake_info.style.style_id,
-                )
+            hr = self._handshake_result
+            style = getattr(hr, 'style', None) if hr else None
+            if style:
+                led_colors = remap_led_colors(led_colors, style.style_id)
 
             packet = LedPacketBuilder.build_led_packet(
                 led_colors, is_on, global_on, brightness
@@ -390,43 +437,27 @@ class LedProtocol(DeviceProtocol):
             self._notify_send_complete(False)
             return False
 
-    def handshake(self) -> Optional[HandshakeResult]:
-        """Perform LED device handshake and return device info.
-
-        The firmware only responds to the handshake once after power-on.
-        Subsequent calls return the cached result.
-
-        Returns:
-            LedHandshakeInfo with pm byte and resolved device style.
-        """
-        # Return cached result — device firmware ignores re-handshakes
-        if self._handshake_info is not None:
-            return self._handshake_info
+    def _do_handshake(self) -> Optional[HandshakeResult]:
+        """LED handshake — cached after first call (firmware ignores re-handshakes)."""
+        if self._handshake_result is not None:
+            return self._handshake_result
 
-        try:
-            if self._transport is None:
-                self._transport = self._create_transport()
-                self._transport.open()
-                self._notify_state_changed("transport_open", True)
+        if self._transport is None:
+            self._transport = self._create_transport()
+            self._transport.open()
+            self._notify_state_changed("transport_open", True)
 
-            if self._sender is None:
-                from .led import LedHidSender
-                self._sender = LedHidSender(self._transport)
+        if self._sender is None:
+            from .led import LedHidSender
+            self._sender = LedHidSender(self._transport)
 
-            self._handshake_info = self._sender.handshake()
-            self._notify_state_changed("handshake_complete", True)
-            return self._handshake_info
-        except Exception as e:
-            log.exception("LED handshake failed for %04X:%04X",
-                          self._vid, self._pid)
-            self._last_error = e
-            self._notify_error(f"LED handshake failed: {e}")
-            return None
+        result = self._sender.handshake()
+        self._notify_state_changed("handshake_complete", True)
+        return result
 
     @property
-    def last_error(self) -> Optional[Exception]:
-        """Last exception from handshake (None if no error or not yet attempted)."""
-        return self._last_error
+    def _handshake_label(self) -> str:
+        return f"LED {self._vid:04X}:{self._pid:04X}"
 
     def close(self) -> None:
         if self._transport is not None:
@@ -475,11 +506,6 @@ class LedProtocol(DeviceProtocol):
     def is_led(self) -> bool:
         return True
 
-    @property
-    def handshake_info(self):
-        """Cached handshake info (None if not yet handshaked)."""
-        return self._handshake_info
-
     def __repr__(self) -> str:
         return f"LedProtocol(vid=0x{self._vid:04x}, pid=0x{self._pid:04x})"
 
@@ -500,8 +526,6 @@ class BulkProtocol(DeviceProtocol):
         self._vid = vid
         self._pid = pid
         self._device: Optional[Any] = None  # BulkDevice (lazy import)
-        self._handshake_result: Optional[HandshakeResult] = None
-        self._last_error: Optional[Exception] = None
 
     def _ensure_device(self):
         """Lazily create and handshake the bulk device."""
@@ -517,22 +541,14 @@ class BulkProtocol(DeviceProtocol):
             else:
                 log.warning("Bulk handshake: no resolution detected")
 
-    def handshake(self) -> Optional[HandshakeResult]:
-        """Perform bulk device handshake."""
-        try:
-            self._ensure_device()
-            return self._handshake_result
-        except Exception as e:
-            log.exception("Bulk handshake failed for %04X:%04X",
-                          self._vid, self._pid)
-            self._last_error = e
-            self._notify_error(f"Bulk handshake failed: {e}")
-            return None
+    def _do_handshake(self) -> Optional[HandshakeResult]:
+        """Create bulk device and perform handshake."""
+        self._ensure_device()
+        return self._handshake_result
 
     @property
-    def last_error(self) -> Optional[Exception]:
-        """Last exception from handshake."""
-        return self._last_error
+    def _handshake_label(self) -> str:
+        return f"Bulk {self._vid:04X}:{self._pid:04X}"
 
     def send_image(self, image_data: bytes, width: int, height: int) -> bool:
         try:

trcc_linux-5.0.4/src/trcc/adapters/device/frame.py

@@ -0,0 +1,84 @@
+"""
+Transport-layer ABC hierarchy for all USB device types.
+
+Two categories of devices plug into DeviceProtocol (factory.py adapter layer):
+  - Frame devices (SCSI, HID, Bulk) send image frames to LCD screens.
+  - LED devices send RGB color data to LED controllers.
+
+Both share a universal contract (UsbDevice: handshake + close), then
+specialize with their data-sending method.
+
+Hierarchy:
+    UsbDevice (ABC) — handshake() + close()
+    ├── FrameDevice (ABC) — + send_frame()
+    │   ├── ScsiDevice
+    │   ├── BulkDevice
+    │   └── HidDevice (ABC)
+    │       ├── HidDeviceType2
+    │       └── HidDeviceType3
+    └── LedDevice (ABC) — + send_led_data() + is_sending
+        └── LedHidSender
+"""
+
+from abc import ABC, abstractmethod
+
+from trcc.core.models import HandshakeResult
+
+
+class UsbDevice(ABC):
+    """Universal contract for all USB devices.
+
+    Every device — frame-sending or LED — performs a handshake to
+    negotiate capabilities and must release resources on close.
+    """
+
+    @abstractmethod
+    def handshake(self) -> HandshakeResult:
+        """Perform device handshake and return capabilities."""
+
+    @abstractmethod
+    def close(self) -> None:
+        """Release device resources."""
+
+
+class FrameDevice(UsbDevice):
+    """Contract for USB LCD devices that send image frames.
+
+    Adds send_frame() to the universal handshake + close contract.
+    Not for LED devices (which send color data, not image frames).
+    """
+
+    @abstractmethod
+    def send_frame(self, image_data: bytes) -> bool:
+        """Send one image frame to the LCD device.
+
+        Args:
+            image_data: Frame bytes (RGB565, JPEG, etc. depending on device).
+
+        Returns:
+            True if the frame was sent successfully.
+        """
+
+
+class LedDevice(UsbDevice):
+    """Contract for USB LED devices that send RGB color data.
+
+    Adds send_led_data() and is_sending to the universal contract.
+    Not for LCD frame devices (which send image frames, not LED data).
+    """
+
+    @abstractmethod
+    def send_led_data(self, packet: bytes) -> bool:
+        """Send an LED data packet to the device.
+
+        Args:
+            packet: Complete LED packet (header + RGB payload).
+
+        Returns:
+            True if the packet was sent successfully.
+        """
+
+    @property
+    @abstractmethod
+    def is_sending(self) -> bool:
+        """Whether a send is currently in progress."""

{trcc_linux-5.0.2 → trcc_linux-5.0.4}/src/trcc/adapters/device/hid.py

@@ -27,6 +27,7 @@ from typing import Any, Optional, Set
 import usb.core
 import usb.util
 
+from trcc.adapters.device.frame import FrameDevice
 from trcc.core.models import (
     DEVICE_BUTTON_IMAGE,  # noqa: F401 — re-export
     PM_TO_BUTTON_IMAGE,  # noqa: F401 — re-export
@@ -161,7 +162,7 @@ def _ceil_to_512(n: int) -> int:
 # HID device base class
 # =========================================================================
 
-class HidDevice:
+class HidDevice(FrameDevice):
     """Base for HID LCD device handlers (Type 2 and Type 3).
 
     Provides shared init state and the handshake template:
@@ -351,21 +352,34 @@ class HidDeviceType2(HidDevice):
     def build_frame_packet(image_data: bytes) -> bytes:
         """Build a frame packet from raw image data.
 
-        The 20-byte header is structured so that bytes[16:20] contain
-        the image data length as a little-endian uint32.  The rest of
-        the header is zeros (populated by the TRCC GUI in Windows via
-        shared memory; we only need the size field for the device to
-        parse it).
+        C# FormCZTV.ImageTo565() mode 3 builds a 20-byte header::
+
+            DA DB DC DD 02 00 01 00 F0 00 40 01 02 00 00 00 [len_LE32]
+
+        - [0:4]   DA DB DC DD — protocol magic (same as handshake)
+        - [4]     02 — SSCRM_CMD_TYPE_PICTURE
+        - [6]     01 — mode flag
+        - [8:10]  F0 00 — 240 (LE16, hardcoded in C#)
+        - [10:12] 40 01 — 320 (LE16, hardcoded in C#)
+        - [12]    02 — sub-flag
+        - [16:20] image data length (LE uint32)
 
         The total transfer length is rounded up to the next 512-byte
         boundary (C#: ``num2 / 512 * 512 + (num2 % 512 != 0 ? 512 : 0)``).
 
         Returns the padded packet ready for USB bulk write.
         """
-        data_len = len(image_data)
-        # 20-byte header: 16 zero bytes + LE uint32 image size
-        header = b'\x00' * 16 + struct.pack('<I', data_len)
-        raw = header + image_data
+        # Match C# FormCZTV.ImageTo565() mode 3 header exactly
+        header = bytearray([
+            0xDA, 0xDB, 0xDC, 0xDD,  # magic
+            0x02, 0x00,               # cmd_type = PICTURE
+            0x01, 0x00,               # mode flag
+            0xF0, 0x00,               # 240 (LE16, hardcoded)
+            0x40, 0x01,               # 320 (LE16, hardcoded)
+            0x02, 0x00, 0x00, 0x00,   # sub-flag
+        ])
+        header.extend(struct.pack('<I', len(image_data)))
+        raw = bytes(header) + image_data
         padded_len = _ceil_to_512(len(raw))
         return raw.ljust(padded_len, b'\x00')
 

{trcc_linux-5.0.2 → trcc_linux-5.0.4}/src/trcc/adapters/device/led.py

@@ -30,6 +30,7 @@ from trcc.core.models import (
     remap_led_colors,  # noqa: F401 — re-export
 )
 
+from .frame import LedDevice
 from .hid import (
     DEFAULT_TIMEOUT_MS,
     EP_READ_01,
@@ -297,7 +298,7 @@ class LedPacketBuilder:
 # LED HID sender (from UCDevice.cs ThreadSendDeviceData1)
 # =========================================================================
 
-class LedHidSender:
+class LedHidSender(LedDevice):
     """Sends LED packets via UsbTransport with 64-byte report chunking.
 
     Matches UCDevice.cs ThreadSendDeviceData1 (lines 983-1026):

{trcc_linux-5.0.2 → trcc_linux-5.0.4}/src/trcc/adapters/device/scsi.py

@@ -18,6 +18,7 @@ import time
 import zlib
 from typing import Dict, List, Set
 
+from trcc.adapters.device.frame import FrameDevice
 from trcc.adapters.infra.data_repository import SysUtils
 from trcc.core.models import HandshakeResult, fbl_to_resolution
 
@@ -53,7 +54,7 @@ _BOOT_ANIM_RESOLUTIONS = {
 # =========================================================================
 
 
-class ScsiDevice:
+class ScsiDevice(FrameDevice):
     """SCSI LCD device handler wrapping sg_raw subprocess calls."""
 
     # Track which devices have been initialized (poll + init sent)
@@ -257,7 +258,8 @@ class ScsiDevice:
         resolution = fbl_to_resolution(fbl)
         self.width, self.height = resolution
         self._initialized = True
-        return HandshakeResult(resolution=resolution)
+        log.info("SCSI handshake OK: FBL=%d, resolution=%s", fbl, resolution)
+        return HandshakeResult(resolution=resolution, model_id=fbl)
 
     def send_frame(self, rgb565_data: bytes) -> bool:
         """Send one RGB565 frame."""