os_q.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

			break;

		default:
			OS_EXIT_CRITICAL();
			*perr = OS_ERR_INVALID_OPT;
			pevent_return = pevent;
			break;
	}
	return (pevent_return);
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
*   										  FLUSH QUEUE
*
* Description : This function is used to flush the contents of the message queue.
*
* Arguments   : none
*
* Returns     : OS_ERR_NONE 		upon success
*   			OS_ERR_EVENT_TYPE   If you didn't pass a pointer to a queue
*   			OS_ERR_PEVENT_NULL  If 'pevent' is a NULL pointer
*
* WARNING     : You should use this function with great care because, when to flush the queue, you LOOSE
*   			the references to what the queue entries are pointing to and thus, you could cause
*   			'memory leaks'.  In other words, the data you are pointing to that's being referenced
*   			by the queue entries should, most likely, need to be de-allocated (i.e. freed).
*********************************************************************************************************
*/

#if OS_Q_FLUSH_EN > 0
INT8U OSQFlush(OS_EVENT *pevent)
{
	OS_Q	  *pq;
#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 (pevent->OSEventType != OS_EVENT_TYPE_Q)
	{
		/* Validate event block type					 */
		return (OS_ERR_EVENT_TYPE);
	}
#endif
	OS_ENTER_CRITICAL();
	pq = (OS_Q *) pevent->OSEventPtr;      /* Point to queue storage structure  			*/
	pq->OSQIn = pq->OSQStart;
	pq->OSQOut = pq->OSQStart;
	pq->OSQEntries = 0;
	OS_EXIT_CRITICAL();
	return (OS_ERR_NONE);
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
*   								  PEND ON A QUEUE FOR A MESSAGE
*
* Description: This function waits for a message to be sent to a queue
*
* Arguments  : pevent   	 is a pointer to the event control block associated with the desired queue
*
*   		   timeout  	 is an optional timeout period (in clock ticks).  If non-zero, your task will
*   						 wait for a message to arrive at the queue up to the amount of time
*   						 specified by this argument.  If you specify 0, however, your task will wait
*   						 forever at the specified queue or, until a message arrives.
*
*   		   perr 		 is a pointer to where an error message will be deposited.  Possible error
*   						 messages are:
*
*   						 OS_ERR_NONE		 The call was successful and your task received a
*   											 message.
*   						 OS_ERR_TIMEOUT 	 A message was not received within the specified 'timeout'.
*   						 OS_ERR_PEND_ABORT   The wait on the queue was aborted.
*   						 OS_ERR_EVENT_TYPE   You didn't pass a pointer to a queue
*   						 OS_ERR_PEVENT_NULL  If 'pevent' is a NULL pointer
*   						 OS_ERR_PEND_ISR	 If you called this function from an ISR and the result
*   											 would lead to a suspension.
*   						 OS_ERR_PEND_LOCKED  If you called this function with the scheduler is locked
*
* Returns    : != (void *)0  is a pointer to the message received
*   		   == (void *)0  if you received a NULL pointer message or,
*   						 if no message was received or,
*   						 if 'pevent' is a NULL pointer or,
*   						 if you didn't pass a pointer to a queue.
*
* Note(s)    : As of V2.60, this function allows you to receive NULL pointer messages.
*********************************************************************************************************
*/

void * OSQPend(OS_EVENT *pevent, INT16U timeout, INT8U *perr)
{
	void	  *pmsg;
	OS_Q	  *pq;
	INT8U      pend_stat;
#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 ((void *) 0);
	}
	if (pevent == (OS_EVENT *) 0)
	{
		/* Validate 'pevent'								  */
		*perr = OS_ERR_PEVENT_NULL;
		return ((void *) 0);
	}
	if (pevent->OSEventType != OS_EVENT_TYPE_Q)
	{
		/* Validate event block type						  */
		*perr = OS_ERR_EVENT_TYPE;
		return ((void *) 0);
	}
#endif
	if (OSIntNesting > 0)
	{
		/* See if called from ISR ...   					  */
		*perr = OS_ERR_PEND_ISR;				 /* ... can't PEND from an ISR                         */
		return ((void *) 0);
	}
	if (OSLockNesting > 0)
	{
		/* See if called with scheduler locked ...  		  */
		*perr = OS_ERR_PEND_LOCKED; 			 /* ... can't PEND when locked                         */
		return ((void *) 0);
	}
	OS_ENTER_CRITICAL();
	pq = (OS_Q *) pevent->OSEventPtr;   		  /* Point at queue control block   					*/
	if (pq->OSQEntries > 0)
	{
		/* See if any messages in the queue 				  */
		pmsg = *pq->OSQOut++;   				 /* Yes, extract oldest message from the queue  	   */
		pq->OSQEntries--;   					 /* Update the number of entries in the queue   	   */
		if (pq->OSQOut == pq->OSQEnd)
		{
			/* Wrap OUT pointer if we are at the end of the queue */
			pq->OSQOut = pq->OSQStart;
		}
		OS_EXIT_CRITICAL();
		*perr = OS_ERR_NONE;
		return (pmsg);  						 /* Return message received 						   */
	}
	OSTCBCur->OSTCBStat |= OS_STAT_Q;   	 /* Task will have to pend for a message to be posted  */
	OSTCBCur->OSTCBStatPend = OS_STAT_PEND_OK;
	OSTCBCur->OSTCBDly = timeout;   	   /* Load timeout into TCB 							 */
	OS_EventTaskWait(pevent);   				 /* Suspend task until event or timeout occurs  	   */
	OS_EXIT_CRITICAL();
	OS_Sched(); 								 /* Find next highest priority task ready to run	   */
	OS_ENTER_CRITICAL();
	if (OSTCBCur->OSTCBStatPend != OS_STAT_PEND_OK)
	{
		/* Was task readied because timed-out or aborted?*/
		pend_stat = OSTCBCur->OSTCBStatPend;
		OS_EventTOAbort(pevent);
		OS_EXIT_CRITICAL();
		switch (pend_stat)
		{
			case OS_STAT_PEND_TO:
			default:
				*perr = OS_ERR_TIMEOUT; 		/*     Indicate a timeout occured   				  */
				break;

			case OS_STAT_PEND_ABORT:
				*perr = OS_ERR_PEND_ABORT;  	/*     Indicate that we aborted 					  */
				break;
		}
		return ((void *) 0);					  /*	 No message received							*/
	}
	pmsg = OSTCBCur->OSTCBMsg;/* No, Extract message from TCB (Put there by QPost)  */
	OSTCBCur->OSTCBMsg = (void *) 0;
	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 message received 					   */
}
/*$PAGE*/
/*
*********************************************************************************************************
*   								   ABORT WAITING ON A MESSAGE QUEUE
*
* Description: This function aborts & readies any tasks currently waiting on a queue.  This function 
*   		   should be used to fault-abort the wait on the queue, rather than to normally signal
*   		   the queue via OSQPost(), OSQPostFront() or OSQPostOpt().
*
* Arguments  : pevent   	 is a pointer to the event control block associated with the desired queue.
*
*   		   opt  		 determines the type of ABORT performed:
*   						 OS_PEND_OPT_NONE   	  ABORT wait for a single task (HPT) waiting on the
*   												  queue
*   						 OS_PEND_OPT_BROADCAST    ABORT wait for ALL tasks that are  waiting on the
*   												  queue
*
*   		   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 queue.
*   						 OS_ERR_PEND_ABORT   At least one task waiting on the queue was readied
*   											 and informed of the aborted wait; check return value 
*   											 for the number of tasks whose wait on the queue 
*   											 was aborted.
*   						 OS_ERR_EVENT_TYPE   If you didn't pass a pointer to a queue.
*   						 OS_ERR_PEVENT_NULL  If 'pevent' is a NULL pointer.
*
* Returns    : == 0 		 if no tasks were waiting on the queue, or upon error.
*   		   >  0 		 if one or more tasks waiting on the queue are now readied and informed.
*********************************************************************************************************
*/

