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

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

微处理器开发

开发平台：

C/C++

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