os_core.c

完整的ucos实例

 
 
    OSTCBList     = (OS_TCB *)0;                                 /* TCB Initialization                       */ 
    for (i = 0; i < (OS_LOWEST_PRIO + 1); i++) {                 /* Clear the priority table                 */ 
        OSTCBPrioTbl[i] = (OS_TCB *)0; 
    } 
    ptcb1 = &OSTCBTbl[0]; 
    ptcb2 = &OSTCBTbl[1]; 
    for (i = 0; i < (OS_MAX_TASKS + OS_N_SYS_TASKS - 1); i++) {  /* Init. list of free TCBs                  */ 
        ptcb1->OSTCBNext = ptcb2; 
        ptcb1++; 
        ptcb2++; 
    } 
    ptcb1->OSTCBNext = (OS_TCB *)0;                              /* Last OS_TCB                              */ 
    OSTCBFreeList    = &OSTCBTbl[0]; 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                              SCHEDULER 
* 
* Description: This function is called by other uC/OS-II services to determine whether a new, high 
*              priority task has been made ready to run.  This function is invoked by TASK level code 
*              and is not used to reschedule tasks from ISRs (see OSIntExit() for ISR rescheduling). 
* 
* Arguments  : none 
* 
* Returns    : none 
* 
* Notes      : 1) This function is INTERNAL to uC/OS-II and your application should not call it. 
*              2) Rescheduling is prevented when the scheduler is locked (see OS_SchedLock()) 
********************************************************************************************************* 
*/ 
 
void  OS_Sched (void) 
{ 
#if OS_CRITICAL_METHOD == 3                            /* Allocate storage for CPU status register     */ 
    OS_CPU_SR  cpu_sr; 
#endif     
    INT8U      y; 
 
 
    OS_ENTER_CRITICAL(); 
    if ((OSIntNesting == 0) && (OSLockNesting == 0)) { /* Sched. only if all ISRs done & not locked    */ 
        y             = OSUnMapTbl[OSRdyGrp];          /* Get pointer to HPT ready to run              */ 
        OSPrioHighRdy = (INT8U)((y << 3) + OSUnMapTbl[OSRdyTbl[y]]); 
        if (OSPrioHighRdy != OSPrioCur) {              /* No Ctx Sw if current task is highest rdy     */ 
            OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy]; 
            OSCtxSwCtr++;                              /* Increment context switch counter             */ 
            OS_TASK_SW();                              /* Perform a context switch                     */ 
        } 
    } 
    OS_EXIT_CRITICAL(); 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                              IDLE TASK 
* 
* Description: This task is internal to uC/OS-II and executes whenever no other higher priority tasks 
*              executes because they are ALL waiting for event(s) to occur. 
* 
* Arguments  : none 
* 
* Returns    : none 
* 
* Note(s)    : 1) OSTaskIdleHook() is called after the critical section to ensure that interrupts will be 
*                 enabled for at least a few instructions.  On some processors (ex. Philips XA), enabling 
*                 and then disabling interrupts didn't allow the processor enough time to have interrupts 
*                 enabled before they were disabled again.  uC/OS-II would thus never recognize 
*                 interrupts. 
*              2) This hook has been added to allow you to do such things as STOP the CPU to conserve  
*                 power. 
********************************************************************************************************* 
*/ 
 
