rt-thread的定时器管理源码分析

1 前言

rt-thread可以采用软件定时器或硬件定时器来实现定时器管理的，所谓软件定时器是指由操作系统提供的一类系统接口，它构建在硬件定时器基础之上，使系统能够提供不受数目限制的定时器服务。而硬件定时器是芯片本身提供的定时功能。一般是由外部晶振提供给芯片输入时钟，芯片向软件模块提供一组配置寄存器，接受控制输入，到达设定时间值后芯片中断控制器产生时钟中断。硬件定时器的精度一般很高，可以达到纳秒级别，并且是中断触发方式。软件定时器的精度取决于它使用的硬件定时器精度。而rt-thread操作系统在默认情况下是采用的硬件定时器的方式，用户可以通过修改宏定义#ifdef RT_USING_TIMER_SOFT来修改采用哪种。

2 rt-thread的定时器的基本工作原理

在RT-Thread定时器模块维护两个重要的全局变量，一个是当前系统的时间rt_tick（当硬件定时器中断来临时，它将加1），另一个是定时器链表rt_timer_list，系统中新创建的定时期都会被以排序的方式插入到rt_timer_list(硬件定时器模式下使用)链表中,rt_timer_list的每个节点保留了一个定时器的信息，并且在这个节点加入链表时就计算好了产生时间到达时的时间点，即tick,在rt-thread系统中如果采用软件定时器模式，则存在一定时器线程rt_thread_timer_entry，不断获取当前TICK值并与定时器链表rt_timer_list上的定时器对比判断是否时间已到，一旦发现就调用对应的回调函数，即事件处理函数进行处理，而如果采用硬件定时器管理模式的话，则该检查过程放到系统时钟中断例程中进行处理，此时，是不存在定时器线程的。如下图：注：如果采用软件定时器软件定时器，则该定时器链表为rt_soft_timer_list。

 

3 源码分析

3.1 数据定义

