ROS学习之 cpp回调函数和轮转(spin)

本文详细介绍了ROS中消息处理的方式,包括ros::spin()和ros::spinOnce()的使用场景,以及如何通过ros::MultiThreadedSpinner和ros::AsyncSpinner实现多线程消息处理。同时探讨了自定义回调队列的应用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >


wiki链接: http://wiki.ros.org/roscpp/Overview/Callbacks%20and%20Spinning

资料(云飞机器人实验室的一篇小文): http://www.yfworld.com/?p=2318
这篇文章会帮助理解ros::spin()调用和回调函数的关系,其参考链接:http://answers.ros.org/question/11887/significance-of-rosspinonce/

关于spin一词: spin在英语中是"纺纱,吐司,旋转,延伸"等意思,在看这部分时,脑子里想的是怎么翻译这个词,
          看了上面的这篇资料,决定将它翻成"轮转"的意思.消息会被压入消息队列,而消息回调函数也回被压入队列,消息到来并不会立即执行消息处理回调函数,而是在调用ros::spin()之后,才进行消息处理的轮转,消息回调函数统一处理订阅话题的消息.

好了,开始正题.    
    roscpp不会在你的应用中明确一个线程模型.也就是说即使roscpp会在幕后使用多线程管理网络链接,调度等,但它不会将自己的线程暴露在你的应用中.
    roscpp允许你的回调函数被任意多线程调用,如果你愿意.
    最后的结果可能是你的回调函数将没有机会被调用.最常用的方法是使用ros::spin()调用.
    注意:回调函数的排队和轮转,不会对内部的网路通信造成影响.它们仅仅会影响到用户的回调函数何时发生.它们会影响到订阅者队列.因为处理你回调函数的速度,你消息到来的速度,将会决定以前的消息会不会被丢弃.
    

    1.单线程下的轮转


    最简单的单线程spin的例子就是ros::spin()自己.
        ros::init(argc, argv, "my_node"); //初始化节点
        ros::NodeHandle nh;        //创建节点句柄
        ros::Subscriber sub = nh.subscribe(...);  //创建消息订阅者
        ...
        ros::spin();         //调用spin(),统一处理消息
    在这里,所有的用户回调函数将在spin()调用之后被调用.
    ros::spin()不会返回,直到节点被关闭,或者调用ros::shutdown(),或者按下ctrl+C

    另一个常用的模式是周期性地调用ros::spinOnce():
        ros::Rate r(10); // 10 hz
        while (should_continue)
        {
          //... do some work, publish some messages, etc. ...
          ros::spinOnce();  //轮转一次,返回
          r.sleep();        //休眠
        }

        ros::spinOnce()将会在被调用的那一时间点调用所有等待的回调函数.
        注意: ros::spin()和ros::spinOnce()函数对单线程应用很有意义,目前不会应用于多线程.

    2.多线程轮转


        上面是单线程下的消息回调函数轮转,那多线程下是什么样子?
        roscpp库提供了一些内嵌的支持来从多线程中调用回调函数.

        1) ros::MultiThreadedSpiner
        它是一个阻塞型轮转器,类似于ros::spin().
        可以使用它的构造器来设定线程的个数,如果不设置或设成0,它将为每个cpu核心使用一个线程.
            ros::MultiThreadedSpinner spinner(4); // Use 4 threads
            spinner.spin(); // spin() will not return until the node has been shutdown
        2)ros::AsyncSpinner
        API : http://docs.ros.org/api/roscpp/html/classros_1_1AsyncSpinner.html
        更实用的多线程轮转是异步轮转器(AsyncSpiner).相对于阻塞的spin()调用,它有自己的start()和stop()调用
        并且在销毁后将自动停止.对上述MultiThreadedSpiner等效的AsyncSpiner使用如下:
            ros::AsyncSpinner spinner(4); // Use 4 threads
            spinner.start();
            ros::waitForShutdown();

    3.CallbackQueue::callAvailable() and callOne()

    
        CallbackQueue API 回调函数队列类: http://docs.ros.org/api/roscpp/html/classros_1_1CallbackQueue.html
        可以创建一个回调函数队列类:
            #include <ros/callback_queue.h>
            ...
            ros::CallbackQueue my_queue;
        回调函数队列类有两种触发其内部回调函数的方法: callAvailable()方法和callOne()方法.
        前者将获取当前可以符合条件的回调函数,并且全部触发它们;后者将简单地触发队列中最早的那个回调函数.
        这两个方法都接受一个可选的timeout超时时间,它们将在此时间之内等待一个回调函数变得符合条件.
        如果这个值是0,那么,如果队列中没有回调函数,该方法立即返回.

    4.高级主题:使用不同的回调函数队列

        默认的是所有的消息回调函数都会被压入全局消息回调队列.
        roscpp允许使用自定义的消息回调函数队列并分别服务.这可以以两种粒度实现:
        1)每个subsceribe(),advertise(),advertiseService(),等
            这部分可以使用高级版的方法调用原型,使用一个选项结构体指针参数.
        2)每个节点句柄
            这是常见的方法,使用节点句柄的setCallbackQueue()方法:
            ros::NodeHandle nh;
            nh.setCallbackQueue(&my_callback_queue);
            这使所有的消息订阅者,服务,定时器等的回调函数都进入my_callback_queue,而非roscpp的默认队列.
            这意味着,ros::spin()和ros::spinOnce()将不会触发这些回调函数.
            用户自己必须额外调用这些回调函数.可以使用的是回调函数队列类对象的callAvailable()方法和callOne()方法
        应用:
        将不同的回调函数分别压进不同的回调函数队列有下面几个优势:
        1)长时服务:对一个服务的回调函数安排一个单独的队列,然后单独地使用一个线程来调用它,可以保证不会阻塞其它回调函数
        2)计算消耗回调函数:与长时服务相似,为一个费计算时间的回调函数安排一个单独的回调队列处理,能够减轻应用的负担.


