8051 Interfacing

LCD AND KEYBOARD

INTERFACING
LCD Operation
LCD is finding widespread use replacing
LEDs
◦ The declining prices of LCD
◦ The ability to display numbers, characters,
and graphics
◦ Incorporation of a refreshing controller into
the LCD
 Relieving the CPU of the task of refreshing the
LCD
◦ Ease of programming for characters and
graphics
LCD PIN Descriptions
The function of each pin is given in the previous slide
Vcc, Vss, VEE
While Vcc and Vss provide +5v and ground respectively, VEE is used for controlling LCD
contrast
RS, register select
Two very important registers inside the LCD. The RS pin is used for their selection as follows
IF RS=0, the instruction command code register is selected, allowing the user to send a
command such as clear display, cursor at home etc
IF RS=1, the data register is selected, allowing the user to send data to be displayed on the
LCD.
R/W, read/write
R/W input allows the user to write information to the LCD or read information from it.
R/W=1, when reading; R/W=0 when writing.
E, enable
The enable pin is used by the LCD to latch information presented to the data pins.
LCD PIN Descriptions
The function of each pin is given in the previous slide
D0 – D7
The 8-bit data pins, D0-D7 are used to send information to the LCD or read the contents of the
LCD’s internal registers.
To display letters and numbers, send ASCII codes for the letters A-Z, a-z and numbers 0-9 to
these pins while making RS=1.
There are also instruction command codes that can be sent to the LCD to clear the display or
force the cursor to the home position or blink the cursor.
RS=0, to check the busy flag bit to see if LCD is ready to receive information.
The busy flag is D7 and can be read when R/W =1 and RS=0, as follows:
IF R/W=1, RS=0. When D7 = 1(busy flag=1), the LCD is busy taking care of internal
operations and will not accept any new information.
When D7=0, the LCD is ready to receive new information.
(It is recommended to check the busy flag before writing any data to the LCD)
LCD Read/Write
To read the command register we make R/W=1 and RS=0 and a Low to High Pulse for the E
pin will provide us the command register.
After reading the command register, if bit D7 (the busy flag) is high, the LCD is busy and no
information (command or data) should be issued to it.
Only when D7=0 can we send data or commands to the LCD. Notice in this method that no
time delays are used since we are checking the busy flag before issuing commands or data to
the LCD.
Contrast the Read and Write timing
Note that the E line is negative-edge triggered for the write while it is positive-edge triggered
for the read.
LCD Data Sheet
One can put data at any location in the
LCD
◦ The following shows address locations and
how they are accessed
 AAAAAAA=000_0000 to 010_0111 for line1
 AAAAAAA=100_0000 to 110_0111 for line2
 The upper address range can go as high as 0100111 for the
40-character-wide LCD
 Corresponds to locations 0 to 39
Keyboard Interfacing
Keyboards are organized in a matrix of
rows and columns
◦ The CPU accesses both rows and columns
through ports
 With two 8-bit ports, an 8 x 8 matrix of keys can be
connected to a microprocessor
 When a key is pressed, a row and a column make a
contact
 Otherwise, there is no connection between rows and
columns
◦ In IBM PC keyboards, a microcontroller takes
care of hardware and software interfacing
Keyboard Interfacing (cont.)
A 4x4 matrix connected to two ports
◦ The rows are connected to an output port
◦ The columns are connected to an input port
 If no key has been pressed, reading the input port
will yield 1s for all columns
 Since they are all connected to high (Vcc)
 If all the rows are grounded and a key is pressed,
one of the columns will have 0
 Since the key pressed provides the path to ground
◦ It is the function of the microcontroller to scan
the keyboard continuously to detect and
identify the key pressed
Grounding Rows and Reading
Columns
To detect a pressed key
◦ The microcontroller grounds all rows by
providing 0 to the output latch
◦ Then it reads the columns
 If the data read from columns is D3 – D0 = 1111, no
key has been pressed
 The process continues till key press is detected
 If one of the column bits has a zero, this means that
a key press has occurred
 For example, if D3 – D0 = 1101, this means that a
key in the D1 column has been pressed
Grounding Rows and Reading
Columns (cont.)
After detecting a key press, the
microcontroller will go through the
process of identifying the key
◦ Starting with the top row, the microcontroller
grounds it by providing a low to row D0 only
 It reads the columns, if the data read is all 1s, no key
in that row is activated
 The process is moved to the next row
◦ It grounds the next row, reads the columns,
and checks for any zero
Grounding Rows and Reading
Columns (cont.)
◦ This process continues until the row is
identified
After identification of the row in which
the key has been pressed
◦ Find out which column the pressed key
belongs to
Grounding Rows and Reading
Columns (cont.)
Detection and identification of key
activation goes through the following:
◦ To make sure that the preceding key has been
released, 0s are output to all rows at once, and
the columns are read and checked repeatedly
until all the columns are high
 When all columns are found to be high, the program
waits for a short amount of time before it goes to the
next stage of waiting for a key to be pressed
Grounding Rows and Reading
Columns (cont.)
◦ To see if any key is pressed, the columns are
scanned over and over in an infinite loop until
one of them has a 0 on it
 Remember that the output latches connected to rows
still have their initial zeros (provided in stage 1),
making them grounded
 After the key press detection, it waits 20 ms for the
bounce and then scans the columns again
 It ensures that the first key press detection was not an
erroneous one due a spike noise
 If after the 20-ms delay the key is still pressed, it goes back
into the loop to detect a real key press
Grounding Rows and Reading
Columns (cont.)
◦ To detect which row key press belongs to, it
grounds one row at a time, reading the
columns each time
 If it finds that all columns are high, this means that
the key press cannot belong to that row
 It grounds the next row and continues until it finds the row
the key press belongs to
 Upon finding the row that the key press belongs to,
it sets up the starting address for the look-up table
holding the scan codes (or ASCII) for that row
Grounding Rows and Reading
Columns (cont.)
◦ To identify the key press, it rotates the column
bits, one bit at a time, into the carry flag and
checks to see if it is low
 Upon finding the zero, it pulls out the ASCII code
for that key from the look-up table
 Otherwise, it increments the pointer to point to the
next element of the look-up table