UART Transmit and Receive functions. More...

Collaboration diagram for IO operation functions:

Functions
HAL_StatusTypeDef	HAL_UART_Transmit (UART_HandleTypeDef huart, const uint8_t pData, uint16_t Size, uint32_t Timeout)
	Sends an amount of data in blocking mode.

HAL_StatusTypeDef	HAL_UART_Receive (UART_HandleTypeDef huart, uint8_t pData, uint16_t Size, uint32_t Timeout)
	Receives an amount of data in blocking mode.

HAL_StatusTypeDef	HAL_UART_Transmit_IT (UART_HandleTypeDef huart, const uint8_t pData, uint16_t Size)
	Sends an amount of data in non blocking mode.

HAL_StatusTypeDef	HAL_UART_Receive_IT (UART_HandleTypeDef huart, uint8_t pData, uint16_t Size)
	Receives an amount of data in non blocking mode.

HAL_StatusTypeDef	HAL_UART_Transmit_DMA (UART_HandleTypeDef huart, const uint8_t pData, uint16_t Size)
	Sends an amount of data in DMA mode.

HAL_StatusTypeDef	HAL_UART_Receive_DMA (UART_HandleTypeDef huart, uint8_t pData, uint16_t Size)
	Receives an amount of data in DMA mode.

HAL_StatusTypeDef	HAL_UART_DMAPause (UART_HandleTypeDef *huart)
	Pauses the DMA Transfer.

HAL_StatusTypeDef	HAL_UART_DMAResume (UART_HandleTypeDef *huart)
	Resumes the DMA Transfer.

HAL_StatusTypeDef	HAL_UART_DMAStop (UART_HandleTypeDef *huart)
	Stops the DMA Transfer.

HAL_StatusTypeDef	HAL_UARTEx_ReceiveToIdle (UART_HandleTypeDef huart, uint8_t pData, uint16_t Size, uint16_t *RxLen, uint32_t Timeout)
	Receive an amount of data in blocking mode till either the expected number of data is received or an IDLE event occurs.

HAL_StatusTypeDef	HAL_UARTEx_ReceiveToIdle_IT (UART_HandleTypeDef huart, uint8_t pData, uint16_t Size)
	Receive an amount of data in interrupt mode till either the expected number of data is received or an IDLE event occurs.

HAL_StatusTypeDef	HAL_UARTEx_ReceiveToIdle_DMA (UART_HandleTypeDef huart, uint8_t pData, uint16_t Size)
	Receive an amount of data in DMA mode till either the expected number of data is received or an IDLE event occurs.

HAL_UART_RxEventTypeTypeDef	HAL_UARTEx_GetRxEventType (UART_HandleTypeDef *huart)
	Provide Rx Event type that has lead to RxEvent callback execution.

HAL_StatusTypeDef	HAL_UART_Abort (UART_HandleTypeDef *huart)
	Abort ongoing transfers (blocking mode).

HAL_StatusTypeDef	HAL_UART_AbortTransmit (UART_HandleTypeDef *huart)
	Abort ongoing Transmit transfer (blocking mode).

HAL_StatusTypeDef	HAL_UART_AbortReceive (UART_HandleTypeDef *huart)
	Abort ongoing Receive transfer (blocking mode).

HAL_StatusTypeDef	HAL_UART_Abort_IT (UART_HandleTypeDef *huart)
	Abort ongoing transfers (Interrupt mode).

HAL_StatusTypeDef	HAL_UART_AbortTransmit_IT (UART_HandleTypeDef *huart)
	Abort ongoing Transmit transfer (Interrupt mode).

HAL_StatusTypeDef	HAL_UART_AbortReceive_IT (UART_HandleTypeDef *huart)
	Abort ongoing Receive transfer (Interrupt mode).

void	HAL_UART_IRQHandler (UART_HandleTypeDef *huart)
	This function handles UART interrupt request.

void	HAL_UART_TxCpltCallback (UART_HandleTypeDef *huart)
	Tx Transfer completed callbacks.

void	HAL_UART_TxHalfCpltCallback (UART_HandleTypeDef *huart)
	Tx Half Transfer completed callbacks.

void	HAL_UART_RxCpltCallback (UART_HandleTypeDef *huart)
	Rx Transfer completed callbacks.

