os_flag.c

lpc2368-keil环境下的ucos的移植例程

			else
			{
				OS_EXIT_CRITICAL();
				*err = OS_ERR_TASK_WAITING;
				return (pgrp);
			}

		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		*/
				OS_FlagTaskRdy(pnode, (OS_FLAGS) 0);
				pnode = (OS_FLAG_NODE *) pnode->OSFlagNodeNext;
			}
			pgrp->OSFlagType = OS_EVENT_TYPE_UNUSED;
			pgrp->OSFlagWaitList = (void *) OSFlagFreeList;/* Return group to free list 			   */
			OSFlagFreeList = pgrp;
			OS_EXIT_CRITICAL();
			if (tasks_waiting == TRUE)
			{
				/* Reschedule only if task(s) were waiting  */
				OS_Sched(); 							  /* Find highest priority task ready to run  */
			}
			*err = OS_NO_ERR;
			return ((OS_FLAG_GRP *) 0); 				   /* Event Flag Group has been deleted 	   */

		default:
			OS_EXIT_CRITICAL();
			*err = OS_ERR_INVALID_OPT;
			return (pgrp);
	}
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*   									 WAIT ON AN EVENT FLAG GROUP
*
* Description: This function is called to wait for a combination of bits to be set in an event flag
*   		   group.  Your application can wait for ANY bit to be set or ALL bits to be set.
*
* 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 wait for.
*   						 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 or ANY of the bits to be set.
*   						 You can specify the following argument:
*
*   						 OS_FLAG_WAIT_CLR_ALL   You will wait for ALL bits in 'mask' to be clear (0)
*   						 OS_FLAG_WAIT_SET_ALL   You will wait for ALL bits in 'mask' to be set   (1)
*   						 OS_FLAG_WAIT_CLR_ANY   You will wait for ANY bit  in 'mask' to be clear (0)
*   						 OS_FLAG_WAIT_SET_ANY   You will wait for ANY bit  in 'mask' 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
*
*   		   timeout  	 is an optional timeout (in clock ticks) that your task will wait for the
*   						 desired bit combination.  If you specify 0, however, your task will wait
*   						 forever at the specified event flag group or, until a message arrives.
*
*   		   err  		 is a pointer to an error code and can be:
*   						 OS_NO_ERR  			The desired bits have been set within the specified
*   												'timeout'.
*   						 OS_ERR_PEND_ISR		If you tried to PEND from an ISR
*   						 OS_FLAG_INVALID_PGRP   If 'pgrp' is a NULL pointer.
*   						 OS_ERR_EVENT_TYPE  	You are not pointing to an event flag group
*   						 OS_TIMEOUT 			The bit(s) have not been set in the specified
*   												'timeout'.
*   						 OS_FLAG_ERR_WAIT_TYPE  You didn't specify a proper 'wait_type' argument.
*
* Returns    : The new state of the flags in the event flag group when the task is resumed or,
*   		   0 if a timeout or an error occurred.
*
* Called from: Task ONLY
*********************************************************************************************************
*/

OS_FLAGS OSFlagPend(OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err)
{
#if OS_CRITICAL_METHOD == 3 							   /* Allocate storage for CPU status register */
	OS_CPU_SR     cpu_sr;
#endif
	OS_FLAG_NODE  node;
	OS_FLAGS	  flags_cur;
	OS_FLAGS	  flags_rdy;
	BOOLEAN 	  consume;


	if (OSIntNesting > 0)
	{
		/* See if called from ISR ...   			*/
		*err = OS_ERR_PEND_ISR; 						   /* ... can't PEND from an ISR               */
		return ((OS_FLAGS) 0);
	}
#if OS_ARG_CHK_EN > 0
	if (pgrp == (OS_FLAG_GRP *) 0)
	{
		/* Validate 'pgrp'  						*/
		*err = OS_FLAG_INVALID_PGRP;
		return ((OS_FLAGS) 0);
	}
	if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG)
	{
		/* Validate event block type				*/
		*err = OS_ERR_EVENT_TYPE;
		return ((OS_FLAGS) 0);
	}
