os_task.c

基于51单片机来实现UCOS用一个串口来看到实现阶段

}
#endif

//删除任务
#if OS_TASK_DEL_EN
INT8U OSTaskDel (INT8U prio)reentrant
{
    OS_TCB   *ptcb;
    OS_EVENT *pevent;


    if (prio == OS_IDLE_PRIO) {                                 /* Not allowed to delete idle task     */
        return (OS_TASK_DEL_IDLE);
    }
    if (prio >= OS_LOWEST_PRIO && prio != OS_PRIO_SELF) {       /* Task priority valid ?               */
        return (OS_PRIO_INVALID);
    }
    OS_ENTER_CRITICAL();
    if (OSIntNesting > 0) {                                     /* See if trying to delete from ISR    */
        OS_EXIT_CRITICAL();
        return (OS_TASK_DEL_ISR);
    }
    if (prio == OS_PRIO_SELF) {                                 /* See if requesting to delete self    */
        prio = OSTCBCur->OSTCBPrio;                             /* Set priority to delete to current   */
    }
    if ((ptcb = OSTCBPrioTbl[prio]) != (OS_TCB *)0) {           /* Task to delete must exist           */
        if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) {/* Make task not ready                 */
            OSRdyGrp &= ~ptcb->OSTCBBitY;
        }
        if ((pevent = ptcb->OSTCBEventPtr) != (OS_EVENT *)0) {  /* If task is waiting on event         */
            if ((pevent->OSEventTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) { /* ... remove task from */
                pevent->OSEventGrp &= ~ptcb->OSTCBBitY;                        /* ... event ctrl block */
            }
        }
        ptcb->OSTCBDly  = 0;                                    /* Prevent OSTimeTick() from updating  */
        ptcb->OSTCBStat = OS_STAT_RDY;                          /* Prevent task from being resumed     */
        OSLockNesting++;
        OS_EXIT_CRITICAL();                                     /* Enabling INT. ignores next instruc. */
        OSDummy();                                              /* ... Dummy ensures that INTs will be */
        OS_ENTER_CRITICAL();                                    /* ... disabled HERE!                  */
        OSLockNesting--;
        OSTaskDelHook(ptcb);                                    /* Call user defined hook              */
        OSTaskCtr--;                                            /* One less task being managed         */
        OSTCBPrioTbl[prio] = (OS_TCB *)0;                       /* Clear old priority entry            */

		ptcb->OSTCBStkCb->OSTKCBNext=OSTKCBFreeList;
        OSTKCBFreeList = ptcb->OSTCBStkCb;
		ptcb->OSTCBStkCb=(void*)0;

        if (ptcb->OSTCBPrev == (OS_TCB *)0) {                   /* Remove from TCB chain               */
            ptcb->OSTCBNext->OSTCBPrev = (OS_TCB *)0;
            OSTCBList                  = ptcb->OSTCBNext;
        } else {
            ptcb->OSTCBPrev->OSTCBNext = ptcb->OSTCBNext;
            ptcb->OSTCBNext->OSTCBPrev = ptcb->OSTCBPrev;
        }
        ptcb->OSTCBNext = OSTCBFreeList;                        /* Return TCB to free TCB list         */
        OSTCBFreeList   = ptcb;

        OS_EXIT_CRITICAL();
        OSSched();                                              /* Find new highest priority task      */
        return (OS_NO_ERR);
    } else {
        OS_EXIT_CRITICAL();
        return (OS_TASK_DEL_ERR);
    }
}
#endif

//请求删除任务
#if OS_TASK_DELR_EN
INT8U OSTaskDelReq (INT8U prio)reentrant
{
    BOOLEAN  stat;
    INT8U    err;
    OS_TCB  *ptcb;


    if (prio == OS_IDLE_PRIO) {                                
        return (OS_TASK_DEL_IDLE);
    }
    if (prio >= OS_LOWEST_PRIO && prio != OS_PRIO_SELF) {       
        return (OS_PRIO_INVALID);
    }
    if (prio == OS_PRIO_SELF) {                                
        OS_ENTER_CRITICAL();                                   
        stat = OSTCBCur->OSTCBDelReq;                           
        OS_EXIT_CRITICAL();
        return (stat);
    } else {
        OS_ENTER_CRITICAL();
        if ((ptcb = OSTCBPrioTbl[prio]) != (OS_TCB *)0) {     
            ptcb->OSTCBDelReq = OS_TASK_DEL_REQ;               
            err               = OS_NO_ERR;
        } else {
            err               = OS_TASK_NOT_EXIST;             
        }
        OS_EXIT_CRITICAL();
        return (err);
    }
}
#endif

