Writing the Publisher Node C++.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Code Explained\n",
    "Let's break the code down."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include \"ros/ros.h\"\n",
    "#pragma cling load(\"roscpp\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ros/ros.h` is a convenience include that includes all the headers necessary to use the most common public pieces of the ROS system. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <sstream>\n",
    "#include \"std_msgs/String.h\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This includes the [std_msgs/String message](http://docs.ros.org/api/std_msgs/html/msg/String.html), which resides in the [std_msgs](http://wiki.ros.org/std_msgs) package. This is a header generated automatically from the `String.msg` file in that package. For more information on message definitions, see the [msg](http://wiki.ros.org/msg) page. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int argc = 1;\n",
    "char arg0[] = \"talker\";\n",
    "char* argv[] = {arg0, NULL};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ros::init(argc, argv, \"talker\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize ROS. This allows ROS to do name remapping through the command line -- not important for now. This is also where we specify the name of our node. Node names must be unique in a running system.\n",
    "\n",
    "The name used here must be a [base name](http://wiki.ros.org/Names#Graph), ie. it cannot have a `/` in it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ros::NodeHandle n;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a handle to this process' node. The first `NodeHandle` created will actually do the initialization of the node, and the last one destructed will cleanup any resources the node was using. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ros::Publisher chatter_pub = n.advertise<std_msgs::String>(\"chatter\", 10);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tell the master that we are going to be publishing a message of type [std_msgs/String](http://docs.ros.org/api/std_msgs/html/msg/String.html) on the `topic` chatter. This lets the master tell any nodes listening on chatter that we are going to publish data on that topic. The second argument is the size of our publishing queue. In this case if we are publishing too quickly it will buffer up a maximum of 1000 messages before beginning to throw away old ones.\n",
    "\n",
    "`NodeHandle::advertise()` returns a `ros::Publisher object`, which serves two purposes: 1) it contains a `publish()` method that lets you publish messages onto the topic it was created with, and 2) when it goes out of scope, it will automatically unadvertise. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ros::Rate loop_rate(10);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `ros::Rate` object allows you to specify a frequency that you would like to loop at. It will keep track of how long it has been since the last call to `Rate::sleep()`, and sleep for the correct amount of time.\n",
    "\n",
    "In this case we tell it we want to run at 10Hz. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int count = 0;\n",
    "while (ros::ok())\n",
    "{\n",
    "    std_msgs::String msg;\n",
    "\n",
    "    std::stringstream ss;\n",
    "    ss << \"hello world \" << count;\n",
    "    msg.data = ss.str();\n",
    "\n",
    "    chatter_pub.publish(msg);\n",
    "\n",
    "    ros::spinOnce();\n",
    "\n",
    "    loop_rate.sleep();\n",
    "    ++count;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default `roscpp` will install a SIGINT handler which provides Ctrl-C handling which will cause `ros::ok()` to return false if that happens.\n",
    "\n",
    "`ros::ok()` will return false if:\n",
    "* a SIGINT is received (Ctrl-C)\n",
    "* we have been kicked off the network by another node with the same name\n",
    "* `ros::shutdown()` has been called by another part of the application.\n",
    "* all `ros::NodeHandles` have been destroyed \n",
    "\n",
    "Once `ros::ok()` returns false, all ROS calls will fail. \n",
    "\n",
    "We broadcast a message on ROS using a message-adapted class, generally generated from a [msg file](http://wiki.ros.org/msg). More complicated datatypes are possible, but for now we're going to use the standard `String` message, which has one member: \"data\".\n",
    "\n",
    "Now we actually broadcast the message to anyone who is connected. \n",
    "\n",
    "`ROS_INFO` and friends are our replacement for `printf/cout`. See the [rosconsole documentation](http://wiki.ros.org/rosconsole) for more information.\n",
    "\n",
    "Calling `ros::spinOnce()` here is not necessary for this simple program, because we are not receiving any callbacks. However, if you were to add a subscription into this application, and did not have `ros::spinOnce()` here, your callbacks would never get called. So, add it for good measure. \n",
    "\n",
    "Now we use the `ros::Rate` object to sleep for the time remaining to let us hit our 10Hz publish rate.\n",
    "\n",
    "Here's the condensed version of what's going on:\n",
    "* Initialize the ROS system\n",
    "* Advertise that we are going to be publishing [std_msgs/String](http://docs.ros.org/api/std_msgs/html/msg/String.html) messages on the `chatter` topic to the master\n",
    "* Loop while publishing messages to chatter 10 times a second "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "xeus C++11",
   "language": "",
   "name": "xeus-cling-cpp11"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}