Book Description

Enhancing your existing robotic skills by learning how to design and build multifunctional robots using Robots Operating System libraries and tools

About This Book

  • Successfully design and simulate your 3D robot model and use powerful algorithms and tools to program and set up your robots
  • Work through concrete examples that will help you build your own robotic systems of varying complexity levels
  • Discover the best practices and troubleshooting solutions everyone needs when working on ROS

Who This Book Is For

This course targets robotic enthusiasts, developers, and researchers who would like to build robot applications using ROS. If you are looking to explore the advanced ROS features in your projects, then this learning path is for you. Basic knowledge of ROS, GNU/Linux, and programming concepts is assumed.

What You Will Learn

  • Understand the concepts of ROS, the command-line tools, visualization GUIs, and how to debug ROS
  • Connect robot sensors and actuators to ROS
  • Obtain and analyze data from cameras and 3D sensors
  • Dig deep into the ROS Pluginlib, ROS nodelets, and Gazebo plugins
  • Interface I/O boards such as Arduino, robot sensors, and high-end actuators with ROS
  • Get to grips with teleoperating robots using hand gestures
  • Build ROS-based applications using Matlab and Android
  • Build interactive applications using TurtleBot

In Detail

This learning path is designed to help you program and build your robots using open source ROS libraries and tools. We start with the installation and basic concepts, then continue with the more complex modules available in ROS, such as sensor and actuator integration (drivers), navigation and mapping (so you can create an autonomous mobile robot), manipulation, computer vision, perception in 3D with PCL, and more.

We then discuss advanced concepts in robotics and how to program using ROS.

You'll get a deep overview of the ROS framework, which will give you a clear idea of how ROS really works. During the course of the book, you will learn how to build models of complex robots, and simulate and interface the robot using the ROS MoveIt motion planning library and ROS navigation stacks.

We'll go through great projects such as building a self-driving car, an autonomous mobile robot, and image recognition using deep learning and ROS. You can find beginner, intermediate, and expert ROS robotics applications inside!

It includes content from the following Packt products:

  • Effective Robotics Programming with ROS - Third Edition
  • Mastering ROS for Robotics Programming
  • ROS Robotics Projects

Style and approach

This course is packed with fun-filled, end-to-end projects on mobile, armed, and flying robots, and describes the ROS implementation and execution of these models.

Downloading the example code for this book You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the files e-mailed directly to you.

