os_core/os_time.c File Reference

Go to the source code of this file.

Functions

void OsTimeInit (void)
void OsTimeTickHandler (void)
void OsTimeDelayTaskPut (OS_TCB *pOsTcb)
void OsTimeDelay (INT16U Ticks)
void OsTimeEventListPut (OS_EVENT *pOsEvent)
INT8U OsTimeEventListDelete (OS_EVENT *pOsEvent)

Variables

OS_EVENT * OsTimeEventList
OS_TCB * OsTimeDelayList
OS_TIME_CONTROL OsTimeCtrl


Function Documentation

void OsTimeDelay ( INT16U  Ticks  ) 

Definition at line 121 of file os_time.c.

00121                               {
00122     OS_TCB *pOsTcb;
00123     
00124     #if(OS_TIME_EVENT_ENABLE==0)
00125         return;
00126     #endif      
00127     OS_ENTER_CRITICAL();
00128     if(Ticks==0){
00129         OS_EXIT_CRITICAL();
00130         return;    
00131     }     
00132     pOsTcb=(OS_TCB *)OSTCBCur;
00133     pOsTcb->Status=OS_TASK_PENDING;
00134     pOsTcb->PendingType=OS_PENDING_TIME;
00135     pOsTcb->TimeDelay=Ticks;         
00136     OsTimeDelayTaskPut(pOsTcb);    
00137     OsSchedulerRunNext();  
00138     OS_EXIT_CRITICAL();
00139 }

void OsTimeDelayTaskPut ( OS_TCB *  pOsTcb  ) 

Definition at line 107 of file os_time.c.

00107                                        {
00108     pOsTcb->Next=(OS_TCB *)0;
00109     pOsTcb->Prev=(OS_TCB *)0;
00110     if(OsTimeCtrl.EntryNumber==0){        
00111         OsTimeDelayList=pOsTcb;
00112         OsTimeCtrl.EntryNumber=1;
00113     }
00114     else{
00115         pOsTcb->Next=OsTimeDelayList;
00116         OsTimeDelayList->Prev=pOsTcb;
00117         OsTimeDelayList=pOsTcb;
00118         OsTimeCtrl.EntryNumber++;
00119     }
00120 }

INT8U OsTimeEventListDelete ( OS_EVENT *  pOsEvent  ) 

Definition at line 154 of file os_time.c.

00154                                                {
00155     OS_EVENT *pEvent;
00156 
00157     if(OsTimeEventList==(OS_EVENT *)0) return FALSE;
00158     pEvent=OsTimeEventList;
00159     while(pEvent!=(OS_EVENT *)0){        
00160         if(pOsEvent==pEvent){ // find event in list
00161             if(pEvent==OsTimeEventList){ // at list head
00162                 if(OsTimeEventList->Next==(OS_EVENT *)0){
00163                     OsTimeEventList=(OS_EVENT *)0;                    
00164                 }
00165                 else{
00166                     OsTimeEventList=OsTimeEventList->Next;
00167                     OsTimeEventList->Prev=(OS_EVENT *)0;               
00168                 }    
00169             }
00170             else if(pEvent->Next==(OS_EVENT *)0){ // at list tail
00171                 pEvent->Prev->Next=(OS_EVENT *)0;                        
00172             }
00173             else{ // at list middle
00174                 pEvent->Prev->Next=pEvent->Next;
00175                 pEvent->Next->Prev=pEvent->Prev;                      
00176             }
00177             OsTimeCtrl.EventListNumber--;
00178             //OsEventFreeEventPut(pOsEvent); // no do it here 
00179             return TRUE;
00180         }  
00181         else pEvent=pEvent->Next;
00182     }    
00183     return FALSE;
00184 }

void OsTimeEventListPut ( OS_EVENT *  pOsEvent  ) 

Definition at line 140 of file os_time.c.

00140                                            {
00141     pOsEvent->Next=(OS_EVENT *)0; // clear linking relation 
00142     pOsEvent->Prev=(OS_EVENT *)0; // clear linking relation
00143     if(OsTimeEventList==(OS_EVENT *)0){        
00144         OsTimeEventList=pOsEvent;
00145         OsTimeCtrl.EventListNumber=1;
00146     }
00147     else{
00148         pOsEvent->Next=OsTimeEventList;
00149         OsTimeEventList->Prev=pOsEvent;
00150         OsTimeEventList=pOsEvent;
00151         OsTimeCtrl.EventListNumber++;
00152     }
00153 }

void OsTimeInit ( void   ) 

Definition at line 25 of file os_time.c.

