[004] [RT-Thread学习笔记] 定时器源码浅析及其应用

已于 2022-03-25 20:33:34 修改
阅读量1.2k 收藏 4
点赞数 1
分类专栏： RT-Thread 文章标签： 单片机 rtt rtos 嵌入式
于 2022-01-25 00:26:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kouxi1/article/details/122658776
版权
RT-Thread
学习笔记
RT-Thread定时器基础知识
定时器控制块与工作机制
定时器控制块
定时器工作机制
硬件定时器实现
超时函数执行环境
私有对象
硬件定时器管理列表
系统硬件定时器初始化
硬件定时器扫描函数
软件定时器实现
超时函数执行环境
私有对象
软件定时器管理列表
系统软件定时器线程初始化
软件定时器扫描函数
定时器通用函数接口
创建与删除函数
初始化与脱离函数
启动与停止函数
控制函数
定时器钩子函数
应用示例

RT-Thread版本：4.0.5
MCU型号：STM32F103RCT6（ARM Cortex-M3 内核）

1 RT-Thread定时器基础知识

RT-Thread 的定时器提供两类定时器机制：

  • 单次触发定时器：在启动后只会触发一次定时器事件，然后定时器自动停止
  • 周期触发定时器：周期性的触发定时器事件，直到用户手动的停止，否则将永远周期性执行下去

当系统时钟节拍到达定时器设定的超时时间时会回调一个函数，此函数即为超时函数，根据超时函数执行的上下文环境不同，RT-Thread定时器分为硬件定时器与软件定时器，如下图所示：
在这里插入图片描述
可以通过下列宏配置定时器模式及其状态：

#define RT_TIMER_FLAG_DEACTIVATED       0x0             /* 非活动状态 */
#define RT_TIMER_FLAG_ACTIVATED         0x1             /* 活动状态 */

#define RT_TIMER_FLAG_ONE_SHOT          0x0             /* 单次触发定时器 */
#define RT_TIMER_FLAG_PERIODIC          0x2             /* 周期触发定时器 */

#define RT_TIMER_FLAG_HARD_TIMER        0x0             /* 硬件定时器，超时函数在tick中断服务例程中回调  */
#define RT_TIMER_FLAG_SOFT_TIMER        0x4             /* 软件定时器，超时函数在timer线程中回调 */

2 定时器控制块与工作机制

2.1 定时器控制块

struct rt_object
{
    char       name[RT_NAME_MAX];                       /* 内核对象名 */
    rt_uint8_t type;                                    /* 内核对象类型 */
    rt_uint8_t flag;                                    /* 内核对象标志位 */

    rt_list_t  list;                                    /* 内核对象链表结点 */
};
struct rt_timer
{
    struct rt_object parent;                      /* 继承父类属性与方法 */
    rt_list_t row[RT_TIMER_SKIP_LIST_LEVEL];      /* 定时器链表节点 */
    void (*timeout_func)(void *parameter);        /* 定时器超时调用的函数 */
    void      *parameter;                         /* 超时函数的参数 */
    rt_tick_t init_tick;                          /* 定时器初始超时节拍数 */
    rt_tick_t timeout_tick;                       /* 定时器实际超时时的节拍数 */
};
typedef struct rt_timer *rt_timer_t;

RT-Thread采用面向对象的思想设计的代码，所有内核对象都继承rt_object结构体，定时器模式及其状态通过timer->parent.flag成员修改：
在这里插入图片描述

2.2 定时器工作机制

创建的定时器会以超时时间排序（升序）的方式插入到定时器链表中（软件与硬件定时器采用不同的链表），因此该链表是一个有序链表，因此RT-Thread采用跳表算法来加快搜索链表元素的速度，使得查找元素时链表的时间复杂度由O(n) -> O(logn)。
【官方举例】
一个有序的链表，如下图所示，从该有序链表中搜索元素 {13, 39}，需要比较的次数分别为 {3, 5}，总共比较的次数为 3 + 5 = 8 次。
在这里插入图片描述
使用跳表算法后可以采用类似二叉搜索树的方法，把一些节点提取出来作为索引，得到如下图所示的结构：
在这里插入图片描述
在这个结构里把 {3, 18,77} 提取出来作为一级索引，这样搜索的时候就可以减少比较次数了。还可以再从一级索引提取一些元素出来，作为二级索引，这样更能加快元素搜索：
在这里插入图片描述
可以看出，跳表算法是一种“空间换时间”的算法，跳表的最大层数为log2n - 1层（n为链表长度），在 RT-Thread 中通过宏定义RT_TIMER_SKIP_LIST_LEVEL来配置跳表的层数，默认为 1，表示采用一级有序链表图的有序链表算法，每增加一，表示在原链表基础上增加一级索引。

3 硬件定时器实现

RT-Thread 定时器默认的方式就是HARD_TIMER模式，线程对象都有一个内置定时器，其默认就是此模式。所谓的默认就是timer->parent.flag成员为0时的标志状态。

3.1 超时函数执行环境

硬件定时器超时函数工作在中断上下文环境，因此对超时函数的要求与中断服务例程的要求相同：

  • 快进快出，执行时间尽量短
  • 执行时不应导致当前上下文挂起、等待
  • 绝对不允许试图去申请动态内存、释放动态内存

3.2 私有对象

3.2.1 硬件定时器管理列表

struct rt_list_node
{
    struct rt_list_node *next;                          /**< point to next node. */
    struct rt_list_node *prev;                          /**< point to prev node. */
};
typedef struct rt_list_node rt_list_t;                  /**< Type for lists. */

static rt_list_t  _timer_list[RT_TIMER_SKIP_LIST_LEVEL];

