Interfacing LCD and Matrix Keypad with ARM LPC2138

Interfacing LCD with ARM

16×2 LCD is widely used in various embedded applications. The reason for this is its easy operation and it can display a large number of characters and symbols. In this tutorial we’ll interface LCD with ARM7 based microcontroller LPC2138.

LCD can be interfaced in 8-bit as well as 4-bit mode (mode signifies Data bits sent at a time). In the 8-bit mode we require 8-pins of the microcontroller whereas in 4-bit mode the data is sent ‘nibble’ by ‘nibble’ (4 data lines used).

Description

Fig. 1: Image showing pin configuration of 16X2 Character LCD

16×2 alphanumeric LCD can display 16 characters in each of its row, and it has two rows. To interface an LCD we need to know about its internal registers and pin functions.

An LCD has two important registers namely command register and Data register. Both are 8-bit registers. The command register is written with various commands by the user. These commands are responsible for the functioning of LCD.

The data register is loaded with the ASCII value of the Data (Character/Number, etc.) to be displayed.

Both the registers are accessed through 8-bit Data Line (D0-D7). There is one selection line provided, namely R/S Pin, in LCD Module which selects between these two registers.

R/S=0-> Command Register

R/S=1-> Data Register

Apart from R/S, there are other two Pins, viz. R/W and EN.

EN pin is to enable (1) or to disable (0) the LCD.

R/W is used to select the operation ‘Read from LCD’ or ‘Write to LCD’. Logic 0 at R/W stands for Write operation and 1 for Read operation.

Apart from these pins, the last two Pins (15 & 16) on the LCD are for Backlight. And pins 1,2,3 are for GND, +VCC and +VEE(contrast adjustment) respectively.

There are various commands that need to be send to LCD so as to Initialize it, to make it work accordingly. These command are listed below.

Screenshot of LCD commands from its datasheet

Fig. 2: Screenshot of LCD commands from its datasheet

Apart from these there are two more important commands.

(0x8m)à value of m (in hex) determines the position of character to be displayed in first line.

For e.g. (0x80)-> place display pointer at 1^st line 1^st position

(0x8a)-> place display pointer at 1^st line 10^th position

Similarly for displaying at various positions in Second line of LCD, we use the commandà (0xcm), again m (in hex) determines the position of character to be displayed in second line.

In this tutorial of ARM, the Data lines of the LCD are connected at Port 0 (P0.0 to P0.7) and Control lines (r/s, r/w, en) at P0.8 to P0.10 of the LPC2138.

An important concept behind getting a logic state on a particular pin, without altering logic state of other pins, is ANDing and ORing. Here in LCD interfacing it is of much use, so let us get familiar with it.

Let us say we want ‘1’ at pin P0.4. This has a simple syntax,

IOPIN0= (1<<4)

But the problem with this is, it alters the logic state of other pins. To overcome this problem we introduce OR condition, as below;

IOPIN0|= (1<<4)

This means;

IOPIN0 = IOPIN0 + (1<<4)

Similarly, for a low logic state we use AND-operation,

e.g. to make P0.6 = low, we write,

IOPIN0& = ~ (1<<6)

Which means, IOPIN0 = IOPIN0 x (0<<6)

This makes P0.6=0, leaving states of other pins unchanged.

Now let’s come back to 16×2 LCD interfacing which has got three control lines (viz. r/s, r/w, en ) that need to be controlled individually.

However in this code we’ll use IOSET and IOCLR for the sake of simplicity.

Explanation of the code:

The functions cmd() , data() and str() are purposefully for sending command, data and string to LCD.

To latch a command to LCD, rs=0(command register); r/w=0; en=1

Similarly to latch data, rs=1(data register); r/w=0; en=1;

To display string, each of its character is extracted through str() function and is latched one byte at a time (at fast rate, so it appears to be continuous).

Scrolling Text and Interfacing Keypad

