Abstract: Embedded systems which require user interaction must interface with devices that accept user input (such as a keypad, bar code reader or smart card acceptor) as well as devices that display information to the user (such as LED or LCD displays). This application note, using the MAXQ2000 microcontroller, covers the use of two such typical devices - a 4x4 switch keypad and an LCD display.
Overview
Embedded systems which require user interaction must interface with devices that accept user input (such as a keypad, bar code reader, or smart card acceptor), as well as devices that display information to the user (such as LED or LCD displays). This application note covers the use of two such typical devices, a 4 x 4 switch keypad and an LCD display, with the MAXQ2000 microcontroller.
All example code for this application note was written in MAXQ assembly language, using the MAX-IDE development environment. The code was targeted for the MAXQ2000 Evaluation Kit (EV kit) board, using the following additional hardware.
- LCD—Varitronix static 3-volt LCD display, part number VI-502 (included with the MAXQ2000 EV Kit)
- Keypad—Grayhill 16-button (4 rows by 4 columns) keypad, part number 96BB2-006-F
Design Goals
Our example application will demonstrate basic use of both the keypad and LCD display by accepting input from the keypad and displaying the characters entered on the LCD. The application will handle switch debouncing correctly to avoid registering multiple characters from a single keypress, and it will also allow characters to be deleted once input. As a final task, contrast adjustment of the LCD display will be supported by the keypad.
As with any embedded design, the application should attempt to utilize the resources of the MAXQ2000 efficiently.
- Interrupt routines should use as little stack space as possible.
- Working register usage should be kept to a minimum.
Interfacing to the 4x4 Keypad
The keypad used for this example application consists of 16 switches, organized in a 4 x 4 grid. (Figure 1.)
Figure 1. Keypad switch layout.
The switches are tied together in a row and column matrix as shown below in Figure 2. Depressing a keypad switch connects one row line to one column line. For example, depressing the "3" key connects row 1 and column 3 together.
Figure 2. Keypad row/column matrix.
The keypad provides eight interface pins, one pin for each row and column of the keypad matrix. To allow use of a single, eight-connector cable to run from the keypad to the MAXQ2000 EV Kit, we will connect the keypad to port pins P6[5:0] and P7[1:0] through the JU2 header pin connector on the evaluation kit board, as shown below in Table 1. For a custom design, the keypad could be connected to the microcontroller in the most efficient method possible.
Table 1. Port Pin Connections to Keypad Row and Column Lines
| Pin |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
| Connect |
Row 1 |
Row 2 |
Row 3 |
Row 4 |
Col 1 |
Col 2 |
Col 3 |
Col 4 |
| Port Pin |
P6.0 |
P6.1 |
P6.2 |
P6.3 |
P6.4 |
P6.5 |
P7.0 |
P7.1 |
| JU2 Pin |
54 |
52 |
50 |
48 |
46 |
44 |
42 |
40 |
When connecting the keypad to the EV kit board for this example, the board should be configured as follows:
- These DIP switches must be OFF—All SW1 switches, SW3.1, SW3.7, SW3.8, SW6.1, SW6.4, SW6.5, SW6.6, SW6.7, and SW6.8.
- OPEN jumpers JU5, JU6, JU8, and JU9.
Optionally, when running the example application without modification, all the DIP switches may be turned off to simplify setup; only jumpers JU1, JU2, JU3 and JU11 need to be connected.
Scanning by Columns
With the row and column arrangement of the keypad, it is possible to read the state of four of the switches at any one time. This can be done on either a per row or per column basis.
To read four switches in one column, the line for that column must be pulled low, and all other columns tristated. Next, a weak pull-up must be established on each row line. Finally, connect the four row lines to port pin inputs. Defaulting to a HIGH state, the row input transitions low when the switch for that row is depressed. (Figure 3.)
Figure 3. Keypad setup to read column 1 switches.
Similarly, the state of four switches in a row may be read by pulling that row line low and setting inputs and weak pullups on all four columns. The rows and columns are interchangeable.
In our setup (Table 2), the four row lines (keypad pins 1 through 4) are all connected to the same input port (P6[3:0]), which makes it easier to read them all at once. For this reason, the example application will scan the keypad by columns, not by rows.
There are four setup states for the eight port-pin lines connected to the keypad, each of which allows four of the switches to be read. All input lines read LOW when the switch being read is closed, and HIGH when the switch is open.
Table 2. Port Pin Settings for Keypad Column Read States
| State |
P6.0 |
P6.1 |
P6.2 |
P6.3 |
P6.4 |
P6.5 |
P7.0 |
P7.1 |
| 1 |
Input - 1 |
Input - 4 |
Input - 7 |
Input - * |
LOW |
Tristate |
Tristate |
Tristate |
| 2 |
Input - 2 |
Input - 5 |
Input - 8 |
Input - 0 |
Tristate |
LOW |
Tristate |
Tristate |
| 3 |
Input - 3 |
Input - 6 |
Input - 9 |
Input - # |
Tristate |
Tristate |
LOW |
Tristate |
| 4 |
Input - A |
Input - B |
Input - C |
Input - D |
Tristate |
Tristate |
Tristate |
LOW |
An Interrupt-Driven State Machine
To ensure that a keypress is not missed, the four columns must be strobed quickly. Additionally, to prevent the bouncing contacts of a switch from registering multiple presses, the application requires that a key be held down for a certain amount of time before it registers. Both of these problems can be solved at once, by making a timer-driven interrupt routine the heart of the application.
RELOAD equ 0FF00h
StartTimer:
move IIR.3, #1 ; Enable interrupts for module 3
move IMR.3, #1
move T2V0, #RELOAD
move T2R0, #0h
move T2C0, #0h
move Acc, T2CFG0 ; Set timer 0 to run from HFClk/128
and #08Fh
or #070h
move T2CFG0, Acc
move T2CNA0.3, #1 ; Start timer 0
move T2CNA0.7, #1 ; Enable timer 0 interrupts
ret
The reload value for the timer, which controls how often the interrupt will fire, should be short enough that all key presses are caught and that key response is not noticeably sluggish. The reload value also should be long enough that it does not occupy an excessive amount of processing time. The value 0FF00h shown above (once about every 2.4 ms) was arrived at through experimentation.
Once the column line for a group of four switches is driven LOW, a certain amount of time may be required for the connection through a depressed switch to pull its input line low. This time will be affected by the on-resistance of the switch and by how many switches on the column are depressed at once. To avoid having to delay in the interrupt service routine between pulling the column line low and reading the four switches, the column line for a given state will be driven LOW in the previous state, as shown in Figure 4.
Figure 4. Keypad read-state machine.
Because the interrupt vector (IV) for the MAXQ2000 can be set on-the-fly, it is possible to hold the next-state value in the interrupt vector register by having the handler routine for each state set the vector address to the next state's handler routine.
org 0000h
Main:
call InitializeLCD
move PD6, #010h ; For state 1
move PO6, #00Fh ; For all states
move PD7, #000h ; For state 1
move PO7, #000h ; For all states
move IV, #State1
call StartTimer
move IC, #1 ; Enable global interrupts
jump $
State1:
push PSF
push Acc
move Acc, PI6
and #000Fh ; Grab lowest four bits only
sla4
move A[13], Acc
move PD6, #020h ; For state 2
move PD7, #000h
move T2V0, #RELOAD ; Set reload value
move T2CNB0.1, #0 ; Clear interrupt flags
move T2CNB0.3, #0
move IV, #State2
pop Acc
pop PSF
reti
The handler routines for the other four states are similar, with a slight adjustment to OR in the previously collected switch bits in the A[13] holding register. Three working accumulators are used by the state routines.
A[13] holds the bit array of all the switch states read on the current pass through the keypad. After the State 4 read has completed, this register will contain the following bits, where a 1 bit represents an open (released) key switch and a 0 bit represents a closed (depressed) key switch.
| bit 15 |
bit 14 |
bit 13 |
bit 12 |
bit 11 |
bit 10 |
bit 9 |
bit 8 |
bit 7 |
bit 6 |
bit 5 |
bit 4 |
bit 3 |
bit 2 |
bit 1 |
bit 0 |
| * |
7 |
4 |
1 |
2 |
5 |
8 |
0 |
3 |
6 |
9 |
# |
D |
C |
B |
A |
A[14] holds the bit array from the previous pass through the state machine. This is used by the debouncing code.
A[15] holds the last bit pattern which was held long enough to be registered as a key press. This is used to prevent key presses from repeating.
Debouncing Switches
After State 4 has been reached and all keys have been scanned, a decision must be made whether to accept any keys that are pressed.
A simple way to handle debouncing would be to maintain a counter value for each of the sixteen switches. Every time State 4 is reached and the key is pressed, the counter is incremented. If the key is not pressed, the counter is decremented. When the counter reaches a certain value, the keypress is registered. To prevent a held-down key from repeating (which typically is allowed on computer keyboards but not on keypads), the counter must be allowed to decrement back to zero (by releasing the key) before that key may be registered again.
Because we have the state of all 16 keys in a single register, there is a simpler, less memory-intensive solution. The application will maintain a single counter value (held in LC[0]) which will initially be set to a debounce constant. This counter is decremented each time the bit pattern matches the pattern read on the previous pass (in A[14]).
State4:
push PSF
push Acc
move Acc, PI6
and #000Fh ; Grab low four bits only
or A[13]
cmp A[15]
jump E, State4_End ; Ignore the last debounced pattern
cmp A[14]
jump E, State4_Match ; Match against pattern from last keypad read
move LC[0], #DEBOUNCE
move A[14], Acc ; Reset current bit array
To prevent keys from repeating, once a bit pattern has been static long enough to be accepted, a different bit pattern (which includes the idle state where no keys are depressed) must be accepted before the first bit pattern can be accepted again.
Handling Simultaneous Keypresses
It is possible for more than one key to be pressed at once. The debouncing code will ensure that if a second key is pressed right after the first, the debounce interval will start over, but the interval will be short enough in practice that this will not be an issue.
Once a bit pattern has been accepted, the action for each depressed-key bit may be taken by rotating all 16 bits into the carry bit, one at a time using the accumulator and checking each in turn. The code below responds only to the first depressed key, but this could be changed easily enough.
State4_Match:
djnz LC[0], State4_End
move A[15], Acc ; Reset last debounced pattern
rrc
jump NC, State4_KeyA
rrc
jump NC, State4_KeyB
rrc
jump NC, State4_KeyC
rrc
jump NC, State4_KeyD
rrc
jump NC, State4_Key3
rrc
jump NC, State4_Key6
rrc
jump NC, State4_Key9
rrc
jump NC, State4_KeyPound
rrc
jump NC, State4_Key2
rrc
jump NC, State4_Key5
rrc
jump NC, State4_Key8
rrc
jump NC, State4_Key0
rrc
jump NC, State4_Key1
rrc
jump NC, State4_Key4
rrc
jump NC, State4_Key7
rrc
jump NC, State4_KeyStar
jump State4_End
Interfacing to the LCD Display
The LCD display included with the MAXQ2000 evaluation kit has segments defined as shown in Figure 5.
Figure 5. LCD segment memory mapping.
To use the LCD display, the LCD controller must first be initialized to static drive mode and enabled.
InitializeLCD:
move LCRA, #03E0h ; xxx0001111100000
; 00 - DUTY : Static
; 0111 - FRM : Frame freq
; 1 - LCCS : HFClk / 128
; 1 - LRIG : Ground VADJ
; 00000 - LRA : RADJ = max
move LCFG, #0F3h ; 1111xx11
; 1111 - PCF : All segments enabled
; 1 - OPM : Normal operation
; 1 - DPE : Display enabled
move LCD0, #00h ; Clear all segments
move LCD1, #00h
move LCD2, #00h
move LCD3, #00h
move LCD4, #00h
ret
Once this has been done, characters may be written to the display by setting segments appropriately. The display is wired to the LCD segment lines of the MAXQ2000 so that the segments map into memory the same for each of the four 7-segment characters. As shown in the mapping diagram above (Figure 5), the characters are written (from right to left) by setting the LCD0, LCD1, LCD2 and LCD3 display memory registers.
; dGFEDCBA
LCD_CHAR_0 equ 00111111b
LCD_CHAR_1 equ 00000110b
LCD_CHAR_2 equ 01011011b
LCD_CHAR_3 equ 01001111b
LCD_CHAR_4 equ 01100110b
LCD_CHAR_5 equ 01101101b
LCD_CHAR_6 equ 01111101b
LCD_CHAR_7 equ 00000111b
LCD_CHAR_8 equ 01111111b
LCD_CHAR_9 equ 01101111b
LCD_CHAR_A equ 01110111b
LCD_CHAR_B equ 01111100b
LCD_CHAR_C equ 00111001b
LCD_CHAR_D equ 01011110b
State4_Key0:
move Acc, #LCD_CHAR_0
jump State4_Shift
State4_Key1:
move Acc, #LCD_CHAR_1
jump State4_Shift
State4_Key2:
move Acc, #LCD_CHAR_2
jump State4_Shift
State4_Key3:
move Acc, #LCD_CHAR_3
jump State4_Shift
State4_Key4:
move Acc, #LCD_CHAR_4
jump State4_Shift
State4_Key5:
move Acc, #LCD_CHAR_5
jump State4_Shift
State4_Key6:
move Acc, #LCD_CHAR_6
jump State4_Shift
State4_Key7:
move Acc, #LCD_CHAR_7
jump State4_Shift
State4_Key8:
move Acc, #LCD_CHAR_8
jump State4_Shift
State4_Key9:
move Acc, #LCD_CHAR_9
jump State4_Shift
State4_KeyA:
move Acc, #LCD_CHAR_A
jump State4_Shift
State4_KeyB:
move Acc, #LCD_CHAR_B
jump State4_Shift
State4_KeyC:
move Acc, #LCD_CHAR_C
jump State4_Shift
State4_KeyD:
move Acc, #LCD_CHAR_D
jump State4_Shift
Editing the PIN
When any of the alphanumeric keys are pressed, the corresponding character is loaded into the rightmost character on the LCD display. All existing characters are shifted one place left.
State4_KeyStar:
move LCD0, LCD1
move LCD1, LCD2
move LCD2, LCD3
move LCD3, #0
jump State4_End
State4_Shift:
move LCD3, LCD2
move LCD2, LCD1
move LCD1, LCD0
move LCD0, Acc
State4_End:
move PD6, #010h ; Set up values for next state
move PD7, #000h
move T2V0, #RELOAD ; Set reload value
move T2CNB0.1, #0 ; Clear interrupt flags
move T2CNB0.3, #0
move IV, #State1
pop Acc
pop PSF
reti
The 'star' key is connected in this application to a delete/backspace function. Pressing the star key shifts all characters one place to the right and erases the leftmost character from the display.
Contrast Adjustment
The pound key performs one additional function for demonstration purposes. Pressing it adjusts the contrast of the LCD display, a simple function performed by incrementing the RADJ bits in the LCRA register.
State4_KeyPound:
move Acc, LCRA
or #0FFE0h ; clear low five bits
move A[13], Acc ; save version with bits cleared
move Acc, LCRA
and #0001Fh ; get low five bits only
add #1 ; increment
and #0001Fh ; mask out any carry to sixth bit
or A[13] ; OR in the rest of the bits
move LCRA, Acc ; change contrast
jump State4_End
Conclusion
The MAXQ2000 interfaces easily and directly to LCD displays by means of its dedicated LCD controller peripheral. Multiplexed key pads can be read in a straightforward manner using the flexible port pin configuration provided by the MAXQ2000. An interrupt-driven state machine allows all keys in the matrix to be scanned and debounced behind the scenes of the main application with minimal effect on processor overhead.