void  OS_TaskIdle (void *pdata) 
{ 
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */ 
    OS_CPU_SR  cpu_sr; 
#endif     
     
     
    pdata = pdata;                               /* Prevent compiler warning for not using 'pdata'     */ 
    for (;;) { 
        OS_ENTER_CRITICAL(); 
        OSIdleCtr++; 
        OS_EXIT_CRITICAL(); 
        OSTaskIdleHook();                        /* Call user definable HOOK                           */ 
    } 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                            STATISTICS TASK 
* 
* Description: This task is internal to uC/OS-II and is used to compute some statistics about the 
*              multitasking environment.  Specifically, OS_TaskStat() 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 > 0 
void  OS_TaskStat (void *pdata) 
{ 
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */ 
    OS_CPU_SR  cpu_sr; 
#endif     
    INT32U     run; 
    INT32U     max; 
    INT8S      usage; 
 
 
    pdata = pdata;                               /* Prevent compiler warning for not using 'pdata'     */ 
    while (OSStatRdy == FALSE) { 
        OSTimeDly(2 * OS_TICKS_PER_SEC);         /* Wait until statistic task is ready                 */ 
    } 
    max = OSIdleCtrMax / 100L; 
    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 (max > 0L) { 
            usage = (INT8S)(100L - run / max); 
            if (usage >= 0) {                    /* Make sure we don't have a negative percentage      */ 
                OSCPUUsage = usage; 
            } else { 
                OSCPUUsage = 0; 
            } 
        } else { 
            OSCPUUsage = 0; 
            max        = OSIdleCtrMax / 100L; 
        } 
        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. 
********************************************************************************************************* 
*/ 
 
INT8U  OS_TCBInit (INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT32U stk_size, void *pext, INT16U opt) 
{ 
#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */ 
    OS_CPU_SR  cpu_sr; 
#endif     
    OS_TCB    *ptcb; 
 
 
    OS_ENTER_CRITICAL(); 
    ptcb = OSTCBFreeList;                                  /* Get a free TCB from the free TCB list    */ 
    if (ptcb != (OS_TCB *)0) { 
        OSTCBFreeList        = ptcb->OSTCBNext;            /* Update pointer to free TCB list          */ 
        OS_EXIT_CRITICAL(); 
        ptcb->OSTCBStkPtr    = ptos;                       /* Load Stack pointer in TCB                */ 
        ptcb->OSTCBPrio      = (INT8U)prio;                /* Load task priority into TCB              */ 
        ptcb->OSTCBStat      = OS_STAT_RDY;                /* Task is ready to run                     */ 
        ptcb->OSTCBDly       = 0;                          /* Task is not delayed                      */ 
 
#if OS_TASK_CREATE_EXT_EN > 0 
        ptcb->OSTCBExtPtr    = pext;                       /* Store pointer to TCB extension           */ 
        ptcb->OSTCBStkSize   = stk_size;                   /* Store stack size                         */ 
        ptcb->OSTCBStkBottom = pbos;                       /* Store pointer to bottom of stack         */ 
        ptcb->OSTCBOpt       = opt;                        /* Store task options                       */ 
        ptcb->OSTCBId        = id;                         /* Store task ID                            */ 
#else 
        pext                 = pext;                       /* Prevent compiler warning if not used     */ 
        stk_size             = stk_size; 
        pbos                 = pbos; 
        opt                  = opt; 
        id                   = id; 
#endif 
 
#if OS_TASK_DEL_EN > 0 
        ptcb->OSTCBDelReq    = OS_NO_ERR; 
#endif 
 
        ptcb->OSTCBY         = prio >> 3;                  /* Pre-compute X, Y, BitX and BitY          */ 
        ptcb->OSTCBBitY      = OSMapTbl[ptcb->OSTCBY]; 
        ptcb->OSTCBX         = prio & 0x07; 
        ptcb->OSTCBBitX      = OSMapTbl[ptcb->OSTCBX]; 
 
#if OS_EVENT_EN > 0 
        ptcb->OSTCBEventPtr  = (OS_EVENT *)0;              /* Task is not pending on an event          */ 
#endif 
 
#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0) && (OS_TASK_DEL_EN > 0) 
        ptcb->OSTCBFlagNode  = (OS_FLAG_NODE *)0;          /* Task is not pending on an event flag     */ 
#endif 
 
#if (OS_MBOX_EN > 0) || ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) 
        ptcb->OSTCBMsg       = (void *)0;                  /* No message received                      */ 
#endif 
 
#if OS_VERSION >= 204 
        OSTCBInitHook(ptcb); 
#endif 
 
        OSTaskCreateHook(ptcb);                            /* Call user defined hook                   */ 
         
        OS_ENTER_CRITICAL(); 
        OSTCBPrioTbl[prio] = ptcb; 
        ptcb->OSTCBNext    = OSTCBList;                    /* Link into TCB chain                      */ 
        ptcb->OSTCBPrev    = (OS_TCB *)0; 
        if (OSTCBList != (OS_TCB *)0) { 
            OSTCBList->OSTCBPrev = ptcb; 
        } 
        OSTCBList               = ptcb; 
        OSRdyGrp               |= ptcb->OSTCBBitY;         /* Make task ready to run                   */ 
        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX; 
        OS_EXIT_CRITICAL(); 
        return (OS_NO_ERR); 
    } 
    OS_EXIT_CRITICAL(); 
    return (OS_NO_MORE_TCB); 
}