Skip to content

About

Main Repository of OpenDoge Mini Quadruped Robot

Resources

Stars

15 stars

Watchers

0 watching

Forks

Latest commit

 

History

13 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 

Repository files navigation

OpenDoge

中文 · Live simulator · Roadmap (中文)

OpenDoge (OpenDog V1.1) is a fully open-source 12-DoF quadruped robot. SolidWorks structure, URDF/MJCF description, mjlab reinforcement learning, ONNX policy export, a ROS-free C++ deployment runtime, and a browser simulator — the whole chain lives in this project.

The goal is not a one-off demo, but a reproducible, replaceable, and continuously improvable path from "build one" to "train one" to "make it walk".

OpenDoge V1.1

Highlights

  • 12 DoF, ~4.6 kg: 4 legs × 3 joints, 409 SolidWorks part files; suitable for both 3D printing and CNC.
  • Training mainline on mjlab: MuJoCo-Warp + RSL-RL PPO with no Isaac Gym dependency; flat, rough, get-up, handstand, jump, and multi-skill tasks ship with playable baselines.
  • One shared contract: a 48-D proprioceptive core, 12-D action, Kp=12, and action_scale=0.25; policies do not need an interface swap between simulation and hardware.
  • ROS-free deployment: a single C++ process owns ONNX inference, four SocketCAN buses, EL05 control frames, and safety damping; CAN/IMU/gamepad are managed by systemd.
  • Runs in a browser: MuJoCo WASM + ONNX Runtime Web, zero install.

Architecture

OpenDoge_hardware             OpenDoge_description
  CAD · STEP · 3MF     ───►   URDF · MJCF · STL
                                     │
                                     ▼
                           OpenDoge_train (mjlab)
                 PPO · curriculum · domain randomization · baselines
                                     │
                           opendoge-export → ONNX
                                     │
                    ┌────────────────┴────────────────┐
                    ▼                                 ▼
          OpenDoge_deploy (C++)          OpenDogeRobotics.github.io
          ONNX CPU · 4×CAN · damping      MuJoCo WASM · ORT Web
                    │
                    ▼
             OpenDoge V1.1 hardware

OpenDoge_origin is the project entry point: it owns the overview, module navigation, and cross-repository contract. Implementations evolve in their own repositories.

Repository map

Repository Role Key contents
OpenDoge_origin (this repo) Project overview and docs README, roadmap, cross-repo contract
OpenDoge_hardware Mechanical and component data V1.1 CAD/STEP/3MF, EL05 / DM-IMU / CHIWU / Orange Pi 5 material
OpenDoge_description Robot description package URDF, STL, RViz/Gazebo launch files, MuJoCo MJCF
OpenDoge_train Training, validation, export mjlab 1.6, six OpenDoge tasks, baselines, Viser, ONNX export
OpenDoge_deploy Real-robot runtime C++17, ONNX Runtime, 4×CAN, systemd, sim2sim, web console
OpenDogeRobotics.github.io Browser simulator MuJoCo WASM, ONNX Runtime Web, terrain editor

Robot specification

Item Value
Model OpenDoge / OpenDog V1.1
Configuration 12 DoF: 4 legs × (hip / thigh / calf), fixed feet
Mass ≈4.6 kg (V1.1 MJCF model)
Standing height ≈0.16 m
Actuation 12× EL05 (RobStride) 6 N·m; 1.5:1 calf reduction, 9 N·m at the joint
Onboard compute Orange Pi 5 (RK3588S)
Attitude sensing DM-IMU-L1 over a USB virtual serial port
CAN CHIWU 4×CAN, native SocketCAN, classic CAN at 1 Mbps
Remote control Xbox-compatible 2.4G gamepad
Structure 3D printed (PLA/PETG/nylon) or CNC aluminum; TPU/rubber feet

Tech stack

Layer Technology
Mechanical SolidWorks, STEP / 3MF
Description URDF, MJCF, STL, ROS 1 catkin
Training mjlab 1.6.0 (MuJoCo-Warp), RSL-RL PPO, PyTorch, uv
Validation/playback MuJoCo, Viser, opendoge-eval
Export ONNX
Deployment C++17, ONNX Runtime, SocketCAN, systemd
Hardware EL05, DM-IMU-L1, CHIWU 4×CAN, Orange Pi 5
Front end MuJoCo WASM, ONNX Runtime Web, Three.js, Vite

