MoveIt framework overview in ROS - Mini Project: Build & Apply

MoveIt Framework Overview

📖 Scenario: You are working on a robot arm project and want to use MoveIt to plan and control the robot's movements.MoveIt is a popular framework in ROS (Robot Operating System) that helps with motion planning, kinematics, and robot control.

🎯 Goal: Build a simple ROS node setup that initializes MoveIt with a robot description, sets up a planning scene, and plans a motion to a target pose.

📋 What You'll Learn

Create a ROS node that loads the robot description parameter

Set up a MoveIt planning interface for the robot

Define a target pose for the robot's end effector

Plan a motion to the target pose using MoveIt

💡 Why This Matters

🌍 Real World

MoveIt is widely used in robotics to plan and control robot arms for tasks like assembly, pick-and-place, and inspection.

💼 Career

Understanding MoveIt is essential for robotics engineers working with ROS to develop robot motion planning and control applications.

1

Load Robot Description Parameter

Create a ROS node in Python called moveit_demo and load the robot description parameter from /robot_description into a variable called robot_description.

ROS

# Your code here to create ROS node and load robot description

Hint

Use get_parameter('robot_description') inside your node class to get the robot description.

2

Set Up MoveIt Planning Interface

Inside the MoveItDemo class, create a MoveIt planning interface object called move_group for the group named 'arm'.

ROS

import rclpy
from rclpy.node import Node

class MoveItDemo(Node):
    def __init__(self):
        super().__init__('moveit_demo')
        self.robot_description = self.get_parameter('robot_description').get_parameter_value().string_value
        # Create move_group for 'arm'
        # Your code here

def main(args=None):
    rclpy.init(args=args)
    node = MoveItDemo()
    rclpy.spin(node)
    rclpy.shutdown()

Hint

Use MoveGroupCommander('arm') to create the planning interface.

3

Define Target Pose

Inside the MoveItDemo class, define a target pose variable called target_pose as a dictionary with keys 'position' and 'orientation'. Set position to {'x': 0.4, 'y': 0.1, 'z': 0.4} and orientation to {'x': 0.0, 'y': 0.0, 'z': 0.0, 'w': 1.0}.

ROS

import rclpy
from rclpy.node import Node
from moveit_commander.move_group import MoveGroupCommander

class MoveItDemo(Node):
    def __init__(self):
        super().__init__('moveit_demo')
        self.robot_description = self.get_parameter('robot_description').get_parameter_value().string_value
        self.move_group = MoveGroupCommander('arm')
        # Define target_pose dictionary
        # Your code here

def main(args=None):
    rclpy.init(args=args)
    node = MoveItDemo()
    rclpy.spin(node)
    rclpy.shutdown()

Hint

Use a dictionary with keys 'position' and 'orientation' and set the exact values.

4

Plan Motion to Target Pose

Use the move_group object to set the pose target using set_pose_target() with self.target_pose, then call plan() to create a motion plan. Store the result in a variable called plan.

ROS

import rclpy
from rclpy.node import Node
from moveit_commander.move_group import MoveGroupCommander

class MoveItDemo(Node):
    def __init__(self):
        super().__init__('moveit_demo')
        self.robot_description = self.get_parameter('robot_description').get_parameter_value().string_value
        self.move_group = MoveGroupCommander('arm')
        self.target_pose = {
            'position': {'x': 0.4, 'y': 0.1, 'z': 0.4},
            'orientation': {'x': 0.0, 'y': 0.0, 'z': 0.0, 'w': 1.0}
        }
        # Set pose target and plan motion
        # Your code here

def main(args=None):
    rclpy.init(args=args)
    node = MoveItDemo()
    rclpy.spin(node)
    rclpy.shutdown()

Hint

Create a Pose message from self.target_pose, set it as the pose target, then call plan().

Practice

1. What is the main purpose of the MoveIt framework in ROS?

easy

A. To help robots plan and move their arms safely

B. To control robot sensors and cameras

C. To manage robot battery and power levels

D. To handle robot communication protocols

Solution

1. Step 1: Understand MoveIt's role in ROS

   MoveIt is designed to help robots plan and execute arm movements safely and efficiently.

2. Step 2: Compare options with MoveIt's purpose

   The other options relate to sensors, power, and communication, which are not MoveIt's focus.

3. Final Answer:

   To help robots plan and move their arms safely -> Option A

4. Quick Check:

   MoveIt = arm planning and safe movement [OK]

