os_time.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

/*
*********************************************************************************************************
*   											 uC/OS-II
*   									   The Real-Time Kernel
*   										  TIME MANAGEMENT
*
*   					   (c) Copyright 1992-2007, Jean J. Labrosse, Weston, FL
*   										All Rights Reserved
*
* File    : OS_TIME.C
* By	  : Jean J. Labrosse
* Version : V2.85
*
* 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 Micri祄 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