trcc-linux 5.1.1__tar.gz → 5.2.0__tar.gz

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/PKG-INFO

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

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

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "5.1.1"
+__version__ = "5.2.0"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -266,3 +266,14 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 #          extract LEDEffectEngine from LEDService (Strategy pattern), move
 #          HW info to adapters/system/hardware.py, shared test conftest.py.
 #          Net -3100 lines. 2286 tests.
+# 5.1.2  - Fix SCSI SG_IO ioctl (was silently broken — ctypes bytearray bug
+#          caused every write to fork sg_raw subprocess). Pre-allocate ctypes
+#          buffers per chunk size. Cache shutil.which('sg_raw'). Cache
+#          psutil.cpu_freq (10s TTL). Slow sensor poll 2s→4s. CPU usage
+#          drops ~21%→15% (animated theme), ~7% (static). 2286 tests.
+# 5.2.0  - HID Type 2 JPEG encoding for large-resolution devices: 1280x480
+#          (Trofeo Vision), 1600x720, 1920x462, 854x480, 960x540, 800x480,
+#          360x360 (FanLCD). C# uses ImageToJpg() (mode 2) instead of
+#          ImageTo565() (mode 3) for these FBLs — header byte[6]=0x00 with
+#          actual width/height instead of hardcoded 240x320. Auto-detects
+#          JPEG by FF D8 magic bytes. Addresses #34/#35. 2286 tests.

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/src/trcc/adapters/device/hid.py

@@ -349,36 +349,46 @@ class HidDeviceType2(HidDevice):
     # -- Frame send -------------------------------------------------------
 
     @staticmethod
-    def build_frame_packet(image_data: bytes) -> bytes:
+    def build_frame_packet(
+        image_data: bytes,
+        width: int = 240,
+        height: int = 320,
+    ) -> bytes:
         """Build a frame packet from raw image data.
 
-        C# FormCZTV.ImageTo565() mode 3 builds a 20-byte header::
+        C# FormCZTV has two encoding modes for HID Type 2:
+
+        **Mode 3** (RGB565, ``ImageTo565()``): hardcoded 240x320 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)
+        **Mode 2** (JPEG, ``ImageToJpg()``): actual resolution in header::
 
-        The total transfer length is rounded up to the next 512-byte
-        boundary (C#: ``num2 / 512 * 512 + (num2 % 512 != 0 ? 512 : 0)``).
+            DA DB DC DD 02 00 00 00 WW WW HH HH 02 00 00 00 [len_LE32]
 
-        Returns the padded packet ready for USB bulk write.
+        Differences: byte[6] = 0x01 (RGB565) vs 0x00 (JPEG),
+        bytes[8:12] = hardcoded 240x320 vs actual width/height.
+
+        JPEG is auto-detected by FF D8 magic bytes.
+        The total transfer length is 512-byte aligned.
         """
-        # Match C# FormCZTV.ImageTo565() mode 3 header exactly
+        is_jpeg = len(image_data) >= 2 and image_data[0] == 0xFF and image_data[1] == 0xD8
+
         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
         ])
