Update uart handling and version string Fixes #357

Author: georgevigelette

src/openlifu/io/LIFUDFU.py

@@ -308,18 +308,20 @@ def _recover_idle(self) -> None:
             else:
                 break
 
-    def _wait_while_busy(self) -> dict:
+    def _wait_while_busy(self, timeout_s: float = 30.0) -> dict:
         busy = {
             self.STATE_DFU_DNLOAD_SYNC,
             self.STATE_DFU_DNLOAD_BUSY,
             self.STATE_DFU_MANIFEST_SYNC,
             self.STATE_DFU_MANIFEST,
         }
-        while True:
+        deadline = time.monotonic() + timeout_s
+        while time.monotonic() < deadline:
             st = self.get_status()
             if st["state"] not in busy:
                 return st
             time.sleep(max(st["poll_timeout_ms"] / 1000.0, 0.005))
+        raise TimeoutError(f"USB DFU device stuck in busy state after {timeout_s:.0f} s")
 
     def _dnload(self, block_num: int, payload: bytes) -> dict:
         self._recover_idle()
@@ -328,8 +330,10 @@ def _dnload(self, block_num: int, payload: bytes) -> dict:
                 self.DFU_DNLOAD, block_num, bytes(payload) if payload else b""
             )
         except _usb_core.USBError as e:
-            if "timeout" not in str(e).lower():
+            # errno 110 = ETIMEDOUT (libusb); swallow only genuine transfer timeouts
+            if e.errno != 110:
                 raise
+            logger.debug("_dnload timeout on block %d, polling status anyway: %s", block_num, e)
         return self._wait_while_busy()
 
     def _set_address(self, address: int) -> None:
@@ -456,8 +460,14 @@ def _exchange(self, payload: bytes, read_len: int,
                 f"I2C passthrough exchange failed (addr=0x{self._addr:02X}, "
                 f"want_rx={read_len})"
             )
-        return bytes(r.data[:read_len]) if (r.data and len(r.data) >= read_len) \
-               else bytes(read_len)
+        actual = len(r.data) if r.data else 0
+        if actual < read_len:
+            raise RuntimeError(
+                f"I2C passthrough exchange returned too few bytes: "
+                f"expected {read_len}, got {actual} "
+                f"(addr=0x{self._addr:02X})"
+            )
+        return bytes(r.data[:read_len])
 
     # --- DFU protocol commands ---
 

src/openlifu/io/LIFUHVController.py

@@ -133,8 +133,11 @@ def get_version(self) -> str:
             # r.print_packet()
             if r.data_len == 3:
                 ver = f"v{r.data[0]}.{r.data[1]}.{r.data[2]}"
-            else:
-                ver = "v0.0.0"
+            elif r.data_len and r.data:
+                # Decode only the valid length, strip trailing NULs and whitespace
+                ver_str = r.data[:r.data_len].decode('utf-8', errors='ignore').rstrip('\x00').strip()
+                ver = ver_str if ver_str else 'v0.0.0'
+
             logger.info(ver)
             return ver
 

src/openlifu/io/LIFUTXDevice.py

@@ -1363,7 +1363,11 @@ def read_block(self, identifier: int, start_address: int, count: int) -> Optiona
                 raise ValueError(f"count must be 1-62, got {count}")
 
             # Request payload: uint16_t start_addr, uint8_t count, uint8_t reserved
-            data = struct.pack('<HBB', start_address, count, 0)
+            try:
+                data = struct.pack('<HBB', start_address, count, 0)
+            except struct.error as e:
+                logger.error(f"Error packing read_block request: {e}")
+                raise ValueError("Invalid start_address or count format") from e
 
             r = self.uart.send_packet(
                 id=None,
@@ -1383,7 +1387,12 @@ def read_block(self, identifier: int, start_address: int, count: int) -> Optiona
                 logger.error(f"Unexpected data length: {r.data_len}, expected {expected_len}")
                 return None
 
-            values = list(struct.unpack(f'<{count}I', r.data))
+            try:
+                values = list(struct.unpack(f'<{count}I', r.data[:expected_len]))
+            except struct.error as e:
+                logger.error(f"Failed to unpack read_block response ({len(r.data)} bytes): {e}")
+                return None
+
             logger.debug(f"read_block: {count} regs from 0x{start_address:04X} on tx {identifier}")
             return values
 

src/openlifu/io/LIFUUart.py

@@ -228,7 +228,7 @@ def disconnect(self):
             return
 
         if self.read_thread:
-            self.read_thread.join()
+            self.read_thread.join(timeout=5)
         if self.serial and self.serial.is_open:
             self.serial.close()
             self.serial = None
@@ -367,8 +367,14 @@ def _read_data(self, timeout=20):
                 else:
                     time.sleep(0.05)  # Brief sleep to avoid a busy loop
             except serial.SerialException as e:
+                if "ClearCommError" in str(e):
+                    log.warning("Serial _read_data ClearCommError on %s (ignoring): %s", self.descriptor, e)
+                    time.sleep(0.1)
+                    continue
                 log.error("Serial _read_data error on %s: %s", self.descriptor, e)
                 self.running = False
+                self.signal_disconnect.emit(self.descriptor, self.port)
+                self.port = None
 
     def _tx(self, data: bytes):
         """Send data over UART."""