ROS Actions

Learn to create and run your first action server and client for ROS actions. Explore the simple action interface, one-goal handling, and creating messages and servers.

Learn how to create a ROS action definition, generate the corresponding messages, and implement a simple counter action with goal, result, and feedback for a client-server workflow.

Build a Python-based ROS simple action solver by creating a new package, implementing a simple action server with a goal callback to count to a max and return the result.

Create a ros actions client to send a goal to a simple action server, wait for the server and result, and log outcomes with an optional timeout.

Make your client asynchronous by registering a done callback that signals when the server sets a goal to a terminal state, delivering status and result without blocking.

Learn how to send feedback from the server to the client during a ROS action, by publishing feedback messages and handling callbacks asynchronously.

Determine whether a ROS actions goal succeeds or aborts by checking if the model reaches the target, with the server providing feedback and the client receiving the final result.

Explore how goal status flows in ROS actions, from pending to terminal states, and how the server and client exchange goal IDs and results through status topics.

Enable clients to cancel a goal in ROS actions by signaling a pre-emptive cancellation flag on the server, handling cancellation during execution, and returning a final result.

Explore how to debug ROS actions by listening to goal, feedback, and result topics, observe status transitions from accepted to preempted or aborted, and understand cancel requests.

Use rqt_graph to visualize ROS actions and topics, revealing nodes, the server and client interactions, and how goals, feedback, and results flow through the graph.

Learn to create a C++ simple action server with SimpleActionServer, comparing it to Python, including headers, constructor setup, goal handling, feedback, and preemption.

learn to create a c++ simple action client using simpleactionclient, initialize the client, send goals, and handle active, feedback, and done callbacks while testing with ros nodes.

Create an action definition and run a first action solver and client using simple action server and client classes, sending goals, receiving feedback, and delivering success or failure results.

Learn how to control a robot along a single axis from zero to 100 meters using actions, sending goals with a position and velocity, monitoring feedback, and canceling goals.

Create the action definition and generate the required messages for inter-node communication in ROS actions; configure the workspace, name the action, define goal, result, and feedback, and build with catkin.

Create the simple move robot action server in ROS, implementing a Python and C++ action server with execute callback, feedback, and result handling, including preemption and goal management.

Learn how to cancel a running ROS action goal using a subscriber and a publisher, and explore preemption of prior goals with simple action servers.

Learn to use rqt_graph to visualize the ROS graph, confirm which topics are publishing or subscribing, and debug the move robot workflow by inspecting three publishing topics and two subscribers.

Learn to create a C++ ROS action server for moving a robot, handle goal callbacks, publish feedback, and return results with proper initialization and bindings.

Create a C++ simple action client for the move robot action, wait for the server, and configure done, active, and feedback callbacks with a goal, and use boost::bind for callback.

You build a complete system using the simple action classes, showing how to send goals to the server, handle them, send feedback and results, and cancel from the client.

Explore the full action functionalities in ROS actions with auction seller and auction client classes, and compare them to the simple action class while noting limitations.

Explain the main limitations of simple actions in ROS actions, including single-goal handling, goal mutation canceling callbacks, and why standard action classes suit multi-goal scenarios.

Explore when simple actions fit ROS actions, where simple actions are normal action classes with a preselected goal policy, yet you still generate messages, feedback, results, state and consent.

Explore how a ROS action server manages goals: a client sends a goal, the server accepts or rejects it, updates status, and returns feedback and results.

the action client sends a goal to the action server and tracks its progress using the goal, feedback, and result topics, including cancellation and awaiting the terminal state.

Explore building and testing a ROS actions server and client using action client classes, managing multiple goals, and adjusting the policy for single-goal handling.

Create a ROS action server using the action server pattern, defining goal, feedback, and result callbacks, with threading to support fast cancellation and goal state transitions.

Create a ROS action client using an action plan, handle goal transitions with transition callbacks, and manage client and server state machines for goals, feedback, results, and cancellations.

Handle multiple goals by running parallel processing threads in the action server, using per-goal tracking to allow targeted cancellations without disrupting others.

Demonstrates changing the goal policy to process one active goal at a time, reject new goals on the server when another is processing, and interpret the rejection code.

Place incoming goals into a queue and execute them one at a time using a FIFO approach, ensuring each goal is processed in order.

Learn to implement a C++ ROS action server with ActionServer, handling goals via callbacks, preemption, feedback, and threading, with examples and code.

Learn to create a ROS action client in C++ with ActionClient, initialize the client, and send goals while handling asynchronous startup with a spinner, transitions, and feedback.

Create a complete action, observe the limits of simple actions, and use action plans to manage goals. Handle multiple goals, choose one-at-a-time execution or process queued goals in ROS actions.

This lecture reviews ros actions from simple action solver and simple action count to patterns, including sending a goal from a client to the server and handling many goals concurrently.

Discover where ROS actions are implemented in control messages and the gripper common action, and how goals, feedback, and results enable asynchronous hardware control.