void	HAL_UART_RxHalfCpltCallback (UART_HandleTypeDef *huart)
	Rx Half Transfer completed callbacks.

void	HAL_UART_ErrorCallback (UART_HandleTypeDef *huart)
	UART error callbacks.

void	HAL_UART_AbortCpltCallback (UART_HandleTypeDef *huart)
	UART Abort Complete callback.

void	HAL_UART_AbortTransmitCpltCallback (UART_HandleTypeDef *huart)
	UART Abort Complete callback.

void	HAL_UART_AbortReceiveCpltCallback (UART_HandleTypeDef *huart)
	UART Abort Receive Complete callback.

void	HAL_UARTEx_RxEventCallback (UART_HandleTypeDef *huart, uint16_t Size)
	Reception Event Callback (Rx event notification called after use of advanced reception service).

Detailed Description

UART Transmit and Receive functions.

 ===============================================================================
                      ##### IO operation functions #####
 ===============================================================================
    This subsection provides a set of functions allowing to manage the UART asynchronous
    and Half duplex data transfers.

    (#) There are two modes of transfer:
       (+) Blocking mode: The communication is performed in polling mode.
           The HAL status of all data processing is returned by the same function
           after finishing transfer.
       (+) Non-Blocking mode: The communication is performed using Interrupts
           or DMA, these API's return the HAL status.
           The end of the data processing will be indicated through the
           dedicated UART IRQ when using Interrupt mode or the DMA IRQ when
           using DMA mode.
           The HAL_UART_TxCpltCallback(), HAL_UART_RxCpltCallback() user callbacks
           will be executed respectively at the end of the transmit or receive process
           The HAL_UART_ErrorCallback()user callback will be executed when a communication error is detected.

    (#) Blocking mode API's are :
        (+) HAL_UART_Transmit()
        (+) HAL_UART_Receive()

    (#) Non-Blocking mode API's with Interrupt are :
        (+) HAL_UART_Transmit_IT()
        (+) HAL_UART_Receive_IT()
        (+) HAL_UART_IRQHandler()

    (#) Non-Blocking mode API's with DMA are :
        (+) HAL_UART_Transmit_DMA()
        (+) HAL_UART_Receive_DMA()
        (+) HAL_UART_DMAPause()
        (+) HAL_UART_DMAResume()
        (+) HAL_UART_DMAStop()

    (#) A set of Transfer Complete Callbacks are provided in Non_Blocking mode:
        (+) HAL_UART_TxHalfCpltCallback()
        (+) HAL_UART_TxCpltCallback()
        (+) HAL_UART_RxHalfCpltCallback()
        (+) HAL_UART_RxCpltCallback()
        (+) HAL_UART_ErrorCallback()

    (#) Non-Blocking mode transfers could be aborted using Abort API's :
        (+) HAL_UART_Abort()
        (+) HAL_UART_AbortTransmit()
        (+) HAL_UART_AbortReceive()
        (+) HAL_UART_Abort_IT()
        (+) HAL_UART_AbortTransmit_IT()
        (+) HAL_UART_AbortReceive_IT()

    (#) For Abort services based on interrupts (HAL_UART_Abortxxx_IT), a set of Abort Complete Callbacks are provided:
        (+) HAL_UART_AbortCpltCallback()
        (+) HAL_UART_AbortTransmitCpltCallback()
        (+) HAL_UART_AbortReceiveCpltCallback()

    (#) A Rx Event Reception Callback (Rx event notification) is available for Non_Blocking modes of enhanced reception services:
        (+) HAL_UARTEx_RxEventCallback()

    (#) In Non-Blocking mode transfers, possible errors are split into 2 categories.
        Errors are handled as follows :
       (+) Error is considered as Recoverable and non blocking : Transfer could go till end, but error severity is
           to be evaluated by user : this concerns Frame Error, Parity Error or Noise Error in Interrupt mode reception .
           Received character is then retrieved and stored in Rx buffer, Error code is set to allow user to identify error type,
           and HAL_UART_ErrorCallback() user callback is executed. Transfer is kept ongoing on UART side.
           If user wants to abort it, Abort services should be called by user.
       (+) Error is considered as Blocking : Transfer could not be completed properly and is aborted.
           This concerns Overrun Error In Interrupt mode reception and all errors in DMA mode.
           Error code is set to allow user to identify error type, and HAL_UART_ErrorCallback() user callback is executed.

    -@- In the Half duplex communication, it is forbidden to run the transmit
        and receive process in parallel, the UART state HAL_UART_STATE_BUSY_TX_RX can't be useful.

Function Documentation

◆ HAL_UART_Transmit()

HAL_StatusTypeDef HAL_UART_Transmit	(	UART_HandleTypeDef *	huart,
		const uint8_t *	pData,
		uint16_t	Size,
		uint32_t	Timeout )

#include <stm32f4xx_hal_uart.h>

Sends an amount of data in blocking mode.

Note: When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01), the sent data is handled as a set of u16. In this case, Size must indicate the number of u16 provided through pData.

Parameters

huart	Pointer to a UART_HandleTypeDef structure that contains the configuration information for the specified UART module.
pData	Pointer to data buffer (u8 or u16 data elements).
Size	Amount of data elements (u8 or u16) to be sent
Timeout	Timeout duration

Return values

HAL status

Definition at line 1135 of file stm32f4xx_hal_uart.c.

References __UART_HandleTypeDef::ErrorCode, __UART_HandleTypeDef::gState, HAL_BUSY, HAL_ERROR, HAL_GetTick(), HAL_OK, HAL_TIMEOUT, HAL_UART_ERROR_NONE, HAL_UART_STATE_BUSY_TX, HAL_UART_STATE_READY, __UART_HandleTypeDef::Init, __UART_HandleTypeDef::Instance, UART_InitTypeDef::Parity, __UART_HandleTypeDef::TxXferCount, __UART_HandleTypeDef::TxXferSize, UART_FLAG_TC, UART_FLAG_TXE, UART_PARITY_NONE, UART_WaitOnFlagUntilTimeout(), UART_WORDLENGTH_9B, and UART_InitTypeDef::WordLength.

◆ HAL_UART_Receive()

HAL_StatusTypeDef HAL_UART_Receive	(	UART_HandleTypeDef *	huart,
		uint8_t *	pData,
		uint16_t	Size,
		uint32_t	Timeout )

#include <stm32f4xx_hal_uart.h>

Receives an amount of data in blocking mode.

Note: When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01), the received data is handled as a set of u16. In this case, Size must indicate the number of u16 available through pData.

Parameters

huart	Pointer to a UART_HandleTypeDef structure that contains the configuration information for the specified UART module.
pData	Pointer to data buffer (u8 or u16 data elements).
Size	Amount of data elements (u8 or u16) to be received.
Timeout	Timeout duration

Return values

HAL status

Definition at line 1221 of file stm32f4xx_hal_uart.c.

References __UART_HandleTypeDef::ErrorCode, HAL_BUSY, HAL_ERROR, HAL_GetTick(), HAL_OK, HAL_TIMEOUT, HAL_UART_ERROR_NONE, HAL_UART_RECEPTION_STANDARD, HAL_UART_STATE_BUSY_RX, HAL_UART_STATE_READY, __UART_HandleTypeDef::Init, __UART_HandleTypeDef::Instance, UART_InitTypeDef::Parity, __UART_HandleTypeDef::ReceptionType, __UART_HandleTypeDef::RxState, __UART_HandleTypeDef::RxXferCount, __UART_HandleTypeDef::RxXferSize, UART_FLAG_RXNE, UART_PARITY_NONE, UART_WaitOnFlagUntilTimeout(), UART_WORDLENGTH_8B, UART_WORDLENGTH_9B, and UART_InitTypeDef::WordLength.

◆ HAL_UART_Transmit_IT()

HAL_StatusTypeDef HAL_UART_Transmit_IT	(	UART_HandleTypeDef *	huart,
		const uint8_t *	pData,
		uint16_t	Size )

#include <stm32f4xx_hal_uart.h>

Sends an amount of data in non blocking mode.

Note: When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01), the sent data is handled as a set of u16. In this case, Size must indicate the number of u16 provided through pData.

Parameters

huart	Pointer to a UART_HandleTypeDef structure that contains the configuration information for the specified UART module.
pData	Pointer to data buffer (u8 or u16 data elements).
Size	Amount of data elements (u8 or u16) to be sent

Return values

HAL status

Definition at line 1308 of file stm32f4xx_hal_uart.c.

References __HAL_UART_ENABLE_IT, __UART_HandleTypeDef::ErrorCode, __UART_HandleTypeDef::gState, HAL_BUSY, HAL_ERROR, HAL_OK, HAL_UART_ERROR_NONE, HAL_UART_STATE_BUSY_TX, HAL_UART_STATE_READY, __UART_HandleTypeDef::pTxBuffPtr, __UART_HandleTypeDef::TxXferCount, __UART_HandleTypeDef::TxXferSize, and UART_IT_TXE.

◆ HAL_UART_Receive_IT()

HAL_StatusTypeDef HAL_UART_Receive_IT	(	UART_HandleTypeDef *	huart,
		uint8_t *	pData,
		uint16_t	Size )

#include <stm32f4xx_hal_uart.h>

Receives an amount of data in non blocking mode.

Note: When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01), the received data is handled as a set of u16. In this case, Size must indicate the number of u16 available through pData.

Parameters

huart	Pointer to a UART_HandleTypeDef structure that contains the configuration information for the specified UART module.
pData	Pointer to data buffer (u8 or u16 data elements).
Size	Amount of data elements (u8 or u16) to be received.

Return values

HAL status

Definition at line 1347 of file stm32f4xx_hal_uart.c.

References HAL_BUSY, HAL_ERROR, HAL_UART_RECEPTION_STANDARD, HAL_UART_STATE_READY, __UART_HandleTypeDef::ReceptionType, __UART_HandleTypeDef::RxState, and UART_Start_Receive_IT().

◆ HAL_UART_Transmit_DMA()

HAL_StatusTypeDef HAL_UART_Transmit_DMA	(	UART_HandleTypeDef *	huart,
		const uint8_t *	pData,
		uint16_t	Size )

#include <stm32f4xx_hal_uart.h>

Sends an amount of data in DMA mode.

Note: When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01), the sent data is handled as a set of u16. In this case, Size must indicate the number of u16 provided through pData.

Parameters

huart	Pointer to a UART_HandleTypeDef structure that contains the configuration information for the specified UART module.
pData	Pointer to data buffer (u8 or u16 data elements).
Size	Amount of data elements (u8 or u16) to be sent

Return values

HAL status

Definition at line 1379 of file stm32f4xx_hal_uart.c.

References __HAL_UART_CLEAR_FLAG, __UART_HandleTypeDef::ErrorCode, __UART_HandleTypeDef::gState, HAL_BUSY, HAL_DMA_Start_IT(), HAL_ERROR, HAL_OK, HAL_UART_ERROR_NONE, HAL_UART_STATE_BUSY_TX, HAL_UART_STATE_READY, __UART_HandleTypeDef::hdmatx, __UART_HandleTypeDef::Instance, __UART_HandleTypeDef::pTxBuffPtr, __UART_HandleTypeDef::TxXferCount, __UART_HandleTypeDef::TxXferSize, UART_DMAError(), UART_DMATransmitCplt(), UART_DMATxHalfCplt(), UART_FLAG_TC, __DMA_HandleTypeDef::XferAbortCallback, __DMA_HandleTypeDef::XferCpltCallback, __DMA_HandleTypeDef::XferErrorCallback, and __DMA_HandleTypeDef::XferHalfCpltCallback.

◆ HAL_UART_Receive_DMA()

HAL_StatusTypeDef HAL_UART_Receive_DMA	(	UART_HandleTypeDef *	huart,
		uint8_t *	pData,
		uint16_t	Size )

#include <stm32f4xx_hal_uart.h>

Receives an amount of data in DMA mode.

Note: When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01), the received data is handled as a set of u16. In this case, Size must indicate the number of u16 available through pData.

Parameters

huart	Pointer to a UART_HandleTypeDef structure that contains the configuration information for the specified UART module.
pData	Pointer to data buffer (u8 or u16 data elements).
Size	Amount of data elements (u8 or u16) to be received.

Note: When the UART parity is enabled (PCE = 1) the received data contains the parity bit.

Return values

HAL status

Definition at line 1441 of file stm32f4xx_hal_uart.c.

References HAL_BUSY, HAL_ERROR, HAL_UART_RECEPTION_STANDARD, HAL_UART_STATE_READY, __UART_HandleTypeDef::ReceptionType, __UART_HandleTypeDef::RxState, and UART_Start_Receive_DMA().

◆ HAL_UART_DMAPause()

HAL_StatusTypeDef HAL_UART_DMAPause ( UART_HandleTypeDef * huart )

#include <stm32f4xx_hal_uart.h>

Pauses the DMA Transfer.

Parameters

huart Pointer to a UART_HandleTypeDef structure that contains the configuration information for the specified UART module.

Return values

HAL status

Definition at line 1468 of file stm32f4xx_hal_uart.c.

References __UART_HandleTypeDef::gState, HAL_IS_BIT_SET, HAL_OK, HAL_UART_STATE_BUSY_RX, HAL_UART_STATE_BUSY_TX, __UART_HandleTypeDef::Instance, and __UART_HandleTypeDef::RxState.

◆ HAL_UART_DMAResume()

HAL_StatusTypeDef HAL_UART_DMAResume ( UART_HandleTypeDef * huart )

#include <stm32f4xx_hal_uart.h>

Resumes the DMA Transfer.

Parameters

huart Pointer to a UART_HandleTypeDef structure that contains the configuration information for the specified UART module.

Return values

HAL status

Definition at line 1499 of file stm32f4xx_hal_uart.c.

References __HAL_UART_CLEAR_OREFLAG, __UART_HandleTypeDef::gState, HAL_OK, HAL_UART_STATE_BUSY_RX, HAL_UART_STATE_BUSY_TX, __UART_HandleTypeDef::Init, __UART_HandleTypeDef::Instance, UART_InitTypeDef::Parity, __UART_HandleTypeDef::RxState, and UART_PARITY_NONE.

◆ HAL_UART_DMAStop()

HAL_StatusTypeDef HAL_UART_DMAStop ( UART_HandleTypeDef * huart )

#include <stm32f4xx_hal_uart.h>

Stops the DMA Transfer.

Parameters

huart Pointer to a UART_HandleTypeDef structure that contains the configuration information for the specified UART module.

Return values

HAL status

Definition at line 1533 of file stm32f4xx_hal_uart.c.

References __UART_HandleTypeDef::gState, HAL_DMA_Abort(), HAL_IS_BIT_SET, HAL_OK, HAL_UART_STATE_BUSY_RX, HAL_UART_STATE_BUSY_TX, __UART_HandleTypeDef::hdmarx, __UART_HandleTypeDef::hdmatx, __UART_HandleTypeDef::Instance, __UART_HandleTypeDef::RxState, UART_EndRxTransfer(), and UART_EndTxTransfer().

◆ HAL_UARTEx_ReceiveToIdle()

HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle	(	UART_HandleTypeDef *	huart,
		uint8_t *	pData,
		uint16_t	Size,
		uint16_t *	RxLen,
		uint32_t	Timeout )

#include <stm32f4xx_hal_uart.h>

Receive an amount of data in blocking mode till either the expected number of data is received or an IDLE event occurs.

Note: HAL_OK is returned if reception is completed (expected number of data has been received) or if reception is stopped after IDLE event (less than the expected number of data has been received) In this case, RxLen output parameter indicates number of data available in reception buffer.; When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M = 01), the received data is handled as a set of uint16_t. In this case, Size must indicate the number of uint16_t available through pData.

Parameters

huart	UART handle.
pData	Pointer to data buffer (uint8_t or uint16_t data elements).
Size	Amount of data elements (uint8_t or uint16_t) to be received.
RxLen	Number of data elements finally received (could be lower than Size, in case reception ends on IDLE event)
Timeout	Timeout duration expressed in ms (covers the whole reception sequence).

Return values

HAL status

Definition at line 1588 of file stm32f4xx_hal_uart.c.

◆ HAL_UARTEx_ReceiveToIdle_IT()

HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_IT	(	UART_HandleTypeDef *	huart,
		uint8_t *	pData,
		uint16_t	Size )

#include <stm32f4xx_hal_uart.h>

Receive an amount of data in interrupt mode till either the expected number of data is received or an IDLE event occurs.

Note: Reception is initiated by this function call. Further progress of reception is achieved thanks to UART interrupts raised by RXNE and IDLE events. Callback is called at end of reception indicating number of received data elements.; When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M = 01), the received data is handled as a set of uint16_t. In this case, Size must indicate the number of uint16_t available through pData.

Parameters

huart	UART handle.
pData	Pointer to data buffer (uint8_t or uint16_t data elements).
Size	Amount of data elements (uint8_t or uint16_t) to be received.

Return values

HAL status

Definition at line 1713 of file stm32f4xx_hal_uart.c.

References __HAL_UART_CLEAR_IDLEFLAG, HAL_BUSY, HAL_ERROR, HAL_OK, HAL_UART_RECEPTION_TOIDLE, HAL_UART_RXEVENT_TC, HAL_UART_STATE_READY, __UART_HandleTypeDef::Instance, __UART_HandleTypeDef::ReceptionType, __UART_HandleTypeDef::RxEventType, __UART_HandleTypeDef::RxState, and UART_Start_Receive_IT().

◆ HAL_UARTEx_ReceiveToIdle_DMA()

HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_DMA	(	UART_HandleTypeDef *	huart,
		uint8_t *	pData,
		uint16_t	Size )

#include <stm32f4xx_hal_uart.h>

Receive an amount of data in DMA mode till either the expected number of data is received or an IDLE event occurs.

Note: Reception is initiated by this function call. Further progress of reception is achieved thanks to DMA services, transferring automatically received data elements in user reception buffer and calling registered callbacks at half/end of reception. UART IDLE events are also used to consider reception phase as ended. In all cases, callback execution will indicate number of received data elements.; When the UART parity is enabled (PCE = 1), the received data contain the parity bit (MSB position).; When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M = 01), the received data is handled as a set of uint16_t. In this case, Size must indicate the number of uint16_t available through pData.

Parameters

huart	UART handle.
pData	Pointer to data buffer (uint8_t or uint16_t data elements).
Size	Amount of data elements (uint8_t or uint16_t) to be received.

Return values

HAL status

Definition at line 1773 of file stm32f4xx_hal_uart.c.

References __HAL_UART_CLEAR_IDLEFLAG, HAL_BUSY, HAL_ERROR, HAL_OK, HAL_UART_RECEPTION_TOIDLE, HAL_UART_RXEVENT_TC, HAL_UART_STATE_READY, __UART_HandleTypeDef::Instance, __UART_HandleTypeDef::ReceptionType, __UART_HandleTypeDef::RxEventType, __UART_HandleTypeDef::RxState, and UART_Start_Receive_DMA().

◆ HAL_UARTEx_GetRxEventType()

HAL_UART_RxEventTypeTypeDef HAL_UARTEx_GetRxEventType ( UART_HandleTypeDef * huart )

#include <stm32f4xx_hal_uart.h>

Provide Rx Event type that has lead to RxEvent callback execution.

Note

When HAL_UARTEx_ReceiveToIdle_IT() or HAL_UARTEx_ReceiveToIdle_DMA() API are called, progress of reception process is provided to application through calls of Rx Event callback (either default one HAL_UARTEx_RxEventCallback() or user registered one). As several types of events could occur (IDLE event, Half Transfer, or Transfer Complete), this function allows to retrieve the Rx Event type that has lead to Rx Event callback execution.

This function is expected to be called within the user implementation of Rx Event Callback, in order to provide the accurate value : In Interrupt Mode :

HAL_UART_RXEVENT_TC : when Reception has been completed (expected nb of data has been received)
HAL_UART_RXEVENT_IDLE : when Idle event occurred prior reception has been completed (nb of received data is lower than expected one) In DMA Mode :
HAL_UART_RXEVENT_TC : when Reception has been completed (expected nb of data has been received)
HAL_UART_RXEVENT_HT : when half of expected nb of data has been received
HAL_UART_RXEVENT_IDLE : when Idle event occurred prior reception has been completed (nb of received data is lower than expected one). In DMA mode, RxEvent callback could be called several times; When DMA is configured in Normal Mode, HT event does not stop Reception process; When DMA is configured in Circular Mode, HT, TC or IDLE events don't stop Reception process;

Parameters

huart UART handle.

Return values

Rx	Event Type (returned value will be a value of UART RxEvent type values)

Definition at line 1841 of file stm32f4xx_hal_uart.c.

References __UART_HandleTypeDef::RxEventType.

◆ HAL_UART_Abort()

HAL_StatusTypeDef HAL_UART_Abort ( UART_HandleTypeDef * huart )

#include <stm32f4xx_hal_uart.h>

Abort ongoing transfers (blocking mode).

