13. [Option] C++ 코드, template - 2

🧐

13. [Option] C++ 코드, template - 2

지난 시간에 이어서 roscpp코드들을 계속 살펴보겠습니다.

spawn_model_client.cpp

robot_turning_client.cpp

robot_turning_srv.cpp

fibonacci_action_server.cpp

fibonacci_action_client.cpp

Reference

spawn_model_client.cpp

---

/*
 * gazebo model spawn by rosservice
 * 
 * referenced from answers.ros.org
 * url : https://pastebin.com/UTWJSScZ
 * 
 * basic template of roscpp service client
 * 
 * referenced from wiki.ros.org
 * url : http://wiki.ros.org/ROS/Tutorials/WritingServiceClient%28c%2B%2B%29
 */

#include <fstream> // ros.h doesn't contain this lib
#include <ros/ros.h>
#include <ros/package.h>
#include <gazebo_msgs/SpawnModel.h>
#include <geometry_msgs/Pose.h>

void addXml(gazebo_msgs::SpawnModel& model_in, const std::string& file_path ){
    std::ifstream file(file_path);
    std::string line;

    while (!file.eof()){
        std::getline(file, line);
        model_in.request.model_xml += line;
    }
    file.close();
}

geometry_msgs::Pose getPose(){
    geometry_msgs::Pose initial_pose;

    initial_pose.position.x = -2;
    initial_pose.position.y = 1;
    initial_pose.position.z = 1;

    initial_pose.orientation.z = -0.707;
    initial_pose.orientation.w = 0.707;

    return initial_pose;
}

int main(int argc, char** argv){

    ros::init(argc, argv, "gazebo_spawn_model");

    ros::NodeHandle nh;
    ros::ServiceClient spawn_model_prox = nh.serviceClient<gazebo_msgs::SpawnModel>("gazebo/spawn_urdf_model");
    
    gazebo_msgs::SpawnModel model;

    // add roslib in find_package()
    auto file_path = ros::package::getPath("cpp_service_tutorial") +  "/models/r2d2.urdf";

    addXml(model, file_path);

    model.request.model_name = "r2d2";
    model.request.reference_frame = "world";

    model.request.initial_pose = getPose();

    // ServiceClient.call() => return bool type
    if (spawn_model_prox.call(model)){
        auto response = model.response;
        ROS_INFO("%s", response.status_message.c_str()); // Print the result given by the service called
    }
    else {
        ROS_ERROR("Failed to call service /trajectory_by_name");
        return 1;   
    }

    return 0;
}

이번 코드에서는 본래의 목적인 serviceClient를 생성하는 것과 더불어 여러 유틸리티들을 살펴보고자 합니다.

우선 Service Client의 생성입니다.

ros::ServiceClient spawn_model_prox = nh.serviceClient<gazebo_msgs::SpawnModel>("gazebo/spawn_urdf_model");

주고 받을 srv로 instantiation해주고, Server의 이름을 매개변수로 넣어주었습니다.

파이썬과 차이가 나는 부분이 여기 있는데요, gazebo_msgs::SpawnModel 구조체 안에, request, response가 같이 들어있기에 아래와 같이 사용됩니다.

    gazebo_msgs::SpawnModel model;

    model.request.model_name = "r2d2";
    model.request.reference_frame = "world";

    model.request.initial_pose = getPose();

    // ServiceClient.call() => return bool type
    if (spawn_model_prox.call(model)){
        auto response = model.response;
        ROS_INFO("%s", response.status_message.c_str()); // Print the result given by the service called
    }

• urdf 파일 입출력 부분을 볼까요?

#include <fstream> // ros.h doesn't contain this lib
...
void addXml(gazebo_msgs::SpawnModel& model_in, const std::string& file_path ){
    std::ifstream file(file_path);
    std::string line;

    while (!file.eof()){
        std::getline(file, line);
        model_in.request.model_xml += line;
    }
    file.close();
}

ros.h에는 fstream이 없습니다. 그래서 따로 include 해주었고, 위 코드는 ifstream으로부터 std::string에 한줄씩 담아 model_xml 에게 넘겨주는 부부입니다. 이 코드는 다른 곳에서도 재사용이 가능할 것입니다.

• 다음으로 service call을 하는 부분입니다.

    // ServiceClient.call() => return bool type
    if (spawn_model_prox.call(model)){
        auto response = model.response;
        ROS_INFO("%s", response.status_message.c_str()); // Print the result given by the service called
    }
    else {
        ROS_ERROR("Failed to call service /trajectory_by_name");
        return 1;   
    }

