Connecting to sources…

How to build ROBOTO_ORIGIN: the whole process

72 steps to build ROBOTO_ORIGIN, from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop links and the official …

ROBOTO_ORIGIN is a fully open-source DIY humanoid robot designed to be assembled independently. This repository aggregates its structural, electronic, training, and deployment resources, with a BOM and module documentation.

Buy parts

  • Confirm the hardware version

    Select the corresponding directory for your hardware version. The V2.0 mechanical structure and hardware interfaces are not compatible with V1.0, so confirm the version before assembly or purchasing materials.

Print and make

  • View V2.0 mechanical drawings and STL files

    Enter the V2.0 mechanical directory to view assembly drawings and STL files.

  • Obtain V2.0 PCB files

    Enter the V2.0 PCB directory to obtain Gerber files and schematics.

  • View V1.0 mechanical drawings

    Legacy V1.0 users enter the V1.0 mechanical directory.

  • View V1.0 PCB files

    Legacy V1.0 users enter the V1.0 PCB directory.

Software

  • Select the operating system

    Select the operating system you are using, then follow the corresponding system update instructions.

  • Update the Ubuntu system

    This guide covers Ubuntu version 24.04 LTS and later; run the update and upgrade commands.

  • Update the Apple system

    In System Settings, select General, then Software Update, and install any available updates.

  • Update the Windows system

    Check for updates in Windows Update and install any that are available.

  • Install Ubuntu host dependencies

    Install the tools Zephyr needs to configure and build applications using Ubuntu's recommended package manager, then check the cmake, python3, and dtc versions.

  • Install macOS host dependencies

    Install the host tools needed by Zephyr with Homebrew, and configure PATH for Homebrew and Python in the shell profile.

  • Prepare Windows Terminal

    On Windows 10 and later, install Windows Terminal from the Microsoft Store; these instructions work in either cmd.exe or PowerShell.

  • Create the Zephyr Python environment

    Use Python 3 to create ~/zephyrproject/.venv, or Python 3.12 in Windows Command Prompt and PowerShell to create zephyrproject\.venv.

  • Activate the Python virtual environment

    Activate the virtual environment so Zephyr’s Python dependencies remain separate from the system Python installation. In Windows PowerShell, first set the current user execution policy to RemoteSigned.

  • Install west

    Install west in the activated Python virtual environment.

  • Initialize and update the workspace

    Use west to initialize the ~/zephyrproject workspace, fetch Zephyr and its modules, then enter the directory and run west update.

  • Initialize a relative-path workspace

    Alternatively, use zephyrproject as the workspace name in the current directory; after initialization, enter it and update the modules.

  • Install Zephyr Python packages

    Install the Zephyr Python packages with west packages pip --install. On Windows, run the provided helper command or install the package list output by west with python -m pip.

  • Export the Zephyr CMake package

    Run west zephyr-export to export the Zephyr CMake package.

  • Install the Zephyr SDK

    Change to the Zephyr repository and run west sdk install. The SDK includes the compiler, assembler, linker, custom QEMU, OpenOCD, and other tools needed to build, emulate, flash, and debug Zephyr applications.

  • Find the Zephyr board name

    Run west boards to list all supported Zephyr boards, then confirm the exact board target name to pass to west build in the Board Catalog.

  • Build the Blinky sample

    Replace <your-board-name> with your board name and build samples/basic/blinky with west build. The -p always option forces a pristine build and removes output from a previous configuration; later, -p auto can be used.

  • Build for a CPU Cluster

    When building for a board with multiple SoCs or CPU clusters, specify the target SoC or CPU cluster. To build Blinky for the cpuapp core on the nRF5340 DK, provide the board as nrf5340dk/nrf5340/cpuapp.

  • Connect and Power the Board

    Connect the board, usually through USB, and turn it on if it has a power switch. If unsure, check the board’s page in Supported Boards and Shields for any required setup or flashing procedure.

  • Configure Linux udev Rules

    On Linux, you may need to configure udev rules before flashing with a debug probe for the first time.

  • Flash the Sample to the Board

    Run west flash to program the application you just built onto the connected board.

  • Download and flash adapter firmware

    Download the latest roboto_usb2can_xxx.bin from the GitHub Releases page and flash it to the device with your preferred tool.

  • Build the roboto_usb2can firmware

    Enter the roboto_usb2can directory and run west build for the roboto_usb2can board.

  • Flash firmware with a debugger

    Choose the STM32CubeProgrammer, Probe-rs, J-Link, PyOCD, or OpenOCD command for your debugger; STM32CubeProgrammer is recommended for STLINK-V3MINIE.

  • Recognize the device on Windows

    No additional drivers are needed on Windows because the system automatically recognizes the device as a WinUSB device.

  • Prepare a Python 3.8+ environment

    Prepare a Python 3.8 or newer environment and install the pyusb dependency.

  • Install tkinter on Linux

    Windows usually includes tkinter; Linux may require python3-tk to be installed.

  • Run the multi-device management tool

    Ensure libusb-1.0.dll is in the current directory or system path, then enter the scripts directory and run roboto_usb2can_tool.py.

  • Install the packaging tool

    Install PyInstaller so the tool can run on computers without a Python environment.

  • Package as an EXE file

    Enter the scripts directory and run PyInstaller to generate scripts/dist/roboto_usb2can.exe.

  • Install host tool dependencies

    Install python3-pip, python3-tk, and pyusb.

  • Quickly install the udev rules

    Copy the rule file from the workspace root, set its permissions, reload the rules, and trigger udev.

  • Copy the udev rule file

    Copy scripts/99-roboto-usb2can.rules into /etc/udev/rules.d/ and set its permissions to 644.

  • Reload the udev rules

    Reload the udev rules and trigger rule application.

  • Add device access groups

    Optionally add the current user to the plugdev and dialout groups; re-login is required afterward.

  • Uninstall the udev rule

    Remove 99-roboto-usb2can.rules from /etc/udev/rules.d/.

  • Reload and trigger udev rules

    Reload the udev rules and trigger the device rules on Linux.

  • Troubleshoot Windows device recognition

    Check whether the USB cable supports data transmission and look for yellow exclamation marks in Device Manager; if present, manually update the driver and select WinUSB.

  • 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 has access to the USB device.

  • Build the Orange Pi firmware

    On Ubuntu 22.04, enter the orangepi-build directory and run the build script.

