MCU软件定时器常见的实现方式

2万 · 2025-4-23 16:50

在一般的嵌入式产品设计中，介于成本、功耗等，所选型的MCU基本都是资源受限的，而里面的定时器的数量更是有限。在我们软件设计中往往有多种定时需求，例如脉冲输出、按键检测、LCD切屏延时等等，我们不可能让每一个定时业务都去开一个硬件定时器，一来硬件资源可能不足，二来会使软件过度依赖于硬件平台，从而导致较差的可移植性。

而若我们有一个软件定时器，所有定时业务都依赖于软件定时器，不仅节省硬件资源，以后在移植的时候也只需要将软件定时器和硬件相关的部分修改就行了，其他部分都不用动。

软件定时器实现方式：

一、用结构体数组的方式实现软件定时器

用结构体数组的方式实现起来较简单，也容易理解，除此之外和之后的链表实现方式比起来没有其他优点。但还是介绍一下实现方法：在结构体数组内定义一个start标志和定时时长duration，还有一个为计数值count，这3个变量为最基本的3个变量，其他的可以自己补充，比如运行模式、回调函数指针等。还有就是每一个结构体数组就是一个定时器，需要我们提前定义好这个结构体数组有多大。

定义好之后，在开启定时器的时候我们将对应的数组内start标志置位，在硬件tick中断服务函数里面我们去查所有结构体数组内的start标志是否置位，当查到当前start被置位时，将此数组内的duration和count做比较，如果相等就说明此定时器定时时间到了，如果不等就将count++，然后接着查其他数组的start标志，以此无限循环。

此种方式缺点非常明显，那就是在硬件tick中断服务函数内，我们得轮询所有数组，如果我们软件业务需求是20个定时任务，那我们就得在软件定时器的实现里定义20个数组，空间浪费倒是其次的，关键是硬件tick轮询的数组越多，执行到某个数组的时间就越长，若以后有50个、100个定时需求时，将会导致定时时间极不精准。

二、用链表实现软件定时器

介于以上用结构体数组实现软件定时器的种种缺点，我们提出改进方案。经过分析，在大多数定时业务中，往往只需要在某个时间段定时一次，也就是说定时器会开启定时和结束定时，当然，用数组的实现的定时器也可以开启定时和关闭定时，只需要用start标志去决定就行了，但是用数组实现的方式中，即使你关闭了定时器，也就是去掉了start标志，此定时器虽然不运行了，但是数组的空间不会减少，硬件 tick依然要轮询所有数组。

所以我们需要用链表来实现软件定时器，在硬件tick中轮询所有节点，开启一个定时器就加入一个节点，关闭定时器就删除一个节点，可以保证在当前时刻只轮询需要定时的节点，可以极大的保证定时准确性。

在加上可以让用户选择定时时间到了直接在硬件tick内执行或者在硬件tick内置标志，然后在while循环内排队执行，可以非常有效的解决关键业务定时不精准的问题，比如脉冲输出这种需要定时准确的业务。

2万 · 2025-4-23 16:51

链表实现方式

H文件：

/**
* sfor_timer_list.h
* 链表实现的软件定时器库
*/
#ifndef __SOFT_TIMER_LIST_H
#define __SOFT_TIMER_LIST_H

/**
* 硬件中断tick
*/
#define TIMER_HARD_TICK                   100U //ms,硬件tick取决于硬件定时中断时间
#define TIMER_200MS_TICK                   (200U/TIMER_HARD_TICK) //TIMER_HARD_TICK * (2) = 100mS
#define TIMER_SEC_TICK                      (1000U/TIMER_HARD_TICK) //TIMER_HARD_TICK * (20) = 1S

/**
* 定时模式选择
*/
typedefenum
{
ONCE_MODE,                         /* 单次定时模式，即超时后自动关闭定时器 */
CONTINUE_MODE,                      /* 持续定时模式，只要开启除非手动关闭否则永不停歇 */
DEFINE_NUM_MODE,                   /* 定义次数的模式，运行指定的次数后关闭定时器 */
}TimerTimingModeType;

