ROS通信-小例子
 
1、环境
 
​ ubuntu20.04 + ROS Noetic Ninjemys(http://wiki.ros.org/noetic/Installation)
 
2、例子（目的是建立talker1和listener1的通信，talker1为发布者，listener1为订阅者）
 
2.1 cd ~ # 进入用户目录。
2.2 mkdir -p ~/catkin_ws/src # 创建工作空间。
2.3 catkin_create_pkg message std_msgs roscpp # 创建message功能包，message依赖于std_msg，roscpp等package。运行该命令后会生成CMakeLists.txt、include、package.xml、src等文件。如下图所示
 
 
2.4 cd ~/catkin_ws/src/message/src # 进入cpp节点创建路径。
2.5 touch talker1.cpp和touch listener1.cpp # 创建两个cpp节点。如下图所示。
 

 ​ talk1.cpp代码（代码有不懂的可以去看《ROS机器人上程序设计》的P35页）：
 
#include "ros/ros.h"
#include "std_msgs/String.h"

#include <sstream>

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

  ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);

  ros::Rate loop_rate(10);

  int count = 0;
  while (ros::ok())
  {

    std_msgs::String msg;

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

    ROS_INFO("%s", msg.data.c_str());

    chatter_pub.publish(msg);

    ros::spinOnce();

    loop_rate.sleep();
    ++count;
  }


  return 0;
}
 
​ listener1.cpp代码：
 
#include "ros/ros.h"
#include "std_msgs/String.h"

void chatterCallback(const std_msgs::String::ConstPtr& msg)
{
  ROS_INFO("I heard: [%s]", msg->data.c_str());
}

int main(int argc, char **argv)
{
  ros::init(argc, argv, "listener");
  ros::NodeHandle n;
  ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
  ros::spin();
  return 0;
}
 
​ 2.6 修改~/catkin_ws/src目录下的CMakelist.txt文件，加入
 
add_executable(talker1 src/talker1cpp)
target_link_libraries(talker1 ${catkin_LIBRARIES})
add_executable(listener1 src/listener1.cpp)
target_link_libraries(listener1  ${catkin_LIBRARIES})
 
四行代码即可。如下图所示。
 
 2.7 cd ~/catkin_ws，然后运行catkin_make进行编译。如下图所示为编译成功。
 
 ​ 2.8 编译成功后，会在~/catkin_ws/devel/lib/messager目录下生成talker1和listener1两个可执行文件。
 
 ​ 2.9 另起一个终端，运行roscore
 ​ 2.10 再另起两个终端运行，先运行./talker1发布节点到topic，再运行./listener1订阅该节点。至此即完成ROS通信过程。如下图所示。
 

各位博友，好久不见。自从window系统顺利安装ROS系统之后，小海龟顺利跑起来，就面临Ubuntu系统和windows系统上的ROS通信问题。这个问题卡了很久，就在今天上午，在实验室强哥的帮助下，这个问题终于解决。
 
查了很多博客，对这个问题，并没有一个系统性的解决方案。今天将这一过程梳理一二，整理如下：
 
想要实现Windows中ros和Ubuntu系统中的ros进行通信，按照两个Ubuntu系统中ROS通信的思路，这里参考该链接先对ubuntu的配置过程进行阐述：
 
一、Ubuntu系统ros和Ubuntu系统ros的通信过程
 
1、配置IP地址
 
 
首先需要确定ROS多机系统中的所有计算机处于同一网络，然后分别在计算机ubuntu、shibopi-desktop上使用ifconfig命令查看计算机的局域网IP地址 为了防止每次开机分配的IP地址变化，这里建议为俩机分配固定IP,一劳永逸，下面我使用的这两个IP是我分配好的。
 
主机
ubuntu
192.168.8.88
从机
shibopi-desktop
192.168.8.197
 
分别在两台计算机系统的/etc/hosts文件中加入对方的IP地址和对应的计算机名
 
在Ubuntu主机上运行以下指令
 
sudo gedit /etc/hosts
 
将指令加入到该文件中192.168.8.197 shibopi-desktop
 
在shibopi-desktop从机上运行以下指令
 
sudo gedit /etc/hosts
 
将指令加入到该文件中192.168.8.88 ubuntu
 
设置完毕后，分别在两台计算机上使用ping命令测试网络是否连通
 
 
2、设置ROS_MASTER_URI
 
因为系统中只能存在一个Master，所以从机shibopi-desktop需要知道Master的位置。ROS Master的位置可以使用环境变量ROS_MASTER_URI进行定义，在从机shibopi-desktop上使用如下命令设置ROS_MASTER_URI：
 
