【基于链表的软件定时器实现】

已于 2022-06-08 19:20:04 修改
阅读量801 收藏 9
点赞数 3
分类专栏： 嵌入式 文章标签： 链表 单片机 c语言
于 2022-05-24 20:59:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Linux_LR/article/details/123383429
版权

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

目录

1. 应用需求
1.1 背景
  • 主要是针对单片机的开发，一般单片机的硬件定时器是有限的，不太可能有一个定时任务就用硬件定时器实现。
1.2 前提
  • 有一个已经实现的硬件定时器在进行计数。（本文的实现是基于time.h的库进行获取的时间）
1.3 功能
  • 支持根据参数设置的优先级进行顺序插入，优先级的值越小，则轮询定时器的时候会更快执行。
  • 支持配置软件定时器的定时时间，可以有两种模式配置，一种是持续性的自动装载，另外一种是设置重复运行的次数。
2. 功能实现
2.1 头文件定义
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "time.h"

//所用的参数类型定义
typedef unsigned char       uint8_t;
typedef unsigned short      uint16_t;
typedef unsigned long       uint32_t;

//超时回调函数,无参数无返回值
typedef void (*TimeoutCb)(void);

//软件定时器属性
typedef struct
{
    uint8_t id;                 //软件定时器ID
    uint8_t priority;           //软件定时器优先级
    uint16_t mode;              //BIT15:1表示无限制连续重载,0表示启用重载次数,此时BIT[14:0]表示重载的次数
    uint16_t timeout;           //定时时间
    uint32_t startTimer;        //设置软件定时器的起始时间
    TimeoutCb timeoutFun;       //软件定时的超时回调
} SoftTimer;

//软件定时器节点
typedef struct _SoftTimerNode
{
    SoftTimer property;
    struct _SoftTimerNode *next;
} SoftTimerNode;
2.2 源文件功能
2.2.1 链表头的定义
//初始化一个软件定时器链表默认指向空
static SoftTimerNode *s_softTimerHead = NULL;
2.2.2 基准定时器的参考
  • 在单片机的应用中，单片机中应该有一个基准定时器进行计数，可供外部文件获取计数值。本文中直接从系统中获取一个utc时间，模拟计数值的产生。
  • 检测软件定时器是否超时，这里要特别注意溢出的情况，本文中实现没有考虑这个问题，实际应用中根据情况而定。
//获取系统当前UTC时间
uint32_t GetTimerCount(void)
{
    time_t utcTimer = 0;

    time(&utcTimer);

    return utcTimer;
}

//软件定时器是否超时
uint8_t IsSoftTimerTimeout(SoftTimer *softTimer)
{
    return ((softTimer->startTimer + softTimer->timeout) <= GetTimerCount());
}
2.2.3 获取软件定时器的个数
  • 如果链表是空的话，直接返回0，表示没有定时器。
  • 如果链表存在，则返回实际的软件定时器个数。
//获取软件定时器链表的长度
uint32_t GetSoftTimerCount(void)
{
    SoftTimerNode *cur = NULL;
    uint32_t cnt = 0;

    if (s_softTimerHead == NULL)
    {
        return 0;
    }

    cur = s_softTimerHead;
    //下一个数据不为空
    while (cur->next != NULL)
    {
        cnt++;
        cur = cur->next;
    }

    return 1 + cnt;
}
2.2.4 查找软件定时器的位置
  • 主要用于查找固定的定时器ID是否存在于当前链表的位置，如果不存在返回一个-1。
  • 如果链表中存在这个名称为ID的软件定时器，则返回当前存在的位置。这个位置从0开始表示，即链表头指向的是第一个数据，此时位置为0。
//查找定时器ID的位置
int SearchSoftTimerById(uint8_t id)
{
    SoftTimerNode *cur = NULL;
    int pos = 0;

    if (s_softTimerHead == NULL)
    {
        return -1;
    }

    cur = s_softTimerHead;
    for (;;)
    {
        if (cur->property.id == id)
        {
            break;
        }

        if (cur->next == NULL)
        {
            pos = -1;            //找不到位置
            break;
        }

        cur = cur->next;
        pos++;
    }

    return pos;
}
2.2.5 根据优先级判断应该插入的位置
  • 主要用于判断当前优先级应该位于链表的哪个位置，这个位置从0开始表示，即链表头指向的是第一个数据，此时位置为0。
  • 链表的排放顺序是按照优先级进行顺序排放，优先级的参数值越小，则插入的位置应该越靠前。
  • 如果优先级是相同的，则放在相同优先级结点的最后一个位置。
