dexter-controller 0.1.0__tar.gz

dexter_controller-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

dexter_controller-0.1.0/.python-version

@@ -0,0 +1 @@
+3.11

dexter_controller-0.1.0/.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        
+        {
+            "name": "Python Debugger: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        }
+    ]
+}

dexter_controller-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,44 @@
+# 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/example/example.py

@@ -0,0 +1,94 @@
+import time
+from dexter_controller import Finger, DexterHandController
+
+mapping = {
+    "COM20": [Finger.THUMB, Finger.INDEX],
+    "COM5": [Finger.MIDDLE, Finger.RING],
+    "COM8": [Finger.PINKY],
+}
+controller = DexterHandController(mapping)
+
+event_counts = {
+    Finger.THUMB: 0,
+    Finger.INDEX: 0,
+    Finger.MIDDLE: 0,
+    Finger.RING: 0,
+    Finger.PINKY: 0,
+}
+
+
+def make_counter(finger):
+    def on_next(data):
+        event_counts[finger] += 1
+
+    return on_next
+
+
+# Register direct callbacks for event counting
+controller.register_finger_callback(Finger.THUMB, make_counter(Finger.THUMB))
+controller.register_finger_callback(Finger.INDEX, make_counter(Finger.INDEX))
+controller.register_finger_callback(Finger.MIDDLE, make_counter(Finger.MIDDLE))
+controller.register_finger_callback(Finger.RING, make_counter(Finger.RING))
+controller.register_finger_callback(Finger.PINKY, make_counter(Finger.PINKY))
+
+start = time.time()
+try:
+    print("Press Ctrl+C to exit.")
+    while True:
+        time.sleep(1)
+        elapsed = time.time() - start
+        thumb_rate = event_counts[Finger.THUMB] / elapsed
+        index_rate = event_counts[Finger.INDEX] / elapsed
+        middle_rate = event_counts[Finger.MIDDLE] / elapsed
+        ring_rate = event_counts[Finger.RING] / elapsed
+        pinky_rate = event_counts[Finger.PINKY] / elapsed
+
+        thumb_val = controller.thumb.raw_data
+        index_val = controller.index.raw_data
+        middle_val = controller.middle.raw_data
+        ring_val = controller.ring.raw_data
+        pinky_val = controller.pinky.raw_data
+        print(
+            f"Thumb: {thumb_val} ({thumb_rate:.1f} Hz) | "
+            f"Index: {index_val} ({index_rate:.1f} Hz) | "
+            f"Middle: {middle_val} ({middle_rate:.1f} Hz) | "
+            f"Ring: {ring_val} ({ring_rate:.1f} Hz) | "
+            f"Pinky: {pinky_val} ({pinky_rate:.1f} Hz) ",
+            end="\r",
+            flush=True,
+        )
+except KeyboardInterrupt:
+    print("\nExiting...")
+finally:
+    controller.close()
+
+# import time
+# from dexter_controller import Finger, DexterHandController
+
+# mapping = {"COM8": [Finger.THUMB, Finger.INDEX]}
+# controller = DexterHandController(mapping)
+
+# event_counts = {Finger.THUMB: 0, Finger.INDEX: 0}
+
+
+# def make_counter(finger):
+#     def on_next(data):
+#         event_counts[finger] += 1
+
+#     return on_next
+
+
+# controller.thumb_observable.subscribe(make_counter(Finger.THUMB))
+# controller.index_observable.subscribe(make_counter(Finger.INDEX))
+
+# start = time.time()
+# try:
+#     while True:
+#         time.sleep(1)
+#         elapsed = time.time() - start
+#         print(
+#             f"Thumb: {event_counts[Finger.THUMB] / elapsed:.1f} Hz | "
+#             f"Index: {event_counts[Finger.INDEX] / elapsed:.1f} Hz"
+#         )
+# except KeyboardInterrupt:
+#     controller.close()

dexter_controller-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "dexter-controller"
+version = "0.1.0"
+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.11"
+dependencies = [
+    "harp-loadcells>=0.1.0a1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

dexter_controller-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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/uv.lock

@@ -0,0 +1,47 @@
+version = 1
+revision = 2
+requires-python = ">=3.11"
+
+[[package]]
+name = "dexter-controller"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "harp-loadcells" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "harp-loadcells", specifier = ">=0.1.0a1" }]
+
+[[package]]
+name = "harp-loadcells"
+version = "0.1.0a1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "harp-protocol" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bf/4e/5c7dfd822e8ebfe21027c6d2c0196fad2a9094c1d00672b8446824c03e00/harp_loadcells-0.1.0a1.tar.gz", hash = "sha256:1c96806dfa4dfe3f97a3f44b699e94e4198081f6916c8973c84fcef98c3503f5", size = 12635, upload-time = "2025-07-02T10:32:37.076Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/d1/60ef756842c910185d18124bb3930310ca749310465e2880251470774f81/harp_loadcells-0.1.0a1-py3-none-any.whl", hash = "sha256:f4d31851457487199e1faac977274dab89ce91072c4580ea459b472ff23e57bb", size = 9497, upload-time = "2025-07-02T10:32:35.248Z" },
+]
+
+[[package]]
+name = "harp-protocol"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyserial" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/9d/cb689a64faa50b11a96eef252a22d52853d5d057a11e25d741c94aad0665/harp_protocol-0.2.0.tar.gz", hash = "sha256:37483cf538d618d3de5fcbd66673dc61916246dd078a20ce2af0c74954c5621e", size = 86316, upload-time = "2025-07-02T09:29:47.138Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/7f/6ee08075cf060311953067589940ad0a132336695ebb4d8337cd849d93c8/harp_protocol-0.2.0-py3-none-any.whl", hash = "sha256:d07fe0f530900fd137a8f3e8d36b4184603e34d407c3c98919d5d7b2e20cf5d6", size = 16831, upload-time = "2025-07-02T09:29:45.809Z" },
+]
+
+[[package]]
+name = "pyserial"
+version = "3.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1e/7d/ae3f0a63f41e4d2f6cb66a5b57197850f919f59e558159a4dd3a818f5082/pyserial-3.5.tar.gz", hash = "sha256:3c77e014170dfffbd816e6ffc205e9842efb10be9f58ec16d3e8675b4925cddb", size = 159125, upload-time = "2020-11-23T03:59:15.045Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/bc/587a445451b253b285629263eb51c2d8e9bcea4fc97826266d186f96f558/pyserial-3.5-py2.py3-none-any.whl", hash = "sha256:c4451db6ba391ca6ca299fb3ec7bae67a5c55dde170964c7a14ceefec02f2cf0", size = 90585, upload-time = "2020-11-23T03:59:13.41Z" },
+]