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.