Mastering ROS for Robotics Programming

Table of Contents

Mastering ROS for Robotics Programming

Credits

About the Author

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers, and more

Why subscribe?

Free access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

1. Introduction to ROS and Its Package Management

Why should we learn ROS?

Why we prefer ROS for robots

Why some do not prefer ROS for robots

Understanding the ROS file system level

ROS packages

ROS meta packages

ROS messages

The ROS services

Understanding the ROS computation graph level

Understanding ROS nodes

ROS messages

ROS topics

ROS services

ROS bags

Understanding ROS Master

Using the ROS parameter

Understanding ROS community level

What are the prerequisites to start with ROS?

Running ROS Master and ROS parameter server

Checking the roscore command output

Creating a ROS package

Working with ROS topics

Creating ROS nodes

Building the nodes

Adding custom msg and srv files

Working with ROS services

Working with ROS actionlib

Creating the ROS action server

Creating the ROS action client

Building the ROS action server and client

Creating launch files

Applications of topics, services, and actionlib

Maintaining the ROS package

Releasing your ROS package

Preparing the ROS package for the release

Releasing our package

Creating a Wiki page for your ROS package

Questions

Summary

2. Working with 3D Robot Modeling in ROS

ROS packages for robot modeling

Understanding robot modeling using URDF

Creating the ROS package for the robot description

Creating our first URDF model

Explaining the URDF file

Visualizing the robot 3D model in RViz

Interacting with pan and tilt joints

Adding physical and collision properties to a URDF model

Understanding robot modeling using xacro

Using properties

Using the math expression

Using macros

Conversion of xacro to URDF

Creating the robot description for a seven DOF robot manipulator

Arm specification

Type of joints

Explaining the xacro model of seven DOF arm

Using constants

Using macros

Including other xacro files

Using meshes in the link

Working with the robot gripper

Viewing the seven DOF arm in RViz

Understanding joint state publisher

Understanding the robot state publisher

Creating a robot model for the differential drive mobile robot

Questions

Summary

3. Simulating Robots Using ROS and Gazebo

Simulating the robotic arm using Gazebo and ROS

The Robotic arm simulation model for Gazebo

Adding colors and textures to the Gazebo robot model

Adding transmission tags to actuate the model

Adding the gazebo_ros_control plugin

Adding a 3D vision sensor to Gazebo

Simulating the robotic arm with Xtion Pro

Visualizing the 3D sensor data

Moving robot joints using ROS controllers in Gazebo

Understanding the ros_control packages

Different types of ROS controllers and hardware interfaces

How the ROS controller interacts with Gazebo

Interfacing joint state controllers and joint position controllers to the arm

Launching the ROS controllers with Gazebo

Moving the robot joints

Simulating a differential wheeled robot in Gazebo

Adding the laser scanner to Gazebo

Moving the mobile robot in Gazebo

Adding joint state publishers in the launch file

Adding the ROS teleop node

Questions

Summary

4. Using the ROS MoveIt! and Navigation Stack

Installing MoveIt!

MoveIt! architecture

The move_group node

Motion planning using MoveIt!

Motion planning request adapters

MoveIt! planning scene

MoveIt! kinematics handling

MoveIt! collision checking

Generating MoveIt! configuration package using Setup Assistant tool

Step 1 – Launching the Setup Assistant tool

Step 2 – Generating the Self-Collision matrix

Step 3 – Adding virtual joints

Step 4 – Adding planning groups

Step 5 – Adding the robot poses

Step 6 – Setup the robot end effector

Step 7 – Adding passive joints

Step 8 – Generating configuration files

Motion planning of robot in RViz using MoveIt! configuration package

Using the RViz MotionPlanning plugin

Interfacing the MoveIt! configuration package to Gazebo

Step 1 – Writing the controller configuration file for MoveIt!

Step 2 – Creating the controller launch files

Step 3 – Creating the controller configuration file for Gazebo

Step 4 – Creating the launch file for Gazebo trajectory controllers

Step 5 – Debugging the Gazebo- MoveIt! interface

Understanding ROS Navigation stack

ROS Navigation hardware requirements

Working with Navigation packages

Understanding the move_base node

Working of Navigation stack

Localizing on the map

Sending a goal and path planning

Collision recovery behavior

Sending the command velocity

Installing ROS Navigation stack