call() 함수가 bool type을 return 하기 때문에 위와 같은 로직이 구현되었습니다.

기존 파이썬에서는 print만 하면 알아서 예쁘게 출력해주었는데 C++은 c_str()등의 처리가 들어갑니다.

• 추가적으로, 파일 경로를 가져오는 상황에서 유용한 ros::package::getPath입니다.

#include <ros/package.h>

...

    // add roslib in find_package()
    auto file_path = ros::package::getPath("cpp_service_tutorial") +  "/models/r2d2.urdf";

이제 파이썬 Service 예제였던 로봇을 회전시키는 코드를 살펴보겠습니다.

robot_turning_client.cpp

---

/*
 * turn your robot with angular velocity
 * 
 * created by kimsooyoung : https://github.com/kimsooyoung
 */

#include <ros/ros.h>
#include "cpp_service_tutorial/ControlTurningMessage.h"

using srv_t = cpp_service_tutorial::ControlTurningMessage;

using std::cout;
using std::endl;
using std::cin;

int main(int argc, char** argv) {
    ros::init(argc, argv, "robot_turning_client");
    ros::NodeHandle nh;

    ros::ServiceClient client = nh.serviceClient<srv_t>("/control_robot_angle");

    ROS_INFO("==== Service Client initialized ====");

    // srv type

    // uint32 time_duration
    // float64 angular_vel
    // ---
    // bool success

    srv_t srv;
    
    unsigned int time_duration;
    float angular_vel;

    cout << "Enter time_duration : ";
    cin >> time_duration;
    cin.clear(); cin.ignore(32767, '\n'); 

    cout << "Enter angular_vel : ";
    cin >> angular_vel;
    cin.clear(); cin.ignore(32767, '\n'); 

    srv.request.time_duration = time_duration;
    srv.request.angular_vel = angular_vel;

    if ( client.call(srv) ){
        auto response = srv.response;
        cout << std::boolalpha;
        cout << "Response : " << bool(response.success) << endl;
    }
    else {
        ROS_ERROR("Failed to call service /control_robot_angle");
        return 1;      
    }

    return 0;
}

어느정도 시간 동안 얼마큼의 각속도로 회전할 것인지, 이를 위해 우리만의 custom srv를 만들었습니다. 이렇게 만들어진 srv는 "패키지 이름"/".srv 파일 이름" 으로 include가 가능합니다.

그러다보니 이름이 너무 길어져서 저는 축약형을 따로 정의하였습니다.

using srv_t = cpp_service_tutorial::ControlTurningMessage srv_t;

