A1.

8051 Interfacing:LCD 16x2

Introduction:LCD
Liquid Crystal Display(LCDs) provide a cost effective way to put a text output unit for a microcontroller. As
we have seen in the previous tutorial, LEDs or 7 Segments do no have the flexibility to display informative
messages. This display has 2 lines and can display 16 characters on each line. Nonetheless, when it is
interfaced with the microcontroller, we can scroll the messages with software to display information which is
more than 16 characters in length.

LCD Internal Controller

Fig 1: LCD Block diagram

The LCD is a simple device to use but the internal details are complex. Most of the 16x2 LCDs use a Hitachi
HD44780 or a compatible controller. Yes, a micrcontroller is present inside a Liquid crystal display as shown
in figure 1.

The Display Controller takes commands and data from a external microcontroller and drivers the LCD
panel(LCDP). It takes a ASCII value as input and generate a patter for the dot matrix. E.g., to display letter 'A',
it takes its value 0X42(hex) or 66(dec) decodes it into a dot matrix of 5x7 as shown in figure 2.

Basic Commands
The LCD controller uses RS and RW lines along with E to operate the LCD.

Resister Select (RS): Determines weather a command(RS = 0) is sent (to set

up the display) or actual data(RS=1) is sent.

Read/Write RW=0; writes to the LCD. RW=1;Reads from the LCD.

The commonly used instructions are shown in the instruction set below. Observe the Bit names: I/D, S, D,
C etc at the bottom of instruction set to decode the instructions completely.

Clear Display

Cursor Home

Set Entry Mode

Display on/off control

Cursor/display shift

Function Set

Read Busy Flag

Data Read

Data Write

Instruction Set
HD44780U based instruction set
Code
Instruction

R R/ B B B B B
S W 7 6 5 4 3

Clear display 0

Cursor home 0

Entry mode
set

Display
on/off
control

Description

0 0 0 0

0 0 0 0

0 0 0 0

B B B
2 1 0

0 1

Clears display and returns cursor to the

home position (address 0).

Returns cursor to home position. Also

returns display being shifted to the
original position. DDRAM content
*
remains unchanged.

Sets cursor move direction (I/D);

specifies to shift the display (S). These
operations are performed during data
I/
S
read/write.
D

Sets on/off of all display (D), cursor

on/off (C), and blink of cursor position
C B character (B).

0 0 0 0

Cursor/displa 0
y shift

0 0 0 1 S/ R/ *
C L

* Sets cursor-move or display-shift (S/C),

shift direction (R/L). DDRAM content

remains unchanged.

Function set

D
0 0 1
N
L

Sets interface data length (DL), number

* of display line (N), and character font
(F).

Reads busy flag (BF) indicating internal

operation being performed and reads
CGRAM or DDRAM address counter
contents (depending on previous
instruction).

Read busy
flag &
address
counter

Write
CGRAM or
DDRAM

Write Data

Write data to CGRAM or DDRAM.

Write
CGRAM or
DDRAM

Write Data

Write data to CGRAM or DDRAM.

B
F

CGRAM/DDRAM
address

Instruction bit names

I/D - 0 = decrement cursor position, 1 = increment cursor position;

S - 0 = no display shift, 1 = display shift;
D - 0 = display off, 1 = display on;
C - 0 = cursor off, 1 = cursor on;
B - 0 = cursor blink off, 1 = cursor blink on ;
S/C - 0 = move cursor, 1 = shift display;
R/L - 0 = shift left, 1 = shift right;
DL - 0 = 4-bit interface, 1 = 8-bit interface;
N - 0 = 1/8 or 1/11 duty (1 line), 1 = 1/16 duty (2 lines);
F - 0 = 58 dots, 1 = 510 dots;
BF - 0 = can accept instruction, 1 = internal operation in progress.

LCD UNIT
4

Let us look at a pin diagram of a commercially available LCD like JHD162 which uses
a HD44780 controller and then describe its operation.

All the pins are identically to the lcd internal controller discussed above

PIN NUMBER

FUNCTION

Ground

VCC

Contrast adjustment (VO)

Register Select (RS). RS=0: Command, RS=1: Data

Read/Write (R/W). R/W=0: Write, R/W=1: Read

Clock (Enable). Falling edge triggered

Bit 0 (Not used in 4-bit operation)

Bit 1 (Not used in 4-bit operation)

Bit 2 (Not used in 4-bit operation)

10

Bit 3 (Not used in 4-bit operation)

11

Bit 4

12

Bit 5

13

Bit 6

14

Bit 7

15

Back-light Anode(+)

16

Back-Light Cathode(-)

Interfacing LCD with 8051

LCD can be interfaced with the 8051 micrcontroller in two modes, 8 bit and 4 bit. Let us
Interface it in 8 bit mode first.

