rtthread定时器的实现

最新推荐文章于 2024-04-30 01:52:45 发布
最新推荐文章于 2024-04-30 01:52:45 发布
阅读量2k 收藏 3
点赞数 1
分类专栏： 记录 STM32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzw508170827/article/details/111347752
版权
记录 同时被 2 个专栏收录
82 篇文章 7 订阅
订阅专栏
STM32
31 篇文章 4 订阅
订阅专栏

title: rtthread定时器的实现
date: 2020-10-25 15:57:01
tags: rtthread

每当线程需要延时的时候，就初始化 remaining_tick 需要延时的时间，然后将线程挂起，这里的挂起只是将线程在线程就绪优先级组中对应的位清 0，并不会将线程从线程优先级表（即就绪列表）中删除。当每次时基中断（SysTick 中断）来临时，就扫描就绪列表中的每个线程的 remaining_tick，如果 remaining_tick 大于 0 则递减一次，然后判断 remaining_tick 是否为 0，如果为 0 则表示延时时间到，将该线程就绪（即将线程在线程就绪优先级组中对应的位置位），然后等待系统下一次调度。这种延时的缺点是，在每个时基中断中需要对所有线程都扫描一遍，费时，优点是容易理解。之所以先这样讲解是为了慢慢地过度到 RT-Thread 定时器的讲解。

在 RT-Thread 中，每个线程都内置一个定时器，当线程需要延时的时候，则先将线程挂起，然后内置的定时器就会启动，并且将定时器插入到一个全局的系统定时器列表rt_timer_list，这个全局的系统定时器列表维护着一条双向链表，每个节点代表了正在延时的线程的定时器，节点按照延时时间大小做升序排列。当每次时基中断（SysTick 中断）来临时，就扫描系统定时器列表的第一个定时器，看看延时时间是否到，如果到则让该定时器对应的线程就绪，如果延时时间不到，则退出扫描，因为定时器节点是按照延时时间升序排列的，第一个定时器延时时间不到期的话，那后面的定时器延时时间自然不到期。比起第一种方法，这种方法就大大缩短了寻找延时到期的线程的时间。

定时器实现

系统定时器列表

在 RT-Thread 中，定义了一个全局的系统定时器列表，当线程需要延时时，就先把线程挂起，然后线程内置的定时器将线程挂起到这个系统定时器列表中，系统定时器列表维护着一条双向链表，节点按照定时器的延时时间的大小做升序排列。

redef.h

#ifndef RT_TIMER_SKIP_LIST_LEVEL
#define RT_TIMER_SKIP_LIST_LEVEL          1
#endif

timer.c

/* hard timer list */
static rt_list_t rt_timer_list[RT_TIMER_SKIP_LIST_LEVEL];

数组只有一个成员。

系统定时器列表初始化

