Rt-thread源码剖析(2)——时钟与定时器

前言

        时钟是所有系统工作的心脏，单片机有自己的主频，每一步逻辑算术运算都发生在时钟信号的翻转时刻；RTOS自然也有自己的时钟系统，本文着眼于RTT的系统时钟以及定时器两个方向对RTT的内核进行阐述

系统时钟

        RTOS的时钟是线程运行的最小时间片，也是系统调度发生的最小单位，接下来我们依次来看OS tick从哪来，怎么起作用

系统时钟的源头

        在rtt_port.c内，MCU厂商会在此通过自己的硬件时钟（mchtimer）设置一个周期性的中断，在这个硬件中断中，调用 rt_tick_increase()接口，实现tick的自增

        

        需要注意的是，RT_TICK_PER_SECOND是定义在rtconfig.h中的一个常量，因此，在这个硬件中断中，你需要根据自身MCU的主频来设置相应的中断触发间隔。

时钟增长做了什么

        在硬件时钟的中断中，除了将下一次中断触发的时间设置成一个预期的时间点，其他只调用了rt_tick_increase();我们看一下他做了什么

void rt_tick_increase(void) { struct rt_thread *thread; rt_base_t level; RT_OBJECT_HOOK_CALL(rt_tick_hook, ()); level = rt_hw_interrupt_disable(); /* increase the global tick */ #ifdef RT_USING_SMP rt_cpu_self()->tick ++; #else ++ rt_tick; #endif /* RT_USING_SMP */ /* 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; thread->stat |= RT_THREAD_STAT_YIELD; rt_hw_interrupt_enable(level); rt_schedule(); } else { rt_hw_interrupt_enable(level); } /* check timer */ rt_timer_check(); }

概括来说，当OS tick增长时，会依次进行以下操作：

        1.如果你注册了tick hook，那么会自动执行

        2.禁用全局中断

        3.全局变量rt_tick自增

        4.获取当前运行线程的句柄，将其剩余时间减少一个tick

        5.如果当前运行线程剩余时间为0，则打开全局中断，进行一次线程调度

        6.打开全局中断

        7.检查是否有定时器超时

关于线程调度的详细内容，会展其他文章内进行展开，接下来着重讲一下第7点，与定时器有关的内容

定时器 定时器结构体

        首先我们来看下timer struct的源码，结构体的成员就是创建时需要传入的参数

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_object parent，该成员就是本系列第一篇文章中提到的内核成员的公共部分，在此不再展开

        其次需要传入超时回调函数，回调函数所需的参数以及超时时间

这里展开一下row[RT_TIMER_SKIP_LIST_LEVEL];

        定时器在创建成功后进入定时队列时，是进入一个按照剩余时间排序的链表，而该链表是支持调表的。因此，如果你将RT_TIMER_SKIP_LIST_LEVEL定义为1，那么就意味着不使用跳表，定义为n，就代表有n层跳表

定时器创建

        定时器的创建分为动态和静态，这一部分是和内核容器对象完全一致的，动态和静态创建最终调用的都是_rt_timer_init

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[i])); } }

这里值得说的有以下两点：

1.定时器在创建后的标志位是deactivated的，需要start后才会被激活

2.定时器的timeout_tick初始化成了0，也就是如果你设置了500个tick后超时，是从start开始计时的，而非创建后

定时器启动

定时器启动的源码非常多，因此先贴上代码大概做了什么的流程，然后再附上源码

rt_timer_start 其主要功能包括：

参数检查：确认传入的定时器指针 timer 非空，并且其对象类型为 RT_Object_Class_Timer。

停止定时器：在启动前，先停止定时器，也就是说调用两次接口会重置超时时间

计算超时时间：设置定时器的超时时刻 timeout_tick 为当前系统时钟加上定时器的初始计时时间 init_tick。

选择定时器列表：根据定时器类型（硬件或软件），选择相应的定时器列表，下文会展开

插入定时器：将定时器按照超时时间插入到定时器列表的适当位置，按超时时间排序

激活定时器：标记定时器为激活状态，并在必要时唤醒软件定时器处理线程。

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_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; #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 ((soft_timer_status == RT_SOFT_TIMER_IDLE) && ((timer_thread.stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND)) { /* resume timer thread to check soft timer */ rt_thread_resume(&timer_thread); rt_schedule(); } } #endif return RT_EOK; } 硬件定时和软件定时

        这里首先要明确的是，这个概念基于定时器超时的回调函数运行环境来区分的，在OS tick自增的中断中，会调用rt_timer_check();该运行环境处于中断，因此如果是此时运行的定时器，成为硬件定时器；

        而如果开启了软件定时的宏，则会在系统启动过程中，开启一个timer_thread，他的优先级由RT_TIMER_THREAD_PRIO定义，一般需要选择一个较高的优先级，确保定时器超时后能第一时间执行，这样的定时器则成为软件定时器。

        rt_soft_timer_check和rt_timer_check逻辑几乎一致，软件定时多了一个线程更加复杂，因此以软件定时举例

软件定时线程入口

        软件定时器的线程入口函数如下：

