声明：本篇文章是学习wiki ROS上的相应教程。
第一步：创建一个catkin程序包（如过已经配置好catkin那就可跳过这一步）
本部分教程将演示如何使用catkin_create_pkg命令来创建一个新的catkin程序包以及创建之后都能做些什么。
首先切换到之前通过创建catkin工作空间教程创建的catkin工作空间中的src目录下：
# You should have created this in the Creating a Workspace Tutorial
$ cd ~/catkin_ws/src
现在使用catkin_create_pkg命令来创建一个名为'beginner_tutorials'的新程序包，这个程序包依赖于std_msgs、roscpp和rospy：
$ catkin_create_pkg beginner_tutorials std_msgs rospy roscpp
这将会创建一个名为beginner_tutorials的文件夹，这个文件夹里面包含一个package.xml文件和一个CMakeLists.txt文件，这两个文件都已经自动包含了部分你在执行catkin_create_pkg命令时提供的信息。
catkin_create_pkg命令会要求你输入package_name，如果有需要你还可以在后面添加一些需要依赖的其它程序包：
# This is an example, do not try to run this
# catkin_create_pkg <package_name> [depend1] [depend2] [depend3]
catkin_create_pkg命令也有更多的高级功能，这些功能在catkin/commands/catkin_create_pkg中有描述。
第二步：编写简单的消息发布器和订阅器 (C++)
http://wiki.ros.org/cn/ROS/Tutorials/WritingPublisherSubscriber%28c%2B%2B%29
1.编写发布器节点
"节点(Node)" 是ROS中指代连接到ROS网络的可执行文件的术语。接下来，我们将会创建一个发布器节点("talker")，它将不断的在ROS网络中广播消息。
转移到之前教程在catkin工作空间所创建的beginner_tutorials package路径下:
cd ~/catkin_ws/src/beginner_tutorials
1.1源代码
在beginner_tutorials package路径下创建src目录:
mkdir -p ~/catkin_ws/src/beginner_tutorials/src
这个目录将会存储beginner_tutorials package的所有源代码.
在beginner_tutorials package里创建src/talker.cpp文件，并粘贴如下代码：
https://raw.github.com/ros/ros_tutorials/groovy-devel/roscpp_tutorials/talker/talker.cpp
27 #include "ros/ros.h"
28 #include "std_msgs/String.h"
29
30 #include <sstream>
31
32 /**
33 * This tutorial demonstrates simple sending of messages over the ROS system.
34 */
35 int main(int argc, char **argv)
36 {
37 /**
38 * The ros::init() function needs to see argc and argv so that it can perform
39 * any ROS arguments and name remapping that were provided at the command line. For programmatic
40 * remappings you can use a different version of init() which takes remappings
41 * directly, but for most command-line programs, passing argc and argv is the easiest
42 * way to do it. The third argument to init() is the name of the node.
43 *
44 * You must call one of the versions of ros::init() before using any other
45 * part of the ROS system.
46 */
47 ros::init(argc, argv, "talker");
48
49 /**
50 * NodeHandle is the main access point to communications with the ROS system.
51 * The first NodeHandle constructed will fully initialize this node, and the last
52 * NodeHandle destructed will close down the node.
53 */
54 ros::NodeHandle n;
55
56 /**
57 * The advertise() function is how you tell ROS that you want to
58 * publish on a given topic name. This invokes a call to the ROS
59 * master node, which keeps a registry of who is publishing and who
60 * is subscribing. After this advertise() call is made, the master
61 * node will notify anyone who is trying to subscribe to this topic name,
62 * and they will in turn negotiate a peer-to-peer connection with this
63 * node. advertise() returns a Publisher object which allows you to
64 * publish messages on that topic through a call to publish(). Once
65 * all copies of the returned Publisher object are destroyed, the topic
66 * will be automatically unadvertised.
67 *
68 * The second parameter to advertise() is the size of the message queue
69 * used for publishing messages. If messages are published more quickly
70 * than we can send them, the number here specifies how many messages to
71 * buffer up before throwing some away.
72 */
73 ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);
74
75 ros::Rate loop_rate(10);
76
77 /**
78 * A count of how many messages we have sent. This is used to create
79 * a unique string for each message.
80 */
81 int count = 0;
82 while (ros::ok())
83 {
84 /**
85 * This is a message object. You stuff it with data, and then publish it.
86 */
87 std_msgs::String msg;
88
89 std::stringstream ss;
90 ss << "hello world " << count;
91 msg.data = ss.str();
92
93 ROS_INFO("%s", msg.data.c_str());
94
95 /**
96 * The publish() function is how you send messages. The parameter
97 * is the message object. The type of this object must agree with the type
98 * given as a template parameter to the advertise<>() call, as was done
99 * in the constructor above.
100 */
101 chatter_pub.publish(msg);
102
103 ros::spinOnce();
104
105 loop_rate.sleep();
106 ++count;
107 }
108
109
110 return 0;
111 }
1.2代码解释
现在，我们来分段解释代码.
27 #include "ros/ros.h"
28
ros/ros.h是一个实用的头文件，它引用了ROS系统中大部分常用的头文件，使用它会使得编程很简便。
28 #include "std_msgs/String.h"
29
这引用了std_msgs/String 消息, 它存放在std_msgs package里，是由String.msg文件自动生成的头文件。需要更详细的消息定义,参考msg页面.
47 ros::init(argc, argv, "talker");
初始化ROS。它允许ROS通过命令行进行名称重映射——目前，这不是重点。同样，我们也在这里指定我们节点的名称——必须唯一。
这里的名称必须是一个base name，不能包含/。
54 ros::NodeHandle n;
为这个进程的节点创建一个句柄。第一个创建的NodeHandle会为节点进行初始化，最后一个销毁的会清理节点使用的所有资源。
73 ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);
告诉master我们将要在chatter topic上发布一个std_msgs/String的消息。这样master就会告诉所有订阅了chatter topic的节点，将要有数据发布。第二个参数是发布序列的大小。在这样的情况下，如果我们发布的消息太快，缓冲区中的消息在大于1000个的时候就会开始丢弃先前发布的消息。
NodeHandle::advertise() 返回一个 ros::Publisher对象,它有两个作用: 1) 它有一个publish()成员函数可以让你在topic上发布消息； 2) 如果消息类型不对,它会拒绝发布。
75 ros::Rate loop_rate(10);
ros::Rate对象可以允许你指定自循环的频率。它会追踪记录自上一次调用Rate::sleep()后时间的流逝，并休眠直到一个频率周期的时间。
在这个例子中，我们让它以10hz的频率运行。
81 int count = 0;
82 while (ros::ok())
83 {
roscpp会默认安装一个SIGINT句柄，它负责处理Ctrl-C键盘操作——使得ros::ok()返回FALSE。
ros::ok()返回false，如果下列条件之一发生：
- SIGINT接收到(Ctrl-C)
- 被另一同名节点踢出ROS网络
-
ros::shutdown()被程序的另一部分调用
-
所有的ros::NodeHandles都已经被销毁
一旦ros::ok()返回false, 所有的ROS调用都会失效。
我们使用一个由msg file文件产生的‘消息自适应’类在ROS网络中广播消息。现在我们使用标准的String消息，它只有一个数据成员"data"。当然你也可以发布更复杂的消息类型。
101 chatter_pub.publish(msg);
现在我们已经向所有连接到chatter topic的节点发送了消息。
93 ROS_INFO("%s", msg.data.c_str());
ROS_INFO和类似的函数用来替代printf/cout. 参考rosconsole documentation以获得更详细的信息。
103 ros::spinOnce();
在这个例子中并不是一定要调用ros::spinOnce()，因为我们不接受回调。然而，如果你想拓展这个程序，却又没有在这调用ros::spinOnce()，你的回调函数就永远也不会被调用。所以，在这里最好还是加上这一语句。
105 loop_rate.sleep();
这条语句是调用ros::Rate对象来休眠一段时间以使得发布频率为10hz。
对上边的内容进行一下总结：
- 初始化ROS系统
-
在ROS网络内广播我们将要在chatter topic上发布std_msgs/String消息
- 以每秒10次的频率在chatter上发布消息
接下来我们要编写一个节点来接收消息。
2.编写订阅器节点
2.1源代码
在beginner_tutorials package目录下创建src/listener.cpp文件，并粘贴如下代码：
https://raw.github.com/ros/ros_tutorials/groovy-devel/roscpp_tutorials/listener/listener.cpp
28 #include "ros/ros.h"
29 #include "std_msgs/String.h"
30
31 /**
32 * This tutorial demonstrates simple receipt of messages over the ROS system.
33 */
34 void chatterCallback(const std_msgs::String::ConstPtr& msg)
35 {
36 ROS_INFO("I heard: [%s]", msg->data.c_str());
37 }
38
39 int main(int argc, char **argv)
40 {
41 /**
42 * The ros::init() function needs to see argc and argv so that it can perform
43 * any ROS arguments and name remapping that were provided at the command line. For programmatic
44 * remappings you can use a different version of init() which takes remappings
45 * directly, but for most command-line programs, passing argc and argv is the easiest
46 * way to do it. The third argument to init() is the name of the node.
47 *
48 * You must call one of the versions of ros::init() before using any other
49 * part of the ROS system.
50 */
51 ros::init(argc, argv, "listener");
52
53 /**
54 * NodeHandle is the main access point to communications with the ROS system.
55 * The first NodeHandle constructed will fully initialize this node, and the last
56 * NodeHandle destructed will close down the node.
57 */
58 ros::NodeHandle n;
59
60 /**
61 * The subscribe() call is how you tell ROS that you want to receive messages
62 * on a given topic. This invokes a call to the ROS
63 * master node, which keeps a registry of who is publishing and who
64 * is subscribing. Messages are passed to a callback function, here
65 * called chatterCallback. subscribe() returns a Subscriber object that you
66 * must hold on to until you want to unsubscribe. When all copies of the Subscriber
67 * object go out of scope, this callback will automatically be unsubscribed from
68 * this topic.
69 *
70 * The second parameter to the subscribe() function is the size of the message
71 * queue. If messages are arriving faster than they are being processed, this
72 * is the number of messages that will be buffered up before beginning to throw
73 * away the oldest ones.
74 */
75 ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
76
77 /**
78 * ros::spin() will enter a loop, pumping callbacks. With this version, all
79 * callbacks will be called from within this thread (the main one). ros::spin()
80 * will exit when Ctrl-C is pressed, or the node is shutdown by the master.
81 */
82 ros::spin();
83
84 return 0;
85 }
2.2代码解释
下面我们将逐条解释代码，当然，之前解释过的代码就不再赘述了。
34 void chatterCallback(const std_msgs::String::ConstPtr& msg)
35 {
36 ROS_INFO("I heard: [%s]", msg->data.c_str());
37 }
这是一个回调函数，当消息到达chatter topic的时候就会被调用。消息是以 boost shared_ptr指针的形式传输，这就意味着你可以存储它而又不需要复制数据
75 ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
告诉master我们要订阅chatter topic上的消息。当有消息到达topic时，ROS就会调用chatterCallback()函数。第二个参数是队列大小，以防我们处理消息的速度不够快，在缓存了1000个消息后，再有新的消息到来就将开始丢弃先前接收的消息。
NodeHandle::subscribe()返回ros::Subscriber对象,你必须让它处于活动状态直到你不再想订阅该消息。当这个对象销毁时，它将自动退订 上的消息。
有各种不同的NodeHandle::subscribe()函数，允许你指定类的成员函数，甚至是Boost.Function对象可以调用的任何数据类型。roscpp overview 提供了更为详尽的信息。
82 ros::spin();
ros::spin()进入自循环，可以尽可能快的调用消息回调函数。如果没有消息到达，它不会占用很多CPU，所以不用担心。一旦ros::ok()返回FALSE，ros::spin()就会立刻跳出自循环。这有可能是ros::shutdown()被调用，或者是用户按下了Ctrl-C，使得master告诉节点要shutdown。也有可能是节点被人为的关闭。
还有其他的方法进行回调，但在这里我们不涉及。想要了解，可以参考roscpp_tutorials package里的一些demo应用。需要更为详尽的信息，参考roscpp overview。
下边，我们来总结一下:
- 初始化ROS系统
-
订阅chatter topic
- 进入自循环，等待消息的到达
-
当消息到达，调用chatterCallback()函数
3.编译节点
之前教程中使用catkin_create_pkg创建了package.xml 和 CMakeLists.txt 文件。
生成的CMakeLists.txt看起来应该是这样(在Creating Msgs and Srvs教程中的修改和未被使用的注释和例子都被移除了):
1 cmake_minimum_required(VERSION 2.8.3)
2 project(beginner_tutorials)
3
4 ## Find catkin and any catkin packages
5 find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs genmsg)
6
7 ## Declare ROS messages and services
8 add_message_files(DIRECTORY msg FILES Num.msg)
9 add_service_files(DIRECTORY srv FILES AddTwoInts.srv)
10
11 ## Generate added messages and services
12 generate_messages(DEPENDENCIES std_msgs)
13
14 ## Declare a catkin package
15 catkin_package()
在CMakeLists.txt文件末尾加入几条语句:
include_directories(include ${catkin_INCLUDE_DIRS})
add_executable(talker src/talker.cpp)
target_link_libraries(talker ${catkin_LIBRARIES})
add_executable(listener src/listener.cpp)
target_link_libraries(listener ${catkin_LIBRARIES})
结果，CMakeLists.txt文件看起来像这样:
1 cmake_minimum_required(VERSION 2.8.3)
2 project(beginner_tutorials)
3
4 ## Find catkin and any catkin packages
5 find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs genmsg)
6
7 ## Declare ROS messages and services
8 add_message_files(FILES Num.msg)
9 add_service_files(FILES AddTwoInts.srv)
10
11 ## Generate added messages and services
12 generate_messages(DEPENDENCIES std_msgs)
13
14 ## Declare a catkin package
15 catkin_package()
16
17 ## Build talker and listener
18 include_directories(include ${catkin_INCLUDE_DIRS})
19
20 add_executable(talker src/talker.cpp)
21 target_link_libraries(talker ${catkin_LIBRARIES})
22 add_dependencies(talker beginner_tutorials_generate_messages_cpp)
23
24 add_executable(listener src/listener.cpp)
25 target_link_libraries(listener ${catkin_LIBRARIES})
26 add_dependencies(listener beginner_tutorials_generate_messages_cpp)
这会生成两个可执行文件, talker 和 listener, 默认存储到devel space目录,具体是在~/catkin_ws/devel/lib/<package name>中.
现在要为可执行文件添加对生成的消息文件的依赖：
add_dependencies(talker beginner_tutorials_generate_messages_cpp)
这样就可以确保自定义消息的头文件在被使用之前已经被生成。因为catkin把所有的package并行的编译，所以如果你要使用其他catkin工作空间中其他package的消息，你同样也需要添加对他们各自生成的消息文件的依赖。当然，如果在*Groovy*版本下，你可以使用下边的这个变量来添加对所有必须的文件依赖:
add_dependencies(talker ${catkin_EXPORTED_TARGETS})
你可以直接调用可执行文件，也可以使用rosrun来调用他们。他们不会被安装到'<prefix>/bin'路径下，因为那样会改变系统的PATH环境变量。如果你确定要将可执行文件安装到该路径下，你需要设置安装目标，请参考catkin/CMakeLists.txt
需要关于CMakeLists.txt更详细的信息，请参考catkin/CMakeLists.txt
现在运行 catkin_make:
# In your catkin workspace
$ catkin_make
注意:如果你是添加了新的package，你需要通过--force-cmake选项告诉catkin进行强制编译。参考catkin/Tutorials/using_a_workspace#With_catkin_make.
既然已经编写好了发布器和订阅器，下面让我们来测试消息发布器和订阅器.
第三步：编译ROS程序包
1.编译程序包
一旦安装了所需的系统依赖项，我们就可以开始编译刚才创建的程序包了。
注意: 如果你是通过apt或者其它软件包管理工具来安装ROS的，那么系统已经默认安装好所有依赖项。
记得事先source你的环境配置(setup)文件，在Ubuntu中的操作指令如下：
$ source /opt/ros/groovy/setup.bash
使用 catkin_make
catkin_make 是一个命令行工具，它简化了catkin的标准工作流程。你可以认为catkin_make是在CMake标准工作流程中依次调用了cmake 和 make。
使用方法:
# 在catkin工作空间下
$ catkin_make [make_targets] [-DCMAKE_VARIABLES=...]
CMake标准工作流程主要可以分为以下几个步骤：
注意: 如果你运行以下命令是无效的，因为它只是一个演示CMake工作流程的例子。
# 在一个CMake项目里
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install # (可选)
每个CMake工程在编译时都会执行这个操作过程。相反，多个catkin项目可以放在工作空间中一起编译，工作流程如下：
# In a catkin workspace
$ catkin_make
$ catkin_make install # (可选)
上述命令会编译src文件夹下的所有catkin工程。想更深入了解请参考REP128。 如果你的源代码不在默认工作空间中（~/catkin_ws/src),比如说存放在了my_src中，那么你可以这样来使用catkin_make:
注意: 运行以下命令时无效的，因为my_src不存在。
# In a catkin workspace
$ catkin_make --source my_src
$ catkin_make install --source my_src # (optionally)
对于catkin_make更高级的使用方法，请参考catkin/commands/catkin_make
1.1开始编译你的程序包
按照之前的创建一个ROS程序包教程，你应该已经创建好了一个catkin 工作空间 和一个名为beginner_tutorials的catkin 程序包。现在切换到catkin workspace 并查看src文件夹：
$ cd ~/catkin_ws/
$ ls src
-
beginner_tutorials/ CMakeLists.txt@
你可以看到一个名为beginner_tutorials的文件夹，这就是你在之前的 catkin_create_pkg教程里创建的。现在我们可以使用catkin_make来编译它了:
$ catkin_make
你可以看到很多cmake 和 make 输出的信息：
-
Base path: /home/user/catkin_ws Source space: /home/user/catkin_ws/src Build space: /home/user/catkin_ws/build Devel space: /home/user/catkin_ws/devel Install space: /home/user/catkin_ws/install #### #### Running command: "cmake /home/user/catkin_ws/src -DCATKIN_DEVEL_PREFIX=/home/user/catkin_ws/devel -DCMAKE_INSTALL_PREFIX=/home/user/catkin_ws/install" in "/home/user/catkin_ws/build" #### -- The C compiler identification is GNU 4.2.1 -- The CXX compiler identification is Clang 4.0.0 -- Checking whether C compiler has -isysroot -- Checking whether C compiler has -isysroot - yes -- Checking whether C compiler supports OSX deployment target flag -- Checking whether C compiler supports OSX deployment target flag - yes -- Check for working C compiler: /usr/bin/gcc -- Check for working C compiler: /usr/bin/gcc -- works -- Detecting C compiler ABI info -- Detecting C compiler ABI info - done -- Check for working CXX compiler: /usr/bin/c++ -- Check for working CXX compiler: /usr/bin/c++ -- works -- Detecting CXX compiler ABI info -- Detecting CXX compiler ABI info - done -- Using CATKIN_DEVEL_PREFIX: /tmp/catkin_ws/devel -- Using CMAKE_PREFIX_PATH: /opt/ros/groovy -- This workspace overlays: /opt/ros/groovy -- Found PythonInterp: /usr/bin/python (found version "2.7.1") -- Found PY_em: /usr/lib/python2.7/dist-packages/em.pyc -- Found gtest: gtests will be built -- catkin 0.5.51 -- BUILD_SHARED_LIBS is on -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- ~~ traversing packages in topological order: -- ~~ - beginner_tutorials -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- +++ add_subdirectory(beginner_tutorials) -- Configuring done -- Generating done -- Build files have been written to: /home/user/catkin_ws/build #### #### Running command: "make -j4" in "/home/user/catkin_ws/build" ####
catkin_make首先输出它所使用到的每个空间所在的路径。更多关于空间的信息，请参考REP128和catkin/workspaces。需要注意的是由于这些空间存在默认配置的原因，有几个文件夹已经在catkin工作空间自动生成了，使用ls查看:
$ ls
-
build devel src
build 目录是build space的默认所在位置，同时cmake 和 make也是在这里被调用来配置并编译你的程序包。devel 目录是devel space的默认所在位置, 同时也是在你安装程序包之前存放可执行文件和库文件的地方。
第四步：测试消息发布器和订阅器（http://wiki.ros.org/cn/ROS/Tutorials/ExaminingPublisherSubscriber）
Description: 本教程将测试上一教程所写的消息发布器和订阅器。
Tutorial Level: BEGINNER
Next Tutorial: 写一个简单的服务端和客户端 (python) (c++)
1.启动发布器
确保roscore可用，并运行：
$ roscore
catkin specific 如果使用catkin，确保你在调用catkin_make后，在运行你自己的程序前，已经source了catkin工作空间下的setup.sh文件：
# In your catkin workspace
$ cd ~/catkin_ws
$ source ./devel/setup.bash
In the last tutorial we made a publisher called "talker". Let's run it:
$ rosrun beginner_tutorials talker (C++)
$ rosrun beginner_tutorials talker.py (Python)
你将看到如下的输出信息:
-
[INFO] [WallTime: 1314931831.774057] hello world 1314931831.77 [INFO] [WallTime: 1314931832.775497] hello world 1314931832.77 [INFO] [WallTime: 1314931833.778937] hello world 1314931833.78 [INFO] [WallTime: 1314931834.782059] hello world 1314931834.78 [INFO] [WallTime: 1314931835.784853] hello world 1314931835.78 [INFO] [WallTime: 1314931836.788106] hello world 1314931836.79
发布器节点已经启动运行。现在需要一个订阅器节点来接受发布的消息。
2.启动订阅器
上一教程，我们编写了一个名为"listener"的订阅器节点。现在运行它：
# In your catkin workspace
$ cd ~/catkin_ws
$ source ./devel/setup.bash #如果有打开新的终端来运行就要从新在启动。
$ rosrun beginner_tutorials listener (C++)
$ rosrun beginner_tutorials listener.py (Python)
你将会看到如下的输出信息:
-
[INFO] [WallTime: 1314931969.258941] /listener_17657_1314931968795I heard hello world 1314931969.26 [INFO] [WallTime: 1314931970.262246] /listener_17657_1314931968795I heard hello world 1314931970.26 [INFO] [WallTime: 1314931971.266348] /listener_17657_1314931968795I heard hello world 1314931971.26 [INFO] [WallTime: 1314931972.270429] /listener_17657_1314931968795I heard hello world 1314931972.27 [INFO] [WallTime: 1314931973.274382] /listener_17657_1314931968795I heard hello world 1314931973.27 [INFO] [WallTime: 1314931974.277694] /listener_17657_1314931968795I heard hello world 1314931974.28 [INFO] [WallTime: 1314931975.283708] /listener_17657_1314931968795I heard hello world 1314931975.28
你已经测试完了发布器和订阅器，下面我们来编写一个服务和客户端(python) (c++).
