UCOSIII 内核源码解析——os_core.c

最新推荐文章于 2024-06-18 20:01:38 发布
最新推荐文章于 2024-06-18 20:01:38 发布
阅读量673 收藏 1
点赞数
文章标签： c语言 单片机 嵌入式硬件 stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cocoklng/article/details/128350592
版权

UCOSIII 内核源码解析——os_core.c

os_core.c是OS的核心函数，里面有 OSInit(),OSSched()，任务级别调度函数

栈的设置：栈是单片机RAM里面的一段连续的内存空间，栈的大小由启动文件里面的代码配置

多任务系统中，每个任务都是独立的，互不干扰的，所以要为每个任务都分配独立的栈空间

多任务系统在一个统一的一个栈空间里分配好一个个独立空间

堆也是一样

注意：在uC/OS-III中，空闲任务的栈最小应该大于128

  1. **OSInit()**调用初始化钩子函数，初始化系统全局变量，初始化优先级，就绪队列，任务管理器等相关变量

    void  OSInit (OS_ERR  *p_err)//调用初始化钩子函数  （设置中断使用的堆栈地址）初始化系统全局变量 初始化Prio、ReadList
{
    CPU_STK      *p_stk;
    CPU_STK_SIZE  size;
 
 
 
#ifdef OS_SAFETY_CRITICAL
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif
 
    OSInitHook();                                           
    /* Call port specific initialization code   调用初始化钩子函数代码               */
 
    OSIntNestingCtr                 = (OS_NESTING_CTR)0;    
    /* Clear the interrupt nesting counter 清除中断嵌套计数器                   */
 
    OSRunning                       =  OS_STATE_OS_STOPPED; 
    /* Indicate that multitasking not started   多任务处理关闭              */
 
    OSSchedLockNestingCtr           = (OS_NESTING_CTR)0;    
    /* Clear the scheduling lock counter       清除计划锁定计数器              */
 
    OSTCBCurPtr                     = (OS_TCB *)0;          
    /* Initialize OS_TCB pointers to a known state  将OS_TCB指针初始化为已知状态          */
    OSTCBHighRdyPtr                 = (OS_TCB *)0;
 
    OSPrioCur                       = (OS_PRIO)0;           
    /* Initialize priority variables to a known state 将优先级变量初始化为已知状态        */
    OSPrioHighRdy                   = (OS_PRIO)0;
    OSPrioSaved                     = (OS_PRIO)0;
 
#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u
    OSSchedLockTimeBegin            = (CPU_TS)0;
    OSSchedLockTimeMax              = (CPU_TS)0;
    OSSchedLockTimeMaxCur           = (CPU_TS)0;
#endif
 
#ifdef OS_SAFETY_CRITICAL_IEC61508
    OSSafetyCriticalStartFlag       =  DEF_FALSE;
#endif
 
#if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
    OSSchedRoundRobinEn             = DEF_FALSE;
    OSSchedRoundRobinDfltTimeQuanta = OSCfg_TickRate_Hz / 10u;
#endif
 
    if (OSCfg_ISRStkSize > (CPU_STK_SIZE)0) {
        p_stk = OSCfg_ISRStkBasePtr;                        
        /* Clear exception stack for stack checking.清除异常堆栈以进行堆栈检查。              */
        if (p_stk != (CPU_STK *)0) {
            size  = OSCfg_ISRStkSize;
            while (size > (CPU_STK_SIZE)0) {					
                /*　这里是对堆栈初始化，清零　同时　堆栈指针p_stk会指向堆栈数组的尾部*/
                size--;
               *p_stk = (CPU_STK)0;
                p_stk++;
            }
        }
    }
 
#if OS_CFG_APP_HOOKS_EN > 0u
    OS_AppTaskCreateHookPtr = (OS_APP_HOOK_TCB )0;          
    /* Clear application hook pointers                        */
    OS_AppTaskDelHookPtr    = (OS_APP_HOOK_TCB )0;
    OS_AppTaskReturnHookPtr = (OS_APP_HOOK_TCB )0;
 
    OS_AppIdleTaskHookPtr   = (OS_APP_HOOK_VOID)0;
    OS_AppStatTaskHookPtr   = (OS_APP_HOOK_VOID)0;
    OS_AppTaskSwHookPtr     = (OS_APP_HOOK_VOID)0;
    OS_AppTimeTickHookPtr   = (OS_APP_HOOK_VOID)0;
#endif
 
#if OS_CFG_TASK_REG_TBL_SIZE > 0u
    OSTaskRegNextAvailID    = (OS_REG_ID)0;
#endif
 
    OS_PrioInit();                                          
    /* Initialize the priority bitmap table  初始化优先级位图表                 */
 
    OS_RdyListInit();                                       
    /* Initialize the Ready List     初始化就绪列表                         */
 
    
#if OS_CFG_FLAG_EN > 0u                                     
    /* Initialize the Event Flag module       初始化事件标志模块                */
    OS_FlagInit(p_err);
    if (*p_err != OS_ERR_NONE) {
        return;
    }
#endif
 
 
#if OS_CFG_MEM_EN > 0u                                      
    /* Initialize the Memory Manager module     初始化内存管理器模块              */
    OS_MemInit(p_err);
    if (*p_err != OS_ERR_NONE) {
        return;
    }
#endif
 
 
#if (OS_MSG_EN) > 0u                                        
    /* Initialize the free list of OS_MSGs                    */
    OS_MsgPoolInit(p_err);
    if (*p_err != OS_ERR_NONE) {
        return;
    }
#endif
 
 
#if OS_CFG_MUTEX_EN > 0u                                    
    /* Initialize the Mutex Manager module    初始化互斥管理器模块                */
    OS_MutexInit(p_err);
    if (*p_err != OS_ERR_NONE) {
        return;
    }
#endif
 
 
#if OS_CFG_Q_EN > 0u
    OS_QInit(p_err);                                        
    /* Initialize the Message Queue Manager module  初始化消息队列管理器模块          */
    if (*p_err != OS_ERR_NONE) {
        return;
    }
#endif
 
 
#if OS_CFG_SEM_EN > 0u                                      
    /* Initialize the Semaphore Manager module   初始化信号量管理器模块             */
    OS_SemInit(p_err);
    if (*p_err != OS_ERR_NONE) {
        return;
    }
#endif
 
 
#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)
    OS_TLS_Init(p_err);                                     
    /* Initialize Task Local Storage, before creating tasks 在创建任务之前初始化任务本地存储  */
    if (*p_err != OS_ERR_NONE) {
        return;
    }
#endif
 
 
    OS_TaskInit(p_err);                                     
    /* Initialize the task manager  初始化任务管理器                          */
    if (*p_err != OS_ERR_NONE) {
        return;
    }
 
 
#if OS_CFG_ISR_POST_DEFERRED_EN > 0u
    OS_IntQTaskInit(p_err);                                 
    /* Initialize the Interrupt Queue Handler Task 初始化中断队列处理程序任务           */
    if (*p_err != OS_ERR_NONE) {
        return;
    }
#endif
 
    
    OS_IdleTaskInit(p_err);                                 
    /* Initialize the Idle Task    初始化空闲任务                           */
    if (*p_err != OS_ERR_NONE) {
        return;
    }
 
 
    OS_TickTaskInit(p_err);                                 
    /* Initialize the Tick Task    初始化滴答定时器任务                          */
    if (*p_err != OS_ERR_NONE) {
        return;
    }
 
 
#if OS_CFG_STAT_TASK_EN > 0u                                
    /* Initialize the Statistic Task   初始化统计任务                      */
    OS_StatTaskInit(p_err);
    if (*p_err != OS_ERR_NONE) {
        return;
    }
#endif
 
 
#if OS_CFG_TMR_EN > 0u                                      
    /* Initialize the Timer Manager module 初始化计时器管理器模块                   */
    OS_TmrInit(p_err);
    if (*p_err != OS_ERR_NONE) {
        return;
    }
#endif
 
 
#if OS_CFG_DBG_EN > 0u
    OS_Dbg_Init();
#endif
 
 
    OSCfg_Init();
}

  2. OSIntExit()中断级调度器函数，在OS_CPU_SysTickHandler()中用到了，当中断处理完成之后，并且没有中断嵌套，查看是否有新的高优先级任务，如果有启动任务调度

    代码意思：如果内核没有工作则退出，如果中断嵌套为零则退出，反则自减一，减后如果中断嵌套计数器依旧大于零，则说明还有中断，调用CPU_INT_EN()进入中断，不需要任务切换，任务调度器依旧被锁，则继续进入中断，判断完后获得最高优先级的就绪列表中的任务，增加任务切换计数器的值并跟踪任务切换总数，最后执行中断级任务切换

    /*
如果内核没有工作则退出，如果中断嵌套为零则退出，反则自减一，减后如果中断嵌套计数器依旧大
于零，则说明还有中断，调用CPU_INT_EN（）进入中断，不需要任务切换。任务调度器依旧被锁，则
继续进入中断，判断完后获得最高优先级的就绪列表中的任务，增加任务切换计数器的值并跟踪任务
切换总数，最后执行中断级任务切换。
*/
void  OSIntExit (void)
{
    CPU_SR_ALLOC();
 
    if (OSRunning != OS_STATE_OS_RUNNING) {           /* Has the OS started? */
        return;                                             /* No */
    }
 
    CPU_INT_DIS();
    if (OSIntNestingCtr == (OS_NESTING_CTR)0) {             
        /* Prevent OSIntNestingCtr    from wrapping   */
        CPU_INT_EN();
        return;
    }
    OSIntNestingCtr--;
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              
        /* ISRs still nested?                     */
        CPU_INT_EN();                                       /* Yes         */
        return;
    }
 
    if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {        
        /* Scheduler still locked?  调度程序依旧被锁定                            */
        CPU_INT_EN();                                       /* Yes */
        return;
    }
 
    OSPrioHighRdy   = OS_PrioGetHighest();                  
    /* Find highest priority   寻找最高优先级                               */
    OSTCBHighRdyPtr = OSRdyList[OSPrioHighRdy].HeadPtr;     
    /* Get highest priority task ready-to-run 获得最高优先级的任务准备执行                */
    if (OSTCBHighRdyPtr == OSTCBCurPtr) {                   
        /* Current task still the highest priority?   查看当前任务是否为最高优先级            */
        CPU_INT_EN();                                       
        /* Yes                                                    */
        return;
    }
 
