LPC1768 UART Programming Tutorial

In this discussion we will go through ARM Cortex-M3 LP1768 UART programming Tutorial. It is also applicable to for other MCUs of LPC17xx family like LPC1769. If you are new to UART, you can go through the basic UART tutorial which I’ve posted @ Basic Uart Tutorial.

UART basics revisited

Uart uses TxD(Transmit) Pin for sending Data and RxD(Receive) Pin to get data. UART sends & receives data in form of chunks or packets. These chunks or packets are also referred to as ‘Frames’. While sending Data, LSB(i.e. Data Bit 0) is transmitted First and MSB is transmitted Last. The structure of a UART Packet/Frame using 1 stop bit is as shown below:

Here is an example of single Packet/Frame using 8 data bits, even parity and 1 stop bit:

LPC1768 UART Block

Now, Lets start with the main Tutorial. ARM Cortex-M3 LPC176x has 4 UART blocks which are UART0 to UART3. UART0/2/3 are identical. UART1 additionally supports Full modem control handshaking & RS-485. Refer Datasheet for more info. After reset UART0 & UART1 are enabled by default. TxD and RxD pins for these blocks are mapped on multiple pins.

All UART blocks internally have a 16-byte FIFO (First In First Out) structure to hold data. Each byte in this FIFO represents a character which was sent or received in order. All blocks also contain 2 registers each, for data access and assembly as given below:

• Tx has THR(Transmit Holding Register) and TSR(Transmit Shift Register) – When Tx Data is written to THR, it is then transferred to TSR which assembles the Transmit data.
• Similarly Rx has RSR(Receive Shift Register) and RBR(Receive Buffer Register) – When Data is Received at the Rx Pin, it is first assembled in RSR and then transferred into Rx FIFO which can be then accessed using RBR.

LPC176x UART Registers used in programming

Before we can use these pins to transfer data, first we need to configure and initialize the UART block in our LPC176x microcontroller. But before doing that, lets go through some of the important registers:

UART Baud Rate Calculations

Now we know the formula, how we do actually start ?

1) The Dirty and Simplest Method:

The quickest and also the dirtiest(accuracy wise) method without using any algorithm or fine-tuning is to set DLM=0 and disable the Fractional Divider. In this case MULVAL=1 and DIVADDVAL=0 which makes the Fraction Part(FP) = 1. Now we are left with only 1 unknown in the equation which is UxDLL and hence we simplify the equation and solve for UxDLL.

In my opinion, if possible, you must stay away from above method as it works only for particular bauds & specific PCLK value and moreover computed UxDLL might get out of range i.e. > 255 in which case you have to start increasing DLM and recompute a new value for DLL.

2) A better Method/Algorithm (Recommended):

In these method we again start with DLM=0 , DIVADDVAL=0(i.e. Fractional divider disabled) and MULVAL=1 and get an initial value for DLM. If you are lucky you will get a very close baudrate to the desired one. If not then we perform some fine-tuning using DLM, MULVAL and DIVADDVAL and get a new value for DLM. There is on one single method to perform fine-tuning and one can also make an algorithm for computing the best match given the desired baudrate and PCLK. The fine-tuning method or Algorithm which I have given below is a basic one suitable for beginners(in my opinion though). A more invloved Iterative Algorithm is given on Page 324(Rev 4.1) of the user manual.

How to Configure and Initialize UART

Once you know how UART communication works, configuring and initializing UART is pretty straight forward. In Source Code Examples for this tutorial we will use UART0 with following configuration:

• BaudRate = 115200 (with PCLK=25Mhz)
• Data Length = 8 bits
• No Parity Bit
• and 1 Stop Bit

Note: Its your responsibility to make it sure that configuration is same on both the communicating ends.

As seen in example above: in order to get 115200(114882 actually) bauds at 25Mhz PCLK we must use the following settings for baud generation :

Now, lets write a function “InitUART0()” which we can use initialize and configure UART0:

