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.

ATMega644P Pin Change Interrupt Example

Overview

In previous post I introduce about external interrupt of the ATMega644P that has only three interrupt source with software select-able. Additionally to the external interrupt the this chip has four more interrupt source that is the Pin Change Interrupt (PCINTXX). It triggers whenever there is any logic change at each pins. 

The Pin change interrupt PCI3 will trigger if any enabled PCINT31:24 pin toggle, Pin change
interrupt PCI2 will trigger if any enabled PCINT23:16 pin toggles, Pin change interrupt PCI1 if
any enabled PCINT15:8 toggles and Pin change interrupts PCI0 will trigger if any enabled
PCINT7:0 pin toggles. PCMSK3, PCMSK2, PCMSK1 and PCMSK0 Registers control which pins contribute to the pin change interrupts. Pin change interrupts on PCINT31:0 are detected asynchronously. This implies that these interrupts can be used for waking the part also from sleep modes other than Idle mode. 

ATMega644P 40-Pin DIP Pin Diagram

However any logic change from high to low or even from low to high can generate interrupt. To select any logic level the programmer must mask one logic level.

The Pin Change Interrupt source are distinct from external interrupt so they are grouped in different registers. These are some essential registers relate to PCINTXX:

1. PCICR – Pin Change Interrupt Control Register 
2. PCIFR – Pin Change Interrupt Flag Register 
3. PCMSK3 – Pin Change Mask Register 3 
4. PCMSK2 – Pin Change Mask Register 2 
5. PCMSK1 – Pin Change Mask Register 1 
6. PCMSK0 – Pin Change Mask Register 0 

To use any interrupt source the programmer must enable it, write the ISR and test its interrupt flag. 

Relevant Registers

 

Pin Change Interrupt Programming in C

Using AVR-LibC in Microchip Studio the programming of this interrupt source could be done from scratch just like we state it above. 

Schematic

In this example the interrupt source is at PortD (PCINT31:24). That's the Pin Change Interrupt 3. Each time the logic low level is detected the ISR will toggle the LED connects to PortB. PC0 blinks a LED for every 500ms.

1. /*
2. * 5-PCINT_2_LED.c
3. *
4. * Created: 1/27/2026 10:10:26 AM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <avr/interrupt.h>
10. #include <util/delay.h>
11. #define F_CPU 16000000UL
12. 
    
13. volatile uint8_t mask=0;
14. 
    
15. int main(void)
16. {
17. /* Replace with your application code */
18. DDRB=0xFF;
19. DDRC=0xFF;
20. DDRD=0x00;
21. PIND=0xFF;
22. PCICR=0x08;
23. PCMSK3=0xFF;
25. sei();
26. while (1)
27. {
28. PORTC^=0x01;
29. _delay_ms(500);
30. }
31. }
32. 
    
33. /*Pin Change Interrupt ISR*/
34. ISR(PCINT3_vect){
35. switch(PIND){
36. case 0xFE: PORTB^=0x01;
37. break;
38. case 0xFD: PORTB^=0x02;
39. break;
40. case 0xFB: PORTB^=0x04;
41. break;
42. case 0xF7: PORTB^=0x08;
43. break;
44. case 0xEF: PORTB^=0x10;
45. break;
46. case 0xDF: PORTB^=0x20;
47. break;
48. case 0xBF: PORTB^=0x40;
49. break;
50. case 0x7F: PORTB^=0x80;
51. break;
52. }
53. }
54. 
    

In Proteus VSM this program run correctly. In physical Hardware I has some switches bouncing problems.

Test Program

I tested this program on my AVR Prototype Board that offered by PCBWay.com. 

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

I tested this demo example on my AVR Prototype Board.

 

ATMega644P External Interrupt Programming

Overview

An interrupt is a notification for CPU of a micro-controller. It happen very fast commanding the CPU to execute the routine in the Interrupt Service Routine (ISR) handler without waiting for next instruction execution . This mechanism make the program execution more responsive and effective.

The ATMega644P has many interrupt source each corresponds to their interrupt vector number.

Interrupt Vectors in ATmega644

An interrupt source could happen whenever the user's program enable it and properly configure it. 

External Interrupt Programming in C

The Atmega644P has three external interrupt sources, INT0( PD2), INT1(PD3) and INT2(PB2). These interrupt sources are use to detect edge(falling or rising) and logic level (Low or High). Their interrupt vector addresses are list in the figure above.

I Microchip Studio that use the AVR-LibC tool-chain the programmer doesn't need to remember the address number of each source. All of them have a readable name specified the compiler.

The programmer must modify these registers to enable the external interrupts.

1. EICRA – External Interrupt Control Register A ( Modes: edge or logic level)
2. EIMSK – External Interrupt Mask Register (Enable or Disable)
3. EIFR – External Interrupt Flag Register (Flag of external interrupt source)

 These feature are common for most of the 40-pin AVR ATMega series.

In this example I use these interrupt sources to toggle each LED at PortB.

1. /*
2. * 4-external_interrupt.c
3. *
4. * Created: 1/25/2026 7:12:38 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include "avr/interrupt.h"
10. #include <util/delay.h>
11. #define F_CPU 16000000UL
12. 
    
13. int main(void)
14. {
15. /* Replace with your application code */
16. DDRB=0xFF;
17. DDRB&=~(1<<2);
18. DDRD=0x01;
19. PINB=(1<<2);
20. PIND=(1<<2)|(1<<3);
21. EIMSK=0x07;
22. sei();
23. while (1)
24. {
25. PORTD^=1;
26. _delay_ms(500);
27. }
28. }
29. 
    
30. /*
31. Interrupt Service Routine (ISR)
32. for External Interrupt
33. */
34. ISR(INT0_vect){
35. PORTB^=(1<<5);
36. }
37. 
    
38. ISR(INT1_vect){
39. PORTB^=(1<<6);
40. }
41. 
    
42. ISR(INT2_vect){
43. PORTB^=(1<<7);
44. }
45. 
    

 

Proteus VSM simulate this program correctly. 

Proteus Schematic and Simulation

However in real hardware the input button bounce. So we need to add a short delay time in the ISR or adding a low pass filter to each input button. 

Testing in Real Hardware

Multiplexing Display Example

Since the interrupts happens very fast it's suitable to make a counting display that counts the time of switch pressing. The on-board display has up to six digits that able display the number of 999999.

1. /*
2. * 4-ext_interrupt_6_digit_16M.c
3. *
4. * Created: 1/26/2026 8:53:49 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <avr/interrupt.h>
10. #include <util/delay.h>
11. #define F_CPU 16000000UL
12. 
    
13. const uint8_t cc_7[16]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,
14. 0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71};
15. const uint16_t d_time=5;
16. volatile long count=0;
17. int main(void)
18. {
19. /* Replace with your application code */
20. DDRB=0xFF;
21. DDRC=0xFF;
22. DDRD=0x00;
23. PIND=(1<<2)|(1<<3);
24. EIMSK=0x03;
25. sei();
26. while (1)
27. {
28. PORTC=0;
29. PORTB=cc_7[count/100000];
30. PORTC=0x20;
31. _delay_ms(d_time);
33. PORTC=0;
34. PORTB=cc_7[(count%100000)/10000];
35. PORTC=0x40;
36. _delay_ms(d_time);
38. PORTC=0;
39. PORTB=cc_7[(count%10000)/1000];
40. PORTC=0x80;
41. _delay_ms(d_time);
43. PORTC=0;
44. PORTB=cc_7[(count%1000)/100];
45. PORTC=0x04;
46. _delay_ms(d_time);
48. PORTC=0;
49. PORTB=cc_7[(count%100)/10];
50. PORTC=0x08;
51. _delay_ms(d_time);
53. PORTC=0;
54. PORTB=cc_7[count%10];
55. PORTC=0x10;
56. _delay_ms(d_time);
57. }
58. }
59. 
    
60. /*
61. Interrupt Service Routine (ISR)
62. for External Interrupt
63. */
64. ISR(INT0_vect){
65. count++;
66. if(count>999999) count=0;
67. }
68. 
    
69. ISR(INT1_vect){
70. count--;
71. if(count<0) count=999999;
72. }

Whenever each buttons are pressed it will update the value on the display.

Program Simulation

In Proteus VSM the display run very smooth without flickering.

However in real hardware the display flickers whenever any button is pressed due to switch bouncing. It does not increase or decrease by one.

I tested this program on my AVR Prototype Board that offered by PCBWay.com. 

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

I tested this demo example on my AVR Prototype Board.