RT-Thread 时钟管理

一、时钟节拍

任何操作系统都需要提供一个时钟节拍，以供系统处理所有和时间有关的事件，如线程的延时、线程的时间片轮转调度以及定时器超时等。时钟节拍是特定的周期性中断，这个中断可以看做是系统心跳，中断之间的时间间隔取决于不同的应用，一般是 1ms–100ms，时钟节拍率越快，系统的实时响应越快，但是系统的额外开销就越大，从系统启动开始计数的时钟节拍数称为系统时间。

RT-Thread 中，时钟节拍的长度可以根据 RT_TICK_PER_SECOND 的定义来调整，等于 1/RT_TICK_PER_SECOND 秒。

  • 实现方式
    RT-Thread在board.c文件中实现了SysTick_Handler中断函数，在rt_hw_board_init()函数中设置了系统的时钟节拍，也就是1/RT_TICK_PER_SECOND 秒会发生一次中断。如下图所示：

    从图中可以，当中断函数发生时都会调用一次 rt_tick_increase() 对全局变量 rt_tick 进行自加，代码如下所示：

    		void rt_tick_increase(void)
    		{
    		    struct rt_thread *thread;
    		 
    		    /* 全局变量 rt_tick 自加 */
    		    ++ rt_tick;
    		 
    		    /* 检查时间片 */
    		    thread = rt_thread_self();
    		 
    		    -- thread->remaining_tick;
    		    if (thread->remaining_tick == 0)
    		    {
    		        /* 重新赋初值 */
    		        thread->remaining_tick = thread->init_tick;
    		 
    		        /* 线程挂起 */
    		        rt_thread_yield();
    		    }
    		 
    		    /* 检查定时器 */
    		    rt_timer_check();
    		}

    可以看到全局变量 rt_tick 在每经过一个时钟节拍时，值就会加 1，rt_tick 的值表示了系统从启动开始总共经过的时钟节拍数，即系统时间。此外，每经过一个时钟节拍时，都会检查当前线程的时间片是否用完，以及是否有定时器超时。

    注意：中断中的 rt_timer_check() 用于检查系统硬件定时器链表，如果有定时器超时，将调用相应的超时函数。且所有定时器在定时超时后都会从定时器链表中被移除，而周期性定时器会在它再次启动时被加入定时器链表。

二、定时器管理

定时器分硬件定时器和软件定时器，RT-Thread 操作系统提供软件实现的定时器，以时钟节拍（OS Tick）的时间长度为单位，即定时数值必须是 OS Tick 的整数倍，例如一个 OS Tick 是 10ms，那么上层软件定时器只能是 10ms，20ms，100ms 等，而不能定时为 15ms。

  1. 定时器介绍
    RT-Thread定时器提供两类定时器机制：一种是只会触发一次的定时器；另一种是周期性触发定时器。另外根据超时函数执行时所处的上下文环境，RT-Thread 的定时器可以分为 HARD_TIMER 模式与 SOFT_TIMER 模式，如下图。

  • HARD_TIMER 模式
    1）HARD_TIMER 模式是在中断过程中执行，可以在初始化 / 创建定时器时使用参数 RT_TIMER_FLAG_HARD_TIMER 来指定。
    2）在HARD_TIMER 模式中不能申请动态内存、释放动态内存等。
    3）中断是优先级最好的抢占式服务，所以不能在HARD_TIMER 模式下的超时函数中执行长时间的占用操作。

  • SOFT_TIMER 模式
    1）通过宏定义 RT_USING_TIMER_SOFT 来决定是否启用该模式
    2）SOFT_TIMER 模式的定时器超时函数在都会在 timer 线程的上下文环境中执行。
    3）初始化 / 创建定时器时使用参数 RT_TIMER_FLAG_SOFT_TIMER 来指定设置 SOFT_TIMER 模式。

  1. 定时器工作机制
    在 RT-Thread 定时器模块中维护着两个重要的全局变量：

    • 当前系统经过的 tick 时间 rt_tick（当硬件定时器中断来临时，它将加 1）；
    • 定时器链表 rt_timer_list。系统新创建并激活的定时器都会按照以超时时间排序的方式插入到 rt_timer_list 链表中。

    注意：t_timer_list 链表是一个有序链表，当创建了一个新的tick值时，在链表中的添加如下图所示：

  2. 定时器跳表 (Skip List) 算法
    如下图所示，从该有序链表中搜索元素 {13, 39}，需要比较的次数分别为 {3, 5}，总共比较的次数为 3 + 5 = 8 次。

    使用跳表算法，把一些节点提取出来作为索引，得到如下图所示的结构。在这个结构里把 {3, 18,77} 提取出来作为一级索引，这样搜索的时候就可以减少比较次数了, 例如在搜索 39 时仅比较了 3 次（通过比较 3，18，39)。

    注意：跳表算法可以提取多级索引，在 RT-Thread 中通过宏定义 RT_TIMER_SKIP_LIST_LEVEL 来配置跳表的层数，默认为 1。

  3. 定时器控制快
    RT-Thread 在 rtdef.h 文件中定义了结构体 struct rt_timer ，如下所示：

    		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;

