ROS学习记录：话题发布和订阅的实现（C++/python）

发布方（C++）：

#include "ros/ros.h"
#include "std_msgs/String.h"
#include <sstream>

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

         PS: 二者需要设置相同的话题


    消息发布方:
        循环发布信息:Hello... 后缀数字编号

    实现流程:
        1.包含头文件 
        2.初始化 ROS 节点:命名(唯一)
        3.实例化 ROS 句柄
        4.实例化 发布者 对象
        5.组织被发布的数据，并编写逻辑发布数据
    
*/

int main(int argc, char *argv[])
{
    // 解决乱码问题
    setlocale(LC_ALL,"");
    // 2.初始化ROS节点,这里是节点名
    ros::init(argc,argv,"besproma_pub_node");

    // 3.实例化 ROS 句柄
    ros::NodeHandle nh;
    
    // 4.实例化发布者对象，参数是话题名，buffer大小
    ros::Publisher pub = nh.advertise<std_msgs::String>("besproma_topic",10);
    
    // 以10HZ的平率发布数据
    ros::Rate rate(10);

    //设置编号，让数据发布时带上编号
    int count = 0;

    // 加入休眠 ros::Duration(3.0).sleep(); 延迟第一条数据的发送,防止前几条数据的丢失
    ros::Duration(3.0).sleep();

    // 5.组织被发布的数据，并编写逻辑发布数据,程序会一直在这里循环
    std_msgs::String msg;
    while(ros::ok()){
        // 发布的内容和编号拼接
        count++;
        std::stringstream ss;
        ss<<"hello ..."<<count;
        msg.data = ss.str();
        // msg.data = "hello";s

        pub.publish(msg);

        ROS_INFO("发布的数据是： %s",ss.str().c_str());

        rate.sleep();
    }

    return 0;
}

接收方（C++）：

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

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


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

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

*/

// 回调函数
void doMsg(const std_msgs::String::ConstPtr& msg_p){
    // 通过msg_p来获取并操作订阅到的数据
    ROS_INFO("我收到了 %s",msg_p->data.c_str());
}

int main(int argc, char *argv[])
{
    // 解决乱码问题
    setlocale(LC_ALL,"");
    // 2.初始化 ROS 节点:命名(唯一)
    ros::init(argc,argv,"besproma_sub_node");
    // 3.实例化 ROS 句柄
    ros::NodeHandle nh;
    // 4.实例化订阅者对象,参数1是话题名(要保证和发布方的话题一致)，参数2是buffer空间大小，参数3是回调函数
    ros::Subscriber sub=nh.subscribe<std_msgs::String>("besproma_topic",10,doMsg);
    // 5.处理订阅的消息(回调函数)

    // 6.设置循环调用回调函数
    ros::spin();

    return 0;
}

CMakeLists.txt

add_executable(besproma_pub src/demo1_pub.cpp)
add_executable(besproma_sub src/demo2_sub.cpp)

target_link_libraries(besproma_pub
  ${catkin_LIBRARIES}
)
target_link_libraries(besproma_sub
  ${catkin_LIBRARIES}
)

发布方（Python）

#! /usr/bin/env python

from rosgraph.names import SRV_EXT
import rospy
from std_msgs.msg import String

'''

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

         PS: 二者需要设置相同的话题


    消息发布方:
        循环发布信息:HelloWorld 后缀数字编号

    实现流程:
        1.导包 
        2.初始化 ROS 节点:命名(唯一)
        3.实例化 发布者 对象
        4.组织被发布的数据，并编写逻辑发布数据

'''

if __name__=="__main__":
    # 2.初始化 ROS 节点:命名(唯一)
    rospy.init_node("besproma_pub_node_py")
    # 3.实例化 发布者 对象
    pub = rospy.Publisher("besproma_topic",String,queue_size=10)
    # 4.组织被发布的数据，并编写逻辑发布数据
    msg = String() # 创建msg对象
    msg_front = "hello 你好"
    count = 0
    rospy.sleep(3)
    rate = rospy.Rate(1)
    while not rospy.is_shutdown():
        # 拼接字符串
        count+=1
        msg.data = msg_front + str(count)
        pub.publish(msg)
        rospy.loginfo("发布的数据 %s",msg.data)
        rate.sleep()
        
        

订阅方（Python）

#! /usr/bin/env python

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


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

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