From training to the real robot

  1. Model it: OpenDoge_description provides the general URDF/STL; the training repository ships its own V1.1 MJCF and STL assets.
  2. Train it: OpenDoge_train runs PPO on mjlab, replays with play / Viser, and exports ONNX with opendoge-export.
  3. Verify the loop: OpenDoge_deploy/sim2sim reproduces the C++ control loop in MuJoCo — the last gate before hardware.
  4. Deploy it: opendoge_deploy runs ONNX at 100 Hz, holds targets at 200 Hz, and drives 12 EL05 motors over CAN.
  5. Show it: the same ONNX file can be loaded into the browser simulator for demos or quick policy comparisons.

Cross-repository contract:

Item Convention
Shared observation 48-D: base_lin_vel(3) + base_ang_vel(3) + projected_gravity(3) + joint_pos_rel(12) + joint_vel_rel(12) + last_action(12) + command(3)
Action 12-D; target = default_pos + 0.25 × action, with per-joint sign mapping
Default pose Firmware convention (hip 0, thigh 0.8, calf -1.6); training mirrors it through joint signs
PD Kp=12; Kd=0.5 for training/simulation, 0.8 on the current robot to suppress vibration
Rates Policy 100 Hz → targets 200 Hz → CAN loop at 200 Hz (current hardware setting; higher rates need CAN timing validation)
Policy network MLP 48→512→256→128→12 (ELU), normalization embedded in ONNX
Linear velocity No state estimator on the robot: lin_vel_source=zero / command / imu
Compatibility The 48-D runtime is incompatible with legacy 49-D policies

Observation size grows per task: Rough adds a 165-D height scan on top of the 48-D base (213-D); Skills adds a 3-D jump command, a 4-D skill one-hot, and a 2-D phase (57-D); the Jump task alone uses 51-D.

Quick start

1. Try it online

Open https://opendogerobotics.github.io/, pick a policy, and drive it with WASD / QE or the virtual joystick. The page also includes a terrain editor and drag-to-push disturbances.

OpenDoge browser simulator

2. Training and simulation

cd OpenDoge_train
uv sync --extra cu128          # use --extra cpu for CPU-only config checks
uv run list-envs

# Train flat-ground velocity tracking
uv run train LainLab-OpenDoge-Flat --env.scene.num-envs 4096

# Replay a bundled baseline
uv run baseline-play opendoge flat --device cuda:0 --num-envs 1

# Export ONNX
uv run opendoge-export LainLab-OpenDoge-Flat --checkpoint <ckpt> --output policy.onnx

Python 3.10–3.13 is required. Training needs an NVIDIA GPU; CPU is only for configuration checks and smoke tests.

3. Real-robot deployment

cd OpenDoge_deploy
./scripts/setup_onnx.sh
export ONNXRUNTIME_ROOT=$(realpath build/deps/onnxruntime)
colcon build --symlink-install --packages-select opendoge_deploy
source install/setup.bash

bash scripts/install_services.sh       # install CAN / IMU / gamepad systemd services
./scripts/start_robot.sh verify        # check can0-3, IMU, gamepad
./scripts/start_robot.sh dry           # hardware-free dry run
./scripts/start_robot.sh damping       # real-robot damping / safe hold
POLICY_PATH=policy/opendoge_flat.onnx ./scripts/start_robot.sh policy

⚠️ This is real hardware, not a simulation. On the first power-up, follow dry → damping → low-gain → policy, with the robot suspended or lifted off the ground; verify the E-stop, joint limits, torque limits, and CAN watchdog before any ground test. Before running on hardware, check every joint's direction, offset, lower, and upper in deploy/configs/opendoge_deploy.conf.

4. Manufacturing and description

The V1.1 SolidWorks assembly, parts, and 3MF live in OpenDoge_hardware/mechanical/V1.1/. The description package provides URDF, STL, and RViz/Gazebo launch files; the model can also be imported into MuJoCo, Isaac Gym, and other simulators.

