Skip to content
Cyber-physical-Systems-LabPublic

About

Multi-robot visualization setup in ROS 2 Humble using RViz2 with namespaced URDFs and static transforms for spatial layout.

Topics

Resources

Stars

1 star

Watchers

0 watching

Forks

Repository files navigation

All_Robot — CPS Lab robot models

validate-models

These are the simulation models of the robots in the Cyber-physical Systems Lab at Uppsala University. All of them live in this one repository. The meshes, URDFs, USDs and MJCFs here are the only copies to use. The same URDF works in RViz2, Gazebo Fortress, MuJoCo and Isaac Sim / Isaac Lab. Each simulator can run from its own conda environment or its own Docker image.

Robots_IsaacLab has been merged into this repo and is archived. See docs/MIGRATION.md.


Robots and simulator status

Robot (robots.yaml key) Description RViz2 Gazebo Fortress MuJoCo Isaac Sim / Lab
go2 Unitree Go2 quadruped ✅ 🟢 🟢 ¹ 🟢 ²
myagv Elephant myAGV base ✅ 🟢 🟢 🟢 ³
mycobot_280_pi myCobot 280 Pi + camera flange + pump (+3 variants) ✅ 🟢 🟢 🟢
mycobot_280_gripper myCobot 280 + adaptive gripper 🟢 🟢 🟢 🟢
mycomb myAGV + myCobot 280 Pi + gripper (mycomb1 = second instance) ✅ 🟢 🟢 🟢
nova5 Dobot Nova 5 🟢 🟢 🟢 🟢
nova5_2f85 Dobot Nova 5 + Robotiq 2F-85 ✅ 🟢 🟢 🟢

✅ verified by a lab member · 🟢 loads, holds its pose and renders correctly in an automated run (see the gallery; captured 2026-11-05 with RViz2 Humble, Gazebo Fortress 6.18, MuJoCo 3.x, Isaac Sim 6.0) · 🟡 loads, but uses legacy assets · ⬜ not yet verified · ❌ known broken

Physics everywhere still uses placeholder masses for the Elephant robots (see Known issues).

¹ For serious Go2 work, use the tuned MuJoCo Menagerie Go2. ² Isaac Lab ships UNITREE_GO2_CFG, and isaaclab/cps_robots_cfg.py uses it. ³ myAGV has no movable joints, so Isaac imports it as a rigid prop, not an articulation.

CI (.github/workflows/validate.yml) runs on every push:

  • the static URDF checks
  • check_urdf (urdfdom)
  • Gazebo URDF→SDF
  • a MuJoCo load-and-step test

To turn a cell ✅, a person must still open the robot in that simulator. See Validation.

Gallery

Every robot is shown in every simulator from the same camera angle (from the +x+y diagonal, 25° above). The images live in docs/screenshots/<simulator>/<robot>.png. Click one to enlarge it.

Robot RViz2 Gazebo Fortress MuJoCo Isaac Sim / Lab
go2 go2 in RViz2 go2 in Gazebo Fortress go2 in MuJoCo go2 in Isaac Sim / Lab
myagv myagv in RViz2 myagv in Gazebo Fortress myagv in MuJoCo myagv in Isaac Sim / Lab
mycobot_280_pi mycobot_280_pi in RViz2 mycobot_280_pi in Gazebo Fortress mycobot_280_pi in MuJoCo mycobot_280_pi in Isaac Sim / Lab
mycobot_280_gripper mycobot_280_gripper in RViz2 mycobot_280_gripper in Gazebo Fortress mycobot_280_gripper in MuJoCo mycobot_280_gripper in Isaac Sim / Lab
mycomb mycomb in RViz2 mycomb in Gazebo Fortress mycomb in MuJoCo mycomb in Isaac Sim / Lab
nova5 nova5 in RViz2 nova5 in Gazebo Fortress nova5 in MuJoCo nova5 in Isaac Sim / Lab
nova5_2f85 nova5_2f85 in RViz2 nova5_2f85 in Gazebo Fortress nova5_2f85 in MuJoCo nova5_2f85 in Isaac Sim / Lab

28/28 screenshots captured. Regenerate: see Screenshots.


Repository layout