#define MULVAL      14
#define DIVADDVAL   2
#define Ux_FIFO_EN  (1<<0)
#define Rx_FIFO_RST (1<<1)
#define Tx_FIFO_RST (1<<2)
#define DLAB_BIT    (1<<7)
void InitUART0(void)
{
	LPC_PINCON->PINSEL0 |= (1<<4) | (1<<6); //Select TXD0 and RXD0 function for P0.2 & P0.3!
	//LPC_SC->PCONP |= 1<<3; //Power up UART0 block. By Default it is enabled after RESET.

	LPC_UART0->LCR = 3 | DLAB_BIT ; /* 8 bits, no Parity, 1 Stop bit & DLAB set to 1  */
	LPC_UART0->DLL = 12;
	LPC_UART0->DLM = 0;
	
	//LPC_UART0->IER |= ..; //Edit this if want you to use UART interrupts
	LPC_UART0->FCR |= Ux_FIFO_EN | Rx_FIFO_RST | Tx_FIFO_RST;
	LPC_UART0->FDR = (MULVAL<<4) | DIVADDVAL; /* MULVAL=15(bits - 7:4) , DIVADDVAL=2(bits - 3:0)  */
	LPC_UART0->LCR &= ~(DLAB_BIT);
	//Now since we have applied DLL and DLM we now lock or freeze those valuse by diabling DLAB i.e DLAB=0 
	//Baud= ~115200(114882). Now we can perform UART communication!
}

Once this is done you are now ready to transfer data using U0RBR and U0THR registers.

Connections between MCU and PC or Laptop

Here we can have 2 possible scenarios.

1. Your PC/Laptop(older ones) already has a serial port. In this case you will need a RS232 to TTL converter.
2. Your PC/Laptop doesn’t have a serial port and you are using USB to Serial converter(FTDI ones, etc..).

Please refer to the connection diagrams & terminal software configuration(and COM ports) as given in Basic Uart Tutorial.

Here is a configuration screenshot for terminal software PuTTYtel which we will be using for examples :

Note: You can get PuTTYtel from Here. Direct download link: Here. You can also use other similar terminal software as well.

LPC1768 UART Programming Examples

Now its time to actually use UART in real life! Lets do some communication between your LPC1768(or similar MCU like LPC1769) MCU and PC/Laptop. Before we get into actual examples for LPC1768, first lets define 2 functions which will be used to Read and Write Data from UART block. The code is based on CMSIS which is the Base library for ARM Cortex Micrcontrollers.

U0Read() – Read Data from UART0:

#define RDR (1<<0) //Receiver Data Ready
char U0Read(void)
{
	while(!(LPC_UART0->LSR & RDR)); //wait until any data arrives in Rx FIFO
	return LPC_UART0->RBR; 
}

U0Write() – Write Data to UART0:

#define THRE (1<<5) //Transmit Holding Register Empty
void U0Write(char data)
{
	while(!(LPC_UART0->LSR & THRE)); //wait till the THR is empty
	//now we can write to the Tx FIFO
	LPC_UART0->THR = data;
}

LPC1768 UART Example 1

This demo will print “Hello from LPC1768!” on a new line in Serial Terminal repeatedly. The code given below uses Carriage-Return + Line-Feed (i.e. CR+LF) as New-Line(Enter or “\n”) character. If you are using Terminal on Linux or MacOS to interfacing LPC176x then only use Line-Feed(LF) character for New-Line.

/*(C) Umang Gajera - www.ocfreaks.com
More Embedded tutorials @ www.ocfreaks.com/cat/embedded
LPC1768 Basic UART Example 1 Source Code.
License : GPL.*/

#include <lpc17xx.h>

#define THRE        (1<<5) //Transmit Holding Register Empty
#define MULVAL      15
#define DIVADDVAL   2
#define Ux_FIFO_EN  (1<<0)
#define Rx_FIFO_RST (1<<1)
#define Tx_FIFO_RST (1<<2)
#define DLAB_BIT    (1<<7)
#define LINE_FEED   0x0A //LF, For Linux, MAC and Windows Terminals  
#define CARRIAGE_RETURN 0x0D //CR, For Windows Terminals (CR+LF).

void initUART0(void);
void U0Write(char data);