"""

import rospy
from std_msgs.msg import String

def doMsg(msg):
    rospy.loginfo("收到了 %s",msg.data)


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

当四个文件全部开启时的计算图：

自定义话题msg

Person.msg

string name
int32 age
float32 height

package.xml中添加编译依赖与执行依赖

  <build_depend>message_generation</build_depend>
  <exec_depend>message_runtime</exec_depend>
  <!-- 
  exce_depend 以前对应的是 run_depend 现在非法
  -->

CMakeLists.txt编辑 msg 相关配置

find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  message_generation
)
# 需要加入 message_generation,必须有 std_msgs

# 配置 msg 源文件
add_message_files(
  FILES
  Person.msg
)

# 生成消息时依赖于 std_msgs
generate_messages(
  DEPENDENCIES
  std_msgs
)

#执行时依赖
catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES demo02_talker_listener
  CATKIN_DEPENDS roscpp rospy std_msgs message_runtime
#  DEPENDS system_lib
)

VScode配置

c_cpp_properties.json

{
  "configurations": [
    {
      "browse": {
        "databaseFilename": "",
        "limitSymbolsToIncludedHeaders": true
      },
      "includePath": [
        "/opt/ros/noetic/include/**",
        "/home/besproma//ROS_learning/learning_ws/src/learning_topic/include/**",
        "/home/besproma/ROS_learning/learning_ws/devel/include/**",
        "/usr/include/**"
      ],
      "name": "ROS",
      "cppStandard": "c++17"
    }
  ],
  "version": 4
}

settings.json

{
    "python.autoComplete.extraPaths": [
        "/opt/ros/noetic/lib/python3/dist-packages"
    ],
    "python.analysis.extraPaths": [
        "/opt/ros/noetic/lib/python3/dist-packages",
        "/home/besproma/ROS_learning/learning_ws/devel/lib/python3/dist-packages"
    ],
    "files.associations": {
        "sstream": "cpp"
    }
}

发布方C++代码

/*
    需求: 循环发布人的信息

*/

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

int main(int argc, char *argv[])
{
    // 解决乱码问题
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"besproma_pub_msg");
    ros::NodeHandle nh;
    ros::Publisher pub = nh.advertise<learning_topic::Person>("besproma_topic_msg",10);
    learning_topic::Person per;
    per.name = "besproma";
    per.age = 21;
    per.height = 100.88;
    ros::Rate rate(10);
    ros::Duration(3.0).sleep();

    while(ros::ok()){
        pub.publish(per);
        ROS_INFO("发送的内容是 %s %d %.2f",per.name.c_str(),per.age,per.height);
        rate.sleep();
        ros::spinOnce();
    }    

    return 0;
}

订阅方C++代码

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

void doMsg(const learning_topic::Person::ConstPtr &msg_p){
    ROS_INFO("名字: %s , 年龄： %d , 身高 %.2f ...", msg_p->name.c_str(), msg_p->age, msg_p->height);
}


int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"besproma_sub_msg");
    ros::NodeHandle nh;
    ros::Subscriber sub = nh.subscribe<learning_topic::Person>("besproma_topic_msg",10,doMsg);
    ros::spin();

    return 0;
}

CMakeLists.txt

add_executable(besproma_pub_msg src/demo3_pub_msg.cpp)
add_executable(besproma_sub_msg src/demo4_sub_msg.cpp)

target_link_libraries(besproma_pub_msg
  ${catkin_LIBRARIES}
)
target_link_libraries(besproma_sub_msg
  ${catkin_LIBRARIES}
)

发布方Python：

#! /usr/bin/env python
import rospy
from learning_topic.msg import Person

if __name__ =="__main__":
    rospy.init_node("besproma_pub_msg.py")
    pub = rospy.Publisher("besproma_topic_msg",Person,queue_size=10)
    p = Person()
    p.name = "besproma_py"
    p.age = 1
    p.height = 100.88
    rospy.sleep(3)
    rate = rospy.Rate(1)
    while not rospy.is_shutdown():
        pub.publish(p)
        p.age=p.age+1
        rospy.loginfo("姓名 %s, 年龄 %d, 身高：%.2f",p.name,p.age,p.height)
        rate.sleep()

订阅方Python：

#! /usr/bin/env python
import rospy
from learning_topic.msg import Person

def doPerson(p):
    rospy.loginfo("姓名： %s，年龄： %d，身高%.2f",p.name,p.age,p.height)

if __name__=="__main__":
    rospy.init_node("besproma_sub_msg_node")
    rospy.Subscriber("besproma_topic_msg",Person,doPerson,queue_size=10)
    rospy.spin()

4个节点都打开的计算图：