text: /*
  *********************************************************************************************************
  *                                                uC/OS-II
  *                                          The Real-Time Kernel
  *                                             TIME MANAGEMENT
  *
  *                              (c) Copyright 1992-2007, Micrium, Weston, FL
  *                                           All Rights Reserved
  *
  * File    : OS_TIME.C
  * By      : Jean J. Labrosse
  * Version : V2.86
  *
  * LICENSING TERMS:
  * ---------------
  *   uC/OS-II is provided in source form for FREE evaluation, for educational use or for peaceful research.
  * If you plan on using  uC/OS-II  in a commercial product you need to contact Micrium to properly license
  * its use in your product. We provide ALL the source code for your convenience and to help you experience
  * uC/OS-II.   The fact that the  source is provided does  NOT  mean that you can use it without  paying a
  * licensing fee.
  *********************************************************************************************************
  */
  
  #ifndef  OS_MASTER_FILE
  #include <ucos_ii.h>
  #endif
  
  /*
  *********************************************************************************************************
  *                                DELAY TASK 'n' TICKS   (n from 0 to 65535)
  *
  * Description: This function is called to delay execution of the currently running task until the
  *              specified number of system ticks expires.  This, of course, directly equates to delaying
  *              the current task for some time to expire.  No delay will result If the specified delay is
  *              0.  If the specified delay is greater than 0 then, a context switch will result.
  *
  * Arguments  : ticks     is the time delay that the task will be suspended in number of clock 'ticks'.
  *                        Note that by specifying 0, the task will not be delayed.
  *
  * Returns    : none
  *********************************************************************************************************
  */
  
  void  OSTimeDly (INT16U ticks)
  {
      INT8U      y;
  #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
      OS_CPU_SR  cpu_sr = 0;
  #endif
  
  
  
      if (OSIntNesting > 0) {                      /* See if trying to call from an ISR                  */
          return;
      }
      if (ticks > 0) {                             /* 0 means no delay!                                  */
          OS_ENTER_CRITICAL();
          y            =  OSTCBCur->OSTCBY;        /* Delay current task                                 */
          OSRdyTbl[y] &= ~OSTCBCur->OSTCBBitX;
          if (OSRdyTbl[y] == 0) {
              OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
          }
          OSTCBCur->OSTCBDly = ticks;              /* Load ticks in TCB                                  */
          OS_EXIT_CRITICAL();
          OS_Sched();                              /* Find next task to run!                             */
      }
  }
  /*$PAGE*/
  /*
  *********************************************************************************************************
  *                                     DELAY TASK FOR SPECIFIED TIME
  *
  * Description: This function is called to delay execution of the currently running task until some time
  *              expires.  This call allows you to specify the delay time in HOURS, MINUTES, SECONDS and
  *              MILLISECONDS instead of ticks.
  *
  * Arguments  : hours     specifies the number of hours that the task will be delayed (max. is 255)
  *              minutes   specifies the number of minutes (max. 59)
  *              seconds   specifies the number of seconds (max. 59)
  *              milli     specifies the number of milliseconds (max. 999)
  *
  * Returns    : OS_ERR_NONE
  *              OS_ERR_TIME_INVALID_MINUTES
  *              OS_ERR_TIME_INVALID_SECONDS
  *              OS_ERR_TIME_INVALID_MS
  *              OS_ERR_TIME_ZERO_DLY
  *              OS_ERR_TIME_DLY_ISR
  *
  * Note(s)    : The resolution on the milliseconds depends on the tick rate.  For example, you can't do
  *              a 10 mS delay if the ticker interrupts every 100 mS.  In this case, the delay would be
  *              set to 0.  The actual delay is rounded to the nearest tick.
  *********************************************************************************************************
  */
  
  #if OS_TIME_DLY_HMSM_EN > 0
  INT8U  OSTimeDlyHMSM (INT8U hours, INT8U minutes, INT8U seconds, INT16U ms)
  {
      INT32U ticks;
      INT16U loops;
  
  
      if (OSIntNesting > 0) {                      /* See if trying to call from an ISR                  */
          return (OS_ERR_TIME_DLY_ISR);
      }
  #if OS_ARG_CHK_EN > 0
      if (hours == 0) {
          if (minutes == 0) {
              if (seconds == 0) {
                  if (ms == 0) {
                      return (OS_ERR_TIME_ZERO_DLY);
                  }
              }
          }
      }
      if (minutes > 59) {
          return (OS_ERR_TIME_INVALID_MINUTES);    /* Validate arguments to be within range              */
      }
      if (seconds > 59) {
          return (OS_ERR_TIME_INVALID_SECONDS);
      }
      if (ms > 999) {
          return (OS_ERR_TIME_INVALID_MS);
      }
  #endif
                                                   /* Compute the total number of clock ticks required.. */
                                                   /* .. (rounded to the nearest tick)                   */
      ticks = ((INT32U)hours * 3600L + (INT32U)minutes * 60L + (INT32U)seconds) * OS_TICKS_PER_SEC
            + OS_TICKS_PER_SEC * ((INT32U)ms + 500L / OS_TICKS_PER_SEC) / 1000L;
      loops = (INT16U)(ticks >> 16);               /* Compute the integral number of 65536 tick delays   */
      ticks = ticks & 0xFFFFL;                     /* Obtain  the fractional number of ticks             */
      OSTimeDly((INT16U)ticks);
      while (loops > 0) {
          OSTimeDly((INT16U)32768u);
          OSTimeDly((INT16U)32768u);
          loops--;
      }
      return (OS_ERR_NONE);
  }
  #endif
  /*$PAGE*/
  /*
  *********************************************************************************************************
  *                                         RESUME A DELAYED TASK
  *
  * Description: This function is used resume a task that has been delayed through a call to either
  *              OSTimeDly() or OSTimeDlyHMSM().  Note that you can call this function to resume a
  *              task that is waiting for an event with timeout.  This would make the task look
  *              like a timeout occurred.
  *
  *              Also, you cannot resume a task that has called OSTimeDlyHMSM() with a combined time that
  *              exceeds 65535 clock ticks.  In other words, if the clock tick runs at 100 Hz then, you will
  *              not be able to resume a delayed task that called OSTimeDlyHMSM(0, 10, 55, 350) or higher:
  *
  *                  (10 Minutes * 60 + 55 Seconds + 0.35) * 100 ticks/second.
  *
  * Arguments  : prio                      specifies the priority of the task to resume
  *
  * Returns    : OS_ERR_NONE               Task has been resumed
  *              OS_ERR_PRIO_INVALID       if the priority you specify is higher that the maximum allowed
  *                                        (i.e. >= OS_LOWEST_PRIO)
  *              OS_ERR_TIME_NOT_DLY       Task is not waiting for time to expire
  *              OS_ERR_TASK_NOT_EXIST     The desired task has not been created or has been assigned to a Mutex.
  *********************************************************************************************************
  */
  
  #if OS_TIME_DLY_RESUME_EN > 0
  INT8U  OSTimeDlyResume (INT8U prio)
  {
      OS_TCB    *ptcb;
  #if OS_CRITICAL_METHOD == 3                                    /* Storage for CPU status register      */
      OS_CPU_SR  cpu_sr = 0;
  #endif
  
  
  
      if (prio >= OS_LOWEST_PRIO) {
          return (OS_ERR_PRIO_INVALID);
      }
      OS_ENTER_CRITICAL();
      ptcb = OSTCBPrioTbl[prio];                                 /* Make sure that task exist            */
      if (ptcb == (OS_TCB *)0) {
          OS_EXIT_CRITICAL();
          return (OS_ERR_TASK_NOT_EXIST);                        /* The task does not exist              */
      }
      if (ptcb == OS_TCB_RESERVED) {
          OS_EXIT_CRITICAL();
          return (OS_ERR_TASK_NOT_EXIST);                        /* The task does not exist              */
      }
      if (ptcb->OSTCBDly == 0) {                                 /* See if task is delayed               */
          OS_EXIT_CRITICAL();
          return (OS_ERR_TIME_NOT_DLY);                          /* Indicate that task was not delayed   */
      }
  
      ptcb->OSTCBDly = 0;                                        /* Clear the time delay                 */
      if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {
          ptcb->OSTCBStat     &= ~OS_STAT_PEND_ANY;              /* Yes, Clear status flag               */
          ptcb->OSTCBStatPend  =  OS_STAT_PEND_TO;               /* Indicate PEND timeout                */
      } else {
          ptcb->OSTCBStatPend  =  OS_STAT_PEND_OK;
      }
      if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?                   */
          OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready                      */
          OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
          OS_EXIT_CRITICAL();
          OS_Sched();                                            /* See if this is new highest priority  */
      } else {
          OS_EXIT_CRITICAL();                                    /* Task may be suspended                */
      }
      return (OS_ERR_NONE);
  }
  #endif
  /*$PAGE*/
  /*
  *********************************************************************************************************
  *                                         GET CURRENT SYSTEM TIME
  *
  * Description: This function is used by your application to obtain the current value of the 32-bit
  *              counter which keeps track of the number of clock ticks.
  *
  * Arguments  : none
  *
  * Returns    : The current value of OSTime
  *********************************************************************************************************
  */
  
  #if OS_TIME_GET_SET_EN > 0
  INT32U  OSTimeGet (void)
  {
      INT32U     ticks;
  #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
      OS_CPU_SR  cpu_sr = 0;
  #endif
  
  
  
      OS_ENTER_CRITICAL();
      ticks = OSTime;
      OS_EXIT_CRITICAL();
      return (ticks);
  }
  #endif
  
  /*
  *********************************************************************************************************
  *                                            SET SYSTEM CLOCK
  *
  * Description: This function sets the 32-bit counter which keeps track of the number of clock ticks.
  *
  * Arguments  : ticks      specifies the new value that OSTime needs to take.
  *
  * Returns    : none
  *********************************************************************************************************
  */
  
  #if OS_TIME_GET_SET_EN > 0
  void  OSTimeSet (INT32U ticks)
  {
  #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
      OS_CPU_SR  cpu_sr = 0;
  #endif
  
  
  
      OS_ENTER_CRITICAL();
      OSTime = ticks;
      OS_EXIT_CRITICAL();
  }
  #endif
  