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

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

talker.cpp

// src/talker.cpp

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

#include 

/**
 * 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("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


<package format="2">
  <name>beginner_tutorialsname>
  <version>0.0.0version>
  <description>The beginner_tutorials packagedescription>

  
  
  
  
  
  
  <license>TODOlicense>


  
  
  
  


  
  
  
  


  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  <buildtool_depend>catkinbuildtool_depend>
  <build_depend>roscppbuild_depend>
  <build_depend>rospybuild_depend>
  <build_depend>std_msgsbuild_depend>
  <build_export_depend>roscppbuild_export_depend>
  <build_export_depend>rospybuild_export_depend>
  <build_export_depend>std_msgsbuild_export_depend>
  
  
  <build_depend>message_generationbuild_depend>
  
  <exec_depend>roscppexec_depend>
  <exec_depend>rospyexec_depend>
  <exec_depend>std_msgsexec_depend>
  
  
  <exec_depend>message_runtimeexec_depend>    
  
  
  <export>
    
  export>
package>

参考资料:http://wiki.ros.org/cn/ROS/Tutorials/WritingPublisherSubscriber(c%2B%2B)

你可能感兴趣的:(ROS)