Connecting to sources…

How to build Orion: the whole process

80 steps to build Orion, from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop links and the official sources.

Orion is a custom-built 12-DOF ROS2 quadruped robot dog. The repository provides SolidWorks mechanical models, STL/3MF printable parts, KiCad PCB designs, URDF models, and ROS2 and STM32 control software.

Print and make

  • Fabricate the multilayer KiCad PCBs

    Fabricate the custom multilayer KiCad PCBs described in the document.

  • Model and print the chassis

    Iteratively model the chassis in SolidWorks, then 3D print it.

  • Make the silicone feet

    Make the two-part silicone injection-molded feet described in the document.

  • Use the mechanical model files

    Use the SolidWorks parts and assemblies, STL, and 3MF exports according to the models/ README.

  • Use the PCB project files

    Use the KiCad projects for the Control Board and Power Board according to the pcb/ README.

  • Export the URDF from SolidWorks

    Export the robot URDF from SolidWorks.

  • Change Link and Joint Names

    Change the link and joint names to the required names.

  • Fix Joint Limits

    Fix the limits so they are non-360 degrees.

Assemble

  • Assemble the control board

    Assemble the control board with the STM32F401, BNO055 IMU, and PCA9685 servo driver.

  • Assemble the power board

    Assemble the power board with battery distribution, INA3221 monitoring of three rails, high-current servo lines, and a battery alarm.

  • Configure I2C and debug interfaces

    Configure LTC4311 active termination on multiple I2C buses and provide test pads and debug headers.

  • Install bearings in the joints

    Install bearings in all 12 joints.

  • Fit magnetic internal mounts

    Fit magnetic mounts to provide tool-free access to the internal electronics.

  • Build the single-leg test jig

    Build a linear-rail jig for single-leg testing.

  • Add a Foot Joint

    Before training, add a foot joint for a touch sensor in Isaac Lab.

Software

  • Install Foxglove Studio

    Install Foxglove Studio.

  • Install Node.js 16+ and npm

    Prepare Node.js version 16 or later and npm.

  • Enter the extension directory

    Clone the repository or navigate to the rpy-panel directory.

  • Install dependencies

    Install the npm dependencies in the rpy-panel directory.

  • Build the extension

    Build the RPY panel extension for Foxglove Studio.

  • Package the extension

    Package the extension and create a .foxe file in the dist folder.

  • Install the extension in Foxglove Studio

    Open Foxglove Studio, go to Extensions → Install Extension, and select the generated .foxe file from the dist folder.

  • Start hot-reload development mode

    Run the watch command for automatic reloading during development.

  • Install the development directory extension

    In Foxglove Studio, go to Extensions → Install Extension, navigate to the rpy-panel directory, and select it.

  • Define the RPY ROS message

    Create a custom ROS message with float64 roll, pitch, and yaw fields, and provide angle values in degrees rather than radians.

  • Add the RPY visualization panel

    In Foxglove Studio, click the “+” button and select “RPY Visualization”.

  • Select the RPY ROS topic

    Use the dropdown at the top of the panel to select the ROS topic containing RPY data.

  • Customize the gauge colors

    Edit src/RPYPanel.tsx and change the preferred colors for roll, pitch, and yaw in the colors object.

  • Adjust the gauge size

    Modify the CircularGauge size prop in src/RPYPanel.tsx; the default is 220px.

  • Create Python 3.11 Environment

    Create and activate a Conda environment named env_isaaclab using Python 3.11.

  • Install Isaac Sim 5.1.0

    Upgrade pip, then install isaacsim 5.1.0 with the all and extscache components from the NVIDIA extra index.

  • Install PyTorch and torchvision

    Install torch 2.7.0 and torchvision 0.22.0 from the specified PyTorch wheel index.

  • Launch Isaac Sim

    Run the isaacsim command to launch Isaac Sim.

  • Clone IsaacLab Repository

    Clone the specified IsaacLab Git repository.

  • Install Build Dependencies

    Install cmake and build-essential with apt.

  • Run IsaacLab Installer

    Enter the cloned IsaacLab directory and run its installation script.

  • Install Correct NVIDIA Drivers

    Select the NVIDIA graphics configuration and automatically install the Ubuntu drivers.

  • Reboot the Computer

    Reboot the computer after installing the drivers.

  • Confirm NVIDIA Configuration and Log In

    Run prime-select query and confirm that it says nvidia; then log out and log back in, choosing Ubuntu on Xorg at the bottom right of the screen.

  • Import into Isaac Sim for USD

    Import the model into Isaac Sim to obtain the USD file.

  • Prepare Custom Quadruped Files

    Place the USD file and configuration folder in the `custom_quadruped` folder.

  • Copy the Custom Quadruped Folder

    Copy the `custom_quadruped` folder into the Isaac Lab velocity configuration directory.

  • Enter the extension directory

    Navigate to the desired directory, then enter the rpy-panel/ directory where the extension files have already been created.

  • Install dependencies

    Run npm install to install the Foxglove Studio SDK, React and TypeScript dependencies, and build tools and linters.

  • Build the extension

    Run npm run build to compile the TypeScript code into a Foxglove-compatible extension.

  • Package the extension

    Run npm run package to create a .foxe file in the dist/ folder.

  • Install in development mode

    Open Foxglove Studio, go to Extensions, select Install Extension, navigate to ./rpy-panel, select the entire folder rather than individual files, and click Open.

  • Install in production mode

    Open Foxglove Studio, go to Extensions and select Install Extension, navigate to rpy-panel/dist/, select the .foxe file, and click Open.

  • Add the panel to your layout

    In Foxglove Studio, click the “+” button in the layout, search for “RPY Visualization”, and click it to add the panel to your workspace.

  • Select an RPY topic

    Click the dropdown at the top of the panel labeled “Select RPY Topic” and choose the ROS topic containing roll, pitch, and yaw data. The panel automatically detects topics with names containing rpy, orientation, or attitude.

  • Define the RPY ROS Message

    Create `RPYData.msg` with three `float64` fields named `roll`, `pitch`, and `yaw`. Each value is measured in degrees and ranges from -180 to +180.

  • Publish Example RPY Messages

    Create a Python ROS publisher that publishes `RPYData` on `/robot/rpy` with a queue size of 10 and a rate of 10 Hz. In the loop, publish oscillating Roll and Pitch, rotating Yaw, increment the angle by 0.1, and sleep at the selected rate.

  • Enable Hot-Reload Development

    Run the hot-reload command to start a file watcher. It automatically rebuilds when changes are saved, and Foxglove Studio hot-reloads the extension.

  • Install CMake

    Install CMake to provide the build tool for STM32 project configuration.

  • Install STM32CubeIDE Extension

    Install the `STM32CubeIDE for VSCode` extension in VSCode.