#if OS_Q_PEND_ABORT_EN > 0
INT8U OSQPendAbort(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_Q)
	{
		/* Validate event block type				*/
		*perr = OS_ERR_EVENT_TYPE;
		return (0);
	}
	OS_ENTER_CRITICAL();
	if (pevent->OSEventGrp != 0)
	{
		/* See if any task waiting on queue?		*/
		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 queue	*/
					(void) OS_EventTaskRdy(pevent, (void *) 0, OS_STAT_Q, OS_STAT_PEND_ABORT);
					nbr_tasks++;
				}
				break;

			case OS_PEND_OPT_NONE:
				/* No,  ready HPT   	waiting on queue	*/
			default:
				(void) OS_EventTaskRdy(pevent, (void *) 0, OS_STAT_Q, 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 queue 			   */
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
*   									 POST MESSAGE TO A QUEUE
*
* Description: This function sends a message to a queue
*
* Arguments  : pevent   	 is a pointer to the event control block associated with the desired queue
*
*   		   pmsg 		 is a pointer to the message to send.
*
* Returns    : OS_ERR_NONE  		 The call was successful and the message was sent
*   		   OS_ERR_Q_FULL		 If the queue cannot accept any more messages because it is full.
*   		   OS_ERR_EVENT_TYPE	 If you didn't pass a pointer to a queue.
*   		   OS_ERR_PEVENT_NULL    If 'pevent' is a NULL pointer
*
* Note(s)    : As of V2.60, this function allows you to send NULL pointer messages.
*********************************************************************************************************
*/

#if OS_Q_POST_EN > 0
INT8U OSQPost(OS_EVENT *pevent, void *pmsg)
{
	OS_Q	  *pq;
#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);
	}
#endif
	if (pevent->OSEventType != OS_EVENT_TYPE_Q)
	{
		/* Validate event block type					*/
		return (OS_ERR_EVENT_TYPE);
	}
	OS_ENTER_CRITICAL();
	if (pevent->OSEventGrp != 0)