/**
* 定时超时后运行的回调函数可以选择在中断直接运行或者挂起任务轮询执行
* 只要在定时需求准确的时候才建议选择中断模式执行，类似无磁传感器脉冲测量
* 像一些超时判断类的应用以轮询的方式进行执行
* 中断执行模式越多，其他定时器越不准,毕竟中断允许占时间，查询其他定时器时
* 会有延时
*/
typedefenum
{
RUN_IN_LOOP_MODE,                   /* 轮询执行模式 */
RUN_IN_INTERRUPT_MODE,                /* 中断实时执行模式 */
}TimerRunModeType;

/**
* 软件定时器基本类型
*/
typedefstructSoftTimer
{
unsignedlong counter;             /* 计数             */
unsignedlong duration;             /* 定时时长       */
unsignedlong run_num;             /* 自定义的定时次数  */
BOOL start_flag;                   /* 启动标志       */
BOOL loop_flag;                      /* 轮询标志       */
TimerRunModeType run_mode;
TimerTimingModeType timing_mode;
void (*callback_function)(void);    /* 回调函数       */
structSoftTimer *next;
}SoftTimer;

/*
* 初始化软件定时器的硬件tick
*/
externvoidsoft_timer_tick_init(void);

/*
* 创建一个只运行一次的软件定时器并立刻开始计时
* 参数表：p: 定时器结构体指针，由用户创建
*       mode: 选择运行模式，可选定时器到了之后是直接在tick中断内执行还是置起标志在while循环内轮询执行
*       duration: 要计时的时长，单位为硬件中断的tick
*       timeout_handler: 定时到了之后要执行的函数指针
* return：无
*/
externvoidcreat_single_soft_timer(SoftTimer *p, TimerRunModeType mode, unsignedlong duration, void(*timeout_handler)(void));

/*
* 创建***运行的软件定时器并立刻开始计时
* 参数表：p: 定时器结构体指针，由用户创建
*       mode: 选择运行模式，可选定时器到了之后是直接在tick中断内执行还是置起标志在while循环内轮询执行
*       duration: 要计时的时长，单位为硬件中断的tick
*       timeout_handler: 定时到了之后要执行的函数指针
* return：无
*/
externvoidcreat_continue_soft_timer(SoftTimer *p, TimerRunModeType mode, unsignedlong duration, void(*timeout_handler)(void));

/*
* 创建指定次数运行的软件定时器并立刻开始计时
* 参数表：p: 定时器结构体指针，由用户创建
*       mode: 选择运行模式，可选定时器到了之后是直接在tick中断内执行还是置起标志在while循环内轮询执行
*       run_num：要定时的次数，比如1就是定时1次，5就是定时5次以后自动关闭定时器
*       duration: 要计时的时长，单位为硬件中断的tick
*       timeout_handler: 定时到了之后要执行的函数指针
* return：无
*/
externvoidcreat_limit_num_soft_timer(SoftTimer *p, TimerRunModeType mode,unsignedlong run_num, unsignedlong duration, void(*timeout_handler)(void));

/*
* 重启指定的单次软件定时器
* 参数表：p: 定时器结构体指针，由用户创建
*       mode: 选择运行模式，可选定时器到了之后是直接在tick中断内执行还是置起标志在while循环内轮询执行
*       duration: 要计时的时长，单位为硬件中断的tick
*       timeout_handler: 定时到了之后要执行的函数指针
* return：无
*/
externvoidrestart_single_soft_timer(SoftTimer *p, TimerRunModeType mode, unsignedlong duration, void(*timeout_handler)(void));

/**
* 删除一个软件定时器
*/
externvoidstop_timer(SoftTimer *p);

/**
* 系统main循环进程，用于执行轮询模式的回调函数
*/
externvoidsoft_timer_main_loop(void);

/**
* 此函数为tick中断服务函数，需要挂载在外部硬件定时器上
* 因此软件定时器的定时精度由此函数挂载的硬件定时时间决定，
* 比如此函数挂载在定时50ms的外部定时器上，那么定时dutation
* 为20时定时时间就是20*50ms=1S
*/
externvoidsystem_tick_IrqHandler(void);

#endif /* !1__SOFT_TIMER_LIST_H */

C文件：

/**
* sfor_timer_list.c
* 链表实现的软件定时器库
*/
#define NULL ((void *)0)
typedefenum {FALSE = 0, TRUE = !FALSE} BOOL;

#include "meter_include.h" //包含用户的硬件定时器初始化函数
#include "soft_timer_list.h"

