pyrobotiqtactile 0.1.0__tar.gz

pyrobotiqtactile-0.1.0/LICENCE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Robotiq
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pyrobotiqtactile-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: pyrobotiqtactile
+Version: 0.1.0
+Summary: Python support for the Robotiq TSF-85 tactile sensor
+Author: Benoit CASTETS
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/bcastets-robotiq/pyRobotiqTactile
+Project-URL: Repository, https://github.com/bcastets-robotiq/pyRobotiqTactile
+Project-URL: Issues, https://github.com/bcastets-robotiq/pyRobotiqTactile/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: numpy>=1.26
+Requires-Dist: pyserial>=3.5
+Dynamic: license-file
+
+# pyRobotiqTactile
+
+A Python package for communicating with the Robotiq TSF-85 tactile sensor.
+
+The project focuses on a public `RobotiqTactileSensor` class that provides:
+
+- serial communication setup
+- sensor configuration and autosend control
+- pressure-frame decoding as NumPy arrays
+- accelerometer and gyroscope access
+- a structured `SensorReading` container for the decoded data
+
+## Quick start
+
+```python
+from pyrobotiqtactile import RobotiqTactileSensor
+
+sensor = RobotiqTactileSensor()
+sensor.connect("COM3")
+sensor.configure(update_period_ms=50, synchronous=True)
+
+reading = sensor.read_frame()
+print(reading.pressure.shape)
+print(sensor.get_imu())
+```
+
+## Development
+
+```bash
+pip install -e .
+python -m unittest discover -s tests -v
+```

pyrobotiqtactile-0.1.0/README.md

@@ -0,0 +1,32 @@
+# pyRobotiqTactile
+
+A Python package for communicating with the Robotiq TSF-85 tactile sensor.
+
+The project focuses on a public `RobotiqTactileSensor` class that provides:
+
+- serial communication setup
+- sensor configuration and autosend control
+- pressure-frame decoding as NumPy arrays
+- accelerometer and gyroscope access
+- a structured `SensorReading` container for the decoded data
+
+## Quick start
+
+```python
+from pyrobotiqtactile import RobotiqTactileSensor
+
+sensor = RobotiqTactileSensor()
+sensor.connect("COM3")
+sensor.configure(update_period_ms=50, synchronous=True)
+
+reading = sensor.read_frame()
+print(reading.pressure.shape)
+print(sensor.get_imu())
+```
+
+## Development
+
+```bash
+pip install -e .
+python -m unittest discover -s tests -v
+```

pyrobotiqtactile-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyrobotiqtactile"
+version = "0.1.0"
+description = "Python support for the Robotiq TSF-85 tactile sensor"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "numpy>=1.26",
+  "pyserial>=3.5",
+]
+authors = [
+  { name = "Benoit CASTETS" },
+]
+license = "BSD-3-Clause"
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering",
+]
+[project.urls]
+Homepage = "https://github.com/bcastets-robotiq/pyRobotiqTactile"
+Repository = "https://github.com/bcastets-robotiq/pyRobotiqTactile"
+Issues = "https://github.com/bcastets-robotiq/pyRobotiqTactile/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.uv]
+package = true

pyrobotiqtactile-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyrobotiqtactile-0.1.0/src/pyrobotiqtactile/__init__.py

@@ -0,0 +1,35 @@
+"""Python package for the Robotiq TSF-85 tactile sensor."""
+
+from .data import SensorReading
+from .exceptions import (
+    RobotiqTactileError,
+    SensorConnectionError,
+    SensorNotFoundError,
+    SensorTimeoutError,
+)
+from .protocol import (
+    BAUD_RATE,
+    COMMAND_AUTOSEND_ASYNC,
+    COMMAND_AUTOSEND_SYNC,
+    COMMAND_ENTER_BOOTLOADER,
+    COMMAND_GET_VERSION,
+    COMMAND_READ_SENSORS,
+    NUM_FINGERS,
+)
+from .sensor import RobotiqTactileSensor
+
+__all__ = [
+    "BAUD_RATE",
+    "COMMAND_AUTOSEND_ASYNC",
+    "COMMAND_AUTOSEND_SYNC",
+    "COMMAND_ENTER_BOOTLOADER",
+    "COMMAND_GET_VERSION",
+    "COMMAND_READ_SENSORS",
+    "NUM_FINGERS",
+    "RobotiqTactileError",
+    "RobotiqTactileSensor",
+    "SensorConnectionError",
+    "SensorNotFoundError",
+    "SensorReading",
+    "SensorTimeoutError",
+]

