सॉफ्टवेयर सेटअप

एसडीके स्थापना

DK1 SDK को LeRobot प्लगइन के रूप में वितरित किया जाता है trlc-dk1 भण्डार. यह चार डिवाइस प्रकार पंजीकृत करता है: dk1_leader, dk1_follower, bi_dk1_leader, और bi_dk1_follower.

सबसे पहले LeRobot इंस्टॉल करें

pip install lerobot

DK1 प्लगइन को क्लोन करें और इंस्टॉल करें

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

स्थापना सत्यापित करें

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)
"

तुम्हें देखना चाहिए dk1_leader, dk1_follower, bi_dk1_leader, bi_dk1_follower मुद्रित. यदि नहीं, तो सुनिश्चित करें कि प्लगइन सही ढंग से स्थापित है uv pip show trlc-dk1.

किसी विशिष्ट कमिट से इंस्टॉल करें (पुनरुत्पादन के लिए)

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

लीडर/फ़ॉलोअर आर्म कॉन्फ़िगरेशन

DK1 की द्वि-मैनुअल प्रणाली लीडर आर्म (डायनामिक्सल XL330) को फॉलोअर आर्म (DM4340 + DM4310) से अलग करने के लिए पोर्ट असाइनमेंट पर निर्भर करती है। गलत पोर्ट असाइनमेंट सबसे आम सेटअप त्रुटि है।

यूएसबी सीरियल पोर्ट का पता लगाएं

LeRobot पोर्ट-डिटेक्शन उपयोगिता को एक समय में एक हाथ से जोड़कर चलाएँ:

# 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

द्वि-मैन्युअल रोबोट कॉन्फिगरेशन बनाएं

द्वि-मैनुअल जोड़ी के लिए एक YAML कॉन्फ़िगरेशन फ़ाइल बनाएं। LeRobot इसका उपयोग कमांड को सही आर्म तक रूट करने के लिए करता है:

# ~/.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

कॉन्फ़िगरेशन सत्यापित करें

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

यह दोनों भुजाओं को बिना हिलाए उनसे जुड़ जाता है। कनेक्शन त्रुटियों की जाँच करें. यदि कोई भी हाथ कनेक्ट करने में विफल रहता है, तो पोर्ट डिटेक्शन या स्वैप पोर्ट असाइनमेंट को फिर से चलाएँ।

ROS2 द्वि-मैन्युअल नियंत्रण

ROS2 Humble पूर्ण MoveIt2 द्वि-मैनुअल योजना समर्थन के साथ DK1 के लिए एक उच्च-स्तरीय नियंत्रण परत प्रदान करता है। यह केवल LeRobot डेटा संग्रह वर्कफ़्लो के लिए वैकल्पिक है।

ROS2 विनम्र और द्वि-मैन्युअल पैकेज स्थापित करें

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

क्लोन करें और DK1 ROS2 पैकेज बनाएं

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

द्वि-मैन्युअल मोड में लॉन्च करें

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

नकली हार्डवेयर के साथ परीक्षण करें (हथियार की आवश्यकता नहीं)

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

एक द्विमासिक प्रक्षेपवक्र भेजें

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}}]}'

लेरोबोट DK1 कॉन्फ़िगरेशन

DK1 प्लगइन के साथ LeRobot मूल रूप से द्वि-मैनुअल टेलीऑपरेशन रिकॉर्डिंग को संभालता है। bi_dk1_follower दोनों भुजाओं और सभी कैमरों से डिवाइस प्रकार के रिकॉर्ड एक साथ।

दोनों भुजाओं को कैलिब्रेट करें

# 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

द्वि-मैन्युअल टेलीऑपरेशन प्रारंभ करें

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

एक द्वि-मैन्युअल डेटासेट रिकॉर्ड करें

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

हगिंगफेस हब पर पुश करें

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

द्वि-मैन्युअल नियंत्रण के लिए पायथन एपीआई

DK1 पायथन एपीआई सीरियल के माध्यम से दोनों भुजाओं तक सीधी पहुंच प्रदान करता है। बुनियादी नियंत्रण और डेटा लॉगिंग के लिए कोई ROS2 आवश्यक नहीं है।

दोनों हाथ जोड़ लें

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()

दोनों भुजाओं की संयुक्त अवस्थाएँ पढ़ें

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()

लीडर-फ़ॉलोअर लूप को मैन्युअल रूप से चलाएँ

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()

सिमुलेशन समर्थन

DK1 एक कैलिब्रेटेड मॉडल के साथ MuJoCo द्वि-मैनुअल सिमुलेशन का समर्थन करता है जो वास्तविक-हार्डवेयर किनेमेटिक्स को प्रतिबिंबित करता है। हार्डवेयर पर तैनात करने से पहले नीतियों को सिमुलेशन में प्रशिक्षित करें।

म्यूजोको द्वि-मैन्युअल सिमुलेशन

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

मुजोको पर्यावरण के विरुद्ध एक नीति तैयार करें

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

शीर्ष 3 द्वि-मैनुअल-विशिष्ट मुद्दे

# 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

अभी भी अटके हुए हैं? पर पूछें डीके1 फोरम या मौजूदा की जाँच करें गिटहब मुद्दे.