os_task.c

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

/*
*********************************************************************************************************
*                                                uC/OS-II
*                                          The Real-Time Kernel
*                                            TASK MANAGEMENT
*
*                        (c) Copyright 1992-1998, Jean J. Labrosse, Plantation, FL
*                                           All Rights Reserved
*
*                                                  V2.00
*
* File : OS_TASK.C
* By   : Jean J. Labrosse
*********************************************************************************************************
*/
/**************************************local************************************************************/
#include "includes.h"

#if OS_TASK_DEL_EN
static void  OSDummy (void)reentrant
{
}
#endif
//建立系统空闲任务
INT8U   OSTaskIdleCreate(){

	    INT8U   err;
		OS_STKCB *stkcb;
	
		OS_ENTER_CRITICAL();
	    OSTCBPrioTbl[OS_LOWEST_PRIO] = (OS_TCB *)1;    
		stkcb=OStkAsk();	   
		OS_EXIT_CRITICAL();	
				 
		OSTaskStkInit(OSTaskIdle, stkcb, 0); 
		err = OSTCBInit(OS_LOWEST_PRIO, stkcb, 0, (void *)0, 0);  
						         
        if (err == OS_NO_ERR) {
            OS_ENTER_CRITICAL();
            OSTaskCtr++;                                  
            OSTaskCreateHook(OSTCBPrioTbl[OS_LOWEST_PRIO]);            
            OS_EXIT_CRITICAL();
            if (OSRunning) {                
                OSSched();
            }
        } else {
            OS_ENTER_CRITICAL();
            OSTCBPrioTbl[OS_LOWEST_PRIO] = (OS_TCB *)0;            
            OS_EXIT_CRITICAL();
        }
        return (err);
}
//建立系统统计任务
#if		OS_TASK_STAT_EN
INT8U   OSTaskStatCreate(){

	    INT8U   err;
	    OS_STKCB *stkcb;
	
	    OS_ENTER_CRITICAL();
	    OSTCBPrioTbl[OS_LOWEST_PRIO-1 ] = (OS_TCB *)1;    
		stkcb=OStkAsk();	  
		OS_EXIT_CRITICAL();	
				 
		OSTaskStkInit(OSTaskStat, stkcb, 0); 
		err = OSTCBInit(OS_LOWEST_PRIO-1, stkcb, 0, (void *)0, 0);  
							       
        if (err == OS_NO_ERR){
            OS_ENTER_CRITICAL();
            OSTaskCtr++;                                   
            OSTaskCreateHook(OSTCBPrioTbl[OS_LOWEST_PRIO-1]);    
            OS_EXIT_CRITICAL();
            if (OSRunning) {               
                OSSched();
            }
        } else {
            OS_ENTER_CRITICAL();
            OSTCBPrioTbl[OS_LOWEST_PRIO-1] = (OS_TCB *)0;
            OS_EXIT_CRITICAL();
        }
        return (err);
}
#endif

//改变任务优先级
#if OS_TASK_CHANGE_PRIO_EN
INT8U OSTaskChangePrio (INT8U oldprio, INT8U newprio)reentrant
{
    OS_TCB   *ptcb;
    OS_EVENT *pevent;
    INT8U     x;
    INT8U     y;
    INT8U     bitx;
    INT8U     bity;


    if ((oldprio >= OS_LOWEST_PRIO && oldprio != OS_PRIO_SELF)  || 
         newprio >= OS_LOWEST_PRIO) {
        return (OS_PRIO_INVALID);
    }
    OS_ENTER_CRITICAL();
    if (OSTCBPrioTbl[newprio] != (OS_TCB *)0) {                
        OS_EXIT_CRITICAL();
        return (OS_PRIO_EXIST);
    } else {
        OSTCBPrioTbl[newprio] = (OS_TCB *)1;                   
        OS_EXIT_CRITICAL();
        y    = newprio >> 3;                                    
        bity = OSMapTbl[y];
        x    = newprio & 0x07;
        bitx = OSMapTbl[x];
        OS_ENTER_CRITICAL();
        if (oldprio == OS_PRIO_SELF) {                          
            oldprio = OSTCBCur->OSTCBPrio;                      
        }
        if ((ptcb = OSTCBPrioTbl[oldprio]) != (OS_TCB *)0) {    
            OSTCBPrioTbl[oldprio] = (OS_TCB *)0;                
            if (OSRdyTbl[ptcb->OSTCBY] & ptcb->OSTCBBitX) {     
                if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) {
                    OSRdyGrp &= ~ptcb->OSTCBBitY;
                }
                OSRdyGrp    |= bity;                            
                OSRdyTbl[y] |= bitx;
            } else {
                if ((pevent = ptcb->OSTCBEventPtr) != (OS_EVENT *)0) { 
                    if ((pevent->OSEventTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) {
                        pevent->OSEventGrp &= ~ptcb->OSTCBBitY;
                    }
                    pevent->OSEventGrp    |= bity;             
                    pevent->OSEventTbl[y] |= bitx;
                }
            }
            OSTCBPrioTbl[newprio] = ptcb;                      
            ptcb->OSTCBPrio       = newprio;                   
            ptcb->OSTCBY          = y;
            ptcb->OSTCBX          = x;
            ptcb->OSTCBBitY       = bity;
            ptcb->OSTCBBitX       = bitx;
            OS_EXIT_CRITICAL();
            OSSched();                                          
            return (OS_NO_ERR);
        } else {
            OSTCBPrioTbl[newprio] = (OS_TCB *)0;                
            OS_EXIT_CRITICAL();
            return (OS_PRIO_ERR);                               
        }
    }
}
#endif

//建立任务（简单式）
#if OS_TASK_CREATE_EN
INT8U OSTaskCreate (void (*task)(void *pd)reentrant, 
		            INT8U prio) reentrant
{   
			INT8U   err;
			OS_STKCB *stkcb;
			
			if (prio > OS_LOWEST_PRIO) {                  
			    return (OS_PRIO_INVALID);
			}
			
			OS_ENTER_CRITICAL();
			if (OSTCBPrioTbl[prio] == (OS_TCB *)0){ 
			    OSTCBPrioTbl[prio] = (OS_TCB *)1;   
			                                                    
			    stkcb=(OS_STK *)OStkAsk();	   //申请OS_STKCB
			    OS_EXIT_CRITICAL();	
				 
			    OSTaskStkInit(task, stkcb, 0); 
			    err = OSTCBInit(prio, stkcb, 0, (void *)0, 0);   
				      
		        if (err == OS_NO_ERR) {
		            OS_ENTER_CRITICAL();
		            OSTaskCtr++;                                   
		            OSTaskCreateHook(OSTCBPrioTbl[prio]);       
		            OS_EXIT_CRITICAL();
			        if (OSRunning) {                
			            OSSched();
			        }
		         }else {
		            OS_ENTER_CRITICAL();
		            OSTCBPrioTbl[prio] = (OS_TCB *)0;      
		            OS_EXIT_CRITICAL();
		        }
			    return (err);
			}else {
			    OS_EXIT_CRITICAL();
			    return (OS_PRIO_EXIST);
			}
}
#endif

//建立任务（复杂式）
#if   OS_TASK_CREATE_EXT_EN    
INT8U OSTaskCreateExt (void   (*task)(void *pd)reentrant, 		//任务
                       INT8U    prio,							//优先级
                       INT16U   id,								//任务ID
                       void    *pext,							//任务附加数据域指针
                       INT16U   opt)reentrant					//堆栈操作选项
{
    INT8U    err;
    INT16U   i;
    OS_STK  *pfill; 
    OS_STKCB *stkcb;

    if (prio > OS_LOWEST_PRIO) {          
        return (OS_PRIO_INVALID);
    }
    OS_ENTER_CRITICAL();
    if (OSTCBPrioTbl[prio] == (OS_TCB *)0) {
        OSTCBPrioTbl[prio] = (OS_TCB *)1;    
                                             
		stkcb=(OS_STKCB *)OStkAsk();
        OS_EXIT_CRITICAL();

        if (opt & OS_TASK_OPT_STK_CHK) {     
            if (opt & OS_TASK_OPT_STK_CLR) { 
                pfill = stkcb->OSTKBtomPtr ;             
                for (i = 0; i < OS_STK_SIZE ; i++) {
                    #if OS_STK_GROWTH == 1
                    *pfill++ = (OS_STK)0;
                    #else
                    *pfill-- = (OS_STK)0;
                    #endif
                }
            }
        }

        OSTaskStkInit(task, stkcb, opt); 
        err = OSTCBInit(prio, stkcb, id, pext, opt);         
        if (err == OS_NO_ERR){
            OS_ENTER_CRITICAL();
            OSTaskCtr++;                                     
            OSTaskCreateHook(OSTCBPrioTbl[prio]);         
            OS_EXIT_CRITICAL();
            if (OSRunning) {                
                OSSched();
            }
        } else {
            OS_ENTER_CRITICAL();
            OSTCBPrioTbl[prio] = (OS_TCB *)0;
            OS_EXIT_CRITICAL();
        }
        return (err);
    } else {
        OS_EXIT_CRITICAL();
        return (OS_PRIO_EXIST);
    }