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

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

uCOS

开发平台：

Visual C++

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