os_tmr.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

	}
#endif
	if (ptmr->OSTmrType != OS_TMR_TYPE)
	{
		/* Validate timer structure 								   */
		*perr = OS_ERR_TMR_INVALID_TYPE;
		return (0);
	}
	if (OSIntNesting > 0)
	{
		/* See if trying to call from an ISR						   */
		*perr = OS_ERR_TMR_ISR;
		return (0);
	}
	OSTmr_Lock();
	switch (ptmr->OSTmrState)
	{
		case OS_TMR_STATE_RUNNING:
			remain = ptmr->OSTmrMatch - OSTmrTime;    /* Determine how much time is left to timeout 				 */
			OSTmr_Unlock();
			*perr = OS_ERR_NONE;
			return (remain);

		case OS_TMR_STATE_STOPPED:
			/* It's assumed that the timer has not started yet             */
			switch (ptmr->OSTmrOpt)
			{
				case OS_TMR_OPT_PERIODIC:
					if (ptmr->OSTmrDly == 0)
					{
						remain = ptmr->OSTmrPeriod;
					}
					else
					{
						remain = ptmr->OSTmrDly;
					}
					OSTmr_Unlock();
					*perr = OS_ERR_NONE;
					break;

				case OS_TMR_OPT_ONE_SHOT:
				default:
					remain = ptmr->OSTmrDly;
					OSTmr_Unlock();
					*perr = OS_ERR_NONE;
					break;
			}
			return (remain);

		case OS_TMR_STATE_COMPLETED:
			/* Only ONE-SHOT that timed out can be in this state		   */
			OSTmr_Unlock();
			*perr = OS_ERR_NONE;
			return (0);

		case OS_TMR_STATE_UNUSED:
			OSTmr_Unlock();
			*perr = OS_ERR_TMR_INACTIVE;
			return (0);

		default:
			OSTmr_Unlock();
			*perr = OS_ERR_TMR_INVALID_STATE;
			return (0);
	}
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*   								 FIND OUT WHAT STATE A TIMER IS IN
*
* Description: This function is called to determine what state the timer is in:
*
*   			   OS_TMR_STATE_UNUSED     the timer has not been created
*   			   OS_TMR_STATE_STOPPED    the timer has been created but has not been started or has been stopped
*   			   OS_TMR_COMPLETED 	   the timer is in ONE-SHOT mode and has completed it's timeout
*   			   OS_TMR_RUNNING   	   the timer is currently running
*
* Arguments  : ptmr 		 Is a pointer to the desired timer
*
*   		   perr 		 Is a pointer to an error code.  '*perr' will contain one of the following:
*   							OS_ERR_NONE
*   							OS_ERR_TMR_INVALID  	  'ptmr' is a NULL pointer
*   							OS_ERR_TMR_INVALID_TYPE   'ptmr'  is not pointing to an OS_TMR
*   							OS_ERR_TMR_ISR  		  if the call was made from an ISR
*   							OS_ERR_TMR_INACTIVE 	  'ptmr' points to a timer that is not active
*   							OS_ERR_TMR_INVALID_STATE  if the timer is not in a valid state
*
* Returns    : The current state of the timer (see description).
************************************************************************************************************************
*/

#if OS_TMR_EN > 0
INT8U OSTmrStateGet(OS_TMR *ptmr, INT8U *perr)
{
	INT8U  state;


#if OS_ARG_CHK_EN > 0
	if (perr == (INT8U *) 0)
	{
		return (0);
	}
	if (ptmr == (OS_TMR *) 0)
	{
		*perr = OS_ERR_TMR_INVALID;
		return (0);
	}
#endif
	if (ptmr->OSTmrType != OS_TMR_TYPE)
	{
		/* Validate timer structure 								   */
		*perr = OS_ERR_TMR_INVALID_TYPE;
		return (0);
	}
	if (OSIntNesting > 0)
	{
		/* See if trying to call from an ISR						   */
		*perr = OS_ERR_TMR_ISR;
		return (0);
	}
	OSTmr_Lock();
	state = ptmr->OSTmrState;
	switch (state)
	{
		case OS_TMR_STATE_UNUSED:
		case OS_TMR_STATE_STOPPED:
		case OS_TMR_STATE_COMPLETED:
		case OS_TMR_STATE_RUNNING:
			*perr = OS_ERR_NONE;
			break;

		default:
			*perr = OS_ERR_TMR_INVALID_STATE;
			break;
	}
	OSTmr_Unlock();
	return (state);
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*   												START A TIMER
*
* Description: This function is called by your application code to start a timer.
*
* Arguments  : ptmr 		 Is a pointer to an OS_TMR
*
*   		   perr 		 Is a pointer to an error code.  '*perr' will contain one of the following:
*   							OS_ERR_NONE
*   							OS_ERR_TMR_INVALID
*   							OS_ERR_TMR_INVALID_TYPE    'ptmr'  is not pointing to an OS_TMR
*   							OS_ERR_TMR_ISR  		   if the call was made from an ISR
*   							OS_ERR_TMR_INACTIVE 	   if the timer was not created
*   							OS_ERR_TMR_INVALID_STATE   the timer is in an invalid state
*
* Returns    : OS_TRUE    if the timer was started
*   		   OS_FALSE   if an error was detected
************************************************************************************************************************
*/

#if OS_TMR_EN > 0
BOOLEAN OSTmrStart(OS_TMR *ptmr, INT8U *perr)
{
#if OS_ARG_CHK_EN > 0
	if (perr == (INT8U *) 0)
	{
		/* Validate arguments   								  */
		return (OS_FALSE);
	}
	if (ptmr == (OS_TMR *) 0)
	{
		*perr = OS_ERR_TMR_INVALID;
		return (OS_FALSE);
	}
#endif
	if (ptmr->OSTmrType != OS_TMR_TYPE)
	{
		/* Validate timer structure 							  */
		*perr = OS_ERR_TMR_INVALID_TYPE;
		return (OS_FALSE);
	}
	if (OSIntNesting > 0)
	{
		/* See if trying to call from an ISR					  */
		*perr = OS_ERR_TMR_ISR;
		return (OS_FALSE);
	}
	OSTmr_Lock();
	switch (ptmr->OSTmrState)
	{
		case OS_TMR_STATE_RUNNING:
			/* Restart the timer									  */
			OSTmr_Unlink(ptmr); 						   /* ... Stop the timer									 */
			OSTmr_Link(ptmr, OS_TMR_LINK_DLY);  		   /* ... Link timer to timer wheel 						 */
			OSTmr_Unlock();
			*perr = OS_ERR_NONE;
			return (OS_TRUE);

		case OS_TMR_STATE_STOPPED:
			/* Start the timer  									  */
		case OS_TMR_STATE_COMPLETED:
			OSTmr_Link(ptmr, OS_TMR_LINK_DLY);  		   /* ... Link timer to timer wheel 						 */
			OSTmr_Unlock();
			*perr = OS_ERR_NONE;
			return (OS_TRUE);

		case OS_TMR_STATE_UNUSED:
			/* Timer not created									  */
			OSTmr_Unlock();
			*perr = OS_ERR_TMR_INACTIVE;
			return (OS_FALSE);

		default:
			OSTmr_Unlock();
			*perr = OS_ERR_TMR_INVALID_STATE;
			return (OS_FALSE);
	}
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*   												STOP A TIMER
*
* Description: This function is called by your application code to stop a timer.
*
* Arguments  : ptmr 		 Is a pointer to the timer to stop.
*
*   		   opt  		 Allows you to specify an option to this functions which can be:
*
*   							OS_TMR_OPT_NONE 		 Do nothing special but stop the timer
*   							OS_TMR_OPT_CALLBACK 	 Execute the callback function, pass it the callback argument
*   													 specified when the timer was created.
*   							OS_TMR_OPT_CALLBACK_ARG  Execute the callback function, pass it the callback argument
*   													 specified in THIS function call
*
*   		   callback_arg  Is a pointer to a 'new' callback argument that can be passed to the callback function
*   							instead of the timer's callback argument.  In other words, use 'callback_arg' passed in
*   							THIS function INSTEAD of ptmr->OSTmrCallbackArg
*
*   		   perr 		 Is a pointer to an error code.  '*perr' will contain one of the following:
*   							OS_ERR_NONE
*   							OS_ERR_TMR_INVALID  	   'ptmr' is a NULL pointer
*   							OS_ERR_TMR_INVALID_TYPE    'ptmr'  is not pointing to an OS_TMR
*   							OS_ERR_TMR_ISR  		   if the function was called from an ISR
*   							OS_ERR_TMR_INACTIVE 	   if the timer was not created
*   							OS_ERR_TMR_INVALID_OPT     if you specified an invalid option for 'opt'
*   							OS_ERR_TMR_STOPPED  	   if the timer was already stopped
*   							OS_ERR_TMR_INVALID_STATE   the timer is in an invalid state
*   							OS_ERR_TMR_NO_CALLBACK     if the timer does not have a callback function defined
*
* Returns    : OS_TRUE  	 If we stopped the timer (if the timer is already stopped, we also return OS_TRUE)
*   		   OS_FALSE 	 If not
************************************************************************************************************************
*/

#if OS_TMR_EN > 0
BOOLEAN OSTmrStop(OS_TMR *ptmr, INT8U    opt, void *callback_arg, INT8U *perr)
{
	OS_TMR_CALLBACK  pfnct;


#if OS_ARG_CHK_EN > 0
	if (perr == (INT8U *) 0)
	{
		/* Validate arguments   							*/
		return (OS_FALSE);
	}
	if (ptmr == (OS_TMR *) 0)
	{
		*perr = OS_ERR_TMR_INVALID;
		return (OS_FALSE);
	}
#endif
	if (ptmr->OSTmrType != OS_TMR_TYPE)
	{
		/* Validate timer structure 						*/
		*perr = OS_ERR_TMR_INVALID_TYPE;
		return (OS_FALSE);
	}
	if (OSIntNesting > 0)
	{
		/* See if trying to call from an ISR				*/
		*perr = OS_ERR_TMR_ISR;
		return (OS_FALSE);
	}
	OSTmr_Lock();
	switch (ptmr->OSTmrState)
	{
		case OS_TMR_STATE_RUNNING:
			OSTmr_Unlink(ptmr); 								 /* Remove from current wheel spoke 				 */
			*perr = OS_ERR_NONE;
			switch (opt)
			{
				case OS_TMR_OPT_CALLBACK:
					pfnct = ptmr->OSTmrCallback;				/* Execute callback function if available ...   	*/
					if (pfnct != (OS_TMR_CALLBACK) 0)
					{
						(*pfnct) ((void *) ptmr, ptmr->OSTmrCallbackArg);  /* Use callback arg when timer was created */
					}
					else
					{
						*perr = OS_ERR_TMR_NO_CALLBACK;
					}
					break;

				case OS_TMR_OPT_CALLBACK_ARG:
					pfnct = ptmr->OSTmrCallback;				/* Execute callback function if available ...   	*/
					if (pfnct != (OS_TMR_CALLBACK) 0)
					{
						(*pfnct) ((void *) ptmr, callback_arg);   /* ... using the 'callback_arg' provided in call    */
					}
					else
					{
						*perr = OS_ERR_TMR_NO_CALLBACK;
					}
					break;

				case OS_TMR_OPT_NONE:
					break;

				default:
					*perr = OS_ERR_TMR_INVALID_OPT;
					break;
			}
			OSTmr_Unlock();
			return (OS_TRUE);

		case OS_TMR_STATE_COMPLETED:
			/* Timer has already completed the ONE-SHOT or ...  */
		case OS_TMR_STATE_STOPPED:
			/* ... timer has not started yet.   				*/
			OSTmr_Unlock();
			*perr = OS_ERR_TMR_STOPPED;
			return (OS_TRUE);

		case OS_TMR_STATE_UNUSED:
			/* Timer was not created							*/
			OSTmr_Unlock();
			*perr = OS_ERR_TMR_INACTIVE;
			return (OS_FALSE);

		default:
			OSTmr_Unlock();
			*perr = OS_ERR_TMR_INVALID_STATE;
			return (OS_FALSE);
	}
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*   								   SIGNAL THAT IT'S TIME TO UPDATE THE TIMERS
*
* Description: This function is typically called by the ISR that occurs at the timer tick rate and is used to signal to
*   		   OSTmr_Task() that it's time to update the timers.
*
* Arguments  : none
*
* Returns    : OS_ERR_NONE  	   The call was successful and the timer task was signaled.
*   		   OS_ERR_SEM_OVF      If OSTmrSignal() was called more often than OSTmr_Task() can handle the timers.  
*   							   This would indicate that your system is heavily loaded.
*   		   OS_ERR_EVENT_TYPE   Unlikely you would get this error because the semaphore used for signaling is created 
*   							   by uC/OS-II.
*   		   OS_ERR_PEVENT_NULL  Again, unlikely you would ever get this error because the semaphore used for signaling 
*   							   is created by uC/OS-II.
************************************************************************************************************************
*/

#if OS_TMR_EN > 0
INT8U OSTmrSignal(void)
{
	INT8U  err;


	err = OSSemPost(OSTmrSemSignal);
	return (err);
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*   											ALLOCATE AND FREE A TIMER
*
* Description: This function is called to allocate a timer.
*
* Arguments  : none
*
* Returns    : a pointer to a timer if one is available
************************************************************************************************************************
*/