os_time.c
上传用户:ht5068443
上传日期:2016-07-26
资源大小:802k
文件大小:10k
源码类别:

MacOS编程

开发平台:

C/C++

  1. /*
  2. *********************************************************************************************************
  3. *                                                uC/OS-II
  4. *                                          The Real-Time Kernel
  5. *                                             TIME MANAGEMENT
  6. *
  7. *                              (c) Copyright 1992-2009, Micrium, Weston, FL
  8. *                                           All Rights Reserved
  9. *
  10. * File    : OS_TIME.C
  11. * By      : Jean J. Labrosse
  12. * Version : V2.88
  13. *
  14. * LICENSING TERMS:
  15. * ---------------
  16. *   uC/OS-II is provided in source form for FREE evaluation, for educational use or for peaceful research.  
  17. * If you plan on using  uC/OS-II  in a commercial product you need to contact Micri祄 to properly license 
  18. * its use in your product. We provide ALL the source code for your convenience and to help you experience 
  19. * uC/OS-II.   The fact that the  source is provided does  NOT  mean that you can use it without  paying a 
  20. * licensing fee.
  21. *********************************************************************************************************
  22. */
  23. #ifndef  OS_MASTER_FILE
  24. #include <ucos_ii.h>
  25. #endif
  26. /*
  27. *********************************************************************************************************
  28. *                                       DELAY TASK 'n' TICKS
  29. *
  30. * Description: This function is called to delay execution of the currently running task until the
  31. *              specified number of system ticks expires.  This, of course, directly equates to delaying
  32. *              the current task for some time to expire.  No delay will result If the specified delay is
  33. *              0.  If the specified delay is greater than 0 then, a context switch will result.
  34. *
  35. * Arguments  : ticks     is the time delay that the task will be suspended in number of clock 'ticks'.
  36. *                        Note that by specifying 0, the task will not be delayed.
  37. *
  38. * Returns    : none
  39. *********************************************************************************************************
  40. */
  41. void  OSTimeDly (INT32U ticks)
  42. {
  43.     INT8U      y;
  44. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  45.     OS_CPU_SR  cpu_sr = 0;
  46. #endif
  47.     if (OSIntNesting > 0) {                      /* See if trying to call from an ISR                  */
  48.         return;
  49.     }
  50.     if (ticks > 0) {                             /* 0 means no delay!                                  */
  51.         OS_ENTER_CRITICAL();
  52.         y            =  OSTCBCur->OSTCBY;        /* Delay current task                                 */
  53.         OSRdyTbl[y] &= ~OSTCBCur->OSTCBBitX;
  54.         if (OSRdyTbl[y] == 0) {
  55.             OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
  56.         }
  57.         OSTCBCur->OSTCBDly = ticks;              /* Load ticks in TCB                                  */
  58.         OS_EXIT_CRITICAL();
  59.         OS_Sched();                              /* Find next task to run!                             */
  60.     }
  61. }
  62. /*$PAGE*/
  63. /*
  64. *********************************************************************************************************
  65. *                                     DELAY TASK FOR SPECIFIED TIME
  66. *
  67. * Description: This function is called to delay execution of the currently running task until some time
  68. *              expires.  This call allows you to specify the delay time in HOURS, MINUTES, SECONDS and
  69. *              MILLISECONDS instead of ticks.
  70. *
  71. * Arguments  : hours     specifies the number of hours that the task will be delayed (max. is 255)
  72. *              minutes   specifies the number of minutes (max. 59)
  73. *              seconds   specifies the number of seconds (max. 59)
  74. *              milli     specifies the number of milliseconds (max. 999)
  75. *
  76. * Returns    : OS_ERR_NONE
  77. *              OS_ERR_TIME_INVALID_MINUTES
  78. *              OS_ERR_TIME_INVALID_SECONDS
  79. *              OS_ERR_TIME_INVALID_MS
  80. *              OS_ERR_TIME_ZERO_DLY
  81. *              OS_ERR_TIME_DLY_ISR
  82. *
  83. * Note(s)    : The resolution on the milliseconds depends on the tick rate.  For example, you can't do
  84. *              a 10 mS delay if the ticker interrupts every 100 mS.  In this case, the delay would be
  85. *              set to 0.  The actual delay is rounded to the nearest tick.
  86. *********************************************************************************************************
  87. */
  88. #if OS_TIME_DLY_HMSM_EN > 0
  89. INT8U  OSTimeDlyHMSM (INT8U   hours, 
  90.                       INT8U   minutes, 
  91.                       INT8U   seconds, 
  92.                       INT16U  ms)
  93. {
  94.     INT32U ticks;
  95.     if (OSIntNesting > 0) {                      /* See if trying to call from an ISR                  */
  96.         return (OS_ERR_TIME_DLY_ISR);
  97.     }
  98. #if OS_ARG_CHK_EN > 0
  99.     if (hours == 0) {
  100.         if (minutes == 0) {
  101.             if (seconds == 0) {
  102.                 if (ms == 0) {
  103.                     return (OS_ERR_TIME_ZERO_DLY);
  104.                 }
  105.             }
  106.         }
  107.     }
  108.     if (minutes > 59) {
  109.         return (OS_ERR_TIME_INVALID_MINUTES);    /* Validate arguments to be within range              */
  110.     }
  111.     if (seconds > 59) {
  112.         return (OS_ERR_TIME_INVALID_SECONDS);
  113.     }
  114.     if (ms > 999) {
  115.         return (OS_ERR_TIME_INVALID_MS);
  116.     }
  117. #endif
  118.                                                  /* Compute the total number of clock ticks required.. */
  119.                                                  /* .. (rounded to the nearest tick)                   */
  120.     ticks = ((INT32U)hours * 3600L + (INT32U)minutes * 60L + (INT32U)seconds) * OS_TICKS_PER_SEC
  121.           + OS_TICKS_PER_SEC * ((INT32U)ms + 500L / OS_TICKS_PER_SEC) / 1000L;
  122.     OSTimeDly(ticks);
  123.     return (OS_ERR_NONE);
  124. }
  125. #endif
  126. /*$PAGE*/
  127. /*
  128. *********************************************************************************************************
  129. *                                         RESUME A DELAYED TASK
  130. *
  131. * Description: This function is used resume a task that has been delayed through a call to either
  132. *              OSTimeDly() or OSTimeDlyHMSM().  Note that you can call this function to resume a
  133. *              task that is waiting for an event with timeout.  This would make the task look
  134. *              like a timeout occurred.
  135. *
  136. * Arguments  : prio                      specifies the priority of the task to resume
  137. *
  138. * Returns    : OS_ERR_NONE               Task has been resumed
  139. *              OS_ERR_PRIO_INVALID       if the priority you specify is higher that the maximum allowed
  140. *                                        (i.e. >= OS_LOWEST_PRIO)
  141. *              OS_ERR_TIME_NOT_DLY       Task is not waiting for time to expire
  142. *              OS_ERR_TASK_NOT_EXIST     The desired task has not been created or has been assigned to a Mutex.
  143. *********************************************************************************************************
  144. */
  145. #if OS_TIME_DLY_RESUME_EN > 0
  146. INT8U  OSTimeDlyResume (INT8U prio)
  147. {
  148.     OS_TCB    *ptcb;
  149. #if OS_CRITICAL_METHOD == 3                                    /* Storage for CPU status register      */
  150.     OS_CPU_SR  cpu_sr = 0;
  151. #endif
  152.     if (prio >= OS_LOWEST_PRIO) {
  153.         return (OS_ERR_PRIO_INVALID);
  154.     }
  155.     OS_ENTER_CRITICAL();
  156.     ptcb = OSTCBPrioTbl[prio];                                 /* Make sure that task exist            */
  157.     if (ptcb == (OS_TCB *)0) {
  158.         OS_EXIT_CRITICAL();
  159.         return (OS_ERR_TASK_NOT_EXIST);                        /* The task does not exist              */
  160.     }
  161.     if (ptcb == OS_TCB_RESERVED) {
  162.         OS_EXIT_CRITICAL();
  163.         return (OS_ERR_TASK_NOT_EXIST);                        /* The task does not exist              */
  164.     }
  165.     if (ptcb->OSTCBDly == 0) {                                 /* See if task is delayed               */
  166.         OS_EXIT_CRITICAL();
  167.         return (OS_ERR_TIME_NOT_DLY);                          /* Indicate that task was not delayed   */
  168.     }
  169.     ptcb->OSTCBDly = 0;                                        /* Clear the time delay                 */
  170.     if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {
  171.         ptcb->OSTCBStat     &= ~OS_STAT_PEND_ANY;              /* Yes, Clear status flag               */
  172.         ptcb->OSTCBStatPend  =  OS_STAT_PEND_TO;               /* Indicate PEND timeout                */
  173.     } else {
  174.         ptcb->OSTCBStatPend  =  OS_STAT_PEND_OK;
  175.     }
  176.     if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?                   */
  177.         OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready                      */
  178.         OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
  179.         OS_EXIT_CRITICAL();
  180.         OS_Sched();                                            /* See if this is new highest priority  */
  181.     } else {
  182.         OS_EXIT_CRITICAL();                                    /* Task may be suspended                */
  183.     }
  184.     return (OS_ERR_NONE);
  185. }
  186. #endif
  187. /*$PAGE*/
  188. /*
  189. *********************************************************************************************************
  190. *                                         GET CURRENT SYSTEM TIME
  191. *
  192. * Description: This function is used by your application to obtain the current value of the 32-bit
  193. *              counter which keeps track of the number of clock ticks.
  194. *
  195. * Arguments  : none
  196. *
  197. * Returns    : The current value of OSTime
  198. *********************************************************************************************************
  199. */
  200. #if OS_TIME_GET_SET_EN > 0
  201. INT32U  OSTimeGet (void)
  202. {
  203.     INT32U     ticks;
  204. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  205.     OS_CPU_SR  cpu_sr = 0;
  206. #endif
  207.     OS_ENTER_CRITICAL();
  208.     ticks = OSTime;
  209.     OS_EXIT_CRITICAL();
  210.     return (ticks);
  211. }
  212. #endif
  213. /*
  214. *********************************************************************************************************
  215. *                                            SET SYSTEM CLOCK
  216. *
  217. * Description: This function sets the 32-bit counter which keeps track of the number of clock ticks.
  218. *
  219. * Arguments  : ticks      specifies the new value that OSTime needs to take.
  220. *
  221. * Returns    : none
  222. *********************************************************************************************************
  223. */
  224. #if OS_TIME_GET_SET_EN > 0
  225. void  OSTimeSet (INT32U ticks)
  226. {
  227. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  228.     OS_CPU_SR  cpu_sr = 0;
  229. #endif
  230.     OS_ENTER_CRITICAL();
  231.     OSTime = ticks;
  232.     OS_EXIT_CRITICAL();
  233. }
  234. #endif