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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dexter-controller
-Version: 0.2.0
+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.0 → dexter_controller-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dexter-controller"
-version = "0.2.0"
+version = "0.2.2"
 description = "Dexter Controller for the HARP Load Cells"
 readme = "README.md"
 authors = [

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

@@ -26,10 +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()
@@ -59,29 +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))
+
+        readings.sort(key=lambda x: x[0])
 
         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]
-                load_cells = list(struct.unpack_from(f"<{LOAD_CELLS}H", data, base + 8))
+            for timestamp_us, load_cells in readings:
+                # ignore if it is a repeated timestamp
+                if timestamp_us in self._recent_timestamps_set:
+                    continue
+
+                if len(self._recent_timestamps) == self._recent_timestamps.maxlen:
+                    expired_timestamp = self._recent_timestamps.popleft()
+                    self._recent_timestamps_set.discard(expired_timestamp)
+
+                self._recent_timestamps.append(timestamp_us)
+                self._recent_timestamps_set.add(timestamp_us)
                 self._queue.append(
                     BLELoadCellEvent(
                         payload=load_cells,
@@ -93,6 +107,7 @@ class BLELoadCellDevice:
     async def _run(self):
         print("Searching for BLE device...")
         device = await self._discover_target()
+        print(f"Found {self.identifier}")
         if not device:
             self._connection_error = RuntimeError("No matching BLE peripheral found")
             self._ready_event.set()
@@ -102,7 +117,7 @@ class BLELoadCellDevice:
             device,
             disconnected_callback=lambda _: self._stop_event.set(),
         )
-
+        print(f"Connecting to {self.identifier}")
         try:
             await self._client.connect()
             await self._client.start_notify(CHAR_UUID, self._notification_callback)

{dexter_controller-0.2.0 → 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}")