MoveIt 2: Arm Motion Planning on ROS 2

MoveIt

MoveIt is the most widely used open-source motion planning framework for robot arms and mobile manipulators. Built on ROS 2 (MoveIt 2), it combines robot models, collision checking, inverse kinematics, motion planners, trajectory processing, and execution into a pipeline: describe the robot and its environment, ask for a goal pose or joint configuration, receive a collision-free, time-parameterized trajectory, and execute it on real or simulated controllers.

Most of the effort in a MoveIt deployment goes into configuration: an accurate robot description, sensible collision geometry, joint limits that match the hardware, kinematics solvers that converge reliably, and a planning scene that reflects the real workcell. With those in place, application code can be short.

TL;DR

Describe the robot in URDF (links, joints, geometry) and SRDF (planning groups, end effectors, disabled collisions); generate configs with the Setup Assistant.
Keep the planning scene accurate: robot state, attached objects, and collision objects from CAD or perception.
Choose kinematics solvers (KDL, TRAC-IK, pick_ik) and planning pipelines (OMPL for general sampling, Pilz for industrial LIN/PTP/CIRC moves, STOMP/CHOMP for optimization).
Time-parameterize trajectories within joint velocity and acceleration limits; set limits from the hardware, not defaults.
Execute through ros2_control controllers with execution monitoring; use MoveIt Servo for real-time teleoperation and visual servoing.
Validate plans in simulation and with conservative speeds before running at full speed near people.

Quick Example

Planning and executing a pose goal with the MoveIt 2 Python API (moveit_py), as in the official tutorials for a Franka Panda arm:

Joint limits used for time parameterization (joint_limits.yaml), set from the robot's datasheet:

Python API details differ slightly between ROS 2 distributions; follow the tutorial for your release.

Core Concepts

Robot Description

URDF defines links, joints, limits, visual meshes, and collision geometry — use simplified collision shapes to keep checks fast.
SRDF defines planning groups (for example arm, gripper), end effectors, named poses such as "home," and an allowed collision matrix that disables checks between links that never collide or always touch.
The MoveIt Setup Assistant generates SRDF, kinematics, joint limits, controller, and launch configurations.

See Robot Kinematics and Dynamics.

Planning Scene

The planning scene holds the robot's current state and the world: tables, bins, fixtures (from CAD), objects detected by perception, an octomap from depth sensors, and objects attached to the gripper so they move with the arm and are collision-checked. An outdated scene is the main source of collisions in "planned" motions.

Kinematics

Inverse kinematics plugins compute joint values for Cartesian goals: KDL (general, numerical), TRAC-IK (more reliable convergence), pick_ik (flexible cost-based), or analytic solvers such as IKFast for specific arms. Redundant 7-DOF arms have infinitely many solutions; constraints and seeds affect which is chosen.

Planning Pipelines

Planning requests can include constraints (keep a cup upright, stay within a region) and multiple goal options. MoveIt Task Constructor composes multi-stage tasks such as pick and place. See Robot Motion Planning.

Time Parameterization and Execution

Planners return geometric paths; time-optimal trajectory generation (and optional Ruckig jerk-limited smoothing) assigns timing within joint limits. The trajectory execution manager sends trajectories to ros2_control controllers (such as the joint trajectory controller), monitors execution against tolerances, and aborts on deviation. MoveIt Servo streams real-time commands for teleoperation and reactive control with collision checking and singularity handling. See Feedback Control Systems.

Best Practices

Invest in Collision Geometry

Use simplified, slightly padded collision shapes and a tuned allowed collision matrix for fast, safe checks.

Keep the Scene Current

Load fixtures from CAD, update dynamic objects from perception, and attach grasped objects to the gripper.

Use Real Limits and Scaling

Set velocity and acceleration limits from hardware specs and start with reduced scaling factors in new cells.

Validate in Simulation First

Run motions against a simulated robot and scene, ideally in Gazebo with ros2_control, before hardware. See Robot Simulation and Validation.

Common Mistakes

Detailed Meshes for Collision

Forgetting Attached Objects

Default Joint Limits

FAQ

What is MoveIt used for?

Planning and executing collision-free motions for robot arms and mobile manipulators: pick and place, assembly, inspection, and teleoperation, on real or simulated robots running ROS 2.

What is the difference between URDF and SRDF?

URDF describes the robot's physical structure — links, joints, geometry, and limits. SRDF adds semantic information for planning — planning groups, end effectors, named poses, and disabled collision pairs.

Which planner should I use in MoveIt?

OMPL's RRT-Connect is a good general default; Pilz is useful for predictable industrial point-to-point and linear moves; optimization planners produce smoother paths when needed.

What is the planning scene?

MoveIt's representation of the robot's current state and its environment, including collision objects, attached objects, and sensor-derived occupancy, used for collision checking.

What is MoveIt Servo?

A real-time controller interface that converts streaming velocity or pose commands into joint commands with collision and singularity checks, used for teleoperation and reactive behaviors.