后期添加定时器，按定时器超时时间顺序进行排序插入。如果两个定时器超时时间相同, 会按FIFO顺序插入，即先初始化的定时器位于链表前面。

3.2.2 系统硬件定时器初始化

void rt_system_timer_init(void)
{
    int i;

    for (i = 0; i < sizeof(_timer_list) / sizeof(_timer_list[0]); i++)
    {
        rt_list_init(_timer_list + i);
    }
}

【功能】
初始化硬件定时器链表结点，将其前驱指针和后继指针均指向表头结点。

3.2.3 硬件定时器扫描函数

/**
 * @brief 该函数用于扫描系统定时器列表，当有超时事件发生时
 *        就调用对应的超时函数
 *
 * @note 该函数在操作系统定时器中断中被调用
 */
void rt_timer_check(void)
{
    struct rt_timer *t;
    rt_tick_t current_tick;
    register rt_base_t level;
    rt_list_t list;

    rt_list_init(&list);

    /* 获取系统时基计数器 rt_tick 的值 */
    current_tick = rt_tick_get();

    /* 关中断 */
    level = rt_hw_interrupt_disable();

    /* 系统定时器列表不为空，则扫描定时器列表 */
    while (!rt_list_isempty(&_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1]))
    {
        /* 获取第一个节点定时器的地址 */
        t = rt_list_entry(_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1].next,   // 节点地址
                          struct rt_timer,                                  // 结点所在的父结构的数据类型
                          row[RT_TIMER_SKIP_LIST_LEVEL - 1]);               // 节点在父结构的成员名

        /* 最大超时时间不能大>= RT_TICK_MAX / 2 */
        // t->timeout_tick当定时器重新启动时都会刷新
        if ((current_tick - t->timeout_tick) < RT_TICK_MAX / 2)
        {
            RT_OBJECT_HOOK_CALL(rt_timer_enter_hook, (t));  // 回调进入定时器钩子函数

            /* 将定时器从定时器列表移除 */
            _timer_remove(t);
            if (!(t->parent.flag & RT_TIMER_FLAG_PERIODIC))
            {
                t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
            }
            /* 将定时器添加到临时列表  */
            rt_list_insert_after(&list, &(t->row[RT_TIMER_SKIP_LIST_LEVEL - 1]));
            /* 调用超时函数 */
            t->timeout_func(t->parameter);

            /* 重新获取 tick */
            current_tick = rt_tick_get();

            RT_OBJECT_HOOK_CALL(rt_timer_exit_hook, (t));   // 回调退出定时器钩子函数

            /* 检测timer对象处于分离还是启动状态 */
            if (rt_list_isempty(&list))
            {
                continue;
            }
            rt_list_remove(&(t->row[RT_TIMER_SKIP_LIST_LEVEL - 1]));
            if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&
                (t->parent.flag & RT_TIMER_FLAG_ACTIVATED))
            {
                /* 启动定时器 */
                t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
                rt_timer_start(t);
            }
        }
        else break;
    }

    /* 开中断 */
    rt_hw_interrupt_enable(level);
}

rt_timer_check()函数用于检查系统硬件定时器链表，如果有定时器超时，将调用相应的超时函数，且所有定时器在定时超时后都会从定时器链表中被移除，若是周期性定时器则会在它再次启动时重新加入到定时器链表。该函数在rt_tick_increase()中被调用，具体查看[时钟节拍的获取与线程时间片轮转调度的实现]一文。

4 软件定时器实现

4.1 超时函数执行环境

软件定时器模式可通过配置宏定义RT_USING_TIMER_SOFT来决定是否启用该模式，该模式被启用后，系统会在初始化时创建一个 timer 线程，SOFT_TIMER模式的定时器超时函数在都会在 timer 线程的上下文环境中执行，因此与线程一下需要注意以下几点：

  • 不允许使用任何可能引软件定时器起线程挂起或者阻塞的 API 接口
  • 不允许在超时函数中有阻塞的情况出现，更不允许有死循环
  • 不应该影响到其他定时器执行超时函数或本定时器的下一次超时回调
  • 不应该申请动态内存、释放动态内存，因为malloc、free 等内存相关的函数内部使用了信号量作为临界区保护（如果没有获取到信号量会挂起当前线程）

4.2 私有对象

4.2.1 软件定时器管理列表

static rt_list_t  _soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL];

4.2.2 系统软件定时器线程初始化

  • 定时器列表与timer线程初始化
static rt_list_t _soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL];	// 软件定时器
static struct rt_thread _timer_thread;  // 定义timer线程
ALIGN(RT_ALIGN_SIZE)    // 四字节排列
static rt_uint8_t _timer_thread_stack[RT_TIMER_THREAD_STACK_SIZE];  // 定义timer线程栈大小

/**
 * @brief 这个函数将初始化系统定时器线程
 */
void rt_system_timer_thread_init(void)
{
#ifdef RT_USING_TIMER_SOFT	// 是否使用软件定时器的宏开关
    int i;
    /* 初始化软件定时器链表 */ 
    for (i = 0;
         i < sizeof(_soft_timer_list) / sizeof(_soft_timer_list[0]);
         i++)
    {
        rt_list_init(_soft_timer_list + i);
    }

    /* 创建timer线程 */
    rt_thread_init(&_timer_thread,
                   "timer",
                   _timer_thread_entry,
                   RT_NULL,
                   &_timer_thread_stack[0],
                   sizeof(_timer_thread_stack),
                   RT_TIMER_THREAD_PRIO,
                   10);

    /* 启动timer线程 */
    rt_thread_startup(&_timer_thread);
#endif /* RT_USING_TIMER_SOFT */
}

