rt_timer实际就是RTT中实现的一个软定时器。MCU底层做的多的人一般对硬件定时器都很熟悉，软件定时器反而不太熟悉。这里稍微介绍下软件定时器。
回忆一下硬件定时器，设置一个通用的硬件定时器，步骤如下：
配置定时器时钟。
初始化定时寄存器，前两步就是为了确定超时时间。
写定时器中断函数，确定时间到了之后执行的代码。
再之后就是开启或者关闭定时器了。
软件定时器其实也一样，只是这些全部由程序来执行，软件定时器的时钟节拍由软件周期性的产生，在RTOS中一般由心跳提供。通过软定时器初始化函数来设置超时时间以及超时回调函数（对应硬件定时器的中断函数）。
在RTT中，软件定时器又被分为纯软定时器以及普通定时器。纯软定时器中，定时器是由一个专门的线程来执行超时回调，该线程默认优先级为0（既最高）。普通定时器的时钟节拍由心跳中断来提供，超时回调也在硬件ISR中执行，心跳中断一般是一个硬件定时器的中断。
开启
#define RT_USING_TIMER_SOF
这个宏可以开启纯软定时器功能。
为了知道RTT如何实现这两种模式的软件定时器，先来看看rt_timer类
```struct rt_timer
{
struct rt_object parent; /*< inherit from rt_object /
rt_list_t row[RT_TIMER_SKIP_LIST_LEVEL];
void (*timeout_func)(void *parameter); /**< timeout function */
void *parameter; /**< timeout function's parameter */
rt_tick_t init_tick; /**< timer timeout tick */
rt_tick_t timeout_tick; /**< timeout tick */
};
typedef struct rt_timer *rt_timer_t;```
rt_timer的成员比较少，
1.parent，是object类的一个实例，说明rt_timer也继承自rt_object。
2.row[RT_TIMER_SKIP_LIST_LEVEL]，一个双向链表结构，用来把rt_timer加入各种链表中。RT_TIMER_SKIP_LIST_LEVEL被定义为1，暂时不清楚RT_TIMER_SKIP_LIST_LEVEL这个变量的作用。可能是为日后可以将timer加入更多的链表。
3.timeout_func，超时回调函数指针，指向定时器超时后执行的回调函数。
4.parameter，回调函数的参数指针，指向回调函数执行时输入的参数。
5.init_tick，超时周期。超时时间=超时周期*每个周期的时间
6.timeout_tick，超时剩余周期。每个周期，该变量会被减1，直到到达0，就会触发timeout回调函数。
只有6个成员，看来成员是真的少啊。接下来，还是一样，继续看看与rt_timer相关的函数。可以看见，rt_timer相关函数有很多都与rt_thread相同，如init，creat，delete，detach，
control等函数。
```void rt_system_tick_init(void);
rt_tick_t rt_tick_get(void);
void rt_tick_set(rt_tick_t tick);
void rt_tick_increase(void);
int rt_tick_from_millisecond(rt_int32_t ms);
void rt_system_timer_init(void);
void rt_system_timer_thread_init(void);
rt_tick_t rt_timer_next_timeout_tick(void);
void rt_timer_check(void);
void rt_timer_init(rt_timer_t timer,
const char name,
void (timeout)(void parameter),
void parameter,
rt_tick_t time,
rt_uint8_t flag);
rt_err_t rt_timer_detach(rt_timer_t timer);
rt_timer_t rt_timer_create(const char name,
void (timeout)(void parameter),
void parameter,
rt_tick_t time,
rt_uint8_t flag);
rt_err_t rt_timer_delete(rt_timer_t timer);
rt_err_t rt_timer_start(rt_timer_t timer);
rt_err_t rt_timer_stop(rt_timer_t timer);
rt_err_t rt_timer_control(rt_timer_t timer, int cmd, void *arg);```
一、rt_timer_init()和rt_timer_create()
还是一个规律，rt_timer_init是针对静态的rt_timer进行初始化，rt_timer_create是动态创建rt_timer，并进行初始化。
```rt_timer_t rt_timer_create(const char name,
void (timeout)(void parameter),
void parameter,
rt_tick_t time,
rt_uint8_t flag)
{
struct rt_timer *timer;
/* allocate a object */
timer = (struct rt_timer *)rt_object_allocate(RT_Object_Class_Timer, name);
if (timer == RT_NULL)
{
return RT_NULL;
}
_rt_timer_init(timer, timeout, parameter, time, flag);
return timer;
}```
两个函数最后都调用了_rt_timer_init()这个实际的初始化函数
这个函数做了以下一些操作：
1.设置flag，去掉RT_TIMER_FLAG_ACTIVATED的标志，rt_timer使用了基类object中的flag成员作为自己的标志位。主要有以下几种标志：
```#define RT_TIMER_FLAG_DEACTIVATED 0x0 /*< timer is deactive /
define RT_TIMER_FLAG_ACTIVATED 0x1 /*< timer is active /
define RT_TIMER_FLAG_ONE_SHOT 0x0 /*< one shot timer /
define RT_TIMER_FLAG_PERIODIC 0x2 /*< periodic timer /
define RT_TIMER_FLAG_HARD_TIMER 0x0 /*< hard timer,the timer’s callback function will be called in tick isr. /
define RT_TIMER_FLAG_SOFT_TIMER 0x4 /*< soft timer,the timer’s callback function will be called in timer thread. /```
可以看到有3个标志都是0x0，这点有点怪。
2.配置time_out回调函数，以及parameter参数
3.设置超时周期init_tick，并把timeout_tick置为0
4.初始化双向链表row
```static void _rt_timer_init(rt_timer_t timer,
void (timeout)(void parameter),
void *parameter,
rt_tick_t time,
rt_uint8_t flag)
{
int i;
/* set flag */
timer->parent.flag = flag;
/* set deactivated */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
timer->timeout_func = timeout;
timer->parameter = parameter;
timer->timeout_tick = 0;
timer->init_tick = time;
/* initialize timer list */
for (i = 0; i < RT_TIMER_SKIP_LIST_LEVEL; i++)
{
rt_list_init(&(timer->row*));
}
}```
二、rt_timer_detach()和rt_timer_delete()
同样的，这两个函数都是对rt_timer进行删除，rt_timer_detach()针对的是静态的。
主要执行以下操作：
1.参数检查
2.执行_rt_timer_remove()将rt_timer移除相应的timer队列。(ISR或软timer线程将不再执行它)
3.删除rt_timer(释放分配的内存，移出对象容器)
```rt_err_t rt_timer_delete(rt_timer_t timer)
{
register rt_base_t level;
/* timer check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(rt_object_get_type(&timer->parent) == RT_Object_Class_Timer);
RT_ASSERT(rt_object_is_systemobject(&timer->parent) == RT_FALSE);
/* disable interrupt */
level = rt_hw_interrupt_disable();
_rt_timer_remove(timer);
/* enable interrupt */
rt_hw_interrupt_enable(level);
rt_object_delete((rt_object_t)timer);
return RT_EOK;
}```
三、rt_timer_start()和rt_timer_stop()
从名字就可以看出这两个函数一个是启动定时器一个是停止定时器。先来看启动的代码，代码挺长的主要完成以下一些步骤：
1.参数检查
2.重置rt_timer(将timer移出当前队列，RT_TIMER_FLAG_ACTIVATED标志移除。
3.调用rt_object_take_hook钩子函数
4.设置timeout_tick。
5.将rt_timer加入到对应的定时器列表中（纯软定时器加入纯软队列，普通定时器加入普通队列）
这里详细解析下下面这段代码。
rt_list_entry是一个神奇的宏定义，这个宏定义我也看了很久，写的很复杂。。关于宏定义提一下，RTT中具有很多很神奇的宏定义，写的十分精彩，大大减小了代码的复杂度，可以说是很优雅了。
#define rt_container_of(ptr, type, member) \ ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))
总的来说rt_list_entry会通过成员地址返回包含该成员的实例的地址。一般使用方式是，ptr为类中rt_list_t成员的地址，type为类名，member为成员名
这段代码搜寻timer_list这个列表中的所有timer，当
else if ((t->timeout_tick - timer->timeout_tick) < RT_TICK_MAX / 2)
时停止，后面在这个位置，把当前timer加入列表。这条语句看似是一个相减小与 RT_TICK_MAX / 2的条件，其实真实的含义是t->timeout_tick - timer->timeout_tick>0，这里是利用的32位整型的表示方式，RT_TICK_MAX 为0xffffffff，在MCU中对于有符号的整型，最高为都是符号位，当两个数相减的时候实际是把减数按位取反+1再相加，所以其实只有一种情况t->timeout_tick - timer->timeout_tick>RT_TICK_MAX /2会成立，那就是为负数的时候。
综上，这个for循环，其实是在rt_timer列表中搜寻到了刚好超时时间大于启动的rt_timer的那个索引，作为之后rt_timer插入列表的位置。所以整个rt_timer的列表（软timer一个列表，普通timer一个列表），都是按照timeout_tick 这个参数的值进行排序的，是一个有序列表。
``` row_head[0] = &timer_list[0];
for (row_lvl = 0; row_lvl < RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
{
for (; row_head[row_lvl] != timer_list[row_lvl].prev;
row_head[row_lvl] = row_head[row_lvl]->next)
{
struct rt_timer t;
rt_list_t p = row_head[row_lvl]->next;
/* fix up the entry pointer */
t = rt_list_entry(p, struct rt_timer, row[row_lvl]);
/* If we have two timers that timeout at the same time, it's
* preferred that the timer inserted early get called early.
* So insert the new timer to the end the the some-timeout timer
* list.
*/
if ((t->timeout_tick - timer->timeout_tick) == 0)
{
continue;
}
else if ((t->timeout_tick - timer->timeout_tick) < RT_TICK_MAX / 2)
{
break;
}
}
if (row_lvl != RT_TIMER_SKIP_LIST_LEVEL - 1)
row_head[row_lvl + 1] = row_head[row_lvl] + 1;
}```
至于之后函数，功能其实是把一个完整的rt_timer列表拆分成几份，这样做的作用我也还没有看出来。。。
6.若启动的定时器为纯软的定时器，那么检测定时器线程是否启动，若未启动则重新启动线程。
```rt_err_t rt_timer_start(rt_timer_t timer)
{
unsigned int row_lvl;
rt_list_t timer_list;
register rt_base_t level;
rt_list_t row_head[RT_TIMER_SKIP_LIST_LEVEL];
unsigned int tst_nr;
static unsigned int random_nr;
/* timer check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(rt_object_get_type(&timer->parent) == RT_Object_Class_Timer);
/* stop timer firstly */
level = rt_hw_interrupt_disable();
/* remove timer from list */
_rt_timer_remove(timer);
/* change status of timer */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
rt_hw_interrupt_enable(level);
RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(timer->parent)));
/*
* get timeout tick,
* the max timeout tick shall not great than RT_TICK_MAX/2
*/
RT_ASSERT(timer->init_tick < RT_TICK_MAX / 2);
timer->timeout_tick = rt_tick_get() + timer->init_tick;
/* disable interrupt */
level = rt_hw_interrupt_disable();
ifdef RT_USING_TIMER_SOFT
if (timer->parent.flag & RT_TIMER_FLAG_SOFT_TIMER)
{
/* insert timer to soft timer list */
timer_list = rt_soft_timer_list;
}
else
endif
{
/* insert timer to system timer list */
timer_list = rt_timer_list;
}
row_head[0] = &timer_list[0];
for (row_lvl = 0; row_lvl < RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
{
for (; row_head[row_lvl] != timer_list[row_lvl].prev;
row_head[row_lvl] = row_head[row_lvl]->next)
{
struct rt_timer *t;
rt_list_t *p = row_head[row_lvl]->next;
/* fix up the entry pointer */
t = rt_list_entry(p, struct rt_timer, row[row_lvl]);
/* If we have two timers that timeout at the same time, it's
* preferred that the timer inserted early get called early.
* So insert the new timer to the end the the some-timeout timer
* list.
*/
if ((t->timeout_tick - timer->timeout_tick) == 0)
{
continue;
}
else if ((t->timeout_tick - timer->timeout_tick) < RT_TICK_MAX / 2)
{
break;
}
}
if (row_lvl != RT_TIMER_SKIP_LIST_LEVEL - 1)
row_head[row_lvl + 1] = row_head[row_lvl] + 1;
}
/* Interestingly, this super simple timer insert counter works very very
* well on distributing the list height uniformly. By means of "very very
* well", I mean it beats the randomness of timer->timeout_tick very easily
* (actually, the timeout_tick is not random and easy to be attacked). */
random_nr++;
tst_nr = random_nr;
rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - 1],
&(timer->row[RT_TIMER_SKIP_LIST_LEVEL - 1]));
for (row_lvl = 2; row_lvl <= RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
{
if (!(tst_nr & RT_TIMER_SKIP_LIST_MASK))
rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - row_lvl],
&(timer->row[RT_TIMER_SKIP_LIST_LEVEL - row_lvl]));
else
break;
/* Shift over the bits we have tested. Works well with 1 bit and 2
* bits. */
tst_nr >>= (RT_TIMER_SKIP_LIST_MASK + 1) >> 1;
}
timer->parent.flag |= RT_TIMER_FLAG_ACTIVATED;
/* enable interrupt */
rt_hw_interrupt_enable(level);
ifdef RT_USING_TIMER_SOFT
if (timer->parent.flag & RT_TIMER_FLAG_SOFT_TIMER)
{
/* check whether timer thread is ready */
if ((timer_thread.stat & RT_THREAD_STAT_MASK) != RT_THREAD_READY)
{
/* resume timer thread to check soft timer */
rt_thread_resume(&timer_thread);
rt_schedule();
}
}
endif
return RT_EOK;
}```
stop函数就相对来说简单了很多，主要就是：
1.参数检查
2.调用rt_object_put_hook钩子函数
3.将rt_timer移出列表。
```rt_err_t rt_timer_stop(rt_timer_t timer)
{
register rt_base_t level;
/* timer check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(rt_object_get_type(&timer->parent) == RT_Object_Class_Timer);
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();
_rt_timer_remove(timer);
/* enable interrupt */
rt_hw_interrupt_enable(level);
/* change stat */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
return RT_EOK;
}```
四、rt_timer_control()函数
改函数可以通过参数中的cmd来实现不同的功能，cmd总共有4中取值：
```#define RT_TIMER_CTRL_SET_TIME 0x0 /*< set timer control command /
define RT_TIMER_CTRL_GET_TIME 0x1 /*< get timer control command /
define RT_TIMER_CTRL_SET_ONESHOT 0x2 /*< change timer to one shot /
define RT_TIMER_CTRL_SET_PERIODIC 0x3 /*< change timer to periodic /```
分别对应：
设置定时器时间
获取定时器时间
设置定时器为单触发模式
设置定时器为周期性触发模式
当rt_timer被标记为周期性定时器后，当time_out回调触发后会执行start重新启动该定时器。
五、其他函数。
剩下的函数还有
（1）void rt_system_tick_init(void); （2）rt_tick_t rt_tick_get(void); （3）void rt_tick_set(rt_tick_t tick); （4）void rt_tick_increase(void); （5）int rt_tick_from_millisecond(rt_int32_t ms); （6）void rt_system_timer_init(void); （7）void rt_system_timer_thread_init(void); （8）rt_tick_t rt_timer_next_timeout_tick(void); （9）void rt_timer_check(void);
（1）是个空函数。
（2）返回系统tick数，这个数在系统启动后就随着心跳不断的增加。
（3）设置系统tick数
（4）
```void rt_tick_increase(void)
{
struct rt_thread *thread;
/* increase the global tick */
++ rt_tick;
/* check time slice */
thread = rt_thread_self();
-- thread->remaining_tick;
if (thread->remaining_tick == 0)
{
/* change to initialized tick */
thread->remaining_tick = thread->init_tick;
/* yield */
rt_thread_yield();
}
/* check timer */
rt_timer_check();
}```
函数会对rt_tick加1，并检查线程时间片时间是否过期，若过期，则调用rt_thread_yield()。这个函数在上一篇分析过。
之后会执行（9）rt_timer_check()函数
（5）是个工具函数，将ms数换算成tick数
（6）初始化普通定时器列表
（7）若开启了纯软定时器，启动定时器线程，纯软定时器的time_out回调将在这个线程中执行，该线程默认优先级为0
（8）返回下一个最近会到期的普通定时器的time_out值。
（9）
```void rt_timer_check(void)
{
struct rt_timer *t;
rt_tick_t current_tick;
register rt_base_t level;
RT_DEBUG_LOG(RT_DEBUG_TIMER, ("timer check enter
"));
current_tick = rt_tick_get();
/* disable interrupt */
level = rt_hw_interrupt_disable();
while (!rt_list_isempty(&rt_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1]))
{
t = rt_list_entry(rt_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1].next,
struct rt_timer, row[RT_TIMER_SKIP_LIST_LEVEL - 1]);
/*
* 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));
/* remove timer from timer list firstly */
_rt_timer_remove(t);
/* 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
", 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);
}
else
{
/* stop timer */
t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
}
}
else
break;
}
/* enable interrupt */
rt_hw_interrupt_enable(level);
RT_DEBUG_LOG(RT_DEBUG_TIMER, ("timer check leave
"));
}```
该函数在ISR中执行，检测是否有普通定时器到期，对于到期的定时器先执行time_out回调，并判断是否是周期定时器，若是周期定时器，重新启动这个定时器。
那么对于rt_timer的解读就这么多，篇幅感觉越来越长呀。。
原作者：yushigengyu
