URDF (Unified Robot Description Format)

A link element defines a rigid body segment of the robot, representing a single physical part like a chassis, wheel, or gripper finger. Each link contains properties describing its physical characteristics:

• Inertial: Mass and 3D inertia matrix, crucial for dynamic simulation.
• Visual: The 3D geometry (mesh or primitive) and material (color/texture) for rendering.
• Collision: A (often simplified) geometry used for physics engine contact calculations.

A joint element defines the kinematic connection between two links. It specifies the type of movement allowed and the relationship between the parent and child links. Key attributes include:

• Type: continuous (unlimited rotation), revolute (limited rotation), prismatic (linear slide), fixed (no movement), floating, or planar.
• Axis: The vector (x, y, z) around or along which movement occurs.
• Origin: The transform from the parent link's frame to the child link's frame.
• Limits: For revolute and prismatic joints, the lower and upper bounds of motion.

A URDF model must form a kinematic tree, a connected graph with no closed loops. This means every link (except the root) has exactly one parent joint. The tree structure is defined by the parent and child attributes within each joint. The base link is the root of this tree. While URDF itself does not support parallel mechanisms or closed chains, they can be approximated using fixed joints or require extensions like SDF.

URDF separates the concepts of how a robot looks from how it physically interacts.

• Visual Geometry: Used for graphical rendering (e.g., in RViz). Can be high-detail meshes (.stl, .dae) for realism.
• Collision Geometry: Used by the physics engine (e.g., in Gazebo). Should be simplified primitives (boxes, cylinders, spheres) or convex hulls for faster and more stable simulation. The collision geometry is often a less detailed approximation of the visual mesh.

The inertial tag within a link is mandatory for accurate dynamic simulation. It defines:

• Mass: In kilograms.
• Origin: The center of mass for the link.
• Inertia: A 3x3 rotational inertia matrix (often diagonal: ixx, iyy, izz, ixy, ixz, iyz). Incorrect or missing inertial properties will cause simulation to behave unrealistically or fail. For simple shapes, these can be calculated analytically; for complex meshes, tools can compute approximations.

While URDF is foundational, it has known limitations addressed by other formats and tools:

• No Sensors: URDF describes structure, not sensors. Sensors are added in simulation worlds (SDF) or via ROS plugins.
• No Closed Loops: Cannot natively describe parallel mechanisms (e.g., a Stewart platform).
• Static Description: Cannot change parameters at runtime.
• Xacro (XML Macros): A macro language used to create modular, reusable, and parameterized URDF files, enabling programmatic generation of robot descriptions.
• SDF: The Simulation Description Format is a more feature-rich successor used in Gazebo, supporting nested models, loops, and plugins.

URDF provides the complete kinematic tree required for real-time state estimation and control. Robotics libraries like KDL (Kinematics and Dynamics Library) parse URDF to:

• Compute forward kinematics to determine end-effector pose from joint angles.
• Calculate inverse kinematics solutions for motion planning.
• Derive the Jacobian matrix for velocity control and singularity analysis.
• Build the dynamic model for model-based controllers like computed-torque control. The precise specification of link relationships and joint axes is critical for these calculations.

URDF serves as a single source of truth for a robot's physical parameters across all software modules. This ensures consistency between:

• The move_group node in MoveIt for motion planning.
• The robot_state_publisher node, which broadcasts the transform (TF) tree describing the relationship of all robot links.
• Localization and perception pipelines that need to know sensor mounting positions.
• Controller managers that send commands to specific joints. This eliminates configuration drift and manual parameter duplication.

As a standardized, human-readable XML format, URDF facilitates the sharing and reuse of robot models across the global ROS community. Key benefits include:

• Public repositories like the ROS wiki host URDFs for common robots (e.g., PR2, TurtleBot, Universal Robots arms).
• Enables benchmarking and algorithm comparison on identical simulated robot models.
• Provides a common interface for tooling; converters exist to translate URDF into formats for MuJoCo, PyBullet, and Webots.
• Simplifies the process of modeling custom robots for research and development.

Inverse Kinematics (IK) is the computational process of calculating the joint angles or positions required for a robotic manipulator's end-effector to achieve a desired position and orientation in space. It relies directly on the kinematic chain defined in a URDF.

• Dependency on URDF: IK solvers (e.g., KDL, TRAC-IK) use the <joint> types (revolute, prismatic), <axis> vectors, and the <link> transform tree specified in the URDF to model the robot's kinematic structure.
• Motion Planning Foundation: IK is a critical subroutine within broader motion planning pipelines, translating high-level Cartesian goals into feasible joint-level commands for the robot described by the URDF.

In robotics, middleware is a software layer that provides common communication services, data management, and hardware abstraction, enabling the integration of modular software components. URDF acts as a key data standard within this layer.

• Abstraction Role: URDF abstracts the robot's physical description from the application code. Control, planning, and perception nodes interact with a standardized robot model, not proprietary hardware APIs.
• ROS 2 & DDS: Modern middleware like ROS 2 uses the Data Distribution Service (DDS) for communication but retains URDF (and its successor, URDF in XML combined with <xacro> macros) as the standard robot description format, shared via topics like /robot_description.

Xacro (XML Macros) is an XML macro language used to create more manageable and reusable URDF files. It allows developers to avoid repetitive XML code, use variables, and employ simple programming constructs.

• Code Reuse: Enables the definition of reusable components (like a wheel assembly) and instantiate them multiple times with parameters.
• Variables and Math: Constants (e.g., wheel radius) can be defined as properties, and mathematical expressions can be used within attribute values.
• Preprocessing: A .xacro file is processed by the xacro tool to generate a plain, expanded .urdf XML file, which is then consumed by ROS tools and simulators. It is the de facto standard for writing maintainable robot descriptions.