ROS：编写一个简单的发布者和订阅者

最新推荐文章于 2024-09-07 21:25:41 发布

凌云飞鸿

最新推荐文章于 2024-09-07 21:25:41 发布

阅读量3k

点赞数 3

分类专栏： ROS 文章标签： ROS topic

本文链接：https://blog.csdn.net/fskeps/article/details/89602981

版权

ROS 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

ROS学习笔记之——编写一个简单的发布者和订阅者

talker.cpp

// src/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;
}

代码说明：

ros/ros.h 头文件中包含了ros系统中绝大部分公用部分的所有必需的headers
std_msgs/String 消息在std_msgs包中，该头文件由std_msgs功能包中的String.msg文件自动生成
在使用ROS系统的其他部分之前，必须先调用ros::init()函数，用于初始化ROS,而且允许ROS通过命令行进行名称重映射。第3个参数为节点的名字，必须是一个base name，即不能含有/
ros::NodeHandle n;
为此进程的节点创建句柄。第一个创建的NodeHandle用于初始化节点，最后一个NodeHandle被毁时会清除节点所占用的任何资源
ros::Publisher chatter_pub = n.advertise < std_msgs::String > (“chatter”, 1000);
告诉master，该节点要在chatter话题上发布std_msgs/String类型的消息。第2个参数用来设定分布队列的大小，如果消息分布得太快，最多存储1000个消息，之后会扔掉最先存储的消息来容纳最新发布的消息。NodeHandle::advertise()返回一个ros::Publisher对象，有两个作用：1.包含一个publish()方法用于发布消息；2.当离开作用域时会自动停止广播（unadvertise）
ros::Rate loop_rate(10);
使用ros::Rate对象可以指定要循环的频率。它将跟踪自上次调用Rate::sleep（）以来的持续时间，并在正确的时间内休眠。
默认情况下，roscpp将安装一个SIGINT处理程序，该处理程序提供Ctrl-C处理，如果发生这种情况，将导致ros::ok（）返回false。

当以下情况之一发生时，ros::ok（）将返回false，

1.接受到一个SIGINT（Ctrl+C)

2.该节点已被另一个具有相同名称的节点踢出ROS网络

3.程序的任何其他部分已将调用了ros::shutdown()

4.所有的ros::NodeHandles已经被销毁
一旦ros::ok()返回false，所有的ROS调用都会失败
std_msgs::String msg;
std::stringstream ss;
ss << "hello world " << count;
msg.data = ss.str();
我们使用消息适配类在ROS上广播消息，它通常从msg文件生成。
chatter_pub.publish(msg);
向任何已经连接的节点广播消息
ROS_INFO和类似的函数用于替代 printf/cout
ros::spinOnce();
在此例中调用ros::spinOnce()并不是必须的，因为没有接受任何回调函数。但是，如果您要在此应用程序中添加了订阅，并且此处没有ros::spinOnce()，那么回调函数将永远不会得到调用。
loop_rate.sleep();
现在我们使用ros::Rate对象在剩余时间内休眠，让我们达到10Hz的发布速度。

总结：
1.初始化ROS系统
2.广播该节点将在chatter话题上向master发布std_msgs/String 类型的消息
3.循环发布消息，每10Hz一次向chatter发布消息

listener.cpp

// 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;
}

代码说明：

void chatterCallback(const std_msgs::String::ConstPtr& msg)
{
ROS_INFO(“I heard: [%s]”, msg->data.c_str());
}
这是一个回调函数，当一个新消息到达chatter话题时将被调用。消息在boost shared_ptr中传递，这意味
着您可以根据需要将其存储起来，而不必担心它会被删除，并且不会复制基础数据。
ros::Subscriber sub = n.subscribe(“chatter”, 1000, chatterCallback);
向matser订阅chatter话题。每当有新消息到达时，ROS都会调用chatterCallback（）函数。第二个参数是队列大小，以防我们无法足够快地处理消息。在这种情况下，如果队列达到1000条消息，我们将在新消息到达时开始丢弃旧消息。NodeHandle::subscribe()返回一个ros::Subscriber对象，您必须保留该对象，直到您想取消订阅为止。订阅者对象被销毁后，它将自动取消订阅chatter话题。
ros::spin();
ros::spin()进入一个循环，尽可能快地调用消息回调函数。不过不用担心，如果没有什么可以做的话就不会占用太多的CPU。一旦ros::ok()返回false，ros::spin()将会退出，这意味着已经调用了ros::shutdown()，可以是默认的Ctrl-C处理程序，或master告诉我们关闭，或者手动调用它。

