os_task.h File Reference

Go to the source code of this file.

Data Structures

struct  OS_TASK_CONTROL

Defines

#define OS_TASK_FREE   0
#define OS_TASK_READY   1
#define OS_TASK_PENDING   2
#define OS_TASK_SUSPEND   3
#define OS_TASK_EXECUTION   4
#define OS_TOTAL_TASK_NUMBER   10
#define OS_TASK_PRIORITY_MAX   10

Functions

void OsTaskInit (void)
bool OsTaskCreat (void(*pTask)(void), OS_STACK *pStack, U8 *pTaskName, U8 Priority)
OS_TASKENTRY * OsTaskFreeTaskGet (void)
void OsTaskFreeTaskPut (OS_TASKENTRY *pOsTcb)
U8 OsTaskReadyListCheck (U8 Priority)
void OsTaskReadyTaskPut (OS_TASKENTRY *pOsTcb)
OS_TASKENTRY * OsTaskReadyTaskGet (U8 Priority)
OS_BOOL OsTaskReadyTaskDelete (U8 *pTaskName)
OS_STACK * OsTaskStackInit (void(*Task)(void), OS_STACK *pStack)
void OsTaskFinish (void)

Variables

OS_TASKENTRY * TaskFreeList
OS_TASKENTRY * TaskSuspendList
OS_TASK_CONTROL OsTaskCtrl

Define Documentation

#define OS_TASK_EXECUTION   4

Definition at line 8 of file os_task.h.

#define OS_TASK_FREE   0

Definition at line 4 of file os_task.h.

#define OS_TASK_PENDING   2

Definition at line 6 of file os_task.h.

#define OS_TASK_PRIORITY_MAX   10

Definition at line 11 of file os_task.h.

#define OS_TASK_READY   1

Definition at line 5 of file os_task.h.

#define OS_TASK_SUSPEND   3

Definition at line 7 of file os_task.h.

#define OS_TOTAL_TASK_NUMBER   10

Definition at line 10 of file os_task.h.

Function Documentation

bool OsTaskCreat ( void(*)(void)  pTask,
OS_STACK *  pStack,
U8 *  pTaskName,
U8  Priority 
)

Definition at line 60 of file os_task.c.

00060                                                                                    {
00061     OS_TASKENTRY *pOsTask;
00062     U8 i;
00063     #if(OS_CRITICAL_METHOD==3)
00064         U32 CpuEflags;
00065     #endif
00066 
00067     OsEnterCritical();
00068     pOsTask=OsTaskFreeTaskGet();
00069     if(pOsTask==(OS_TASKENTRY *)OS_NULL) return OS_FALSE; 
00070     pOsTask->Id=0;    
00071     if(Priority<OS_TASK_PRIORITY_MAX) pOsTask->Priority=Priority;
00072     else pOsTask->Priority=0;
00073     pOsTask->pTask=pTask;
00074     pOsTask->TimeDelay=0;
00075     pOsTask->pStack=OsTaskStackInit(pTask,pStack);   
00076     for(i=0;i<16;i++) pOsTask->Name[i]=0;
00077     if(pTaskName==(U8 *)OS_NULL) OsLibStringCopy(&pOsTask->Name,OsUnkown);
00078     else OsLibStringCopy(&pOsTask->Name,pTaskName);
00079     OsTaskReadyTaskPut(pOsTask);
00080     OsExitCritical();
00081     return OS_TRUE;
00082 }

void OsTaskFinish ( void   ) 

Definition at line 237 of file os_task.c.

00237                        {
00238     OsFinish();
00239     while(1);
00240 }

OS_TASKENTRY* OsTaskFreeTaskGet ( void   ) 

Definition at line 107 of file os_task.c.

00107                                      {
00108     OS_TASKENTRY *pOsTask;
00109     
00110     if(OsTaskCtrl.FreeList==(OS_TASKENTRY *)OS_NULL) return (OS_TASKENTRY *)OS_NULL;  
00111     pOsTask=OsTaskCtrl.FreeList;
00112     OsTaskCtrl.FreeList=OsTaskCtrl.FreeList->Next;
00113     OsTaskCtrl.FreeList->Prev=(OS_TASKENTRY *)OS_NULL;  
00114     return pOsTask;
00115 }

void OsTaskFreeTaskPut ( OS_TASKENTRY *  pOsTcb  ) 

Definition at line 84 of file os_task.c.