Parameters

huart UART handle.

Note

This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode. This procedure performs following operations :

Disable UART Interrupts (Tx and Rx)
Disable the DMA transfer in the peripheral register (if enabled)
Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
Set handle State to READY

This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.

Return values

HAL status

Definition at line 1859 of file stm32f4xx_hal_uart.c.

◆ HAL_UART_AbortTransmit()

HAL_StatusTypeDef HAL_UART_AbortTransmit ( UART_HandleTypeDef * huart )

#include <stm32f4xx_hal_uart.h>

Abort ongoing Transmit transfer (blocking mode).

Parameters

huart UART handle.

Note

This procedure could be used for aborting any ongoing Tx transfer started in Interrupt or DMA mode. This procedure performs following operations :

Disable UART Interrupts (Tx)
Disable the DMA transfer in the peripheral register (if enabled)
Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
Set handle State to READY

This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.

Return values

HAL status

Definition at line 1948 of file stm32f4xx_hal_uart.c.

References __UART_HandleTypeDef::ErrorCode, __UART_HandleTypeDef::gState, HAL_DMA_Abort(), HAL_DMA_ERROR_TIMEOUT, HAL_DMA_GetError(), HAL_IS_BIT_SET, HAL_OK, HAL_TIMEOUT, HAL_UART_ERROR_DMA, HAL_UART_STATE_READY, __UART_HandleTypeDef::hdmatx, __UART_HandleTypeDef::Instance, __UART_HandleTypeDef::TxXferCount, and __DMA_HandleTypeDef::XferAbortCallback.

