您的位置: 首页  >  文章  >  转:rosspin、rosspinOnce及多线程订阅

转:rosspin、rosspinOnce及多线程订阅

分类: 文章 • 2025-05-06 13:25:10

背景

因为在一些点云处理的程序中，出现多个订阅者订阅同一个topic，由于内部处理的时间不同，最后造成显示界面出现卡顿，现象就是用鼠标拖动点云的视角会感觉非常卡，不顺畅。为此，决定先走一遍官方的多线程系列教程。

https://github.com/ros/ros_tutorials/tree/jade-devel/roscpp_tutorials

http://wiki.ros.org/roscpp_tutorials/Tutorials

关于Spin和SpinOnce的解释来自英文书《A Gentle Introduction to ROS》P59页

转:rosspin、rosspinOnce及多线程订阅

什么时候用ros::spin()和ros::spinOnce()呢，如果仅仅只是响应topic，就用ros::spin()。当程序中除了响应回调函数还有其他重复性工作的时候，那就在循环中做那些工作，然后调用ros::spinOnce()。如下面的用spinOnce，循环调用print( )函数。

转:rosspin、rosspinOnce及多线程订阅

这里一直在打印while 中的部分，并且处理message queue。

而下面的打印输出不会更新，相当于只执行了一次，但是它会不断处理ROS 的message queue（下图右边的subscriber 开头的打印函数只调用了一次，然后一直响应订阅的消息）。

转:rosspin、rosspinOnce及多线程订阅

这里只在一开始进入main的时候调用了一次print函数，其余的都在响应topic 去了。


spinOnce( )较常用的做法是while里放publisher所要发布的msg的赋值处理，然后一直循环发布topic。

[cpp] view plain copy
  1. ros::Rate loop_rate(10);  
  2.   
  3.   while (ros::ok())  
  4.   {  
  5.     std_msgs::String msg;  
  6.   
  7.     std::stringstream ss;  
  8.     ss << "hello world " << count;  
  9.     msg.data = ss.str();  
  10.   
  11.     chatter_pub.publish(msg);  
  12.   
  13.     ros::spinOnce();  
  14.     loop_rate.sleep();  
  15.   }  


1. customer_callback_processing
自定义消息队列处理线程，关键字：JOIN，在主线程spinOnce进入自定义处理线程。

http://wiki.ros.org/roscpp/Overview/Callbacks%20and%20Spinning这里官网给出了补充说明

[cpp] view plain copy
  1. #include "ros/ros.h"  
  2. #include "ros/callback_queue.h"  
  3. #include "std_msgs/String.h"  
  4.   
  5. #include <boost/thread.hpp>  
  6.   
  7. /** 
  8.  * This tutorial demonstrates the use of custom separate callback queues that can be processed 
  9.  * independently, whether in different threads or just at different times. 
  10.  */  
  11.   
  12. void chatterCallbackMainQueue(const std_msgs::String::ConstPtr& msg)  
  13. {  
  14.   ROS_INFO_STREAM("I heard: [ " << msg->data << "] in thread [" << boost::this_thread::get_id() << "] (Main thread)");  
  15. }  
  16.   
  17.   
  18. void chatterCallbackCustomQueue(const std_msgs::String::ConstPtr& msg)  
  19. {  
  20.   ROS_INFO_STREAM("I heard: [ " << msg->data << "] in thread [" << boost::this_thread::get_id() << "]");  
  21. }  
  22.   
  23. /** 
  24.  * The custom queue used for one of the subscription callbacks 
  25.  */  
  26. ros::CallbackQueue g_queue;  
  27. void callbackThread()  
  28. {  
  29.   ROS_INFO_STREAM("Callback thread id=" << boost::this_thread::get_id());  
  30.   
  31.   ros::NodeHandle n;  
  32.   while (n.ok())  
  33.   {  
  34.     g_queue.callAvailable(ros::WallDuration(0.01));  
  35.   }  
  36. }  
  37.   
  38. int main(int argc, char **argv)  
  39. {  
  40.   ros::init(argc, argv, "listener_with_custom_callback_processing");  
  41.   ros::NodeHandle n;  
  42.   
  43.   /** 
  44.    * The SubscribeOptions structure lets you specify a custom queue to use for a specific subscription. 
  45.    * You can also set a default queue on a NodeHandle using the NodeHandle::setCallbackQueue() function. 
  46.    * 
  47.    * AdvertiseOptions and AdvertiseServiceOptions offer similar functionality. 
  48.    */  
  49.   ros::SubscribeOptions ops = ros::SubscribeOptions::create<std_msgs::String>("chatter", 1000,  
  50.                                                                               chatterCallbackCustomQueue,  
  51.                                                                               ros::VoidPtr(), &g_queue);  
  52.   ros::Subscriber sub = n.subscribe(ops);  
  53.   
  54.   ros::Subscriber sub2 = n.subscribe("chatter", 1000, chatterCallbackMainQueue);  
  55.   
  56.   boost::thread chatter_thread(callbackThread);  
  57.   
  58.   ROS_INFO_STREAM("Main thread id=" << boost::this_thread::get_id());  
  59.   
  60.   ros::Rate r(1);  
  61.   while (n.ok())  
  62.   {  
  63.     ros::spinOnce();  
  64.     r.sleep();  
  65.   }  
  66.   
  67.   chatter_thread.join();  
  68.   
  69.   return 0;  
  70. }  
