- Why do we perform robotic simulation?
- How can we add sensors into a Gazebo simulation?
- What are the different types of ROS controllers and hardware interfaces?
- How can we move the mobile robot in a Gazebo simulation?
Questions
by Lentin Joseph, Aaron Martinez, Enrique Fernandez, Luis Sanchez, Anil Mahtani
ROS Programming: Building Powerful Robots
- Title page
- Copyright and Credits
- Packt Upsell
- Preface
- Effective Robotics Programming with ROS, Third Edition
- Getting Started with ROS
- ROS Architecture and Concepts
- Understanding the ROS Filesystem level
- Understanding the ROS Computation Graph level
- 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
- Visualization and Debugging Tools
- Debugging 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
- Setting dynamic parameters
- Dealing with the unexpected
- Visualizing nodes diagnostics
- Plotting scalar data
- Image visualization
- 3D visualization
- Saving and playing back data
- Using the rqt_gui and rqt plugins
- Summary
- The Navigation Stack - Robot Setups
- The Navigation Stack - Beyond Setups
- Creating a package
- Creating a robot configuration
- Configuring the costmaps - global_costmap and local_costmap
- Creating a launch file for the navigation stack
- Setting up rviz for the navigation stack
- Adaptive Monte Carlo Localization
- Modifying parameters with rqt_reconfigure
- Avoiding obstacles
- Sending goals
- Summary
- Manipulation with MoveIt!
- Using Sensors and Actuators with ROS
- Using a joystick or a gamepad
- Using Arduino to add sensors and actuators
- Using a low-cost IMU - 9 degrees of freedom
- Using the IMU - Xsens MTi
- Using a GPS system
- Using a laser rangefinder - Hokuyo URG-04lx
- Creating a launch file
- Using the Kinect sensor to view objects in 3D
- Using servomotors - Dynamixel
- Summary
- Computer Vision
- Point Clouds
- Mastering ROS for Robotics Programming
- 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
- Adding physical and collision properties to a URDF model
- Understanding robot modeling using xacro
- Conversion of xacro to URDF
- Creating the robot description for a seven DOF robot manipulator
- Explaining the xacro model of seven DOF arm
- Creating a robot model for the differential drive mobile robot
- Questions
- Summary
- Simulating Robots Using ROS and Gazebo
- 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
- Working with pluginlib_calculator package
- 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
- Creating plugins for the calculator application using pluginlib
- Understanding the Gazebo plugins
- Questions
- Summary
- Understanding pluginlib
- Writing ROS Controllers and Visualization Plugins
- Understanding pr2_mechanism packages
- 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
- 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
- Methodology of building RViz plugin
- Questions
- Summary
- 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
- Arduino-ROS, example - blink LED and push button
- Arduino-ROS, example - Accelerometer ADXL 335
- Arduino-ROS, example - ultrasonic distance 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
- Connecting to Odroid-C1 and Raspberry Pi 2 from a PC
- Configuring an Ethernet hotspot for Odroid-C1 and 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
- Interfacing Dynamixel actuators to ROS
- Questions
- Summary
- Programming Vision Sensors using ROS, Open-CV, and PCL
- Understanding ROS - OpenCV interfacing packages
- Understanding ROS - PCL interfacing packages
- Interfacing USB webcams in ROS
- Working with ROS camera calibration
- Interfacing Kinect and Asus Xtion Pro in ROS
- Interfacing Intel Real Sense camera with ROS
- Interfacing Hokuyo Laser in ROS
- Interfacing Velodyne LIDAR in ROS
- Working with point cloud data
- Streaming webcam from Odroid using ROS
- Questions
- Summary
- 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
- Discussing Chefbot interface packages on ROS
- Computing odometry from encoder ticks
- Computing motor velocities from ROS twist message
- Configuring the Navigation stack for Chefbot
- Configuring the gmapping node
- Configuring the Navigation stack packages
- Understanding AMCL
- Understanding RViz for working with the Navigation stack
- Obstacle avoidance using the Navigation stack
- Working with Chefbot simulation
- Sending a goal to the Navigation stack from a ROS node
- Questions
- Summary
- Introduction to Chefbot- a DIY mobile robot and its hardware configuration
- Exploring the Advanced Capabilities of ROS-MoveIt!
- Motion planning using the move_group C++ interface
- Collision checking in robot arm using MoveIt!
- Working with perception using MoveIt! and Gazebo
- Grasping using MoveIt!
- Working with robot pick and place task using MoveIt!
- Understanding Dynamixel ROS Servo controllers for robot hardware interfacing
- Interfacing seven DOF Dynamixel based robotic arm to ROS MoveIt!
- Questions
- Summary
- ROS for Industrial Robots
- Understanding ROS-Industrial packages
- Installing ROS-Industrial packages
- Block diagram of ROS-Industrial packages
- Creating URDF for an industrial robot
- Creating MoveIt! configuration for an industrial robot
- Installing ROS-Industrial packages of universal robotic arm
- Understanding the Moveit! configuration of a universal robotic arm
- Working with MoveIt! configuration of ABB robots
- Understanding the ROS-Industrial robot support packages
- ROS-Industrial robot client package
- ROS-Industrial robot driver package
- Understanding MoveIt! IKFast plugin
- Creating the MoveIt! IKFast plugin for the ABB-IRB6640 robot
- Creating the COLLADA file of a robot to work with OpenRave
- Generating the IKFast CPP file for the IRB 6640 robot
- Questions
- Summary
- Troubleshooting and Best Practices in ROS
- ROS Robotics Projects
- Face Detection and Tracking Using ROS, OpenCV and Dynamixel Servos
- Overview of the project
- Hardware and software prerequisites
- Interfacing Dynamixel with ROS
- Creating face tracker ROS packages
- Working with the face-tracking ROS package
- Understanding the face tracker code
- Understanding CMakeLists.txt
- The track.yaml file
- The launch files
- Running the face tracker node
- The face_tracker_control package
- The pan controller configuration file
- The servo parameters configuration file
- The face tracker controller node
- Creating CMakeLists.txt
- Testing the face tracker control package
- Bringing all the nodes together
- Fixing the bracket and setting up the circuit
- The final run
- Questions
- Summary
- Building a Siri-Like Chatbot in ROS
- Social robots
- Building social robots
- Prerequisites
- Getting started with AIML
- Questions
- Summary
- Controlling Embedded Boards Using ROS
- Teleoperate a Robot Using Hand Gestures
- Object Detection and Recognition
- Deep Learning Using ROS and TensorFlow
- ROS on MATLAB and Android
- Getting started with the ROS-MATLAB interface
- Setting Robotics Toolbox in MATLAB
- Communicating from MATLAB to a ROS network
- Controlling a ROS robot from MATLAB
- Getting started with Android and its ROS interface
- Installing the ROS-Android interface
- Playing with ROS-Android applications
- Code walkthrough
- Creating basic applications using the ROS-Android interface
- Questions
- Summary
- Building an Autonomous Mobile Robot
- Robot specification and design overview
- Designing and selecting the motors and wheels for the robot
- Building 2D and 3D models of the robot body
- Simulating the robot model in Gazebo
- Mathematical model of a differential drive robot
- Designing and building actual robot hardware
- Interfacing robot hardware with ROS
- Gmapping and localization in Chefbot
- Questions
- Summary
- Creating a Self-Driving Car Using ROS
- Getting started with self-driving cars
- Functional block diagram of a typical self-driving car
- GPS, IMU, and wheel encoders
- Camera
- Ultrasonic sensors
- LIDAR and RADAR
- On-board computer
- Software block diagram of self-driving cars
- Simulating the Velodyne LIDAR
- Interfacing Velodyne sensors with ROS
- Simulating a laser scanner
- Explaining the simulation code
- Interfacing laser scanners with ROS
- Simulating stereo and mono cameras in Gazebo
- Interfacing cameras with ROS
- Simulating GPS in Gazebo
- Simulating IMU on Gazebo
- Interfacing IMUs with ROS
- Simulating an ultrasonic sensor in Gazebo
- Low-cost LIDAR sensors
- Simulating a self-driving car with sensors in Gazebo
- Interfacing a DBW car with ROS
- Introducing the Udacity open source self-driving car project
- Questions
- Summary
- Teleoperating a Robot Using a VR Headset and Leap Motion
- Getting started with a VR headset and Leap Motion
- Project prerequisites
- Design and working of the project
- Installing the Leap Motion SDK on Ubuntu 14.04.5
- Visualizing Leap Motion data in Rviz
- Creating a teleoperation node using the Leap Motion controller
- Building a ROS-VR Android application
- Working with the ROS-VR application and interfacing with Gazebo
- Working with TurtleBot simulation in VR
- Troubleshooting the ROS-VR application
- Integrating ROS-VR application and Leap Motion teleoperation
- Questions
- Summary
- Controlling Your Robots over the Web
- Getting started with ROS web packages
- Setting up ROS web packages on ROS Kinetic
- Installing tf2_web_republisher on ROS Kinetic
- Teleoperating and visualizing a robot on a web browser
- Controlling robot joints from a web browser
- Web-based speech-controlled robot
- Running a speech-controlled robot application
- Questions
- Summary
- Bibliography
- Other Books You May Enjoy
Questions
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.