os_core.c

c代码的操作系统 已经移植使用到产品上的内核

#if OS_TASK_STAT_EN
void OSStatInit (void) reentrant
{
    OSTimeDly(2);                                /* Synchronize with clock tick                        */
    OS_ENTER_CRITICAL();
    OSIdleCtr    = 0L;                           /* Clear idle counter                                 */
    OS_EXIT_CRITICAL();
    OSTimeDly(OS_TICKS_PER_SEC);                 /* Determine MAX. idle counter value for 1 second     */
    OS_ENTER_CRITICAL();
    OSIdleCtrMax = OSIdleCtr;                    /* Store maximum idle counter count in 1 second       */
    OSStatRdy    = TRUE;
    OS_EXIT_CRITICAL();
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                              IDLE TASK
*
* Description: This task is internal to uC/OS-II and executes whenever no other higher priority tasks
*              executes because they are waiting for event(s) to occur.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

void OSTaskIdle (void *ppdata) reentrant
{
    ppdata = ppdata;                               /* Prevent compiler warning for not using 'pdata'     */
    for (;;) {
        OS_ENTER_CRITICAL();
        OSIdleCtr++;
        OS_EXIT_CRITICAL();
    }
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                            STATISTICS TASK
*
* Description: This task is internal to uC/OS-II and is used to compute some statistics about the
*              multitasking environment.  Specifically, OSTaskStat() computes the CPU usage.
*              CPU usage is determined by:
*
*                                          OSIdleCtr
*                 OSCPUUsage = 100 * (1 - ------------)     (units are in %)
*                                         OSIdleCtrMax
*
* Arguments  : pdata     this pointer is not used at this time.
*
* Returns    : none
*
* Notes      : 1) This task runs at a priority level higher than the idle task.  In fact, it runs at the
*                 next higher priority, OS_IDLE_PRIO-1.
*              2) You can disable this task by setting the configuration #define OS_TASK_STAT_EN to 0.
*              3) We delay for 5 seconds in the beginning to allow the system to reach steady state and
*                 have all other tasks created before we do statistics.  You MUST have at least a delay
*                 of 2 seconds to allow for the system to establish the maximum value for the idle 
*                 counter.
*********************************************************************************************************
*/

