Connecting to sources…

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

  • Documentation images are missing or placed incorrectly #6
  • The rsl_rl dependency cannot be downloaded from the project #1
  • All five modules contain suspected software bugs #8
  • GMR motion capture lacks Atom01-specific FBX conversion configuration #12

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

Documents