Week 2

• We've already compiled this when compiling last week
• Recap:

    cd catkin_ws # cd to where your catkin workspace is located
    catkin_make

• Now, try running the executable with rosrun

  • ROS package: igvc_training_exercises
  • Executable: week2_publisher.

• How do you run week2_publisher?

rosrun igvc_training_exercises week2_publisher

• Verify that Hello World correctly prints out:

  Hello World

• Although we have a Hello World executable, this isn't a node yet. To make this a proper ROS node, we need to initialize it.

• Start by adding an #include for the ROS headers at the top of the file.
• We'll be covering what this does in general software training later.

#include <ros/ros.h> // <-- Add this line

#include <iostream>
...

• Next, add ros::init(argc, argv, "week2") above the std::cout:

    int main(int argc, char** argv)
    {
      ros::init(argc, argv, "week2"); // <-- Add this line
  
      std::cout << "Hello World!" << std::endl;
    }

• Recompile with catkin_make and run the node again to verify that it still works
  • Make sure you have roscore running in a separate window, as ROS needs roscore to work.
• You should still see Hello World being printed out
• However, we can't actually tell that it's working, because the program is exiting immediately

• To make the program wait, add ros::spin()

int main(int argc, char** argv)
{
  ros::init(argc, argv, "week2");

  std::cout << "Hello World!" << std::endl;
  ros::spin(); // <-- Add this line
}

• For now, don't worry about what ros::spin() does. All you need to know is that it stops the program from exiting until you do Ctrl-C to stop it.

• Compile the program again, and run it
  • The program now doesn't exit
• Open up a new terminal window and type in rosnode list
• You should see the week2 node show up:

  /rosout
  /week2

1. Create a ros::NodeHandle

• ros::NodeHandle as a "handle" for the ROS node
• Main access point for a lot of the ROS functionality
  • Creating ROS publishers and subscribers.

• Create a ros::NodeHandle by adding the following line in the main function:

int main(int argc, char** argv)
{
  ros::init(argc, argv, "week2");
  ros::NodeHandle nh; // <-- Add this line

  std::cout << "Hello World!" << std::endl;
  ros::spin();
}

2. Create the ros::Publisher

Now we can create a ros::Publisher for the node.

• ros::NodeHandle has a function advertise that creates a ros::Publisher
• Need to specify the type of the message
  • Number -> std_msgs::Int32.
• Also need a topic name
  • my_number

std_msgs is a library provided by ROS for creating messages for standard types

Add an include for the std_msgs/Int32.h:

#include <ros/ros.h>
#include <std_msgs/Int32.h> // <-- Add this line

#include <iostream>
...

Then call the function on the nh node handle we just created, and store the result in a publisher:

int main(int argc, char** argv)
{
  ros::init(argc, argv, "week2");
  ros::NodeHandle nh;

  // Add the line below
  ros::Publisher integer_pub = nh.advertise<std_msgs::Int32>("my_number", 1);

  std::cout << "Hello World!" << std::endl;
  ros::spin();
}

nh.advertise<TYPE>(TOPIC_NAME, QUEUE_SIZE)

• Specify the type of the message, std_msgs::Int32, as a template argument to the advertise function
• We'll cover templates in a later week during general software training
• Queue size of 1 => only want to publish the newest message
  • Don't worry about the queue size

3. Create the message to be published

Now that we've got a publisher, let's publish a message.

• Create the message which we want to publish in a variable.

• Since the type of the message is std_msgs::Int32, we make a variable of the same type

int main(int argc, char** argv)
{
  ros::init(argc, argv, "week2");
  ros::NodeHandle nh;

  ros::Publisher integer_pub = nh.advertise<std_msgs::Int32>("my_number", 1);

  std_msgs::Int32 message; // <-- Add this line

  std::cout << "Hello World!" << std::endl;
  ros::spin();
}

• Need to assign the message some data
• To find out what fields are in a message, we can make use of Clion's handy autocomplete
• Type message. in the line below
  • clion's autocomplete should show fields
  • one field data of type int

• set the message.data to any number you like:

int main(int argc, char** argv)
{
  ros::init(argc, argv, "week2");
  ros::NodeHandle nh;

  ros::Publisher integer_pub = nh.advertise<std_msgs::Int32>("my_number", 1);

  std_msgs::Int32 message;
  message.data = 13; // <-- Add this line

  std::cout << "Hello World!" << std::endl;
  ros::spin();
}

4. Call the publish() function for the ros::Publisher

To actually publish the message, we call integer_pub.publish and pass the std_msgs::Int32 message we just created as an argument:

int main(int argc, char** argv)
{
  ros::init(argc, argv, "week2");
  ros::NodeHandle nh;

  ros::Publisher integer_pub = nh.advertise<std_msgs::Int32>("my_number", 1);

  std_msgs::Int32 message;
  message.data = 13;            // <-- Add these lines
  integer_pub.publish(message); // <--

  std::cout << "Hello World!" << std::endl;
  ros::spin();
}

• One problem: publisher needs to wait for the subscriber to connect first before publishing
  • Otherwise message will be published before the subscriber will see it
• Add ros::Duration(1).sleep() to sleep for one second

  ...
  ros::Publisher integer_pub = nh.advertise<std_msgs::Int32>("my_number", 1);

  ros::Duration(1).sleep() // <-- Add in a sleep here to give time to subscribers to connect.

  std_msgs::Int32 message;
  message.data = 13;
  integer_pub.publish(message);
  ...

Checking that the publisher works

• Compile with catkin_make, then run with rosrun
• How do you run the node? (The name of the executable is week2_publisher)

  • rosrun igvc_training_exercises week2_publisher

• A message should be published to the `my_number` topic

• How do you see the message that the node published?

• rostopic echo /my_number

Make sure you run the command before you launch the week2 node. You should see something like this.

data: 13

0. Blank main to ROS node

• Start off with code/igvc_training_exercises/src/week2/subscriber.cpp
• Node name of subscriber instead
• Refer back to the code/igvc_training_exercises/src/week2/publisher.cpp if you need to
• Don't forget #include <ros/ros.h>
• There are again four things that we need to do:

1. Create a ros::NodeHandle

Since we need to do ROS things, ie. create a Subscriber, we need a ros::NodeHandle also

• Create one like before again
• How do you create a ros::NodeHandle?

  • ros::NodeHandle nh;

2. Create a ros::Subscriber

• Now, we need to create a ros::Subscriber.
  • Similar to ros::Publisher, we can create a ros::Subscriber by calling the subscribe function on ros::NodeHandle:

    ros::Subscriber integer_sub = nh.subscribe("my_number", 1, integerCallback);

  • nh.subscribe(TOPIC_NAME, QUEUE_SIZE, CALLBACK_FUNCTION);

3. Create a callback function

• One thing different is that we need to write a callback function (the integerCallback function)
• We haven't written yet, so Clion gives us an error

What is a callback function?

• In general, a callback function is a function which is passed into some other function
  • Called when some event happens
• For ROS subscribers, the event is when a message is received
  • The callback function is called when the ROS subscriber received a new message

• For example, if the integerCallback function was something like below

void integerCallback(std_msgs::Int32 message)
{
  std::cout << "I received a message: " << message.data << std::endl;
}

• Understand it as the ROS library calling your callback function with the new message

integerCallback(new_message) // You can imagine that this is happening somewhere.

Creating the callback function and ROS_INFO_STREAM

• Let's create the callback function. Add this function above the main function:

    void integerCallback(std_msgs::Int32 message)
    {
      ROS_INFO_STREAM("I received a message: " << message.data);
    }

ROS_INFO_STREAM

• Convenient method that ROS provides us for logging things
• Usually better than `std::cout` beacuse also includes a timestamp

Testing the subscriber

• Try compiling with catkin_make and testing it out
• Run the subscriber node first with rosrun, then run the publisher node

And...... nothing gets printed. What's happening?

4. ros::spin()

The subscriber node doesn't have the ros::spin

What does ros::spin() do

• Stops the program from exiting until we hit Ctrl-C
• Hands control of the program to ROS, so that ROS can do all the behind-the-scenes work
  • Allow ROS to call the callback function when a new message is received

• Add the missing ros::spin function right after we call nh.subscribe
• Recompile and run
  • Should see the subscriber print out the message correctly

    [ INFO] [1565078804.617569525]: I received a message: 13

If you're not seeing the message print correctly, make sure that you run the subscriber node first, and then the publisher node afterwards, otherwise the publisher node might publish before the subscriber node has a chance to receive the message.

• Creating a ROS Node
  • ros::init(argc, argv, "NODE_NAME")

• Writing A ROS Publisher
  • Need a ros::NodeHandle
  • ros::Publisher publisher = nh.advertise<MESSAGE_TYPE>(TOPIC, QUEUE_SIZE)
  • Create the message
  • publisher.publish(message)

• Writing a ROS Subscriber
  • Need a ros::NodeHandle
  • ros::Subscriber subscriber = nh.subscribe(TOPIC, QUEUE_SIZE, CALLBACK_FUNCTION)
    • A Callback Function is called when a new message is received
  • Create the callback function
  • ros::spin() to let ROS handle the messages

Next Week

Next week we'll learn about launch files and PID, and get to (properly) play with the simulator.