转:rosspin、rosspinOnce及多线程订阅
2. listenner_multiple_spin 

思想：利用一个类的不同成员函数实现同一个topic的不同处理(在一个线程中)。

[cpp] view plain copy
  1. #include "ros/ros.h"  
  2. #include "std_msgs/String.h"  
  3.   
  4. /** 
  5.  * This tutorial demonstrates simple receipt of messages over the ROS system, with 
  6.  * multiple callbacks for the same topic.  See the "listener" tutorial for more 
  7.  * information. 
  8.  */  
  9.   
  10. class Listener  
  11. {  
  12. public:  
  13.   void chatter1(const std_msgs::String::ConstPtr& msg) { ROS_INFO("chatter1: [%s]", msg->data.c_str()); }  
  14.   void chatter2(const std_msgs::String::ConstPtr& msg) { ROS_INFO("chatter2: [%s]", msg->data.c_str()); }  
  15.   void chatter3(const std_msgs::String::ConstPtr& msg) { ROS_INFO("chatter3: [%s]", msg->data.c_str()); }  
  16. };  
  17.   
  18. void chatter4(const std_msgs::String::ConstPtr& msg)  
  19. {  
  20.   ROS_INFO("chatter4: [%s]", msg->data.c_str());  
  21. }  
  22.   
  23. int main(int argc, char **argv)  
  24. {  
  25.   ros::init(argc, argv, "listener");  
  26.   ros::NodeHandle n;  
  27.   
  28.   Listener l;  
  29.   ros::Subscriber sub1 = n.subscribe("chatter", 10, &Listener::chatter1, &l);  
  30.   ros::Subscriber sub2 = n.subscribe("chatter", 10, &Listener::chatter2, &l);  
  31.   ros::Subscriber sub3 = n.subscribe("chatter", 10, &Listener::chatter3, &l);  
  32.   ros::Subscriber sub4 = n.subscribe("chatter", 10, chatter4);  
  33.   
  34.   ros::spin();  
  35.   
  36.   return 0;  
  37. }  

转:rosspin、rosspinOnce及多线程订阅

3. listener_threaded_spin 

思想：利用一个类的不同成员函数实现同一个topic的不同处理(在四个不同线程中)。

