uC/OS-III之时钟节拍列表

最新推荐文章于 2022-04-13 15:14:44 发布
最新推荐文章于 2022-04-13 15:14:44 发布
阅读量1.5k 收藏 2
点赞数 1
分类专栏： uC/OS-III 文章标签： uC-OS-III 时钟节拍列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linuxweiyh/article/details/72730571
版权

1.时钟节拍列表由一个时钟节拍轮（，见os_cfg_app.c中的OSCfg_TickWheel[]）和一个计数器OSTickCtr构成。

2.时钟节拍轮是一个数组，其中数组的元素的类型为OS_TICK_SPOKE，它的大小由OS_CFG_TICK_WHEEL_SIZE设定。
建议OS_CFG_TICK_WHEEL_SIZE的大小为任务数目的1/4左右，不要把它的值与时钟节拍的频率成倍数关系，最好为素数。
注：时钟节拍轮的每个元素也成为表项。

3.OS_TICK_SPOKE结构体

struct  os_tick_spoke {
    OS_TCB              *FirstPtr;       // 指向该表项上的等待任务构成的双向链表
    OS_OBJ_QTY           NbrEntries;     // 该表项上等待的任务的数目
    OS_OBJ_QTY           NbrEntriesMax;  // 该表项上等待的任务的最大数目
};

4.OS_TickListInsert()函数的功能是把任务添加到时钟节拍列表，该函数的定义位于os_tick.c文件中，209行 - 306行