#if OS_CFG_TASK_PROFILE_EN > 0u
    OSTCBHighRdyPtr->CtxSwCtr++;                            
    /* Inc. # of context switches for this new task  增加新任务的上下文切换次数         */
#endif
    OSTaskCtxSwCtr++;                                       
    /* Keep track of the total number of ctx switches  跟踪 ctx 开关的总数       */
 
#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)
    OS_TLS_TaskSw();
#endif
 
    OSIntCtxSw();                                           
    /* Perform interrupt level ctx switch  执行中断级ctx切换                   */
    CPU_INT_EN();
}

    在中断级调度器中真正完成任务切换的就是中断级任务切换函数OSIntCtxSw(),由于在进入中断前线程就已经保存过了，所以它不像OSCtxSW(任务级调度器)需要先保存现场，只需要调用OSIntEnter()函数其主要功能就是为OSIntNestingCtr自加一，这个变量的意思是中断嵌套计数器，用来纪录中断嵌套的深度

  3. OSSched()：任务级调度，与中断调度器有所不同，这个函数是在任务中调用，目的是切换到更高优先级的任务。真正起到切换的函数OS_TASK_SW()，OS_TASK_SW()就是函数OSCtxSW()，**OSCtxSW()**是os_cpu_a.asm中用汇编写的一段代码，其主要作用就是将当前任务的CPU寄存器的值保存在任务堆栈中，就是保存现场,之后将新任务的堆栈指针加载到CPU的堆栈指针寄存器中，就实现了任务切换，最后还要从新任务的堆栈中恢复CPU寄存器的值

    void  OSSched (void)//在任务中调用，切换到更高优先级的任务
{
    CPU_SR_ALLOC();
 
 
 
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              
        /* ISRs still nested?                                     */
        return;                                             
        /* Yes ... only schedule when no nested ISRs              */
    }
 
    if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {        
        /* Scheduler locked?                                      */
        return;                                             
        /* Yes                                                    */
    }
 
    CPU_INT_DIS();
    OSPrioHighRdy   = OS_PrioGetHighest();                  
    /* Find the highest priority ready  找到最高优先级的就绪任务      */
    OSTCBHighRdyPtr = OSRdyList[OSPrioHighRdy].HeadPtr;
    if (OSTCBHighRdyPtr == OSTCBCurPtr) {                   
    /* Current task is still highest priority task?  当前任务是否还是最高优先级 */
        CPU_INT_EN();                                       
        /* Yes ... no need to context switch                      */
        return;
    }
 