Module details

OpenDoge_hardware

Single source of truth for the mechanical structure and purchased components. V1.1 (2026-09) is current; V1.0 is superseded and kept in git history.

  • 409 .SLDPRT parts and the OpenDog.SLDASM assembly
  • base.STEP, base.3mf, plus CHIWU PCB, Orange Pi 5, and IMU STEP/model files
  • datasheets/: EL05 manual, DM-IMU-L1 manual/firmware/examples, CHIWU schematic, Orange Pi 5 material
  • 12-DoF layout; parts can be 3D printed or CNC machined; TPU/rubber feet recommended

OpenDoge_description

ROS 1 (catkin) description package under URDF/:

  • Opendoge.urdf + 17 STL meshes + a joint/link mapping CSV
  • display.launch (RViz) and gazebo.launch
  • xml/Opendoge.xml and scene.xml (MuJoCo MJCF)
  • 12 actuated joints named FL/FR/RL/RR_{hip,thigh,calf}_joint; feet are fixed links

The training side maintains the V1.1 MJCF; the deployment repository carries its own URDF copy for hardware-parameter checks. The description package itself is BSD-licensed.

OpenDoge_train

The training, validation, and export repository; default branch mjlab:

  • Built on mjlab 1.6.0 (MuJoCo-Warp) + RSL-RL PPO, with no Isaac Gym dependency
  • The framework version is pinned; the repo only owns OpenDoge assets, task differences, validation contracts, and deployment adapters
  • The isaacgym branch keeps the original Isaac Gym + HIMLoco stack for reproducing historical results and comparison
Task ID Capability Actor observation
LainLab-OpenDoge-Flat Flat-ground velocity tracking 48
LainLab-OpenDoge-Rough Rough-terrain velocity tracking 213
LainLab-OpenDoge-Getup Flat-ground fall recovery 48
LainLab-OpenDoge-Handstand Front-leg handstand 48
LainLab-OpenDoge-Jump In-place jump 51
LainLab-OpenDoge-Skills-Flat walk / handstand / getup / jump in one policy 57

The LainLab- prefix is historical. It is kept for compatibility with published baselines and checkpoints.

Bundled baselines live in src/baseline/opendoge/{flat,rough,getup,skills}/, each with baseline.json, model.pt, and policy.onnx. The repository also ships a standalone workbench (src-workbench: model viewer, policy selection, training, ONNX export, Viser playback) and an offline toolchain (calibration, collection, BC, DAgger, export). The mjlab branch does not include real-robot deployment code; exported ONNX goes to OpenDoge_deploy.

OpenDoge_deploy

A ROS-free C++ real-robot runtime. The ROS / ros2_control path has been removed so that controller managers, topic queues, and executors do not add coupling to the hardware path.

opendoge_deploy (single process)
  → ONNX CPU inference @ 100 Hz
  → target position hold @ 200 Hz
  → EL05 q/dq/tau/kp/kd frames @ control rate (currently 200 Hz)
  → SocketCAN can0 / can1 / can2 / can3
  → CHIWU 4×CAN adapter
  → 12× EL05 (one leg per CAN bus)

Each CAN bus carries one leg, and the 12-D ONNX output maps 1:1 to motor IDs:

CAN Leg Motor IDs (hip / thigh / calf)
can0 Front-left FL 1 / 2 / 3
can1 Front-right FR 4 / 5 / 6
can2 Rear-left RL 7 / 8 / 9
can3 Rear-right RR 10 / 11 / 12
  • Inputs: command.state from the gamepad and imu.state from the IMU, maintained by systemd daemons; files can also be injected for dry runs
  • Safety: automatic damping on motor fault, over-temperature, feedback timeout, CAN error, or E-stop; position ramps, startup deviation checks, and a CAN watchdog
  • Policy: defaults to policy/opendoge_flat.onnx (48-D); the legacy 49-D opendoge_r5.onnx is no longer compatible
  • Validation: sim2sim/deploy_mujoco.py reproduces the C++ control loop; test/ contains regression and hardware-timing tests
  • Tooling: optional web console in web_tools/; start_robot.sh supports dry, damping, policy, low-gain, calibrate, and verify