Building a map using SLAM

Creating a launch file for gmapping

Running SLAM on the differential drive robot

Implementing autonomous navigation using AMCL and a static map

Creating an AMCL launch file

Questions

Summary

5. Working with Pluginlib, Nodelets, and Gazebo Plugins

Understanding pluginlib

Creating plugins for the calculator application using pluginlib

Working with pluginlib_calculator package

Step 1 – Creating calculator_base header file

Step 2 – Creating calculator_plugins header file

Step 3 – Exporting plugins using calculator_plugins.cpp

Step 4 – Implementing plugin loader using calculator_loader.cpp

Step 5 – Creating plugin description file: calculator_plugins.xml

Step 6 – Registering plugin with the ROS package system

Step 7 – Editing the CMakeLists.txt file

Step 8: Querying the list of plugins in a package

Step 9 – Running the plugin loader

Understanding ROS nodelets

Creating a nodelet

Step 1 – Creating a package for nodelet

Step 2 – Creating hello_world.cpp nodelet

Step 3 – Explanation of hello_world.cpp

Step 4 – Creating plugin description file

Step 5 – Adding the export tag in package.xml

Step 6 – Editing CMakeLists.txt

Step 7 – Building and running nodelets

Step 8 – Creating launch files for nodelets

Understanding the Gazebo plugins

Creating a basic world plugin

Questions

Summary

6. Writing ROS Controllers and Visualization Plugins

Understanding pr2_mechanism packages

pr2_controller_interface package

Initialization of the controller

Starting the ROS controller

Updating ROS controller

Stopping the controller

pr2_controller_manager

Writing a basic real-time joint controller in ROS

Step 1 – Creating controller package

Step 2 – Creating controller header file

Step 3 – Creating controller source file

Step 4 – Explanation of the controller source file

Step 5 – Creating plugin description file

Step 6 – Updating package.xml

Step 7 – Updating CMakeLists.txt

Step 8 – Building controller

Step 9 – Writing controller configuration file

Step 10 – Writing launch file for the controller

Step 11 – Running controller along with PR2 simulation in Gazebo

Understanding ros_control packages

Understanding ROS visualization tool (RViz) and its plugins

Displays panel

RViz toolbar

Views

Time panel

Dockable panels

Writing a RViz plugin for teleoperation

Methodology of building RViz plugin

Step 1 – Creating RViz plugin package

Step 2 – Creating RViz plugin header file

Step 3 – Creating RViz plugin definition

Step 4 – Creating plugin description file

Step 5 – Adding export tags in package.xml

Step 6 – Editing CMakeLists.txt

Step 7 – Building and loading plugins

Questions

Summary

7. Interfacing I/O Boards, Sensors, and Actuators to ROS

Understanding the Arduino–ROS interface

What is the Arduino–ROS interface?

Understanding the rosserial package in ROS

Installing rosserial packages on Ubuntu 14.04/15.04

Understanding ROS node APIs in Arduino

ROS – Arduino Publisher and Subscriber example

Arduino-ROS, example – blink LED and push button

Arduino-ROS, example – Accelerometer ADXL 335

Arduino-ROS, example – ultrasonic distance sensor

Equations to find distance using the ultrasonic range sensor

Arduino-ROS, example – Odometry Publisher

Interfacing Non-Arduino boards to ROS

Setting ROS on Odroid–C1 and Raspberry Pi 2

How to install an OS image to Odroid-C1 and Raspberry Pi 2

Installation in Windows

Installation in Linux

Connecting to Odroid-C1 and Raspberry Pi 2 from a PC

Configuring an Ethernet hotspot for Odroid-C1 and Raspberry Pi 2

Installing Wiring Pi on Odroid-C1

Installing Wiring Pi on Raspberry Pi 2

Blinking LED using ROS on Odroid-C1 and Raspberry Pi 2

Push button + blink LED using ROS on Odroid-C1 and Raspberry Pi 2

Running LED blink in Odroid-C1

Running button handling and LED blink in Odroid-C1

Running LED blink in Raspberry Pi 2

Interfacing Dynamixel actuators to ROS

Questions

Summary

8. Programming Vision Sensors using ROS, Open-CV, and PCL

Understanding ROS – OpenCV interfacing packages

Understanding ROS – PCL interfacing packages

Installing ROS perception

Interfacing USB webcams in ROS

