单片机定时器之改良版：时间轮定时器

前段时间把自己以前用的单片机定时器整理出来，我称之为简单定时器，这种简单定时器比较适合定时器使用量少的程序中，如果定时器数量要求多，精度要求高，效率就会有问题，为此，俺就实现了一个时间轮定时器，简单测试下来效果非常不错。

#ifndef __SOFT_TIMER_H__
#define __SOFT_TIMER_H__

#define EVENT_TYPE_ONESHOT 0
#define EVENT_TYPE_PERIODIC 1

#define TMR_POOL_SIZE 20  // 定时器池，即可用定时器个数
#define TMR_WHEEL_SIZE 8  // 时间轮的粒度

#define HANDLE int

typedef void (*pTimerProc)(void*);

void TimerInit(void);
HANDLE SetTimer(unsigned long uElapse,pTimerProc pFunc,void *para,unsigned int Tmr_type);
void KillTimer(HANDLE hTmr);
void TimerServer(void);     // call in main loop
void TimerSignal(void);     // call it in timer isr
unsigned long TmrGetTime(void);

#endif 

简单介绍一下：

SetTimer():   
参数uElapse：定时器超时时间. 参数pFunc：定时器超时回调函数. 参数para：定时器超时回调函数参数.参数Tmr_type：定时器类型，EVENT_TYPE_ONESHOT为单次定时器，定时器超时后，会被自动删除.EVENT_TYPE_PERIODIC 表示周期性定时器，使用完后需主动删除。
返回值：返回定时器id,用于删除定时器。

KillTimer(): 删除由SetTimer()创建的定时器。

TimerServer(): 定时器管理函数，需在主循环中调用。

TimerSignal(): 定时器信号函数，提供定时器运行所需节拍数，需在硬件定时器中断中调用，例如，硬件定时器10ms中断一次，在中断中调用TimerSignal()，则时间轮定时器的节拍时间为10ms.

TmrGetTime():记录定时器的节拍数，

#include "timer.h"

typedef struct _tagTimer{
    unsigned int elapse;
    unsigned int interval;
    void *prev;
    void *next;
    TimerProc pFunc;
    void *para;
    unsigned char state;
    unsigned char event_type;
    unsigned char timeout;
}Timer_Typedef;

typedef struct _tagTimerWheel{
    Timer_Typedef *pFirst;
    unsigned int entries;
}TimerWheel_Typedef;

#define TMR_STATE_FREE 0
#define TMR_STATE_STOP 1
#define TMR_STATE_RUNNING 3

static Timer_Typedef _timerArray[TMR_POOL_SIZE]={0};
static TimerWheel_Typedef TmrWheel[TMR_WHEEL_SIZE]={0};
static Timer_Typedef* tmr_free_list;
static unsigned tmr_free_slot = 0;
static unsigned _tmr_tick = 0;


static Timer_Typedef* Tmr_alloc(void);
static void Tmr_free(Timer_Typedef* pTmr);
static void Tmr_link(Timer_Typedef* pTmr);
static void Tmr_unlink(Timer_Typedef* pTmr);

 
void TimerInit(void)
{
    int i = 0;
    for(i=0;i<TMR_POOL_SIZE-1;++i)
    {
       _timerArray[i].next = (void*)(&_timerArray[i+1]);
    }
    _timerArray[TMR_POOL_SIZE-1].next = (void*)0;
    tmr_free_list = _timerArray;
    tmr_free_slot = TMR_POOL_SIZE;
    
    for(i=0;i<TMR_WHEEL_SIZE;++i)
    {
       TmrWheel[i].pFirst = (void*)0;
       TmrWheel[i].entries = 0;
    }
}

HANDLE SetTimer(unsigned long uElapse,TimerProc pFunc,void *para,unsigned int Tmr_type)
{
    int unused_slot = -1;
    Timer_Typedef *pTmr = (Timer_Typedef *)0;
    
    pTmr = Tmr_alloc();
    if(pTmr) unused_slot = pTmr - _timerArray;

    if(unused_slot !=  -1)
    {
        _timerArray[unused_slot].pFunc = pFunc;
        _timerArray[unused_slot].para = para;
        _timerArray[unused_slot].interval = uElapse;
        _timerArray[unused_slot].event_type = Tmr_type;
        _timerArray[unused_slot].state = 1;
        Tmr_link(pTmr);
    }
    return unused_slot;
}