软件定时器使用了系统的一个链表和一个线程资源，软件定时器线程的优先级通过宏RT_TIMER_THREAD_PRIO设置，默认为4，定时器线程的堆栈大小 通过宏RT_TIMER_THREAD_STACK_SIZE设置，默认为 512 个字节。

  • timer线程入口函数
static void _timer_thread_entry(void *parameter)
{
    rt_tick_t next_timeout;

    while (1)
    {
        /* 获取软件定时器列表中下一个定时器的到达时间 */
        next_timeout = _timer_list_next_timeout(_soft_timer_list);
        if (next_timeout == RT_TICK_MAX)
        {
            /* 如果没有软件定时器，则挂起线程自身 */
            rt_thread_suspend(rt_thread_self());
            rt_schedule();
        }
        else
        {
            rt_tick_t current_tick;

            /* 获取当前系统时间 */
            current_tick = rt_tick_get();

            if ((next_timeout - current_tick) < RT_TICK_MAX / 2)
            {
                /* 计算下一个定时器溢出时间与当前时间的间隔 */
                next_timeout = next_timeout - current_tick;
                rt_thread_delay(next_timeout);
            }
        }

        /* 检查软件定时器列表 */
        rt_soft_timer_check();
    }
}
  • 如果软件定时器列表为空时，_timer_list_next_timeout函数会返回RT_TICK_MAX，然后会将定时器线程自身挂起。当其他执行单元调用rt_timer_start函数启动软件定时器时，会将该定时器插入到软件定时器列表，如果发现定时器线程已挂起，则会将其唤醒。
  • 如果不为空，则会计算判断下一个定时器的超时时间是否到达，若没有到达则延时阻塞挂起，等到达后就会继续执行软件定时器扫描函数，然后在此函数中判断是否可以执行超时回调函数、修改定时器状态等。

4.2.3 软件定时器扫描函数

#define RT_SOFT_TIMER_IDLE              1
#define RT_SOFT_TIMER_BUSY              0
/* 软件定时器状态 */
static rt_uint8_t _soft_timer_status = RT_SOFT_TIMER_IDLE;

/**
 * @brief 函数会检查软件定时器列表，如果出现超时事件，则会调用相应的超时函数
 */
void rt_soft_timer_check(void)
{
    rt_tick_t current_tick;
    struct rt_timer *t;
    register rt_base_t level;
    rt_list_t list;

    rt_list_init(&list);

    /* 关中断 */
    level = rt_hw_interrupt_disable();

    while (!rt_list_isempty(&_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1]))
    {
         /* 获取第一个节点定时器的地址 */
        t = rt_list_entry(_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1].next,
                            struct rt_timer, 
                            row[RT_TIMER_SKIP_LIST_LEVEL - 1]);

        current_tick = rt_tick_get();

    
        if ((current_tick - t->timeout_tick) < RT_TICK_MAX / 2)
        {
            RT_OBJECT_HOOK_CALL(rt_timer_enter_hook, (t));

            /* 获取第一个节点定时器的地址 */
            _timer_remove(t);
            if (!(t->parent.flag & RT_TIMER_FLAG_PERIODIC))
            {
                t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
            }
            /* 将定时器添加到临时列表  */
            rt_list_insert_after(&list, &(t->row[RT_TIMER_SKIP_LIST_LEVEL - 1]));

            _soft_timer_status = RT_SOFT_TIMER_BUSY;    // 将软件定时器标记为忙碌状态
            /* 开中断 */
            rt_hw_interrupt_enable(level);

            /* 调用超时函数 */
            t->timeout_func(t->parameter);

            RT_OBJECT_HOOK_CALL(rt_timer_exit_hook, (t));
            RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d\n", current_tick));

            /* 关中断 */
            level = rt_hw_interrupt_disable();

            _soft_timer_status = RT_SOFT_TIMER_IDLE;    // 取消标记软件定时器为忙碌状态
            /* 检测timer对象处于分离还是启动状态 */
            if (rt_list_isempty(&list))
            {
                continue;
            }
            rt_list_remove(&(t->row[RT_TIMER_SKIP_LIST_LEVEL - 1]));
            if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&
                (t->parent.flag & RT_TIMER_FLAG_ACTIVATED))
            {
                /* start it */
                t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
                rt_timer_start(t);
            }
        }
        else break; 
    }
    /* 开中断 */
    rt_hw_interrupt_enable(level);
}

软件定时器与硬件定时器扫描函数内部实现基本一致，注意：无论是软件还是硬件定时器，其超时时间必须小于RT_TICK_MAX / 2，其中RT_TICK_MAX = 0xffff ffff）

5 定时器通用函数接口

在这里插入图片描述

5.1 创建与删除函数

打开RT_USING_HEAP宏才能创建与删除动态对象。

  • 创建定时器
/**
 * @brief 该函数用于初始化一个定时器，通常该函数用于初始化一个动态的定时器
 *
 * @param name 定时器的名字
 * @param timeout 超时函数
 * @param parameter 超时函数形参
 * @param time 定时器的超时时间
 * @param flag 定时器的标志
 *
 * @return 成功创建返回定时器结构体指针
 */
rt_timer_t rt_timer_create(const char *name,
                           void (*timeout)(void *parameter),
                           void       *parameter,
                           rt_tick_t   time,
                           rt_uint8_t  flag)
{
    struct rt_timer *timer;

    /* 动态申请内存*/
    timer = (struct rt_timer *)rt_object_allocate(RT_Object_Class_Timer, name);
    if (timer == RT_NULL)
    {
        return RT_NULL;
    }

    /* 定时器初始化 */
    _timer_init(timer, timeout, parameter, time, flag);

    return timer;
}

rt_timer_init函数将定时器具体的初始化封装在了一个内部函数_timer_init中：

