Mastering ROS for robotics programming design, build, and simulate complex robots using the Robot Operating System
Discover best practices and troubleshooting solutions when working on ROS About This Book Develop complex robotic applications using ROS to interface robot manipulators and mobile robots Gain insight into autonomous navigation in mobile robots and motion planning in robot manipulators Discover best...
| Otros Autores: | , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham, [England] ; Mumbai, [India] :
Packt
2018.
|
| Edición: | Second edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009631113406719 |
Tabla de Contenidos:
- Cover
- Title Page
- Copyright and Credits
- www.PacktPub.com
- Contributors
- Table of Contents
- Preface
- Chapter 1: Introduction to ROS
- Why should we learn ROS?
- Why we prefer ROS for robots
- Why some do not prefer ROS for robots
- Understanding the ROS filesystem level
- ROS packages
- ROS metapackages
- ROS messages
- The ROS services
- Understanding the ROS computation graph level
- ROS nodes
- ROS messages
- ROS topics
- ROS services
- ROS bags
- The ROS Master
- Using the ROS parameter
- ROS community level
- What are the prerequisites for starting with ROS?
- Running the ROS Master and the ROS parameter server
- Checking the roscore command output
- Questions
- Summary
- Chapter 2: Getting Started with ROS Programming
- 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
- Chapter 3: 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 3D robot 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
- Converting xacro to URDF.
- Creating the robot description for a seven DOF robot manipulator
- Arm specification
- Type of joints
- Explaining the xacro model of the 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 robot state publisher
- Creating a robot model for the differential drive mobile robot
- Questions
- Summary
- Chapter 4: Simulating Robots Using ROS and Gazebo
- Simulating the robotic arm using Gazebo and ROS
- Creating 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
- Chapter 5: Simulating Robots Using ROS and V-REP
- Setting up V-REP with ROS
- Understanding the vrep_plugin
- Interacting with V-REP using ROS services
- Interacting with V-REP using ROS topics
- Simulating the robotic arm using V-REP and ROS
- Adding the ROS interface to V-REP joint controllers
- Simulating a differential wheeled robot in V-REP.
- Adding a laser sensor to V-REP
- Adding a 3D vision sensor to V-REP
- Questions
- Summary
- Chapter 6: 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 the 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 - Setting up the robot end effector
- Step 7 - Adding passive joints
- Step 8 - Author information
- Step 9 - Generating configuration files
- Motion planning of robot in RViz using MoveIt! configuration package
- Using the RViz Motion Planning 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 the 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 the 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.
- Chapter 7: Working with pluginlib, Nodelets, and Gazebo Plugins
- Understanding pluginlib
- Creating plugins for the calculator application using pluginlib
- Working with the pluginlib_calculator package
- Step 1 - Creating the calculator_base header file
- Step 2 - Creating the calculator_plugins header file
- Step 3 - Exporting plugins using the calculator_plugins.cpp
- Step 4 - Implementing the plugin loader using the calculator_loader.cpp
- Step 5 - Creating the plugin description file: calculator_plugins.xml
- Step 6 - Registering the 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 a nodelet
- Step 2 - Creating the hello_world.cpp nodelet
- Step 3 - Explanation of hello_world.cpp
- Step 4 - Creating the 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
- Chapter 8: Writing ROS Controllers and Visualization Plugins
- Understanding ros_control packages
- The controller_interface package
- Initializating the controller
- Starting the ROS controller
- Updating the ROS controller
- Stopping the controller
- The controller_manager
- Writing a basic joint controller in ROS
- Step 1 - Creating the controller package
- Step 2 - Creating the controller header file
- Step 3 - Creating the controller source file
- Step 4 - Explaining the controller source file
- Step 5 - Creating the plugin description file
- Step 6 - Updating package.xml
- Step 7 - Updating CMakeLists.txt.
- Step 8 - Building the controller
- Step 9 - Writing the controller configuration file
- Step 10 - Writing the launch file for the controller
- Step 11 - Running the controller along with the seven dof arm in Gazebo
- Understanding the ROS visualization tool (RViz) and its plugins
- Displays panel
- RViz toolbar
- Views
- Time panel
- Dockable panels
- Writing an RViz plugin for teleoperation
- Methodology of building the RViz plugin
- Step 1 - Creating the RViz plugin package
- Step 2 - Creating the RViz plugin header file
- Step 3 - Creating the RViz plugin definition
- Step 4 - Creating the plugin description file
- Step 5 - Adding the export tags in package.xml
- Step 6 - Editing CMakeLists.txt
- Step 7 - Building and loading plugins
- Questions
- Summary
- Chapter 9: 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 16.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-XU4 and Raspberry Pi 2
- How to install an OS image to Odroid-XU4 and Raspberry Pi 2
- Installation in Windows
- Installation in Linux
- Connecting to Odroid-XU4 and Raspberry Pi 2 from a PC
- Configuring an Ethernet hotspot for Odroid-XU4 and Raspberry Pi 2
- Installing Wiring Pi on Odroid-XU4
- Installing Wiring Pi on Raspberry Pi 2
- Blinking LED using ROS on Raspberry Pi 2.
- Push button + blink LED using ROS on Raspberry Pi 2.