void rt_system_timer_init(void)
{
    int i;

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

即初始化数组每个成员节点的next和prev两个指向自己本身。

定时器结构体定义

rtdef.h

/**
 * 定时器结构体
 */
struct rt_timer
{
    struct rt_object parent;                         /* 从 rt_object 继承 */

    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;

定时器也属内核对象，也会在结构体包含内核对象类型的成员。

row[RT_TIMER_SKIP_LIST_LEVEL]定时器自身的节点，通过该节点可以实现将定时器插入到系统定

时器列表。

(*timeout_func)(void *parameter)定时器超时函数，定时器到期会调用相应的超时函数。

timeout_tick:我们知道系统定义了一个全局的系统时基计数器 rt_tick（在 clock.c 中定义），每产生一次系统时基中断（即 SysTick 中断）时，rt_tick 计数加一。假设线程要延时 10 个 tick，即 init_tick 等于 10，此时 rt_tick 等于 2，那么 timeout_tick 就等于 10 加 2 等于 12，当 rt_tick 递增到 12 的时候，线程延时到期，这个就是 timeout_tick 的实际含义。

线程控制块内置定时器

rtdef.h

struct rt_thread
{
    /* rt 对象 */
    char        name[RT_NAME_MAX];    /* 对象的名字 */
    rt_uint8_t  type;                 /* 对象类型 */
    rt_uint8_t  flags;                /* 对象的状态 */
    rt_list_t   list;                 /* 对象的列表节点 */
    
	rt_list_t   tlist;                /* 线程链表节点 */
    
	void        *sp;	              /* 线程栈指针 */
	void        *entry;	              /* 线程入口地址 */
	void        *parameter;	          /* 线程形参 */	
	void        *stack_addr;          /* 线程起始地址 */
	rt_uint32_t stack_size;           /* 线程栈大小，单位为字节 */
	
    rt_ubase_t  remaining_tick;       /* 用于实现阻塞延时 */
    
    rt_uint8_t  current_priority;     /* 当前优先级 */
    rt_uint8_t  init_priority;        /* 初始优先级 */
    rt_uint32_t number_mask;          /* 当前优先级掩码 */
    
    rt_err_t    error;                /* 错误码 */
    rt_uint8_t  stat;                 /* 线程的状态 */
    
    struct rt_timer thread_timer;     /* 内置的线程定时器 */
};
typedef struct rt_thread *rt_thread_t;

定时器初始化函数

timer.c

/**
 * 该函数用于初始化一个定时器，通常该函数用于初始化一个静态的定时器
 *
 * @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_object_init((rt_object_t)timer, RT_Object_Class_Timer, name);

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

static void _rt_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]));
    }
}

定时器的标志位：

rtdef.h

/**
 * 时钟 & 定时器 宏定义
 */
#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 isr中调用 */

#define RT_TIMER_FLAG_SOFT_TIMER        0x4     /* 软件定时器，定时器回调函数在定时器线程中调用 */

定时器相关函数

删除函数

rt_inline void _rt_timer_remove(rt_timer_t timer)
{
    int i;

    for (i = 0; i < RT_TIMER_SKIP_LIST_LEVEL; i++)
    {
        rt_list_remove(&timer->row[i]);
    }
}

停止函数

实现的算法主要分成两步，先将定时器从系统定时器列表删除，然后改变定时器的状态为非 active 即可

/**
 * 该函数将停止一个定时器
 *
 * @param timer 将要被停止的定时器
 *
 * @return 操作状态, RT_EOK on OK, -RT_ERROR on error
 */
rt_err_t rt_timer_stop(rt_timer_t timer)
{
    register rt_base_t level;

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

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

    /* 将定时器从定时器列表删除 */
    _rt_timer_remove(timer);

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

    /* 改变定时器的状态为非active */
    timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;

    return RT_EOK;
}

定时器控制函数

根据不同的形参来设置定时器的状态和初始时间值

/**
 * 该函数将获取或者设置定时器的一些选项
 * 
 * @param timer 将要被设置或者获取的定时器
 * @param cmd 控制命令
 * @param arg 形参
 *
 * @return RT_EOK
 */
rt_err_t rt_timer_control(rt_timer_t timer, int cmd, void *arg)
{
    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;
    }

    return RT_EOK;
}

相关宏定义

#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     /* 修改定时器为周期定时 */

*启动函数

/**
 * 启动定时器
 *
 * @param timer 将要启动的定时器
 *
 * @return 操作状态, RT_EOK on OK, -RT_ERROR on error
 */
rt_err_t rt_timer_start(rt_timer_t timer)
{
    unsigned int row_lvl = 0;
    rt_list_t *timer_list;
    register rt_base_t level;
    rt_list_t *row_head[RT_TIMER_SKIP_LIST_LEVEL];
    unsigned int tst_nr;
    static unsigned int random_nr;


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

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

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


    /* 将定时器插入到定时器列表 */
    /* 获取系统定时器列表根节点地址，rt_timer_list是一个全局变量 */
    timer_list = rt_timer_list;


    /* 获取系统定时器列表第一条链表根节点地址 */
    row_head[0]  = &timer_list[0];
    
    /* 因为RT_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;
            }
            
        }
        /* 条件不会成真，不会被执行 */
        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;

        tst_nr >>= (RT_TIMER_SKIP_LIST_MASK + 1) >> 1;
    }

    /* 设置定时器标志位为激活态 */
    timer->parent.flag |= RT_TIMER_FLAG_ACTIVATED;

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

    return -RT_EOK;
}