$ export ROS_MASTER_URI=http:/ubuntu:11311
 
但是以上设置只能在输入的终端中生效，为了让所有打开的终端都能识别，最好使用如下命令将环境变量的设置加入终端的配置文件中。
 
$ echo "export ROS_MASTER_URI=http://ubuntu:11311" >> ～/.bzshrc
 
这样，两个Ubuntu系统中的ROS就能通讯了。
 
二、windows系统中的ROS和Ubuntu系统的ROS进行通信
 
这里准备的硬件条件为
 
Windows
melodic
10.42.0.100
从机
Ubuntu
kinetic
10.42.0.1
主机
1、配置IP地址
 
将Windows系统和Ubuntu系统放置在同一个局域网下，分别在Ubuntu系统和windows系统中固定IP地址。这里默认各位博友天生就会固定Ubuntu下的IP地址。windows的IP地址固定的过程用一张图说清楚：
 
 这里固定Windows端的IP地址为10.42.0.100
 Ubuntu端的IP地址为10.42.0.1
 
与上述两个Ubuntu系统中ROS通讯不同的是，这次就不在/etc/hosts文件进行任何操作
 
直接在windows上的命令行窗口去ping 10.42.0.1和在Ubuntu系统的终端去ping 10.42.0.100
 
这里不出意外的话，会遇到一个问题。就是在Windows下去ping通Ubuntu是可以ping通的，但是从Ubuntu去ping通Windows就ping不同。这里需要设置一下防火墙，这里以一张图片和一个链接阐述这一操作过程：
 
 设置完成了！！！
 发现可以ping通了，走到这里，相信大部分博友开始暗自高兴，因为大佬总会对问题解决的程度有一个敏锐感觉，问题已经解决大半了。
 
2、设置ROS_MASTER_URI
 
因为系统中只能存在一个Master，所以从机Windows需要知道Master的位置。但是Windows下没有.bashrc文件呀，这如何设置呢？
 这里主要参考这个链接，给我们的进展打开了新的思路。
 在Windows系统中安装ROS的过程中，都会在桌面生成一个ROS的快捷命令窗口，双击这个ROS快捷命令窗口，并在其中执行以下两条指令：
 
set ROS_MASTER_URI=http://主机IP:11311

set ROS_IP=从机IP
 
对应于之前的设定，本电脑执行如下命令：
 
 这两条语句对应于Ubuntu系统写入.bashrc文件中的两条：
 
export ROS_MASTER_URI=http://主机IP:11311  #要和主机的roscore终端中的ROS_MASTER_URI的port一致，默认为11311。http不可省略

export ROS_IP=从机IP              #本机的ip地址
 
注意
 Windows作为从机，在每次启动的时候都要单独在命令行中执行这两条语句，如果嫌麻烦的话，可以将其写到一个脚本文件中。
 
三、小海龟测试
 
在Ubuntu系统的终端执行以下指令
 
roscore
rosrun turtlesim turtlesim_node
 
把小海龟的节点跑起来
 
 
在Windows系统中，通过ROS命令行快捷方式输入以下指令
 
set ROS_MASTER_URI=http://10.42.0.1:11311
set ROS_IP=10.42.0.100
rosrun turtlesim turtle_teleop_key.exe
 
键盘控制的节点跑起来：
 
 
最后
 Windows上的ros和Ubuntu系统ros通信成功！！！
 
附一张照片
 
 
在此，向以下链接提供的帮助表示诚挚的谢意！
 https://www.codenong.com/cs106025874/
 https://www.guyuehome.com/25106

ROS通信架构及其弊端
 
严格来讲ROS并非是一种操作系统，它只是一种通信框架，一种基于消息传递通信的分布式多进程框架。ROS的主要组成包括ROS Mastar 、 ROS Node、ROS Service等。不同的功能可以由不同的节点实现，节点之间可以通过发布和订阅话题来传递消息，它的本质是基于TCP/IP的Socket通信机制。不同的模块可以被单独设计，在运行时松散耦合，它执行若干种类型的通信，比如基于服务的同步RPC通信、基于话题的异步数据流通信以及基于参数服务器的数据存储等。
 
