os_core.c

EventOS操作系统核心源码

* Arguments  : INT8U nTaskID  -  is task ID code
*
* Returns    : the task prio
*********************************************************************************************************
*/
INT8U  GetTskPrio(INT8U nTaskID)
{
    OS_TCB   *pTmpTcb;

    pTmpTcb = OSMsgHd->FstProc;
    while (pTmpTcb != NULL) {
        if (pTmpTcb->TaskID == nTaskID) break;
        else pTmpTcb = (OS_TCB *)pTmpTcb->pTcbNext;
    }
    if (pTmpTcb != NULL)
        return pTmpTcb->nTskPrio;
    return 0;
}

/********************************************************************************************************
*                                     GET CURRENT ACTIVE OS_TCB or MSGPROC
*
* Description: This function is used to Get the Active One
*
* Arguments  : INT8U nTaskID  -  task that Semphere being ID Code
*
* Returns    : the ACTIVE STRUCT pointer
*********************************************************************************************************
*/
OS_TCB *GetActive(INT8U nTaskID)
{
    OS_MSG  *pCurMsg;
    MSGPROC *pTmpMsgP;
    OS_TCB  *pTskTcb;
    
    pCurMsg = OSMsgHd, pTskTcb = NULL;
    while (pCurMsg != NULL) {
       if (pCurMsg->OSMsgID == 1) {
           pTskTcb = pCurMsg->FstProc;
           while (pTskTcb != NULL) {
               if (pTskTcb->TaskID == nTaskID && pTskTcb->bStatus == OS_TSK_ACTIVE)
                   break;
               pTskTcb = pTskTcb->pTcbNext;
           }
       } else if (pCurMsg->OSMsgID > 16) {
           pTmpMsgP = pCurMsg->FstProc;
           while (pTmpMsgP != NULL) {
               if (pTmpMsgP->TaskID == nTaskID && pTmpMsgP->bStatus == OS_TSK_RUN)
                   break;
               pTmpMsgP = pTmpMsgP->pNextMsgP;
           }
       }       
       pCurMsg = pCurMsg->pNextMsg;
       if (pTskTcb != NULL || pTmpMsgP != NULL) break;
    }
    if (pTskTcb == NULL) pTskTcb = (OS_TCB *)pTmpMsgP;
    return pTskTcb;
}

/********************************************************************************************************
*                                SET CURRENT ACTIVE OS_TCB
*
* Description: This function is used to Set the Active Task
*
* Arguments  : INT8U nTaskID  -  task ID that will be set to active
*
* Returns    : none
*********************************************************************************************************
*/
void SetActive(INT8U nTaskID)
{
    OS_MSG  *pCurMsg;
    OS_TCB  *pTskTcb;
    
    pCurMsg = OSMsgHd, pTskTcb = NULL;
    if (pCurMsg->OSMsgID == 1) {
        pTskTcb = pCurMsg->FstProc;
        while (pTskTcb != NULL) {
            if (pTskTcb->TaskID == nTaskID)
                pTskTcb->bStatus |= OS_TSK_ACTIVE;
            else
                pTskTcb->bStatus &= (OS_TSK_ACTIVE^0xFF);
            pTskTcb = pTskTcb->pTcbNext;
        }
    }
}
/********************************************************************************************************
*                                     GET TASK STATUS 
*
* Description: This function is used to Get the task stauts that is pointed
*
* Arguments  : nTaskID   -  is task ID code
*
* Returns    : the task status
*********************************************************************************************************
*/
INT8U   GetTaskSta(INT8U nTaskID)
{
    OS_TCB   *pTmpTcb;

    pTmpTcb = OSMsgHd->FstProc;
    while (pTmpTcb != NULL) {
        if (pTmpTcb->TaskID == nTaskID) break;
        else pTmpTcb = (OS_TCB *)pTmpTcb->pTcbNext;
    }
    if (pTmpTcb != NULL)
        return pTmpTcb->bStatus;
    else 
        return 0;
    
}
/********************************************************************************************************
*                                             INITIALIZATION
*
* Description: This function is used to initialize the internals of uC/OS-II and MUST be called prior to
*              creating any uC/OS-II object and, prior to calling OSStart().
*
* Arguments  : none
* Returns    : none
*********************************************************************************************************
*/
OS_MSG   SysMsg[10];                               // PUBLIC DATA LOCAL USE
OS_TCB   SysStart;

extern  INT8U PutEvent(INT8U OSEventID, INT8U nTaskID, INT16U nParamL, INT32U lParamM);
extern   void OSInitHookBegin(void);
extern   void OSInitHookEnd(void);
extern   void TargetInit(void);
extern   void EventMain(INT16U, INT32U);