一个初始化好的空的系统定时器列表示意图，只有一个成员

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mEZjpQI7-1608216004386)(https://i.loli.net/2020/10/25/BneYF4PWR3TScXj.png)]

假设现在有3个定时器要启动。

定时器1: timeout_tick=4

定时器2: timeout_tick=2

定时器3: timeout_tick=3

插入定时器1（timeout_tick=4）
  1. 将定时器1节点从系统定时器移除。（相当于将节点取下晾衣架）
  2. 将定时器1状态为非active。
  3. 获取定时器1的超时节拍。（定时器超时节拍 = 系统节拍 + 定时器延时节拍）
  4. 获取系统定时器列表根节点地址到timer_list。
  5. 获取链表第一个节点的地址到row_head[0] 。（row_head[0] = &timer_list[0];）
  6. 应为链表为空，所以不执行for循环。
  7. 将定时器1插入系统定时器列表根节点。
  8. 将定时器1状态为active。

如图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PCYQA4Gu-1608216004394)(https://i.loli.net/2020/10/25/kzacUWSnIOo4Mb3.png)]

插入定时器2（timeout_tick=2）

前五步一样。

  1. 此时链表不为空，执行for循环。
  2. 获取定时器1的节点地址给 p 。
  3. 根据定时器1的节点地址p得出定时器1的地址给t 。
  4. 较定时器1(t) 和定时器2(timer) 超时时间大小。如果时间相同则在定时器列表中寻找下一个节点。如果定时器1（t）大，跳出for循环。即将定时器2节点插入到定时器1前面。（超时时间大的在后面）
  5. 后面几步一样。

如图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wT9lozaw-1608216004396)(https://i.loli.net/2020/10/25/hBITaoXnKcv1yEl.png)]

插入定时器3（timeout_tick=3）

前五步一样。

  1. 第一次执行for循环，t(定时器2_timeout_tick=2) < timer(定时器3_timeout_tick=3)。
  2. row_head[row_lvl] = row_head[row_lvl]->next。执行第二次for循环。
  3. 此时t(定时器1_timeout_tick=4) > timer(定时器3_timeout_tick=3)。
  4. 定时器3节点插入到定时器1节点之前。

如图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tjk17mOV-1608216004399)(https://i.loli.net/2020/10/25/iV6qvufY9FzWwJb.png)]

扫描函数

用于扫描系统定时器列表，查询定时器的延时是否到期，如果到期则让对应的线程就绪。

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

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

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

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

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

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

            /* 周期定时器 */
            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
            {
                /* 停止定时器 */
                t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
            }
        }
        else
            break;
    }

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

通过判断current_tick - t->timeout_tick > 0 判断定时器是否到期。到期移除定时器并调用超时函数。最后判断是否为周期定时器。

超时函数：

thread.c

/**
 * 线程超时函数
 * 当线程延时到期或者等待的资源可用或者超时时，该函数会被调用
 *
 * @param parameter 超时函数的形参
 */
void rt_thread_timeout(void *parameter)
{
    struct rt_thread *thread;

    thread = (struct rt_thread *)parameter;

    /* 设置错误码为超时 */
    thread->error = -RT_ETIMEOUT;

    /* 将线程从挂起列表中删除 */
    rt_list_remove(&(thread->tlist));

    /* 将线程插入到就绪列表 */
    rt_schedule_insert_thread(thread);

    /* 系统调度 */
    rt_schedule();
}
  1. 设置线程错误码为超时。
  2. 将线程从挂起列表中删除，前提是线程在等待某些资源而被挂起到挂起列表，如果只是延时到期，则这个只是空操作。
  3. 将线程就绪。执行系统调度。