/** * timer structure */ struct rt_timer { struct rt_object parent; //内核对象
rt_list_t list; //链表节点
void (*timeout_func)(void *parameter); //定时器超时例程 void *parameter; //定时器例程的传入参数
rt_tick_t init_tick; //定时器的超时时间,即总共多长时间将产生超时事件 rt_tick_t timeout_tick; //定时器超时的时间点，即产生超时事件时那一该的时间点 }; typedef struct rt_timer *rt_timer_t;

1. 
   

3.2 rt-thread的软件定时器模式

软件定时器线程初始化及启动:

 ​

1. 1. 
      
2. /**
3. * @ingroup SystemInit
4. *
5. * This function will initialize system timer thread
6. */
7. void rt_system_timer_thread_init(void)
8. {
9. #ifdef RT_USING_TIMER_SOFT//如果采用软件定时器管理模式，则启动定时器线程
10. rt_list_init(&rt_soft_timer_list);//初始化软件定时器链表
11. 
    
12. /* start software timer thread */
13. rt_thread_init(&timer_thread,//初始化软件定时器线程，并启动
14. "timer",
15. rt_thread_timer_entry,
16. RT_NULL,
17. &timer_thread_stack[0],
18. sizeof(timer_thread_stack),
19. RT_TIMER_THREAD_PRIO,
20. 10);
21. 
    
22. /* startup */
23. rt_thread_startup(&timer_thread);
24. #endif
25. }
    1. 
       

软件定时器线程如下：

 ​

1. 1. 
      
2. /* system timer thread entry */
3. static void rt_thread_timer_entry(void *parameter)
4. {
5. rt_tick_t next_timeout;
6. 
   
7. while (1)
8. {
9. /* get the next timeout tick */
10. next_timeout = rt_timer_list_next_timeout(&rt_soft_timer_list);//得到软件定时器链表上的下一个定时器的超时时间点
11. if (next_timeout == RT_TICK_MAX)//如果超过范围，则挂起当前线程，继续线程调度
12. {
13. /* no software timer exist, suspend self. */
14. rt_thread_suspend(rt_thread_self());
15. rt_schedule();
16. }
17. else
18. {
19. rt_tick_t current_tick;
20. 
    
21. /* get current tick */
22. current_tick = rt_tick_get();//获取当前时间点
23. 
    
24. if ((next_timeout - current_tick) < RT_TICK_MAX/2)//离下个中断时间点还差些时候
25. {
26. /* get the delta timeout tick */
27. next_timeout = next_timeout - current_tick;//计算还差多长时间
28. rt_thread_delay(next_timeout);//休眠一段时间
29. }
30. }
31. 
    
32. /* lock scheduler */
33. rt_enter_critical();//时间到，进入临界区
34. /* check software timer */
35. rt_soft_timer_check();//检查是否该产生超时事件
36. /* unlock scheduler */
37. rt_exit_critical();//退出临界区
38. }
39. }
    1. 
       

检查是否产生中断函数rt_soft_timer_check函数如下定义:

/** * This function will check timer list, if a timeout event happens, the * corresponding timeout function will be invoked. */ void rt_soft_timer_check(void) { rt_tick_t current_tick; rt_list_t *n; struct rt_timer *t;
RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check enter\n"));
current_tick = rt_tick_get();//得到当前时间点
for (n = rt_soft_timer_list.next; n != &(rt_soft_timer_list);)//得到下一定时器节点 { t = rt_list_entry(n, struct rt_timer, list);//t指向rt_timer定时器
/* * It supposes that the new tick shall less than the half duration of * tick max. */ if ((current_tick - t->timeout_tick) < RT_TICK_MAX / 2)//如果当前的时间点超过定时器的超时时间点 { RT_OBJECT_HOOK_CALL(rt_timer_timeout_hook, (t));//使用钩子函数
/* move node to the next */ n = n->next;//指向下一定时器
/* remove timer from timer list firstly */ rt_list_remove(&(t->list));//移除当前定时器
/* call timeout function */ t->timeout_func(t->parameter);//产生定时器超时事件，调用对应处理函数
/* re-get tick */ current_tick = rt_tick_get();//再次获取当前时间点
RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d\n", current_tick));
if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&//如果当前定时器是周期性定时器，则将其再次按序放入软件定时器链表 (t->parent.flag & RT_TIMER_FLAG_ACTIVATED)) { /* start it */ t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//置标志为非激活状态 rt_timer_start(t);//再次将定时器t放入软件定时器链表末尾 } else { /* stop timer */ t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//置标志为非激活状态 } } else break; /* not check anymore */ }
RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check leave\n")); }

1. 
   

上面代码中，为什么定时器里判断超时的条件是((current_tick - t→timeout_tick) < RT_TICK_MAX/2)？

因为系统时钟溢出后会自动回绕。取定时器比较最大值是定时器最大值的一半，即RT_TICK_MAX/2（在比较两个定时器值时，值是32位无符号数，相减运算将会自动回绕）。系统支持的定时器最大长度就是RT_TICK_MAX的一半：即248天(10ms/tick)，124天(5ms/tick)，24.5天(1ms/tick)，以下内容相同道理。

其上rt_timer_start函数如下定义:

 ​

1. 1. 
      
2. /**
3. * This function will start the timer
4. *
5. * @param timer the timer to be started
6. *
7. * @return the operation status, RT_EOK on OK, -RT_ERROR on error
8. */
9. rt_err_t rt_timer_start(rt_timer_t timer)
10. {
11. struct rt_timer *t;
12. register rt_base_t level;
13. rt_list_t *n, *timer_list;
14. 
    
15. /* timer check */
16. RT_ASSERT(timer != RT_NULL);
17. if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED)//如果传入的定时器已经激活，则直接返回错误
18. return -RT_ERROR;
19. 
    
20. RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(timer->parent)));//使用钩子函数
21. 
    
22. /*
23. * get timeout tick,
24. * the max timeout tick shall not great than RT_TICK_MAX/2
25. */
26. RT_ASSERT(timer->init_tick < RT_TICK_MAX / 2);
27. timer->timeout_tick = rt_tick_get() + timer->init_tick;//得到定时器超时的时间点
28. 
    
29. /* disable interrupt */
30. level = rt_hw_interrupt_disable();//关中断
31. 
    
32. #ifdef RT_USING_TIMER_SOFT//如果采用的是软件定时器管理模式，则将定时器加入到rt_soft_timer_list中
33. if (timer->parent.flag & RT_TIMER_FLAG_SOFT_TIMER)
34. {
35. /* insert timer to soft timer list */
36. timer_list = &rt_soft_timer_list;
37. }
38. else
39. #endif
40. {
41. /* insert timer to system timer list */
42. timer_list = &rt_timer_list;
43. }
44. 
    