Scrolling Text on LCD

For scrolling text on LCD there are commands, provided in the LCD datasheet.

For scrolling a character from right to left by one position, we give write commandà (0x18)

For scrolling a character from left to right by one position, we give write commandà (0x1c)

Now to shift by ‘n’ positions we run a loop n-times shifting by one place at each iteration of the loop.

Suppose, we display the character at 8^th position of line-1, and we need to shift it by 5 positions to left.

The code snippet for above task can be:

lcd_command (0x88); //place cursor at 8^th position of line-1

lcd_data (‘D’); // display D

for (i=0;i<5;i++) // shift displayed char. By 5 positions

{

lcd_command(0x18);

}

Similarly to shift the displayed character or string to right, we write command à (0x1c) in the command register of LCD.

In the example, our string was “Hello World..This is LCD”.

To display all its characters, we need to shift the display left by 8 positions.

Hence the loop for this will be as:

lcd_string(“Hello World..This is LCD”)

for (i=0;i<8;i++) // shift displayed char. By 8 positions

{

lcd_command(0x18);

}

Explanation of the code:

· The functions cmd (), data () and str () are purposefully for sending command, data and string to LCD.

· To latch a command to LCD, rs=0 (command register); r/w=0; en=1

· Similarly to latch data, rs=1 (data register); r/w=0; en=1;

· To display string, each of its character is extracted through str() function and is latched one byte at a time (at fast rate, so it appears to be continuous).

· For scrolling, the count value given is purposefully 39. It is because the string length is 23, and we want to shift entire display by 16 positions. So, first 23 characters shifted and then extra 16 shifts to get a blank LCD.

Interfacing Matrix Keypad with ARM

In the circuit we’ve interfaced LCD at port-0 of the LPC2138. The data lines from P0.0 to P0.7; and control lines at P0.8 to P0.10.

In the keypad connections, rows connected to P1.16 to P1.19; and the columns at P1.20 to P1.22.

Please note that, rows will be configured as output from controller, and columns as input to controller.

Details of Code:

· IOSET and IOCLR are used to make the logic states of pins as 0 or 1.

· IODIR is used to configure port as input/output.

· Functions init(), cmd(), data(), str(), and delay are purposefully for LCD initialization, LCD command, LCD Data, LCD String and Delay respectively.

· The crystal used in the hardware is 14.768 MHz, and so the delay is according to that. However delay value can be set accordingly as per need.

Here I have used individual ports for LCD and Keypad (P0àLCD; P1àKeypad). However they can be interfaced on a single port also.

Circuit Images

Fig. 3: Image showing message displayed on LCD from LPC2138

Fig. 4: Image showing circuit connections of character LCD and LPC2138

Fig. 5: Image showing scrolling of message on LCD interfaced to LPC2138

Project Source Code

###

***************Code for Interfacing LCD***************  #include<lpc21xx.h>				 // header file for lpc devices
	
