Mobile Robot URDF Maker (V4)

Mobile Robot URDF Maker is a ROS 2 desktop application that automates the creation of a complete, simulation-ready URDF for your mobile robot — through a guided PyQt5 wizard, with no hand-written XML required. V4 adds six selectable ros2_control controllers, a dynamic multi-sensor system, a Controller Tuner, hardware-interface selection, and built-in teleoperation — so you can pick a chassis, tune the kinematics, add sensors, and drive the robot live in Gazebo, all from one window.

The app walks you through building a mobile-robot description step by step: pick a chassis type, choose a controller, set dimensions, add as many lidars and cameras as you like, tune the controller, then simulate and drive. The result is a clean .urdf and a re-editable .urdf.xacro, plus matching controller configuration, ready to drop into your own stack.

• Supported platforms: ROS 2 Humble (Ubuntu 22.04) and ROS 2 Jazzy (Ubuntu 24.04) — the same codebase auto-adapts to whichever you build/source.
• Simulator: Gazebo Harmonic (gz sim 8) via gz_ros2_control.
• GUI: PyQt5 with a live OpenGL 3D preview.

One codebase, both distros. The app detects $ROS_DISTRO at runtime and adjusts the parts that differ between distributions — chiefly the controller command interface (Humble/Iron use unstamped Twist; Jazzy+ use TwistStamped). The detected environment is shown on the Start Project page. You don’t pick a distro in the app; it follows the environment you sourced.

What’s New in V4

• Six Selectable Controllers: Differential, skid-steer differential, mecanum, tricycle, tricycle-steering and Ackermann — each backed by a real ros2_control plugin, and only the controllers valid for the chosen chassis are offered.
• Dynamic Multi-Sensor System: Add any number of lidars and cameras, each fully configurable, with a live 3D preview and an auto-generated Gazebo bridge.
• Controller Tuner: Edit publish/update rates, command timeout, velocity/acceleration and steering limits — or fill them with physics-based Auto-suggest values.
• Hardware-Interface Selection: Gazebo simulation, mock hardware, or your own custom ros2_control plugin, injected directly into the generated URDF.
• Built-in Teleoperation: Launch the simulation and drive with an on-screen D-pad or the keyboard — no extra terminals needed.
• Presets & Sessions: Save/load chassis+sensor presets, or snapshot the entire wizard state (including manual URDF edits) and resume later.
• Dual Output: Every build produces both a flattened mobRob.urdf and a re-editable mobRob.urdf.xacro, and the 2-wheeled + caster now uses a 3-DOF free joint.

Key Features

• 🧭 Guided 9-Step Wizard: A side navigation bar lets you go forward, jump back, and revisit any completed step.
• 🤖 Three Chassis Families, Six Controllers: Differential, mecanum, tricycle, tricycle-steering and Ackermann.
• 🛞 Geometry-Driven Kinematics: Wheel separation, wheelbase, track and the mecanum projection term are computed from the dimensions you enter and written straight into the controller YAML.
• 🎛️ Controller Tuner: Motion and steering limits, with physics-based Auto-suggest.
• 🔌 Selectable Hardware Interface: Gazebo, mock hardware, or a custom plugin.
• 📡 Dynamic Multi-Sensor System: Any number of lidars and cameras, live in the 3D preview, auto-bridged from Gazebo to ROS 2.
• 🕹️ Built-in Teleoperation: On-screen D-pad or keyboard (WASD / arrows, diagonals, strafe).
• 💾 Presets & Sessions: Reusable presets and full-state session snapshots.
• 🧊 Dual Output: Both mobRob.urdf and mobRob.urdf.xacro.

Code Structure

Mobile_Robot_URDF_Maker/
├── src/
│   ├── mobRobURDF_wizard/                          # PyQt5 wizard application (main entry point)
│   │   ├── mobRobURDF_wizard/
│   │   │   ├── RobotWizard.py                       # Main wizard: navigation sidebar, page orchestration
│   │   │   ├── classes/
│   │   │   │   ├── OpenGLWidget.py                  # Live OpenGL 3D robot preview
│   │   │   │   ├── URDFManager.py                   # URDF / xacro generation and flattening
│   │   │   │   ├── launch_manager.py                # Launches the Gazebo + RViz simulation
│   │   │   │   ├── sensor_config.py                 # Dynamic sensor model (lidars + cameras)
│   │   │   │   ├── SensorEditor.py                  # Per-sensor configuration cards
│   │   │   │   ├── cards.py                         # Robot / controller selection cards
│   │   │   │   ├── responsive_widgets.py            # Responsive buttons and layouts
│   │   │   │   └── pages/
│   │   │   │       ├── WelcomePage.py
│   │   │   │       ├── StartSessionPage.py          # New project / load saved session
│   │   │   │       ├── RobotTypeSelectionPage.py    # Choose chassis family
│   │   │   │       ├── ControlConfigurationPage.py  # Pick a compatible controller
│   │   │   │       ├── ConfigurationPage.py         # Dimensions, sensors, 3D preview
│   │   │   │       ├── ControllerTunerPage.py       # Limits + hardware interface + Auto-suggest
│   │   │   │       ├── FinalCheckPage.py            # Review / edit URDF, save session
│   │   │   │       ├── TeleoperationPage.py         # Launch the sim and drive
│   │   │   │       └── FutureFeaturesPage.py
│   │   │   └── utils/
│   │   │       ├── presets.py                       # Preset + session save / load
│   │   │       ├── style.py                         # Stylesheet
│   │   │       └── utils.py
│   │   └── images/                                  # Wizard imagery (robot types, controllers, future)
│   ├── mobRobURDF_description/                      # Xacro templates, macros, Gazebo files, generated URDF
│   │   └── urdf/
│   │       ├── mobRob.urdf                          # Generated flattened URDF
│   │       ├── mobRob.urdf.xacro                    # Generated re-editable xacro
│   │       ├── submodules/                          # 2_wheeled_caster / 3_wheeled / 4_wheeled
│   │       ├── macros/                              # inertial + material macros
│   │       └── gazebo_files/                        # gazebo properties, colors, sensors, control
│   ├── mobRobURDF_control/                          # Per-controller ros2_control YAML configs
│   │   └── config/
│   │       ├── drive/                               # diff-drive (2WC, 4WD), mecanum
│   │       ├── steer/                               # tricycle-steering, Ackermann
│   │       └── gazebo_controller_tricycle.yaml
│   ├── mobRobURDF_gazebo/                           # Gazebo worlds, bridge config, use_sim_time
│   │   ├── worlds/                                  # empty_world.sdf, warehouse_world.sdf
│   │   └── config/                                  # gz_bridge.yaml, use_sim_time.yaml
│   ├── mobRobURDF_launch/                           # Launch files + cmd_vel_relay node
│   │   ├── launch/                                  # gazebo_test, urdf_test, slam_launch, nav_launch
│   │   └── mobRobURDF_launch/                       # cmd_vel_relay.py, ros_compat.py
│   ├── mobRobURDF_navigation/                       # Nav2 / SLAM configs and maps (upcoming features)
│   └── gz_ros2_control/                             # Vendored gz_ros2_control plugin (Harmonic)
├── LICENSE
└── README.md

Note: The vendored gz_ros2_control is included unmodified under its original Apache 2.0 licence to provide Gazebo Harmonic support on ROS 2 Humble (where the apt package targets Fortress). On Jazzy the apt package is already Harmonic, so the vendored copy must be excluded from the build with COLCON_IGNORE.

Supported Robots and Controllers

File truncated at 100 lines see the full file