trcc-linux 4.2.6__tar.gz → 4.2.8__tar.gz

{trcc_linux-4.2.6 → trcc_linux-4.2.8}/PKG-INFO

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

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

{trcc_linux-4.2.6 → trcc_linux-4.2.8}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "4.2.6"
+__version__ = "4.2.8"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -164,3 +164,13 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 #          (pm_to_fbl, fbl_to_resolution), extract _render_and_send/_scan_lsscsi
 #          helpers, remove duplicate overlay.configure(), dead code cleanup.
 #          SCSI handshake fix (was returning None since v4.2.4). 2311 tests.
+# 4.2.7  - Fix frame transfer: send entire buffer in single USB transfer
+#          instead of chunking (HID Type 2 + Bulk), matching Windows USBLCDNEW.
+#          Expand debug report raw handshake output from 16 to 64 bytes.
+#          2311 tests.
+# 4.2.8  - Fix LED segment display: LF8/LF12 MHz now uses 4 digits (0-9999)
+#          matching C# SetMyNumeral, fixing 999 MHz cap. Correct usage digit
+#          indices (were overlapping MHz ones position via remap table).
+#          Fix LED device handshake warning on boot: route LED devices
+#          directly to LED panel in auto-select, skipping LCD handshake.
+#          2311 tests.

{trcc_linux-4.2.6 → trcc_linux-4.2.8}/src/trcc/adapters/device/bulk.py

@@ -309,18 +309,14 @@ class BulkDevice:
         struct.pack_into("<I", header, 60, data_size)    # payload length
 
         try:
-            # Send header
-            self._ep_out.write(bytes(header), timeout=_WRITE_TIMEOUT_MS)  # type: ignore[union-attr]
-
-            # Send payload in chunks
-            offset = 0
-            while offset < data_size:
-                chunk = image_data[offset:offset + _WRITE_CHUNK_SIZE]
-                self._ep_out.write(chunk, timeout=_WRITE_TIMEOUT_MS)  # type: ignore[union-attr]
-                offset += len(chunk)
-
-            # ZLP frame delimiter
-            self._ep_out.write(b"", timeout=_WRITE_TIMEOUT_MS)  # type: ignore[union-attr]
+            # C# USBLCDNEW ThreadSendDeviceData: single SubmitAsyncTransfer
+            # of header + payload as one contiguous buffer.
+            frame = bytes(header) + image_data
+            self._ep_out.write(frame, timeout=_WRITE_TIMEOUT_MS)  # type: ignore[union-attr]
+
+            # C#: ZLP when total is 512-aligned (num2 % 512 == 0)
+            if len(frame) % 512 == 0:
+                self._ep_out.write(b"", timeout=_WRITE_TIMEOUT_MS)  # type: ignore[union-attr]
 
             log.debug("Bulk frame sent: %dx%d, cmd=%d, %d bytes",
                       self.width, self.height, cmd, data_size)

{trcc_linux-4.2.6 → trcc_linux-4.2.8}/src/trcc/adapters/device/hid.py