All_Robot/
├── robots.yaml                 # registry: the one place that lists every robot
├── robots/<name>/
│   ├── urdf/<name>.urdf        # canonical URDF, package://cps_robot_description/... mesh URIs
│   ├── urdf/standalone/        # generated: relative mesh paths (Isaac Sim, MuJoCo, any non-ROS tool)
│   ├── urdf/isaac/             # generated: standalone + flattened meshes, input of isaaclab/convert_all.sh
│   ├── meshes/                 # DAE / STL  (+ meshes/flat/: generated STL of each DAE, see below)
│   ├── mjcf/<name>.xml, scene.xml   # generated MuJoCo model
│   └── usd/<name>.usd          # generated Isaac USD   (usd/legacy/ = old hand-made USDs)
├── envs/                       # conda envs: env_isaaclab, env_mujoco, env_ros_gz + setup.sh
├── docker/                     # one image per simulator + compose.yaml + run.sh
├── launch/                     # ROS 2: display, all_in_one (RViz2), gazebo (Fortress)
├── isaaclab/                   # Isaac Lab ArticulationCfg, URDF->USD conversion, spawn/check script
├── scripts/                    # normalize_urdf, build_assets, validate, migrate, screenshot_*, make_gallery
├── package.xml, CMakeLists.txt # repo root is the ROS 2 package `cps_robot_description`
└── docs/screenshots/<sim>/      # rviz, gazebo, mujoco, isaac  -> README gallery

Rule: edit only the canonical urdf/<name>.urdf and meshes/. Everything else is generated by scripts/build_assets.py or isaaclab/convert_all.sh.


0. Get the repo and pick a runtime

git clone https://github.com/Cyber-physical-Systems-Lab/All_Robot.git && cd All_Robot
Simulator Conda environment Docker image Needs
Isaac Sim 4.5 + Isaac Lab 2.1 env_isaaclab cps/isaaclab:4.5.0-2.1.0 Ubuntu 22.04, NVIDIA RTX GPU, driver ≥ 535
MuJoCo 3.x env_mujoco cps/mujoco:3 any CPU
ROS 2 Humble + Gazebo Fortress + RViz2 env_ros_gz (RoboStack) cps/ros_gz:humble-fortress any CPU

Conda setup. You need Miniconda; mamba is used automatically when it's installed. Each command can be re-run safely.

bash envs/setup.sh mujoco      # -> env_mujoco
bash envs/setup.sh ros_gz      # -> env_ros_gz  (also colcon-builds this package into ~/cps_ws)
bash envs/setup.sh isaaclab    # -> env_isaaclab (clones Isaac Lab v2.1.0 to ~/IsaacLab, ~25 GB)

Docker setup. You need Docker with Compose v2. Isaac also needs the NVIDIA Container Toolkit.

docker/run.sh build mujoco ros_gz isaaclab      # once; isaaclab pulls nvcr.io/nvidia/isaac-sim:4.5.0 (~20 GB)
docker/run.sh <mujoco|ros_gz|isaaclab> [cmd]    # repo is mounted, X11 + GPU forwarded

1. ROS 2 Humble · RViz2

# conda
conda activate env_ros_gz
ros2 launch cps_robot_description display.launch.py robot:=nova5_2f85
ros2 launch cps_robot_description display.launch.py robot:=mycobot_280_pi variant:=with_pump
ros2 launch cps_robot_description all_in_one.launch.py                 # all robots side by side

# docker
docker/run.sh ros_gz ros2 launch cps_robot_description display.launch.py robot:=go2

With a system ROS install instead, put the repo in a colcon workspace and run colcon build --packages-select cps_robot_description.

RViz2 multi-robot


2. Gazebo Fortress

# conda
conda activate env_ros_gz
ros2 launch cps_robot_description gazebo.launch.py robot:=nova5_2f85
ros2 launch cps_robot_description gazebo.launch.py robot:=go2

# docker
docker/run.sh ros_gz ros2 launch cps_robot_description gazebo.launch.py robot:=nova5_2f85
  • Arms (fixed_base: true) are welded to the world. Mobile robots spawn free at spawn_z.
  • The launch file sets IGN_GAZEBO_RESOURCE_PATH so that package://cps_robot_description/... resolves.
  • Every actuated joint gets a Gazebo JointPositionController that holds the start pose (init_joints in robots.yaml, else 0), so arms stay up and Go2 stands. Mimic joints are left free.
  • Command a joint from ROS: ros2 topic pub --once /nova5/joint3/cmd_pos std_msgs/msg/Float64 "{data: 1.0}" (topic /<robot>/<joint>/cmd_pos). Joint states come back on /joint_states, so robot_state_publisher follows the simulation.
  • Collision meshes are swapped for the flattened STLs in meshes/flat/: Gazebo's DART/ODE loader crashes on several of the Collada files (and on any OBJ). Visuals stay DAE.