总结：
1.初始化ROS
2.订阅chatter话题
3.循环，等待消息到达
4.当消息到达时，调用回调函数chatterCallback()

CMakeLists.txt

cmake_minimum_required(VERSION 2.8.3)
project(beginner_tutorials)

## Find catkin and any catkin packages
find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs genmsg)

## Declare ROS messages and services
add_message_files(FILES Num.msg)
add_service_files(FILES AddTwoInts.srv)

## Generate added messages and services
generate_messages(DEPENDENCIES std_msgs)

## Declare a catkin package
catkin_package()

## Build talker and listener
include_directories(include ${catkin_INCLUDE_DIRS})

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)

注意：最后add_dependencies选项也可以写为下面这种形式

add_dependencies(talker ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
add_dependencies(listener ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})

推荐采用后面一种写法，新的ROS版本普遍采用这种形式。

package.xml

<?xml version="1.0"?>
<package format="2">
  <name>beginner_tutorials</name>
  <version>0.0.0</version>
  <description>The beginner_tutorials package</description>

  <!-- One maintainer tag required, multiple allowed, one person per tag -->
  <!-- Example:  -->
  <!-- <maintainer email="jane.doe@example.com">Jane Doe</maintainer> -->
  <!-- One license tag required, multiple allowed, one license per tag -->
  <!-- Commonly used license strings: -->
  <!--   BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1, LGPLv3 -->
  <license>TODO</license>


  <!-- Url tags are optional, but multiple are allowed, one per tag -->
  <!-- Optional attribute type can be: website, bugtracker, or repository -->
  <!-- Example: -->
  <!-- <url type="website">http://wiki.ros.org/beginner_tutorials</url> -->


  <!-- Author tags are optional, multiple are allowed, one per tag -->
  <!-- Authors do not have to be maintainers, but could be -->
  <!-- Example: -->
  <!-- <author email="jane.doe@example.com">Jane Doe</author> -->


  <!-- The *depend tags are used to specify dependencies -->
  <!-- Dependencies can be catkin packages or system dependencies -->
  <!-- Examples: -->
  <!-- Use depend as a shortcut for packages that are both build and exec dependencies -->
  <!--   <depend>roscpp</depend> -->
  <!--   Note that this is equivalent to the following: -->
  <!--   <build_depend>roscpp</build_depend> -->
  <!--   <exec_depend>roscpp</exec_depend> -->
  <!-- Use build_depend for packages you need at compile time: -->
  <!--   <build_depend>message_generation</build_depend> -->
  <!-- Use build_export_depend for packages you need in order to build against this package: -->
  <!--   <build_export_depend>message_generation</build_export_depend> -->
  <!-- Use buildtool_depend for build tool packages: -->
  <!--   <buildtool_depend>catkin</buildtool_depend> -->
  <!-- Use exec_depend for packages you need at runtime: -->
  <!--   <exec_depend>message_runtime</exec_depend> -->
  <!-- Use test_depend for packages you need only for testing: -->
  <!--   <test_depend>gtest</test_depend> -->
  <!-- Use doc_depend for packages you need only for building documentation: -->
  <!--   <doc_depend>doxygen</doc_depend> -->
  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>roscpp</build_depend>
  <build_depend>rospy</build_depend>
  <build_depend>std_msgs</build_depend>
  <build_export_depend>roscpp</build_export_depend>
  <build_export_depend>rospy</build_export_depend>
  <build_export_depend>std_msgs</build_export_depend>
  
  <!-- 用于将msg文件转换为C++源码，needed at build time -->
  <build_depend>message_generation</build_depend>
  
  <exec_depend>roscpp</exec_depend>
  <exec_depend>rospy</exec_depend>
  <exec_depend>std_msgs</exec_depend>
  
  <!-- 用于将msg文件转换为C++源码，needed at run time -->
  <exec_depend>message_runtime</exec_depend>    
  
  <!-- The export tag contains other, unspecified, tags -->
  <export>
    <!-- Other tools can request additional information be placed here -->
  </export>
</package>