pyrobotiqtactile-0.1.0/src/pyrobotiqtactile/data.py

@@ -0,0 +1,54 @@
+"""numpy-friendly snapshot of a decoded sensor frame."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Sequence
+
+import numpy as np
+
+from .protocol import FingerFrame, STATIC_TACTILE_COLS, STATIC_TACTILE_ROWS
+
+
+@dataclass
+class SensorReading:
+    """A snapshot of all fingers' sensor values, as numpy arrays.
+
+    Array shapes are (num_fingers, ...): index by finger id first, e.g.
+    ``reading.pressure[0]`` is finger 0's 7x4 pressure grid.
+    """
+
+    pressure: np.ndarray  # (F, 7, 4) uint16 — static tactile grid
+    dynamic_tactile: np.ndarray  # (F,) int16
+    accelerometer: np.ndarray  # (F, 3) int16
+    gyroscope: np.ndarray  # (F, 3) int16
+    magnetometer: np.ndarray  # (F, 3) int16
+    temperature: np.ndarray  # (F,) int16
+    timestamp: np.ndarray  # (F,) uint64 — sensor-side timestamp per finger
+
+    @classmethod
+    def from_fingers(cls, fingers: Sequence[FingerFrame]) -> "SensorReading":
+        num_fingers = len(fingers)
+        pressure = np.array(
+            [f.static_tactile for f in fingers], dtype=np.uint16
+        ).reshape(num_fingers, STATIC_TACTILE_ROWS, STATIC_TACTILE_COLS)
+        return cls(
+            pressure=pressure,
+            dynamic_tactile=np.array([f.dynamic_tactile for f in fingers], dtype=np.int16),
+            accelerometer=np.array([f.accelerometer for f in fingers], dtype=np.int16),
+            gyroscope=np.array([f.gyroscope for f in fingers], dtype=np.int16),
+            magnetometer=np.array([f.magnetometer for f in fingers], dtype=np.int16),
+            temperature=np.array([f.temperature for f in fingers], dtype=np.int16),
+            timestamp=np.array([f.timestamp for f in fingers], dtype=np.uint64),
+        )
+
+    def copy(self) -> "SensorReading":
+        return SensorReading(
+            pressure=self.pressure.copy(),
+            dynamic_tactile=self.dynamic_tactile.copy(),
+            accelerometer=self.accelerometer.copy(),
+            gyroscope=self.gyroscope.copy(),
+            magnetometer=self.magnetometer.copy(),
+            temperature=self.temperature.copy(),
+            timestamp=self.timestamp.copy(),
+        )

pyrobotiqtactile-0.1.0/src/pyrobotiqtactile/exceptions.py

@@ -0,0 +1,14 @@
+class RobotiqTactileError(Exception):
+    """Base exception for all pyRobotiqTactile errors."""
+
+
+class SensorNotFoundError(RobotiqTactileError):
+    """Raised when no TSF-85 device could be located on any serial port."""
+
+
+class SensorConnectionError(RobotiqTactileError):
+    """Raised when the serial connection to the sensor fails or drops."""
+
+
+class SensorTimeoutError(RobotiqTactileError):
+    """Raised when a request to the sensor (e.g. firmware version) times out."""

pyrobotiqtactile-0.1.0/src/pyrobotiqtactile/protocol.py

@@ -0,0 +1,224 @@
+"""
+Low-level USB packet framing and parsing for the Robotiq TSF-85 tactile sensor.
+
+Wire format reverse-ported from Robotiq/tactile_sensors (communicator.cpp /
+sensor_quickstart/protocol.py): each packet is a 4-byte header (start byte,
+CRC8 placeholder, command, data length) followed by a sequence of
+[type+finger byte, big-endian payload] fields.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Tuple
+
+# Serial link parameters (fixed by the sensor's hardware/firmware)
+BAUD_RATE = 115200
+DATA_BITS = 8
+PARITY = "N"
+STOP_BITS = 1
+
+# USB VID:PID pairs used to auto-discover the sensor's serial port
+MASTER_HUB_VID_PID_PAIRS: Tuple[Tuple[int, int], ...] = (
+    (0x16D0, 0x14CC),  # Robotiq master hub
+    (0x04B4, 0xF232),  # Cypress USB UART (older units)
+)
+
+# Packet framing
+START_BYTE = 0x9A
+HEADER_SIZE = 4
+MAX_DATA_SIZE = 256
+
+# Commands
+COMMAND_READ_SENSORS = 0x61
+COMMAND_AUTOSEND_SYNC = 0x58
+COMMAND_AUTOSEND_ASYNC = 0x59
+COMMAND_ENTER_BOOTLOADER = 0xE2
+COMMAND_GET_VERSION = 0xE3
+
+# Sensor type identifiers (high nibble of the per-field type byte)
+SENSOR_STATIC_TACTILE = 0x10
+SENSOR_DYNAMIC_TACTILE = 0x20
+SENSOR_ACCELEROMETER = 0x30
+SENSOR_GYROSCOPE = 0x40
+SENSOR_MAGNETOMETER = 0x50
+SENSOR_TEMPERATURE = 0x60
+SENSOR_TIMESTAMP = 0x70
+
+# Fixed field sizes (element counts, not bytes)
+STATIC_TACTILE_ROWS = 7
+STATIC_TACTILE_COLS = 4
+STATIC_TACTILE_SIZE = STATIC_TACTILE_ROWS * STATIC_TACTILE_COLS  # 28
+DYNAMIC_TACTILE_SIZE = 1
+IMU_AXES = 3
+NUM_FINGERS = 2
+
+
+@dataclass
+class FingerFrame:
+    """Raw (non-numpy) values decoded for a single finger from one or more packets."""
+
+    updated: bool = False
+    static_tactile: List[int] = field(default_factory=lambda: [0] * STATIC_TACTILE_SIZE)
+    dynamic_tactile: int = 0
+    accelerometer: List[int] = field(default_factory=lambda: [0, 0, 0])
+    gyroscope: List[int] = field(default_factory=lambda: [0, 0, 0])
+    magnetometer: List[int] = field(default_factory=lambda: [0, 0, 0])
+    temperature: int = 0
+    timestamp: int = 0
+
+
+def _extract_uint16(data: bytes, count: int) -> Tuple[List[int], int]:
+    values = []
+    n = min(len(data), count * 2)
+    for i in range(0, n - (n % 2), 2):
+        values.append((data[i] << 8) | data[i + 1])
+    return values, n - (n % 2)
+
+
+def _extract_int16(data: bytes, count: int) -> Tuple[List[int], int]:
+    values, consumed = _extract_uint16(data, count)
+    return [v - 65536 if v >= 32768 else v for v in values], consumed
+
+
+def _extract_uint64(data: bytes, count: int) -> Tuple[List[int], int]:
+    values = []
+    n = min((len(data) // 8) * 8, count * 8)
+    for i in range(0, n, 8):
+        value = 0
+        for b in data[i : i + 8]:
+            value = (value << 8) | b
+        values.append(value)
+    return values, n
+
+
+class PacketParser:
+    """Buffers raw serial bytes into complete packets and decodes sensor fields."""
+
+    def __init__(self, num_fingers: int = NUM_FINGERS):
+        self._buffer = bytearray()
+        self.num_fingers = num_fingers
+        self.fingers: List[FingerFrame] = [FingerFrame() for _ in range(num_fingers)]
+        self.packet_count = 0
+
+    # -- outgoing commands ------------------------------------------------
+
+    @staticmethod
+    def build_command(command: int, data: bytes = b"") -> bytes:
+        if len(data) > MAX_DATA_SIZE:
+            raise ValueError(f"Data too large: {len(data)} > {MAX_DATA_SIZE}")
+        packet = bytearray([START_BYTE, 0x00, command, len(data)])
+        packet.extend(data)
+        return bytes(packet)
+
+    @classmethod
+    def build_get_version_command(cls) -> bytes:
+        return cls.build_command(COMMAND_GET_VERSION)
+
+    @classmethod
+    def build_autosend_command(cls, period_ms: int, synchronous: bool = True) -> bytes:
+        if not 0 <= period_ms <= 255:
+            raise ValueError(f"period_ms must be in [0, 255], got {period_ms}")
+        command = COMMAND_AUTOSEND_SYNC if synchronous else COMMAND_AUTOSEND_ASYNC
+        return cls.build_command(command, bytes([period_ms]))
+
+    # -- incoming bytes -----------------------------------------------------
+
+    def feed(self, data: bytes) -> List[bytes]:
+        """Feed raw serial bytes; returns any complete packets found (header+payload)."""
+        self._buffer.extend(data)
+        packets: List[bytes] = []
+
+        while len(self._buffer) >= HEADER_SIZE:
+            start = self._buffer.find(START_BYTE)
+            if start == -1:
+                self._buffer.clear()
+                break
+            if start > 0:
+                del self._buffer[:start]
+            if len(self._buffer) < HEADER_SIZE:
+                break
+
+            data_length = self._buffer[3]
+            packet_size = HEADER_SIZE + data_length
+            if len(self._buffer) < packet_size:
+                break
+
+            packets.append(bytes(self._buffer[:packet_size]))
+            del self._buffer[:packet_size]
+            self.packet_count += 1
+
+        return packets
+
+    def reset_buffer(self) -> None:
+        self._buffer.clear()
+
+    def parse_sensor_packet(self, packet: bytes) -> List[bool]:
+        """Decode a sensor-data packet, updating self.fingers in place.
+
+        Returns one bool per finger: True if that finger received a field in
+        this packet (mirrors upstream's `newDataAvailable` semantics).
+        """
+        if len(packet) < HEADER_SIZE:
+            return [False] * self.num_fingers
+
+        data = packet[HEADER_SIZE:]
+        idx = 0
+        n = len(data)
+
+        while idx < n:
+            sensor_byte = data[idx]
+            idx += 1
+            sensor_type = sensor_byte & 0xF0
+            finger_id = (sensor_byte >> 2) & 0x03
+            if finger_id >= self.num_fingers:
+                continue
+
+            finger = self.fingers[finger_id]
+            finger.updated = True
+            remaining = data[idx:]
+
+            if sensor_type == SENSOR_STATIC_TACTILE:
+                values, consumed = _extract_uint16(remaining, STATIC_TACTILE_SIZE)
+                if len(values) == STATIC_TACTILE_SIZE:
+                    finger.static_tactile = values
+                idx += consumed
+            elif sensor_type == SENSOR_DYNAMIC_TACTILE:
+                values, consumed = _extract_int16(remaining, DYNAMIC_TACTILE_SIZE)
+                if values:
+                    finger.dynamic_tactile = values[0]
+                idx += consumed
+            elif sensor_type == SENSOR_ACCELEROMETER:
+                values, consumed = _extract_int16(remaining, IMU_AXES)
+                if len(values) == IMU_AXES:
+                    finger.accelerometer = values
+                idx += consumed
+            elif sensor_type == SENSOR_GYROSCOPE:
+                values, consumed = _extract_int16(remaining, IMU_AXES)
+                if len(values) == IMU_AXES:
+                    finger.gyroscope = values
+                idx += consumed
+            elif sensor_type == SENSOR_MAGNETOMETER:
+                values, consumed = _extract_int16(remaining, IMU_AXES)
+                if len(values) == IMU_AXES:
+                    finger.magnetometer = values
+                idx += consumed
+            elif sensor_type == SENSOR_TEMPERATURE:
+                values, consumed = _extract_int16(remaining, 1)
+                if values:
+                    finger.temperature = values[0]
+                idx += consumed
+            elif sensor_type == SENSOR_TIMESTAMP:
+                values, consumed = _extract_uint64(remaining, 1)
+                if values:
+                    finger.timestamp = values[0]
+                idx += consumed
+            else:
+                # Unknown field type: stop, we can't know its size.
+                break
+
+        return [f.updated for f in self.fingers]
+
+    def clear_updated_flags(self) -> None:
+        for f in self.fingers:
+            f.updated = False

pyrobotiqtactile-0.1.0/src/pyrobotiqtactile/sensor.py

@@ -0,0 +1,204 @@
+"""High-level Python interface for the Robotiq TSF-85 tactile sensor."""
+
+from __future__ import annotations
+
+import time
+from typing import Optional, Tuple
+
+import numpy as np
+
+from .data import SensorReading
+from .exceptions import SensorConnectionError, SensorNotFoundError
+from .protocol import BAUD_RATE, PacketParser, NUM_FINGERS
+
+try:  # pragma: no cover - optional dependency
+    import serial  # type: ignore
+except ImportError:  # pragma: no cover - optional dependency
+    serial = None  # type: ignore
+
+
+__all__ = ["RobotiqTactileSensor"]
+
+
+class RobotiqTactileSensor:
+    """Convenience wrapper around the low-level TSF-85 packet protocol.
+
+    The class exposes the main operations requested for a Python package:
+    - connect/setup communication,
+    - configure the sensor's autosend loop,
+    - retrieve pressure as a NumPy array,
+    - retrieve accelerometer and gyroscope data,
+    - expose the full decoded frame as a :class:`SensorReading`.
+    """
+
+    def __init__(
+        self,
+        serial_port: Optional[object] = None,
+        port: Optional[str] = None,
+        baud_rate: int = BAUD_RATE,
+        timeout: float = 0.5,
+        num_fingers: int = NUM_FINGERS,
+    ) -> None:
+        self.serial_port = serial_port
+        self.port = port
+        self.baud_rate = baud_rate
+        self.timeout = timeout
+        self.parser = PacketParser(num_fingers=num_fingers)
+        self._latest_reading: Optional[SensorReading] = None
+        self._connected = False
+
+    def __enter__(self) -> "RobotiqTactileSensor":
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
+    def discover_ports(self) -> list[str]:
+        """Return a list of currently available serial ports."""
+        if serial is None:
+            return []
+        return [port.device for port in serial.tools.list_ports.comports()]
+
+    def connect(self, port: Optional[str] = None, baud_rate: Optional[int] = None) -> "RobotiqTactileSensor":
+        """Open the serial connection to the sensor.
+
+        When ``serial_port`` was passed in at construction time, it is reused.
+        Otherwise this will try to auto-detect a port and use :mod:`pyserial`.
+        """
+        if self.serial_port is not None:
+            if not getattr(self.serial_port, "is_open", True):
+                if hasattr(self.serial_port, "open"):
+                    self.serial_port.open()
+            self._connected = True
+            return self
+
+        if serial is None:
+            raise ImportError("pyserial is required to open a hardware connection")
+
+        if port is None:
+            port = self.port
+        if port is None:
+            candidates = self.discover_ports()
+            if not candidates:
+                raise SensorNotFoundError("No serial port discovered for the TSF-85 sensor")
+            port = candidates[0]
+
+        if baud_rate is None:
+            baud_rate = self.baud_rate
+
+        self.serial_port = serial.Serial(port=port, baudrate=baud_rate, timeout=self.timeout)
+        self._connected = True
+        return self
+
+    def setup_communication(self, port: Optional[str] = None, baud_rate: Optional[int] = None) -> "RobotiqTactileSensor":
+        """Alias for :meth:`connect` that matches the package's public API."""
+        return self.connect(port=port, baud_rate=baud_rate)
+
+    def close(self) -> None:
+        """Close the underlying serial connection if it exists."""
+        if self.serial_port is not None and hasattr(self.serial_port, "close"):
+            self.serial_port.close()
+        self._connected = False
+
+    def configure(self, update_period_ms: int = 50, synchronous: bool = True) -> "RobotiqTactileSensor":
+        """Configure the sensor to stream data using the upstream autosend command.
+
+        The Robotiq firmware exposes several sensor settings; this wrapper
+        currently exposes the most useful general-purpose configuration option:
+        the autosend update period.
+        """
+        self._ensure_connected()
+        command = PacketParser.build_autosend_command(update_period_ms, synchronous=synchronous)
+        self._write(command)
+        return self
+
+    def get_version(self) -> Optional[bytes]:
+        """Request the firmware version and return the raw response payload."""
+        self._ensure_connected()
+        self._write(PacketParser.build_get_version_command())
+        return self._read_response(timeout=self.timeout)
+
+    def read_frame(self, timeout: Optional[float] = None) -> SensorReading:
+        """Read one decoded sensor frame and return it as :class:`SensorReading`."""
+        self._ensure_connected()
+        deadline = None if timeout is None else time.monotonic() + timeout
+
+        while True:
+            data = self._read_bytes()
+            if not data:
+                if deadline is not None and time.monotonic() >= deadline:
+                    break
+                time.sleep(0.001)
+                continue
+
+            for packet in self.parser.feed(data):
+                self.parser.parse_sensor_packet(packet)
+
+            if self.parser.packet_count:
+                break
+
+            if deadline is not None and time.monotonic() >= deadline:
+                break
+
+        self.parser.clear_updated_flags()
+        reading = SensorReading.from_fingers(self.parser.fingers)
+        self._latest_reading = reading
+        return reading
+
+    def get_pressure(self) -> np.ndarray:
+        """Return the latest static pressure grid as a NumPy array."""
+        return self.read_frame().pressure
+
+    def get_accelerometer(self) -> np.ndarray:
+        """Return the latest accelerometer values as a NumPy array."""
+        return self.read_frame().accelerometer
+
+    def get_gyroscope(self) -> np.ndarray:
+        """Return the latest gyroscope values as a NumPy array."""
+        return self.read_frame().gyroscope
+
+    def get_imu(self) -> Tuple[np.ndarray, np.ndarray]:
+        """Return the latest accelerometer and gyroscope values as a tuple."""
+        reading = self.read_frame()
+        return reading.accelerometer, reading.gyroscope
+
+    def get_latest_reading(self) -> Optional[SensorReading]:
+        """Return the most recently decoded frame, if any."""
+        return self._latest_reading
+
+    def _ensure_connected(self) -> None:
+        if not self._connected:
+            self.connect()
+
+    def _write(self, payload: bytes) -> None:
+        if self.serial_port is None:
+            raise SensorConnectionError("The sensor is not connected")
+        if getattr(self.serial_port, "is_open", True) is False:
+            raise SensorConnectionError("The sensor serial connection is closed")
+
+        written = self.serial_port.write(payload)
+        if written != len(payload):
+            raise SensorConnectionError("Failed to write the full payload to the sensor")
+
+    def _read_bytes(self) -> bytes:
+        if self.serial_port is None:
+            raise SensorConnectionError("The sensor is not connected")
+
+        if getattr(self.serial_port, "is_open", True) is False:
+            raise SensorConnectionError("The sensor serial connection is closed")
+
+        if hasattr(self.serial_port, "in_waiting"):
+            if self.serial_port.in_waiting > 0:
+                return self.serial_port.read(self.serial_port.in_waiting)
+
+        return self.serial_port.read(1)
+
+    def _read_response(self, timeout: float) -> Optional[bytes]:
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            data = self._read_bytes()
+            if data:
+                return data
+            time.sleep(0.001)
+        return None

pyrobotiqtactile-0.1.0/src/pyrobotiqtactile.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: pyrobotiqtactile
+Version: 0.1.0
+Summary: Python support for the Robotiq TSF-85 tactile sensor
+Author: Benoit CASTETS
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/bcastets-robotiq/pyRobotiqTactile
+Project-URL: Repository, https://github.com/bcastets-robotiq/pyRobotiqTactile
+Project-URL: Issues, https://github.com/bcastets-robotiq/pyRobotiqTactile/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: numpy>=1.26
+Requires-Dist: pyserial>=3.5
+Dynamic: license-file
+
+# pyRobotiqTactile
+
+A Python package for communicating with the Robotiq TSF-85 tactile sensor.
+
+The project focuses on a public `RobotiqTactileSensor` class that provides:
+
+- serial communication setup
+- sensor configuration and autosend control
+- pressure-frame decoding as NumPy arrays
+- accelerometer and gyroscope access
+- a structured `SensorReading` container for the decoded data
+
+## Quick start
+
+```python
+from pyrobotiqtactile import RobotiqTactileSensor
+
+sensor = RobotiqTactileSensor()
+sensor.connect("COM3")
+sensor.configure(update_period_ms=50, synchronous=True)
+
+reading = sensor.read_frame()
+print(reading.pressure.shape)
+print(sensor.get_imu())
+```
+
+## Development
+
+```bash
+pip install -e .
+python -m unittest discover -s tests -v
+```

pyrobotiqtactile-0.1.0/src/pyrobotiqtactile.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENCE
+README.md
+pyproject.toml
+src/pyrobotiqtactile/__init__.py
+src/pyrobotiqtactile/data.py
+src/pyrobotiqtactile/exceptions.py
+src/pyrobotiqtactile/protocol.py
+src/pyrobotiqtactile/sensor.py
+src/pyrobotiqtactile.egg-info/PKG-INFO
+src/pyrobotiqtactile.egg-info/SOURCES.txt
+src/pyrobotiqtactile.egg-info/dependency_links.txt
+src/pyrobotiqtactile.egg-info/requires.txt
+src/pyrobotiqtactile.egg-info/top_level.txt
+tests/test_sensor.py

pyrobotiqtactile-0.1.0/src/pyrobotiqtactile.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyrobotiqtactile-0.1.0/src/pyrobotiqtactile.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=1.26
+pyserial>=3.5

pyrobotiqtactile-0.1.0/src/pyrobotiqtactile.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyrobotiqtactile

pyrobotiqtactile-0.1.0/tests/test_sensor.py

@@ -0,0 +1,75 @@
+import unittest
+
+from pyrobotiqtactile import RobotiqTactileSensor
+from pyrobotiqtactile.protocol import (
+    IMU_AXES,
+    SENSOR_ACCELEROMETER,
+    SENSOR_STATIC_TACTILE,
+    STATIC_TACTILE_COLS,
+    STATIC_TACTILE_ROWS,
+    STATIC_TACTILE_SIZE,
+)
+
+
+class FakeSerial:
+    def __init__(self, packets):
+        self._packets = list(packets)
+        self.writes = []
+        self._is_open = True
+
+    def write(self, data):
+        self.writes.append(data)
+        return len(data)
+
+    def read(self, size=1):
+        if self._packets:
+            return self._packets.pop(0)
+        return b""
+
+    @property
+    def in_waiting(self):
+        return len(self._packets)
+
+    @property
+    def is_open(self):
+        return self._is_open
+
+    def close(self):
+        self._is_open = False
+
+
+class RobotiqTactileSensorTests(unittest.TestCase):
+    def test_read_frame_returns_pressure_and_imu_arrays(self):
+        static_payload = bytearray()
+        for value in range(STATIC_TACTILE_SIZE):
+            static_payload.append(((value + 1) & 0xFF00) >> 8)
+            static_payload.append((value + 1) & 0xFF)
+
+        accel_payload = bytearray()
+        for value in (1, -2, 3):
+            accel_payload.append(((value & 0xFFFF) >> 8) & 0xFF)
+            accel_payload.append(value & 0xFF)
+
+        payload = bytes([SENSOR_STATIC_TACTILE | 0x00]) + bytes(static_payload) + bytes([SENSOR_ACCELEROMETER | 0x00]) + bytes(accel_payload)
+        packet = bytes([0x9A, 0x00, 0x61, len(payload)]) + payload
+
+        sensor = RobotiqTactileSensor(serial_port=FakeSerial([packet]))
+        reading = sensor.read_frame()
+
+        self.assertEqual(reading.pressure.shape, (2, STATIC_TACTILE_ROWS, STATIC_TACTILE_COLS))
+        self.assertEqual(reading.accelerometer.shape, (2, IMU_AXES))
+        self.assertEqual(reading.gyroscope.shape, (2, IMU_AXES))
+        self.assertEqual(reading.pressure[0, 0, 0], 1)
+        self.assertEqual(reading.accelerometer[0, 0], 1)
+        self.assertEqual(reading.accelerometer[0, 1], -2)
+
+    def test_configure_sends_autosend_command(self):
+        sensor = RobotiqTactileSensor(serial_port=FakeSerial([]))
+        sensor.configure(update_period_ms=50, synchronous=True)
+
+        self.assertTrue(sensor.serial_port.writes)
+        self.assertEqual(sensor.serial_port.writes[-1][2], 0x58)
+
+
+if __name__ == "__main__":
+    unittest.main()