45. for (n = timer_list->next; n != timer_list; n = n->next)//将定时器按序加入到定时器链表中
46. {
47. t = rt_list_entry(n, struct rt_timer, list);
48. 
    
49. /*
50. * It supposes that the new tick shall less than the half duration of
51. * tick max.
52. */
53. if ((t->timeout_tick - timer->timeout_tick) < RT_TICK_MAX / 2)
54. {
55. rt_list_insert_before(n, &(timer->list));//将定时器timer插入到t之前
56. break;
57. }
58. }
59. /* no found suitable position in timer list */
60. if (n == timer_list)//没有找到合适的位置，则放到链表头
61. {
62. rt_list_insert_before(n, &(timer->list));
63. }
64. 
    
65. timer->parent.flag |= RT_TIMER_FLAG_ACTIVATED;//置定时器为激活状态
66. 
    
67. /* enable interrupt */
68. rt_hw_interrupt_enable(level);
69. 
    
70. #ifdef RT_USING_TIMER_SOFT
71. if (timer->parent.flag & RT_TIMER_FLAG_SOFT_TIMER)//如果系统采用的是软件定时器管理模式，且软件定时器线程处理ready状态，则恢复此线程
72. {
73. /* check whether timer thread is ready */
74. if (timer_thread.stat != RT_THREAD_READY)
75. {
76. /* resume timer thread to check soft timer */
77. rt_thread_resume(&timer_thread);//恢复定时器线程
78. rt_schedule();//开始线程调度
79. }
80. }
81. #endif
82. 
    
83. return -RT_EOK;
84. }
    1. 
       

软件定时器管理模式的源码分析完了，接下来介绍RTT的硬件定时器管理模式。

3.3 RTT的硬件定时器管理模式

硬件定时器管理模式顾名思义，就是说与硬件相关，因此，不用的MCU，其部分源码是不一样的，因为其要采用MCU的系统时钟中断例程来实现。

以STM32F2XX为例，先找到其启动汇编，位置在：RTT/bsp/stm32f2xx/Libraries/CMSIS/CM3/DeviceSupport/ST/STM32F2xx/startup/arm/startup_stm32f2xx.s

找到中断向量:

 ​

1. 1. 
      
2. DCD SysTick_Handler ; SysTick Handler
   1. 
      

这是系统时钟中断向量，再找到其中断例程实现：

在bsp/stm32f2xx/drivers/board.c文件中:

 

1. /**
2. * This is the timer interrupt service routine.
3. *
4. */
5. void SysTick_Handler(void)//系统时钟中断例程
6. {
7. /* enter interrupt */
8. rt_interrupt_enter();
9. 
   
10. rt_tick_increase();
11. 
    
12. /* leave interrupt */
13. rt_interrupt_leave();
14. }
    1. 
       

其中rt_tick_increase函数在RTT/src/clock.c文件中的实现如下:

 ​

1. 1. 
      
2. /**
3. * This function will notify kernel there is one tick passed. Normally,
4. * this function is invoked by clock ISR.
5. */
6. void rt_tick_increase(void)
7. {
8. struct rt_thread *thread;
9. 
   
10. /* increase the global tick */
11. ++ rt_tick;//全局rt_tick加1
12. 
    
13. /* check time slice */
14. thread = rt_thread_self();//得到当前正在运行的线程
15. 
    
16. -- thread->remaining_tick;//纯种剩下时间减1
17. if (thread->remaining_tick == 0)//如果线程剩余时间为0，即调度时间已到
18. {
19. /* change to initialized tick */
20. thread->remaining_tick = thread->init_tick;//将线程剩余时间重新设置初始化值
21. 
    
22. /* yield */
23. rt_thread_yield();//调度时间到，切换到其它线程
24. }
25. 
    
26. /* check timer */
27. rt_timer_check();//检查硬件定时器链表是否有定时器产生超时事件
28. }
    1. 
       

其中rt_timer_check函数在RTT/src/timer.c文件中如下定义:

 ​

1. 1. 
      
