MoveIt: Concept

MoveIt (previously MoveIt!) is a very popular, and probably the most popular, ROS package for motion planning, particularly motion planning of manipulators. Although MoveIt is commonly used for manipulators, it is sometimes used for other robot types, including unmanned aerial vehicles (UAV). For example:

• https://www.wilselby.com/research/ros-integration/3d-mapping-navigation/ and https://github.com/wilselby/ROS_quadrotor_simulator
• https://github.com/tahsinkose/hector-moveit
• https://www.theconstructsim.com/robotigniteacademy_learnros-3/ros-courses-library/ros-courses-programming-drones-ros/

The concept of MoveIt can be found here: https://moveit.ros.org/documentation/concepts/. The main purpose of MoveIt is actually motion planning with obstacle avoidance. The obstacle avoidance here includes avoiding collision with the robot’s body (self-collision) and avoiding collision with the environment.

The high-level architecture of MoveIt can be seen in the following figure:

It can be seen in the figure that the main components of MoveIt are the following:

• Interface to the user
• move_group node
• Interface to the robot controller: which uses JointTrajcetoryAction (FollowJointTrajectoryAction).
• Planning Scene: which describes the current state of the robot and the environment representation (occupancy map of the environment).
• Motion Planner and Collision Checking: which plans the feasible planning trajectory (not just path) subject to collision avoidance.

Other ROS packages required by MoveIt (but not part of MoveIt) include:

• URDF package: which serves as the base of kinematics, tf/tf2, and SRDF. In fact, the URDF package is included in the ROS core packages.
• Kinematics package (not shown in the figure above): which solves the kinematics of the robot. The KDL kinematics package is included by default.
• ros_control and friends (particularly the joint_state_controller and joint_trajectory_action controller in ros_controller).
• Occupancy map package
• Motion planner package

How the “move_group” node is using the other components can be seen in the following figure:

It can be seen that the “move_group” node can interface with the user by using any of the following user interfaces:

• move_group_interface (written in C++)
• moveit_commander (written in Python)
• RViz GUI (Motion Planning pallet)

The “move_group” node interacts with the user interface through:

• actions (indicated by the red lines on the left side)
• services (indicated by the blue lines on the left side)
• user setup inputs (indicated by the green lines on the left side)

The “move_group” node is configured based on:

• robot URDF (taken from the “robot_description” parameter)
• robot SRDF
• configuration files

Both the SRDF and configuration files can be conveniently created by using the GUI-based MoveIt Setup Assistant. This GUI-based tool will create the robot SRDF and the required configuration files. After the completion of MoveIt Setup Assistant, one may still need to modify some of the configuration files created by the tool.

The “move_group” node interacts with ros_control through JointTrajectoryAction (one of the controllers in ros_controller). It gets the joints’ states from the joint_state_controller, gets the transforms of all the robot links from the robot_state_publisher and tf/tf2, and gives the control commands to the joint_trajectory_action controller.

The “move_group” node also receive the information about the information through topics published by sensors, such as 3D pointcloud topic and depth image topic. The 3D perception in MoveIt is handled by the “occupancy map monitor” which uses Octomap to maintain the occupancy map of the environment. Currently, MoveIt has two inbuilt occupancy map updaters to handle the following data inputs:

• Point clouds: handled by the point cloud occupancy map updater plugin
• Depth images: handled by the depth image occupancy map updater plugin

Modularity in MoveIt

MoveIt is extensible due to its modular architecture which incorporate the inclusion of plugins, such as:

• The kinematics in MoveIt can be handled by a kinematics plugin. The default kinematics solver in Moveit is KDL. But one can also use other kinematics solvers, such as IKFast and TRAC-IK.
• The motion planner in MoveIt can be handled by a motion planner plugin. The default motion planner in MoveIt is OMPL. However, one may also use other planners such as the Pilz industrial motion planner, CHOMP, and STOMP.

The official documentation on the plugin interfaces can be found here: https://moveit.ros.org/documentation/plugins/

Official MoveIt Webpages

• Main page: https://moveit.ros.org/
• MoveIt tutorial for ROS Melodic: http://docs.ros.org/en/melodic/api/moveit_tutorials/html/index.html