//获取插入的位置
uint32_t GetInsertPosByPriority(uint16_t priority)
{
    SoftTimerNode *cur = NULL;
    uint32_t pos = 0;

    if (s_softTimerHead == NULL)
    {
        return pos;           //插入在头部
    }

    cur = s_softTimerHead;
    for (;;)
    {
        //优先级比当前的结点要高
        if (priority < cur->property.priority)
        {
            break;
        }

        pos++;
        if (cur->next == NULL)
        {
            break;
        }

        cur = cur->next;
    }

    return pos;
}
2.2.6 删除一个软件定时器
  • 软件ID应该是唯一的，类似于软件定时的名称
//删除软件ID为id的软件定时器
void DeleteSoftTimer(uint8_t id)
{
    SoftTimerNode *del = NULL;
    SoftTimerNode *cur = NULL;
    int pos = 0;
    int i = 0;

    pos = SearchSoftTimerById(id);
    if (pos < 0)
    {
        //不存在当前ID
        return;
    }

    if (pos == 0)
    {
        //删除头结点
        del = s_softTimerHead;
        s_softTimerHead = s_softTimerHead->next;
        free(del);
        return;
    }

    cur = s_softTimerHead;
    //删除非头部结点
    for (i = 0; i < pos - 1; i++)
    {
        cur = cur->next;
    }

    del = cur->next;
    cur->next = del->next;
    free(del);

    return;
}
2.2.7 创建一个软件定时器
  • 如果当前软件ID是重名的，会将重名的软件定时器删掉并用新创建的替代。
//创建软件定时器
void CreatSoftTimer(SoftTimer *softTimer)
{
    SoftTimerNode *prev = NULL;
    SoftTimerNode *cur = NULL;
    SoftTimerNode *add = NULL;
    uint32_t pos = 0;
    uint32_t i = 0;

    //动态分配空间
    add = (SoftTimerNode*)malloc(sizeof(SoftTimerNode));
    if (add == NULL)
    {
        return;
    }

    //生成结点
    memcpy(&add->property, softTimer, sizeof(SoftTimerNode));
    add->next = NULL;

    //如果当前软件定时器ID存在则会直接删除
    DeleteSoftTimer(softTimer->id);

    //获取插入的位置
    pos = GetInsertPosByPriority(softTimer->priority);
    if (pos == 0)
    {
        add->next = s_softTimerHead;
        s_softTimerHead = add;
        return;
    }

    //插入的位置不是头部
    cur = s_softTimerHead;
    for (i = 0; i < pos - 1; i++)
    {
        cur = cur->next;
    }

    add->next = cur->next;
    cur->next = add;
    return;
}
2.2.8 轮询软件定时器
  • 这个接口一般放在主函数中轮询调用，如果检测到计数时间到了，则运行软件定时器的回调函数。
  • 如果软件定时器是连续自动重载的，在每次执行回调之后会在下一个超时继续执行。
  • 如果软件定时器是设置的重载次数，则在重载次数清0之后，会自动删除该软件定时器。实际运行次数是重载次数+1。即设置的重载次数为0会执行1次。