Calibrate and test

  • Run Empty Scene Tutorial

    Run the create_empty.py tutorial script in the 00_sim directory.

  • Run Spawn Prims Tutorial

    Run the spawn_prims.py tutorial script in the 00_sim directory.

  • Rerun Empty Scene Tutorial

    Run the create_empty.py tutorial script in the 00_sim directory again.

  • Run Scene Creation Tutorial

    Run the create_scene.py tutorial script in the 02_scene directory.

  • Run Quadruped Environment Tutorial

    Run the create_quadruped_base_env.py tutorial script in the 03_envs directory.

  • Rerun Scene Creation Tutorial

    Run the create_scene.py tutorial script in the 02_scene directory again.

  • Troubleshoot Random Glitches

    For random glitches, try restarting Isaac Lab or the simulator, restarting the machine, and reinstalling drivers or dependencies.

  • Tune Parameters and Overrides

    Adjust parameters in the `custom_quadruped` folder as needed and add override commands if desired.

  • Validate IK and gait

    Use the single-leg linear-rail jig to validate inverse kinematics and gait before full integration.

  • Run servo calibration

    Run the servo calibration test from TestScripts/.

  • Interpret the RPY gauges

    The top of each gauge at 12 o’clock represents 0°; positive angles rotate clockwise and negative angles rotate counter-clockwise. Major ticks occur every 90° at -180°, -90°, 0°, and +90°, and the large number below each gauge shows the exact value.

Data and training

  • Train and Play the Quadruped

    Activate the `env_isaaclab` environment, enter the RSL-RL directory, train with 128 environments, and then play the trained model.

  • View TensorBoard in VS Code

    Install the TensorBoard extension in VS Code, press `ctrl + shift + P`, and select the `~/Isaaclab/scripts/reinforcement-learning/rsl_rl` folder.

  • Use Headless Mode to Reduce Load

    Add `--headless` to the train command and switch the power mode from `performance` to `power save` to prevent Processor 0 from heating up.

  • Run Isaac Lab PPO training

    Run the Isaac Lab PPO training in the reinforcement-learning/ directory.

  • Run camera and depth tests

    Run the camera and depth-mapping tests from TestScripts/.

  • View Real-Time Orientation Data

    Select a topic and play its data source. Roll shows rotation around the X-axis, Pitch around the Y-axis, and Yaw around the Z-axis.

Use it

  • View the real-time RPY gauges

    As messages arrive, three gauges update in real time: Roll is the red left gauge, Pitch is the green middle gauge, and Yaw is the blue right gauge.

Documents