修改代码

线程初始化函数

rt_err_t rt_thread_init(struct rt_thread *thread,
                        const char       *name,
                        void (*entry)(void *parameter),
                        void             *parameter,
                        void             *stack_start,
                        rt_uint32_t       stack_size,
                        rt_uint8_t        priority)
{
	/* 线程对象初始化 */
	/* 线程结构体开头部分的成员就是rt_object_t类型 */
	rt_object_init((rt_object_t)thread, RT_Object_Class_Thread, name);
    rt_list_init(&(thread->tlist));
	
	thread->entry = (void *)entry;
	thread->parameter = parameter;

	thread->stack_addr = stack_start;
	thread->stack_size = stack_size;
	
	/* 初始化线程栈，并返回线程栈指针 */
	thread->sp = (void *)rt_hw_stack_init( thread->entry, 
		                                   thread->parameter,
							               (void *)((char *)thread->stack_addr + thread->stack_size - 4) );
	
    thread->init_priority    = priority;
    thread->current_priority = priority;
    thread->number_mask = 0;
    
    /* 错误码和状态 */
    thread->error = RT_EOK;
    thread->stat  = RT_THREAD_INIT;
    
    /* 初始化线程定时器 */
    rt_timer_init(&(thread->thread_timer),     /* 静态定时器对象 */
                  thread->name,                /* 定时器的名字，直接使用的是线程的名字 */
                  rt_thread_timeout,           /* 超时函数 */
                  thread,                      /* 超时函数形参 */
                  0,                           /* 延时时间 */
                  RT_TIMER_FLAG_ONE_SHOT);     /* 定时器的标志 */
    
    return RT_EOK;
}

线程延时函数

rt_err_t rt_thread_delay(rt_tick_t tick)
{
    return rt_thread_sleep(tick);
}    

/**
 * 该函数将让当前线程睡眠一段时间，单位为tick
 * 
 * @param tick 睡眠时间，单位为tick
 *
 * @return RT_EOK
 */
rt_err_t rt_thread_sleep(rt_tick_t tick)
{
    register rt_base_t temp;
    struct rt_thread *thread;

    /* 关中断 */
    temp = rt_hw_interrupt_disable();
    
    /* 获取当前线程的线程控制块 */
    thread = rt_current_thread;

    /* 挂起线程 */
    rt_thread_suspend(thread);

    /* 设置线程定时器的超时时间 */
    rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick);
    
    /* 启动定时器 */
    rt_timer_start(&(thread->thread_timer));

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

    /* 执行系统调度 */
    rt_schedule();

    return RT_EOK;
}

/**
 * 该函数用于挂起指定的线程
 * @param thread 要被挂起的线程
 *
 * @return 操作状态, RT_EOK on OK, -RT_ERROR on error
 *
 * @note 如果挂起的是线程自身，在调用该函数后，
 * 必须调用rt_schedule()进行系统调度
 * 
 */
rt_err_t rt_thread_suspend(rt_thread_t thread)
{
    register rt_base_t temp;


    /* 只有就绪的线程才能被挂起，否则退出返回错误码 */
    if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_READY)
    {
        return -RT_ERROR;
    }

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

    /* 改变线程状态 */
    thread->stat = RT_THREAD_SUSPEND;
    /* 将线程从就绪列表删除 */
    rt_schedule_remove_thread(thread);

    /* 停止线程定时器 */
    rt_timer_stop(&(thread->thread_timer));

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

    return RT_EOK;
}

修改系统时基更新函数

