USART - Synchronous/Asynchronous Serial
Description
Universal Synchronous/Asynchronous Receiver/Transmitter Peripheral API.
The Universal Synchronous/Asynchronous Receiver/Transmitter (USART) is a very flexible serial I/O module. It supports full duplex asynchronous UART communication as well as RS-485, SPI, MicroWire, and 3-wire. It can also interface with ISO7816 Smart-Cards, and IrDA devices.
The USART has a wide selection of operating modes, frame formats, and baud rates. All features are supported through the API of this module.
Triple buffering and DMA support makes high data-rates possible with minimal CPU intervention. It is possible to transmit and receive large frames while the MCU remains in EM1 Sleep.
This module does not support DMA configuration. The UARTDRV and SPIDRV drivers provide full support for DMA and more.
The following steps are necessary for basic operation:
Clock enable:
To initialize the USART for asynchronous operation (e.g., UART):
To initialize the USART for synchronous operation (e.g., SPI):
After pins are assigned for the application/board, enable pins at the desired location. Available locations can be obtained from the Pin Definitions section in the data sheet.
- Note
- UART hardware flow control is not directly supported in hardware on _SILICON_LABS_32B_SERIES_0 parts.
- UARTDRV supports all types of UART flow control. Software assisted hardware flow control is available for parts without true UART hardware flow control.
Data Structures |
|
struct | USART_InitAsync_TypeDef |
Asynchronous mode initialization structure.
|
|
struct | USART_PrsTriggerInit_TypeDef |
USART PRS trigger enable.
|
|
struct | USART_InitSync_TypeDef |
Synchronous mode initialization structure.
|
|
struct | USART_InitIrDA_TypeDef |
IrDA mode initialization structure.
|
|
struct | USART_InitI2s_TypeDef |
I2S mode initialization structure.
|
|
Functions |
|
void | USART_BaudrateAsyncSet (USART_TypeDef *usart, uint32_t refFreq, uint32_t baudrate, USART_OVS_TypeDef ovs) |
Configure USART/UART operating in asynchronous mode to use a given baudrate (or as close as possible to a specified baudrate).
|
|
uint32_t | USART_BaudrateCalc (uint32_t refFreq, uint32_t clkdiv, bool syncmode, USART_OVS_TypeDef ovs) |
Calculate baudrate for USART/UART given reference frequency, clock division, and oversampling rate (if async mode).
|
|
uint32_t | USART_BaudrateGet (USART_TypeDef *usart) |
Get the current baudrate for USART/UART.
|
|
void | USART_BaudrateSyncSet (USART_TypeDef *usart, uint32_t refFreq, uint32_t baudrate) |
Configure the USART operating in synchronous mode to use a given baudrate (or as close as possible to a specified baudrate).
|
|
void | USART_Enable (USART_TypeDef *usart, USART_Enable_TypeDef enable) |
Enable/disable USART/UART receiver and/or transmitter.
|
|
void | USART_InitAsync (USART_TypeDef *usart, const USART_InitAsync_TypeDef *init) |
Initialize USART/UART for normal asynchronous mode.
|
|
void | USART_InitSync (USART_TypeDef *usart, const USART_InitSync_TypeDef *init) |
Initialize USART for synchronous mode.
|
|
void | USARTn_InitIrDA (USART_TypeDef *usart, const USART_InitIrDA_TypeDef *init) |
Initialize USART for asynchronous IrDA mode.
|
|
void | USART_InitI2s (USART_TypeDef *usart, USART_InitI2s_TypeDef *init) |
Initialize USART for I2S mode.
|
|
void | USART_InitPrsTrigger (USART_TypeDef *usart, const USART_PrsTriggerInit_TypeDef *init) |
Initialize the automatic transmissions using PRS channel as a trigger.
|
|
void | USART_IntClear (USART_TypeDef *usart, uint32_t flags) |
Clear one or more pending USART interrupts.
|
|
void | USART_IntDisable (USART_TypeDef *usart, uint32_t flags) |
Disable one or more USART interrupts.
|
|
void | USART_IntEnable (USART_TypeDef *usart, uint32_t flags) |
Enable one or more USART interrupts.
|
|
uint32_t | USART_IntGet (USART_TypeDef *usart) |
Get pending USART interrupt flags.
|
|
uint32_t | USART_IntGetEnabled (USART_TypeDef *usart) |
Get enabled and pending USART interrupt flags.
|
|
void | USART_IntSet (USART_TypeDef *usart, uint32_t flags) |
Set one or more pending USART interrupts from SW.
|
|
uint32_t | USART_StatusGet (USART_TypeDef *usart) |
Get USART STATUS register.
|
|
void | USART_Reset (USART_TypeDef *usart) |
Reset USART/UART to the same state that it was in after a hardware reset.
|
|
uint8_t | USART_Rx (USART_TypeDef *usart) |
Receive one 4-8 bit frame, (or part of 10-16 bit frame).
|
|
uint16_t | USART_RxDouble (USART_TypeDef *usart) |
Receive two 4-8 bit frames or one 10-16 bit frame.
|
|
uint32_t | USART_RxDoubleExt (USART_TypeDef *usart) |
Receive two 4-9 bit frames, or one 10-16 bit frame with extended information.
|
|
uint16_t | USART_RxExt (USART_TypeDef *usart) |
Receive one 4-9 bit frame (or part of 10-16 bit frame) with extended information.
|
|
uint8_t | USART_RxDataGet (USART_TypeDef *usart) |
Receive one 4-8 bit frame, (or part of 10-16 bit frame).
|
|
uint16_t | USART_RxDoubleGet (USART_TypeDef *usart) |
Receive two 4-8 bit frames, or one 10-16 bit frame.
|
|
uint32_t | USART_RxDoubleXGet (USART_TypeDef *usart) |
Receive two 4-9 bit frames, or one 10-16 bit frame with extended information.
|
|
uint16_t | USART_RxDataXGet (USART_TypeDef *usart) |
Receive one 4-9 bit frame, (or part of 10-16 bit frame) with extended information.
|
|
uint8_t | USART_SpiTransfer (USART_TypeDef *usart, uint8_t data) |
Perform one 8 bit frame SPI transfer.
|
|
void | USART_Tx (USART_TypeDef *usart, uint8_t data) |
Transmit one 4-9 bit frame.
|
|
void | USART_TxDouble (USART_TypeDef *usart, uint16_t data) |
Transmit two 4-9 bit frames or one 10-16 bit frame.
|
|
void | USART_TxDoubleExt (USART_TypeDef *usart, uint32_t data) |
Transmit two 4-9 bit frames or one 10-16 bit frame with extended control.
|
|
void | USART_TxExt (USART_TypeDef *usart, uint16_t data) |
Transmit one 4-9 bit frame with extended control.
|
|
Macros |
|
#define | USART_INITASYNC_DEFAULT |
Default configuration for USART asynchronous initialization structure.
|
|
#define | USART_INITPRSTRIGGER_DEFAULT |
Default configuration for USART PRS triggering structure.
|
|
#define | USART_INITSYNC_DEFAULT |
Default configuration for USART sync initialization structure.
|
|
#define | USART_INITIRDA_DEFAULT |
Default configuration for IrDA mode initialization structure.
|
|
#define | USART_INITI2S_DEFAULT |
Default configuration for I2S mode initialization structure.
|
|
Typedefs |
|
typedef uint8_t | USART_PRS_Channel_t |
PRS Channel type.
|
|
Enumerations |
|
enum |
USART_Databits_TypeDef
{
usartDatabits4 = USART_FRAME_DATABITS_FOUR, usartDatabits5 = USART_FRAME_DATABITS_FIVE, usartDatabits6 = USART_FRAME_DATABITS_SIX, usartDatabits7 = USART_FRAME_DATABITS_SEVEN, usartDatabits8 = USART_FRAME_DATABITS_EIGHT, usartDatabits9 = USART_FRAME_DATABITS_NINE, usartDatabits10 = USART_FRAME_DATABITS_TEN, usartDatabits11 = USART_FRAME_DATABITS_ELEVEN, usartDatabits12 = USART_FRAME_DATABITS_TWELVE, usartDatabits13 = USART_FRAME_DATABITS_THIRTEEN, usartDatabits14 = USART_FRAME_DATABITS_FOURTEEN, usartDatabits15 = USART_FRAME_DATABITS_FIFTEEN, usartDatabits16 = USART_FRAME_DATABITS_SIXTEEN } |
Databit selection.
|
|
enum |
USART_Enable_TypeDef
{
usartDisable = 0x0, usartEnableRx = USART_CMD_RXEN, usartEnableTx = USART_CMD_TXEN, usartEnable = (USART_CMD_RXEN | USART_CMD_TXEN) } |
Enable selection.
|
|
enum |
USART_OVS_TypeDef
{
usartOVS16 = USART_CTRL_OVS_X16, usartOVS8 = USART_CTRL_OVS_X8, usartOVS6 = USART_CTRL_OVS_X6, usartOVS4 = USART_CTRL_OVS_X4 } |
Oversampling selection, used for asynchronous operation.
|
|
enum |
USART_Parity_TypeDef
{
usartNoParity = USART_FRAME_PARITY_NONE, usartEvenParity = USART_FRAME_PARITY_EVEN, usartOddParity = USART_FRAME_PARITY_ODD } |
Parity selection, mainly used for asynchronous operation.
|
|
enum |
USART_Stopbits_TypeDef
{
usartStopbits0p5 = USART_FRAME_STOPBITS_HALF, usartStopbits1 = USART_FRAME_STOPBITS_ONE, usartStopbits1p5 = USART_FRAME_STOPBITS_ONEANDAHALF, usartStopbits2 = USART_FRAME_STOPBITS_TWO } |
Stop bits selection, used for asynchronous operation.
|
|
enum |
USART_ClockMode_TypeDef
{
usartClockMode0 = USART_CTRL_CLKPOL_IDLELOW | USART_CTRL_CLKPHA_SAMPLELEADING, usartClockMode1 = USART_CTRL_CLKPOL_IDLELOW | USART_CTRL_CLKPHA_SAMPLETRAILING, usartClockMode2 = USART_CTRL_CLKPOL_IDLEHIGH | USART_CTRL_CLKPHA_SAMPLELEADING, usartClockMode3 = USART_CTRL_CLKPOL_IDLEHIGH | USART_CTRL_CLKPHA_SAMPLETRAILING } |
Clock polarity/phase mode.
|
|
enum |
USART_IrDAPw_Typedef
{
usartIrDAPwONE = USART_IRCTRL_IRPW_ONE, usartIrDAPwTWO = USART_IRCTRL_IRPW_TWO, usartIrDAPwTHREE = USART_IRCTRL_IRPW_THREE, usartIrDAPwFOUR = USART_IRCTRL_IRPW_FOUR } |
Pulse width selection for IrDA mode.
|
|
enum |
USART_I2sFormat_TypeDef
{
usartI2sFormatW32D32 = USART_I2SCTRL_FORMAT_W32D32, usartI2sFormatW32D24M = USART_I2SCTRL_FORMAT_W32D24M, usartI2sFormatW32D24 = USART_I2SCTRL_FORMAT_W32D24, usartI2sFormatW32D16 = USART_I2SCTRL_FORMAT_W32D16, usartI2sFormatW32D8 = USART_I2SCTRL_FORMAT_W32D8, usartI2sFormatW16D16 = USART_I2SCTRL_FORMAT_W16D16, usartI2sFormatW16D8 = USART_I2SCTRL_FORMAT_W16D8, usartI2sFormatW8D8 = USART_I2SCTRL_FORMAT_W8D8 } |
I2S format selection.
|
|
enum |
USART_I2sJustify_TypeDef
{
usartI2sJustifyLeft = USART_I2SCTRL_JUSTIFY_LEFT, usartI2sJustifyRight = USART_I2SCTRL_JUSTIFY_RIGHT } |
I2S frame data justify.
|
|
Function Documentation
◆ USART_BaudrateAsyncSet()
void USART_BaudrateAsyncSet | ( | USART_TypeDef * |
usart,
|
uint32_t |
refFreq,
|
||
uint32_t |
baudrate,
|
||
USART_OVS_TypeDef |
ovs
|
||
) |
Configure USART/UART operating in asynchronous mode to use a given baudrate (or as close as possible to a specified baudrate).
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block. [in] refFreq
USART/UART reference clock frequency in Hz. If set to 0, the currently configured reference clock is assumed. [in] baudrate
Baudrate to try to achieve for USART/UART. [in] ovs
Oversampling to be used. Normal is 16x oversampling but lower oversampling may be used to achieve higher rates or better baudrate accuracy in some cases. Notice that lower oversampling frequency makes the channel more vulnerable to bit faults during reception due to clock inaccuracies compared to the link partner.
◆ USART_BaudrateCalc()
uint32_t USART_BaudrateCalc | ( | uint32_t |
refFreq,
|
uint32_t |
clkdiv,
|
||
bool |
syncmode,
|
||
USART_OVS_TypeDef |
ovs
|
||
) |
Calculate baudrate for USART/UART given reference frequency, clock division, and oversampling rate (if async mode).
This function returns the baudrate that a USART/UART module will use if configured with the given frequency, clock divisor, and mode. Notice that this function will not use the hardware configuration. It can be used to determine if a given configuration is sufficiently accurate for the application.
- Parameters
-
[in] refFreq
USART/UART HF peripheral frequency used. [in] clkdiv
A clock division factor to be used. [in] syncmode
- True - synchronous mode operation.
- False - asynchronous mode operation.
[in] ovs
Oversampling used if in asynchronous mode. Not used if syncmode
is true.
- Returns
- Baudrate with given settings.
◆ USART_BaudrateGet()
uint32_t USART_BaudrateGet | ( | USART_TypeDef * |
usart
|
) |
Get the current baudrate for USART/UART.
This function returns the actual baudrate (not considering oscillator inaccuracies) used by a USART/UART peripheral.
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block.
- Returns
- The current baudrate.
◆ USART_BaudrateSyncSet()
void USART_BaudrateSyncSet | ( | USART_TypeDef * |
usart,
|
uint32_t |
refFreq,
|
||
uint32_t |
baudrate
|
||
) |
Configure the USART operating in synchronous mode to use a given baudrate (or as close as possible to a specified baudrate).
The configuration will be set to use a baudrate <= the specified baudrate to ensure that the baudrate does not exceed the specified value.
The fractional clock division is suppressed, although the hardware design allows it. It could cause half clock cycles to exceed a specified limit and thus potentially violate specifications for the slave device. In some special situations, a fractional clock division may be useful even in synchronous mode, but in those cases it must be directly adjusted, possibly assisted by USART_BaudrateCalc() :
- Parameters
-
[in] usart
A pointer to the USART peripheral register block. (Cannot be used on UART modules.) [in] refFreq
A USART reference clock frequency in Hz that will be used. If set to 0, the currently-configured reference clock is assumed. [in] baudrate
Baudrate to try to achieve for USART.
◆ USART_Enable()
void USART_Enable | ( | USART_TypeDef * |
usart,
|
USART_Enable_TypeDef |
enable
|
||
) |
Enable/disable USART/UART receiver and/or transmitter.
Notice that this function does not do any configuration. Enabling should normally be done after initialization (if not enabled as part of initialization).
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block. [in] enable
Select the status for the receiver/transmitter.
◆ USART_InitAsync()
void USART_InitAsync | ( | USART_TypeDef * |
usart,
|
const USART_InitAsync_TypeDef * |
init
|
||
) |
Initialize USART/UART for normal asynchronous mode.
This function will configure basic settings to operate in normal asynchronous mode.
A special control setup not covered by this function must be done after using this function by direct modification of the CTRL register.
Notice that pins used by the USART/UART module must be properly configured by the user explicitly for the USART/UART to work as intended. (When configuring pins, remember to consider the sequence of configuration to avoid unintended pulses/glitches on output pins.)
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block. [in] init
A pointer to the initialization structure used to configure the basic async setup.
◆ USART_InitSync()
void USART_InitSync | ( | USART_TypeDef * |
usart,
|
const USART_InitSync_TypeDef * |
init
|
||
) |
Initialize USART for synchronous mode.
This function will configure basic settings to operate in synchronous mode.
A special control setup not covered by this function must be done after using this function by direct modification of the CTRL register.
Notice that pins used by the USART module must be properly configured by the user explicitly for the USART to work as intended. (When configuring pins remember to consider the sequence of configuration to avoid unintended pulses/glitches on output pins.)
- Parameters
-
[in] usart
A pointer to the USART peripheral register block. (UART does not support this mode.) [in] init
A pointer to the initialization structure used to configure basic async setup.
◆ USARTn_InitIrDA()
void USARTn_InitIrDA | ( | USART_TypeDef * |
usart,
|
const USART_InitIrDA_TypeDef * |
init
|
||
) |
Initialize USART for asynchronous IrDA mode.
This function will configure basic settings to operate in asynchronous IrDA mode.
A special control setup not covered by this function must be done after using this function by direct modification of the CTRL and IRCTRL registers.
Notice that pins used by the USART/UART module must be properly configured by the user explicitly for the USART/UART to work as intended. (When configuring pins, remember to consider the sequence of configuration to avoid unintended pulses/glitches on output pins.)
- Parameters
-
[in] usart
A pointer to the USART peripheral register block. [in] init
A pointer to the initialization structure used to configure async IrDA setup.
- Note
- Not all USART instances support IrDA. See the data sheet for your device.
◆ USART_InitI2s()
void USART_InitI2s | ( | USART_TypeDef * |
usart,
|
USART_InitI2s_TypeDef * |
init
|
||
) |
Initialize USART for I2S mode.
This function will configure basic settings to operate in I2S mode.
A special control setup not covered by this function must be done after using this function by direct modification of the CTRL and I2SCTRL registers.
Notice that pins used by the USART module must be properly configured by the user explicitly for the USART to work as intended. (When configuring pins, remember to consider the sequence of configuration to avoid unintended pulses/glitches on output pins.)
- Parameters
-
[in] usart
A pointer to the USART peripheral register block. (UART does not support this mode.) [in] init
A pointer to the initialization structure used to configure the basic I2S setup.
- Note
- This function does not apply to all USART's. See the chip Reference Manual.
◆ USART_InitPrsTrigger()
void USART_InitPrsTrigger | ( | USART_TypeDef * |
usart,
|
const USART_PrsTriggerInit_TypeDef * |
init
|
||
) |
Initialize the automatic transmissions using PRS channel as a trigger.
- Note
- Initialize USART with USART_Init() before setting up the PRS configuration.
- Parameters
-
[in] usart
A pointer to USART to configure. [in] init
A pointer to the initialization structure.
◆ USART_IntClear()
|
inline |
Clear one or more pending USART interrupts.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block. [in] flags
Pending USART/UART interrupt source(s) to clear. Use one or more valid interrupt flags for the USART module (USART_IF_nnn) OR'ed together.
◆ USART_IntDisable()
|
inline |
Disable one or more USART interrupts.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block. [in] flags
USART/UART interrupt source(s) to disable. Use one or more valid interrupt flags for the USART module (USART_IF_nnn) OR'ed together.
◆ USART_IntEnable()
|
inline |
Enable one or more USART interrupts.
- Note
- Depending on the use, a pending interrupt may already be set prior to enabling the interrupt. To ignore a pending interrupt, consider using USART_IntClear() prior to enabling the interrupt.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block. [in] flags
USART/UART interrupt source(s) to enable. Use one or more valid interrupt flags for the USART module (USART_IF_nnn) OR'ed together.
◆ USART_IntGet()
|
inline |
Get pending USART interrupt flags.
- Note
- The event bits are not cleared by the use of this function.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block.
- Returns
- USART/UART interrupt source(s) pending. Returns one or more valid interrupt flags for the USART module (USART_IF_nnn) OR'ed together.
◆ USART_IntGetEnabled()
|
inline |
Get enabled and pending USART interrupt flags.
Useful for handling more interrupt sources in the same interrupt handler.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block.
- Note
- Interrupt flags are not cleared by the use of this function.
- Returns
-
Pending and enabled USART interrupt sources. The return value is the bitwise AND combination of
- the OR combination of enabled interrupt sources in USARTx_IEN_nnn register (USARTx_IEN_nnn) and
- the OR combination of valid interrupt flags of the USART module (USARTx_IF_nnn).
◆ USART_IntSet()
|
inline |
Set one or more pending USART interrupts from SW.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block. [in] flags
USART/UART interrupt source(s) to set to pending. Use one or more valid interrupt flags for the USART module (USART_IF_nnn) OR'ed together.
◆ USART_StatusGet()
|
inline |
Get USART STATUS register.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block.
- Returns
- STATUS register value.
◆ USART_Reset()
void USART_Reset | ( | USART_TypeDef * |
usart
|
) |
Reset USART/UART to the same state that it was in after a hardware reset.
- Parameters
-
[in] usart
A pointer to USART/UART peripheral register block.
◆ USART_Rx()
uint8_t USART_Rx | ( | USART_TypeDef * |
usart
|
) |
Receive one 4-8 bit frame, (or part of 10-16 bit frame).
This function is normally used to receive one frame when operating with frame length 4-8 bits. See USART_RxExt() for reception of 9 bit frames.
Notice that possible parity/stop bits in asynchronous mode are not considered part of a specified frame bit length.
- Note
- This function will stall if the buffer is empty until data is received. Alternatively, the user can explicitly check whether data is available. If data is available, call USART_RxDataGet() to read the RXDATA register directly.
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block.
- Returns
- Data received.
◆ USART_RxDouble()
uint16_t USART_RxDouble | ( | USART_TypeDef * |
usart
|
) |
Receive two 4-8 bit frames or one 10-16 bit frame.
This function is normally used to receive one frame when operating with frame length 10-16 bits. See USART_RxDoubleExt() for reception of two 9 bit frames.
Notice that possible parity/stop bits in asynchronous mode are not considered part of a specified frame bit length.
- Note
- This function will stall if the buffer is empty until data is received. Alternatively, the user can explicitly check whether data is available. If data is available, call USART_RxDoubleGet() to read the RXDOUBLE register directly.
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block.
- Returns
- Data received.
◆ USART_RxDoubleExt()
uint32_t USART_RxDoubleExt | ( | USART_TypeDef * |
usart
|
) |
Receive two 4-9 bit frames, or one 10-16 bit frame with extended information.
This function is normally used to receive one frame when operating with frame length 10-16 bits and additional RX status information is required.
Notice that possible parity/stop bits in asynchronous mode are not considered part of a specified frame bit length.
- Note
- This function will stall if buffer is empty until data is received. Alternatively, the user can explicitly check whether data is available. If data is available, call USART_RxDoubleXGet() to read the RXDOUBLEX register directly.
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block.
- Returns
- Data received.
◆ USART_RxExt()
uint16_t USART_RxExt | ( | USART_TypeDef * |
usart
|
) |
Receive one 4-9 bit frame (or part of 10-16 bit frame) with extended information.
This function is normally used to receive one frame when operating with frame length 4-9 bits and additional RX status information is required.
Notice that possible parity/stop bits in asynchronous mode are not considered part of a specified frame bit length.
- Note
- This function will stall if the buffer is empty until data is received. Alternatively, the user can explicitly check whether data is available. If data is available, call USART_RxDataXGet() to read the RXDATAX register directly.
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block.
- Returns
- Data received.
◆ USART_RxDataGet()
|
inline |
Receive one 4-8 bit frame, (or part of 10-16 bit frame).
This function is used to quickly receive one 4-8 bits frame by reading the RXDATA register directly, without checking the STATUS register for the RXDATAV flag. This can be useful from the RXDATAV interrupt handler, i.e., waiting is superfluous, in order to quickly read the received data. Please refer to USART_RxDataXGet() for reception of 9 bit frames.
- Note
- Since this function does not check whether the RXDATA register actually holds valid data, it should only be used in situations when it is certain that there is valid data, ensured by some external program routine, e.g., when handling an RXDATAV interrupt. The USART_Rx() is normally a better choice if the validity of the RXDATA register is not certain.
- Notice that possible parity/stop bits in asynchronous mode are not considered part of specified frame bit length.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block.
- Returns
- Data received.
◆ USART_RxDoubleGet()
|
inline |
Receive two 4-8 bit frames, or one 10-16 bit frame.
This function is used to quickly receive one 10-16 bits frame or two 4-8 bit frames by reading the RXDOUBLE register directly, without checking the STATUS register for the RXDATAV flag. This can be useful from the RXDATAV interrupt handler, i.e., waiting is superfluous, in order to quickly read the received data. This function is normally used to receive one frame when operating with frame length 10-16 bits. Please refer to USART_RxDoubleXGet() for reception of two 9 bit frames.
- Note
- Since this function does not check whether the RXDOUBLE register actually holds valid data, it should only be used in situations when it is certain that there is valid data, ensured by some external program routine, e.g., when handling an RXDATAV interrupt. The USART_RxDouble() is normally a better choice if the validity of the RXDOUBLE register is not certain.
- Notice that possible parity/stop bits in asynchronous mode are not considered part of specified frame bit length.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block.
- Returns
- Data received.
◆ USART_RxDoubleXGet()
|
inline |
Receive two 4-9 bit frames, or one 10-16 bit frame with extended information.
This function is used to quickly receive one 10-16 bits frame or two 4-9 bit frames by reading the RXDOUBLEX register directly, without checking the STATUS register for the RXDATAV flag. This can be useful from the RXDATAV interrupt handler, i.e., waiting is superfluous, in order to quickly read the received data.
- Note
- Since this function does not check whether the RXDOUBLEX register actually holds valid data, it should only be used in situations when it is certain that there is valid data, ensured by some external program routine, e.g., when handling an RXDATAV interrupt. The USART_RxDoubleExt() is normally a better choice if the validity of the RXDOUBLEX register is not certain.
- Notice that possible parity/stop bits in asynchronous mode are not considered part of specified frame bit length.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block.
- Returns
- Data received.
◆ USART_RxDataXGet()
|
inline |
Receive one 4-9 bit frame, (or part of 10-16 bit frame) with extended information.
This function is used to quickly receive one 4-9 bit frame, (or part of 10-16 bit frame) with extended information by reading the RXDATAX register directly, without checking the STATUS register for the RXDATAV flag. This can be useful from the RXDATAV interrupt handler, i.e., waiting is superfluous, in order to quickly read the received data.
- Note
- Since this function does not check whether the RXDATAX register actually holds valid data, it should only be used in situations when it is certain that there is valid data, ensured by some external program routine, e.g., when handling an RXDATAV interrupt. The USART_RxExt() is normally a better choice if the validity of the RXDATAX register is not certain.
- Notice that possible parity/stop bits in asynchronous mode are not considered part of specified frame bit length.
- Parameters
-
[in] usart
Pointer to USART/UART peripheral register block.
- Returns
- Data received.
◆ USART_SpiTransfer()
uint8_t USART_SpiTransfer | ( | USART_TypeDef * |
usart,
|
uint8_t |
data
|
||
) |
Perform one 8 bit frame SPI transfer.
- Note
- This function will stall if the transmit buffer is full. When a transmit buffer becomes available, data is written and the function will wait until data is fully transmitted. The SPI return value is then read out and returned.
- Parameters
-
[in] usart
A pointer to the USART peripheral register block. [in] data
Data to transmit.
- Returns
- Data received.
◆ USART_Tx()
void USART_Tx | ( | USART_TypeDef * |
usart,
|
uint8_t |
data
|
||
) |
Transmit one 4-9 bit frame.
Depending on the frame length configuration, 4-8 (least significant) bits from
data
are transmitted. If the frame length is 9, 8 bits are transmitted from
data
and one bit as specified by CTRL register, BIT8DV field. See
USART_TxExt()
for transmitting 9 bit frame with full control of all 9 bits.
Notice that possible parity/stop bits in asynchronous mode are not considered part of a specified frame bit length.
- Note
- This function will stall if the buffer is full until the buffer becomes available.
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block. [in] data
Data to transmit. See details above for more information.
◆ USART_TxDouble()
void USART_TxDouble | ( | USART_TypeDef * |
usart,
|
uint16_t |
data
|
||
) |
Transmit two 4-9 bit frames or one 10-16 bit frame.
Depending on the frame length configuration, 4-8 (least significant) bits from each byte in
data
are transmitted. If frame length is 9, 8 bits are transmitted from each byte in
data
adding one bit as specified by the CTRL register, BIT8DV field, to each byte. See
USART_TxDoubleExt()
for transmitting two 9 bit frames with full control of all 9 bits.
If the frame length is 10-16, 10-16 (least significant) bits from
data
are transmitted.
Notice that possible parity/stop bits in asynchronous mode are not considered part of a specified frame bit length.
- Note
- This function will stall if the buffer is full until the buffer becomes available.
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block. [in] data
Data to transmit, the least significant byte holds the frame transmitted first. See details above for more info.
◆ USART_TxDoubleExt()
void USART_TxDoubleExt | ( | USART_TypeDef * |
usart,
|
uint32_t |
data
|
||
) |
Transmit two 4-9 bit frames or one 10-16 bit frame with extended control.
Notice that possible parity/stop bits in asynchronous mode are not considered part of a specified frame bit length.
- Note
- This function will stall if the buffer is full until the buffer becomes available.
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block. [in] data
Data to transmit with extended control. Contains two 16 bit words concatenated. Least significant word holds the frame transmitted first. If the frame length is 4-9, two frames with 4-9 least significant bits from each 16 bit word are transmitted.
- If the frame length is 10-16 bits, 8 data bits are taken from the least significant 16 bit word and the remaining bits from the other 16 bit word.
- Additional control bits are available as documented in the reference manual (set to 0 if not used). For 10-16 bit frame length, these control bits are taken from the most significant 16 bit word.
◆ USART_TxExt()
void USART_TxExt | ( | USART_TypeDef * |
usart,
|
uint16_t |
data
|
||
) |
Transmit one 4-9 bit frame with extended control.
Notice that possible parity/stop bits in asynchronous mode are not considered part of a specified frame bit length.
- Note
- This function will stall if the buffer is full until the buffer becomes available.
- Parameters
-
[in] usart
A pointer to the USART/UART peripheral register block. [in] data
Data to transmit with extended control. Least significant bit contains frame bits. Additional control bits are available as documented in the reference manual (set to 0 if not used).
Macro Definition Documentation
◆ USART_INITASYNC_DEFAULT
#define USART_INITASYNC_DEFAULT |
Default configuration for USART asynchronous initialization structure.
◆ USART_INITPRSTRIGGER_DEFAULT
#define USART_INITPRSTRIGGER_DEFAULT |
Default configuration for USART PRS triggering structure.
◆ USART_INITSYNC_DEFAULT
#define USART_INITSYNC_DEFAULT |
Default configuration for USART sync initialization structure.
◆ USART_INITIRDA_DEFAULT
#define USART_INITIRDA_DEFAULT |
Default configuration for IrDA mode initialization structure.
◆ USART_INITI2S_DEFAULT
#define USART_INITI2S_DEFAULT |
Default configuration for I2S mode initialization structure.
Typedef Documentation
◆ USART_PRS_Channel_t
typedef uint8_t USART_PRS_Channel_t |
PRS Channel type.
Enumeration Type Documentation
◆ USART_Databits_TypeDef
Databit selection.
◆ USART_Enable_TypeDef
enum USART_Enable_TypeDef |
◆ USART_OVS_TypeDef
enum USART_OVS_TypeDef |
◆ USART_Parity_TypeDef
enum USART_Parity_TypeDef |
◆ USART_Stopbits_TypeDef
◆ USART_ClockMode_TypeDef
◆ USART_IrDAPw_Typedef
enum USART_IrDAPw_Typedef |
Pulse width selection for IrDA mode.
◆ USART_I2sFormat_TypeDef
I2S format selection.