os_flag.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

/*
*********************************************************************************************************
*   											 uC/OS-II
*   									   The Real-Time Kernel
*   									  EVENT FLAG  MANAGEMENT
*
*   					   (c) Copyright 2001-2007, Jean J. Labrosse, Weston, FL
*   										All Rights Reserved
*
* File    : OS_FLAG.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

#if (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
/*
*********************************************************************************************************
*   										 LOCAL PROTOTYPES
*********************************************************************************************************
*/

static  void OS_FlagBlock(OS_FLAG_GRP *pgrp, OS_FLAG_NODE *pnode, OS_FLAGS flags, INT8U wait_type, INT16U timeout);
static  BOOLEAN OS_FlagTaskRdy(OS_FLAG_NODE *pnode, OS_FLAGS flags_rdy);

/*$PAGE*/
/*
*********************************************************************************************************
*   						   CHECK THE STATUS OF FLAGS IN AN EVENT FLAG GROUP
*
* Description: This function is called to check the status of a combination of bits to be set or cleared
*   		   in an event flag group.  Your application can check for ANY bit to be set/cleared or ALL
*   		   bits to be set/cleared.
*
*   		   This call does not block if the desired flags are not present.
*
* Arguments  : pgrp 		 is a pointer to the desired event flag group.
*
*   		   flags		 Is a bit pattern indicating which bit(s) (i.e. flags) you wish to check.
*   						 The bits you want are specified by setting the corresponding bits in
*   						 'flags'.  e.g. if your application wants to wait for bits 0 and 1 then
*   						 'flags' would contain 0x03.
*
*   		   wait_type	 specifies whether you want ALL bits to be set/cleared or ANY of the bits
*   						 to be set/cleared.
*   						 You can specify the following argument:
*
*   						 OS_FLAG_WAIT_CLR_ALL   You will check ALL bits in 'flags' to be clear (0)
*   						 OS_FLAG_WAIT_CLR_ANY   You will check ANY bit  in 'flags' to be clear (0)
*   						 OS_FLAG_WAIT_SET_ALL   You will check ALL bits in 'flags' to be set   (1)
*   						 OS_FLAG_WAIT_SET_ANY   You will check ANY bit  in 'flags' to be set   (1)
*
*   						 NOTE: Add OS_FLAG_CONSUME if you want the event flag to be 'consumed' by
*   							   the call.  Example, to wait for any flag in a group AND then clear
*   							   the flags that are present, set 'wait_type' to:
*
*   							   OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME
*
*   		   perr 		 is a pointer to an error code and can be:
*   						 OS_ERR_NONE			   No error
*   						 OS_ERR_EVENT_TYPE  	   You are not pointing to an event flag group
*   						 OS_ERR_FLAG_WAIT_TYPE     You didn't specify a proper 'wait_type' argument.
*   						 OS_ERR_FLAG_INVALID_PGRP  You passed a NULL pointer instead of the event flag
*   												   group handle.
*   						 OS_ERR_FLAG_NOT_RDY	   The desired flags you are waiting for are not
*   												   available.
*
* Returns    : The flags in the event flag group that made the task ready or, 0 if a timeout or an error
*   		   occurred.
*
* Called from: Task or ISR
*
* Note(s)    : 1) IMPORTANT, the behavior of this function has changed from PREVIOUS versions.  The
*   			  function NOW returns the flags that were ready INSTEAD of the current state of the
*   			  event flags.
*********************************************************************************************************
*/

#if OS_FLAG_ACCEPT_EN > 0
OS_FLAGS OSFlagAccept(OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT8U *perr)
{
	OS_FLAGS	  flags_rdy;
	INT8U   	  result;
	BOOLEAN 	  consume;
#if OS_CRITICAL_METHOD == 3 							   /* Allocate storage for CPU status register */
	OS_CPU_SR     cpu_sr = 0;
#endif



#if OS_ARG_CHK_EN > 0
	if (perr == (INT8U *) 0)
	{
		/* Validate 'perr'  						*/
		return ((OS_FLAGS) 0);
	}
	if (pgrp == (OS_FLAG_GRP *) 0)
	{
		/* Validate 'pgrp'  						*/
		*perr = OS_ERR_FLAG_INVALID_PGRP;
		return ((OS_FLAGS) 0);
	}
#endif
	if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG)
	{
		/* Validate event block type				*/
		*perr = OS_ERR_EVENT_TYPE;
		return ((OS_FLAGS) 0);
	}
	result = (INT8U) (wait_type & OS_FLAG_CONSUME);
	if (result != (INT8U) 0)
	{
		/* See if we need to consume the flags  	*/
		wait_type &= ~OS_FLAG_CONSUME;
		consume = OS_TRUE;
	}
	else
	{
		consume = OS_FALSE;
	}
	/*$PAGE*/
	*perr = OS_ERR_NONE;								   /* Assume NO error until proven otherwise.  */
	OS_ENTER_CRITICAL();
	switch (wait_type)
	{
		case OS_FLAG_WAIT_SET_ALL:
			/* See if all required flags are set		*/
			flags_rdy = (OS_FLAGS) (pgrp->OSFlagFlags & flags); 	/* Extract only the bits we want   */
			if (flags_rdy == flags)
			{
				/* Must match ALL the bits that we want 	*/
				if (consume == OS_TRUE)
				{
					/* See if we need to consume the flags  	*/
					pgrp->OSFlagFlags &= ~flags_rdy;	  /* Clear ONLY the flags that we wanted	  */
				}
			}
			else
			{
				*perr = OS_ERR_FLAG_NOT_RDY;
			}
			OS_EXIT_CRITICAL();
			break;

		case OS_FLAG_WAIT_SET_ANY:
			flags_rdy = (OS_FLAGS) (pgrp->OSFlagFlags & flags); 	/* Extract only the bits we want   */
			if (flags_rdy != (OS_FLAGS) 0)
			{
				/* See if any flag set  					*/
				if (consume == OS_TRUE)
				{
					/* See if we need to consume the flags  	*/
					pgrp->OSFlagFlags &= ~flags_rdy;	  /* Clear ONLY the flags that we got   	  */
				}
			}
			else
			{
				*perr = OS_ERR_FLAG_NOT_RDY;
			}
			OS_EXIT_CRITICAL();
			break;

#if OS_FLAG_WAIT_CLR_EN > 0
		case OS_FLAG_WAIT_CLR_ALL:
			/* See if all required flags are cleared	*/
			flags_rdy = (OS_FLAGS) (~pgrp->OSFlagFlags & flags);  /* Extract only the bits we want     */
			if (flags_rdy == flags)
			{
				/* Must match ALL the bits that we want 	*/
				if (consume == OS_TRUE)
				{
					/* See if we need to consume the flags  	*/
					pgrp->OSFlagFlags |= flags_rdy; 	  /* Set ONLY the flags that we wanted  	  */
				}
			}
			else
			{
				*perr = OS_ERR_FLAG_NOT_RDY;
			}
			OS_EXIT_CRITICAL();
			break;

		case OS_FLAG_WAIT_CLR_ANY:
			flags_rdy = (OS_FLAGS) (~pgrp->OSFlagFlags & flags); /* Extract only the bits we want      */
			if (flags_rdy != (OS_FLAGS) 0)
			{
				/* See if any flag cleared  				*/
				if (consume == OS_TRUE)
				{
					/* See if we need to consume the flags  	*/
					pgrp->OSFlagFlags |= flags_rdy; 	  /* Set ONLY the flags that we got 		  */
				}
			}
			else
			{
				*perr = OS_ERR_FLAG_NOT_RDY;
			}
			OS_EXIT_CRITICAL();
			break;
#endif

		default:
			OS_EXIT_CRITICAL();
			flags_rdy = (OS_FLAGS) 0;
			*perr = OS_ERR_FLAG_WAIT_TYPE;
			break;
	}
	return (flags_rdy);
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
*   										CREATE AN EVENT FLAG
*
* Description: This function is called to create an event flag group.
*
* Arguments  : flags		 Contains the initial value to store in the event flag group.
*
*   		   perr 		 is a pointer to an error code which will be returned to your application:
*   							OS_ERR_NONE 			  if the call was successful.
*   							OS_ERR_CREATE_ISR   	  if you attempted to create an Event Flag from an
*   													  ISR.
*   							OS_ERR_FLAG_GRP_DEPLETED  if there are no more event flag groups
*
* Returns    : A pointer to an event flag group or a NULL pointer if no more groups are available.
*
* Called from: Task ONLY
*********************************************************************************************************
*/

OS_FLAG_GRP * OSFlagCreate(OS_FLAGS flags, INT8U *perr)
{
	OS_FLAG_GRP *pgrp;
#if OS_CRITICAL_METHOD == 3 						/* Allocate storage for CPU status register 	   */
	OS_CPU_SR    cpu_sr = 0;
#endif



#if OS_ARG_CHK_EN > 0
	if (perr == (INT8U *) 0)
	{
		/* Validate 'perr'  							   */
		return ((OS_FLAG_GRP *) 0);
	}
#endif
	if (OSIntNesting > 0)
	{
		/* See if called from ISR ...   				   */
		*perr = OS_ERR_CREATE_ISR;  				/* ... can't CREATE from an ISR                    */
		return ((OS_FLAG_GRP *) 0);
	}
	OS_ENTER_CRITICAL();
	pgrp = OSFlagFreeList;  						/* Get next free event flag 					   */
	if (pgrp != (OS_FLAG_GRP *) 0)
	{
		/* See if we have event flag groups available      */
		/* Adjust free list 							   */
		OSFlagFreeList = (OS_FLAG_GRP *) OSFlagFreeList->OSFlagWaitList;
		pgrp->OSFlagType = OS_EVENT_TYPE_FLAG;  /* Set to event flag group type 				   */
		pgrp->OSFlagFlags = flags;  			 /* Set to desired initial value					*/
		pgrp->OSFlagWaitList = (void *) 0;  		 /* Clear list of tasks waiting on flags			*/
#if OS_FLAG_NAME_SIZE > 1
		pgrp->OSFlagName[0] = '?';
		pgrp->OSFlagName[1] = OS_ASCII_NUL;
#endif
		OS_EXIT_CRITICAL();
		*perr = OS_ERR_NONE;
	}
	else
	{
		OS_EXIT_CRITICAL();
		*perr = OS_ERR_FLAG_GRP_DEPLETED;
	}
	return (pgrp);  								/* Return pointer to event flag group   		   */
}

/*$PAGE*/
/*
*********************************************************************************************************
*   								  DELETE AN EVENT FLAG GROUP
*
* Description: This function deletes an event flag group and readies all tasks pending on the event flag
*   		   group.
*
* Arguments  : pgrp 		 is a pointer to the desired event flag group.
*
*   		   opt  		 determines delete options as follows:
*   						 opt == OS_DEL_NO_PEND   Deletes the event flag group ONLY if no task pending
*   						 opt == OS_DEL_ALWAYS    Deletes the event flag group even if tasks are
*   												 waiting.  In this case, all the tasks pending will be
*   												 readied.
*
*   		   perr 		 is a pointer to an error code that can contain one of the following values:
*   						 OS_ERR_NONE			   The call was successful and the event flag group was
*   												   deleted
*   						 OS_ERR_DEL_ISR 		   If you attempted to delete the event flag group from
*   												   an ISR
*   						 OS_ERR_FLAG_INVALID_PGRP  If 'pgrp' is a NULL pointer.
*   						 OS_ERR_EVENT_TYPE  	   If you didn't pass a pointer to an event flag group
*   						 OS_ERR_INVALID_OPT 	   An invalid option was specified
*   						 OS_ERR_TASK_WAITING	   One or more tasks were waiting on the event flag
*   												   group.
*
* Returns    : pgrp 		 upon error
*   		   (OS_EVENT *)0 if the event flag group was successfully deleted.
*
* Note(s)    : 1) This function must be used with care.  Tasks that would normally expect the presence of
*   			  the event flag group MUST check the return code of OSFlagAccept() and OSFlagPend().
*   		   2) This call can potentially disable interrupts for a long time.  The interrupt disable
*   			  time is directly proportional to the number of tasks waiting on the event flag group.
*********************************************************************************************************
*/

