Software-Setup

SDK-Installation

Das DK1 SDK wird als LeRobot-Plugin über verteilt trlc-dk1 Repository. Es registriert vier Gerätetypen: dk1_leader, dk1_follower, bi_dk1_leader, Und bi_dk1_follower.

Installieren Sie zuerst LeRobot

pip install lerobot

Klonen und installieren Sie das DK1-Plugin

git clone https://github.com/TRLC-AI/trlc-dk1.git
cd trlc-dk1
uv pip install -e .

Überprüfen Sie die Installation

python3 -c "from lerobot.common.robots import make_robot; print('DK1 plugin OK')"

# Check that DK1 device types are registered
python3 -c "
from lerobot.common.robots.factory import get_robot_types
types = get_robot_types()
for t in types:
    if 'dk1' in t:
        print(t)
"

Das solltest du sehen dk1_leader, dk1_follower, bi_dk1_leader, bi_dk1_follower gedruckt. Wenn nicht, stellen Sie sicher, dass das Plugin korrekt installiert ist uv pip show trlc-dk1.

Von einem bestimmten Commit aus installieren (zur Reproduzierbarkeit)

cd trlc-dk1
git checkout v0.3.0
uv pip install -e .

Konfiguration des Führungs-/Folgearms

Das bimanuelle System des DK1 basiert auf der Anschlusszuweisung, um den Führungsarm (Dynamixel XL330) vom Folgearm (DM4340 + DM4310) zu unterscheiden. Falsche Portzuweisungen sind der häufigste Setup-Fehler.

Erkennen Sie serielle USB-Anschlüsse

Führen Sie das Dienstprogramm zur Porterkennung von LeRobot aus, wobei jeweils nur ein Arm angeschlossen ist:

# Connect ONLY the leader arm (Dynamixel XL330)
python -m lerobot.scripts.find_motors_bus_port
# Note the reported port, e.g. /dev/ttyACM0

# Disconnect leader, connect ONLY the follower arm (DM series)
python -m lerobot.scripts.find_motors_bus_port
# Note the reported port, e.g. /dev/ttyACM1

Erstellen Sie die bimanuelle Roboterkonfiguration

Erstellen Sie eine YAML-Konfigurationsdatei für das bimanuelle Paar. LeRobot nutzt dies, um Befehle an den richtigen Arm weiterzuleiten:

# ~/.lerobot/robots/dk1_bimanual.yaml
robot_type: bi_dk1_follower
leader_arms:
  left:
    port: /dev/ttyACM0
    motors: [shoulder_pan, shoulder_lift, elbow_flex, wrist_flex, wrist_roll, gripper_left, gripper_right]
follower_arms:
  left:
    port: /dev/ttyACM1
    motors: [shoulder_pan, shoulder_lift, elbow_flex, wrist_flex, wrist_roll, gripper_left, gripper_right]
cameras:
  wrist_left:
    type: opencv
    index: 0
    fps: 30
    width: 640
    height: 480
  overhead:
    type: opencv
    index: 2
    fps: 30
    width: 640
    height: 480

Überprüfen Sie die Konfiguration

python -m lerobot.scripts.control_robot \
  --robot.type=bi_dk1_follower \
  --robot.config=~/.lerobot/robots/dk1_bimanual.yaml \
  --control.type=none

Dadurch werden beide Arme verbunden, ohne sie zu bewegen. Überprüfen Sie, ob Verbindungsfehler vorliegen. Wenn einer der Arme keine Verbindung herstellen kann, führen Sie die Porterkennung erneut durch oder tauschen Sie die Portzuweisungen aus.

Bimanuelle Steuerung ROS2

ROS2 Humble bietet eine übergeordnete Steuerungsebene für den DK1 mit vollständiger Unterstützung für die bimanuelle Planung von MoveIt2. Dies ist optional für reine LeRobot-Datenerfassungsworkflows.

Installieren Sie ROS2 Humble und bimanuelle Pakete

sudo apt update && sudo apt install ros-humble-desktop \
  ros-humble-ros2-control ros-humble-ros2-controllers \
  ros-humble-moveit ros-humble-joint-state-publisher-gui -y

Klonen und erstellen Sie das DK1 ROS2-Paket

mkdir -p ~/dk1_ws/src && cd ~/dk1_ws/src
git clone https://github.com/TRLC-AI/trlc-dk1-ros2.git
cd ~/dk1_ws
source /opt/ros/humble/setup.bash
colcon build --symlink-install

Starten Sie im bimanuellen Modus

source ~/dk1_ws/install/setup.bash

# Launch both arms (use_fake_hardware for testing without hardware)
ros2 launch trlc_dk1_ros2 dk1_bimanual.launch.py \
  use_fake_hardware:=false \
  leader_port:=/dev/ttyACM0 \
  follower_port:=/dev/ttyACM1

Test mit gefälschter Hardware (keine Arme erforderlich)

ros2 launch trlc_dk1_ros2 dk1_bimanual.launch.py \
  use_fake_hardware:=true

Senden Sie eine bimanuelle Flugbahn

ros2 topic pub /follower_left/joint_trajectory_controller/joint_trajectory \
  trajectory_msgs/msg/JointTrajectory \
  '{joint_names: ["shoulder_pan"], points: [{positions: [0.3], time_from_start: {sec: 2}}]}'

LeRobot DK1-Konfiguration

LeRobot mit dem DK1-Plugin übernimmt die bimanuelle Teleoperationsaufzeichnung nativ. Der bi_dk1_follower Gerätetyp zeichnet von beiden Armen und allen Kameras gleichzeitig auf.

Kalibrieren Sie beide Arme

# Calibrate the leader arm
python -m lerobot.scripts.control_robot \
  --robot.type=dk1_leader \
  --robot.port=/dev/ttyACM0 \
  --control.type=calibrate

