dexter-controller 0.1.0__py3-none-any.whl

dexter_controller/__init__.py

@@ -0,0 +1,10 @@
+from .finger import Finger, FingerData
+from .loadcell_device import LoadCellDevice
+from .dexter_hand_controller import DexterHandController
+
+__all__ = [
+    "Finger",
+    "FingerData",
+    "LoadCellDevice",
+    "DexterHandController",
+]

dexter_controller/dexter_hand_controller.py

@@ -0,0 +1,72 @@
+import threading
+import time
+from collections import defaultdict
+
+from dexter_controller import Finger, FingerData, LoadCellDevice
+
+
+class DexterHandController:
+    def __init__(self, mapping):
+        if not mapping:
+            raise ValueError("mapping cannot be empty")
+        self._finger_to_device = {}
+        self.finger_data = defaultdict(lambda: FingerData([0, 0, 0, 0]))
+        self._devices = []
+        self._callbacks = defaultdict(list)  # {Finger: [callback, ...]}
+        self._stop_event = threading.Event()
+
+        for com_port, fingers in mapping.items():
+            device = LoadCellDevice(com_port, start_thread=False)
+            self._devices.append(device)
+            for i, finger in enumerate(fingers):
+                self._finger_to_device[finger] = (device, i)
+
+        self._poll_thread = threading.Thread(target=self._poll_loop, daemon=True)
+        self._poll_thread.start()
+
+    def _poll_loop(self):
+        while not self._stop_event.is_set():
+            for device in self._devices:
+                for event in device.device.get_events():
+                    data = event.payload  # 8 values: 4 per finger
+                    for i in (0, 1):
+                        finger_data = data[i * 4 : (i + 1) * 4]
+                        # Find which finger this is
+                        for finger, (dev, idx) in self._finger_to_device.items():
+                            if dev is device and idx == i:
+                                self.finger_data[finger].raw_data = finger_data
+                                for cb in self._callbacks[finger]:
+                                    cb(finger_data)
+            time.sleep(0.001)
+
+    def register_finger_callback(self, finger, callback):
+        """Register a callback for a finger. Callback will be called with new data."""
+        self._callbacks[finger].append(callback)
+
+    def close(self):
+        self._stop_event.set()
+        self._poll_thread.join()
+        # Close all devices
+        for device in self._devices:
+            device.close()
+        self._callbacks.clear()
+
+    @property
+    def thumb(self):
+        return self.finger_data[Finger.THUMB]
+
+    @property
+    def index(self):
+        return self.finger_data[Finger.INDEX]
+
+    @property
+    def middle(self):
+        return self.finger_data[Finger.MIDDLE]
+
+    @property
+    def ring(self):
+        return self.finger_data[Finger.RING]
+
+    @property
+    def pinky(self):
+        return self.finger_data[Finger.PINKY]

dexter_controller/finger.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class Finger(Enum):
+    THUMB = 0
+    INDEX = 1
+    MIDDLE = 2
+    RING = 3
+    PINKY = 4
+
+
+class FingerData:
+    def __init__(self, raw_data):
+        if raw_data is None or len(raw_data) != 4:
+            raise ValueError("raw_data must have exactly 4 elements")
+        self.raw_data = raw_data

dexter_controller/loadcell_device.py