[cpp] view plain copy
  1. #include "ros/ros.h"  
  2. #include "std_msgs/String.h"  
  3.   
  4. #include <boost/thread.hpp>  
  5.   
  6. /** 
  7.  * This tutorial demonstrates simple receipt of messages over the ROS system, using 
  8.  * a threaded Spinner object to receive callbacks in multiple threads at the same time. 
  9.  */  
  10.   
  11. ros::Duration d(0.01);  
  12.   
  13. class Listener  
  14. {  
  15. public:  
  16.   void chatter1(const std_msgs::String::ConstPtr& msg)  
  17.   {  
  18.     ROS_INFO_STREAM("chatter1: [" << msg->data << "] [thread=" << boost::this_thread::get_id() << "]");  
  19.     d.sleep();  
  20.   }  
  21.   void chatter2(const std_msgs::String::ConstPtr& msg)  
  22.   {  
  23.     ROS_INFO_STREAM("chatter2: [" << msg->data << "] [thread=" << boost::this_thread::get_id() << "]");  
  24.     d.sleep();  
  25.   }  
  26.   void chatter3(const std_msgs::String::ConstPtr& msg)  
  27.   {  
  28.     ROS_INFO_STREAM("chatter3: [" << msg->data << "] [thread=" << boost::this_thread::get_id() << "]");  
  29.     d.sleep();  
  30.   }  
  31. };  
  32.   
  33. void chatter4(const std_msgs::String::ConstPtr& msg)  
  34. {  
  35.   ROS_INFO_STREAM("chatter4: [" << msg->data << "] [thread=" << boost::this_thread::get_id() << "]");  
  36.   d.sleep();  
  37. }  
  38.   
  39. int main(int argc, char **argv)  
  40. {  
  41.   ros::init(argc, argv, "listener");  
  42.   ros::NodeHandle n;  
  43.   
  44.   Listener l;  
  45.   ros::Subscriber sub1 = n.subscribe("chatter", 10, &Listener::chatter1, &l);  
  46.   ros::Subscriber sub2 = n.subscribe("chatter", 10, &Listener::chatter2, &l);  
  47.   ros::Subscriber sub3 = n.subscribe("chatter", 10, &Listener::chatter3, &l);  
  48.   ros::Subscriber sub4 = n.subscribe("chatter", 10, chatter4);  
  49.   
  50.   /** 
  51.    * The MultiThreadedSpinner object allows you to specify a number of threads to use 
  52.    * to call callbacks.  If no explicit # is specified, it will use the # of hardware 
  53.    * threads available on your system.  Here we explicitly specify 4 threads. 
  54.    */  
  55.   ros::MultiThreadedSpinner s(4);  
  56.   ros::spin(s);  
  57.   
  58.   return 0;  
  59. }  