/**
* 软件定时器内部变量
*/
static SoftTimer *head_point = NULL;

staticstruct SoftTimer *creat_node(SoftTimer *node);
staticchardelete_node(SoftTimer *node);
static BOOL is_node_already_creat(SoftTimer *node);

/**
* 初始化软件定时器的硬件tick
*/
voidsoft_timer_tick_init(void)
{
R_IT_Create(); /* 由用户初始化一个硬件定时器，当前tick 100ms */
R_IT_Start();
}

/**
* 系统main循环进程，用于执行轮询模式的回调函数
*/
voidsoft_timer_main_loop(void)
{
structSoftTimer *p1 = head_point;

while (p1 != NULL) //下一个节点如果不为空
{
      if(p1->loop_flag == TRUE)
      {
         p1->loop_flag= FALSE;
         p1->callback_function();
         if(p1->start_flag != TRUE)
            delete_node(p1); /* 如果定时器被删除就删除节点 */
      }
      /*  寻找下一个有意义的节点  */
      p1 = p1->next;
}
}

/*
* 创建一个只运行一次的软件定时器并立刻开始计时
* 参数表：p: 定时器结构体指针，由用户创建
*       mode: 选择运行模式，可选定时器到了之后是直接在tick中断内执行还是置起标志在while循环内轮询执行
*       duration: 要计时的时长，单位为硬件中断的tick
*       timeout_handler: 定时到了之后要执行的函数指针
* return：无
*/
voidcreat_single_soft_timer(SoftTimer *p, TimerRunModeType mode, unsignedlong duration, void(*timeout_handler)(void))
{
if ((p == NULL)||(timeout_handler == NULL) || duration == 0) return;

p->start_flag = TRUE;
p->counter = 0;
p->loop_flag = FALSE;
p->duration = duration;
if(mode == RUN_IN_LOOP_MODE)
      p->run_mode = RUN_IN_LOOP_MODE;
else
      p->run_mode = RUN_IN_INTERRUPT_MODE;
p->callback_function = timeout_handler;
p->timing_mode = ONCE_MODE;
p->run_num = 0; /* 只有在自定义运行次数的情况下此值才有效 */
head_point = creat_node(p);
}

/*
* 创建***运行的软件定时器并立刻开始计时
* 参数表：p: 定时器结构体指针，由用户创建
*       mode: 选择运行模式，可选定时器到了之后是直接在tick中断内执行(除非实在必要)还是置起标志在while循环内轮询执行
*       duration: 要计时的时长，单位为硬件中断的tick
*       timeout_handler: 定时到了之后要执行的函数指针
* return：无
*/
voidcreat_continue_soft_timer(SoftTimer *p, TimerRunModeType mode, unsignedlong duration, void(*timeout_handler)(void))
{
if ((p == NULL)||(timeout_handler == NULL) || duration == 0) return;

p->start_flag = TRUE;
p->counter = 0;
p->loop_flag = FALSE;
p->duration = duration;
if(mode == RUN_IN_LOOP_MODE)
      p->run_mode = RUN_IN_LOOP_MODE;
else
      p->run_mode = RUN_IN_INTERRUPT_MODE;
p->callback_function = timeout_handler;
p->timing_mode = CONTINUE_MODE;
p->run_num = 0;    /* 只有在自定义运行次数的情况下此值才有效 */
head_point = creat_node(p);
}

/*
* 创建指定次数运行的软件定时器并立刻开始计时
* 参数表：p: 定时器结构体指针，由用户创建
*       mode: 选择运行模式，可选定时器到了之后是直接在tick中断内执行还是置起标志在while循环内轮询执行
*       run_num：要定时的次数，比如1就是定时1次，5就是定时5次以后自动关闭定时器
*       duration: 要计时的时长，单位为硬件中断的tick
*       timeout_handler: 定时到了之后要执行的函数指针
* return：无
*/
voidcreat_limit_num_soft_timer(SoftTimer *p, TimerRunModeType mode,unsignedlong run_num, unsignedlong duration, void(*timeout_handler)(void))
{
if ((p == NULL)||(timeout_handler == NULL) || duration == 0) return;
p->start_flag = TRUE;
p->counter = 0;
p->loop_flag = FALSE;
p->duration = duration;
if(mode == RUN_IN_LOOP_MODE)
      p->run_mode = RUN_IN_LOOP_MODE;
else
      p->run_mode = RUN_IN_INTERRUPT_MODE;
p->callback_function = timeout_handler;
p->timing_mode = DEFINE_NUM_MODE;
p->run_num = run_num;    /* 只有在自定义运行次数的情况下此值才有效 */
head_point = creat_node(p);
}

