在模型实现中ROS Master不需要实现，而连接建立也已经被封装了，需要关注的关键点有三个：

  1. 发布方
  2. 接收方
  3. 数据（此处为普通文本）

流程：

  1. 编写发布方实现
  2. 编写订阅方实现
  3. 编写配置文件
  4. 编译并执行

1、发布方

/*
    需求: 实现基本的话题通信，一方发布数据，一方接收数据，
         实现的关键点:
         1.发送方
         2.接收方
         3.数据(此处为普通文本)
 
         PS: 二者需要设置相同的话题
 
 
    消息发布方:
        循环发布信息:HelloWorld 后缀数字编号
    实现流程：
        1、包含头文件
        2、初始化ROS节点：命名唯一
        3、实例化ROS句柄
        4、实例化发布者对象
        5、组织被发布的数据，并编写逻辑发布数据
        
//1、包含头文件按
#include "ros.ros.h"
#include "std_msgs/String.h"
#include <sstream>
 
int main(int argc,char *argv[])
{
    //设置编码
    setlocale(LC_ALL,"");
    //初始化ROS节点
    ros::init(argc,argv,"ergouzi");
    //实例化ROS句柄
    ros::NodeHandle nh;
    //实例化发布者对象
    ros::Publisher pub = nh.advertise<std_msgs::String>("chatter",10);
    //组织被发布的数据，并编写逻辑发布数据
    std_msgs:String msg;
    std_msgs msg_front = "Hello 你好！"；
    int count =0;
    ros::Rate r(1);
while(ros::ok())
    {
        std::stringstream ss;
        ss<<mag_front<<count;
        msg.data=ss.str();
 
        pub.publish(msg);
        ROS_INFO("发送的消息是：%s",msg.data.c_str());
        r.sleep();
        count++;
        ros::spinOnce();
    }
 
}

2、订阅方

/*
    需求: 实现基本的话题通信，一方发布数据，一方接收数据，
         实现的关键点:
         1.发送方
         2.接收方
         3.数据(此处为普通文本)
 
 
    消息订阅方:
        订阅话题并打印接收到的消息
 
    实现流程:
        1.包含头文件 
        2.初始化 ROS 节点:命名(唯一)
        3.实例化 ROS 句柄
        4.实例化 订阅者 对象
        5.处理订阅的消息(回调函数)
        6.设置循环调用回调函数
 
*/
// 1.包含头文件 
#include "ros/ros.h"
#include "std_msgs/String.h"
 
void doMsg(const std_msgs::String::ConstPtr& msg_p){
    ROS_INFO("我听见:%s",msg_p->data.c_str());
    // ROS_INFO("我听见:%s",(*msg_p).data.c_str());
}
int main(int argc, char  *argv[])
{
    setlocale(LC_ALL,"");
    //2.初始化 ROS 节点:命名(唯一)
    ros::init(argc,argv,"listener");
    //3.实例化 ROS 句柄
    ros::NodeHandle nh;
 
    //4.实例化 订阅者 对象
    ros::Subscriber sub = nh.subscribe<std_msgs::String>("chatter",10,doMsg);
    //5.处理订阅的消息(回调函数)
 
    //     6.设置循环调用回调函数
    ros::spin();//循环读取接收的数据，并调用回调函数处理
 
    return 0;
}

 3、配置文件CMakeLists.txt

add_executable(Hello_pub
  src/Hello_pub.cpp
)
add_executable(Hello_sub
  src/Hello_sub.cpp
)

target_link_libraries(Hello_pub
  ${catkin_LIBRARIES}
)
target_link_libraries(Hello_sub
  ${catkin_LIBRARIES}
）

4、执行

1、启动roscore

2、启动发布节点

3、启动订阅节点

下面介绍下Python的实现过程

流程：

1、编写发布方实现

2、编写订阅方实现

3、为python文件添加可执行权限

4、编辑配置文件

5、编译并执行

1、发布方

#！ /usr/bin/env python

#PS:二者之间的话题要一致

“”“

实现流程：

1、导包

2、初始化ROS节点：命名唯一

3、实例化发布者对象

4、组织被发布的数据，并编写逻辑发布数据

”“”

import rospy

from std_msgs.msg import String

if __name__ == "__main__":

rospy.init_node("talker_p")

pub = rospy.Publisher("chatter",String,queue_size=10)

msg = String()

msg_front="hello 你好"

count = 0  #计数器 
    # 设置循环频率
    rate = rospy.Rate(1)
    while not rospy.is_shutdown():
 
        #拼接字符串
        msg.data = msg_front + str(count)
 
        pub.publish(msg)
        rate.sleep()
        rospy.loginfo("写出的数据:%s",msg.data)
        count += 1

2、订阅方

#! /usr/bin/env python
"""
    需求: 实现基本的话题通信，一方发布数据，一方接收数据，
         实现的关键点:
         1.发送方
         2.接收方
         3.数据(此处为普通文本)


    消息订阅方:
        订阅话题并打印接收到的消息

    实现流程:
        1.导包 
        2.初始化 ROS 节点:命名(唯一)
        3.实例化 订阅者 对象
        4.处理订阅的消息(回调函数)
        5.设置循环调用回调函数

"""
#1.导包 
import rospy
from std_msgs.msg import String

def doMsg(msg):
    rospy.loginfo("I heard:%s",msg.data)

if __name__ == "__main__":
    #2.初始化 ROS 节点:命名(唯一)
    rospy.init_node("listener_p")
    #3.实例化 订阅者 对象
    sub = rospy.Subscriber("chatter",String,doMsg,queue_size=10)
    #4.处理订阅的消息(回调函数)
    #5.设置循环调用回调函数
    rospy.spin()

3、添加可执行权限

终端下进入scripts执行：chmod +x *.py

4、配置CMakeList.txt

catkin_install_python(PROGRAMS
  scripts/talker_p.py
  scripts/listener_p.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)
5、执行

1.启动 roscore;

2.启动发布节点;

3.启动订阅节点。

PS：可以使用 rqt_graph 查看节点关系。