ATMega644P LCD Display and Matrix Keypad Interface

Using a matrix keypad could save the I/O port of a micro-controller. For instant a 4x4 matrix keypad yields different 16 key values. It requires only 8 pins of micro-controller or one I/O port only. We can program the keypad scanning from scratch using C language.The program just divides the 8-bit port into two nibbles, one for output scanning and one for input key press detecting. 

 

A matrix keypad can be made from scratch by using tactile switches and breadboard soldering without hazardous chemical etching. However there are many types of matrix keypad that made from tactile switches or even membrane switches. They are available at very low cost.

16 Key Membrane Switch Keypad 4X4 3X4 Matrix Keyboard For Arduino DIY Kit

In a simple introductory example, I just make a keypad scanning routine that uses PortD. Whenever any key press is founded the key value will display on a single seven-segment connects to PortA.

1. /*
2. * 7-keyapd_4x4_7.c
3. *
4. * Created: 1/28/2026 7:29:49 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. /*
13. const char key_16[][4]={'1','2','3','A',
14. '4','5','6','B',
15. '7','8','9','C',
16. '*','0','#','D'};
17. */
18. const char key_16[][4]={7,8,9,15,
19. 4,5,6,14,
20. 1,2,3,13,
21. 10,0,11,12};
23. const uint8_t cc_7[16]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,
24. 0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71};
25. volatile char keyScan(void){
26. char data=0,temp,key;
27. for(uint8_t i=0;i<4;i++){
28. data=0xFF;
29. data&=~(1<<i);
30. PORTB=data;
31. _delay_ms(5);
32. data=PINB;
33. data&=0xF0;
34. if((data&0x10)==0) {temp=key_16[i][0]; break;}
35. else if((data&0x20)==0){temp=key_16[i][1]; break;}
36. else if((data&0x40)==0){temp=key_16[i][2]; break;}
37. else if((data&0x80)==0){temp=key_16[i][3]; break;}
38. else temp=0xFF;
39. _delay_ms(10);
40. }
41. return temp;
42. }
43. int main(void)
44. {
45. /* Replace with your application code */
46. DDRB=0x0F;
47. PINB=0x0F;
48. DDRD=0xFF;
49. char temp;
50. while (1)
51. {
52. temp=keyScan();
53. if(temp!=0xFF){
54. PORTD=cc_7[temp];
55. _delay_ms(250);
56. }
57. }
58. }
59. 
    

I just tested this example in software simulator since I don't want wire additional seven-segment display. 

Schematic and Simulation Program 

I will use the real hardware on next example. 

However we can use other micro-controller chips or even additional interface chips. 

• ATMega32 interfaces to keypad and display 
• ATMega32 LCD and Keypad Interfacing Example
• AT89C52 Matrix Keypad Interfacing in C using Keil 
• AT89C52 Character LCD and Keypad Interfacing Using C 
• PIC16F887 TM1637 Display and Key Scan Example using XC8 
• PIC16F887 KeyPad and Character LCD Example using XC8 
• PIC16F887 PCF8574AP I2C 4x4 KeyPad using XC8 
• PIC16F887 MCP23017 Key Pad and 7-Segment Display Example using XC8 
• PIC16F887 MCP23017 LCD and Keypad Interfacing using XC8 
• PIC16F887 SPI MCP23S17 Character LCD and KeyPad XC8 Example 

 Here I added the LCD driver to this example program since it's already placed on-board.

1. /*
2. * 7-keypad_4x4_lcd.c
3. *
4. * Created: 1/28/2026 6:20:48 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. 
    
13. #include "hd44780.c"
14. 
    
15. const char key_16[4][4]={'1','2','3','A',
16. '4','5','6','B',
17. '7','8','9','C',
18. '*','0','#','D'};
19. 
    
20. /*
21. const char key_16[4][4]={'7','8','9','/',
22. '4','5','6','X',
23. '1','2','3','-',
24. '*','0','=','+'};
25. */
26. 
    
27. volatile char keyScan(void){
28. char data=0,temp,key;
29. for(uint8_t i=0;i<4;i++){
30. data=0xFF;
31. data&=~(1<<i);
32. PORTB=data;
33. _delay_ms(5);
34. data=PINB;
35. data&=0xF0;
36. if((data&0x10)==0) {temp=key_16[i][0]; break;}
37. else if((data&0x20)==0){temp=key_16[i][1]; break;}
38. else if((data&0x40)==0){temp=key_16[i][2]; break;}
39. else if((data&0x80)==0){temp=key_16[i][3]; break;}
40. else temp=0;
41. _delay_ms(10);
42. }
43. return temp;
44. }
45. int main(void)
46. {
47. /* Replace with your application code */
48. DDRB=0x0F;
49. PINB=0x0F;
50. lcd_init();
51. lcd_text("ATMega644P LCD");
52. lcd_xy(1,2);
53. lcd_text("4x4 Key Pad");
54. _delay_ms(10000);
55. lcd_clear();
56. char temp,charCount=0,newLine=0,line=1;
57. while (1)
58. {
59. temp=keyScan();
60. if(temp!=0){
61. lcd_data(temp);
62. charCount++;
63. _delay_ms(500);
64. }
65. if(charCount>=16){
66. newLine=1;
67. charCount=0;
68. line+=1;
69. }
70. if(newLine){
71. newLine=0;
72. if(line==2) lcd_xy(1,2);
73. else{
74. lcd_command(0x01);
75. _delay_ms(5);
76. line=1;
77. }
78. }
79. }
80. }
81. 
    

It requires the "hd44780.c" that created in previous post.

hd44780.c 

1. /*
2. * hd44780.c
3. *
4. * Created: 1/28/2026 9:55:18 PM
5. * Author: Admin
6. */
7. 
   
8. 
   
9. #include "hd44780.h"
10. 
    
11. 
    
12. void lcd_command(char command){
13. char temp;
14. temp=command&0xF0;
15. PORTC=temp|(1<<EN);
16. _delay_us(d_time);
17. PORTC=temp;
18. _delay_us(d_time);
20. temp=command<<4;
21. PORTC=temp|(1<<EN);
22. _delay_us(d_time);
23. PORTC=temp;
24. _delay_us(d_time);
25. }
26. 
    
27. void lcd_data(char data){
28. char temp;
29. temp=data&0xF0;
30. PORTC=temp|(1<<EN)|(1<<RS);
31. _delay_us(d_time);
32. PORTC=temp|(1<<RS);
33. _delay_us(d_time);
35. temp=data<<4;
36. PORTC=temp|(1<<EN)|(1<<RS);
37. _delay_us(d_time);
38. PORTC=temp|(1<<RS);
39. _delay_us(d_time);
40. }
41. void lcd_init(void){
42. DDRC=0xFF;
43. lcd_command(0x33);
44. _delay_us(100);
45. lcd_command(0x32);
46. _delay_us(100);
47. lcd_command(0x28);
48. _delay_us(100);
49. lcd_command(0x0F);
50. _delay_us(100);
51. lcd_command(0x01);
52. _delay_ms(5);
53. lcd_command(0x06);
54. _delay_us(100);
55. }
56. void lcd_xy(char x, char y){
57. char addr[]={0x80,0xC0};
58. lcd_command(addr[y-1]+x-1);
59. }
60. void lcd_text(char *text){
61. while(*text) lcd_data(*text++);
62. }
63. void lcd_clear(void){
64. lcd_command(0x01);
65. _delay_ms(5);
66. }
67. 
    

hd44780.h

1. /*
2. * hd44780.h
3. *
4. * Created: 1/28/2026 9:56:39 PM
5. * Author: Admin
6. */
7. 
   
8. 
   
9. #ifndef HD44780_H_
10. #define HD44780_H_
11. 
    
12. 
    
13. 
    
14. 
    
15. 
    
16. #endif /* HD44780_H_ */
17. 
    
18. #include <avr/io.h>
19. #include <stdio.h>
20. #include <util/delay.h>
21. 
    
22. #define F_CPU 16000000UL
23. 
    
24. 
    
25. #define RS 2
26. #define EN 3
27. 
    
28. const char d_time=50;
29. 
    
30. extern void lcd_command(char command);
31. extern void lcd_data(char data);
32. extern void lcd_init(void);
33. extern void lcd_xy(char x, char y);
34. extern void lcd_text(char *text);
35. extern void lcd_clear(void);

 

The key press counts is auto-increment and it will start a new line whenever it reaches 16 character counts. 

Proteus Simulation

In Proteus it work slower than in real hardware since I add a 500ms delay time. 

However on my AVR Prototype Board (PCBWay Offer) it work fine. 

This PCB was offered from PCBWay. 

I have been using PCBWay for many years now. PCBWay fabricate PCBs at low cost, fast processing time for only 24 hours, and fast delivery time using any carrier options. This double side 10cmx10cm can be fabricate at only 5USD for 5 to 10pcs by PCBWay. It's a standard PCB with silk screen and solder mask.

10 PCBs for only 5USD

 

For different size of PCB we can instantly quote on PCBWay website using a zip PCB Gerber file without account.

PCBWay Instant Quote

 

ATMega644P HD44780 Character LCD Interfacing

Overview

The industrial standard HD44780 character LCD controller is popular display among electronic hobbyists and commercial product for a few decade. Currently it still popular among students who start micro-controller programming, hobbyist electronic project or even low end consumer electronic product. It doesn't obsolete due to the newer replacement controllers that are fully compatible in controller chips and device footprint. It is very easy to use, wide availability and low cost.

 

There many choices for this LCD, 8x1, 8x2, 16x1, 16x2, 16x4, 20x4 etc. The manufacture produce many types of this LCD that have different character and back-light colors and size. 

The interface of this LCD is an 8-bit parallel port with three control pins. However the micro-processor can interfaces to this LCD using a 8-bit data transfer mode that can save pins usage. It is very common for most of micro-controller programming. For tutorial how to use this LCD controller please visit these post,

• ATMega32 Interfaces To HD44780 Character LCD Module 
• ATMega32 interfaces to HD44780 Character LCD in 4-bit mode 

ATMega644P LCD Interfacing

This simple task could be done using a smaller micro-controller for instance the PIC16F84A. However we can use any micro-controller that is suitable for the project. I have many 16x2 LCD and a few 16x4 LCD that left from my university time and finished projects.

TC1604A-01A 16x4 LCD Interfacing

This LCD module is obsolete now. But there are a lot of replacement LCD module with different color and very low cost. In this example the ATMega644P use its 8-bit PortA to send command and data to the LCD while PortC is selected as control pins. The R/W pin is wire to GND because the micro-controller just need to send data or command.

Top View

 

Back View

The brightness of this LCD is lower than new product since there is a limit on LED technology at that time. 

1. /*
2. * 6-hd4470_1604_8.c
3. *
4. * Created: 1/27/2026 8:02:41 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. #define RS 0
13. #define EN 2
14. 
    
15. void lcd_command(uint8_t command){
16. PORTA&=~(1<<RS);
17. PORTA|=(1<<EN);
18. PORTC=command;
19. PORTA&=~(1<<EN);
20. _delay_us(100);
21. }
22. 
    
23. void lcd_data(uint8_t data){
24. PORTA|=(1<<RS);
25. PORTA|=(1<<EN);
26. PORTC=data;
27. PORTA&=~(1<<EN);
28. _delay_us(100);
29. }
30. 
    
31. void lcd_text(char *txt){
32. while(*txt) lcd_data(*txt++);
33. }
34. 
    
35. void lcd_xy(char x, char y){
36. // 20x4 LCD
37. //uint8_t tbe[]={0x80,0xC0,0x94,0xD4};
38. // 16x4 LCD
39. char tbe[]={0x80,0xC0,0x90,0xD0};
40. lcd_command(tbe[y-1]+x-1);
41. _delay_ms(100);
42. }
43. 
    
44. void lcd_clear(void){
45. lcd_command(0x01);
46. _delay_ms(1000);
47. }
48. void lcd_init(void){
49. DDRA=0xFF;
50. DDRC=0xFF;
52. lcd_command(0x38);
53. _delay_us(100);
54. lcd_command(0x38);
55. _delay_us(100);
56. lcd_command(0x0C);
57. _delay_us(100);
58. lcd_command(0x06);
59. _delay_us(100);
60. }
61. 
    
62. struct date_time{
63. char hour;
64. char minute;
65. char second;
66. char *day_w;
67. char day_m;
68. char month;
69. int year;
70. };
72. int main(void)
73. {
74. /* Replace with your application code */
75. lcd_init();
76. lcd_clear();
77. lcd_text("HELLO WORLD!");
78. lcd_xy(1,2);
79. lcd_text("ATMEGA644P-20PU");
80. lcd_xy(1,3);
81. lcd_text("TC1604A-01A 16x4");
82. lcd_xy(1,4);
83. lcd_text("Microchip Studio");
84. _delay_ms(5000);
85. lcd_clear();
86. struct date_time my_date={10,30,10,
87. "Wed",28,1,2026};
88. char date[16];
89. lcd_xy(1,1);
90. lcd_text("Date:");
91. sprintf(date,"%s %02d/%02d/%04d",
92. my_date.day_w,my_date.day_m,
93. my_date.month,my_date.year);
94. lcd_xy(1,2);
95. lcd_text(date);
96. lcd_xy(1,3);
97. lcd_text("Time:");
98. sprintf(date,"%02d:%02d:%02d",
99. my_date.hour,my_date.minute,
100. my_date.second);
101. lcd_xy(1,4);
102. lcd_text(date);
103. while (1)
104. {
105. }
106. }
107. 
     