void  OS_TickListInsert (OS_TCB   *p_tcb,
                         OS_TICK   time,
                         OS_OPT    opt,
                         OS_ERR   *p_err)
{
    OS_TICK            tick_delta;
    OS_TICK            tick_next;
    OS_TICK_SPOKE     *p_spoke;
    OS_TCB            *p_tcb0;
    OS_TCB            *p_tcb1;
    OS_TICK_SPOKE_IX   spoke;

    if (opt == OS_OPT_TIME_MATCH) {                       // 绝对模式
        tick_delta = time - OSTickCtr - 1u;               // 计算剩余时间
        if (tick_delta > OS_TICK_TH_RDY) {                // 若延时已经发生
            p_tcb->TickCtrMatch = (OS_TICK        )0u;
            p_tcb->TickRemain   = (OS_TICK        )0u;
            p_tcb->TickSpokePtr = (OS_TICK_SPOKE *)0;
           *p_err               =  OS_ERR_TIME_ZERO_DLY;  // 不做时，直接返回
            return;
        }
        p_tcb->TickCtrMatch = time;                       // 匹配延时时间长度
        p_tcb->TickRemain   = tick_delta + 1u;            // 剩余延时时间长度
    } else if (time > (OS_TICK)0u) {                      // 延时长度不为0
        if (opt == OS_OPT_TIME_PERIODIC) {                // 周期模式
            tick_next  = p_tcb->TickCtrPrev + time;       // 下一个周期的时间
            tick_delta = tick_next - OSTickCtr - 1u;      // 距下一个周期还剩多长时间
            if (tick_delta < time) {                      // 若下一个周期未发生
                p_tcb->TickCtrMatch = tick_next;          // 使用下一个周期的时间
            } else {                                      // 下一个周期已发生
                p_tcb->TickCtrMatch = OSTickCtr + time;   // 重置任务的时钟节拍匹配值
            }
            p_tcb->TickRemain   = p_tcb->TickCtrMatch - OSTickCtr;
            p_tcb->TickCtrPrev  = p_tcb->TickCtrMatch;

        } else {                                          // 相对模式
            p_tcb->TickCtrMatch = OSTickCtr + time;
            p_tcb->TickRemain   = time;
        }

    } else {                                              // 延时长度为0
        p_tcb->TickCtrMatch = (OS_TICK        )0u;
        p_tcb->TickRemain   = (OS_TICK        )0u;
        p_tcb->TickSpokePtr = (OS_TICK_SPOKE *)0;
       *p_err               =  OS_ERR_TIME_ZERO_DLY;      // 不做延时，直接返回
        return;
    }

    spoke   = (OS_TICK_SPOKE_IX)(p_tcb->TickCtrMatch % OSCfg_TickWheelSize);  // 获取表项
    p_spoke = &OSCfg_TickWheel[spoke];
    if (p_spoke->NbrEntries == (OS_OBJ_QTY)0u) {                    // 若表项中的任务链表为空
        p_tcb->TickNextPtr   = (OS_TCB   *)0;
        p_tcb->TickPrevPtr   = (OS_TCB   *)0;
        p_spoke->FirstPtr    =  p_tcb;
        p_spoke->NbrEntries  = (OS_OBJ_QTY)1u;
    } else {                                                        // 表项中的任务链表不为空
        p_tcb1     = p_spoke->FirstPtr;                             // 指针指向表项的第一个任务的任务控制块OS_TCB
        while (p_tcb1 != (OS_TCB *)0) {                             // 若指针不为空
            p_tcb1->TickRemain = p_tcb1->TickCtrMatch - OSTickCtr;  // 计算任务的剩余时间
            if (p_tcb->TickRemain > p_tcb1->TickRemain) {           // 指针继续向后移
                if (p_tcb1->TickNextPtr != (OS_TCB *)0) {
                    p_tcb1               =  p_tcb1->TickNextPtr;
                } else {                                            // 到达链表尾部，在链表尾部插入
                    p_tcb->TickNextPtr   = (OS_TCB *)0;
                    p_tcb->TickPrevPtr   =  p_tcb1;
                    p_tcb1->TickNextPtr  =  p_tcb;
                    p_tcb1               = (OS_TCB *)0;             // 跳出循环
                }
            } else {                                                // 插入到当前任务的前面
                if (p_tcb1->TickPrevPtr == (OS_TCB *)0) {           // 在链表头部插入
                    p_tcb->TickPrevPtr   = (OS_TCB *)0;
                    p_tcb->TickNextPtr   =  p_tcb1;
                    p_tcb1->TickPrevPtr  =  p_tcb;
                    p_spoke->FirstPtr    =  p_tcb;
                } else {                                            // 在链表中间插入
                    p_tcb0               =  p_tcb1->TickPrevPtr;
                    p_tcb->TickPrevPtr   =  p_tcb0;
                    p_tcb->TickNextPtr   =  p_tcb1;
                    p_tcb0->TickNextPtr  =  p_tcb;
                    p_tcb1->TickPrevPtr  =  p_tcb;
                }
                p_tcb1 = (OS_TCB *)0;                               // 跳出循环
            }
        }
        p_spoke->NbrEntries++;                                      // 等待的任务的数目加1
    }
    if (p_spoke->NbrEntriesMax < p_spoke->NbrEntries) {
        p_spoke->NbrEntriesMax = p_spoke->NbrEntries;
    }
    p_tcb->TickSpokePtr = p_spoke;                                  // 任务回指到时钟节拍轮的表项上
   *p_err               = OS_ERR_NONE;
}

4.OS_TickListRemove()函数的功能是把任务从时钟节拍列表中删除，该函数的定义位于os_tick.c文件中，326行 - 357行