ROS具备丰富的机器人功能库，比如用于坐标变换的 Tf、用于导航的SLAM功能库、用于视觉的OPenCV功能库、用于运动的MoveIt、用于激光雷达的PCL点云库等等，这些丰富的功能库可以使得开发人员快速开发并验证自己的机器人原型；ROS还具备非常便利的数据分析、仿真、调试、可视化工具，比如RVIZ、Gazebo等，还有rosbag、rqt等可以提供数据记录功能等，这些工具可以方便的进行调试开发、验证、仿真自己的机器人，从而提高开发速度。
 当然正是由于ROS的这种架构使得它存在一些弊端：
 

 1 Master 与 Node 之间并不关心对方的存在，Master 作为网络拓扑的中心，一旦Master崩溃，整个系统将会崩溃；
 
 2 当 Master 或 Node 崩溃后ROS没有应对策略，ROS不具备动态发现、生存检测、访问控制等机制，因此对系统是一种灾难；
 
 3 系统存在大量的话题和数据时，一个节点与多个节点通信时，一个消息会拷贝多次，因此对系统资源也是一种极大的浪费，并降低系统通信效率，严重时会丢包；
 
 4 ROS通信的消息数据是开放的未加密的，如果通信过程中Master或Node任何一个或多个被劫持，那系统将无法继续有效的运作下去，如果是安全性要求比较高的系统比如无人驾驶中，那么所带来的灾难是不可估量的；
 
可尝试的改进
 
去中心化
 
ROS并非完全的基于分布式的框架结构，它严重依赖 Master 中心节点，因此可以尝试在架构中去掉 Master 这个中心节点，采用节点自发现模式，动态的添加和去掉节点，比如ROS2.0所采用的DDS(Data Distribution Service)数据分发服务，以及 Apollo 中的基于 RTPS 协议的服务发现机制，当一个新的节点加入时，系统的自发现机制会自动向其他节点广播消息，各个节点也会将自己的信息发送至新加入的节点，从而代替 Master 功能。
 
采用共享内存，提高数据传输效率
 
摒弃ROS中的多个消息接收端拷贝多次现象，直接采用共享内存的方式实现，提高数据吞吐量，减少CPU负担，提高系统效率。
 
实时监控
 
实时监测并记录节点的运行数据，当检测到系统错误时做出报警，并采取必要的措施进行解决。监测记录节点的运行数据、统计数据、运行状态等，能够为错误追踪提供必要的线索，在系统发生紧急情况时做出反应。记录节点的状态，也是为了恢复宕掉的节点，如果没有记录这些状态，那么再启动将会丢失一些必要的数据，造成系统错误。
 
信息加密与安全
 
节点之间传递的信息很容易被截获，或被伪造，在无人驾驶领域，发生这种情况意味着严重的事故。必要时可以对发送的信息进行加密，或虚拟化处理，限制ROS节点进程权限，避免对其他节点造成破坏。
 
转至：https://zhuanlan.zhihu.com/p/35219808

 
目录
 
发布/订阅者模型
（一）发布者
（二）订阅者
（三）综合
参考资料
    
   
  
 

 
ROS (Robot Operating System)，即机器人操作系统，是为了加快机器人的开发效率，提高机器人软件代码的复用率，用于机器人算法快速仿真验证的一个软件平台。
 
ROS已经成为机器人领域的一个普遍标准。换句话说，未来的任何一个机器人工程师都必须会ROS，越来越多的机器人也将基于ROS来进行开发。
 
ROS主要可以由以下四个部分组成： ROS = 通信机制 + 开发工具 + 应用功能 + 生态系统。
 
通信机制：ROS的通信机制属于分布式松耦合通信机制，即各通信对象（ROS中指节点）之间相对独立。
开发工具：主要有命令行工具，Qt工具箱，Rviz三维可视化软件，Gazebo物理仿真平台等。
应用功能：包括机器人的主要功能，如即时定位与地图构建（SLAM），导航（Navigation），运动规划（MoveIt）等。
生态系统：主要是指ROS的社区资源。
 
ROS通信机制中有两大通信模型:
 
异步通信模型：Publish and Subscribe model (发布/订阅者模型)
同步通信模型：Server and Client model （服务/客户端模型）
 
发布/订阅者模型
 
发布/订阅者模型是基于话题（topic)和消息（message）来实现的。发布者负责发布某一话题topic，而话题的内容就是消息message，其有属于自己的消息类型。当某个话题被发布后，该话题的订阅者便会接收到该消息。
 
（一）发布者
 
举个例子。
 
我们打算编写这样一个节点：该节点名为“velocity_publisher”，负责发布turtlesim仿真器的海龟速度消息，而海龟仿真器负责订阅该话题消息。
 
 
再编写程序之前，我们先来看看ROS的海龟仿真器turtlesim。
 
