Effective Robotics Programming with ROS

556 Pages·2016·13.87 MB·English

Effective Robotics Programming with ROS
Third Edition
Table of Contents
Effective Robotics Programming with ROS Third Edition
Credits
About the Authors
About the Reviewer
www.PacktPub.com
eBooks, discount offers, and more
Why subscribe?
Customer Feedback
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. Getting Started with ROS
PC installation
Installing ROS Kinetic using repositories
Configuring your Ubuntu repositories
Setting up your source.list file
Setting up your keys
Installing ROS
Initializing rosdep
Setting up the environment
Getting rosinstall
How to install VirtualBox and Ubuntu
Downloading VirtualBox
Creating the virtual machine
Using ROS from a Docker image
Installing Docker
Getting and using ROS Docker images and containers
Installing ROS in BeagleBone Black
Prerequisites
Setting up the local machine and source.list file
Setting up your keys
Installing the ROS packages
Initializing rosdep for ROS
Setting up the environment in the BeagleBone Black
Getting rosinstall for BeagleBone Black
Basic ROS example on the BeagleBone Black
Summary
2. ROS Architecture and Concepts
Understanding the ROS Filesystem level
The workspace
Packages
Metapackages
Messages
Services
Understanding the ROS Computation Graph level
Nodes and nodelets
Topics
Services
Messages
Bags
The ROS master
Parameter Server
Understanding the ROS Community level
Tutorials to practise with ROS
Navigating through the ROS filesystem
Creating our own workspace
Creating an ROS package and metapackage
Building an ROS package
Playing with ROS nodes
Learning how to interact with topics
Learning how to use services
Using Parameter Server
Creating nodes
Building the node
Creating msg and srv files
Using the new srv and msg files
The launch file
Dynamic parameters
Summary
3. Visualization and Debugging Tools
Debugging ROS nodes
Using the GDB debugger with ROS nodes
Attaching a node to GDB while launching ROS
Profiling a node with valgrind while launching ROS
Enabling core dumps for ROS nodes
Logging messages
Outputting logging messages
Setting the debug message level
Configuring the debugging level of a particular node
Giving names to messages
Conditional and filtered messages
Showing messages once, throttling, and other combinations
Using rqt_console and rqt_logger_level to modify the logging level on the fly
Inspecting the system
Inspecting the node's graph online with rqt_graph
Setting dynamic parameters
Dealing with the unexpected
Visualizing nodes diagnostics
Plotting scalar data
Creating a time series plot with rqt_plot
Image visualization
Visualizing a single image
3D visualization
Visualizing data in a 3D world using rqt_rviz
The relationship between topics and frames
Visualizing frame transformations
Saving and playing back data
What is a bag file?
Recording data in a bag file with rosbag
Playing back a bag file
Inspecting all the topics and messages in a bag file
Using the rqt_gui and rqt plugins
Summary
4. 3D Modeling and Simulation
A 3D model of our robot in ROS
Creating our first URDF file
Explaining the file format
Watching the 3D model on rviz
Loading meshes to our models
Making our robot model movable
Physical and collision properties
Xacro – a better way to write our robot models
Using constants
Using math
Using macros
Moving the robot with code
3D modeling with SketchUp
Simulation in ROS
Using our URDF 3D model in Gazebo
Adding sensors to Gazebo
Loading and using a map in Gazebo
Moving the robot in Gazebo
Summary
5. The Navigation Stack – Robot Setups
The navigation stack in ROS
Creating transforms
Creating a broadcaster
Creating a listener
Watching the transformation tree
Publishing sensor information
Creating the laser node
Publishing odometry information
How Gazebo creates the odometry
Using Gazebo to create the odometry
Creating our own odometry
Creating a base controller
Creating our base controller
Creating a map with ROS
Saving the map using map_server
Loading the map using map_server
Summary
6. The Navigation Stack – Beyond Setups
Creating a package
Creating a robot configuration
Configuring the costmaps – global_costmap and local_costmap
Configuring the common parameters
Configuring the global costmap
Configuring the local costmap
Base local planner configuration
Creating a launch file for the navigation stack
Setting up rviz for the navigation stack
The 2D pose estimate
The 2D nav goal
The static map
The particle cloud
The robot's footprint
The local costmap
The global costmap
The global plan
The local plan
The planner plan
The current goal
Adaptive Monte Carlo Localization
Modifying parameters with rqt_reconfigure
Avoiding obstacles
Sending goals
Summary
7. Manipulation with MoveIt!
The MoveIt! architecture
Motion planning
The planning scene
World geometry monitor
Kinematics
Collision checking
Integrating an arm in MoveIt!
What's in the box?
Generating a MoveIt! package with the Setup Assistant
Integration into RViz
Integration into Gazebo or a real robotic arm
Simple motion planning
Planning a single goal
Planning a random target
Planning a predefined group state
Displaying the target motion
Motion planning with collisions
Adding objects to the planning scene
Removing objects from the planning scene
Motion planning with point clouds
The pick and place task
The planning scene
The target object to grasp
The support surface
Perception
Grasping
The pickup action
The place action
The demo mode
Simulation in Gazebo
Summary
8. Using Sensors and Actuators with ROS
Using a joystick or a gamepad
How does joy_node send joystick movements?
Using joystick data to move our robot model
Using Arduino to add sensors and actuators
Creating an example program to use Arduino
Robot platform controlled by ROS and Arduino
Connecting your robot motors to ROS using Arduino
Connecting encoders to your robot
Controlling the wheel velocity
Using a low-cost IMU – 9 degrees of freedom
Installing Razor IMU ROS library
How does Razor send data in ROS?
Creating an ROS node to use data from the 9DoF sensor in our robot
Using robot localization to fuse sensor data in your robot
Using the IMU – Xsens MTi
How does Xsens send data in ROS?
Using a GPS system
How GPS sends messages
Creating an example project to use GPS
Using a laser rangefinder – Hokuyo URG-04lx
Understanding how the laser sends data in ROS
Accessing the laser data and modifying it
Creating a launch file
Using the Kinect sensor to view objects in 3D
How does Kinect send data from the sensors, and how do we see it?
Creating an example to use Kinect
Using servomotors – Dynamixel
How does Dynamixel send and receive commands for the movements?
Creating an example to use the servomotor
Summary
9. Computer Vision
ROS camera drivers support
FireWire IEEE1394 cameras
USB cameras
Making your own USB camera driver with OpenCV
ROS images
Publishing images with ImageTransport
OpenCV in ROS
Installing OpenCV 3.0
Using OpenCV in ROS
Visualizing the camera input images with rqt_image_view
Camera calibration
How to calibrate a camera
Stereo calibration
The ROS image pipeline
Image pipeline for stereo cameras
ROS packages useful for Computer Vision tasks
Visual odometry
Using visual odometry with viso2
Camera pose calibration
Running the viso2 online demo
Performing visual odometry with viso2 with a stereo camera
Performing visual odometry with an RGBD camera
Installing fovis
Using fovis with the Kinect RGBD camera
Computing the homography of two images
Summary
10. Point Clouds
Understanding the Point Cloud Library
Different point cloud types
Algorithms in PCL
The PCL interface for ROS
My first PCL program
Creating point clouds
Loading and saving point clouds to the disk
Visualizing point clouds
Filtering and downsampling
Registration and matching
Partitioning point clouds
Segmentation
Summary
Index
Effective Robotics Programming with ROS
Third Edition