//恢复任务
#if OS_TASK_SUSPEND_EN
INT8U OSTaskResume (INT8U prio)reentrant
{
    OS_TCB   *ptcb;


    if (prio >= OS_LOWEST_PRIO) {                               /* Make sure task priority is valid    */
        return (OS_PRIO_INVALID);
    }
    OS_ENTER_CRITICAL();
    if ((ptcb = OSTCBPrioTbl[prio]) == (OS_TCB *)0) {           /* Task to suspend must exist          */
        OS_EXIT_CRITICAL();
        return (OS_TASK_RESUME_PRIO);
    } else {
        if (ptcb->OSTCBStat & OS_STAT_SUSPEND) {                           /* Task must be suspended   */
            if (((ptcb->OSTCBStat &= ~OS_STAT_SUSPEND) == OS_STAT_RDY) &&  /* Remove suspension        */
                 (ptcb->OSTCBDly  == 0)) {                                 /* Must not be delayed      */
                OSRdyGrp               |= ptcb->OSTCBBitY;                 /* Make task ready to run   */
                OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
                OS_EXIT_CRITICAL();
                OSSched();
            } else {
                OS_EXIT_CRITICAL();
            }
            return (OS_NO_ERR);
        } else {
            OS_EXIT_CRITICAL();
            return (OS_TASK_NOT_SUSPENDED);
        }
    }
}
#endif

//任务堆栈检查
 /*
#if   OS_TASK_CREATE_EXT_EN
INT8U OSTaskStkChk (INT8U prio, OS_STK_DATA *dataptr)reentrant
{
    OS_TCB  *ptcb;
    OS_STK  *pchk;
    INT32U   free;
    INT32U   size;


    dataptr->OSFree = 0;                                         
    dataptr->OSUsed = 0;
    if (prio > OS_LOWEST_PRIO && prio != OS_PRIO_SELF) {      
        return (OS_PRIO_INVALID);
    }
    OS_ENTER_CRITICAL();
    if (prio == OS_PRIO_SELF) {                      
        prio = OSTCBCur->OSTCBPrio;
    }
    ptcb = OSTCBPrioTbl[prio];
    if (ptcb == (OS_TCB *)0) {                      
        OS_EXIT_CRITICAL();
        return (OS_TASK_NOT_EXIST);
    }
    if ((ptcb->OSTCBOpt & OS_TASK_OPT_STK_CHK) == 0) { 
        OS_EXIT_CRITICAL();
        return (OS_TASK_OPT_ERR);
    }
    free = 0;
    size = ptcb->OSTCBStkSize;
    pchk = ptcb->OSTCBStkBottom;
    OS_EXIT_CRITICAL();
#if OS_STK_GROWTH == 1
    while (*pchk++ == 0) {                            
        free++;
    }
#else
    while (*pchk-- == 0) {
        free++;
    }
#endif
    dataptr->OSFree = free * sizeof(OS_STK);            
    dataptr->OSUsed = (size - free) * sizeof(OS_STK);   
    return (OS_NO_ERR);
}
#endif	*/   

//挂起任务
#if OS_TASK_SUSPEND_EN
INT8U OSTaskSuspend (INT8U prio)reentrant
{
    BOOLEAN   self;
    OS_TCB   *ptcb;


    if (prio == OS_IDLE_PRIO) {                                 /* Not allowed to suspend idle task    */
        return (OS_TASK_SUSPEND_IDLE);
    }
    if (prio >= OS_LOWEST_PRIO && prio != OS_PRIO_SELF) {       /* Task priority valid ?               */
        return (OS_PRIO_INVALID);
    }
    OS_ENTER_CRITICAL();
    if (prio == OS_PRIO_SELF) {                                 /* See if suspend SELF                 */
        prio = OSTCBCur->OSTCBPrio;
        self = TRUE;
    } else if (prio == OSTCBCur->OSTCBPrio) {                   /* See if suspending self              */
        self = TRUE;
    } else {
        self = FALSE;                                           /* No suspending another task          */
    }
    if ((ptcb = OSTCBPrioTbl[prio]) == (OS_TCB *)0) {                /* Task to suspend must exist     */
        OS_EXIT_CRITICAL();
        return (OS_TASK_SUSPEND_PRIO);
    } else {
        if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) {     /* Make task not ready            */
            OSRdyGrp &= ~ptcb->OSTCBBitY;
        }
        ptcb->OSTCBStat |= OS_STAT_SUSPEND;                          /* Status of task is 'SUSPENDED'  */
        OS_EXIT_CRITICAL();
        if (self == TRUE) {                                          /* Context switch only if SELF    */
            OSSched();
        }
        return (OS_NO_ERR);
    }
}
#endif

//获取任务信息
#if OS_Task_Query_EN
INT8U OSTaskQuery(INT8U prio, OS_TCB *dataptr)reentrant
{
    OS_TCB *ptcb;

    if (prio > OS_LOWEST_PRIO && prio != OS_PRIO_SELF) {   /* Task priority valid ?                    */
        return (OS_PRIO_INVALID);
    }
    OS_ENTER_CRITICAL();
    if (prio == OS_PRIO_SELF) {                            /* See if suspend SELF                      */
        prio = OSTCBCur->OSTCBPrio;
    }
    if ((ptcb = OSTCBPrioTbl[prio]) == (OS_TCB *)0) {      /* Task to query must exist                 */
        OS_EXIT_CRITICAL();
        return (OS_PRIO_ERR);
    }
    *dataptr = *ptcb;                                        /* Copy TCB into user storage area          */
    OS_EXIT_CRITICAL();
    return (OS_NO_ERR);
}
#endif