自学教程：C++ uxQueueMessagesWaiting函数代码示例

static void vInterruptCountingSemaphoreTask( void *pvParameters ){    BaseType_t xCount;    const TickType_t xDelay = pdMS_TO_TICKS( intsemINTERRUPT_MUTEX_GIVE_PERIOD_MS ) * ( intsemMAX_COUNT + 1 );    ( void ) pvParameters;    for( ;; ) {        /* Expect to start with the counting semaphore empty. */        if( uxQueueMessagesWaiting( ( QueueHandle_t ) xISRCountingSemaphore ) != 0 ) {            xErrorDetected = pdTRUE;        }        /* Wait until it is expected that the interrupt will have filled the        counting semaphore. */        xOkToGiveCountingSemaphore = pdTRUE;        vTaskDelay( xDelay );        xOkToGiveCountingSemaphore = pdFALSE;        /* Now it is expected that the counting semaphore is full. */        if( uxQueueMessagesWaiting( ( QueueHandle_t ) xISRCountingSemaphore ) != intsemMAX_COUNT ) {            xErrorDetected = pdTRUE;        }        if( uxQueueSpacesAvailable( ( QueueHandle_t ) xISRCountingSemaphore ) != 0 ) {            xErrorDetected = pdTRUE;        }        ulCountingSemaphoreLoops++;        /* Expect to be able to take the counting semaphore intsemMAX_COUNT        times.  A block time of 0 is used as the semaphore should already be        there. */        xCount = 0;        while( xSemaphoreTake( xISRCountingSemaphore, 0 ) == pdPASS ) {            xCount++;        }        if( xCount != intsemMAX_COUNT ) {            xErrorDetected = pdTRUE;        }        /* Now raise the priority of this task so it runs immediately that the        semaphore is given from the interrupt. */        vTaskPrioritySet( NULL, configMAX_PRIORITIES - 1 );        /* Block to wait for the semaphore to be given from the interrupt. */        xOkToGiveCountingSemaphore = pdTRUE;        xSemaphoreTake( xISRCountingSemaphore, portMAX_DELAY );        xSemaphoreTake( xISRCountingSemaphore, portMAX_DELAY );        xOkToGiveCountingSemaphore = pdFALSE;        /* Reset the priority so as not to disturbe other tests too much. */        vTaskPrioritySet( NULL, tskIDLE_PRIORITY );        ulCountingSemaphoreLoops++;    }}