void delay(unsigned int t);		  	// delay function
void init(void);
void cmd(unsigned char cd); // lcd command function
void data(unsigned char dt); // lcd data function
void str(unsigned char *str); // lcd string function
int main(void)
{
IODIR0=0X00000fff; // P0.0 to P0.11 selected as o/p pins
init(); // lcd initialization
cmd(0x80); // row 1 selected
str("LCD interfacing"); // display string 1
delay(10);
cmd(0xc0); // row 2 selected
str("with LPC2138");
delay(10);
while(1);
return 0;
}
void init()
{
cmd(0x01); //call 0x01 command to clear display
delay(50); //wait for completion of clear display command
cmd(0x38); //command for 16 character and 2 line display
delay(10); //wait for completion of command
cmd(0x0C); //turn ON display, cursor OFF, cursor blinking OFF
delay(10); //wait for completion of command
cmd(0x06); //increment cursor after each write,
delay(10); //wait for completion of command
}
void cmd(unsigned char cd)
{
IOCLR0=(1<<10); // en=0
IOPIN0=cd; // Latch Command DATA on P0.0 to P0.7
IOCLR0=(1<<8); // r/s=0
IOCLR0=(1<<9); // r/w=0 (write operation)
IOSET0=(1<<10); // en=1 (lcd enable)
delay(1);
IOCLR0=(1<<10); // en=0 (lcd disable)
}
void data(unsigned char dt)
{
IOCLR0=(1<<10); // en=0
IOPIN0=dt; // Latch Command DATA on P0.0 to P0.7
IOSET0=(1<<8); // r/s=0
IOCLR0=(1<<9); // r/w=0 (write operation)
IOSET0=(1<<10); // en=1 (lcd enable)
delay(1);
IOCLR0=(1<<10); // en=0 (lcd disable)
}
void str(unsigned char *str)
{
unsigned int i=0;
while(str[i]!='') // Loop untill NULL chsr
{
data(str[i]);
delay(10);
i++;
}
}
void delay(unsigned int t) // Delay definition
{
unsigned int j,k;
for(j=0;j<t;j++)
for(k=0;k<11200;k++);
}

***************Code for Scrolling LCD***************

