os_mbox.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

	OS_ENTER_CRITICAL();
	if (OSTCBCur->OSTCBStatPend != OS_STAT_PEND_OK)
	{
		/* See if we weren't given the message           */
		pend_stat = OSTCBCur->OSTCBStatPend;
		OS_EventTOAbort(pevent);					  /* Timed out, Make task ready 				   */
		OS_EXIT_CRITICAL();
		switch (pend_stat)
		{
			case OS_STAT_PEND_TO:
			default:
				*perr = OS_ERR_TIMEOUT; 			 /* Indicate that a timeout occured 			  */
				break;

			case OS_STAT_PEND_ABORT:
				*perr = OS_ERR_PEND_ABORT;  		 /* Indicate that we aborted					  */
				break;
		}
		return ((void *) 0);						   /* Return a NULL message 						*/
	}
	pmsg = OSTCBCur->OSTCBMsg;
	OSTCBCur->OSTCBMsg = (void *) 0;			  /* Yes, clear message received				   */
	OSTCBCur->OSTCBStat = OS_STAT_RDY;
	OSTCBCur->OSTCBEventPtr = (OS_EVENT *) 0;   	   /* No longer waiting for event   				*/
	OS_EXIT_CRITICAL();
	*perr = OS_ERR_NONE;
	return (pmsg);  								  /* Return the message received				   */
}
/*$PAGE*/
/*
*********************************************************************************************************
*   								   ABORT WAITING ON A MESSAGE MAILBOX
*
* Description: This function aborts & readies any tasks currently waiting on a mailbox.  This function 
*   		   should be used to fault-abort the wait on the mailbox, rather than to normally signal
*   		   the mailbox via OSMboxPost() or OSMboxPostOpt().
*
* Arguments  : pevent   	 is a pointer to the event control block associated with the desired mailbox.
*
*   		   opt  		 determines the type of ABORT performed:
*   						 OS_PEND_OPT_NONE   	  ABORT wait for a single task (HPT) waiting on the
*   												  mailbox
*   						 OS_PEND_OPT_BROADCAST    ABORT wait for ALL tasks that are  waiting on the
*   												  mailbox
*
*   		   perr 		 is a pointer to where an error message will be deposited.  Possible error
*   						 messages are:
*
*   						 OS_ERR_NONE		 No tasks were     waiting on the mailbox.
*   						 OS_ERR_PEND_ABORT   At least one task waiting on the mailbox was readied
*   											 and informed of the aborted wait; check return value 
*   											 for the number of tasks whose wait on the mailbox 
*   											 was aborted.
*   						 OS_ERR_EVENT_TYPE   If you didn't pass a pointer to a mailbox.
*   						 OS_ERR_PEVENT_NULL  If 'pevent' is a NULL pointer.
*
* Returns    : == 0 		 if no tasks were waiting on the mailbox, or upon error.
*   		   >  0 		 if one or more tasks waiting on the mailbox are now readied and informed.
*********************************************************************************************************
*/

#if OS_MBOX_PEND_ABORT_EN > 0
INT8U OSMboxPendAbort(OS_EVENT *pevent, INT8U opt, INT8U *perr)
{
	INT8U      nbr_tasks;
#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 (0);
	}
	if (pevent == (OS_EVENT *) 0)
	{
		/* Validate 'pevent'						*/
		*perr = OS_ERR_PEVENT_NULL;
		return (0);
	}