#if OS_TASK_STAT_EN
void OSTaskStat (void *ppdata) reentrant
{
    INT32U run;
    INT8S  usage;
    
    
    ppdata = ppdata;                               /* Prevent compiler warning for not using 'pdata'     */
    while (OSStatRdy == FALSE) {
        OSTimeDly(2 * OS_TICKS_PER_SEC);             /* Wait until statistic task is ready                 */
    }
    for (;;) {
        OS_ENTER_CRITICAL();
        OSIdleCtrRun = OSIdleCtr;                /* Obtain the of the idle counter for the past second */
        run          = OSIdleCtr;
        OSIdleCtr    = 0L;                       /* Reset the idle counter for the next second         */
        OS_EXIT_CRITICAL();
        if (OSIdleCtrMax > 0L) {
            usage = (INT8S)(100L - 100L * run / OSIdleCtrMax);
            if (usage > 100) {
                OSCPUUsage = 100;
            } else if (usage < 0) {
                OSCPUUsage =   0;
            } else {
                OSCPUUsage = usage;
            }
        } else {
            OSCPUUsage = 0;
        }
        OSTaskStatHook();                        /* Invoke user definable hook                         */
        OSTimeDly(OS_TICKS_PER_SEC);             /* Accumulate OSIdleCtr for the next second           */
    }
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                            INITIALIZE TCB
*
* Description: This function is internal to uC/OS-II and is used to initialize a Task Control Block when
*              a task is created (see OSTaskCreate() and OSTaskCreateExt()).
*
* Arguments  : prio          is the priority of the task being created
*
*              ptos          is a pointer to the task's top-of-stack assuming that the CPU registers
*                            have been placed on the stack.  Note that the top-of-stack corresponds to a 
*                            'high' memory location is OS_STK_GROWTH is set to 1 and a 'low' memory
*                            location if OS_STK_GROWTH is set to 0.  Note that stack growth is CPU
*                            specific.
*
*              pbos          is a pointer to the bottom of stack.  A NULL pointer is passed if called by
*                            'OSTaskCreate()'.
*
*              id            is the task's ID (0..65535)
*
*              stk_size      is the size of the stack (in 'stack units').  If the stack units are INT8Us
*                            then, 'stk_size' contains the number of bytes for the stack.  If the stack
*                            units are INT32Us then, the stack contains '4 * stk_size' bytes.  The stack
*                            units are established by the #define constant OS_STK which is CPU
*                            specific.  'stk_size' is 0 if called by 'OSTaskCreate()'.
*
*              pext          is a pointer to a user supplied memory area that is used to extend the task
*                            control block.  This allows you to store the contents of floating-point
*                            registers, MMU registers or anything else you could find useful during a 
*                            context switch.  You can even assign a name to each task and store this name
*                            in this TCB extension.  A NULL pointer is passed if called by OSTaskCreate().
*
*              opt           options as passed to 'OSTaskCreateExt()' or, 
*                            0 if called from 'OSTaskCreate()'.
*
* Returns    : OS_NO_ERR         if the call was successful
*              OS_NO_MORE_TCB    if there are no more free TCBs to be allocated and thus, the task cannot
*                                be created.
*
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/

                       //prio任务优先级   psp任务堆栈顶 pbos任务堆栈底 id任务的ID  stk_size任务堆栈大小  pext扩展任务选项
                       //opt任务选项
INT8U OSTCBInit (INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT16U stk_size, void *pext, INT16U opt) reentrant
{    //任务控制块初始化 
		//任务优先级别    堆栈顶的位置    堆栈底   任务id号	 堆栈大小扩展选项pext	 选项参数opt	    

    OS_TCB *ptcb; //定义任务控制指针
			
    OS_ENTER_CRITICAL();//关中断
    
    ptcb = OSTCBFreeList;   //获取释放任务链表的首地址
    		
    	   //指向释放任务的首地址==任务首地址
    	
    if (ptcb != (OS_TCB *)0) {
    	//若任务不为空
    	
        OSTCBFreeList        = ptcb->OSTCBNext;          
        			//释放任务指针指向下一个任务控制块
        OS_EXIT_CRITICAL();//开中断
        
        ptcb->OSTCBStkPtr    = ptos; //保存堆栈顶
        
        ptcb->OSTCBPrio      = (INT8U)prio;      //保存任务优先级
        ptcb->OSTCBStat      = OS_STAT_RDY;   //任务控制块的状态为准备就绪
        ptcb->OSTCBDly       = 0;        //任务不延时

#if OS_TASK_CREATE_EXT_EN        //若允许创建扩展任务
        ptcb->OSTCBExtPtr    = pext;       //保存扩展选项
        ptcb->OSTCBStkSize   = stk_size;//保存堆栈大小
        ptcb->OSTCBStkBottom = pbos; //保存堆栈底
        ptcb->OSTCBOpt       = opt; //保存任务选项
        ptcb->OSTCBId        = id;  //保存任务id
#else
//若不允许创建扩展任务功能
        pext                 = pext;  //防止编译错误
        stk_size             = stk_size;//防止编译错误
        pbos                 = pbos;//防止编译错误
        opt                  = opt;//防止编译错误
        id                   = id;//防止编译错误
#endif

#if OS_TASK_DEL_EN        
//若允许任务删除功能
        ptcb->OSTCBDelReq    = OS_NO_ERR;
//保存任务删除请求为没有错误        
#endif

        ptcb->OSTCBY         = prio >> 3;    //任务优先级右移3位 并且保存到任务控制表的X位置
//举例 若prio=12   00001100>>3=00000001      则ptcb->OSTCBY=1
        ptcb->OSTCBBitY      = OSMapTbl[ptcb->OSTCBY];//获取对应消息表中的内容 所属任务组号
//        ptcb->OSTCBBitY=0x02
        ptcb->OSTCBX         = prio & 0x07;//任务序号
//	        00001100&0x07==0x04==ptcb->OSTCBX==0x04
        ptcb->OSTCBBitX      = OSMapTbl[ptcb->OSTCBX];
				//ptcb->OSTCBBitX==0x10==00010000
#if     OS_MBOX_EN || (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_SEM_EN
//若允许使用邮箱 或者 (使用队列 并且队列个数大于2个) 或者 使用信号功能
       ptcb->OSTCBEventPtr  = (OS_EVENT *)0;       
//初始化事件指针为0       
#endif

#if     OS_MBOX_EN || (OS_Q_EN && (OS_MAX_QS >= 2))
//若允许使用邮箱 或者 (使用队列 并且队列个数大于2个) 
        ptcb->OSTCBMsg       = (void *)0;            
//初始化任务消息指针为0        
#endif

        OS_ENTER_CRITICAL();
///////关中断        
        OSTCBPrioTbl[prio]   = ptcb;
// 把初始化好的任务指针赋给 对应任务优先级中的任务优先级表       
        ptcb->OSTCBNext      = OSTCBList;                 
///把任务列表指针赋给 任务控制块的下个任务控制块        
        ptcb->OSTCBPrev      = (OS_TCB *)0;
////前个任务指针初始化为0        
        if (OSTCBList != (OS_TCB *)0) {
            OSTCBList->OSTCBPrev = ptcb;
///若任务链表指针为非0则
//任务控制块的指针前移            
        }
        
        OSTCBList               = ptcb;
/////保存已经初始化好的任务指针给操作系统列表指针        
        OSRdyGrp               |= ptcb->OSTCBBitY;
//把任务所属表中的Y位置给任务组号        
        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
//保存任务所属表中的X位置        
        OS_EXIT_CRITICAL();
//开中断        
        return (OS_NO_ERR);
//函数返回无错误        
    } else {
//否则若任务为空    	
        OS_EXIT_CRITICAL();
//开中断        
        return (OS_NO_MORE_TCB);
    }
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                         PROCESS SYSTEM TICK
*
* Description: This function is used to signal to uC/OS-II the occurrence of a 'system tick' (also known
*              as a 'clock tick').  This function should be called by the ticker ISR but, can also be
*              called by a high priority task.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

void OSTimeTick (void) reentrant
{
    OS_TCB *ptcb;


    OSTimeTickHook();                                      /* Call user definable hook                 */
    ptcb = OSTCBList;                                      /* Point at first TCB in TCB list           */
    while (ptcb->OSTCBPrio != OS_IDLE_PRIO) {              /* Go through all TCBs in TCB list          */
        OS_ENTER_CRITICAL();
        if (ptcb->OSTCBDly != 0) {                         /* Delayed or waiting for event with TO     */
            if (--ptcb->OSTCBDly == 0) {                   /* Decrement nbr of ticks to end of delay   */
                if (!(ptcb->OSTCBStat & OS_STAT_SUSPEND)) {    /* Is task suspended?                   */
                    OSRdyGrp               |= ptcb->OSTCBBitY; /* No,  Make task Rdy to Run (timed out)*/
                    OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
                } else {                                       /* Yes, Leave 1 tick to prevent ...     */
                    ptcb->OSTCBDly = 1;                        /* ... loosing the task when the ...    */
                }                                              /* ... suspension is removed.           */
            }
        }
        ptcb = ptcb->OSTCBNext;                            /* Point at next TCB in TCB list            */
        OS_EXIT_CRITICAL();
    }
    OS_ENTER_CRITICAL();                                   /* Update the 32-bit tick counter           */
    OSTime++;
    OS_EXIT_CRITICAL();
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                             GET VERSION
*
* Description: This function is used to return the version number of uC/OS-II.  The returned value
*              corresponds to uC/OS-II's version number multiplied by 100.  In other words, version 2.00
*              would be returned as 200.
*
* Arguments  : none
*
* Returns    : the version number of uC/OS-II multiplied by 100.
*********************************************************************************************************
*/

INT16U OSVersion (void) reentrant
{
    return (OS_VERSION);
}