Connecting to sources…

How to build NavBot-D1 open-source quadruped robot dog: the whole process

132 steps to build NavBot-D1 open-source quadruped robot dog, from buying parts, printing and assembly to software, calibration and training, with the bill of materials,…

$4,999 for the assembled robot (NavBot's official store, read 2026‑11‑03 in US dollars), including the assembled and calibrated robot, battery packs and charger, with international shipping calculated at checkout and tax not stated. The creator's BOM (bom/BOM.xlsx) totals $4,249.36, of which the 12 DM‑6248P motors are $2,082 and the CNC parts for four legs $764; the BOM lists no 3D-printed parts, BMS board or wiring and excludes shipping

Buy parts

  • Organize the BOM by function

    Organize the core hardware list by the functional layers shown, and pair every component with a validation action.

  • Order the NavBot-D1 Robot Platform

    Order the available NavBot-D1 open-source quadruped robot platform. It is a 12-DOF platform with mechanical CAD/CNC files, wiring and BOM guidance, printable parts, control software, and reinforcement-learning resources.

  • Obtain Actual Hardware Resource Files

    Install Git LFS before cloning to obtain actual binary files for CAD, manufacturing drawings, and spreadsheets instead of pointer files.

Print and make

  • Visit the EasyEDA website

    Open the EasyEDA website in your browser.

  • Select Online Design and Pro Edition

    On the website’s main page, click “Design online” and select “Pro Edition”.

  • Log in to EasyEDA

    You need to log in to EasyEDA at this point.

  • Import the NavBot-EN01 PCB project

    Choose File, Import, and JLCEDA(Professional), then select NavBot-EN01.epro.

Assemble

  • Inspect All Mechanical Parts

    Check the body frame, side plates, top and bottom plates; upper legs, lower legs, and knee joint connectors for all four legs; bearings, linkages, limiters, and support posts; all 12 actuators; battery bay, BMS, main board, Jetson, IMU, USB-CAN, and wiring; then LoRa, remote controller, GPS, image transmission module, and antennas.

  • Temporarily Label Actuator Positions

    Before mechanical assembly, label each actuator’s future leg and joint position, such as FL-HIP, FL-THIGH, and FL-CALF, to make later ID writing, CAN wiring, and zero calibration less error-prone.

  • Secure Actuators and Main Frame

    Secure the actuators and main frame first, keeping the actuators’ debug ports accessible from the frame.

  • Keep Debug Ports Accessible

    Leave access to the actuator debug ports because they may later need ID rewriting, parameter reads, or debugging.

  • Apply Thread Locker to Critical Screws

    Use a small amount of thread locker on critical screws around the actuators, linkages, and support structures because legged robots vibrate heavily.

  • Move Each Assembled Layer Manually

    Manually move each layer after it is assembled instead of waiting until all four legs are complete to discover a binding joint.

  • Assemble One Side Then Mirror It

    Assemble one side of the robot first, then repeat the process on the other side.

  • Check Each Leg for Key Conditions

    For each leg, check hip actuator mounting strength, upper-leg alignment with the actuator output, proper knee-joint bearing insertion, smooth linkage motion, and limiters that prevent unsafe over-rotation.

  • Install Mechanical and Software Limits

    Install mechanical limiters to prevent joints from rotating into dangerous positions during software faults, manual handling, or falls. Both mechanical and software limits should exist rather than relying only on the control policy.

  • Connect the power and signal wiring

    Connect the battery through BMS/power management and the emergency stop/power switch to the main board power input, Jetson power, external module power, and actuator power path. Connect the Jetson by USB to the IMU, USB-CAN adapter, and LoRa/receiver module; use HDMI, keyboard, and mouse for the first boot, and Ethernet or Wi-Fi for SSH.

  • Route and secure the cables

    Route cables so they are not pulled when the joints move or crushed by actuator housings during a fall or while carrying the robot. Keep the purpose of every cable visible for later maintenance.

  • Apply Thread Locker Sparingly

    Use a small amount of thread locker around actuators, linkages, support posts, and frame joints. Overuse makes later maintenance difficult, while skipping it can loosen fasteners during long-duration locomotion.

  • Secure All Cable Routing

    Provide fixed routing points for CAN, power, USB, and antenna cables. Keep them away from rotating joints and crush zones, and do not rely on connectors to absorb pulling force.

  • Ensure Jetson Cooling and Power

    Provide adequate power and cooling for the Jetson because it runs ROS 2, drivers, and the RL policy simultaneously. Poor cooling can cause throttling, while unstable power can cause random reboots or peripheral dropouts.

Software

  • Update the system and install catkin

    Run apt update and install ros-noetic-catkin.

  • Install Eigen and development dependencies

    Install Eigen, GLPK, GLFW, pybind11, and Python catkin tools.

  • Install documentation and simulation tools

    Install Doxygen, urdfdom, OctoMap, Assimp, and rqt_multiplot.

  • Install ROS message dependencies

    Install grid_map_msgs and octomap_msgs.

  • Install readline and serial tools

    Install libreadline, libcgal, checkinstall, libserialport, and the serial development package.

  • Install serial and teleoperation software

    Install ros-noetic-serial, ros-noetic-joy, and ros-noetic-joy-teleop.

  • Prepare OCS2 and remaining dependencies

    The remaining listed dependencies include OCS2, Boost 1.71, Gazebo, RViz, and SocketCAN.

  • Create a separate OCS2 workspace

    Create `~/ocs2_ws/src` and clone Pinocchio, hpp-fcl, ocs2_robotic_assets, raisimLib, elevation_mapping_cupy, grid_map, and OCS2.

  • Clone the remaining OCS2 dependencies

    Clone raisimLib, elevation_mapping_cupy, grid_map, and OCS2 in the OCS2 source workspace.

  • Build Raisim first

    Enter the raisimLib `build` directory, run CMake and Make, and install with checkinstall.

  • Download and extract ONNX Runtime

    Download the ONNX Runtime v1.7.0 Linux x64 archive, extract it in `/tmp`, and create the local include, library, and CMake directories.

  • Install ONNX Runtime files

    Sync the ONNX Runtime headers and libraries into `~/.local/include/onnxruntime` and `~/.local/lib`.

  • Set ONNX Runtime environment variables

    Add the `onnxruntime_DIR` and `LD_LIBRARY_PATH` environment variables to `~/.bashrc`.

  • Initialize and build the first OCS2 packages

    Initialize catkin from `~/ocs2_ws`, set the `RelWithDebInfo` build type, and build elevation_mapping_cupy and grid_map.

  • Build the remaining OCS2 packages

    Build hpp-fcl, pinocchio, ocs2_robotic_assets, and ocs2.

  • Source the OCS2 environment

    Append OCS2's setup.bash to `~/.bashrc`, then reload `~/.bashrc`.

  • Create the Catkin Workspace

    Create `~/catkin_ws`, copy the repository's `code/src` folder into it, and initialize, configure, and build the workspace. Add the workspace setup script to `~/.bashrc` and reload it after the build.

  • Load the Simulation Controller

    Set `ROBOT_TYPE` to `d1` and load the legged controller with `cheater:=false`.

  • Start the Legged Controller

    Call `/controller_manager/switch_controller` to start `controllers/legged_controller` without stopping other controllers.

  • Run the CAN Setup Script

    Run `can.sh` in `src/legged_examples/legged_damiao/5.15` to set up CAN.

  • Start the Real Hardware Interface

    Set `ROBOT_TYPE` to `d1` and launch `legged_damiao_hw.launch`.

  • Load the Real Robot Controller

    Set `ROBOT_TYPE` to `d1` and load the legged controller with `cheater:=false`.

  • Start the Real Legged Controller

    Call `/controller_manager/switch_controller` to start `controllers/legged_controller` without stopping other controllers.

  • Remove the Temporary Initialization Guard

    After the states match, remove the temporary initialization guard indicated by `src/docs/write.png`, rebuild, and restart the program.

  • Install Git LFS

    Before cloning the repository, install Git LFS when actual CAD, machining, and spreadsheet binary files are required.

  • Choose the correct software entry

    The software code is maintained in separate repositories; use the navigation to select the data generation, policy training, or deployment entry point rather than looking for ROS, training, or deployment code here.

  • Prepare and validate the exported policy

    Select and validate the exported policy before using the D1_rl_sar repository for deployment.

  • Install the environment from the current README

    Open D1_rl_sar and set it up according to the support environment and installation steps in the repository's current README, while following its validation gates and license.

  • Configure Jetson Orin

    Configure Jetson Orin according to the D1_rl_sar instructions. This repository is responsible for the Jetson Orin deployment configuration.

  • Configure the USB-CANFD connection

    Set up USB-CANFD according to the D1_rl_sar instructions. Check the CAN mapping after configuration.

  • Set motor and IMU parameters

    Set the motor and IMU parameters according to the D1_rl_sar instructions. Check the IMU orientation and parameters before the powered test.

  • Open the Training Repository

    Open NavBotHub/D1_HIMLoco and follow its current README; it is the normal software starting point for training a D1 locomotion policy without new expert data.

  • Train with Isaac Gym

    Use Isaac Gym according to the repository README and choose a scratch, weights-only, or resume workflow.

  • Export the Trained Policy

    Export the selected checkpoint as ONNX using the D1_HIMLoco workflow.

  • Set Up Jetson and USB-CANFD

    Set up Jetson Orin and complete USB-CANFD integration according to the repository README.

  • Follow Each Repository README

    Each software repository has its own supported environment, installation steps, validation gates, and license; follow its current README as the source of truth.

  • Use Owning Repositories for Limits

    Do not infer current dataset support, training limits, or deployment limits from this landing page; these values evolve in the owning repository.

  • Flash Jetson with SDK Manager

    Put the Jetson into recovery mode, use NVIDIA SDK Manager to flash JetPack, and select NVMe as the target disk. Connect a monitor, keyboard, and mouse for the first boot.

  • Create the account and verify networking

    After the first boot, create the user account and verify that the desktop and base network work. Obtain the Jetson IP address so you can switch to SSH.

  • Maintain Jetson Remotely via SSH

    Confirm that the Jetson can be maintained remotely through SSH.

Calibrate and test

  • Validate the IMU data

    Read reasonable roll, pitch, yaw, or raw IMU data from the software stack.

  • Validate CAN communication

    Confirm that the adapter is detected, the bitrate is configured, and messages can be exchanged with the actuators.

  • Check the power before first startup

    Do not enable the actuators immediately during the first power-on. Confirm that the BMS display and battery state are normal, the emergency stop reliably removes dangerous output, the Jetson fan starts, the main board indicators look normal, and the peripheral power rails are stable.

  • Verify SSH and reconnection

    Connect from the host computer to the Jetson over SSH, and confirm that the Jetson can access the internet or local network. Verify that it can reboot and reconnect; move on to ROS 2 and driver installation only after these are stable.

  • Prepare zero-position calibration

    Place the robot body level and make all four leg poses consistent. Use a level surface or fixture so unevenness does not contaminate the zero position.

  • Test each joint direction

    Move one joint at a time and confirm its direction against the body coordinate frame. Use low torque or a safe mode for the first test.

  • Validate emergency stopping

    Before proving that the robot can stand, verify that the emergency stop can intervene immediately when actuator output becomes unsafe.

  • Check actuator IDs

    Check that every actuator ID is unique and that the software labels for front-left, front-right, rear-left, and rear-right match the physical robot.

  • Verify joint and attitude definitions

    Confirm that each joint's positive direction matches the control definition and that the IMU attitude matches the body orientation.

  • Pass the calibration gate

    Do not enter RL mode until every actuator ID, leg label, joint direction, IMU attitude, and emergency-stop question has been answered.

  • Test Each Actuator Direction

    Confirm each joint ID, then test every joint independently with a small command even if the ID is correct. A reversed direction makes the policy output the wrong physical motion.

  • Validate Emergency Stop Before Enabling

    Validate the emergency stop before enabling the actuators for the first time. Human reaction time is usually insufficient if a quadruped fails while standing.

  • Check the CAN Bus

    Check bitrate, termination, cable length, loose connectors, USB-CAN driver behavior, and device permissions. CAN bus issues may cause intermittent motion loss or one joint dropping offline.

  • Change One Variable at a Time

    Do not change wiring, ID mapping, policy, and remote mapping simultaneously, because it becomes hard to know which change actually fixed the issue.

  • Detect and Test IMU and USB-CAN

    Detect and test the IMU and USB-CAN.

  • Trace All Actuator Configurations

    Ensure that all 12 actuator IDs, directions, and zero positions are traceable.

  • Reproduce Bring-Up Before Changes

    Reproduce bring-up first and do not modify algorithms first.

  • Test One Leg Before the Robot

    If possible, use a single leg or actuator to validate ID, direction, mode, and CAN communication.

  • Separate Mechanical and Software Changes

    Record changes to leg geometry, wiring, battery, or policy parameters separately.

  • Run the optional OCS2 test

    Launch the `legged_robot_ddp.launch` file to run the optional OCS2 test.

  • Start Gazebo and RViz

    Set `ROBOT_TYPE` to `d1`, then launch `empty_world.launch` to open the Gazebo and RViz simulation.

  • Publish Velocity Commands

    Run `rqt_robot_steering` and publish velocity commands. The velocity must not be zero, otherwise no command is published.

  • Prepare Real Motor Configuration

    Before enabling torque on the real robot, configure the motor CAN IDs, baud rate, DM6248P parameters, and zero positions.

  • Set Motor CAN and Master IDs

    Set `can_id` and `mst_id` for each motor according to the wiring diagram.

  • Set Motor Baud Rate

    Set each motor baud rate to 5 Mbps.

  • Configure DM6248P Motor Parameters

    Configure the required DM6248P motor parameters.

  • Calibrate Motor Zero Positions

    The first motor on each leg is the yaw joint and should be horizontal. The second motor is the thigh pitch joint and should follow the original zero-position reference image, while the third motor is the calf pitch joint and should reach the mechanical stop.

  • Wait for RViz to Display the Robot

    Wait for RViz to display the robot, then manually move the motors and body.

  • Compare Real and RViz States

    Confirm that the real robot state matches the state displayed in RViz after manually moving the motors and body.

  • Evaluate a Training Checkpoint

    Evaluate the training checkpoint using the workflow supported by the repository.

  • Select and Validate an Exported Policy

    Select and validate an exported policy, then open NavBotHub/D1_rl_sar and follow its current README.

  • Run Deployment Contract Checks

    Run the repository's deployment-contract checks to verify that the exported policy satisfies the deployment requirements.

  • Verify the Policy in MuJoCo

    Verify the policy in MuJoCo using the D1_rl_sar workflow.

  • Configure Motors and IMU

    Configure the motors and IMU using the configuration owned by D1_rl_sar.

  • Preserve Validation Gates

    Preserve the QA and validation gates between motion data, training, and hardware deployment stages.

  • Run contract and simulation validation

    Complete the deployment contract check and MuJoCo validation in D1_rl_sar. Both checks must be completed before running the real robot.

  • Complete pre-run validation

    Before controlling the real robot, complete the simulation validation and policy contract check. Real-robot control may cause falls, collisions, actuator damage, or personal injury.

  • Safely prepare the first powered test

    For the first powered test, suspend the robot or support it reliably. Make sure the emergency power disconnect is within reach.

  • Check joints and control configuration

    Before the powered test, check the joint order, direction, zero position, IMU orientation, motor ID, CAN mapping, PD parameters, and command range.

Data and training

  • Record Robot Motion Data

    Use D1_Legged_mpc_amp to record motion in Gazebo with NMPC and WBC.

  • Use the Audited AMP Dataset

    The workflow uses the audited 61-D command-conditioned AMP dataset.

  • Train and Export the Robot Policy

    Use D1_HIMLoco for Isaac Gym training, checkpoint evaluation, and ONNX export.

  • Check Whether Existing Data Is Enough

    Check whether the reviewed dataset included with D1_HIMLoco already meets your training needs; skip this stage if it does.

  • Open the Motion Data Repository

    Open NavBotHub/D1_Legged_mpc_amp and follow its current README to record or regenerate expert motion.

  • Collect Expert Motion

    Use the repository's Gazebo/NMPC/WBC collection workflow to obtain expert motion.

  • Apply Motion Quality Gates

    Preserve the steady-trajectory quality gates in the motion workflow; a recorded motion is not automatically a training dataset.

  • Export Validated Motion Data

    Export HIMLoco-native 61-D command-conditioned NPZ data with QA, manifests, provenance, and checksums.

  • Use the Published D1 AMP Dataset

    Use the published D1 AMP dataset provided by D1_HIMLoco.

  • Enter RL locomotion testing

    After mechanical assembly, power, Jetson, ROS 2, IMU, CAN, and actuator mapping all pass validation, enter reinforcement-learning locomotion testing.

  • Prepare an open flat surface

    Place the robot on an open flat surface, power it on, and wait for the Jetson and ROS 2 nodes to start. Connect the remote controller or LoRa control side.

  • Enter stand mode safely

    Enter stand mode using the safe sequence, then confirm that all four legs carry load evenly without obvious shaking.

  • Start RL locomotion mode

    After the standing check passes, enter reinforcement-learning locomotion mode.

  • Test motion commands gradually

    Start with slow forward and backward commands, test small left and right yaw commands, and increase speed gradually.

  • Record every test run

    After every run, record battery percentage and voltage changes, actuator temperature and warnings, Jetson CPU/GPU load and temperature, ROS 2 node timeouts or dropped messages, CAN bus communication errors, and the motion most likely to trigger instability.

  • Keep Logs for Every Test

    Keep logs for every test; when a robot falls or shakes, logs are more reliable than intuition.

  • Generate expert action dataset

    In D1_Legged_mpc_amp, collect expert actions with Gazebo/NMPC/WBC, apply the steady-state trajectory quality gate, and export the HIMLoco-native 61-D command-conditioned NPZ, QA, manifest, provenance, and checksum.

  • Check whether collection can be skipped

    Skip the action-data generation stage if D1_HIMLoco already contains an audited dataset that satisfies the training requirements.

  • Train and export motion policy

    Use the published D1 AMP dataset for Isaac Gym training in D1_HIMLoco with scratch, weights-only, or resume, then evaluate checkpoints and export ONNX.

Use it

  • Optimize from test records

    With enough test records, tune policies, change mechanics, adjust parameters, or optimize gait behavior. The goal is a repeatable test procedure rather than fast movement on the first attempt.

  • Choose an Appropriate Remote Control Link

    Use LoRa for longer-range operation in open areas, but do not assume the long-range link is stable indoors or in cluttered environments. A local remote controller or ROS 2 control interface is usually more convenient for indoor or short-range bring-up.

  • Safely Enable RL Locomotion Mode

    Bring up the robot safely, stand, and switch into RL locomotion mode.

  • Test Remote Movement Commands

    Use remote input to test forward, backward, turning, and faster movement.

  • Start Indoors at Short Range

    Start first bring-up tests indoors and over short distances before outdoor long-range tests.

  • Put Safety Before Features

    Emergency stop, mechanical limits, low-speed testing, and power management are the foundation of dynamic robot development.

  • Select a Robot Gait

    Wait for the model to load and stand in RViz, return to the controller terminal, list the available options, and select `trot`.

  • Use Joystick Control

    Start the simulation and controller in the same way as in the simulation section, then use the joystick according to the mappings in `src/docs/handle.png`.

  • Validate and deploy on robot

    Use the D1_rl_sar workflow to validate the policy in MuJoCo and deploy it to Jetson/CANFD and the physical robot.

  • Run the robot using the safety workflow

    After completing simulation, contract checks, and the first powered-test checks, run the real robot according to the complete safety workflow in D1_rl_sar.

  • Verify and Deploy the Real-Robot Policy

    Use the validated policy and deployment contract with D1_rl_sar for MuJoCo verification and Jetson/CANFD real-robot deployment.

  • Run the Real-Robot Runtime

    Run the real-robot runtime after completing the deployment-contract checks, MuJoCo verification, and hardware configuration.

Parts

  • 12 × DaMiao DM6248P joint motors
  • A Jetson Orin Nano Super module and an edge-computing carrier board
  • A DM‑IMU‑L1 IMU and a DaMiao DM‑USB2CANFD_Dual two-channel USB‑CAN FD adapter
  • A 6S 5000 mAh 45C XT60 LiPo battery; a custom BMS board (EasyEDA Pro, STM32F1 firmware)
  • Aluminium joint supports, CNC leg parts, aluminium tubes, a fibreglass board mount and a sheet-metal body, plus 3D-printed parts (STL)
  • A LoRa + GPS + video-transmission module, a video screen with power bank and a LoRa remote
  • A screw and bearing pack (AXK1024 thrust needle bearings, 6800ZZ deep-groove bearings and more)

Tools

  • Outsourced CNC and sheet-metal work from the STEP files and PDF drawings, or parts from the official store
  • A 3D printer
  • NVIDIA SDK Manager to flash JetPack 6.2.2 (a Windows host needs WSL2 and usbipd)
  • A suspension or support stand for the first powered test, and emergency power isolation within reach

Skills

  • Jetson flashing, Ubuntu 22.04 and ROS 2 Humble
  • CAN FD setup and motor ID, direction and zero calibration
  • Isaac Gym (HIMLoco) training, MuJoCo verification and ONNX deployment; optionally Gazebo + NMPC/WBC to record expert motion

Software

  • D1_rl_sar: ROS 2 Humble deployment on the Jetson (based on rl_sar; v1.0 flat-ground stable release, 2026‑07‑30)
  • D1_HIMLoco: Isaac Gym training, checkpoint evaluation and ONNX export, with the D1 AMP dataset
  • D1_Legged_mpc_amp: Gazebo + NMPC + WBC expert-motion recording (adapted from legged_control)
  • D1_SDK: SDK and samples

Documents