#endif
	if (pevent->OSEventType != OS_EVENT_TYPE_MBOX)
	{
		/* Validate event block type				*/
		*perr = OS_ERR_EVENT_TYPE;
		return (0);
	}
	OS_ENTER_CRITICAL();
	if (pevent->OSEventGrp != 0)
	{
		/* See if any task waiting on mailbox?  	*/
		nbr_tasks = 0;
		switch (opt)
		{
			case OS_PEND_OPT_BROADCAST:
				/* Do we need to abort ALL waiting tasks?   */
				while (pevent->OSEventGrp != 0)
				{
					/* Yes, ready ALL tasks waiting on mailbox  */
					(void) OS_EventTaskRdy(pevent, (void *) 0, OS_STAT_MBOX, OS_STAT_PEND_ABORT);
					nbr_tasks++;
				}
				break;

			case OS_PEND_OPT_NONE:
				/* No,  ready HPT   	waiting on mailbox  */
			default:
				(void) OS_EventTaskRdy(pevent, (void *) 0, OS_STAT_MBOX, OS_STAT_PEND_ABORT);
				nbr_tasks++;
				break;
		}
		OS_EXIT_CRITICAL();
		OS_Sched(); 									   /* Find HPT ready to run 				   */
		*perr = OS_ERR_PEND_ABORT;
		return (nbr_tasks);
	}
	OS_EXIT_CRITICAL();
	*perr = OS_ERR_NONE;
	return (0); 										   /* No tasks waiting on mailbox   		   */
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
*   									POST MESSAGE TO A MAILBOX
*
* Description: This function sends a message to a mailbox
*
* Arguments  : pevent   	 is a pointer to the event control block associated with the desired mailbox
*
*   		   pmsg 		 is a pointer to the message to send.  You MUST NOT send a NULL pointer.
*
* Returns    : OS_ERR_NONE  		The call was successful and the message was sent
*   		   OS_ERR_MBOX_FULL 	If the mailbox already contains a message.  You can can only send one
*   								message at a time and thus, the message MUST be consumed before you
*   								are allowed to send another one.
*   		   OS_ERR_EVENT_TYPE	If you are attempting to post to a non mailbox.
*   		   OS_ERR_PEVENT_NULL   If 'pevent' is a NULL pointer
*   		   OS_ERR_POST_NULL_PTR If you are attempting to post a NULL pointer
*
* Note(s)    : 1) HPT means Highest Priority Task
*********************************************************************************************************
*/

#if OS_MBOX_POST_EN > 0
INT8U OSMboxPost(OS_EVENT *pevent, void *pmsg)
{
#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 (pevent == (OS_EVENT *) 0)
	{
		/* Validate 'pevent'							 */
		return (OS_ERR_PEVENT_NULL);
	}
	if (pmsg == (void *) 0)
	{
		/* Make sure we are not posting a NULL pointer   */
		return (OS_ERR_POST_NULL_PTR);
	}
#endif
	if (pevent->OSEventType != OS_EVENT_TYPE_MBOX)
	{
		/* Validate event block type					 */
		return (OS_ERR_EVENT_TYPE);
	}
	OS_ENTER_CRITICAL();
	if (pevent->OSEventGrp != 0)
	{
		/* See if any task pending on mailbox   		 */
		/* Ready HPT waiting on event   				 */
		(void) OS_EventTaskRdy(pevent, pmsg, OS_STAT_MBOX, OS_STAT_PEND_OK);
		OS_EXIT_CRITICAL();
		OS_Sched(); 								  /* Find highest priority task ready to run	   */
		return (OS_ERR_NONE);
	}
	if (pevent->OSEventPtr != (void *) 0)
	{
		/* Make sure mailbox doesn't already have a msg  */
		OS_EXIT_CRITICAL();
		return (OS_ERR_MBOX_FULL);
	}
	pevent->OSEventPtr = pmsg;  					  /* Place message in mailbox   				   */
	OS_EXIT_CRITICAL();
	return (OS_ERR_NONE);
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
*   									POST MESSAGE TO A MAILBOX
*
* Description: This function sends a message to a mailbox
*
* Arguments  : pevent   	 is a pointer to the event control block associated with the desired mailbox
*
*   		   pmsg 		 is a pointer to the message to send.  You MUST NOT send a NULL pointer.
*
*   		   opt  		 determines the type of POST performed:
*   						 OS_POST_OPT_NONE   	  POST to a single waiting task
*   												  (Identical to OSMboxPost())
*   						 OS_POST_OPT_BROADCAST    POST to ALL tasks that are waiting on the mailbox
*
*   						 OS_POST_OPT_NO_SCHED     Indicates that the scheduler will NOT be invoked
*
* Returns    : OS_ERR_NONE  		The call was successful and the message was sent
*   		   OS_ERR_MBOX_FULL 	If the mailbox already contains a message.  You can can only send one
*   								message at a time and thus, the message MUST be consumed before you
*   								are allowed to send another one.
*   		   OS_ERR_EVENT_TYPE	If you are attempting to post to a non mailbox.
*   		   OS_ERR_PEVENT_NULL   If 'pevent' is a NULL pointer
*   		   OS_ERR_POST_NULL_PTR If you are attempting to post a NULL pointer
*
* Note(s)    : 1) HPT means Highest Priority Task
*
* Warning    : Interrupts can be disabled for a long time if you do a 'broadcast'.  In fact, the
*   		   interrupt disable time is proportional to the number of tasks waiting on the mailbox.
*********************************************************************************************************
*/

