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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
OS_CORE.C
资源名称：QFI4ddQe.rar　[点击查看]
上传用户：tzjinxin1
上传日期：2022-08-08
资源大小：272k
文件大小：44k
源码类别：

嵌入式/单片机编程

开发平台：

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