#if OS_CFG_TASK_PROFILE_EN > 0u
    OSTCBHighRdyPtr->CtxSwCtr++;                            
    /* Inc. # of context switches to this task  上下文切换到此任务   */
#endif
    OSTaskCtxSwCtr++;                                       
    /* Increment context switch counter   递增上下文切换计数器        */
 
#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)
    OS_TLS_TaskSw();
#endif
 
    OS_TASK_SW();                                           
    /* Perform a task level context switch                    */
    CPU_INT_EN();
}

    这是任务级调度器，结合前面的中端机调度器我们可以知道有两种切换任务的函数为OSCtxSW(),OSIntCtxSW()，他们才是真正进行任务切换的，从以下代码看出他们两个主要做的事情就是触发PendSV异常，也就是一段汇编代码

    /*
这里看起来一样是因为Cortex-m3系列进入异常时自动压栈了R0-R3、R12、LR、PSR、PC寄存器，
并在返回时自动弹出，不需要用汇编来写了。
*/
OSCtxSw   ;保存现场，并产生PendSV切换任务
    LDR     R0, =NVIC_INT_CTRL     
    ; Trigger the PendSV exception (causes context switch)
    LDR     R1, =NVIC_PENDSVSET
    STR     R1, [R0]
    BX      LR
 
 
OSIntCtxSw 因为是中断级调度，所以之前已经保护过现场了，直接产生PendSV切换任务
    LDR     R0, =NVIC_INT_CTRL      
    ; Trigger the PendSV exception (causes context switch)
    LDR     R1, =NVIC_PENDSVSET
    STR     R1, [R0]
    BX      LR

    ;PendSV_Handler			
PendSV_Handler
    CPSID   I                                                   ; 关所有中断
    MRS     R0, PSP                                             ; PSP是当前进程堆栈的指针，将PSP赋值给R0
    CBZ     R0, PendSV_Handler_Nosave                     ; 如果R0为0时跳转到PendSV_Handler_Nosave
 
    ;已经存在任务  保存正在运行的任务 
    SUBS    R0, R0, #0x20                                       ; 偏移0x20的位置用来保存R4至R11
    STM     R0, {R4-R11} ;将剩下的R4至R11寄存器保存在此进程的堆栈中
 
    LDR     R1, =p_OSTCBCur                      
    ; OSTCBCur->OSTCBStkPtr = SP; 即OSTCBCur->OSTCBStkPtr这个保存当前的栈尾，以便下次弹出
    LDR     R1, [R1]
    STR     R0, [R1]                                            ; R0 is SP of process being switched out
   ;此时,整个上下文的过程已经被保存
 ;—————————切换上下文—————————————
 ; 实现 OSTCBCurPtr = OSTCBHighRdyPtr
 ; 把下一个要运行的任务的堆栈OSPrioHighRdy加载到 CPU 寄存器中   
PendSV_Handler_Nosave
    PUSH    {R14}                                               ; Save LR exc_return value
    LDR     R0, =OSTaskSwHook                                   ; OSTaskSwHook();  这里用于用户扩展
    BLX     R0
    POP     {R14}
 
    ;将最高优先级任务赋给当前优先级
    LDR     R0, =OSPrioCur             ; OSPrioCur = OSPrioHighRdy;
    LDR     R1, =OSPrioHighRdy 		   ;将当前优先级变量指向最高优先级
    LDRB    R2, [R1]
    STRB    R2, [R0]
 
    LDR     R0, =p_OSTCBCur            ; OSTCBCur  = OSTCBHighRdy;
    LDR     R1, =p_OSTCBHighRdy ;TCB表也一样
    LDR     R2, [R1]
    STR     R2, [R0]
    ;到这里，[R2]保存的是新的进程的堆栈指针SP
    LDR     R0, [R2]         ;  SP = OSTCBHighRdy->OSTCBStkPtr;
    LDM     R0, {R4-R11}     ;  弹出其它寄存器，和前面的是一个逆过程
    ADDS    R0, R0, #0x20    ;和前面的逆过程对比可知
    MSR     PSP, R0          ; 将R0中的SP赋值给PSP寄存器
    ORR     LR, LR, #0x04    ; 确保异常返回时使用进程堆栈
    CPSIE   I ;开中断
    BX      LR               ; 异常返回将恢复那些自动出栈的剩余寄存器