static void _timer_init(rt_timer_t timer,
                           void (*timeout)(void *parameter),
                           void      *parameter,
                           rt_tick_t  time,
                           rt_uint8_t flag)
{
    int i;

    /* 设置标志 */
    timer->parent.flag  = flag;

    /* 先设置为非激活态 */
    timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;

    timer->timeout_func = timeout;
    timer->parameter    = parameter;

    /* 初始化 定时器实际超时时的系统节拍数 */
    timer->timeout_tick = 0;
    /* 初始化 定时器需要超时的节拍数 */
    timer->init_tick    = time;

    /* 初始化定时器链表的内置节点 */
    for (i = 0; i < RT_TIMER_SKIP_LIST_LEVEL; i++)
    {
        rt_list_init(&(timer->row[i]));
    }
}
  • 删除定时器
rt_err_t rt_timer_delete(rt_timer_t timer)
{
    register rt_base_t level;

    /* 检查定时器 */
    RT_ASSERT(timer != RT_NULL);
    RT_ASSERT(rt_object_get_type(&timer->parent) == RT_Object_Class_Timer);
    RT_ASSERT(rt_object_is_systemobject(&timer->parent) == RT_FALSE);

    level = rt_hw_interrupt_disable();

    /* 将定时器从链表中移除 */
    _timer_remove(timer);
    /* 将状态设为非激活态 */
    timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;

    rt_hw_interrupt_enable(level);
	/* 从内核对象链表中移除并释放内存 */
    rt_object_delete(&(timer->parent));

    return RT_EOK;
}

_timer_remove是内联函数：

rt_inline void _timer_remove(rt_timer_t timer)
{
    int i;
	/* 将定时器自身的节点从系统定时器列表 rt_timer_list 脱离 */    
	for (i = 0; i < RT_TIMER_SKIP_LIST_LEVEL; i++)
    {
        rt_list_remove(&timer->row[i]);
    }
}

调用rt_timer_delete函数后，系统会把传入的定时器对象指针从 rt_timer_list 链表中删除，然后释放相应的定时器控制块占有的内存

5.2 初始化与脱离函数

  • 初始化定时器
/**
 * @brief 该函数用于初始化一个定时器，通常该函数用于初始化一个静态的定时器
 *
 * @param timer 静态定时器对象
 * @param name 定时器的名字
 * @param timeout 超时函数
 * @param parameter 超时函数形参
 * @param time 定时器的超时时间
 * @param flag 定时器的标志
 */
void rt_timer_init(rt_timer_t  timer,
                   const char *name,
                   void (*timeout)(void *parameter),
                   void       *parameter,
                   rt_tick_t   time,
                   rt_uint8_t  flag)
{
    RT_ASSERT(timer != RT_NULL);

    /* 定时器对象初始化,  将定时器插入到系统对象容器列表 */
    rt_object_init(&(timer->parent), RT_Object_Class_Timer, name);

    /* 定时器初始化 */
    _timer_init(timer, timeout, parameter, time, flag);
}
  • 脱离定时器
rt_err_t rt_timer_detach(rt_timer_t timer)
{
    register rt_base_t level;

    /* 检查定时器 */
    RT_ASSERT(timer != RT_NULL);
    RT_ASSERT(rt_object_get_type(&timer->parent) == RT_Object_Class_Timer);
    RT_ASSERT(rt_object_is_systemobject(&timer->parent));

    level = rt_hw_interrupt_disable();

    _timer_remove(timer);
    /* 将状态设为非激活态 */
    timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;

    rt_hw_interrupt_enable(level);
    /* 从内核对象链表中移除，但不会释放内存 */
    rt_object_detach(&(timer->parent));

    return RT_EOK;
}

调用rt_timer_detach函数会把定时器对象从内核对象容器中脱离，但是定时器对象所占有的内存不会被释放（静态对象也无法释放）

5.3 启动与停止函数

  • 启动定时器
rt_err_t rt_timer_start(rt_timer_t timer)
{
    unsigned int row_lvl;
    rt_list_t *timer_list;
    register rt_base_t level;
    register rt_bool_t need_schedule;
    rt_list_t *row_head[RT_TIMER_SKIP_LIST_LEVEL];
    unsigned int tst_nr;
    static unsigned int random_nr;

    /* 检查定时器 */
    RT_ASSERT(timer != RT_NULL);
    RT_ASSERT(rt_object_get_type(&timer->parent) == RT_Object_Class_Timer);

    need_schedule = RT_FALSE;

    /* 关中断 */
    level = rt_hw_interrupt_disable();
    /* 将定时器从系统定时器列表移除 */
    _timer_remove(timer);
    /* 改变定时器的状态为非激活态 */
    timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;

    RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(timer->parent)));

    /*
     * 获取 timeout tick,
     * 最大的 timeout tick 不能大于 RT_TICK_MAX/2
     */
    RT_ASSERT(timer->init_tick < RT_TICK_MAX / 2);
    timer->timeout_tick = rt_tick_get() + timer->init_tick;

#ifdef RT_USING_TIMER_SOFT
    if (timer->parent.flag & RT_TIMER_FLAG_SOFT_TIMER)
    {
        /* 将定时器插入到软件定时器列表 */
        timer_list = _soft_timer_list;
    }
    else    
