book

ROS 2 from Scratch

Name: ROS 2 from Scratch
Author: Edouard Renard
ISBN: 9781835881408

by Edouard Renard

November 2024

Beginner to intermediate

386 pages

9h 30m

English

Packt Publishing

Read now

Unlock full access

ROS 2 from Scratch
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchSubscribe to Game Dev Assembly Newsletter!Share Your ThoughtsFree Benefits with Your Book
Part 1:Getting Started with ROS 2
Chapter 1: Introduction to ROS 2 – What Is ROS 2?
TerminologyWhat is ROS, when should we use it, and why?Why ROS?What is ROS?When to use ROSROS 1 versus ROS 2A quick story of ROS, and how we got to ROS 2Is ROS 1 dead already?Prerequisites for starting with ROS 2Knowledge prerequisitesHardware and softwareHow to follow this bookSummary
Chapter 2: Installing and Setting Up ROS 2
Which ROS 2 distribution to chooseWhat is a ROS 2 distribution?LTS and non-LTS distributionsHow to choose a ROS distributionInstalling the OS (Ubuntu)The relationship between ROS 2 and UbuntuInstalling Ubuntu 24.04 natively with a dual bootInstalling Ubuntu 24.04 on a VMInstalling ROS 2 on UbuntuSetting the localeSetting up the sourcesInstalling ROS 2 packagesSetting up the environment for ROS 2Sourcing ROS 2 in the environmentAdding the source line to the .bashrc fileExtra tools for ROS developmentVisual Studio CodeThe Terminal and other toolsSummary
Chapter 3: Uncovering ROS 2 Core Concepts
Running your first nodeStarting a node from the terminal with ros2 runIntrospecting the nodes with rqt_graphRunning a 2D robot simulationRecap – nodesTopicsRunning a topic publisher and subscriberA name and an interface (data type)More experimentation with topicsRecap – topicsServicesRunning a service server and clientA name and an interface (data type)Sending a request from the terminalMore experimentation with servicesRecap – servicesActionsRunning an action serverA name and an interface (data type)Sending a goal from the terminalRecap – actionsParametersGetting the parameters for a nodeSetting up a parameter value for a nodeRecap – parametersLaunch filesStarting a launch fileRecap – launch filesSummary
Part 2: Developing with ROS 2 – Python and C++
Chapter 4: Writing and Building a ROS 2 Node
Technical requirementsCreating and setting up a ROS 2 workspaceCreating a workspaceBuilding the workspaceSourcing the workspaceCreating a packageWhat is a ROS 2 package?Creating a Python packageCreating a C++ packageBuilding a packageHow are nodes organized in a package?Creating a Python nodeCreating a file for the nodeWriting a minimal ROS 2 Python nodeBuilding the nodeRunning the nodeImproving the node – timer and callbackCreating a C++ nodeWriting a C++ nodeBuilding and running the nodeNode template for Python and C++ nodesTemplate for a Python nodeTemplate for a C++ nodeIntrospecting your nodesros2 node command lineChanging the node name at run timeSummary
Chapter 5: Topics – Sending and Receiving Messages between Nodes
What is a ROS 2 topic?A publisher and a subscriberMultiple publishers and subscribersMultiple publishers and subscribers inside one nodeWrapping things upWriting a topic publisherWriting a Python publisherWriting a C++ publisherWriting a topic subscriberWriting a Python subscriberWriting a C++ subscriberRunning the Python and C++ nodes togetherAdditional tools to handle topicsIntrospecting topics with rqt_graphThe ros2 topic command lineChanging a topic name at runtimeReplaying topic data with bagsCreating a custom interface for a topicUsing existing interfacesCreating a new topic interfaceTopic challenge – closed-loop controlChallengeSolutionSummary
Chapter 6: Services – Client/Server Interaction between Nodes
What is a ROS 2 service?A server and a clientMultiple clients for one serviceAnother service example with roboticsWrapping things upCreating a custom service interfaceFinding an existing interface for our serviceCreating a new service interfaceWriting a service serverWriting a Python service serverWriting a C++ service serverWriting a service clientWriting a Python service clientRunning the client and server nodes togetherWriting a C++ service clientAdditional tools to handle servicesListing and introspecting servicesSending a service requestChanging a service name at runtimeService challenge – client and serverChallengeSolutionSummary