;跳到当前任务 开始运行
;这里是系统默认中断做的事：主要工作有判断是否第一次运行、将最高级任务赋给当前任务，然后将放到cpu寄存器运行，最高优先级任务开始运行。

    ​ PenSV异常服务要完成两个工作保存上文和切换下文，PenSV还可以有OSStarHighRdy触发。uCOS操作系统里，各种异常/中断的优先级关系：SYSTICK异常 > 中断 > PendSv异常 ，所以PenSV会自动的延迟上下文切换的请求，直到他的中断都处理完了后才触发，这保证了实时性内核的实时性也保证了操作系统的正常轮转。

    ​ PenSV的配置是在OSStartHighRdy()中完成的，这个函数用于启动任务切换，即配置PendSV,触发PendSV，在PendSV异常服务函数中完成任务切换

  4. OSStartHighRdy()

    ;常量说明：
NVIC_INT_CTRL EQU 0xE000ED04  ; 中断控制及状态寄存器 SCB_ICSR。
NVIC_SYSPRI14 EQU 0xE000ED22  ; 系统优先级寄存器 SCB_SHPR3：
; bit16~23
NVIC_PENDSV_PRI EQU 0xFF 	  ; PendSV 优先级的值(最低)。
NVIC_PENDSVSET EQU 0x10000000 ; 触发 PendSV 异常的值 Bit28： PENDSVSET
 
/* 
开始第一次上下文切换
配置 PendSV 异常的优先级为最低
在开始第一次上下文切换之前，设置 psp=0
触发 PendSV 异常，开始上下文切换
*/
;*******************************************************************
OSStartHighRdy
 LDR R0, = NVIC_SYSPRI14 ; 设置 PendSV 异常优先级为最低(1)
 LDR R1, = NVIC_PENDSV_PRI
 STRB R1, [R0]
 MOVS R0, #0 ; 设置 psp 的值为 0，开始第一次上下文切换 (2)
 MSR PSP, R0
 LDR R0, =NVIC_INT_CTRL ; 触发 PendSV 异常(3)
 LDR R1, =NVIC_PENDSVSET
 STR R1, [R0]
 CPSIE I ; 启用总中断， NMI 和 HardFault 除外(4)
 OSStartHang
 BOSStartHang ; 程序应永远不会运行到这里

    1. 配置PenSV的优先级为0xFF,最低。在uC/OS-III中，上下文切换是在PendSV异常服务程序中执行的，配置PendSV的优先级为最低，从而消除了在中断服务程序中执行上下文切换的可能

    2. 设置PSP的值为0，开始第一个任务切换。在任务中，使用栈指针都是PSP，后面如果判断出PSP为0，则表示第一次任务切换

    3. 触发PenSV异常，如果中断启用且有编写PenSV异常函数的话，则内核会响应PenSV异常，去执行PendSV异常服务函数

    4. 开中断，因为有些用户在main()函数开始会关掉中断，等全部初始化完成后，在启动OS的时候才开中断

      CPSID I ;	PRIMASK=1; 		//关中断