8 bit Mode

Objective

fig LCD display

There is lot of stuff that can be done with the LCDs, to start with we will simple display a couple of strings on
the 2 lines of the LCD as shown in the image.

Schematic Discription

Data Lines: In this mode, all of the 8 datalines DB0 to DB7 are connected from
the microcontroller to a LCD module as shown the schematic.

Control Lines:' The RS, RW and E are control lines, as discussed earlier.

Power & contrast:Apart from that the LCD should be powered with 5V
between PIN 2(VCC) and PIN 1(gnd). PIN 3 is the contrast pin and is output of
center terminal of potentiometer(voltage divider) which varies voltage between 0
to 5v to vary the contrast.

Back-light: The PIN 15 and 16 are used as backlight. The led backlight can be
powered through a simple current limiting resistor as we do with normal leds.

Schematic

Code
As with all the interfaces to simplify thing we have separated code into two files, main.c and lcd_8_bit.c. You
may go through the tools setup tutorial on configuring the code.
The main.c is very simple it includes the standard library files. Then it uses several functions from the
lcd_8_bit.c file to set up and display messages. As you can see, it makes things very simple when the libraries
are well written. We will discuss the implementation while discussing the lcd_8_bit.c file.

The main file main.c

/* Reg51.h contains the defnition of all ports and SFRs */
#include <reg51.h>
#include "lcd.h"
//Xplore labz LCD library
#include "delay.h" //Xplore Labz Delay library
/* start the main program */
void main()
{
/* Initilize the lcd before displaying any thing on the lcd */
LCD_Init();
/* Display "hello, world" on first line*/
LCD_DisplayString("hello, world");
/*Go to second line and display "good morning" */
LCD_GoToLineTwo();
LCD_DisplayString("good morning");
while(1);
}

lcd_8_bit.c: 8 bit lcd library file

The lcd_8_bit.c consists of various functions that are required to initialize and use the
LCD. Let us look at few important lines and functions. Specifying the Connections:
The connections described in the schematic are specified with following lines of code.
#define databus
sbit rs= P0^0;
sbit rw= P0^1;
sbit en= P0^2;

P2
// LCD databus connected to PORT2
// Register select pin connected to P0.0
// Read Write pin connected to P0.1
// Enable pin connected to P0.2

Let us look at three important functons in lcd_8_bit.c

1. void LCD_CmdWrite( char cmd)
Commands are required to sent to lcd in order to set it up or initialize. The timing diagrams for command write

are shown in the figure,

step1: Send the I/P command to LCD.

step2: Select the Control Register by making RS low.

step3: Select Write operation making RW low.

step4: Send a High-to-Low pulse on Enable PIN with some delay_us.

void LCD_CmdWrite( char cmd)

{
databus=cmd;
// Send the command to LCD
rs=0;
// Select the Command Register by pulling RS LOW
rw=0;
// Select the Write Operation by pulling RW LOW
en=1;
// Send a High-to-Low Pusle at Enable Pin
delay_us(10);
en=0;
delay_ms(1);
}

10

2. void LCD_DataWrite( char dat) This function sends a character to be displayed on LCD in the following
steps.

step1: Send the character to LCD.

step2: Select the Data Register by making RS high.

step3: Select Write operation making RW low.

step4: Send a High-to-Low pulse on Enable PIN with some delay_us.

The timings are similar as above only change is that RS is made high.
void LCD_DataWrite( char dat)
{
databus=dat;
// Send the data to LCD
rs=1;
// Select the Data Register by pulling RS HIGH
rw=0;
// Select the Write Operation by pulling RW LOW
en=1;
// Send a High-to-Low Pusle at Enable Pin
delay_us(10);
en=0;
delay_ms(1);
}
3. void LCD_Init()
Looking at the instruction set of the LCD controller, we can initialize the LCD with following steps

Set the display mode as 2 lines, 5 x 7 matrix

Turn On the dislay, and cursor.

Clear the LCD

Get the cursor to first line first position.

The code is listed below.