◆ HAL_UART_AbortReceive()

HAL_StatusTypeDef HAL_UART_AbortReceive ( UART_HandleTypeDef * huart )

#include <stm32f4xx_hal_uart.h>

Abort ongoing Receive transfer (blocking mode).

Parameters

huart UART handle.

Note

This procedure could be used for aborting any ongoing Rx transfer started in Interrupt or DMA mode. This procedure performs following operations :

Disable UART Interrupts (Rx)
Disable the DMA transfer in the peripheral register (if enabled)
Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
Set handle State to READY

This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.

Return values

HAL status

Definition at line 1999 of file stm32f4xx_hal_uart.c.

References __UART_HandleTypeDef::ErrorCode, HAL_DMA_Abort(), HAL_DMA_ERROR_TIMEOUT, HAL_DMA_GetError(), HAL_IS_BIT_SET, HAL_OK, HAL_TIMEOUT, HAL_UART_ERROR_DMA, HAL_UART_RECEPTION_STANDARD, HAL_UART_RECEPTION_TOIDLE, HAL_UART_STATE_READY, __UART_HandleTypeDef::hdmarx, __UART_HandleTypeDef::Instance, __UART_HandleTypeDef::ReceptionType, __UART_HandleTypeDef::RxState, __UART_HandleTypeDef::RxXferCount, and __DMA_HandleTypeDef::XferAbortCallback.

