TRLC-DK1 Bimanual Dev Kit — LeRobot Setup, Teleop & Data Recording

1. Overview

The TRLC-DK1 (The Robot Learning Company Dev Kit 1) is an open-source bimanual robot arm kit designed for AI-native robotics research and imitation learning data collection. It ships as a first-class LeRobot plugin — install once and every LeRobot CLI command (lerobot-teleoperate, lerobot-record, lerobot-find-port) works out of the box with DK1 hardware.

The kit consists of two arm types that work together: a leader arm (the teleoperation controller) and a follower arm (the robot that executes motion). Both arms communicate via USB serial. In a bimanual setup, you use two leader arms and two follower arms connected to four serial ports simultaneously.

Key differentiators: open-source hardware and software, STEP CAD files, LeRobot plugin conventions (no manual registration), community-contributed URDF, and support for multi-camera bimanual recording with wrist and head cameras in a single lerobot-record command.

2. Hardware Specs

3. Quick Start

From unboxing to first motion in four steps:

1. Clone the repo and install.

   git clone https://github.com/robot-learning-co/trlc-dk1.git
   cd trlc-dk1
   uv venv
   uv pip install -e .

   This registers the dk1_follower, dk1_leader, bi_dk1_follower, and bi_dk1_leader device types with your LeRobot installation automatically.
2. Connect the arm via USB and find the port.

   # Use the LeRobot port finder (recommended)
   uv run lerobot-find-port
   
   # Or list manually
   ls /dev/ttyACM*          # Linux
   ls /dev/tty.usbmodem*    # macOS

   Note the port for the follower (e.g., /dev/ttyACM0) and leader (e.g., /dev/ttyACM1).
3. Run the follower motion demo (no leader required).

   uv run python examples/follower_demo_move.py --port /dev/ttyACM0
   
   # macOS — use your actual port:
   uv run python examples/follower_demo_move.py --port /dev/tty.usbmodem5A460819651
   
   # Optional flags:
   # --duration 20    run for 20 seconds
   # --scale 0.1      reduce motion amplitude (safer for first run)

   Press Ctrl+C to stop at any time.
4. Verify follower communication (read-only, no motion).

   uv run python examples/follower_read_position.py

   Edit port="/dev/ttyACM1" in the script to match your follower port. Continuous joint position output confirms the connection is healthy.

4. SDK Integration

The TRLC-DK1 follows LeRobot's plugin conventions. After uv pip install -e ., the DK1 device classes are importable directly from Python:

from lerobot_robot_trlc_dk1.follower import DK1Follower
from lerobot_robot_trlc_dk1.leader import DK1Leader

# Create a follower robot instance
robot = DK1Follower(port="/dev/ttyACM0", joint_velocity_scaling=0.2)
robot.connect()

# Read joint positions
state = robot.get_state()
print(state)  # dict of joint names → angles

robot.disconnect()

For bimanual use, the bi_dk1_follower type handles both arms under a single LeRobot robot object:

# Bimanual follower via CLI (no Python needed)
uv run lerobot-teleoperate \
    --robot.type=bi_dk1_follower \
    --robot.right_arm_port=/dev/ttyACM0 \
    --robot.left_arm_port=/dev/ttyACM1 \
    --teleop.type=bi_dk1_leader \
    --teleop.right_arm_port=/dev/ttyACM2 \
    --teleop.left_arm_port=/dev/ttyACM3

You can also install via the RoboticsCenter SDK which wraps DK1 under the unified platform session model:

pip install roboticscenter
rc connect --device dk1_follower --port /dev/ttyACM0

5. Single-Arm Teleoperation

Single-arm teleop connects one leader arm to one follower arm. The follower tracks the leader in real time:

# Option A: LeRobot CLI with cameras
uv run lerobot-teleoperate \
    --robot.type=dk1_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.joint_velocity_scaling=0.2 \
    --teleop.type=dk1_leader \
    --teleop.port=/dev/ttyACM1 \
    --robot.cameras="{
        context: {type: opencv, index_or_path: 0, width: 1280, height: 720, fps: 60, fourcc: MJPG},
        wrist:   {type: opencv, index_or_path: 1, width: 1280, height: 720, fps: 60, rotation: 180, fourcc: MJPG}
    }" \
    --display_data=true

# Option B: Minimal Python script (edit ports in examples/teleop.py first)
uv run python examples/teleop.py

6. Bimanual Recording

The full bimanual recording command connects two leader arms to two follower arms and records synchronized episodes with up to three camera streams:

lerobot-record \
    --robot.type=bi_dk1_follower \
    --robot.right_arm_port=/dev/ttyACM0 \
    --robot.left_arm_port=/dev/ttyACM1 \
    --robot.joint_velocity_scaling=1.0 \
    --teleop.type=bi_dk1_leader \
    --teleop.right_arm_port=/dev/ttyACM2 \
    --teleop.left_arm_port=/dev/ttyACM3 \
    --robot.cameras="{
        head:        {type: opencv, index_or_path: /dev/video0, width: 960, height: 540, fps: 60, fourcc: MJPG},
        right_wrist: {type: opencv, index_or_path: /dev/video2, width: 960, height: 540, fps: 60, rotation: 180, fourcc: MJPG},
        left_wrist:  {type: opencv, index_or_path: /dev/video4, width: 960, height: 540, fps: 60, rotation: 180, fourcc: MJPG}
    }" \
    --dataset.repo_id=$USER/my_bimanual_dataset \
    --dataset.push_to_hub=false \
    --dataset.num_episodes=10 \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=20 \
    --dataset.single_task="Bimanual pick and place task."

Each episode is saved as a LeRobot-format HDF5 file containing:

• Joint angles for both arms (right + left, 7 DOF + gripper each)
• Gripper state (open/close)
• Synchronized camera frames from all configured cameras
• Episode metadata: task description, timestamps, and arm port assignments

To discover camera indices before recording:

uv run lerobot-find-cameras

7. ROS2 Integration

A community-contributed URDF for the DK1 follower arm is maintained at andreaskoepf/trlc-dk1-follower-urdf. It provides complete kinematic and visual meshes suitable for:

• MoveIt2 motion planning with the follower arm
• RViz visualization during teleop sessions
• Simulation in Isaac Sim or MuJoCo
• State publishing via joint_state_publisher

# Clone the community URDF
git clone https://github.com/andreaskoepf/trlc-dk1-follower-urdf.git

# Build in your ROS2 workspace
cp -r trlc-dk1-follower-urdf <ros2_ws>/src/
cd <ros2_ws>
colcon build --packages-select trlc_dk1_follower_urdf
source install/setup.bash

# Launch RViz with the follower model
ros2 launch trlc_dk1_follower_urdf display.launch.py

8. Troubleshooting

9. Related Hardware

• OpenArm 101 — 7 DOF, SocketCAN, MoveIt2 & LeRobot integration, ROS2-native
• LinkerBot O6 Dexterous Hand — USB serial, 921600 baud, tactile sensing, glove teleop
• VLAI L1 Dual-Arm Mobile Robot — mobile bimanual platform, ROS2 bridge, VLA training
• Wuji Dexterous Hand — complementary end-effector for DK1 follower arm