# Calibrate the follower arm
python -m lerobot.scripts.control_robot \
  --robot.type=dk1_follower \
  --robot.port=/dev/ttyACM1 \
  --control.type=calibrate

Bimanuelle Teleoperation starten

python -m lerobot.scripts.control_robot \
  --robot.type=bi_dk1_follower \
  --robot.config=~/.lerobot/robots/dk1_bimanual.yaml \
  --control.type=teleoperate

Zeichnen Sie einen bimanuellen Datensatz auf

python -m lerobot.scripts.control_robot \
  --robot.type=bi_dk1_follower \
  --robot.config=~/.lerobot/robots/dk1_bimanual.yaml \
  --control.type=record \
  --control.fps=30 \
  --control.repo_id=your-username/dk1-bimanual-pick-place-v1 \
  --control.num_episodes=50 \
  --control.single_task="Bimanual: pick up the block with left arm, transfer to right arm" \
  --control.warmup_time_s=5 \
  --control.reset_time_s=10

Drücken Sie auf HuggingFace Hub

huggingface-cli login
python -m lerobot.scripts.push_dataset_to_hub \
  --repo_id=your-username/dk1-bimanual-pick-place-v1

Python-API für bimanuelle Steuerung

Die DK1-Python-API bietet direkten seriellen Zugriff auf beide Arme. Für die grundlegende Steuerung und Datenprotokollierung ist kein ROS2 erforderlich.

Verbinden Sie beide Arme

from trlc_dk1 import DK1Leader, DK1Follower, BimanualDK1

# Connect individually
leader = DK1Leader(port="/dev/ttyACM0")
follower = DK1Follower(port="/dev/ttyACM1")
leader.connect()
follower.connect()

# Or use the bimanual controller (recommended)
robot = BimanualDK1(
    leader_port="/dev/ttyACM0",
    follower_port="/dev/ttyACM1"
)
robot.connect()

Lesen Sie die Gelenkzustände beider Arme ab

import time
from trlc_dk1 import BimanualDK1

robot = BimanualDK1(leader_port="/dev/ttyACM0", follower_port="/dev/ttyACM1")
robot.connect()

for _ in range(100):
    leader_state = robot.get_leader_state()
    follower_state = robot.get_follower_state()
    print(f"Leader:   {leader_state.positions}")
    print(f"Follower: {follower_state.positions}")
    time.sleep(0.033)  # 30 Hz

robot.disconnect()

Führen Sie die Leader-Follower-Schleife manuell aus

from trlc_dk1 import BimanualDK1
import time

robot = BimanualDK1(leader_port="/dev/ttyACM0", follower_port="/dev/ttyACM1")
robot.connect()
robot.enable_follower()

try:
    while True:
        leader_state = robot.get_leader_state()
        # Apply leader positions to follower (scaled if needed)
        robot.set_follower_positions(leader_state.positions)
        time.sleep(0.01)  # 100 Hz control loop
finally:
    robot.disable_follower()
    robot.disconnect()

Simulationsunterstützung

Der DK1 unterstützt die bimanuelle MuJoCo-Simulation mit einem kalibrierten Modell, das die Kinematik echter Hardware widerspiegelt. Trainieren Sie Richtlinien in der Simulation, bevor Sie sie auf der Hardware bereitstellen.

Bimanuelle MuJoCo-Simulation

pip install mujoco
git clone https://github.com/TRLC-AI/trlc-dk1-mujoco.git
cd trlc-dk1-mujoco

# Run the bimanual simulation with leader/follower
python examples/bimanual_sim.py

# Run with keyboard teleop
python examples/bimanual_sim.py --teleop keyboard

Trainieren Sie eine Richtlinie gegen die MuJoCo-Umgebung

python -m lerobot.scripts.train \
  --policy.type=act \
  --env.type=dk1_bimanual_sim \
  --policy.chunk_size=100 \
  --training.num_epochs=5000 \
  --output_dir=outputs/dk1-act-sim

Die drei häufigsten bimanuellen Probleme

# 1. Unplug both arms
# 2. Connect ONLY the leader arm (XL330 servos)
python -m lerobot.scripts.find_motors_bus_port
# Note: leader_port = /dev/ttyACM?

# 3. Disconnect leader, connect ONLY the follower arm (DM servos)
python -m lerobot.scripts.find_motors_bus_port
# Note: follower_port = /dev/ttyACM?

# 4. Update your YAML config with the correct ports
# 5. Create udev rules to make assignments permanent

# Reduce follower PD gains in the DK1 config
# Edit trlc-dk1/configs/follower_gains.yaml:
joint_gains:
  default:
    kp: 30   # reduce from default 50
    kd: 0.5  # reduce from default 1.0
  wrist:
    kp: 15   # wrist joints need lower gains
    kd: 0.3

# Apply and restart teleoperation
python -m lerobot.scripts.control_robot \
  --robot.type=bi_dk1_follower \
  --control.type=teleoperate

# 1. Check which USB bus each device is on
lsusb -t

# 2. Spread devices across separate USB bus controllers
#    - Cameras: use a powered USB hub on one controller
#    - Arms: connect directly on a different controller

# 3. Reduce camera resolution if bandwidth is still tight
# In dk1_bimanual.yaml:
cameras:
  wrist_left:
    width: 480
    height: 320   # lower resolution reduces USB bandwidth

# 4. Verify timestamp skew is acceptable
python -m trlc_dk1.tools.check_sync \
  --config ~/.lerobot/robots/dk1_bimanual.yaml
# Target: < 5ms skew between all streams

Stecken Sie immer noch fest? Fragen Sie auf der DK1-Forum oder vorhandene prüfen GitHub-Probleme.