#if OS_FLAG_DEL_EN > 0
OS_FLAG_GRP * OSFlagDel(OS_FLAG_GRP *pgrp, INT8U opt, INT8U *perr)
{
	BOOLEAN 	  tasks_waiting;
	OS_FLAG_NODE *pnode;
	OS_FLAG_GRP  *pgrp_return;
#if OS_CRITICAL_METHOD == 3 							   /* Allocate storage for CPU status register */
	OS_CPU_SR     cpu_sr = 0;
#endif



#if OS_ARG_CHK_EN > 0
	if (perr == (INT8U *) 0)
	{
		/* Validate 'perr'  						*/
		return (pgrp);
	}
	if (pgrp == (OS_FLAG_GRP *) 0)
	{
		/* Validate 'pgrp'  						*/
		*perr = OS_ERR_FLAG_INVALID_PGRP;
		return (pgrp);
	}
#endif
	if (OSIntNesting > 0)
	{
		/* See if called from ISR ...   			*/
		*perr = OS_ERR_DEL_ISR; 						   /* ... can't DELETE from an ISR             */
		return (pgrp);
	}
	if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG)
	{
		/* Validate event group type				*/
		*perr = OS_ERR_EVENT_TYPE;
		return (pgrp);
	}
	OS_ENTER_CRITICAL();
	if (pgrp->OSFlagWaitList != (void *) 0)
	{
		/* See if any tasks waiting on event flags  */
		tasks_waiting = OS_TRUE;						   /* Yes   								   */
	}
	else
	{
		tasks_waiting = OS_FALSE;   					   /* No									   */
	}
	switch (opt)
	{
		case OS_DEL_NO_PEND:
			/* Delete group if no task waiting  		*/
			if (tasks_waiting == OS_FALSE)
			{
#if OS_FLAG_NAME_SIZE > 1
				pgrp->OSFlagName[0] = '?';  			 /* Unknown name							 */
				pgrp->OSFlagName[1] = OS_ASCII_NUL;
#endif
				pgrp->OSFlagType = OS_EVENT_TYPE_UNUSED;
				pgrp->OSFlagWaitList = (void *) OSFlagFreeList; /* Return group to free list		   */
				pgrp->OSFlagFlags = (OS_FLAGS) 0;
				OSFlagFreeList = pgrp;
				OS_EXIT_CRITICAL();
				*perr = OS_ERR_NONE;
				pgrp_return = (OS_FLAG_GRP *) 0;  /* Event Flag Group has been deleted  	  */
			}
			else
			{
				OS_EXIT_CRITICAL();
				*perr = OS_ERR_TASK_WAITING;
				pgrp_return = pgrp;
			}
			break;

		case OS_DEL_ALWAYS:
			/* Always delete the event flag group   	*/
			pnode = (OS_FLAG_NODE *) pgrp->OSFlagWaitList;
			while (pnode != (OS_FLAG_NODE *) 0)
			{
				/* Ready ALL tasks waiting for flags		*/
				(void) OS_FlagTaskRdy(pnode, (OS_FLAGS) 0);
				pnode = (OS_FLAG_NODE *) pnode->OSFlagNodeNext;
			}
#if OS_FLAG_NAME_SIZE > 1
			pgrp->OSFlagName[0] = '?';  				 /* Unknown name							 */
			pgrp->OSFlagName[1] = OS_ASCII_NUL;
#endif
			pgrp->OSFlagType = OS_EVENT_TYPE_UNUSED;
			pgrp->OSFlagWaitList = (void *) OSFlagFreeList;/* Return group to free list 			   */
			pgrp->OSFlagFlags = (OS_FLAGS) 0;
			OSFlagFreeList = pgrp;
			OS_EXIT_CRITICAL();
			if (tasks_waiting == OS_TRUE)
			{
				/* Reschedule only if task(s) were waiting  */
				OS_Sched(); 							  /* Find highest priority task ready to run  */
			}
			*perr = OS_ERR_NONE;
			pgrp_return = (OS_FLAG_GRP *) 0;	  /* Event Flag Group has been deleted  	  */
			break;

		default:
			OS_EXIT_CRITICAL();
			*perr = OS_ERR_INVALID_OPT;
			pgrp_return = pgrp;
			break;
	}
	return (pgrp_return);
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*   							  GET THE NAME OF AN EVENT FLAG GROUP
*
* Description: This function is used to obtain the name assigned to an event flag group
*
* Arguments  : pgrp 	 is a pointer to the event flag group.
*
*   		   pname	 is a pointer to an ASCII string that will receive the name of the event flag
*   					 group.  The string must be able to hold at least OS_FLAG_NAME_SIZE characters.
*
*   		   perr 	 is a pointer to an error code that can contain one of the following values:
*
*   					 OS_ERR_NONE				if the requested task is resumed
*   					 OS_ERR_EVENT_TYPE  		if 'pevent' is not pointing to an event flag group
*   					 OS_ERR_PNAME_NULL  		You passed a NULL pointer for 'pname'