◆ HAL_UART_Abort_IT()

HAL_StatusTypeDef HAL_UART_Abort_IT ( UART_HandleTypeDef * huart )

#include <stm32f4xx_hal_uart.h>

Abort ongoing transfers (Interrupt mode).

Parameters

huart UART handle.

Note

This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode. This procedure performs following operations :

Disable UART Interrupts (Tx and Rx)
Disable the DMA transfer in the peripheral register (if enabled)
Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
Set handle State to READY
At abort completion, call user abort complete callback

This procedure is executed in Interrupt mode, meaning that abort procedure could be considered as completed only when user abort complete callback is executed (not when exiting function).

Return values

HAL status

Definition at line 2060 of file stm32f4xx_hal_uart.c.

◆ HAL_UART_AbortTransmit_IT()

HAL_StatusTypeDef HAL_UART_AbortTransmit_IT ( UART_HandleTypeDef * huart )

#include <stm32f4xx_hal_uart.h>

Abort ongoing Transmit transfer (Interrupt mode).

Parameters

huart UART handle.

Note

This procedure could be used for aborting any ongoing Tx transfer started in Interrupt or DMA mode. This procedure performs following operations :

Disable UART Interrupts (Tx)
Disable the DMA transfer in the peripheral register (if enabled)
Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
Set handle State to READY
At abort completion, call user abort complete callback