转:rosspin、rosspinOnce及多线程订阅
4. listener_async_spin 
因为这里用的是spinOnce，主线程每隔（1/5秒）打印，然后sleep把控制权交给系统，系统然后就把控制权分配到四个子线程，所以结果看到一共是五个线程。
[cpp] view plain copy
  1. #include "ros/ros.h"  
  2. #include "std_msgs/String.h"  
  3.   
  4. #include <boost/thread.hpp>  
  5.   
  6. /** 
  7.  * This tutorial demonstrates simple receipt of messages over the ROS system, using 
  8.  * an asynchronous Spinner object to receive callbacks in multiple threads at the same time. 
  9.  */  
  10.   
  11. ros::Duration d(0.01);  
  12.   
  13. class Listener  
  14. {  
  15. public:  
  16.   void chatter1(const std_msgs::String::ConstPtr& msg)  
  17.   {  
  18.     ROS_INFO_STREAM("chatter1: [" << msg->data << "] [thread=" << boost::this_thread::get_id() << "]");  
  19.     d.sleep();  
  20.   }  
  21.   void chatter2(const std_msgs::String::ConstPtr& msg)  
  22.   {  
  23.     ROS_INFO_STREAM("chatter2: [" << msg->data << "] [thread=" << boost::this_thread::get_id() << "]");  
  24.     d.sleep();  
  25.   }  
  26.   void chatter3(const std_msgs::String::ConstPtr& msg)  
  27.   {  
  28.     ROS_INFO_STREAM("chatter3: [" << msg->data << "] [thread=" << boost::this_thread::get_id() << "]");  
  29.     d.sleep();  
  30.   }  
  31. };  
  32.   
  33. void chatter4(const std_msgs::String::ConstPtr& msg)  
  34. {  
  35.   ROS_INFO_STREAM("chatter4: [" << msg->data << "] [thread=" << boost::this_thread::get_id() << "]");  
  36.   d.sleep();  
  37. }  
  38.   
  39. int main(int argc, char **argv)  
  40. {  
  41.   ros::init(argc, argv, "listener");  
  42.   ros::NodeHandle n;  
  43.   
  44.   Listener l;  
  45.   ros::Subscriber sub1 = n.subscribe("chatter", 10, &Listener::chatter1, &l);  
  46.   ros::Subscriber sub2 = n.subscribe("chatter", 10, &Listener::chatter2, &l);  
  47.   ros::Subscriber sub3 = n.subscribe("chatter", 10, &Listener::chatter3, &l);  
  48.   ros::Subscriber sub4 = n.subscribe("chatter", 10, chatter4);  
  49.   
  50.   /** 
  51.    * The AsyncSpinner object allows you to specify a number of threads to use 
  52.    * to call callbacks.  If no explicit # is specified, it will use the # of hardware 
  53.    * threads available on your system.  Here we explicitly specify 4 threads. 
  54.    */  
  55.   ros::AsyncSpinner s(4);  
  56.   s.start();  
  57.   
  58.   ros::Rate r(5);  
  59.   while (ros::ok())  
  60.   {  
  61.     ROS_INFO_STREAM("Main thread [" << boost::this_thread::get_id() << "].");  
  62.     r.sleep();  
  63.   }  
  64.   
  65.   return 0;  
  66. }  

转:rosspin、rosspinOnce及多线程订阅


============2016.11====一次订阅四个topic===============

http://wiki.ros.org/message_filters#ApproximateTime_Policy


https://github.com/tum-vision/rgbd_demo/blob/master/src/example.cpp

