UART Library

The UART hardware module is available with a number of ARM MCUs. The mikroC PRO for ARM UART Library provides comfortable work with the Asynchronous (full duplex) mode.

Important :

UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 0 to 7.
Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Switching between the UART modules in the UART library is done by the UART_Set_Active function (UART modules have to be previously initialized).

Generic Routines

UART_Data_Ready
UART_Tx_Idle
UART_Read
UART_Read_Text
UART_Write
UART_Write_Text

UARTx_Init

Prototype	void UARTx_Init(unsigned long baud_rate);
Description	Configures and initializes the UART module. The internal UART module module is set to : default Tx and Rx pins. 8-bit data, no parity. 1 STOP bit.
Parameters	`baud_rate:` requested baud rate.
Returns	Nothing.
Requires	Routine requires the UART module.
Example	// Initialize hardware UART1 module and establish communication at 2400 bps UART1_Init(2400);
Notes	Refer to the device data sheet for baud rates allowed for specific peripheral clock values. UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 0 to 7. Switching between the UART modules in the UART library is done by the UART_Set_Active function (UART modules have to be previously initialized). Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library. Stellaris For MCUs with alternative PORT functions on GPIO pins, UART modules can be set on the following pins. : UART0 - PA0/PA1, UART1 - PB0/PB1, PB4/PB5, PC6/PC7, PD2/PD3, UART2 - PB4/E4, PD0/PD1, PG0/PG1, The compiler will choose for which speed the calculation is to be performed (high or low). This does not mean that it is the best choice for desired baud rate. If the baud rate error generated in this way is too big then UARTx_Init_Advanced routine, which allows speed select, should be used. STM32 UART modules can be set on the following pins : UART1 - PA9/PA10, UART2 - PA2/PA3, UART3 - PB10/PB11, UART4 - PC10/PC11, UART5 - PC12/PD2, UART6 - PC6/PC7.

UARTx_Init_Advanced

Prototype

// for Stellaris MCUs :

void UARTx_Init_Advanced(unsigned long baud_rate, unsigned long freq_Khz, unsigned int data_bits, unsigned int parity, unsigned int stop_bits, unsigned int high_low);

// for Stellaris MCUs with alternative PORT functions on GPIO pins :

void UARTx_Init_Advanced(unsigned long baud_rate, unsigned long freq_Khz, unsigned int data_bits, unsigned int parity, unsigned int stop_bits, unsigned int high_low, const Module_Struct *module);

// for ST MCUs :

void UARTx_Init_Advanced(unsigned long baud_rate, unsigned int data_bits, unsigned int parity, unsigned int stop_bits, const module_Struct* module);

Description

Configures and initializes the UART module with user defined settings.

Parameters

Stellaris

baud_rate: Requested baud rate.
freq_Khz: Peripheral Bus Clock frequency in kHz.

data_bits: Data bits selection parameter. Valid values :

Data Bits
Description	Predefined library const
`5 data bits`	`_UART_5_BIT_DATA`
`6 data bits`	`_UART_6_BIT_DATA`
`7 data bits`	`_UART_7_BIT_DATA`
`8 data bits`	`_UART_8_BIT_DATA`

parity: Parity selection parameter. Valid values :

Parity Mode
Description	Predefined library const
`No parity`	`_UART_NOPARITY`
`Even parity`	`_UART_EVENPARITY`
`Odd parity`	`_UART_ODDPARITY`
`Parity bit is one`	`_UART_PARITY_ONE`
`Parity bit is zero`	`_UART_PARITY_ZERO`

stop_bits: Stop bit selection parameter. Valid values :

Stop bits
Description	Predefined library const
`One stop bit`	`_UART_ONE_STOPBIT`
`Two stop bit`	`_UART_TWO_STOPBITS`

high_low: High/low speed selection parameter. Valid values :

High/Low Speed
Description	Predefined library const
`Low Speed UART`	`_UART_LOW_SPEED`
`Hi Speed UART`	`_UART_HI_SPEED`

module: appropriate module pinout, see the following table :

UART Module Pinouts for Stellaris Cortex M3
UART0	_GPIO_MODULE_UART0_A01
UART1	_GPIO_MODULE_UART1_A01	_GPIO_MODULE_UART1_B01	_GPIO_MODULE_UART1_B45	_GPIO_MODULE_UART1_C67	_GPIO_MODULE_UART1_D01	_GPIO_MODULE_UART1_D23
UART2	_GPIO_MODULE_UART2_D01	_GPIO_MODULE_UART2_D56	_GPIO_MODULE_UART2_G01

UART Module Pinouts for Stellaris Cortex M4
UART0	_GPIO_MODULE_UART0_A01_AHB
UART1	_GPIO_MODULE_UART1_B01_AHB	_GPIO_MODULE_UART1_C45_AHB
UART2	_GPIO_MODULE_UART2_D67_AHB	_GPIO_MODULE_UART2_G45_AHB
UART3	_GPIO_MODULE_UART3_C67_AHB
UART4	_GPIO_MODULE_UART4_C45_AHB	_GPIO_MODULE_UART4_J01_AHB
UART5	_GPIO_MODULE_UART5_E45_AHB	_GPIO_MODULE_UART5_J23_AHB
UART6	_GPIO_MODULE_UART6_D45_AHB	_GPIO_MODULE_UART6_J45_AHB
UART7	_GPIO_MODULE_UART7_E01_AHB	_GPIO_MODULE_UART7_K45_AHB

STM32

baud_rate: Requested baud rate.

data_bits: Data bits selection parameter. Valid values :

Data Bits
Description	Predefined library const
`5 data bits`	`_UART_5_BIT_DATA`
`6 data bits`	`_UART_6_BIT_DATA`
`7 data bits`	`_UART_7_BIT_DATA`
`8 data bits`	`_UART_8_BIT_DATA`
`9 data bits`	`_UART_9_BIT_DATA`

parity: Parity selection parameter. Valid values :

Parity Mode
Description	Predefined library const
`No parity`	`_UART_NOPARITY`
`Even parity`	`_UART_EVENPARITY`
`Odd parity`	`_UART_ODDPARITY`
`Parity bit is one`	`_UART_PARITY_ONE`
`Parity bit is zero`	`_UART_PARITY_ZERO`

stop_bits: Stop bit selection parameter. Valid values :

Stop bits
Description	Predefined library const
`Half stop bit`	`_UART_HALF_STOPBIT`
`One stop bit`	`_UART_ONE_STOPBIT`
`One and a half stop bits`	`_UART_ONE_AND_A_HALF_STOPBITS`
`Two stop bit`	`_UART_TWO_STOPBITS`

module: appropriate module pinout, see the following table :

UART Module Pinouts for ST M3
UART1	_GPIO_MODULE_USART1_PA9_10	_GPIO_MODULE_USART1_PB67
UART2	_GPIO_MODULE_USART2_PA23	_GPIO_MODULE_USART2_PD56
UART3	_GPIO_MODULE_USART3_PB10_11	_GPIO_MODULE_USART3_PC10_11	_GPIO_MODULE_USART3_PD89
UART4	_GPIO_MODULE_UART4_PC10_11	_GPIO_MODULE_UART4_PA01
UART5	_GPIO_MODULE_UART5_PC12_PD2
UART6	_GPIO_MODULE_USART6_PC67	_GPIO_MODULE_USART6_PG9_14

UART Module Pinouts for ST M4
UART1	_GPIO_MODULE_USART1_PA9_10	_GPIO_MODULE_USART1_PB67
UART2	_GPIO_MODULE_USART2_PA23	_GPIO_MODULE_USART2_PD56
UART3	_GPIO_MODULE_USART3_PB10_11	_GPIO_MODULE_USART3_PC10_11	_GPIO_MODULE_USART3_PD89
UART4	_GPIO_MODULE_UART4_PA01	_GPIO_MODULE_UART4_PC10_11
UART5	_GPIO_MODULE_UART5_PC12_PD2
UART6	_GPIO_MODULE_USART6_PC67	_GPIO_MODULE_USART6_PG9_14

Returns

Nothing.

Requires

Routine requires the UART module.

Example

Stellaris

// Initialize hardware UART1 module at 115200 bps with 10 MHz peripheral clock, 8 data, no parity and 1 stop bit in high speed mode :
UART1_Init_Advanced(115200, 10000, _UART_8_BIT_DATA, _UART_NOPARITY, _UART_ONE_STOPBIT, _UART_HI_SPEED);

// Initialize hardware UART1 module on GPIO_PORTA at 115200 bps with 10 MHz peripheral clock, 8 data, no parity and 1 stop bit in high speed mode :
UART1_Init_Advanced(115200, 10000, _UART_8_BIT_DATA, _UART_NOPARITY, _UART_ONE_STOPBIT, _UART_HI_SPEED, &_GPIO_MODULE_UART1_A01);

STM32

// Initialize hardware UART1 module on PORTA at 115200 bps, 8 data, no parity and 1 stop bit :
UART1_Init_Advanced(115200, _UART_8_BIT_DATA, _UART_NOPARITY, _UART_ONE_STOPBIT, &_GPIO_MODULE_USART1_PA9_10);

Notes

Refer to the device data sheet for baud rates allowed for specific peripheral clock values.
UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 0 to 7.
Switching between the UART modules in the UART library is done by the UART_Set_Active function (UART modules have to be previously initialized).
Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
For available working modes for a specific MCU please read the appropriate datasheet.

UARTx_Data_Ready

Prototype	unsigned UARTx_Data_Ready();
Description	The function tests if data in receive buffer is ready for reading.
Parameters	None.
Returns	`1` if data is ready for reading. `0` if there is no data in the receive register.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	unsigned receive; ... // read data if ready if (UART1_Data_Ready()) receive = UART1_Read();
Notes	UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 0 to 7. Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.

UARTx_Tx_Idle

Prototype	char UARTx_Tx_Idle();
Description	Use the function to test if the transmit shift register is empty or not.
Parameters	None.
Returns	`1` if the data has been transmitted. `0` otherwise.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	// If the previous data has been shifted out, send next data: if (UART1_Tx_Idle() == 1) { UART1_Write(_data); }
Notes	UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 0 to 7. Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.

UARTx_Read

Prototype	unsigned UARTx_Read();
Description	The function receives a byte via UART. Use the UARTx_Data_Ready function to test if data is ready first.
Parameters	None.
Returns	Received byte.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	unsigned receive; ... // read data if ready if (UART1_Data_Ready()) receive = UART1_Read();
Notes	UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 0 to 7. Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.

UARTx_Read_Text

Prototype	void UARTx_Read_Text(char Output, char* Delimiter, char* Attempts);
Description	Reads characters received via UART until the delimiter sequence is detected. The read sequence is stored in the parameter `output`; delimiter sequence is stored in the parameter `delimiter`. This is a blocking call: the delimiter sequence is expected, otherwise the procedure exits (if the delimiter is not found).
Parameters	`Output:` received text. `Delimiter:` sequence of characters that identifies the end of a received string. `Attempts:` defines number of received characters in which `Delimiter` sequence is expected. If `Attempts` is set to 255, this routine will continuously try to detect the `Delimiter` sequence.
Returns	Nothing.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	Read text until the sequence “OK” is received, and send back what’s been received: UART1_Init(4800); // initialize UART1 module Delay_ms(100); while (1) { if (UART1_Data_Ready() == 1) { // if data is received UART1_Read_Text(output, "OK", 10); // reads text until 'OK' is found UART1_Write_Text(output); // sends back text } }
Notes	UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 0 to 7. Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.

UARTx_Write

Prototype	void UARTx_Write(unsigned _data);
Description	The function transmits a byte via the UART module.
Parameters	`_data:` data to be sent.
Returns	Nothing.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	unsigned data = 0x1E; ... UART1_Write(data);
Notes	UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 0 to 7. Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.

UARTx_Write_Text

Prototype	void UARTx_Write_Text(char * UART_text);
Description	Sends text via UART. Text should be zero terminated.
Parameters	`UART_text:` text to be sent.
Returns	Nothing.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	Read text until the sequence “OK” is received, and send back what’s been received: UART1_Init(4800); // initialize UART1 module Delay_ms(100); while (1) { if (UART1_Data_Ready() == 1) { // if data is received UART1_Read_Text(output, "OK", 10); // reads text until 'OK' is found UART1_Write_Text(output); // sends back text } }
Notes	UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 0 to 7. Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.

UART_Set_Active

Prototype	void UART_Set_Active(unsigned (read_ptr)(), void* (write_ptr)(unsigned* char _data), unsigned (ready_ptr)(), unsigned* (*tx_idle_ptr)());
Description	Sets active UART module which will be used by UARTx_Data_Ready, UARTx_Read and UARTx_Write routines.
Parameters	Parameters : `read_ptr:` UARTx_Read handler. `write_ptr:` UARTx_Write handler. `ready_ptr:` UARTx_Data_Ready handler. `tx_idle_ptr:` UARTx_Tx_Idle handler.
Returns	Nothing.
Requires	Routine is available only for MCUs with multiple UART modules. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	UART1_Init(9600); // initialize UART1 module UART2_Init(9600); // initialize UART2 module RS485Master_Init(); // initialize MCU as Master UART_Set_Active(&UART1_Read, &UART1_Write, &UART1_Data_Ready, &UART1_Tx_Idle); // set UART1 active RS485Master_Send(dat,1,160); // send message through UART1 UART_Set_Active(&UART2_Read, &UART2_Write, &UART2_Data_Ready, &UART2_Tx_Idle); // set UART2 active RS485Master_Send(dat,1,160); // send through UART2
Notes	None.

UART_Data_Ready

Prototype	unsigned UART_Data_Ready();
Description	The function tests if data in receive buffer is ready for reading. This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Parameters	None.
Returns	`1` if data is ready for reading. `0` if there is no data in the receive register.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	unsigned receive; ... // read data if ready if (UART_Data_Ready()) receive = UART_Read();
Notes	None.

UART_Tx_Idle

Prototype	char UART_Tx_Idle();
Description	Use the function to test if the transmit shift register is empty or not. This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Parameters	None.
Returns	`1` if the data has been transmitted. `0` otherwise.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	// If the previous data has been shifted out, send next data: if (UART_Tx_Idle() == 1) { UART_Write(_data); }
Notes	None.

UART_Read

Prototype	unsigned UART_Read();
Description	The function receives a byte via UART. Use the UART_Data_Ready function to test if data is ready first. This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Parameters	None.
Returns	Received byte.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	unsigned receive; ... // read data if ready if (UART_Data_Ready()) receive = UART_Read();
Notes	None.

UART_Read_Text

Prototype	void UART_Read_Text(char Output, char* Delimiter, char* Attempts);
Description	Reads characters received via UART until the delimiter sequence is detected. The read sequence is stored in the parameter `output`; delimiter sequence is stored in the parameter `delimiter`. This is a blocking call: the delimiter sequence is expected, otherwise the procedure exits (if the delimiter is not found). This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Parameters	`Output:` received text. `Delimiter:` sequence of characters that identifies the end of a received string. `Attempts:` defines number of received characters in which `Delimiter` sequence is expected. If `Attempts` is set to 255, this routine will continuously try to detect the `Delimiter` sequence.
Returns	Nothing.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	Read text until the sequence “OK” is received, and send back what’s been received: while (1) { if (UART_Data_Ready() == 1) { // if data is received UART_Read_Text(output, "OK", 10); // reads text until 'OK' is found UART_Write_Text(output); // sends back text } }
Notes	None.

UART_Write

Prototype	void UART_Write(unsigned _data);
Description	The function transmits a byte via the UART module. This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Parameters	`_data:` data to be sent.
Returns	Nothing.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	unsigned data = 0x1E; ... UART_Write(data);
Notes	None.

UART_Write_Text

Prototype	void UART_Write_Text(char * UART_text);
Description	Sends text via UART. Text should be zero terminated. This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Parameters	`UART_text:` text to be sent.
Returns	Nothing.
Requires	Routine requires at least one UART module. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	Read text until the sequence “OK” is received, and send back what’s been received: while (1) { if (UART_Data_Ready() == 1) { // if data is received UART_Read_Text(output, "OK", 10); // reads text until 'OK' is found UART_Write_Text(output); // sends back text } }
Notes	None.

Library Example

This example demonstrates simple data exchange via UART. If MCU is connected to the PC, you can test the example from the mikroC PRO for ARM USART communication terminal, launch it from the drop-down menu Tools › USART Terminal or simply click the USART Terminal Icon .

Copy Code To Clipboard

char uart_rd;

void main() {

  UART0_Init(56000);              // Initialize UART module at 56000 bps
  Delay_ms(100);                  // Wait for UART module to stabilize

  UART0_Write_Text("Start");
  UART0_Write(13);
  UART0_Write(10);

  while (1) {                     // Endless loop
    if (UART0_Data_Ready()) {     // If data is received
      uart_rd = UART0_Read();     // read the received data
      UART0_Write(uart_rd);       // and send data via UART
    }
  }
}

Want more examples and libraries?
Find them on