*                                        STATISTICS INITIALIZATION** Description: This function is called by your application to establish CPU usage by first determining*              how high a 32-bit counter would count to in 1 second if no other tasks were to execute*              during that time.  CPU usage is then determined by a low priority task which keeps track*              of this 32-bit counter every second but this time, with other tasks running.  CPU usage is*              determined by:**                                             OSIdleCtr*                 CPU Usage (%) = 100 * (1 - ------------)*                                            OSIdleCtrMax** Arguments  : none** Returns    : none**********************************************************************************************************/#if OS_TASK_STAT_ENvoid OSStatInit (void){    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 *pdata){    pdata = pdata;                               /* 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_ENvoid OSTaskStat (void *pdata){    INT32U run;    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                 */    }    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.**********************************************************************************************************/INT8U OSTCBInit (INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT16U stk_size, void *pext, INT16U opt){    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                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                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_MBOX_EN || (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_SEM_EN        ptcb->OSTCBEventPtr  = (OS_EVENT *)0;              /* Task is not pending on an event          */#endif#if     OS_MBOX_EN || (OS_Q_EN && (OS_MAX_QS >= 2))        ptcb->OSTCBMsg       = (void *)0;                  /* No message received                      */#endif        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);    } 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){    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){    return (OS_VERSION);}