int main(void)
{
	//SystemInit(); //This already gets called by CMSIS Startup Code.
	char msg[] = { 'H','e','l','l','o',' ','f','r','o','m',' ','L','P','C','1','7','6','8','\0' }; 
	int count=0;
	 
	initUART0();
	
	while(1)	
	{
		while( msg[count]!='\0' )
		{
			U0Write(msg[count]);
			count++;
		}
		//Send NEW Line Character(s) i.e. "\n"
		U0Write(CARRIAGE_RETURN); //Comment this for Linux or MacOS
		U0Write(LINE_FEED); //Windows uses CR+LF for newline.
		count=0; // reset counter		
	}
	//return 0; //This won't execute normally
}

void U0Write(char txData)
{
	while(!(LPC_UART0->LSR & THRE)); //wait until THR is empty
	//now we can write to Tx FIFO
	LPC_UART0->THR = txData;
}

void initUART0(void)
{
	/*Assuming CCLK = 100Mhz and PCLK = 25Mhz!*/
	LPC_PINCON->PINSEL0 |= (1<<4) | (1<<6); //Select TXD0 and RXD0 function for P0.2 & P0.3!
	//LPC_SC->PCONP |= 1<<3; //Power up UART0 block. By Default it is enabled after RESET.

	LPC_UART0->LCR = 3 | DLAB_BIT ; /* 8 bits, no Parity, 1 Stop bit & DLAB set to 1  */
	LPC_UART0->DLL = 12;
	LPC_UART0->DLM = 0;
	
	//LPC_UART0->IER |= ..; //Edit this if want you to use UART interrupts
	LPC_UART0->FCR |= Ux_FIFO_EN | Rx_FIFO_RST | Tx_FIFO_RST;
	LPC_UART0->FDR = (MULVAL<<4) | DIVADDVAL; /* MULVAL=15(bits - 7:4) , DIVADDVAL=2(bits - 3:0)  */
	LPC_UART0->LCR &= ~(DLAB_BIT);
	//Now since we have applied DLL and DLM we now lock or freeze those valuse by diabling DLAB i.e DLAB=0 
	//Baud= ~115200(114882). Now we can perform UART communication!
}

LPC1768 UART Example 2

In this example you will see the characters that you type on your keyboard i.e. we echo back the characters(data) received by MCU. Serial Terminals only displays the character that it receives via serial Port. When you type a character it is directly sent to the other side via serial port. Hence, in order for us to see the character which we typed, we need to send back the same character. This is what the program below does. Whenever MCU receives a character from the RXD0 pin, it will send the same character back to PC via the TXD0 Pin and it gets displayed in Terminal.

Here is a snippet of Example 2: (Full source code given is in KEIL ARM project files – attached below)

/*(C) Umang Gajera - www.ocfreaks.com
More Embedded tutorials @ www.ocfreaks.com/cat/embedded/
LPC1768 Basic UART Example 2 Source Code.
License: GPL.*/

#include <lpc17xx.h>

#define RDR         (1<<0) //Receiver Data Ready
#define THRE        (1<<5) //Transmit Holding Register Empty
#define MULVAL      15
#define DIVADDVAL   2
#define Ux_FIFO_EN  (1<<0)
#define Rx_FIFO_RST (1<<1)
#define Tx_FIFO_RST (1<<2)
#define DLAB_BIT    (1<<7)
#define LINE_FEED   0x0A //LF, For Linux, MAC and Windows Terminals  
#define CARRIAGE_RETURN 0x0D //CR, For Windows Terminals (CR+LF).
#define ENTER       CARRIAGE_RETURN //Ascii value/code for Enter is 0x0D i.e. CR

void initUART0(void);
char U0Read(void);
void U0Write(char data);

int main(void)
{
	initUART0();
	char data = 0;
	
	while(1)		
	{
		data = U0Read(); //Read Data from Rx
		if(data == ENTER) //Check if user pressed Enter key
		{
			//Send NEW Line Character(s) i.e. "\n"
			U0Write(CARRIAGE_RETURN); //Comment this for Linux or MacOS
			U0Write(LINE_FEED); //Windows uses CR+LF for newline.
		}
		else
		{
			U0Write(data); //Tx Read Data back
		}
	}
	//return 0; //Normally this won't execute
}

char U0Read(void)
{
	while(!(LPC_UART0->LSR & RDR)); //wait until data arrives in Rx FIFO
	return LPC_UART0->RBR;
}