LinkerBot O6 Dexterous Hand — SDK Setup & Teleop Guide

1. Overview

The LinkerBot O6 (also marketed as Linker or Juqiao) is a dexterous robotic hand system designed for contact-rich manipulation research and teleoperation data collection. It includes a glove controller that maps the operator's hand movements in real time to the robotic fingers, enabling high-fidelity demonstration capture for imitation learning pipelines.

The O6 captures 16 tactile pressure regions per hand and 5-finger bend angle readings at high frequency, making it suitable for tactile-aware grasping research, compliant manipulation demonstrations, and contact-rich skill learning datasets.

2. Quick Start

Three commands from unboxing to a live browser teleop session:

1. Plug in the O6 hand system via USB. Confirm the port appears: ls /dev/ttyUSB* on Linux or Device Manager on Windows.
2. Install the SDK and connect.

   pip install roboticscenter
   rc connect

   The CLI auto-detects the O6 hand, opens a session on the platform, and prints a browser URL.
3. Open the session URL in your browser. The teleop panel shows live finger positions, gesture presets, and the tactile heatmap. No additional configuration required.

3. SDK Setup

Install

The roboticscenter package is available on PyPI and supports Python 3.9+:

pip install roboticscenter

Auto-detect

With no arguments, rc connect scans all serial ports for a Juqiao AA 55 03 99 frame and auto-selects the O6 if found. Use rc devices first to confirm the device is visible:

rc devices                    # scan all ports, print detected devices
rc connect                    # auto-detect LinkerBot O6 and start session

Manual port

If multiple serial devices are connected or auto-detect selects the wrong port, pass the port explicitly:

rc connect --port /dev/ttyUSB0        # Linux
rc connect --port COM3                # Windows

Mock mode

Simulate the full O6 data stream without hardware. Useful for CI pipelines, UI development, and testing data collection logic:

rc connect --mock             # synthetic data, full browser panel

Python SDK

Use LinkerO6 directly in Python for custom collection scripts or integration into existing pipelines:

from roboticscenter import LinkerO6

device = LinkerO6.connect()
print(f"Connected on: {device.port}")
print(f"Session: {device.session_url}")

for frame in device.stream():
    left = frame.data.get('left', {})
    print(f"Index: {left.get('index', 0):.3f}")

4. Protocol

The O6 communicates over USB Serial using the Juqiao framing protocol at 921600 baud. All packets begin with the 4-byte header AA 55 03 99 followed by a length byte, payload, and checksum.

Payload layout within a full-hand frame:

• Finger bend angles: 5 values per hand (thumb through pinky), each a uint8 mapped to 0–180°.
• Tactile pressure regions: 16 values per hand, each a uint8 representing relative pressure (0 = no contact).
• Timestamp: device-side microsecond counter for frame alignment.

The SDK handles all framing, checksum validation, and packet reassembly internally. You never need to parse raw bytes unless implementing a custom agent outside the SDK.

5. Teleop

After running rc connect, the CLI opens the session URL in your default browser automatically (pass --no-browser to suppress). The teleop panel includes:

• Finger position display: Real-time bend angle bars for all 10 fingers (5 per hand), updated at the sensor frame rate.
• Gesture presets: One-click gestures — Rock, Paper, Scissors, Pinch, Spread — sent as motor position targets to the hand.
• Real-time tactile heatmap: 16-region pressure overlay rendered on a hand outline. Color intensity maps to contact pressure.
• Hand selector: Toggle between left hand, right hand, or both simultaneously.
• Session recorder: Start/stop episode recording directly from the panel. Each episode is timestamped and uploaded to the platform on stop.

6. Data Collection

Every frame streamed from the O6 during an active recording session is captured and structured for downstream training use. The SDK records the following per frame:

Episodes are stored as JSONL files (one frame per line) with a companion manifest containing task metadata, episode boundaries, operator notes, and hardware serial. Data is upload-ready for the Fearless Platform episode browser immediately after recording stops.

7. Platform Integration

The SDK integrates with the Fearless Platform automatically when rc connect is run. The connection sequence is:

1. SDK calls POST /api/teleop/sessions/create-sdk with device_type: "linker_o6".
2. Platform returns a session ID, WebSocket relay URL, and browser deep link.
3. SDK opens the WebSocket and begins forwarding sensor frames in real time.
4. Browser panel connects to the same session via the deep link.

The session URL printed by the CLI has the form:

https://platform.roboticscenter.ai/session/RC-XXXX-XXXX

Share this URL with teammates or embed it in your data collection tooling. Sessions expire after inactivity but all recorded episodes remain accessible in the episode browser.

Episode browser

After recording, navigate to Episodes in the platform sidebar. Each recorded episode is listed with timestamp, duration, hand(s) used, and a tactile heatmap preview. Episodes can be downloaded as JSONL, viewed in the built-in playback timeline, or fed directly into a training pipeline via the platform API.

Data upload (manual)

If you collected data offline or with a custom script, upload JSONL episode files via the platform Upload page or the CLI:

rc session RC-XXXX-XXXX          # show session info and upload URL

8. Debugging