void LCD_Init()
{
delay_us(5000);
LCD_CmdWrite(0x38);
LCD_CmdWrite(0x0E);
LCD_CmdWrite(0x01);
LCD_CmdWrite(0x80);

// LCD
//
//
//

2lines, 5*7 matrix

Display ON cursor ON Blinking off
Clear the LCD
Cursor to First line First Position

11

The remaining code is listed below. You could observe that the basic functions to read
data and write write command are used extensively and entire library is built upon
them. There are also other functions that are used to display number etc in the lcd
library file.
#include<reg51.h> #include "delay.h" #include "lcd.h" #define databus P2 // LCD
databus connected to PORT2 sbit rs= P0^0; // Register select pin connected to P0.0
sbit rw= P0^1; // Read Write pin connected to P0.1 sbit en= P0^2; // Enable pin
connected to P0.2
/* 16x2 LCD Specification */ #define LCDMaxLines 2 #define
LCDMaxChars 16 #define LineOne 0x80 #define LineTwo 0xc0 #define BlankSpace ' '
void LCD_Init() { delay_us(5000); LCD_CmdWrite(0x38); // LCD 2lines, 5*7 matrix
LCD_CmdWrite(0x0E); // Display ON cursor ON Blinking off LCD_CmdWrite(0x01); // Clear
the LCD LCD_CmdWrite(0x80); // Cursor to First line First Position }
void
LCD_CmdWrite( char cmd) { databus=cmd; // Send the command to LCD rs=0; // Select
Command Register by pulling RS LOW rw=0; // Select Write Operation by pulling RW
LOW en=1; // Send a High-to-Low Pusle at Enable Pin delay_us(10); en=0;
delay_ms(1); }
void LCD_DataWrite( char dat) { databus=dat; // Send the data to
LCD rs=1; // Select the Data Register by pulling RS HIGH rw=0; // Select the Write
Operation by pulling RW LOW en=1; // Send a High-to-Low Pusle at Enable Pin
delay_us(10); en=0; delay_ms(1); } void LCD_GoToXY(char row, char col) { char pos;
if(row<LCDMaxLines) { pos= LineOne | (row << 6); // take the line number //row0>pos=0x80 row1->pos=0xc0 if(col<LCDMaxChars) pos= pos+col; //take the char
number //now pos points to XY pos LCD_CmdWrite(pos) } }
void
LCD_DisplayString(char *string_ptr) { while(*string_ptr) LCD_DataWrite(*string_ptr+
+); }

4 bit Mode

Schematic
There are following differences in 4 bit mode.

Only data lines D4 to D7 are used as shown in the schematic below.

In code, we need to send the command to select 4 bit mode as shown in the
instruction set above.

12

The main program remains exactly as in 8 bit mode, we simply include the lcd_4_bit.c to work in 4 bit mode.
The important and required code is listed below,

Code
#include<reg51.h> #include "delay.h" #include "lcd.h" #define databus P0 //LCD
databus connected to PORT0 sbit rs= databus^0; // Register select pin connected to
P0.0 sbit rw= databus^1; // Read Write pin connected to P0.1 sbit en= databus^2; //
Enable pin connected to P0.2 /* 16x2 LCD Specification */ #define LCDMaxLines 2
#define LCDMaxChars 16 #define LineOne 0x80 #define LineTwo 0xc0 #define
BlankSpace ' ' void LCD_Init() { delay_us(5000); LCD_CmdWrite(0x02); //Initilize the LCD

13

in 4bit Mode LCD_CmdWrite(0x28); LCD_CmdWrite(0x0E); // Display ON cursor ON

LCD_CmdWrite(0x01); // Clear the LCD LCD_CmdWrite(0x80); // Cursor to First line First
Position }
void LCD_CmdWrite( char cmd) { databus=(cmd & 0xf0); // Send the
Higher Nibble rs=0; // Select the Command Register by pulling RS LOW rw=0; // Select
the Write Operation by pulling RW LOW en=1; // Send a High-to-Low Pusle at Enable Pin
delay_us(1); en=0; delay_us(10); // wait for some time databus=((cmd<<4) &
0xf0); // Send the Lower Nibble rs=0; // Select the Command Register by pulling RS LOW
rw=0; // Select the Write Operation by pulling RW LOW en=1; // Send a High-to-Low
Pusle at Enable Pin delay_us(1); en=0; delay_ms(1); }
void LCD_DataWrite( char
dat) { databus=(dat & 0xf0); // Send the Higher Nibble rs=1; // Select the Data Register
by pulling RS HIGH rw=0; // Select the Write Operation by pulling RW LOW en=1; // Send
a High-to-Low Pusle at Enable Pin delay_us(1); en=0; delay_us(10); // wait for some
time. databus=((dat <<4) & 0xf0); // Send the Lower Nibble rs=1; // Select the Data
Register by pulling RS HIGH rw=0; // Select the Write Operation by pulling RW LOW
en=1; // Send a High-to-Low Pusle at Enable Pin delay_us(1); en=0; delay_ms(1); }
void LCD_DisplayString(char *string_ptr) { while(*string_ptr)
LCD_DataWrite(*string_ptr++); } void LCD_GoToLineTwo() { LCD_CmdWrite(LineTwo); //
Move the Cursor to Second line }

Downloads
"The code is given for 4 and 8 bit modes with and without busy Flag"
8051_LCD_Tutorial_Code.zip

14