码迷,mamicode.com
首页 > 其他好文 > 详细

基于链表的软件定时器实现(转)

时间:2018-11-15 21:19:17      阅读:298      评论:0      收藏:0      [点我收藏+]

标签:扩展   主循环   当前时间   ade   oid   else   roc   ica   插入   

软件定时器在实际应用比较重要,本文旨在实现一种便于移植,易扩展功能,效率高的软件定时器。本定时器是基于排序链表,将最近将触发的定时器置于链表头,后续新增定时器将计算出其合适位置插入。

主要数据结构及数据

 


typedef struct m_tm_tcb_struct

{

uint32_t time; //初次触发时间

uint32_t period; //周期时间,如果是只执行1次,则设为0

void *pdata; //定时器私有参数

m_timeout_handler phandler; //定时器回调函数

struct m_tm_tcb_struct *next;//链表

}m_tm_tcb;

static m_tm_tcb *ptm_list_header;

static uint32_t m_timeouts_last_time; //上次触发的时间

 

例一:我们将依次新增5个定时器,定时周期为3,5,8,8,12;当前时间为n;插入第1个时,如果链表空,则设置m_timeouts_last_time = n;设置第一个元素time=3; next=null;插入第2个,设置time2=5-3 = 2(相对与第一个时间),next=NULL;插入第3个,设置time = 8 - 3 - 2 = 3(相对与第二个时间);同理,第4个,time = 0; 第5个 time = 4。

上述是按照排好序的方式添加,如果打乱呢?

例二:依次添加周期为3,5,12,8的定时器。前3个定时器的添加与上个例子相同,插入完成后time1=3,time2=2,time3=7;  插入第4个,time4-time1>0? 成立,time4-=time1=5;与链表第2个元素时间对比,time4-time2>0?,成立,time4-=time2 = 3;在与链表第3个元素时间对比时,time4-time3>0?不成立,此定时器应该插入在2、3两个元素之间;但是原来第3个元素的触发时间就增加了time4的时间,因此将time3 -= time4 = 4。

最后,上述添加是同时添加5个定时器,实际运用时不可能全部同时添加。

例三:添加第1个定时器,间隔5;过了4个时间片后,新增第2个定时器,间隔3;显然第2个定时器应该在第1个触发后2个时间片再触发;虽然time2-time1>0不成立;这里就新增1个变量记录上次触发时间:m_timeouts_last_time;添加定时器时将计算出现在距离上次触发时间diff = now-m_timeouts_last_time;time2+=diff;这个例子中time2=3+(4-0)=7;然后按照例2进行添加。

定时器主处理函数可在中断中调用,也可在普通任务中(无OS时就是主循环)调用,判断now-m_timeouts_last_time>ptm_list_header->time?成立,则代表有定时器触发,需要进行处理;处理后表头直针后移,看新元素时间是否为0(相对前一个)如果为0,则进行处理,直到不为0;如果时周期性定时器,则可在添加是将定时器结构体内period设置为周期时间,在定时器回调执行完成后重新添加定时器即可。

该定时器使用过程中的注意事项,如果定时器主处理函数如果放在中断中,则代表超时回调函数也在中断中处理,此时不应将回调函数写的太长,例如:擦、写flash;串口用阻塞的方式发送太长的数据(115200大约在10kB/S,10个字节对应1ms,如果,回调执行超过1ms,明显会使定时器不准确);如果在普通任务调用则无此问题。比较好的方法其实是使用前后台处理机制,将回调函数必要参数传回普通任务中,在任务中去执行,这样想写多长也不会影响实时性。后续的另一篇文章中,我将实现一种通用的无OS的前后台调度器,降低中断平面、任务平面的耦合性。

/**
 * @file m_timeouts.h
 * Timer implementations
 */
 #ifndef M_TIMEOUTS_H
 #define M_TIMEOUTS_H
 
 
#include "m_common.h"
//定时器回调函数
typedef void (* m_timeout_handler)(void *arg);
 