#endif /* RT_USING_TIMER_SOFT */
    {
        /* 将定时器插入到系统(硬件)定时器列表 */
        timer_list = _timer_list;
    }
    /* 获取定时器列表第一条链表根节点地址 */
    row_head[0]  = &timer_list[0];
    /* T_TIMER_SKIP_LIST_LEVEL 等于 1，这个循环只会执行一次 */
    for (row_lvl = 0; row_lvl < RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
    {
        for (; row_head[row_lvl] != timer_list[row_lvl].prev;   // 遍历定时器链表(双向循环链表)
             row_head[row_lvl]  = row_head[row_lvl]->next)
        {
            struct rt_timer *t;
            /* 获取定时器列表节点地址 */
            rt_list_t *p = row_head[row_lvl]->next;

            /* 根据节点地址获取父结构的指针 */
            t = rt_list_entry(p, struct rt_timer, row[row_lvl]);

            /* 如果两个定时器超时时间相同, 最好是最早插入的最先被调用
             * 因此将新定时器插入到该定时器列表的尾部
             */
            if ((t->timeout_tick - timer->timeout_tick) == 0)
            {
                continue;
            }
            else if ((t->timeout_tick - timer->timeout_tick) < RT_TICK_MAX / 2)
            {
                break;
            }
        }
        /* T_TIMER_SKIP_LIST_LEVEL 等于 1, 判断条件永不为真, 即不使用跳表算法 */
        if (row_lvl != RT_TIMER_SKIP_LIST_LEVEL - 1)
            row_head[row_lvl + 1] = row_head[row_lvl] + 1;
    }

    /* random_nr 是一个静态变量，用于记录启动了多少个定时器 */
    random_nr++;
    tst_nr = random_nr;
    /* 将定时器插入到定时器管理列表 */
    rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - 1],        // 列表根节点地址
                         &(timer->row[RT_TIMER_SKIP_LIST_LEVEL - 1]));  // 要被插入的节点的地址
    /* RT_TIMER_SKIP_LIST_LEVEL 等于 1，该 for 循环永远不会执行 */
    for (row_lvl = 2; row_lvl <= RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
    {
        if (!(tst_nr & RT_TIMER_SKIP_LIST_MASK))
            rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - row_lvl],       
                                 &(timer->row[RT_TIMER_SKIP_LIST_LEVEL - row_lvl])); 
        else
            break;
        /* Shift over the bits we have tested. Works well with 1 bit and 2
         * bits. */
        tst_nr >>= (RT_TIMER_SKIP_LIST_MASK + 1) >> 1;
    }
    /* 设置定时器标志位为激活态 */
    timer->parent.flag |= RT_TIMER_FLAG_ACTIVATED;

#ifdef RT_USING_TIMER_SOFT
    if (timer->parent.flag & RT_TIMER_FLAG_SOFT_TIMER)
    {
        /* 检查timer线程是否准备好 */
        if ((_soft_timer_status == RT_SOFT_TIMER_IDLE) &&
           ((_timer_thread.stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND))   // 软件定时器链表为空时timer线程会挂起自身,让出CPU资源
        {
            /* 唤醒timer线程去调用软件定时器扫描函数 */
            rt_thread_resume(&_timer_thread);
            need_schedule = RT_TRUE;
        }
    }
#endif /* RT_USING_TIMER_SOFT */

    /* 开中断 */
    rt_hw_interrupt_enable(level);

    if (need_schedule)
    {
        rt_schedule();
    }

    return RT_EOK;
}

调用rt_timer_start函数，将定时器的状态将更改为激活状态RT_TIMER_FLAG_ACTIVATED，并计算当前超时时间timer->timeout_tick = rt_tick_get() + timer->init_tick；然后遍历定时器链表，根据timer->timeout_tick超时时间大小，升序插入到定时器链表中。

同时在这里也可以看出只有使用了RT_USING_TIMER_SOFT宏，才会判断定时器的flag是否为RT_TIMER_FLAG_SOFT_TIMER软件定时器，如果是会执行两个操作：

  1. 将定时器要插入的链表改为_soft_timer_list——软件定时器管理链表
  2. 判断定时器线程是否已挂起（定时器链表为空时，该线程会主动挂起），若挂起则会唤醒定时器线程。
  • 停止定时器
rt_err_t rt_timer_stop(rt_timer_t timer)
{
    register rt_base_t level;

    RT_ASSERT(timer != RT_NULL);
    RT_ASSERT(rt_object_get_type(&timer->parent) == RT_Object_Class_Timer);

    /* 只有 active 的定时器才能被停止，否则退出返回错误码 */
    if (!(timer->parent.flag & RT_TIMER_FLAG_ACTIVATED))
        return -RT_ERROR;

    RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(timer->parent)));

    /* 关中断  */
    level = rt_hw_interrupt_disable();
    /* 将定时器从定时器列表删除 */
    _timer_remove(timer);
    /* 改变定时器的状态为非 active  */
    timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;

    /* 开中断  */
    rt_hw_interrupt_enable(level);

    return RT_EOK;
}

调用rt_timer_stop函数，将定时器状态改为非激活态RT_TIMER_FLAG_DEACTIVATED，并将其从定时器链表移除，不参与定时器超时检查。

5.4 控制函数

/**
 * @brief 该函数将获取或者设置定时器的一些选项
 *
 * @param timer 将要被设置或者获取的定时器
 * @param cmd 控制命令
 * @param arg 形参
 *
 * @return 控制状态
 */
