Function esp_idf_hal::sys::xTaskCheckForTimeOut

pub unsafe extern "C" fn xTaskCheckForTimeOut(
    pxTimeOut: *mut xTIME_OUT,
    pxTicksToWait: *mut u32
) -> i32

@cond !DOC_EXCLUDE_HEADER_SECTION task.h @code BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait ); @endcode @endcond

Determines if pxTicksToWait ticks has passed since a time was captured using a call to vTaskSetTimeOutState(). The captured time includes the tick count and the number of times the tick count has overflowed.

@param pxTimeOut The time status as captured previously using vTaskSetTimeOutState. If the timeout has not yet occurred, it is updated to reflect the current time status. @param pxTicksToWait The number of ticks to check for timeout i.e. if pxTicksToWait ticks have passed since pxTimeOut was last updated (either by vTaskSetTimeOutState() or xTaskCheckForTimeOut()), the timeout has occurred. If the timeout has not occurred, pxTicksToWait is updated to reflect the number of remaining ticks.

@return If timeout has occurred, pdTRUE is returned. Otherwise pdFALSE is returned and pxTicksToWait is updated to reflect the number of remaining ticks.

@see https://www.FreeRTOS.org/xTaskCheckForTimeOut.html

Example Usage: @code // Driver library function used to receive uxWantedBytes from an Rx buffer // that is filled by a UART interrupt. If there are not enough bytes in the // Rx buffer then the task enters the Blocked state until it is notified that // more data has been placed into the buffer. If there is still not enough // data then the task re-enters the Blocked state, and xTaskCheckForTimeOut() // is used to re-calculate the Block time to ensure the total amount of time // spent in the Blocked state does not exceed MAX_TIME_TO_WAIT. This // continues until either the buffer contains at least uxWantedBytes bytes, // or the total amount of time spent in the Blocked state reaches // MAX_TIME_TO_WAIT – at which point the task reads however many bytes are // available up to a maximum of uxWantedBytes.

size_t xUART_Receive( uint8_t *pucBuffer, size_t uxWantedBytes ) { size_t uxReceived = 0; TickType_t xTicksToWait = MAX_TIME_TO_WAIT; TimeOut_t xTimeOut;

 // Initialize xTimeOut.  This records the time at which this function
 // was entered.
 vTaskSetTimeOutState( &xTimeOut );

 // Loop until the buffer contains the wanted number of bytes, or a
 // timeout occurs.
 while( UART_bytes_in_rx_buffer( pxUARTInstance ) < uxWantedBytes )
 {
     // The buffer didn't contain enough data so this task is going to
     // enter the Blocked state. Adjusting xTicksToWait to account for
     // any time that has been spent in the Blocked state within this
     // function so far to ensure the total amount of time spent in the
     // Blocked state does not exceed MAX_TIME_TO_WAIT.
     if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) != pdFALSE )
     {
         //Timed out before the wanted number of bytes were available,
         // exit the loop.
         break;
     }

     // Wait for a maximum of xTicksToWait ticks to be notified that the
     // receive interrupt has placed more data into the buffer.
     ulTaskNotifyTake( pdTRUE, xTicksToWait );
 }

 // Attempt to read uxWantedBytes from the receive buffer into pucBuffer.
 // The actual number of bytes read (which might be less than
 // uxWantedBytes) is returned.
 uxReceived = UART_read_from_receive_buffer( pxUARTInstance,
                                             pucBuffer,
                                             uxWantedBytes );

 return uxReceived;

} @endcode @cond !DOC_SINGLE_GROUP \defgroup xTaskCheckForTimeOut xTaskCheckForTimeOut @endcond \ingroup TaskCtrl