<think>在ROS中,控制回调函数的频率通常有两种方法: 1. 使用ros::Rate在循环中控制频率,但这种方法通常用于主循环,而不是直接用于回调函数。 2. 使用ROS的时间器(timer)来定时调用回调函数,这是控制回调函数频率的推荐方法。 具体来说,我们可以创建一个定时器(timer),设置其触发频率,然后将需要定时执行的回调函数与该定时器绑定。这样,ROS就会按照指定的频率调用该回调函数。 下面是一个简单的示例,展示如何使用ROS的定时器来控制回调函数的执行频率。 假设我们有一个节点,需要以10Hz的频率执行某个任务(即每秒10次)。 ```cpp #include <ros/ros.h> void timerCallback(const ros::TimerEvent& event) { // 这里写定时执行的代码 ROS_INFO("Timer callback triggered"); } int main(int argc, char **argv) { ros::init(argc, argv, "timer_example_node"); ros::NodeHandle nh; // 创建一个定时器,设置频率为10Hz(即每0.1秒触发一次) ros::Timer timer = nh.createTimer(ros::Duration(0.1), timerCallback); // 进入事件循环 ros::spin(); return 0; } ``` 解释: - 首先,我们包含必要的头文件。 - 定义了一个回调函数`timerCallback`,它将在定时器触发时被调用。参数`const ros::TimerEvent& event`包含了定时事件的信息,比如当前时间、上一次触发时间等(可以根据需要使用)。 - 在`main`函数中,初始化ROS节点。 - 使用`ros::NodeHandle`的`createTimer`方法创建一个定时器。第一个参数是触发的时间间隔(`ros::Duration`类型),这里设置为0.1秒(即10Hz)。第二个参数是回调函数。 - 最后,调用`ros::spin()`进入事件循环,等待并处理回调。 注意:定时器的频率设置是理想的频率,实际执行频率可能会因为系统负载、回调函数执行时间等因素而有所偏差。如果回调函数的执行时间超过了定时周期,那么下一次回调可能会被延迟,或者如果使用`ros::Timer`的选项,也可以设置是否一次性执行或自动重置等。 另外,`createTimer`还有其他参数,例如: - `oneshot`:如果为true,则定时器只触发一次;默认为false,即循环触发。 - `autostart`:如果为true(默认),定时器在创建后立即启动;如果为false,需要手动调用`timer.start()`来启动。 - `callback_queue`:指定回调队列,默认为全局队列。 例如,创建一个只触发一次的定时器: ```cpp ros::Timer timer = nh.createTimer(ros::Duration(1.0), timerCallback, true); ``` 在Python中,也可以使用类似的定时器机制。以下是一个Python版本的示例: ```python #!/usr/bin/env python import rospy def timer_callback(event): rospy.loginfo("Timer callback triggered at %s", event.current_real) if __name__ == '__main__': rospy.init_node('timer_example_py') # 创建定时器,每0.1秒(10Hz)触发一次 timer = rospy.Timer(rospy.Duration(0.1), timer_callback) rospy.spin() ``` 在Python中,使用`rospy.Timer`类来创建定时器。第一个参数是时间间隔(`rospy.Duration`),第二个参数是回调函数。同样,使用`rospy.spin()`保持节点运行。 注意事项: - 在回调函数中,避免执行耗时操作,以免影响定时器的准确性。 - 如果需要停止定时器,可以在回调函数中调用`timer.stop()`(例如满足某个条件时)。在C++中,保存`ros::Timer`对象,然后调用`stop()`方法;在Python中,调用`timer.shutdown()`。 例如,在Python中,5秒后停止定时器: ```python def timer_callback(event): rospy.loginfo("Timer callback triggered") if event.last_real is not None and event.current_real - event.last_real >= rospy.Duration(5): rospy.loginfo("Stopping timer") timer.shutdown() # 停止定时器 ``` 在C++中,可以在回调函数中停止定时器: ```cpp void timerCallback(const ros::TimerEvent& event) { static int count = 0; ROS_INFO("Timer callback triggered"); if (++count >= 50) // 假设触发50次后停止 { timer.stop(); ROS_INFO("Timer stopped."); } } ``` 注意:在C++中,`timer`对象需要在能够被回调函数访问到的地方定义(比如作为全局变量,或者通过类成员等方式)。 综上所述,使用ROS的定时器是控制回调函数频率的标准方法。 §§相关问题§§: 1. ROS中如何创建一次性定时器? 2. 如果回调函数的执行时间超过了定时周期,会发生什么? 3. 如何在ROS中实现多个定时器? 4. 在ROS Python节点中,如何动态改变定时器的触发频率?</think>在ROS中控制回调函数的频率通常有两种方法:使用`ros::Rate`在循环中控制处理频率,或使用`ros::Timer`创建定时回调。以下是两种方法的详细实现解释: ### 方法1:使用`ros::Timer`(推荐) 这是ROS推荐的方式,通过创建定时器精确控制回调函数的执行频率。 ```cpp #include <ros/ros.h> void timerCallback(const ros::TimerEvent& event) { // 这里写需要周期性执行的代码 ROS_INFO_STREAM("Timer triggered at: " << event.current_real); } int main(int argc, char** argv) { ros::init(argc, argv, "timer_node"); ros::NodeHandle nh; // 创建定时器(10Hz = 每秒10次) ros::Timer timer = nh.createTimer( ros::Duration(0.1), // 时间间隔(秒) timerCallback, // 回调函数 false, // oneshot(是否只执行一次) true // autostart(是否自动启动) ); ros::spin(); return 0; } ``` **代码解释:** 1. `ros::Timer timer = nh.createTimer(...)` 创建定时器对象 2. `ros::Duration(0.1)` 设置执行间隔(0.1秒 = 10Hz) 3. `timerCallback` 是定时触发的回调函数 4. `TimerEvent` 参数包含时间信息(如当前时间、上次触发时间等) 5. `ros::spin()` 保持节点运行并处理回调 ### 方法2:使用`ros::Rate`在循环中控制 适用于需要在主循环中控制处理频率的场景。 ```cpp #include <ros/ros.h> int main(int argc, char** argv) { ros::init(argc, argv, "rate_control_node"); ros::NodeHandle nh; ros::Rate rate(10); // 10Hz频率控制 while (ros::ok()) { // 这里写需要周期性执行的代码 ROS_INFO_STREAM("Processing at: " << ros::Time::now()); // 处理回调队列 ros::spinOnce(); // 睡眠保持频率 rate.sleep(); } return 0; } ``` **代码解释:** 1. `ros::Rate rate(10)` 设置10Hz执行频率 2. `while (ros::ok())` 保持节点运行 3. `ros::spinOnce()` 处理所有待处理回调 4. `rate.sleep()` 自动计算并休眠以维持设定频率 ### 两种方法对比 | **特性** | `ros::Timer` | `ros::Rate` | |------------------|----------------------------------|------------------------------| | 执行机制 | 独立定时器线程 | 主循环手动控制 | | 精度 | 更高(系统级定时器) | 依赖循环执行时间 | | 回调类型 | 专用定时回调 | 需手动处理所有回调 | | 适用场景 | 精确周期任务 | 简单循环处理 | | 资源占用 | 较低(事件驱动) | 较高(持续循环) | ### 最佳实践建议 1. **精确计时**:对时间敏感的任务(如控制循环)使用`ros::Timer` 2. **简单任务**:数据处理等简单任务可用`ros::Rate` 3. **避免阻塞**:回调函数执行时间应小于定时周期 4. **时间同步**:需要时间同步时使用`TimerEvent`的时间戳 5. **动态调整**:可通过`timer.setPeriod()`动态改变频率
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值