之前的基础部分应该讲的差不多了，现在开始介绍VSF里的各个模块了。第一个模块是最常用的定时器模块，几乎各个应用都会用到，而且实现上也比较简单。

首先，定时器模块需要指定一个mem_op，来实现定时器内存结构的动态分配，应用层可以选择堆分配或者池分配，一般使用池分配。当然，定时器的动态分配并不是必须的。另一个就是1ms中断调用一个回调函数。代码如下：

void vsftimer_callback_int(void)
{
    vsfsm_post_evt_pending(&vsftimer.sm, VSFSM_EVT_TIMER);
}

vsf_err_t vsftimer_init(struct vsftimer_mem_op_t *mem_op)
{
    vsftimer.mem_op = mem_op;

    vsfq_init(&vsftimer.timerlist);
    return vsfsm_init(&vsftimer.sm);
}

一般系统的tickclk中断里，调用vsftimer_callback_int，发送VSFSM_EVT_TIMER事件给定时器主任务。mem_op在动态分配定时器的情况下需要使用。当然，定时器模块也可以使用非动态分配接口，代码如下：

void vsftimer_enqueue(struct vsftimer_t *timer)
{
    timer->node.addr = timer->interval + vsfhal_tickclk_get_ms();
    vsftimer_dequeue(timer);
    vsfq_enqueue(&vsftimer.timerlist, &timer->node);
}

void vsftimer_dequeue(struct vsftimer_t *timer)
{
    vsfq_remove(&vsftimer.timerlist, &timer->node);
}

vsftimer_enqueue只是把用户初始化好的定时器结构，加入到timerlist队列，加入时会自动把先触发的定时器放在队列的前面。vsftimer_dequeue也只是简单从队列中，移除指定的定时器。这里定时器内存由用户指定，不动态分配。这里有一点需要注意，每次enqueue的时候，都会先dequeue，所以一个定时器，修改超时时间后，只需从新enqueue一次即可更新。

动态分配接口如下：

static struct vsftimer_t *vsftimer_allocate(void)
{
    return vsftimer.mem_op->alloc();
}

void vsftimer_free(struct vsftimer_t *timer)
{
    vsftimer_dequeue(timer);
    vsftimer.mem_op->free(timer);
}

struct vsftimer_t *vsftimer_create_cb(uint32_t interval, int16_t trigger_cnt,
                                    void (*cb)(void *), void *param)
{
    struct vsftimer_t *timer = vsftimer_allocate();
    if (NULL == timer)
    {
        return NULL;
    }

    timer->evt = VSFSM_EVT_INVALID;
    timer->cb = cb;
    timer->param = param;
    timer->interval = interval;
    timer->trigger_cnt = trigger_cnt;
    vsftimer_enqueue(timer);
    return timer;
}

struct vsftimer_t *vsftimer_create(struct vsfsm_t *sm, uint32_t interval,
                                    int16_t trigger_cnt, vsfsm_evt_t evt)
{
    struct vsftimer_t *timer = vsftimer_allocate();
    if (NULL == timer)
    {
        return NULL;
    }

    timer->sm = sm;
    timer->evt = evt;
    timer->interval = interval;
    timer->trigger_cnt = trigger_cnt;
    vsftimer_enqueue(timer);
    return timer;
}

vsftimer_create_cb为定时器的回调方式，超时后回调指定接口。vsftimer_create为定时器的事件方式，超时后发送指定的事件。当然，还可以指定触发次数，-1表示每隔指定时间触发一次。

下面时核心的事件处理：

static struct vsfsm_state_t *
vsftimer_init_handler(struct vsfsm_t *sm, vsfsm_evt_t evt)
{
    uint32_t cur_tick = vsfhal_tickclk_get_ms();
    struct vsftimer_t *timer;

    switch (evt)
    {
    case VSFSM_EVT_TIMER:
        timer = (struct vsftimer_t *)vsftimer.timerlist.head;
        while (timer != NULL)
        {
            if (cur_tick >= timer->node.addr)
            {
                if (timer->trigger_cnt > 0)
                {
                    timer->trigger_cnt--;
                }
                if (timer->trigger_cnt != 0)
                {
                    vsftimer_enqueue(timer);
                }
                else
                {
                    vsftimer_free(timer);
                }

                if (timer->evt != VSFSM_EVT_INVALID)
                {
                    if (timer->sm != NULL)
                    {
                        vsfsm_post_evt(timer->sm, timer->evt);
                    }
                }
                else
                {
                    if (timer->cb != NULL)
                    {
                        timer->cb(timer->param);
                    }
                }
                timer = (struct vsftimer_t *)vsftimer.timerlist.head;
            }
            else
            {
                break;
            }
        }
        break;
    }
    return NULL;
}

只是处理VSFSM_EVT_TIMER事件，然后判断是否有定时器超时，有的话则根据设置调用回调或者发送事件。vsfhal_tickclk_get_ms时hal层的得到systick的毫秒计数。定时器的主任务，一般都运行在软实时优先级。