Subscribing 2 topics of different types in a callback function

edit

An example on how to protect callbacks with mutextes. You can use POSIX mutexes, then you have to change enter()/exit() by pthread_mutex_lock()/_unlock(). Please see that

myNode::myCallback(const my_msgs::m1::ConstPtr& msg)
{
   mutex.enter();
   this->a = msg->a;
   mutex.exit();
}
myNode::myCallback(const my_msgs::m2::ConstPtr& msg)
{
   mutex.enter();
   this->b = msg->b;
   mutex.exit();
}
myNode::process()
{
   mutex.enter();
   std::cout << this->a + this->b << std::endl;
   mutex.exit();
}

I believe the best way to do this is to use the boost::shared_ptr<synchronizer>. For example the openni node uses this to synchronize a depth_msg and rgb_msg and pass them as arguments to callback a function. The following code is from the openni_nodelet.cpp:

boost::shared_ptr<synchronizer> depth_rgb_sync_; //from header file

SyncPolicy sync_policy (4); // queue size

depth_rgb_sync_.reset (new Synchronizer (sync_policy));

depth_rgb_sync_->registerCallback (boost::bind (&OpenNINodelet::publishXYZRGBPointCloud, this, _1, _2));

depth_rgb_sync_->add < 1 > (rgb_msg);

depth_rgb_sync_->add < 0 > (depth_msg);

and the callback function is:

void OpenNINodelet::publishXYZRGBPointCloud (const sensor_msgs::ImageConstPtr& depth_msg, const sensor_msgs::ImageConstPtr& rgb_msg) const {}

So you can subscribe to 2 different topics, each having their own message, and in their callback functions you can add the msg to the boost synchronizer. For example in the first callback you can do depth_rgb_sync_->add < 1 > (rgb_msg) and in the second one depth_rgb_sync_->add < 0 > (depth_msg) where depth_rgb_sync_ will be replaced by your boost::shared_ptr<synchronizer> and rgb_msg and depth_msg will be replaced by the messages of the 2 topics. When both messages are received the boost synchronizer will call your function with the 2 msgs as arguments.

Hope this help. Ivan

If what you want is a callback that is triggered when messages come in at (approximately) the same time on two (or more) separate topics, you should look at message_filters.

Why you want to do this? Is it a reasonable case?

What I know is writing 2 callbacks and each callback call the same function.

Therefore, you can implement that function deal with 2 cases of callback events.

I haven't trying,just an idea.

The best way is to create two sparated callbacks , and associate each callback to each topic with the subscribe() function (ros::NodeHandle::subscribe(), see this.

Otherwise, I don't see why you should use a single callback for both topics ? Do you have a motivation about this requirement ?

kind regards,

andreu