CPSIE I ;	PRIMASK=0; 		//开中断
CPSID F ;	FAULTMASK=1; 	// 关异常
CPSIE F ;	FAULTMASK=0; 	//开异常

    OSStartHighRdy()函数有OSStart()调用，OSStart()函数用来启用多任务，如果多任务开始正常进入OSStartHighRdy()函数触发PendSV异常就会进行任务切换

  5. **OSStart(OS_ERR *p_err) **: 此函数由于启动多任务，让ucosiii接管任务，在调用OSStart()之前，必须调用OSInit()并且必须至少创建一项申请任务

    系统使用全局变量OSRunning来表示当前的系统运行状态，刚开始系统初始化的时候停止状态，进入if首先寻找最高优先级的就绪任务，再OSStartHighRdy()用于启动任务切换，操作系统开始执行最高优先级的任务

    void  OSStart (OS_ERR  *p_err)
{
#ifdef OS_SAFETY_CRITICAL
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif
 
    if (OSRunning == OS_STATE_OS_STOPPED) {
        OSPrioHighRdy   = OS_PrioGetHighest();              
        /* Find the highest priority  寻找最高优先级的任务*/
        OSPrioCur       = OSPrioHighRdy;           
        /*将最高优先级付给当前优先级*/
        OSTCBHighRdyPtr = OSRdyList[OSPrioHighRdy].HeadPtr;
        /* 从TCB链表中取出最高优先级 赋给 最高级TCB   */
        OSTCBCurPtr     = OSTCBHighRdyPtr;//最高优先级赋给 当前优先级
        OSRunning       = OS_STATE_OS_RUNNING; 
        //将OSRunning标记为1表示已经开始运行内核
        OSStartHighRdy();  //一长段汇编代码
        /* Execute target specific code to start task  执行目标特定代码以启动任务*/
 		*p_err           = OS_ERR_FATAL_RETURN;              
        /* OSStart() is not supposed to returnOSStart() 不应该返回*/
    } else {
       *p_err           = OS_ERR_OS_RUNNING;                
        /* OS is already running  操作系统已经在运行*/
    }
}
    哪些会发送任务切换(任务调度)
    1. 使用延时函数OSTimeDly()或者OSTimeDlyHMSM();
    2. OSStart()启动任务调度器
    3. 删除任务
    4. 任务通过调用OSTaskSuspend()将自身挂起
    5. 任务解挂某个挂起任务
    6. 用户调用OSSched();
    7. 释放信号量或者发送消息，也可通过配置相应的参数不发生任务调度
    8. 任务等待的事情还没有发生(等待信号量，消息队列等)
    9. 任务取消等待
    10. 删除一个内核对象
    11. 任务改变自身的优先级或者其他任务的优先级
    12. 退出所有的嵌套中断
    13. 通过OSSchedUnlock()给调度器解锁
    14. 任务调用OSSchedRoundRobinYield()放弃其执行时间片

  6. *OSSchedLock(OS_ERR p_err);

    允许这个应用程序防止上下文切换，直到已经准备好允许上下文切换

    void  OSSchedLock (OS_ERR  *p_err)
 //当任务调度发生时，阻止任务调度，直到调用了 OSSchedUnlock()。主要是 OSSchedLockNestingCtr++;
{
    CPU_SR_ALLOC();
 
    CPU_CRITICAL_ENTER();
    OSSchedLockNestingCtr++;                                
    /* Increment lock nesting level  递增嵌套级别                         */
#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u
    OS_SchedLockTimeMeasStart();
#endif
    CPU_CRITICAL_EXIT();
   *p_err = OS_ERR_NONE;
}
 
 
#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u   
void  OS_SchedLockTimeMeasStart (void)
{
    if (OSSchedLockNestingCtr == 1u) {
        OSSchedLockTimeBegin = CPU_TS_TmrRd();
    }
}

    进入临界区，递增嵌套级别(主要目的)，判断是否设置了测量锁定时间的代码，有的话进入OS_SchedLockTimeMeasStart()，这个函数用于测量计划程序锁定的峰值时间，CPU_TS_TmrRd()是一个16位的计时器，不希望锁定调度程序的时间超过65536，这不是个好事，开头的CPU_SR_ALLOC()是定义的一个局部变量，用来存CPU关闭前的中断状态。

  7. *OSSchedUnlock(OS_ERR p_err)

    void  OSSchedUnlock (OS_ERR  *p_err)
{
    CPU_CRITICAL_ENTER();
    OSSchedLockNestingCtr--;                                
    /* Decrement lock nesting level  递减锁嵌套级别                         */
    if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {
        CPU_CRITICAL_EXIT();                                
        /* Scheduler is still locked   调度器依旧被锁                           */
       *p_err = OS_ERR_SCHED_LOCKED;
        return;
    }
#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u
    OS_SchedLockTimeMeasStop();
#endif
 
    CPU_CRITICAL_EXIT();                                    
    /* Scheduler should be re-enabled                         */
    OSSched();                                              
    /* Run the scheduler                                      */
   *p_err = OS_ERR_NONE;
}
 
 
void  OS_SchedLockTimeMeasStop (void)
{
    CPU_TS_TMR  delta;
 
 
    if (OSSchedLockNestingCtr == (OS_NESTING_CTR)0) {       
        /* Make sure we fully un-nested scheduler lock            */
        delta = CPU_TS_TmrRd()                              
            /* Compute the delta time between begin and end           */
              - OSSchedLockTimeBegin;
        if (OSSchedLockTimeMax    < delta) {                
            /* Detect peak value                                      */
            OSSchedLockTimeMax    = delta;
        }
        if (OSSchedLockTimeMaxCur < delta) {                
            /* Detect peak value (for resettable value)               */
            OSSchedLockTimeMaxCur = delta;
        }
    }
}

    进入临界区，递减锁嵌套级别，判断如果还有锁嵌套，异常退出，反之判断是否设置测量锁定时间的代码，有的话进入OS_SchedLockTimeMeasStop函数计算出调度器被锁时间，再判断是否有效，退出临界区，在调度器被锁期间可能有就绪任务所以通过调用OSSched()函数打开调度

  8. *OSSchedRoundRobinCfg(CPU_BOOLEAN en,OS_TICK dflt_time_quanta,OS_ERR p_err)

    调用该函数改变轮询调度参数，如是否打开时间片轮询，时间片大小的设置。代码的流程是如果开启了时间片轮询，进入临界区判断参数en是否开启了时间片轮询，1开启，0关闭。判断参数dflt_time_quanta是否大于0，大于0则时间大小为dflt__time_quanta，小于0则选取系统默认的时间片大小(OS_TICK)(OSCfg_TickRate_HZ/(OS_RATE_HZ)10)。退出临界区，并正确返回

    #if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u    //当启动了相同任务优先级时间片轮询（OS_CFG_SCHED_ROUND_ROBIN_EN==1 ）