Hint: Remember MoveIt is about arm movement planning [OK]

Common Mistakes:

• Confusing MoveIt with sensor or power management
• Thinking MoveIt handles communication protocols
• Assuming MoveIt controls the whole robot

2. Which of the following is the correct way to define a MoveIt planning group named "gripper" in a ROS configuration?

easy

A.

B.

C.

D. arm

Solution

1. Step 1: Identify correct XML tag for MoveIt groups

   MoveIt uses the <group> tag with a name attribute to define planning groups such as 'gripper'.

2. Step 2: Check options for valid syntax

   <group name="gripper" /> correctly uses the proper syntax and name. <group name="arm" /> has the correct tag format but wrong name value. <moveit_group name="arm" /> and <planning_group>arm</planning_group> use incorrect tags and structure.

3. Final Answer:

   <group name="gripper" /> -> Option B

4. Quick Check:

   MoveIt groups use <group name="..." /> [OK]

Hint: Look for syntax in MoveIt configs [OK]

Common Mistakes:

• Using incorrect XML tags like <planning_group>
• Confusing group names with tags
• Missing the name attribute in group tag

3. Given the following MoveIt code snippet, what will be the output if the goal pose is reachable?

move_group.setPoseTarget(goal_pose);
bool success = (move_group.plan(my_plan) == moveit::planning_interface::MoveItErrorCode::SUCCESS);
std::cout << "Planning success: " << success << std::endl;

medium

A. Planning success: false

B. Planning success: 0

C. Planning success: 1

D. Planning success: true

Solution

1. Step 1: Understand the return type of plan()

   The plan() function returns a MoveItErrorCode. Comparing it to SUCCESS returns true or false, which converts to 1 or 0 when printed as an integer.

2. Step 2: Check output of std::cout for bool

   std::cout prints bool as 1 for true and 0 for false by default, so if the goal is reachable, success is true, printed as 1.

3. Final Answer:

   Planning success: 1 -> Option C

4. Quick Check:

   Bool true prints as 1 in std::cout [OK]

Hint: Bool prints as 1 or 0 in C++ std::cout [OK]

Common Mistakes:

• Expecting 'true' or 'false' strings instead of 1 or 0
• Confusing success variable type
• Assuming plan() returns a boolean directly

4. You wrote this MoveIt code but the robot arm does not move:

move_group.setPoseTarget(goal_pose);
move_group.move();

What is the most likely reason?

medium

A. You forgot to call move_group.plan() before move()

B. move() does not execute the planned motion

C. You need to call move_group.stop() before move()

D. The goal_pose is not set correctly or unreachable

Solution

1. Step 1: Understand move_group.move() behavior

   move() plans and executes the motion internally, so calling plan() first is not required.

2. Step 2: Check common reasons for no movement

   If the goal_pose is invalid or unreachable, the robot will not move despite calling move().

3. Final Answer:

   The goal_pose is not set correctly or unreachable -> Option D

4. Quick Check:

   Invalid goal_pose stops movement [OK]

Hint: Check if goal pose is valid and reachable first [OK]

Common Mistakes:

• Thinking plan() must be called before move()
• Assuming move() only executes without planning
• Calling stop() unnecessarily before move()

5. You want to control both the robot arm and gripper using MoveIt. How should you organize your MoveIt configuration to plan motions for both parts together?

hard

A. Create a single planning group including both arm and gripper joints

B. Use separate planning groups and plan motions independently

C. Control the gripper manually outside MoveIt and plan only the arm

D. Use a custom plugin to merge arm and gripper groups at runtime

Solution

1. Step 1: Understand MoveIt planning groups

   Planning groups define which joints MoveIt controls together. To move arm and gripper simultaneously, they must be in one group.

2. Step 2: Compare options for combined control

   Create a single planning group including both arm and gripper joints enables coordinated planning. Using separate planning groups and planning motions independently or controlling the gripper manually outside MoveIt may cause uncoordinated motions. Using a custom plugin to merge arm and gripper groups at runtime is complex and unnecessary for typical use.

3. Final Answer:

   Create a single planning group including both arm and gripper joints -> Option A

4. Quick Check:

   One group controls multiple parts together [OK]

Hint: Combine joints in one group for coordinated moves [OK]

Common Mistakes:

• Planning arm and gripper separately causing conflicts
• Trying manual control instead of MoveIt planning
• Overcomplicating with custom plugins unnecessarily