ROS 2 Moveit 2 - Control a Robotic Arm

Install and set up ROS 2 Jesse on Ubuntu 24.04, install MoveIt 2 packages and essential tools, and prep for building a URDF for MoveIt.

Install and configure ROS 2 Jessie on Ubuntu 24.04, including locale setup, adding sources, installing the desktop package, and automating environment setup via bashrc and completion scripts.

install MoveIt 2 for ros2 by running a one-line command from MoveIt installation page's binary install section, set cyclone dds as the middleware via an env var, and update bashrc.

Install and configure vscode with the ros 2 robot developer extension and cmake, then use terminator for split terminals to support ros 2 moveit 2 and urdf workflows.

Create a urdf for a six-axis robotic arm with two links connected by a joint for Moveit configuration. Build a workspace and a description package to visualize the arm.

Create a ROS 2 workspace, set up a my_robot_description package with urdf, launch, and avis folders, and configure CMakeLists.txt to install these resources, then build the workspace in VS Code.

Create the base link in a URDF, add a box visual with geometry and origin, assign a gray material, and preview the model using a URDF tutorial visualization.

Learn to extend a URDF by adding a shoulder link and a revolute joint. Establish parent–child relations, proper origins, axis, limits, and visual alignment through a five-step, iterative process.

Complete the six-axis arm URDF by tackling the activity, using the provided base, shoulder, and six joint specifications. Build the robot from base to tool link with TF relations.

This activity guides building a six-axis robotic arm in ROS 2 MoveIt 2 from base to hand, using links, revolute and fixed joints, a tool interface, and URDF visualization.

Improve the six-axis robot arm URDF by adopting Zakuro to enable modular, scalable configuration with variables, macros, and file inclusion, moving from a single file to a multi-file, reusable setup.

Create a launch file to visualize robot with the robot state publisher and a joint state publisher GUI using urdf, and configure rviz to load model and tf for Moveit.

Configure a six-axis robot arm from its urdf by adding collision tags, then use the Moveit setup assistant to create a Moveit config package with motion and path planning.

Add collision elements in the urdf for moveit, pairing each link's collision with simple geometry and origin to enable efficient collision detection, while the visual remains for illustration.

Add collision tags for each robot link, using simplified boxes instead of cylinders, creating six collision elements to enable MoveIt 2 collision detection and validate in the workspace.

Configure a robotic arm using MoveIt Setup Assistant by loading a URDF, generating a collision matrix, creating a virtual joint named world, and defining a planning group and poses.

Explore the moveit 2 package structure for a robotic arm, reviewing config, launch, and urdf files, including initial positions, joint limits, ros2 control, and demo launches.

Build the workspace, launch the MoveIt demo, and fix configuration errors to enable motion planning, execution, and visualization of the robotic arm using OMPL and Cartesian paths.

Add a parallel gripper as the arm's end effector by extending urdf with gripper links, visuals, collisions, and joints, binding the gripper base to the arm while updating moveit configuration.

Design a gripper in a urdf by adding gripper base link, left and right finger links with prismatic joints, visuals and collisions, and a mimic constraint to synchronize fingers.

Attach a gripper to the robotic arm in the urdf by adding a fixed joint between the arm tool link and the gripper base link.

Configure the gripper with MoveIt by adding a gripper planning group and open, closed, and half‑closed poses, then plan and execute with velocity scaling and setup guidance.

Add the gripper to MoveIt config by creating a gripper planning group and end effector, regenerating the collision matrix, and configuring controllers for plan-and-execute testing of open and close poses.

Create a dedicated bringup package to launch the six-axis robotic arm with a gripper, centralizing launch files and controller configurations for your ROS MoveIt workflow and avoiding dependency loops.

Create the my_robot_bring_up package with launch and config folders, update cmake for installation, copy ros2 controllers YAML, and modify the main urdf to use ros2 control tags.

Start everything from the terminal by launching the robot state publisher, the controller manager, and each controller, then run the move group launch for motion planning with ompl.

Write a single launch file to start the robot state publisher and controller manager, configure move group controllers, and run ompl with an avis config to move the arm.

Construct and reuse a ROS 2 launch file to bring up a robotic arm with MoveIt, including the robot state publisher, controller manager, three controllers, and move group integration.

Explore using the Moveit c++ API to command a simulated robotic arm, building a command node as the brain of a ROS 2 application and preparing for real-world hardware control.

Learn to move a robotic arm with the MoveIt C++ API in ROS 2 by building a test package. Plan and execute named targets from code using a planning group.

Learn to send joint and pose goals in ros2 moveit2 using the c++ api, setting start and target states, planning, and executing with joint values and quaternions.

Explore how to use a cartesian path for a six-axis robotic arm by building pose waypoints, computing a trajectory, and executing when the full path is achievable.

Learn how to integrate the Moveit C++ API inside a ROS 2 node using composition, creating a commander class, and binding move group interfaces for the arm and gripper.

Develop private plan and execute methods for any move group interface and implement go to named, joint, and pose targets, including a cartesian path option, for a robotic arm.

Learn to add a ROS 2 MoveIt 2 commander topic subscriber to open and close the gripper via a boolean message, using a gripper move group interface.

Add subscribers for joint targets and pose targets to command a robotic arm in ros 2 moveit 2, using a six-value array and a pose of six doubles plus boolean.

Implement two topic subscribers for the joint target and post target in ROS 2 MoveIt 2, using the example interfaces float 64 multi array and a joint command callback.

Create a pose command topic with a custom interface for ros 2 moveit 2, including x, y, z, roll, pitch, yaw, and cartesian path, connected to the moveit commander.

Explore the Python API for ROS 2 MoveIt 2, compare it with the C++ API, and learn its limitations, benefits, and how to create a new myrobot commander package.

Install the MoveIt python API and create a python package to control the arm and gripper with ros2. Set start and goal states, plan, and execute the trajectory using ompl.

Implement joint and pose goals in python with moveit 2 using a robot state from a joint-values dictionary, converting Euler angles to a quaternion for a pose stamped.

Learn how to integrate a Python API inside an object-oriented ROS 2 node to control a robotic arm with MoveIt 2, including go-to targets, joint planning, and gripper operations.

Add topic subscribers to ros2 moveit 2 robotic arm controller to open and close the gripper, set joint targets, and publish pose commands.

Explore how the ROS 2 control part connects to hardware in a MoveIt 2 robotic arm project, bridging the robot state publisher and control.

This lecture offers a ros2_control recap and shows the hardware setup with the Excel 330 and open rb 150 board, detailing the read-update-write loop translating moveit commands into motor actions.

Overview of my_robot_hardware package explains its lightweight C++ driver, init, activate and deactivate hooks, and read/write position and velocity, plus a ROS 2 control hardware interface loaded as a plugin.

Learn to use the hardware interface in the urdf with ros2 control to connect a six-joint robotic arm and a mock gripper, using a plugin and dynamic hardware parameters.

Switch between the MOC component and the ARM hardware interface by adding a use_mock_component launch argument and passing it to the URDF, enabling easy toggle between mock and real hardware.

Build a MoveIt-enabled ROS 2 arm by defining a URDF with visual and collision tags, and use the MoveIt setup assistant to generate a config package and launch the stack.