3. MuJoCo 3.x

The MJCF files are generated from the canonical URDFs. DAE meshes are flattened to binary STL in robots/<r>/meshes/flat/, because MuJoCo can't read DAE (units and node transforms baked in, <up_axis> ignored like RViz does).

# conda
conda activate env_mujoco
python scripts/build_assets.py --mujoco                       # generate (all robots, or list names)
python -m mujoco.viewer --mjcf=robots/nova5_2f85/mjcf/scene.xml

# docker
docker/run.sh mujoco python scripts/build_assets.py --mujoco
docker/run.sh mujoco python -m mujoco.viewer --mjcf=robots/nova5_2f85/mjcf/scene.xml

What the generator adds:

  • A freejoint for mobile robots.
  • equality constraints for URDF <mimic> joints (grippers).
  • A position actuator on every joint (mimic joints excluded).
  • scene.xml, with a floor and a light.

Use robots/<r>/mjcf/<r>.xml with <include> in your own scenes.


4. Isaac Sim / Isaac Lab

Tested with Isaac Sim 4.5 + Isaac Lab 2.1 (the Docker image) and Isaac Sim 6.0 + current Isaac Lab (the 2026-11-05 screenshots). The generated USDs are committed, so you can skip convert_all.sh unless you change a URDF.

# conda  (envs/setup.sh set ISAACLAB_PATH and CPS_ROBOTS_PATH inside the env)
conda activate env_isaaclab
bash isaaclab/convert_all.sh                                   # robots/<r>/urdf/isaac/*.urdf -> robots/<r>/usd/<r>.usd
python isaaclab/spawn_robot.py --robot nova5_2f85              # view + wiggle joints
bash scripts/screenshot_isaac.sh                               # PASS/FAIL table + screenshots, one process per robot

# docker  (inside the container, Isaac Lab is at /workspace/isaaclab)
docker/run.sh isaaclab bash isaaclab/convert_all.sh
docker/run.sh isaaclab /workspace/isaaclab/isaaclab.sh -p isaaclab/spawn_robot.py --robot nova5_2f85

On its first start, Isaac Sim pulls extensions and compiles shaders, which takes about 10 minutes. With Docker, these are cached in named volumes.

Notes on the conversion:

  • convert_all.sh reads urdf/isaac/, made by python scripts/build_assets.py --isaac. It is the standalone URDF with every Collada mesh that uses <instance_node> (the Onshape-exported myCobot / myAGV parts) replaced by its flattened STL. Isaac's URDF importer drops those node transforms and would pile the parts onto the link origin.
  • Newer Isaac Lab converters write a folder (usd/<r>.usd/<urdf-stem>/<urdf-stem>.usda + payloads/) instead of one file. cps_robots_cfg.py accepts both.
  • Mimic joints (grippers) are never driven: the importer turns them into PhysX mimic constraints, and an actuator on them as well makes the solver produce NaNs.
  • Run several robots in separate processes (scripts/screenshot_isaac.sh does). In one process they leak state into each other.

Isaac Sim GUI only: go to File → Import and pick robots/<r>/urdf/standalone/<r>.urdf. Importer options:

  • Fix Base Link: on for arms.
  • Joint Drive: Position.
  • Merge Fixed Joints: off.

In your own Isaac Lab project:

import os, sys; sys.path.append(os.path.join(os.environ["CPS_ROBOTS_PATH"], "isaaclab"))
from cps_robots_cfg import make_cfg
robot_cfg = make_cfg("nova5_2f85").replace(prim_path="{ENV_REGEX_NS}/Robot")

make_cfg resolves the USD in this order:

  1. usd/<r>.usd (regenerated).
  2. usd/legacy/... (the old hand-made USD).
  3. For go2, Isaac Lab's built-in UNITREE_GO2_CFG.

The actuator gains are in ACTUATORS / GAINS in isaaclab/cps_robots_cfg.py. The start pose comes from init_joints in robots.yaml.


Validation

python scripts/validate.py -v               # static: tree, meshes exist, inertia, limits, no /home paths
python scripts/validate.py --mujoco         # in env_mujoco / docker mujoco
python scripts/validate.py --gazebo         # in env_ros_gz / docker ros_gz (runs `ign sdf -p`)
bash scripts/screenshot_isaac.sh                                # in env_isaaclab / docker isaaclab