Table of Contents

  1. Title page
  2. Copyright and Credits
    1. ROS Programming: Building Powerful Robots
  3. Packt Upsell
    1. Why subscribe?
    2. PacktPub.com
  4. Preface
    1. Who this learning path is for
    2. What this learning path covers
    3. To get the most out of this learning path
      1. Download the example code files
      2. Conventions used
    4. Get in touch
      1. Reviews
  5. Effective Robotics Programming with ROS, Third Edition
  6. Getting Started with ROS
    1. PC installation
      1. Installing ROS Kinetic using repositories
      2. Configuring your Ubuntu repositories
      3. Setting up your source.list file
      4. Setting up your keys
      5. Installing ROS
      6. Initializing rosdep
      7. Setting up the environment
      8. Getting rosinstall
    2. How to install VirtualBox and Ubuntu
      1. Downloading VirtualBox
      2. Creating the virtual machine
    3. Using ROS from a Docker image
      1. Installing Docker
      2. Getting and using ROS Docker images and containers
    4. Installing ROS in BeagleBone Black
      1. Prerequisites
      2. Setting up the local machine and source.list file
      3. Setting up your keys
      4. Installing the ROS packages
      5. Initializing rosdep for ROS
      6. Setting up the environment in the BeagleBone Black
      7. Getting rosinstall for BeagleBone Black
      8. Basic ROS example on the BeagleBone Black
    5. Summary
  7. ROS Architecture and Concepts
    1. Understanding the ROS Filesystem level
      1. The workspace
      2. Packages
      3. Metapackages
      4. Messages
      5. Services
    2. Understanding the ROS Computation Graph level
      1. Nodes and nodelets
      2. Topics
      3. Services
      4. Messages
      5. Bags
      6. The ROS master
      7. Parameter Server
    3. Understanding the ROS Community level
    4. Tutorials to practise with ROS
      1. Navigating through the ROS filesystem
      2. Creating our own workspace
      3. Creating an ROS package and metapackage
      4. Building an ROS package
      5. Playing with ROS nodes
      6. Learning how to interact with topics
      7. Learning how to use services
      8. Using Parameter Server
      9. Creating nodes
      10. Building the node
      11. Creating msg and srv files
      12. Using the new srv and msg files
      13. The launch file
      14. Dynamic parameters
    5. Summary
  8. Visualization and Debugging Tools
    1. Debugging ROS nodes
      1. Using the GDB debugger with ROS nodes
      2. Attaching a node to GDB while launching ROS
      3. Profiling a node with valgrind while launching ROS
      4. Enabling core dumps for ROS nodes
    2. Logging messages
      1. Outputting logging messages
      2. Setting the debug message level
      3. Configuring the debugging level of a particular node
      4. Giving names to messages
      5. Conditional and filtered messages
      6. Showing messages once, throttling, and other combinations
      7. Using rqt_console and rqt_logger_level to modify the logging level on the fly
    3. Inspecting the system
      1. Inspecting the node's graph online with rqt_graph
    4. Setting dynamic parameters
    5. Dealing with the unexpected
    6. Visualizing nodes diagnostics
    7. Plotting scalar data
      1. Creating a time series plot with rqt_plot
    8. Image visualization
      1. Visualizing a single image
    9. 3D visualization
      1. Visualizing data in a 3D world using rqt_rviz
      2. The relationship between topics and frames
      3. Visualizing frame transformations
    10. Saving and playing back data
      1. What is a bag file?
      2. Recording data in a bag file with rosbag
      3. Playing back a bag file
      4. Inspecting all the topics and messages in a bag file
    11. Using the rqt_gui and rqt plugins
    12. Summary
  9. The Navigation Stack - Robot Setups
    1. The navigation stack in ROS
    2. Creating transforms
      1. Creating a broadcaster
      2. Creating a listener
      3. Watching the transformation tree
    3. Publishing sensor information
      1. Creating the laser node
    4. Publishing odometry information
      1. How Gazebo creates the odometry
      2. Using Gazebo to create the odometry
      3. Creating our own odometry
    5. Creating a base controller
      1. Creating our base controller
    6. Creating a map with ROS
      1. Saving the map using map_server
      2. Loading the map using map_server
    7. Summary
  10. The Navigation Stack - Beyond Setups
    1. Creating a package
    2. Creating a robot configuration
    3. Configuring the costmaps - global_costmap and local_costmap
      1. Configuring the common parameters
      2. Configuring the global costmap
      3. Configuring the local costmap
      4. Base local planner configuration
    4. Creating a launch file for the navigation stack
    5. Setting up rviz for the navigation stack
      1. The 2D pose estimate
      2. The 2D nav goal
      3. The static map
      4. The particle cloud
      5. The robot's footprint
      6. The local costmap
      7. The global costmap
      8. The global plan
      9. The local plan
      10. The planner plan
      11. The current goal
    6. Adaptive Monte Carlo Localization
    7. Modifying parameters with rqt_reconfigure
    8. Avoiding obstacles
    9. Sending goals
    10. Summary
  11. Manipulation with MoveIt!
    1. The MoveIt! architecture
      1. Motion planning
      2. The planning scene
      3. World geometry monitor
      4. Kinematics
      5. Collision checking
    2. Integrating an arm in MoveIt!
      1. What's in the box?
      2. Generating a MoveIt! package with the Setup Assistant
      3. Integration into RViz
      4. Integration into Gazebo or a real robotic arm
    3. Simple motion planning
      1. Planning a single goal
      2. Planning a random target
      3. Planning a predefined group state
      4. Displaying the target motion
    4. Motion planning with collisions
      1. Adding objects to the planning scene
      2. Removing objects from the planning scene
      3. Motion planning with point clouds
    5. The pick and place task
      1. The planning scene
      2. The target object to grasp
      3. The support surface
      4. Perception
      5. Grasping
      6. The pickup action
      7. The place action
      8. The demo mode
      9. Simulation in Gazebo
    6. Summary
  12. Using Sensors and Actuators with ROS
    1. Using a joystick or a gamepad
      1. How does joy_node send joystick movements?
      2. Using joystick data to move our robot model
    2. Using Arduino to add sensors and actuators
      1. Creating an example program to use Arduino
      2. Robot platform controlled by ROS and Arduino
        1. Connecting your robot motors to ROS using Arduino
        2. Connecting encoders to your robot
        3. Controlling the wheel velocity
    3. Using a low-cost IMU - 9 degrees of freedom
      1. Installing Razor IMU ROS library
      2. How does Razor send data in ROS?
      3. Creating an ROS node to use data from the 9DoF sensor in our robot
      4. Using robot localization to fuse sensor data in your robot
    4. Using the IMU - Xsens MTi
      1. How does Xsens send data in ROS?
    5. Using a GPS system
      1. How GPS sends messages
      2. Creating an example project to use GPS
    6. Using a laser rangefinder - Hokuyo URG-04lx
      1. Understanding how the laser sends data in ROS
      2. Accessing the laser data and modifying it
    7. Creating a launch file
    8. Using the Kinect sensor to view objects in 3D
      1. How does Kinect send data from the sensors, and how do we see it?
      2. Creating an example to use Kinect
    9. Using servomotors - Dynamixel
      1. How does Dynamixel send and receive commands for the movements?
      2. Creating an example to use the servomotor
    10. Summary
  13. Computer Vision
    1. ROS camera drivers support
      1. FireWire IEEE1394 cameras
      2. USB cameras
      3. Making your own USB camera driver with OpenCV
    2. ROS images
      1. Publishing images with ImageTransport
    3. OpenCV in ROS
      1. Installing OpenCV 3.0
      2. Using OpenCV in ROS
    4. Visualizing the camera input images with rqt_image_view
    5. Camera calibration
      1. How to calibrate a camera
      2. Stereo calibration
    6. The ROS image pipeline
      1. Image pipeline for stereo cameras
    7. ROS packages useful for Computer Vision tasks
      1. Visual odometry
      2. Using visual odometry with viso2
      3. Camera pose calibration
      4. Running the viso2 online demo
      5. Performing visual odometry with viso2 with a stereo camera
    8. Performing visual odometry with an RGBD camera
      1. Installing fovis
      2. Using fovis with the Kinect RGBD camera
    9. Computing the homography of two images
    10. Summary
  14. Point Clouds
    1. Understanding the PCL
      1. Different point cloud types
      2. Algorithms in PCL
      3. The PCL interface for ROS
    2. My first PCL program
      1. Creating point clouds
      2. Loading and saving point clouds to the disk
      3. Visualizing point clouds
      4. Filtering and downsampling
      5. Registration and matching
      6. Partitioning point clouds
    3. Segmentation
    4. Summary
  15. Mastering ROS for Robotics Programming
  16. Working with 3D Robot Modeling in ROS
    1. ROS packages for robot modeling
    2. Understanding robot modeling using URDF
    3. Creating the ROS package for the robot description
    4. Creating our first URDF model
    5. Explaining the URDF file
    6. Visualizing the robot 3D model in RViz
      1. Interacting with pan and tilt joints
    7. Adding physical and collision properties to a URDF model
    8. Understanding robot modeling using xacro
      1. Using properties
      2. Using the math expression
      3. Using macros
    9. Conversion of xacro to URDF
    10. Creating the robot description for a seven DOF robot manipulator
      1. Arm specification
        1. Type of joints
    11. Explaining the xacro model of seven DOF arm
      1. Using constants
      2. Using macros
      3. Including other xacro files
      4. Using meshes in the link
      5. Working with the robot gripper
      6. Viewing the seven DOF arm in RViz
        1. Understanding joint state publisher
        2. Understanding the robot state publisher
    12. Creating a robot model for the differential drive mobile robot
    13. Questions
    14. Summary
  17. Simulating Robots Using ROS and Gazebo
    1. Simulating the robotic arm using Gazebo and ROS
      1. The Robotic arm simulation model for Gazebo
        1. Adding colors and textures to the Gazebo robot model
        2. Adding transmission tags to actuate the model
        3. Adding the gazebo_ros_control plugin
        4. Adding a 3D vision sensor to Gazebo
      2. Simulating the robotic arm with Xtion Pro
        1. Visualizing the 3D sensor data
      3. Moving robot joints using ROS controllers in Gazebo
        1. Understanding the ros_control packages
        2. Different types of ROS controllers and hardware interfaces
        3. How the ROS controller interacts with Gazebo
        4. Interfacing joint state controllers and joint position controllers to the arm
        5. Launching the ROS controllers with Gazebo
        6. Moving the robot joints
      4. Simulating a differential wheeled robot in Gazebo
        1. Adding the laser scanner to Gazebo
        2. Moving the mobile robot in Gazebo
        3. Adding joint state publishers in the launch file
      5. Adding the ROS teleop node
    2. Questions
    3. Summary
  18. Working with Pluginlib, Nodelets, and Gazebo Plugins
    1. Understanding pluginlib
      1. Creating plugins for the calculator application using pluginlib
        1. Working with pluginlib_calculator package
          1. Step 1 - Creating calculator_base header file
          2. Step 2 - Creating calculator_plugins header file
          3. Step 3 - Exporting plugins using calculator_plugins.cpp
          4. Step 4 - Implementing plugin loader using calculator_loader.cpp
          5. Step 5 - Creating plugin description file: calculator_plugins.xml
          6. Step 6 - Registering plugin with the ROS package system
          7. Step 7 - Editing the CMakeLists.txt file
          8. Step 8: Querying the list of plugins in a package
          9. Step 9 - Running the plugin loader
      2. Understanding ROS nodelets
      3. Creating a nodelet
        1. Step 1 - Creating a package for nodelet
        2. Step 2 - Creating hello_world.cpp nodelet
        3. Step 3 - Explanation of hello_world.cpp
        4. Step 4 - Creating plugin description file
        5. Step 5 - Adding the export tag in package.xml
        6. Step 6 - Editing CMakeLists.txt
        7. Step 7 - Building and running nodelets
        8. Step 8 - Creating launch files for nodelets
    2. Understanding the Gazebo plugins
      1. Creating a basic world plugin
    3. Questions
    4. Summary
  19. Writing ROS Controllers and Visualization Plugins
    1. Understanding pr2_mechanism packages
      1. pr2_controller_interface package
        1. Initialization of the controller
        2. Starting the ROS controller
        3. Updating ROS controller
        4. Stopping the controller
      2. pr2_controller_manager
    2. Writing a basic real-time joint controller in ROS
      1. Step 1 – Creating controller package
      2. Step 2 – Creating controller header file
      3. Step 3 – Creating controller source file
      4. Step 4 – Explanation of the controller source file
      5. Step 5 – Creating plugin description file
      6. Step 6 – Updating package.xml
      7. Step 7 – Updating CMakeLists.txt
      8. Step 8 – Building controller
      9. Step 9 – Writing controller configuration file
      10. Step 10 – Writing launch file for the controller
      11. Step 11 – Running controller along with PR2 simulation in Gazebo
    3. Understanding ros_control packages
    4. Understanding ROS visualization tool (RViz) and its plugins
      1. Displays panel
      2. RViz toolbar
      4. Time panel
      5. Dockable panels
    5. Writing a RViz plugin for teleoperation
      1. Methodology of building RViz plugin
        1. Step 1 – Creating RViz plugin package
        2. Step 2 – Creating RViz plugin header file
        3. Step 3 – Creating RViz plugin definition
        4. Step 4 – Creating plugin description file
        5. Step 5 – Adding export tags in package.xml
        6. Step 6 – Editing CMakeLists.txt
        7. Step 7 – Building and loading plugins
    6. Questions
    7. Summary
  20. Interfacing I/O Boards, Sensors, and Actuators to ROS
    1. Understanding the Arduino-ROS interface
    2. What is the Arduino-ROS interface?
      1. Understanding the rosserial package in ROS
        1. Installing rosserial packages on Ubuntu 14.04/15.04
          1. Understanding ROS node APIs in Arduino
        2. ROS - Arduino Publisher and Subscriber example
      2. Arduino-ROS, example - blink LED and push button
      3. Arduino-ROS, example - Accelerometer ADXL 335
      4. Arduino-ROS, example - ultrasonic distance sensor
        1. Equations to find distance using the ultrasonic range sensor
      5. Arduino-ROS, example - Odometry Publisher
      6. Interfacing Non-Arduino boards to ROS
      7. Setting ROS on Odroid-C1 and Raspberry Pi 2
      8. How to install an OS image to Odroid-C1 and Raspberry Pi 2
        1. Installation in Windows
        2. Installation in Linux
      9. Connecting to Odroid-C1 and Raspberry Pi 2 from a PC
      10. Configuring an Ethernet hotspot for Odroid-C1 and Raspberry Pi 2
        1. Installing Wiring Pi on Odroid-C1
        2. Installing Wiring Pi on Raspberry Pi 2
      11. Blinking LED using ROS on Odroid-C1 and Raspberry Pi 2
      12. Push button + blink LED using ROS on Odroid-C1 and Raspberry Pi 2
        1. Running LED blink in Odroid-C1
        2. Running button handling and LED blink in Odroid-C1
        3. Running LED blink in Raspberry Pi 2
    3. Interfacing Dynamixel actuators to ROS
    4. Questions
    5. Summary
  21. Programming Vision Sensors using ROS, Open-CV, and PCL
    1. Understanding ROS - OpenCV interfacing packages
    2. Understanding ROS - PCL interfacing packages
      1. Installing ROS perception
    3. Interfacing USB webcams in ROS
    4. Working with ROS camera calibration
      1. Converting images between ROS and OpenCV using cv_bridge
      2. Image processing using ROS and OpenCV
        1. Step 1: Creating ROS package for the experiment
        2. Step 2: Creating source files
        3. Step 3: Explanation of the code
          1. Publishing and subscribing images using image_transport
          2. Converting OpenCV-ROS images using cv_bridge
          3. Finding edges on the image
          4. Visualizing raw and edge detected image
        4. Step 4: Editing the CMakeLists.txt file
        5. Step 5: Building and running example
    5. Interfacing Kinect and Asus Xtion Pro in ROS
    6. Interfacing Intel Real Sense camera with ROS
      1. Working with point cloud to laser scan package
    7. Interfacing Hokuyo Laser in ROS
    8. Interfacing Velodyne LIDAR in ROS
    9. Working with point cloud data
      1. How to publish a point cloud
      2. How to subscribe and process the point cloud
      3. Writing a point cloud data to a PCD file
      4. Read and publish point cloud from a PCD file
    10. Streaming webcam from Odroid using ROS
    11. Questions
    12. Summary
  22. Building and Interfacing Differential Drive Mobile Robot Hardware in ROS
    1. Introduction to Chefbot- a DIY mobile robot and its hardware configuration
      1. Flashing Chefbot firmware using Energia IDE
        1. Serial data sending protocol from LaunchPad to PC
        2. Serial data sending protocol from PC to Launchpad
      2. Discussing Chefbot interface packages on ROS
      3. Computing odometry from encoder ticks
      4. Computing motor velocities from ROS twist message
        1. Running robot stand alone launch file using C++ nodes
      5. Configuring the Navigation stack for Chefbot
      6. Configuring the gmapping node
      7. Configuring the Navigation stack packages
        1. Common configuration (local_costmap) and (global_costmap)
        2. Configuring global costmap parameters
        3. Configuring local costmap parameters
        4. Configuring base local planner parameters
        5. Configuring DWA local planner parameters
        6. Configuring move_base node parameters
      8. Understanding AMCL
      9. Understanding RViz for working with the Navigation stack
        1. 2D Pose Estimate button
        2. Visualizing the particle cloud
        3. The 2D Nav Goal button
        4. Displaying the static map
        5. Displaying the robot footprint
        6. Displaying the global and local cost map
        7. Displaying the global plan, local plan, and planner plan
        8. The current goal
      10. Obstacle avoidance using the Navigation stack
      11. Working with Chefbot simulation
        1. Building a room in Gazebo
        2. Adding model files to the Gazebo model folder
      12. Sending a goal to the Navigation stack from a ROS node
    2. Questions
    3. Summary
  23. Exploring the Advanced Capabilities of ROS-MoveIt!
    1. Motion planning using the move_group C++ interface
      1. Motion planning a random path using MoveIt! C++ APIs
      2. Motion planning a custom path using MoveIt! C++ APIs
    2. Collision checking in robot arm using MoveIt!
      1. Adding a collision object in MoveIt!
      2. Removing a collision object from the  planning scene
      3. Checking self collision using MoveIt! APIs
    3. Working with perception using MoveIt! and Gazebo
    4. Grasping using MoveIt!
    5. Working with robot pick and place task using MoveIt!
      1. Creating Grasp Table and Grasp Object in MoveIt!
      2. Pick and place action in Gazebo and real Robot
    6. Understanding Dynamixel ROS Servo controllers for robot hardware interfacing
      1. The Dynamixel Servos
      2. Dynamixel-ROS interface
    7. Interfacing seven DOF Dynamixel based robotic arm to ROS MoveIt!
      1. Creating a controller package for COOL arm robot
      2. MoveIt! configuration of the COOL Arm
    8. Questions
    9. Summary
  24. ROS for Industrial Robots
    1. Understanding ROS-Industrial packages
      1. Goals of ROS-Industrial
      2. ROS-Industrial - a brief history
      3. Benefits of ROS-Industrial
    2. Installing ROS-Industrial packages
    3. Block diagram of ROS-Industrial packages
    4. Creating URDF for an industrial robot
    5. Creating MoveIt! configuration for an industrial robot
      1. Updating the MoveIt! configuration files
      2. Testing the MoveIt! configuration
    6. Installing ROS-Industrial packages of universal robotic arm
      1. Installing the ROS interface of universal robots
    7. Understanding the Moveit! configuration of a universal robotic arm
    8. Working with MoveIt! configuration of ABB robots
    9. Understanding the ROS-Industrial robot support packages
      1. Visualizing the ABB robot model in RViz
    10. ROS-Industrial robot client package
      1. Designing industrial robot client nodes
    11. ROS-Industrial robot driver package
    12. Understanding MoveIt! IKFast plugin
    13. Creating the MoveIt! IKFast plugin for the ABB-IRB6640 robot
      1. Prerequisites for developing the MoveIt! IKFast plugin
      2. OpenRave and IK Fast Module
        1. MoveIt! IK Fast
        2. Installing MoveIt! IKFast package
        3. Installing OpenRave on Ubuntu 14.04.3
    14. Creating the COLLADA file of a robot to work with OpenRave
    15. Generating the IKFast CPP file for the IRB 6640 robot
      1. Creating the MoveIt! IKFast plugin
    16. Questions
    17. Summary
  25. Troubleshooting and Best Practices in ROS
    1. Setting up Eclipse IDE on Ubuntu 14.04.3
    2. Setting ROS development environment in Eclipse IDE
      1. Global settings in Eclipse IDE
        1. ROS compile script for Eclipse IDE
        2. Adding ROS Catkin package to Eclipse
        3. Adding run configurations to run ROS nodes in Eclipse
    3. Best practices in ROS
      1. ROS C++ coding style guide
        1. Standard naming conventions used in ROS
        2. Code license agreement
        3. ROS code formatting
        4. ROS code documentation
        5. Console output
    4. Best practices in the ROS package
    5. Important troubleshooting tips in ROS
      1. Usage of roswtf
    6. Questions
    7. Summary
  26. ROS Robotics Projects
  27. Face Detection and Tracking Using ROS, OpenCV and Dynamixel Servos
    1. Overview of the project
    2. Hardware and software prerequisites
      1. Installing dependent ROS packages
        1. Installing the usb_cam ROS package
          1. Creating a ROS workspace for dependencies
    3. Interfacing Dynamixel with ROS
      1. Installing the ROS dynamixel_motor packages
    4. Creating face tracker ROS packages
      1. The interface between ROS and OpenCV
    5. Working with the face-tracking ROS package
      1. Understanding the face tracker code
      2. Understanding CMakeLists.txt
      3. The track.yaml file
      4. The launch files
      5. Running the face tracker node
      6. The face_tracker_control package
        1. The start_dynamixel launch file
        2. The pan controller launch file
      7. The pan controller configuration file
      8. The servo parameters configuration file
      9. The face tracker controller node
      10. Creating CMakeLists.txt
      11. Testing the face tracker control package
      12. Bringing all the nodes together
      13. Fixing the bracket and setting up the circuit
      14. The final run
    6. Questions
    7. Summary
  28. Building a Siri-Like Chatbot in ROS
    1. Social robots
    2. Building social robots
    3. Prerequisites
    4. Getting started with AIML
      1. AIML tags
      2. The PyAIML interpreter
      3. Installing PyAIML on Ubuntu 16.04 LTS
      4. Playing with PyAIML
      5. Loading multiple AIML files
      6. Creating an AIML bot in ROS
      7. The AIML ROS package
        1. Installing the ROS sound_play package
          1. Installing the dependencies of sound_play
          2. Installing the sound_play ROS package
          3. Creating the ros_aiml package
          4. The aiml_server node
          5. The AIML client node
          6. The aiml_tts client node
          7. The AIML speech recognition node
          8. start_chat.launch
          9. start_tts_chat.launch
          10. start_speech_chat.launch
    5. Questions
    6. Summary
  29. Controlling Embedded Boards Using ROS
    1. Getting started with popular embedded boards
      1. An introduction to Arduino boards
        1. How to choose an Arduino board for your robot
        2. Getting started with STM32 and TI Launchpads
        3. The Tiva C Launchpad
      2. Introducing the Raspberry Pi
        1. How to choose a Raspberry Pi board for your robot
      3. The Odroid board
    2. Interfacing Arduino with ROS
      1. Monitoring light using Arduino and ROS
        1. Running ROS serial server on PC
        2. Interfacing STM32 boards to ROS using mbed
        3. Interfacing Tiva C Launchpad boards with ROS using Energia
      2. Running ROS on Raspberry Pi and Odroid boards
        1. Connecting Raspberry Pi and Odroid to PC
        2. Controlling GPIO pins from ROS
          1. Creating a ROS package for the blink demo
          2. Running the LED blink demo on Raspberry Pi and Odroid
    3. Questions
    4. Summary
  30. Teleoperate a Robot Using Hand Gestures
    1. Teleoperating ROS Turtle using a keyboard
    2. Teleoperating using hand gestures
    3. Setting up the project
    4. Interfacing the MPU-9250 with the Arduino and ROS
      1. The Arduino-IMU interfacing code
    5. Visualizing IMU TF in Rviz
    6. Converting IMU data into twist messages
    7. Integration and final run
    8. Teleoperating using an Android phone
    9. Questions
    10. Summary
  31. Object Detection and Recognition
    1. Getting started with object detection and recognition
    2. The find_object_2d package in ROS
      1. Installing find_object_2d
        1. Installing from source code
      2. Running find_object_2d nodes using webcams
      3. Running find_object_2d nodes using depth sensors
    3. Getting started with 3D object recognition
    4. Introduction to 3D object recognition packages in ROS
      1. Installing ORK packages in ROS
    5. Detecting and recognizing objects from 3D meshes
      1. Training using 3D models of an object
      2. Training from captured 3D models
    6. Recognizing objects
    7. Questions
    8. Summary
  32. Deep Learning Using ROS and TensorFlow
    1. Introduction to deep learning and its applications
    2. Deep learning for robotics
    3. Deep learning libraries
    4. Getting started with TensorFlow
      1. Installing TensorFlow on Ubuntu 16.04 LTS
      2. TensorFlow concepts
        1. Graph
        2. Session
        3. Variables
        4. Fetches
        5. Feeds
      3. Writing our first code in TensorFlow
    5. Image recognition using ROS and TensorFlow
      1. Prerequisites
      2. The ROS image recognition node
        1. Running the ROS image recognition node
    6. Introducing to scikit-learn
      1. Installing scikit-learn on Ubuntu 16.04 LTS
    7. Introducing to SVM and its application in robotics
      1. Implementing an SVM-ROS application
    8. Questions
    9. Summary
  33. ROS on MATLAB and Android
    1. Getting started with the ROS-MATLAB interface
    2. Setting Robotics Toolbox in MATLAB
      1. Basic ROS functions in MATLAB
        1. Initializing a ROS network
      2. Listing ROS nodes, topics, and messages
    3. Communicating from MATLAB to a ROS network
    4. Controlling a ROS robot from MATLAB
      1. Designing the MATLAB GUI application
      2. Explaining callbacks
      3. Running the application
    5. Getting started with Android and its ROS interface
      1. Installing rosjava
        1. Installing from the Ubuntu package manager
        2. Installing from source code
      2. Installing android-sdk from the Ubuntu package manager
        1. Installing android-sdk from prebuilt binaries
    6. Installing the ROS-Android interface
    7. Playing with ROS-Android applications
      1. Troubleshooting
        1. Android-ROS publisher-subscriber application
        2. The teleop application
        3. The ROS Android camera application
        4. Making the Android device the ROS master
    8. Code walkthrough
    9. Creating basic applications using the ROS-Android interface
      1. Troubleshooting tips
    10. Questions
    11. Summary
  34. Building an Autonomous Mobile Robot
    1. Robot specification and design overview
    2. Designing and selecting the motors and wheels for the robot
      1. Computing motor torque
      2. Calculation of motor RPM
      3. Design summary
    3. Building 2D and 3D models of the robot body
      1. The base plate
      2. The pole and tube design
      3. The motor, wheel, and motor clamp design
      4. The caster wheel design
      5. Middle plate and top plate design
      6. The top plate
      7. 3D modeling of the robot
    4. Simulating the robot model in Gazebo
    5. Mathematical model of a differential drive robot
      1. Simulating Chefbot
        1. Building the URDF model of Chefbot
          1. Inserting 3D CAD parts into URDF as links
          2. Inserting Gazebo controllers into URDF
        2. Running the simulation
          1. Mapping and localization
    6. Designing and building actual robot hardware
      1. Motor and motor driver
      2. Motor encoders
      3. Tiva C Launchpad
      4. Ultrasonic sensor
      5. OpenNI depth sensor
      6. Intel NUC
      7. Interfacing sensors and motors with the Launchpad
      8. Programming the Tiva C Launchpad
    7. Interfacing robot hardware with ROS
      1. Running Chefbot ROS driver nodes
    8. Gmapping and localization in Chefbot
    9. Questions
    10. Summary
  35. Creating a Self-Driving Car Using ROS
    1. Getting started with self-driving cars
      1. History of autonomous vehicles
        1. Levels of autonomy
    2. Functional block diagram of a typical self-driving car
      1. GPS, IMU, and wheel encoders
        1. Xsens MTi IMU
      2. Camera
      3. Ultrasonic sensors
      4. LIDAR and RADAR
        1. Velodyne HDL-64 LIDAR
        2. SICK LMS 5xx/1xx and Hokuyo LIDAR
        3. Continental ARS 300 radar (ARS)
        4. Delphi radar
      5. On-board computer
      6. Software block diagram of self-driving cars
      7. Simulating the Velodyne LIDAR
      8. Interfacing Velodyne sensors with ROS
      9. Simulating a laser scanner
      10. Explaining the simulation code
      11. Interfacing laser scanners with ROS
      12. Simulating stereo and mono cameras in Gazebo
      13. Interfacing cameras with ROS
      14. Simulating GPS in Gazebo
        1. Interfacing GPS with ROS
      15. Simulating IMU on Gazebo
      16. Interfacing IMUs with ROS
      17. Simulating an ultrasonic sensor in Gazebo
      18. Low-cost LIDAR sensors
        1. Sweep LIDAR
        2. RPLIDAR
    3. Simulating a self-driving car with sensors in Gazebo
      1. Installing prerequisites
      2. Visualizing robotic car sensor data
      3. Moving a self-driving car in Gazebo
      4. Running hector SLAM using a robotic car
    4. Interfacing a DBW car with ROS
      1. Installing packages
      2. Visualizing the self-driving car and sensor data
      3. Communicating with DBW from ROS
    5. Introducing the Udacity open source self-driving car project
      1. MATLAB ADAS toolbox
    6. Questions
    7. Summary
  36. Teleoperating a Robot Using a VR Headset and Leap Motion
    1. Getting started with a VR headset and Leap Motion
    2. Project prerequisites
    3. Design and working of the project
    4. Installing the Leap Motion SDK on Ubuntu 14.04.5
      1. Visualizing Leap Motion controller data
      2. Playing with the Leap Motion visualizer tool
      3. Installing the ROS driver for the Leap Motion controller
        1. Testing the Leap Motion ROS driver
    5. Visualizing Leap Motion data in Rviz
    6. Creating a teleoperation node using the Leap Motion controller
    7. Building a ROS-VR Android application
    8. Working with the ROS-VR application and interfacing with Gazebo
    9. Working with TurtleBot simulation in VR
    10. Troubleshooting the ROS-VR application
    11. Integrating ROS-VR application and Leap Motion teleoperation
    12. Questions
    13. Summary
  37. Controlling Your Robots over the Web
    1. Getting started with ROS web packages
      1. rosbridge_suite
      2. roslibjs, ros2djs, and ros3djs
      3. The tf2_web_republisher package
    2. Setting up ROS web packages on ROS Kinetic
      1. Installing rosbridge_suite
      2. Setting up rosbridge client libraries
    3. Installing tf2_web_republisher on ROS Kinetic
    4. Teleoperating and visualizing a robot on a web browser
      1. Working of the project
      2. Connecting to rosbridge_server
      3. Initializing the teleop
      4. Creating a 3D viewer inside a web browser
      5. Creating a TF client
      6. Creating a URDF client
      7. Creating text input
      8. Running the web teleop application
    5. Controlling robot joints from a web browser
      1. Installing joint_state_publisher_js
        1. Including the joint state publisher module
        2. Creating the joint state publisher object
        3. Creating an HTML division for sliders
      2. Running the web-based joint state publisher
        1. Prerequisites
        2. Installing prerequisites
      3. Explaining the code
      4. Running the robot surveillance application
    6. Web-based speech-controlled robot
      1. Prerequisites
      2. Enabling speech recognition in the web application
    7. Running a speech-controlled robot application
    8. Questions
    9. Summary
  38. Bibliography
  39. Other Books You May Enjoy
    1. Leave a review - let other readers know what you think