Connecting to sources…

How to build TRLC-DK1 (The Robot Learning Company Developer Kit 1): the whole process

121 steps to build TRLC-DK1 (The Robot Learning Company Developer Kit 1), from buying parts, printing and assembly to software, calibration and training, with the bill o…

No official price found: the shop link robot-learning.co showed no product or price on 2026‑11‑01, and neither the repo nor the docs give a BOM cost; the docs price only the light box, at about €600 in off-the-shelf parts

Bill of materials · Components

PartQty
Dynamixel XL330-M077-T · https://en.robotis.com/shop_en/7
Waveshare Serial Bus Servo Driver Board · https://www.amazon.com/1
3D-printed Links using PLA(-CF) · https://store.bambulab.com/
5V DC Power Supply (2 Pole or 5.5x2.1 Power Jack) · https://www.amazon.com/1
M2x4 Inserts · https://www.amazon.com/4
M2x5 Screws (e.g. ISO 4762) · https://www.amazon.com/4

Bill of materials · DK1-X Desktop Setup

PartQty
HFS8-4080-700 · Aluminium extrusion: follower mount · MiSUMi1
HFS6-3030-400 · Aluminium extrusion: context camera mount · MiSUMi1
SHNTP8-5 · M5 T-slot nuts · MiSUMi12
ISO 4762 M5x12 · Screws: follower arms · MiSUMi / Amazon8
ISO 4762 M5x16 · Screws: 3D-printed context cam mount · MiSUMi / Amazon4
ISO 7093 M5 · Washers: 3D-printed plates · MiSUMi / Amazon4
e.g. K&M 260/1 · Microphone Stand (3/8” mount) · e.g. Thomann2

Buy parts

  • Choose a Supported Feetech or Dynamixel Servo

    Supported Feetech models are sts3215, sts3250, sm8512bl, and scs0009. Supported Dynamixel models are xl330-m077, xl330-m288, xc330-t181, xc330-t288, xl430-w250, xl430-w250-2, xc430-w150, xm430-w350, xm540-w270, and xh540-w150.

Print and make

  • Download Follower CAD

    Download the TRLC-DK1 v0.3.0 Follower STEP model.

  • Get Leader CAD

    Access the TRLC-DK1 v0.2.0 Leader CAD through the A360 link.

Assemble

  • Expose a Robot Communication Interface

    Make sure the robot exposes a communication interface such as serial, CAN, or TCP.

  • Initialize the Motor Bus

    In MyCoolRobot.__init__, initialize the parent Robot, retain the supplied configuration, and create a SerialMotorsBus using the configured port. Supply the robot’s motors mapping to the bus.