void  OS_TickListRemove (OS_TCB  *p_tcb)
{
    OS_TICK_SPOKE  *p_spoke;
    OS_TCB         *p_tcb1;
    OS_TCB         *p_tcb2;

    p_spoke = p_tcb->TickSpokePtr;                 // 根据OS_TCB中的成员TickSpoketPtr获取任务所在时钟节拍轮的表项
    if (p_spoke != (OS_TICK_SPOKE *)0) {           // 若表项不为空
        p_tcb->TickRemain = (OS_TICK)0u;           // 任务的剩余时间长度设为0
        if (p_spoke->FirstPtr == p_tcb) {          // 若OS_TCB在链表的头部
            p_tcb1            = (OS_TCB *)p_tcb->TickNextPtr;
            p_spoke->FirstPtr = p_tcb1;
            if (p_tcb1 != (OS_TCB *)0) {
                p_tcb1->TickPrevPtr = (void *)0;
            }
        } else {                                   // OS_TCB在链表中
            p_tcb1              = p_tcb->TickPrevPtr;
            p_tcb2              = p_tcb->TickNextPtr;
            p_tcb1->TickNextPtr = p_tcb2;
            if (p_tcb2 != (OS_TCB *)0) {
                p_tcb2->TickPrevPtr = p_tcb1;
            }
        }
        p_tcb->TickNextPtr  = (OS_TCB        *)0;  // 清空OS_TCB中与时钟节拍有关的成员
        p_tcb->TickPrevPtr  = (OS_TCB        *)0;
        p_tcb->TickSpokePtr = (OS_TICK_SPOKE *)0;
        p_tcb->TickCtrMatch = (OS_TICK        )0u;
        p_spoke->NbrEntries--;
    }
}

5.OS_TickListUpdate()函数的功能是更新时钟节拍列表，该函数的定义位于os_tick.c文件中，404行 - 506行