void  OSSchedRoundRobinCfg (CPU_BOOLEAN   en,
                            OS_TICK       dflt_time_quanta,
                            OS_ERR       *p_err)
{
    // 决定是否开启时间片轮询，设置任务的默认时间片时间（多少个SysTick），默认为 OSCfg_TickRate_Hz / 10
    CPU_SR_ALLOC();
 
 
 
#ifdef OS_SAFETY_CRITICAL
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif
 
    CPU_CRITICAL_ENTER();
    if (en != DEF_ENABLED) {   //是否开启时间片轮循
        OSSchedRoundRobinEn = DEF_DISABLED;
    } else {
        OSSchedRoundRobinEn = DEF_ENABLED;
    }
 
    if (dflt_time_quanta > (OS_TICK)0) {			//设置任务的默认时间片，如果未设置就选取默认值
        OSSchedRoundRobinDfltTimeQuanta = dflt_time_quanta;
    } else {
        OSSchedRoundRobinDfltTimeQuanta = (OS_TICK)(OSCfg_TickRate_Hz / (OS_RATE_HZ)10);
    }
    CPU_CRITICAL_EXIT();
   *p_err = OS_ERR_NONE;
}
#endif

  9. *OSSchedRoundRobinYield(OS_ERR p_err)

    该函数在时间片到期前执行完毕，被调用放弃CPU。进入临界区前需要判断，同优先级的任务数是否大于1，轮询是否启用，调度器是否被锁定，判断是否在中断中。判断完后，将之前任务控制块移至就绪列表尾部，将执行的权利给就绪列表的表头指向的任务，确定要使用的时间片大小，退出临界区

    #if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
void  OSSchedRoundRobinYield (OS_ERR  *p_err)
{// 当一个任务在给定的时间片之前完成了任务，可以调用此函数放弃CPU让给相同优先级的等待运行的任务。即放弃未使用的时间片给同等级的任务    
 
    OS_RDY_LIST  *p_rdy_list;
    OS_TCB       *p_tcb;
    CPU_SR_ALLOC();
 
 
 
#ifdef OS_SAFETY_CRITICAL
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif
 
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              
        /* Can't call this function from an ISR                   */
       *p_err = OS_ERR_YIELD_ISR;
        return;
    }
#endif
 
    if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {        
        /* Can't yield if the scheduler is locked                 */
       *p_err = OS_ERR_SCHED_LOCKED;
        return;
    }
 
    if (OSSchedRoundRobinEn != DEF_TRUE) {                  
        /* Make sure round-robin has been enabled                 */
       *p_err = OS_ERR_ROUND_ROBIN_DISABLED;
        return;
    }
 
    CPU_CRITICAL_ENTER();
    p_rdy_list = &OSRdyList[OSPrioCur];                     
    /* Can't yield if it's the only task at that priority 如果这是该优先级队列的唯一任务，则无法让步    */
    if (p_rdy_list->NbrEntries < (OS_OBJ_QTY)2) {
        CPU_CRITICAL_EXIT();
       *p_err = OS_ERR_ROUND_ROBIN_1;
        return;
    }
 
    OS_RdyListMoveHeadToTail(p_rdy_list);                   
    /* Move current OS_TCB to the end of the list 将当前 OS_TCB 移动到列表末尾，从而实现任务切换            */
    p_tcb = p_rdy_list->HeadPtr;                            
    /* Point to new OS_TCB at head of the list    指向列表头部的新 OS_TCB         */
    if (p_tcb->TimeQuanta == (OS_TICK)0) {                  
   /* See if we need to use the default time slice  看看我们是否需要使用默认的时间片*/
        p_tcb->TimeQuantaCtr = OSSchedRoundRobinDfltTimeQuanta;//使用默认时间片
    } else {
        p_tcb->TimeQuantaCtr = p_tcb->TimeQuanta;           
        /* Load time slice counter with new time 用新时间加载时间片计数器    */
    }
 
    CPU_CRITICAL_EXIT();
 
    OSSched();                                              
    /* Run new task  执行任务调度          */
   *p_err = OS_ERR_NONE;//正确执行
}
#endif

    再看看OS_RdyListMoveHeadToTail(p_rdy_list)函数时如何实现的。调用此函数可将列表的当前头部移动到列表的尾部。0和1是没有任务和只有一个任务，不需要移动，如果是两个任务则将任务控制块的指针进行交换即可，这里的调换实际就是双向链表的删除插入操作。

    void  OS_RdyListMoveHeadToTail (OS_RDY_LIST  *p_rdy_list)
{
    OS_TCB  *p_tcb1;
    OS_TCB  *p_tcb2;
    OS_TCB  *p_tcb3;
 
 
 
    switch (p_rdy_list->NbrEntries) {
        case 0:
        case 1:
             break;			//0和1没有任务和只有一个任务，不需要移动
            
        case 2:                                             
            /* SWAP the TCBs                                          */
             p_tcb1              = p_rdy_list->HeadPtr;     
            /* Point to current head                                  */
             p_tcb2              = p_rdy_list->TailPtr;     
            /* Point to current tail                                  */
             p_tcb1->PrevPtr     = p_tcb2;
             p_tcb1->NextPtr     = (OS_TCB *)0;
             p_tcb2->PrevPtr     = (OS_TCB *)0;
             p_tcb2->NextPtr     = p_tcb1;
             p_rdy_list->HeadPtr = p_tcb2;
             p_rdy_list->TailPtr = p_tcb1;
             break;
 			//前后调换
        default:                                            
            /*仅当列表中有两个以上的OS_TCB时才移动*/
             p_tcb1              = p_rdy_list->HeadPtr;     /*指向当前头部*/
             p_tcb2              = p_rdy_list->TailPtr;     /*指向当前尾部*/
             p_tcb3              = p_tcb1->NextPtr;         /*指向新的列表头*/
             p_tcb3->PrevPtr     = (OS_TCB *)0;             /*调整新列表头的后链接*/
             p_tcb1->NextPtr     = (OS_TCB *)0;             
            /*调整新列表尾部的前向链接*/
             p_tcb1->PrevPtr     = p_tcb2;                  
            /*调整新列表尾部的后链接*/
             p_tcb2->NextPtr     = p_tcb1;                  
            /*调整旧列表尾部的前向链接*/
             p_rdy_list->HeadPtr = p_tcb3;                  
            /*调整新列表的头和尾指针*/
             p_rdy_list->TailPtr = p_tcb1;
             break;
    }
}

  10. OS_IdleTask(void *p_arg)

