Functions
static void	UARTParityModeSet (uint32_t ui32Base, uint32_t ui32Parity)
	Sets the type of parity. More...

static uint32_t	UARTParityModeGet (uint32_t ui32Base)
	Gets the type of parity currently being used. More...

static void	UARTFIFOLevelSet (uint32_t ui32Base, uint32_t ui32TxLevel, uint32_t ui32RxLevel)
	Sets the FIFO level at which interrupts are generated. More...

void	UARTFIFOLevelGet (uint32_t ui32Base, uint32_t pui32TxLevel, uint32_t pui32RxLevel)
	Gets the FIFO level at which interrupts are generated. More...

void	UARTConfigSetExpClk (uint32_t ui32Base, uint32_t ui32UARTClk, uint32_t ui32Baud, uint32_t ui32Config)
	Sets the configuration of a UART. More...

void	UARTConfigGetExpClk (uint32_t ui32Base, uint32_t ui32UARTClk, uint32_t pui32Baud, uint32_t pui32Config)
	Gets the current configuration of a UART. More...

static void	UARTEnable (uint32_t ui32Base)
	Enables transmitting and receiving. More...

void	UARTDisable (uint32_t ui32Base)
	Disables transmitting and receiving. More...

static void	UARTFIFOEnable (uint32_t ui32Base)
	Enables the transmit and receive FIFOs. More...

static void	UARTFIFODisable (uint32_t ui32Base)
	Disables the transmit and receive FIFOs. More...

static bool	UARTCharsAvail (uint32_t ui32Base)
	Determines if there are any characters in the receive FIFO. More...

static bool	UARTSpaceAvail (uint32_t ui32Base)
	Determines if there is any space in the transmit FIFO. More...

int32_t	UARTCharGetNonBlocking (uint32_t ui32Base)
	Receives a character from the specified port. More...

int32_t	UARTCharGet (uint32_t ui32Base)
	Waits for a character from the specified port. More...

bool	UARTCharPutNonBlocking (uint32_t ui32Base, uint8_t ui8Data)
	Sends a character to the specified port. More...

void	UARTCharPut (uint32_t ui32Base, uint8_t ui8Data)
	Waits to send a character from the specified port. More...

static bool	UARTBusy (uint32_t ui32Base)
	Determines whether the UART transmitter is busy or not. More...

static void	UARTBreakCtl (uint32_t ui32Base, bool bBreakState)
	Causes a BREAK to be sent. More...

void	UARTIntRegister (uint32_t ui32Base, void(*pfnHandler)(void))
	Registers an interrupt handler for a UART interrupt in the dynamic interrupt table. More...

void	UARTIntUnregister (uint32_t ui32Base)
	Unregisters an interrupt handler for a UART interrupt in the dynamic interrupt table. More...

static void	UARTIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags)
	Enables individual UART interrupt sources. More...

static void	UARTIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags)
	Disables individual UART interrupt sources. More...

static uint32_t	UARTIntStatus (uint32_t ui32Base, bool bMasked)
	Gets the current interrupt status. More...

static void	UARTIntClear (uint32_t ui32Base, uint32_t ui32IntFlags)
	Clears UART interrupt sources. More...

static void	UARTDMAEnable (uint32_t ui32Base, uint32_t ui32DMAFlags)
	Enable UART DMA operation. More...

static void	UARTDMADisable (uint32_t ui32Base, uint32_t ui32DMAFlags)
	Disable UART DMA operation. More...

static uint32_t	UARTRxErrorGet (uint32_t ui32Base)
	Gets current receiver errors. More...

static void	UARTRxErrorClear (uint32_t ui32Base)
	Clears all reported receiver errors. More...

static void	UARTHwFlowControlEnable (uint32_t ui32Base)
	Enables hardware flow control for both CTS and RTS. More...

static void	UARTHwFlowControlDisable (uint32_t ui32Base)
	Disables hardware flow control for both CTS and RTS. More...

Detailed Description

Use printf()

DriverLib only supports writing a single character at a time to the UART buffer but it is possible to utilize the library function printf by overriding a few of the functions used by printf with a device specific definition. However, the implementation of printf is compiler specific and requires different functions to be overridden depending on the compiler.

Using printf can increase code size significantly but some compilers provide a highly optimized and configurable implementation suitable for embedded systems which makes the code size increase acceptable for most applications. See the compiler's documentation for details about how to configure the printf library function.

It is required that the application configures and enables the UART module before using printf function.

Code Composer Studio

In Code Composer Studio the functions fputc and fputs must be overridden.

#include <stdio.h>
#include <string.h>
#define PRINTF_UART                     UART0_BASE
// Override 'fputc' function in order to use printf() to output to UART
int fputc(int _c, register FILE *_fp)
{
    UARTCharPut(PRINTF_UART, (uint8_t)_c);
    return _c;
}
// Override 'fputs' function in order to use printf() to output to UART
int fputs(const char *_ptr, register FILE *_fp)
{
  unsigned int i, len;
  len = strlen(_ptr);
  for(i=0 ; i<len ; i++)
  {
      UARTCharPut(PRINTF_UART, (uint8_t)_ptr[i]);
  }
  return len;
}

IAR

In IAR the function putchar must be overridden.

#include <stdio.h>
#include <string.h>
#define PRINTF_UART                     UART0_BASE
// Override 'putchar' function in order to use printf() to output to UART.
int putchar(int data)
{
    UARTCharPut(PRINTF_UART, (uint8_t)data);
    return data;
}

Function Documentation

static void UARTBreakCtl	(	uint32_t	ui32Base,
		bool	bBreakState
	)

inlinestatic

Causes a BREAK to be sent.

Note: For proper transmission of a break command, the break must be asserted for at least two complete frames.

Parameters

ui32Base	is the base address of the UART port.
bBreakState	controls the output level. `true` : Asserts a break condition on the UART. `false` : Removes the break condition.

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Set the break condition as requested.
     HWREG(ui32Base + UART_O_LCRH) =
          (bBreakState ?
          (HWREG(ui32Base + UART_O_LCRH) | UART_LCRH_BRK) :
          (HWREG(ui32Base + UART_O_LCRH) & ~(UART_LCRH_BRK)));
 }

static bool UARTBusy ( uint32_t ui32Base )

inlinestatic

Determines whether the UART transmitter is busy or not.

Allows the caller to determine whether all transmitted bytes have cleared the transmitter hardware. If false is returned, the transmit FIFO is empty and all bits of the last transmitted character, including all stop bits, have left the hardware shift register.

Parameters

ui32Base is the base address of the UART port.

Returns

Returns status of UART transmitter.

true : UART is transmitting.
false : All transmissions are complete.

 {
     // Check the argument.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Determine if the UART is busy.
     return((HWREG(ui32Base + UART_O_FR) & UART_FR_BUSY) ?
            UART_BUSY : UART_IDLE);
 }

int32_t UARTCharGet ( uint32_t ui32Base )

Waits for a character from the specified port.

This function gets a character from the receive FIFO for the specified port. If there are no characters available, this function waits until a character is received before returning.

Parameters

ui32Base is the base address of the UART port.

Returns: Returns the character read from the specified port, cast as an int32_t.

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Wait until a char is available.
     while(HWREG(ui32Base + UART_O_FR) & UART_FR_RXFE)
     {
     }
 
     // Now get the character.
     return(HWREG(ui32Base + UART_O_DR));
 }

int32_t UARTCharGetNonBlocking ( uint32_t ui32Base )

Receives a character from the specified port.

This function gets a character from the receive FIFO for the specified port.

Note: The UARTCharsAvail() function should be called before attempting to call this function.

Parameters

ui32Base is the base address of the UART port.

Returns: Returns the character read from the specified port, cast as an int32_t. A -1 is returned if there are no characters present in the receive FIFO.

See also: UARTCharsAvail()

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // See if there are any characters in the receive FIFO.
     if(!(HWREG(ui32Base + UART_O_FR) & UART_FR_RXFE))
     {
         // Read and return the next character.
         return(HWREG(ui32Base + UART_O_DR));
     }
     else
     {
         // There are no characters, so return a failure.
         return(-1);
     }
 }

void UARTCharPut	(	uint32_t	ui32Base,
		uint8_t	ui8Data
	)

Waits to send a character from the specified port.

This function sends the character ui8Data to the transmit FIFO for the specified port. If there is no space available in the transmit FIFO, this function waits until there is space available before returning.

Parameters

ui32Base	is the base address of the UART port.
ui8Data	is the character to be transmitted.

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Wait until space is available.
     while(HWREG(ui32Base + UART_O_FR) & UART_FR_TXFF)
     {
     }
 
     // Send the char.
     HWREG(ui32Base + UART_O_DR) = ui8Data;
 }

bool UARTCharPutNonBlocking	(	uint32_t	ui32Base,
		uint8_t	ui8Data
	)

Sends a character to the specified port.

This function writes the character ui8Data to the transmit FIFO for the specified port. This function does not block, so if there is no space available, then a false is returned, and the application must retry the function later.

Parameters

ui32Base	is the base address of the UART port.
ui8Data	is the character to be transmitted.

Returns

Returns status of the character transmit.

true : The character was successfully placed in the transmit FIFO.
false : There was no space available in the transmit FIFO. Try again later.

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // See if there is space in the transmit FIFO.
     if(!(HWREG(ui32Base + UART_O_FR) & UART_FR_TXFF))
     {
         // Write this character to the transmit FIFO.
         HWREG(ui32Base + UART_O_DR) = ui8Data;
 
         // Success.
         return(true);
     }
     else
     {
         // There is no space in the transmit FIFO, so return a failure.
         return(false);
     }
 }

static bool UARTCharsAvail ( uint32_t ui32Base )

inlinestatic

Determines if there are any characters in the receive FIFO.

This function returns a flag indicating whether or not there is data available in the receive FIFO.

Parameters

ui32Base is the base address of the UART port.

Returns

Returns status of the receive FIFO.

true : There is data in the receive FIFO.
false : There is no data in the receive FIFO.

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Return the availability of characters.
     return((HWREG(ui32Base + UART_O_FR) & UART_FR_RXFE) ? false : true);
 }

void UARTConfigGetExpClk	(	uint32_t	ui32Base,
		uint32_t	ui32UARTClk,
		uint32_t *	pui32Baud,
		uint32_t *	pui32Config
	)

Gets the current configuration of a UART.

The baud rate and data format for the UART is determined, given an explicitly provided peripheral clock (hence the ExpClk suffix). The returned baud rate is the actual baud rate; it may not be the exact baud rate requested or an "official" baud rate. The data format returned in pui32Config is enumerated the same as the ui32Config parameter of UARTConfigSetExpClk().

Note: The peripheral clock is not necessarily the same as the processor clock. The frequency of the peripheral clock is set by the system control.

Parameters

ui32Base	is the base address of the UART port.
ui32UARTClk	is the rate of the clock supplied to the UART module.
pui32Baud	is a pointer to storage for the baud rate.
pui32Config	is a pointer to storage for the data format.

Returns: None

 {
     uint32_t ui32Int, ui32Frac;
 
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Compute the baud rate.
     ui32Int = HWREG(ui32Base + UART_O_IBRD);
     ui32Frac = HWREG(ui32Base + UART_O_FBRD);
     *pui32Baud = (ui32UARTClk * 4) / ((64 * ui32Int) + ui32Frac);
 
     // Get the parity, data length, and number of stop bits.
     *pui32Config = (HWREG(ui32Base + UART_O_LCRH) &
                     (UART_LCRH_SPS | UART_LCRH_WLEN_M | UART_LCRH_STP2 |
                      UART_LCRH_EPS | UART_LCRH_PEN));
 }

void UARTConfigSetExpClk	(	uint32_t	ui32Base,
		uint32_t	ui32UARTClk,
		uint32_t	ui32Baud,
		uint32_t	ui32Config
	)

Sets the configuration of a UART.

This function configures the UART for operation in the specified data format.

Note: The peripheral clock is not necessarily the same as the processor clock. The frequency of the peripheral clock is set by the system control.

Parameters

ui32Base	is the base address of the UART port.
ui32UARTClk	is the rate of the clock supplied to the UART module.
ui32Baud	is the desired baud rate. Minimum baud rate: ui32Baud >= ceil(ui32UARTClk / 1,048,559.875) Maximum baud rate: ui32Baud <= floor(ui32UARTClk / 15.875)
ui32Config	is the data format for the port. The parameter is the bitwise OR of three values: Number of data bits UART_CONFIG_WLEN_8 : 8 data bits per byte. UART_CONFIG_WLEN_7 : 7 data bits per byte. UART_CONFIG_WLEN_6 : 6 data bits per byte. UART_CONFIG_WLEN_5 : 5 data bits per byte. Number of stop bits UART_CONFIG_STOP_ONE : One stop bit. UART_CONFIG_STOP_TWO : Two stop bits. Parity UART_CONFIG_PAR_NONE UART_CONFIG_PAR_EVEN UART_CONFIG_PAR_ODD UART_CONFIG_PAR_ONE UART_CONFIG_PAR_ZERO

Returns: None

 {
     uint32_t ui32Div;
 
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
     ASSERT(ui32Baud != 0);
 
     // Stop the UART.
     UARTDisable(ui32Base);
 
     // Compute the fractional baud rate divider.
     ui32Div = (((ui32UARTClk * 8) / ui32Baud) + 1) / 2;
 
     // Set the baud rate.
     HWREG(ui32Base + UART_O_IBRD) = ui32Div / 64;
     HWREG(ui32Base + UART_O_FBRD) = ui32Div % 64;
 
     // Set parity, data length, and number of stop bits.
     HWREG(ui32Base + UART_O_LCRH) = ui32Config;
 }

Here is the call graph for this function:

void UARTDisable ( uint32_t ui32Base )

Disables transmitting and receiving.

This function clears the UARTEN, TXE, and RXE bits, waits for the end of transmission of the current character, and flushes the transmit FIFO.

Parameters

ui32Base is the base address of the UART port.

Returns: None

Referenced by UARTConfigSetExpClk().

 {
 
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Wait for end of TX.
     while(HWREG(ui32Base + UART_O_FR) & UART_FR_BUSY)
     {
     }
 
     // Disable the FIFO.
     HWREG(ui32Base + UART_O_LCRH) &= ~(UART_LCRH_FEN);
 
     // Disable the UART.
     HWREG(ui32Base + UART_O_CTL) &= ~(UART_CTL_UARTEN | UART_CTL_TXE |
                                       UART_CTL_RXE);
 }

static void UARTDMADisable	(	uint32_t	ui32Base,
		uint32_t	ui32DMAFlags
	)

inlinestatic

Disable UART DMA operation.

This function is used to disable UART DMA features that were enabled by UARTDMAEnable(). The specified UART DMA features are disabled.

Parameters

ui32Base	is the base address of the UART port.
ui32DMAFlags	is a bit mask of the DMA features to disable. The parameter is the bitwise OR of any of the following values: UART_DMA_RX : Enable DMA for receive. UART_DMA_TX : Enable DMA for transmit. UART_DMA_ERR_RXSTOP : Disable DMA receive on UART error.

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Clear the requested bits in the UART DMA control register.
     HWREG(ui32Base + UART_O_DMACTL) &= ~ui32DMAFlags;
 }

static void UARTDMAEnable	(	uint32_t	ui32Base,
		uint32_t	ui32DMAFlags
	)

inlinestatic

Enable UART DMA operation.

The specified UART DMA features are enabled. The UART can be configured to use DMA for transmit or receive, and to disable receive if an error occurs.

Note: The uDMA controller must also be set up before DMA can be used with the UART.

Parameters

ui32Base	is the base address of the UART port.
ui32DMAFlags	is a bit mask of the DMA features to enable. The parameter is the bitwise OR of any of the following values: UART_DMA_RX : Enable DMA for receive. UART_DMA_TX : Enable DMA for transmit. UART_DMA_ERR_RXSTOP : Disable DMA receive on UART error.

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Set the requested bits in the UART DMA control register.
     HWREG(ui32Base + UART_O_DMACTL) |= ui32DMAFlags;
 }

static void UARTEnable ( uint32_t ui32Base )

inlinestatic

Enables transmitting and receiving.

This function sets the UARTEN, TXE, and RXE bits, and enables the transmit and receive FIFOs.

Parameters

ui32Base is the base address of the UART port.

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Enable the FIFO.
     HWREG(ui32Base + UART_O_LCRH) |= UART_LCRH_FEN;
 
     // Enable RX, TX, and the UART.
     HWREG(ui32Base + UART_O_CTL) |= (UART_CTL_UARTEN | UART_CTL_TXE |
                                      UART_CTL_RXE);
 }

static void UARTFIFODisable ( uint32_t ui32Base )

inlinestatic

Disables the transmit and receive FIFOs.

This functions disables the transmit and receive FIFOs in the UART.

Parameters

ui32Base is the base address of the UART port.

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Disable the FIFO.
     HWREG(ui32Base + UART_O_LCRH) &= ~(UART_LCRH_FEN);
 }

static void UARTFIFOEnable ( uint32_t ui32Base )

inlinestatic

Enables the transmit and receive FIFOs.

This functions enables the transmit and receive FIFOs in the UART.

Parameters

ui32Base is the base address of the UART port.

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Enable the FIFO.
     HWREG(ui32Base + UART_O_LCRH) |= UART_LCRH_FEN;
 }

void UARTFIFOLevelGet	(	uint32_t	ui32Base,
		uint32_t *	pui32TxLevel,
		uint32_t *	pui32RxLevel
	)

Gets the FIFO level at which interrupts are generated.

This function gets the FIFO level at which transmit and receive interrupts are generated.

Parameters

ui32Base	is the base address of the UART port.
pui32TxLevel	is a pointer to storage for the transmit FIFO level, returned as one of: UART_FIFO_TX1_8 UART_FIFO_TX2_8 UART_FIFO_TX4_8 UART_FIFO_TX6_8 UART_FIFO_TX7_8
pui32RxLevel	is a pointer to storage for the receive FIFO level, returned as one of: UART_FIFO_RX1_8 UART_FIFO_RX2_8 UART_FIFO_RX4_8 UART_FIFO_RX6_8 UART_FIFO_RX7_8

Returns: None

 {
     uint32_t ui32Temp;
 
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Read the FIFO level register.
     ui32Temp = HWREG(ui32Base + UART_O_IFLS);
 
     // Extract the transmit and receive FIFO levels.
     *pui32TxLevel = ui32Temp & UART_IFLS_TXSEL_M;
     *pui32RxLevel = ui32Temp & UART_IFLS_RXSEL_M;
 }

static void UARTFIFOLevelSet	(	uint32_t	ui32Base,
		uint32_t	ui32TxLevel,
		uint32_t	ui32RxLevel
	)

inlinestatic

Sets the FIFO level at which interrupts are generated.

This function sets the FIFO level at which transmit and receive interrupts are generated.

Parameters

ui32Base	is the base address of the UART port.
ui32TxLevel	is the transmit FIFO interrupt level, specified as one of: UART_FIFO_TX1_8 UART_FIFO_TX2_8 UART_FIFO_TX4_8 UART_FIFO_TX6_8 UART_FIFO_TX7_8
ui32RxLevel	is the receive FIFO interrupt level, specified as one of: UART_FIFO_RX1_8 UART_FIFO_RX2_8 UART_FIFO_RX4_8 UART_FIFO_RX6_8 UART_FIFO_RX7_8

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
     ASSERT((ui32TxLevel == UART_FIFO_TX1_8) ||
            (ui32TxLevel == UART_FIFO_TX2_8) ||
            (ui32TxLevel == UART_FIFO_TX4_8) ||
            (ui32TxLevel == UART_FIFO_TX6_8) ||
            (ui32TxLevel == UART_FIFO_TX7_8));
     ASSERT((ui32RxLevel == UART_FIFO_RX1_8) ||
            (ui32RxLevel == UART_FIFO_RX2_8) ||
            (ui32RxLevel == UART_FIFO_RX4_8) ||
            (ui32RxLevel == UART_FIFO_RX6_8) ||
            (ui32RxLevel == UART_FIFO_RX7_8));
 
     // Set the FIFO interrupt levels.
     HWREG(ui32Base + UART_O_IFLS) = ui32TxLevel | ui32RxLevel;
 }

static void UARTHwFlowControlDisable ( uint32_t ui32Base )

inlinestatic

Disables hardware flow control for both CTS and RTS.

Hardware flow control is disabled by default.

Parameters

ui32Base is the base address of the UART port.

Returns: None

 {
     // Check the arguments.
     ASSERT( UARTBaseValid( ui32Base ));
 
     HWREG( ui32Base + UART_O_CTL ) &= ~( UART_CTL_CTSEN | UART_CTL_RTSEN );
 }

static void UARTHwFlowControlEnable ( uint32_t ui32Base )

inlinestatic

Enables hardware flow control for both CTS and RTS.

Hardware flow control is disabled by default.

Parameters

ui32Base is the base address of the UART port.

Returns: None

 {
     // Check the arguments.
     ASSERT( UARTBaseValid( ui32Base ));
 
     HWREG( ui32Base + UART_O_CTL ) |= ( UART_CTL_CTSEN | UART_CTL_RTSEN );
 }

static void UARTIntClear	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

inlinestatic

Clears UART interrupt sources.

The specified UART interrupt sources are cleared, so that they no longer assert. This function must be called in the interrupt handler to keep the interrupt from being recognized again immediately upon exit.

Note

Due to write buffers and synchronizers in the system it may take several clock cycles from a register write clearing an event in a module and until the event is actually cleared in the NVIC of the system CPU. It is recommended to clear the event source early in the interrupt service routine (ISR) to allow the event clear to propagate to the NVIC before returning from the ISR. At the same time, an early event clear allows new events of the same type to be pended instead of ignored if the event is cleared later in the ISR. It is the responsibility of the programmer to make sure that enough time has passed before returning from the ISR to avoid false re-triggering of the cleared event. A simple, although not necessarily optimal, way of clearing an event before returning from the ISR is:

Write to clear event (interrupt source). (buffered write)
Dummy read from the event source module. (making sure the write has propagated)
Wait two system CPU clock cycles (user code or two NOPs). (allowing cleared event to propagate through any synchronizers)

Parameters

ui32Base	is the base address of the UART port.
ui32IntFlags	is a bit mask of the interrupt sources to be cleared. UART_INT_OE : Overrun Error interrupt. UART_INT_BE : Break Error interrupt. UART_INT_PE : Parity Error interrupt. UART_INT_FE : Framing Error interrupt. UART_INT_RT : Receive Timeout interrupt. UART_INT_TX : Transmit interrupt. UART_INT_RX : Receive interrupt. UART_INT_CTS : CTS interrupt.

Returns: None

 {
     // Check the arguments
     ASSERT(UARTBaseValid(ui32Base));
 
     // Clear the requested interrupt sources
     HWREG(ui32Base + UART_O_ICR) = ui32IntFlags;
 }

static void UARTIntDisable	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

inlinestatic

Disables individual UART interrupt sources.

This function disables the indicated UART interrupt sources. Only the sources that are enabled can be reflected to the processor interrupt; disabled sources have no effect on the processor.

Parameters

ui32Base	is the base address of the UART port.
ui32IntFlags	is the bit mask of the interrupt sources to be disabled. UART_INT_OE : Overrun Error interrupt. UART_INT_BE : Break Error interrupt. UART_INT_PE : Parity Error interrupt. UART_INT_FE : Framing Error interrupt. UART_INT_RT : Receive Timeout interrupt. UART_INT_TX : Transmit interrupt. UART_INT_RX : Receive interrupt. UART_INT_CTS : CTS interrupt.

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Disable the specified interrupts.
     HWREG(ui32Base + UART_O_IMSC) &= ~(ui32IntFlags);
 }

static void UARTIntEnable	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

inlinestatic

Enables individual UART interrupt sources.

This function enables the indicated UART interrupt sources. Only the sources that are enabled can be reflected to the processor interrupt; disabled sources have no effect on the processor.

Parameters

ui32Base is the base address of the UART port.

ui32IntFlags

is the bit mask of the interrupt sources to be enabled. The parameter is the bitwise OR of any of the following:

UART_INT_OE : Overrun Error interrupt.
UART_INT_BE : Break Error interrupt.
UART_INT_PE : Parity Error interrupt.
UART_INT_FE : Framing Error interrupt.
UART_INT_RT : Receive Timeout interrupt.
UART_INT_TX : Transmit interrupt.
UART_INT_RX : Receive interrupt.
UART_INT_CTS : CTS interrupt.

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Enable the specified interrupts.
     HWREG(ui32Base + UART_O_IMSC) |= ui32IntFlags;
 }

void UARTIntRegister	(	uint32_t	ui32Base,
		void(*)(void)	pfnHandler
	)

Registers an interrupt handler for a UART interrupt in the dynamic interrupt table.

Note: Only use this function if you want to use the dynamic vector table (in SRAM)!

This function registers a function as the interrupt handler for a specific interrupt and enables the corresponding interrupt in the interrupt controller.

Specific UART interrupts must be enabled via UARTIntEnable(). It is the interrupt handler's responsibility to clear the interrupt source.

Parameters

ui32Base	is the base address of the UART module.
pfnHandler	is a pointer to the function to be called when the UART interrupt occurs.

Returns: None

See also: IntRegister() for important information about registering interrupt handlers.

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Register the interrupt handler.
     IntRegister(INT_UART0_COMB, pfnHandler);
 
     // Enable the UART interrupt.
     IntEnable(INT_UART0_COMB);
 }

Here is the call graph for this function:

static uint32_t UARTIntStatus	(	uint32_t	ui32Base,
		bool	bMasked
	)

inlinestatic

Gets the current interrupt status.

This function returns the interrupt status for the specified UART. Either the raw interrupt status or the status of interrupts that are allowed to reflect to the processor can be returned.

Parameters

ui32Base	is the base address of the UART port.
bMasked	selects either raw or masked interrupt. `true` : Masked interrupt status is required. `false` : Raw interrupt status is required.

Returns

Returns the current interrupt status, enumerated as a bit field of:

UART_INT_OE : Overrun Error interrupt.
UART_INT_BE : Break Error interrupt.
UART_INT_PE : Parity Error interrupt.
UART_INT_FE : Framing Error interrupt.
UART_INT_RT : Receive Timeout interrupt.
UART_INT_TX : Transmit interrupt.
UART_INT_RX : Receive interrupt.
UART_INT_CTS : CTS interrupt.

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Return either the interrupt status or the raw interrupt status as
     // requested.
     if(bMasked)
     {
         return(HWREG(ui32Base + UART_O_MIS));
     }
     else
     {
         return(HWREG(ui32Base + UART_O_RIS));
     }
 }

void UARTIntUnregister ( uint32_t ui32Base )

Unregisters an interrupt handler for a UART interrupt in the dynamic interrupt table.

This function does the actual unregistering of the interrupt handler. It clears the handler to be called when a UART interrupt occurs. This function also masks off the interrupt in the interrupt controller so that the interrupt handler no longer is called.

Parameters

ui32Base is the base address of the UART module.

Returns: None

See also: IntRegister() for important information about registering interrupt handlers.

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Disable the interrupt.
     IntDisable(INT_UART0_COMB);
 
     // Unregister the interrupt handler.
     IntUnregister(INT_UART0_COMB);
 }

Here is the call graph for this function:

static uint32_t UARTParityModeGet ( uint32_t ui32Base )

inlinestatic

Gets the type of parity currently being used.

This function gets the type of parity used for transmitting data and expected when receiving data.

Parameters

ui32Base is the base address of the UART port.

Returns

Returns the current parity settings, specified as one of:

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Return the current parity setting
     return(HWREG(ui32Base + UART_O_LCRH) &
            (UART_LCRH_SPS | UART_LCRH_EPS | UART_LCRH_PEN));
 }

static void UARTParityModeSet	(	uint32_t	ui32Base,
		uint32_t	ui32Parity
	)

inlinestatic

Sets the type of parity.

This function sets the type of parity to use for transmitting and expect when receiving.

Parameters

ui32Base	is the base address of the UART port.
ui32Parity	specifies the type of parity to use. The last two allow direct control of the parity bit; it is always either one or zero based on the mode. UART_CONFIG_PAR_NONE UART_CONFIG_PAR_EVEN UART_CONFIG_PAR_ODD UART_CONFIG_PAR_ONE UART_CONFIG_PAR_ZERO

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
     ASSERT((ui32Parity == UART_CONFIG_PAR_NONE) ||
            (ui32Parity == UART_CONFIG_PAR_EVEN) ||
            (ui32Parity == UART_CONFIG_PAR_ODD) ||
            (ui32Parity == UART_CONFIG_PAR_ONE) ||
            (ui32Parity == UART_CONFIG_PAR_ZERO));
 
     // Set the parity mode.
     HWREG(ui32Base + UART_O_LCRH) = ((HWREG(ui32Base + UART_O_LCRH) &
                                       ~(UART_LCRH_SPS | UART_LCRH_EPS |
                                         UART_LCRH_PEN)) | ui32Parity);
 }

static void UARTRxErrorClear ( uint32_t ui32Base )

inlinestatic

Clears all reported receiver errors.

This function is used to clear all receiver error conditions reported via UARTRxErrorGet(). If using the overrun, framing error, parity error or break interrupts, this function must be called after clearing the interrupt to ensure that later errors of the same type trigger another interrupt.

Parameters

ui32Base is the base address of the UART port.

Returns: None

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Any write to the Error Clear Register will clear all bits which are
     // currently set.
     HWREG(ui32Base + UART_O_ECR) = 0;
 }

static uint32_t UARTRxErrorGet ( uint32_t ui32Base )

inlinestatic

Gets current receiver errors.

This function returns the current state of each of the 4 receiver error sources. The returned errors are equivalent to the four error bits returned via the previous call to UARTCharGet() or UARTCharGetNonBlocking() with the exception that the overrun error is set immediately the overrun occurs rather than when a character is next read.

Parameters

ui32Base is the base address of the UART port.

Returns

Returns a bitwise OR combination of the receiver error flags:

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Return the current value of the receive status register.
     return(HWREG(ui32Base + UART_O_RSR) & 0x0000000F);
 }

static bool UARTSpaceAvail ( uint32_t ui32Base )

inlinestatic

Determines if there is any space in the transmit FIFO.

This function returns a flag indicating whether or not there is space available in the transmit FIFO.

Parameters

ui32Base is the base address of the UART port.

Returns

Returns status of the transmit FIFO.

true : There is space available in the transmit FIFO.
false : There is no space available in the transmit FIFO.

 {
     // Check the arguments.
     ASSERT(UARTBaseValid(ui32Base));
 
     // Return the availability of space.
     return((HWREG(ui32Base + UART_O_FR) & UART_FR_TXFF) ? false : true);
 }