void  OS_TickListUpdate (void)
{
    CPU_BOOLEAN        done;
    OS_TICK_SPOKE     *p_spoke;
    OS_TCB            *p_tcb;
    OS_TCB            *p_tcb_next;
    OS_TICK_SPOKE_IX   spoke;
    CPU_TS             ts_start;
    CPU_TS             ts_end;
    CPU_SR_ALLOC();                        // 宏定义，声明变量cpu_sr，用来临时保存CPU的状态寄存器的值

    OS_CRITICAL_ENTER();                        // 进入临界区
    ts_start = OS_TS_GET();                     // 获取时间戳
    OSTickCtr++;                                // 计数器加1
    spoke    = (OS_TICK_SPOKE_IX)(OSTickCtr % OSCfg_TickWheelSize);  // 获取表项的位置
    p_spoke  = &OSCfg_TickWheel[spoke];         // 获取表项的地址
    p_tcb    = p_spoke->FirstPtr;               // 获取表项中的第一个OS_TCB
    done     = DEF_FALSE;
    while (done == DEF_FALSE) {
        if (p_tcb != (OS_TCB *)0) {             // 若OS_TCB不为空
            p_tcb_next = p_tcb->TickNextPtr;  // 获取下一个OS_TCB
            switch (p_tcb->TaskState) {
                case OS_TASK_STATE_RDY:                         // 就绪
                case OS_TASK_STATE_PEND:                        // 等待
                case OS_TASK_STATE_SUSPENDED:                   // 被挂起
                case OS_TASK_STATE_PEND_SUSPENDED:              // 等待且被挂起
                     break;
                case OS_TASK_STATE_DLY:                         // 延时
                     p_tcb->TickRemain = p_tcb->TickCtrMatch - OSTickCtr;  // 计算剩余的时间长度   
                     if (OSTickCtr == p_tcb->TickCtrMatch) {    // 若延时时间到
                         p_tcb->TaskState = OS_TASK_STATE_RDY;  // 改变任务的状态未就绪
                         OS_TaskRdy(p_tcb);                     // 把任务添加到任务就绪表中
                     } else {
                         done             = DEF_TRUE;           // 延时时间未到
                     }
                     break;
                case OS_TASK_STATE_PEND_TIMEOUT:                // 带超时检测的等待
                     p_tcb->TickRemain = p_tcb->TickCtrMatch - OSTickCtr;  // 计算剩余的时间长度
                     if (OSTickCtr == p_tcb->TickCtrMatch) {
#if (OS_MSG_EN > 0u)
                         p_tcb->MsgPtr     = (void      *)0;
                         p_tcb->MsgSize    = (OS_MSG_SIZE)0u;
#endif
                         p_tcb->TS         = OS_TS_GET();
                         OS_PendListRemove(p_tcb);              // 从任务挂起表中删除该任务
                         OS_TaskRdy(p_tcb);                     // 把任务添加到任务就绪表中
                         p_tcb->TaskState  = OS_TASK_STATE_RDY; // 任务的状态改为就绪
                         p_tcb->PendStatus = OS_STATUS_PEND_TIMEOUT;
                         p_tcb->PendOn     = OS_TASK_PEND_ON_NOTHING;
                     } else {
                         done              = DEF_TRUE;          // 延时时间未到
                     }
                     break;
                case OS_TASK_STATE_DLY_SUSPENDED:               // 延时且被挂起
                     p_tcb->TickRemain = p_tcb->TickCtrMatch - OSTickCtr;
                     if (OSTickCtr == p_tcb->TickCtrMatch) {
                         p_tcb->TaskState  = OS_TASK_STATE_SUSPENDED;  // 任务的状态改为被挂起
                         OS_TickListRemove(p_tcb);              // 把任务从时钟节拍轮中删除
                     } else {
                         done              = DEF_TRUE;          // 延时时间未到
                     }
                     break;
                case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED:      // 带超时检测的等待且被挂起
                     p_tcb->TickRemain = p_tcb->TickCtrMatch - OSTickCtr;                                       
                     if (OSTickCtr == p_tcb->TickCtrMatch) {
#if (OS_MSG_EN > 0u)
                         p_tcb->MsgPtr     = (void      *)0;
                         p_tcb->MsgSize    = (OS_MSG_SIZE)0u;
#endif
                         p_tcb->TS         = OS_TS_GET();
                         OS_PendListRemove(p_tcb);              // 把任务从任务挂起表中删除
                         OS_TickListRemove(p_tcb);              // 把任务从时钟节拍列表中删除
                         p_tcb->TaskState  = OS_TASK_STATE_SUSPENDED;  // 任务的状态改为被挂起
                         p_tcb->PendStatus = OS_STATUS_PEND_TIMEOUT;
                         p_tcb->PendOn     = OS_TASK_PEND_ON_NOTHING;
                     } else {
                         done              = DEF_TRUE;          // 延时未结束
                     }
                     break;
                default:
                     break;
            }
            p_tcb = p_tcb_next;
        } else {
            done  = DEF_TRUE;
        }
    }
    ts_end = OS_TS_GET() - ts_start;                            // 测量时钟节拍任务的执行时间
    if (ts_end > OSTickTaskTimeMax) {
        OSTickTaskTimeMax = ts_end;
    }
    OS_CRITICAL_EXIT();  // 退出临界区
}
linuxweiyh
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
uC/OS-III 时钟节拍，时间管理，时间片调度
weixin_34342578的博客
08-08 480
时钟节拍 时钟节拍可谓是 uC/OS 操作系统的心脏，它若不跳动，整个系统都将会瘫痪。 时钟节拍就是操作系统的时基，操作系统要实现时间上的管理，必须依赖于时基。 时钟节拍就是系统以固定的频率产生中断（时基中断），并在中断中处理与时间相关的事件，推动所有任务向前运行。 时钟节拍需要依赖于硬件定时器， 在 STM32 裸机程序中经常使用的 SysTick时钟是 MCU的内核定时器，通常都使用该定时器产...
c语言os内核思路,ucosIII内核文件分析-os_core.c
weixin_42510888的博客
05-23 215
Suspend时挂起的意思，是task主动调用使自己挂起，并且是无条件的挂起；而pend时系统让task等待信号量或事件时阻塞的。/********************************************************************************************************************************...
RTOS滴答Tick设置多少才合适
m0_38012497的博客
04-13 579
本文转载，留作笔记，如有侵权，请联系删除，原文链接地址： 嵌入式开发 | RTOS滴答Tick设置多少才合适？ (qq.com)https://mp.weixin.qq.com/s/E2_f8u1qJcvkbF7Lcv9mNQ 最近有读者问了这么一个问题：为啥RTOS的系统滴答（Tick）默认配置都是1000，我配置为100、10000，或者2000可以不？ 相信很多初学者都有这个疑问，包括我初学RTOS也曾困惑滴答配置不同值到底有啥不同和影响。 今天就来简单...
uCOS-Ⅲ学习笔记-时基列表
嵌入式学习记录站点
11-03 891
多优先级总结1.简介2.设置时基列表有关函数以及变量添加全局变量变量类型（OS_TICK_SPOKE）添加任务控制块成员链表实现函数往时基列表插入一个任务TCB（OS_TickListInsert()）从时基列表删除一个指定的节点（OS_TickListRemove()）更新计数器Ctr，扫描时基判断任务是否到期（OS_TickListUpdate()）3.调用流程初始化调用时基更新 1.简介 每个任务都有对应的优先级，优先级高的可以抢占优先级低的 2.设置时基列表有关函数以及变量 添加全局变量 1、O
UCOSIII总结-时钟节拍任务(1)
chenbinchao的博客
06-13 2844
1. 时钟节拍函数怎么建立和启动的 首先时钟节拍任务是整个操作系统UCOSIII的一个核心的任务，是系统的时基，即它是系统的心脏。主要是处理UCOSIII延时、超时的任务，推动整个系统的运行，那么这个这个时钟节拍任务是什么时候建立的 在 OSInit(&err); //初始化UCOSIII 的这个函数里面的 OS_TickTaskInit() 这个函数建立这个任务 void OSInit (OS_ERR *p_err) { //省略大量代码 OS_TickTaskInit(p_err
UC/OS-III移植样例
10-26
STM32F107内置了SysTick定时器，可以配置为系统定时器，用于实现UC/OS-III的时钟节拍。 3. **内存管理**：UC/OS-III提供了动态内存分配和释放的接口。在STM32上，这通常涉及到RAM的分配，需要编写内存池管理代码。 ...
stm32f407ZG 移植uc/OS-iii , 含有w25q128驱动
03-23
5. **时钟节拍**：设置一个定时器作为系统节拍源，用于任务调度和超时检测。 6. **中断处理**：确保中断服务例程与UC/OS-III的上下文切换机制兼容，避免在中断处理过程中发生任务切换。 W25Q128是旺宏电子...
UCOSIII 源码.zip
11-01
7. **Porting层**：为了适应不同硬件平台，uC/OS-III具有可移植性，源码中包含针对特定处理器和开发板的Porting层代码，如初始化、时钟节拍设置等。 **版本对比与更新** 从3.03到3.04的版本升级，可能涉及性能优化...
实验5：UCOSIII-时钟节拍_stm32_exchangeueu_ucoslll_
09-29
本文将深入探讨“实验5：UCOSIII-时钟节拍_stm32_exchangeueu_ucoslll_”这个主题，它涉及到了UCOSIII操作系统在STM32处理器上的应用，以及如何实现时钟节拍功能。 UCOSIII，全称为uC/OS-III，是由Micrium公司开发...
神舟STM32开发板 uc/os3模板
03-16
3. **移植uc/OS**：将uc/OS-III移植到STM32上，包括修改启动代码以初始化堆栈和中断向量表，实现定时器中断服务例程以驱动uc/OS的时钟节拍。 4. **创建任务**：编写应用程序任务，每个任务都有自己的入口函数和...
ucos源代码-os_tick.c
u010743406的博客
08-11 779
/* *********************************************************************************************************************** * uC/OS-III * ...
ucos 时钟节拍_UCOS----时钟节拍源码分析
weixin_42214418的博客
12-24 666
时钟节拍类似于人体心脏的跳动，人体依赖心脏的跳动将血液输入身体各个部位，支撑生命活动。时钟节拍的是操作系统的时基，操作系统依赖于时钟节拍推动 CPU 去执行指令。1 时钟节拍原理时钟节拍是系统以固定的频率产生中断(时基中断)，并在中断处理与时间相关的事件，推动所有任务向前运行。时钟节拍需要依赖于硬件定时器，STM32 通常使用 systick 时钟作为 MCU 的内核定时器。2 系统时钟初始化初始...
ucosIII 时钟节拍和时间管理
本地服务器
10-25 6812
时钟节拍 时间管理器 软件定时器
ucosIII自学笔记-时间片＿５
u010743406的博客
05-29 2311
本节课程主要进行时间片内容的学习。在一个同一优先级列表下挂载两个任务，每个任务工作一个时间片，时间片到了，任务从 切就绪列表头部切换到尾部，换到另一个任务。注意：每个任务软件延时的时间一定要小于时间片。时间片相关成员介绍TimeQuanta需要多少个时间片TimeQuantaCtr还剩多少个时间片时间片的调度函数在systick中断服务程序OSTimeTick()中调用。代码介绍：main：1、C...
uCOS时钟节拍和滴答定时器的关系
热门推荐
猪哥的专栏
04-26 1万+
在使用uCOS时，有一个非常重要，非常关键的概念就是操作系统的时钟节拍，uCOS的时钟节拍来源于滴答定时器，滴答定时器按照设定的时间不停的计时和产生中断，在uCOS-III中滴答定时器的中断服务函数如下： void OS_CPU_SysTickHandler (void) { CPU_SR_ALLOC(); CPU_CRITICAL_ENTER(); OSIntNes
搞懂时钟管理，看这个就好啦~
OneOS是中国移动针对物联网领域推出的轻量级操作系统
02-22 3197
本文主要介绍了操作系统中时钟管理相关知识，从时钟节拍、定时器管理两个部分展开讲解，给出相关函数及其功能的介绍，为初学者提供帮助。
μC/OS III - 常用功能及其API源代码解析
Talk is expensive, I don't care the code.
06-13 955
本文主要介绍μC/OS III 中常用的功能和API，包括内核中常见的内部接口、事件标志组OS_FLAG_GRP、计数信号量OS_SEM、互斥信号量OS_MUTEX、消息OS_MSG、消息队列OS_Q、软件定时器OS_TMR以及任务相关的API等。 一. 内核中常见的内部接口 1. OS_TaskBlock OS_TaskBlock的实现如下： [os_core.c OS_Task...
【18】从0到1教你写uC/OS-III————>时基列表
Dream Catcher
04-15 391
简述： 所有的实时系统都需要一个能提供周期性时间的时间源，叫做时基周期或系统周期； 当时基任务执行时，它会遍历队列中所有等待期满的任务、等待事件超时的任务； 时基任务会就绪时基列表中的那些期满、超时的任务； 时基列表中包含了一个表OSCfg_TickWheel[]和一个计数器OSTickCtr； 这个表由OS_CFG_TICK_WHELL_SIZE记录，记录数取决于处理器的RAM...
UCOSiii--源码阅读
风间琉璃的博客
08-22 1183
我在阅读ucos源码过程遇到的一写小问题 1.OSTaskDel()任务删除函数 在任务函数中，调用次函数传入空指针，将会删除本任务(一直以为要传入任务控制块才行，原来还可以传入空指针） 2.钩子函数 以空闲任务的钩子函数来说， 在OSIdleTaskHook() （在os_cpu_c.c）中调用 最终调用的是函数App_OS_IdleTaskHook(),也就是说如果我们想要在空闲任务的钩子函数中做其他处理就需要将代码写在App_OS_IdleTaskHook() 如下：空闲任务钩子函数相应的处理
uC/OS-III中文翻译版
最新发布
09-20
"uC/OS-III中文翻译版 - 屈环宇译" uC/OS-III是一个专为嵌入式系统设计的实时操作系统内核，由Micro C OS Three（微型的C语言编写的操作系统第三版）发展而来。作为一个第3代的实时内核，它具有高度可扩展和固化的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值