三、定时器函数

在系统启动时，会在 rtthread_startup 函数中调用 rt_system_timer_init 函数和 rt_system_timer_thread_init 函数，如下所示：

 
// 初始化定时器管理系统
void rt_system_timer_init(void);
 
// 计时器线程初始化
void rt_system_timer_thread_init(void);

定时器的相关操作如下图所示：

  1. 获取时钟节拍

    		rt_tick_t rt_tick_get(void);
    • rt_tick_t：返回当前时钟节拍值 rt_tick

  2. 动态创建定时器

    		rt_timer_t rt_timer_create(const char* name,
    		                           void (*timeout)(void* parameter),
    		                           void* parameter,
    		                           rt_tick_t time,
    		                           rt_uint8_t flag);

    • name：定时器的名称

    • void (timeout) (void parameter)： 定时器超时函数指针（当定时器超时时，系统会调用这个函数）

    • parameter：定时器超时函数的入口参数（当定时器超时时，调用超时回调函数会把这个参数做为入口参数传递给超时函数）

    • time：定时器的超时时间，单位是时钟节拍

    • flag：定时器创建时的参数，支持的值包括单次定时、周期定时、硬件定时器、软件定时器等（可以用 “或” 关系取多个值）

    • rt_timer_t ：RT_NULL：创建失败（通常会由于系统内存不够用而返回 RT_NULL）。创建成功是返回定时器的句柄

    • flag 的值在rtdef.h 中定义了相关的宏：

      		 
      		#define RT_TIMER_FLAG_ONE_SHOT      0x0     /* 单次定时     */
      		#define RT_TIMER_FLAG_PERIODIC      0x2     /* 周期定时     */
      		 
      		#define RT_TIMER_FLAG_HARD_TIMER    0x0     /* 硬件定时器   */
      		#define RT_TIMER_FLAG_SOFT_TIMER    0x4     /* 软件定时器   */

    注意： 上面 2 组值可以以 “或” 逻辑的方式赋给 flag。

  3. 删除动态定时器

    		rt_err_t rt_timer_delete(rt_timer_t timer);
    • timer：定时器句柄，指向要删除的定时器
    • rt_err_t：RT_EOK：删除成功（如果参数 timer 句柄是一个 RT_NULL，将会导致一个 ASSERT 断言）

  4. 创建静态定时器

    		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);
    • timer：定时器句柄，指向要初始化的定时器控制块
    • name：定时器的名称
    • void (timeout) (void parameter)：定时器超时函数指针（当定时器超时时，系统会调用这个函数）
    • parameter：定时器超时函数的入口参数（当定时器超时时，调用超时回调函数会把这个参数做为入口参数传递给超时函数）
    • time：定时器的超时时间，单位是时钟节拍
    • flag：定时器创建时的参数，支持的值包括单次定时、周期定时、硬件定时器、软件定时器（可以用 “或” 关系取多个值），详见创建定时器小节

  5. 删除静态定时器

    		rt_err_t rt_timer_detach(rt_timer_t timer);
    • timer：定时器句柄，指向要脱离的定时器控制块
    • rt_err_t ：RT_EOK：脱离成功

  6. 启动定时器

    		rt_err_t rt_timer_start(rt_timer_t timer);
    • timer：定时器句柄，指向要启动的定时器控制块
    • rt_err_t ：RT_EOK：启动成功

  7. 停止定时器

    		rt_err_t rt_timer_stop(rt_timer_t timer);
    • timer：定时器句柄，指向要启动的定时器控制块
    • rt_err_t ：RT_EOK：成功停止定时器，RT_ERROR：timer 已经处于停止状态

  8. 控制定时器

    		rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void* arg);
    • timer：定时器句柄，指向要启动的定时器控制块
    • cmd ：用于控制定时器的命令，当前支持四个命令，分别是设置定时时间，查看定时时间，设置单次触发，设置周期触发
    • arg：与 cmd 相对应的控制命令参数 比如，cmd 为设定超时时间时，就可以将超时时间参数通过 arg 进行设定
    • rt_err_t ：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     /* 设置定时器为周期型定时器 */