[cpp] view plain copy
  1. #include <message_filters/subscriber.h>  
  2. #include <message_filters/synchronizer.h>  
  3. #include <message_filters/sync_policies/approximate_time.h>  
  4. #include <sensor_msgs/Image.h>  
  5. #include <sensor_msgs/CameraInfo.h>  
  6. #include <cv_bridge/cv_bridge.h>  
  7. #include <opencv2/imgproc/imgproc.hpp>  
  8. #include <opencv2/highgui/highgui.hpp>  
  9. #include <iostream>  
  10. #include <ros/ros.h>  
  11. #include <pcl_ros/point_cloud.h>  
  12. #include <pcl/point_types.h>  
  13.   
  14. // Note: for colorized point cloud, use PointXYZRGBA  
  15. typedef pcl::PointCloud<pcl::PointXYZ> PointCloud;  
  16.   
  17. using namespace std;  
  18. using namespace sensor_msgs;  
  19. using namespace message_filters;  
  20.   
  21. ros::Publisher pointcloud_pub;  
  22.   
  23. void callback(const ImageConstPtr& image_color_msg,  
  24.         const ImageConstPtr& image_depth_msg,  
  25.         const CameraInfoConstPtr& info_color_msg,  
  26.         const CameraInfoConstPtr& info_depth_msg)   
  27. {  
  28.     // Solve all of perception here...  
  29.     cv::Mat image_color = cv_bridge::toCvCopy(image_color_msg)->image;  
  30.     cv::Mat image_depth = cv_bridge::toCvCopy(image_depth_msg)->image;  
  31.   
  32.     cvtColor(image_color,image_color, CV_RGB2BGR);  
  33.   
  34.     // colorize the image  
  35.     cv::Vec3b color(255,0,0);  
  36.     for(int y=0;y<image_color.rows;y++)   
  37.        {  
  38.         for(int x=0;x<image_color.cols;x++)   
  39.           {  
  40.             float depth = image_depth.at<short int>(cv::Point(x,y)) / 1000.0;  
  41.   
  42.             if( depth == 0)   
  43.                       {  
  44.                 image_color.at<cv::Vec3b>(cv::Point(x,y)) = cv::Vec3b(0,0,255);  
  45.             }  
  46.             if( depth > 1.00)   
  47.                       {  
  48.                 image_color.at<cv::Vec3b>(cv::Point(x,y)) = cv::Vec3b(255,0,0);  
  49.             }  
  50.         }  
  51.     }  
  52.   
  53.     //cout <<"depth[320,240]="<< image_depth.at<short int>(cv::Point(320,240)) / 1000.0 <<"m"<< endl;  
  54.     image_color.at<cv::Vec3b>(cv::Point(320,240)) = cv::Vec3b(255,255,255);  
  55.   
  56.     // get camera intrinsics  
  57.     float fx = info_depth_msg->K[0];  
  58.     float fy = info_depth_msg->K[4];  
  59.     float cx = info_depth_msg->K[2];  
  60.     float cy = info_depth_msg->K[5];  
  61.     //cout << "fx="<< fx << " fy="<<fy<<" cx="<<cx<<" cy="<<cy<<endl;  
  62.   
  63.     // produce a point cloud  
  64.     PointCloud::Ptr pointcloud_msg (new PointCloud);  
  65.     pointcloud_msg->header = image_depth_msg->header;  
  66.   
  67.     pcl::PointXYZ pt;  
  68.     for(int y=0;y<image_color.rows;y+=4)   
  69.         {  
  70.         for(int x=0;x<image_color.cols;x+=4)   
  71.               {  
  72.             float depth = image_depth.at<short int>(cv::Point(x,y)) / 1000.0;  
  73.   
  74.             if(depth>0)   
  75.                   {  
  76.                 pt.x = (x - cx) * depth / fx;  
  77.                 pt.y = (y - cy) * depth / fy;  
  78.                 pt.z = depth;  
  79.                 //cout << pt.x<<" "<<pt.y<<" "<<pt.z<<endl;  
  80.                 pointcloud_msg->points.push_back (pt);  
  81.             }  
  82.         }  
  83.     }  
  84.     pointcloud_msg->height = 1;  
  85.     pointcloud_msg->width = pointcloud_msg->points.size();  
  86.     pointcloud_pub.publish (pointcloud_msg);  
  87.   
  88.     cv::imshow("color", image_color);  
  89.   
  90.     cv::waitKey(3);  
  91. }  
  92.   
  93. int main(int argc, char** argv)   
  94. {  
  95.     ros::init(argc, argv, "vision_node");  
  96.   
  97.     ros::NodeHandle nh;  
  98.   
  99.     message_filters::Subscriber<Image> image_color_sub(nh,"/camera/rgb/image_raw", 1);  
  100.     message_filters::Subscriber<Image> image_depth_sub(nh,"/camera/depth_registered/image_raw", 1);  
  101.     message_filters::Subscriber<CameraInfo> info_color_sub(nh,"/camera/rgb/camera_info", 1);  
  102.     message_filters::Subscriber<CameraInfo> info_depth_sub(nh,"/camera/depth_registered/camera_info", 1);  
  103.     pointcloud_pub = nh.advertise<PointCloud> ("mypoints", 1);  
  104.   
  105.     typedef sync_policies::ApproximateTime<Image, Image, CameraInfo, CameraInfo> MySyncPolicy;  
  106.     Synchronizer<MySyncPolicy> sync(MySyncPolicy(10), image_color_sub, image_depth_sub, info_color_sub, info_depth_sub);  
  107.   
  108.     sync.registerCallback(boost::bind(&callback, _1, _2, _3, _4));  
  109.   
  110.     ros::spin();  
  111.   
  112.     return 0;  
  113. }  
5. listener_with_userdata 

利用boost_bind向消息回调函数传入多个参数

关于boost_bind以前写过一个用法简介http://blog.****.net/yaked/article/details/44942773