/*
* 重启指定的单次软件定时器
* 参数表：p: 定时器结构体指针，由用户创建
*       mode: 选择运行模式，可选定时器到了之后是直接在tick中断内执行还是置起标志在while循环内轮询执行
*       duration: 要计时的时长，单位为硬件中断的tick
*       timeout_handler: 定时到了之后要执行的函数指针
* return：无
*/
voidrestart_single_soft_timer(SoftTimer *p, TimerRunModeType mode, unsignedlong duration, void(*timeout_handler)(void))
{
if ((p == NULL)||(timeout_handler == NULL) || duration == 0) return;

p->start_flag = TRUE;
p->counter = 0;
p->loop_flag = FALSE;
p->duration = duration;
if(mode == RUN_IN_LOOP_MODE)
      p->run_mode = RUN_IN_LOOP_MODE;
else
      p->run_mode = RUN_IN_INTERRUPT_MODE;
p->callback_function = timeout_handler;
p->timing_mode = ONCE_MODE;
p->run_num = 0; /* 只有在自定义运行次数的情况下此值才有效 */
if (is_node_already_creat(p) != TRUE) /* 若之前的节点已被删除就重新创建 */
      head_point = creat_node(p);
}

/**
* 封装后给用户使用
*/
voidstop_timer(SoftTimer *p)
{
if (p != NULL) {
      p->counter = 0;
      p->start_flag = FALSE;
      delete_node(p);
}
}

staticstruct SoftTimer *creat_node(SoftTimer *node)
{
structSoftTimer *p1; //p1保存当前需要检查的节点的地址
if(node == NULL)
      return head_point;

if(is_node_already_creat(node)!=FALSE) {
      delete_node(node);  /* 当节点已经存在的时候在这里选择退出还是删除后重新创建，目前重新创建 */
}
//当头节点为空时，将传入的节点作为头节点，返回头节点
if (head_point == NULL)       {
      head_point = node;
      node->next = NULL;
      return head_point;
}
p1 = head_point;
while(p1->next != NULL)
{
      p1 = p1->next;    //后移一个节点
}

if(p1->next == NULL)  //将该节点插入链表的末尾
{
      p1->next = node;
      node->next = NULL;
}
else
{

}
return head_point;
}

staticchardelete_node(SoftTimer *node)
{
structSoftTimer *p1; //p1保存当前需要检查的节点的地址
structSoftTimer *temp;
if(node == NULL)
   return1;

p1 = head_point;
if(node == head_point) {
      head_point = head_point->next; /* 如果要删除头指针，就将头指针后移  */
} else {
      while (p1 != NULL) /*头节点如果不为空 */
      {
         temp = p1;    /* 记录当前节点 */
         p1 = p1->next; /* 检索的是下一个节点  */
         if (p1 == NULL) {
            return1;
         }
         if (p1 == node) {
            temp->next = p1->next; /* 删除此节点 */
            return0;
         }
      }
}
return0;
}

static BOOL is_node_already_creat(SoftTimer *node)
{
structSoftTimer *p1; //p1保存当前需要检查的节点的地址
if(node == NULL)
   return FALSE;

p1 = head_point;
while(p1 != NULL)
{
      if(p1 == node)
         return TRUE;
      p1 = p1->next;    //后移一个节点
}
return FALSE;
}

