`/detect_dock`#

Caution

This documentation page has been auto-generated.

It may be missing some details.

/detect_dock Quick Facts

Category: 🧭 Navigation
Message type: pal_nav2_msgs/action/DetectTarget

Action Server responsible for detecting and localizing an specific dock station with respect to the robot. It can load multiple plugins for the detection of different dock stations using different sensors.

For more information, check the 📡 Target Detection.

Quick snippets#

Send a goal from the command-line#

$ ros2 action send_goal /detect_dock pal_nav2_msgs/action/DetectTarget # press Tab to complete the message prototype

How to use in your code#

Call the action from a Python script#

#!/usr/bin/env python

import rclpy
from rclpy.action import ActionClient
from rclpy.node import Node

from pal_nav2_msgs.action import DetectTarget

class DetectDockActionClient(Node):

    def __init__(self):
        super().__init__('detect_dock_client')
        self._action_client = ActionClient(self, DetectTarget, '/detect_dock')

    def send_goal(self, a, b):
        goal_msg = DetectTarget.Goal()

        # TODO: adapt to the action's parameters
        # check the pal_nav2_msgs/action/DetectTargetGoal message
        # definition for the possible goal parameters
        # goal_msg.a = a
        # goal_msg.b = b

        self._action_client.wait_for_server()

        return self._action_client.send_goal_async(goal_msg)

if __name__ == '__main__':
    rclpy.init(args=args)

    action_client = DetectDockActionClient()

    # TODO: adapt to your action's parameters
    future = action_client.send_goal(a, b)

    rclpy.spin_until_future_complete(action_client, future)

    rclpy.shutdown()

Call the action from a C++ program#

#include <functional>
#include <future>
#include <memory>
#include <string>
#include <sstream>
#include <chrono>

#include "pal_nav2_msgs/action/detect_target.hpp"

#include "rclcpp/rclcpp.hpp"
#include "rclcpp_action/rclcpp_action.hpp"
#include "rclcpp_components/register_node_macro.hpp"

using namespace std::chrono_literals;
using namespace std;

class DetectDockActionClient : public rclcpp::Node
{
public:
  using DetectTarget = pal_nav2_msgs::action::DetectTarget;
  using GoalHandleDetectTarget = rclcpp_action::ClientGoalHandle<DetectTarget>;

  explicit DetectDockActionClient(const rclcpp::NodeOptions & options)
  : Node("detect_dock_action_client", options)
  {
    this->client_ptr_ = rclcpp_action::create_client<DetectTarget>(
            this,
            "/detect_dock");

    this->timer_ = this->create_wall_timer(
            500ms,
            bind(&DetectDockActionClient::send_goal, this));
  }

  void send_goal()
  {
    using namespace std::placeholders;

    this->timer_->cancel();

    if (!this->client_ptr_->wait_for_action_server()) {
      RCLCPP_ERROR(this->get_logger(), "Action server not available after waiting");
      rclcpp::shutdown();
    }

    auto goal_msg = DetectTarget::Goal();

    // check the pal_nav2_msgs/action/DetectTargetGoal message
    // definition for the possible goal parameters
    // goal_msg.... = ...;

    RCLCPP_INFO(this->get_logger(), "Sending goal");

    auto send_goal_options = rclcpp_action::Client<DetectTarget>::SendGoalOptions();

    send_goal_options.goal_response_callback =
        bind(&DetectDockActionClient::goal_response_callback, this, _1);

    send_goal_options.feedback_callback =
        bind(&DetectDockActionClient::feedback_callback, this, _1, _2);

    send_goal_options.result_callback =
        bind(&DetectDockActionClient::result_callback, this, _1);


    this->client_ptr_->async_send_goal(goal_msg, send_goal_options);
  }

private:
  rclcpp_action::Client<DetectTarget>::SharedPtr client_ptr_;
  rclcpp::TimerBase::SharedPtr timer_;

  void goal_response_callback(const GoalHandleDetectTarget::SharedPtr & goal_handle)
  {
    if (!goal_handle) {
      RCLCPP_ERROR(this->get_logger(), "Goal was rejected by server");
    } else {
      RCLCPP_INFO(this->get_logger(), "Goal accepted by server, waiting for result");
    }
  }

  void feedback_callback(
      GoalHandleDetectTarget::SharedPtr,
      const shared_ptr<const DetectTarget::Feedback> feedback)
  {
    stringstream ss;
    ss << "Next number in sequence received: ";
    for (auto number : feedback->partial_sequence) {
      ss << number << " ";
    }
    RCLCPP_INFO(this->get_logger(), ss.str().c_str());
  }

  void result_callback(const GoalHandleDetectTarget::WrappedResult & result)
  {
    switch (result.code) {
      case rclcpp_action::ResultCode::SUCCEEDED:
          break;
      case rclcpp_action::ResultCode::ABORTED:
          RCLCPP_ERROR(this->get_logger(), "Goal was aborted");
          return;
      case rclcpp_action::ResultCode::CANCELED:
          RCLCPP_ERROR(this->get_logger(), "Goal was canceled");
          return;
      default:
          RCLCPP_ERROR(this->get_logger(), "Unknown result code");
          return;
    }
    stringstream ss;
    ss << "Result received: ";
    for (auto number : result.result->sequence) {
      ss << number << " ";
    }
    RCLCPP_INFO(this->get_logger(), ss.str().c_str());
    rclcpp::shutdown();
  }
};  // class DetectDockActionClient


RCLCPP_COMPONENTS_REGISTER_NODE(DetectDockActionClient)

/detect_dock#

Quick snippets#

How to use in your code#

`/detect_dock`#