Chapter 7: Actions – When Services Are Not Enough
What is a ROS 2 action?Why actions?How do actions work?Wrapping things upCreating a custom action interfaceDefining the application and the interface we needCreating a new action interfaceWriting an action serverWriting a Python action serverWriting a C++ action serverWriting an action clientWriting a Python action clientCreating an action clientWriting a C++ action clientTaking advantage of all the action mechanismsAdding the feedback mechanismAdding the cancel mechanismAdditional tools to handle actionsListing and introspecting actionsSending a goal from the TerminalTopics and services inside actionsSummary
Chapter 8: Parameters – Making Nodes More Dynamic
What is a ROS 2 parameter?Why parameters?Example of a node with parametersROS 2 parameters – wrapping things upUsing parameters in your nodesDeclaring, getting, and using parameters with PythonProviding parameters at runtimeParameters with C++Storing parameters in YAML filesLoading parameters from a YAML fileParameters for multiple nodesRecapping all parameters’ data typesAdditional tools for handling parametersGetting parameters’ values from the terminalExporting parameters into YAMLSetting a parameter’s value from the terminalParameter servicesUpdating parameters with parameter callbacksPython parameter callbackC++ parameter callbackParameter challengeChallengeSolutionSummary
Chapter 9: Launch Files – Starting All Your Nodes at Once
What is a ROS 2 launch file?Why launch files?Example of a launch file with seven nodesCreating and installing an XML launch fileSetting up a package for launch filesWriting an XML launch fileInstalling and starting a launch fileCreating a Python launch file – XML or Python for launch files?Writing a Python launch fileXML versus Python for launch filesConfiguring nodes inside a launch fileRenaming nodes and communicationsParameters in a launch fileNamespacesLaunch file challengeChallengeSolutionSummary
Part 3: Creating and Simulating a Custom Robot with ROS 2
Chapter 10: Discovering TFs with RViz
Technical requirementsVisualizing a robot model in RVizInstallation and setupStarting RViz with a robot modelWhat are TFs?LinksTFsRelationship between TFsParent and childThe /tf topicVisualizing the TF treeWhat problem are we trying to solve with TFs?What we want to achieveHow to compute TFsSummary
Chapter 11: Creating a URDF for a Robot
Creating a URDF with a linkSetting up a URDF fileCreating a linkCustomizing the link visualThe process of assembling links and jointsStep 1 – adding a second linkStep 2 – adding a jointStep 3 – fixing the joint originStep 4 – setting up the joint typeStep 5 – fixing the visual originRecap – the process to follow every timeWriting a URDF for a mobile robotWhat we want to achieveAdding the wheelsAdding the caster wheelExtra link – base footprintImproving the URDF with XacroMaking a URDF file compatible with XacroXacro propertiesXacro macrosIncluding a Xacro file in another fileSummary
Chapter 12: Publishing TFs and Packaging the URDF
Understanding how to publish TFs with our URDFThe robot_state_publisher nodeInputs for the robot_state_publisherRecap – how to publish TFsStarting all nodes from the terminalPublishing the TFs from the terminalVisualizing the robot model in RVizCreating a package to install the URDFAdding a new workspaceCreating a _description packageInstalling the URDF and other filesWriting a launch file to publish TFs and visualize the robotThe XML launch fileThe Python launch fileSummary
Chapter 13: Simulating a Robot in Gazebo
Technical requirementsHow Gazebo worksClarifying – Gazebo versus RVizStarting GazeboHow Gazebo works with ROS 2Adapting the URDF for GazeboInertial tagsCollision tagsSpawning the robot in GazeboSpawning the robot from the terminalSpawning the robot from a launch fileControlling the robot in GazeboWhat do we need to do?Adding Gazebo systemsBridging Gazebo and ROS 2 communicationsTesting the robotSummary
Chapter 14: Going Further – What To Do Next
ROS 2 roadmap – exploration phaseCommon stacks and frameworksMore exploration topicsLearning for a specific goalWhat to learn for a project?What to learn to get a job?Summary
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your Thoughts

Overview

Embark on your journey into robotics software development with 'ROS 2 from Scratch'. This book is your hands-on guide to mastering the Robot Operating System (ROS) 2 framework for building robotics applications using Python and C++. With a structured approach, you'll gain the knowledge and confidence needed to develop real-world robotics projects effectively.

What this Book will help me do

Understand the fundamentals of ROS 2, its advantages, and how to begin using it.
Learn to develop ROS 2 applications using core components such as nodes, topics, and services.
Model robots with URDF, simulate them in Gazebo, and visualize with RViz.
Master techniques for creating scalable applications using parameters and launch files.
Develop a fully functional robotics application from conception to simulation and deployment.

Author(s)

Edouard Renard, the author of this comprehensive guide, is a cofounder of a robotics company and has extensive experience in robotics engineering and education. With years of teaching ROS and working on innovative robotics projects, Edouard brings a real-world perspective to this book. He is passionate about making ROS accessible to engineers, researchers, and hobbyists alike, breaking down complex concepts into clear, actionable instructions.

Who is it for?

This book is perfect for engineers, researchers, educators, and hobbyists who are eager to learn ROS 2 and apply it to robotics projects. Whether you're starting from scratch or looking to deepen your understanding of ROS 2, this book caters to beginners in the field of robotics development. It's ideal for learners with a basic grasp of Linux command-line skills and Python, and it's designed to make ROS 2 intuitive and approachable for its readers.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Build a Large Language Model (From Scratch)

Publisher Resources

ISBN: 9781835881408

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills