os_core.c

完整的ucos实例

*              and you MUST have created at least one task. 
* 
* Arguments  : none 
* 
* Returns    : none 
* 
* Note       : OSStartHighRdy() MUST: 
*                 a) Call OSTaskSwHook() then, 
*                 b) Set OSRunning to TRUE. 
*                 c) Load the context of the task pointed to by OSTCBHighRdy. 
*                 d_ Execute the task. 
********************************************************************************************************* 
*/ 
 
void  OSStart (void) 
{ 
    INT8U y; 
    INT8U x; 
 
 
    if (OSRunning == FALSE) { 
        y             = OSUnMapTbl[OSRdyGrp];        /* Find highest priority's task priority number   */ 
        x             = OSUnMapTbl[OSRdyTbl[y]]; 
        OSPrioHighRdy = (INT8U)((y << 3) + x); 
        OSPrioCur     = OSPrioHighRdy; 
        OSTCBHighRdy  = OSTCBPrioTbl[OSPrioHighRdy]; /* Point to highest priority task ready to run    */ 
        OSTCBCur      = OSTCBHighRdy; 
        OSStartHighRdy();                            /* Execute target specific code to start task     */ 
    } 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                        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_EN > 0 
void  OSStatInit (void) 
{ 
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */ 
    OS_CPU_SR  cpu_sr; 
#endif     
     
     
    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*/ 
/* 
********************************************************************************************************* 
*                                         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) 
{ 
#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */ 
    OS_CPU_SR  cpu_sr; 
#endif     
    OS_TCB    *ptcb; 
 
 
    OSTimeTickHook();                                      /* Call user definable hook                 */ 
#if OS_TIME_GET_SET_EN > 0    
    OS_ENTER_CRITICAL();                                   /* Update the 32-bit tick counter           */ 
    OSTime++; 
    OS_EXIT_CRITICAL(); 
#endif 
    if (OSRunning == TRUE) {     
        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) == OS_STAT_RDY) { /* Is task suspended?    */ 
                        OSRdyGrp               |= ptcb->OSTCBBitY; /* No,  Make task R-to-R (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(); 
        } 
    } 
} 
/*$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); 
} 
 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                            DUMMY FUNCTION 
* 
* Description: This function doesn't do anything.  It is called by OSTaskDel(). 
* 
* Arguments  : none 
* 
* Returns    : none 
********************************************************************************************************* 
*/ 
 
#if OS_TASK_DEL_EN > 0 
void  OS_Dummy (void) 
{ 
} 
#endif 
 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                             MAKE TASK READY TO RUN BASED ON EVENT OCCURING 
* 
* Description: This function is called by other uC/OS-II services and is used to ready a task that was 
*              waiting for an event to occur. 
* 
* Arguments  : pevent    is a pointer to the event control block corresponding to the event. 
* 
*              msg       is a pointer to a message.  This pointer is used by message oriented services 
*                        such as MAILBOXEs and QUEUEs.  The pointer is not used when called by other 
*                        service functions. 
* 
*              msk       is a mask that is used to clear the status byte of the TCB.  For example, 
*                        OSSemPost() will pass OS_STAT_SEM, OSMboxPost() will pass OS_STAT_MBOX etc. 
* 
* Returns    : none 
* 
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it. 
********************************************************************************************************* 
*/ 
#if OS_EVENT_EN > 0 
INT8U  OS_EventTaskRdy (OS_EVENT *pevent, void *msg, INT8U msk) 
{ 
    OS_TCB *ptcb; 
    INT8U   x; 
    INT8U   y; 
    INT8U   bitx; 
    INT8U   bity; 
    INT8U   prio; 
 
 
    y    = OSUnMapTbl[pevent->OSEventGrp];            /* Find highest prio. task waiting for message   */ 
    bity = OSMapTbl[y]; 
    x    = OSUnMapTbl[pevent->OSEventTbl[y]]; 
    bitx = OSMapTbl[x]; 
    prio = (INT8U)((y << 3) + x);                     /* Find priority of task getting the msg         */ 
    if ((pevent->OSEventTbl[y] &= ~bitx) == 0x00) {   /* Remove this task from the waiting list        */ 
        pevent->OSEventGrp &= ~bity;                  /* Clr group bit if this was only task pending   */ 
    } 
    ptcb                 =  OSTCBPrioTbl[prio];       /* Point to this task's OS_TCB                   */ 
    ptcb->OSTCBDly       =  0;                        /* Prevent OSTimeTick() from readying task       */ 
    ptcb->OSTCBEventPtr  = (OS_EVENT *)0;             /* Unlink ECB from this task                     */ 
#if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0) 
    ptcb->OSTCBMsg       = msg;                       /* Send message directly to waiting task         */ 
#else 
    msg                  = msg;                       /* Prevent compiler warning if not used          */ 
#endif 
    ptcb->OSTCBStat     &= ~msk;                      /* Clear bit associated with event type          */ 
    if (ptcb->OSTCBStat == OS_STAT_RDY) {             /* See if task is ready (could be susp'd)        */ 
        OSRdyGrp        |=  bity;                     /* Put task in the ready to run list             */ 
        OSRdyTbl[y]     |=  bitx; 
    } 
    return (prio); 
} 
#endif 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                   MAKE TASK WAIT FOR EVENT TO OCCUR 
* 
* Description: This function is called by other uC/OS-II services to suspend a task because an event has 
*              not occurred. 
* 
* Arguments  : pevent   is a pointer to the event control block for which the task will be waiting for. 
* 
* Returns    : none 
* 
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it. 
********************************************************************************************************* 
*/ 
#if OS_EVENT_EN > 0 
void  OS_EventTaskWait (OS_EVENT *pevent) 
{ 
    OSTCBCur->OSTCBEventPtr = pevent;            /* Store pointer to event control block in TCB        */ 
    if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0x00) {   /* Task no longer ready      */ 
        OSRdyGrp &= ~OSTCBCur->OSTCBBitY;        /* Clear event grp bit if this was only task pending  */ 
    } 
    pevent->OSEventTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;          /* Put task in waiting list  */ 
    pevent->OSEventGrp                   |= OSTCBCur->OSTCBBitY; 
} 
#endif 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                              MAKE TASK READY TO RUN BASED ON EVENT TIMEOUT 
* 
* Description: This function is called by other uC/OS-II services to make a task ready to run because a 
*              timeout occurred. 
* 
* Arguments  : pevent   is a pointer to the event control block which is readying a task. 
* 
* Returns    : none 
* 
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it. 
********************************************************************************************************* 
*/ 
#if OS_EVENT_EN > 0 
void  OS_EventTO (OS_EVENT *pevent) 
{ 
    if ((pevent->OSEventTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0x00) { 
        pevent->OSEventGrp &= ~OSTCBCur->OSTCBBitY; 
    } 
    OSTCBCur->OSTCBStat     = OS_STAT_RDY;       /* Set status to ready                                */ 
    OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;     /* No longer waiting for event                        */ 
} 
#endif 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                 INITIALIZE EVENT CONTROL BLOCK'S WAIT LIST 
* 
* Description: This function is called by other uC/OS-II services to initialize the event wait list. 
* 
* Arguments  : pevent    is a pointer to the event control block allocated to the event. 
* 
* Returns    : none 
* 
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it. 
*********************************************************************************************************