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
| Part | Qty |
|---|---|
| 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
| Part | Qty |
|---|---|
| HFS8-4080-700 · Aluminium extrusion: follower mount · MiSUMi | 1 |
| HFS6-3030-400 · Aluminium extrusion: context camera mount · MiSUMi | 1 |
| SHNTP8-5 · M5 T-slot nuts · MiSUMi | 12 |
| ISO 4762 M5x12 · Screws: follower arms · MiSUMi / Amazon | 8 |
| ISO 4762 M5x16 · Screws: 3D-printed context cam mount · MiSUMi / Amazon | 4 |
| ISO 7093 M5 · Washers: 3D-printed plates · MiSUMi / Amazon | 4 |
| e.g. K&M 260/1 · Microphone Stand (3/8” mount) · e.g. Thomann | 2 |
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)