OpenDogeRobotics.github.io

An in-browser policy simulator, fully static, deployable to GitHub Pages:

  • MuJoCo (WebAssembly) runs physics, ONNX Runtime Web evaluates policies, Three.js renders
  • Includes flat velocity, rough terrain, get-up, and multi-skill (walk / handstand / getup) policies
  • Joystick/keyboard commands, terrain editor, external push disturbances, and live monitoring
  • Observation and action pipelines mirror the mjlab training configuration; a Python reference implementation ships with the repo

It is a demo and quick-comparison tool, not a training acceptance criterion; formal evaluation stays in the OpenDoge_train MuJoCo/Viser workflow.

Status

As of November 2026:

Module Status
Mechanical V1.1 ✅ 409 parts, assembly, STEP/3MF, component data
Robot description ✅ URDF/STL/MJCF/ROS 1 package
Training mainline ✅ mjlab 1.6, six tasks, four baselines, workbench
Sim2Sim ✅ C++ control loop reproduced
Deployment runtime ✅ 48-D contract, safety state machine, systemd, web console
Hardware bring-up ✅ CAN / 12 motors / IMU / gamepad; zero and direction calibration
Real-robot walking 🟡 PD standing works; RL walking still being tuned
Browser simulator ✅ Live
BOM / assembly docs ⬜ In progress

Hardware bring-up is complete for CAN, all 12 EL05 motors, the DM-IMU-L1, and the gamepad, including zero and direction calibration; PD standing holds. RL walking is still being tuned for high-frequency oscillation, CAN feedback timing, and IMU noise. The symptoms, root causes, and fixes are recorded in the deployment repository's hardware logs.

Roadmap

  • V1.1 mechanical structure and component data
  • 12-DoF URDF/STL/MJCF with RViz/Gazebo support
  • mjlab mainline: velocity, get-up, handstand, jump, multi-skill
  • Four directly playable OpenDoge baselines
  • MuJoCo Sim2Sim deployment-loop validation
  • ROS-free C++ runtime and safety state machine
  • 48-D training/deployment contract migration
  • Browser MuJoCo + ONNX simulator
  • Stable real-robot walking and velocity tracking
  • Real-robot get-up / handstand / jump
  • Gait library (trot / walk / bound / pace) with switching
  • Stairs, slopes, and uneven terrain
  • Vision/state estimation and autonomous navigation
  • Complete BOM, assembly guide, and v1.0 release

Safety

Twelve EL05 motors can deliver 6–9 N·m at the joint, enough to break a 3D-printed structure. Treat the following as mandatory:

  1. Run dry, then damping, then low-gain while suspended or lifted, and only then policy.
  2. Before power-up, confirm the E-stop works, joint and torque limits are configured, and the CAN watchdog is enabled.
  3. After changing direction, offset, or the reduction ratio, test one motor, then one leg, then the whole robot.
  4. Never put an unvalidated policy on the ground; standing in simulation does not mean standing on hardware.

Documentation

Document Contents
Hardware README CAD, component data, manufacturing notes
Description README URDF structure, joint naming, RViz/Gazebo usage
Training README mjlab install, tasks, baselines, workbench, multi-skill
Deployment README Build, run, configuration, safety
Bring-up and debugging guide Bring-up sequence, calibration, troubleshooting
Hardware issue and change log Real failures, root causes, itemized fixes
48-D contract migration 49→48-D, sign mapping, gains, action scale
Multi-skill design Observation layout, training, acceptance
Workbench docs Module boundaries and front-end development
Simulator README Policy integration and reference implementation

Acknowledgments

OpenDoge builds on a large body of open-source work:

Thanks also to every open-source project that makes quadrupeds cheaper and more open.

License

Each sub-repository is licensed independently: OpenDoge_train, OpenDoge_deploy, and OpenDogeRobotics.github.io use Apache-2.0; OpenDoge_description uses BSD. For hardware CAD, read the corresponding repository's terms first. When reusing project content, follow the license of the source repository.

About

Main Repository of OpenDoge Mini Quadruped Robot

Resources

Stars

15 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors