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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 微处理器开发 > 查看源码
os_core.c
资源名称：str711USB.rar　[点击查看]
上传用户：yyyd609
上传日期：2022-07-18
资源大小：183k
文件大小：67k
源码类别：

微处理器开发

开发平台：

C/C++

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