四、应用实例

动态定时器使用

 
#include "stm32f10x.h"
#include "drv_gpio.h"
#include "drv_usart.h"
#include <rtthread.h>
 
/* 定时器的控制块 */
static rt_timer_t timer1;
static rt_timer_t timer2;
static int cnt = 0;
 
/* 定时器 1 超时函数 */
static void timeout1(void *parameter)
{
    rt_kprintf("periodic timer is timeout %d\n", cnt);
 
    /* 运行第 10 次，停止周期定时器 */
    if (cnt++>= 9)
    {
        rt_timer_stop(timer1);
        rt_kprintf("periodic timer was stopped! \n");
    }
}
 
/* 定时器 2 超时函数 */
static void timeout2(void *parameter)
{
    rt_kprintf("one shot timer is timeout\n");
}
 
int timer_sample(void)
{
    /* 创建定时器 1  周期定时器 */
    timer1 = rt_timer_create("timer1", timeout1,
                             RT_NULL, 10,
                             RT_TIMER_FLAG_PERIODIC);
 
    /* 启动定时器 1 */
    if (timer1 != RT_NULL) rt_timer_start(timer1);
 
    /* 创建定时器 2 单次定时器 */
    timer2 = rt_timer_create("timer2", timeout2,
                             RT_NULL,  30,
                             RT_TIMER_FLAG_ONE_SHOT);
 
    /* 启动定时器 2 */
    if (timer2 != RT_NULL) rt_timer_start(timer2);
    return 0;
}
 
 
 
 
 
int main(void)
{ 
	rt_kprintf("RT-Thread Start...... \n");
	
	timer_sample();
	
	while (1)
	{	 
		
		GPIO_ResetBits(GPIOB,GPIO_Pin_12);
		rt_thread_delay(1000);	// 延时1000 ms
		
		GPIO_SetBits(GPIOB, GPIO_Pin_12 );
		rt_thread_delay(1000);	// 延时1000 ms
		
	}
}

运行结果如下：

静态定时器使用

#include "stm32f10x.h"
#include "drv_gpio.h"
#include "drv_usart.h"
#include <rtthread.h>
 
/* 定时器的控制块 */
static struct rt_timer timer1;
static struct rt_timer timer2;
static int cnt = 0;
 
/* 定时器 1 超时函数 */
static void timeout1(void* parameter)
{
    rt_kprintf("periodic timer is timeout\n");
    /* 运行 10 次 */
    if (cnt++>= 9)
    {
        rt_timer_stop(&timer1);
    }
}
 
/* 定时器 2 超时函数 */
static void timeout2(void* parameter)
{
    rt_kprintf("one shot timer is timeout\n");
}
 
int timer_static_sample(void)
{
    /* 初始化定时器 */
    rt_timer_init(&timer1, "timer1",  /* 定时器名字是 timer1 */
                    timeout1, /* 超时时回调的处理函数 */
                    RT_NULL, /* 超时函数的入口参数 */
                    10, /* 定时长度，以 OS Tick 为单位，即 10 个 OS Tick */
                    RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
    rt_timer_init(&timer2, "timer2",   /* 定时器名字是 timer2 */
                    timeout2, /* 超时时回调的处理函数 */
                      RT_NULL, /* 超时函数的入口参数 */
                      30, /* 定时长度为 30 个 OS Tick */
                    RT_TIMER_FLAG_ONE_SHOT); /* 单次定时器 */
 
    /* 启动定时器 */
    rt_timer_start(&timer1);
    rt_timer_start(&timer2);
    return 0;
}
 
 
int main(void)
{ 
	rt_kprintf("RT-Thread Start...... \n");
	
	timer_static_sample();
	
	while (1)
	{	 
		
		GPIO_ResetBits(GPIOB,GPIO_Pin_12);
		rt_thread_delay(1000);	// 延时1000 ms
		
		GPIO_SetBits(GPIOB, GPIO_Pin_12 );
		rt_thread_delay(1000);	// 延时1000 ms
		
	}
}

运行结果如下：

参考文献

RT-Thread文档中心：https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-standard/README

posted @   浇筑菜鸟  阅读(386)  评论(0)  编辑  收藏  举报
相关博文：
·  RT-Thread线程管理
·  RT-Thread移植到stm32
·  RT-Thread速览——内核
·  rtthread：rt_timer定时器
·  实时线程(RT Thread)的定时器稳定性测试
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
· winform 绘制太阳，地球，月球 运作规律
点击右上角即可分享
微信分享提示
AI IDE Trae