终端输入：roscore，启动ros_master。
 
终端输入：rosrun turtlesim turtlesim_node，启动海龟仿真器，界面如下。
 
 
终端输入：rostopic list，查看当前环境的话题消息。
 
 
可见，当前环境中已经有了话题/turtle1/cmd_vel，turtle1表示仿真器中产生的第一只海龟，cmd_vel表示速度指令。
 
终端输入:rostopic info /turtle1/cmd_vel，获取该话题的具体信息。
 
 
通过终端输出，我们可以知道话题的三个重要信息：消息类型、发布者和订阅者。
 
turtle1/cmd_vel话题消息的类型是geometry_msgs/Twist，发布者无，订阅者是/turtlesim。即，/turtlesim已经自动订阅了话题消息/turtle/cmd_vel，我们需要做的仅仅是编写一个发布/turtle1/cmd_vel的节点。
 
终端输入：rosmsg show geometry_msgs/Twist ，获取Twist消息的具体消息格式。
 
 
Twist消息格式主要分为两部分：linear和angular。其中，linear指海龟在空间三个维度上的线速度，angular指海龟在空间三个维度上的角速度。
 
首先，我们选择C++来编写程序，直接上代码,，详细可参考代码中的注释。
 
#include <ros/ros.h>              //导入ros功能包
#include <geometry_msgs/Twist.h>  //导入geometry_msgs::Twist消息类型

/*
  功能：创建一个名为“velocity_publisher”的节点，负责发布海龟的速度指令
*/

int main(int argc,char **argv)
{
   //创建一个名为“velocity_publisher”的节点
   ros::init(argc,argv,"velocity_publisher");

   //创建节点句柄，用于管理节点对象
   ros::NodeHandle n;
   /*
      创建一个发布者对象: turtle_vel_pub，负责发布海龟速度消息
      消息类型：geometry_msgs::Twist（ros定义的关于海龟的速度消息类型）
      消息名字：/turtle1/cmd_vel
      消息队列长度：10
   */
   ros::Publisher turtle_vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel",10);

   //创建Rate对象，设置速度消息发布频率 单位Hz 10次/s 
   ros::Rate pub_rate(10);

   while (ros::ok())
   {
      //创建消息对象，并初始化数据
      geometry_msgs::Twist vel_msg;
      vel_msg.linear.x = 0.3;
      vel_msg.angular.z = 0.3;

      //发布速度消息
      turtle_vel_pub.publish(vel_msg);

      //打印日志信息
      ROS_INFO("Publishing turtle velocity command:[%0.2f  m/s,%0.2f rad/s]",vel_msg.linear.x,vel_msg.angular.z);

      //配合发布频率进行自适应延时
      pub_rate.sleep();
   }
   return 0;
}
 
编写好C++代码后，我们还需要在CMakeLists.txt中配置编译规则。
 
生成可执行文件
设置链接库
 
add_executable(velocity_publisher src/velocity_publisher.cpp)
target_link_libraries(velocity_publisher ${catkin_LIBRARIES})
 
终端输入：
 
roscore
 
rosrun turtlesim turtlesim_node
 
rosrun learning_topic velocity_publisher
 
运行结果：
 
 
发现了嘛，我们的小海龟已经在做圆周运动了。
 
终端输入：rqt_graph ，利用Qt工具箱得到当前环境的计算图。
 
 
通过rqt_graph我们可以直观的了解当前环境中各个节点之间的关系。
 
python 版代码
 
#!/usr/bin/env python
# _*_ coding:utf-8 _*_

"""
func: creating a node to publish a topic of /turtle1/cm_vel
"""

import rospy    # 导入rospy库
from geometry_msgs.msg import Twist  # 导入Twist消息类型


def velocity_publisher():
    # 创建一个名为“velocity_publisher”的节点
    rospy.init_node("velocity_publisher", anonymous=True)

    # 创建一个发布者：turtle_vel_pub
    # 消息名称：/turtle1/cmd_vel
    # 消息类型：Twist
    # 消息队列长度：10
    turtle_vel_pub = rospy.Publisher("/turtle1/cmd_vel", Twist, queue_size=10)

    # 创建消息发布频率对象，10次/s
    pub_rate = rospy.Rate(10)

    while not rospy.is_shutdown():
        # 创建消息，并初始化数据
        vel_msg = Twist()
        vel_msg.linear.x = 0.3
        vel_msg.angular.z = 0.3

        # 发布消息
        turtle_vel_pub.publish(vel_msg)

        # 打印日志信息
        rospy.loginfo("Publishing turtle velocity commanding: [% 0.2f m/s, %0.2f rad/s]", vel_msg.linear.x,
                      vel_msg.angular.z)

        # 按照发布频率进行延时
        pub_rate.sleep()