2. /**
3. * This function will check timer list, if a timeout event happens, the
4. * corresponding timeout function will be invoked.
5. *
6. * @note this function shall be invoked in operating system timer interrupt.
7. */
8. void rt_timer_check(void)
9. {
10. struct rt_timer *t;
11. rt_tick_t current_tick;
12. register rt_base_t level;
13. 
    
14. RT_DEBUG_LOG(RT_DEBUG_TIMER, ("timer check enter\n"));
15. 
    
16. current_tick = rt_tick_get();
17. 
    
18. /* disable interrupt */
19. level = rt_hw_interrupt_disable();
20. 
    
21. while (!rt_list_isempty(&rt_timer_list))
22. {
23. t = rt_list_entry(rt_timer_list.next, struct rt_timer, list);
24. 
    
25. /*
26. * It supposes that the new tick shall less than the half duration of
27. * tick max.
28. */
29. if ((current_tick - t->timeout_tick) < RT_TICK_MAX/2)
30. {
31. RT_OBJECT_HOOK_CALL(rt_timer_timeout_hook, (t));
32. 
    
33. /* remove timer from timer list firstly */
34. rt_list_remove(&(t->list));
35. 
    
36. /* call timeout function */
37. t->timeout_func(t->parameter);
38. 
    
39. /* re-get tick */
40. current_tick = rt_tick_get();
41. 
    
42. RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d\n", current_tick));
43. 
    
44. if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&
45. (t->parent.flag & RT_TIMER_FLAG_ACTIVATED))
46. {
47. /* start it */
48. t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
49. rt_timer_start(t);
50. }
51. else
52. {
53. /* stop timer */
54. t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
55. }
56. }
57. else
58. break;
59. }
60. 
    
61. /* enable interrupt */
62. rt_hw_interrupt_enable(level);
63. 
    
64. RT_DEBUG_LOG(RT_DEBUG_TIMER, ("timer check leave\n"));
65. }
    1. 
       

此函数与rt_soft_timer_check基本大致相同，只不过一个是查找硬件定时器链表rt_timer_list，一个是查找rt_soft_timer_list.

在此，硬件定时器管理模式基本上介绍完毕，接下来介绍一些定时器接口.

4 定时器接口

4.1 定时器初始化

静态初始化定义器

 ​

1. 1. 
      
2. /**
3. * This function will initialize a timer, normally this function is used to
4. * initialize a static timer object.
5. *
6. * @param timer the static timer object
7. * @param name the name of timer
8. * @param timeout the timeout function
9. * @param parameter the parameter of timeout function
10. * @param time the tick of timer
11. * @param flag the flag of timer
12. */
13. void rt_timer_init(rt_timer_t timer,
14. const char *name,
15. void (*timeout)(void *parameter),
16. void *parameter,
17. rt_tick_t time,
18. rt_uint8_t flag)
19. {
20. /* timer check */
21. RT_ASSERT(timer != RT_NULL);
22. 
    
23. /* timer object initialization */
24. rt_object_init((rt_object_t)timer, RT_Object_Class_Timer, name);//初始化内核对象
25. 
    
26. _rt_timer_init(timer, timeout, parameter, time, flag);
27. }
    1. 
       

_rt_timer_init函数如下定义:

 ​

1. 1. 
      
2. static void _rt_timer_init(rt_timer_t timer,
3. void (*timeout)(void *parameter),
4. void *parameter,
5. rt_tick_t time,
6. rt_uint8_t flag)
7. {
8. /* set flag */
9. timer->parent.flag = flag;//置flag
10. 
    
11. /* set deactivated */
12. timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//初始化时，设置为非激活状态
13. 
    
14. timer->timeout_func = timeout;//设置超时事件处理函数
15. timer->parameter = parameter;//超时事件处理函数的传入参数
16. 
    
17. timer->timeout_tick = 0;//定时器的超时时间点初始化时为0
18. timer->init_tick = time;//置超时时间
19. 
    
20. /* initialize timer list */
21. rt_list_init(&(timer->list));//初始化本身节点
22. }
    1. 
       

动态创建定时器

 

1. /**
2. * This function will create a timer
3. *
4. * @param name the name of timer
5. * @param timeout the timeout function
6. * @param parameter the parameter of timeout function
7. * @param time the tick of timer
8. * @param flag the flag of timer
9. *
10. * @return the created timer object
11. */
12. rt_timer_t rt_timer_create(const char *name,
13. void (*timeout)(void *parameter),
14. void *parameter,
15. rt_tick_t time,
16. rt_uint8_t flag)
17. {
18. struct rt_timer *timer;
19. 
    
20. /* allocate a object */
21. timer = (struct rt_timer *)rt_object_allocate(RT_Object_Class_Timer, name);//动态分配定时器内核对象
22. if (timer == RT_NULL)
23. {
24. return RT_NULL;
25. }
26. 
    
27. _rt_timer_init(timer, timeout, parameter, time, flag);//调用上述的初始化接口
28. 
    
29. return timer;
30. }
    1. 
       

