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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
os_core.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：67k
源码类别：

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-2006, Jean J. Labrosse, Weston, FL
  8. *                                           All Rights Reserved
  9. *
  10. * File    : OS_CORE.C
  11. * By      : Jean J. Labrosse
  12. * Version : V2.83
  13. *********************************************************************************************************
  14. */
  16. #ifndef  OS_MASTER_FILE
  17. #define  OS_GLOBALS
  18. #include <ucos_ii.h>
  19. #endif
  21. /*
  22. *********************************************************************************************************
  23. *                                       PRIORITY RESOLUTION TABLE
  24. *
  25. * Note: Index into table is bit pattern to resolve highest priority
  26. *       Indexed value corresponds to highest priority bit position (i.e. 0..7)
  27. *********************************************************************************************************
  28. */
  30. INT8U  const  OSUnMapTbl[256] = {
  31.     0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x00 to 0x0F                             */
  32.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x10 to 0x1F                             */
  33.     5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x20 to 0x2F                             */
  34.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x30 to 0x3F                             */
  35.     6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x40 to 0x4F                             */
  36.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x50 to 0x5F                             */
  37.     5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x60 to 0x6F                             */
  38.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x70 to 0x7F                             */
  39.     7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x80 to 0x8F                             */
  40.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x90 to 0x9F                             */
  41.     5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xA0 to 0xAF                             */
  42.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xB0 to 0xBF                             */
  43.     6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xC0 to 0xCF                             */
  44.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xD0 to 0xDF                             */
  45.     5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xE0 to 0xEF                             */
  46.     4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0        /* 0xF0 to 0xFF                             */
  47. };
  49. /*$PAGE*/
  50. /*
  51. *********************************************************************************************************
  52. *                                       FUNCTION PROTOTYPES
  53. *********************************************************************************************************
  54. */
  56. static  void  OS_InitEventList(void);
  58. static  void  OS_InitMisc(void);
  60. static  void  OS_InitRdyList(void);
  62. static  void  OS_InitTaskIdle(void);
  64. #if OS_TASK_STAT_EN > 0
  65. static  void  OS_InitTaskStat(void);
  66. #endif
  68. static  void  OS_InitTCBList(void);
  70. static  void  OS_SchedNew(void);
  72. /*$PAGE*/
  73. /*
  74. *********************************************************************************************************
  75. *                         GET THE NAME OF A SEMAPHORE, MUTEX, MAILBOX or QUEUE
  76. *
  77. * Description: This function is used to obtain the name assigned to a semaphore, mutex, mailbox or queue.
  78. *
  79. * Arguments  : pevent    is a pointer to the event group.  'pevent' can point either to a semaphore,
  80. *                        a mutex, a mailbox or a queue.  Where this function is concerned, the actual
  81. *                        type is irrelevant.
  82. *
  83. *              pname     is a pointer to an ASCII string that will receive the name of the semaphore,
  84. *                        mutex, mailbox or queue.  The string must be able to hold at least
  85. *                        OS_EVENT_NAME_SIZE characters.
  86. *
  87. *              err       is a pointer to an error code that can contain one of the following values:
  88. *
  89. *                        OS_NO_ERR                  if the name was copied to 'pname'
  90. *                        OS_ERR_EVENT_TYPE          if 'pevent' is not pointing to the proper event
  91. *                                                   control block type.
  92. *                        OS_ERR_PNAME_NULL          You passed a NULL pointer for 'pname'
  93. *                        OS_ERR_PEVENT_NULL         if you passed a NULL pointer for 'pevent'
  94. *
  95. * Returns    : The length of the string or 0 if the 'pevent' is a NULL pointer.
  96. *********************************************************************************************************
  97. */
  99. #if OS_EVENT_EN && (OS_EVENT_NAME_SIZE > 1)
  100. INT8U  OSEventNameGet (OS_EVENT *pevent, INT8U *pname, INT8U *err)
  101. {
  102.     INT8U      len;
  103. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  104.     OS_CPU_SR  cpu_sr = 0;
  105. #endif
  109. #if OS_ARG_CHK_EN > 0
  110.     if (err == (INT8U *)0) {                     /* Validate 'err'                                     */
  111.         return (0);
  112.     }
  113.     if (pevent == (OS_EVENT *)0) {               /* Is 'pevent' a NULL pointer?                        */
  114.         *err = OS_ERR_PEVENT_NULL;
  115.         return (0);
  116.     }
  117.     if (pname == (INT8U *)0) {                   /* Is 'pname' a NULL pointer?                         */
  118.         *err = OS_ERR_PNAME_NULL;
  119.         return (0);
  120.     }
  121. #endif
  122.     switch (pevent->OSEventType) {
  123.         case OS_EVENT_TYPE_SEM:
  124.         case OS_EVENT_TYPE_MUTEX:
  125.         case OS_EVENT_TYPE_MBOX:
  126.         case OS_EVENT_TYPE_Q:
  127.              break;
  129.         default:
  130.              *err = OS_ERR_EVENT_TYPE;
  131.              return (0);
  132.     }
  133.     OS_ENTER_CRITICAL();
  134.     len  = OS_StrCopy(pname, pevent->OSEventName);    /* Copy name from OS_EVENT                       */
  135.     OS_EXIT_CRITICAL();
  136.     *err = OS_NO_ERR;
  137.     return (len);
  138. }
  139. #endif
  141. /*$PAGE*/
  142. /*
  143. *********************************************************************************************************
  144. *                         ASSIGN A NAME TO A SEMAPHORE, MUTEX, MAILBOX or QUEUE
  145. *
  146. * Description: This function assigns a name to a semaphore, mutex, mailbox or queue.
  147. *
  148. * Arguments  : pevent    is a pointer to the event group.  'pevent' can point either to a semaphore,
  149. *                        a mutex, a mailbox or a queue.  Where this function is concerned, it doesn't
  150. *                        matter the actual type.
  151. *
  152. *              pname     is a pointer to an ASCII string that will be used as the name of the semaphore,
  153. *                        mutex, mailbox or queue.  The string must be able to hold at least
  154. *                        OS_EVENT_NAME_SIZE characters.
  155. *
  156. *              err       is a pointer to an error code that can contain one of the following values:
  157. *
  158. *                        OS_NO_ERR                  if the requested task is resumed
  159. *                        OS_ERR_EVENT_TYPE          if 'pevent' is not pointing to the proper event
  160. *                                                   control block type.
  161. *                        OS_ERR_PNAME_NULL          You passed a NULL pointer for 'pname'
  162. *                        OS_ERR_PEVENT_NULL         if you passed a NULL pointer for 'pevent'
  163. *
  164. * Returns    : None
  165. *********************************************************************************************************
  166. */
  168. #if OS_EVENT_EN && (OS_EVENT_NAME_SIZE > 1)
  169. void  OSEventNameSet (OS_EVENT *pevent, INT8U *pname, INT8U *err)
  170. {
  171.     INT8U      len;
  172. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  173.     OS_CPU_SR  cpu_sr = 0;
  174. #endif
  178. #if OS_ARG_CHK_EN > 0
  179.     if (err == (INT8U *)0) {                     /* Validate 'err'                                     */
  180.         return;
  181.     }
  182.     if (pevent == (OS_EVENT *)0) {               /* Is 'pevent' a NULL pointer?                        */
  183.         *err = OS_ERR_PEVENT_NULL;
  184.         return;
  185.     }
  186.     if (pname == (INT8U *)0) {                    /* Is 'pname' a NULL pointer?                         */
  187.         *err = OS_ERR_PNAME_NULL;
  188.         return;
  189.     }
  190. #endif
  191.     switch (pevent->OSEventType) {
  192.         case OS_EVENT_TYPE_SEM:
  193.         case OS_EVENT_TYPE_MUTEX:
  194.         case OS_EVENT_TYPE_MBOX:
  195.         case OS_EVENT_TYPE_Q:
  196.              break;
  198.         default:
  199.              *err = OS_ERR_EVENT_TYPE;
  200.              return;
  201.     }
  202.     OS_ENTER_CRITICAL();
  203.     len = OS_StrLen(pname);                           /* Can we fit the string in the storage area?    */
  204.     if (len > (OS_EVENT_NAME_SIZE - 1)) {             /* No                                            */
  205.         OS_EXIT_CRITICAL();
  206.         *err = OS_ERR_EVENT_NAME_TOO_LONG;
  207.         return;
  208.     }
  209.     (void)OS_StrCopy(pevent->OSEventName, pname);     /* Yes, copy name to the event control block     */
  210.     OS_EXIT_CRITICAL();
  211.     *err = OS_NO_ERR;
  212. }
  213. #endif
  215. /*$PAGE*/
  216. /*
  217. *********************************************************************************************************
  218. *                                             INITIALIZATION
  219. *
  220. * Description: This function is used to initialize the internals of uC/OS-II and MUST be called prior to
  221. *              creating any uC/OS-II object and, prior to calling OSStart().
  222. *
  223. * Arguments  : none
  224. *
  225. * Returns    : none
  226. *********************************************************************************************************
  227. */
  229. void  OSInit (void)
  230. {
  231. #if OS_VERSION >= 204
  232.     OSInitHookBegin();                                           /* Call port specific initialization code   */
  233. #endif
  235.     OS_InitMisc();                                               /* Initialize miscellaneous variables       */
  237.     OS_InitRdyList();                                            /* Initialize the Ready List                */
  239.     OS_InitTCBList();                                            /* Initialize the free list of OS_TCBs      */
  241.     OS_InitEventList();                                          /* Initialize the free list of OS_EVENTs    */
  243. #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
  244.     OS_FlagInit();                                               /* Initialize the event flag structures     */
  245. #endif
  247. #if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
  248.     OS_MemInit();                                                /* Initialize the memory manager            */
  249. #endif
  251. #if (OS_Q_EN > 0) && (OS_MAX_QS > 0)
  252.     OS_QInit();                                                  /* Initialize the message queue structures  */
  253. #endif
  255.     OS_InitTaskIdle();                                           /* Create the Idle Task                     */
  256. #if OS_TASK_STAT_EN > 0
  257.     OS_InitTaskStat();                                           /* Create the Statistic Task                */
  258. #endif
  260. #if OS_TMR_EN > 0
  261.     OSTmr_Init();                                                /* Initialize the Timer Manager             */
  262. #endif
  264. #if OS_VERSION >= 204
  265.     OSInitHookEnd();                                             /* Call port specific init. code            */
  266. #endif
  268. #if OS_VERSION >= 270 && OS_DEBUG_EN > 0
  269.     OSDebugInit();
  270. #endif
  271. }
  272. /*$PAGE*/
  273. /*
  274. *********************************************************************************************************
  275. *                                              ENTER ISR
  276. *
  277. * Description: This function is used to notify uC/OS-II that you are about to service an interrupt
  278. *              service routine (ISR).  This allows uC/OS-II to keep track of interrupt nesting and thus
  279. *              only perform rescheduling at the last nested ISR.
  280. *
  281. * Arguments  : none
  282. *
  283. * Returns    : none
  284. *
  285. * Notes      : 1) This function should be called ith interrupts already disabled
  286. *              2) Your ISR can directly increment OSIntNesting without calling this function because
  287. *                 OSIntNesting has been declared 'global'.
  288. *              3) You MUST still call OSIntExit() even though you increment OSIntNesting directly.
  289. *              4) You MUST invoke OSIntEnter() and OSIntExit() in pair.  In other words, for every call
  290. *                 to OSIntEnter() at the beginning of the ISR you MUST have a call to OSIntExit() at the
  291. *                 end of the ISR.
  292. *              5) You are allowed to nest interrupts up to 255 levels deep.
  293. *              6) I removed the OS_ENTER_CRITICAL() and OS_EXIT_CRITICAL() around the increment because
  294. *                 OSIntEnter() is always called with interrupts disabled.
  295. *********************************************************************************************************
  296. */
  298. void  OSIntEnter (void)
  299. {
  300.     if (OSRunning == OS_TRUE) {
  301.         if (OSIntNesting < 255u) {
  302.             OSIntNesting++;                      /* Increment ISR nesting level                        */
  303.         }
  304.     }
  305. }
  306. /*$PAGE*/
  307. /*
  308. *********************************************************************************************************
  309. *                                               EXIT ISR
  310. *
  311. * Description: This function is used to notify uC/OS-II that you have completed serviving an ISR.  When
  312. *              the last nested ISR has completed, uC/OS-II will call the scheduler to determine whether
  313. *              a new, high-priority task, is ready to run.
  314. *
  315. * Arguments  : none
  316. *
  317. * Returns    : none
  318. *
  319. * Notes      : 1) You MUST invoke OSIntEnter() and OSIntExit() in pair.  In other words, for every call
  320. *                 to OSIntEnter() at the beginning of the ISR you MUST have a call to OSIntExit() at the
  321. *                 end of the ISR.
  322. *              2) Rescheduling is prevented when the scheduler is locked (see OS_SchedLock())
  323. *********************************************************************************************************
  324. */
  326. void  OSIntExit (void)
  327. {
  328. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  329.     OS_CPU_SR  cpu_sr = 0;
  330. #endif
  334.     if (OSRunning == OS_TRUE) {
  335.         OS_ENTER_CRITICAL();
  336.         if (OSIntNesting > 0) {                            /* Prevent OSIntNesting from wrapping       */
  337.             OSIntNesting--;
  338.         }
  339.         if (OSIntNesting == 0) {                           /* Reschedule only if all ISRs complete ... */
  340.             if (OSLockNesting == 0) {                      /* ... and not locked.                      */
  341.                 OS_SchedNew();
  342.                 if (OSPrioHighRdy != OSPrioCur) {          /* No Ctx Sw if current task is highest rdy */
  343.                     OSTCBHighRdy  = OSTCBPrioTbl[OSPrioHighRdy];
  344. #if OS_TASK_PROFILE_EN > 0
  345.                     OSTCBHighRdy->OSTCBCtxSwCtr++;         /* Inc. # of context switches to this task  */
  346. #endif
  347.                     OSCtxSwCtr++;                          /* Keep track of the number of ctx switches */
  348.                     OSIntCtxSw();                          /* Perform interrupt level ctx switch       */
  349.                 }
  350.             }
  351.         }
  352.         OS_EXIT_CRITICAL();
  353.     }
  354. }
  355. /*$PAGE*/
  356. /*
  357. *********************************************************************************************************
  358. *                                          PREVENT SCHEDULING
  359. *
  360. * Description: This function is used to prevent rescheduling to take place.  This allows your application
  361. *              to prevent context switches until you are ready to permit context switching.
  362. *
  363. * Arguments  : none
  364. *
  365. * Returns    : none
  366. *
  367. * Notes      : 1) You MUST invoke OSSchedLock() and OSSchedUnlock() in pair.  In other words, for every
  368. *                 call to OSSchedLock() you MUST have a call to OSSchedUnlock().
  369. *********************************************************************************************************
  370. */
  372. #if OS_SCHED_LOCK_EN > 0
  373. void  OSSchedLock (void)
  374. {
  375. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  376.     OS_CPU_SR  cpu_sr = 0;
  377. #endif
  381.     if (OSRunning == OS_TRUE) {                  /* Make sure multitasking is running                  */
  382.         OS_ENTER_CRITICAL();
  383.         if (OSIntNesting == 0) {                 /* Can't call from an ISR                             */
  384.             if (OSLockNesting < 255u) {          /* Prevent OSLockNesting from wrapping back to 0      */
  385.                 OSLockNesting++;                 /* Increment lock nesting level                       */
  386.             }
  387.         }
  388.         OS_EXIT_CRITICAL();
  389.     }
  390. }
  391. #endif
  393. /*$PAGE*/
  394. /*
  395. *********************************************************************************************************
  396. *                                          ENABLE SCHEDULING
  397. *
  398. * Description: This function is used to re-allow rescheduling.
  399. *
  400. * Arguments  : none
  401. *
  402. * Returns    : none
  403. *
  404. * Notes      : 1) You MUST invoke OSSchedLock() and OSSchedUnlock() in pair.  In other words, for every
  405. *                 call to OSSchedLock() you MUST have a call to OSSchedUnlock().
  406. *********************************************************************************************************
  407. */
  409. #if OS_SCHED_LOCK_EN > 0
  410. void  OSSchedUnlock (void)
  411. {
  412. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  413.     OS_CPU_SR  cpu_sr = 0;
  414. #endif
  418.     if (OSRunning == OS_TRUE) {                            /* Make sure multitasking is running        */
  419.         OS_ENTER_CRITICAL();
  420.         if (OSLockNesting > 0) {                           /* Do not decrement if already 0            */
  421.             OSLockNesting--;                               /* Decrement lock nesting level             */
  422.             if (OSLockNesting == 0) {                      /* See if scheduler is enabled and ...      */
  423.                 if (OSIntNesting == 0) {                   /* ... not in an ISR                        */
  424.                     OS_EXIT_CRITICAL();
  425.                     OS_Sched();                            /* See if a HPT is ready                    */
  426.                 } else {
  427.                     OS_EXIT_CRITICAL();
  428.                 }
  429.             } else {
  430.                 OS_EXIT_CRITICAL();
  431.             }
  432.         } else {
  433.             OS_EXIT_CRITICAL();
  434.         }
  435.     }
  436. }
  437. #endif
  439. /*$PAGE*/
  440. /*
  441. *********************************************************************************************************
  442. *                                          START MULTITASKING
  443. *
  444. * Description: This function is used to start the multitasking process which lets uC/OS-II manages the
  445. *              task that you have created.  Before you can call OSStart(), you MUST have called OSInit()
  446. *              and you MUST have created at least one task.
  447. *
  448. * Arguments  : none
  449. *
  450. * Returns    : none
  451. *
  452. * Note       : OSStartHighRdy() MUST:
  453. *                 a) Call OSTaskSwHook() then,
  454. *                 b) Set OSRunning to OS_TRUE.
  455. *                 c) Load the context of the task pointed to by OSTCBHighRdy.
  456. *                 d_ Execute the task.
  457. *********************************************************************************************************
  458. */
  460. void  OSStart (void)
  461. {
  462.     if (OSRunning == OS_FALSE) {
  463.         OS_SchedNew();                               /* Find highest priority's task priority number   */
  464.         OSPrioCur     = OSPrioHighRdy;
  465.         OSTCBHighRdy  = OSTCBPrioTbl[OSPrioHighRdy]; /* Point to highest priority task ready to run    */
  466.         OSTCBCur      = OSTCBHighRdy;
  467.         OSStartHighRdy();                            /* Execute target specific code to start task     */
  468.     }
  469. }
  470. /*$PAGE*/
  471. /*
  472. *********************************************************************************************************
  473. *                                        STATISTICS INITIALIZATION
  474. *
  475. * Description: This function is called by your application to establish CPU usage by first determining
  476. *              how high a 32-bit counter would count to in 1 second if no other tasks were to execute
  477. *              during that time.  CPU usage is then determined by a low priority task which keeps track
  478. *              of this 32-bit counter every second but this time, with other tasks running.  CPU usage is
  479. *              determined by:
  480. *
  481. *                                             OSIdleCtr
  482. *                 CPU Usage (%) = 100 * (1 - ------------)
  483. *                                            OSIdleCtrMax
  484. *
  485. * Arguments  : none
  486. *
  487. * Returns    : none
  488. *********************************************************************************************************
  489. */
  491. #if OS_TASK_STAT_EN > 0
  492. void  OSStatInit (void)
  493. {
  494. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  495.     OS_CPU_SR  cpu_sr = 0;
  496. #endif
  500.     OSTimeDly(2);                                /* Synchronize with clock tick                        */
  501.     OS_ENTER_CRITICAL();
  502.     OSIdleCtr    = 0L;                           /* Clear idle counter                                 */
  503.     OS_EXIT_CRITICAL();
  504.     OSTimeDly(OS_TICKS_PER_SEC / 10);            /* Determine MAX. idle counter value for 1/10 second  */
  505.     OS_ENTER_CRITICAL();
  506.     OSIdleCtrMax = OSIdleCtr;                    /* Store maximum idle counter count in 1/10 second    */
  507.     OSStatRdy    = OS_TRUE;
  508.     OS_EXIT_CRITICAL();
  509. }
  510. #endif
  511. /*$PAGE*/
  512. /*
  513. *********************************************************************************************************
  514. *                                         PROCESS SYSTEM TICK
  515. *
  516. * Description: This function is used to signal to uC/OS-II the occurrence of a 'system tick' (also known
  517. *              as a 'clock tick').  This function should be called by the ticker ISR but, can also be
  518. *              called by a high priority task.
  519. *
  520. * Arguments  : none
  521. *
  522. * Returns    : none
  523. *********************************************************************************************************
  524. */
  526. void  OSTimeTick (void)
  527. {
  528.     OS_TCB    *ptcb;
  529. #if OS_TICK_STEP_EN > 0
  530.     BOOLEAN    step;
  531. #endif
  532. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register     */
  533.     OS_CPU_SR  cpu_sr = 0;
  534. #endif
  538. #if OS_TIME_TICK_HOOK_EN > 0
  539.     OSTimeTickHook();                                      /* Call user definable hook                     */
  540. #endif
  541. #if OS_TIME_GET_SET_EN > 0
  542.     OS_ENTER_CRITICAL();                                   /* Update the 32-bit tick counter               */
  543.     OSTime++;
  544.     OS_EXIT_CRITICAL();
  545. #endif
  546.     if (OSRunning == OS_TRUE) {
  547. #if OS_TICK_STEP_EN > 0
  548.         switch (OSTickStepState) {                         /* Determine whether we need to process a tick  */
  549.             case OS_TICK_STEP_DIS:                         /* Yes, stepping is disabled                    */
  550.                  step = OS_TRUE;
  551.                  break;
  553.             case OS_TICK_STEP_WAIT:                        /* No,  waiting for uC/OS-View to set ...       */
  554.                  step = OS_FALSE;                          /*      .. OSTickStepState to OS_TICK_STEP_ONCE */
  555.                  break;
  557.             case OS_TICK_STEP_ONCE:                        /* Yes, process tick once and wait for next ... */
  558.                  step            = OS_TRUE;                /*      ... step command from uC/OS-View        */
  559.                  OSTickStepState = OS_TICK_STEP_WAIT;
  560.                  break;
  562.             default:                                       /* Invalid case, correct situation              */
  563.                  step            = OS_TRUE;
  564.                  OSTickStepState = OS_TICK_STEP_DIS;
  565.                  break;
  566.         }
  567.         if (step == OS_FALSE) {                            /* Return if waiting for step command           */
  568.             return;
  569.         }
  570. #endif
  571.         ptcb = OSTCBList;                                  /* Point at first TCB in TCB list               */
  572.         while (ptcb->OSTCBPrio != OS_TASK_IDLE_PRIO) {     /* Go through all TCBs in TCB list              */
  573.             OS_ENTER_CRITICAL();
  574.             if (ptcb->OSTCBDly != 0) {                     /* No, Delayed or waiting for event with TO     */
  575.                 if (--ptcb->OSTCBDly == 0) {               /* Decrement nbr of ticks to end of delay       */
  576.                                                            /* Check for timeout                            */
  577.                     if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {
  578.                         ptcb->OSTCBStat   &= ~OS_STAT_PEND_ANY;                /* Yes, Clear status flag   */
  579.                         ptcb->OSTCBPendTO  = OS_TRUE;                          /* Indicate PEND timeout    */
  580.                     } else {
  581.                         ptcb->OSTCBPendTO  = OS_FALSE;
  582.                     }
  584.                     if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?       */
  585.                         OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready          */
  586.                         OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
  587.                     }
  588.                 }
  589.             }
  590.             ptcb = ptcb->OSTCBNext;                        /* Point at next TCB in TCB list                */
  591.             OS_EXIT_CRITICAL();
  592.         }
  593.     }
  594. }
  595. /*$PAGE*/
  596. /*
  597. *********************************************************************************************************
  598. *                                             GET VERSION
  599. *
  600. * Description: This function is used to return the version number of uC/OS-II.  The returned value
  601. *              corresponds to uC/OS-II's version number multiplied by 100.  In other words, version 2.00
  602. *              would be returned as 200.
  603. *
  604. * Arguments  : none
  605. *
  606. * Returns    : the version number of uC/OS-II multiplied by 100.
  607. *********************************************************************************************************
  608. */
  610. INT16U  OSVersion (void)
  611. {
  612.     return (OS_VERSION);
  613. }
  615. /*$PAGE*/
  616. /*
  617. *********************************************************************************************************
  618. *                                            DUMMY FUNCTION
  619. *
  620. * Description: This function doesn't do anything.  It is called by OSTaskDel().
  621. *
  622. * Arguments  : none
  623. *
  624. * Returns    : none
  625. *********************************************************************************************************
  626. */
  628. #if OS_TASK_DEL_EN > 0
  629. void  OS_Dummy (void)
  630. {
  631. }
  632. #endif
  634. /*$PAGE*/
  635. /*
  636. *********************************************************************************************************
  637. *                             MAKE TASK READY TO RUN BASED ON EVENT OCCURING
  638. *
  639. * Description: This function is called by other uC/OS-II services and is used to ready a task that was
  640. *              waiting for an event to occur.
  641. *
  642. * Arguments  : pevent    is a pointer to the event control block corresponding to the event.
  643. *
  644. *              msg       is a pointer to a message.  This pointer is used by message oriented services
  645. *                        such as MAILBOXEs and QUEUEs.  The pointer is not used when called by other
  646. *                        service functions.
  647. *
  648. *              msk       is a mask that is used to clear the status byte of the TCB.  For example,
  649. *                        OSSemPost() will pass OS_STAT_SEM, OSMboxPost() will pass OS_STAT_MBOX etc.
  650. *
  651. * Returns    : none
  652. *
  653. * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
  654. *********************************************************************************************************
  655. */
  656. #if OS_EVENT_EN
  657. INT8U  OS_EventTaskRdy (OS_EVENT *pevent, void *msg, INT8U msk)
  658. {
  659.     OS_TCB  *ptcb;
  660.     INT8U    x;
  661.     INT8U    y;
  662.     INT8U    prio;
  663. #if OS_LOWEST_PRIO <= 63
  664.     INT8U    bitx;
  665.     INT8U    bity;
  666. #else
  667.     INT16U   bitx;
  668.     INT16U   bity;
  669.     INT16U  *ptbl;
  670. #endif
  673. #if OS_LOWEST_PRIO <= 63
  674.     y     = OSUnMapTbl[pevent->OSEventGrp];             /* Find HPT waiting for message                */
  675.     bity  = (INT8U)(1 << y);
  676.     x     = OSUnMapTbl[pevent->OSEventTbl[y]];
  677.     bitx  = (INT8U)(1 << x);
  678.     prio  = (INT8U)((y << 3) + x);                      /* Find priority of task getting the msg       */
  679. #else
  680.     if ((pevent->OSEventGrp & 0xFF) != 0) {             /* Find HPT waiting for message                */
  681.         y = OSUnMapTbl[pevent->OSEventGrp & 0xFF];
  682.     } else {
  683.         y = OSUnMapTbl[(pevent->OSEventGrp >> 8) & 0xFF] + 8;
  684.     }
  685.     bity = (INT16U)(1 << y);
  686.     ptbl = &pevent->OSEventTbl[y];
  687.     if ((*ptbl & 0xFF) != 0) {
  688.         x = OSUnMapTbl[*ptbl & 0xFF];
  689.     } else {
  690.         x = OSUnMapTbl[(*ptbl >> 8) & 0xFF] + 8;
  691.     }
  692.     bitx = (INT16U)(1 << x);
  693.     prio = (INT8U)((y << 4) + x);                       /* Find priority of task getting the msg       */
  694. #endif
  696.     pevent->OSEventTbl[y] &= ~bitx;                     /* Remove this task from the waiting list      */
  697.     if (pevent->OSEventTbl[y] == 0) {
  698.         pevent->OSEventGrp &= ~bity;                    /* Clr group bit if this was only task pending */
  699.     }
  700.     ptcb                 =  OSTCBPrioTbl[prio];         /* Point to this task's OS_TCB                 */
  701.     ptcb->OSTCBDly       =  0;                          /* Prevent OSTimeTick() from readying task     */
  702.     ptcb->OSTCBEventPtr  = (OS_EVENT *)0;               /* Unlink ECB from this task                   */
  703. #if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0)
  704.     ptcb->OSTCBMsg       = msg;                         /* Send message directly to waiting task       */
  705. #else
  706.     msg                  = msg;                         /* Prevent compiler warning if not used        */
  707. #endif
  708.     ptcb->OSTCBPendTO    = OS_FALSE;                    /* Cancel 'any' timeout because of post        */
  709.     ptcb->OSTCBStat     &= ~msk;                        /* Clear bit associated with event type        */
  710.     if (ptcb->OSTCBStat == OS_STAT_RDY) {               /* See if task is ready (could be susp'd)      */
  711.         OSRdyGrp        |=  bity;                       /* Put task in the ready to run list           */
  712.         OSRdyTbl[y]     |=  bitx;
  713.     }
  714.     return (prio);
  715. }
  716. #endif
  717. /*$PAGE*/
  718. /*
  719. *********************************************************************************************************
  720. *                                   MAKE TASK WAIT FOR EVENT TO OCCUR
  721. *
  722. * Description: This function is called by other uC/OS-II services to suspend a task because an event has
  723. *              not occurred.
  724. *
  725. * Arguments  : pevent   is a pointer to the event control block for which the task will be waiting for.
  726. *
  727. * Returns    : none
  728. *
  729. * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
  730. *********************************************************************************************************
  731. */
  732. #if OS_EVENT_EN
  733. void  OS_EventTaskWait (OS_EVENT *pevent)
  734. {
  735.     INT8U  y;
  738.     OSTCBCur->OSTCBEventPtr = pevent;             /* Store pointer to event control block in TCB       */
  739.     y                       = OSTCBCur->OSTCBY;   /* Task no longer ready                              */
  740.     OSRdyTbl[y]            &= ~OSTCBCur->OSTCBBitX;
  741.     if (OSRdyTbl[y] == 0) {
  742.         OSRdyGrp &= ~OSTCBCur->OSTCBBitY;         /* Clear event grp bit if this was only task pending */
  743.     }
  744.     pevent->OSEventTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;          /* Put task in waiting list  */
  745.     pevent->OSEventGrp                   |= OSTCBCur->OSTCBBitY;
  746. }
  747. #endif
  748. /*$PAGE*/
  749. /*
  750. *********************************************************************************************************
  751. *                              MAKE TASK READY TO RUN BASED ON EVENT TIMEOUT
  752. *
  753. * Description: This function is called by other uC/OS-II services to make a task ready to run because a
  754. *              timeout occurred.
  755. *
  756. * Arguments  : pevent   is a pointer to the event control block which is readying a task.
  757. *
  758. * Returns    : none
  759. *
  760. * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
  761. *********************************************************************************************************
  762. */
  763. #if OS_EVENT_EN
  764. void  OS_EventTO (OS_EVENT *pevent)
  765. {
  766.     INT8U  y;
  769.     y                      = OSTCBCur->OSTCBY;
  770.     pevent->OSEventTbl[y] &= ~OSTCBCur->OSTCBBitX;     /* Remove task from wait list                   */
  771.     if (pevent->OSEventTbl[y] == 0x00) {
  772.         pevent->OSEventGrp &= ~OSTCBCur->OSTCBBitY;
  773.     }
  774.     OSTCBCur->OSTCBPendTO   = OS_FALSE;                /* Clear the Pend Timeout flag                  */
  775.     OSTCBCur->OSTCBStat     = OS_STAT_RDY;             /* Set status to ready                          */
  776.     OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;           /* No longer waiting for event                  */
  777. }
  778. #endif
  779. /*$PAGE*/
  780. /*
  781. *********************************************************************************************************
  782. *                                 INITIALIZE EVENT CONTROL BLOCK'S WAIT LIST
  783. *
  784. * Description: This function is called by other uC/OS-II services to initialize the event wait list.
  785. *
  786. * Arguments  : pevent    is a pointer to the event control block allocated to the event.
  787. *
  788. * Returns    : none
  789. *
  790. * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
  791. *********************************************************************************************************
  792. */
  793. #if OS_EVENT_EN
  794. void  OS_EventWaitListInit (OS_EVENT *pevent)
  795. {
  796. #if OS_LOWEST_PRIO <= 63
  797.     INT8U  *ptbl;
  798. #else
  799.     INT16U *ptbl;
  800. #endif
  801.     INT8U   i;
  804.     pevent->OSEventGrp = 0;                      /* No task waiting on event                           */
  805.     ptbl               = &pevent->OSEventTbl[0];
  807.     for (i = 0; i < OS_EVENT_TBL_SIZE; i++) {
  808.         *ptbl++ = 0;
  809.     }
  810. }
  811. #endif
  812. /*$PAGE*/
  813. /*
  814. *********************************************************************************************************
  815. *                                             INITIALIZATION
  816. *                           INITIALIZE THE FREE LIST OF EVENT CONTROL BLOCKS
  817. *
  818. * Description: This function is called by OSInit() to initialize the free list of event control blocks.
  819. *
  820. * Arguments  : none
  821. *
  822. * Returns    : none
  823. *********************************************************************************************************
  824. */
  826. static  void  OS_InitEventList (void)
  827. {
  828. #if OS_EVENT_EN && (OS_MAX_EVENTS > 0)
  829. #if (OS_MAX_EVENTS > 1)
  830.     INT16U     i;
  831.     OS_EVENT  *pevent1;
  832.     OS_EVENT  *pevent2;
  835.     OS_MemClr((INT8U *)&OSEventTbl[0], sizeof(OSEventTbl)); /* Clear the event table                   */
  836.     pevent1 = &OSEventTbl[0];
  837.     pevent2 = &OSEventTbl[1];
  838.     for (i = 0; i < (OS_MAX_EVENTS - 1); i++) {             /* Init. list of free EVENT control blocks */
  839.         pevent1->OSEventType    = OS_EVENT_TYPE_UNUSED;
  840.         pevent1->OSEventPtr     = pevent2;
  841. #if OS_EVENT_NAME_SIZE > 1
  842.         pevent1->OSEventName[0] = '?';                      /* Unknown name                            */
  843.         pevent1->OSEventName[1] = OS_ASCII_NUL;
  844. #endif
  845.         pevent1++;
  846.         pevent2++;
  847.     }
  848.     pevent1->OSEventType            = OS_EVENT_TYPE_UNUSED;
  849.     pevent1->OSEventPtr             = (OS_EVENT *)0;
  850. #if OS_EVENT_NAME_SIZE > 1
  851.     pevent1->OSEventName[0]         = '?';
  852.     pevent1->OSEventName[1]         = OS_ASCII_NUL;
  853. #endif
  854.     OSEventFreeList                 = &OSEventTbl[0];
  855. #else
  856.     OSEventFreeList                 = &OSEventTbl[0];       /* Only have ONE event control block       */
  857.     OSEventFreeList->OSEventType    = OS_EVENT_TYPE_UNUSED;
  858.     OSEventFreeList->OSEventPtr     = (OS_EVENT *)0;
  859. #if OS_EVENT_NAME_SIZE > 1
  860.     OSEventFreeList->OSEventName[0] = '?';                  /* Unknown name                            */
  861.     OSEventFreeList->OSEventName[1] = OS_ASCII_NUL;
  862. #endif
  863. #endif
  864. #endif
  865. }
  866. /*$PAGE*/
  867. /*
  868. *********************************************************************************************************
  869. *                                             INITIALIZATION
  870. *                                    INITIALIZE MISCELLANEOUS VARIABLES
  871. *
  872. * Description: This function is called by OSInit() to initialize miscellaneous variables.
  873. *
  874. * Arguments  : none
  875. *
  876. * Returns    : none
  877. *********************************************************************************************************
  878. */
  880. static  void  OS_InitMisc (void)
  881. {
  882. #if OS_TIME_GET_SET_EN > 0
  883.     OSTime        = 0L;                                    /* Clear the 32-bit system clock            */
  884. #endif
  886.     OSIntNesting  = 0;                                     /* Clear the interrupt nesting counter      */
  887.     OSLockNesting = 0;                                     /* Clear the scheduling lock counter        */
  889.     OSTaskCtr     = 0;                                     /* Clear the number of tasks                */
  891.     OSRunning     = OS_FALSE;                              /* Indicate that multitasking not started   */
  893.     OSCtxSwCtr    = 0;                                     /* Clear the context switch counter         */
  894.     OSIdleCtr     = 0L;                                    /* Clear the 32-bit idle counter            */
  896. #if OS_TASK_STAT_EN > 0
  897.     OSIdleCtrRun  = 0L;
  898.     OSIdleCtrMax  = 0L;
  899.     OSStatRdy     = OS_FALSE;                              /* Statistic task is not ready              */
  900. #endif
  901. }
  902. /*$PAGE*/
  903. /*
  904. *********************************************************************************************************
  905. *                                             INITIALIZATION
  906. *                                       INITIALIZE THE READY LIST
  907. *
  908. * Description: This function is called by OSInit() to initialize the Ready List.
  909. *
  910. * Arguments  : none
  911. *
  912. * Returns    : none
  913. *********************************************************************************************************
  914. */
  916. static  void  OS_InitRdyList (void)
  917. {
  918.     INT8U    i;
  919. #if OS_LOWEST_PRIO <= 63
  920.     INT8U   *prdytbl;
  921. #else
  922.     INT16U  *prdytbl;
  923. #endif
  926.     OSRdyGrp      = 0;                                     /* Clear the ready list                     */
  927.     prdytbl       = &OSRdyTbl[0];
  928.     for (i = 0; i < OS_RDY_TBL_SIZE; i++) {
  929.         *prdytbl++ = 0;
  930.     }
  932.     OSPrioCur     = 0;
  933.     OSPrioHighRdy = 0;
  935.     OSTCBHighRdy  = (OS_TCB *)0;
  936.     OSTCBCur      = (OS_TCB *)0;
  937. }
  939. /*$PAGE*/
  940. /*
  941. *********************************************************************************************************
  942. *                                             INITIALIZATION
  943. *                                         CREATING THE IDLE TASK
  944. *
  945. * Description: This function creates the Idle Task.
  946. *
  947. * Arguments  : none
  948. *
  949. * Returns    : none
  950. *********************************************************************************************************
  951. */
  953. static  void  OS_InitTaskIdle (void)
  954. {
  955. #if OS_TASK_NAME_SIZE > 7
  956.     INT8U  err;
  957. #endif
  960. #if OS_TASK_CREATE_EXT_EN > 0
  961.     #if OS_STK_GROWTH == 1
  962.     (void)OSTaskCreateExt(OS_TaskIdle,
  963.                           (void *)0,                                 /* No arguments passed to OS_TaskIdle() */
  964.                           &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Top-Of-Stack                     */
  965.                           OS_TASK_IDLE_PRIO,                         /* Lowest priority level                */
  966.                           OS_TASK_IDLE_ID,
  967.                           &OSTaskIdleStk[0],                         /* Set Bottom-Of-Stack                  */
  968.                           OS_TASK_IDLE_STK_SIZE,
  969.                           (void *)0,                                 /* No TCB extension                     */
  970.                           OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
  971.     #else
  972.     (void)OSTaskCreateExt(OS_TaskIdle,
  973.                           (void *)0,                                 /* No arguments passed to OS_TaskIdle() */
  974.                           &OSTaskIdleStk[0],                         /* Set Top-Of-Stack                     */
  975.                           OS_TASK_IDLE_PRIO,                         /* Lowest priority level                */
  976.                           OS_TASK_IDLE_ID,
  977.                           &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Bottom-Of-Stack                  */
  978.                           OS_TASK_IDLE_STK_SIZE,
  979.                           (void *)0,                                 /* No TCB extension                     */
  980.                           OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
  981.     #endif
  982. #else
  983.     #if OS_STK_GROWTH == 1
  984.     (void)OSTaskCreate(OS_TaskIdle,
  985.                        (void *)0,
  986.                        &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1],
  987.                        OS_TASK_IDLE_PRIO);
  988.     #else
  989.     (void)OSTaskCreate(OS_TaskIdle,
  990.                        (void *)0,
  991.                        &OSTaskIdleStk[0],
  992.                        OS_TASK_IDLE_PRIO);
  993.     #endif
  994. #endif
  996. #if OS_TASK_NAME_SIZE > 14
  997.     OSTaskNameSet(OS_TASK_IDLE_PRIO, (INT8U *)"uC/OS-II Idle", &err);
  998. #else
  999. #if OS_TASK_NAME_SIZE > 7
  1000.     OSTaskNameSet(OS_TASK_IDLE_PRIO, (INT8U *)"OS-Idle", &err);
  1001. #endif
  1002. #endif
  1003. }
  1004. /*$PAGE*/
  1005. /*
  1006. *********************************************************************************************************
  1007. *                                             INITIALIZATION
  1008. *                                      CREATING THE STATISTIC TASK
  1009. *
  1010. * Description: This function creates the Statistic Task.
  1011. *
  1012. * Arguments  : none
  1013. *
  1014. * Returns    : none
  1015. *********************************************************************************************************
  1016. */
  1018. #if OS_TASK_STAT_EN > 0
  1019. static  void  OS_InitTaskStat (void)
  1020. {
  1021. #if OS_TASK_NAME_SIZE > 7
  1022.     INT8U  err;
  1023. #endif
  1026. #if OS_TASK_CREATE_EXT_EN > 0
  1027.     #if OS_STK_GROWTH == 1
  1028.     (void)OSTaskCreateExt(OS_TaskStat,
  1029.                           (void *)0,                                   /* No args passed to OS_TaskStat()*/
  1030.                           &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],   /* Set Top-Of-Stack               */
  1031.                           OS_TASK_STAT_PRIO,                           /* One higher than the idle task  */
  1032.                           OS_TASK_STAT_ID,
  1033.                           &OSTaskStatStk[0],                           /* Set Bottom-Of-Stack            */
  1034.                           OS_TASK_STAT_STK_SIZE,
  1035.                           (void *)0,                                   /* No TCB extension               */
  1036.                           OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
  1037.     #else
  1038.     (void)OSTaskCreateExt(OS_TaskStat,
  1039.                           (void *)0,                                   /* No args passed to OS_TaskStat()*/
  1040.                           &OSTaskStatStk[0],                           /* Set Top-Of-Stack               */
  1041.                           OS_TASK_STAT_PRIO,                           /* One higher than the idle task  */
  1042.                           OS_TASK_STAT_ID,
  1043.                           &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],   /* Set Bottom-Of-Stack            */
  1044.                           OS_TASK_STAT_STK_SIZE,
  1045.                           (void *)0,                                   /* No TCB extension               */
  1046.                           OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
  1047.     #endif
  1048. #else
  1049.     #if OS_STK_GROWTH == 1
  1050.     (void)OSTaskCreate(OS_TaskStat,
  1051.                        (void *)0,                                      /* No args passed to OS_TaskStat()*/
  1052.                        &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],      /* Set Top-Of-Stack               */
  1053.                        OS_TASK_STAT_PRIO);                             /* One higher than the idle task  */
  1054.     #else
  1055.     (void)OSTaskCreate(OS_TaskStat,
  1056.                        (void *)0,                                      /* No args passed to OS_TaskStat()*/
  1057.                        &OSTaskStatStk[0],                              /* Set Top-Of-Stack               */
  1058.                        OS_TASK_STAT_PRIO);                             /* One higher than the idle task  */
  1059.     #endif
  1060. #endif
  1062. #if OS_TASK_NAME_SIZE > 14
  1063.     OSTaskNameSet(OS_TASK_STAT_PRIO, (INT8U *)"uC/OS-II Stat", &err);
  1064. #else
  1065. #if OS_TASK_NAME_SIZE > 7
  1066.     OSTaskNameSet(OS_TASK_STAT_PRIO, (INT8U *)"OS-Stat", &err);
  1067. #endif
  1068. #endif
  1069. }
  1070. #endif
  1071. /*$PAGE*/
  1072. /*
  1073. *********************************************************************************************************
  1074. *                                             INITIALIZATION
  1075. *                            INITIALIZE THE FREE LIST OF TASK CONTROL BLOCKS
  1076. *
  1077. * Description: This function is called by OSInit() to initialize the free list of OS_TCBs.
  1078. *
  1079. * Arguments  : none
  1080. *
  1081. * Returns    : none
  1082. *********************************************************************************************************
  1083. */
  1085. static  void  OS_InitTCBList (void)
  1086. {
  1087.     INT8U    i;
  1088.     OS_TCB  *ptcb1;
  1089.     OS_TCB  *ptcb2;
  1092.     OS_MemClr((INT8U *)&OSTCBTbl[0],     sizeof(OSTCBTbl));      /* Clear all the TCBs                 */
  1093.     OS_MemClr((INT8U *)&OSTCBPrioTbl[0], sizeof(OSTCBPrioTbl));  /* Clear the priority table           */
  1094.     ptcb1 = &OSTCBTbl[0];
  1095.     ptcb2 = &OSTCBTbl[1];
  1096.     for (i = 0; i < (OS_MAX_TASKS + OS_N_SYS_TASKS - 1); i++) {  /* Init. list of free TCBs            */
  1097.         ptcb1->OSTCBNext = ptcb2;
  1098. #if OS_TASK_NAME_SIZE > 1
  1099.         ptcb1->OSTCBTaskName[0] = '?';                           /* Unknown name                       */
  1100.         ptcb1->OSTCBTaskName[1] = OS_ASCII_NUL;
  1101. #endif
  1102.         ptcb1++;
  1103.         ptcb2++;
  1104.     }
  1105.     ptcb1->OSTCBNext = (OS_TCB *)0;                              /* Last OS_TCB                        */
  1106. #if OS_TASK_NAME_SIZE > 1
  1107.     ptcb1->OSTCBTaskName[0] = '?';                               /* Unknown name                       */
  1108.     ptcb1->OSTCBTaskName[1] = OS_ASCII_NUL;
  1109. #endif
  1110.     OSTCBList               = (OS_TCB *)0;                       /* TCB lists initializations          */
  1111.     OSTCBFreeList           = &OSTCBTbl[0];
  1112. }
  1113. /*$PAGE*/
  1114. /*
  1115. *********************************************************************************************************
  1116. *                                        CLEAR A SECTION OF MEMORY
  1117. *
  1118. * Description: This function is called by other uC/OS-II services to clear a contiguous block of RAM.
  1119. *
  1120. * Arguments  : pdest    is the start of the RAM to clear (i.e. write 0x00 to)
  1121. *
  1122. *              size     is the number of bytes to clear.
  1123. *
  1124. * Returns    : none
  1125. *
  1126. * Notes      : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
  1127. *              2) Note that we can only clear up to 64K bytes of RAM.  This is not an issue because none
  1128. *                 of the uses of this function gets close to this limit.
  1129. *              3) The clear is done one byte at a time since this will work on any processor irrespective
  1130. *                 of the alignment of the destination.
  1131. *********************************************************************************************************
  1132. */
  1134. void  OS_MemClr (INT8U *pdest, INT16U size)
  1135. {
  1136.     while (size > 0) {
  1137.         *pdest++ = (INT8U)0;
  1138.         size--;
  1139.     }
  1140. }
  1141. /*$PAGE*/
  1142. /*
  1143. *********************************************************************************************************
  1144. *                                        COPY A BLOCK OF MEMORY
  1145. *
  1146. * Description: This function is called by other uC/OS-II services to copy a block of memory from one
  1147. *              location to another.
  1148. *
  1149. * Arguments  : pdest    is a pointer to the 'destination' memory block
  1150. *
  1151. *              psrc     is a pointer to the 'source'      memory block
  1152. *
  1153. *              size     is the number of bytes to copy.
  1154. *
  1155. * Returns    : none
  1156. *
  1157. * Notes      : 1) This function is INTERNAL to uC/OS-II and your application should not call it.  There is
  1158. *                 no provision to handle overlapping memory copy.  However, that's not a problem since this
  1159. *                 is not a situation that will happen.
  1160. *              2) Note that we can only copy up to 64K bytes of RAM
  1161. *              3) The copy is done one byte at a time since this will work on any processor irrespective
  1162. *                 of the alignment of the source and destination.
  1163. *********************************************************************************************************
  1164. */
  1166. void  OS_MemCopy (INT8U *pdest, INT8U *psrc, INT16U size)
  1167. {
  1168.     while (size > 0) {
  1169.         *pdest++ = *psrc++;
  1170.         size--;
  1171.     }
  1172. }
  1173. /*$PAGE*/
  1174. /*
  1175. *********************************************************************************************************
  1176. *                                              SCHEDULER
  1177. *
  1178. * Description: This function is called by other uC/OS-II services to determine whether a new, high
  1179. *              priority task has been made ready to run.  This function is invoked by TASK level code
  1180. *              and is not used to reschedule tasks from ISRs (see OSIntExit() for ISR rescheduling).
  1181. *
  1182. * Arguments  : none
  1183. *
  1184. * Returns    : none
  1185. *
  1186. * Notes      : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
  1187. *              2) Rescheduling is prevented when the scheduler is locked (see OS_SchedLock())
  1188. *********************************************************************************************************
  1189. */
  1191. void  OS_Sched (void)
  1192. {
  1193. #if OS_CRITICAL_METHOD == 3                            /* Allocate storage for CPU status register     */
  1194.     OS_CPU_SR  cpu_sr = 0;
  1195. #endif
  1199.     OS_ENTER_CRITICAL();
  1200.     if (OSIntNesting == 0) {                           /* Schedule only if all ISRs done and ...       */
  1201.         if (OSLockNesting == 0) {                      /* ... scheduler is not locked                  */
  1202.             OS_SchedNew();
  1203.             if (OSPrioHighRdy != OSPrioCur) {          /* No Ctx Sw if current task is highest rdy     */
  1204.                 OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];
  1205. #if OS_TASK_PROFILE_EN > 0
  1206.                 OSTCBHighRdy->OSTCBCtxSwCtr++;         /* Inc. # of context switches to this task      */
  1207. #endif
  1208.                 OSCtxSwCtr++;                          /* Increment context switch counter             */
  1209.                 OS_TASK_SW();                          /* Perform a context switch                     */
  1210.             }
  1211.         }
  1212.     }
  1213.     OS_EXIT_CRITICAL();
  1214. }
  1217. /*
  1218. *********************************************************************************************************
  1219. *                              FIND HIGHEST PRIORITY TASK READY TO RUN
  1220. *
  1221. * Description: This function is called by other uC/OS-II services to determine the highest priority task
  1222. *              that is ready to run.  The global variable 'OSPrioHighRdy' is changed accordingly.
  1223. *
  1224. * Arguments  : none
  1225. *
  1226. * Returns    : none
  1227. *
  1228. * Notes      : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
  1229. *              2) Interrupts are assumed to be disabled when this function is called.
  1230. *********************************************************************************************************
  1231. */
  1233. static  void  OS_SchedNew (void)
  1234. {
  1235. #if OS_LOWEST_PRIO <= 63                         /* See if we support up to 64 tasks                   */
  1236.     INT8U   y;
  1239.     y             = OSUnMapTbl[OSRdyGrp];
  1240.     OSPrioHighRdy = (INT8U)((y << 3) + OSUnMapTbl[OSRdyTbl[y]]);
  1241. #else                                            /* We support up to 256 tasks                         */
  1242.     INT8U   y;
  1243.     INT16U *ptbl;
  1246.     if ((OSRdyGrp & 0xFF) != 0) {
  1247.         y = OSUnMapTbl[OSRdyGrp & 0xFF];
  1248.     } else {
  1249.         y = OSUnMapTbl[(OSRdyGrp >> 8) & 0xFF] + 8;
  1250.     }
  1251.     ptbl = &OSRdyTbl[y];
  1252.     if ((*ptbl & 0xFF) != 0) {
  1253.         OSPrioHighRdy = (INT8U)((y << 4) + OSUnMapTbl[(*ptbl & 0xFF)]);
  1254.     } else {
  1255.         OSPrioHighRdy = (INT8U)((y << 4) + OSUnMapTbl[(*ptbl >> 8) & 0xFF] + 8);
  1256.     }
  1257. #endif
  1258. }
  1260. /*$PAGE*/
  1261. /*
  1262. *********************************************************************************************************
  1263. *                                        COPY AN ASCII STRING
  1264. *
  1265. * Description: This function is called by other uC/OS-II services to copy an ASCII string from a 'source'
  1266. *              string to a 'destination' string.
  1267. *
  1268. * Arguments  : pdest    is a pointer to the string that will be receiving the copy.  Note that there MUST
  1269. *                       be sufficient space in the destination storage area to receive this string.
  1270. *
  1271. *              psrc     is a pointer to the source string.  The source string MUST NOT be greater than
  1272. *                       254 characters.
  1273. *
  1274. * Returns    : The size of the string (excluding the NUL terminating character)
  1275. *
  1276. * Notes      : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
  1277. *********************************************************************************************************
  1278. */
  1280. #if (OS_EVENT_NAME_SIZE > 1) || (OS_FLAG_NAME_SIZE > 1) || (OS_MEM_NAME_SIZE > 1) || (OS_TASK_NAME_SIZE > 1) || (OS_TMR_CFG_NAME_SIZE > 1)
  1281. INT8U  OS_StrCopy (INT8U *pdest, INT8U *psrc)
  1282. {
  1283.     INT8U  len;
  1286.     len = 0;
  1287.     while (*psrc != OS_ASCII_NUL) {
  1288.         *pdest++ = *psrc++;
  1289.         len++;
  1290.     }
  1291.     *pdest = OS_ASCII_NUL;
  1292.     return (len);
  1293. }
  1294. #endif
  1295. /*$PAGE*/
  1296. /*
  1297. *********************************************************************************************************
  1298. *                                DETERMINE THE LENGTH OF AN ASCII STRING
  1299. *
  1300. * Description: This function is called by other uC/OS-II services to determine the size of an ASCII string
  1301. *              (excluding the NUL character).
  1302. *
  1303. * Arguments  : psrc     is a pointer to the string for which we need to know the size.
  1304. *
  1305. * Returns    : The size of the string (excluding the NUL terminating character)
  1306. *
  1307. * Notes      : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
  1308. *              2) The string to check must be less than 255 characters long.
  1309. *********************************************************************************************************
  1310. */
  1312. #if (OS_EVENT_NAME_SIZE > 1) || (OS_FLAG_NAME_SIZE > 1) || (OS_MEM_NAME_SIZE > 1) || (OS_TASK_NAME_SIZE > 1) || (OS_TMR_CFG_NAME_SIZE > 1)
  1313. INT8U  OS_StrLen (INT8U *psrc)
  1314. {
  1315.     INT8U  len;
  1318.     len = 0;
  1319.     while (*psrc != OS_ASCII_NUL) {
  1320.         psrc++;
  1321.         len++;
  1322.     }
  1323.     return (len);
  1324. }
  1325. #endif
  1326. /*$PAGE*/
  1327. /*
  1328. *********************************************************************************************************
  1329. *                                              IDLE TASK
  1330. *
  1331. * Description: This task is internal to uC/OS-II and executes whenever no other higher priority tasks
  1332. *              executes because they are ALL waiting for event(s) to occur.
  1333. *
  1334. * Arguments  : none
  1335. *
  1336. * Returns    : none
  1337. *
  1338. * Note(s)    : 1) OSTaskIdleHook() is called after the critical section to ensure that interrupts will be
  1339. *                 enabled for at least a few instructions.  On some processors (ex. Philips XA), enabling
  1340. *                 and then disabling interrupts didn't allow the processor enough time to have interrupts
  1341. *                 enabled before they were disabled again.  uC/OS-II would thus never recognize
  1342. *                 interrupts.
  1343. *              2) This hook has been added to allow you to do such things as STOP the CPU to conserve
  1344. *                 power.
  1345. *********************************************************************************************************
  1346. */
  1348. void  OS_TaskIdle (void *p_arg)
  1349. {
  1350. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  1351.     OS_CPU_SR  cpu_sr = 0;
  1352. #endif
  1356.     (void)p_arg;                                 /* Prevent compiler warning for not using 'parg'      */
  1357.     for (;;) {
  1358.         OS_ENTER_CRITICAL();
  1359.         OSIdleCtr++;
  1360.         OS_EXIT_CRITICAL();
  1361.         OSTaskIdleHook();                        /* Call user definable HOOK                           */
  1362.     }
  1363. }
  1364. /*$PAGE*/
  1365. /*
  1366. *********************************************************************************************************
  1367. *                                            STATISTICS TASK
  1368. *
  1369. * Description: This task is internal to uC/OS-II and is used to compute some statistics about the
  1370. *              multitasking environment.  Specifically, OS_TaskStat() computes the CPU usage.
  1371. *              CPU usage is determined by:
  1372. *
  1373. *                                          OSIdleCtr
  1374. *                 OSCPUUsage = 100 * (1 - ------------)     (units are in %)
  1375. *                                         OSIdleCtrMax
  1376. *
  1377. * Arguments  : parg     this pointer is not used at this time.
  1378. *
  1379. * Returns    : none
  1380. *
  1381. * Notes      : 1) This task runs at a priority level higher than the idle task.  In fact, it runs at the
  1382. *                 next higher priority, OS_TASK_IDLE_PRIO-1.
  1383. *              2) You can disable this task by setting the configuration #define OS_TASK_STAT_EN to 0.
  1384. *              3) You MUST have at least a delay of 2/10 seconds to allow for the system to establish the
  1385. *                 maximum value for the idle counter.
  1386. *********************************************************************************************************
  1387. */
  1389. #if OS_TASK_STAT_EN > 0
  1390. void  OS_TaskStat (void *p_arg)
  1391. {
  1392.     INT32U     run;
  1393.     INT32U     max;
  1394.     INT8S      usage;
  1395. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  1396.     OS_CPU_SR  cpu_sr = 0;
  1397. #endif
  1401.     p_arg = p_arg;                               /* Prevent compiler warning for not using 'parg'      */
  1402.     while (OSStatRdy == OS_FALSE) {
  1403.         OSTimeDly(2 * OS_TICKS_PER_SEC / 10);    /* Wait until statistic task is ready                 */
  1404.     }
  1405.     max = OSIdleCtrMax / 100L;
  1406.     for (;;) {
  1407.         OS_ENTER_CRITICAL();
  1408.         OSIdleCtrRun = OSIdleCtr;                /* Obtain the of the idle counter for the past second */
  1409.         run          = OSIdleCtr;
  1410.         OSIdleCtr    = 0L;                       /* Reset the idle counter for the next second         */
  1411.         OS_EXIT_CRITICAL();
  1412.         if (max > 0L) {
  1413.             usage = (INT8S)(100L - run / max);
  1414.             if (usage >= 0) {                    /* Make sure we don't have a negative percentage      */
  1415.                 OSCPUUsage = usage;
  1416.             } else {
  1417.                 OSCPUUsage = 0;
  1418.             }
  1419.         } else {
  1420.             OSCPUUsage = 0;
  1421.             max        = OSIdleCtrMax / 100L;
  1422.         }
  1423.         OSTaskStatHook();                        /* Invoke user definable hook                         */
  1424. #if (OS_TASK_STAT_STK_CHK_EN > 0) && (OS_TASK_CREATE_EXT_EN > 0)
  1425.         OS_TaskStatStkChk();                     /* Check the stacks for each task                     */
  1426. #endif
  1427.         OSTimeDly(OS_TICKS_PER_SEC / 10);        /* Accumulate OSIdleCtr for the next 1/10 second      */
  1428.     }
  1429. }
  1430. #endif
  1431. /*$PAGE*/
  1432. /*
  1433. *********************************************************************************************************
  1434. *                                      CHECK ALL TASK STACKS
  1435. *
  1436. * Description: This function is called by OS_TaskStat() to check the stacks of each active task.
  1437. *
  1438. * Arguments  : none
  1439. *
  1440. * Returns    : none
  1441. *********************************************************************************************************
  1442. */
  1444. #if (OS_TASK_STAT_STK_CHK_EN > 0) && (OS_TASK_CREATE_EXT_EN > 0)
  1445. void  OS_TaskStatStkChk (void)
  1446. {
  1447.     OS_TCB      *ptcb;
  1448.     OS_STK_DATA  stk_data;
  1449.     INT8U        err;
  1450.     INT8U        prio;
  1453.     for (prio = 0; prio <= OS_TASK_IDLE_PRIO; prio++) {
  1454.         err = OSTaskStkChk(prio, &stk_data);
  1455.         if (err == OS_NO_ERR) {
  1456.             ptcb = OSTCBPrioTbl[prio];
  1457.             if (ptcb != (OS_TCB *)0) {                               /* Make sure task 'ptcb' is ...   */
  1458.                 if (ptcb != (OS_TCB *)1) {                           /* ... still valid.               */
  1459. #if OS_TASK_PROFILE_EN > 0
  1460.                     #if OS_STK_GROWTH == 1
  1461.                     ptcb->OSTCBStkBase = ptcb->OSTCBStkBottom + ptcb->OSTCBStkSize;
  1462.                     #else
  1463.                     ptcb->OSTCBStkBase = ptcb->OSTCBStkBottom - ptcb->OSTCBStkSize;
  1464.                     #endif
  1465.                     ptcb->OSTCBStkUsed = stk_data.OSUsed;            /* Store the number of bytes used */
  1466. #endif
  1467.                 }
  1468.             }
  1469.         }
  1470.     }
  1471. }
  1472. #endif
  1473. /*$PAGE*/
  1474. /*
  1475. *********************************************************************************************************
  1476. *                                            INITIALIZE TCB
  1477. *
  1478. * Description: This function is internal to uC/OS-II and is used to initialize a Task Control Block when
  1479. *              a task is created (see OSTaskCreate() and OSTaskCreateExt()).
  1480. *
  1481. * Arguments  : prio          is the priority of the task being created
  1482. *
  1483. *              ptos          is a pointer to the task's top-of-stack assuming that the CPU registers
  1484. *                            have been placed on the stack.  Note that the top-of-stack corresponds to a
  1485. *                            'high' memory location is OS_STK_GROWTH is set to 1 and a 'low' memory
  1486. *                            location if OS_STK_GROWTH is set to 0.  Note that stack growth is CPU
  1487. *                            specific.
  1488. *
  1489. *              pbos          is a pointer to the bottom of stack.  A NULL pointer is passed if called by
  1490. *                            'OSTaskCreate()'.
  1491. *
  1492. *              id            is the task's ID (0..65535)
  1493. *
  1494. *              stk_size      is the size of the stack (in 'stack units').  If the stack units are INT8Us
  1495. *                            then, 'stk_size' contains the number of bytes for the stack.  If the stack
  1496. *                            units are INT32Us then, the stack contains '4 * stk_size' bytes.  The stack
  1497. *                            units are established by the #define constant OS_STK which is CPU
  1498. *                            specific.  'stk_size' is 0 if called by 'OSTaskCreate()'.
  1499. *
  1500. *              pext          is a pointer to a user supplied memory area that is used to extend the task
  1501. *                            control block.  This allows you to store the contents of floating-point
  1502. *                            registers, MMU registers or anything else you could find useful during a
  1503. *                            context switch.  You can even assign a name to each task and store this name
  1504. *                            in this TCB extension.  A NULL pointer is passed if called by OSTaskCreate().
  1505. *
  1506. *              opt           options as passed to 'OSTaskCreateExt()' or,
  1507. *                            0 if called from 'OSTaskCreate()'.
  1508. *
  1509. * Returns    : OS_NO_ERR         if the call was successful
  1510. *              OS_NO_MORE_TCB    if there are no more free TCBs to be allocated and thus, the task cannot
  1511. *                                be created.
  1512. *
  1513. * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
  1514. *********************************************************************************************************
  1515. */
  1517. INT8U  OS_TCBInit (INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT32U stk_size, void *pext, INT16U opt)
  1518. {
  1519.     OS_TCB    *ptcb;
  1520. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  1521.     OS_CPU_SR  cpu_sr = 0;
  1522. #endif
  1526.     OS_ENTER_CRITICAL();
  1527.     ptcb = OSTCBFreeList;                                  /* Get a free TCB from the free TCB list    */
  1528.     if (ptcb != (OS_TCB *)0) {
  1529.         OSTCBFreeList        = ptcb->OSTCBNext;            /* Update pointer to free TCB list          */
  1530.         OS_EXIT_CRITICAL();
  1531.         ptcb->OSTCBStkPtr    = ptos;                       /* Load Stack pointer in TCB                */
  1532.         ptcb->OSTCBPrio      = prio;                       /* Load task priority into TCB              */
  1533.         ptcb->OSTCBStat      = OS_STAT_RDY;                /* Task is ready to run                     */
  1534.         ptcb->OSTCBPendTO    = OS_FALSE;                   /* Clear the Pend timeout flag              */
  1535.         ptcb->OSTCBDly       = 0;                          /* Task is not delayed                      */
  1537. #if OS_TASK_CREATE_EXT_EN > 0
  1538.         ptcb->OSTCBExtPtr    = pext;                       /* Store pointer to TCB extension           */
  1539.         ptcb->OSTCBStkSize   = stk_size;                   /* Store stack size                         */
  1540.         ptcb->OSTCBStkBottom = pbos;                       /* Store pointer to bottom of stack         */
  1541.         ptcb->OSTCBOpt       = opt;                        /* Store task options                       */
  1542.         ptcb->OSTCBId        = id;                         /* Store task ID                            */
  1543. #else
  1544.         pext                 = pext;                       /* Prevent compiler warning if not used     */
  1545.         stk_size             = stk_size;
  1546.         pbos                 = pbos;
  1547.         opt                  = opt;
  1548.         id                   = id;
  1549. #endif
  1551. #if OS_TASK_DEL_EN > 0
  1552.         ptcb->OSTCBDelReq    = OS_NO_ERR;
  1553. #endif
  1555. #if OS_LOWEST_PRIO <= 63
  1556.         ptcb->OSTCBY         = (INT8U)(prio >> 3);         /* Pre-compute X, Y, BitX and BitY          */
  1557.         ptcb->OSTCBBitY      = (INT8U)(1 << ptcb->OSTCBY);
  1558.         ptcb->OSTCBX         = (INT8U)(prio & 0x07);
  1559.         ptcb->OSTCBBitX      = (INT8U)(1 << ptcb->OSTCBX);
  1560. #else
  1561.         ptcb->OSTCBY         = (INT8U)((prio >> 4) & 0xFF);/* Pre-compute X, Y, BitX and BitY          */
  1562.         ptcb->OSTCBBitY      = (INT16U)(1 << ptcb->OSTCBY);
  1563.         ptcb->OSTCBX         = (INT8U)(prio & 0x0F);
  1564.         ptcb->OSTCBBitX      = (INT16U)(1 << ptcb->OSTCBX);
  1565. #endif
  1567. #if OS_EVENT_EN
  1568.         ptcb->OSTCBEventPtr  = (OS_EVENT *)0;              /* Task is not pending on an event          */
  1569. #endif
  1571. #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0) && (OS_TASK_DEL_EN > 0)
  1572.         ptcb->OSTCBFlagNode  = (OS_FLAG_NODE *)0;          /* Task is not pending on an event flag     */
  1573. #endif
  1575. #if (OS_MBOX_EN > 0) || ((OS_Q_EN > 0) && (OS_MAX_QS > 0))
  1576.         ptcb->OSTCBMsg       = (void *)0;                  /* No message received                      */
  1577. #endif
  1579. #if OS_TASK_PROFILE_EN > 0
  1580.         ptcb->OSTCBCtxSwCtr    = 0L;                       /* Initialize profiling variables           */
  1581.         ptcb->OSTCBCyclesStart = 0L;
  1582.         ptcb->OSTCBCyclesTot   = 0L;
  1583.         ptcb->OSTCBStkBase     = (OS_STK *)0;
  1584.         ptcb->OSTCBStkUsed     = 0L;
  1585. #endif
  1587. #if OS_TASK_NAME_SIZE > 1
  1588.         ptcb->OSTCBTaskName[0] = '?';                      /* Unknown name at task creation            */
  1589.         ptcb->OSTCBTaskName[1] = OS_ASCII_NUL;
  1590. #endif
  1592. #if OS_VERSION >= 204
  1593.         OSTCBInitHook(ptcb);
  1594. #endif
  1596.         OSTaskCreateHook(ptcb);                            /* Call user defined hook                   */
  1598.         OS_ENTER_CRITICAL();
  1599.         OSTCBPrioTbl[prio] = ptcb;
  1600.         ptcb->OSTCBNext    = OSTCBList;                    /* Link into TCB chain                      */
  1601.         ptcb->OSTCBPrev    = (OS_TCB *)0;
  1602.         if (OSTCBList != (OS_TCB *)0) {
  1603.             OSTCBList->OSTCBPrev = ptcb;
  1604.         }
  1605.         OSTCBList               = ptcb;
  1606.         OSRdyGrp               |= ptcb->OSTCBBitY;         /* Make task ready to run                   */
  1607.         OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
  1608.         OSTaskCtr++;                                       /* Increment the #tasks counter             */
  1609.         OS_EXIT_CRITICAL();
  1610.         return (OS_NO_ERR);
  1611.     }
  1612.     OS_EXIT_CRITICAL();
  1613.     return (OS_NO_MORE_TCB);
  1614. }