#endif
	if (wait_type & OS_FLAG_CONSUME)
	{
		/* See if we need to consume the flags  	*/
		wait_type &= ~OS_FLAG_CONSUME;
		consume = TRUE;
	}
	else
	{
		consume = FALSE;
	}
	/*$PAGE*/
	OS_ENTER_CRITICAL();
	switch (wait_type)
	{
		case OS_FLAG_WAIT_SET_ALL:
			/* See if all required flags are set		*/
			flags_rdy = pgrp->OSFlagFlags & flags;  	  /* Extract only the bits we want  		  */
			if (flags_rdy == flags)
			{
				/* Must match ALL the bits that we want 	*/
				if (consume == TRUE)
				{
					/* See if we need to consume the flags  	*/
					pgrp->OSFlagFlags &= ~flags_rdy;	  /* Clear ONLY the flags that we wanted	  */
				}
				flags_cur = pgrp->OSFlagFlags;  		  /* Will return the state of the group 	  */
				OS_EXIT_CRITICAL(); 					  /* Yes, condition met, return to caller     */
				*err = OS_NO_ERR;
				return (flags_cur);
			}
			else
			{
				/* Block task until events occur or timeout */
				OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
				OS_EXIT_CRITICAL();
			}
			break;

		case OS_FLAG_WAIT_SET_ANY:
			flags_rdy = pgrp->OSFlagFlags & flags;  	  /* Extract only the bits we want  		  */
			if (flags_rdy != (OS_FLAGS) 0)
			{
				/* See if any flag set  					*/
				if (consume == TRUE)
				{
					/* See if we need to consume the flags  	*/
					pgrp->OSFlagFlags &= ~flags_rdy;	  /* Clear ONLY the flags that we got   	  */
				}
				flags_cur = pgrp->OSFlagFlags;  		  /* Will return the state of the group 	  */
				OS_EXIT_CRITICAL(); 					  /* Yes, condition met, return to caller     */
				*err = OS_NO_ERR;
				return (flags_cur);
			}
			else
			{
				/* Block task until events occur or timeout */
				OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
				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 = ~pgrp->OSFlagFlags & flags; 	  /* Extract only the bits we want  		  */
			if (flags_rdy == flags)
			{
				/* Must match ALL the bits that we want 	*/
				if (consume == TRUE)
				{
					/* See if we need to consume the flags  	*/
					pgrp->OSFlagFlags |= flags_rdy; 	  /* Set ONLY the flags that we wanted  	  */
				}
				flags_cur = pgrp->OSFlagFlags;  		  /* Will return the state of the group 	  */
				OS_EXIT_CRITICAL(); 					  /* Yes, condition met, return to caller     */
				*err = OS_NO_ERR;
				return (flags_cur);
			}
			else
			{
				/* Block task until events occur or timeout */
				OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
				OS_EXIT_CRITICAL();
			}
			break;

		case OS_FLAG_WAIT_CLR_ANY:
			flags_rdy = ~pgrp->OSFlagFlags & flags; 	  /* Extract only the bits we want  		  */
			if (flags_rdy != (OS_FLAGS) 0)
			{
				/* See if any flag cleared  				*/
				if (consume == TRUE)
				{
					/* See if we need to consume the flags  	*/
					pgrp->OSFlagFlags |= flags_rdy; 	  /* Set ONLY the flags that we got 		  */
				}
				flags_cur = pgrp->OSFlagFlags;  		  /* Will return the state of the group 	  */
				OS_EXIT_CRITICAL(); 					  /* Yes, condition met, return to caller     */
				*err = OS_NO_ERR;
				return (flags_cur);
			}
			else
			{
				/* Block task until events occur or timeout */
				OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
				OS_EXIT_CRITICAL();
			}
			break;
#endif

		default:
			OS_EXIT_CRITICAL();
			flags_cur = (OS_FLAGS) 0;
			*err = OS_FLAG_ERR_WAIT_TYPE;
			return (flags_cur);
	}
	OS_Sched(); 										   /* Find next HPT ready to run			   */
	OS_ENTER_CRITICAL();
	if (OSTCBCur->OSTCBStat & OS_STAT_FLAG)
	{
		/* Have we timed-out?   					*/
		OS_FlagUnlink(&node);
		OSTCBCur->OSTCBStat = OS_STAT_RDY;  			   /* Yes, make task ready-to-run   		   */
		OS_EXIT_CRITICAL();
		flags_cur = (OS_FLAGS) 0;
		*err = OS_TIMEOUT;  				/* Indicate that we timed-out waiting   	*/
	}
	else
	{
		if (consume == TRUE)
		{
			/* See if we need to consume the flags  	*/
			switch (wait_type)
			{
				case OS_FLAG_WAIT_SET_ALL:
				case OS_FLAG_WAIT_SET_ANY:
					/* Clear ONLY the flags we got  			*/
					pgrp->OSFlagFlags &= ~OSTCBCur->OSTCBFlagsRdy;
					break;

#if OS_FLAG_WAIT_CLR_EN > 0
				case OS_FLAG_WAIT_CLR_ALL:
				case OS_FLAG_WAIT_CLR_ANY:
					/* Set   ONLY the flags we got  			*/
					pgrp->OSFlagFlags |= OSTCBCur->OSTCBFlagsRdy;
					break;
#endif
			}
		}
		flags_cur = pgrp->OSFlagFlags;
		OS_EXIT_CRITICAL();
		*err = OS_NO_ERR;   						  /* Event(s) must have occurred			  */
	}
	return (flags_cur);
}
/*$PAGE*/
/*
*********************************************************************************************************
*   									  POST EVENT FLAG BIT(S)
*
* Description: This function is called to set or clear some bits in an event flag group.  The bits to
*   		   set or clear are specified by a 'bit mask'.
*
* Arguments  : pgrp 		 is a pointer to the desired event flag group.
*
*   		   flags		 If 'opt' (see below) is OS_FLAG_SET, each bit that is set in 'flags' will
*   						 set the corresponding bit in the event flag group.  e.g. to set bits 0, 4
*   						 and 5 you would set 'flags' to:
*
*   							 0x31     (note, bit 0 is least significant bit)
*
*   						 If 'opt' (see below) is OS_FLAG_CLR, each bit that is set in 'flags' will
*   						 CLEAR the corresponding bit in the event flag group.  e.g. to clear bits 0,
*   						 4 and 5 you would specify 'flags' as:
*
*   							 0x31     (note, bit 0 is least significant bit)
*
*   		   opt  		 indicates whether the flags will be:
*   							 set	 (OS_FLAG_SET) or
*   							 cleared (OS_FLAG_CLR)
*
*   		   err  		 is a pointer to an error code and can be:
*   						 OS_NO_ERR  			The call was successfull
*   						 OS_FLAG_INVALID_PGRP   You passed a NULL pointer
*   						 OS_ERR_EVENT_TYPE  	You are not pointing to an event flag group
*   						 OS_FLAG_INVALID_OPT	You specified an invalid option
*
* Returns    : the new value of the event flags bits that are still set.
*
* Called From: Task or ISR
*
* WARNING(s) : 1) The execution time of this function depends on the number of tasks waiting on the event
*   			  flag group.
*   		   2) The amount of time interrupts are DISABLED depends on the number of tasks waiting on
*   			  the event flag group.
*********************************************************************************************************
*/
OS_FLAGS OSFlagPost(OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U opt, INT8U *err)
{
#if OS_CRITICAL_METHOD == 3 						 /* Allocate storage for CPU status register	   */
	OS_CPU_SR     cpu_sr;
#endif
	OS_FLAG_NODE *pnode;
	BOOLEAN 	  sched;
	OS_FLAGS	  flags_cur;
	OS_FLAGS	  flags_rdy;


#if OS_ARG_CHK_EN > 0
	if (pgrp == (OS_FLAG_GRP *) 0)
	{
		/* Validate 'pgrp'  							  */
		*err = OS_FLAG_INVALID_PGRP;
		return ((OS_FLAGS) 0);
	}
	if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG)
	{
		/* Make sure we are pointing to an event flag grp */
		*err = OS_ERR_EVENT_TYPE;
		return ((OS_FLAGS) 0);
	}
#endif
	/*$PAGE*/
	OS_ENTER_CRITICAL();
	switch (opt)
	{
		case OS_FLAG_CLR:
			pgrp->OSFlagFlags &= ~flags;			/* Clear the flags specified in the group   	  */
			break;

		case OS_FLAG_SET:
			pgrp->OSFlagFlags |= flags; 		   /* Set   the flags specified in the group		 */
			break;

		default:
			OS_EXIT_CRITICAL(); 					/* INVALID option   							  */