1. What is ROS? Robot Operating System
ROS essentially provides two things:
A set of tools that are generally useful for controlling robots
E.g. Interfaces to sensors, general-purpose algorithms, etc.
A communication framework to allow different pieces of your robot brain to talk to one another

2. Intro to ROS Nodes cam_data subscriber cam_data publisher

3. ROS $ roscore Master rosout
... logging to ~/.ros/log/9cf88ce4-b14d-11df-8a e8cf/roslaunch-machine_name log
Checking log directory for disk usage. This may take awhile.
Press Ctrl-C to interrupt
Done checking log file disk usage. Usage is <1GB.
… blah blah blah
Master
Launches the ROS Master, which keeps track of all of nodes that your run and all of the topics that each node publishes and subscribes to
Also initializes some other ROS components that are generally useful
rosout

4. Note: run this in a new terminal window
ROS
$ rosrun package1 first-node
Note: run this in a new terminal window
Master
Advertise topic1
rosout
first-node

5. Note: run this in a new terminal window
ROS
$ rosrun package2 second-node
Note: run this in a new terminal window
Master
Subscribe to topic1
rosout
first-node
second-node

6. Note: run this in a new terminal window
ROS
$ rosrun package2 second-node
Note: run this in a new terminal window
Master
Master connects topic1 publisher to topic1 subscriber
rosout
first-node
second-node

7. ROS $ rosnode list /rosout /first-node /second-node Master rosout
topic1
rosout
first-node
second-node

8. ROS $ rostopic list /rosout /rosout_agg /topic1 Master rosout
first-node
second-node

9. ROS commands
roscore : Run this first; starts the Master and some other essential ROS stuff
rosrun [package-name] [node-name] : Use this to start a ROS node
rosnode :
rosnode list : List all currently running nodes
rosnode info [node-name] : Get more info about a particular node
rosnode -h : Learn about more things rosnode can do
rostopic :
rostopic list : List all topics currently published
rostopic echo : See the messages being published to a particular topic
rostopic -h : Learn about more things rostopic can do

10. ROS commands
roslaunch [package-name] [launch-file-name] : Reads a .launch file, which contains instructions for running multiple nodes, and doing fancy things like passing parameters to nodes, renaming topics, etc.
<launch>
<node name="listener-1" pkg="rospy_tutorials" type="listener" />
<node name="listener-2" pkg="rospy_tutorials" type="listener" args="-foo arg2" />
<node name="listener-3" pkg="rospy_tutorials" type="listener" respawn="true" />
<group ns="wg2">
<remap from="chatter" to="hello"/>
<node pkg="rospy_tutorials" type="listener" name="listener" args="--test" />
<node pkg="rospy_tutorials" type="talker" name="talker">
<param name="talker_1_param" value="a value" />
<remap from="chatter" to="hello-1"/>
<env name="ENV_EXAMPLE" value="some value" />
</node>
</group>
</launch>

11. /* Body of event loop goes here */
ROS Skeleton
#include "ros/ros.h" int main (int argc, char **argv) { ros::init(argc, argv, “name"); ros::NodeHandle n; ros::Rate loop_rate(10); while (ros::ok()) ros::spinOnce(); loop_rate.sleep(); } return 0;
/* Body of event loop goes here */

