xQueueOverwriteFromISR

queue. h

 BaseType_t xQueueOverwriteFromISR(
                                                          QueueHandle_t xQueue,
                                                          const void * pvItemToQueue,
                                                          BaseType_t *pxHigherPriorityTaskWoken
                                                 );
   

A version of xQueueOverwrite() that can be used in an interrupt service routine (ISR).

Only for use with queues that can hold a single item - so the queue is either empty or full.

Post an item on a queue. If the queue is already full then overwrite the value held in the queue. The item is queued by copy, not by reference.

Parameters

xQueue	The handle to the queue on which the item is to be posted.
pvItemToQueue	A pointer to the item that is to be placed on the queue. The size of the items the queue will hold was defined when the queue was created, so this many bytes will be copied from pvItemToQueue into the queue storage area.
pxHigherPriorityTaskWoken	xQueueOverwriteFromISR() will set *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task to unblock, and the unblocked task has a priority higher than the currently running task. If xQueueOverwriteFromISR() sets this value to pdTRUE then a context switch should be requested before the interrupt is exited.

Returns

xQueueOverwriteFromISR() is a macro that calls xQueueGenericSendFromISR(), and therefore has the same return values as xQueueSendToFrontFromISR(). However, pdPASS is the only value that can be returned because xQueueOverwriteFromISR() will write to the queue even when the queue is already full.

Example usage:

 QueueHandle_t xQueue;

 void vFunction( void <em>pvParameters )
 {
Create a queue to hold one uint32_t value.  It is strongly
recommended *not to use xQueueOverwriteFromISR() on queues that can
contain more than one value, and doing so will trigger an assertion
if configASSERT() is defined.
        xQueue = xQueueCreate( 1, sizeof( uint32_t ) );
}

void vAnInterruptHandler( void )
{
xHigherPriorityTaskWoken must be set to pdFALSE before it is used.
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
uint32_t ulVarToSend, ulValReceived;

Write the value 10 to the queue using xQueueOverwriteFromISR().
        ulVarToSend = 10;
        xQueueOverwriteFromISR( xQueue, &ulVarToSend, &xHigherPriorityTaskWoken );

The queue is full, but calling xQueueOverwriteFromISR() again will still
pass because the value held in the queue will be overwritten with the
new value.
        ulVarToSend = 100;
        xQueueOverwriteFromISR( xQueue, &ulVarToSend, &xHigherPriorityTaskWoken );

Reading from the queue will now return 100.

...

    if( xHigherPrioritytaskWoken == pdTRUE )
    {

Writing to the queue caused a task to unblock and the unblocked task
has a priority higher than or equal to the priority of the currently
executing task (the task this interrupt interrupted).  Perform a context
switch so this interrupt returns directly to the unblocked task.
                portYIELD_FROM_ISR(); // or portEND_SWITCHING_ISR() depending on the port.
        }
}