Unit 3: Sync Tactile with Robot Arm — Paxini Gen3 Path

Step 1 — Physical Mounting

Mounting the Sensor on Your Gripper

Use the mounting adapter that shipped with your sensor. For flat-face grippers (Robotiq 2F, custom 3D-printed): apply the adhesive pad to the gripper fingertip, press the sensor firmly for 30 seconds, then secure with M2 screws through the corner holes. Allow adhesive to fully cure (30 minutes minimum) before applying any load.

For curved fingertips (Allegro, Orca Hand fingerpads): use the conformable adhesive mount (included). The sensor body is flexible enough to conform to curves up to 20 mm radius.

Do not apply adhesive to the sensing surface The sensing surface is the flat face with the fine grid pattern. Mount from the back side or edge tabs only. Any adhesive on the sensing surface will permanently reduce sensitivity.

Step 2 — Cable Routing

Routing USB Cables Along the Arm

Route the sensor USB-C cable along the arm link toward the wrist, then up the forearm to a USB hub mounted at the last link before the end-effector. Use spiral cable wrap or adhesive cable clips (not included). Key rules:

Leave 15 cm of slack at each joint that rotates — the cable must not be taut at any joint angle in the arm's workspace.
Route cables parallel to the arm links, not diagonally — diagonal routing creates torque on joints.
Secure cable clips every 10–15 cm to prevent the cable from catching on obstacles during arm motion.
The USB hub at the wrist should be rigidly mounted (not floating) to prevent connector stress during rapid movements.

USB hub placement A powered USB 3.0 hub at the robot wrist is the cleanest solution for multi-sensor setups. The USB cable from hub to host PC runs along the arm cable bundle. For single-sensor setups, the sensor cable can run directly to the host PC if the arm's workspace is constrained.

Step 3 — Synchronized Recording

Synchronized Recording with MultiSourceSync

The MultiSourceSync class accepts callbacks for each data source and yields time-aligned tuples. Implement the arm interface by wrapping your arm SDK's joint state reader:

import paxini
from paxini.sync import MultiSourceSync
import time

# Minimal arm interface — adapt to your arm SDK
class ArmInterface:
    def get_joint_state(self):
        # Returns dict with 'positions', 'velocities', 'timestamp_ns'
        return your_arm_sdk.read_joint_state()

arm = ArmInterface()
sensor = paxini.Sensor()
sensor.start()
sensor.calibrate()

sync = MultiSourceSync(
    sensor=sensor,
    arm=arm,
    max_dt_ms=5.0           # reject frame pairs with >5ms gap
)

print("Synchronized stream — move your arm and grasp something:")
for arm_state, tactile in sync.stream():
    print(
        f"q={arm_state['positions'][:3]}  "
        f"F={tactile.total_force_n:.2f}N  "
        f"contact={tactile.in_contact}"
    )

Step 4 — Verify Timestamp Alignment

Verifying Sync Quality

Before recording your real dataset, verify that timestamps are aligned within your tolerance. The SDK provides a sync diagnostics function:

# Record a 10-second test episode and check sync quality
from paxini.sync import MultiSourceRecorder, check_sync_quality

recorder = MultiSourceRecorder(
    arm=arm,
    sensor=sensor,
    output_dir="./test_recordings/",
    episode_prefix="sync_test"
)

recorder.start_episode()
time.sleep(10)               # 10 seconds — move arm and grasp during this
recorder.end_episode()

# Check the saved episode
report = check_sync_quality("./test_recordings/sync_test_000.hdf5")
print(report.summary())
# Look for: mean_dt_ms < 3.0, max_dt_ms < 10.0, dropped_frames < 1%

If max_dt_ms is above 10 ms, your arm SDK is returning stale joint state. Check that the arm SDK polling rate matches the sensor rate. For ROS2-based arms, ensure the joint state publisher is not being throttled by message queue depth.

Typical sync quality numbers mean_dt_ms: 0.5–2.0 ms. max_dt_ms: 3–8 ms. Dropped frames: 0–0.5%. These numbers indicate reliable synchronization for robot learning data collection.

Unit 3 Complete When...

The Gen3 sensor is physically mounted on your gripper with all cables secured and no slack under tension. python -m paxini.discover still finds the sensor with the arm at various configurations. A 10-second synchronized recording completes without errors, and check_sync_quality() reports mean_dt_ms below 3.0 ms.