00084                                            {
00085     if(pTask==(OS_TASKENTRY *)OS_NULL) return;
00086     pTask->Status=OS_TASK_FREE;
00087     pTask->PendingType=OS_PENDING_NONE;
00088     pTask->Priority=0;
00089     pTask->WeightedPriority=0;
00090     pTask->PendingType=0; 
00091     pTask->TimeDelay=0;        
00092     if(OsTaskCtrl.FreeList==(OS_TASKENTRY *)OS_NULL){
00093         pTask->Status=OS_TASK_FREE;
00094         OsTaskCtrl.FreeList=pTask;
00095         OsTaskCtrl.FreeList->Prev=(OS_TASKENTRY *)OS_NULL;        
00096         OsTaskCtrl.FreeList->Next=(OS_TASKENTRY *)OS_NULL;
00097     } 
00098     else{
00099         pTask->Status=OS_TASK_FREE;
00100         OsTaskCtrl.FreeList->Prev=pTask;
00101         pTask->Next=OsTaskCtrl.FreeList;          
00102         pTask->Prev=(OS_TASKENTRY *)OS_NULL;    
00103         OsTaskCtrl.FreeList=pTask; 
00104     }    
00105 }

void OsTaskInit ( void   ) 

Definition at line 19 of file os_task.c.

00019                      {
00020     U32 i; 
00021     
00022     OsTaskCtrl.Status=0;
00023     OsTaskCtrl.FreeTaskNumber=0;
00024     OsTaskCtrl.FreeList=(OS_TASKENTRY *)OS_NULL;
00025     for(i=0;i<OS_TOTAL_TASK_NUMBER;i++){
00026         OsTaskCtrl.ReadyListHead[i]=(OS_TASKENTRY *)OS_NULL;
00027         OsTaskCtrl.ReadyListTail[i]=(OS_TASKENTRY *)OS_NULL;
00028         OsTaskCtrl.ReadyListTaskNumber[i]=0;
00029     }
00030     for(i=0;i<OS_TOTAL_TASK_NUMBER;i++){
00031         OsTask[i].Id=0;
00032         OsTask[i].Status=OS_TASK_FREE;  
00033         OsTask[i].Priority=0;
00034         OsTask[i].WeightedPriority=0;
00035         OsTask[i].PendingType=0;
00036         OsTask[i].TimeDelay=0;
00037         OsTask[i].Prev=(OS_TASKENTRY *)OS_NULL;           
00038         OsTask[i].Next=(OS_TASKENTRY *)OS_NULL;
00039         OsTaskFreeTaskPut(&OsTask[i]);
00040     }                                    
00041 }

U8 OsTaskReadyListCheck ( U8  Priority  ) 

OS_BOOL OsTaskReadyTaskDelete ( U8 *  pTaskName  ) 

Definition at line 191 of file os_task.c.

00191                                             {
00192     OS_TASKENTRY **pListHead;
00193     OS_TASKENTRY **pListTail;
00194     OS_TASKENTRY *pHead;
00195     OS_TASKENTRY *pTail;
00196     OS_TASKENTRY *pOsTask;
00197     U8 i;
00198 
00199     for(i=0;i<OS_TASK_PRIORITY_MAX;i++){
00200         pHead=OsTaskCtrl.ReadyListHead[i];     
00201         pTail=OsTaskCtrl.ReadyListTail[i];   
00202         pListHead=&OsTaskCtrl.ReadyListHead[i];
00203         pListTail=&OsTaskCtrl.ReadyListTail[i];
00204         pOsTask=pHead;
00205         while(pOsTask!=(OS_TASKENTRY *)OS_NULL){
00206             if(OsLibStringCompare((U8 *)pOsTask->Name,pTaskName)==OS_TRUE){
00207                 if(pOsTask==pHead){
00208                     if(pOsTask==pTail){
00209                         *pListHead=(OS_TASKENTRY *)OS_NULL;
00210                         *pListTail=(OS_TASKENTRY *)OS_NULL;
00211                         OsTaskFreeTaskPut(pOsTask);
00212                     }
00213                     else{
00214                         pOsTask->Next->Prev=(OS_TASKENTRY *)OS_NULL;
00215                         *pListHead=(U32 *)pOsTask->Next;
00216                         OsTaskFreeTaskPut(pOsTask);
00217                     }
00218                 }
00219                 else if(pOsTask==pTail){
00220                         pOsTask->Prev->Next=(OS_TASKENTRY *)OS_NULL;
00221                         *pListTail=(U32 *)pOsTask->Prev;
00222                         OsTaskFreeTaskPut(pOsTask);
00223                 }
00224                 else{
00225                     pOsTask->Prev->Next=pOsTask->Next;
00226                     pOsTask->Next->Prev=pOsTask->Prev;
00227                     OsTaskFreeTaskPut(pOsTask);
00228                 }
00229                 return OS_TRUE; 
00230             }
00231             else pOsTask=pOsTask->Next;
00232         }
00233     }
00234     return OS_FALSE;    
00235 }

OS_TASKENTRY* OsTaskReadyTaskGet ( U8  Priority  ) 

Definition at line 147 of file os_task.c.