/* * sendDataTask read data from xQueueOutput and send them * to the mobile application through the Bluetooth module * (UART interface for now is used) */void sendDataTask(void *pvParameters) {	uint8_t flag = FANION;	uint8_t buff[MAX_XQUEUEOUTPUT];	memset(buff, 0, sizeof(buff));#ifdef DEBUG_MODE	UART_Send(LPC_UART0, "sendDataTask launched/r/n", strlen("sendDataTask launched/r/n"), NONE_BLOCKING);#endif	for(;;) {		if(xQueueOutput != 0) { // xQueueOutput MUST be valid			vTaskDelay((PERIOD/portTICK_PERIOD_MS));			if(uxQueueMessagesWaiting(xQueueOutput) > 0) {				xQueueReceive(xQueueOutput, buff, (TickType_t) 0);				UART_Send(LPC_UART0, &flag, 1, NONE_BLOCKING);				UART_Send(LPC_UART0, buff, sizeof(buff), NONE_BLOCKING);			}		}else {			UART_Send(LPC_UART0, &flag, 1, NONE_BLOCKING);			UART_Send(LPC_UART0, "Error - xQueueOutput not valid", strlen("Error - xQueueOutput not valid"), NONE_BLOCKING);		}	}}

/** * Destroys a mailbox. * * @param mbox is the mailbox to be destroyed. */voidsys_mbox_free(sys_mbox_t *mbox){  /* There should not be any messages waiting (if there are it is a bug).  If     any are waiting, increment the mailbox error count. */#if RTOS_FREERTOS  if(uxQueueMessagesWaiting(mbox->queue) != 0) {#endif /* RTOS_FREERTOS */#if SYS_STATS    STATS_INC(sys.mbox.err);#endif /* SYS_STATS */  }	/* Find a semaphore that would be freed. */	u32_t i;	for(i = 0; i < SYS_MBOX_MAX; i++) {		if(mboxes[i].queue == mbox->queue) {			mboxes[i].queue = SYS_MBOX_NULL;			vSemaphoreDelete(mbox->queue);			mbox->queue = 0;			return;		}	}  /* Clear the queue handle. */  mbox->queue = 0;  /* Update the mailbox statistics. */#if SYS_STATS   STATS_DEC(sys.mbox.used);#endif /* SYS_STATS */}

/**		Returns a single character from the receive queue if available.  This character is returned  unsigned - i.e. having a value of 0 - 255.  The return value is -1 if there is no character waiting.  @return character from the queue or -1 if there is no character.*/int Serial2_GetChar( int index ){  if ( index < 0 || index > 1 )    return CONTROLLER_ERROR_ILLEGAL_INDEX;  Serial2_* s2p = &Serial2[ index ];  if ( s2p->users == 0 )  {    int status = Serial2_SetActive( index, 1 );    if ( status != CONTROLLER_OK )      return -1;  }  if ( uxQueueMessagesWaiting( s2p->receiveQueue ) )  {    unsigned char c;    if( xQueueReceive( s2p->receiveQueue, &c, 0 ) == 0 )      return -1;    else      return (int)c;  }  else    return -1; }

// *************** Sensor_HasMessage *************** int Sensor_HasMessage( PORT_T *port ){	if(uxQueueMessagesWaiting( (xQueueHandle)port->rx_fifo ) > 0) 		return SENSOR_TRUE;	else		return SENSOR_FALSE;}	

void prvLcdShow( void *pvParameters ){    uint8_t symb, buffer_cnt=0, el_in_queue=0;    portBASE_TYPE xStatus;    while(1){    	el_in_queue = uxQueueMessagesWaiting(xQueueLCD);    	if(el_in_queue > 0){    		if(xSemaphoreTake(xLcdMutex, portMAX_DELAY) == pdPASS){            	while(el_in_queue > 0){            		if(xQueueReceive(xQueueLCD, &symb, 0) == pdPASS){            			if (buffer_cnt == 32){							lcd_clrscr();							buffer_cnt = 0;						}						if(buffer_cnt == 16){							lcd_goto(2,0);						}						lcd_putc(symb);						buffer_cnt++;						el_in_queue--;            		}            	}            	xSemaphoreGive(xLcdMutex);    		}    	}    }}

/***************************************************函数名：vTaskFillFrame参数  ：返回值：描述  ：填写点击屏幕产生的数据帧***************************************************/void vTaskFillFrame( void* pvParam ){	TP_DATA buf ;	static MSG_A1_OUT temp ;	//static u8 A1[7] = { 0X5A, 0X08, 0XFF, 0XFF, 0XFF, 0XFF, 0XA1 } ; 	Uart_putstr( "vTaskFillFrame start " ) ;	while(1)	{				xQueueReceive( xqh_Tpdata, &buf, portMAX_DELAY ) ;  		//*		Buf_A1_OUT.client_ID = Get_clientID() ;		//屏幕点击产生数据填写		Buf_A1_OUT.feature_ID = buf.allorsg << 3 ;		Buf_A1_OUT.feature_ID |= buf.id << 4  ;		Buf_A1_OUT.btA |= buf.temperature << 4 ;        //A1同报btA的高四位为温度		Buf_A1_OUT.btA |= buf.runmode << 1 ;						//A1同报btA的D3~D1为模式		Buf_A1_OUT.btA |= buf.windupdown ;	            //A1同报btA的最低位为上下白凤		Buf_A1_OUT.btB |= buf.envtemperature << 2 ;	    //A1同报 btB 的7~2位为环境温度		Buf_A1_OUT.btC |= buf.windspeed << 4 ;		Buf_A1_OUT.btC |= buf.windleftright << 4 ;							//特殊设定填写		Buf_A1_OUT.btB |= Registing[buf.id].speset.eding ;		Buf_A1_OUT.btD |= Registing[buf.id].speset.adress_allow_set << 3 ;		Buf_A1_OUT.btD |= Registing[buf.id].speset.jingyadangshu << 1 ;		Buf_A1_OUT.checksum = CheckingSum( (u8*)&Buf_A1_OUT, 7 ) ;		//*/		while( uxQueueMessagesWaiting(xqh_Tpframe) )    			xQueueReceive( xqh_Tpframe, &temp, portMAX_DELAY ) ;   //覆盖原有邮件		memcpy( (void*)((u8*)&temp), (void*)((u8*)&Buf_A1_OUT), 7 ) ;  //传递拷贝份，避免在发送数据过程中，buf_a1_out被重写		xQueueSend( xqh_Tpframe, (void*)&temp, 0 ) ;	}}

void get_uart_commands(void)/******************************************************************************   Function : Parses commands from UART.*****************************************************************************/{	portBASE_TYPE status;	uart_command c;		// Evenst from UART	if(uxQueueMessagesWaiting(uart_command_queue) != 0)	{		status = xQueueReceive(uart_command_queue, &c, 0);				if(status == pdPASS)		{			switch ( c.type )			{				case UART_COMMAND_POSITION:					switch ( c.key )					{						case UART_COMMAND_X_AXIS:						if(c.value >= 0 && c.value <= 1079)						{							write_5_char_int_to_buffer (11, 0, c.value ); // Disable on production							xSemaphoreTake(x_pos_mutex, portMAX_DELAY );							x_target_pos = c.value;							xSemaphoreGive(x_pos_mutex );						}						break;					}				break;			}		}	}}

/****************************************************************************** * Function: RtlMailboxMsgWaiting * Desc: To get the number of message blocks are storing in a given mailbox. * Para: *  MboxID: The identifier of the target mailbox. *  IsFromISR: Is this function is called from an ISR ? * Return: The number of message blocks are storing in this mailbox. ******************************************************************************/u32 RtlMailboxMsgWaiting(    IN u8 MboxID,     IN u8 IsFromISR){	RTL_MAILBOX *pMbox=NULL;    u32 msg_num=0;	pMbox = RtlMBoxIdToHdl(MboxID);	if (NULL == pMbox) {		MSG_MBOX_ERR("RtlMailboxMsgWaiting: Didn't find the MBox with ID=%d/n", MboxID);		return 0;	}#ifdef PLATFORM_FREERTOS    if (IsFromISR) {        msg_num = uxQueueMessagesWaitingFromISR(pMbox->mbox_hdl);    }    else {        msg_num = uxQueueMessagesWaiting(pMbox->mbox_hdl);    }#endif#ifdef PLATFORM_ECOS    // TODO: call eCos API to implement this function#endif    return msg_num;}

bool BufferCapacity(){	unsigned portBASE_TYPE uxBufLen = uxQueueMessagesWaiting(s_QueueBuff);	if (uxBufLen < 128)		return false;	return true;}

/**		Returns a single character from the receive queue if available.  This character is returned unsigned - i.e. having a value of 0 - 255.    The return value is -1 if there is no character waiting.  @param index Which serial port - SERIAL_0 or SERIAL_1  @return character from the queue or -1 if there is no character.*/int Serial_GetChar( int index ){  if ( index < 0 || index >= SERIAL_PORTS )    return CONTROLLER_ERROR_ILLEGAL_INDEX;  Serial_* sp = &Serial[ index ];  if ( !sp->active )  {    int status = Serial_SetActive( index, 1 );    if ( status != CONTROLLER_OK )      return -1;  }  if ( uxQueueMessagesWaiting( sp->receiveQueue ) )  {    unsigned char c;    if( xQueueReceive( sp->receiveQueue, &c, 0 ) == 0 )      return -1;    else      return (int)c;  }  else    return -1; }

static void vReceiverTask(void* pvParameters){	// Declare the structure that will hold the values received from the queue.	xData xReceivedStructure;	portBASE_TYPE xStatus;	// This task is also defined within an infinite loop.	for (;;)	{		// Because it has the lowest priority this task will only run when the		// sending tasks are in the Blocked state. The sending tasks will only		// enter the Blocked state when the queue is full so this task always		// expects the number of items in the queue to be equal to the queue		// length - 3 in this case.		if ( uxQueueMessagesWaiting(xQueue) != 3)		{			vTaskSuspendAll();			xil_printf("Queue should have been full!/n");		}		// Receive from the queue.		// The second parameter is the buffer into which the received data will		// be placed. In this case the buffer is simply the address of a variable		// that has the required size to hold the received structure.				// The last parameter is the block time - the maximum amount of time 		// that the task will remain in the Blocked state to wait for data to		// be available if the queue is already empty. In this case a block time		// is not necessary because this task will only run when queue is full.		xStatus = xQueueReceive(xQueue, &xReceivedStructure, 0);		if (xStatus == pdPASS)		{			// Data was successfully received from the queue, print out the			// received value and the source of the value.			if (xReceivedStructure.ucSource == mainSENDER_1)			{				vTaskSuspendAll();				xil_printf("From Sender 1 = %d/n", xReceivedStructure.ucValue);				xTaskResumeAll();			}			else			{				vTaskSuspendAll();				xil_printf("From Sender 2 = %d/n", xReceivedStructure.ucValue);				xTaskResumeAll();			}		}		else		{			// Nothing was received from the queue. This must be an error			// as this task should only run when the queue is full.			vTaskSuspendAll();			xil_printf("Could not receive from the queue./n");			xTaskResumeAll();		}	}}

static void updateSpindleSpeed(uint32_t speed){    while(uxQueueMessagesWaiting( movementQueue )); // Clear Movements        if(speed > 100)        speed = 100;    TIM_SetCompare1(TIM3, 2400 * speed / 100);    return;}

inline bool frt_text_queue::check_for_char (void){	if (uxQueueMessagesWaiting (the_queue) == 0)	{		return (false);	}	return (true);}

/** * Destroys a mailbox. * * @param mbox is the mailbox to be destroyed. */voidsys_mbox_free(sys_mbox_t mbox){  unsigned portBASE_TYPE count;  /* There should not be any messages waiting (if there are it is a bug).  If     any are waiting, increment the mailbox error count. */#if RTOS_SAFERTOS  if((xQueueMessagesWaiting(mbox->queue, &count) != pdPASS) || (count != 0)) {#elif RTOS_FREERTOS  if(uxQueueMessagesWaiting(mbox->queue) != 0) {#endif /* RTOS_SAFERTOS */#if SYS_STATS    STATS_INC(sys.mbox.err);#endif /* SYS_STATS */  }  /* Clear the queue handle. */  mbox->queue = 0;  /* Update the mailbox statistics. */#if SYS_STATS   STATS_DEC(sys.mbox.used);#endif /* SYS_STATS */}/** * The routine for a thread.  This handles some housekeeping around the * applications's thread routine. * * @param arg is the index into the thread structure for this thread */static voidsys_arch_thread(void *arg){  u32_t i;  /* Get this threads index. */  i = (u32_t)arg;  /* Call the application's thread routine. */  threads[i].thread(threads[i].arg);  /* Free the memory used by this thread's stack. */  mem_free(threads[i].stackstart);  /* Clear the stack from the thread structure. */  threads[i].stackstart = NULL;  threads[i].stackend = NULL;  /* Delete this task. */#if RTOS_SAFERTOS  xTaskDelete(NULL);#elif RTOS_FREERTOS  vTaskDelete(NULL);#endif}

/**		Returns the number of bytes in the queue waiting to be read.  @return bytes in the receive queue.*/int Serial2_GetReadable( int index ){  if ( index < 0 || index > 1 )    return CONTROLLER_ERROR_ILLEGAL_INDEX;  Serial2_* s2p = &Serial2[ index ];  return uxQueueMessagesWaiting( s2p->receiveQueue );}

unsigned portBASE_TYPE MPU_uxQueueMessagesWaiting( const xQueueHandle pxQueue ){portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();unsigned portBASE_TYPE uxReturn;	uxReturn = uxQueueMessagesWaiting( pxQueue );	portRESET_PRIVILEGE( xRunningPrivileged );	return uxReturn;}

/**		Returns the number of bytes in the queue waiting to be read.  @param index Which serial port - SERIAL_0 or SERIAL_1  @return bytes in the receive queue.*/int Serial_GetReadable( int index ){  if ( index < 0 || index >= SERIAL_PORTS )    return CONTROLLER_ERROR_ILLEGAL_INDEX;  Serial_* sp = &Serial[ index ];  return uxQueueMessagesWaiting( sp->receiveQueue );}

UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ){BaseType_t xRunningPrivileged = xPortRaisePrivilege();UBaseType_t uxReturn;	uxReturn = uxQueueMessagesWaiting( pxQueue );	vPortResetPrivilege( xRunningPrivileged );	return uxReturn;}

/* Function: uint8_t OSAL_SEM_GetCount(OSAL_SEM_HANDLE_TYPE semID)  Summary:    Return the current value of a counting semaphore.  Description:    Return the current value of a counting semaphore. The value returned is    assumed to be a single value ranging from 0-255.  Precondition:     Semaphore must have been created.  Parameters:     semID       - The semID  Returns:    0           - Semaphore is unavailable    1-255       - Current value of the counting semaphore  Example:    <code>     uint8_t semCount;     semCount = OSAL_SEM_GetCount(semUART);     if (semCount > 0)     {        // obtain the semaphore         if (OSAL_SEM_Pend(semUART) == OSAL_RESULT_TRUE)         {            // perform processing on the comm channel            ...         }     }     else     {        // no comm channels available        ...     }    </code>  Remarks:     This version of the OSAL_SEM_Post function should be used if the program     is, or may be, operating inside and ISR. The OSAL will take the necessary     steps to ensure correct operation possibly disabling interrupts or entering     a critical section. The exact requirements will depend upon the particular     RTOS being used. */uint8_t OSAL_SEM_GetCount(OSAL_SEM_HANDLE_TYPE* semID){   unsigned portBASE_TYPE SemCount;   SemCount = uxQueueMessagesWaiting(*(xSemaphoreHandle*)semID);   if(SemCount > 255)      SemCount = 255;   return SemCount;}

UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ){    BaseType_t xRunningPrivileged = prvRaisePrivilege();    UBaseType_t uxReturn;    uxReturn = uxQueueMessagesWaiting( pxQueue );    portRESET_PRIVILEGE( xRunningPrivileged );    return uxReturn;}

/*  Deallocates a mailbox. If there are messages still present in the  mailbox when the mailbox is deallocated, it is an indication of a  programming error in lwIP and the developer should be notified.*/voidsys_mbox_free(sys_mbox_t *mbox){    if (uxQueueMessagesWaiting(*mbox)) {        /* Line for breakpoint.  Should never break here! *///		__asm volatile ( "NOP" );    }    vQueueDelete(*mbox);}

s08 uartQueueIsEmpty(u08 nUart){	switch(nUart) {	case 0:		if ( uxQueueMessagesWaiting(xUart0CharsForTxQueue) == 0)			return (TRUE);		else			return(FALSE);		break;	case 1:		if ( uxQueueMessagesWaiting(xUart1CharsForTxQueue) == 0)			return (TRUE);		else			return(FALSE);		break;	}}

void MOMENT_TASK(void *pvParameters){	float Theta[3];	float Cordinate[3];	float F[3] = {0.0, 0.0, 20.0};	float Phi[3];	float Moment[3];	portBASE_TYPE xStatus;	CanRxMsg CanReceiveData;	Moment_Typedef M;	unsigned char Status;	while(1)	{		if (uxQueueMessagesWaiting(CanRxQueue) != NULL)		{			xStatus = xQueueReceive(CanRxQueue, &CanReceiveData, 1);			if (xStatus == pdPASS)			{				F[0] = CanReceiveData.Data[1];				F[1] = CanReceiveData.Data[3];				F[2] = CanReceiveData.Data[5];				if (CanReceiveData.Data[0] == 0)					F[0] = -F[0];				if (CanReceiveData.Data[2] == 0)					F[1] = -F[1];				if (CanReceiveData.Data[4] == 0)					F[2] = -F[2];				F[2] += 18.0;			}		}		Theta[0] = ((float)TSVN_QEI_TIM1_Value()*0.9)/7.0;		Theta[1] = ((float)TSVN_QEI_TIM4_Value()*0.9)/7.0;		Theta[2] = ((float)TSVN_QEI_TIM3_Value()*0.9)/7.0;				Status = (char)Delta_CalcForward(Theta[0], Theta[1], Theta[2], &Cordinate[0], &Cordinate[1], &Cordinate[2]);		if (Status == 0)		{			if (Cordinate[0] >= -44.165 && Cordinate[0] <= 44.165 && 					Cordinate[1] >= -44.165 && Cordinate[1] <= 44.165 &&					Cordinate[2] >= -203.648 && Cordinate[2] <= -115.318)			{					Phi[0] = -90.0;					Phi[1] = 30.0;					Phi[2] = 150;					MomentCalculate(Theta, Phi, Cordinate, F, &Moment);					M.Mx = Moment[0]*1100.0;					M.My = Moment[1]*1100.0;					M.Mz = Moment[2]*1100.0;					xQueueSendToBack(Moment_Queue, &M, 1);			}		}		TSVN_Led_Toggle(LED_D6);		vTaskDelay(200);	}}

static portTASK_FUNCTION( vPolledQueueConsumer, pvParameters ){    unsigned portSHORT usData, usExpectedValue = ( unsigned portSHORT ) 0;    signed portBASE_TYPE xError = pdFALSE;#ifdef USE_STDIO    void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend );    const portCHAR * const pcTaskStartMsg = "Alt blocking queue consumer task started./r/n";    /* Queue a message for printing to say the task has started. */    vPrintDisplayMessage( &pcTaskStartMsg );#endif    for( ;; )    {        /* Loop until the queue is empty. */        while( uxQueueMessagesWaiting( *( ( xQueueHandle * ) pvParameters ) ) )        {            if( xQueueAltReceive( *( ( xQueueHandle * ) pvParameters ), &usData, pollqNO_DELAY ) == pdPASS )            {                if( usData != usExpectedValue )                {                    /* This is not what we expected to receive so an error has                    occurred. */                    xError = pdTRUE;                    /* Catch-up to the value we received so our next expected                    value should again be correct. */                    usExpectedValue = usData;                }                else                {                    if( xError == pdFALSE )                    {                        /* Only increment the check variable if no errors have                        occurred. */                        portENTER_CRITICAL();                        xPollingConsumerCount++;                        portEXIT_CRITICAL();                    }                }                /* Next time round we would expect the number to be one higher. */                usExpectedValue++;            }        }        /* Now the queue is empty we block, allowing the producer to place more        items in the queue. */        vTaskDelay( pollqCONSUMER_DELAY );    }} /*lint !e818 Function prototype must conform to API. */

static void prvHighPriorityPeekTask( void *pvParameters ){xQueueHandle xQueue = ( xQueueHandle ) pvParameters;unsigned portLONG ulValue;	for( ;; )	{		/* Try peeking from the queue.  The queue should be empty so we will		block, allowing the medium priority task to execute.  Both the high		and highest priority tasks will then be blocked on the queue. */		if( xQueuePeek( xQueue, &ulValue, portMAX_DELAY ) != pdPASS )		{			/* We expected to have received something by the time we unblock. */			xErrorDetected = pdTRUE;		}		/* When we get here the highest priority task should have peeked the data		(unblocking this task) then suspended (allowing this task to also peek		the data). */		if( ulValue != 0x01234567 )		{			/* We did not receive the expected value. */			xErrorDetected = pdTRUE;		}		if( uxQueueMessagesWaiting( xQueue ) != 1 )		{			/* The message should have been left on the queue. */			xErrorDetected = pdTRUE;		}		/* We only peeked the data, so suspending ourselves now should enable		the medium priority task to also peek the data.  The medium priority task		will have been unblocked when we peeked the data as we left the data		in the queue. */		vTaskSuspend( NULL );		/* This time we are going actually receive the value, so the medium		priority task will never peek the data - we removed it from the queue. */		if( xQueueReceive( xQueue, &ulValue, portMAX_DELAY ) != pdPASS )		{			xErrorDetected = pdTRUE;		}		if( ulValue != 0xaabbaabb )		{			xErrorDetected = pdTRUE;		}		vTaskSuspend( NULL );					}}

// Read value from local message queuevoid receiveFromMotorQ() {    char readdata[MSG_LENGTH];    // Read from messages until most recent data (FIFO queue)    while (uxQueueMessagesWaiting(motorData.motorQ_LR) != 0){            if (xQueueReceive(motorData.motorQ_LR, &readdata, portMAX_DELAY))        {            //dbgOutputVal(MOTOR_RECEIVEFROMQ);        }     }}

/*---------------------------------------------------------------------------* * Routine:  sys_mbox_free *---------------------------------------------------------------------------* * Description: *      Deallocates a mailbox. If there are messages still present in the *      mailbox when the mailbox is deallocated, it is an indication of a *      programming error in lwIP and the developer should be notified. * Inputs: *      sys_mbox_t mbox         -- Handle of mailbox * Outputs: *      sys_mbox_t              -- Handle to new mailbox *---------------------------------------------------------------------------*/void sys_mbox_free(sys_mbox_t *pxMailBox) {    #if SYS_STATS    unsigned long ulMessagesWaiting;        ulMessagesWaiting = uxQueueMessagesWaiting( *pxMailBox );    configASSERT( ( ulMessagesWaiting == 0 ) );    if (ulMessagesWaiting != 0UL) {            SYS_STATS_INC( mbox.err );    }        SYS_STATS_DEC( mbox.used );        #else        uxQueueMessagesWaiting( *pxMailBox);        #endif    vQueueDelete( *pxMailBox );}

static void setStepperState(uint32_t state){    while(uxQueueMessagesWaiting( movementQueue )); // Clear Movements    if(state){        GPIO_ResetBits(EnPinPort, XEnPin | YEnPin | ZEnPin);    }else{        GPIO_SetBits(EnPinPort, XEnPin | YEnPin | ZEnPin);    }        stepperState = state;    return;}

/** *  Get buffer from stack. * *	/param blocktime  time to wait for buffer * *  /return           pointer to buffer, 0 on failure (all buffers allocated) */buffer_t* stack_buffer_get ( portTickType blocktime ){  buffer_t *b;  if (xQueueReceive( buffers, &( b ), 0) == pdTRUE)	{		b->dir = BUFFER_DOWN;		b->buf_ptr = 0;		b->buf_end = 0;		b->size = BUFFER_SIZE;		buffer_left--;		if (uxQueueMessagesWaiting(buffers) == 0){b->options.last_buffer_when_pulled = 1;}else{b->options.last_buffer_when_pulled = 0;}#ifdef CHECK_BUFFERS		del_from_buffer(b, avail_buffers);#endif /* CHECK_BUFFERS */		return b;	}    else if (xQueueReceive( buffers, &( b ), blocktime / portTICK_RATE_MS) == pdTRUE)	{		b->dir = BUFFER_DOWN;		b->buf_ptr = 0;		b->buf_end = 0;		b->size = BUFFER_SIZE;		buffer_left--;		if (uxQueueMessagesWaiting(buffers) == 0){b->options.last_buffer_when_pulled = 1;}else{b->options.last_buffer_when_pulled = 0;}#ifdef CHECK_BUFFERS		del_from_buffer(b, avail_buffers);#endif /* CHECK_BUFFERS */		return b;	}	debug_printf("S: No buffer left (%d)/r/n", mac_tx_wr);#ifdef HAVE_WDT	WDTCTL  = 0; // reset chip !#endif /* HAVE_WDG */	return 0;}