ROS1&2 액션 예제 (C++)

[한창호]

* ROS1 액션 (Action)

구분	설명
액션	Action은 비동기식과 동기식 양방향 메시지 송수신 방식이다. 액션 Goal (목표)를 지정하는 Action client 와 액션 Goal을 받아 특정 태스크를 수행하면서 중간 진행값에 해당되는 액션 Feedback과 최종 결과값에 해당되는 액션 Result를 전송한다. Service와 비슷하게 다른 node에서 제공하는 기능을 호출한다. 단, service를 호출할 경우 그 service가 끝날 때까지 기다려야 하지만, action은 기다리지 않는다.
서버와 클라이언트	Action Client와 Action Server 간의 Interface  - 액션에서 Server와 Client간의 통신 (Goal, Feedback, Result)을 보여주고 있다.
Action Server
Action Client
Action Interface

Library 참고 actionlib::SimpleActionServer

* ROS1 피보나치 예제 샘플   (http://wiki.ros.org/actionlib_tutorials)

단계	설명
피보나치 수열 (wiki)
패키지 생성	$ cd ~/catkin_ws/src $ catkin_create_pkg actionlib_tutorials actionlib message_generation roscpp rospy std_msgs actionlib_msgs $ cd actionlib_tutorials
package.xml	<?xml version="1.0"?> <package format="2">   <name>my_custom_action_msg_pkg</name>   <version>0.0.0</version>   <description>The my_custom_action_msg_pkg package</description>   <maintainer email="user@todo.todo">user</maintainer>   <license>TODO</license>     <buildtool_depend>catkin</buildtool_depend>     <build_depend>actionlib</build_depend>   <build_depend>actionlib_msgs</build_depend>   <build_depend>roscpp</build_depend>   <build_depend>rospy</build_depend>   <build_depend>std_msgs</build_depend>     <build_export_depend>actionlib</build_export_depend>   <build_export_depend>actionlib_msgs</build_export_depend>   <build_export_depend>roscpp</build_export_depend>   <build_export_depend>rospy</build_export_depend>   <build_export_depend>std_msgs</build_export_depend>   <exec_depend>actionlib</exec_depend>   <exec_depend>actionlib_msgs</exec_depend>   <exec_depend>roscpp</exec_depend>   <exec_depend>rospy</exec_depend>   <exec_depend>std_msgs</exec_depend>   <exec_depend>message_generation</exec_depend>   <export>   </export> </package>
CMakeList.txt 수정	cmake_minimum_required(VERSION 2.8.3) project(my_custom_action_msg_pkg)   ## Find catkin macros and libraries find_package(catkin REQUIRED COMPONENTS   actionlib   actionlib_msgs   message_generation   roscpp   rospy   std_msgs )   ## Generate actions in the 'action' folder add_action_files(    DIRECTORY action    FILES  Fibonacci.action  )   ## Generate added messages and services with any dependencies listed here generate_messages(    DEPENDENCIES       actionlib_msgs  std_msgs   )   catkin_package(   CATKIN_DEPENDS actionlib actionlib_msgs message_generation roscpp rospy std_msgs )   ## Specify additional locations of header files include_directories(   ${catkin_INCLUDE_DIRS} ) add_executable(fibonacci_server src/fibonacci_server.cpp) add_executable(fibonacci_client src/fibonacci_client.cpp) target_link_libraries( fibonacci_server  ${catkin_LIBRARIES} ) target_link_libraries( fibonacci_client  ${catkin_LIBRARIES} ) add_dependencies(   fibonacci_server   fibonacci_client   ${actionlib_tutorials_EXPORTED_TARGETS} )
Action 메시지 파일 Fibonacci.action	$ mkdir action $ vi action/Fibonacci.action #goal definition int32 order --- #result definition int32[] sequence --- #feedback int32[] sequence
액션 서버	$ vi src/fibonacci_server.cpp #include <ros/ros.h> #include <actionlib/server/simple_action_server.h> #include <actionlib_tutorials/FibonacciAction.h> class FibonacciAction { protected:   ros::NodeHandle nh_;   actionlib::SimpleActionServer<actionlib_tutorials::FibonacciAction> as_; // NodeHandle instance must be created before this line. Otherwise strange error occurs.   std::string action_name_;   // create messages that are used to published feedback/result   actionlib_tutorials::FibonacciFeedback feedback_;   actionlib_tutorials::FibonacciResult result_; public:   FibonacciAction(std::string name) :     as_(nh_, name, boost::bind(&FibonacciAction::executeCB, this, _1), false), action_name_(name)   {     as_.start();   }   ~FibonacciAction(void)  {  }   void executeCB(const actionlib_tutorials::FibonacciGoalConstPtr &goal)   {     // helper variables     ros::Rate r(1);     bool success = true;     // push_back the seeds for the fibonacci sequence     feedback_.sequence.clear();     feedback_.sequence.push_back(0);     feedback_.sequence.push_back(1);     // publish info to the console for the user     ROS_INFO("%s: Executing, creating fibonacci sequence of order %i with seeds %i, %i",            action_name_.c_str(),           goal->order,           feedback_.sequence[0],           feedback_.sequence[1]);     // start executing the action     for(int i=1; i<=goal->order; i++)     {       // check that preempt has not been requested by the client       if (as_.isPreemptRequested() || !ros::ok())       {         ROS_INFO("%s: Preempted", action_name_.c_str());  // 액션이 이미 선점되었다.         // set the action state to preempted         as_.setPreempted();         success = false;         break;       }       feedback_.sequence.push_back(feedback_.sequence[i] + feedback_.sequence[i-1]);       // publish the feedback       as_.publishFeedback(feedback_);       // this sleep is not necessary, the sequence is computed at 1 Hz for demonstration purposes       r.sleep();     }     if(success) {       result_.sequence = feedback_.sequence;       ROS_INFO("%s: Succeeded", action_name_.c_str());       // set the action state to succeeded       as_.setSucceeded(result_);     }   } }; int main(int argc, char** argv) {   ros::init(argc, argv, "fibonacci");   FibonacciAction fibonacci("fibonacci");   ros::spin();   return 0; }
액션 클라이언트	$ vi src/fibonacci_client.cpp #include <ros/ros.h> #include <actionlib/client/simple_action_client.h> #include <actionlib_tutorials/FibonacciAction.h> using namespace actionlib_tutorials; typedef actionlib::SimpleActionClient<FibonacciAction> Client; class MyNode { public:   MyNode() : ac("fibonacci", true)   {     ROS_INFO("Waiting for action server to start.");     ac.waitForServer();  //액션은 비동기라서 기다리는 함수가 필요하다. 이때 다른 작업이 가능하다.     ROS_INFO("Action server started, sending goal.");   }   void doStuff(int order)   {     FibonacciGoal goal;     goal.order = order;     // Need boost::bind to pass in the 'this' pointer     ac.sendGoal(goal,                 boost::bind(&MyNode::doneCb, this, _1, _2),                 Client::SimpleActiveCallback(),                 Client::SimpleFeedbackCallback());   }   void doneCb(const actionlib::SimpleClientGoalState& state,               const FibonacciResultConstPtr& result)   {     ROS_INFO("Finished in state [%s]", state.toString().c_str());     ROS_INFO("Answer: %i", result->sequence.back());     ros::shutdown();   } private:   Client ac; }; int main (int argc, char **argv) {   ros::init(argc, argv, "test_fibonacci_class_client");   MyNode my_node;   my_node.doStuff(10);   ros::spin();   return 0; }
컴파일	$ cd ~/catkin_ws $ catkin_make $ source ~/catkin_ws/devel/setup.bash # 생성된 파일 확인하기 $ ls ~/catkin_ws/devel/share/actionlib_tutorials/msg/ FibonacciActionFeedback.msg  FibonacciAction.msg        FibonacciFeedback.msg FibonacciResult.msg          FibonacciActionGoal.msg    FibonacciActionResult.msg  FibonacciGoal.msg $ ls ~/catkin_ws/devel/include/actionlib_tutorials/ FibonacciActionFeedback.h  FibonacciAction.h        FibonacciFeedback.h  FibonacciResult.h FibonacciActionGoal.h      FibonacciActionResult.h  FibonacciGoal.h
액션 msg 조회	$ rosmsg list | grep Fibonacci actionlib_tutorials/FibonacciAction actionlib_tutorials/FibonacciActionFeedback actionlib_tutorials/FibonacciActionGoal actionlib_tutorials/FibonacciActionResult actionlib_tutorials/FibonacciFeedback actionlib_tutorials/FibonacciGoal actionlib_tutorials/FibonacciResult
실행	$ roscore $ rosrun actionlib_tutorials fibonacci_server [ INFO] [1708993303.652838775]: fibonacci: Executing, creating fibonacci sequence of order 10 with seeds 0, 1 [ INFO] [1708993313.653343846]: fibonacci: Succeeded $ rosrun actionlib_tutorials fibonacci_client [ INFO] [1708993303.429043892]: Waiting for action server to start. [ INFO] [1708993303.651961541]: Action server started, sending goal. [ INFO] [1708993313.656749030]: Finished in state [SUCCEEDED] [ INFO] [1708993313.657268588]: Answer: 89
액션 Feedback	$ roscore $ rosrun actionlib_tutorials fibonacci_server $ rosrun actionlib_tutorials fibonacci_client # 액션이 끝나기 전에 다음을 실행하면, feedback에 대한 정보가 출력된다. $ rostopic echo /fibonacci/feedback header:    seq: 18   stamp:      secs: 1708993537     nsecs: 308300153   frame_id: '' status:    goal_id:      stamp:        secs: 1708993529       nsecs: 306617996     id: "/test_fibonacci_class_client-1-1708993529.306617996"   status: 1   text: "This goal has been accepted by the simple action server" feedback:    sequence: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55] ---
액션 Result	$ roscore $ rosrun actionlib_tutorials fibonacci_server $ rosrun actionlib_tutorials fibonacci_client # 액션이 끝나기 전에 다음을 실행하면, 액션이 끝나면서 result에 대한 정보가 출력된다. $ rostopic echo /fibonacci/result header:    seq: 3   stamp:      secs: 1708993724     nsecs: 732221455   frame_id: '' status:    goal_id:      stamp:        secs: 1708993714       nsecs: 730927374     id: "/test_fibonacci_class_client-1-1708993714.730927374"   status: 3   text: '' result:    sequence: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] ---
rqt_graph
토픽 조회	$ rostopic list -v Published topics:  * /rosout_agg [rosgraph_msgs/Log] 1 publisher  * /rosout [rosgraph_msgs/Log] 2 publishers  * /turtle1/pose [turtlesim/Pose] 1 publisher  * /turtle1/color_sensor [turtlesim/Color] 1 publisher  * /fibonacci/result [actionlib_tutorials/FibonacciActionResult] 1 publisher  * /fibonacci/feedback [actionlib_tutorials/FibonacciActionFeedback] 1 publisher  * /fibonacci/status [actionlib_msgs/GoalStatusArray] 1 publisher Subscribed topics:  * /rosout [rosgraph_msgs/Log] 1 subscriber  * /turtle1/cmd_vel [geometry_msgs/Twist] 1 subscriber  * /fibonacci/goal [actionlib_tutorials/FibonacciActionGoal] 1 subscriber  * /fibonacci/cancel [actionlib_msgs/GoalID] 1 subscriber

* ROS1 Action 예제 - actionlib_tutorials/Tutorials/SimpleActionServer(GoalCallbackMethod) - ROS Wiki

단계	설명
패키지 생성
CMakeLists.txt	add_executable(averaging_server src/averaging_server.cpp) target_link_libraries(averaging_server ${catkin_LIBRARIES}) add_executable(averaging_client src/averaging_client.cpp) target_link_libraries(averaging_client ${catkin_LIBRARIES})
package.xml
서버 코드	#include <ros/ros.h> #include <std_msgs/Float32.h> #include <actionlib/server/simple_action_server.h> #include <actionlib_tutorials/AveragingAction.h> class AveragingAction { public:        AveragingAction(std::string name) :      as_(nh_, name, false),     action_name_(name)   {     //register the goal and feeback callbacks     as_.registerGoalCallback(boost::bind(&AveragingAction::goalCB, this));     as_.registerPreemptCallback(boost::bind(&AveragingAction::preemptCB, this));     //subscribe to the data topic of interest     sub_ = nh_.subscribe("/random_number", 1, &AveragingAction::analysisCB, this);     as_.start();   }   ~AveragingAction(void)  {  }   void goalCB()   {     // reset helper variables     data_count_ = 0;     sum_ = 0;     sum_sq_ = 0;     // accept the new goal     goal_ = as_.acceptNewGoal()->samples;   }   void preemptCB()   // 선점   {     ROS_INFO("%s: Preempted", action_name_.c_str());     // set the action state to preempted     as_.setPreempted();   }   void analysisCB(const std_msgs::Float32::ConstPtr& msg)   {     // make sure that the action hasn't been canceled     if (!as_.isActive())       return;          data_count_++;     feedback_.sample = data_count_;     feedback_.data = msg->data;     //compute the std_dev and mean of the data      sum_ += msg->data;     feedback_.mean = sum_ / data_count_;     sum_sq_ += pow(msg->data, 2);     feedback_.std_dev = sqrt(fabs((sum_sq_/data_count_) - pow(feedback_.mean, 2)));     as_.publishFeedback(feedback_);     if(data_count_ > goal_)      {       result_.mean = feedback_.mean;       result_.std_dev = feedback_.std_dev;       if(result_.mean < 5.0)       {         ROS_INFO("%s: Aborted", action_name_.c_str());         //set the action state to aborted         as_.setAborted(result_);       }       else        {         ROS_INFO("%s: Succeeded", action_name_.c_str());         // set the action state to succeeded         as_.setSucceeded(result_);       }     }    } protected:        ros::NodeHandle nh_;   actionlib::SimpleActionServer<actionlib_tutorials::AveragingAction> as_;   std::string action_name_;   int data_count_, goal_;   float sum_, sum_sq_;   actionlib_tutorials::AveragingFeedback feedback_;   actionlib_tutorials::AveragingResult result_;   ros::Subscriber sub_; }; int main(int argc, char** argv) {   ros::init(argc, argv, "averaging");   AveragingAction averaging(ros::this_node::getName());   ros::spin();   return 0; }
클라이언트 코드	#include <ros/ros.h> #include <actionlib/client/simple_action_client.h> #include <actionlib/client/terminal_state.h> #include <actionlib_tutorials/AveragingAction.h> #include <boost/thread.hpp> void spinThread() {   ros::spin(); } int main (int argc, char **argv) {   ros::init(argc, argv, "test_averaging");   // create the action client   actionlib::SimpleActionClient<actionlib_tutorials::AveragingAction> ac("averaging");   boost::thread spin_thread(&spinThread);   ROS_INFO("Waiting for action server to start.");   ac.waitForServer();   ROS_INFO("Action server started, sending goal.");   // send a goal to the action   actionlib_tutorials::AveragingGoal goal;   goal.samples = 100;   ac.sendGoal(goal);   //wait for the action to return   bool finished_before_timeout = ac.waitForResult(ros::Duration(30.0));   if (finished_before_timeout)   {     actionlib::SimpleClientGoalState state = ac.getState();     ROS_INFO("Action finished: %s",state.toString().c_str());   }   else     ROS_INFO("Action did not finish before the time out.");   // shutdown the node and join the thread back before exiting   ros::shutdown();   spin_thread.join();   //exit   return 0; }
실행	$ roscore $ rosrun actionlib_tutorials averaging_server $ rosrun actionlib_tutorials averaging_client
서버	$ rostopic list -v Published topics:  * /averaging/status [actionlib_msgs/GoalStatusArray] 1 publisher  * /averaging/result [actionlib_tutorials/AveragingActionResult] 1 publisher  * /averaging/feedback [actionlib_tutorials/AveragingActionFeedback] 1 publisher  * /rosout [roslib/Log] 1 publisher  * /rosout_agg [roslib/Log] 1 publisher Subscribed topics:  * /time [unknown type] 2 subscribers  * /rosout [roslib/Log] 1 subscriber  * /averaging/goal [unknown type] 1 subscriber  * /averaging/cancel [unknown type] 1 subscriber
클라이언트	$ rostopic list -v Published topics:  * /averaging/goal [actionlib_tutorials/AveragingActionGoal] 1 publisher  * /averaging/cancel [actionlib/GoalID] 1 publisher  * /rosout [roslib/Log] 1 publisher  * /rosout_agg [roslib/Log] 1 publisher Subscribed topics:  * /time [unknown type] 2 subscribers  * /rosout [roslib/Log] 1 subscriber  * /averaging/feedback [unknown type] 1 subscriber  * /averaging/status [unknown type] 1 subscriber  * /averaging/result [unknown type] 1 subscriber $ rqt_graph

* ROS2 Action 예제 - 참고: Writing an action server and client (C++) — ROS 2 Documentation: Eloquent documentation

단계	설명
패키지 생성	$ cd ~/action_ws/src $ ros2 pkg create --dependencies action_tutorials_interfaces rclcpp rclcpp_action rclcpp_components -- action_tutorials_cpp
visibility 제어	$ gedit action_tutorials_cpp/include/action_tutorials_cpp/visibility_control.h #ifndef ACTION_TUTORIALS_CPP__VISIBILITY_CONTROL_H_ #define ACTION_TUTORIALS_CPP__VISIBILITY_CONTROL_H_ #ifdef __cplusplus extern "C" { #endif // This logic was borrowed (then namespaced) from the examples on the gcc wiki: //     https://gcc.gnu.org/wiki/Visibility #if defined _WIN32 || defined __CYGWIN__   #ifdef __GNUC__     #define ACTION_TUTORIALS_CPP_EXPORT __attribute__ ((dllexport))     #define ACTION_TUTORIALS_CPP_IMPORT __attribute__ ((dllimport))   #else     #define ACTION_TUTORIALS_CPP_EXPORT __declspec(dllexport)     #define ACTION_TUTORIALS_CPP_IMPORT __declspec(dllimport)   #endif   #ifdef ACTION_TUTORIALS_CPP_BUILDING_DLL     #define ACTION_TUTORIALS_CPP_PUBLIC ACTION_TUTORIALS_CPP_EXPORT   #else     #define ACTION_TUTORIALS_CPP_PUBLIC ACTION_TUTORIALS_CPP_IMPORT   #endif   #define ACTION_TUTORIALS_CPP_PUBLIC_TYPE ACTION_TUTORIALS_CPP_PUBLIC   #define ACTION_TUTORIALS_CPP_LOCAL #else   #define ACTION_TUTORIALS_CPP_EXPORT __attribute__ ((visibility("default")))   #define ACTION_TUTORIALS_CPP_IMPORT   #if __GNUC__ >= 4     #define ACTION_TUTORIALS_CPP_PUBLIC __attribute__ ((visibility("default")))     #define ACTION_TUTORIALS_CPP_LOCAL  __attribute__ ((visibility("hidden")))   #else     #define ACTION_TUTORIALS_CPP_PUBLIC     #define ACTION_TUTORIALS_CPP_LOCAL   #endif   #define ACTION_TUTORIALS_CPP_PUBLIC_TYPE #endif #ifdef __cplusplus } #endif #endif  // ACTION_TUTORIALS_CPP__VISIBILITY_CONTROL_H_
서버코드	$ gedit action_tutorials_cpp/src/fibonacci_action_server.cpp #include <functional> #include <memory> #include <thread> #include "action_tutorials_interfaces/action/fibonacci.hpp" #include "rclcpp/rclcpp.hpp" #include "rclcpp_action/rclcpp_action.hpp" #include "rclcpp_components/register_node_macro.hpp" #include "action_tutorials_cpp/visibility_control.h" namespace action_tutorials_cpp { class FibonacciActionServer : public rclcpp::Node { public:   using Fibonacci = action_tutorials_interfaces::action::Fibonacci;   using GoalHandleFibonacci = rclcpp_action::ServerGoalHandle<Fibonacci>;   ACTION_TUTORIALS_CPP_PUBLIC   explicit FibonacciActionServer(const rclcpp::NodeOptions & options = rclcpp::NodeOptions())   : Node("fibonacci_action_server", options)   {     using namespace std::placeholders;     this->action_server_ = rclcpp_action::create_server<Fibonacci>(       this,       "fibonacci",       std::bind(&FibonacciActionServer::handle_goal, this, _1, _2),       std::bind(&FibonacciActionServer::handle_cancel, this, _1),       std::bind(&FibonacciActionServer::handle_accepted, this, _1));   } private:   rclcpp_action::Server<Fibonacci>::SharedPtr action_server_;   rclcpp_action::GoalResponse handle_goal(     const rclcpp_action::GoalUUID & uuid,     std::shared_ptr<const Fibonacci::Goal> goal)   {     RCLCPP_INFO(this->get_logger(), "Received goal request with order %d", goal->order);     (void)uuid;     return rclcpp_action::GoalResponse::ACCEPT_AND_EXECUTE;   }   rclcpp_action::CancelResponse handle_cancel(     const std::shared_ptr<GoalHandleFibonacci> goal_handle)   {     RCLCPP_INFO(this->get_logger(), "Received request to cancel goal");     (void)goal_handle;     return rclcpp_action::CancelResponse::ACCEPT;   }   void handle_accepted(const std::shared_ptr<GoalHandleFibonacci> goal_handle)   {     using namespace std::placeholders;     // this needs to return quickly to avoid blocking the executor, so spin up a new thread     std::thread{std::bind(&FibonacciActionServer::execute, this, _1), goal_handle}.detach();   }   void execute(const std::shared_ptr<GoalHandleFibonacci> goal_handle)   {     RCLCPP_INFO(this->get_logger(), "Executing goal");     rclcpp::Rate loop_rate(1);     const auto goal = goal_handle->get_goal();     auto feedback = std::make_shared<Fibonacci::Feedback>();     auto & sequence = feedback->partial_sequence;     sequence.push_back(0);     sequence.push_back(1);     auto result = std::make_shared<Fibonacci::Result>();     for (int i = 1; (i < goal->order) && rclcpp::ok(); ++i) {       // Check if there is a cancel request       if (goal_handle->is_canceling()) {         result->sequence = sequence;         goal_handle->canceled(result);         RCLCPP_INFO(this->get_logger(), "Goal canceled");         return;       }       // Update sequence       sequence.push_back(sequence[i] + sequence[i - 1]);       // Publish feedback       goal_handle->publish_feedback(feedback);       RCLCPP_INFO(this->get_logger(), "Publish feedback");       loop_rate.sleep();     }     // Check if goal is done     if (rclcpp::ok()) {       result->sequence = sequence;       goal_handle->succeed(result);       RCLCPP_INFO(this->get_logger(), "Goal succeeded");     }   } };  // class FibonacciActionServer }  // namespace action_tutorials_cpp RCLCPP_COMPONENTS_REGISTER_NODE(action_tutorials_cpp::FibonacciActionServer)
MakeLists.txt	$ gedit action_tutorials_cpp/CMakeLists.txt add_library(action_server SHARED   src/fibonacci_action_server.cpp) target_include_directories(action_server PRIVATE <BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include> <INSTALL_INTERFACE:include>) target_compile_definitions(action_server   PRIVATE "ACTION_TUTORIALS_CPP_BUILDING_DLL") ament_target_dependencies(action_server   "action_tutorials_interfaces"   "rclcpp"   "rclcpp_action"   "rclcpp_components") rclcpp_components_register_node(action_server PLUGIN "action_tutorials_cpp::FibonacciActionServer" EXECUTABLE fibonacci_action_server) install(TARGETS   action_server   ARCHIVE DESTINATION lib   LIBRARY DESTINATION lib   RUNTIME DESTINATION bin)
컴파일	$ cd action_ws $ colcon build
클라이언트 코드	$ gedit action_tutorials_cpp/src/fibonacci_action_client.cpp #include <functional> #include <future> #include <memory> #include <string> #include <sstream> #include "action_tutorials_interfaces/action/fibonacci.hpp" #include "rclcpp/rclcpp.hpp" #include "rclcpp_action/rclcpp_action.hpp" #include "rclcpp_components/register_node_macro.hpp" namespace action_tutorials_cpp { class FibonacciActionClient : public rclcpp::Node { public:   using Fibonacci = action_tutorials_interfaces::action::Fibonacci;   using GoalHandleFibonacci = rclcpp_action::ClientGoalHandle<Fibonacci>;   explicit FibonacciActionClient(const rclcpp::NodeOptions & options)   : Node("fibonacci_action_client", options)   {     this->client_ptr_ = rclcpp_action::create_client<Fibonacci>(       this,       "fibonacci");     this->timer_ = this->create_wall_timer(       std::chrono::milliseconds(500),       std::bind(&FibonacciActionClient::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 = Fibonacci::Goal();     goal_msg.order = 10;     RCLCPP_INFO(this->get_logger(), "Sending goal");     auto send_goal_options = rclcpp_action::Client<Fibonacci>::SendGoalOptions();     send_goal_options.goal_response_callback =       std::bind(&FibonacciActionClient::goal_response_callback, this, _1);     send_goal_options.feedback_callback =       std::bind(&FibonacciActionClient::feedback_callback, this, _1, _2);     send_goal_options.result_callback =       std::bind(&FibonacciActionClient::result_callback, this, _1);     this->client_ptr_->async_send_goal(goal_msg, send_goal_options);   } private:   rclcpp_action::Client<Fibonacci>::SharedPtr client_ptr_;   rclcpp::TimerBase::SharedPtr timer_;   void goal_response_callback(std::shared_future<GoalHandleFibonacci::SharedPtr> future)   {     auto goal_handle = future.get();     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(     GoalHandleFibonacci::SharedPtr,     const std::shared_ptr<const Fibonacci::Feedback> feedback)   {     std::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 GoalHandleFibonacci::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;     }     std::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 FibonacciActionClient }  // namespace action_tutorials_cpp RCLCPP_COMPONENTS_REGISTER_NODE(action_tutorials_cpp::FibonacciActionClient)
CMakeLists.txt	$ gedit action_tutorials_cpp/CMakeLists.txt add_library(action_client SHARED   src/fibonacci_action_client.cpp) target_include_directories(action_client PRIVATE   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>   $<INSTALL_INTERFACE:include>) target_compile_definitions(action_client   PRIVATE "ACTION_TUTORIALS_CPP_BUILDING_DLL") ament_target_dependencies(action_client   "action_tutorials_interfaces"   "rclcpp"   "rclcpp_action"   "rclcpp_components") rclcpp_components_register_node(action_client PLUGIN "action_tutorials_cpp::FibonacciActionClient" EXECUTABLE fibonacci_action_client) install(TARGETS   action_client   ARCHIVE DESTINATION lib   LIBRARY DESTINATION lib   RUNTIME DESTINATION bin)
컴파일	$ cd action_ws $ colcon build
실행	$ ros2 run action_tutorials_cpp fibonacci_action_server $ ros2 run action_tutorials_cpp fibonacci_action_client