/* system timer thread entry */ static void rt_thread_timer_entry(void *parameter) { rt_tick_t next_timeout; while (1) { /* get the next timeout tick */ next_timeout = rt_timer_list_next_timeout(rt_soft_timer_list); if (next_timeout == RT_TICK_MAX) { /* no software timer exist, suspend self. */ rt_thread_suspend(rt_thread_self()); rt_schedule(); } else { rt_tick_t current_tick; /* get current tick */ current_tick = rt_tick_get(); if ((next_timeout - current_tick) < RT_TICK_MAX / 2) { /* get the delta timeout tick */ next_timeout = next_timeout - current_tick; rt_thread_delay(next_timeout); } } /* check software timer */ rt_soft_timer_check(); } }

         首先，在线程运行时，如果定时器队列为空，则会将自己挂起并释放CPU；如果定时器队列非空，则会看一下当前队列中下一个超时的定时器还有多久，比如说还有100个tick，则他将自己挂起100个tick，最后进入定时器处理

        这里不必担心如果这100个tick内如果有新创建的定时器，如果超时时间更短会来不及调度，因为timer在start的时候，会唤醒timer_thread

timer_check

rt_soft_timer_check函数用于检查并处理软件定时器的超时事件。以下是该函数的主要步骤：

初始化临时列表：创建并初始化一个临时列表list，用于暂存已超时的定时器，这个列表是用于存放当前正在被处理的定时器的，如果在定时器超时函数执行完毕后，该列表为空，证明在其他线程里已经删除了这个定时器，即使它是周期定时器，也不应该再次启动

禁用中断：调用rt_hw_interrupt_disable函数，禁用中断以确保在操作定时器列表时的原子性。

遍历定时器列表：循环检查软件定时器跳表的最高层级（即rt_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1]）中的定时器。

获取当前时间：调用rt_tick_get函数，获取当前的系统节拍计数current_tick。

判断定时器是否超时：比较当前时间current_tick与定时器的超时时间t->timeout_tick。如果当前时间未达到超时时间，退出循环。

处理超时定时器：对于已超时的定时器，执行以下操作：

调用钩子函数：如果定义了rt_timer_enter_hook，则调用该钩子函数，表示定时器即将触发。

从定时器列表中移除：调用_rt_timer_remove函数，将定时器从定时器列表中移除。

检查定时器类型：如果定时器是非周期性的（即单次定时器），清除其激活标志RT_TIMER_FLAG_ACTIVATED。

加入临时列表：将该定时器插入到临时列表list中，以便稍后处理。

设置定时器状态：将软定时器状态soft_timer_status设置为RT_SOFT_TIMER_BUSY，表示定时器正在处理。

启用中断：在调用定时器的超时回调函数之前，先启用中断，以允许其他中断或任务的执行。

调用超时回调函数：执行定时器的超时回调函数t->timeout_func，并传递参数t->parameter。

调用退出钩子函数：如果定义了rt_timer_exit_hook，则在回调函数执行完毕后调用，表示定时器处理完成。

禁用中断：回调函数执行完毕后，重新禁用中断，以继续安全地操作定时器列表。

重置定时器状态：将软定时器状态soft_timer_status设置为RT_SOFT_TIMER_IDLE，表示定时器处理空闲。

检查定时器状态：如果定时器未被重新启动且为非周期性定时器，则从临时列表中移除。

重新启动周期性定时器：如果定时器是周期性的且仍处于激活状态，调用rt_timer_start函数重新启动定时器。

启用中断：在处理完所有超时定时器后，调用rt_hw_interrupt_enable函数，重新启用中断

细节：

1.遍历timer链表时，需关闭全局中断；但进行定时器超时回调函数时，允许中断

2.在进行定时器超时回调时，该定时器已经有可能被其他线程删除了，所以需要临时列表来暂存他

源码如下

void rt_soft_timer_check(void) { rt_tick_t current_tick; struct rt_timer *t; register rt_base_t level; rt_list_t list; rt_list_init(&list); RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check enter\n")); /* disable interrupt */ level = rt_hw_interrupt_disable(); while (!rt_list_isempty(&rt_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1])) { t = rt_list_entry(rt_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1].next, struct rt_timer, row[RT_TIMER_SKIP_LIST_LEVEL - 1]); current_tick = rt_tick_get(); /* * 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_enter_hook, (t)); /* remove timer from timer list firstly */ _rt_timer_remove(t); if (!(t->parent.flag & RT_TIMER_FLAG_PERIODIC)) { t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED; } /* add timer to temporary list */ rt_list_insert_after(&list, &(t->row[RT_TIMER_SKIP_LIST_LEVEL - 1])); soft_timer_status = RT_SOFT_TIMER_BUSY; /* enable interrupt */ rt_hw_interrupt_enable(level); /* call timeout function */ t->timeout_func(t->parameter); RT_OBJECT_HOOK_CALL(rt_timer_exit_hook, (t)); RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d\n", current_tick)); /* disable interrupt */ level = rt_hw_interrupt_disable(); soft_timer_status = RT_SOFT_TIMER_IDLE; /* Check whether the timer object is detached or started again */ if (rt_list_isempty(&list)) { continue; } rt_list_remove(&(t->row[RT_TIMER_SKIP_LIST_LEVEL - 1])); 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 break; /* not check anymore */ } /* enable interrupt */ rt_hw_interrupt_enable(level); RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check leave\n")); }