+        if is_jpeg:
+            # Mode 2: JPEG — byte[6]=0x00, actual resolution
+            header.extend(b'\x00\x00')
+            header.extend(struct.pack('<HH', width, height))
+        else:
+            # Mode 3: RGB565 — byte[6]=0x01, hardcoded 240x320
+            header.extend(b'\x01\x00')
+            header.extend(struct.pack('<HH', 240, 320))
+        header.extend([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')
@@ -390,9 +400,11 @@ class HidDeviceType2(HidDevice):
         buffer in a single Transfer() call.  pyusb splits into USB packets
         internally — the device sees one logical transfer.
 
+        For JPEG-mode devices (FBL in JPEG_MODE_FBLS), the header includes
+        actual width/height. For RGB565 devices, header uses hardcoded 240x320.
+
         Args:
-            image_data: Raw image bytes (JPEG or other format the
-                        device expects).
+            image_data: Raw image bytes (RGB565 or JPEG depending on device).
 
         Returns:
             True if the transfer succeeded.
@@ -403,7 +415,9 @@ class HidDeviceType2(HidDevice):
         if not self._initialized:
             raise RuntimeError("Type 2 device not initialized — call handshake() first")
 
-        packet = self.build_frame_packet(image_data)
+        di = self.device_info
+        w, h = di.resolution if di is not None and di.resolution is not None else (240, 320)
+        packet = self.build_frame_packet(image_data, w, h)
 
         # C# USBLCDNEW ThreadSendDeviceDataH: single Transfer() call
         total = self.transport.write(EP_WRITE_02, packet, DEFAULT_TIMEOUT_MS)

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/src/trcc/adapters/device/scsi.py

@@ -7,10 +7,18 @@ This module provides those two functions.
 SCSI send protocol is inlined here (from trcc_handshake_v2) so everything
 lives in one place under src/trcc/.  LCDDriver is used only for resolution
 auto-detection during device discovery.
+
+Performance: uses native SG_IO ioctl when available (no subprocess fork).
+Falls back to sg_raw subprocess automatically on older kernels or permission
+issues.
 """
+from __future__ import annotations
 
 import binascii
+import ctypes
+import fcntl
 import logging
+import os
 import struct
 import subprocess
 import tempfile
@@ -24,6 +32,145 @@ from trcc.core.models import HandshakeResult, fbl_to_resolution
 
 log = logging.getLogger(__name__)
 
+# =========================================================================
+# SG_IO ioctl — direct SCSI passthrough (no subprocess fork)
+# =========================================================================
+
+_SG_IO = 0x2285
+_SG_DXFER_TO_DEV = -2
+_SG_DXFER_FROM_DEV = -3
+
+
+class _SgIoHdr(ctypes.Structure):
+    """Linux sg_io_hdr_t for SG_IO ioctl."""
+
+    _fields_ = [
+        ('interface_id', ctypes.c_int),
+        ('dxfer_direction', ctypes.c_int),
+        ('cmd_len', ctypes.c_ubyte),
+        ('mx_sb_len', ctypes.c_ubyte),
+        ('iovec_count', ctypes.c_ushort),
+        ('dxfer_len', ctypes.c_uint),
+        ('dxferp', ctypes.c_void_p),
+        ('cmdp', ctypes.c_void_p),
+        ('sbp', ctypes.c_void_p),
+        ('timeout', ctypes.c_uint),
+        ('flags', ctypes.c_uint),
+        ('pack_id', ctypes.c_int),
+        ('usr_ptr', ctypes.c_void_p),
+        ('status', ctypes.c_ubyte),
+        ('masked_status', ctypes.c_ubyte),
+        ('msg_status', ctypes.c_ubyte),
+        ('sb_len_wr', ctypes.c_ubyte),
+        ('host_status', ctypes.c_ushort),
+        ('driver_status', ctypes.c_ushort),
+        ('resid', ctypes.c_int),
+        ('duration', ctypes.c_uint),
+        ('info', ctypes.c_uint),
+    ]
+
+
+# Module state: None = untested, True/False = tested
+_sg_io_available: bool | None = None
+# Cached file descriptors per device path
+_device_fds: dict[str, int] = {}
+
+# Pre-allocated SG_IO buffers per data size (avoids ctypes alloc per write).
+# Key: data length → (cdb_buf, data_buf, sense_buf, hdr, ioctl_buf)
+_SG_HDR_SIZE = ctypes.sizeof(_SgIoHdr)
+_write_bufs: dict[int, tuple] = {}
+
+
+def _get_device_fd(dev: str) -> int:
+    """Get or open a file descriptor for the SCSI generic device."""
+    fd = _device_fds.get(dev)
+    if fd is not None:
+        return fd
+    fd = os.open(dev, os.O_RDWR | os.O_NONBLOCK)
+    _device_fds[dev] = fd
+    return fd
+
+
+def _close_device_fd(dev: str) -> None:
+    """Close and remove cached fd."""
+    fd = _device_fds.pop(dev, None)
+    if fd is not None:
+        try:
+            os.close(fd)
+        except OSError:
+            pass
+
+
+def _get_write_bufs(cdb_len: int, data_len: int) -> tuple:
+    """Get or create pre-allocated ctypes buffers for a given data size."""
+    bufs = _write_bufs.get(data_len)
+    if bufs is not None:
+        return bufs
+    cdb_buf = (ctypes.c_ubyte * cdb_len)()
+    data_buf = (ctypes.c_ubyte * data_len)()
+    sense_buf = (ctypes.c_ubyte * 32)()
+    hdr = _SgIoHdr()
+    ioctl_buf = ctypes.create_string_buffer(_SG_HDR_SIZE)
+    # Pre-fill immutable header fields
+    hdr.interface_id = ord('S')
+    hdr.dxfer_direction = _SG_DXFER_TO_DEV
+    hdr.cmd_len = cdb_len
+    hdr.mx_sb_len = 32
+    hdr.dxfer_len = data_len
+    hdr.dxferp = ctypes.addressof(data_buf)
+    hdr.cmdp = ctypes.addressof(cdb_buf)
+    hdr.sbp = ctypes.addressof(sense_buf)
+    hdr.timeout = 10000
+    bufs = (cdb_buf, data_buf, sense_buf, hdr, ioctl_buf)
+    _write_bufs[data_len] = bufs
+    return bufs
+
+
+def _sg_io_write(dev: str, cdb: bytes, data: bytes) -> bool:
+    """SCSI write via SG_IO ioctl. No subprocess, no temp file."""
+    fd = _get_device_fd(dev)
+
+    cdb_buf, data_buf, _sense, hdr, ioctl_buf = _get_write_bufs(len(cdb), len(data))
+    # Copy payload into pre-allocated buffers
+    ctypes.memmove(cdb_buf, cdb, len(cdb))
+    ctypes.memmove(data_buf, data, len(data))
+
+    ctypes.memmove(ioctl_buf, ctypes.addressof(hdr), _SG_HDR_SIZE)
+    fcntl.ioctl(fd, _SG_IO, ioctl_buf)
+    ctypes.memmove(ctypes.addressof(hdr), ioctl_buf, _SG_HDR_SIZE)
+
+    return hdr.status == 0
+
+
+def _sg_io_read(dev: str, cdb: bytes, length: int) -> bytes:
+    """SCSI read via SG_IO ioctl. No subprocess."""
+    fd = _get_device_fd(dev)
+
+    cdb_buf = (ctypes.c_ubyte * len(cdb)).from_buffer_copy(cdb)
+    data_buf = (ctypes.c_ubyte * length)()
+    sense_buf = (ctypes.c_ubyte * 32)()
+
+    hdr = _SgIoHdr()
+    hdr.interface_id = ord('S')
+    hdr.dxfer_direction = _SG_DXFER_FROM_DEV
+    hdr.cmd_len = len(cdb)
+    hdr.mx_sb_len = 32
+    hdr.dxfer_len = length
+    hdr.dxferp = ctypes.addressof(data_buf)
+    hdr.cmdp = ctypes.addressof(cdb_buf)
+    hdr.sbp = ctypes.addressof(sense_buf)
+    hdr.timeout = 10000
+
+    buf = ctypes.create_string_buffer(ctypes.sizeof(hdr))
+    ctypes.memmove(buf, ctypes.addressof(hdr), ctypes.sizeof(hdr))
+    fcntl.ioctl(fd, _SG_IO, buf)
+    ctypes.memmove(ctypes.addressof(hdr), buf, ctypes.sizeof(hdr))
+
+    if hdr.status != 0:
+        return b''
+    actual = length - hdr.resid
+    return bytes(data_buf[:actual])
+
 # Boot signature: device still initializing its display controller
 _BOOT_SIGNATURE = b'\xa1\xa2\xa3\xa4'
 _BOOT_WAIT_SECONDS = 3.0
@@ -103,7 +250,19 @@ class ScsiDevice(FrameDevice):
 
     @staticmethod
     def _scsi_read(dev: str, cdb: bytes, length: int) -> bytes:
-        """Execute SCSI READ via sg_raw."""
+        """Execute SCSI READ via SG_IO ioctl (or sg_raw fallback)."""
+        global _sg_io_available
+        if _sg_io_available is not False:
+            try:
+                result = _sg_io_read(dev, cdb, length)
+                _sg_io_available = True
+                return result
+            except OSError as e:
+                if _sg_io_available is None:
+                    log.warning("SG_IO read failed (%s: %s), falling back to sg_raw",
+                                type(e).__name__, e)
+                    _sg_io_available = False
+
         SysUtils.require_sg_raw()
         cdb_hex = ' '.join(f'{b:02x}' for b in cdb)
         cmd = ['sg_raw', '-r', str(length), dev] + cdb_hex.split()
@@ -112,9 +271,23 @@ class ScsiDevice(FrameDevice):
 
     @staticmethod
     def _scsi_write(dev: str, header: bytes, data: bytes) -> bool:
-        """Execute SCSI WRITE via sg_raw with temp file for payload."""
+        """Execute SCSI WRITE via SG_IO ioctl (or sg_raw fallback)."""
+        global _sg_io_available
+        cdb = header[:16]
+
+        if _sg_io_available is not False:
+            try:
+                ok = _sg_io_write(dev, cdb, data)
+                _sg_io_available = True
+                return ok
+            except OSError as e:
+                if _sg_io_available is None:
+                    log.warning("SG_IO ioctl failed (%s: %s), falling back to sg_raw",
+                                type(e).__name__, e)
+                    _sg_io_available = False
+
         SysUtils.require_sg_raw()
-        cdb_hex = ' '.join(f'{b:02x}' for b in list(header[:16]))
+        cdb_hex = ' '.join(f'{b:02x}' for b in cdb)
 
         with tempfile.NamedTemporaryFile(delete=True) as f:
             f.write(data)

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/src/trcc/adapters/infra/data_repository.py

@@ -84,10 +84,16 @@ class SysUtils:
             return []
         return [e for e in sorted(os.listdir(sysfs)) if e.startswith('sg')]
 
+    _sg_raw_path: str | None = None
+    _sg_raw_checked: bool = False
+
     @staticmethod
     def require_sg_raw() -> None:
         """Verify sg_raw is available; raise FileNotFoundError with install help if not."""
-        if not shutil.which('sg_raw'):
+        if not SysUtils._sg_raw_checked:
+            SysUtils._sg_raw_path = shutil.which('sg_raw')
+            SysUtils._sg_raw_checked = True
+        if not SysUtils._sg_raw_path:
             raise FileNotFoundError(SysUtils._SG_RAW_INSTALL_HELP)
 
     @staticmethod

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/src/trcc/adapters/infra/debug_report.py

@@ -57,6 +57,7 @@ class DebugReport:
         self._devices()
         self._device_permissions()
         self._handshakes()
+        self._process_usage()
         self._config()
 
     @property
@@ -245,6 +246,31 @@ class DebugReport:
         except Exception as e:
             sec.lines.append(f"  Error: {e}")
 
+    def _process_usage(self) -> None:
+        sec = self._add("Process usage")
+        try:
+            result = subprocess.run(
+                ["ps", "-eo", "pid,pcpu,pmem,rss,comm", "--no-headers"],
+                capture_output=True, text=True, timeout=5,
+            )
+            trcc_procs = [
+                line.strip() for line in result.stdout.splitlines()
+                if "trcc" in line.split()[-1]
+            ]
+            if not trcc_procs:
+                sec.lines.append("  (no trcc process running)")
+                return
+            sec.lines.append("  PID    %CPU  %MEM   RSS(MB)  CMD")
+            for proc in trcc_procs:
+                parts = proc.split(None, 4)
+                if len(parts) >= 5:
+                    pid, cpu, mem, rss, cmd = parts
+                    rss_mb = f"{int(rss) / 1024:.0f}"
+                    sec.lines.append(
+                        f"  {pid:>6}  {cpu:>5}  {mem:>4}  {rss_mb:>7}  {cmd}")
+        except Exception as e:
+            sec.lines.append(f"  Error: {e}")
+
     def _config(self) -> None:
         sec = self._add("Config")
         try:

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/src/trcc/adapters/system/sensors.py

@@ -177,7 +177,7 @@ class SensorEnumerator:
                     self._cached_readings = readings
             except Exception:
                 log.debug("Sensor poll error", exc_info=True)
-            self._poll_stop.wait(2.0)  # ~2s between reads (C# polls ~1s)
+            self._poll_stop.wait(4.0)  # ~4s between reads (overlay ticks at 1s)
 
     def _read_all_sync(self) -> dict[str, float]:
         """Read current values for ALL discovered sensors (blocking)."""
@@ -493,6 +493,10 @@ class SensorEnumerator:
                 except ValueError:
                     pass
 
+    _cpu_freq_cache: float = 0.0
+    _cpu_freq_time: float = 0.0
+    _CPU_FREQ_TTL: float = 10.0  # cpu_freq barely changes; cache 10s
+
     def _read_psutil(self, readings: dict[str, float]):
         """Read psutil-based sensors."""
 
@@ -501,9 +505,16 @@ class SensorEnumerator:
         except Exception:
             pass
         try:
-            freq = psutil.cpu_freq()
-            if freq:
-                readings['psutil:cpu_freq'] = freq.current
+            now = time.monotonic()
+            if now - self._cpu_freq_time >= self._CPU_FREQ_TTL:
+                freq = psutil.cpu_freq()
+                if freq:
+                    self._cpu_freq_cache = freq.current
+                else:
+                    self._cpu_freq_cache = 0.0
+                self._cpu_freq_time = now
+            if self._cpu_freq_cache > 0:
+                readings['psutil:cpu_freq'] = self._cpu_freq_cache
         except Exception:
             pass
         try:

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/src/trcc/core/models.py

@@ -1150,6 +1150,11 @@ FBL_TO_RESOLUTION: dict[int, tuple[int, int]] = {
     224: (854, 480),
 }
 
+# FBL values that trigger JPEG encoding for HID Type 2 (C# myDeviceMode == 2).
+# C# FormCZTV: these resolutions use ImageToJpg() instead of ImageTo565().
+# Header byte[6] = 0x00 (JPEG) vs 0x01 (RGB565), with actual width/height.
+JPEG_MODE_FBLS: frozenset[int] = frozenset({54, 114, 128, 192, 224})
+
 # Reverse lookup: resolution → PM/FBL (first match wins)
 RESOLUTION_TO_PM: dict[tuple[int, int], int] = {
     res: fbl for fbl, res in FBL_TO_RESOLUTION.items()

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/src/trcc/qt_components/base.py

@@ -206,6 +206,21 @@ class ImageLabel(QLabel):
         pixmap = pil_to_pixmap(pil_image)
         self.setPixmap(pixmap)
 
+    def set_rgb565(self, data: bytes, width: int, height: int,
+                   byte_order: str = '>'):
+        """Set image from pre-converted RGB565 bytes.
+
+        Skips PIL→RGB888→QImage conversion — creates QPixmap directly from
+        the same RGB565 bytes sent to the LCD device.
+        """
+        pixmap = rgb565_to_pixmap(data, width, height, byte_order)
+        if (width, height) != (self._width, self._height):
+            pixmap = pixmap.scaled(
+                self._width, self._height,
+                Qt.AspectRatioMode.IgnoreAspectRatio,
+                Qt.TransformationMode.SmoothTransformation)
+        self.setPixmap(pixmap)
+
     def mousePressEvent(self, event):
         """Handle mouse click — start drag."""
         self.clicked.emit()
@@ -289,6 +304,29 @@ def pil_to_pixmap(pil_image):
     return QPixmap.fromImage(qimage)
 
 
+def rgb565_to_pixmap(data: bytes, width: int, height: int,
+                     byte_order: str = '>') -> QPixmap:
+    """Create QPixmap from RGB565 bytes.
+
+    Qt Format_RGB16 expects native byte order (little-endian on x86).
+    Device byte order is swapped to native if needed.
+    """
+    import sys
+
+    import numpy as np
+
+    if byte_order == '>' and sys.byteorder == 'little':
+        buf = np.frombuffer(data, dtype='>u2').astype('<u2').tobytes()
+    elif byte_order == '<' and sys.byteorder == 'big':
+        buf = np.frombuffer(data, dtype='<u2').astype('>u2').tobytes()
+    else:
+        buf = bytes(data)
+
+    qimage = QImage(buf, width, height, width * 2,
+                    QImage.Format.Format_RGB16)
+    return QPixmap.fromImage(qimage)
+
+
 def pixmap_to_pil(pixmap):
     """Convert QPixmap to PIL Image.
 

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/src/trcc/qt_components/qt_app_mvc.py

@@ -546,21 +546,29 @@ class TRCCMainWindowMVC(QMainWindow):
         self._tray.show()
 
     def _setup_sleep_monitor(self):
-        """Listen for system suspend/resume via dbus (C# OnPowerModeChanged)."""
+        """Listen for system suspend/resume via QDBus (C# OnPowerModeChanged).
+
+        Uses Qt's native QDBusConnection instead of dbus-python + GLib main
+        loop.  The old dbus-python approach called DBusGMainLoop() which
+        integrates the GLib event loop into the Qt event loop — a well-known
+        source of excessive CPU wakeups (~10-15% idle overhead).
+        """
         try:
-            import dbus  # pyright: ignore[reportMissingImports]
-            from dbus.mainloop.glib import DBusGMainLoop  # pyright: ignore[reportMissingImports]
-            DBusGMainLoop(set_as_default=True)
-            bus = dbus.SystemBus()
-            bus.add_signal_receiver(
+            from PySide6.QtDBus import QDBusConnection  # pyright: ignore[reportMissingImports]
+            bus = QDBusConnection.systemBus()
+            if not bus.isConnected():
+                log.debug("Sleep monitor: QDBus system bus not connected")
+                return
+            bus.connect(  # pyright: ignore[reportCallIssue]
+                'org.freedesktop.login1',           # service
+                '/org/freedesktop/login1',           # path
+                'org.freedesktop.login1.Manager',    # interface
+                'PrepareForSleep',                   # signal
                 self._on_sleep_signal,
-                signal_name='PrepareForSleep',
-                dbus_interface='org.freedesktop.login1.Manager',
-                bus_name='org.freedesktop.login1',
             )
-            log.info("Sleep monitor: dbus PrepareForSleep listener active")
+            log.info("Sleep monitor: QDBus PrepareForSleep listener active")
         except Exception:
-            log.debug("Sleep monitor: dbus not available, skipping")
+            log.debug("Sleep monitor: QDBus not available, skipping")
 
     def _on_sleep_signal(self, sleeping: bool):
         """Handle suspend (sleeping=True) / resume (sleeping=False)."""
@@ -1253,7 +1261,7 @@ class TRCCMainWindowMVC(QMainWindow):
             self.controller.overlay.enable(enabled)
             if enabled:
                 self.uc_info_module.setVisible(True)
-                self.uc_info_module.start_updates()
+                self.uc_info_module.start_updates(3000)
                 self.start_metrics()
             else:
                 self.uc_info_module.setVisible(False)
@@ -1717,7 +1725,7 @@ class TRCCMainWindowMVC(QMainWindow):
         """Toggle overlay display and info module visibility."""
         self.uc_info_module.setVisible(enabled)
         if enabled:
-            self.uc_info_module.start_updates()
+            self.uc_info_module.start_updates(3000)
             self.start_metrics()
         else:
             self.uc_info_module.stop_updates()
@@ -2039,7 +2047,11 @@ class TRCCMainWindowMVC(QMainWindow):
     # =========================================================================
 
     def _on_device_poll(self):
-        """Poll for LCD and LED device connections."""
+        """Poll for LCD and LED device connections.
+
+        Adaptive interval: 15s when a device is connected (hot-unplug detect),
+        5s when searching for a device (faster initial connect).
+        """
         try:
             devices = find_lcd_devices()
 
@@ -2055,6 +2067,13 @@ class TRCCMainWindowMVC(QMainWindow):
                 else:
                     self.controller.devices.select_device(device)
                     self.uc_preview.set_status(f"Device: {device.path}")
+
+            # Adaptive poll: slow when connected, fast when searching
+            has_device = bool(
+                self.controller.devices.get_selected() or self._led.active)
+            interval = 15000 if has_device else 5000
+            if self._device_timer.interval() != interval:
+                self._device_timer.start(interval)
         except Exception as e:
             log.error("Device poll error: %s", e)
 
@@ -2136,8 +2155,9 @@ class TRCCMainWindowMVC(QMainWindow):
             (self.controller.current_image and self.controller.overlay.is_enabled())
             or self._background_active
         )
-        if should_render:
-            self._render_and_send(skip_if_video=True)
+        if not should_render:
+            return
+        self._render_and_send(skip_if_video=True)
 
     def start_metrics(self):
         """Start live metrics collection for overlay display."""

{trcc_linux-5.1.1 → trcc_linux-5.2.0}/src/trcc/services/device.py

@@ -9,7 +9,7 @@ import logging
 import threading
 from typing import Any, Optional
 
-from ..core.models import DeviceInfo, LCDDeviceConfig
+from ..core.models import JPEG_MODE_FBLS, DeviceInfo, LCDDeviceConfig
 
 log = logging.getLogger(__name__)
 
@@ -162,16 +162,17 @@ class DeviceService:
     def send_pil(self, image: Any, width: int, height: int) -> bool:
         """Encode PIL Image for device and send.
 
-        Bulk devices use JPEG (C# ImageToJpg — no rotation),
-        SCSI/HID use RGB565 (C# ImageTo565 — non-square pre-rotation).
+        Bulk and HID JPEG-mode devices use JPEG (C# ImageToJpg — no rotation).
+        SCSI/HID (standard) use RGB565 (C# ImageTo565 — non-square pre-rotation).
         """
         from .image import ImageService
 
         device = self._selected
         protocol = device.protocol if device else 'scsi'
         resolution = device.resolution if device else (320, 320)
+        fbl = device.fbl_code if device else None
 
-        if protocol == 'bulk':
+        if protocol == 'bulk' or (protocol == 'hid' and fbl in JPEG_MODE_FBLS):
             jpeg = ImageService.to_jpeg(image)
             return self.send_rgb565(jpeg, width, height)