What is the use of multiple nodehandles

nodehandle

asked 2015-09-28 11:02:00 -0500

takahashi
185 ●15 ●20 ●23

I didn't really get the concept of nodehandles from the ROS wiki and couldn't find any concise answer with google. I understood that a ROS node can have multiple nodehandles and they refer to the same node. In a node's main(), I first initialize the node using ros::Init() and then use a nodehandle for starting and shutting down the node. So what does the declaration of multiple nodehandles do in this case?

edit retag flag offensive close merge delete

add a comment

8

answered 2015-09-29 02:57:47 -0500

Adolfo Rodriguez T

3907 ●28 ●45 ●71

Two reasons for having different NodeHandle instances in the same node are:

1. namespace scope: This is the most common usecase, and specifies the namespace prefix that applies to all graph resource names that hang from it. This is what @Boris refers to in his answer. For instance, the following two constructs are equivalent:

ros::NodeHandle("/foo").hasParam("bar");
ros::NodeHandle().hasParam("/foo/bar");

2. control callback spinning: This usecase is more advanced, or at least less common. It is possible to assign different callback queues to different NodeHandle instances, so you can for instance have a node in which some callbacks are processed at high-frequency (e.g. control commands), while others are processed at a slower rate.

edit flag offensive delete link

add a comment

8

answered 2015-09-28 17:26:00 -0500

Boris

3060 ●32 ●57 ●83 http://people.idsia.ch/~gromov

updated 2015-09-28 17:26:55 -0500

The most common use is to get access to both private and global ROS namespaces.

So a very typical thing to do would be something like this:

node_ = ros::NodeHandlePtr(new ros::NodeHandle);
pnode_ = ros::NodeHandlePtr(new ros::NodeHandle("~"));

with this approach you can publish your topics on the global namespace by using node_->advertise<...>(...), while accessing parameters under private namespace with pnode_->param(...).

Also note that NodeHandlePtr is actually a shared pointer (smart pointer), so it does internal reference counting, thus it controls object's lifetime.