ROSPub-Sub, Parameters, Services, Roslaunch etc

Agenda• Publishing messages to topics • Subscribing to topics • Differential drive robots • Sending velocity commands • roslaunch

2

ROS Parameters• Parameters are like global data • Accessed through the Parameter Server • Typically handled by roscore

3

Setting Parameters• Command line

• Programs

4

rosrun my_pkg load_robot _ip:=“192.168.1.21” rosparam set “/debug” true

nh.setParam(“name”, “left”);

Namespaces• Folder Hierarchy allows Separation: • Separate nodes can co-exist, in different “namespaces” • –relative vs. absolute name references • Accessed through rose::NodeHandle object

• also sets default Namespace for access • Global (root) Namespace

• Fixed Namespace:

5

ros::NodeHandle global(); global.getParam(“test”);

ros::NodeHandle fixed(“/myApp”); global.getParam(“test”);

Parameters: C++ API• NodeHandle object methods • nh.hasParam(key)

• Returns true if parameter exists • nh.getParam(key, &value)

• Gets value, returns T/F if exists. • nh.param(key, &value, default)

• Get value (or default, if doesn’t exist) • nh.setParam(key, value)

• Sets value • nh.deleteParam(key)

• Deletes parameter

6

ros::Publisher• Manages an advertisement on a specific topic • A Publisher is created by calling NodeHandle::advertise()

• Registers this topic in the master node • Example for creating a publisher:

• First parameter is the topic name • Second parameter is the queue size

• Once all the publishers for a given topic go out of scope the topic will be unadvertised

7

ros::Publisher chatter_pub = node.advertise<std_msgs::String>("chatter", 1000);

ros::Publisher• Messages are published on a topic through a call to publish() • Example:

• The type of the message object must agree with the type given as a template parameter to the advertise<>() call

8

std_msgs::String msg; chatter_pub.publish(msg);

Talker and Listener• We now create a new package with two nodes:

• talker publishes messages to topic “chatter” • listener reads the messages from the topic and prints them out

to the screen • First create the package

• Open the package source directory in QtCreator and add a C++ source file named Talker.cpp

• Copy the following code into it

9

$ cd ~/catkin_ws/src catkin_create_pkg chat_pkg std_msgs rospy roscpp

Talker.cpp

10

#include "ros/ros.h" #include "std_msgs/String.h" #include <sstream>   int main(int argc, char **argv) { ros::init(argc, argv, "talker"); // Initiate new ROS node named "talker"   ros::NodeHandle node; ros::Publisher chatter_pub = node.advertise<std_msgs::String>("chatter", 1000); ros::Rate loop_rate(10);   int count = 0; while (ros::ok()) // Keep spinning loop until user presses Ctrl+C { std_msgs::String msg;   std::stringstream ss; ss << "hello world " << count; msg.data = ss.str();  ROS_INFO("%s", msg.data.c_str());   chatter_pub.publish(msg);   ros::spinOnce(); // Need to call this function often to allow ROS to process incoming messages   loop_rate.sleep(); // Sleep for the rest of the cycle, to enforce the loop rate count++; }  return 0; }

Subscribing to a Topic• To start listening to a topic, call the method subscribe() of the node handle

• This returns a Subscriber object that you must hold on to until you want to unsubscribe

• Example for creating a subscriber:

• First parameter is the topic name • Second parameter is the queue size • Third parameter is the function to handle the message

11

ros::Subscriber sub = node.subscribe("chatter", 1000, messageCallback);

Listener.cpp

12

#include "ros/ros.h" #include "std_msgs/String.h"   // Topic messages callback void chatterCallback(const std_msgs::String::ConstPtr& msg) { ROS_INFO("I heard: [%s]", msg->data.c_str()); }   int main(int argc, char **argv) { // Initiate a new ROS node named "listener" ros::init(argc, argv, "listener");  ros::NodeHandle node;   // Subscribe to a given topic ros::Subscriber sub = node.subscribe("chatter", 1000, chatterCallback);   // Enter a loop, pumping callbacks ros::spin();   return 0; }

ros::spin()• The ros::spin() creates a loop where the node starts to read the topic, and when a message arrives messageCallback is called

• ros::spin() will exit once ros::ok() returns false • For example, when the user presses Ctrl+C or when

ros::shutdown() is called

13

Using Class Methods as Callbacks• Suppose you have a simple class, Listener:

• Then the NodeHandle::subscribe() call using the class method looks like this:

14

class Listener { public: void callback(const std_msgs::String::ConstPtr& msg); };

Listener listener; ros::Subscriber sub = node.subscribe("chatter", 1000, &Listener::callback, &listener);

Compile the Nodes• Add the following to the package’s CMakeLists file

15

cmake_minimum_required(VERSION 2.8.3) project(chat_pkg) …

## Declare a cpp executable add_executable(talker src/Talker.cpp) add_executable(listener src/Listener.cpp)

## Specify libraries to link a library or executable target against target_link_libraries(talker ${catkin_LIBRARIES}) target_link_libraries(listener ${catkin_LIBRARIES})

Building the Nodes• Now build the package and compile all the nodes using the catkin_make tool:

• This will create two executables, talker and listener, at ~/catkin_ws/devel/lib/chat_pkg

16

cd ~/catkin_ws catkin_make

Running the Nodes From Terminal• Run roscore • Run the nodes in two different terminals:

17

$ rosrun chat_pkg talker $ rosrun chat_pkg listener

Running the Nodes From Terminal• You can use rosnode and rostopic to debug and see what the nodes are doing

• Examples: • $rosnode info /talker • $rosnode info /listener • $rostopic list • $rostopic info /chatter • $rostopic echo /chatter

18

rqt_graph• rqt_graph creates a dynamic graph of what's going on in the system

• Use the following command to run it:

19

$ rosrun rqt_graph rqt_graph

ROS Services• The next step is to learn how to read the map in your ROS nodes • For that purpose we will use a ROS service called sta$c_map from the package map_server

• Services use the request/reply paradigm instead of the publish/subscribe model

20

Service Definitions• ROS Services are defined by srv files, which contains

a request message and a response message. • These are identical to the messages used with ROS Topics 

• roscpp converts these srv files into C++ source code and creates 3 classes

• The names of these classes come directly from the srv filename: my_package/srv/Foo.srv → • my_package::Foo – service definition • my_package::Foo::Request – request message • my_package::Foo::Response – response message

21

Generated Structure

22

Calling Services• Since service calls are blocking, it will return once the call is done

• If the service call succeeded, call() will return true and the value in srv.response will be valid.

• If the call did not succeed, call() will return false and the value in srv.response will be invalid.

23

ros::NodeHandle nh; ros::ServiceClient client = nh.serviceClient<my_package::Foo>("my_service_name"); my_package::Foo foo; foo.request.<var> = <value>; ... if (client.call(foo)) { ... }

roslaunch• roslaunch is a tool for easily launching multiple ROS nodes as well as setting parameters on the Parameter Server 

• It takes in one or more XML configuration files (with the .launch extension) that specify the parameters to set and nodes to launch

• If you use roslaunch, you do not have to run roscore manually

24

Launch File Example• Launch file for launching both the talker and listener nodes (chat.launch):

• output=“screen” makes the ROS log messages appear on the launch terminal window

• To run a launch file use:

25

$ roslaunch chat_pkg chat.launch

<launch> <node name="talker" pkg="chat_pkg" type="talker" output="screen"/> <node name="listener" pkg="chat_pkg" type="listener" output="screen"/> </launch>

Launch File Example

26