ROS 2 for Beginners Level 3 - Advanced Concepts

Explore ROS 2 actions, alongside topics and services, through a hands-on, three-section course that uses Python and C++, and learn why you need actions.

Explore why ROS 2 actions exist and when to use them, contrasted with topics and services. Learn how actions provide cancellation, feedback, and concurrent request handling.

Create a ROS 2 action definition for counting to a target number, including goal, result, feedback, and cancel mechanism, and set up a workspace and package to generate interfaces.

Learn how to implement a minimal ros2 python action server that accepts goals, counts to a target with a delay, and returns a result, while wiring and building actions_py package.

Create a minimal python action client to send a goal to a ROS 2 action server, wait for the server, and receive the result via asynchronous callbacks.

Learn to implement a python action server that accepts or rejects a goal via a goal callback, validating the target number and guiding the client result flow.

Explore the goal state machine in ROS 2 actions, detailing client-server interactions, goal acceptance, execution, cancellation, and final states of succeeded or aborted, with per-goal state tracking.

Learn how to set a ROS 2 goal as succeeded or aborted by finishing the execute callback, checking statuses in the client, and handling final states with practical examples.

Learn to send feedback from server to client in a ROS 2 action. The client receives feedback during execution via a callback, including the current number, before the final result.

Explore canceling a goal in ROS 2 actions by implementing a cancel callback, managing state transitions to canceled, and testing with a timer and multi-threaded executor.

Learn to introspect and debug ros2 actions from the command line. List actions, inspect nodes, topics, and services, and test simple goals with the send goal workflow.

Choose goal policies for ROS 2 action servers, including parallel execution, one goal at a time, and preemption. Use a multi-threaded executor and reentrant callback group to run goals concurrently.

Demonstrate a ROS 2 goal policy that rejects new goals while the current goal is active, using a multithreaded executor, goal handles, and a thread lock for safety.

Preempt the current goal when a new goal is received by validating the incoming goal, aborting the active goal via its goal handle, and starting the new goal.

Learn how to implement a queue-based goal policy in ROS 2, accepting incoming goals, enqueuing them in a goal queue, and executing sequentially with a handle accepted callback.

write a complete C++ action server and client in ROS 2, and implement different goal policies. Compare C++ with Python approaches and follow the recommended order for mastering actions.

Learn to build a minimal ROS 2 C++ action server by implementing goal, cancel, and handle accepted callbacks. Execute the goal to count to a target and return the result.

Learn to implement a minimal C++ action client in ROS 2, sending a goal to an action server, and handling the result with a dedicated callback using send goal options.

Explore accepting or rejecting goals in ROS 2 action servers with C++; implement the goal callback, decide acceptance, and handle results via the client's goal response callback.

Set a goal as succeeded or aborted and query its status from the client, using the server-side execution and the action result code to determine final states.

Learn the publish/subscribe feedback mechanism in ROS 2 actions, where the server publishes feedback during goal execution and the client processes it via a feedback callback.

Explore implementing a ROS 2 action cancel mechanism: accept cancel requests, set the goal to canceling, then finalize as canceled, with a multithreaded executor and callback group for testing.

Explore the goal policy for handling multiple goals in parallel, accepting all goals and processing them concurrently with an action server using a multi-threaded executor and re-entrant callback group.

Enforce a one-goal-at-a-time policy by tracking the active goal and rejecting new goals. Use a mutex to guard access for thread safety with a multi-threaded, reentrant callback group.

Implement a preemptive goal policy that replaces the current goal with a new valid goal, aborting the active goal and returning the result, with data validation and mutex handling.

Implement a queue-based goal policy in ROS 2 by enqueuing accepted goals and executing them one by one in a dedicated thread; compare C++ and Python approaches.

Develop and test a ROS 2 action client and server to move a robot along an axis from 0 to 100, using a goal, velocity, feedback, and cancelable preemption policy.

Create and generate the move robot action in the my robot interfaces package, defining goal, result, and feedback in that order, then build and source the environment.

Implement a minimal ROS 2 action server in Python that accepts a move robot goal (position and velocity), updates the robot position toward the target with feedback, and returns success.

Learn to implement a ROS 2 move robot action client from scratch, creating an action client, sending asynchronous goals, and handling feedback, results, and status callbacks.

This lecture validates incoming goals (position 0 to 100, positive velocity) and implements a preemptive goal policy with a multi-threaded executor to abort active goals on new requests.

Implement a server-side cancel mechanism and add a client-side cancel subscriber to publish a cancel request using a goal handle to cancel goals.

Build and test ROS 2 actions using C++ by implementing a move robot server and client with callbacks, goal validation, and a multi-threaded executor, mirroring the Python solution.

Explore life cycle nodes and learn why and when to use them. Implement a life cycle node with Python and C plus plus, and distinguish them from actions.

Master how ROS 2 lifecycle nodes use a state machine to manage unconfigured, inactive, and active lifecycles, with on configure, on activate, and on shutdown transitions.

