dexter-controller 0.2.1__tar.gz → 0.2.2__tar.gz

{dexter_controller-0.2.1 → dexter_controller-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dexter-controller
-Version: 0.2.1
+Version: 0.2.2
 Summary: Dexter Controller for the HARP Load Cells
 Author: Hardware and Software Platform, Champalimaud Foundation
 Author-email: Hardware and Software Platform, Champalimaud Foundation <software@research.fchampalimaud.org>

{dexter_controller-0.2.1 → dexter_controller-0.2.2}/pyproject.toml

@@ -1,21 +1,21 @@
-[project]
-name = "dexter-controller"
-version = "0.2.1"
-description = "Dexter Controller for the HARP Load Cells"
-readme = "README.md"
-authors = [
-    { name = "Hardware and Software Platform, Champalimaud Foundation", email = "software@research.fchampalimaud.org" }
-]
-requires-python = ">=3.10"
-dependencies = [
-    "bleak==2.1.1",
-    "harp-loadcells>=0.1.0a3",
-]
-
-[project.urls]
-Repository = "https://github.com/fchampalimaud/dexter-controller/"
-"Bug Tracker" = "https://github.com/fchampalimaud/dexter-controller/issues"
-
-[build-system]
-requires = ["uv_build>=0.9.5,<0.10.0"]
-build-backend = "uv_build"
+[project]
+name = "dexter-controller"
+version = "0.2.2"
+description = "Dexter Controller for the HARP Load Cells"
+readme = "README.md"
+authors = [
+    { name = "Hardware and Software Platform, Champalimaud Foundation", email = "software@research.fchampalimaud.org" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "bleak==2.1.1",
+    "harp-loadcells>=0.1.0a3",
+]
+
+[project.urls]
+Repository = "https://github.com/fchampalimaud/dexter-controller/"
+"Bug Tracker" = "https://github.com/fchampalimaud/dexter-controller/issues"
+
+[build-system]
+requires = ["uv_build>=0.9.5,<0.10.0"]
+build-backend = "uv_build"

{dexter_controller-0.2.1 → dexter_controller-0.2.2}/src/dexter_controller/ble_loadcell_device.py

@@ -26,11 +26,13 @@ class BLELoadCellEvent:
 
 
 class BLELoadCellDevice:
-    def __init__(self):
+    def __init__(self, scan_timeout=1.0):
         self.identifier = f"BLE:{DEVICE_NAME}"
         self._queue = deque()
         self._queue_lock = threading.Lock()
         self._recent_timestamps = deque(maxlen=NUM_READINGS * 2)
+        self._recent_timestamps_set = set()
+        self._scan_timeout = scan_timeout
 
         self._stop_event = threading.Event()
         self._ready_event = threading.Event()
@@ -60,35 +62,40 @@ class BLELoadCellDevice:
 
     async def _discover_target(self):
         target = DEVICE_NAME.lower()
-        discovered = await BleakScanner.discover(timeout=10, return_adv=True)
-
-        for _, (candidate, adv_data) in discovered.items():
-            name = (candidate.name or adv_data.local_name or "").lower()
-            if target in name:
-                self.identifier = (
-                    f"BLE:{candidate.name or DEVICE_NAME} ({candidate.address})"
-                )
-                return candidate
-
-        return None
+        return await BleakScanner.find_device_by_filter(
+            lambda device, adv_data: (
+                target in (device.name or adv_data.local_name or "").lower()
+            ),
+            timeout=self._scan_timeout,
+        )
 
     def _notification_callback(self, _, data: bytearray):
         if len(data) < PACKET_SIZE:
             return
 
         counter = struct.unpack_from("<i", data, 0)[0]
+        # make sure timestamps are monotonically increasing
+        readings = []
+        for reading_index in range(NUM_READINGS):
+            base = 4 + (reading_index * BLOCK_SIZE)
+            timestamp_us = struct.unpack_from("<Q", data, base)[0]
+            load_cells = list(struct.unpack_from(f"<{LOAD_CELLS}H", data, base + 8))
+            readings.append((timestamp_us, load_cells))
 
-        with self._queue_lock:
-            for reading_index in range(NUM_READINGS):
-                base = 4 + (reading_index * BLOCK_SIZE)
-                timestamp_us = struct.unpack_from("<Q", data, base)[0]
+        readings.sort(key=lambda x: x[0])
 
-                if timestamp_us in self._recent_timestamps:
+        with self._queue_lock:
+            for timestamp_us, load_cells in readings:
+                # ignore if it is a repeated timestamp
+                if timestamp_us in self._recent_timestamps_set:
                     continue
 
-                self._recent_timestamps.append(timestamp_us)
+                if len(self._recent_timestamps) == self._recent_timestamps.maxlen:
+                    expired_timestamp = self._recent_timestamps.popleft()
+                    self._recent_timestamps_set.discard(expired_timestamp)
 
-                load_cells = list(struct.unpack_from(f"<{LOAD_CELLS}H", data, base + 8))
+                self._recent_timestamps.append(timestamp_us)
+                self._recent_timestamps_set.add(timestamp_us)
                 self._queue.append(
                     BLELoadCellEvent(
                         payload=load_cells,

{dexter_controller-0.2.1 → dexter_controller-0.2.2}/src/dexter_controller/dexter_hand_controller.py

@@ -12,12 +12,30 @@ class DexterHandController:
         self,
         mapping: dict | None = None,  # {com_port: [Finger, ...]}
         use_ble=False,  # use BLE instead of serial
+        ble_scan_timeout=1.0,  # seconds to scan for BLE devices in each connection attempt
     ):
+        """Controller for Dexter hand load cells, supporting both serial and BLE devices.
+
+        Attributes
+        ----------
+        mapping : dict
+            Optional mapping of serial COM ports to lists of Fingers. Ignored if use_ble is True. Example:
+            mapping = {
+                "COM3": [Finger.THUMB, Finger.INDEX],
+                "COM4": [Finger.MIDDLE, Finger.RING, Finger.PINKY],
+            }
+        use_ble : bool
+            If True, ignore mapping and connect to the first available BLE device with the expected service/characteristic.
+        ble_scan_timeout : float
+            Seconds to scan for BLE devices in each connection attempt (only relevant if use_ble is True).
+        """
+
         if not use_ble and not mapping:
             raise ValueError("mapping cannot be empty when use_ble is False")
 
         self._mapping = dict(mapping or {})
         self._use_ble = use_ble
+        self._ble_scan_timeout = ble_scan_timeout
         self._lock = threading.Lock()
 
         self._finger_to_binding = {}  # {Finger: (device, start, stop)}
@@ -103,7 +121,7 @@ class DexterHandController:
             self._reset_connections()
 
             try:
-                device = BLELoadCellDevice()
+                device = BLELoadCellDevice(scan_timeout=self._ble_scan_timeout)
             except Exception as e:
                 self.unavailable_ports.append("BLE:Dexter")
                 print(f"Failed to connect to BLE device: {e}")