A cell in the status table becomes ✅ only after a lab member has:

  1. Run the matching check.
  2. Opened the robot in the simulator and seen that the meshes are in the right place and the joints move the right way.

Write the simulator version and conda/Docker in the PR description.


Screenshots

The gallery above is generated, so don't paste images into the README by hand.

bash scripts/capture_all.sh                  # all four simulators via Docker, then refresh the gallery
bash scripts/capture_all.sh mujoco isaac     # a subset

Or, inside each conda environment:

Simulator Command (from the repo root) How it renders
RViz2 bash scripts/screenshot_ros.sh rviz (env_ros_gz) Xvfb virtual display
Gazebo bash scripts/screenshot_ros.sh gazebo (env_ros_gz) Xvfb + software OpenGL, GUI reduced to the 3D view
MuJoCo MUJOCO_GL=egl python scripts/screenshot_mujoco.py (env_mujoco) offscreen renderer
Isaac Sim / Lab bash scripts/screenshot_isaac.sh (env_isaaclab) RTX camera sensor

The ROS script needs the package built and sourced (colcon build in a workspace containing this repo). Then run python3 scripts/make_gallery.py and commit docs/screenshots/ together with README.md.

All four use 960×720 images, a 45° vertical field of view and the camera from robots.yaml, so the pictures line up.

From CI: every push uploads CPU-rendered RViz2, Gazebo and MuJoCo screenshots as a workflow artifact. To commit them instead (for example after changing a robot on a machine without the simulators), go to GitHub → Actions → validate-models → Run workflow and tick commit_screenshots. Isaac needs an RTX GPU, so capture it locally.

To change the framing of a robot, edit camera: in robots.yaml. All four simulators use it.


Adding a new robot

  1. Put the files in robots/<name>/meshes/ and robots/<name>/urdf/<name>.urdf.
  2. Add an entry to robots.yaml (copy an existing one).
  3. python scripts/normalize_urdf.py <name>: fixes mesh URIs and fills missing inertia and limits. Every change is listed.
  4. python scripts/build_assets.py --mujoco --isaac <name>, then bash isaaclab/convert_all.sh <name>.
  5. python scripts/validate.py -v <name>. Add a row to the status table above. CI checks the rest.
  6. Add a camera: entry in robots.yaml and capture screenshots (see Screenshots).

Known issues / TODO

  • Placeholder physics. These links had no <inertial>, so they got a placeholder mass from normalize_urdf.py, marked with an XML comment:

    • myAGV
    • myCobot 280 (all variants)
    • the mycomb arm

    Several joints also had effort="0" velocity="0" and were given the defaults from robots.yaml. See docs/normalize_report.md. Replace these with CAD or datasheet values before using the models for dynamics or RL.

  • myAGV is a visual shell with no wheels or drive.

  • DAE → STL flattening applies the Collada <unit> scale and node transforms, and ignores <up_axis> like RViz. The myCobot M5 meshes were tagged Y_UP although their coordinates are Z-up; they are now tagged Z_UP, so Isaac and RViz agree.

  • Large meshes (>10 MB DAE) slow down Gazebo and MuJoCo collision. Simplified collision meshes would help.

  • RTX 50-series GPUs need a PyTorch nightly build in env_isaaclab; see the note in envs/env_isaaclab.yml.


Acknowledgements

The meshes and URDFs come from, or are adapted from, the vendor and community sources below. Third-party assets keep their original licenses.

Robot Source
Go2 Unitree Robotics – unitree_ros/go2_description
myAGV Elephant Robotics, URDF adapted in-lab
myCobot 280 Pi / gripper elephantrobotics/mycobot_ros, mycobot_ros2, extended with camera flange and suction pump
Nova 5 Dobot-Arm/DOBOT_6Axis_ROS2_V3
Robotiq 2F-85 ros-industrial/robotiq
Composites (mycomb, nova5_2f85) Composed by Xuezhi Niu

If any asset is missing attribution, please open an issue.

License

MIT for this repository's own code and composed models (see LICENSE). Vendor meshes keep their original licenses.


HelloDog

About

Multi-robot visualization setup in ROS 2 Humble using RViz2 with namespaced URDFs and static transforms for spatial layout.

Topics

Resources

Stars

1 star

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages