USART - Synchronous/Asynchronous Serial#

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:

#if !defined(_SILICON_LABS_32B_SERIES_2)
/* USART is a HFPERCLK peripheral. Enable HFPERCLK domain and USART0.
 * We also need to enable the clock for GPIO to configure pins. */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_USART0, true);
CMU_ClockEnable(cmuClock_GPIO, true);
#endif

To initialize the USART for asynchronous operation (e.g., UART):

/* Initialize with default settings and then update fields according to application requirements. */
USART_InitAsync_TypeDef initAsync = USART_INITASYNC_DEFAULT;
initAsync.baudrate = 38400;
USART_InitAsync(USART0, &initAsync);

To initialize the USART for synchronous operation (e.g., SPI):

/* Initialize with default settings and then update fields according to application requirements. */
USART_InitSync_TypeDef initSync = USART_INITSYNC_DEFAULT;
/* Operate as SPI master */
initSync.master = true;
/* Clock idle low, sample on falling edge. */
initSync.clockMode = usartClockMode1;
USART_InitSync(USART0, &initSync);

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.

/* Enable I/O and set location */
USART0->ROUTE = USART_ROUTE_RXPEN | USART_ROUTE_TXPEN | USER_LOCATION;

/* Also enable CS and CLK pins if the USART is configured for synchronous mode.
 * Set GPIO mode. */
if (USART0->CTRL & USART_CTRL_SYNC) {
  USART0->ROUTE |= USART_ROUTE_CSPEN | USART_ROUTE_CLKPEN;

  GPIO_PinModeSet((GPIO_Port_TypeDef)AF_USART0_TX_PORT(USER_LOCATION), AF_USART0_TX_PIN(USER_LOCATION), gpioModePushPull, 0);
  GPIO_PinModeSet((GPIO_Port_TypeDef)AF_USART0_RX_PORT(USER_LOCATION), AF_USART0_RX_PIN(USER_LOCATION), gpioModeInput, 0);
  GPIO_PinModeSet((GPIO_Port_TypeDef)AF_USART0_CS_PORT(USER_LOCATION), AF_USART0_CS_PIN(USER_LOCATION), gpioModePushPull, 0);
  GPIO_PinModeSet((GPIO_Port_TypeDef)AF_USART0_CLK_PORT(USER_LOCATION), AF_USART0_CLK_PIN(USER_LOCATION), gpioModePushPull, 0);
} else {
  /* To avoid false start, configure TX pin as initial high */
  GPIO_PinModeSet((GPIO_Port_TypeDef)AF_USART0_TX_PORT(USER_LOCATION), AF_USART0_TX_PIN(USER_LOCATION), gpioModePushPull, 1);
  GPIO_PinModeSet((GPIO_Port_TypeDef)AF_USART0_RX_PORT(USER_LOCATION), AF_USART0_RX_PIN(USER_LOCATION), gpioModeInput, 0);
  /* Don't enable CTS/RTS hardware flow control pins in this example. */
}

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.

Modules#

USART_InitAsync_TypeDef

USART_PrsTriggerInit_TypeDef

USART_InitSync_TypeDef

USART_InitIrDA_TypeDef

USART_InitI2s_TypeDef

Enumerations#

enum
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
usartDisable = 0x0
usartEnableRx = USART_CMD_RXEN
usartEnableTx = USART_CMD_TXEN
usartEnable = (USART_CMD_RXEN | USART_CMD_TXEN)
}

Enable selection.

enum
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
usartNoParity = USART_FRAME_PARITY_NONE
usartEvenParity = USART_FRAME_PARITY_EVEN
usartOddParity = USART_FRAME_PARITY_ODD
}

Parity selection, mainly used for asynchronous operation.

enum
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
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
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
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
usartI2sJustifyLeft = USART_I2SCTRL_JUSTIFY_LEFT
usartI2sJustifyRight = USART_I2SCTRL_JUSTIFY_RIGHT
}

I2S frame data justify.

Typedefs#

typedef uint8_t

PRS Channel type.

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_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_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.

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.

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.

Macros#

#define

Default configuration for USART asynchronous initialization structure.

#define

Default configuration for USART PRS triggering structure.

#define

Default configuration for USART sync initialization structure.

#define

Default configuration for IrDA mode initialization structure.

#define

Default configuration for I2S mode initialization structure.

Enumeration Documentation#

USART_Databits_TypeDef#

USART_Databits_TypeDef

Databit selection.

Enumerator
usartDatabits4

4 data bits (not available for UART).

usartDatabits5

5 data bits (not available for UART).

usartDatabits6

6 data bits (not available for UART).

usartDatabits7

7 data bits (not available for UART).

usartDatabits8

8 data bits.

usartDatabits9

9 data bits.

usartDatabits10

10 data bits (not available for UART).

usartDatabits11

11 data bits (not available for UART).

usartDatabits12

12 data bits (not available for UART).

usartDatabits13

13 data bits (not available for UART).

usartDatabits14

14 data bits (not available for UART).

usartDatabits15

15 data bits (not available for UART).

usartDatabits16

16 data bits (not available for UART).


Definition at line 97 of file platform/emlib/inc/em_usart.h

USART_Enable_TypeDef#

USART_Enable_TypeDef

Enable selection.

Enumerator
usartDisable

Disable both receiver and transmitter.

usartEnableRx

Enable receiver only, transmitter disabled.

usartEnableTx

Enable transmitter only, receiver disabled.

usartEnable

Enable both receiver and transmitter.


Definition at line 114 of file platform/emlib/inc/em_usart.h

USART_OVS_TypeDef#

USART_OVS_TypeDef

Oversampling selection, used for asynchronous operation.

Enumerator
usartOVS16

16x oversampling (normal).

usartOVS8

8x oversampling.

usartOVS6

6x oversampling.

usartOVS4

4x oversampling.


Definition at line 129 of file platform/emlib/inc/em_usart.h

USART_Parity_TypeDef#

USART_Parity_TypeDef

Parity selection, mainly used for asynchronous operation.

Enumerator
usartNoParity

No parity.

usartEvenParity

Even parity.

usartOddParity

Odd parity.


Definition at line 137 of file platform/emlib/inc/em_usart.h

USART_Stopbits_TypeDef#

USART_Stopbits_TypeDef

Stop bits selection, used for asynchronous operation.

Enumerator
usartStopbits0p5

0.5 stop bits.

usartStopbits1

1 stop bits.

usartStopbits1p5

1.5 stop bits.

usartStopbits2

2 stop bits.


Definition at line 144 of file platform/emlib/inc/em_usart.h

USART_ClockMode_TypeDef#

USART_ClockMode_TypeDef

Clock polarity/phase mode.

Enumerator
usartClockMode0

Clock idle low, sample on rising edge.

usartClockMode1

Clock idle low, sample on falling edge.

usartClockMode2

Clock idle high, sample on falling edge.

usartClockMode3

Clock idle high, sample on rising edge.


Definition at line 179 of file platform/emlib/inc/em_usart.h

USART_IrDAPw_Typedef#

USART_IrDAPw_Typedef

Pulse width selection for IrDA mode.

Enumerator
usartIrDAPwONE

IrDA pulse width is 1/16 for OVS=0 and 1/8 for OVS=1.

usartIrDAPwTWO

IrDA pulse width is 2/16 for OVS=0 and 2/8 for OVS=1.

usartIrDAPwTHREE

IrDA pulse width is 3/16 for OVS=0 and 3/8 for OVS=1.

usartIrDAPwFOUR

IrDA pulse width is 4/16 for OVS=0 and 4/8 for OVS=1.


Definition at line 194 of file platform/emlib/inc/em_usart.h

USART_I2sFormat_TypeDef#

USART_I2sFormat_TypeDef

I2S format selection.

Enumerator
usartI2sFormatW32D32

32-bit word, 32-bit data.

usartI2sFormatW32D24M

32-bit word, 32-bit data with 8 lsb masked.

usartI2sFormatW32D24

32-bit word, 24-bit data.

usartI2sFormatW32D16

32-bit word, 16-bit data.

usartI2sFormatW32D8

32-bit word, 8-bit data.

usartI2sFormatW16D16

16-bit word, 16-bit data.

usartI2sFormatW16D8

16-bit word, 8-bit data.

usartI2sFormatW8D8

8-bit word, 8-bit data.


Definition at line 265 of file platform/emlib/inc/em_usart.h

USART_I2sJustify_TypeDef#

USART_I2sJustify_TypeDef

I2S frame data justify.

Enumerator
usartI2sJustifyLeft

Data is left-justified within the frame.

usartI2sJustifyRight

Data is right-justified within the frame.


Definition at line 277 of file platform/emlib/inc/em_usart.h

Typedef Documentation#

USART_PRS_Channel_t#

typedef uint8_t USART_PRS_Channel_t

PRS Channel type.


Definition at line 209 of file platform/emlib/inc/em_usart.h

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.


Definition at line 313 of file platform/emlib/src/em_usart.c

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).

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.

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.

Returns

  • Baudrate with given settings.


Definition at line 455 of file platform/emlib/src/em_usart.c

USART_BaudrateGet#

uint32_t USART_BaudrateGet (USART_TypeDef * usart)

Get the current baudrate for USART/UART.

Parameters
[in]usart

A pointer to the USART/UART peripheral register block.

This function returns the actual baudrate (not considering oscillator inaccuracies) used by a USART/UART peripheral.

Returns

  • The current baudrate.


Definition at line 586 of file platform/emlib/src/em_usart.c

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).

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.

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():

Warnings

  • The consequence of the aforementioned suppression of the fractional part of the clock divider is that some frequencies won't be achievable. The divider will only be able to be an integer value so the reference clock will only be dividable by N (where N is a positive integer).


Definition at line 649 of file platform/emlib/src/em_usart.c

USART_Enable#

void USART_Enable (USART_TypeDef * usart, USART_Enable_TypeDef enable)

Enable/disable USART/UART receiver and/or transmitter.

Parameters
[in]usart

A pointer to the USART/UART peripheral register block.

[in]enable

Select the status for the receiver/transmitter.

Notice that this function does not do any configuration. Enabling should normally be done after initialization (if not enabled as part of initialization).


Definition at line 711 of file platform/emlib/src/em_usart.c

USART_InitAsync#

void USART_InitAsync (USART_TypeDef * usart, const USART_InitAsync_TypeDef * init)

Initialize USART/UART for normal asynchronous mode.

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.

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.)


Definition at line 762 of file platform/emlib/src/em_usart.c

USART_InitSync#

void USART_InitSync (USART_TypeDef * usart, const USART_InitSync_TypeDef * init)

Initialize USART for synchronous mode.

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.

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.)


Definition at line 870 of file platform/emlib/src/em_usart.c

USARTn_InitIrDA#

void USARTn_InitIrDA (USART_TypeDef * usart, const USART_InitIrDA_TypeDef * init)

Initialize USART for asynchronous IrDA mode.

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.

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.)

Note

  • Not all USART instances support IrDA. See the data sheet for your device.


Definition at line 954 of file platform/emlib/src/em_usart.c

USART_InitI2s#

void USART_InitI2s (USART_TypeDef * usart, USART_InitI2s_TypeDef * init)

Initialize USART for I2S mode.

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.

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.)

Note

  • This function does not apply to all USART's. See the chip Reference Manual.


Definition at line 1013 of file platform/emlib/src/em_usart.c

USART_InitPrsTrigger#

void USART_InitPrsTrigger (USART_TypeDef * usart, const USART_PrsTriggerInit_TypeDef * init)

Initialize the automatic transmissions using PRS channel as a trigger.

Parameters
[in]usart

A pointer to USART to configure.

[in]init

A pointer to the initialization structure.

Note

  • Initialize USART with USART_Init() before setting up the PRS configuration.


Definition at line 1053 of file platform/emlib/src/em_usart.c

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.


Definition at line 1087 of file platform/emlib/src/em_usart.c

USART_Rx#

uint8_t USART_Rx (USART_TypeDef * usart)

Receive one 4-8 bit frame, (or part of 10-16 bit frame).

Parameters
[in]usart

A pointer to the USART/UART peripheral register block.

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.

Returns

  • Data received.


Definition at line 1182 of file platform/emlib/src/em_usart.c

USART_RxDouble#

uint16_t USART_RxDouble (USART_TypeDef * usart)

Receive two 4-8 bit frames or one 10-16 bit frame.

Parameters
[in]usart

A pointer to the USART/UART peripheral register block.

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.

Returns

  • Data received.


Definition at line 1214 of file platform/emlib/src/em_usart.c

USART_RxDoubleExt#

uint32_t USART_RxDoubleExt (USART_TypeDef * usart)

Receive two 4-9 bit frames, or one 10-16 bit frame with extended information.

Parameters
[in]usart

A pointer to the USART/UART peripheral register block.

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.

Returns

  • Data received.


Definition at line 1246 of file platform/emlib/src/em_usart.c

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.

Parameters
[in]usart

A pointer to the USART/UART peripheral register block.

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.

Returns

  • Data received.


Definition at line 1278 of file platform/emlib/src/em_usart.c

USART_SpiTransfer#

uint8_t USART_SpiTransfer (USART_TypeDef * usart, uint8_t data)

Perform one 8 bit frame SPI transfer.

Parameters
[in]usart

A pointer to the USART peripheral register block.

[in]data

Data to transmit.

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.

Returns

  • Data received.


Definition at line 1305 of file platform/emlib/src/em_usart.c

USART_Tx#

void USART_Tx (USART_TypeDef * usart, uint8_t data)

Transmit one 4-9 bit frame.

Parameters
[in]usart

A pointer to the USART/UART peripheral register block.

[in]data

Data to transmit. See details above for more information.

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.


Definition at line 1338 of file platform/emlib/src/em_usart.c

USART_TxDouble#

void USART_TxDouble (USART_TypeDef * usart, uint16_t data)

Transmit two 4-9 bit frames or one 10-16 bit frame.

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.

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.


Definition at line 1373 of file platform/emlib/src/em_usart.c

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.

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.

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.

  • 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.


Definition at line 1408 of file platform/emlib/src/em_usart.c

USART_TxExt#

void USART_TxExt (USART_TypeDef * usart, uint16_t data)

Transmit one 4-9 bit frame with extended control.

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).

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.


Definition at line 1435 of file platform/emlib/src/em_usart.c

USART_IntClear#

void USART_IntClear (USART_TypeDef * usart, uint32_t flags)

Clear one or more pending USART interrupts.

Parameters
[in]usart

Pointer to the 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.


Definition at line 803 of file platform/emlib/inc/em_usart.h

USART_IntDisable#

void USART_IntDisable (USART_TypeDef * usart, uint32_t flags)

Disable one or more USART interrupts.

Parameters
[in]usart

Pointer to the 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.


Definition at line 823 of file platform/emlib/inc/em_usart.h

USART_IntEnable#

void USART_IntEnable (USART_TypeDef * usart, uint32_t flags)

Enable one or more USART interrupts.

Parameters
[in]usart

Pointer to the 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.

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.


Definition at line 844 of file platform/emlib/inc/em_usart.h

USART_IntGet#

uint32_t USART_IntGet (USART_TypeDef * usart)

Get pending USART interrupt flags.

Parameters
[in]usart

Pointer to the USART/UART peripheral register block.

Note

  • The event bits are not cleared by the use of this function.

Returns

  • USART/UART interrupt source(s) pending. Returns one or more valid interrupt flags for the USART module (USART_IF_nnn) OR'ed together.


Definition at line 863 of file platform/emlib/inc/em_usart.h

USART_IntGetEnabled#

uint32_t USART_IntGetEnabled (USART_TypeDef * usart)

Get enabled and pending USART interrupt flags.

Parameters
[in]usart

Pointer to the USART/UART peripheral register block.

Useful for handling more interrupt sources in the same interrupt handler.

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).


Definition at line 887 of file platform/emlib/inc/em_usart.h

USART_IntSet#

void USART_IntSet (USART_TypeDef * usart, uint32_t flags)

Set one or more pending USART interrupts from SW.

Parameters
[in]usart

Pointer to the 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.


Definition at line 910 of file platform/emlib/inc/em_usart.h

USART_StatusGet#

uint32_t USART_StatusGet (USART_TypeDef * usart)

Get USART STATUS register.

Parameters
[in]usart

Pointer to the USART/UART peripheral register block.

Returns

  • STATUS register value.


Definition at line 930 of file platform/emlib/inc/em_usart.h

USART_RxDataGet#

uint8_t USART_RxDataGet (USART_TypeDef * usart)

Receive one 4-8 bit frame, (or part of 10-16 bit frame).

Parameters
[in]usart

Pointer to USART/UART peripheral register block.

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

  • Because 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.

Returns

  • Data received.


Definition at line 969 of file platform/emlib/inc/em_usart.h

USART_RxDoubleGet#

uint16_t USART_RxDoubleGet (USART_TypeDef * usart)

Receive two 4-8 bit frames, or one 10-16 bit frame.

Parameters
[in]usart

Pointer to USART/UART peripheral register block.

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

  • Because 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.

Returns

  • Data received.


Definition at line 1006 of file platform/emlib/inc/em_usart.h

USART_RxDoubleXGet#

uint32_t USART_RxDoubleXGet (USART_TypeDef * usart)

Receive two 4-9 bit frames, or one 10-16 bit frame with extended information.

Parameters
[in]usart

Pointer to USART/UART peripheral register block.

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

  • Because 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.

Returns

  • Data received.


Definition at line 1041 of file platform/emlib/inc/em_usart.h

USART_RxDataXGet#

uint16_t USART_RxDataXGet (USART_TypeDef * usart)

Receive one 4-9 bit frame, (or part of 10-16 bit frame) with extended information.

Parameters
[in]usart

Pointer to USART/UART peripheral register block.

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

  • Because 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.

Returns

  • Data received.


Definition at line 1075 of file platform/emlib/inc/em_usart.h

Macro Definition Documentation#

USART_INITASYNC_DEFAULT#

#define USART_INITASYNC_DEFAULT
Value:
{ \
usartEnable, /* Enable RX/TX when initialization is complete. */ \
0, /* Use current configured reference clock for configuring baud rate. */ \
115200, /* 115200 bits/s. */ \
usartOVS16, /* 16x oversampling. */ \
usartDatabits8, /* 8 data bits. */ \
usartNoParity, /* No parity. */ \
usartStopbits1, /* 1 stop bit. */ \
false, /* Do not disable majority vote. */ \
false, /* Not USART PRS input mode. */ \
0, /* PRS channel 0. */ \
false, /* Auto CS functionality enable/disable switch. */ \
false, /* No CS invert. */ \
}

Default configuration for USART asynchronous initialization structure.


Definition at line 375 of file platform/emlib/inc/em_usart.h

USART_INITPRSTRIGGER_DEFAULT#

#define USART_INITPRSTRIGGER_DEFAULT
Value:
{ \
false, /* Do not enable autoTX triggering. */ \
false, /* Do not enable receive triggering. */ \
false, /* Do not enable transmit triggering. */ \
0 /* Set default channel to zero. */ \
}

Default configuration for USART PRS triggering structure.


Definition at line 414 of file platform/emlib/inc/em_usart.h

USART_INITSYNC_DEFAULT#

#define USART_INITSYNC_DEFAULT
Value:
{ \
usartEnable, /* Enable RX/TX when initialization is complete. */ \
0, /* Use current configured reference clock for configuring baud rate. */ \
1000000, /* 1 Mbits/s. */ \
usartDatabits8, /* 8 data bits. */ \
true, /* Master mode. */ \
false, /* Send least significant bit first. */ \
usartClockMode0, /* Clock idle low, sample on rising edge. */ \
false, /* Not USART PRS input mode. */ \
0, /* PRS channel 0. */ \
false, /* No AUTOTX mode. */ \
false, /* No AUTOCS mode. */ \
false, /* No CS invert. */ \
}

Default configuration for USART sync initialization structure.


Definition at line 503 of file platform/emlib/inc/em_usart.h

USART_INITIRDA_DEFAULT#

#define USART_INITIRDA_DEFAULT
Value:
{ \
{ \
usartEnable, /* Enable RX/TX when initialization is complete. */ \
0, /* Use current configured reference clock for configuring baud rate. */ \
115200, /* 115200 bits/s. */ \
usartOVS16, /* 16x oversampling. */ \
usartDatabits8, /* 8 data bits. */ \
usartEvenParity, /* Even parity. */ \
usartStopbits1, /* 1 stop bit. */ \
false, /* Do not disable majority vote. */ \
false, /* Not USART PRS input mode. */ \
0, /* PRS channel 0. */ \
false, /* Auto CS functionality enable/disable switch */ \
false, /* No CS invert. */ \
}, \
false, /* Rx invert disabled. */ \
false, /* Filtering disabled. */ \
usartIrDAPwTHREE, /* Pulse width is set to ONE. */ \
false, /* Routing to PRS is disabled. */ \
0 /* PRS channel 0. */ \
}

Default configuration for IrDA mode initialization structure.


Definition at line 589 of file platform/emlib/inc/em_usart.h

USART_INITI2S_DEFAULT#

#define USART_INITI2S_DEFAULT
Value:
{ \
{ \
usartEnable, /* Enable RX/TX when initialization is complete. */ \
0, /* Use current configured reference clock for configuring baud rate. */ \
1000000, /* 1 Mbits/s. */ \
usartDatabits16, /* 16 databits. */ \
true, /* Master mode. */ \
true, /* Most significant bit first. */ \
usartClockMode0, /* Clock idle low, sample on rising edge. */ \
false, /* Not USART PRS input mode. */ \
0, /* PRS channel 0. */ \
false, /* No AUTOTX mode. */ \
false, /* No AUTOCS mode */ \
false, /* No CS invert. */ \
}, \
usartI2sFormatW16D16, /* 16-bit word, 16-bit data */ \
true, /* Delay on I2S data. */ \
false, /* No DMA split. */ \
usartI2sJustifyLeft,/* Data is left-justified within the frame */ \
false /* Stereo mode. */ \
}

Default configuration for I2S mode initialization structure.


Definition at line 714 of file platform/emlib/inc/em_usart.h