void rt_tick_increase(void)
{
    /* 系统时基计数器加1操作,rt_tick是一个全局变量 */
    ++ rt_tick;
    
    /* 扫描系统定时器列表 */
    rt_timer_check();
}
橘长_
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RTthread 定时器
fan15513083328的博客
05-17 1463
struct rt_timer { struct rt_object parent; /**< inherit from rt_object */ rt_list_t row[RT_TIMER_SKIP_LIST_LEVEL]; // 定时器列表节点 void (*timeout_func)(void *parameter); /**< timeout functio...
用龙芯1c库在RT-Thread下实现硬件定时器中断
勤为本的专栏
07-19 1805
用龙芯1c库中的硬件定时器接口和RT-Thread中的中断接口一起实现硬件定时器中断
Rtthread Timer管理
weixin_43522787的博客
02-26 458
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定时器介绍与使用
最新发布
hgfjv的博客
04-30 702
而 rt_tick 随着硬件定时器的触发一直在增长（每一次硬件定时器中断来临，rt_tick 变量会加 1） ，50个tick以后，rt_tick从20增长到70，与Timer1的timeout值相等，这时会触发与Timer1定时器相关联的超时函数，同时将Timer1从rt_timer_list链表上删除。rt_timer_create（）参数依次是定时器的名，定时器的超时函数，定时器的超时函数的输入参数，定时时间，定时设置的属性。RT_TIMER_FLAG_HARD_TIMER表示是软件定时器。
时钟中断是rt-thread的线程调度器的驱动力
管子（zero）的杂乱空间
02-19 255
1 系统时钟中断驱动引擎 rt-thread操作系统中当线程时间片耗尽，或是当线程sleep一段时间后唤醒再被调度，此过程又是如何进行的呢？到底是谁来驱动这一过程的呢？ 答案是时钟中断源。且来看看时钟中断例程： 在bsp/stm32f20x/drivers/board.c源文件中存在这么一个时钟中断例程代码:(这里以stm32f20x的MCU为例) /** * This is th...
rt thread 3.1.3版本操作系统定时器卡死的问题
fhqlongteng的博客
01-14 2209
1、操作系统定时器 操作系统定时器是由rt thread内核提供的一个定时功能，支持硬件定时器或软件定时器。最后在一个产品的使用了多个定时器来实现数据通信指示灯的功能，原理是创建一个周期定时器，创建一个单次定时器，当有数据通信时，启动周期定时器来控制灯闪烁，启动单次定时器来超时关闭灯和周期定时器。当有数据再次到来时重新启动，达到了闪灯的效果。 2、定时器卡死的问题 这个定时器由2个不同优先级的线程调用，在程序经过长时间运行后，会出现定时器卡死，即程序一直运行在rt_timer_...
rt-thread 硬件定时器实现时间片轮询
01-26
rt-thread是一个轻量级实时操作系统，它支持硬件定时器来实现时间片轮询功能。在rt-thread 3.0版本中，硬件定时器与时间片轮询的实现主要涉及以下几个关键点： 1. **硬件定时器**：硬件定时器是操作系统中用于产生...
rtthread-api手册
11-30
5. **定时器**：RTThread提供了一套完善的定时器服务，如`rt_timer_create()`、`rt_timer_start()`、`rt_timer_stop()`、`rt_timer_detach()`和`rt_timer_init()`等，开发者可以根据需求设置定时任务。 6. **内存...
zynq7020+rtthread.zip
10-30
在Zynq7020上移植RTThread，开发者可以充分利用其强大的处理能力和灵活的硬件资源，实现复杂的实时应用。 移植RTThread到Zynq7020的过程中，首先需要配置和编译内核，确保它适应Zynq7020的硬件特性。这包括设置中断...
RTTHREAD.rar
04-17
1. **实时性**：RTThread 实现了抢占式调度，可以确保关键任务的及时响应。 2. **微内核设计**：基础内核小而精，只包含最基本的任务调度、内存管理和中断处理，提供高效运行环境。 3. **组件丰富**：包含TCP/IP网络...
rtthread详细资料
07-28
7. **网络编程**：通过RTThread的TCP/IP网络栈，学习如何实现网络通信功能，包括HTTP、FTP、UDP等协议。 8. **设备驱动开发**：掌握RTThread的设备驱动框架，编写和集成各种硬件驱动。 9. **文件系统**：了解如何...
RT-Thread学习笔记 -- 时钟管理
weixin_45383564的博客
10-26 292
RT-Thread学习笔记 – 时钟管理 软件硬件定时器区别 1.定时器分为硬件定时器和软件定时器。区别：硬件定时器的超时函数是在定时器中断中管理的（也就是时基中断systick中断）。而软件定时器的超时函数是在线程中管理的。 进中断的就是“硬的”，在线程里或任务里的是“软的”。 2.软件定时器比硬件定时器使用起来更简单，但是硬件定时器能提供更高精度的定时效果。一般来说软件定时器提供的 ms 级别的。精确定时，请使用硬件定时器，比如 us 级。 3.一般而言，芯片内部的硬件定时器数量有限，可能无法满足用户需
rtthread系统 - 普中stm32开发板 - rtthread内核资源 - 定时器
lamdonn的博客
01-29 169
rtthread内核资源定时器使用笔记
[嵌入式系统-31]：RT-Thread -16- 定时器机制与定时器使用
文火冰糖（王文兵）的博客
02-20 1493
在操作系统中，定时器（Timer）是一种常用的机制，用于在指定的时间间隔或特定的时刻执行某个任务或触发某个事件。操作系统中的定时器通常用于实现各种功能，比如任务调度、时间片轮转、任务延时、定时中断等。
RT-Thread硬件定时器未进入中断问题解决
南林夕的博客
07-11 920
问题现象： 问题原因：造成这个的原因主要是未使能硬件定时器时钟 问题解决：我使用的是TIM13 随便找地方添加代码使能时钟就可以 void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base) { if(htim_base->Instance==TIM13) { /* USER CODE BEGIN TIM2_MspInit 0 */ /* USER CODE END TIM2_MspInit 0 */
RT-Thread记录（四、RT-Thread 时钟节拍和软件定时器）
不浮夸，不将就，认真对待学知识的我们
03-19 1945
RT-Thread第4课，听听 RT-Thread 的心跳，再学习一下基于心跳的软件定时器使用。
RT-Thread记录（九、RT-Thread 中断处理与阶段小结）
不浮夸，不将就，认真对待学知识的我们
04-19 2920
RT-Thread 内核部分最后一个点 中断管理，顺带着对前面所学知识做个小结。
RTThread中的启动分析
queqiongtao的博客
08-26 3073
RTThread中的启动分析$Sub$$main()和$Super$$main() @(RTThread源码学习) main入口的重新定义$Super$$main()和$Sub$$main() 这是一种特殊模式：用于有一个已经存在且不能被改变的函数 的情况。使用这两个模式可以帮原函数打补丁。如存在一个函数foo(); $Sub$$foo() ：定义的新功能函数，原先foo()函数的入...
【rtthread内核系列】第一篇：定时器
weixin_43810563的博客
05-12 818
一、定时器概念 1.1 时钟节拍 时钟节拍是系统的最小时间单位，宏RT_TICK_PER_SECOND为100时，一个时钟节拍的时间为10ms，时钟节拍也是线程时间片的最小单位。在stm32中，时钟节拍通过systick中断实现，在每次systick中断，全局变量rt_tick加1。 void SysTick_Handler(void) { /* 进 入 中 断 */ rt_interrupt_enter(); …… rt_tick_increase(); /* 退
RT-Thread定时器源码分析
06-09
下面是RT-Thread定时器的源码分析： 1. 定时器结构体 在RT-Thread中，定时器的结构体定义如下： ```c struct rt_timer { char name[RT_NAME_MAX]; /* 定时器名称 */ rt_list_t list; /* 定时器列表 */ rt_tick...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值