if __name__ == "__main__":
    try:
        velocity_publisher()
    except rospy.ROSInterruptException:
        pass
 
小提示：在运行.py文件之前，确保右击文件，在属性中修改.py可作为可执行文件执行。
 
这里，我们小结一下编写节点，发布话题的步骤：
 
创建节点（节点名字）
创建话题发布者对象（话题名，话题类型，队列长度等）
设置话题发布频率
创建话题消息，并初始化数据
发布者发布话题
延时
 
（二）订阅者
 
前面我们已经实现了编写一个节点用来发布海龟的速度指令信息。这一节，我们将编写一个节点，负责订阅海龟的位置信息。
 
 
不知道你们有没有发现在启动海龟仿真器turtlesim后，话题消息列表（见前面）中出现了/turtle1/pose这个话题？那我们来看看它的具体信息。
 
终端输入：
 
roscore
 
rosrun turtlesim turtlesim_node
 
rostopic info /turtle1/pose
 
终端输出结果如下：
 
 
可知，话题消息/turtle1/pose的发布者是turtlesim，订阅者无。所以，我们需要做的仅仅是编写一个节点，负责订阅海龟的位置信息即可。
 
终端输入：rosmsg show geometry_msgs/Pose
 
终端输出：
 
 
可知，Pose话题消息格式包含两个部分：position和orientation，其中position代表三维空间中的位置，orientation代表的是三维空间中的方位。
 
C++代码如下：
 
#include <ros/ros.h>          // 导入ros cpp库
#include "turtlesim/Pose.h"   // 导入Pose消息类型

// 订阅者注册的回调函数
void poseCallback(const turtlesim::Pose::ConstPtr &msg)
{
   //将接收到的消息打印出来,这里只显示平面二维坐标
   ROS_INFO("The turtle pose: x:%0.6f, y: %0.6f",msg->x,msg->y);
}


int main(int argc,char **argv)
{
    // 创建节点
    ros::init(argc,argv,"pose_subscriber");

    // 创建节点句柄
    ros::NodeHandle n;
    /*
      创建一个订阅者：turtle_pose_sub
      订阅消息名称：/turtle1/pose
      订阅消息类型：Pose
      消息队列长度：10
      回调函数：poseCallback
    */
    ros::Subscriber turtle_pose_sub = n.subscribe("/turtle1/pose",10,poseCallback);

    //循环等待回调函数
    ros::spin();

    return 0;
}
 
同样，在CMakeLists.txt配置编译规则
 
add_executable(pose_subscriber src/pose_subscriber.cpp)
target_link_libraries(pose_subscriber ${catkin_LIBRARIES})
 
终端输入：
 
roscore
 
rosrun turtlesim turtlesim_node
 
rosrun learning_topic velocity_publisher
 
rosrun learning_topic pose_subscriber
 
终端输出：
 
 
我们可以看到，小海龟在做圆周运动，同时它的位置也被实时输出到终端。
 
终端输入：rqt_graph，查看计算图。
 
 
现在来总结一下，编写一个节点，实现订阅者的步骤：
 
创建节点（配置节点名）
创建订阅者，订阅话题消息（话题名，话题类型，回调函数）
编写回调函数
循环等待回调函数
 
python版本代码
 
#!/usr/bin/env python
# _*_ coding:utf-8 _*_

"""
func: subscribing the pose information of a turtle
"""

import rospy   # 导入rospy
from turtlesim.msg import Pose    # 导入Pose类型


def poseCallback(msg):
    # 打印位置信息
    rospy.loginfo("The turtle's pose: x: %0.6f, y:%0.6f", msg.x, msg.y)


def pose_subscriber():
    # 创建一个名为"pose_subscriber"的节点
    rospy.init_node("pose_subscriber", anonymous=True)

    # 订阅位置信息
    rospy.Subscriber("/turtle1/pose", Pose, poseCallback)

    # 循环等待回调函数
    rospy.spin()


if __name__ == "__main__":
    pose_subscriber()
 
（三）综合
 
前面，我们分别单独介绍了如何编写一个节点实现发布者发布消息和订阅者订阅消息。但是，我们使用的都是ROS库封装好的消息结构，那我们可不可以定义自己的话题消息结构，然后实现发布和订阅呢？
 