rt_err_t rt_timer_control(rt_timer_t timer, int cmd, void *arg)
{
    register rt_base_t level;

    /* timer check */
    RT_ASSERT(timer != RT_NULL);
    RT_ASSERT(rt_object_get_type(&timer->parent) == RT_Object_Class_Timer);

    level = rt_hw_interrupt_disable();
    switch (cmd)
    {
    case RT_TIMER_CTRL_GET_TIME:
        *(rt_tick_t *)arg = timer->init_tick;
        break;

    case RT_TIMER_CTRL_SET_TIME:
        timer->init_tick = *(rt_tick_t *)arg;
        break;

    case RT_TIMER_CTRL_SET_ONESHOT:
        timer->parent.flag &= ~RT_TIMER_FLAG_PERIODIC;
        break;

    case RT_TIMER_CTRL_SET_PERIODIC:
        timer->parent.flag |= RT_TIMER_FLAG_PERIODIC;
        break;

    case RT_TIMER_CTRL_GET_STATE:
        if(timer->parent.flag & RT_TIMER_FLAG_ACTIVATED)
        {
            /* 定时器处于运行或启动状态 */
            *(rt_tick_t *)arg = RT_TIMER_FLAG_ACTIVATED;
        }
        else
        {
            /* 定时器处于停止状态 */
            *(rt_tick_t *)arg = RT_TIMER_FLAG_DEACTIVATED;
        }
        break;

    default:
        break;
    }
    rt_hw_interrupt_enable(level);

    return RT_EOK;
}

其中cmd有以下几种选择：

#define RT_TIMER_CTRL_SET_TIME      0x0     /* 设置定时器超时时间       */
#define RT_TIMER_CTRL_GET_TIME      0x1     /* 获得定时器超时时间       */
#define RT_TIMER_CTRL_SET_ONESHOT   0x2     /* 设置定时器为单次定时器   */
#define RT_TIMER_CTRL_SET_PERIODIC  0x3     /* 设置定时器为周期型定时器 */
#define RT_TIMER_CTRL_GET_STATE     0x4     /* 获取定时器状态：active or deactive */

注意：使用控制函数并且需要传入arg时，定义的参数变量大小必须是4字节，否则可能会直接卡死或者得到错误的数据。（个人猜测与字节对齐有关）

5.5 定时器钩子函数

定时器钩子函数在扫描函数中调用。

  • 设置定时器入口钩子
void rt_timer_enter_sethook(void (*hook)(struct rt_timer *timer))
{
    rt_timer_enter_hook = hook;
}
  • 设置定时器出口钩子
void rt_timer_exit_sethook(void (*hook)(struct rt_timer *timer))
{
    rt_timer_exit_hook = hook;
}

6 应用示例

static rt_timer_t timer1;
static struct rt_timer timer2;

static void timer1_callback(void *parameter)
{
    rt_uint32_t active_status = 0; // 必须是四字节, 否则内存错误

    rt_timer_control(timer1, RT_TIMER_CTRL_GET_STATE, &active_status);
    rt_kprintf("[%u]tm1_flag: %u\n", rt_tick_get(), timer1->parent.flag);
    rt_kprintf("[%u]tm1_active_status: %u\n", rt_tick_get(), active_status);
    rt_kprintf("[%u]timer1_callback running...\n", rt_tick_get());
//        rt_timer_delete(timer1); // 绝对不允许在ISR中申请与释放内存，否则断言报错卡在死循环
}

static void timer2_callback(void *parameter)
{
    static rt_uint8_t count = 0;

    if(++count == 10)
    {
        rt_timer_detach(&timer2);     // 将状态设为非active，同时从定时器链表中脱离
//            rt_timer_stop(&timer2);     // 仅将状态改为非active
    }
    rt_kprintf("[%u]timer2_callback running...\n", rt_tick_get());
    rt_thread_mdelay(10);        // 挂起timer线程, 同时会把timer线程的定时器加入到软件定时器链表(这里仅做测试, 实际使用一般不允许调用延时函数)
}

static void tm_enter_hook(struct rt_timer *timer)
{
    rt_kprintf("[%u]%s enter hook\n", rt_tick_get(), timer->parent.name);
}

static void tm_exit_hook(struct rt_timer *timer)
{
    rt_kprintf("[%u]%s exit hook\n", rt_tick_get(), timer->parent.name);
}

static int tick_sample(void)
{
    rt_uint32_t tm2_timeout = 1000; // 必须是四字节

    // 设置定时器钩子
    rt_timer_enter_sethook(tm_enter_hook);
    rt_timer_exit_sethook(tm_exit_hook);

    // 动态创建定时器
    timer1 =  rt_timer_create("tm1",
                             timer1_callback,
                             RT_NULL,
                             3000,  // timeout 不能 >= RT_TICK_MAX / 2
                             RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_HARD_TIMER);
    if(timer1 == NULL)
    {
        LOG_E("rt_timer1_create failed...\n");
        return -RT_ENOMEM;
    }
    LOG_D("rt_timer1_create successed...\n");
    rt_timer_start(timer1);

    // 静态创建定时器
    rt_timer_init(&timer2,
                  "tm2",
                  timer2_callback,
                  NULL,
                  5000,
                  RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_SOFT_TIMER);
    rt_timer_start(&timer2);
    /* 重新设置tm2超时时间为1000 os_tick(第二次超时调用时生效, 因为只有当rt_soft_timer_check函数
     * 调用rt_timer_start重新获取timer->init_tick时生效) */
    rt_timer_control(&timer2, RT_TIMER_CTRL_SET_TIME, (rt_tick_t*)&tm2_timeout);

    return RT_EOK;
}

INIT_APP_EXPORT(tick_sample);

部分打印结果：
在这里插入图片描述

END