12. Line-by-Line Breakdown
#include "ros/ros.h"
int main (int argc, char **argv) {
ros::init(argc, argv, “name");
ros::NodeHandle n;
ros::Rate loop_rate(10);
while (ros::ok())
ros::spinOnce();
loop_rate.sleep(); }
return 0;
Include the ROS library
/* Body of event loop goes here */

13. Line-by-Line Breakdown
#include "ros/ros.h"
int main (int argc, char **argv) {
ros::init(argc, argv, “name");
ros::NodeHandle n;
ros::Rate loop_rate(10);
while (ros::ok())
ros::spinOnce();
loop_rate.sleep(); }
return 0;
Program execution always starts at “main”
main gets passed command line arguments (argc, argv), which you are required to pass into ros::init so it can handle them appropriately
/* Body of event loop goes here */

14. Line-by-Line Breakdown
#include "ros/ros.h" int main (int argc, char **argv) { ros::init(argc, argv, “name"); ros::NodeHandle n; ros::Rate loop_rate(10); while (ros::ok()) ros::spinOnce(); loop_rate.sleep(); } return 0;
ros:: is a namespace; a collection of related functions, data, etc. that are all packaged together
Anything in this namespace has to be accessed by prefixing it with ros::
ros::init (initialize) must be called before any other ROS functions; it expects to be passed main’s command line arguments (argc, argv) and the name of the current node
/* Body of event loop goes here */

15. Line-by-Line Breakdown
#include "ros/ros.h" int main (int argc, char **argv) { ros::init(argc, argv, “name"); ros::NodeHandle n; ros::Rate loop_rate(10); while (ros::ok()) ros::spinOnce(); loop_rate.sleep(); } return 0;
ros::NodeHandle is a class which allows us to communicate with the ROS system
You must create a NodeHandle object in order to properly initialize and register your ROS node; when the handle goes out of scope at the end of the program, it will automatically cleanup after itself
In the body of your ROS node, a NodeHandle can also be used to advertise or subscribe to topics
/* Body of event loop goes here */

16. Line-by-Line Breakdown
#include "ros/ros.h" int main (int argc, char **argv) { ros::init(argc, argv, “name"); ros::NodeHandle n; ros::Rate loop_rate(10); while (ros::ok()) ros::spinOnce(); loop_rate.sleep(); } return 0;
The main body of a ROS program is a loop
The loop keeps running as long as this ROS node hasn’t been asked to shutdown (i.e. as long as ros::ok() returns true)
At a high level, a typical loop might look like this:
Do some work
Publish results
Handle any incoming messages
Sleep for a little while, then repeat
/* Body of event loop goes here */

17. Line-by-Line Breakdown
#include "ros/ros.h" int main (int argc, char **argv) { ros::init(argc, argv, “name"); ros::NodeHandle n; ros::Rate loop_rate(10); while (ros::ok()) ros::spinOnce(); loop_rate.sleep(); } return 0;
ros::spinOnce() checks to see if there are any new incoming messages from other ROS nodes, and if so, it invokes callbacks to handle them appropriately
We haven’t subscribed to any topics in this example, but we’ll see shortly how this works
/* Body of event loop goes here */

18. Line-by-Line Breakdown
#include "ros/ros.h" int main (int argc, char **argv) { ros::init(argc, argv, “name"); ros::NodeHandle n; ros::Rate loop_rate(10); while (ros::ok()) ros::spinOnce(); loop_rate.sleep(); } return 0;
ros::Rate is essentially a timer class that helps to keep your main loop running at a reasonable frequency
We first declare loop_rate(10), which is a 10Hz timer
At the end of our main loop, we call loop_rate.sleep(); if our loop took less than 0.1s (1/10th of a second), loop_rate.sleep() will wait until the full 0.1s has passed
This way, our main loop always runs at a (roughly) consistent frequency
/* Body of event loop goes here */

19. Now, let’s subscribe to a topic

20. ROS Subscriber
#include "ros/ros.h"
int main (int argc, char **argv) {
ros::init(argc, argv, “name");
ros::NodeHandle n;
ros::Subscriber sub =
n.subscribe(“topic1", 1000,
callbackFunction);
ros::Rate loop_rate(10);
while (ros::ok())
ros::spinOnce();
loop_rate.sleep(); }
return 0;
Recall, `n` is our NodeHandle
Subscribe to a topic using n.subscribe(...)
“topic1” is the name of the topic to subscribe to
1000 is the number of incoming messages to hold on to before deleting some (so, if we cannot process messages fast enough, and get more than 1000 messages behind, we will start dropping old messages)
callbackFunction is the name of the function to invoke when a new message is received
n.subscribe(…) returns a ros::Subscriber object; as long as we hold on to this object, we will remain subscribed to “topic1”

21. ROS Subscriber
// somewhere else in the program … void callbackFunction(const std_msgs::String::ConstPtr& msg) { printf("I heard: [%s]", msg->data.c_str()); }
This function will be invoked whenever a new “topic1” message is processed by ros::spinOnce()
Note the signature of the function: it returns void, and it accepts a single parameter “msg”, which is a pointer to the message received
The type of “msg” will naturally vary, depending on the type of messages that you are subscribed to. In our case, messages published to “topic1” are string messages, and have type std_msgs::String
Note this is not the same thing as a C++ string object; it is a ROS message which contains a C++ string

22. Common std_msgs Message Type Include Callback signature Usage
std_msgs::String
#include “std_msgs/String.h”
void callback( const::std_msgs::String::ConstPtr & msg)
string data = msg->data
std_msgs::Bool
#include “std_msgs/Bool.h”
void callback(
const::std_msgs::Bool::ConstPtr & msg)
bool data = msg->data
std_msgs::Int32
#include “std_msgs/Int32.h”
const::std_msgs::Int32::ConstPtr & msg)
int data = msg->data
std_msgs::
Float64
#include “std_msgs/
Float64.h”
const::std_msgs::Float64::ConstPtr & msg)
double data = msg->data

23. Let’s publish to a topic

24. ROS Publisher Advertise a topic using n.advertise(...)
#include "ros/ros.h“
int main (int argc, char **argv) {
/* … blah blah blah … */
ros::Publisher pub =
n.advertise<std_msgs::String>
(“topic1”, 1000);
ros::Rate loop_rate(10);
while (ros::ok())
std_msgs::String msg;
msg.data = “Foobar”;
pub.publish(msg);
ros::spinOnce();
loop_rate.sleep(); }
return 0;
Advertise a topic using n.advertise(...)
Unlike with subscribers, where the type of the message can be inferred from the callback function, we need to explicitly tell ROS what type of message to expect using <> triangle brackets
“topic1” is the name of the topic to advertise
1000 is the number of outgoing messages to hold on to before deleting some (so, if we cannot send messages fast enough, and get more than 1000 messages behind, we will start dropping old messages)
n.advertise(…) returns a ros::Publisher object; we send a message by calling its .publish(…) method and passing in a ROS message of the appropriate type

25. Okay, we’ve got a complete (trivial) program – let’s build it!

26. ROS Package
workspace

27. workspace
ROS Package
art

28. art
ROS Package
localplanner
artsystem
imu
ucontroller

29. localplanner
ROS Package
src
include
bin
CMakeLists.txt
manifest.xml

30. ROS Package Source files go in here localplanner src include bin
CMakeLists.txt
manifest.xml

31. ROS Package Header files go in here localplanner src include bin
CMakeLists.txt
manifest.xml

32. ROS Package Executables will be built here localplanner src include
bin
CMakeLists.txt
manifest.xml

33. ROS Package Build instructions go here localplanner src include bin
CMakeLists.txt
manifest.xml

34. ROS Package CMakeLists.txt cmake_minimum_required(VERSION 2.4.6)
include($ENV{ROS_ROOT}/core/rosbuild/rosbuild.cmake)
# This is a comment
rosbuild_init()
rosbuild_gen_msg()
rosbuild_add_executable(localplanner src/main.cpp)

35. ROS Package rosbuild_add_executable(localplanner src/main.cpp)
CMakeLists.txt
ROS Package
You don’t have to worry about most of this junk …
But this line is important. ROS doesn’t magically know where your source files are and which ones you want to package into an executable. So you need to say
rosbuild_add_executable(executable_name source.cpp) or
rosbuild_add_executable(executable_name source1.cpp source2.cpp source3.cpp)
cmake_minimum_required(VERSION 2.4.6)
include($ENV{ROS_ROOT}/core/rosbuild/rosbuild.cmake)
# This is a comment
rosbuild_init()
rosbuild_gen_msg()
rosbuild_add_executable(localplanner src/main.cpp)

36. localplanner
ROS Package
src
include
bin
CMakeLists.txt
manifest.xml

37. ROS Package Package description goes here localplanner src include bin
CMakeLists.txt
manifest.xml

38. ROS Package manifest.xml <package>
<description brief=“localplanner”>
Local Planner
</description>
<author>Your Name Here</author>
<license>BSD</license>
<review status=“unreviewed” notes=“”/>
<url>
<depend package=“roscpp”/> <depend package=“artsystem”/>
<depend package=“nav_msgs”/>
<depend package=“ucontroller”/>
</package>

39. manifest.xml
ROS Package
<package>
<description brief=“localplanner”>
Local Planner
</description>
<author>Your Name Here</author>
<license>BSD</license>
<review status=“unreviewed” notes=“”/>
<url>
<depend package=“roscpp”/> <depend package=“artsystem”/>
<depend package=“nav_msgs”/>
<depend package=“ucontroller”/>
</package>
You need to list your dependencies here! So if you #include something, and ROS is complaining, one of the first things that you should check is whether you need to add another dependency to the manifest.

40. roscd
$ roscd localplanner
in general, roscd [package-name]
localplanner
ROS will find the specified package and will change your working directory to be the top-level package directory
src
include
bin
CMakeLists
manifest

41. rosmake ROS will build the specified package $ rosmake localplanner
in general, rosmake [package-name]
or, when in a package directory, just rosmake
ROS will build the specified package

42. Output of rosmake $ rosmake localplanner
[ rosmake ] rosmake starting …
[ rosmake ] Packages requested are: [‘localplanner’]
[ rosmake ] Logging into directory /home/sandro/.ros/rosmake/rosmake_output
[ rosmake ] Expanded args [‘localplanner’] to:
[‘localplanner’]
[ rosmake-0] Starting >>> roslang [ make ]
[ rosmake-1] Starting >>> geometry_msgs [ make ]
… blah blah blah …
[ rosmake-0 ] Finished <<< ucontroller [PASS] [ 1.53 seconds ]
[ rosmake-0] Finished <<< localplanner [PASS] [ 1.02 seconds ]
[ rosmake ] Results:
[ rosmake ] Built 8 packages with 0 failures.
[ rosmake ] Summary output to directory
[ rosmake ] /home/sandro/.ros/rosmake/rosmake_output

43. Output of rosmake
$ rosmake localplanner
[ rosmake ] rosmake starting …
[ rosmake ] Packages requested are: [‘localplanner’]
[ rosmake ] Logging into directory /home/sandro/.ros/rosmake/rosmake_output
[ rosmake ] Expanded args [‘localplanner’] to:
[‘localplanner’]
[ rosmake-0] Starting >>> roslang [ make ]
[ rosmake-1] Starting >>> geometry_msgs [ make ]
… blah blah blah …
[ rosmake-0 ] Finished <<< ucontroller [PASS] [ 1.53 seconds ]
[ rosmake-0] Finished <<< localplanner [PASS] [ 1.02 seconds ]
[ rosmake ] Results:
[ rosmake ] Built 8 packages with 0 failures.
[ rosmake ] Summary output to directory
[ rosmake ] /home/sandro/.ros/rosmake/rosmake_output
You could potentially see a lot of stuff here, because rosmake actually goes and builds all of your package’s dependencies for you.

44. Output of rosmake
$ rosmake localplanner
[ rosmake ] rosmake starting …
[ rosmake ] Packages requested are: [‘localplanner’]
[ rosmake ] Logging into directory /home/sandro/.ros/rosmake/rosmake_output
[ rosmake ] Expanded args [‘localplanner’] to:
[‘localplanner’]
[ rosmake-0] Starting >>> roslang [ make ]
[ rosmake-1] Starting >>> geometry_msgs [ make ]
… blah blah blah …
[ rosmake-0 ] Finished <<< ucontroller [PASS] [ 1.53 seconds ]
[ rosmake-0] Finished <<< localplanner [PASS] [ 1.02 seconds ]
[ rosmake ] Results:
[ rosmake ] Built 8 packages with 0 failures.
[ rosmake ] Summary output to directory
[ rosmake ] /home/sandro/.ros/rosmake/rosmake_output
[PASS] means that rosmake successfully built a package. [FAIL] means there were errors.

45. Output of rosmake
$ rosmake localplanner
[ rosmake ] rosmake starting …
[ rosmake ] Packages requested are: [‘localplanner’]
[ rosmake ] Logging into directory /home/sandro/.ros/rosmake/rosmake_output
[ rosmake ] Expanded args [‘localplanner’] to:
[‘localplanner’]
[ rosmake-0] Starting >>> roslang [ make ]
[ rosmake-1] Starting >>> geometry_msgs [ make ]
… blah blah blah …
[ rosmake-0 ] Finished <<< ucontroller [PASS] [ 1.53 seconds ]
[ rosmake-0] Finished <<< localplanner [PASS] [ 1.02 seconds ]
[ rosmake ] Results:
[ rosmake ] Built 8 packages with 0 failures.
[ rosmake ] Summary output to directory
[ rosmake ] /home/sandro/.ros/rosmake/rosmake_output
0 failures is what you’re looking for (obviously). If there were failures, you’ll also see a list of error messages.