ROS消息, 服务, 主题, 订阅 2

#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");
  //一开始要初始化ros, 没啥可说的.

  /**
   * 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;
  //获取节点的handle 

  /**
   * 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);
  //advertise()函数, 用来告诉ROS, 你要发布一个topic, 名字叫chatter, ROS会注册对应的发布者跟订阅者, 一旦发现订阅者, 直接让他们建立点对点通信.一旦所有的发布者都不
  //在了, 主题会被自动不再广告.这个函数的第二个参数是message的缓存数量, 一旦消息被发布得太快, 来不及发送, 超过这个数量的消息就被扔掉了.

  ros::Rate loop_rate(10);
  //建一个间隔大意是1秒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;
    //new 一个标准的String对象.

    std::stringstream ss;
    ss << "hello world " << count;
    msg.data = ss.str();
    //这个有点像java的bufferredString

    ROS_INFO("%s", msg.data.c_str());
    //给ROS发个infor, 类似打印log.
    /**
     * 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);
    //发布者开始发布msg

    ros::spinOnce();
    //spin可能就是执行一次吧.

    loop_rate.sleep();
    //休眠一个间隔
    ++count;

  }

  return 0;
}

wget https://raw.github.com/ros/ros_tutorials/kinetic-devel/roscpp_tutorials/talker/talker.cpp