//运行软件定时器
void RunSoftTimer(void)
{
    SoftTimerNode *cur = NULL;
    uint32_t reload = 0;

    if (s_softTimerHead == NULL)
    {
        return;
    }

    cur = s_softTimerHead;
    for (;;)
    {
        if (IsSoftTimerTimeout(&cur->property))
        {
            if (cur->property.timeoutFun != NULL)
            {
                cur->property.timeoutFun();
            }

            if (cur->property.mode & (1 << 15))     //自动重载
            {
                reload = GetTimerCount();
                printf("[%d]+++ soft timer auto reload %d - %d = %d\r\n", cur->property.id,
                    reload, cur->property.startTimer, reload - cur->property.startTimer);
                cur->property.startTimer = reload;
            }
            else if (cur->property.mode > 0)
            {
                cur->property.mode--;               //限制重载次数
                reload = GetTimerCount();
                printf("[%d]+++ soft timer remain reload %d, %d - %d = %d\r\n", cur->property.id, cur->property.mode,
                    reload, cur->property.startTimer, reload - cur->property.startTimer);
                cur->property.startTimer = reload;
            }
            else
            {
                printf("[%d]--- soft timer auto delete\r\n", cur->property.id);
                DeleteSoftTimer(cur->property.id);     //删除该结点
            }
        }

        if (cur->next == NULL)
        {
            break;
        }

        cur = cur->next;
    }

    return;
}
3. 功能测试
3.1 打印软件定时器链表信息
//显示软件定时器列表
void ShowSoftTimerList(void)
{
    SoftTimerNode *cur = NULL;
    uint32_t i = 0;
    uint32_t count = 0;

    cur = s_softTimerHead;
    count = GetSoftTimerCount();
    printf("soft timer totol count: %d\r\n", count);
    printf("------------------------------------------------------------------------\r\n");
    for (i = 0; i < GetSoftTimerCount(); i++)
    {

        printf("[%d]: addr = %08X, id = %d; priority = %d; mode = %d, timeout = %d, startTimer = %d, next = %08X\r\n", cur->property.id, cur,
                cur->property.id, cur->property.priority, cur->property.mode, cur->property.timeout, cur->property.startTimer, cur->next);
        cur = cur->next;
    }
    printf("------------------------------------------------------------------------\r\n");

    return;
}
3.2 测试函数
int main()
{
    uint8_t i = 0;
    uint8_t optMode = 0;
    SoftTimer softTimer = {0};
    SoftTimer softTimerList[] = {
        {0, 4, 4, 4, 0, NULL},      //测试插入一个结点
        {0, 7, 7, 7, 0, NULL},      //测试插入同名结点
        {2, 3, 3, 3, 0, NULL},      //测试头部插入
        {3, 8, 8, 8, 0, NULL},      //测试尾部插入
        {4, 7, 7, 7, 0, NULL},      //测试中间插入且为同优先级
        {5, 1, 1, 1, 0, NULL},      //优先级最高测试删除头
        {6, 9, 9, 9, 0, NULL},      //优先级最低测试删除头
        {7, 5, 5, 5, 0, NULL},      //在中间删除一个优先级
    };

    for (i = 0; i < sizeof(softTimerList) / sizeof(SoftTimer); i++)
    {
        printf("[%d]+++ Creat soft timer. ", softTimerList[i].id);
        softTimerList[i].startTimer = GetTimerCount();
        CreatSoftTimer(&softTimerList[i]);
        ShowSoftTimerList();
    }

    for (i = 0; i < 3; i++)
    {
        printf("[%d]--- Delete soft timer. ", softTimerList[sizeof(softTimerList) / sizeof(SoftTimer) -1 - i].id);
        softTimerList[sizeof(softTimerList) / sizeof(SoftTimer) -1 - i].startTimer = GetTimerCount();
        DeleteSoftTimer(softTimerList[sizeof(softTimerList) / sizeof(SoftTimer) -1 - i].id);
        ShowSoftTimerList();
    }

    do
    {
        RunSoftTimer();
    } while (GetSoftTimerCount());

    printf("All software timers are automatically released!\r\n");

    return 0;
}
3.3 测试结果
[0]+++ Creat soft timer. soft timer totol count: 1
------------------------------------------------------------------------
[0]: addr = 001713E0, id = 0; priority = 4; mode = 4, timeout = 4, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[0]+++ Creat soft timer. soft timer totol count: 1
------------------------------------------------------------------------
[0]: addr = 00171410, id = 0; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[2]+++ Creat soft timer. soft timer totol count: 2
------------------------------------------------------------------------
[2]: addr = 001713E0, id = 2; priority = 3; mode = 3, timeout = 3, startTimer = 1653389188, next = 00171410
[0]: addr = 00171410, id = 0; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[3]+++ Creat soft timer. soft timer totol count: 3
------------------------------------------------------------------------
[2]: addr = 001713E0, id = 2; priority = 3; mode = 3, timeout = 3, startTimer = 1653389188, next = 00171410
[0]: addr = 00171410, id = 0; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171440
[3]: addr = 00171440, id = 3; priority = 8; mode = 8, timeout = 8, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[4]+++ Creat soft timer. soft timer totol count: 4
------------------------------------------------------------------------
[2]: addr = 001713E0, id = 2; priority = 3; mode = 3, timeout = 3, startTimer = 1653389188, next = 00171410
[0]: addr = 00171410, id = 0; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171470
[4]: addr = 00171470, id = 4; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171440
[3]: addr = 00171440, id = 3; priority = 8; mode = 8, timeout = 8, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[5]+++ Creat soft timer. soft timer totol count: 5
------------------------------------------------------------------------
[5]: addr = 001714A0, id = 5; priority = 1; mode = 1, timeout = 1, startTimer = 1653389188, next = 001713E0
[2]: addr = 001713E0, id = 2; priority = 3; mode = 3, timeout = 3, startTimer = 1653389188, next = 00171410
[0]: addr = 00171410, id = 0; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171470
[4]: addr = 00171470, id = 4; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171440
[3]: addr = 00171440, id = 3; priority = 8; mode = 8, timeout = 8, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[6]+++ Creat soft timer. soft timer totol count: 6
------------------------------------------------------------------------
[5]: addr = 001714A0, id = 5; priority = 1; mode = 1, timeout = 1, startTimer = 1653389188, next = 001713E0
[2]: addr = 001713E0, id = 2; priority = 3; mode = 3, timeout = 3, startTimer = 1653389188, next = 00171410
[0]: addr = 00171410, id = 0; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171470
[4]: addr = 00171470, id = 4; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171440
[3]: addr = 00171440, id = 3; priority = 8; mode = 8, timeout = 8, startTimer = 1653389188, next = 001714D0
[6]: addr = 001714D0, id = 6; priority = 9; mode = 9, timeout = 9, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[7]+++ Creat soft timer. soft timer totol count: 7
------------------------------------------------------------------------
[5]: addr = 001714A0, id = 5; priority = 1; mode = 1, timeout = 1, startTimer = 1653389188, next = 001713E0
[2]: addr = 001713E0, id = 2; priority = 3; mode = 3, timeout = 3, startTimer = 1653389188, next = 00171500
[7]: addr = 00171500, id = 7; priority = 5; mode = 5, timeout = 5, startTimer = 1653389188, next = 00171410
[0]: addr = 00171410, id = 0; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171470
[4]: addr = 00171470, id = 4; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171440
[3]: addr = 00171440, id = 3; priority = 8; mode = 8, timeout = 8, startTimer = 1653389188, next = 001714D0
[6]: addr = 001714D0, id = 6; priority = 9; mode = 9, timeout = 9, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[7]--- Delete soft timer. soft timer totol count: 6
------------------------------------------------------------------------
[5]: addr = 001714A0, id = 5; priority = 1; mode = 1, timeout = 1, startTimer = 1653389188, next = 001713E0
[2]: addr = 001713E0, id = 2; priority = 3; mode = 3, timeout = 3, startTimer = 1653389188, next = 00171410
[0]: addr = 00171410, id = 0; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171470
[4]: addr = 00171470, id = 4; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171440
[3]: addr = 00171440, id = 3; priority = 8; mode = 8, timeout = 8, startTimer = 1653389188, next = 001714D0
[6]: addr = 001714D0, id = 6; priority = 9; mode = 9, timeout = 9, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[6]--- Delete soft timer. soft timer totol count: 5
------------------------------------------------------------------------
[5]: addr = 001714A0, id = 5; priority = 1; mode = 1, timeout = 1, startTimer = 1653389188, next = 001713E0
[2]: addr = 001713E0, id = 2; priority = 3; mode = 3, timeout = 3, startTimer = 1653389188, next = 00171410
[0]: addr = 00171410, id = 0; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171470
[4]: addr = 00171470, id = 4; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171440
[3]: addr = 00171440, id = 3; priority = 8; mode = 8, timeout = 8, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[5]--- Delete soft timer. soft timer totol count: 4
------------------------------------------------------------------------
[2]: addr = 001713E0, id = 2; priority = 3; mode = 3, timeout = 3, startTimer = 1653389188, next = 00171410
[0]: addr = 00171410, id = 0; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171470
[4]: addr = 00171470, id = 4; priority = 7; mode = 7, timeout = 7, startTimer = 1653389188, next = 00171440
[3]: addr = 00171440, id = 3; priority = 8; mode = 8, timeout = 8, startTimer = 1653389188, next = 00000000
------------------------------------------------------------------------
[2]+++ soft timer remain reload 2, 1653389191 - 1653389188 = 3
[2]+++ soft timer remain reload 1, 1653389194 - 1653389191 = 3
[4]+++ soft timer remain reload 6, 1653389195 - 1653389188 = 7
[0]+++ soft timer remain reload 6, 1653389195 - 1653389188 = 7
[3]+++ soft timer remain reload 7, 1653389196 - 1653389188 = 8
[2]+++ soft timer remain reload 0, 1653389197 - 1653389194 = 3
[2]--- soft timer auto delete
[0]+++ soft timer remain reload 5, 1653389202 - 1653389195 = 7
[4]+++ soft timer remain reload 5, 1653389202 - 1653389195 = 7
[3]+++ soft timer remain reload 6, 1653389204 - 1653389196 = 8
[0]+++ soft timer remain reload 4, 1653389209 - 1653389202 = 7
[4]+++ soft timer remain reload 4, 1653389209 - 1653389202 = 7
[3]+++ soft timer remain reload 5, 1653389212 - 1653389204 = 8
[4]+++ soft timer remain reload 3, 1653389216 - 1653389209 = 7
[0]+++ soft timer remain reload 3, 1653389216 - 1653389209 = 7
[3]+++ soft timer remain reload 4, 1653389220 - 1653389212 = 8
[0]+++ soft timer remain reload 2, 1653389223 - 1653389216 = 7
[4]+++ soft timer remain reload 2, 1653389223 - 1653389216 = 7
[3]+++ soft timer remain reload 3, 1653389228 - 1653389220 = 8
[0]+++ soft timer remain reload 1, 1653389230 - 1653389223 = 7
[4]+++ soft timer remain reload 1, 1653389230 - 1653389223 = 7
[3]+++ soft timer remain reload 2, 1653389236 - 1653389228 = 8
[0]+++ soft timer remain reload 0, 1653389237 - 1653389230 = 7
[4]+++ soft timer remain reload 0, 1653389237 - 1653389230 = 7
[4]--- soft timer auto delete
[3]+++ soft timer remain reload 1, 1653389244 - 1653389236 = 8
[0]--- soft timer auto delete
[3]+++ soft timer remain reload 0, 1653389252 - 1653389244 = 8
[3]--- soft timer auto delete
All software timers are automatically released!