Software

  • Enable Programmatic Sensor and Motor Access

    Prepare the manufacturer’s SDK or API, or implement your own protocol to read sensor data and send motor commands programmatically.

  • Install LeRobot in Your Environment

    Install LeRobot in the working environment by following the Installation Guide.

  • Use the Built-in Serial Motors Bus

    For compatible Feetech or Dynamixel motors, use LeRobot’s built-in SerialMotorsBus interface. The motor model determines the definition used by the bus.

  • Install the Serial-Motors Extra

    Install the serial-motors extra, which installs rustypot. Use the editable command when installing from a source checkout.

  • Find a Python SDK or Bindings

    If the chosen motor is not compatible with SerialMotorsBus, find an existing Python SDK or use bindings to C or C++.

  • Implement a Basic Communication Wrapper

    Alternatively, implement a basic communication wrapper using a mechanism such as pyserial, socket, or CANopen.

  • Register Unsupported Servo Models

    Register unsupported Feetech or Dynamixel models in rustypot. A model sharing an existing control table needs only its model number registered; a new one needs a servo definition, and the installed rustypot package must contain it.

  • Define the Robot Configuration Class

    Create MyCoolRobotConfig as a RobotConfig subclass, register it as "my_cool_robot", and add a required port field for the robot’s serial connection.

  • Configure the Default Camera

    Add a cameras dictionary to the robot configuration with a cam_1 OpenCVCameraConfig entry. Set its index_or_path to 2, fps to 30, width to 480, and height to 640.

  • Create the Robot Class

    Create MyCoolRobot as a Robot subclass and set config_class to MyCoolRobotConfig. Give the robot the string name "my_cool_robot".

  • Define Motor Observation Features

    Add a `_motors_ft` property that returns the positions of `joint_1` through `joint_5` as floating-point values. Its keys must match the motor-position entries returned by `get_observation()`.

  • Add Camera Features and Merge

    Add a `_cameras_ft` property that describes each camera image as a tuple containing its height, width, and three channels, then merge it with `_motors_ft` in `observation_features`. Do not depend on connected runtime hardware when defining these properties.

  • Define the Robot Action Features

    Return the same self._motors_ft features used for observations. Each action sent to the robot specifies the goal position for every motor.

  • Report Hardware Connection Status

    Set is_connected to True only when the motor bus and all cameras are connected. Read and write operations are then possible through get_observation() and send_action().

  • Connect and Configure the Robot

    Connect the motor bus, run calibration by default when the robot is not calibrated, connect every camera, and configure the robot.

  • Implement the Robot I/O Loop

    Implement get_observation() to read robot sensor values and send_action() to send matching actions to the hardware.

  • Read Robot Sensor Observations

    Check that the robot is connected, synchronously read each motor's Present_Position, name the values as "<motor>.pos", and asynchronously read frames from each camera. Return the resulting observation dictionary, whose keys and structure must match observation_features.

  • Send Actions to the Robot

    Accept a dictionary matching action_features, remove the ".pos" suffix from its keys, and synchronously write the resulting goal positions to the arm. Return the original action without modifying it.

  • Choose the safe hold contract

    Enable supports_position_hold = True only when every action field can be refreshed safely through send_action(). These fields are usually actual position targets; velocity/effort and locomotion commands remain unsuitable.

  • Use command hold for simulators

    For a robot that can wait without another command, set supports_command_hold = True and implement hold(). This contract is used instead of position hold.

  • Retain the applied action target

    Refresh the last complete finite action returned by send_action(), including the gripper and driver clipping. Return the target actually applied when the driver modifies it, and do not replace it with later observation updates.

  • Initialize the retained target

    Initialize the retained target from a validated measured position snapshot before any command has been applied.

  • Preserve complete position commands

    When holding is enabled, make custom action processors and teleoperation corrections preserve the complete position command, including the gripper. The driver must return every action component with finite applied values.

  • Stop rollout on invalid returns

    After command application, treat an incomplete or invalid return as a contract failure: stop rollout and suppress homing instead of reusing an older target. Command failures also suppress homing in synchronous rollout.

  • Use automatic remote capability checks

    Let remote rollout check the driver capability automatically; do not add a separate hold-mode CLI flag. The generic Robot default remains false.

  • Implement the teleoperator I/O methods

    Create a teleoperator implementation based on the Teleoperator base class. Implement get_action to produce actions and send_feedback to receive controllable feedback actions.

  • Create an installable Python package

    Create a standard, installable Python package and define its name in pyproject.toml or setup.py. Name the package with the appropriate prefix: lerobot_robot_ for a robot, lerobot_camera_ for a camera, lerobot_teleoperator_ for a teleoperation device, or lerobot_strategy_ for a lerobot-rollout strategy.

  • Match the configuration and device names

    Name the implementation class after the configuration class by removing the Config suffix. For example, use MyAwesomeTeleopConfig for the configuration and MyAwesomeTeleop for the device.

  • Place device files predictably

    Place the device class in the same module as the configuration class or in a submodule named after the device, such as my_awesome_teleop.py. The recommended structure is separate, clearly named files within the same directory.

  • Expose both device classes

    Update the package’s __init__.py file to import and expose both the configuration class and the device class. This makes both classes accessible to LeRobot.

  • Import the DaMiao Library

    Place `DM_CAN.py` in your project folder, then import the library.

  • Install Python Dependencies

    Install the required Python packages, `serial` and `numpy`, using `requirements.txt`.

  • Create motor objects

    Create three motors with Motor(DM_Motor_Type.DM4310, slave ID, master ID): the first parameter is the motor type, the second the slave ID (motor CAN ID), the third the master ID (must be unique and not 0x00).

  • Set up the serial device

    Open the serial device with serial.Serial('COM8', 921600, timeout=0.5) on Windows, using baud rate 921600 and a 0.5 s timeout.

  • Initialize motor control object

    Create the motor control object from the opened serial device: MotorControl1 = MotorControl(serial_device).

  • Add motors to the controller

    Add Motor1, Motor2 and Motor3 to MotorControl1 in turn.

  • Enable motors

    Ensure parameters are set before enabling, then enable the three motors one by one with enable.

  • Enable with control mode on older firmware

    For older firmware use enable_old and specify the control mode, e.g. MIT, POS_VEL, VEL.

  • Disable motors

    Use disable to turn motors off; the example disables Motor3 and then Motor6.

  • Add cameras to the setup

    Follow the cameras guide to add cameras to the robot setup.

Calibrate and test

  • Configure Motor-Specific Bus Definitions

    Set each motor’s definition according to its model, including the operating-mode value for position control, whether the homing offset is added or subtracted, and the available registers.

  • Calibrate the SCS Servo by Range

    For a Feetech SCS0009, use range-only calibration because it has neither an operating mode nor a homing offset; do not call set_operating_mode() or set_half_turn_homings().

  • Configure Motor Control and Gains

    Run the hardware configuration at connection time. Disable torque while configuring the motors, set each motor to position mode, and set the P, I, and D coefficients to 16, 0, and 32.

  • Validate an alternative retained command

    If refreshing position targets is unsafe, separately validate a retained command. Opt in only when repeating it keeps the onboard controller balancing.

  • Validate hardware holding behavior

    Validate load support, grip behavior, and command-refresh behavior on hardware for each deployment. The robot may settle toward its retained target because the contract stops trajectory advancement rather than guaranteeing an instantaneous physical stop.

  • Require a complete observation for reset

    Use the normal rollout cleanup path for generic observation failures. Returning to the initial position requires a complete observation and may fail if a camera remains unavailable.

  • Set motor zero position

    With the motor in the disabled state, move it to the desired zero position, then call set_zero_position to make it the new zero.

  • Switch the motor control mode

    Use switchControlMode to put Motor1 in POS_VEL mode and Motor2 in VEL mode, printing a success message when the call returns true.

  • Save parameters to flash memory

    Call save_motor_param to write all changed parameters into the motor's flash memory.

  • Read internal motor registers

    Use read_motor_param to read internal registers such as PMAX, MST_ID, VMAX and TMAX, and use getParam to retrieve stored values.

  • Write internal motor registers

    Use change_motor_param to modify internal registers, for example writing 54 to KP_APR, printing Write success on success.

  • Start missing calibration automatically

    The teleoperate command identifies any missing calibrations and initiates the calibration procedure automatically.

  • Check the replayed movement

    Check that the robot replicates movements similar to those recorded. Replay can be used to test action repeatability and transferability across robots of the same model.