4.2 脱离和删除

脱离:

 ​

1. 1. 
      
2. /**
3. * This function will detach a timer from timer management.
4. *
5. * @param timer the static timer object
6. *
7. * @return the operation status, RT_EOK on OK; RT_ERROR on error
8. */
9. rt_err_t rt_timer_detach(rt_timer_t timer)
10. {
11. register rt_base_t level;
12. 
    
13. /* timer check */
14. RT_ASSERT(timer != RT_NULL);
15. 
    
16. /* disable interrupt */
17. level = rt_hw_interrupt_disable();//关中断
18. 
    
19. /* remove it from timer list */
20. rt_list_remove(&(timer->list));//从定时器链表中移除
21. 
    
22. /* enable interrupt */
23. rt_hw_interrupt_enable(level);//开中断
24. 
    
25. rt_object_detach((rt_object_t)timer);//脱离内核对象
26. 
    
27. return -RT_EOK;
28. }
    1. 
       

删除动态创建的定时器

/** * This function will delete a timer and release timer memory * * @param timer the timer to be deleted * * @return the operation status, RT_EOK on OK; RT_ERROR on error */ rt_err_t rt_timer_delete(rt_timer_t timer) { register rt_base_t level;
/* timer check */ RT_ASSERT(timer != RT_NULL);
/* disable interrupt */ level = rt_hw_interrupt_disable();//关中断
/* remove it from timer list */ rt_list_remove(&(timer->list));//从定时器链表中移除
/* enable interrupt */ rt_hw_interrupt_enable(level);//开中断
rt_object_delete((rt_object_t)timer);//删除动态创建的定时器内核对象
return -RT_EOK; }

1. 
   

4.3 启动定时器

/** * This function will start the timer * * @param timer the timer to be started * * @return the operation status, RT_EOK on OK, -RT_ERROR on error */ rt_err_t rt_timer_start(rt_timer_t timer)

1. 
   

此接口已在上面介绍软件定时器模式时已有分析，这里就不再重复了。

4.4 停止定时器

/** * This function will stop the timer * * @param timer the timer to be stopped * * @return the operation status, RT_EOK on OK, -RT_ERROR on error */ rt_err_t rt_timer_stop(rt_timer_t timer) { register rt_base_t level;
/* timer check */ RT_ASSERT(timer != RT_NULL); if (!(timer->parent.flag & RT_TIMER_FLAG_ACTIVATED))//如果定时器已经为非激活状态 return -RT_ERROR;
RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(timer->parent)));//使用钩子函数
/* disable interrupt */ level = rt_hw_interrupt_disable();//关中断
/* remove it from timer list */ rt_list_remove(&(timer->list));//从定时器链表中移除
/* enable interrupt */ rt_hw_interrupt_enable(level);//开中断
/* change stat */ timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//置非激活状态
return RT_EOK; }

1. 
   

4.5 控制

此接口是用来修改一个定时器的参数，如下代码：

 

1. /**
2. * This function will get or set some options of the timer
3. *
4. * @param timer the timer to be get or set
5. * @param cmd the control command
6. * @param arg the argument
7. *
8. * @return RT_EOK
9. */
10. rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void *arg)
11. {
12. /* timer check */
13. RT_ASSERT(timer != RT_NULL);
14. 
    
15. switch (cmd)
16. {
17. case RT_TIMER_CTRL_GET_TIME://获取时间参数
18. *(rt_tick_t *)arg = timer->init_tick;
19. break;
20. 
    
21. case RT_TIMER_CTRL_SET_TIME://修改时间参数
22. timer->init_tick = *(rt_tick_t *)arg;
23. break;
24. 
    
25. case RT_TIMER_CTRL_SET_ONESHOT://修改定时器模式为单次触发定时器
26. timer->parent.flag &= ~RT_TIMER_FLAG_PERIODIC;
27. break;
28. 
    
29. case RT_TIMER_CTRL_SET_PERIODIC://修改定时器为周期触发定时器
30. timer->parent.flag |= RT_TIMER_FLAG_PERIODIC;
31. break;
32. }
33. 
    
34. return RT_EOK;
35. }
    1.