Proteus VSM also has a model for this old LCD module.

Schematic and Simulation

I wire the example program on my AVR Prototype Board with additional wiring on bread since this LCD is not on my AVR Prototype Board.

 

 

I have been using PCBWay for many years now. PCBWay fabricate PCBs at low cost, fast processing time for only 24 hours, and fast delivery time using any carrier options. This double side 10cmx10cm can be fabricate at only 5USD for 5 to 10pcs by PCBWay. It's a standard PCB with silk screen and solder mask.

10 PCBs for only 5USD

 

For different size of PCB we can instantly quote on PCBWay website using a zip PCB Gerber file without account.

PCBWay Instant Quote

ATMega644P 1602A 16x2 LCD Interfacing

I place a 16x2 LCD on my  AVR Prototype Board. I use a 4-bit data transfer mode to save pin counts. The ATMega644P and the 1602A are wired as follow:

• LCD RS(Register Select) connects to PC2.
• LCD RW(Read/Write) connects to GND.
• LCD EN(Enable) connects to PC3.
• LCD D7:4 connects to PC7:4 (4-bit data bus). 

Source Code:

1. /*
2. * 6-hd44780_1602_4.c
3. *
4. * Created: 1/27/2026 10:25:31 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <stdio.h>
10. #include <util/delay.h>
11. #define F_CPU 16000000UL
12. 
    
13. #define RS 2
14. #define EN 3
15. 
    
16. const char d_time=50;
17. 
    
18. void lcd_command(char command){
19. char temp;
20. temp=command&0xF0;
21. PORTC=temp|(1<<EN);
22. _delay_us(d_time);
23. PORTC=temp;
24. _delay_us(d_time);
26. temp=command<<4;
27. PORTC=temp|(1<<EN);
28. _delay_us(d_time);
29. PORTC=temp;
30. _delay_us(d_time);
31. }
32. 
    
33. void lcd_data(char data){
34. char temp;
35. temp=data&0xF0;
36. PORTC=temp|(1<<EN)|(1<<RS);
37. _delay_us(d_time);
38. PORTC=temp|(1<<RS);
39. _delay_us(d_time);
41. temp=data<<4;
42. PORTC=temp|(1<<EN)|(1<<RS);
43. _delay_us(d_time);
44. PORTC=temp|(1<<RS);
45. _delay_us(d_time);
46. }
47. void lcd_init(void){
48. DDRC=0xFF;
49. lcd_command(0x33);
50. _delay_us(100);
51. lcd_command(0x32);
52. _delay_us(100);
53. lcd_command(0x28);
54. _delay_us(100);
55. lcd_command(0x0F);
56. _delay_us(100);
57. lcd_command(0x01);
58. _delay_ms(5);
59. lcd_command(0x06);
60. _delay_us(100);
61. }
62. void lcd_xy(char x, char y){
63. char addr[]={0x80,0xC0};
64. lcd_command(addr[y-1]+x-1);
65. }
66. void lcd_text(char *text){
67. while(*text) lcd_data(*text++);
68. }
69. void lcd_clear(void){
70. lcd_command(0x01);
71. _delay_ms(5);
72. }
73. 
    
74. int main(void)
75. {
76. /* Replace with your application code */
77. lcd_init();
78. lcd_text("ATMega644P-20PU");
79. lcd_xy(1,2);
80. lcd_text("Microchip Studio");
81. _delay_ms(10000);
82. lcd_clear();
83. lcd_command(0x0C);
84. DDRA=0x00;
85. PINA=0xFF;
86. char data=0,data_old,temp[16];
87. while (1)
88. {
89. data=PINA;
90. if(data!=data_old){
91. lcd_xy(1,1);
92. sprintf(temp,"HEX: 0x%02X D: %3d",data,data);
93. lcd_text(temp);
94. for(char i=0;i<sizeof(temp);i++) temp[i]=0;
95. for (char i=0;i<8;i++)
96. {
97. if(data&(1<<i)) temp[7-i]='1';
98. else temp[7-i]='0';
99. }
100. lcd_xy(1,2); lcd_text("BIN: "); lcd_text(temp);
101. }
102. data_old=data;
103. }
104. }
105. 
     

Schematic and Simulation:

I tested this demo example on my AVR Prototype Board.

I tested this demo example on my AVR Prototype Board.

I tested this demo example on my AVR Prototype Board.

I tested this demo example on my AVR Prototype Board.