/**
* 此函数为tick中断服务函数，需要挂载在外部硬件定时器上
* 因此软件定时器的定时精度由此函数挂载的硬件定时时间决定，
* 比如此函数挂载在定时50ms的外部定时器上，那么定时dutation
* 为20时定时时间就是20*50ms=1S
*/
voidsystem_tick_IrqHandler(void)
{
structSoftTimer *p1 = head_point;
close_global_ir();  //关闭中断，根据硬件平台修改
while (p1 != NULL) //下一个节点如果不为空
{
      if(p1->start_flag != FALSE) /* 判断当前定时器是否被开启  */
      {
         if(++p1->counter >= p1->duration)  /* 判断当前计时有没有到达 */
         {
            switch (p1->timing_mode)
            {
            case ONCE_MODE:
                  p1->start_flag = FALSE;
                  break;
            case CONTINUE_MODE:
                  break;
            case DEFINE_NUM_MODE:
                  if (p1->run_num > 0)
                  {
                     if (--p1->run_num == 0)
                     {
                        p1->start_flag = FALSE;
                     }
                  }
            default:
                  break;
            }
            if(p1->run_mode == RUN_IN_INTERRUPT_MODE)
            {
                  p1->callback_function(); /* 中断内直接运行回调函数，用于实时性比较高的程序 */
                  if(p1->start_flag != TRUE)
                     delete_node(p1);
            }
            else
                  p1->loop_flag = TRUE;
            p1->counter = 0;
         }
      }
      /*  寻找下一个有意义的节点  */
      p1 = p1->next;
}
open_global_ir();  //打开中断，根据硬件平台修改
}结构体实现方式

最后在附上用结构体数组实现的软件定时器以作参考。

H文件：

/**
* sfor_timer_array.h
* 数组实现的软件定时器库
* 一个软件定时器解决整个项目中所有的定时需求，回调函数可根据应用
* 自动切换中断实时操作或者不实时的轮询操作，可以有效解决硬件资源
* 不足或者软件定时器定时不准的问题，定时误差就几个C语言语句，倘若
* 配置最大10个软件定时器，误差就是最多10个for循环的时间
*/
#ifndef __SOFT_TIMER_ARRAY_H
#define __SOFT_TIMER_ARRAY_H

/**
* 定义最大的可用的软件定时器数量
* 理论上可以无限大，但是数量越大定时误差越大，所以用几个开几个
* 误差在于轮询检测所有定时器，定时器越多轮询到自己的定时器就越慢，
* 此外，数量增多亦会带来空间增大
*/
#define MAX_TIMER_NUM                      10

/**
* 定时模式选择
*/
typedefenum
{
ONCE_MODE,                         /* 单次定时模式，即超时后自动关闭定时器 */
CONTINUE_MODE,                      /* 持续定时模式，只要开启除非手动关闭否则永不停歇 */
DEFINE_NUM_MODE,                   /* 定义次数的模式，运行指定的次数后关闭定时器 */
}TimerTimingModeType;

/**
* 定时超时后运行的回调函数可以选择在中断直接运行或者挂起任务轮询执行
* 只要在定时需求准确的时候才建议选择中断模式执行，类似无磁传感器脉冲测量
* 像一些超时判断类的应用以轮询的方式进行执行
* 中断执行模式越多，其他定时器越不准,毕竟中断允许占时间，查询其他定时器时
* 会有延时
*/
typedefenum
{
RUN_IN_LOOP_MODE,                   /* 轮询执行模式 */
RUN_IN_INTERRUPT_MODE,                /* 中断实时执行模式 */
}TimerRunModeType;

/**
* 软件定时器基本类型
*/
typedefstruct
{
unsignedlong counter;             /* 计数          */
unsignedlong duration;             /* 定时时长    */
unsignedlong run_num;             /* 自定义的定时次数  */
unsignedchar start_flag;          /* 启动标志    */
unsignedchar loop_flag;             /* 轮询标志    */
TimerRunModeType run_mode;
TimerTimingModeType timing_mode;
void (*callback_function)(void);    /* 回调函数 */
}SoftTimer;

/**
* 删除一个软件定时器
*/
externvoidstop_timer(void (*callback_function)(void));

/*
* 创建一个软件定时器并立刻开始计时
* return：没有空闲定时器时返回1，创建成功时返回0
*/
externcharsoft_timer_start(TimerTimingModeType timing_mode,
                                 TimerRunModeType run_mode,
                                    unsignedlong run_num,
                                    unsignedlong duration,
                           void (*callback_function)(void));

/**
* 系统main循环进程，用于执行轮询模式的回调函数
*/
externvoidsoft_timer_main_loop(void);

/**
* 此函数为tick中断服务函数，需要挂载在外部硬件定时器上
* 因此软件定时器的定时精度由此函数挂载的硬件定时时间决定，
* 比如此函数挂载在定时50ms的外部定时器上，那么定时dutation
* 为20时定时时间就是20*50ms=1S
*/
externvoidsystem_tick_IrqHandler(void);

#endif /* !1__SOFT_TIMER_LIB_H */

C文件：

/**
* sfor_timer_array.c
* 数组实现的软件定时器库
* 一个软件定时器解决整个项目中所有的定时需求，回调函数可根据应用
* 自动切换中断实时操作或者不实时的轮询操作，可以解决硬件资源
* 不足或者软件定时器定时不准的问题
*/
#include "soft_timer_array.h"

/**
* 软件定时器内部变量
*/
static SoftTimer soft_timer[MAX_TIMER_NUM];

/*
* 创建一个软件定时器并立刻开始计时
* return：没有空闲定时器时返回1，创建成功时返回0
*/
charsoft_timer_start(TimerTimingModeType timing_mode, TimerRunModeType run_mode, unsignedlong run_num, unsignedlong duration,
                  void (*callback_function)(void))
{
unsignedchar i = 0;

if(!callback_function) return1;
stop_timer(callback_function);    /* 先判断有没有一样的定时器，有的话先删除  */
for(i =0; i<MAX_TIMER_NUM;i++)
{
      if(soft_timer.start_flag == 0) /* 查询空闲的定时器 */
      {
         soft_timer.start_flag = 1;
         soft_timer.counter = 0;
         soft_timer.loop_flag = 0;
         soft_timer.duration = duration;
         soft_timer.run_mode = run_mode;
         soft_timer.callback_function = callback_function;
         if ((soft_timer.timing_mode = timing_mode) == DEFINE_NUM_MODE)
            soft_timer.run_num = run_num;                   /* 只有在自定义运行次数的情况下此值才有效 */
         break;
      }
      if (i == MAX_TIMER_NUM ) /* 没有空闲定时器 */
         return1;
}
return0;
}

/**
* 删除一个软件定时器
*/
voidstop_timer(void (*callback_function)(void))
{
unsignedchar i;
for(i = 0; i <MAX_TIMER_NUM; i++)
{
      if(soft_timer.callback_function == callback_function)
      {
         soft_timer.start_flag = 0;
         soft_timer.loop_flag = 0;
      }
}
}

/**
* 系统main循环进程，用于执行轮询模式的回调函数
*/
voidsoft_timer_main_loop(void)
{
unsignedchar i;
for(i = 0; i <MAX_TIMER_NUM; i++)          /*  轮询执行回调函数  */
{
      if(soft_timer.loop_flag == 1)
      {
         soft_timer.loop_flag= 0;
         soft_timer.callback_function();
         // return;                            /*  运行一次任务后就退出去等跑一轮后运行下个程序，防止任务堆积在一起运行  */
      }
}
}

/**
* 此函数为tick中断服务函数，需要挂载在外部硬件定时器上
* 因此软件定时器的定时精度由此函数挂载的硬件定时时间决定，
* 比如此函数挂载在定时50ms的外部定时器上，那么定时dutation
* 为20时定时时间就是20*50ms=1S
*/
voidsystem_tick_IrqHandler(void)
{
unsignedchar i = 0;

for(i =0 ;i <MAX_TIMER_NUM; i++)
{
      if(soft_timer.start_flag !=0 ) /* 判断当前定时器是否被开启  */
      {
         if(++soft_timer.counter >= soft_timer.duration)  /* 判断当前计时有没有到达 */
         {
            switch (soft_timer.timing_mode)
            {
            case ONCE_MODE:
                  soft_timer.start_flag = 0;
            break;
            case CONTINUE_MODE:
                  break;
            case DEFINE_NUM_MODE:
                  if (soft_timer.run_num > 0)
                  {
                     if (--soft_timer.run_num == 0)
                     {
                        soft_timer.start_flag = 0;
                     }
                  }
            default:
                  break;
            }
            if(soft_timer.run_mode == RUN_IN_INTERRUPT_MODE)
                  soft_timer.callback_function(); /* 中断内直接运行回调函数，用于实时性比较高的程序 */
            else
                  soft_timer.loop_flag = 1;
            soft_timer.counter = 0;
         }
         // else
         // {
         //    soft_timer.counter++;
         // }

      }
}
}