• service client 생성과 call을 하는 부분입니다. 앞선 gazebo 예제에서 살펴보았기에 간단히 넘어갑니다.

    ros::ServiceClient client = nh.serviceClient<srv_t>("/control_robot_angle");
		(...)

    if ( client.call(srv) ){

• 사용자로부터 input을 받는 부분이 있습니다. 따로 예외처리는 하지 않았지만, 실제 프로젝트를 진행하면서는 너무 큰 각속도를 갖지 않도록 해야 할 것입니다. 커다란 로봇이 갑자기 엄청난 회전을 한다면.... 생각만 해도 끔찍합니다. 🤖🤖

    cout << "Enter time_duration : ";
    cin >> time_duration;
    cin.ignore(32767, '\n'); cin.clear();

    cout << "Enter angular_vel : ";
    cin >> angular_vel;
    cin.ignore(32767, '\n'); cin.clear();

robot_turning_srv.cpp

---

/*
 * referenced from answer.ros.org
 * 
 * url : https://answers.ros.org/question/214597/service-with-class-method/
 */

#include <chrono>
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#include "cpp_service_tutorial/ControlTurningMessage.h"

using Request_T = cpp_service_tutorial::ControlTurningMessage::Request;
using Response_T = cpp_service_tutorial::ControlTurningMessage::Response;


class TinyBot {
private:
    ros::NodeHandle m_nh;
    ros::ServiceServer m_control_ss; // control service_server
    ros::Publisher m_vel_pub;

    geometry_msgs::Twist m_cmd_vel;
    std::string m_name;

public:
    TinyBot(const std::string &name_in = "tinybot"): m_name(name_in) {

        m_control_ss = m_nh.advertiseService("/control_robot_angle", &TinyBot::servCallback, this);
        m_vel_pub = m_nh.advertise<geometry_msgs::Twist>("/cmd_vel", 5);
        ROS_INFO("Service Server and Publisher initialized");
        ROS_INFO("Waiting for request...");
    }


    /*
    * srv type
    * 
    * uint32 time_duration
    * float64 angular_vel
    * ---
    * bool success
    */

    bool servCallback(Request_T &req, Response_T &res) {
        
        m_cmd_vel.angular.z = req.angular_vel;

        ROS_INFO("==== Start Turning ====");

        auto start = std::chrono::steady_clock::now();
        auto now = std::chrono::steady_clock::now();

        std::chrono::duration<double> time_duration = now - start;

        while (time_duration.count() < req.time_duration){
            m_vel_pub.publish(m_cmd_vel);
            
            now = std::chrono::steady_clock::now();
            time_duration = now - start;
        }

        // while ( ros::Time::now() < end_time ){
        //     // std::cout << ros::Time::now() << std::endl;
        //     m_vel_pub.publish(m_cmd_vel);
        // }

        ROS_WARN("==== Stop Turning ====");
        m_cmd_vel.angular.z = 0;
        m_vel_pub.publish(m_cmd_vel);

        res.success = true;
        
        return 1;
    }
};


int main(int argc, char** argv){

    ros::init(argc, argv, "robot_turning_server");
    auto myTinyBot = TinyBot();
    ros::spin();

    return 0;
}

• ControlTurningMessage.srv

uint32 time_duration
float64 angular_vel
---
bool success

클래스를 사용하고 있습니다. 그 이유에 대해서는 앞서 이야기한 바와 같습니다.

• 주된 내용인 service server를 생성하고 있는 모습입니다. 멤버 함수를 콜백으로 사용하기 위해서, function pointer, object를 받는 것이 보입니다.

TinyBot(const std::string &name_in = "tinybot"): m_name(name_in) {

        m_control_ss = m_nh.advertiseService("/control_robot_angle", &TinyBot::servCallback, this);
        m_vel_pub = m_nh.advertise<geometry_msgs::Twist>("/cmd_vel", 5);
        ROS_INFO("Service Server and Publisher initialized");
        ROS_INFO("Waiting for request...");
    }

이제는 클래스 형태로 구현하는 것이 조금은 익숙해지셨나요? 😎 주로 사용되는 /cmd_vel, /scan과 같은 publisher, subscriber를 담은 클래스를 따로 만들어 재사용할 수도 있겠지요??

나중에 실제 로봇을 제어하신다면 , 거의 ROS에서 구현된 기능들을 상속받아 사용하시게 됩니다. 이를 위해서라도 클래스로의 구현에 익숙해지셨으면 좋겠습니다!!

• service server callback

		// srv type

    // uint32 time_duration
    // float64 angular_vel
    // ---
    // bool success
    bool servCallback(Request_T &req, Response_T &res) {
        m_cmd_vel.angular.z = req.angular_vel;
        while (time_duration.count() < req.time_duration){
				...
        res.success = true;
				...
		}

기존 callback들과 다르게, request, response 두개의 매개변수를 갖습니다.

기능상의 로직은 생략하고, 이제 Action으로 넘어가도록 하겠습니다.

fibonacci_action_server.cpp

---

시작하기에 앞서, action을 사용하기 위해서는 roscpp 말고도 다음과 같은 패키지들을 CMakeLists.txt에 추가해야 합니다.

## Find catkin macros and libraries
## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz)
## is used, also find other catkin packages
find_package(catkin REQUIRED COMPONENTS
  actionlib_msgs
  actionlib # client requires both packages
  roscpp
  std_msgs
)

python에서도 이렇게 차이가 있었지요?

import rospy
import actionlib
from actionlib_tutorials.msg import FibonacciAction, FibonacciGoal

client = actionlib.SimpleActionClient("fibonacci_action_server", FibonacciAction)

• 더불어 피보나치 예제를 작업하면서 파이썬에서는 sequence를 list로 다루었는데요. C++에서는 std::vector로 다루게 됩니다.

Fibonacci.action

#goal definition
int32 order
---
#result definition
int32[] sequence
---
#feedback
int32[] sequence

/*
 * referenced from wiki.ros.org 
 * url : http://wiki.ros.org/actionlib_tutorials/Tutorials/SimpleActionServer%28ExecuteCallbackMethod%29 
 */

#include <ros/ros.h>
#include <actionlib/server/simple_action_server.h>
#include <actionlib_tutorials/FibonacciAction.h>

/* Fibonacci.action
* 
* goal definition
* int32 order
* ---
* result definition
* int32[] sequence
* ---
* feedback
* int32[] sequence
*/ 

class FibonacciActionClass {
protected:
    ros::NodeHandle m_nh;
    
    actionlib::SimpleActionServer<actionlib_tutorials::FibonacciAction> m_as;
    std::string m_name;

    // vector 
    actionlib_tutorials::FibonacciFeedback m_feedback;
    actionlib_tutorials::FibonacciResult m_result;

public:
    FibonacciActionClass(const std::string &name_in = "fibonacci_action_server"): 
        m_name(name_in), 
        m_as(m_nh, name_in, boost::bind(&FibonacciActionClass::actionCallback, this, _1), false) {
        m_as.start();
        ROS_INFO("==== Action Server Class Constructed ====");
    }
    
    ~FibonacciActionClass(){
        ROS_INFO("==== Action Server Class Destroying ====");
    }

    // must use Ptr type or ConstPtr type!!
    void actionCallback(const actionlib_tutorials::FibonacciGoalConstPtr &goal){

        ros::Rate r(5);
        bool success = true;
        int order = int(goal->order);
        const auto sequence = &(m_feedback.sequence);

        // push_back the seeds for the fibonacci sequence
        sequence->clear();
        sequence->push_back(0);
        sequence->push_back(1);

        // publish info to the console for the user
        std::cout << m_name.c_str() << ": Executing, creating fibonacci sequence of order " << 
            order << " with seeds " << sequence->at(0) << " , " << sequence->at(1) << std::endl;

        // start executing the action
        for(int i = 1; i <= order; i++){
            // check that preempt has not been requested by the client
            if (m_as.isPreemptRequested() || !ros::ok()){
                ROS_INFO("%s: Preempted", m_name.c_str());
                // set the action state to preempted
                m_as.setPreempted();
                success = false;
                break;
            }
            sequence->push_back(sequence->at(i) + sequence->at(i-1));
            // publish the feedback
            m_as.publishFeedback(m_feedback);
            // this sleep is not necessary, the sequence is computed at 1 Hz for demonstration purposes
            r.sleep();
        }

        if(success){
            m_result.sequence = m_feedback.sequence;
            ROS_INFO("%s: Succeeded", m_name.c_str());
            // set the action state to succeeded
            m_as.setSucceeded(m_result);
        }
    }
};

int main(int argc, char** argv){

    ros::init(argc, argv, "fibonacci");
    FibonacciActionClass fibonacci;
    ros::spin();

    return 0;
}

• import 시에 다음과 같은 차이점이 있다는 점에 유의합니다.

#include <ros/ros.h>
#include <actionlib/server/simple_action_server.h>
#include <actionlib_tutorials/FibonacciAction.h>

• 생성자 부분을 보겠습니다.

class FibonacciActionClass {
protected:
    ros::NodeHandle m_nh;
    
    actionlib::SimpleActionServer<actionlib_tutorials::FibonacciAction> m_as;
    std::string m_name;

    // vector 
    actionlib_tutorials::FibonacciFeedback m_feedback;
    actionlib_tutorials::FibonacciResult m_result;

public:
    FibonacciActionClass(const std::string &name_in = "fibonacci_action_server"): 
        m_name(name_in), 
        m_as(m_nh, name_in, boost::bind(&FibonacciActionClass::actionCallback, this, _1), false) {
        m_as.start();
        ROS_INFO("==== Action Server Class Constructed ====");
    }
    
    ~FibonacciActionClass(){
        ROS_INFO("==== Action Server Class Destroying ====");
    }

• action server는 아래와 같이 template instantiation을 사용하여 생성합니다. 더불어 server이기 때문에, feedback과 result가 사용되고 있습니다.

    actionlib::SimpleActionServer<actionlib_tutorials::FibonacciAction> m_as;
    std::string m_name;

    // vector 
    actionlib_tutorials::FibonacciFeedback m_feedback;
    actionlib_tutorials::FibonacciResult m_result;

• ~가 붙은 부분은 destructor, 소멸자입니다. 그런데, Action Server에 goal callback을 지정해주는 부분에 새로운 문법이 보입니다.

    FibonacciActionClass(const std::string &name_in = "fibonacci_action_server"): 
        m_name(name_in), 
        m_as(m_nh, name_in, boost::bind(&FibonacciActionClass::actionCallback, this, _1), false) {
        m_as.start();
        ROS_INFO("==== Action Server Class Constructed ====");
    }
    
    ~FibonacciActionClass(){
        ROS_INFO("==== Action Server Class Destroying ====");
    }

boost::bind(&FibonacciActionClass::actionCallback, this, _1)

저 또한 많은 지식을 가진 것이 아니라 간단하게 들어가면,

actionCallback이 몇개의 인자를 받을지, 그 인자들이 어떤 타입일지, 함수일지, 포인터일지, 모르는 상황에서 콜백의 실행을 보다 편리하게 하기 위해, 코드의 양을 줄이기 위해 사용되었다고 이해하시면 좋을 것 같습니다.

지금의 경우 function pointer와 object, 그리고 placeholder 하나가 bind 되었습니다.

• callback시, 유의 사항이 있습니다. goal을 전달받을 때, 반드시 Ptr type으로 전달받아야 합니다!

void actionCallback(const actionlib_tutorials::FibonacciGoalConstPtr &goal){

or

void actionCallback(const actionlib_tutorials::FibonacciGoalPtr &goal){

• 이후의 과정은 비슷하고, publishFeedback, setSucceeded을 통해 feedback/result를 보낸다는 점,

ROS_INFO를 사용하는 방법에 대한 추가 설명을 드릴 수 있습니다.

				if (m_as.isPreemptRequested() || !ros::ok()){
                ROS_INFO("%s: Preempted", m_name.c_str());
                // set the action state to preempted
                m_as.setPreempted();
                success = false;
                break;
            }
            sequence->push_back(sequence->at(i) + sequence->at(i-1));
            // publish the feedback
            m_as.publishFeedback(m_feedback);
            // this sleep is not necessary, the sequence is computed at 1 Hz for demonstration purposes
            r.sleep();
        }

        if(success){
            m_result.sequence = m_feedback.sequence;
            ROS_INFO("%s: Succeeded", m_name.c_str());
            // set the action state to succeeded
            m_as.setSucceeded(m_result);
        }

fibonacci_action_client.cpp

---

/*
 * referenced from wiki.ros.org 
 * url : http://wiki.ros.org/actionlib_tutorials/Tutorials/Writing%20a%20Callback%20Based%20Simple%20Action%20Client
 */

#include <ros/ros.h>
#include <actionlib/client/simple_action_client.h>
#include <actionlib_tutorials/FibonacciAction.h>

/* Fibonacci.action
* 
* goal definition
* int32 order
* ---
* result definition
* int32[] sequence
* ---
* feedback
* int32[] sequence
*/ 

void doneCb(const actionlib::SimpleClientGoalState& state,
            const actionlib_tutorials::FibonacciResultConstPtr& result)
{
    ROS_INFO("[State Result]: %s", state.toString().c_str());
    ROS_INFO("Answer: %i", result->sequence.back());
    ros::shutdown();
}

// Called once when the goal becomes active
void activeCb()
{
    ROS_INFO("Goal just went active");
}

void feedbackCb(const actionlib_tutorials::FibonacciFeedbackConstPtr& feedback){
    ROS_INFO("[Feedback] :");
    for(auto &elem : feedback->sequence){
        std::cout << elem << " ";
    }
    std::cout << std::endl;
}

int main(int argv, char** argc){

    ros::init(argv, argc, "fibonacci_client");
    ros::NodeHandle nh;
    ros::Rate r(5);

    std::string server_name = "fibonacci_action_server";
    // turn on auto threading
    actionlib::SimpleActionClient<actionlib_tutorials::FibonacciAction> client(server_name, true); 
    std::cout << "Wating for Server..." << std::endl;
    client.waitForServer();

    actionlib_tutorials::FibonacciGoal goal;
    goal.order = 20;

    std::cout << "==== Sending Goal to Server ====" << std::endl;
    client.sendGoal(goal, &doneCb, &activeCb, &feedbackCb);

    actionlib::SimpleClientGoalState state_result = client.getState();

    while (!state_result.isDone()){
        // Doing Stuff while waiting for the Server to give a result....

        // if (<cancel-condition>){
        //     client.cancelGoal();
        // }

        state_result = client.getState();
        r.sleep();
    }

    if (state_result == actionlib::SimpleClientGoalState::SUCCEEDED)
        ROS_INFO("[Action Done State Result]: %s", state_result.toString().c_str());
    else 
        ROS_ERROR("[Something Gonna Wrong State Result]: %s", state_result.toString().c_str());

    return 0;
}

• action client는 다음과 같이 생성합니다. 두번째 인자는 auto_threading으로 ros::spin()을 자동으로 실행시켜주는 옵션입니다.

Wiki

Please ask about problems and questions regarding this tutorial on answers.ros.org. Don't forget to include in your question the link to this page, the versions of your OS & ROS, and also add appropriate tags. Description: This tutorial covers using the simple_action_client library to create a averaging action client.

http://wiki.ros.org/actionlib_tutorials/Tutorials/SimpleActionClient%28Threaded%29

actionlib::SimpleActionClient<actionlib_tutorials::FibonacciAction> client(server_name, true); 

• sendGoal부분을 살펴보겠는데요, 콜백이 다소 많습니다 😂 순서대로
  • 완료 시 실행되는 done_callback
  • 초기 active 시 한번만 실행되는 active_callback
  • 서버로부터 feedback을 받을 때마다 실행되는 feedback_callback

이렇게 세가지 형식이 있습니다.

각 callback으로 돌아오는 인자들을 집중해서 살펴보겠습니다.

void doneCb(const actionlib::SimpleClientGoalState& state,
            const actionlib_tutorials::FibonacciResultConstPtr& result)
{
    ROS_INFO("[State Result]: %s", state.toString().c_str());
    ROS_INFO("Answer: %i", result->sequence.back());
    ros::shutdown();
}

// Called once when the goal becomes active
void activeCb()
{
    ROS_INFO("Goal just went active");
}

void feedbackCb(const actionlib_tutorials::FibonacciFeedbackConstPtr& feedback){
    ROS_INFO("[Feedback] :");
    for(auto &elem : feedback->sequence){
        std::cout << elem << " ";
    }
    std::cout << std::endl;
}

client.sendGoal(goal, &doneCb, &activeCb, &feedbackCb);

• Action Client는 server가 작업을 수행중인 동안 다른일을 할 수 있다고 말했지요?

더불어, goal cancel을 요청할 수 있는 cancelGoal() 함수도 보입니다.

while (!state_result.isDone()){
        // Doing Stuff while waiting for the Server to give a result....

        // if (<cancel-condition>){
        //     client.cancelGoal();
        // }

        state_result = client.getState();
        r.sleep();
    }

• 최종 result state에 따라 디버깅 메세지를 출력하는 부분입니다.

		if (state_result == actionlib::SimpleClientGoalState::SUCCEEDED)
        ROS_INFO("[Action Done State Result]: %s", state_result.toString().c_str());
    else 
        ROS_ERROR("[Something Gonna Wrong State Result]: %s", state_result.toString().c_str());

앞서 파이썬 프로그래밍을 배웠기에, 대응되는 함수들을 한번씩 살펴보았습니다.

그럼 어려운 C++을 왜 쓰나요 ❓❓

로봇은 결국 하드웨어를 다루는 작업입니다. 간단히 이야기해서, 제품을 만들거나 연구를 하는 상황에서, 사용하는 하드웨어, 알고리즘으로의 최적화가 필요하기에 C++을 사용한다고 말씀드리고 싶습니다.

최고의 성능이 필요하지 않고, 빠르게 개발하여 결과를 보고 싶은 우리의 경우, 파이썬이 더 적합하다고 생각합니다. 그래서 앞으로의 ROS RC Car 프로젝트에서도 파이썬을 사용하구요.

Reference

---

읽어볼만한 레퍼런스들을 링크해 두었습니다.

고급 ROS 프로그래머도 거듭나기 위해 저도 열심히 공부중이랍니다. 😉

• CppStyleGuide

• Should I switch from using boost::shared_ptr to std::shared_ptr?

• What is ConstPtr&?

• actionlib::SimpleActionServer< ActionSpec > Class Template Reference

• actionlib::SimpleClientGoalState::StateEnum

다음 시간에는 rviz, rqt와 같은 디버깅을연구 도와주는 유용한 툴들에 대해서 배워보도록 하겠습니다!!