面包芯语

嵌入式软件实现定时器的两种方式

一起学嵌入式 2023-05-01 07:36
超低功耗CW32L083系列 热管理技术新标杆：ST维也纳PFC与FOC控制方案深度解析
扫描关注一起学嵌入式，一起学习，一起成长


简介

在一般的嵌入式产品设计中，介于成本、功耗等，所选型的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


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

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

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

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

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

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

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


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

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


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


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

#endif /* !1__SOFT_TIMER_LIST_H */

C文件：

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

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

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

static struct SoftTimer *creat_node(SoftTimer *node);
static char delete_node(SoftTimer *node);
static BOOL is_node_already_creat(SoftTimer *node);


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

/**
 * 系统main循环进程，用于执行轮询模式的回调函数
 */
void soft_timer_main_loop(void)
{
    struct SoftTimer *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：无
 */
void creat_single_soft_timer(SoftTimer *p, TimerRunModeType mode, unsigned long 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：无
 */
void creat_continue_soft_timer(SoftTimer *p, TimerRunModeType mode, unsigned long 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：无
 */
void creat_limit_num_soft_timer(SoftTimer *p, TimerRunModeType mode,unsigned long run_num, unsigned long 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：无
 */
void restart_single_soft_timer(SoftTimer *p, TimerRunModeType mode, unsigned long 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);
}


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


static struct SoftTimer *creat_node(SoftTimer *node)
{  
    struct SoftTimer *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;  
}


static char delete_node(SoftTimer *node)
{  
    struct SoftTimer *p1;   //p1保存当前需要检查的节点的地址  
    struct SoftTimer *temp;
    if(node == NULL)
       return 1;

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


static BOOL is_node_already_creat(SoftTimer *node)
{  
    struct SoftTimer *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
 */
void system_tick_IrqHandler(void)
{
    struct SoftTimer *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


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


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


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



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



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



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



/**
 * 此函数为tick中断服务函数，需要挂载在外部硬件定时器上
 * 因此软件定时器的定时精度由此函数挂载的硬件定时时间决定，
 * 比如此函数挂载在定时50ms的外部定时器上，那么定时dutation
 * 为20时定时时间就是20*50ms=1S
 */
extern void system_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
 */
char soft_timer_start(TimerTimingModeType timing_mode, TimerRunModeType run_mode, unsigned long run_num, unsigned long duration,
                      void (*callback_function)(void))
{
    unsigned char i = 0;

    if(!callback_function) return 1;
    stop_timer(callback_function);     /* 先判断有没有一样的定时器，有的话先删除  */
    for(i =0; 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 )    /* 没有空闲定时器 */
            return 1;
    }
    return 0;
}


/**
 * 删除一个软件定时器
 */
void stop_timer(void (*callback_function)(void))
{
    unsigned char i;
    for(i = 0; i     {
        if(soft_timer[i].callback_function == callback_function)
        {
            soft_timer[i].start_flag = 0;
            soft_timer[i].loop_flag = 0;
        }
    }
}

/**
 * 系统main循环进程，用于执行轮询模式的回调函数
 */
void soft_timer_main_loop(void)
{
    unsigned char i;
    for(i = 0; 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
 */
void system_tick_IrqHandler(void)
{
    unsigned char i = 0;
    
    for(i =0 ;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++;
            // }
            
        }
    }
}

原文：https://blog.csdn.net/qq_35333978/article/details/105173876

文章来源于网络，版权归原作者所有，如有侵权，请联系删除。



个人微信开放，扫码添加，进高质量嵌入式交流群


关注我【一起学嵌入式】，一起学习，一起成长。

觉得文章不错，点击“分享”、“赞”、“在看” 呗！

登录阅读全文
免责声明： 该内容由专栏作者授权发布或作者转载，目的在于传递更多信息，并不代表本网赞同其观点，本站亦不保证或承诺内容真实性等。若内容或图片侵犯您的权益，请及时联系本站删除。侵权投诉联系：  nick.zong@aspencore.com！
一起学嵌入式 公众号【一起学嵌入式】，RTOS、Linux编程、C/C++，以及经验分享、行业资讯、物联网等技术知
评论 （0）
  • 【拆解】无线入耳式蓝牙耳机，从浅到深的认识
    这款无线入耳式蓝牙耳机是长这个样子的，如下图。侧面特写，如下图。充电接口来个特写，用的是卡座卡在PCB板子上的，上下夹紧PCB的正负极，如下图。撬开耳机喇叭盖子，如下图。精致的喇叭(HY)，如下图。喇叭是由电学产生声学的，具体结构如下图。电池包（AFS 451012  21 12），用黄色耐高温胶带进行包裹（安规需求），加强隔离绝缘的，如下图。451012是电池包的型号，聚合物锂电池+3.7V 35mAh，详细如下图。电路板是怎么拿出来的呢，剪断喇叭和电池包的连接线，底部抽出PCB板子
    liweicheng 2025-05-06 22:58 576浏览
  • 不同类型温度传感器的工作原理
    温度传感器的工作原理依据其类型可分为以下几种主要形式：一、热电阻温度传感器利用金属或半导体材料的电阻值随温度变化的特性实现测温：l ‌金属热电阻‌（如铂电阻 Pt100、Pt1000）：高温下电阻值呈线性增长，稳定性高，适用于工业精密测温。l ‌热敏电阻‌（NTC/PTC）：NTC 热敏电阻阻值随温度升高而下降，PTC 则相反；灵敏度高但线性范围较窄，常用于电子设备温控。二、热电偶传感器基于‌塞贝克效应‌（Seebeck effect）：两种不同
    锦正茂科技 2025-05-09 13:31 184浏览
  • 钱程“豪赌”多元化，科沃斯去年业绩回暖，但越来越不赚钱
    文/Leon编辑/cc孙聪颖‍《中国家族企业传承研究报告》显示，超四成“企二代” 明确表达接班意愿，展现出对家族企业延续发展的主动担当。中国研究数据服务平台（CNRDS）提供的精准数据进一步佐证：截至 2022 年，已有至少 280 家上市家族企业完成权杖交接，其中八成新任掌门人为创始人之子，凸显家族企业代际传承中 “子承父业” 的主流模式。然而，对于“企二代” 而言，接棒掌舵绝非易事。在瞬息万变的商业环境中，他们既要在白热化的市场竞争中开拓创新、引领企业突破发展瓶颈，又需应对来自父辈管理层的经
    华尔街科技眼 2025-05-06 18:17 28浏览
  • 飞凌嵌入式携手龙芯发布2K0300i核心板，全国产自主可控新选择
    飞凌嵌入式作为龙芯合作伙伴，隆重推出FET-2K0300i-S全国产自主可控工业级核心板！FET-2K0300i-S核心板基于龙芯2K0300i工业级处理器开发设计，集成1个64位LA264处理器，主频1GHz，提供高效的计算能力；支持硬件ECC；2K0300i还具备丰富的连接接口USB、SDIO、UART、SPI、CAN-FD、Ethernet、ADC等一应俱全，龙芯2K0300i支持四路CAN-FD接口，具备良好的可靠性、实时性和灵活性，可满足用户多路CAN需求。除性价比超高的国产处理器外，
    飞凌嵌入式 2025-05-07 11:54 86浏览
  • 京东外卖狂飙背后：百亿补贴难掩四小短板
    在过去的很长一段时间里，外卖市场呈现出美团和饿了么双寡头垄断的局面。美团凭借先发优势、强大的地推团队以及精细化的运营策略，在市场份额上长期占据领先地位。数据显示，截至2024年上半年，美团外卖以68.2%的市场份额领跑外卖行业，成为当之无愧的行业老大。其业务广泛覆盖，从一线城市的繁华商圈到二三线城市的大街小巷，几乎无处不在，为无数消费者提供便捷的外卖服务。饿了么作为阿里本地生活服务的重要一环，依托阿里强大的资金和技术支持，也在市场中站稳脚跟，以25.4%的份额位居第二。尽管市场份额上与美团有一定
    用户1742991715177 2025-05-06 19:43 92浏览
  • 紫光展锐全新奇迹手游引擎，开启游戏“芯”时代
    UNISOC Miracle Gaming奇迹手游引擎亮点：• 高帧稳帧：支持《王者荣耀》等主流手游90帧高画质模式，连续丢帧率最高降低85%;• 丝滑操控：游戏冷启动速度提升50%，《和平精英》开镜开枪操作延迟降低80%;• 极速网络：专属游戏网络引擎，使《王者荣耀》平均延迟降低80%;• 智感语音：与腾讯GVoice联合，弱网环境仍能保持清晰通话;• 超高画质：游戏画质增强、超级HDR画质、游戏超分技术，优化游戏视效。全球手游市场规模日益壮大，游戏玩家对极致体验的追求愈发苛刻。紫光展锐全新U
    紫光展锐 2025-05-07 17:07 296浏览
  • 【拆解】行车记录仪后摄像头，挺神奇的
    后摄像头是长这个样子，如下图。5孔（D-,D+,5V,12V,GND），说的是连接线的个数，如下图。4LED，+12V驱动4颗LED灯珠，给摄像头补光用的，如下图。打开后盖，发现里面有透明白胶（防水）和白色硬胶（固定），用合适的工具，清理其中的胶状物。BOT层，AN3860，Panasonic Semiconductor （松下电器）制造的，Cylinder Motor Driver IC for Video Camera，如下图。TOP层，感光芯片和广角聚焦镜头组合，如下图。感光芯片，看着是玻
    liweicheng 2025-05-07 23:55 377浏览
  • Matter协议，智能家居生态平台的“共生契约”
    Matter协议是一个由Amazon Alexa、Apple HomeKit、Google Home和Samsung SmartThings等全球科技巨头与CSA联盟共同制定的开放性标准，它就像一份“共生契约”，能让原本相互独立的家居生态在应用层上握手共存，同时它并非另起炉灶，而是以IP（互联网协议）为基础框架，将不同通信协议下的家居设备统一到同一套“语义规则”之下。作为应用层上的互通标准，Matter协议正在重新定义智能家居行业的运行逻辑，它不仅能向下屏蔽家居设备制造商的生态和系统，让设备、平
    华普微HOPERF 2025-05-08 11:40 326浏览
  • 车载AI算力需求激增，紫光国芯车规级LPDDR4如何满足低功耗高性能？
    随着智能驾驶时代到来，汽车正转变为移动计算平台。车载AI技术对存储器提出新挑战：既要高性能，又需低功耗和车规级可靠性。贞光科技代理的紫光国芯车规级LPDDR4存储器，以其卓越性能成为国产芯片产业链中的关键一环，为智能汽车提供坚实的"记忆力"支持。作为官方授权代理商，贞光科技通过专业技术团队和完善供应链，让这款国产存储器更好地服务国内汽车厂商。本文将探讨车载AI算力需求现状及贞光科技如何通过紫光国芯LPDDR4产品满足市场需求。 车载AI算力需求激增的背景与挑战智能驾驶推动算力需求爆发式
    贞光科技 2025-05-07 16:54 196浏览
  • 利亚德净利暴跌、市值缩水，“羞愧”的董事长李军难翻盘
    文/郭楚妤编辑/cc孙聪颖‍相较于一众措辞谨慎、毫无掌舵者个人风格的上市公司财报，利亚德的财报显得尤为另类。利亚德光电集团成立于1995年，是一家以LED显示、液晶显示产品设计、生产、销售及服务为主业的高新技术企业。自2016年年报起，无论业绩优劣，董事长李军每年都会在财报末尾附上一首七言打油诗，抒发其对公司当年业绩的感悟。从“三年翻番顺大势”“智能显示我第一”“披荆斩棘幸从容”等词句中，不难窥见李军的雄心壮志。2012年，利亚德（300296.SZ）在深交所创业板上市。成立以来，该公司在细分领
    华尔街科技眼 2025-05-07 19:25 395浏览
  • 二位半 5线数码管的驱动方法
    二位半 5线数码管的驱动方法这个2位半的7段数码管只用5个管脚驱动。如果用常规的7段+共阳/阴则需要用10个管脚。如果把每个段看成独立的灯。5个管脚来点亮，任选其中一个作为COM端时，另外4条线可以单独各控制一个灯。所以实际上最多能驱动5*4 = 20个段。但是这里会有一个小问题。如果想点亮B1，可以让第3条线（P3）置高，P4 置低，其它阳极连P3的灯对应阴极P2 P1都应置高，此时会发现C1也会点亮。实际操作时，可以把COM端线P3设置为PP输出，其它线为OD输出。就可以单独控制了。实际的驱
    southcreek 2025-05-07 15:06 472浏览
  • 什么是硅二极管温度传感器
    硅二极管温度传感器是一种基于硅半导体材料特性的测温装置，其核心原理是利用硅二极管的电学参数（如正向压降或电阻）随温度变化的特性实现温度检测。以下是其工作原理、技术特点及典型应用：一、工作原理1、‌PN结温度特性‌硅二极管由PN结构成，当温度变化时，其正向电压 VF与温度呈线性负相关关系。例如，温度每升高1℃，VF约下降2 mV。2、‌电压—温度关系‌通过jing确测量正向电压的微小变化，可推算出环境温度值。部分型号（如SI410）在宽温域内（如1.4 K至475 K）仍能保持高线性度。
    锦正茂科技 2025-05-09 13:52 193浏览
我要评论
0
0
点击右上角，分享到朋友圈 我知道啦
请使用浏览器分享功能 我知道啦