www.pudn.com > uCOS-II_MSP430_V11.rar > OS_TIME.C, change:2002-01-25,size:9916b


/* 
********************************************************************************************************* 
*                                                uC/OS-II 
*                                          The Real-Time Kernel 
*                                             TIME MANAGEMENT 
* 
*                          (c) Copyright 1992-2002, Jean J. Labrosse, Weston, FL 
*                                           All Rights Reserved 
* 
* 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 OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */ 
    OS_CPU_SR  cpu_sr; 
#endif     
 
 
    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(); 
        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_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. 
********************************************************************************************************* 
*/ 
 
#if OS_TIME_DLY_HMSM_EN > 0 
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 = (INT16U)(ticks / 65536L);        /* Compute the integral number of 65536 tick delays   */ 
        ticks = ticks % 65536L;                  /* Obtain  the fractional number of ticks             */ 
        OSTimeDly((INT16U)ticks); 
        while (loops > 0) { 
            OSTimeDly(32768); 
            OSTimeDly(32768); 
            loops--; 
        } 
        return (OS_NO_ERR); 
    } 
    return (OS_TIME_ZERO_DLY); 
} 
#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 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 
********************************************************************************************************* 
*/ 
 
#if OS_TIME_DLY_RESUME_EN > 0 
INT8U  OSTimeDlyResume (INT8U prio) 
{ 
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */ 
    OS_CPU_SR  cpu_sr; 
#endif     
    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) == OS_STAT_RDY) {  /* See if task is ready to run  */ 
                OSRdyGrp               |= ptcb->OSTCBBitY;             /* Make task ready to run       */ 
                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_NO_ERR); 
        } else { 
            OS_EXIT_CRITICAL(); 
            return (OS_TIME_NOT_DLY);                      /* Indicate that task was not delayed       */ 
        } 
    } 
    OS_EXIT_CRITICAL(); 
    return (OS_TASK_NOT_EXIST);                            /* The task does not exist                  */ 
} 
#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) 
{ 
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */ 
    OS_CPU_SR  cpu_sr; 
#endif     
    INT32U     ticks; 
 
 
    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; 
#endif     
 
 
    OS_ENTER_CRITICAL(); 
    OSTime = ticks; 
    OS_EXIT_CRITICAL(); 
} 
#endif