Data and training

  • Teleoperate with the CLI

    Run the teleoperate command for an SO101 follower and leader using the listed ports and IDs. Use the same robot ID when teleoperating, recording, and evaluating the same setup.

  • Teleoperate through the Python API

    Create follower and leader configurations with the shown ports and IDs, instantiate both devices, and connect them. In the loop, obtain an action from the leader and send it to the robot.

  • Connect devices and start teleoperation

    The teleoperate command connects the robot and teleop device, then starts teleoperation.

  • Teleoperate with camera visualization

    Run the teleoperation command with the SO101 follower and leader, including the wrist and top cameras. Set display_data=true to visualize the camera feeds and joint positions.

  • Teleoperate through the Python API

    Configure the SO101 follower with wrist and top OpenCV cameras and the SO101 leader, then connect both devices. Run the control loop at 30 Hz, send actions to the robot, and log observations and actions for visualization.

  • Record and upload five episodes

    Adapt the example robot, teleoperator, ports, IDs, cameras, and repository values for your robot, then execute the command to record 5 episodes of the task “Grab the black cube” with streaming encoding and upload the dataset to the Hugging Face Hub.

  • Reset between recorded episodes

    Reset the environment when recording is not stopping and either another episode remains or the episode must be re-recorded. Run record_loop with the configured processors, FPS, teleoperation, RESET_TIME_SEC control time, task description, and display enabled.

  • Re-record the current episode

    When re-recording is requested, clear the dataset episode buffer, reset the re-record and exit flags, and continue with the next iteration.

  • Save each completed episode

    Save the completed episode in the dataset and increment the episode index.

  • Finalize the recorded dataset

    Finalize the dataset after the recording loop completes.

  • Disconnect devices and upload data

    Stop recording, disconnect the robot and teleoperation device, and push the finalized dataset to the Hub.

  • Keep camera names consistent

    The wrist and top camera names become the observation.images.wrist and observation.images.top dataset keys. Reuse the same --robot.cameras value and the same resolution in every step so a trained policy can use the same camera configuration during deployment.

  • Choose a stamped or exact dataset name

    lerobot-record normally appends the session date and time to --dataset.repo_id. Add --dataset.no_stamp=true when the dataset must keep the exact supplied name.

  • Locate the local dataset

    The locally recorded dataset is stored under ~/.cache/huggingface/lerobot/{repo-id}. The full timestamped name can be found on the Hugging Face profile or in ~/.cache/huggingface/lerobot/${HF_USER}.

  • Print the uploaded dataset URL

    After data recording, the dataset is uploaded to the Hugging Face page. Run the provided command to print its dataset URL.

  • Tag and find the dataset

    The uploaded dataset is automatically tagged with LeRobot so the community can find it. Custom tags can also be added, such as the tutorial tag.

  • Push the local dataset manually

    The local dataset can also be pushed manually to the Hugging Face Hub after recording.

  • Upload the recorded dataset

    Upload the timestamped dataset from the local LeRobot cache to the Hugging Face Hub as a dataset repository.

  • Store recordings in LeRobot format

    lerobot-record stores data on disk in the LeRobotDataset format and automatically creates checkpoints during recording. Disable Hub uploading with --dataset.push_to_hub=False when needed.

  • Configure the recording session

    Set each episode to 60 seconds with --dataset.episode_time_s=60, reset time to 60 seconds with --dataset.reset_time_s=60, and the total episode count to 50 with --dataset.num_episodes=50.

  • Resume an existing recording

    Re-run the same command with --resume=true, provide the full timestamped name with --dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS, and set --dataset.root to a local path. Set --dataset.num_episodes to the number of additional episodes, not the dataset’s target total.

  • Start a separate dataset

    Running the command without --resume=true creates a new dataset with a new timestamp. If using --dataset.no_stamp=true, delete the existing dataset directory first.

  • Control recording with the keyboard

    Press Right Arrow or n to move to the next episode, Left Arrow or r to cancel and re-record the current episode, and Escape or q to stop the session, encode videos, and upload the dataset.

  • Use shortcuts in any session

    When a global keyboard backend is unavailable, lerobot-record reads the same keys from an interactive focused terminal; no $DISPLAY setup is required. Keyboard teleoperation still requires a global backend and therefore does not work on Wayland or headless sessions.

  • Choose a grasping dataset task

    Create a larger dataset for training by grasping an object at different locations and placing it in a bin. Record at least 50 episodes, with 10 episodes per location.

  • Keep recordings visually consistent

    Keep the cameras fixed, maintain consistent grasping behavior throughout the recordings, and ensure the manipulated object is visible on the cameras.

  • Check task visibility

    Use only the camera images to confirm that you can perform the task yourself. This checks that the recorded observations provide enough information to perform the task.

  • Add variations after reliable grasping

    After reliable grasping performance is achieved, introduce additional grasp locations, different grasping techniques, and altered camera positions during data collection. Avoid adding too much variation too quickly because it may hinder results.

  • Review recording cadence before training

    Read the cadence report before training. Check the achieved frequency against the target, the measured duration, ticks over the work budget, and whether pacing headroom is near zero.

  • Replay an episode with the CLI

    Run lerobot-replay for an so101_follower using port /dev/tty.usbmodem58760431541 and the specified dataset repository, then select episode 0. The documented example uses the follower arm ID my_awesome_follower_arm.

  • Prepare the API replay example

    Set episode_idx to 0 and import LeRobotDataset, SO101Follower, SO101FollowerConfig, precise_sleep, and log_say.

  • Connect and load the dataset

    Create the follower configuration with port /dev/tty.usbmodem5AB90687491 and ID my_follower_arm, then connect it. Load episode 0 from <hf_username>/<dataset_repo_id> and select the action column.

  • Send the recorded actions

    Log the replay, iterate through all dataset frames, and record each frame’s start time. Build each action from the selected action values and the dataset action feature names, then send it to the robot.

  • Finish the replay session

    After sending the final action, disconnect the robot from the computer.

  • Train an ACT Policy
  • Visualize Training with Trackio

    Enable --trackio.enable=true to visualize training plots. Run trackio show --project lerobot to open the dashboard, or pass --trackio.space_id=<user>/<space> to synchronize the run with a Hugging Face Space.

  • Set the Training Step Count

    Omit --steps to use the default 100,000 training steps. Use the Compute & Hardware Guide to convert the dataset size and batch size into a --steps value; imitation learning typically converges within 5–10 epochs.

  • Locate Training Checkpoints

    Allow several hours for training. Find the resulting checkpoints in outputs/train/act_so101_test/checkpoints.

  • Resume from a Local Checkpoint

    Resume the act_so101_test policy from its last checkpoint by passing the saved train_config.json with --resume=true.

  • Resume from a Hub Policy

    Use --config_path with a Hub repository ID after the run’s checkpoints have been pushed with --save_checkpoint_to_hub=true. The latest checkpoint is downloaded and training resumes while restoring the optimizer, scheduler, step counter, and data order.