这里是boost::bind(&listener::chatterCallback, this,  _1, "User 1" )也即this->chatterCallback( "User1"), _1表示第一个输入参数, 是个占位标记。

[cpp] view plain copy
  1. #include "ros/ros.h"  
  2. #include "std_msgs/String.h"  
  3.   
  4. /** 
  5.  * This tutorial demonstrates a simple use of Boost.Bind to pass arbitrary data into a subscription 
  6.  * callback.  For more information on Boost.Bind see the documentation on the boost homepage, 
  7.  * http://www.boost.org/ 
  8.  */  
  9.   
  10.   
  11. class Listener  
  12. {  
  13. public:  
  14.   ros::NodeHandle node_handle_;  
  15.   ros::V_Subscriber subs_;  
  16.   
  17.   Listener(const ros::NodeHandle& node_handle): node_handle_(node_handle)  
  18.   {  
  19.   }  
  20.   
  21.   void init()  
  22.   {  
  23.     subs_.push_back(node_handle_.subscribe<std_msgs::String>("chatter", 1000, boost::bind(&Listener::chatterCallback, this, _1, "User 1")));  
  24.     subs_.push_back(node_handle_.subscribe<std_msgs::String>("chatter", 1000, boost::bind(&Listener::chatterCallback, this, _1, "User 2")));  
  25.     subs_.push_back(node_handle_.subscribe<std_msgs::String>("chatter", 1000, boost::bind(&Listener::chatterCallback, this, _1, "User 3")));  
  26.   }  
  27.   
  28.   void chatterCallback(const std_msgs::String::ConstPtr& msg, std::string user_string)  
  29.   {  
  30.     ROS_INFO("I heard: [%s] with user string [%s]", msg->data.c_str(), user_string.c_str());  
  31.   }  
  32. };  
  33.   
  34. int main(int argc, char **argv)  
  35. {  
  36.   ros::init(argc, argv, "listener_with_userdata");  
  37.   ros::NodeHandle n;  
  38.   
  39.   Listener l(n);  
  40.   l.init();  
  41.   
  42.   ros::spin();  
  43.   
  44.   return 0;  
  45. }  

转:rosspin、rosspinOnce及多线程订阅

6. timers

可以参考官网http://wiki.ros.org/roscpp/Overview/Timers

[cpp] view plain copy
  1. #include "ros/ros.h"  
  2.   
  3. /** 
  4.  * This tutorial demonstrates the use of timer callbacks. 
  5.  */  
  6.   
  7. void callback1(const ros::TimerEvent&)  
  8. {  
  9.   ROS_INFO("Callback 1 triggered");  
  10. }  
  11.   
  12. void callback2(const ros::TimerEvent&)  
  13. {  
  14.   ROS_INFO("Callback 2 triggered");  
  15. }  
  16.   
  17. int main(int argc, char **argv)  
  18. {  
  19.   ros::init(argc, argv, "talker");  
  20.   ros::NodeHandle n;  
  21.   
  22.   ros::Timer timer1 = n.createTimer(ros::Duration(0.1), callback1);  
  23.   ros::Timer timer2 = n.createTimer(ros::Duration(1.0), callback2);  
  24.   
  25.   ros::spin();  
  26.   
  27.   return 0;  
  28. }  

转:rosspin、rosspinOnce及多线程订阅


======================2016.07=====定时器带入附加参数===============

