/***********************************************************************************************************                                                uC/OS-II*                                          The Real-Time Kernel*                                             TIME MANAGEMENT**                        (c) Copyright 1992-1998, Jean J. Labrosse, Plantation, FL*                                           All Rights Reserved**                                                  V2.00** File : OS_TIME.C* By   : Jean J. Labrosse**********************************************************************************************************/#ifndef  OS_MASTER_FILE#include "includes.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){    if (ticks > 0) {                                                      /* 0 means no delay!         */        OS_ENTER_CRITICAL();        if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {  /* Delay current task        */            OSRdyGrp &= ~OSTCBCur->OSTCBBitY;        }        OSTCBCur->OSTCBDly = ticks;                                       /* Load ticks in TCB         */        OS_EXIT_CRITICAL();        OSSched();                                                        /* 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_NO_ERR*              OS_TIME_INVALID_MINUTES*              OS_TIME_INVALID_SECONDS*              OS_TIME_INVALID_MS*              OS_TIME_ZERO_DLY** 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.**********************************************************************************************************/INT8U OSTimeDlyHMSM (INT8U hours, INT8U minutes, INT8U seconds, INT16U milli){    INT32U ticks;    INT16U loops;    if (hours > 0 || minutes > 0 || seconds > 0 || milli > 0) {        if (minutes > 59) {            return (OS_TIME_INVALID_MINUTES);    /* Validate arguments to be within range              */        }        if (seconds > 59) {            return (OS_TIME_INVALID_SECONDS);        }        if (milli > 999) {            return (OS_TIME_INVALID_MILLI);        }                                                 /* 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)milli + 500L / OS_TICKS_PER_SEC) / 1000L;        loops = ticks / 65536L;                  /* Compute the integral number of 65536 tick delays   */        ticks = ticks % 65536L;                  /* Obtain  the fractional number of ticks             */        OSTimeDly(ticks);        while (loops > 0) {            OSTimeDly(32768);            OSTimeDly(32768);            loops--;        }        return (OS_NO_ERR);    } else {        return (OS_TIME_ZERO_DLY);    }}/*$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 MUST NOT call this function to resume a *              task that is waiting for an event with timeout.  This situation would make the task look *              like a timeout occurred (unless you desire this effect).  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_NO_ERR                 Task has been resumed*              OS_PRIO_INVALID           if the priority you specify is higher that the maximum allowed *                                        (i.e. >= OS_LOWEST_PRIO)*              OS_TIME_NOT_DLY           Task is not waiting for time to expire*              OS_TASK_NOT_EXIST         The desired task has not been created**********************************************************************************************************/INT8U OSTimeDlyResume (INT8U prio){    OS_TCB *ptcb;    if (prio >= OS_LOWEST_PRIO) {        return (OS_PRIO_INVALID);    }    OS_ENTER_CRITICAL();    ptcb = (OS_TCB *)OSTCBPrioTbl[prio];                   /* Make sure that task exist                */    if (ptcb != (OS_TCB *)0) {        if (ptcb->OSTCBDly != 0) {                         /* See if task is delayed                   */            ptcb->OSTCBDly  = 0;                           /* Clear the time delay                     */            if (!(ptcb->OSTCBStat & OS_STAT_SUSPEND)) {    /* See if task is ready to run              */                OSRdyGrp               |= ptcb->OSTCBBitY; /* Make task ready to run                   */                OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;                OS_EXIT_CRITICAL();                OSSched();                                 /* See if this is new highest priority      */            } else {                OS_EXIT_CRITICAL();                        /* Task may be suspended                    */            }            return (OS_NO_ERR);        } else {            OS_EXIT_CRITICAL();            return (OS_TIME_NOT_DLY);                      /* Indicate that task was not delayed       */        }    } else {        OS_EXIT_CRITICAL();        return (OS_TASK_NOT_EXIST);                        /* The task does not exist                  */    }}/*$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**********************************************************************************************************/INT32U OSTimeGet (void){    INT32U ticks;    OS_ENTER_CRITICAL();    ticks = OSTime;    OS_EXIT_CRITICAL();    return (ticks);}/***********************************************************************************************************                                            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**********************************************************************************************************/void OSTimeSet (INT32U ticks){    OS_ENTER_CRITICAL();    OSTime = ticks;    OS_EXIT_CRITICAL();}