Chapter 3: LCD and Keyboard Interfacing tn this chapter we show interfacing to two real-world devices: LCD and Keyboard. They are widely used in different embedded systems Section 3.1: Interfacing to an LCD This section describes the operation modes of the LCDs, then describes how to program and interface an LCD to the Tiva LaunchPad. LCD operation In revent years the LCD is replacing LEDs (seven-segment LEDs or other mul This is due to the following reasons: segment LEDS). The declining prices of LCDs. The ability to display numbers, characters, and graphics. This isin contrast to LEDS, which are limited to numbers and a few characters.( The new OLED panels are relatively much more expensive except the very small ones. But their prices are dropping. The interface and programming to OLED are similar to graphic LCD.) 3, Incorporation of the refreshing controller into the LCD itself, thereby relieving the CPU of the task of refreshing the LCD. 4, Ease of programming for both characters and graphics. 5. The extremely low power consumption of LCD {when backlight is not used). In this Chapter we will fimit the discussions to the character LCD modules. The graphic LCD modules will be discussed ina later | chapter. [3° VEE = Power supply to control LCD module pin descriptions fess i ee COS 4 RS RS = O to select command For many years, the use of Hitachi | HD44780 LCD controller dominated the register, character LCD modules. Even today, most of RS=1toselect data the character LCD modules still use HD44780 or register a Variation of it. The HD44780 controller has a RAW= Ofor write, 14 pin interface for the microprocessor. We will discuss this 14 pin interface in this section, The function of each pin is given in Table 3-1. Figure 3-1 shows the pin positions for various LCD modules. “140870 The abit data bus. ‘aie 3 Pin Destine ToeTD 51pmc20261 buczaaa7 ncs6250 Mozai38 Ditcanais omes2192 ‘omcsa6 fomca2239 omereraxs micaoi3t DMCZD4S4. Meenas Figure 3-1: Pin Positions for Various LCDs from Optrex \VCC, VSS, and VEE: While VCC and VSS provide #5V power supply and ground, respectively, VEE is used for controlling the LCD contrast. RS, register select: There are two registers Inside the LCD and 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, and so on (or query the busy status bit of the controller). IF RS = 4, the data register is selected, allowing the user to send data to be displayed on the LCD (or to retrieve data from the LCD controller). R/W, read/write: R/W input allows the user to write information into the LCD controller or read Information from it. R/W = 2 when reading and R/W = 0 when writing, E, enable: The enable pin is used by the LCD to latch information presented to its data pins. When data is supplied to data pins, a High-to-Low pulse must be applied to this pin in order for the LCD ‘to latch in the data present at the data pins. This pulse must be a minimum of 230 ns wide, according to Hitachi datasheet, D0-D7: The 8-bit data pins are used to send information to the LCD or read the contents of the LCD's internal registers. The LCD controller is capable of operating with 4-bit data and only D4-D7 are used. We will discuss this in more details later. rae inked 1 Clear display screen Return cursor home “Force cursor to beginning of 2nd line 2ilines and 5x7 character (8-bit 52To display letters and numbers, we send ASCII codes for the letters A~Z, 2-2, numbers 0-9, and ‘the punctuation marks to these pins while making RS There are also instruction command codes that can be sent to the LCD in order to clear the ay, force the cursor to the home position, or blink the cursor. Table 3-2 lists some commonly used ‘command codes. For detailed command codes, see Table 3-4. Sending commands to LCDs To send any of the commands to the LCD, make pin RS = 0 and send a High-to-Low pulse on the pin to enable the internal latch of the LCD. The connection of an LCD to the microcontroller is shown in 10K Por Figure 3-2: LCD Connection to Microcontroller Notice the following for the connection in Figure 3-2: ‘The LCD's data pins are connected to PORTx of the microcontroller. ‘The LCD's RS pin is connected to Pin 5 of PORTY of the microcontroller. ‘The LCD's R/W pin is connected to Pin 6 of PORTy of the microcontroller. ‘The LCD's E pin is connected to Pin 7 of PORTy of the microcontroller. Both Ports x and y are configured as output ports. Sending data to the LCD In order to send data to the LCD to be displayed, we must set pin RS ‘o-Low pulse to the E pin to enable the internal latch of the LCD. , and also send a High- Because of the extremely low power feature of the LCD controller, it runs much slower than the ‘microcontroller. The first two commands in Table 3-2 take up to 1.64 ms to execute and all the other Commands and data take up to 40 us. (At the highest clock speed, TM4C123GHGPM can execute more than 3,000 instructions in 40 us.) After one command or data is written to the LCD controller, one must. wait until the LCD controller is ready before issuing the next command/data otherwise the second comrand/data will be ignored. An easy way (not as efficient though) is to delay the microcontroller for 53the maximal time it may take for the previous command. We will use this method in the following examples. All the examples in this chapter follow the original HD44780 datasheet (see Table 3-4). You ‘may have to adjust the delay time for the LCD module you use. [+ pi_L.et Initialize and display "Hello" on the LCD using =bit data mode. */ f* ata pine use Port 8, control pins use Port A */ /* this program strictly follows 1044780 datasheet for timing. You may want to adjust the amount of delay for your LCD controller. */ Binclude "mMac123GHePM.h* Sdefine LcD_OATA GPIOB define UcD_CTRL GPIOA define RS 0x20 /* PORTA BITS mack */ Hdefine RW 0x20 /* PORTA BITE mask */ define EN 0x80 /* PORTA BITT mask */ void delays (int a}: void delays (int n void LCD_conmand unsigned char command) : vold LeD data (unsigned char data); void LCD_init (void); int main(void) ( nep_init 0); Fortra) 1 eD_command (1) 5 J* clear display */ cD command (x60): /* Led cursor location */ delays (500): LeD_data ("8"); EoD data(‘e'); EoD data ("1"); ep data ("1"); Lcd _data(to"}; aeLayts (500) ' void Lcb_init (void) ( SYSCTL->REGCGPIO |= 0x01: /¥ enable clock to GPIOR *+/ SYSCTL-SRCGCGPIO |= 0x02; /* enable clock to GPIOB */ LCD_CTRL->DIR |= OxED; /* set PORTA pin 7-5 ag output for control */ LCD_CTRL->DEN i= OXED; —/* set PORTA pin 7-5 as digital pins */ ECD_DATA->DIR = OxEF? 7+ set all PORTE pine as output for data */ LCD_OATA->DEN ~ OxPF; 7+ set all PORTE pins as digital pins */ deiayts (20); /* initialization sequence */ LLCD_comnand (0x30) + derayeis (5); “LCD _command (0X30) + eiayys (100) 84Lep_conmand (030) ¢ cp _conmand (0x38) 5 J+ set O-bit data, 2-Line, 5x7 font */ ico command (0x08) + Y* move cursor right */ e0_comand (0x01) ¢ /* clear screen, move cursor to home */ {ico “commana (0x08) z 7+ turn on display, cursor blinking */ yoid LCD_conmand (unsigned char command) LCD_CTRL-SOATA = 0; /* BS = 0, B/W = 0 4+/ eD_DATA->DATA = command Hep_eSRL DATA EN; /* puloe © +/ delays (0) ECD_CTRL=>DATA = 05 if (command < 4) delays (2); /* command 1 and 2 needs up to 1.64ms */ delays (40) : /* all others 40 us */ void LeD_data(unsigned char data) 1 RS; /# RS = 1, R/M = 0 +/ data: EN IRS: /* pulse 8 */ Lcb_OTRL-SORTA LcD_DATA~>DATA LCD_CTRL~>DATA delays (0) ; LCD_CTRL=>DATA ~ delayls (40) /* delay n milliseconds (16 MHz CPU clock) */ void delays (int a} int iy 3s for(i 07 i RCGCGPIO |= 0x02; /* enable clock to GPIB */ 1CD_PORT->DIR = OXF? 7+ set all PORTB pins as output */ LCD_PORT-SDEN = OxFF; /* set ail PORTB pins as digital pins */ delays (20): /* initialization sequence */ LCD _nibble write (0x30, 0); delays (517 LED_nibble write (0x30, 9)7 selayue(100) Leb_nibble write (0x30, 0); aelayus(40)7 Lcb_nibble_write(0x20, 0); /* use é-bit data mode */ delays (40); LCD_command (0x28) ; J+ set 4-dit data, 2-Line, 5x7 font */ Lc” command (0x06) 7 V+ move cursor right */ LCD command (0x01) 7 7* clear screen, move cursor to hone */ co _conmand (OX0F} : /* turn on display, cursor blinking */ 7void LeD_nibble_writefunsigned char data, unsigned char control) i data b= OXF; J+ clear lower nibble for control */ control &= 0x08; /* clear upper nibble for data */ ECD_PORT->DATA ~ date | control; J RS = 0, RW OFS LCD_PORT->DATA = data | control | EN; /* pulse & */ dotayus (0); Lcb_PORT->DATA = data; LCD_PORT->OATA = 07 : void LCD_command uneigned chaz command) { Lcb_nibble_write{command & 0x®0, 0); /* upper nibble first +/ Lep_nibble_write(command << 4, 0); /* then lower nibble */ Lf (command < 4) delays (2); /* commands 1 and 2 need up to 1.64ms */ else delays (40); /* all others 40 us */ 1 void LCb_data{unsigned char data) 1 LeD_nibble write(data & OxF0, RS}; /* upper nibble first */ Lcb_nibble write(data << 4, RS); (+ then lower nibble */ delays (40); J+ delay p milliseconds (16 Miz CPU clock) */ void delayMs (int n} ‘ int i, 34 fori = 0; i< ny itty forij = 07 5 < 31807 544) (f+ Qo nothing tor 1 ms */ ) 7+ delay n microseconds (16 milz CPU clock) */ void delayls(int n} 1 int 1, 33 for(i 0p 1 < ny iH) for(} = 0; 3 < 34 344) th 7+ Go notnang tor 1 us */ ) /* This fonction is called by the startup assembly code to perform system specific initialization tasks. */ void Systeminit (void) 1 J+ Grant coprocessor access */ /* This is required since TMAC1236 has a floating point coprocessor */ 58ce->cPACR |= 0x00#00000; ES LCD cursor position In the LCD, one can move the cursor to any location in the display by issuing an address command. The next character sent will appear at the cursor position. For the two-line LCD, the address command for the first location of line 1 is Ox80, and for line 2 itis xCO. The following shows address locations and how they are accessed: RS_ RW. 067 DBs 085 DBs DBI EZ DBI DB0 Of ey ean aa Ae PAT A where AcAcAsAsAvArAg~ 0000000 to 0100111 for line 1 and AgAsAyAxAzA:Ao = 1000000 to 1100111 for line 2. See Table 3-3. Table 23: LCD Addressing Commands Line 4 (min) 1 0 0 0 0 0 0 ° ~ tne 1 (max) 1 ° 1 0 ° 1 1 1 “Line 2 (min) 1 1 0 0 0 0 o 0 Line 2 (max) 2 i 1 0 ° 1 1 1 ‘The upper address range can go as high as 0100111 for the 40-character-wide LCD while for the 20-character-wide LCD the address of the visible positions goes up to 010011 (19 decimal = 10011 binary). Notice that the upper range 0100111 (binary) = 39 decimal, which corresponds to locations 0 to 39 for the LCDs of 40 x 2 size, Figure 3-4 shows the addresses of cursor positions for various sizes of LcDs. All the addresses are in hex. Notice the starting addresses for four line LCD are not in sequential order. ‘As an example of setting the cursor at the fourth location of line 1 we have the following LCD_command (0283) ; and for the sixth location of the second line we have: LCD_command (0xC5) ; Notice that the cursor location addresses are in hex and starting at O as the first location. 59Figure 3-4: Luror Adresses for Some LCDs LCD timing and data sheet Figures 3-5 and 3-6 show timing diagrams for LCD write and read timing, respectively, 60RS team = Enable pulse width = 230 ns (eninimum) tosw = Data setup time = 80 ns (minimum) ‘y= Data hold time = 10 ns (minimum) tas = Sotup time prior to E (going high) for both RS and RAW = un = Hold time after E has come down for both RS and RAW = 10 ns (minimum) Figure 35:10 Write Timing Do-D7 tp = Data output delay time ‘Setup time prior to E (going high) for both RS and RAW = 40 ns (minimum) Note: Read requires an t-to-H pulse for the E pin. Figure 3-6:LCD Read Timing 61Notice that the write operation happens on the H-to-t transition of the E pin. The microcontroller must have data ready and stable on the data lines before the H-to-L transition of E to satisfy the setup time requirement. 3 ‘The read operation is activated by the L-to-H pulse of the E pin. After the delay time, the LCD controller will have the data available on the data bus if the R/W line is high. The microcontroller should _ read the data from the data lines before lowering the E pulse. Table 3-4 provides a more detailed list of LCD instructions. Clears entire display and sets, DD RAM address Oin address | 2.64 ms counter Sets DD RAM address to 03s, address counter. Also returns display being shifted to | 1.64 ms_ original positions. DD RAM 3 contents remain unchanged. i ‘Sets cursor move direction ‘and specifies shift of display. These operations are 4ous | performed during data write and read. Sets On/Off of entire display (0), cursor On/Off (C), and blink of cursor position character (8) ‘Moves cursor and shifts display without changing DD | 40us 40ps RAM contents. Sets interface data length (DL), number of display lines (L), | 40ns x and character font (F) Sete “Sets CG RAM address. CG RAM ram [ojojo|i Acc data is sent and received after | 40's. Address _ this setting. ‘Set DD Sets DD RAM address. DD Ram |o|o|1 ‘ADD RAM data is sent and received | 405 after this setting. Reads Busy flag (BF) internal operation is being a K pele le : performed and reads address | “°H® counter contents. Write Data | i | 0 Weite Data “Writes data into DD oré | 40usRAM. Reads data from DD or CG a[a Read Data Ae 40ys ‘Abbreviations: DD RAM: Display data RAM CG RAM: Character generator RAM AGC: CG RAM address ADD: DD RAM address, corresponds to cursor address ‘AC: address counter used for both DD and CG RAM addresses increment, 0: Decrement. : Accompanies display shift S/C: 1 = Display shift, 0: Cursor move : 1: Shift to the right, 0: Shift to the left bits x7 dots internal operation, 0 = Can accept instruction Table 3-4 list of LCD instructions Review Questions 1. The RS pinis an input, output) pin for the LCD. 2. The Epinisan (input, output) pin for the LCD. 3. The E pin requires an (H-to-L, Lto-H) transition to latch in information at the data pins of the LCD. 4. For the LCD to recognize information at the data pins as data, RS must be set to__(high, low) 5. Give the command codes for line 1, first character, and line 2, first character. Section 3.2: Interfacing the Keyboard to the CPU To reduce the microcontroller /O pin usage, keyboards are organized in a matrix of rows and ‘columns. The CPU accesses both rows and columns through ports; therefore, with two &-bit ports, an 8 x 8 matrix of 64 keys can be connected to a microprocessor. When a key is pressed, a row and a column make @ contact; otherwise, there is no connection between rows and columns. In a PC keyboards, an embedded microcontroller in the keyboard takes care of the hardware and software interfacing of the keyboard. In such systems, it is the function of programs stored in the ROM of the microcontroller to scan the keys continuously, identify which one has been activated, and present it to the main CPU on. the motherboard. In this section, we look at the mechanism by which the microprocessor scans and identifies the key. For clarity some examples are provided. Scanning and identifying the key Figure 3-6 shows a 4 x 4 matrix connected to two ports. The rows are connected to an output Port and the columns are connected to an input port. All the input pins have pull-up resistor connected. l¥no key has been pressed, reading the input port will yield 4s forall columns. if ll the rows are driven 63low and a key is pressed, the column of that key will read back a 0 since the key pressed shorted that column to the row that is driven low. It is the function of the microprocessor to scan the keyboard continuously to detect and identify the key pressed. How it is done is explained next, Figure 3-7: Matrix Keyboard Connection to Ports Key press detection To detect the key pressed, the microprocessor drives all rows low, then it reads the columns. If the data read from the columns is D7-D4 = 1111, no key has been pressed and the process continues Until a key press is detected. However, if one of the column bits has a zero, this means that a key was pressed. For example, if 07-D4= 1101, this means that a key in the D5 column has been pressed, The following program detects whether any of the keys is pressed. J+ to be used in conju sion with program 3-2 */ void keypad_init (void); unsigned char keypad, Xbhit (vold); int main(void) [ 64unsigned char key: keypad_init (); LeD_init 0; whileta) t Leb_commana {0x80) J* LeD cursor location */ if (keypad_konit() != 0) /* if a key is pressed */ EeD_data("P*}? /* display "Pt */ else LeD_data('n'); J+ ateplay ¢Rt+/ delays (10); /* wait for a while */ ' Acefine KEYPAD_ROW GPIOR fdetine KEYPAD_COL GPrOc /* this function initializes the ports connected to the keypad */ yoid keypad_init (void) 1 SYSCPL->RCGOGPIO |= 0x04; /* enable clock to GPIOC */ SYSCTL-DRCGCGPIO |= 0x10; /* enable clock to GPIOE */ KEYERD_FOW->DIR |= Ox0F; /* set row pins 3-0 as output */ KEYPAD_RON-DDEN |= Ox0F; /* set row pins 3-0 as digital pins */ KEYPAD_RON-DODR j= Ox0F; /* set row pins 3-0 as open drain */ KEYPAD COLM>DIR G= ~OxFO; —/* get column pin 7-4 as input */ KBYPAD_COL->DEN |= 0x60; /* set column pin 7-4 as digital pins */ KEYPAD_COL->PUR |= 0x0; /# enable pull-ups for pin 7-4 f+ this 49 a no /* If a key is pressed, it returns 1. */ / Otherwise, it returns a 0 (not ASCII 0).*/ signed char keypad_kbbit (void) int cols J+ check to see any key pressed */ KEYEAD_ROW->DATA = 0; /* enable ali rows */ col = KEYPAD COL->OATA & OxFO; /* read all colunns */ Lf {col == OxFO) return 07 /* no key pressed +/ else return 1; /* a key is pressed */ EES Key identification After @ key press is detected, the microprocessor will o through the process of identifying the key. Starting from the top row, the microprocessor drives one row low at 2 time; then it reads the 65columns. If the data read is all 1s, no key in that row is activated and the process is moved to the next row. It drives the next row low, reads the columns, and checks for any zero. This process continues until row is identified with a zero in one of the columns. The next task is to find out which column the pressed key belongs to. This should be easy since each column is connected to a separate input pin, Look at Example 3-1. ee Example 3-1. From Figure 3-7, identify the row and column of the pressed key for each of the following. (a) D3-D0 = 1110 for the row, D7-D4- 1011 for the column (b) D3-D0 = 1101 for the row, D7-D4= 0111 for the column Solution: From Figure 3-7 the row and column can be used to identify the key. (a) The row belongs to DO and the column belongs to D6; therefore, the key number 2 was pressed, (b) The row belongs to Di and the column belongs to D7; therefore, the key number 7 was pressed, Figure 3-8 is the flowchart for the detection and identification of the key activation. Program 3-4 provides an implementation of the detection and identification algorithm in C language. Next, we will examine it in detail, First for the initialization of the ports, Port E pins 3-0 are used for rows and configured as output digital pin. These pins are also configured as open drain output, ‘which means they are driven low actively but not driven high. Open drain output prevents port damage ‘when two keys of the same column are pressed at the same time. If output pins are driven high and low ‘and two keys of the same column are pressed, it will short the output low to output high of the adjacent pin and cause damages to the output pins. The Port C pins 7-4 are configured as input digital pin with the internal pull-up resistors enabled, This will ensure that the input pins read 1 when no key is pressed. ‘The key scanning function is a non-blocking function, meaning the function returns regardless of whether there is @ key pressed or not. The function first drives all rows low and check to see if any key pressed. if no key is pressed, a zero is returned. Otherwise the code will proceed to check one row at a ‘time by driving only one row low at a time and read the columns. If one of the columns is active, it will find out which column itis. With the combination of the active row and active column, the code will find out the key that is pressed and using the lookup table keymapl | return the ASCII key label. 66EPasseld Key, EE i SenOURON et Figure 3-8: The Flowchart for Key Press Detection and identifiation /* to be used in conjunction with Program 3-2 */ void keypad_init (void); unsigned char keypad_getkey (void): int mainiveia) 1 unsigned char key: keypad init; nep_init(): white (2) i {LCD_command (0380) 2 /* UCD cursor Location */ 67key ~ keypad_getkey(); if (key I= 0) /* read the keypad */ (f+ if a key is pressed */ EeD_data (key); , else EeD_datat? ")s delays (20); Hdofine KEYPAD_ROW GPIOE Hdefine KEYPAD_COL GPrOc /* display the key label +/ ‘J+ wait for a while */ /* this function initializes the ports connected to the keypad */ void keypad_init (void) ( SYSCTL-DREGCGPIO |= 0x04; SYSCTI->REGCGPIO |= 0x10; KEYEAD_ROW-DDIR |= Ox0F KEYEAD_ROW-DOEN |= OX0F: KEYPRD_ROW-DODR |= Ox0F; KEYEAD_COL->DIR = ~OxFO; KEYERO_COL->DEN |= 0x80; KEYEAD_COL->POR |= OxFO: , /* enable clock to GPIOc */ /> enable clock to GPLOE */ (+ eet row pins 3-0 as output */ 7+ at row pine 3-0 as digital pins */ 7* set row pins 3-0 as open drain */ /* set column pin 74 as input */ /* set column pin 7-4 a digital pins */ 7* enable pull-ups for pin 7-4 */ J+ this is @ non-blocking function te read the keypad. */ 7 TE a key is pressed, it returns the key label in ASCIT encoding, returns a 0 (not ASCIT 0). */ unsigned char keypad_get key (void) { const unsigned char keymap(4) [4] 1 ea ca Cay 15, 16, Bt, £17, 1B 19, Thy 18 10%, BD, , int row, cols otherwise, it ‘ J+ check to see any key pressed First */ KBYPAD_ROW->DATA = 0; col = REYPAD_COL->DATA & Ox#0; Af (col =» ORFO) return 0: (er a key pressed, it gets here to find out 7 enable all rows */ /* read all colunns */ 7 no key pressed */ wbich key. 47 7* Although it is weitten ag an infinite loop, it will take one of the breaks or return in one pass.*/ while (1) t row = 07 KEYPAD_ROR~>DATA = Ox0R J enable row 0 */selayus (2) /* wait for signal to settle */ col = KEYPAD COL->0ATA & OxFO; if (col != OXPO) break: KBYPAD_ROW->DATA = 0x00: J+ enable row 1 +/ delays (2); Y* walt for signal to settle */ col = KEYPAD_COL->DATA & OxE07 if (col I= 0#60) break KEYPAD_ROW->DATA = Ox0B 1 enable row 2 */ dolay0s (2); /* wait for signal to aettle +/ col = KEYPAD COL->DATA & OxFO; if (col != 0X60) break, row = 3 KEYERD_ROW->DATA ~ 0x07 /* enable row 3 */ delayus (2): {+ wait for signal to settie */ col = KEYPAD COL->OATA & OxFO; Af (col != 0xFO) break: return 0; /* Lf no key is pressed */ : + gets here when one of the rows has key pressed */ Lf (col == 0x80) return keymap(row] [0]; /* key in column 0 */ Af {col == 0x00} return keymap[row) (117 /* key in column 1 */ if == 0x80} return keymap[row) {2}; /* key in column 2 */ £ (col =» 0x70) return keymaptzow] (31 /* key in column 3 +/ return 0; /* just to be safe */ EEE epeeeeemeemeemmemeeeememeemeemmmmemmmmmmmmmeeee see Debounce When a mechanical switch is closed or opened, the contacts do not make a clean transition instantaneously, rather the contacts open and close several times before they settle. This event is called contact bounce (see Figure 3-9). So itis possible when the program first detects a switch in the keypad is pressed but when interrogating which key is pressed, it would find no key pressed. This is the reason we have a return 0 after checking all the rows. Another problem manifested by contact bounce is that one key press may be recognized as multiple key presses by the program. vec enp- Uastable Unstable Figure 3-8: Switch contact bounces 6‘We will see the software solution in Program 3-5. The sample program here demonstrates the se of keypad with the LCD. For every key pressed, one character representing the key is added to the display. In the infinite loop of main( ), keypad_getkey() is repeatedly called to scan the keypad. If it returns something other than 0, a key is pressed and the key label is displayed on the LCD. It then calls delay for 20 ms to wait for the contact bounce to subside. The next while loop waits for the key release, it continuously calls keypad_getkey( } until it returns a 0 when key is released. Another debounce for key release is required before the program scan the key again. 7+ to be used in conjunction with Program 3-4 */ void keypad init (void): unsigned char keypad_getchar (void) ; Ant main void) 1 unsigned char key; keypad_init()s Lep_init 0; ep data (13412 white(1) i J+ wait until a kay is pressed */ dot key = keypad_getkey(}7 delaytis (20); /* dedoun while(keypad_getkey!) != key): the key contact */ 1cd_data (key) : J* display the key label +/ /* wait until the previous key is released */ eo While (keypad getkey() !~ 0); delays (20) 7+ wait to debounce */ Jwhile(xeypad_getkey() != 0); The debounce code can be put in a new function, as shown in Program 3-6. 7° co be used in conjunction with Program 3-4 */ void keypad_init (void): unsigned char keypad_getchar (void) 7 70int main void) ' unsigned char key? keypad _init(); cb_init EeD_data (">"); white) i key ~ keypad getchar(): Eeb_asta ley) J+ display the key label */ This is a blocking function to read the keypad. *, /* When a key is pressed, it returns the key label.*/ i unsigned char keypad_getchar (void) nsigned char key: J+ wait until the evious key is released +/ aot while (keypad_getkey() != 0); delays (20) ; %* wait to debounce */ Jwbile(keypad_qetkey{) != 0); key = keypad_getkey(): delays (20) /* wait to debounce */ while(keypad_qetkey() != key); a There are IC chips such as National Semiconductor's MM74C923 that incorporate keyboard scanning and decoding all in one chip. Such chips use combinations of counters and logic gates (no microprocessor) to implement the underlying concepts presented in Programs 3-3 through 3-6. Review Questions 1. True or false. To see if any key is pressed, all rows are grounded. 2. 1fD3-D0~ 0111 js the data read from the columns, which column does the key pressed belong, to? 3. True or false. Key press detection and key identification require two different processes. In Figure 3-7, if the row has D3-D0 = 1110 and the columns are D3-D0 = 1110, which key is pressed? 5. True or false. To identify the key pressed, one row at a time is grounded n { |Answers to Review Questions Section 3-1 1. Input 2. Input. 3. HtoL 4. High 5. 0x80 and OxCO Section 3-2 1. True 2. Column 3 3. Tue 40 5. True R