@@ -372,9 +372,9 @@ class HidDeviceType2(HidDevice):
     def send_frame(self, image_data: bytes) -> bool:
         """Send one image frame to the device.
 
-        TRCC (UCDevice.cs ThreadSendDeviceData2) sends frames in 512-byte
-        chunks via UsbHidDevice.SendMessage().  We mirror that: build the
-        padded packet, then write it in 512-byte pieces.
+        USBLCDNEW.exe ThreadSendDeviceDataH sends the entire 512-aligned
+        buffer in a single Transfer() call.  pyusb splits into USB packets
+        internally — the device sees one logical transfer.
 
         Args:
             image_data: Raw image bytes (JPEG or other format the
@@ -391,11 +391,8 @@ class HidDeviceType2(HidDevice):
 
         packet = self.build_frame_packet(image_data)
 
-        # C# UCDevice.cs ThreadSendDeviceData2: sends 512-byte chunks
-        total = 0
-        for offset in range(0, len(packet), USB_BULK_ALIGNMENT):
-            chunk = packet[offset:offset + USB_BULK_ALIGNMENT]
-            total += self.transport.write(EP_WRITE_02, chunk, DEFAULT_TIMEOUT_MS)
+        # C# USBLCDNEW ThreadSendDeviceDataH: single Transfer() call
+        total = self.transport.write(EP_WRITE_02, packet, DEFAULT_TIMEOUT_MS)
 
         # C#: Thread.Sleep(1) after frame transfer
         time.sleep(DELAY_FRAME_TYPE2_S)

{trcc_linux-4.2.6 → trcc_linux-4.2.8}/src/trcc/adapters/device/led_segment.py

@@ -162,6 +162,33 @@ class SegmentDisplay(ABC):
                 if seg_name in segs:
                     mask[leds[wire_idx]] = True
 
+    def _encode_4digit(
+        self,
+        value: int,
+        digit_leds: Tuple[Tuple[int, ...], ...],
+        mask: List[bool],
+    ) -> None:
+        """Encode 0-9999 into 4 seven-segment digits with leading-zero suppression.
+
+        C# SetMyNumeral MHz: num4=thousands, num=hundreds, num2=tens, num3=ones.
+        """
+        v = max(0, min(9999, value))
+        d_th, d_h = v // 1000, (v % 1000) // 100
+        d_t, d_o = (v % 100) // 10, v % 10
+        chars = [str(d_th), str(d_h), str(d_t), str(d_o)]
+        if d_th == 0:
+            chars[0] = ' '
+            if d_h == 0:
+                chars[1] = ' '
+                if d_t == 0:
+                    chars[2] = ' '
+        for digit_idx, ch in enumerate(chars):
+            segs = self.CHAR_7SEG.get(ch, set())
+            leds = digit_leds[digit_idx]
+            for wire_idx, seg_name in enumerate(self.WIRE_7SEG):
+                if seg_name in segs:
+                    mask[leds[wire_idx]] = True
+
     def _encode_2digit_partial(
         self,
         value: int,
@@ -582,15 +609,16 @@ class LF8Display(SegmentDisplay):
         (42, 43, 44, 45, 46, 47, 48),
     )
     MHZ_DIGITS: Tuple[Tuple[int, ...], ...] = (
-        (49, 50, 51, 52, 53, 54, 55),
-        (56, 57, 58, 59, 60, 61, 62),
-        (63, 64, 65, 66, 67, 68, 69),
+        (49, 50, 51, 52, 53, 54, 55),    # seg7 = thousands
+        (56, 57, 58, 59, 60, 61, 62),    # seg8 = hundreds
+        (63, 64, 65, 66, 67, 68, 69),    # seg9 = tens
+        (70, 71, 72, 73, 74, 75, 76),    # seg10 = ones
     )
     USE_DIGITS: Tuple[Tuple[int, ...], ...] = (
-        (70, 71, 72, 73, 74, 75, 76),
-        (77, 78, 79, 80, 81, 82, 83),
+        (77, 78, 79, 80, 81, 82, 83),    # seg11 = tens
+        (84, 85, 86, 87, 88, 89, 90),    # seg12 = ones
     )
-    USE_PARTIAL = (91, 92)
+    USE_PARTIAL = (91, 92)                    # seg13 partial = hundreds (B,C)
 
     PHASES = (
         ('cpu_temp', 'cpu_power', 'cpu_freq', 'cpu_percent', CPU1),
@@ -621,7 +649,7 @@ class LF8Display(SegmentDisplay):
 
         self._encode_3digit(self._to_display_temp(getattr(metrics, temp_key, 0), temp_unit), self.TEMP_DIGITS, mask)
         self._encode_3digit(int(getattr(metrics, watt_key, 0)), self.WATT_DIGITS, mask)
-        self._encode_3digit(int(getattr(metrics, mhz_key, 0)), self.MHZ_DIGITS, mask)
+        self._encode_4digit(int(getattr(metrics, mhz_key, 0)), self.MHZ_DIGITS, mask)
         self._encode_2digit_partial(
             int(getattr(metrics, use_key, 0)), self.USE_DIGITS, self.USE_PARTIAL, mask,
         )
@@ -657,7 +685,7 @@ class LF12Display(LF8Display):
 
         self._encode_3digit(self._to_display_temp(getattr(metrics, temp_key, 0), temp_unit), self.TEMP_DIGITS, mask)
         self._encode_3digit(int(getattr(metrics, watt_key, 0)), self.WATT_DIGITS, mask)
-        self._encode_3digit(int(getattr(metrics, mhz_key, 0)), self.MHZ_DIGITS, mask)
+        self._encode_4digit(int(getattr(metrics, mhz_key, 0)), self.MHZ_DIGITS, mask)
         self._encode_2digit_partial(
             int(getattr(metrics, use_key, 0)), self.USE_DIGITS, self.USE_PARTIAL, mask,
         )

{trcc_linux-4.2.6 → trcc_linux-4.2.8}/src/trcc/adapters/infra/debug_report.py

@@ -285,7 +285,7 @@ class DebugReport:
             if info.serial:
                 sec.lines.append(f"    serial={info.serial}")
             if info.raw_response:
-                sec.lines.append(f"    raw[0:16]={info.raw_response[:16].hex()}")
+                sec.lines.append(f"    raw[0:64]={info.raw_response[:64].hex()}")
         finally:
             protocol.close()
 
@@ -312,7 +312,7 @@ class DebugReport:
                 f"model={info.model_name}, {known}{style_info}"
             )
             if info.raw_response:
-                sec.lines.append(f"    raw[0:16]={info.raw_response[:16].hex()}")
+                sec.lines.append(f"    raw[0:64]={info.raw_response[:64].hex()}")
         finally:
             protocol.close()
 
@@ -331,6 +331,6 @@ class DebugReport:
                 f"serial={result.serial}"
             )
             if result.raw_response:
-                sec.lines.append(f"    raw[0:16]={result.raw_response[:16].hex()}")
+                sec.lines.append(f"    raw[0:64]={result.raw_response[:64].hex()}")
         finally:
             protocol.close()

{trcc_linux-4.2.6 → trcc_linux-4.2.8}/src/trcc/qt_components/qt_app_mvc.py

@@ -1126,6 +1126,13 @@ class TRCCMainWindowMVC(QMainWindow):
                  device.path, device.vid, device.pid, device.protocol, device.resolution)
         self._active_device_key = Settings.device_config_key(
             device.device_index, device.vid, device.pid)
+
+        # LED devices have no LCD resolution — route to LED panel directly.
+        if device.implementation == 'hid_led':
+            self._led.show(device)
+            self._show_view('led')
+            return
+
         self.uc_preview.set_status(f"Device: {device.path}")
 
         # Resolution (0,0) = not yet discovered — handshake to find it.

{trcc_linux-4.2.6 → trcc_linux-4.2.8}/tests/test_device_bulk.py

@@ -492,8 +492,10 @@ class TestBulkDeviceSendFrame(unittest.TestCase):
         data = b'\x00' * 1000
         bd.send_frame(data)
 
-        header = bd._ep_out.write.call_args_list[0][0][0]
-        self.assertEqual(len(header), 64)
+        # Single write: 64-byte header + payload
+        frame = bd._ep_out.write.call_args_list[0][0][0]
+        self.assertEqual(len(frame), 64 + 1000)
+        header = frame[:64]
         self.assertEqual(header[0:4], b'\x12\x34\x56\x78')
         # Cmd = 2 (JPEG)
         self.assertEqual(struct.unpack_from("<I", header, 4)[0], 2)
@@ -508,8 +510,10 @@ class TestBulkDeviceSendFrame(unittest.TestCase):
         data = b'\x00' * 1000
         bd.send_frame(data)
 
-        header = bd._ep_out.write.call_args_list[0][0][0]
-        self.assertEqual(len(header), 64)
+        # Single write: 64-byte header + payload
+        frame = bd._ep_out.write.call_args_list[0][0][0]
+        self.assertEqual(len(frame), 64 + 1000)
+        header = frame[:64]
         self.assertEqual(header[0:4], b'\x12\x34\x56\x78')
         # Cmd = 3 (raw RGB565)
         self.assertEqual(struct.unpack_from("<I", header, 4)[0], 3)
@@ -518,37 +522,38 @@ class TestBulkDeviceSendFrame(unittest.TestCase):
         self.assertEqual(struct.unpack_from("<I", header, 56)[0], 2)
         self.assertEqual(struct.unpack_from("<I", header, 60)[0], 1000)
 
-    def test_send_frame_payload_chunked(self):
-        """Pixel data is sent in chunks after the header."""
+    def test_send_frame_single_transfer(self):
+        """Header + payload sent as one contiguous buffer."""
         bd = self._setup_device()
         data = b'\xAB\xCD' * 500  # 1000 bytes
         bd.send_frame(data)
 
         calls = bd._ep_out.write.call_args_list
-        # calls: header + 1 data chunk (< 16 KiB) + ZLP
-        self.assertEqual(calls[1][0][0], data)
+        # Single write (header + payload), no ZLP (1064 % 512 != 0)
+        self.assertEqual(len(calls), 1)
+        frame = calls[0][0][0]
+        self.assertEqual(frame[64:], data)
 
-    def test_send_frame_zlp_always_sent(self):
-        """ZLP frame delimiter is always sent after pixel data."""
+    def test_send_frame_zlp_when_512_aligned(self):
+        """ZLP sent only when total frame size is 512-aligned."""
         bd = self._setup_device()
-        data = b'\x00' * 100
+        # 512 - 64 = 448 bytes of payload → total 512, 512-aligned
+        data = b'\x00' * 448
         bd.send_frame(data)
 
-        # Last write should be ZLP
-        last_call = bd._ep_out.write.call_args_list[-1]
-        self.assertEqual(last_call[0][0], b"")
+        calls = bd._ep_out.write.call_args_list
+        self.assertEqual(len(calls), 2)
+        self.assertEqual(calls[1][0][0], b"")
 
-    def test_send_frame_large_data_chunked(self):
-        """Data larger than 16 KiB is sent in multiple chunks."""
+    def test_send_frame_no_zlp_when_not_aligned(self):
+        """No ZLP when total frame size is not 512-aligned."""
         bd = self._setup_device()
-        data = b'\x00' * (16 * 1024 + 100)  # 16484 bytes
+        data = b'\x00' * 100
         bd.send_frame(data)
 
+        # Only 1 write (no ZLP needed)
         calls = bd._ep_out.write.call_args_list
-        # header + 2 data chunks + ZLP = 4 writes
-        self.assertEqual(len(calls), 4)
-        self.assertEqual(len(calls[1][0][0]), 16 * 1024)
-        self.assertEqual(len(calls[2][0][0]), 100)
+        self.assertEqual(len(calls), 1)
 
     def test_send_frame_returns_true_on_success(self):
         bd = self._setup_device()