timer 定时器

定时器：
Kal Timer:
KAL timer 是非常底层的timer， 它的实现是直接封装MTK的RTOS(nuleus)的timer
，实现方式是由HISR，从而这种timer具有很高的优先级，也就是说，当这个timer
超时时，就会触发一个HISR(高级中断 High Level ISR (Interrupt Service Routine))
，这个中断会回调注册的回调函数。所以这种timer
使用时，要比较小心，它的优先级很高，在回调函数运行时，其他事件是得不到处理的。?
录范群芨摺?
创建定时器：
kal_timerid kal_create_timer(kal_char* timer_name_ptr); //创建一个timer，
参数是timer的名字
设置并启动定时器：
void kal_set_timer(kal_timerid timer_id, kal_timer_func_ptr handler_func_ptr,
void* handler_param_ptr, kal_uint32 delay, kal_uint32 reschedule_time);  
//设置timer 超时时间， timer_id 是 create 返回值，handler_func_ptr是回调函数，
handler_param_ptr 是回调函数返回的参数(一般回调函数都是这么设置，这样很灵活)，
delay，是超时时间，注意这个参数的单位是ticks 不是ms。reschedule_time
表示是否循环使用timer，0 表示 timer 超时一次就停止，1 表示自动循环启动timer。
设置timer_id的定时时间为delay（s），超过时间则执行函数handler_func_ptr。
取消定时器：
void kal_cancel_timer(kal_timerid timer_id);
取消timer_id定时器。

Stack Timer:
Stack Timer 与具体的KAL Timer ID相关联，由KAL Timer
执行中断，但只是发送一个消息就退出，该消息发给用户希望的目的模块（Task
），在任务中，用户会收到消息MSG_ID_TIMER_EXPIRY，然后执行真正的中断句柄。
这种timer 与 KAL timer 最大的区别是：stack timer 超时后，发送一个超时消息到
相应task的消息队列，由task的消息队列来处理这个消息，而不像KAL timer
，直接在中断状态回调注册函数。从时间的精确性来说，stack timer 可能没有KAL
timer 精确(发送消息，task 切换等都要花费时间)，但是 stack 更加的安全(在 task
里处理这个消息)，提高并发性(stack timer 到期后只是发送了一个消息，具体并不处理
)。当然 stack timer 底层具体实现还是依靠KAL timer。
分配由module_id接收stack_timer消息：
void stack_init_timer(stack_timer_struct *stack_timer, kal_char *timer_name,
module_type module_id);// stack timer 初始化 module_id 是要接受消息的 mdoule
，也就是当stack timer 超时，会像该model 发送消息。
启动定时器：
void stack_start_timer(stack_timer_struct *stack_timer, kal_uint16 timer_indx
, kal_uint32 init_time); //启动定时期，timer_index  timer
索引（有超市时间来决定为0还是1），init_time 超时时间。
停止定时器：
stack_timer_status_type stack_stop_timer(stack_timer_struct *stack_timer);
有一点需要注意的是，当stack timer
超时后，向消息队列发送了消息，但是这个消息还没有来的处理，这个时候取消了这个
timer，需要特别处理，虽然这种情况发生的概率很小。
kal_bool stack_is_time_out_valid(stack_timer_struct *stack_timer);
//判断这个消息是否继续有效，也就是是否需要处理，这个函数就是用于方式上面提到那?
智榭龅姆⑸?
void stack_process_time_out(stack_timer_struct *stack_timer);
//这个函数与上面的函数成对使用，具体看例子。
Event Scheduler：
event scheduler 处理的timer 时间精确性上来说，相对不是那么精确，对于上层app
应用来说，是必不可少的。MMI 层的timer(StartTimer 系列函数) 就是用event
scheduler + stack timer 来实现的。
event scheduler 处理的timer 时间精确性上来说，相对不是那么精确，对于上层app
应用来说，是必不可少的。MMI 层的timer(StartTimer 系列函数) 就是用event
scheduler + stack timer 来实现的。
extern event_scheduler *new_evshed(void *timer_id,
                                   void (*start_timer)(void *, unsigned int),
                                   void (*stop_timer)(void *),
                                   kal_uint32 fuzz,
                                   malloc_fp_t alloc_fn_p,
                                   free_fp_t free_fn_p,
                                   kal_uint8 max_delay_ticks);
创建一个 event scheduler ,  timer_id 是stack timer 创建的timer id，一般称为
base timer，start_timer 启动这个base timer， stop_timer 停止这个base timer，
fuzz 校正timer 时间，alloc_fn_p 内存分配函数，free_fn_p 内存释放函数，
max_delay_ticks timer 最大可延迟时间，这个表示timer
的准确度，这个参数的作用主要是用于节省电池。
extern eventid evshed_set_event(event_scheduler *es,
                                kal_timer_func_ptr event_hf,
                                void *event_hf_param,
                                kal_uint32 elapse_time);
设置一个timer，es 用 new_evshed 创建的，event_hf, timer 超时后的回调函数，
event_hf_param 回调函数传入的参数，elapse_time timer的时间。
extern void evshed_timer_handler(event_scheduler *es);
时间超时后，在aux_task_main函数中统一处理超时回调函数。也就是说，当stack
timer 超时后，向相应的mod 发送 MSG_ID_TIMER_EXPIRY
后，需要调用该函数，该函数会处理相应的回调函数。
L4 Timer:
是对定时器函数的一个封装。
初始化定时器：
void L4InitTimer(void)
{
    
    TIMERTABLE *p;
    TIMERTABLE *pp;
    // 1 释放timer table 内存
    p = g_timer_table.next;
    pp = NULL;
    do
    {
        if (p != NULL)
        {
            pp = p->next;
            OslMfree(p);
        }
        p = pp;
    } while (p != NULL);
    /* reset g_timer_talbe */
    memset(&g_timer_table, 0, sizeof(TIMERTABLE));
    g_timer_table_size = SIMULTANEOUS_TIMER_NUM;
    g_timer_table_used = 0;
    /* Initiate the clock time callback function. */
    get_clocktime_callback_func = NULL;
    set_clocktime_callback_func = NULL;
    //2 初始化 stack timer 1
    /* Initate the no alignment stack timer */
    stack_init_timer(&base_timer1, "MMI_Base_Timer1", MOD_MMI);
    //3 根据 stack timer 1 ，创建 event scheduler 1
    /* Create a no alignment timer schedule */
    event_scheduler1_ptr = new_evshed(
                            &base_timer1,
                            L4StartBaseTimer,
                            L4StopBaseTimer,
                            0,
                            kal_evshed_get_mem,
                            kal_evshed_free_mem,
                            0);
    //4 初始化 stack timer 2
    /* Initate the alignment stack timer */
    stack_init_timer(&base_timer2, "MMI_Base_Timer2", MOD_MMI);
    //5 根据 stack timer 2 创建 event scheduler 2
    /* Create an alignment timer schedule */
    event_scheduler2_ptr = new_evshed(
                            &base_timer2,
                            L4StartBaseTimer,
                            L4StopBaseTimer,
                            0,
                            kal_evshed_get_mem,
                            kal_evshed_free_mem,
                            254);

}

启动定时器：
// 参数  nTimerId 是要自己定义一个timer id，在 timerEvents.h 里的
MMI_TIMER_IDS 定义，用来区分timer的。
// TimerExpiry 超时的回调函数
// funcArg 回调函数回传的参数
// nTimeDuration 超时时间，单位ms
// alignment alignment或者non-alignment
static void L4StartTimer(
        unsigned short nTimerId,
        oslTimerFuncPtr TimerExpiry,
        void *funcArg,
        unsigned long nTimeDuration,
        unsigned char alignment)
｛
      设置TIMERTABLE，它存储了各个L4层定时器的信息；
      若需增加节点设置g_timer_table_size++和若有空节点使用空节点后设置
g_timer_table_used++ ；
      调用eventid evshed_set_event(event_scheduler *es,
                                kal_timer_func_ptr event_hf,
                                void *event_hf_param,
                                kal_uint32 elapse_time);设置event_id
同时启动定时器；

｝
停止定时器：
static void L4StopTimer(unsigned short nTimerId)
｛
     调用kal_int32 evshed_cancel_event(event_scheduler *es, eventid *eid);
函数来取消对应的定时器。
｝

MMI_task 函数中处理所有的消息，while 消息处理中，可以看到下面case处理Stack
Timer引起的中断消息：
case MSG_ID_TIMER_EXPIRY:
{
    kal_uint16 msg_len;
    EvshedMMITimerHandler(get_local_para_ptr(Message.oslDataPtr, &msg_len));
}
break ;

void EvshedMMITimerHandler(void *dataPtr)
｛
          判断 这 stack timer 是否还是有效，也就是否被stop；
          //调用 这个函数，触发注册的 event scheduler timer
         evshed_timer_handler(event_scheduler1_ptr) 或 evshed_timer_handler(
event_scheduler2_ptr);
｝

void mmi_frm_suspend_timers(U32 type)；

void mmi_frm_resume_timers(U32 type)；

再封装就得到：
启动定时器：
void StartTimer(U16 timerid, U32 delay, FuncPtr funcPtr)
void StartTimerEx(U16 timerid, U32 delay, oslTimerFuncPtr funcPtr, void* arg)
停止定时器：
void StopTimer(U16 timerid)

参见：http://blog.csdn.net/yanwuxufeng/archive/2010/07/18/5745187.aspx
          http://www.docin.com/p-62185743.html