00147                                              {         // get a task OS_TASKENTRY from task list 
00148     OS_TASKENTRY **pListHead;
00149     OS_TASKENTRY **pListTail;
00150     OS_TASKENTRY *pHead;
00151     OS_TASKENTRY *pTail;
00152     OS_TASKENTRY *pOsTask;
00153 
00154     if(Priority>=OS_TASK_PRIORITY_MAX) return (OS_TASKENTRY *)OS_NULL;
00155     pHead=OsTaskCtrl.ReadyListHead[Priority];        
00156     if(pHead==(OS_TASKENTRY *)OS_NULL) return (OS_TASKENTRY *)OS_NULL;
00157     pListHead=&OsTaskCtrl.ReadyListHead[Priority];
00158     pListTail=&OsTaskCtrl.ReadyListTail[Priority];
00159     pTail=OsTaskCtrl.ReadyListTail[Priority];
00160     if(pHead==pTail){
00161         pOsTask=pHead;
00162         *pListHead=(OS_TASKENTRY *)OS_NULL;
00163         *pListTail=(OS_TASKENTRY *)OS_NULL;
00164     }
00165     else{
00166         pOsTask=pHead;
00167         pHead=pHead->Next;
00168         pHead->Prev=(OS_TASKENTRY *)OS_NULL;
00169         *pListHead=pHead;
00170     }    
00171     pOsTask->Next=(OS_TASKENTRY *)OS_NULL;        
00172     pOsTask->Prev=(OS_TASKENTRY *)OS_NULL;
00173     return pOsTask;
00174 }

void OsTaskReadyTaskPut ( OS_TASKENTRY *  pOsTcb  ) 

Definition at line 117 of file os_task.c.

00117                                             {
00118     U8  Priority;    
00119     OS_TASKENTRY **pListHead;
00120     OS_TASKENTRY **pListTail;
00121     OS_TASKENTRY *pHead;
00122     OS_TASKENTRY *pTail;
00123     
00124     if(pTask==(OS_TASKENTRY *)OS_NULL) return;
00125     if(pTask->Priority>=OS_TASK_PRIORITY_MAX) return;  // no support priority level
00126     pTask->Next=(OS_TASKENTRY *)OS_NULL;               // clean linking relationship        
00127     pTask->Prev=(OS_TASKENTRY *)OS_NULL;               // clean linking relationship       
00128     pTask->Status=OS_TASK_READY;                       // task status ready for run
00129     pTask->PendingType=OS_PENDING_NONE;                // reset pending type
00130     pTask->TimeDelay=0;                                // reset delay timer 
00131     Priority=pTask->Priority;                          // get task priority  
00132     pListHead=&OsTaskCtrl.ReadyListHead[Priority];     // get task list head related to priority
00133     pListTail=&OsTaskCtrl.ReadyListTail[Priority];     // get task list head related to priority
00134     pHead=OsTaskCtrl.ReadyListHead[Priority];          // get head OS_TASKENTRY
00135     pTail=OsTaskCtrl.ReadyListTail[Priority];          // get tail OS_TASKENTRY
00136     if(pHead==(OS_TASKENTRY *)OS_NULL){                // if list is empty, add task OS_TASKENTRY to list head
00137         *pListHead=pTask;      
00138         *pListTail=pTask;    
00139     }
00140     else{                                              // if list is not empty, add task OS_TASKENTRY to list head
00141         pTask->Prev=pTail;
00142         pTail->Next=pTask;
00143         *pListTail=pTask;
00144     }
00145 }

OS_STACK* OsTaskStackInit ( void(*)(void)  Task,
OS_STACK *  pStack 
)

Definition at line 43 of file os_task.c.

00043                                                               {
00044     pStack--;                    // avoid stack boundary
00045     *pStack--=(U32)OsTaskFinish; // avoid return in task
00046     *pStack--=0x1202;            //eflags IOPL=1,IF=1,bit2 is always 1
00047     *pStack--=(U32)TASK_CS*8;    //cs  set code segment selector
00048     *pStack--=(U32)Task;         //eip
00049     *pStack--=0x8;            //eax
00050     *pStack--=0x7;            //ecx
00051     *pStack--=0x6;            //edx
00052     *pStack--=0x5;            //ebx
00053     *pStack--=0x4;            //esp
00054     *pStack--=0x3;            //ebp
00055     *pStack--=0x2;            //esi
00056     *pStack=0x1;              //edi
00057     return pStack;
00058 }

Variable Documentation

OS_TASK_CONTROL OsTaskCtrl

Definition at line 17 of file os_task.c.

OS_TASKENTRY* TaskFreeList

OS_TASKENTRY* TaskSuspendList

Generated on Sat Apr 10 23:28:08 2010 for 80X86 MULTI-TASKING OPERATION SYSTEM by  doxygen 1.5.9