Paxini PX-6AX GEN3 Setup Guide

The GEN3 family ships in three anatomical form factors. Choose the correct variant and mount point:

• Fingertip (DP) variants — 13 mm to 30 mm diameter. Designed for robotic fingertip caps. The 13 mm (S1813-Core/Elite) and 15 mm (S2015-Elite) fit compact dexterous hands like the LinkerBot O6. The 26 mm (M2826-Omega) and 30 mm (L3530-Omega) suit larger gripper fingertips.
• Finger Pad (IP/CP) variants — Flat pads (16×10 mm to 53×25 mm) for mounting on the dorsal or ventral surface of robot fingers. Secured with the provided adhesive backing or M2 screws depending on the variant.
• Palm (MC) variant — M2020-Elite (20×20 mm). Mounts in a recessed pocket on the robot palm plate. Four M2 screw holes at the corners.

For fingertip (DP) variants, align the sensor flat face flush with the fingertip contact surface. Route the ribbon cable along the finger body toward the wrist, securing with the included cable clips to prevent snagging during motion. Avoid sharp bends in the ribbon cable — maintain a bend radius of at least 5 mm.

Three communication board options are included in the product bundle. Select based on your deployment:

• 10-Channel SPI Hub — Connect up to 10 sensor tiles via the labeled channel ports on the hub PCB. Each port accepts the sensor ribbon connector. Power the hub via the included 5V USB cable. Use this board for full-hand tactile coverage.
• Single-Channel Serial Converter — For single-sensor prototyping. Connect the sensor ribbon to the board's single port. The board exposes a USB-serial interface to the host.
• High-Speed Integrated Board — Multi-channel SPI/I2C. Refer to the communication protocol document (v1.0.5) in the product bundle for channel wiring diagram.

Once wired, plug the communication board USB cable into your Windows x64 host. The board's power LED should illuminate immediately. The host will enumerate a new COM port (Windows) or /dev/ttyUSB* (Linux).

The PXSR software registers the USB driver, provides real-time heatmap visualisation, and handles data export. It is required for initial setup and calibration verification.

1. Locate pxsr-gen3-win-x64-1.0.7_Release.exe in the 【04】Software Installation Package folder of your product bundle.
2. Run the installer as Administrator. Accept the UAC prompt — the installer registers the WHQL-signed USB driver for the communication board.
3. After installation completes, PXSR will be available at C:\Program Files\PaXini\PXSR\PXSR.exe.
4. Reboot if Windows prompts for a driver restart.

Each GEN3 variant ships with a corresponding XLSX file that maps raw taxel indices to physical (x, y) coordinates in millimetres relative to the sensor centre. Loading the correct file is required for accurate heatmap rendering and contact centroid computation.

1. Open PXSR. With the communication board connected, click Connect. The status bar should show "Device Connected".
2. Go to File → Open Coordinate Map and select the XLSX file matching your sensor variant. Use the table in Specs to confirm the correct filename (e.g., PXSR-STDDP03B.xlsx for the 26 mm M2826-Omega fingertip).
3. Ensure the sensor is unloaded (no contact, no gravity load on the sensing face). Click Calibrate → Zero Baseline. PXSR captures 100 frames and stores the zero-load offset for all taxels and all 6 F/T axes.
4. Verify the 6-axis bars in the right panel all read near zero (within ±0.02 N / ±0.001 Nm) with the sensor unloaded.

With PXSR connected and calibrated, verify that all sensor channels are streaming correctly before integrating into your robot pipeline.

1. Apply gentle, uniform fingertip pressure to the sensor surface. The heatmap panel should show a localised high-pressure region at the contact point.
2. Slide your fingertip across the surface and observe the contact centroid tracking in the PXSR overlay.
3. Press the sensor laterally (shear force) — Fx and Fy bars should respond while Fz remains near zero.
4. For SPI hub deployments: verify each channel tab in PXSR shows live data. Channels with zero data indicate a loose ribbon connection — reseat and retry.

To export data for offline analysis, use Record → Start. PXSR saves a CSV with columns: timestamp (Unix ms), Fx, Fy, Fz, Tx, Ty, Tz, and the full flat taxel array. Each row is one sample frame.

For ROS2 integration, use pyserial to read frames directly from the communication board's USB-serial port and publish them on ROS2 topics. The skeleton below matches the JSONL telemetry format expected by the Fearless Platform WebSocket and can be adapted for ROS2 sensor_msgs publishing.

#!/usr/bin/env python3
# paxini_ros2_bridge.py — Paxini GEN3 → ROS2 topic publisher
# Requires: pyserial, rclpy, sensor_msgs

import serial, json, time
import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class PaxiniPublisher(Node):
    def __init__(self):
        super().__init__('paxini_gen3')
        self.pub = self.create_publisher(String, '/paxini/tactile', 10)
        # Configure port per PaXini GEN3 Communication Protocol v1.0.5
        self.ser = serial.Serial('/dev/ttyUSB0', baudrate=115200, timeout=0.1)
        self.create_timer(0.01, self.read_and_publish)  # 100 Hz

    def read_and_publish(self):
        raw = self.ser.read(64)  # frame size: see protocol doc
        if len(raw) == 0:
            return
        ft = self.parse_force_torque(raw)
        taxels = self.parse_taxel_array(raw)
        msg = String()
        msg.data = json.dumps({
            "type": "telemetry",
            "device": "paxini_gen3",
            "ft": ft,
            "taxels": taxels,
            "ts": int(time.time() * 1000)
        })
        self.pub.publish(msg)

    def parse_force_torque(self, raw):
        # Implement per PaXini GEN3 Communication Protocol v1.0.5
        return {"fx": 0.0, "fy": 0.0, "fz": 0.0,
                "tx": 0.0, "ty": 0.0, "tz": 0.0}

    def parse_taxel_array(self, raw):
        # Returns flat list of taxel pressure values
        return []

def main():
    rclpy.init()
    node = PaxiniPublisher()
    rclpy.spin(node)

if __name__ == '__main__':
    main()

To subscribe to the topic and log data to a JSONL file for offline training:

# Subscribe and log to file
ros2 topic echo /paxini/tactile --no-arr > tactile_session.jsonl