Start from an existing number publisher and transform it into a lifecycle node, then build and run python and c++ lifecycle packages from the code.

Write a ROS 2 lifecycle node in Python, implementing on_configure, on_activate, on_cleanup and other lifecycle callbacks, managing transitions from unconfigured to inactive to active, and using a lifecycle publisher.

Learn how to trigger and test transition between states of a ros2 lifecycle node from the terminal using the ros2 lifecycle cli, including configure, activate, deactivate, and shutdown.

Explore ROS 2 lifecycle error processing, detailing the on error callback and transitions between unconfigured and finalized, with guidance on when to use or bypass it.

Create a lifecycle node manager that orchestrates transitions for one or more lifecycle nodes using ROS 2 services, enabling configure, activate, and state changes via change state and get state.

Launch a lifecycle node from a dedicated launch file using xml or python, and manage transitions with a lifecycle node manager to configure and activate the node.

Develop a C++ lifecycle node by adapting a Python example, implementing on_configure, on_activate, on_deactivate, on_cleanup, on_shutdown, and on_error, and utilize a lifecycle publisher and timer.

Practice implementing lifecycle nodes by turning a server into a lifecycle node, adding an activation mechanism, configuring multiple robot servers, and sequencing the configure and activate transitions.

Transform a ros 2 node into a lifecycle node, implementing on configure, on activate, and on deactivate to manage an action server with an activation flag.

Start multiple lifecycle nodes representing different robots, configure per-node action servers via a robot name parameter, and launch them together with an XML launch file for parallel operation.

Configure and activate multiple lifecycle nodes in ROS 2 with a lifecycle node manager that coordinates a list of node names and applies configure and activate transitions in order.

Learn to implement a ROS 2 life cycle node in C++ by adapting the move robot server from Python, covering activation, deactivation, and a life cycle action server.

Explore executors and spin mechanisms in ROS 2, learn to configure callbacks and callback groups, and grasp multithreading fundamentals to accelerate your advanced concepts journey.

Explore how callbacks and the spin mechanism operate in ROS 2, and how executors manage node callbacks, including single and multi-threaded executors, contexts, and spin behavior.

Use the single threaded executor in ROS 2 by adding a node and spinning the executor, so callbacks run sequentially and avoid race conditions with timers or hardware.

Explore how to use a multi threaded executor in ROS 2, configure reentrant and mutually exclusive callback groups, and observe parallel and serialized callbacks with timers and nodes.

Compare single threaded and multi threaded executors and determine when to use each. Learn how to pair callbacks with re-entrant or exclusive groups to avoid deadlocks and enable parallel execution.

Explore how to implement an action server in ROS 2 using a multithreaded executor and a reentrant callback group to run parallel goals, handle cancels, and apply a goal policy.

Run several nodes in one executable by manual composition, adding multiple nodes to a single executor, and configure single-threaded or multithreaded executors with mutually exclusive and re-entrant callback groups.

discover how to use c++ ros 2 executors, including single-threaded and multi-threaded modes, create and add nodes, and configure callback groups for timers, services, actions, and subscriptions.

Explore ROS 2 components and composition, learn to run multiple nodes in a single executable to save memory, and examine manual composition for Python and C++, runtime composition in C++.

Master manual composition in ROS 2 with Python by splitting nodes into separate files, importing them, and running them under a single or multi threaded executor.

Learn manual composition in C++ by running multiple ROS 2 nodes in one executor, splitting nodes into header and cpp files, and configuring includes for proper builds.

Create a ros 2 c++ component loaded at runtime in a component container by removing the main function, adding node options, registering the component, and using a number publisher example.

Learn to load and unload ROS 2 components at runtime with ros2 component cmd line, use a component container, and choose between single threaded, multi threaded, or isolated executors.

Learn to load ROS 2 components from a launch file, using Python and XML, by creating a component container, composing nodes, and launching from a launch description.

Execute a final ROS 2 project that builds actions, executables, lifecycle nodes, and components, using launch files to simulate and control a turtle in Gazebo with an action server.

Explore building a ROS 2 turtle controller: spawn and kill turtles in turtle sim via service clients, with a base node using a multi-threaded executor and a turtle-name parameter.

Create an action server for a turtle in turtle sim, defining the move turtle action with linear x and angular z velocities and a duration for success or failure result.

Transform the turtle controller into a ROS 2 lifecycle node, implement on configure and on cleanup, and introduce activation logic to manage the action server.

Adapt a lifecycle node into a reusable component for runtime loading inside a component container. Configure namespaces, node options, and cpp component registration, then build and load multiple components.

Launch a single XML launch file to start turtle sim, load a multi-threaded component container, and configure and activate a lifecycle node for the turtle controller in ROS 2.

Adapt code to control a Turtlebot3 in gazebo by publishing to the cmd_vel topic with a twist message, bridging ROS 2 Humble with a level 2 project for differential-drive robots.

Plan your next steps by rewatching explanations or tackling challenges, and explore Ros 2 control, the navigation stack, and moveit for mobile robots or robotic arms.