void KillTimer(HANDLE hTmr)
{
    if((hTmr >= 0)&&(hTmr < TMR_POOL_SIZE))
    {
        switch(_timerArray[hTmr].state)
        {
            case TMR_STATE_STOP:
                    Tmr_free(&_timerArray[hTmr]);
                break;
            case TMR_STATE_RUNNING:
                    Tmr_unlink(&_timerArray[hTmr]);
                    Tmr_free(&_timerArray[hTmr]);
                break;
            default:
                break;
        }
        _timerArray[hTmr].timeout = 0;
    }
}

void TimerServer(void)
{
    int i = 0;
    Timer_Typedef* pTmr = _timerArray;
    for(i = 0;i<TMR_POOL_SIZE;++i)
    {
        if((pTmr->timeout)&&(pTmr->pFunc))
        {
            (*(pTmr->pFunc))(pTmr->para);
            pTmr->timeout = 0;
        }
        pTmr++;
    }
}


void TimerSignal(void)
{
    int spoke = 0;
    Timer_Typedef* pTmr,*pNext;
    
    ++_tmr_tick;
    spoke = _tmr_tick%TMR_WHEEL_SIZE;
    pTmr = TmrWheel[spoke].pFirst;
    while(pTmr)
    {
       pNext = pTmr->next;
       if(pTmr->elapse == _tmr_tick)
       {
           Tmr_unlink(pTmr);
           if(pTmr->event_type == EVENT_TYPE_PERIODIC)
           { 
                Tmr_link(pTmr);
           }
           else
           {
                Tmr_free(pTmr);
           }
           pTmr->timeout = 1;
        }
        pTmr = pNext;
    }
}

static void Tmr_link(Timer_Typedef* pTmr)
{
   int spoke;
   TimerWheel_Typedef *pWhl;
   pTmr->state =  TMR_STATE_RUNNING;
   pTmr->elapse = pTmr->interval + _tmr_tick;
   spoke = pTmr->elapse%TMR_WHEEL_SIZE;
   pWhl = &TmrWheel[spoke];
   
   if(pWhl->pFirst)  pWhl->pFirst->prev = pTmr;
   
   pTmr->next = pWhl->pFirst;
   pWhl->pFirst = pTmr;
   pWhl->entries++;
}

static void Tmr_unlink(Timer_Typedef* pTmr)
{
   int spoke;
   TimerWheel_Typedef *pWhl;
   pTmr->state =  TMR_STATE_STOP;
   spoke = pTmr->elapse%TMR_WHEEL_SIZE;
   pWhl = &TmrWheel[spoke];
   
   if(pWhl->pFirst == pTmr) 
   {
        pWhl->pFirst = pTmr->next;
        if(pTmr->next) ((Timer_Typedef*)pTmr->next)->prev = (void*)0;
   }
   else
   {
        ((Timer_Typedef*)pTmr->prev)->next = pTmr->next;
        if(pTmr->next) ((Timer_Typedef*)pTmr->next)->prev = pTmr->prev;
   }
   pWhl->entries--;
}


static Timer_Typedef* Tmr_alloc(void)
{
    Timer_Typedef *pTmr = (Timer_Typedef*)0;
    if(tmr_free_list)
    {
       pTmr = tmr_free_list;
       tmr_free_list =  tmr_free_list->next;
       tmr_free_slot--;
    }
    return pTmr;
}



static void Tmr_free(Timer_Typedef* pTmr)
{
   pTmr->state = TMR_STATE_FREE;
   pTmr->prev = (Timer_Typedef*)0;
   pTmr->next = tmr_free_list;
   tmr_free_list = pTmr;
   tmr_free_slot++;
}

unsigned long TmrGetTime(void)
{
    return _tmr_tick;
}