柯西的彷徨
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RT-Thread入门（三） 定时器
小小小白的博客
01-26 1万+
RT-Thread入门之定时器 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; 上一篇文章我们学习了RT-Thread建立线程相关函数，这次我们将学习系统中一个很重要的功能：定时器。系统提供的软件定时器可以为我们提供无限个定时器使用，但定时时间必须是系统节拍的整数倍。RT-Thread 中，时钟节拍的长度可以根据 RT_TICK_PER_SECOND 的定义来调整，我们使用的工程设置的为...
RT-Thread学习笔记.xmind
06-02
自己做的笔记
【RT-Thread】自我学习笔记→第五章→时钟管理→定时器→动态定时器
qq_66792436的博客
04-20 268
学完了时间节拍的获取，接下来学习动态定时器的创建与使用。RT-Thread 的定时器提供两类定时器机制：☐ 第一类是单次触发定时器，这类定时器在启动后只会触发一次定时器事件，然后定时器自动停止。☐ 第二类是周期触发定时器，这类定时器会周期性的触发定时器事件，直到用户手动的停止，否则将永远持续执行下去根据定时器超时函数执行时所处的上下文环境，RT-Thread的定时器可以分为HARD_TIMER模式和SOFT_TIMER模式。HARD_TIMER模式：中断上下文。
9-钩子函数（介入函数）
深蓝判官
11-10 1097
UCOSIII 钩子函数（介入函数） UCOSIII的钩子函数有8个，有些书籍会翻译为介入函数，其实是同一个意思。什么是钩子函数呢，也许是因为函数名字直译过来就是钩子吧。具体作用还真的不好定义，还不如直接看这几个函数的具体功能作用来得快。 在介绍具体的钩子函数前，先介绍下钩子函数的初始化函数，这个初始化函数可以一次性对所有钩子函数进行初始化，函数原型如下； void App_O...
[嵌入式系统-56]：RT-Thread-内核：时钟管理，时钟节拍和基于时钟节拍的定时器
最新发布
文火冰糖（王文兵）的博客
05-02 1080
如下图所示，系统当前 tick 值为 20，在当前系统中已经创建并启动了三个定时器，分别是定时时间为 50 个 tick 的 Timer1、100 个 tick 的 Timer2 和 500 个 tick 的 Timer3，这三个定时器分别加上系统当前时间 rt_tick=20，从小到大排序链接在 rt_timer_list 链表中，形成如图所示的定时器链表结构。RT-Thread 的定时器提供两类定时器机制：第一类是单次触发定时器，这类定时器在启动后只会触发一次定时器事件，然后定时器自动停止。
10.Vue - 生命周期与钩子函数
weixin_51351637的博客
09-05 1171
又名：生命周期回调函数、生命周期函数、生命周期钩子Vue在关键时刻帮我们调用的一些特殊名称的函数生命周期函数的名字不可更改，但函数的具体内容是程序员根据需求编写的生命周期函数中的this指向的是vm或组件实例对象下图mountedbeforeMount：此时页面呈现的内容Vue还没有编译，比如{{name}}，就会呈现这个，并不会呈现name的值对于beforeDestroy：我们应该做一些收尾性的工作（具体查看图）
RTT 线程管理
weixin_46098612的博客
12-23 1296
1.线程控制块2.线程栈3.线程属性状态。
rt-thread 硬件定时器实现时间片轮询
01-26
rt-thread是一个轻量级实时操作系统，它支持硬件定时器来实现时间片轮询功能。在rt-thread 3.0版本中，硬件定时器与时间片轮询的实现主要涉及以下几个关键点： 1. **硬件定时器**：硬件定时器是操作系统中用于产生...
RT-Thread学习笔记总结.tar.gz
07-08
本学习笔记总结将全面介绍RT-Thread的核心概念、功能特性、开发环境搭建以及实际应用案例，帮助初学者快速入门。 一、RT-Thread核心概念 1. 线程：RT-Thread中的线程相当于操作系统的任务，负责执行特定的功能。...
RT-Thread物联网实时操作系统学习笔记及相关源码.zip
04-29
RT-Thread物联网实时操作系统学习笔记及相关源码.zipRT-Thread物联网实时操作系统学习笔记及相关源码.zipRT-Thread物联网实时操作系统学习笔记及相关源码.zipRT-Thread物联网实时操作系统学习笔记及相关源码.zipRT-...
NXP i.MX RT1052 RT-Thread实战：定时器的实现【基于Cortex-M3】
12-01
在本文中，我们将深入探讨如何在NXP i.MX RT1052微控制器上使用RT-Thread实时操作系统实现定时器功能。NXP i.MX RT1052是一款基于高性能Cortex-M3内核的跨界处理器，适用于需要快速响应和高效能的嵌入式应用。RT-...
RTT Nano学习笔记 4 - 配置
pq的博客
04-17 713
RT-Thread Nano 的配置在 rtconfig.h 中进行，通过开关宏定义来使能或关闭某些功能。 1. RTE_USING_FINSH 这个开关是通过defined(__CC_ARM) || defined(__CLANG_ARM)约束的。其中__CC_ARM是MDK编译器，__CLANG_ARM是CLANG编译器。 RTE_USING_FINSH是控制RT Thread的控制台功能。先不用使能。 2.RT_THREAD_PRIORITY_MAX /* 线程优先级表 */ rt_li.
C语言_钩子函数（回调函数）
#elseif
03-05 5296
钩子函数、回调函数、注册函数，挂钩子这些我们代码中经常涉及到的东西，是否已经困扰你很久了？它们究竟是怎么回事，究竟怎么用？下面我来为你一一解答。 什么是钩子函数？ 钩子函数也叫回调函数，是通过函数指针来实现的，那我们来看看什么是函数指针。 首先看看以下例子： int *p; int a，b； 我们可以让指针p先后指向a, b，这样，p就先后代表了不同变量的地址 p = &a;...
Rtthread Timer管理
weixin_43522787的博客
02-26 461
Rtthread Timer 模块 /* hard timer list */ static rt_list_t rt_timer_list[RT_TIMER_SKIP_LIST_LEVEL]; /** * timer structure */ struct rt_timer { struct rt_object parent; /**< object 头部分 */ rt_list_t row[RT_TIMER
Rt-Thread之双向链表学习
weixin_42536940的博客
01-29 486
一、定义链表节点数据类型 struct rt_list_node { struct rt_list_node *next; /* 指向后一个节点 */ struct rt_list_node *prev; /* 指向前一个节点 */ }; typedef struct rt_list_node rt_list_t; 二、在双向链表头部插入一个节点 l指的是第一个节点，n指新插入的节点。 新插入节点的时候，新节点把两边都断开了联系，所以左右两边需要建立好连接。 先看右边 第一步、看的时候主要是看原
rt_thread源码分析篇六：变量整理（一）
OnlyLove_的博客
08-22 382
一、前言 整理rt-thread中重要变量。
rt-thread的内核对象管理系统分析
管子（zero）的杂乱空间
02-04 250
rt-thread采用内核对象管理系统来访问和管理所有内核对象.首先来看看rt-thread的内核对象是如何定义的: 1 数据结构 1.1 对象控制块 在include/rtdef.h头文件中可以找到内核对象有结构定义: /** * Base structure of Kernel object */ struct rt_object { char name[RT_...
RT-Thread-学习分析(详细版)
热门推荐
姬绪孔的博客
10-17 1万+
RT-Thread简介–>>>下载 具体包括以下部分: 内核层：RT-Thread 内核，是 RT-Thread的核心部分，包括了内核系统中对象的实现，例如多线程及其调度、信号量、邮箱、消息队列、内存管理、定时器等；libcpu/BSP（芯片移植相关文件 / 板级支持包）与硬件密切相关，由外设驱动和 CPU 移植构成。 组件与服务层：组件是基于 RT-Thread 内核之上的上层软件，例如虚拟文件系统、FinSH 命令行界面、 网络框架、设备框架等。采用模块化设计，做到组件内部高内聚，
RT-Thread 内核学习 >> （十五）软件定时器的使用
原谅我这一生不羁放纵爱自由
04-07 1810
软件定时器简介 软件定时器是由操作系统提供的一类系统接口，它构建在硬件定时器基础之上（系统滴答定时器）。软件定时器使系统能够提供不受数目限制的定时器服务。 RT-Thread 操作系统提供的软件定时器，以系统节拍（OS Tick）的时间长度为定时单位，提供了基于系统节拍整数倍的定时能力，即定时数值是OS Tick 的整数倍。 当软件定时器所设定的定时时间到了后，会调用用户设置的定时器timeout...
RT-Thread定时器源码分析
06-09
好的，我会尽力回答你的问题。首先，RT-Thread是一个实时操作系统，它提供了一些基本的实时操作系统功能，例如线程、信号量、消息队列、定时器等。其中，定时器是一种非常重要的实时操作系统功能，它可以用来在指定的时间间隔内执行一些操作。 在RT-Thread中，定时器的实现是基于软件定时器，即在内核中维护一个定时器列表，每个定时器都有一个超时时间。当定时器到期时，内核会调用定时器回调函数来执行相应的操作。 下面是RT-Thread定时器的源码分析： 1. 定时器结构体 在RT-Thread中，定时器的结构体定义如下： ```c struct rt_timer { char name[RT_NAME_MAX]; /* 定时器名称 */ rt_list_t list; /* 定时器列表 */ rt_tick_t timeout_tick; /* 定时器超时时间 */ rt_tick_t init_tick; /* 定时器初始时间 */ rt_uint8_t flag; /* 定时器标志 */ rt_uint8_t state; /* 定时器状态 */ void (*timeout_func)(void* parameter); /* 定时器回调函数 */ void* parameter; /* 回调函数参数 */ }; ``` 可以看到，定时器结构体包含了定时器的名称、超时时间、标志、状态、回调函数等信息。 2. 定时器创建 在RT-Thread中，定时器的创建函数是rt_timer_create()，它的函数原型如下： ```c rt_err_t rt_timer_create(rt_timer_t *timer, const char *name, void (*timeout_func)(void* parameter), void* parameter, rt_tick_t time, rt_uint8_t flag); ``` 其中，timer表示定时器指针，name表示定时器名称，timeout_func表示定时器回调函数，parameter表示回调函数参数，time表示定时器超时时间，flag表示定时器标志。 rt_timer_create()函数会在内核中创建一个定时器，并将定时器添加到定时器列表中。如果创建成功，函数返回RT_EOK，否则返回错误码。 3. 定时器启动 在RT-Thread中，定时器的启动函数是rt_timer_start()，它的函数原型如下： ```c rt_err_t rt_timer_start(rt_timer_t timer); ``` rt_timer_start()函数会启动指定的定时器，并将其状态设置为RT_TIMER_FLAG_ACTIVATED。如果启动成功，函数返回RT_EOK，否则返回错误码。 4. 定时器停止 在RT-Thread中，定时器的停止函数是rt_timer_stop()，它的函数原型如下： ```c rt_err_t rt_timer_stop(rt_timer_t timer); ``` rt_timer_stop()函数会停止指定的定时器，并将其状态设置为RT_TIMER_FLAG_DEACTIVATED。如果停止成功，函数返回RT_EOK，否则返回错误码。 5. 定时器删除 在RT-Thread中，定时器的删除函数是rt_timer_delete()，它的函数原型如下： ```c rt_err_t rt_timer_delete(rt_timer_t timer); ``` rt_timer_delete()函数会删除指定的定时器，并释放相应的资源。如果删除成功，函数返回RT_EOK，否则返回错误码。 以上就是RT-Thread定时器的源码分析，希望能对你有所帮助。如果你有其他问题，可以继续问我。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

柯西的彷徨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值