00025                      {
00026     OsTimeDelayList=(OS_TCB *)0;
00027     OsTimeEventList=(OS_EVENT *)0;
00028     OsTimeCtrl.EntryNumber=0;    
00029     OsTimeCtrl.EventListNumber=0;    
00030     OsTimeCtrl.Time=0;
00031 }

void OsTimeTickHandler ( void   ) 

Definition at line 32 of file os_time.c.

00032                             {
00033     OS_TCB *pTcb,*pTcb2,*pTaskListHead;
00034     OS_EVENT *pEvent;
00035     
00036     OsTimeCtrl.Time++;
00037     if(OsTimeDelayList==(OS_TCB *)0) return;
00038     pTcb=OsTimeDelayList;
00039     while(pTcb!=(OS_TCB *)0){  // scan time delay task list       
00040         if(pTcb->TimeDelay!=0) pTcb->TimeDelay--;
00041         if(pTcb->TimeDelay==0){
00042             pTcb2=pTcb;
00043             if(pTcb2==OsTimeDelayList){
00044                 if(OsTimeDelayList->Next==(OS_TCB *)0){
00045                     OsTimeDelayList=(OS_TCB *)0;
00046                     pTcb=(OS_TCB *)0; // no next task
00047                 }
00048                 else{
00049                     OsTimeDelayList=OsTimeDelayList->Next;
00050                     OsTimeDelayList->Prev=(OS_TCB *)0; 
00051                     pTcb=OsTimeDelayList; // next task is list head              
00052                 }    
00053             }
00054             else if(pTcb2->Next==(OS_TCB *)0){
00055                 pTcb2->Prev->Next=(OS_TCB *)0; 
00056                 pTcb=(OS_TCB *)0; // no next task                         
00057             } 
00058             else{
00059                 pTcb2->Prev->Next=pTcb2->Next;
00060                 pTcb2->Next->Prev=pTcb2->Prev; 
00061                 pTcb=pTcb2->Next;  // next task is next task                    
00062             }
00063             OsTimeCtrl.EntryNumber--;
00064             OsTaskReadyTaskPut(pTcb2); // task time out..become ready task again  
00065         }  
00066         else pTcb=pTcb->Next;
00067     }
00068     return;
00069     // scan event list to see if any pending task time out  
00070     pEvent=OsTimeEventList;  
00071     while(pEvent!=(OS_EVENT *)0){
00072         pTaskListHead=(OS_TCB *)pEvent->ListHead;
00073         pTcb=pTaskListHead;
00074         while(pTcb!=(OS_TCB *)0){
00075             if(pTcb->TimeDelay!=0) pTcb->TimeDelay--;
00076             if(pTcb->TimeDelay==0){
00077                 pTcb2=pTcb;
00078                 if(pTcb2==pTaskListHead){
00079                     if(pTaskListHead->Next==(OS_TCB *)0){
00080                         pEvent->ListHead=(INT32U *)0;
00081                         pTcb=(OS_TCB *)0; // no next task
00082                     }
00083                     else{
00084                         pEvent->ListHead=(INT32U *)pTaskListHead->Next;
00085                         pTaskListHead=pTaskListHead->Next;
00086                         pTaskListHead->Prev=(OS_TCB *)0; 
00087                         pTcb=pTaskListHead; // point to next TCB                     
00088                     }                
00089                 }            
00090                 else if(pTcb2->Next==(OS_TCB *)0){
00091                     pTcb2->Prev->Next=(OS_TCB *)0; 
00092                     pTcb=(OS_TCB *)0; // no next task                                        
00093                 }
00094                 else{
00095                     pTcb2->Prev->Next=pTcb2->Next;
00096                     pTcb2->Next->Prev=pTcb2->Prev; 
00097                     pTcb=pTcb2->Next;  // point to next TCB                                         
00098                 }                
00099                 pEvent->EntryNumber--;
00100                 OsTaskReadyTaskPut(pTcb2); // task time out..become ready task again
00101             }
00102             else pTcb=pTcb->Next;     // point to next TCB  
00103         } 
00104         pEvent=pEvent->Next;   
00105     }
00106 }


Variable Documentation

OS_TIME_CONTROL OsTimeCtrl

Definition at line 16 of file os_time.c.

OS_TCB* OsTimeDelayList

Definition at line 15 of file os_time.c.

OS_EVENT* OsTimeEventList

Definition at line 14 of file os_time.c.


Generated on Tue Sep 2 08:45:42 2008 for A Simple operation System using S3C2410 by  doxygen 1.5.6