Use it

  • Fetch Motor Status

    Refresh Motor1's status and read its position, velocity, and torque.

  • Control in MIT Mode

    After enabling the motor, call the MIT control function with arguments 50, 0.3, 0, 0, and 0.

  • Use Position-Velocity Mode

    Generate q over time with a sine function, then send q*10 as the position and 2 as the velocity to Motor1.

  • Use Velocity Mode

    Generate q over time with a sine function, then send q*5 as the velocity to Motor1.

  • Use Force-Position Mixed Mode

    Send position 10, force 1000, and argument 100 to Motor1.

  • Read Motor State Values

    Read the velocity, position, and torque from the motor object.

  • Refresh and Print Motor Status

    Refresh Motor1's status, then print its position, velocity, and torque.

  • Match the recorded robot settings

    Use the same --robot.id so the calibration can be found, and use the same --robot.cameras and task description as in the recorded dataset.

  • Pin a pushed checkpoint revision

    Add --policy.pretrained_revision with a commit hash, branch, or tag to pin a specific pushed version. A pushed checkpoint is tagged with its step, such as 010000.

  • Run a base rollout

    Deploy the trained policy with the base strategy for autonomous rollout without data recording. This mode is useful for quick evaluation.

Common problems

  • Damiao and Encos actuator sourcing remains unclear #2
  • Follower robot lacks URDF and XML description files #3
  • Motor ID configuration and initial calibration steps are unclear #5
  • CAD drawings for CNC-fabricated sheet-metal parts are missing #12
  • Python 3.12 requirement blocks installation on JetPack 6.x #19

Parts

  • Follower: six joints plus a gripper, Damiao DM4340 on joints 1–3 and DM4310 on joints 4–6 and the gripper, connected through a USB-to-CAN adapter
  • Leader: seven Dynamixel XL330‑M077‑T, a Waveshare servo driver board, a 5V supply, PLA(-CF) printed links, a GELLO handle and trigger, M2 inserts and screws
  • Cameras: a USB 3.0 wrist camera on the follower (InnoMaker U30CAM‑4K‑S1) and a context camera in the kit
  • Gripper fingers: soft TPU and stiff PLA, hot-swappable
  • Kit accessories: power supply (200W solo / 450W bimanual) with Y-splitter, power cables, USB cables, USB-to-CAN adapter, 3-pin debug cable, USB 3.0 hub, E-stop, and a leader base for a microphone stand
  • Structure: bead-blasted, anodised sheet metal (v0.2) and PA‑CF printed joint parts (v0.3)

Tools

  • Ships assembled: mount it with WORKPRO quick-release table clamps or with M5 screws on 3060/4080 aluminium extrusion
  • A computer with USB 3.0; up to seven USB cables for a bimanual kit
  • Building a leader: a 3D printer (PLA‑CF, 0.4 mm nozzle, 0.12 mm layers, 15% gyroid infill, supports on)

Skills

  • Python 3.12+ with uv, and the LeRobot CLI (lerobot-find-port, -teleoperate, -record)
  • Match the leader and follower poses before teleoperating, or the follower jumps fast and hard (docs warning)
  • Leader servo ID setup and zero-offset correction (leader_offset.ipynb)

Software

  • lerobot_robot_trlc_dk1 0.3.0: a LeRobot plugin (LeRobot ≥0.5.1) with robot types dk1_follower / bi_dk1_follower and teleop types dk1_leader / bi_dk1_leader
  • trlc_dk1_control: position control, experimental impedance control and gravity compensation
  • Follower URDF (GLB visual and STL collision meshes)

Documents