Working with ROS camera calibration

Converting images between ROS and OpenCV using cv_bridge

Image processing using ROS and OpenCV

Step 1: Creating ROS package for the experiment

Step 2: Creating source files

Step 3: Explanation of the code

Publishing and subscribing images using image_transport

Converting OpenCV-ROS images using cv_bridge

Finding edges on the image

Visualizing raw and edge detected image

Step 4: Editing the CMakeLists.txt file

Step 5: Building and running example

Interfacing Kinect and Asus Xtion Pro in ROS

Interfacing Intel Real Sense camera with ROS

Working with point cloud to laser scan package

Interfacing Hokuyo Laser in ROS

Interfacing Velodyne LIDAR in ROS

Working with point cloud data

How to publish a point cloud

How to subscribe and process the point cloud

Writing a point cloud data to a PCD file

Read and publish point cloud from a PCD file

Streaming webcam from Odroid using ROS

Questions

Summary

9. Building and Interfacing Differential Drive Mobile Robot Hardware in ROS

Introduction to Chefbot- a DIY mobile robot and its hardware configuration

Flashing Chefbot firmware using Energia IDE

Serial data sending protocol from LaunchPad to PC

Serial data sending protocol from PC to Launchpad

Discussing Chefbot interface packages on ROS

Computing odometry from encoder ticks

Computing motor velocities from ROS twist message

Running robot stand alone launch file using C++ nodes

Configuring the Navigation stack for Chefbot

Configuring the gmapping node

Configuring the Navigation stack packages

Common configuration (local_costmap) and (global_costmap)

Configuring global costmap parameters

Configuring local costmap parameters

Configuring base local planner parameters

Configuring DWA local planner parameters

Configuring move_base node parameters

Understanding AMCL

Understanding RViz for working with the Navigation stack

2D Pose Estimate button

Visualizing the particle cloud

The 2D Nav Goal button

Displaying the static map

Displaying the robot footprint

Displaying the global and local cost map

Displaying the global plan, local plan, and planner plan

The current goal

Obstacle avoidance using the Navigation stack

Working with Chefbot simulation

Building a room in Gazebo

Adding model files to the Gazebo model folder

Sending a goal to the Navigation stack from a ROS node

Questions

Summary

10. Exploring the Advanced Capabilities of ROS-MoveIt!

Motion planning using the move_group C++ interface

Motion planning a random path using MoveIt! C++ APIs

Motion planning a custom path using MoveIt! C++ APIs

Collision checking in robot arm using MoveIt!

Adding a collision object in MoveIt!

Removing a collision object from the planning scene

Checking self collision using MoveIt! APIs

Working with perception using MoveIt! and Gazebo

Grasping using MoveIt!

Working with robot pick and place task using MoveIt!

Creating Grasp Table and Grasp Object in MoveIt!

Pick and place action in Gazebo and real Robot

Understanding Dynamixel ROS Servo controllers for robot hardware interfacing

The Dynamixel Servos

Dynamixel-ROS interface

Interfacing seven DOF Dynamixel based robotic arm to ROS MoveIt!

Creating a controller package for COOL arm robot

MoveIt! configuration of the COOL Arm

Questions

Summary

11. ROS for Industrial Robots

Understanding ROS-Industrial packages

Goals of ROS-Industrial

ROS-Industrial – a brief history

Benefits of ROS-Industrial

Installing ROS-Industrial packages

Block diagram of ROS-Industrial packages

Creating URDF for an industrial robot

Creating MoveIt! configuration for an industrial robot

Updating the MoveIt! configuration files

Testing the MoveIt! configuration

Installing ROS-Industrial packages of universal robotic arm

Installing the ROS interface of universal robots

Understanding the Moveit! configuration of a universal robotic arm

Working with MoveIt! configuration of ABB robots

Understanding the ROS-Industrial robot support packages

Visualizing the ABB robot model in RViz

ROS-Industrial robot client package

Designing industrial robot client nodes

ROS-Industrial robot driver package

Understanding MoveIt! IKFast plugin

Creating the MoveIt! IKFast plugin for the ABB-IRB6640 robot

Prerequisites for developing the MoveIt! IKFast plugin

OpenRave and IK Fast Module

MoveIt! IK Fast

Installing MoveIt! IKFast package

Installing OpenRave on Ubuntu 14.04.3