ROS學習筆記九：用C++編寫ROS發佈與訂閱

ROS學習筆記九：用C++編寫ROS發佈與訂閱

本節主要介紹如何用C++編寫一個簡單的ROS發佈與訂閱。

編寫發佈節點

在之前創建的例子beginner_tutorials軟件包中，在其目錄下的src目錄中，創建talker.cpp文件：

#include "ros/ros.h"  //ROS中最常用片段的頭文件
#include "std_msgs/String.h"   //由String.msg自動產生的頭文件

#include <sstream>   //stringstream頭文件

/**
 * This tutorial demonstrates simple sending of messages over the ROS system.
 */
int main(int argc, char **argv)
{
  /**
   * The ros::init() function needs to see argc and argv so that it can perform
   * any ROS arguments and name remapping that were provided at the command line.
   * For programmatic remappings you can use a different version of init() which takes
   * remappings directly, but for most command-line programs, passing argc and argv is
   * the easiest way to do it.  The third argument to init() is the name of the node.
   *
   * You must call one of the versions of ros::init() before using any other
   * part of the ROS system.
   */
  ros::init(argc, argv, "talker");   //初始化ROS，在這裏可以指定我們節點的名稱，一個ROS系統中節點的名稱必須是唯一的

  /**
   * NodeHandle is the main access point to communications with the ROS system.
   * The first NodeHandle constructed will fully initialize this node, and the last
   * NodeHandle destructed will close down the node.
   */
  ros::NodeHandle n;   //創建一個節點的句柄，第一個創建的節點句柄會初始化節點，而最後一個則會清理節點所用的所有資源

  /**
   * The advertise() function is how you tell ROS that you want to
   * publish on a given topic name. This invokes a call to the ROS
   * master node, which keeps a registry of who is publishing and who
   * is subscribing. After this advertise() call is made, the master
   * node will notify anyone who is trying to subscribe to this topic name,
   * and they will in turn negotiate a peer-to-peer connection with this
   * node.  advertise() returns a Publisher object which allows you to
   * publish messages on that topic through a call to publish().  Once
   * all copies of the returned Publisher object are destroyed, the topic
   * will be automatically unadvertised.
   *
   * The second parameter to advertise() is the size of the message queue
   * used for publishing messages.  If messages are published more quickly
   * than we can send them, the number here specifies how many messages to
   * buffer up before throwing some away.
   */
  ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);   //告訴mster，n將要在topic chatter上面發佈一個std_msgs::String類型的信息，然後master告訴所有節點注意監聽主題chatter。第二個參數是發送隊列的長度。

  ros::Rate loop_rate(10);   //指定一個循環頻率

  /**
   * A count of how many messages we have sent. This is used to create
   * a unique string for each message.
   */
  int count = 0;
  while (ros::ok())
  {
  //ros::ok()在以下情況下會返回false：
  1 收到SIGINT信號（ctrl-c）；
  2 節點網絡斷開；
  3 ros::shutdown()函數被調用；
  4 所有的ros::NodeHandles都已經消失。
    /**
     * This is a message object. You stuff it with data, and then publish it.
     */
    std_msgs::String msg;

    std::stringstream ss;
    ss << "hello world " << count;
    msg.data = ss.str();

    ROS_INFO("%s", msg.data.c_str());   //ROS_INFO系列是printf/cout的替代品

    /**
     * The publish() function is how you send messages. The parameter
     * is the message object. The type of this object must agree with the type
     * given as a template parameter to the advertise<>() call, as was done
     * in the constructor above.
     */
    chatter_pub.publish(msg);   //發佈信息msg到每一個相連接的節點

    ros::spinOnce();

    loop_rate.sleep();   //休眠一段時間以達到循環頻率10Hz
    ++count;
  }
  return 0;
}

編寫訂閱節點

#include "ros/ros.h"
#include "std_msgs/String.h"

/**
 * This tutorial demonstrates simple receipt of messages over the ROS system.
 */
void chatterCallback(const std_msgs::String::ConstPtr& msg)   //callback函數，收到msg時調用
{
  ROS_INFO("I heard: [%s]", msg->data.c_str());
}

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

  /**
   * The subscribe() call is how you tell ROS that you want to receive messages
   * on a given topic.  This invokes a call to the ROS
   * master node, which keeps a registry of who is publishing and who
   * is subscribing.  Messages are passed to a callback function, here
   * called chatterCallback.  subscribe() returns a Subscriber object that you
   * must hold on to until you want to unsubscribe.  When all copies of the Subscriber
   * object go out of scope, this callback will automatically be unsubscribed from
   * this topic.
   *
   * The second parameter to the subscribe() function is the size of the message
   * queue.  If messages are arriving faster than they are being processed, this
   * is the number of messages that will be buffered up before beginning to throw
   * away the oldest ones.
   */
  ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);

  /**
   * ros::spin() will enter a loop, pumping callbacks.  With this version, all
   * callbacks will be called from within this thread (the main one).  ros::spin()
   * will exit when Ctrl-C is pressed, or the node is shutdown by the master.
   */
  ros::spin();

  return 0;
}

編譯新建的節點

主要是需要修改CMakeLists.txt文件，現在只是跟着官網教程走了下來，具體要怎麼修改、爲什麼要這樣修改，還不是很清楚。
按照官網教程，只需要將下列幾行代碼添加到CMakeLists.txt文件中include_directories(include ${catkin_INCLUDE_DIRS})之後：

add_executable(talker src/talker.cpp)
target_link_libraries(talker ${catkin_LIBRARIES})
add_dependencies(talker beginner_tutorials_generate_messages_cpp)

add_executable(listener src/listener.cpp)
target_link_libraries(listener ${catkin_LIBRARIES})
add_dependencies(listener beginner_tutorials_generate_messages_cpp)

然後在catkin工作空間中運行編譯命令：

catkin_make

如果順利編譯的話，將會生成兩個可執行程序talker和listener文件，默認生成可執行文件的目錄是catkin工作空間的devel space下的lib目錄中， ~/ros_tutorials/devel/lib/。

注意需要將可執行文件的依賴添加到信息生成目標中：

add_dependencies(talker beginner_tutorials_generate_messages_cpp)

這樣會確保這個軟件包的信息頭文件在使用之前已經生成。如果使用了工作空間中其他軟件包中的信息，你也需要添加相應的生成目標的依賴，因爲catkin同時編譯所有的項目。

檢驗創建的節點

首先要確認在carkin_make之後加載了工作空間的環境變量，然後分別在三個新的終端運行如下命令：

roscore
rosrun beginner_tutorials talker
rosrun beginner_tutorials listener

祝楓
2016年8月27日於哈爾濱