[cpp] view plain copy
  1. #include "ros/ros.h"  
  2. #include "cstring"  
  3. #include "iostream"  
  4. #include "han_agv/SocketClient.h"  
  5.   
  6. #include "han_agv/VelEncoder.h"  
  7.   
  8. using namespace std;  
  9.   
  10. const float_t PI = 3.14159;  
  11. const int ENCODER_PER_LOOP = 900;  
  12. const float_t WHEEL_RADIUS = 0.075;  
  13.   
  14. ClientSocket soc;  
  15.   
  16. // ros_tutorials/turtlesim/tutorials/draw_square.cpp  
  17. void timerCallback(const ros::TimerEvent&, ros::Publisher vel_pub)  
  18. {  
  19.   ROS_INFO("Timer callback triggered");  
  20.   AGVDATA buffer;  
  21.   AGVSENSORS buffer_left_encoder_start;  
  22.   AGVSENSORS buffer_right_encoder_start;  
  23.   
  24. //  if(soc.recvMsg(buffer) == 0)  
  25. //  {  
  26. //      cout << "Failed to receive message." << endl;  
  27. //      return;  
  28. //  }  
  29.   
  30.   // Reverse the High and Low byte.  
  31.   double time_delay = 0.1;  
  32.   ros::Duration(time_delay).sleep ();  
  33.   
  34.   buffer.SensorsData.WheelLeft_Encoder[0] = buffer.SensorsData.WheelLeft_Encoder[3];  
  35.   buffer.SensorsData.WheelLeft_Encoder[1] = buffer.SensorsData.WheelLeft_Encoder[2];  
  36.   
  37.   buffer.SensorsData.WheelRight_Encoder[0] = buffer.SensorsData.WheelRight_Encoder[3];  
  38.   buffer.SensorsData.WheelRight_Encoder[1] = buffer.SensorsData.WheelRight_Encoder[2];  
  39.   
  40.    han_agv::VelEncoder vel;  
  41.    vel.left_velocity = 1.0;  
  42.    vel.right_velocity = 2.0;  
  43.   
  44.    vel_pub.publish(vel);  
  45. }  
  46.   
  47. int main(int argc, char** argv)  
  48. {  
  49.         ros::init(argc, argv, "TCPDecode_node");  
  50.         ros::NodeHandle nh;  
  51.         ROS_INFO("create node successfully!");  
  52.   
  53.         ros::Publisher vel_pub = nh.advertise<han_agv::VelEncoder>("HansAGV/encoder_vel", 1);  
  54.         ros::Timer decoder_timer = nh.createTimer(ros::Duration(0.1), boost::bind(timerCallback, _1, vel_pub));  
  55.   
  56.          ros::spin();  
  57. }  

7. notify_connect

[cpp] view plain copy
  1. #include "ros/ros.h"  
  2. #include "std_msgs/String.h"  
  3.   
  4. #include <sstream>  
  5.   
  6. /** 
  7.  * This tutorial demonstrates how to get a callback when a new subscriber connects 
  8.  * to an advertised topic, or a subscriber disconnects. 
  9.  */  
  10.   
  11. uint32_t g_count = 0;  
  12.   
  13. void chatterConnect(const ros::SingleSubscriberPublisher& pub)  
  14. {  
  15.   std_msgs::String msg;  
  16.   std::stringstream ss;  
  17.   ss << "chatter connect #" << g_count++;  
  18.   ROS_INFO("%s", ss.str().c_str());  
  19.   msg.data = ss.str();  
  20.   
  21.   pub.publish(msg);  // This message will get published only to the subscriber that just connected  
  22. }  
  23.   
  24. void chatterDisconnect(const ros::SingleSubscriberPublisher&)  
  25. {  
  26.   ROS_INFO("chatter disconnect");  
  27. }  
  28.   
  29. int main(int argc, char **argv)  
  30. {  
  31.   ros::init(argc, argv, "notify_connect");  
  32.   ros::NodeHandle n;  
  33.   
  34.   /** 
  35.    * This version of advertise() optionally takes a connect/disconnect callback 
  36.    */  
  37.   ros::Publisher pub = n.advertise<std_msgs::String>("chatter", 1000, chatterConnect, chatterDisconnect);  
  38.   
  39.   ros::spin();  
  40.   
  41.   return 0;  
  42. }  
rosrun beginner_tutorials listener_with_userdata 和另外其他任何一个，因为其他的node名字都重复了，都叫listener。

转:rosspin、rosspinOnce及多线程订阅

转:rosspin、rosspinOnce及多线程订阅转:rosspin、rosspinOnce及多线程订阅

断开连接，通知延后了一分多钟。囧囧！！


相关推荐