2022-05-24 李不清的烦恼，总结篇。

李不清的烦恼
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
uCOS2 内部软件定时器实现
09-10
### uCOS2内部软件定时器实现解析 #### 一、引言 uCOS2是一款广泛应用的嵌入式实时操作系统，其稳定性和高效性在工业控制领域得到了广泛认可。随着技术的发展，uCOS2也在不断地更新和完善自己的功能，其中软件...
【嵌入式 MultiTimer】软件定时器原理+单向链表的使用详解
欢迎私信、留言交流
09-14 729
MultiTimer 的代码少，非常适合拿来学习单链表的操作，用此实例学习大佬是如何操作单链表的。 > MultiTimer 是一个软件定时器扩展模块，可无限扩展你所需的定时器任务，取代传统的标志位判断方式， 更优雅更便捷地管理程序的时间触发时序。
基于单向链表结构的软件虚拟定时器的设计与构建
u013441358的专栏
07-30 438
本文设计的软件虚拟定时器就是基于一个单向链表进行管理的。通过SList_Traversal方法可以遍历链表的节点并执行注册的回调函数。在回调函数中可以实现数据的类型还原、定时器状态更新等一系列的处理。通过SList_PushTail方法实现链表的节点添加（注册新的定时器），通过SList_RemoveNode方法实现链表的节点删除（移除注册的定时器）。具体的实现可以参考软件定时器的源码。...
C程序设计：基于双向链表的软件定时器
weixin_42549534的博客
07-06 400
基于双向链表的软件定时器是一种常见的实现方式，它可以在操作系统或应用程序中用于管理定时任务。双向链表是一种数据结构，它包含指向前一个节点和后一个节点的指针。在软件定时器的实现中，每个定时任务可以表示为一个节点，节点中包含定时任务的信息，如定时时间、回调函数等。软件定时器可以被添加到硬件定时器中，主线程循环中，另开线程中。
定时器--函数链表
保持每天的清醒
01-18 474
定时器函数链表，减少其他文件与定时器中断文件的耦合
升序定时器的时间链表的完全实现
李邦柱的专栏
07-02 2860
本文详细阐述了定时器的原理，使用方法，以及示例代码，定时器通常包含至少两个成员：一个超时时间（通常采用相对时间或者超时时间）和一个超时时间到达后的一个回调函数。
FreeRTOS学习-软件定时器管理
Duran.L的专栏
02-19 1022
软件定时器用于在未来的某个时间执行某个预先指定的函数，或者以一个固定的频率周期性调度该函数。这个预先指定的函数称为软件定时器回调函数, 它是由软件定时器服务调用的.软件定时器由FreeRTOS的内核控制，不需要硬件的支持，不与硬件定时器和硬件计数器关联。
适用于嵌入式的软件定时器最佳实现方式
风吹花中花吹风的博客
03-29 1302
适用于嵌入式的软件定时器最佳实现方式 简介 在一般的嵌入式产品设计中，介于成本、功耗等，所选型的MCU基本都是资源受限的，而里面的定时器的数量更是有限。在我们软件设计中往往有多种定时需求，例如脉冲输出、按键检测、LCD切屏延时等等 ，我们不可能让每一个定时业务都去开一个硬件定时器，一来硬件资源可能不足，二来会使软件过度依赖于硬件平台，从而导致较差的可移植性。 而若我们有一个软件定时器，所有定时业务...
基于侵入式链表实现高效时间片轮询.rar
10-14
在STM32等微控制器中，由于资源有限，软件定时器经常被用来模拟硬件定时器，以实现时间片轮询。软件定时器通常由中断服务例程驱动，当到达预设时间时触发中断，然后进行任务切换。侵入式链表在此处的作用是将待处理...
多软件定时器管理模块.rar
09-09
而在单片机环境中，由于没有操作系统，软件定时器往往基于中断或轮询机制，通过计数器计数达到预设值后触发事件。 本资源提供的“多软件定时器管理模块”已经在多个项目中得到验证，表明其具有高度的稳定性和可靠性...
时间轮定时器java实现
02-22
而实现基于时间轮的定时器，你需要创建一个二维数组或链表，表示时间轮的不同环。每个任务需要一个唯一的ID，这个ID与时间轮的槽位关联，根据任务的延迟时间计算出对应的槽位。当时间轮的指针移动到某个槽位时，触发...
STM32-C51-单片机-软件定时器
03-09
STM32-C51单片机的软件定时器是一种基于硬件定时器的软件实现机制，它利用了单片机内部的硬件资源，如TIM模块，来实现定时功能，并通过链表结构来管理和调度多个定时器任务。下面将详细介绍这一技术及其相关知识点。...
【网络编程】定时器的应用：基于升序链表的定时器处理非活动连接
lrzHHl的博客
08-05 173
在接下来的对于非活动连接的处理方面，我们将每一对服务端和客户端之间的连接相关的连接数据保存下来，并且加上其超时时间共同打包到上述数据结构的单个节点中。首先我们实现一个数据结构用来存储定时器，它是一个升序的双向链表。同时，我们设置了统一事件源，SIGALRM信号每一次被触发，主循环中调用一次定时任务处理函数，用来处理到期的定时器。
utils 定时器 (二) 链表
饭真好吃的博客
08-03 319
定时器作为常见的工具，要好好掌握。
定时器时间链表(双向)，时间轮，时间堆
qq_39274501的博客
12-30 1054
排序 排序算法 平均时间复杂度 最好情况 最坏情况 空间复杂度 排序方式 稳定性 冒泡排序 O(n2)O(n^2)O(n2) O(n)O(n)O(n) O(n2)O(n^2)O(n2) O(1)O(1)O(1) 内排序 稳定 选择排序 O(n2)O(n^2)O(n2) O(n2)O(n^2)O(n2) O(n2)O(n^2)O(n2) O(1)O(1)O(1) 内排序 不稳定 插入排序 O(n2)O(n^2)O(n2) O(n)O(n)O(n) O(n2)O(n^2)O(n2) O(
基于升序链表的定时器 - 处理非活动连接
destory27的博客
08-16 606
           服务器程序通常要定期处理非活动连接:给客户端发送一个重连请求,或者关闭该连接。利用alarm函数周期性的触发SIGALRM信号， 该信号的信号处理函数利用管道通知主循环执行定时器链表上的定时器任务---关闭非活动的连接。           采用升序双向链表实现定时器的功能，核心函数tick,它每隔一端固定时间就执行一次，以检测并处理到期的任务。判断定时器任务到...
高性能定时器实现
聆听风雨的博客
10-17 320
本文介绍常见的几种定时器实现方式，并对比其特点。
设计一个在裸机下使用的简单软件定时器（1）：框架+数据结构分析
kevin1499的博客
11-29 1020
本文详细分析在裸机下设计一个简单的软件定时器的框架和数据结构。
四、GD32 MCU 常见外设介绍 (2) GPIO 模块介绍
最新发布
聚沃科技&GD32 MCU开发者社区
07-22 612
为了扩展 GPIO 的 灵 活 性 或 外 设 功 能 使 用 ， 通 过 配 置 AFIO 端 口 配 置 寄 存 器（AFIO_PCF0/AFIO_PCF1），每个I/O引脚都可以配置多达4种不同的功能。通过使用外设 IO 的重映射功能可以选择合适的引脚另外，通过配置相应的EXTI源选择寄存器（AFIO_EXTISSx）选择触发中断或事件，GPIO引脚可以用作EXTI中断线。
链表增加软件定时器
05-29
在C语言中，可以使用链表来实现软件定时器，常用的方法是将定时器按照时间先后顺序加入到链表中，然后在主程序中不断遍历链表，查找是否有定时器时间已到期，如果有则执行相应的任务并将该定时器从链表中删除。 以下是一个简单的使用链表增加软件定时器的示例代码： ```c #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <signal.h> struct timer_node { int time_left; // 定时器剩余时间 void (*handler)(void*); // 定时器处理函数 void *arg; // 定时器参数 struct timer_node *next; // 链表指针 }; struct timer_node *timer_list = NULL; // 定时器链表 void timer_handler(int signum) { struct timer_node *p = timer_list; while (p != NULL) { if (p->time_left > 0) { p->time_left--; if (p->time_left == 0) { p->handler(p->arg); // 执行定时器处理函数 } } p = p->next; } } void add_timer(int ms, void (*handler)(void*), void *arg) { struct timer_node *node = (struct timer_node*)malloc(sizeof(struct timer_node)); node->time_left = ms / 10; // 将ms转换为10ms的单位 node->handler = handler; node->arg = arg; node->next = NULL; struct timer_node *p = timer_list; struct timer_node *prev = NULL; while (p != NULL) { if (node->time_left <= p->time_left) { if (prev == NULL) { timer_list = node; } else { prev->next = node; } node->next = p; p->time_left -= node->time_left; return; } else { node->time_left -= p->time_left; prev = p; p = p->next; } } if (prev == NULL) { timer_list = node; } else { prev->next = node; } struct itimerval timer; timer.it_value.tv_sec = 0; timer.it_value.tv_usec = 10 * 1000; // 定时器时间间隔为10ms timer.it_interval.tv_sec = 0; timer.it_interval.tv_usec = 10 * 1000; setitimer(ITIMER_REAL, &timer, NULL); // 设置定时器 } void delete_timer(void (*handler)(void*), void *arg) { struct timer_node *p = timer_list; struct timer_node *prev = NULL; while (p != NULL) { if (p->handler == handler && p->arg == arg) { if (prev == NULL) { timer_list = p->next; } else { prev->next = p->next; } free(p); return; } else { prev = p; p = p->next; } } } void task1(void *arg) { printf("Task 1 executed.\n"); add_timer(2000, task1, NULL); // 重新添加定时器 } void task2(void *arg) { printf("Task 2 executed.\n"); } int main() { signal(SIGALRM, timer_handler); // 注册信号处理函数 add_timer(1000, task1, NULL); // 添加定时器1 add_timer(500, task2, NULL); // 添加定时器2 printf("Waiting for timer to expire...\n"); while (1) { pause(); // 等待信号 } return 0; } ``` 在上述代码中，定义了一个结构体timer_node作为定时器链表的节点，包含定时器剩余时间、定时器处理函数、定时器参数和链表指针。使用timer_list来存储定时器链表。 在定时器处理函数timer_handler中，遍历链表，查找是否有定时器时间已到期，如果有则执行相应的任务并将该定时器从链表中删除。 在add_timer函数中，将新的定时器按照时间先后顺序加入到链表中，并根据定时器时间间隔设置定时器的时间和时间间隔。 在delete_timer函数中，从链表中删除指定的定时器。 在主程序中，添加了两个定时器task1和task2，分别在1000ms和500ms后执行。在task1的处理函数中，重新添加了一个2000ms的定时器。 需要注意的是，软件定时器的精度和稳定性可能受到系统负载、CPU占用率等因素的影响，因此在设计和使用时需要考虑到这些因素。此外，还需要注意定时器的时间间隔不能太小，否则会影响系统的正常运行。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值