百度360必应搜狗淘宝本站头条
当前位置:网站首页 > 技术文章 > 正文

链表和结构体实现:MCU软件定时器(链表在单片机中的应用)

ccwgpt 2025-05-11 14:35 7 浏览 0 评论

在一般的嵌入式产品设计中,介于成本、功耗等,所选型的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循环内排队执行,可以非常有效的解决关键业务定时不精准的问题,比如脉冲输出这种需要定时准确的业务。

链表实现方式

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[i].start_flag == 0)    /* 查询空闲的定时器 */
        {
            soft_timer[i].start_flag = 1;
            soft_timer[i].counter = 0;
            soft_timer[i].loop_flag = 0;
            soft_timer[i].duration = duration;
            soft_timer[i].run_mode = run_mode;
            soft_timer[i].callback_function = callback_function;
            if ((soft_timer[i].timing_mode = timing_mode) == DEFINE_NUM_MODE)
                soft_timer[i].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[i].callback_function == callback_function)
        {
            soft_timer[i].start_flag = 0;
            soft_timer[i].loop_flag = 0;
        }
    }
}



/**
 * 系统main循环进程,用于执行轮询模式的回调函数
 */
voidsoft_timer_main_loop(void)
{
    unsignedchar i;
    for(i = 0; i <MAX_TIMER_NUM; i++)            /*  轮询执行回调函数  */
    {
        if(soft_timer[i].loop_flag == 1)
        {
            soft_timer[i].loop_flag= 0;
            soft_timer[i].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[i].start_flag !=0 )   /* 判断当前定时器是否被开启  */
        {
            if(++soft_timer[i].counter >= soft_timer[i].duration)  /* 判断当前计时有没有到达 */
            {
                switch (soft_timer[i].timing_mode)
                {
                case ONCE_MODE:
                    soft_timer[i].start_flag = 0;
                break;
                case CONTINUE_MODE:
                    break;
                case DEFINE_NUM_MODE:
                    if (soft_timer[i].run_num > 0)
                    {
                        if (--soft_timer[i].run_num == 0)
                        {
                            soft_timer[i].start_flag = 0;
                        }
                    }
                default:
                    break;
                }
                if(soft_timer[i].run_mode == RUN_IN_INTERRUPT_MODE)
                    soft_timer[i].callback_function();   /* 中断内直接运行回调函数,用于实时性比较高的程序 */
                else
                    soft_timer[i].loop_flag = 1;
                soft_timer[i].counter = 0;
            }
            // else
            // {
            //     soft_timer[i].counter++;
            // }
            
        }
    }
}

声明:本文素材来源网络,版权归原作者所有。如涉及作品版权问题,请与我联系删除。

相关推荐

定时任务工具,《此刻我要...》软件体验

之前果核给大家介绍过一款小众但实用的软件——小说规则下载器,可以把网页里的小说章节按照规则下载到本地,非常适合喜欢阅读小说的朋友。有意思的是,软件作者当时看到果核写的体验内容后,给反推荐到他的帖子里去...

前端定时任务的神库:Node-cron,让你的项目更高效!

在前端开发中,定时任务是一个常见的需求。无论是定时刷新数据、轮询接口,还是发送提醒,都需要一个可靠且灵活的定时任务解决方案。今天,我要向大家介绍一个强大的工具——Node-cron,它不仅能解决定时任...

Shutter Pro!一款多功能定时执行任务工具

这是一款可以在电脑上定时执行多种任务的小工具,使用它可以根据时间,电量等来设定一些定时任务,像定时打开程序、打开文件,定时关机重启,以及定时弹窗提醒等都可以轻松做到。这是个即开即用的小工具,无需安装,...

深度解析 Redis 缓存击穿及解决方案

在当今互联网大厂的后端开发体系中,Redis缓存占据着极为关键的地位。其凭借高性能、丰富的数据类型以及原子性操作等显著优势,助力众多高并发系统从容应对海量用户的访问冲击,已然成为后端开发从业者不可或...

从零搭建体育比分网站完整步骤(比较好的体育比分软件)

搭建一个体育比分网站是一个涉及前端、后端、数据源、部署和维护的完整项目。以下是从零开始搭建的详细流程:一、明确项目需求1.功能需求:实时比分展示(如足球、篮球、网球等)支持多个联赛和赛事历史数据查询比...

告别复杂命令行:GoCron 图形界面让定时任务触手可及

如果你是运维人员或者经常接触一些定时任务的配置,那么你一定希望有一款图形界面来帮助你方便的轻松配置定时任务,而GoCron就是这样一款软件,让你的配置可视化。什么是GoCron从名字你就可以大概猜到,...

Java任务管理框架核心技术解析与分布式高并发实战指南

在当今数字化时代,Java任务管理框架在众多应用场景中发挥着关键作用。随着业务规模的不断扩大,面对分布式高并发的复杂环境,掌握其核心技术并进行实战显得尤为重要。Java任务管理框架的核心技术涵盖多个方...

链表和结构体实现:MCU软件定时器(链表在单片机中的应用)

在一般的嵌入式产品设计中,介于成本、功耗等,所选型的MCU基本都是资源受限的,而里面的定时器的数量更是有限。在我们软件设计中往往有多种定时需求,例如脉冲输出、按键检测、LCD切屏延时等等,我们不可能...

SpringBoot定时任务(springboot定时任务每小时执行一次)

前言在我们开发中,经常碰到在某个时间点去执行某些操作,而我们不能人为的干预执行,这个时候就需要我们使用定时任务去完成该任务,下面我们来介绍下载springBoot中定时任务实现的方式。定时任务实现方式...

定时任务新玩法!systemd timer 完整实战详解

原文链接:「链接」Hello,大家好啊!今天给大家带来一篇使用systemdtimer实现定时任务调度的详细实战文章。相比传统的crontab,systemdtimer更加现代化、结构清晰...

Celery与Django:打造高效DevOps的定时任务与异步处理神器

本文详细介绍了Celery这一强大的异步任务队列系统,以及如何在Django框架中应用它来实现定时任务和异步处理,从而提高运维开发(DevOps)的效率和应用性能。下面我们先认识一下Cele...

订单超时自动取消的7种方案,我用这种!

前言在电商、外卖、票务等系统中,订单超时未支付自动取消是一个常见的需求。这个功能乍一看很简单,甚至很多初学者会觉得:"不就是加个定时器么?"但真到了实际工作中,细节的复杂程度往往会超...

裸机下多任务框架设计与实现(gd32裸机配置lwip 网络ping不通)

在嵌入式系统中,特别是在没有操作系统支持的裸机环境下,实现多任务执行是一个常见的挑战。本文将详细介绍一种基于定时器的多任务框架设计,通过全局时钟和状态机机制,实现任务的非阻塞调度,确保任务执行中不会出...

亿级高性能通知系统构建,小白也能拿来即用

作者介绍赵培龙,采货侠JAVA开发工程师分享概要一、服务划分二、系统设计1、首次消息发送2、重试消息发送三、稳定性的保障1、流量突增2、问题服务的资源隔离3、第三方服务的保护4、中间件的容错5、完善...

运维实战:深度拆解Systemd定时任务原理,90%的人不知道的玩法

运维实战:深度拆解Systemd定时任务原理,90%的人不知道的高效玩法一、Systemd定时任务的核心原理Systemd定时任务是Linux系统中替代传统cron的现代化解决方案,通过...

取消回复欢迎 发表评论: