写一个Publisher节点
“Node”是ROS中对可执行文件的一个术语，连接成ROS的网络。这里，我们将创建一个Publisher节点（talker）来持续地广播消息message。
首先，切换到beginner_tutorials包所在的位置。
roscd beginner_tutorials
创建一个src文件夹，存放源码。
mkdir -p src
Publisher节点源码
在src文件夹下创建一个talker.cpp源文件：
touch src/talker.cpp
然后在talker.cpp源文件中粘贴下述内容：
#include "ros/ros.h"
#include "std_msgs/String.h"
#include <sstream>
/**
* 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");
/**
* 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);
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())
{
/**
* 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());
/**
* 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);
ros::spinOnce();
loop_rate.sleep();
++count;
}
return 0;
}
Publisher节点源码解释
下面我们对上述源码展开进行一个解释：
首先是：
#include "ros/ros.h"
ros/ros.h是一个方便的include头文件，其中包括ROS系统中所有头文件所必须的最常用的公共部分。
接下来是：
#include "std_msgs/String.h"
这个是引用了std_msgs/String消息，其在std_msgs包中。这是一个从std_msgs包中的 String.msg 文件中自动生成的头文件。
初始化ROS节点。
ros::init(argc, argv, "talker");
这允许ROS通过命令行进行重命名（现在并不重要）。这里我们只需要知道指定节点的名字为“talker”。
注意在一个运行的系统中，节点的名字必须唯一。同时，这里使用的名字为 base name，也就是在命名时不能有 (/) 或者 (~)等字符。
创建一个此处理节点的“句柄”。
ros::NodeHandle n;
创建的第一个节点“句柄”将实际执行节点的初始化，而最后一个NodeHandle销毁将清理所有节点使用的资源。
ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);
告诉master我们将要通过话题“chatter”发布一个类型为std_msgs::String的消息。这会让master告诉所有正在接听"chatter"的节点说我们将会在此topic上发布消息。第二个参数是我们发布队列的大小。在此情况下，如果我们发布的过快，其在开始丢弃“旧数据”之前为我们最大存储1000个数据。
NodeHandle::advertise() 返回了一个ros::Publisher对象。其满足两个目标：
- 1）其包含一个publish()方法，能够让你发布数据到你创建时所指定的topic。
- 2）当其超出范围时，其将自动停止广播。
ros::Rate对象允许我们来指定循环的频率。其将跟踪自上次调用 Rate::sleep()之后的时间，并休眠对应数量的时间。
ros::Rate loop_rate(10);
这里我们想要以10Hz的频率进行运行。
int count = 0;
while (ros::ok())
{
在默认情况下，roscpp将安装一个SIGINT处理程序，该处理程序提供Ctrl + C处理，如果检测到输入了Ctrl + C，会导致ros:：ok（）返回false。
在下面几种情况中，ros:：ok（）将返回false：
- SIGINT处理器接收到了Ctrl + C
- 我们被另外一个同名节点踢出了网络
- 另外一个程序调用了ros::shutdown()
- 所有的os::NodeHandles 都被销毁了
一旦ros:：ok（）返回false，所有的ROS调用都将失效。
std_msgs::String msg;
std::stringstream ss;
ss << "hello world " << count;
msg.data = ss.str();
我们将使用一个消息自适应类发布消息，通常从一个msg文件中生成。也可以有更加复杂的数据类型，但是现在，我们将使用只有一个成员“data”的标准String 消息。
上述代码片段的含义为：定义一个标准std_msgs中的String类型变量“msg”。然后定义一个字符串流ss。不断输入"hello
world "和count变量的值。再赋值给变量“msg”的成员data。
现在，我们真正的广播这个message给接收它的节点。
chatter_pub.publish(msg);
使用publish()方法。
ROS_INFO是我们常用的替代printf/cout的函数。
ROS_INFO("%s", msg.data.c_str());
在这个简单的程序中，调用ros::spinOnce()不是必须的，因为我们没有接收任何回电。然而，如果我们想要在此程序中添加一个订阅者，并且没有在这里添加ros::spinOnce()，我们就永远不会收到调用，因此不管怎么样添加这句话是一个较好的方法。
ros::spinOnce()
最后，我们使用ros::Rate 所定义的 loop_rate对象休眠一定的时间，来保证我们的10Hz发布频率。
loop_rate.sleep();
下面，我们对上述过程进行一个简要总结：
- 初始化ROS系统
- 广播我们将在“chatter”话题发布的 std_msgs/String消息到master
- 以每秒10Hz的频率进行循环
完成了上述工作之后，我们需要写一个节点来接收消息。
写一个Subscriber节点
Subscriber节点源码
在src文件夹目录下创建一个listener.cpp源文件。
添加下述内容：
#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)
{
ROS_INFO("I heard: [%s]", msg->data.c_str());
}
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, "listener");
/**
* 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 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;
}
Subscriber节点源码解释
现在，我们再来了解一下Subscriber节点的源码片段，其中在前述Publisher中已经解释过的就不再叙述了。
首先是一个回调函数，当有新消息到达chatter topic时就会调用这个函数。消息是通过一个boost shared_ptr指针传递的，这意味着我们可以存储他们，而不需要担心它们被删除了，并且不需要复制底层数据。
void chatterCallback(const std_msgs::String::ConstPtr& msg)
{
ROS_INFO("I heard: [%s]", msg->data.c_str());
}
通过下述命令订阅chatter话题，当有新消息到达时，调用上述的chatterCallback函数。第二个参数是队列的大小，以防我们不能足够快的处理消息。在此情况下，如果队列达到了1000个消息，我们将在新消息到达时丢弃旧数据。
ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
NodeHandle::subscribe()返回一个ros::Subscriber对象，我们必须使用到想要取消订阅为止。当Subscriber对象被销毁时，其将自动的取消对chatter话题的订阅。
一些版本的subscribe()函数允许我们调用一个类的成员函数，或者甚至可以指定Boost.function对象可调用的任何函数。
循环的最后，加入一句ros::spin();，尽快的调用消息回调。如果没有用到它也不必担心，因为其不会占用太多CPU资源。当ros::ok() 返回false时，ros::spin()将会退出，这意味着ros::shutdown()已经被 Ctrl+C 或者 主程序告诉我们结束 或者 手动操作 所调用。
ros::spin();
最后，我们还是总结一下整个程序的流程：
- 初始化ROS系统
- 订阅“chatter”话题
- ros::spin()，等待消息到达
- 当消息到达后，调用回调函数chatterCallback()
编译节点
在之前我们使用catkin_create_pkg命令创建beginner_tutorials包的过程中自动生成了一个 package.xml文件 和 一个CMakeLists.txt文件。
生成的CMakeLists.txt文件形式如下：
cmake_minimum_required(VERSION 3.0.2)
project(beginner_tutorials)
## Compile as C++11, supported in ROS Kinetic and newer
# add_compile_options(-std=c++11)
## 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
roscpp
rospy
std_msgs
message_generation
)
## System dependencies are found with CMake's conventions
# find_package(Boost REQUIRED COMPONENTS system)
## Uncomment this if the package has a setup.py. This macro ensures
## modules and global scripts declared therein get installed
## See http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html
# catkin_python_setup()
################################################
## Declare ROS messages, services and actions ##
################################################
## To declare and build messages, services or actions from within this
## package, follow these steps:
## * Let MSG_DEP_SET be the set of packages whose message types you use in
## your messages/services/actions (e.g. std_msgs, actionlib_msgs, ...).
## * In the file package.xml:
## * add a build_depend tag for "message_generation"
## * add a build_depend and a exec_depend tag for each package in MSG_DEP_SET
## * If MSG_DEP_SET isn't empty the following dependency has been pulled in
## but can be declared for certainty nonetheless:
## * add a exec_depend tag for "message_runtime"
## * In this file (CMakeLists.txt):
## * add "message_generation" and every package in MSG_DEP_SET to
## find_package(catkin REQUIRED COMPONENTS ...)
## * add "message_runtime" and every package in MSG_DEP_SET to
## catkin_package(CATKIN_DEPENDS ...)
## * uncomment the add_*_files sections below as needed
## and list every .msg/.srv/.action file to be processed
## * uncomment the generate_messages entry below
## * add every package in MSG_DEP_SET to generate_messages(DEPENDENCIES ...)
## Generate messages in the 'msg' folder
add_message_files(
FILES
Num.msg
)
## Generate services in the 'srv' folder
add_service_files(
FILES
AddTwoInts.srv
)
## Generate actions in the 'action' folder
# add_action_files(
# FILES
# Action1.action
# Action2.action
# )
## Generate added messages and services with any dependencies listed here
generate_messages(
DEPENDENCIES
std_msgs
)
################################################
## Declare ROS dynamic reconfigure parameters ##
################################################
## To declare and build dynamic reconfigure parameters within this
## package, follow these steps:
## * In the file package.xml:
## * add a build_depend and a exec_depend tag for "dynamic_reconfigure"
## * In this file (CMakeLists.txt):
## * add "dynamic_reconfigure" to
## find_package(catkin REQUIRED COMPONENTS ...)
## * uncomment the "generate_dynamic_reconfigure_options" section below
## and list every .cfg file to be processed
## Generate dynamic reconfigure parameters in the 'cfg' folder
# generate_dynamic_reconfigure_options(
# cfg/DynReconf1.cfg
# cfg/DynReconf2.cfg
# )
###################################
## catkin specific configuration ##
###################################
## The catkin_package macro generates cmake config files for your package
## Declare things to be passed to dependent projects
## INCLUDE_DIRS: uncomment this if your package contains header files
## LIBRARIES: libraries you create in this project that dependent projects also need
## CATKIN_DEPENDS: catkin_packages dependent projects also need
## DEPENDS: system dependencies of this project that dependent projects also need
catkin_package(
# INCLUDE_DIRS include
# LIBRARIES beginner_tutorials
CATKIN_DEPENDS roscpp rospy std_msgs message_runtime
# DEPENDS system_lib
)
###########
## Build ##
###########
## Specify additional locations of header files
## Your package locations should be listed before other locations
include_directories(
# include
${catkin_INCLUDE_DIRS}
)
## Declare a C++ library
# add_library(${PROJECT_NAME}
# src/${PROJECT_NAME}/beginner_tutorials.cpp
# )
## Add cmake target dependencies of the library
## as an example, code may need to be generated before libraries
## either from message generation or dynamic reconfigure
# add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
## Declare a C++ executable
## With catkin_make all packages are built within a single CMake context
## The recommended prefix ensures that target names across packages don't collide
# add_executable(${PROJECT_NAME}_node src/beginner_tutorials_node.cpp)
## Rename C++ executable without prefix
## The above recommended prefix causes long target names, the following renames the
## target back to the shorter version for ease of user use
## e.g. "rosrun someones_pkg node" instead of "rosrun someones_pkg someones_pkg_node"
# set_target_properties(${PROJECT_NAME}_node PROPERTIES OUTPUT_NAME node PREFIX "")
## Add cmake target dependencies of the executable
## same as for the library above
# add_dependencies(${PROJECT_NAME}_node ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
## Specify libraries to link a library or executable target against
# target_link_libraries(${PROJECT_NAME}_node
# ${catkin_LIBRARIES}
# )
#############
## Install ##
#############
# all install targets should use catkin DESTINATION variables
# See http://ros.org/doc/api/catkin/html/adv_user_guide/variables.html
## Mark executable scripts (Python etc.) for installation
## in contrast to setup.py, you can choose the destination
# catkin_install_python(PROGRAMS
# scripts/my_python_script
# DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
# )
## Mark executables for installation
## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_executables.html
# install(TARGETS ${PROJECT_NAME}_node
# RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
# )
## Mark libraries for installation
## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_libraries.html
# install(TARGETS ${PROJECT_NAME}
# ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
# LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
# RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION}
# )
## Mark cpp header files for installation
# install(DIRECTORY include/${PROJECT_NAME}/
# DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
# FILES_MATCHING PATTERN "*.h"
# PATTERN ".svn" EXCLUDE
# )
## Mark other files for installation (e.g. launch and bag files, etc.)
# install(FILES
# # myfile1
# # myfile2
# DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
# )
#############
## Testing ##
#############
## Add gtest based cpp test target and link libraries
# catkin_add_gtest(${PROJECT_NAME}-test test/test_beginner_tutorials.cpp)
# if(TARGET ${PROJECT_NAME}-test)
# target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME})
# endif()
## Add folders to be run by python nosetests
# catkin_add_nosetests(test)
在CMakeLists.txt文件的底部添加下述内容：
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)
如果我们对CMake略有了解，则会意识到这将会创建两个可执行文件 talker 和 listener，将默认放入devel文件夹中，路径为：
~/catkin_ws/devel/lib/<package name>
注意，我们还必须添加可执行文件的目标依赖项到消息生成目标。
add_dependencies(talker beginner_tutorials_generate_messages_cpp)
这确保在使用此包之前生成该包的消息头。如果您在catkin工作区内使用来自其他包的消息，我们还需要将依赖项添加到它们各自的生成目标，因为catkin并行构建所有项目。从ROS的Groovy版本开始，我们可以使用以下变量来依赖于所有必要的目标：
target_link_libraries(talker ${catkin_LIBRARIES})
接下来使用catkin_make来编译生成我们想要的可执行文件。
# In your catkin workspace
$ cd ~/catkin_ws
$ catkin_make
测试Publisher和Subscriber节点
编译之后，我们启动roscore，然后打开两个terminal窗口，分别使用rosrun启动talker和listener两个节点，执行命令如下：
$ roscore
启动talker
$ rosrun beginner_tutorials talker
启动listener
rosrun beginner_tutorials listener
输出结果：
当然，我们也可以在~/catkin_ws/devel/lib/beginner_tutorials文件夹下找到生成的可执行文件，直接调用两个文件，进行运行节点。
./talker
./listener