How to build Roboto Origin (RPO): the whole process
183 steps to build Roboto Origin (RPO), from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop links and the of…
The creator's BOM (Internal Roboto D-BOM, ATOM 01 v1.0.1, 2026‑01‑05) totals CN¥49,713 in its header and CN¥49,743.53 at its foot (the two disagree), of which joint motors are CN¥31,187 and CNC parts CN¥15,670; 3D prints and most harnesses and screws carry no price, and shipping, tools and the optional camera and lidar are excluded. Official parts kits sell through a Taobao shop whose price was not read
Buy parts
- Initialize the Main Branch
Initialize the source repository manifest for the main branch using the x5-manifest repository.
- Synchronize the Source Repositories
Run repo sync to download the source code in the initialized repository manifest.
- Select the develop Branch
You can use `-b develop` when initializing the repository manifest to download the develop branch code. Development branches continuously add features and fix bugs, but their stability is not as high as the main branch code.
- Confirm the Hardware Version
Confirm the hardware version first. The mechanical structure and hardware interfaces of V2.0 are not compatible with V1.0.
Print and make
- Get V2.0 Mechanical Files
Enter `V2.0/roboto_origin_mechanic/` to view assembly drawings and STL files.
- Get V2.0 PCB Files
Enter `V2.0/roboto_origin_pcb/` to obtain Gerber files and schematics.
- Get V1.0 Mechanical Files
For V1.0 legacy hardware, enter `V1.0/atom01_mechanic/` to view the mechanical drawings.
- Get V1.0 PCB Files
For V1.0 legacy hardware, enter `V1.0/atom01_pcb/` to obtain the PCB files.
Assemble
- Check CAN_H and CAN_L Wiring
Check that CAN_H and CAN_L are wired correctly and are not reversed.
Software
- Open the firmware release page
Open the roboto_usb2can GitHub Releases page.
- Download the latest firmware
Download the latest `roboto_usb2can_xxx.bin` firmware file.
- Flash firmware onto the device
Flash the downloaded firmware onto the device using the preferred tool, as described in the “Firmware Compilation and Flashing” section.
- Install the Zephyr SDK
Ensure that the Zephyr SDK is properly installed.
- Configure the CANnectivity module
Create `zephyr/submanifests/cannectivity.yaml` with project name `cannectivity`, URL `https://github.com/CANnectivity/cannectivity.git`, revision `main`, and path `custom/cannectivity`.
- Update the workspace
Update the west workspace.
- Get the project source code
Clone this repository into the `zephyr/samples` directory.
- Build the roboto_usb2can Firmware
Enter the roboto_usb2can directory and build roboto_usb2can with west.
- Flash with STM32CubeProgrammer
Flash the firmware with the STM32CubeProgrammer runner for the STLINK-V3MINIE debugger.
- Flash with Probe-rs
Select the Probe-rs runner to flash the firmware.
- Flash with J-Link
Select the J-Link runner to flash the firmware.
- Flash with PyOCD
Select the PyOCD runner to flash the firmware.
- Flash with OpenOCD
Select the OpenOCD runner to flash the firmware.
- Run the Windows Host Tool
No additional drivers are needed on Windows; the system automatically recognizes the device as WinUSB. Use Python 3.8+ to install pyusb and run scripts/roboto_usb2can_tool.py, ensuring libusb-1.0.dll is in the directory or system path.
- Package as EXE
Install PyInstaller, then execute the packaging command. The generated file is located at `scripts/dist/roboto_usb2can.exe`.
- Install Linux host tool dependencies
Install the Python dependencies `python3-pip`, `python3-tk`, and `pyusb` for the host tool.
- Install the udev rules
Install the udev rules using `scripts/99-roboto-usb2can.rules`.
- Quick-install the udev rules
From the workspace root, copy the rule file, set its permissions, reload the rules, and trigger udev.
- Copy and reload the rules
First copy the rule file to `/etc/udev/rules.d/` and set its permissions to 644. Then reload the udev rules and trigger them.
- Understand the udev rule features
The rules allow non-root access to the device and create `/dev/roboto_usb2can*` symlinks. They work with SocketCAN, libusb, gs_usb, and ttyUSB/ttyACM access paths.
- Check system compatibility
The rules work on mainstream Linux distributions, including Ubuntu, Debian, Fedora, and Arch, and require the kernel gs_usb driver (3.16+).
- Uninstall the udev rules
Remove `/etc/udev/rules.d/99-roboto-usb2can.rules` to uninstall the rules.
- Reload and Trigger udev Rules
Reload the udev rules, then trigger the rules.
- Troubleshoot Windows Device Recognition
Check that the USB cable supports data transmission. In Device Manager, look for yellow exclamation marks and manually update the driver by selecting WinUSB if present.
- Troubleshoot Python Device Not Found
Confirm that `libusb-1.0.dll` exists. On Linux, check USB permissions in `/etc/udev/rules.d/` and ensure the current user can access the USB device.
- Download an RDK X5 System Image
Download a pre-built system image from the recommended GitHub Releases page, which also provides historical versions. Google Drive and Baidu Netdisk mirror links are available on each Release page.
- Prepare the Image Build Host
Use an Ubuntu 22.04 host with x86_64 architecture and root or sudo privileges. Ensure at least 50GB of free space and access to GitHub and Ubuntu package repositories.
- One-Click Full Build
Run the complete build script to perform environment setup, kernel build, bootloader build, rootfs build, deb packaging, and image generation in order.
- Initialize Build Environment
Run the setup subcommand to install dependencies and the toolchain and fetch the source code.
- Build Bootloader
Run the bootloader subcommand to build miniboot, U-Boot, and nand_disk.img.
- Build Standard and RT Kernels
Run the kernel subcommand to build the standard and real-time kernels.
- Build Ubuntu Rootfs
Run the rootfs subcommand to build the Ubuntu root filesystem.
- Build Deb Packages from Source
Run the debs subcommand to build deb packages from source.
- Generate Final System Image
Run the pack subcommand to generate the final system image.
- Quick Image Rebuild
When rootfs is already built and placed in the rootfs/ directory, run the image subcommand to rebuild the kernel, bootloader, and deb packages and generate the image.
- Specify Build Configuration File
Use the -c option to specify a build configuration file; the default is ubuntu-22.04_desktop_rdk-x5_release.conf.
- Show Help
Use the -h option to show help for build.sh.
- Pack Image with Server Configuration
Run pack with the ubuntu-22.04_server_rdk-x5_release.conf configuration to generate a system image using the server configuration.
- Full Build with Beta Configuration
Run all with the ubuntu-22.04_desktop_rdk-x5_beta.conf configuration to perform a full build.
- Extract the root filesystem
Extract the samplefs archive from rootfs into deploy/rootfs/.
Calibrate and test
- Check ROS2 Imports
Confirm that the matching ROS2 environment is sourced and check that rclpy and sensor_msgs can be imported.
- Use Lower-Level Balance Policy
This project handles the VR-to-upper-body teleoperation link, while the lower-level policy controls the real robot's standing and balance.
- Configure Robot Policy Model
Change the loaded configuration file in roboparty_deploy at src/inference/launch/inference.launch.py. Options include inference_amp.yaml, inference_attn_enc.yaml, inference_beyondmimic.yaml, inference_getup.yaml, and inference_interrupt.yaml; inference_interrupt.yaml is currently recommended.
- Start Robot and Load Policy
After configuration, run ./tools/start_robot.sh so the robot loads the corresponding configuration and uses the selected lower-level policy at startup.
- Start Robot Deployment
Start roboparty_deploy on the robot and confirm that inference_interrupt.yaml has been loaded.
- Enable and Reset Robot
Press X on the robot controller to enable the motors, then press A to reset the robot.
- Enter Inference and Balance Mode
Press B on the controller to enter inference mode and confirm that the robot can stand stably, maintain balance, and walk normally.
- Align Simulated and Real Poses
Do not expose the real robot to VR yet; observe the upper-body poses of the simulated and real robots and bring them close.
- Run a pre-robot performance check
Before testing with the physical robot, first run the program with the controller, headless, and profile-loop options.
- Inspect control-loop statistics
The terminal statistics include motion, ik, send, loop, rate, and ipopt_iter_* fields for XR reading and coordinate conversion, IK solving, ROS command publishing, the full loop, actual rate, and Ipopt iteration statistics.
- Confirm the PICO connection
Check the terminal; a connection log confirms that the PICO has connected successfully.
- Align the Meshcat and robot poses
Before pressing a, make the robot pose in Meshcat as close as possible to the physical robot's reset pose.
- Align the operator and robot poses
Before sending control commands, move the operator's arms close to the physical robot's pose.
- Check the USB device
Run `dmesg | grep gs_usb` to check the device; the output should display `Configuring for 1 channels`.
- Start the CAN interface
Set `can0` to 1Mbps and start it.
- Verify the device and rules
After plugging in the device, check the USB device, gs_usb driver, device symlinks, and CAN interface.
- Troubleshoot Linux usage problems
For permission errors, ensure the user is in the `plugdev` or `dialout` group. If there is no `can0`, check whether `gs_usb` is loaded and inspect `dmesg`. If the rules do not apply, ensure the filename starts with `99-`, set permissions to 644, and replug the device or reload the rules.
- Check CAN Bus Termination Resistors
Confirm that termination resistors are connected. The CAN bus requires 120Ω at both ends.
- Check Device Bitrate Matching
Confirm that the bitrate matches between the devices.
- Use a Shorter High-Quality USB Cable
Try using a shorter, higher-quality USB cable.
- Reduce Bus Load or Transmission Frequency
Reduce the bus load or the transmission frequency.
- Confirm the Zephyr board name
Run west boards to list every board supported by Zephyr. The Board Catalog also shows the exact board target name to pass to west build.
- Verify the Blinky LED
If you are using blinky, the LED will start blinking.
- Start the apt-cacher-ng Service
The rootfs build uses `apt-cacher-ng` as an apt proxy cache. Start the service and enable it to run at startup.
- Check the samplefs Archive
Ensure that the `rootfs/` directory contains only one `samplefs*.tar.gz` file and that the file is not corrupted.
- Check the filesystem generation output
The desktop/ directory should contain jammy-rdk-arm64, samplefs_desktop_jammy-v3.0.0.tar.gz, and a .info file listing installed apt packages; extracting the archive should produce rootfs with 23 directories.
- Find the exact RPO task id
If the RPO task name is missing, run list_envs.py and copy the exact task id.
Data and training
- Train an RSL-RL policy
Run training with the specified environment, headless mode, TensorBoard logging, and 8192 parallel environments.
- Prepare AMP and BeyondMimic motion data
Prepare the datasets for AMP and BeyondMimic following the GMR project (https://github.com/Roboparty/GMR).
- Reorder dataset joint sequence
GMR datasets follow the robot URDF/XML joint order, which differs from Isaac Lab's; prepare a joint mapping file such as robolab/scripts/tools/retarget/config/rpo.yaml and reorder the joint sequence before training.
Use it
- Learn Robot Controller Buttons
Use X to enable or disable the motors, A to reset, B to enter inference mode, and LB to expose the upper-body control interface to VR teleoperation.
- Connect PICO and Start Simulation
Start the VR teleoperation program in the repository, complete the PICO connection using the later documented procedure, and let the simulated robot follow the operator.
- Expose Upper-Body Control to VR
After the simulated and real robot poses are basically aligned, press LB on the robot controller to expose the upper-body control interface to VR.
- Send Commands to Real Robot
Continue operating the VR teleoperation side and press A on the VR controller to begin sending upper-body commands to the real robot.
- Confirm Teleoperation Conditions
The robot side must press LB to allow VR to take over the upper-body interface, and the teleoperation side must press A on the VR controller before commands are sent.
- Start the main loop with r
Press r in the terminal to receive VR data; the robot in Meshcat follows the operator's motion while the physical robot does not move.
- Allow arm commands with a
Press a in the terminal to allow arm commands; the physical robot then begins receiving joint positions sent by the computer.
- Quit the program with q
Press q in the terminal to quit the program.
- Send commands with right-hand A
Press A on the right VR controller to start sending commands, with the same effect as the terminal keyboard key a.
- Stop sending commands with right-hand B
Press B on the right VR controller to stop sending commands; press A again afterward to resume sending.
- Check Onboard LED Status
The device has three onboard status indicator LEDs for USB status, CAN status, and communication activity.
- Check Green Communication LED
The green LED being off means the bus is idle with no data transmission; a brief flash means CAN bus data reception (RX) or transmission (TX) was detected.
- Use Multi-device CAN Management
The tool supports simultaneous connection and management of multiple CAN adapters through a USB Hub. Click Connect All to scan and connect all online devices, set the unified bitrate (1Mbps by default), and use Start CAN or Stop CAN to enable or disable all CAN channels.
- Test CAN send and receive
Receive CAN frames with `candump` and send the test frame `123#DEADBEEF` with `cansend`.
- Run the automated test script
Grant execute permission to `scripts/test_roboto_usb2can.sh`, then run it for quick CAN interface verification.
- Verify CAN traffic
Test CAN traffic with `candump can0` and `cansend can0 123#DEADBEEF`.
- Play the trained policy
Run play.py with the specified environment and one parallel environment.
- Play the AMP policy
Run the trained AMP motion-magic policy with task RPO-AMP-Play and a single environment.
- Play the BeyondMimic policy
Run the BeyondMimic policy with task RPO-BeyondMimic and one environment.
- Play the parkour policy
Run the parkour policy with task RPO-Parkour-Play and one environment.
- Export an ONNX model
To export an ONNX model, set num_envs to 1 and add the --exportonnx flag.
- Run the Sim2Sim evaluation
Run sim2sim_rpo.py in MuJoCo, passing the full path of the exported policy model to --load_model.
Common problems
Parts
- 23 joint motors from Damiao (DM series): DM 4340P (48V) ×14 and DM 10010L ×9
- RDK X5 8G controller (the docs also support an Orange Pi 5 Plus), a USB hub, four USB2CAN adapters, a power hub board, CAN adapter boards and a 48V-to-5V module
- HI13 M0‑USB IMU; a gamepad receiver
- 48V 15Ah Li-ion pack (140×140×115 mm), an emergency stop and an aviation-plug charging port
- 68 CNC metal parts of 25 kinds (sandblasted, black anodised) and two 3D-printed rubber soles; a 130×165×18 deep-groove bearing, AXK6085 thrust needle bearings and M3–M6 screws
Tools
- CNC machining and JLC prototyping (or the official parts kit); a 3D printer for the soles and calibration parts
- Soldering tools for the controller switch and emergency-stop wiring
- A load-bearing safety gantry (required by the docs for zeroing and gait tests)
- DM_Motor_Tool for motor IDs and firmware; V2.0 calibrates with GB119 dowel pins
Skills
- Linux and ROS 2 (Humble/Jazzy); the README says a background helps and the docs are written for beginners
- Isaac Lab 3.0 reinforcement learning (RSL-RL, AMP, BeyondMimic) and Sim2Sim to MuJoCo
- CAN-bus motor setup, zero calibration and the C++/Python SDK
Software
- roboparty_deploy: ROS 2 deployment framework with IMU, motor, inference and camera SDKs (C++/Python)
- roboparty_train: training, evaluation and policy export on Isaac Lab and RSL-RL, with motion retargeting
- roboparty_firmware: USB2CAN firmware and RDK X5 / Orange Pi image builds
- rpo_description (URDF/MJCF), roboparty_navigation for navigation and localisation, and roboparty_xr_teleop for XR teleoperation