//定时器结构体
typedef struct m_tm_tcb_struct
{
    uint32_t time;    //初次触发时间
    uint32_t period;    //周期时间,如果是只执行1次,则设为0
    void *pdata;        //定时器私有参数
    m_timeout_handler phandler;  //定时器回调函数
    struct m_tm_tcb_struct *next;//链表
}m_tm_tcb;
 
//定时器初始化
void m_timeout_init(void);
 
//添加定时器
int8_t m_timeout_add(m_tm_tcb *tm);
 
//删除定时器
int8_t m_timeout_delete(m_tm_tcb *tm);
 
//定时器处理函数
void m_timeout_process(void);
 
#endif
--------------------- 
/**
 * @file m_timeouts.c
 * Timer implementations
 */
 
#include "m_timeouts.h"
 
static m_tm_tcb *ptm_list_header;
static uint32_t m_timeouts_last_time;    //上次触发的时间。
 
uint32_t tm_get_now(void)
{
    return HAL_GetTick();
}
 
//定时器初始化
void m_timeout_init(void)
{
    ptm_list_header = NULL;
}
 
 //添加定时器,单次运行;
int8_t m_timeout_add(m_tm_tcb *tm)
{
    uint32_t diff=0,now,msecs;
    m_tm_tcb *p;
    
    now = tm_get_now();
    
    //链表为空
    M_ENTER_CRITICAL();
    if(ptm_list_header == NULL)
    {
        m_timeouts_last_time = now;
        ptm_list_header = tm;
        tm->next = NULL;
        M_EXIT_CRITICAL();
        return 0;
    }
    else
    {
        diff = now - m_timeouts_last_time;
        msecs = tm->time;
        tm->time += diff;
    }
 
    if(ptm_list_header->time > tm->time)
    {
        ptm_list_header->time -= tm->time;
        tm->next = ptm_list_header;
        ptm_list_header = tm;
    }
    else
    {
        for(p = ptm_list_header; p!=NULL; p=p->next)
        {
            tm->time -= p->time;
            if(p->next == NULL || p->next->time > tm->time)
            {
                if(p->next != NULL)
                {
                    p->next->time -= tm->time;
                    
                }
                else if(tm->time > msecs)
                {
                    tm->time = msecs+ptm_list_header->time;
                }
                tm->next = p->next;
                p->next = tm;
                break;
            }
        }
    }
    M_EXIT_CRITICAL();
    return 0;
    
}
 
//删除定时器
int8_t m_timeout_delete(m_tm_tcb *tm)
{
    m_tm_tcb *prev, *t;
    M_ENTER_CRITICAL();
    for(t=ptm_list_header, prev=NULL; t!=NULL; prev=t, t=t->next)
    {
        if(t == tm)
        {
 
            if(t->next)
                t->next->time += tm->time;
            if(prev == NULL)
            {
                ptm_list_header = t->next;
            }
            else
            {
                prev->next = t->next;
            }
            M_EXIT_CRITICAL();
            return 0;
        }
    }
    
    M_EXIT_CRITICAL();
    return -1;
}
 
//定时器处理函数
void m_timeout_process(void)
{
    m_tm_tcb *tmptm = ptm_list_header;
    
    uint32_t diff = tm_get_now() - m_timeouts_last_time;
    
    while(tmptm && (diff >= tmptm->time))
    {
        diff -= tmptm->time;
        
        M_ENTER_CRITICAL();
        m_timeouts_last_time += tmptm->time;
        ptm_list_header = tmptm->next;
        M_EXIT_CRITICAL();
        
        if(tmptm->period)
        {
            tmptm->time = tmptm->period;
            m_timeout_add(tmptm);
        }
    
        if(tmptm->phandler)
            tmptm->phandler(tmptm->pdata);
        
        tmptm = ptm_list_header;
    }
}
 

 

基于链表的软件定时器实现(转)

标签:扩展   主循环   当前时间   ade   oid   else   roc   ica   插入   

原文地址:https://www.cnblogs.com/citroen/p/9965888.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!