#include<lpc213x.h> // header file for lpc devices
void delay(unsigned int t); // delay function
void init(void);
void cmd(unsigned char cd); // lcd command function
void data(unsigned char dt); // lcd data function
void str(unsigned char *str); // lcd string function
unsigned int count=0;
int main()
{
IODIR0=0X00000fff; // P0.0 to P0.11 selected as o/p pins
init(); // lcd initialization
cmd(0x8f);
str(" LCD text scrolling...."); // diaplay string 1
delay(200);
cmd(0xcf); // row 2 selected
str(" with ARM LPC2138 ");
delay(200);
while(1)
{

for(count=0;count<39;count++)
{
cmd(0x1c); // command to shift display left by one position
delay(300);
}
for(count=0;count<39;count++)
{
cmd(0x18); // command to shift the display right by one position
delay(300);
}

}

return 0;
}
void delay(unsigned int t) // Delay definition
{
unsigned int j,k;
for(j=0;j<t;j++)
for(k=0;k<10000;k++);
}
void init()
{
cmd(0x01); //call 0x01 command to clear display
delay(100); //wait for completion of clear display command
cmd(0x38); //command for 16 character and 2 line display
delay(100); //wait for completion of command
cmd(0x0C); //turn ON display, cursor OFF, cursor blinking OFF
delay(50); //wait for completion of command
cmd(0x06); //increment cursor after each write,
delay(50); //wait for completion of command
cmd(0x80); //call command 0x80 to place cursor at first position of first line,
delay(50);
}
void cmd(unsigned char cd)
{

IOPIN0=cd; // Latch Command DATA on P0.0 to P0.7
IOCLR0=(1<<8); // r/s=0
IOCLR0=(1<<9); // r/w=0 (write operation)
IOSET0=(1<<10); // en=1 (lcd enable)
delay(1);
IOCLR0=(1<<10); // en=0 (lcd disable)
}
void data(unsigned char dt)
{

IOPIN0=dt; // Latch Command DATA on P0.0 to P0.7
IOSET0=(1<<8); // r/s=0
IOCLR0=(1<<9); // r/w=0 (write operation)
IOSET0=(1<<10); // en=1 (lcd enable)
delay(1);
IOCLR0=(1<<10); // en=0 (lcd disable)
}
void str(unsigned char *str)
{
unsigned int i=0;
while(str[i]!='') // Loop untill NULL chsr
{
data(str[i]);
delay(10);
i++;
}
}
***************Code for Matrix Keypad*************** Code
#include<lpc213x.h> // header file
void delay(unsigned int);
void init(void); // funtion to initialize LCD
void cmd(unsigned char ch); // LCD command function
void data(unsigned char dt); // LCD data function
void str(unsigned char *str); // LCD string function
int main()
{

IODIR0=0x00007fff;
IODIR1=0x0E0F0000; //P0.16 to P0.19 as output; P0.20 to P0.22 as inputs

cmd(0x80);
init();
str("LCD and Keypad");
delay(30);
cmd(0xc0);
str("with ARM LPC2138");
delay(300);
cmd(0x01);
cmd(0x80);
str(" by Deepesh ");
delay(300);
cmd(0x01);
delay(50);

while(1)
{

cmd(0xc0);
str("U pressed: ");
delay(100);

//scanning for key pressed
IOCLR1=(1<<16);
IOSET1=(1<<17);
IOSET1=(1<<18);
IOSET1=(1<<19);

if(((IOPIN1)&(1<<20))!=(1<<20))
{data('1');}
else if(((IOPIN1)&(1<<21))!=(1<<21))
{data('2');}
else if(((IOPIN1)&(1<<22))!=(1<<22))
{data('3');}

IOSET1=(1<<16);
IOCLR1=(1<<17);
IOSET1=(1<<18);
IOSET1=(1<<19);

if(((IOPIN1)&(1<<20))!=(1<<20))
{data('4');}
else if(((IOPIN1)&(1<<21))!=(1<<21))
{data('5');}
else if(((IOPIN1)&(1<<22))!=(1<<22))
{data('6');}

IOSET1=(1<<16);
IOSET1=(1<<17);
IOCLR1=(1<<18);
IOSET1=(1<<19);

if(((IOPIN1)&(1<<20))!=(1<<20))
{data('7');}
else if(((IOPIN1)&(1<<21))!=(1<<21))
{data('8');}
else if(((IOPIN1)&(1<<22))!=(1<<22))
{data('9');}
IOSET1=(1<<16);
IOSET1=(1<<17);
IOSET1=(1<<18);
IOCLR1=(1<<19);

if(((IOPIN1)&(1<<20))!=(1<<20))
{data('*');}
else if(((IOPIN1)&(1<<21))!=(1<<21))
{data('0');}
else if(((IOPIN1)&(1<<22))!=(1<<22))
{data('#');}


}
return 0;
}
void delay(unsigned int t) // Delay definition
{
unsigned int j,k;
for(j=0;j<t;j++)
for(k=0;k<10000;k++);
}
void init()
{
cmd(0x01); //call 0x01 command to clear display
delay(50); //wait for completion of clear display command
cmd(0x38); //command for 16 character and 2 line display
delay(10); //wait for completion of command
cmd(0x0C); //turn ON display, cursor OFF, cursor blinking OFF
delay(5); //wait for completion of command
cmd(0x06); //increment cursor after each write,
delay(5); //wait for completion of command
cmd(0x80); //call command 0x80 to place cursor at first position of first line,
delay(5);
}
void cmd(unsigned char cd)
{
IOCLR0=(1<<10); // en=0
IOPIN0=cd; // Latch Command DATA on P0.0 to P0.7
IOCLR0=(1<<8); // r/s=0
IOCLR0=(1<<9); // r/w=0 (write operation)
IOSET0=(1<<10); // en=1 (lcd enable)
delay(10);
IOCLR0=(1<<10); // en=0 (lcd disable)
}
void data(unsigned char dt)
{
IOCLR0=(1<<10); // en=0
IOPIN0=dt; // Latch Command DATA on P0.0 to P0.7
IOSET0=(1<<8); // r/s=0
IOCLR0=(1<<9); // r/w=0 (write operation)
IOSET0=(1<<10); // en=1 (lcd enable)
delay(10);
IOCLR0=(1<<10); // en=0 (lcd disable)
}
void str(unsigned char *str)
{
unsigned int i=0;
while(str[i]!='') // Loop untill NULL character
{
data(str[i]);
i++;
delay(10);
}
}

 
###