@@ -0,0 +1,47 @@
+import threading
+from typing import Optional
+
+from pyharp.devices.loadcells import LoadCellEvents, LoadCells
+from pyharp.protocol import OperationMode
+
+
+class LoadCellDevice:
+    def __init__(self, com_port, start_thread=True):
+        if not com_port:
+            raise ValueError("com_port cannot be empty")
+        self.com_port = com_port
+        self.device = LoadCells(com_port)
+        self.device.set_mode(OperationMode.ACTIVE)
+        # set to only receive events from the load cells
+        self.device.write_enable_events(LoadCellEvents.LOAD_CELL_DATA)
+        self._finger_callbacks = {
+            0: [],
+            1: [],
+        }  # 0: first finger, 1: second finger
+        self._stop_event = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+        if start_thread:
+            self._thread = threading.Thread(target=self._event_loop)
+            self._thread.daemon = True
+            self._thread.start()
+
+    def register_callback(self, finger_index, callback):
+        if finger_index not in (0, 1):
+            raise IndexError("finger_index must be 0 or 1")
+        self._finger_callbacks[finger_index].append(callback)
+
+    def _event_loop(self):
+        with self.device as dev:
+            while not self._stop_event.is_set():
+                for event in dev.get_events():
+                    data = event.payload  # Should be a list of 8 values
+                    # Each finger gets 4 values: [0:4] and [4:8]
+                    for i in (0, 1):
+                        finger_data = data[i * 4 : (i + 1) * 4]
+                        for cb in self._finger_callbacks[i]:
+                            cb(finger_data)
+
+    def close(self):
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join()

dexter_controller-0.1.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: dexter-controller
+Version: 0.1.0
+Summary: Dexter Controller for the HARP Load Cells
+Author-email: "Hardware and Software Platform, Champalimaud Foundation" <software@research.fchampalimaud.org>
+Requires-Python: >=3.11
+Requires-Dist: harp-loadcells>=0.1.0a1
+Description-Content-Type: text/markdown
+
+# dexter-controller (Python)
+This is a Python package for controlling the Dexter device. It provides an interface to interact with it using a mapping between the device's and the connected LoadCells for each finger.
+
+# Installation
+You can install the package using uv:
+```bash
+uv add "harp.loadcells @ git+ssh://git@github.com/fchampalimaud/pyharp.loadcells.test.git"
+```
+
+# Usage example
+
+```python
+import time
+from dexter_controller import Finger, DexterHandController
+
+# The mapping dictionary should contain the serial port paths as keys and a list of Finger enums as values.
+mapping = {
+    "/dev/ttyUSB0": [Finger.THUMB, Finger.INDEX],   # "COMx" on Windows
+    "/dev/ttyUSB1": [Finger.MIDDLE, Finger.RING],   # "COMy" on Windows
+    "/dev/ttyUSB2": [Finger.PINKY],                 # "COMz on Windows
+}
+
+# When using the controller, you can access the raw data for each finger.
+# Devices are connected on creation of the controller.
+controller = DexterHandController(mapping)
+
+try:
+    print("Press Ctrl+C to exit.")
+    while True:
+        line = (
+            f"Thumb: {controller.thumb.raw_data if controller.thumb else None} | "
+            f"Index: {controller.index.raw_data if controller.index else None} | "
+            f"Middle: {controller.middle.raw_data if controller.middle else None} | "
+            f"Ring: {controller.ring.raw_data if controller.ring else None} | "
+            f"Pinky: {controller.pinky.raw_data if controller.pinky else None}    "
+        )
+        print(line, end="\r", flush=True)
+        # sleep for a short duration to avoid flooding the output (20 milliseconds)
+        time.sleep(0.02)
+except KeyboardInterrupt:
+    print("Exiting...")
+finally:
+    controller.close()
+```

dexter_controller-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+dexter_controller/__init__.py,sha256=Bhn2cO7oTKBTCR4DA_dLEiOUws_qPp3jDBFRMOYBHGo,237
+dexter_controller/dexter_hand_controller.py,sha256=DdFbunkEuZ6TKdpyuc38dcqSbzToiyx1EkFg2m24v5U,2488
+dexter_controller/finger.py,sha256=SiS4IVW_7oW4YZ9tpL6IqDiDlt0sFBc-XTBPSNdBg2M,322
+dexter_controller/loadcell_device.py,sha256=bIk3TxPOq9ThoCaipwEtNzpZ27rmrPDkIfPejF2xJ2E,1781
+dexter_controller-0.1.0.dist-info/METADATA,sha256=uDwCnX-CbJYU_0HLNzx1WQoV7cR-3v4CR1v2J6efZho,2046
+dexter_controller-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dexter_controller-0.1.0.dist-info/RECORD,,

dexter_controller-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any