This procedure is executed in Interrupt mode, meaning that abort procedure could be considered as completed only when user abort complete callback is executed (not when exiting function).

Return values

HAL status

Definition at line 2195 of file stm32f4xx_hal_uart.c.

References __UART_HandleTypeDef::gState, HAL_DMA_Abort_IT(), HAL_IS_BIT_SET, HAL_OK, HAL_UART_AbortTransmitCpltCallback(), HAL_UART_STATE_READY, __UART_HandleTypeDef::hdmatx, __UART_HandleTypeDef::Instance, __UART_HandleTypeDef::TxXferCount, UART_DMATxOnlyAbortCallback(), and __DMA_HandleTypeDef::XferAbortCallback.

◆ HAL_UART_AbortReceive_IT()

HAL_StatusTypeDef HAL_UART_AbortReceive_IT ( UART_HandleTypeDef * huart )

#include <stm32f4xx_hal_uart.h>

Abort ongoing Receive transfer (Interrupt mode).

Parameters

huart UART handle.

Note

This procedure could be used for aborting any ongoing Rx transfer started in Interrupt or DMA mode. This procedure performs following operations :

Disable UART Interrupts (Rx)
Disable the DMA transfer in the peripheral register (if enabled)
Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
Set handle State to READY
At abort completion, call user abort complete callback

This procedure is executed in Interrupt mode, meaning that abort procedure could be considered as completed only when user abort complete callback is executed (not when exiting function).

Return values

HAL status

Definition at line 2272 of file stm32f4xx_hal_uart.c.

__weak void HAL_UARTEx_RxEventCallback	(	UART_HandleTypeDef *	huart,
		uint16_t	Size )

#include <stm32f4xx_hal_uart.h>

Reception Event Callback (Rx event notification called after use of advanced reception service).

Parameters

huart	UART handle
Size	Number of data available in application reception buffer (indicates a position in reception buffer until which, data are available)

Return values

None

Definition at line 2713 of file stm32f4xx_hal_uart.c.

References UNUSED.

Referenced by HAL_UART_IRQHandler(), UART_DMAReceiveCplt(), UART_DMARxHalfCplt(), and UART_Receive_IT().

Functions

Detailed Description

Function Documentation

◆ HAL_UART_Transmit()

◆ HAL_UART_Receive()

◆ HAL_UART_Transmit_IT()

◆ HAL_UART_Receive_IT()

◆ HAL_UART_Transmit_DMA()

◆ HAL_UART_Receive_DMA()

◆ HAL_UART_DMAPause()

◆ HAL_UART_DMAResume()

◆ HAL_UART_DMAStop()

◆ HAL_UARTEx_ReceiveToIdle()

◆ HAL_UARTEx_ReceiveToIdle_IT()

◆ HAL_UARTEx_ReceiveToIdle_DMA()

◆ HAL_UARTEx_GetRxEventType()

◆ HAL_UART_Abort()

◆ HAL_UART_AbortTransmit()

◆ HAL_UART_AbortReceive()

◆ HAL_UART_Abort_IT()

◆ HAL_UART_AbortTransmit_IT()

◆ HAL_UART_AbortReceive_IT()

◆ HAL_UART_IRQHandler()

◆ HAL_UART_TxCpltCallback()

◆ HAL_UART_TxHalfCpltCallback()

◆ HAL_UART_RxCpltCallback()

◆ HAL_UART_RxHalfCpltCallback()

◆ HAL_UART_ErrorCallback()

◆ HAL_UART_AbortCpltCallback()

◆ HAL_UART_AbortTransmitCpltCallback()

◆ HAL_UART_AbortReceiveCpltCallback()

◆ HAL_UARTEx_RxEventCallback()