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 數據定義
[cpp]
/**
* 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;
3.2 rt-thread的軟件定時器模式
軟件定時器線程初始化及啟動:
[cpp]
/**
* @ingroup SystemInit
*
* This function will initialize system timer thread
*/
void rt_system_timer_thread_init(void)
{
#ifdef RT_USING_TIMER_SOFT//如果采用軟件定時器管理模式，則啟動定時器線程
rt_list_init(&rt_soft_timer_list);//初始化軟件定時器鏈表
/* start software timer thread */
rt_thread_init(&timer_thread,//初始化軟件定時器線程，並啟動
"timer",
rt_thread_timer_entry,
RT_NULL,
&timer_thread_stack[0],
sizeof(timer_thread_stack),
RT_TIMER_THREAD_PRIO,
10);
/* startup */
rt_thread_startup(&timer_thread);
#endif
}
軟件定時器線程如下：
[cpp]
/* 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);//休眠一段時間
}
}
/* lock scheduler */
rt_enter_critical();//時間到，進入臨界區
/* check software timer */
rt_soft_timer_check();//檢查是否該產生超時事件
/* unlock scheduler */
rt_exit_critical();//退出臨界區
}
}
檢查是否產生中斷函數rt_soft_timer_check函數如下定義:
[cpp]
/**
* 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"));
}
其上rt_timer_start函數如下定義:
[cpp]
/**
* 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)
{
struct rt_timer *t;
register rt_base_t level;
rt_list_t *n, *timer_list;
/* timer check */
RT_ASSERT(timer != RT_NULL);
if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED)//如果傳入的定時器已經激活，則直接返回錯誤
return -RT_ERROR;
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//如果采用的是軟件定時器管理模式，則將定時器加入到rt_soft_timer_list中
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;
}
for (n = timer_list->next; n != timer_list; n = n->next)//將定時器按序加入到定時器鏈表中
{
t = rt_list_entry(n, struct rt_timer, list);
/*
* It supposes that the new tick shall less than the half duration of
* tick max.
*/
if ((t->timeout_tick - timer->timeout_tick) < RT_TICK_MAX / 2)
{
rt_list_insert_before(n, &(timer->list));//將定時器timer插入到t之前
break;
}
}
/* no found suitable position in timer list */
if (n == timer_list)//沒有找到合適的位置，則放到鏈表頭
{
rt_list_insert_before(n, &(timer->list));
}
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)//如果系統采用的是軟件定時器管理模式，且軟件定時器線程處理ready狀態，則恢復此線程
{
/* check whether timer thread is ready */
if (timer_thread.stat != RT_THREAD_READY)
{
/* resume timer thread to check soft timer */
rt_thread_resume(&timer_thread);//恢復定時器線程
rt_schedule();//開始線程調度
}
}
#endif
return -RT_EOK;
}
軟件定時器管理模式的源碼分析完了，接下來介紹RTT的硬件定時器管理模式。
3.3 RTT的硬件定時器管理模式
硬件定時器管理模式顧名思義，就是說與硬件相關，因此，不用的MCU，其部分源碼是不一樣的，因為其要采用MCU的系統時鐘中斷例程來實現。
以STM32F2XX為例，先找到其啟動匯編，位置在：RTT/bsp/stm32f2xx/Libraries/CMSIS/CM3/DeviceSupport/ST/STM32F2xx/startup/arm/startup_stm32f2xx.s
找到中斷向量:
[plain]
DCD SysTick_Handler ; SysTick Handler
這是系統時鐘中斷向量，再找到其中斷例程實現：
在bsp/stm32f2xx/drivers/board.c文件中:
[cpp]
/**
* This is the timer interrupt service routine.
*
*/
void SysTick_Handler(void)//系統時鐘中斷例程
{
/* enter interrupt */
rt_interrupt_enter();
rt_tick_increase();
/* leave interrupt */
rt_interrupt_leave();
}
其中rt_tick_increase函數在RTT/src/clock.c文件中的實現如下:
[cpp]
/**
* This function will notify kernel there is one tick passed. Normally,
* this function is invoked by clock ISR.
*/
void rt_tick_increase(void)
{
struct rt_thread *thread;
/* increase the global tick */
++ rt_tick;//全局rt_tick加1
/* check time slice */
thread = rt_thread_self();//得到當前正在運行的線程
-- thread->remaining_tick;//純種剩下時間減1
if (thread->remaining_tick == 0)//如果線程剩余時間為0，即調度時間已到
{
/* change to initialized tick */
thread->remaining_tick = thread->init_tick;//將線程剩余時間重新設置初始化值
/* yield */
rt_thread_yield();//調度時間到，切換到其它線程
}
/* check timer */
rt_timer_check();//檢查硬件定時器鏈表是否有定時器產生超時事件
}
其中rt_timer_check函數在RTT/src/timer.c文件中如下定義:
[cpp]
/**
* This function will check timer list, if a timeout event happens, the
* corresponding timeout function will be invoked.
*
* @note this function shall be invoked in operating system timer interrupt.
*/
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\n"));
current_tick = rt_tick_get();
/* disable interrupt */
level = rt_hw_interrupt_disable();
while (!rt_list_isempty(&rt_timer_list))
{
t = rt_list_entry(rt_timer_list.next, struct rt_timer, list);
/*
* 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_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);
}
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\n"));
}
此函數與rt_soft_timer_check基本大致相同，只不過一個是查找硬件定時器鏈表rt_timer_list，一個是查找rt_soft_timer_list.
在此，硬件定時器管理模式基本上介紹完畢，接下來介紹一些定時器接口.
4 定時器接口
4.1 定時器初始化
靜態初始化定義器
[cpp]
/**
* This function will initialize a timer, normally this function is used to
* initialize a static timer object.
*
* @param timer the static timer object
* @param name the name of timer
* @param timeout the timeout function
* @param parameter the parameter of timeout function
* @param time the tick of timer
* @param flag the flag of timer
*/
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)
{
/* timer check */
RT_ASSERT(timer != RT_NULL);
/* timer object initialization */
rt_object_init((rt_object_t)timer, RT_Object_Class_Timer, name);//初始化內核對象
_rt_timer_init(timer, timeout, parameter, time, flag);
}
_rt_timer_init函數如下定義:
[cpp]
static void _rt_timer_init(rt_timer_t timer,
void (*timeout)(void *parameter),
void *parameter,
rt_tick_t time,
rt_uint8_t flag)
{
/* set flag */
timer->parent.flag = flag;//置flag
/* set deactivated */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//初始化時，設置為非激活狀態
timer->timeout_func = timeout;//設置超時事件處理函數
timer->parameter = parameter;//超時事件處理函數的傳入參數
timer->timeout_tick = 0;//定時器的超時時間點初始化時為0
timer->init_tick = time;//置超時時間
/* initialize timer list */
rt_list_init(&(timer->list));//初始化本身節點
}
動態創建定時器
[cpp]
/**
* This function will create a timer
*
* @param name the name of timer
* @param timeout the timeout function
* @param parameter the parameter of timeout function
* @param time the tick of timer
* @param flag the flag of timer
*
* @return the created timer object
*/
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;
}
4.2 脫離和刪除
脫離:
[cpp]
/**
* This function will detach a timer from timer management.
*
* @param timer the static timer object
*
* @return the operation status, RT_EOK on OK; RT_ERROR on error
*/
rt_err_t rt_timer_detach(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_detach((rt_object_t)timer);//脫離內核對象
return -RT_EOK;
}
刪除動態創建的定時器
[cpp]
/**
* 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;
}
4.3 啟動定時器
[cpp]
/**
* 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)
此接口已在上面介紹軟件定時器模式時已有分析，這裡就不再重復了。
4.4 停止定時器
[cpp]
/**
* 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;
}
4.5 控制
此接口是用來修改一個定時器的參數，如下代碼：
[cpp]
/**
* This function will get or set some options of the timer
*
* @param timer the timer to be get or set
* @param cmd the control command
* @param arg the argument
*
* @return RT_EOK
*/
rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void *arg)
{
/* timer check */
RT_ASSERT(timer != RT_NULL);
switch (cmd)
{
case RT_TIMER_CTRL_GET_TIME://獲取時間參數
*(rt_tick_t *)arg = timer->init_tick;
break;
case RT_TIMER_CTRL_SET_TIME://修改時間參數
timer->init_tick = *(rt_tick_t *)arg;
break;
case RT_TIMER_CTRL_SET_ONESHOT://修改定時器模式為單次觸發定時器
timer->parent.flag &= ~RT_TIMER_FLAG_PERIODIC;
break;
case RT_TIMER_CTRL_SET_PERIODIC://修改定時器為周期觸發定時器
timer->parent.flag |= RT_TIMER_FLAG_PERIODIC;
break;
}
return RT_EOK;
}
