rclpy.action.client module

class rclpy.action.client.ActionClient(node: Node, action_type: type[Action[GoalT, ResultT, FeedbackT, ImplT]], action_name: str, *, callback_group: CallbackGroup | None = None, goal_service_qos_profile: QoSProfile = rclpy.qos.qos_profile_services_default, result_service_qos_profile: QoSProfile = rclpy.qos.qos_profile_services_default, cancel_service_qos_profile: QoSProfile = rclpy.qos.qos_profile_services_default, feedback_sub_qos_profile: QoSProfile = rclpy.qos.QoSProfile, status_sub_qos_profile: QoSProfile = rclpy.qos.qos_profile_action_status_default, enable_feedback_msg_optimization: bool = False)

Bases: Generic[GoalT, ResultT, FeedbackT, ImplT], Waitable[ClientGoalHandleDict[ResultT, FeedbackT]]

ROS Action client.

Create an ActionClient.

When multiple action clients connect to the same action server, the subscription for receiving feedback messages inside each action client will first receive all feedback messages, and then determine which feedback belongs to itself based on goal ID. When enable_feedback_msg_optimization is set to true, the content filter is used to configure the goal ID for the subscription, which helps avoid the reception of irrelevant feedback messages internally for each action client.

If enable_feedback_msg_optimization is set to true, an action client can handle up to 6 goals simultaneously. This optimization takes advantage of the content filter feature. According to the DDS specification, the maximum number of parameters supported by content filter is 100. Configuring one goal ID consumes 16 parameters, so at most, 6 goal IDs can be set simultaneously. If the number of goals exceeds the limit, optimization is automatically disabled. If the rmw implementation doesn’t support content filter, optimization is also automatically disabled.

Even if the RMW implementation supports the content filter feature, different RMW implementations may impose restrictions on the content filter expression. For example, in ConnextDDS, the RMW_CONNEXT_CONTENTFILTER_PROPERTY_MAX_LENGTH setting affects the available length of content filter expressions. When this limit is reached, the optimization will be automatically disabled.

Parameters:

  • node – The ROS node to add the action client to.

  • action_type – Type of the action.

  • action_name – Name of the action. Used as part of the underlying topic and service names.

  • callback_group – Callback group to add the action client to. If None, then the node’s default callback group is used.

  • goal_service_qos_profile – QoS profile for the goal service.

  • result_service_qos_profile – QoS profile for the result service.

  • cancel_service_qos_profile – QoS profile for the cancel service.

  • feedback_sub_qos_profile – QoS profile for the feedback subscriber.

  • status_sub_qos_profile – QoS profile for the status subscriber.

  • enable_feedback_msg_optimization – Enable feedback subscription content filter to optimize the handling of feedback messages.

add_to_wait_set(wait_set: rpyutils.import_c_library.WaitSet) → None

Add entities to wait set.

configure_introspection(clock: rclpy.clock.Clock, service_event_qos_profile: rclpy.qos.QoSProfile, introspection_state: rpyutils.import_c_library.service_introspection.ServiceIntrospectionState) → None

Configure action client introspection.

Parameters:

  • clock – Clock to use for generating timestamps.

  • service_event_qos_profile – QoSProfile to use when creating service event publisher.

  • introspection_state – ServiceIntrospectionState to set introspection.

destroy() → None

Destroy the underlying action client handle.

async execute(taken_data: ClientGoalHandleDict[ResultT, FeedbackT]) → None

Execute work after data has been taken from a ready wait set.

This will set results for Future objects for any received service responses and call any user-defined callbacks (e.g. feedback).

get_num_entities() → NumberOfEntities

Return number of each type of entity used in the wait set.

is_ready(wait_set: rpyutils.import_c_library.WaitSet) → bool

Return True if one or more entities are ready in the wait set.

send_goal(goal: GoalT, **kwargs: Unpack[SendGoalKWargs[FeedbackT]]) → GetResultServiceResponse[ResultT] | None

Send a goal and wait for the result.

Do not call this method in a callback or a deadlock may occur.

See send_goal_async() for more info about keyword arguments.

Unlike send_goal_async(), this method returns the final result of the action (not a goal handle).

Parameters:

goal (action_type.Goal) – The goal request.

Returns:

The result response.

Return type:

action_type.Result

Raises:

TypeError if the type of the passed goal isn’t an instance of the Goal type of the provided action when the service was constructed.

send_goal_async(goal: GoalT, feedback_callback: FeedbackCallbackUnion[FeedbackT] | None = None, goal_uuid: UUID | None = None) → Future[ClientGoalHandle[GoalT, ResultT, FeedbackT, ImplT]]

Send a goal and asynchronously get the result.

The result of the returned Future is set to a ClientGoalHandle when receipt of the goal is acknowledged by an action server.

Parameters:

  • goal (action_type.Goal) – The goal request.

  • feedback_callback (function) – Callback function for feedback associated with the goal.

  • goal_uuid – Universally unique identifier for the goal. If None, then a random UUID is generated.

Type:

unique_identifier_msgs.UUID

Returns:

a Future instance to a goal handle that completes when the goal request has been accepted or rejected.

Return type:

rclpy.task.Future instance

Raises:

TypeError if the type of the passed goal isn’t an instance of the Goal type of the provided action when the service was constructed.

server_is_ready() → bool

Check if there is an action server ready to process requests from this client.

Returns:

True if an action server is ready, False otherwise.

take_data() → ClientGoalHandleDict[ResultT, FeedbackT]

Take stuff from lower level so the wait set doesn’t immediately wake again.

wait_for_server(timeout_sec: float | None = None) → bool

Wait for an action sever to be ready.

Returns as soon as an action server is ready for this client.

Parameters:

timeout_sec – Number of seconds to wait until an action server is available. If None, then wait indefinitely.

Returns:

True if an action server is available, False if the timeout is exceeded.

class rclpy.action.client.ClientGoalHandle(action_client: ActionClient[GoalT, ResultT, FeedbackT, ImplT], goal_id: unique_identifier_msgs.msg.UUID, goal_response: SendGoalServiceResponse)

Bases: Generic[GoalT, ResultT, FeedbackT, ImplT]

Goal handle for working with Action Clients.

property accepted: bool
cancel_goal() → action_msgs.srv.CancelGoal.Response | None

Send a cancel request for the goal and wait for the response.

Do not call this method in a callback or a deadlock may occur.

Returns:

The cancel response.

cancel_goal_async() → Future[action_msgs.srv.CancelGoal.Response]

Asynchronous request for the goal be canceled.

Returns:

a Future instance that completes when the server responds.

Return type:

rclpy.task.Future instance

get_result() → GetResultServiceResponse[ResultT] | None

Request the result for the goal and wait for the response.

Do not call this method in a callback or a deadlock may occur.

Returns:

The result response.

get_result_async() → Future[GetResultServiceResponse[ResultT]]

Asynchronously request the goal result.

Returns:

a Future instance that completes when the result is ready.

Return type:

rclpy.task.Future instance

property goal_id: unique_identifier_msgs.msg.UUID
property stamp: builtin_interfaces.msg.Time
property status: int