答案是可以的！
 
ROS提供了一套机制，让用户可以定义自己想要的话题消息结构。
 
首先，我们在功能包中创建一个msg文件夹，然后在该文件夹下创建一个Person.msg文件，在该文件中我们添加以下内容：
 
string name
string sex
uint8 age
 
在Person.msg中我们定义了三个数据：name 、sex、age，用来表征一个人的信息。
 
接下来我们需要在CMakeLists.txt和package.xml中添加相关内容进行配置。
 
在CMakeLists.txt中添加：
 
find_package( ...... message_generation)

add_message_files(FILES Person.msg)
generate_messages(DEPENDENCIES std_msgs)

catkin_package(...... message_runtime)
 
在package.xml中添加：
 
<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>
 
到此，我们的自定义消息结构便配置完成了，然后在工作空间下进行编译。
 
终端输入：catkin_make
 
编译后，我们在/devel/include/learning_topic目录下可以发现ROS生成了一个Person.h头文件，该文件中的内容就是一些关于我们自定义消息结构的相关配置说明。
 
 
现在我们来检查以下自己创建的消息类型是否成功。
 
终端输入：rosmsg show learning_topic/Person
 
 
可见，我们已经成功定义了自己的话题消息结构learning_topic/Person
 
接下来，便是编写发布者节点和订阅者节点了，具体操作步骤同（一）（二），这里就不详细介绍了，具体参考代码。
 
发布者:person_publisher.cpp
 
/*
  func: 发布/person_info话题消息，自定义消息类型learning_topic::Person
*/
#include <ros/ros.h>
#include "learning_topic/Person.h"  //加入自定义消息结构头文件Person.h

int main(int argc,char **argv)
{
   //创建节点
   ros::init(argc,argv,"person_publisher");
   //创建节点句柄
   ros::NodeHandle n;
   /*
   创建发布者：person_info_pub
   消息名称：/person_info
   消息类型：learning_topic
   消息队列长度：10
   */
   ros::Publisher person_info_pub = n.advertise<learning_topic::Person>("/person_info",10);

   //设置消息发布频率
   ros::Rate pub_rate(10);

   while(ros::ok())
   {
       //创建消息，并初始化数据
       learning_topic::Person person_msg;
       person_msg.name = "Steve";
       person_msg.sex = "male";
       person_msg.age = 25;

       //发布消息
       person_info_pub.publish(person_msg);

       //打印日志信息
       ROS_INFO("publishing person info: name:%s sex: %s age:%d",person_msg.name.c_str(),person_msg.sex.c_str(),person_msg.age);

       //按照发布频率延时
       pub_rate.sleep();
   }
   return 0;
}
 
订阅者:person_subscriber.cpp
 
/*
  func:订阅话题消息/person_info
*/

#include <ros/ros.h>
#include "learning_topic/Person.h"

void personCallback(const learning_topic::Person::ConstPtr &msg)
{
   //打印接收到的信息
   ROS_INFO("Subscribing peron info: name %s  sex:%s  age:%d",msg->name.c_str(),msg->sex.c_str(),msg->age);
}


int main(int argc,char **argv)
{
    //创建节点
    ros::init(argc,argv,"person_subscriber");

    //创建节点句柄
    ros::NodeHandle n;
    /*
      创建订阅者：person_info_sub
      消息名称：/person_info
      回调函数：personCallback
    */
    ros::Subscriber person_info_sub = n.subscribe("/person_info",10,personCallback);

    //循环等待回调函数
    ros::spin();

    return 0;
}
 
配置编译规则
 
add_executable(person_publisher src/person_publisher.cpp)
target_link_libraries(person_publisher ${catkin_LIBRARIES})
add_dependencies(person_publisher ${PROJECT_NAME}_generate_messages_cpp)

add_executable(person_subscriber src/person_subscriber.cpp)
target_link_libraries(person_subscriber ${catkin_LIBRARIES})
add_dependencies(person_subscriber ${PROJECT_NAME}_generate_messages_cpp)
 
在工作空间目录下编译
 
catkin_make
 
终端输入
 
roscore
rosrun learning_topic person_subscriber
rosrun learning_topic person_publisher
 
运行效果：
 
 
终端输入：rqt_graph，查看当前环境的计算图。
 
 
到此，我们便是简单地介绍了ROS的发布/订阅者模型。接下来，我们将会学习ROS的另外一大通信模型:服务/客户端模型。
 
参考资料
 
古月居