并没有做什么，里面的OSIdleTaskHook()函数值得看，是一个空闲任务的钩子函数，在OSIdleTaskHook()中最终调用的是函数App_OS_IdleTaskHook(),也就是如果我们想要在空闲任务的钩子函数中做其他处理就需要将代码写在App_OS_IdleTaskHook()。

void  OS_IdleTask (void  *p_arg) //空闲任务
{
    CPU_SR_ALLOC();
 
 
 
    p_arg = p_arg;                                          
    /* Prevent compiler warning for not using 'p_arg'防止编译器警告不使用'p_arg'*/
 
    while (DEF_ON) {
        CPU_CRITICAL_ENTER();
        OSIdleTaskCtr++;
#if OS_CFG_STAT_TASK_EN > 0u//大于0则启用统计任务
        OSStatTaskCtr++;
#endif
        CPU_CRITICAL_EXIT();
 
        OSIdleTaskHook();                                   
        /* Call user definable HOOK                               */
    }
}
 
void  OSIdleTaskHook (void)
{
#if OS_CFG_APP_HOOKS_EN > 0u //OS_CFG_APP_HOOKSEN置1，即允许使用空闲任务的钩子函数,
														 
	
    if (OS_AppIdleTaskHookPtr != (OS_APP_HOOK_VOID)0) {
        (*OS_AppIdleTaskHookPtr)();//当使能空闲任务的钩子函数以后每次进入空闲任务就会调用指针OS_AppIdleTaskHookPtr所指向的函数。
    }
#endif
}

  1. OS_IdleTaskInit(OS_ERR *p_err)

    空闲任务的创建即初始化，空闲任务的初始化在OSInit()被调用，意味着在系统还没有启动之前空闲任务就已经创建好，必须创建空闲任务(不需要我们手动创建)，因为CPU不能停下来，他有最低的优先级

    void  OS_IdleTaskInit (OS_ERR  *p_err) //空闲任务初始化--创建空闲任务
{
#ifdef OS_SAFETY_CRITICAL
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif
 
    OSIdleTaskCtr = (OS_IDLE_CTR)0;
    /* ---------------- CREATE THE IDLE TASK ---------------- */
    OSTaskCreate((OS_TCB     *)&OSIdleTaskTCB,
                 (CPU_CHAR   *)((void *)"uC/OS-III Idle Task"),
                 (OS_TASK_PTR)OS_IdleTask,
                 (void       *)0,
                 (OS_PRIO     )(OS_CFG_PRIO_MAX - 1u), //最低优先级
                 (CPU_STK    *)OSCfg_IdleTaskStkBasePtr,
                 (CPU_STK_SIZE)OSCfg_IdleTaskStkLimit,
                 (CPU_STK_SIZE)OSCfg_IdleTaskStkSize,
                 (OS_MSG_QTY  )0u,
                 (OS_TICK     )0u,
                 (void       *)0,
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR | OS_OPT_TASK_NO_TLS),
                 (OS_ERR     *)p_err);
}
cocoklng
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
UCOS-III源代码
07-19
UCOS-III源代码
实时操作系统UCOS学习笔记5----UCOSIII移植
qq_38958704的博客
07-01 1291
在2009年Micrium公司推出了UCOSIII，相对于UCOSII性能有了进一步的提升，支持时间片轮转调度，极短的关中断事件等。本章讲解如何在STM32F103开发板上移植UCOSIII操作系统。 1、UCOSIII简介 UCOSIII是一个可裁剪、可固化、可剥夺的多任务操作系统，没有任务数目的限制，是UCOS的第三代内核，UCOSIII有以下几个重要的特性： 可剥夺多任务管理：UCOSIII和UCOSII一样都属于可剥夺的多任务内核，总是执行当前就绪的最高优先级任务。 同优先级的时间片轮转调度：UC
【UCOSIII源码阅读笔记】第二篇
最新发布
inputA的博客
06-18 376
本文主要分析ucosiii中管理优先级表的os_prio.c文件。
ucosiii内核源码解析---os_core.c
weixin_46199479的博客
03-02 1969
os_core.c是OS的核心函数，掌握其内容对我们的学习很有帮助。
【UCOSii源码解析】内存管理
yy197696的博客
10-19 1501
文章目录(一)内存管理算法所以说UCOS中的内存管理算法与标准C中有啥区别嘞1、函数原型及说明：2、 C语言malloc算法产生内存碎片的原因3 、核心变量(二)内存控制块(三)源码分析内存管理初始化函数创建内存分区申请内存释放内存（四）程序示例：等待从一个内存分区中分配内存块（五）基于查表法实现的动态内存管理 (一)内存管理算法 在ANSI C中可以用malloc()和free()两个函数动态地分配内存和释放内存。但是，在嵌入式实时操作系统中，多次这样做会把原来很大的一块连续内存区域，逐渐地分割成许多非常
ucos3源码分析资源
Thinking_calculus的博客
03-28 182
ucosiii 源码分析 源码资源 stm32f103c8 csdn优质分析文章 UCOS 英文释义 REG 寄存器 CFG （compile-time configuration)编译时配置。CFG.h文件用于管理要使用或者不用的功能，功能裁剪位于该文件中 ISR Interrupt Service Routines(中断服务程序) TCB Task Control Block(任务控制块) BSP Board Support Package Ctr Cou
uCOS-II.rar_os_cpu.c_ucos_μC/OS-II
09-22
本教程将深入探讨uCOS-II的核心组件，特别是移植过程中涉及的关键文件——OS_CPU.H、OS_CPU.c和OS_CPU_A.S，以及如何将uCOS-II成功部署到不同的微控制器平台上。 首先，让我们了解uCOS-II的基本架构。uCOS-II是一个...
OS_TASK.rar_OS_TASK.C_os task
09-22
本篇文章将深入解析ucOS-II中的任务（Task）管理机制，以`OS_TASK.C`为例，结合源代码来探讨相关知识点。 ucOS-II的核心特性之一就是任务调度，任务是操作系统中最基本的执行单元。在`OS_TASK.C`中，我们可以看到...
IOS应用源码——OpenCL_sphere.zip
10-14
《OpenCL在iOS应用中的实践：OpenCL_sphere.zip源码解析》 OpenCL，全称为Open Computing Language，是一种跨平台的并行计算框架，由Khronos Group开发，旨在为各种设备提供统一的编程接口，包括CPU、GPU、FPGA等。...
uCOS-II.rar_OS_CPU_A.ASM_ucos ii 实例
09-23
本文将基于提供的"uCOS-II.rar"压缩包中的"OS_CPU_A.ASM"文件，结合uCOS-II的C语言编程实例，深入解析其核心机制和编程技巧。 首先，我们来看"OS_CPU_A.ASM"文件。在uCOS-II中，"OS_CPU_"系列文件是为特定处理器...
OS_CPU.rar_os_cup.h
09-22
本文将详细探讨标题为"OS_CPU.rar"的压缩包文件中的核心部分——"os_cpu.h"，这是UCOS在ARM9处理器上实现的关键文件，它定义了操作系统与CPU硬件之间的接口。 首先，我们需要了解ARM9是ARM公司设计的一种32位RISC...
uCOS全家桶源码来了！！
Simon223的博客
03-03 3535
micrium_os.rar1、CANopen部分源码截图： 2、文件系统部分源码： 3、文件系统配的各种存储类型驱动： 4、文件系统shell： 5、网络协议栈那是相当全面： 6、USB的Host和Device 7、uCOS全家桶的文档是相当完整且详细，不怕你学不会，就怕你不看。https://doc.micrium.com/display/OSUM50800 ...
UCOSiii源码分析——os_task.c任务管理函数分析
weixin_46199479的博客
03-08 3757
ucos的任务处理相关的函数解析。
【Ucos-III源码分析】——系统初始化
m0_58457065的博客
07-01 542
Ucos-III系统调用OSInit(&err);初始化内核都做了什么
嵌入式系统uC/OS-III的结构和代码剖析(四)
liujingshenggggg的博客
09-25 578
这一节我们来看任务结构和任务管理 任务控制块 我们知道，在工作中，管理很多东西都需要一张记录表，包括机器的管理，我们可能会记录其信息，如工作时间，何时启动，运行了多久，当前工作电压电流，温度等等，通过这些信息我们能实时监控和管理好机器的运转。而任务也需要类似的管理，也需要类似的“表”，那么我把任务控制块理解为这样的一张表，可能不够恰当，但是便于理解。在uC/OS-III中，每个任务控制块都是一个在...
【Ucos-III源码分析】——互斥信号量（互斥锁）
m0_58457065的博客
07-05 1132
mutex互斥信号量（互斥锁）
Ucos源码分析------OS启动
qq_43306777的博客
11-24 926
1.Ucos源码分析------任务控制块与任务调度2.Ucos源码分析------事件控制块与事件控制3.Ucos源码分析------信号量4.Ucos源码分析------邮箱与队列5.Ucos源码分析------事件标志组6.Ucos源码分析------内存管理7.Ucos源码分析------临界区与中断管理8.Ucos源码分析------OS启动9.Ucos总结。
UCOIII 消息队列源码解析
qq_32305375的博客
09-12 597
UCOIII 消息队列源码解析引文消息相关的数据结构UCOSIII消息池OSQPost函数 引文 菜鸟一个，请多指教，不多bb，上菜 消息相关的数据结构 先说说消息队列，消息两字，从字面意思感受就是一个信息，那在UOCSIII中，什么东西才算是信息呢？举个简单的例子如下： 打个比方我定义可一个全局变量 int v_key = 0，规定v_key为0表示某一个按键抬起，为1则表示某一个按键...
uCOSIII实时操作系统 三 移植
ttdffmm的博客
10-08 1441
同样复制 Micrium 官方移植好的工程中的相关文件到 UCOS_BSP 文件下，需要复制的文件路径为Micrium\Software\EvalBoards\Micrium\uC-Eval-STM32F107\BSP将下边两个文件移植到自己的所建的UCOSIII_BSP的目录当中。主要内容是基于评估板（厂商的板子）的应用实现，在我们移植中有部分文件是可以用来使用的，在路径红色方框中我们可以看到官方移植的评估板芯片是STM32F107,但是不影响我们在STM32F103开发板上进行移植。
μCOS-II任务管理源码解析：OS_TASK.C关键函数详解
本文档详细解读了μCOS-II的核心模块之一——OS_TASK.C源码，这在深入理解任务管理和调度机制方面提供了宝贵的教育资源。OS_TASK.C是μCOS-II中的关键文件，主要负责处理任务（tasks）的创建、调度、优先级管理和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值