#if OS_MBOX_POST_OPT_EN > 0
INT8U OSMboxPostOpt(OS_EVENT *pevent, void *pmsg, INT8U opt)
{
#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 (pevent == (OS_EVENT *) 0)
	{
		/* Validate 'pevent'							 */
		return (OS_ERR_PEVENT_NULL);
	}
	if (pmsg == (void *) 0)
	{
		/* Make sure we are not posting a NULL pointer   */
		return (OS_ERR_POST_NULL_PTR);
	}
#endif
	if (pevent->OSEventType != OS_EVENT_TYPE_MBOX)
	{
		/* Validate event block type					 */
		return (OS_ERR_EVENT_TYPE);
	}
	OS_ENTER_CRITICAL();
	if (pevent->OSEventGrp != 0)
	{
		/* See if any task pending on mailbox   		 */
		if ((opt & OS_POST_OPT_BROADCAST) != 0x00)
		{
			/* Do we need to post msg to ALL waiting tasks ? */
			while (pevent->OSEventGrp != 0)
			{
				/* Yes, Post to ALL tasks waiting on mailbox	 */
				(void) OS_EventTaskRdy(pevent, pmsg, OS_STAT_MBOX, OS_STAT_PEND_OK);
			}
		}
		else
		{
			/* No,  Post to HPT waiting on mbox 			 */
			(void) OS_EventTaskRdy(pevent, pmsg, OS_STAT_MBOX, OS_STAT_PEND_OK);
		}
		OS_EXIT_CRITICAL();
		if ((opt & OS_POST_OPT_NO_SCHED) == 0)
		{
			/* See if scheduler needs to be invoked 		 */
			OS_Sched(); 							  /* Find HPT ready to run  					   */
		}
		return (OS_ERR_NONE);
	}
	if (pevent->OSEventPtr != (void *) 0)
	{
		/* Make sure mailbox doesn't already have a msg  */
		OS_EXIT_CRITICAL();
		return (OS_ERR_MBOX_FULL);
	}
	pevent->OSEventPtr = pmsg;  					  /* Place message in mailbox   				   */
	OS_EXIT_CRITICAL();
	return (OS_ERR_NONE);
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
*   									 QUERY A MESSAGE MAILBOX
*
* Description: This function obtains information about a message mailbox.
*
* Arguments  : pevent   	 is a pointer to the event control block associated with the desired mailbox
*
*   		   p_mbox_data   is a pointer to a structure that will contain information about the message
*   						 mailbox.
*
* Returns    : OS_ERR_NONE  	   The call was successful and the message was sent
*   		   OS_ERR_EVENT_TYPE   If you are attempting to obtain data from a non mailbox.
*   		   OS_ERR_PEVENT_NULL  If 'pevent'  	is a NULL pointer
*   		   OS_ERR_PDATA_NULL   If 'p_mbox_data' is a NULL pointer
*********************************************************************************************************
*/

#if OS_MBOX_QUERY_EN > 0
INT8U OSMboxQuery(OS_EVENT *pevent, OS_MBOX_DATA *p_mbox_data)
{
	INT8U      i;
#if OS_LOWEST_PRIO <= 63
	INT8U     *psrc;
	INT8U     *pdest;
#else
	INT16U    *psrc;
	INT16U    *pdest;
#endif
#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 (pevent == (OS_EVENT *) 0)
	{
		/* Validate 'pevent'						*/
		return (OS_ERR_PEVENT_NULL);
	}
	if (p_mbox_data == (OS_MBOX_DATA *) 0)
	{
		/* Validate 'p_mbox_data'   				*/
		return (OS_ERR_PDATA_NULL);
	}
#endif
	if (pevent->OSEventType != OS_EVENT_TYPE_MBOX)
	{
		/* Validate event block type				*/
		return (OS_ERR_EVENT_TYPE);
	}
	OS_ENTER_CRITICAL();
	p_mbox_data->OSEventGrp = pevent->OSEventGrp;   	   /* Copy message mailbox wait list		   */
	psrc = &pevent->OSEventTbl[0];
	pdest = &p_mbox_data->OSEventTbl[0];
	for (i = 0; i < OS_EVENT_TBL_SIZE; i++)
	{
		*pdest++ = *psrc++;
	}
	p_mbox_data->OSMsg = pevent->OSEventPtr;			   /* Get message from mailbox  			   */
	OS_EXIT_CRITICAL();
	return (OS_ERR_NONE);
}
#endif  												   /* OS_MBOX_QUERY_EN  					   */
#endif  												   /* OS_MBOX_EN							   */