void  OSInit (void)
{
#if OS_CPU_HOOKS_EN
    OSInitHookBegin();                        /* Call port specific initialization code   */
#endif
    OSMsgHd       =  NULL;
    OSRunning     = FALSE;                    /* Indicate that multitasking not started   */
    
    OSIntNesting  = 0;                       /* Clear the interrupt nesting counter  */
    
    CreateEvt(OS_EVT_ONTASK, NULL, &SysMsg[0]);
    CreateEvt(OS_EVT_TIMEOUT, NULL, &SysMsg[1]);
    CreateEvt(OS_EVT_TICK, NULL, &SysMsg[2]);
    CreateEvt(OS_EVT_SEC, NULL, &SysMsg[3]);
    
    CreateEvt(OS_EVT_STARTUP, NULL, &SysMsg[4]);
    CreateEvt(OS_EVT_STACHG, NULL, &SysMsg[5]);
    CreateEvt(OS_EVT_SENSOR_ERR, NULL, &SysMsg[6]);
    CreateEvt(OS_EVT_STOP_ERR, NULL, &SysMsg[7]);
    CreateEvt(OS_EVT_HALT_ERR, NULL, &SysMsg[8]);
    CreateEvt(OS_EVT_DEV_ERR, NULL, &SysMsg[9]);

    CreateTask(1, EventMain, 1, "EventMain", &SysStart);

    PutEvent(OS_EVT_ONTASK, 1, 0, 0);

    OSRunning = TRUE;
    TargetInit();    
#if OS_CPU_HOOKS_EN
    OSInitHookEnd();                                             /* Call port specific init. code            */
#endif
}

/**********************************************************************************************************
*                                         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
*********************************************************************************************************
*/
extern void OSTimeTickHook(void);

void  OSTimeTick (void)
{
    OS_MSG  *pCurMsg;
    OS_TCB  *pTskProg;
    SEMPROC *pCurSemP, *pProSemP;
    MSGPROC *pCurMsgP;
    
#if OS_CPU_HOOKS_EN
    OSTimeTickHook();                       /* Call user definable hook      */
#endif
#if OS_TIME_GET_SET_EN > 0
    OS_ENTER_CRITICAL();                    /* Update the 32-bit tick counter  */
    OSCurTime++;
    OS_EXIT_CRITICAL();
#endif
    if (OSRunning == TRUE) {
        pCurMsg = OSMsgHd;
        while (pCurMsg != NULL) {
            if (pCurMsg->OSMsgID == 1) {
    // ====See if Task Main Program run too long ==== 
                pTskProg = (OS_TCB *)pCurMsg->FstProc;
                while (pTskProg != NULL) {
                    if (pTskProg->bStatus == 0) {
                        if(pTskProg->nDelayCnt > 0) {
                            pTskProg->nDelayCnt--;
                            if (pTskProg->nDelayCnt == 0)
                                PutEvent(OS_EVT_TIMEOUT, pTskProg->TaskID, pCurMsg->OSMsgID, 0);
                        }
                    }
                    pTskProg = pTskProg->pTcbNext;
                }
            } else if (pCurMsg->OSMsgID < 16) {
    // ====See if each semaphore-process time out==== 
                pCurSemP = (SEMPROC *)pCurMsg->FstProc;
                pProSemP = NULL;
                while (pCurSemP != NULL) {
                    if(pCurSemP->nDelayCnt > 0) {
                        pCurSemP->nDelayCnt--;
                        OS_ENTER_CRITICAL();
                        if (pCurSemP->nDelayCnt == 0) {
                            PutEvent(pCurMsg->OSMsgID, pCurSemP->TaskID, 0, 0);
                            if(pProSemP != NULL)
                                pProSemP->pNextSemP = pCurSemP->pNextSemP;
                            else
                                pCurMsg->FstProc = pCurSemP->pNextSemP;
                        } else {
                            pProSemP = pCurSemP;
                        }
                        OS_EXIT_CRITICAL();
                    }                            
                    pCurSemP = pCurSemP->pNextSemP;
                }
                
            } else {
    // ====See if Event process run too long ==== 
                pCurMsgP = (MSGPROC *)pCurMsg->FstProc;
                while (pCurMsgP != NULL) {
                    if (pCurMsgP->bStatus == OS_TSK_RUN) {     // 超时处理
                        if(pCurMsgP->nDelayCnt > 0) {
                            pCurMsgP->nDelayCnt--;
                            if (pCurMsgP->nDelayCnt == 0)
                                PutEvent(OS_EVT_TIMEOUT, pCurMsgP->TaskID, pCurMsg->OSMsgID, 0);
                        }
                    }
                    pCurMsgP = pCurMsgP->pNextMsgP;
                }
            
            }
            pCurMsg = pCurMsg->pNextMsg;
        }
//        PutEvent(OS_EVT_TICK, 0, 0, 0);
        if ((OSCurTime%20) == 0)
            PutEvent(OS_EVT_SEC, 0,0,0);
    }
}