开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
OS_CORE.C
资源名称：ucosii2.52forlpc2366.rar　[点击查看]
上传用户：ssllxx2007
上传日期：2022-06-12
资源大小：784k
文件大小：49k
源码类别：

uCOS

开发平台：

C/C++

OS_CORE.C：源码内容
  1. /*
  2. *********************************************************************************************************
  3. *                                                uC/OS-II
  4. *                                          The Real-Time Kernel
  5. *                                             CORE FUNCTIONS
  6. *
  7. *                          (c) Copyright 1992-2002, Jean J. Labrosse, Weston, FL
  8. *                                           All Rights Reserved
  9. *
  10. * File : OS_CORE.C
  11. * By   : Jean J. Labrosse
  12. *********************************************************************************************************
  13. */
  15. #ifndef  OS_MASTER_FILE
  16. #define  OS_GLOBALS
  17. #include "..APPincludes.h"
  18. #endif
  20. /*
  21. *********************************************************************************************************
  22. *                              MAPPING TABLE TO MAP BIT POSITION TO BIT MASK
  23. *
  24. * Note: Index into table is desired bit position, 0..7
  25. *       Indexed value corresponds to bit mask
  26. *********************************************************************************************************
  27. */
  29. INT8U  const  OSMapTbl[]   = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
  31. /*
  32. *********************************************************************************************************
  33. *                                       PRIORITY RESOLUTION TABLE
  34. *
  35. * Note: Index into table is bit pattern to resolve highest priority
  36. *       Indexed value corresponds to highest priority bit position (i.e. 0..7)
  37. *********************************************************************************************************
  38. */
  40. INT8U  const  OSUnMapTbl[] = {
  41.     0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x00 to 0x0F                             */
  42.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x10 to 0x1F                             */
  43.     5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x20 to 0x2F                             */
  44.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x30 to 0x3F                             */
  45.     6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x40 to 0x4F                             */
  46.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x50 to 0x5F                             */
  47.     5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x60 to 0x6F                             */
  48.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x70 to 0x7F                             */
  49.     7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x80 to 0x8F                             */
  50.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x90 to 0x9F                             */
  51.     5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xA0 to 0xAF                             */
  52.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xB0 to 0xBF                             */
  53.     6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xC0 to 0xCF                             */
  54.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xD0 to 0xDF                             */
  55.     5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xE0 to 0xEF                             */
  56.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0        /* 0xF0 to 0xFF                             */
  57. };
  59. /*
  60. *********************************************************************************************************
  61. *                                       FUNCTION PROTOTYPES
  62. *********************************************************************************************************
  63. */
  64. static  void  OS_InitEventList(void);
  65. static  void  OS_InitMisc(void);
  66. static  void  OS_InitRdyList(void);
  67. static  void  OS_InitTaskIdle(void);
  68. static  void  OS_InitTaskStat(void);
  69. static  void  OS_InitTCBList(void);
  71. /*$PAGE*/
  72. /*
  73. *********************************************************************************************************
  74. *                                             INITIALIZATION
  75. *
  76. * Description: This function is used to initialize the internals of uC/OS-II and MUST be called prior to
  77. *              creating any uC/OS-II object and, prior to calling OSStart().
  78. *
  79. * Arguments  : none
  80. *
  81. * Returns    : none
  82. *********************************************************************************************************
  83. */
  85. void  OSInit (void)
  86. {
  87. #if OS_VERSION >= 204
  88.     OSInitHookBegin();                                           /* Call port specific initialization code   */
  89. #endif
  91.     OS_InitMisc();                                               /* Initialize miscellaneous variables       */
  93.     OS_InitRdyList();                                            /* Initialize the Ready List                */
  94.     OS_InitTCBList();                                            /* Initialize the free list of OS_TCBs      */
  95.     OS_InitEventList();                                          /* Initialize the free list of OS_EVENTs    */
  97. #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
  98.     OS_FlagInit();                                               /* Initialize the event flag structures     */
  99. #endif
  101. #if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
  102.     OS_MemInit();                                                /* Initialize the memory manager            */
  103. #endif
  105. #if (OS_Q_EN > 0) && (OS_MAX_QS > 0)
  106.     OS_QInit();                                                  /* Initialize the message queue structures  */
  107. #endif
  109.     OS_InitTaskIdle();                                           /* Create the Idle Task                     */
  110. #if OS_TASK_STAT_EN > 0
  111.     OS_InitTaskStat();                                           /* Create the Statistic Task                */
  112. #endif
  114. #if OS_VERSION >= 204
  115.     OSInitHookEnd();                                             /* Call port specific init. code            */
  116. #endif
  117. }
  118. /*$PAGE*/
  119. /*
  120. *********************************************************************************************************
  121. *                                              ENTER ISR
  122. *
  123. * Description: This function is used to notify uC/OS-II that you are about to service an interrupt
  124. *              service routine (ISR).  This allows uC/OS-II to keep track of interrupt nesting and thus
  125. *              only perform rescheduling at the last nested ISR.
  126. *
  127. * Arguments  : none
  128. *
  129. * Returns    : none
  130. *
  131. * Notes      : 1) This function should be called ith interrupts already disabled
  132. *              2) Your ISR can directly increment OSIntNesting without calling this function because
  133. *                 OSIntNesting has been declared 'global'.  
  134. *              3) You MUST still call OSIntExit() even though you increment OSIntNesting directly.
  135. *              4) You MUST invoke OSIntEnter() and OSIntExit() in pair.  In other words, for every call
  136. *                 to OSIntEnter() at the beginning of the ISR you MUST have a call to OSIntExit() at the
  137. *                 end of the ISR.
  138. *              5) You are allowed to nest interrupts up to 255 levels deep.
  139. *              6) I removed the OS_ENTER_CRITICAL() and OS_EXIT_CRITICAL() around the increment because
  140. *                 OSIntEnter() is always called with interrupts disabled.
  141. *********************************************************************************************************
  142. */
  144. void  OSIntEnter (void)
  145. {
  146.     if (OSRunning == TRUE) {
  147.         if (OSIntNesting < 255) {
  148.             OSIntNesting++;                      /* Increment ISR nesting level                        */
  149.         }
  150.     }
  151. }
  152. /*$PAGE*/
  153. /*
  154. *********************************************************************************************************
  155. *                                               EXIT ISR
  156. *
  157. * Description: This function is used to notify uC/OS-II that you have completed serviving an ISR.  When
  158. *              the last nested ISR has completed, uC/OS-II will call the scheduler to determine whether
  159. *              a new, high-priority task, is ready to run.
  160. *
  161. * Arguments  : none
  162. *
  163. * Returns    : none
  164. *
  165. * Notes      : 1) You MUST invoke OSIntEnter() and OSIntExit() in pair.  In other words, for every call
  166. *                 to OSIntEnter() at the beginning of the ISR you MUST have a call to OSIntExit() at the
  167. *                 end of the ISR.
  168. *              2) Rescheduling is prevented when the scheduler is locked (see OS_SchedLock())
  169. *********************************************************************************************************
  170. */
  172. void  OSIntExit (void)
  173. {
  174. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  175.     OS_CPU_SR  cpu_sr;
  176. #endif
  177.     
  178.     
  179.     if (OSRunning == TRUE) {
  180.         OS_ENTER_CRITICAL();
  181.         if (OSIntNesting > 0) {                            /* Prevent OSIntNesting from wrapping       */
  182.             OSIntNesting--;
  183.         }
  184.         if ((OSIntNesting == 0) && (OSLockNesting == 0)) { /* Reschedule only if all ISRs complete ... */
  185.             OSIntExitY    = OSUnMapTbl[OSRdyGrp];          /* ... and not locked.                      */
  186.             OSPrioHighRdy = (INT8U)((OSIntExitY << 3) + OSUnMapTbl[OSRdyTbl[OSIntExitY]]);
  187.             if (OSPrioHighRdy != OSPrioCur) {              /* No Ctx Sw if current task is highest rdy */
  188.                 OSTCBHighRdy  = OSTCBPrioTbl[OSPrioHighRdy];
  189.                 OSCtxSwCtr++;                              /* Keep track of the number of ctx switches */
  190.                 OSIntCtxSw();                              /* Perform interrupt level ctx switch       */
  191.             }
  192.         }
  193.         OS_EXIT_CRITICAL();
  194.     }
  195. }
  196. /*$PAGE*/
  197. /*
  198. *********************************************************************************************************
  199. *                                          PREVENT SCHEDULING
  200. *
  201. * Description: This function is used to prevent rescheduling to take place.  This allows your application
  202. *              to prevent context switches until you are ready to permit context switching.
  203. *
  204. * Arguments  : none
  205. *
  206. * Returns    : none
  207. *
  208. * Notes      : 1) You MUST invoke OSSchedLock() and OSSchedUnlock() in pair.  In other words, for every
  209. *                 call to OSSchedLock() you MUST have a call to OSSchedUnlock().
  210. *********************************************************************************************************
  211. */
  213. #if OS_SCHED_LOCK_EN > 0
  214. void  OSSchedLock (void)
  215. {
  216. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  217.     OS_CPU_SR  cpu_sr;
  218. #endif    
  219.     
  220.     
  221.     if (OSRunning == TRUE) {                     /* Make sure multitasking is running                  */
  222.         OS_ENTER_CRITICAL();
  223.         if (OSLockNesting < 255) {               /* Prevent OSLockNesting from wrapping back to 0      */
  224.             OSLockNesting++;                     /* Increment lock nesting level                       */
  225.         }
  226.         OS_EXIT_CRITICAL();
  227.     }
  228. }
  229. #endif    
  231. /*$PAGE*/
  232. /*
  233. *********************************************************************************************************
  234. *                                          ENABLE SCHEDULING
  235. *
  236. * Description: This function is used to re-allow rescheduling.
  237. *
  238. * Arguments  : none
  239. *
  240. * Returns    : none
  241. *
  242. * Notes      : 1) You MUST invoke OSSchedLock() and OSSchedUnlock() in pair.  In other words, for every
  243. *                 call to OSSchedLock() you MUST have a call to OSSchedUnlock().
  244. *********************************************************************************************************
  245. */
  247. #if OS_SCHED_LOCK_EN > 0
  248. void  OSSchedUnlock (void)
  249. {
  250. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  251.     OS_CPU_SR  cpu_sr;
  252. #endif    
  253.     
  254.     
  255.     if (OSRunning == TRUE) {                                   /* Make sure multitasking is running    */
  256.         OS_ENTER_CRITICAL();
  257.         if (OSLockNesting > 0) {                               /* Do not decrement if already 0        */
  258.             OSLockNesting--;                                   /* Decrement lock nesting level         */
  259.             if ((OSLockNesting == 0) && (OSIntNesting == 0)) { /* See if sched. enabled and not an ISR */
  260.                 OS_EXIT_CRITICAL();
  261.                 OS_Sched();                                    /* See if a HPT is ready                */
  262.             } else {
  263.                 OS_EXIT_CRITICAL();
  264.             }
  265.         } else {
  266.             OS_EXIT_CRITICAL();
  267.         }
  268.     }
  269. }
  270. #endif    
  272. /*$PAGE*/
  273. /*
  274. *********************************************************************************************************
  275. *                                          START MULTITASKING
  276. *
  277. * Description: This function is used to start the multitasking process which lets uC/OS-II manages the
  278. *              task that you have created.  Before you can call OSStart(), you MUST have called OSInit()
  279. *              and you MUST have created at least one task.
  280. *
  281. * Arguments  : none
  282. *
  283. * Returns    : none
  284. *
  285. * Note       : OSStartHighRdy() MUST:
  286. *                 a) Call OSTaskSwHook() then,
  287. *                 b) Set OSRunning to TRUE.
  288. *                 c) Load the context of the task pointed to by OSTCBHighRdy.
  289. *                 d_ Execute the task.
  290. *********************************************************************************************************
  291. */
  293. void  OSStart (void)
  294. {
  295.     INT8U y;
  296.     INT8U x;
  299.     if (OSRunning == FALSE) {
  300.         y             = OSUnMapTbl[OSRdyGrp];        /* Find highest priority's task priority number   */
  301.         x             = OSUnMapTbl[OSRdyTbl[y]];
  302.         OSPrioHighRdy = (INT8U)((y << 3) + x);
  303.         OSPrioCur     = OSPrioHighRdy;
  304.         OSTCBHighRdy  = OSTCBPrioTbl[OSPrioHighRdy]; /* Point to highest priority task ready to run    */
  305.         OSTCBCur      = OSTCBHighRdy;
  306.         OSStartHighRdy();                            /* Execute target specific code to start task     */
  307.     }
  308. }
  309. /*$PAGE*/
  310. /*
  311. *********************************************************************************************************
  312. *                                        STATISTICS INITIALIZATION
  313. *
  314. * Description: This function is called by your application to establish CPU usage by first determining
  315. *              how high a 32-bit counter would count to in 1 second if no other tasks were to execute
  316. *              during that time.  CPU usage is then determined by a low priority task which keeps track
  317. *              of this 32-bit counter every second but this time, with other tasks running.  CPU usage is
  318. *              determined by:
  319. *
  320. *                                             OSIdleCtr
  321. *                 CPU Usage (%) = 100 * (1 - ------------)
  322. *                                            OSIdleCtrMax
  323. *
  324. * Arguments  : none
  325. *
  326. * Returns    : none
  327. *********************************************************************************************************
  328. */
  330. #if OS_TASK_STAT_EN > 0
  331. void  OSStatInit (void)
  332. {
  333. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  334.     OS_CPU_SR  cpu_sr;
  335. #endif    
  336.     
  337.     
  338.     OSTimeDly(2);                                /* Synchronize with clock tick                        */
  339.     OS_ENTER_CRITICAL();
  340.     OSIdleCtr    = 0L;                           /* Clear idle counter                                 */
  341.     OS_EXIT_CRITICAL();
  342.     OSTimeDly(OS_TICKS_PER_SEC);                 /* Determine MAX. idle counter value for 1 second     */
  343.     OS_ENTER_CRITICAL();
  344.     OSIdleCtrMax = OSIdleCtr;                    /* Store maximum idle counter count in 1 second       */
  345.     OSStatRdy    = TRUE;
  346.     OS_EXIT_CRITICAL();
  347. }
  348. #endif
  349. /*$PAGE*/
  350. /*
  351. *********************************************************************************************************
  352. *                                         PROCESS SYSTEM TICK
  353. *
  354. * Description: This function is used to signal to uC/OS-II the occurrence of a 'system tick' (also known
  355. *              as a 'clock tick').  This function should be called by the ticker ISR but, can also be
  356. *              called by a high priority task.
  357. *
  358. * Arguments  : none
  359. *
  360. * Returns    : none
  361. *********************************************************************************************************
  362. */
  364. void  OSTimeTick (void)
  365. {
  366. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  367.     OS_CPU_SR  cpu_sr;
  368. #endif    
  369.     OS_TCB    *ptcb;
  372.     OSTimeTickHook();                                      /* Call user definable hook                 */
  373. #if OS_TIME_GET_SET_EN > 0   
  374.     OS_ENTER_CRITICAL();                                   /* Update the 32-bit tick counter           */
  375.     OSTime++;
  376.     OS_EXIT_CRITICAL();
  377. #endif
  378.     if (OSRunning == TRUE) {    
  379.         ptcb = OSTCBList;                                  /* Point at first TCB in TCB list           */
  380.         while (ptcb->OSTCBPrio != OS_IDLE_PRIO) {          /* Go through all TCBs in TCB list          */
  381.             OS_ENTER_CRITICAL();
  382.             if (ptcb->OSTCBDly != 0) {                     /* Delayed or waiting for event with TO     */
  383.                 if (--ptcb->OSTCBDly == 0) {               /* Decrement nbr of ticks to end of delay   */
  384.                     if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) { /* Is task suspended?    */
  385.                         OSRdyGrp               |= ptcb->OSTCBBitY; /* No,  Make task R-to-R (timed out)*/
  386.                         OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
  387.                     } else {                               /* Yes, Leave 1 tick to prevent ...         */
  388.                         ptcb->OSTCBDly = 1;                /* ... loosing the task when the ...        */
  389.                     }                                      /* ... suspension is removed.               */
  390.                 }
  391.             }
  392.             ptcb = ptcb->OSTCBNext;                        /* Point at next TCB in TCB list            */
  393.             OS_EXIT_CRITICAL();
  394.         }
  395.     }
  396. }
  397. /*$PAGE*/
  398. /*
  399. *********************************************************************************************************
  400. *                                             GET VERSION
  401. *
  402. * Description: This function is used to return the version number of uC/OS-II.  The returned value
  403. *              corresponds to uC/OS-II's version number multiplied by 100.  In other words, version 2.00
  404. *              would be returned as 200.
  405. *
  406. * Arguments  : none
  407. *
  408. * Returns    : the version number of uC/OS-II multiplied by 100.
  409. *********************************************************************************************************
  410. */
  412. INT16U  OSVersion (void)
  413. {
  414.     return (OS_VERSION);
  415. }
  417. /*$PAGE*/
  418. /*
  419. *********************************************************************************************************
  420. *                                            DUMMY FUNCTION
  421. *
  422. * Description: This function doesn't do anything.  It is called by OSTaskDel().
  423. *
  424. * Arguments  : none
  425. *
  426. * Returns    : none
  427. *********************************************************************************************************
  428. */
  430. #if OS_TASK_DEL_EN > 0
  431. void  OS_Dummy (void)
  432. {
  433. }
  434. #endif
  436. /*$PAGE*/
  437. /*
  438. *********************************************************************************************************
  439. *                             MAKE TASK READY TO RUN BASED ON EVENT OCCURING
  440. *
  441. * Description: This function is called by other uC/OS-II services and is used to ready a task that was
  442. *              waiting for an event to occur.
  443. *
  444. * Arguments  : pevent    is a pointer to the event control block corresponding to the event.
  445. *
  446. *              msg       is a pointer to a message.  This pointer is used by message oriented services
  447. *                        such as MAILBOXEs and QUEUEs.  The pointer is not used when called by other
  448. *                        service functions.
  449. *
  450. *              msk       is a mask that is used to clear the status byte of the TCB.  For example,
  451. *                        OSSemPost() will pass OS_STAT_SEM, OSMboxPost() will pass OS_STAT_MBOX etc.
  452. *
  453. * Returns    : none
  454. *
  455. * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
  456. *********************************************************************************************************
  457. */
  458. #if OS_EVENT_EN > 0
  459. INT8U  OS_EventTaskRdy (OS_EVENT *pevent, void *msg, INT8U msk)
  460. {
  461.     OS_TCB *ptcb;
  462.     INT8U   x;
  463.     INT8U   y;
  464.     INT8U   bitx;
  465.     INT8U   bity;
  466.     INT8U   prio;
  469.     y    = OSUnMapTbl[pevent->OSEventGrp];            /* Find highest prio. task waiting for message   */
  470.     bity = OSMapTbl[y];
  471.     x    = OSUnMapTbl[pevent->OSEventTbl[y]];
  472.     bitx = OSMapTbl[x];
  473.     prio = (INT8U)((y << 3) + x);                     /* Find priority of task getting the msg         */
  474.     if ((pevent->OSEventTbl[y] &= ~bitx) == 0x00) {   /* Remove this task from the waiting list        */
  475.         pevent->OSEventGrp &= ~bity;                  /* Clr group bit if this was only task pending   */
  476.     }
  477.     ptcb                 =  OSTCBPrioTbl[prio];       /* Point to this task's OS_TCB                   */
  478.     ptcb->OSTCBDly       =  0;                        /* Prevent OSTimeTick() from readying task       */
  479.     ptcb->OSTCBEventPtr  = (OS_EVENT *)0;             /* Unlink ECB from this task                     */
  480. #if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0)
  481.     ptcb->OSTCBMsg       = msg;                       /* Send message directly to waiting task         */
  482. #else
  483.     msg                  = msg;                       /* Prevent compiler warning if not used          */
  484. #endif
  485.     ptcb->OSTCBStat     &= ~msk;                      /* Clear bit associated with event type          */
  486.     if (ptcb->OSTCBStat == OS_STAT_RDY) {             /* See if task is ready (could be susp'd)        */
  487.         OSRdyGrp        |=  bity;                     /* Put task in the ready to run list             */
  488.         OSRdyTbl[y]     |=  bitx;
  489.     }
  490.     return (prio);
  491. }
  492. #endif
  493. /*$PAGE*/
  494. /*
  495. *********************************************************************************************************
  496. *                                   MAKE TASK WAIT FOR EVENT TO OCCUR
  497. *
  498. * Description: This function is called by other uC/OS-II services to suspend a task because an event has
  499. *              not occurred.
  500. *
  501. * Arguments  : pevent   is a pointer to the event control block for which the task will be waiting for.
  502. *
  503. * Returns    : none
  504. *
  505. * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
  506. *********************************************************************************************************
  507. */
  508. #if OS_EVENT_EN > 0
  509. void  OS_EventTaskWait (OS_EVENT *pevent)
  510. {
  511.     OSTCBCur->OSTCBEventPtr = pevent;            /* Store pointer to event control block in TCB        */
  512.     if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0x00) {   /* Task no longer ready      */
  513.         OSRdyGrp &= ~OSTCBCur->OSTCBBitY;        /* Clear event grp bit if this was only task pending  */
  514.     }
  515.     pevent->OSEventTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;          /* Put task in waiting list  */
  516.     pevent->OSEventGrp                   |= OSTCBCur->OSTCBBitY;
  517. }
  518. #endif
  519. /*$PAGE*/
  520. /*
  521. *********************************************************************************************************
  522. *                              MAKE TASK READY TO RUN BASED ON EVENT TIMEOUT
  523. *
  524. * Description: This function is called by other uC/OS-II services to make a task ready to run because a
  525. *              timeout occurred.
  526. *
  527. * Arguments  : pevent   is a pointer to the event control block which is readying a task.
  528. *
  529. * Returns    : none
  530. *
  531. * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
  532. *********************************************************************************************************
  533. */
  534. #if OS_EVENT_EN > 0
  535. void  OS_EventTO (OS_EVENT *pevent)
  536. {
  537.     if ((pevent->OSEventTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0x00) {
  538.         pevent->OSEventGrp &= ~OSTCBCur->OSTCBBitY;
  539.     }
  540.     OSTCBCur->OSTCBStat     = OS_STAT_RDY;       /* Set status to ready                                */
  541.     OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;     /* No longer waiting for event                        */
  542. }
  543. #endif
  544. /*$PAGE*/
  545. /*
  546. *********************************************************************************************************
  547. *                                 INITIALIZE EVENT CONTROL BLOCK'S WAIT LIST
  548. *
  549. * Description: This function is called by other uC/OS-II services to initialize the event wait list.
  550. *
  551. * Arguments  : pevent    is a pointer to the event control block allocated to the event.
  552. *
  553. * Returns    : none
  554. *
  555. * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
  556. *********************************************************************************************************
  557. */
  558. #if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0) || (OS_SEM_EN > 0) || (OS_MUTEX_EN > 0)
  559. void  OS_EventWaitListInit (OS_EVENT *pevent)
  560. {
  561.     INT8U  *ptbl;
  564.     pevent->OSEventGrp = 0x00;                   /* No task waiting on event                           */
  565.     ptbl               = &pevent->OSEventTbl[0];
  567. #if OS_EVENT_TBL_SIZE > 0
  568.     *ptbl++            = 0x00;
  569. #endif
  571. #if OS_EVENT_TBL_SIZE > 1
  572.     *ptbl++            = 0x00;
  573. #endif
  575. #if OS_EVENT_TBL_SIZE > 2
  576.     *ptbl++            = 0x00;
  577. #endif
  579. #if OS_EVENT_TBL_SIZE > 3
  580.     *ptbl++            = 0x00;
  581. #endif
  583. #if OS_EVENT_TBL_SIZE > 4
  584.     *ptbl++            = 0x00;
  585. #endif
  587. #if OS_EVENT_TBL_SIZE > 5
  588.     *ptbl++            = 0x00;
  589. #endif
  591. #if OS_EVENT_TBL_SIZE > 6
  592.     *ptbl++            = 0x00;
  593. #endif
  595. #if OS_EVENT_TBL_SIZE > 7
  596.     *ptbl              = 0x00;
  597. #endif
  598. }
  599. #endif
  600. /*$PAGE*/
  601. /*
  602. *********************************************************************************************************
  603. *                                             INITIALIZATION
  604. *                           INITIALIZE THE FREE LIST OF EVENT CONTROL BLOCKS
  605. *
  606. * Description: This function is called by OSInit() to initialize the free list of event control blocks.
  607. *
  608. * Arguments  : none
  609. *
  610. * Returns    : none
  611. *********************************************************************************************************
  612. */
  614. static  void  OS_InitEventList (void)
  615. {
  616. #if (OS_EVENT_EN > 0) && (OS_MAX_EVENTS > 0)
  617. #if (OS_MAX_EVENTS > 1)
  618.     INT16U     i;
  619.     OS_EVENT  *pevent1;
  620.     OS_EVENT  *pevent2;
  623.     pevent1 = &OSEventTbl[0];
  624.     pevent2 = &OSEventTbl[1];
  625.     for (i = 0; i < (OS_MAX_EVENTS - 1); i++) {                  /* Init. list of free EVENT control blocks  */
  626.         pevent1->OSEventType = OS_EVENT_TYPE_UNUSED;
  627.         pevent1->OSEventPtr  = pevent2;
  628.         pevent1++;
  629.         pevent2++;
  630.     }
  631.     pevent1->OSEventType = OS_EVENT_TYPE_UNUSED;
  632.     pevent1->OSEventPtr  = (OS_EVENT *)0;
  633.     OSEventFreeList      = &OSEventTbl[0];
  634. #else
  635.     OSEventFreeList              = &OSEventTbl[0];               /* Only have ONE event control block        */
  636.     OSEventFreeList->OSEventType = OS_EVENT_TYPE_UNUSED;
  637.     OSEventFreeList->OSEventPtr  = (OS_EVENT *)0;
  638. #endif
  639. #endif
  640. }
  641. /*$PAGE*/
  642. /*
  643. *********************************************************************************************************
  644. *                                             INITIALIZATION
  645. *                                    INITIALIZE MISCELLANEOUS VARIABLES
  646. *
  647. * Description: This function is called by OSInit() to initialize miscellaneous variables.
  648. *
  649. * Arguments  : none
  650. *
  651. * Returns    : none
  652. *********************************************************************************************************
  653. */
  655. static  void  OS_InitMisc (void)
  656. {
  657. #if OS_TIME_GET_SET_EN > 0   
  658.     OSTime        = 0L;                                          /* Clear the 32-bit system clock            */
  659. #endif
  661.     OSIntNesting  = 0;                                           /* Clear the interrupt nesting counter      */
  662.     OSLockNesting = 0;                                           /* Clear the scheduling lock counter        */
  664.     OSTaskCtr     = 0;                                           /* Clear the number of tasks                */
  666.     OSRunning     = FALSE;                                       /* Indicate that multitasking not started   */
  667.     
  668.     OSCtxSwCtr    = 0;                                           /* Clear the context switch counter         */
  669.     OSIdleCtr     = 0L;                                          /* Clear the 32-bit idle counter            */
  671. #if (OS_TASK_STAT_EN > 0) && (OS_TASK_CREATE_EXT_EN > 0)
  672.     OSIdleCtrRun  = 0L;
  673.     OSIdleCtrMax  = 0L;
  674.     OSStatRdy     = FALSE;                                       /* Statistic task is not ready              */
  675. #endif
  676. }
  677. /*$PAGE*/
  678. /*
  679. *********************************************************************************************************
  680. *                                             INITIALIZATION
  681. *                                       INITIALIZE THE READY LIST
  682. *
  683. * Description: This function is called by OSInit() to initialize the Ready List.
  684. *
  685. * Arguments  : none
  686. *
  687. * Returns    : none
  688. *********************************************************************************************************
  689. */
  691. static  void  OS_InitRdyList (void)
  692. {
  693.     INT16U   i;
  694.     INT8U   *prdytbl;
  697.     OSRdyGrp      = 0x00;                                        /* Clear the ready list                     */
  698.     prdytbl       = &OSRdyTbl[0];
  699.     for (i = 0; i < OS_RDY_TBL_SIZE; i++) {
  700.         *prdytbl++ = 0x00;
  701.     }
  703.     OSPrioCur     = 0;
  704.     OSPrioHighRdy = 0;
  706.     OSTCBHighRdy  = (OS_TCB *)0;                                 
  707.     OSTCBCur      = (OS_TCB *)0;
  708. }
  710. /*$PAGE*/
  711. /*
  712. *********************************************************************************************************
  713. *                                             INITIALIZATION
  714. *                                         CREATING THE IDLE TASK
  715. *
  716. * Description: This function creates the Idle Task.
  717. *
  718. * Arguments  : none
  719. *
  720. * Returns    : none
  721. *********************************************************************************************************
  722. */
  724. static  void  OS_InitTaskIdle (void)
  725. {
  726. #if OS_TASK_CREATE_EXT_EN > 0
  727.     #if OS_STK_GROWTH == 1
  728.     (void)OSTaskCreateExt(OS_TaskIdle,
  729.                           (void *)0,                                 /* No arguments passed to OS_TaskIdle() */
  730.                           &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Top-Of-Stack                     */
  731.                           OS_IDLE_PRIO,                              /* Lowest priority level                */
  732.                           OS_TASK_IDLE_ID,
  733.                           &OSTaskIdleStk[0],                         /* Set Bottom-Of-Stack                  */
  734.                           OS_TASK_IDLE_STK_SIZE,
  735.                           (void *)0,                                 /* No TCB extension                     */
  736.                           OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
  737.     #else
  738.     (void)OSTaskCreateExt(OS_TaskIdle,
  739.                           (void *)0,                                 /* No arguments passed to OS_TaskIdle() */
  740.                           &OSTaskIdleStk[0],                         /* Set Top-Of-Stack                     */
  741.                           OS_IDLE_PRIO,                              /* Lowest priority level                */
  742.                           OS_TASK_IDLE_ID,
  743.                           &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Bottom-Of-Stack                  */
  744.                           OS_TASK_IDLE_STK_SIZE,
  745.                           (void *)0,                                 /* No TCB extension                     */
  746.                           OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
  747.     #endif
  748. #else
  749.     #if OS_STK_GROWTH == 1
  750.     (void)OSTaskCreate(OS_TaskIdle,
  751.                        (void *)0,
  752.                        &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1],
  753.                        OS_IDLE_PRIO);
  754.     #else
  755.     (void)OSTaskCreate(OS_TaskIdle,
  756.                        (void *)0,
  757.                        &OSTaskIdleStk[0],
  758.                        OS_IDLE_PRIO);
  759.     #endif
  760. #endif
  761. }
  762. /*$PAGE*/
  763. /*
  764. *********************************************************************************************************
  765. *                                             INITIALIZATION
  766. *                                      CREATING THE STATISTIC TASK
  767. *
  768. * Description: This function creates the Statistic Task.
  769. *
  770. * Arguments  : none
  771. *
  772. * Returns    : none
  773. *********************************************************************************************************
  774. */
  776. #if OS_TASK_STAT_EN > 0
  777. static  void  OS_InitTaskStat (void)
  778. {
  779. #if OS_TASK_CREATE_EXT_EN > 0
  780.     #if OS_STK_GROWTH == 1
  781.     (void)OSTaskCreateExt(OS_TaskStat,
  782.                           (void *)0,                                   /* No args passed to OS_TaskStat()*/
  783.                           &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],   /* Set Top-Of-Stack               */
  784.                           OS_STAT_PRIO,                                /* One higher than the idle task  */
  785.                           OS_TASK_STAT_ID,
  786.                           &OSTaskStatStk[0],                           /* Set Bottom-Of-Stack            */
  787.                           OS_TASK_STAT_STK_SIZE,
  788.                           (void *)0,                                   /* No TCB extension               */
  789.                           OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
  790.     #else
  791.     (void)OSTaskCreateExt(OS_TaskStat,
  792.                           (void *)0,                                   /* No args passed to OS_TaskStat()*/
  793.                           &OSTaskStatStk[0],                           /* Set Top-Of-Stack               */
  794.                           OS_STAT_PRIO,                                /* One higher than the idle task  */
  795.                           OS_TASK_STAT_ID,
  796.                           &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],   /* Set Bottom-Of-Stack            */
  797.                           OS_TASK_STAT_STK_SIZE,
  798.                           (void *)0,                                   /* No TCB extension               */
  799.                           OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
  800.     #endif
  801. #else
  802.     #if OS_STK_GROWTH == 1
  803.     (void)OSTaskCreate(OS_TaskStat,
  804.                        (void *)0,                                      /* No args passed to OS_TaskStat()*/
  805.                        &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],      /* Set Top-Of-Stack               */
  806.                        OS_STAT_PRIO);                                  /* One higher than the idle task  */
  807.     #else
  808.     (void)OSTaskCreate(OS_TaskStat,
  809.                        (void *)0,                                      /* No args passed to OS_TaskStat()*/
  810.                        &OSTaskStatStk[0],                              /* Set Top-Of-Stack               */
  811.                        OS_STAT_PRIO);                                  /* One higher than the idle task  */
  812.     #endif
  813. #endif
  814. }
  815. #endif
  816. /*$PAGE*/
  817. /*
  818. *********************************************************************************************************
  819. *                                             INITIALIZATION
  820. *                            INITIALIZE THE FREE LIST OF TASK CONTROL BLOCKS
  821. *
  822. * Description: This function is called by OSInit() to initialize the free list of OS_TCBs.
  823. *
  824. * Arguments  : none
  825. *
  826. * Returns    : none
  827. *********************************************************************************************************
  828. */
  830. static  void  OS_InitTCBList (void)
  831. {
  832.     INT8U    i;
  833.     OS_TCB  *ptcb1;
  834.     OS_TCB  *ptcb2;
  837.     OSTCBList     = (OS_TCB *)0;                                 /* TCB Initialization                       */
  838.     for (i = 0; i < (OS_LOWEST_PRIO + 1); i++) {                 /* Clear the priority table                 */
  839.         OSTCBPrioTbl[i] = (OS_TCB *)0;
  840.     }
  841.     ptcb1 = &OSTCBTbl[0];
  842.     ptcb2 = &OSTCBTbl[1];
  843.     for (i = 0; i < (OS_MAX_TASKS + OS_N_SYS_TASKS - 1); i++) {  /* Init. list of free TCBs                  */
  844.         ptcb1->OSTCBNext = ptcb2;
  845.         ptcb1++;
  846.         ptcb2++;
  847.     }
  848.     ptcb1->OSTCBNext = (OS_TCB *)0;                              /* Last OS_TCB                              */
  849.     OSTCBFreeList    = &OSTCBTbl[0];
  850. }
  851. /*$PAGE*/
  852. /*
  853. *********************************************************************************************************
  854. *                                              SCHEDULER
  855. *
  856. * Description: This function is called by other uC/OS-II services to determine whether a new, high
  857. *              priority task has been made ready to run.  This function is invoked by TASK level code
  858. *              and is not used to reschedule tasks from ISRs (see OSIntExit() for ISR rescheduling).
  859. *
  860. * Arguments  : none
  861. *
  862. * Returns    : none
  863. *
  864. * Notes      : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
  865. *              2) Rescheduling is prevented when the scheduler is locked (see OS_SchedLock())
  866. *********************************************************************************************************
  867. */
  869. void  OS_Sched (void)
  870. {
  871. #if OS_CRITICAL_METHOD == 3                            /* Allocate storage for CPU status register     */
  872.     OS_CPU_SR  cpu_sr;
  873. #endif    
  874.     INT8U      y;
  877.     OS_ENTER_CRITICAL();
  878.     if ((OSIntNesting == 0) && (OSLockNesting == 0)) { /* Sched. only if all ISRs done & not locked    */
  879.         y             = OSUnMapTbl[OSRdyGrp];          /* Get pointer to HPT ready to run              */
  880.         OSPrioHighRdy = (INT8U)((y << 3) + OSUnMapTbl[OSRdyTbl[y]]);
  881.         if (OSPrioHighRdy != OSPrioCur) {              /* No Ctx Sw if current task is highest rdy     */
  882.             OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];
  883.             OSCtxSwCtr++;                              /* Increment context switch counter             */
  884.             OS_TASK_SW();                              /* Perform a context switch                     */
  885.         }
  886.     }
  887.     OS_EXIT_CRITICAL();
  888. }
  889. /*$PAGE*/
  890. /*
  891. *********************************************************************************************************
  892. *                                              IDLE TASK
  893. *
  894. * Description: This task is internal to uC/OS-II and executes whenever no other higher priority tasks
  895. *              executes because they are ALL waiting for event(s) to occur.
  896. *
  897. * Arguments  : none
  898. *
  899. * Returns    : none
  900. *
  901. * Note(s)    : 1) OSTaskIdleHook() is called after the critical section to ensure that interrupts will be
  902. *                 enabled for at least a few instructions.  On some processors (ex. Philips XA), enabling
  903. *                 and then disabling interrupts didn't allow the processor enough time to have interrupts
  904. *                 enabled before they were disabled again.  uC/OS-II would thus never recognize
  905. *                 interrupts.
  906. *              2) This hook has been added to allow you to do such things as STOP the CPU to conserve 
  907. *                 power.
  908. *********************************************************************************************************
  909. */
  911. void  OS_TaskIdle (void *pdata)
  912. {
  913. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  914.     OS_CPU_SR  cpu_sr;
  915. #endif    
  916.     
  917.     
  918.     pdata = pdata;                               /* Prevent compiler warning for not using 'pdata'     */
  919.     for (;;) {
  920.         OS_ENTER_CRITICAL();
  921.         OSIdleCtr++;
  922.         OS_EXIT_CRITICAL();
  923.         OSTaskIdleHook();                        /* Call user definable HOOK                           */
  924.     }
  925. }
  926. /*$PAGE*/
  927. /*
  928. *********************************************************************************************************
  929. *                                            STATISTICS TASK
  930. *
  931. * Description: This task is internal to uC/OS-II and is used to compute some statistics about the
  932. *              multitasking environment.  Specifically, OS_TaskStat() computes the CPU usage.
  933. *              CPU usage is determined by:
  934. *
  935. *                                          OSIdleCtr
  936. *                 OSCPUUsage = 100 * (1 - ------------)     (units are in %)
  937. *                                         OSIdleCtrMax
  938. *
  939. * Arguments  : pdata     this pointer is not used at this time.
  940. *
  941. * Returns    : none
  942. *
  943. * Notes      : 1) This task runs at a priority level higher than the idle task.  In fact, it runs at the
  944. *                 next higher priority, OS_IDLE_PRIO-1.
  945. *              2) You can disable this task by setting the configuration #define OS_TASK_STAT_EN to 0.
  946. *              3) We delay for 5 seconds in the beginning to allow the system to reach steady state and
  947. *                 have all other tasks created before we do statistics.  You MUST have at least a delay
  948. *                 of 2 seconds to allow for the system to establish the maximum value for the idle
  949. *                 counter.
  950. *********************************************************************************************************
  951. */
  953. #if OS_TASK_STAT_EN > 0
  954. void  OS_TaskStat (void *pdata)
  955. {
  956. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  957.     OS_CPU_SR  cpu_sr;
  958. #endif    
  959.     INT32U     run;
  960.     INT32U     max;
  961.     INT8S      usage;
  964.     pdata = pdata;                               /* Prevent compiler warning for not using 'pdata'     */
  965.     while (OSStatRdy == FALSE) {
  966.         OSTimeDly(2 * OS_TICKS_PER_SEC);         /* Wait until statistic task is ready                 */
  967.     }
  968.     max = OSIdleCtrMax / 100L;
  969.     for (;;) {
  970.         OS_ENTER_CRITICAL();
  971.         OSIdleCtrRun = OSIdleCtr;                /* Obtain the of the idle counter for the past second */
  972.         run          = OSIdleCtr;
  973.         OSIdleCtr    = 0L;                       /* Reset the idle counter for the next second         */
  974.         OS_EXIT_CRITICAL();
  975.         if (max > 0L) {
  976.             usage = (INT8S)(100L - run / max);
  977.             if (usage >= 0) {                    /* Make sure we don't have a negative percentage      */
  978.                 OSCPUUsage = usage;
  979.             } else {
  980.                 OSCPUUsage = 0;
  981.             }
  982.         } else {
  983.             OSCPUUsage = 0;
  984.             max        = OSIdleCtrMax / 100L;
  985.         }
  986.         OSTaskStatHook();                        /* Invoke user definable hook                         */
  987.         OSTimeDly(OS_TICKS_PER_SEC);             /* Accumulate OSIdleCtr for the next second           */
  988.     }
  989. }
  990. #endif
  991. /*$PAGE*/
  992. /*
  993. *********************************************************************************************************
  994. *                                            INITIALIZE TCB
  995. *
  996. * Description: This function is internal to uC/OS-II and is used to initialize a Task Control Block when
  997. *              a task is created (see OSTaskCreate() and OSTaskCreateExt()).
  998. *
  999. * Arguments  : prio          is the priority of the task being created
  1000. *
  1001. *              ptos          is a pointer to the task's top-of-stack assuming that the CPU registers
  1002. *                            have been placed on the stack.  Note that the top-of-stack corresponds to a
  1003. *                            'high' memory location is OS_STK_GROWTH is set to 1 and a 'low' memory
  1004. *                            location if OS_STK_GROWTH is set to 0.  Note that stack growth is CPU
  1005. *                            specific.
  1006. *
  1007. *              pbos          is a pointer to the bottom of stack.  A NULL pointer is passed if called by
  1008. *                            'OSTaskCreate()'.
  1009. *
  1010. *              id            is the task's ID (0..65535)
  1011. *
  1012. *              stk_size      is the size of the stack (in 'stack units').  If the stack units are INT8Us
  1013. *                            then, 'stk_size' contains the number of bytes for the stack.  If the stack
  1014. *                            units are INT32Us then, the stack contains '4 * stk_size' bytes.  The stack
  1015. *                            units are established by the #define constant OS_STK which is CPU
  1016. *                            specific.  'stk_size' is 0 if called by 'OSTaskCreate()'.
  1017. *
  1018. *              pext          is a pointer to a user supplied memory area that is used to extend the task
  1019. *                            control block.  This allows you to store the contents of floating-point
  1020. *                            registers, MMU registers or anything else you could find useful during a
  1021. *                            context switch.  You can even assign a name to each task and store this name
  1022. *                            in this TCB extension.  A NULL pointer is passed if called by OSTaskCreate().
  1023. *
  1024. *              opt           options as passed to 'OSTaskCreateExt()' or,
  1025. *                            0 if called from 'OSTaskCreate()'.
  1026. *
  1027. * Returns    : OS_NO_ERR         if the call was successful
  1028. *              OS_NO_MORE_TCB    if there are no more free TCBs to be allocated and thus, the task cannot
  1029. *                                be created.
  1030. *
  1031. * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
  1032. *********************************************************************************************************
  1033. */
  1035. INT8U  OS_TCBInit (INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT32U stk_size, void *pext, INT16U opt)
  1036. {
  1037. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  1038.     OS_CPU_SR  cpu_sr;
  1039. #endif    
  1040.     OS_TCB    *ptcb;
  1043.     OS_ENTER_CRITICAL();
  1044.     ptcb = OSTCBFreeList;                                  /* Get a free TCB from the free TCB list    */
  1045.     if (ptcb != (OS_TCB *)0) {
  1046.         OSTCBFreeList        = ptcb->OSTCBNext;            /* Update pointer to free TCB list          */
  1047.         OS_EXIT_CRITICAL();
  1048.         ptcb->OSTCBStkPtr    = ptos;                       /* Load Stack pointer in TCB                */
  1049.         ptcb->OSTCBPrio      = (INT8U)prio;                /* Load task priority into TCB              */
  1050.         ptcb->OSTCBStat      = OS_STAT_RDY;                /* Task is ready to run                     */
  1051.         ptcb->OSTCBDly       = 0;                          /* Task is not delayed                      */
  1053. #if OS_TASK_CREATE_EXT_EN > 0
  1054.         ptcb->OSTCBExtPtr    = pext;                       /* Store pointer to TCB extension           */
  1055.         ptcb->OSTCBStkSize   = stk_size;                   /* Store stack size                         */
  1056.         ptcb->OSTCBStkBottom = pbos;                       /* Store pointer to bottom of stack         */
  1057.         ptcb->OSTCBOpt       = opt;                        /* Store task options                       */
  1058.         ptcb->OSTCBId        = id;                         /* Store task ID                            */
  1059. #else
  1060.         pext                 = pext;                       /* Prevent compiler warning if not used     */
  1061.         stk_size             = stk_size;
  1062.         pbos                 = pbos;
  1063.         opt                  = opt;
  1064.         id                   = id;
  1065. #endif
  1067. #if OS_TASK_DEL_EN > 0
  1068.         ptcb->OSTCBDelReq    = OS_NO_ERR;
  1069. #endif
  1071.         ptcb->OSTCBY         = prio >> 3;                  /* Pre-compute X, Y, BitX and BitY          */
  1072.         ptcb->OSTCBBitY      = OSMapTbl[ptcb->OSTCBY];
  1073.         ptcb->OSTCBX         = prio & 0x07;
  1074.         ptcb->OSTCBBitX      = OSMapTbl[ptcb->OSTCBX];
  1076. #if OS_EVENT_EN > 0
  1077.         ptcb->OSTCBEventPtr  = (OS_EVENT *)0;              /* Task is not pending on an event          */
  1078. #endif
  1080. #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0) && (OS_TASK_DEL_EN > 0)
  1081.         ptcb->OSTCBFlagNode  = (OS_FLAG_NODE *)0;          /* Task is not pending on an event flag     */
  1082. #endif
  1084. #if (OS_MBOX_EN > 0) || ((OS_Q_EN > 0) && (OS_MAX_QS > 0))
  1085.         ptcb->OSTCBMsg       = (void *)0;                  /* No message received                      */
  1086. #endif
  1088. #if OS_VERSION >= 204
  1089.         OSTCBInitHook(ptcb);
  1090. #endif
  1092.         OSTaskCreateHook(ptcb);                            /* Call user defined hook                   */
  1093.         
  1094.         OS_ENTER_CRITICAL();
  1095.         OSTCBPrioTbl[prio] = ptcb;
  1096.         ptcb->OSTCBNext    = OSTCBList;                    /* Link into TCB chain                      */
  1097.         ptcb->OSTCBPrev    = (OS_TCB *)0;
  1098.         if (OSTCBList != (OS_TCB *)0) {
  1099.             OSTCBList->OSTCBPrev = ptcb;
  1100.         }
  1101.         OSTCBList               = ptcb;
  1102.         OSRdyGrp               |= ptcb->OSTCBBitY;         /* Make task ready to run                   */
  1103.         OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
  1104.         OS_EXIT_CRITICAL();
  1105.         return (OS_NO_ERR);
  1106.     }
  1107.     OS_EXIT_CRITICAL();
  1108.     return (OS_NO_MORE_TCB);
  1109. }