Calibrate and test

  • Check the three status LEDs

    The device has three onboard status LEDs for USB status, CAN status, and communication activity.

  • Check the blue USB LED

    Use the onboard blue LED to check USB status.

  • Check the yellow CAN LED

    Use the onboard yellow LED to check CAN status.

  • Check the green communication LED

    Off means the bus is idle with no data transmission; a brief flash means CAN bus data reception or transmission was detected.

  • Check the USB-CAN device

    Run dmesg and filter for gs_usb; the output should display “Configuring for 1 channels”.

  • Start the CAN interface

    Start the can0 interface with a bitrate of 1000000.

  • Test CAN sending and receiving

    Listen on can0 with candump and send a test frame with cansend.

  • Run the automated test script

    Give scripts/test_roboto_usb2can.sh execute permission, then run it to verify the CAN interface.

  • Verify the device and rules

    After plugging in the device, inspect the USB device, gs_usb, roboto_usb2can symlinks, and CAN interfaces.

  • Verify CAN traffic

    Test CAN traffic on can0 using candump and cansend.

  • Troubleshoot permission denial

    Ensure the user is in the plugdev or dialout group, or set the device permissions to 666.

  • Troubleshoot a missing can0

    Check whether gs_usb is loaded and inspect dmesg.

  • Troubleshoot unapplied rules

    Ensure the filename starts with 99-, the permissions are 644, then reconnect the device or reload udev.

  • Troubleshoot fast blinking LED

    This indicates a CAN bus error. Check that 120Ω termination resistors are connected at both ends, that CAN_H and CAN_L are wired correctly and not reversed, and that the bitrate matches between devices.

  • Reduce packet loss at high bitrates

    Try using a shorter, higher-quality USB cable, or reduce the bus load or transmission frequency.

  • Confirm the Blinky LED

    If you are using blinky, the LED will start to blink. The figure shows the Phytec reel_board running blinky.

Use it

  • View multi-device information

    The tool supports simultaneous connection and management of multiple CAN adapters through a USB Hub, with the bottom list showing real-time bus addresses and serial numbers.

  • Connect all online devices

    Click the Connect All button to automatically scan and connect all online devices.

  • Configure and start CAN

    Set a unified bitrate, with a default of 1Mbps; click Start CAN to enable all device CAN channels and Stop CAN to disable them all.

  • Send CAN data

    Broadcast to all devices with Target: All or target a single device, with support for hexadecimal data input and periodic auto-send.

  • Receive and filter CAN data

    The top log area displays real-time bus data, automatically annotates the device number as `[Dev X]`, and supports ID filtering.

Common problems

  • Documentation images are missing and misplaced #6
  • Project dependency cannot be downloaded #1
  • Atom01 motion-capture conversion configuration is missing #12
  • Multiple modules contain unconfirmed software defects #8

Documents