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.

 
 

 

dsPIC30F2010 Prototype Board CCS PICC Examples (Continue)

In previous post I putted some examples of using the dsPIC30F2010 prototype board. However it's too long. So I need to write some remaining posts here.

PCBWay.com Sponsor PCB Project

 

Creating a PWM Output Using Code Generation Wizard

Generating a PWM output signal could be done from scratch with a few line of code using CCS PICC. We can use its code generation wizard or even manually. 

PWM Output Pin of OC1

 

After clicking on Create Project it will generate source code. Then pressing F9 to compile this project.

The main.c C source code is just like below.

1. #include <main.h>
2. 
   
3. 
   
4. void main()
5. {
6. 
   
7. while(TRUE)
8. {
9. //TODO: User Code
10. }
11. 
    
12. }

 Then double click on the main.h header file we will see its source code.

1. #include <30F2010.h>
2. #device ICSP=1
3. #use delay(crystal=20000000)
4. 
   
5. #FUSES NOWDT //No Watch Dog Timer
6. #FUSES CKSFSM //Clock Switching is enabled, fail Safe clock monitor is enabled
7. 
   
8. 
   
9. #use pwm(OC1,TIMER=2,FREQUENCY=10000,DUTY=0)

It will generate a PWM signal output at pin OC1 (RC13) with a frequency of 10kHz and 0% duty cycle. If we want a 50% duty cycle we need to change the DUTY parameter to 50, and rebuilt it.

PWM Duty Cycle Adjusting with ADC

After using the code generation wizard I got some idea of using PWM in CCS PICC. So I modify and write more codes to adjust PWM signal. I use the on-board ADC input from a potentiometer. Then it will convert to PWM duty cycle ranging from 0% to 100%.

1. #include "board.h"
2. 
   
3. #use pwm(OC1,TIMER=2,FREQUENCY=10000,STREAM=_1,DUTY=50)
4. void main()
5. {
6. long adc_value = 0;
7. float duty_cycle = 0;
8. setup_adc_ports(sAN4);
9. setup_adc(ADC_CLOCK_INTERNAL | ADC_TAD_MUL_31);
10. 
    
11. 
    
12. while(TRUE)
13. {
14. //TODO: User Code
15. set_adc_channel(4);
16. delay_us(10);
17. adc_value = read_adc();
18. duty_cycle = (1000.0*adc_value)/1023;
19. pwm_set_duty(_1,(int)duty_cycle);
20. //pwm_set_duty_percent(_1,(int)duty_cycle);
21. delay_ms(100);
22. }
23. 
    
24. }

And its "board.h" file:

1. #include <30F2010.h>
2. #device ADC=10
3. #device ICSP=1
4. #fuses HS,NODEBUG,NOWDT,PR,CKSFSM
5. #use delay(crystal=20000000)
6. 
   
7. 
   
8. #use FIXED_IO( D_outputs=PIN_D1,PIN_D0 )
9. #use rs232(UART1, baud=9600, stream=UART_PORT1)
10. 
    
11. #define LED0 PIN_D0
12. #define LED1 PIN_D1
13. #define SW0 PIN_C13
14. #define SW1 PIN_C14
15. 
    
16. #define DELAY 500
17. 
    

It work fine without wiring additional components. However we can connect the OC1(RC13) PWM pin to a larger LED ( for instance a 5VDC 10mm LED).

 

Low Duty Cycle

High Duty Cycle

Click here to download its source file.  

ADC with On-board Tactile Switches and PWM

Fortunately there are two on-board tactile switches that could be used to adjust PWM duty cycle. So I will use ADC channel 4, SW4 (RC13) and SW5(RC14) to adjust PWM duty cycle of OC1 and OC2 respectively.

PWM Adjustment Using Pot and Tactile Switches

The PWM OC1 is generated by Timer 2 while the PWM OC2 is generated by Timer 3. 

1. #include "board.h"
2. 
   
3. #use pwm(OC1,TIMER=2,FREQUENCY=10000,STREAM=_1,DUTY=0)
4. #use pwm(OC2,TIMER=3,FREQUENCY=10000,STREAM=_2,DUTY=0)
5. 
   
6. void main()
7. {
8. long adc_value = 0;
9. int oc2_count=0;
10. float duty_cycle = 0;
11. set_pullup(TRUE,PIN_C13);
12. set_pullup(TRUE,PIN_C14);
13. setup_adc_ports(sAN4);
14. setup_adc(ADC_CLOCK_INTERNAL | ADC_TAD_MUL_31);
15. 
    
16. while(TRUE)
17. {
18. //TODO: User Code
19. set_adc_channel(4);
20. delay_us(10);
21. adc_value = read_adc();
22. duty_cycle = (1000.0*adc_value)/1023;
23. pwm_set_duty(_1,(int)duty_cycle);
25. if(input(SW0)==0){
26. if(oc2_count<1000) oc2_count+=100;
27. pwm_set_duty(_2,oc2_count);
28. delay_ms(250);
29. }
30. if(input(SW1)==0){
31. if(oc2_count>0) oc2_count-=100;
32. pwm_set_duty(_2,oc2_count);
33. delay_ms(250);
34. }
35. }
36. 
    
37. }

Its "board.h" header file:

1. #include <30F2010.h>
2. #device ADC=10
3. #device ICSP=1
4. #fuses HS,NODEBUG,NOWDT,PR,CKSFSM
5. #use delay(crystal=20000000)
6. 
   
7. #use rs232(UART1, baud=9600, stream=UART_PORT1)
8. 
   
9. #define LED0 PIN_D0
10. #define LED1 PIN_D1
11. #define SW0 PIN_C13
12. #define SW1 PIN_C14
13. 
    
14. #define DELAY 500
15. 
    

Click here to download its source file.

Timer Tick Example

We can use timer tick for timing delay and scheduling instead of using the delay function. We can call it from scratch using the CCS PICC IDE PIC24 project wizard.

Timer Tick Example Using Timer 1

 Then we get generated code lists below.

• main.h

1. #include <30F2010.h>
2. #device ICSP=1
3. #use delay(crystal=20000000)
4. 
   
5. #FUSES NOWDT //No Watch Dog Timer
6. #FUSES CKSFSM //Clock Switching is enabled, fail Safe clock monitor is enabled
7. 
   
8. 
   
9. #use timer(timer=1,tick=100us,bits=32,NOISR)
10. 
    
11. #define TICK_TYPE unsigned int32

• main.c

 

1. #include <main.h>
2. TICK_TYPE GetTickDifference(TICK_TYPE currTick, TICK_TYPE prevTick)
3. {
4. return(currTick-prevTick);
5. }
6. 
   
7. void timer_1_tick(void)
8. {
9. //TODO: User Code
10. }
11. 
    
12. 
    
13. void main()
14. {
15. 
    
16. TICK_TYPE CurrentTick,PreviousTick;
17. 
    
18. 
    
19. 
    
20. //Example program using Tick Timer
21. CurrentTick = PreviousTick = get_ticks();
22. 
    
23. while(TRUE)
24. {
25. CurrentTick = get_ticks();
26. 
    
27. if(GetTickDifference(CurrentTick, PreviousTick) >= ((TICK_TYPE)TICKS_PER_SECOND*1)/1000)
28. {
29. timer_1_tick();
30. PreviousTick = CurrentTick;
31. }
32. 
    
33. //TODO: User Code
34. }
35. 
    
36. }

 Then I need to add some codes to these existing source codes.

•  main.h

 

1. #include <30F2010.h>
2. #device ICSP=1
3. #use delay(crystal=20000000)
4. 
   
5. #FUSES NOWDT //No Watch Dog Timer
6. #FUSES CKSFSM //Clock Switching is enabled, fail Safe clock monitor is enabled
7. 
   
8. 
   
9. #use FIXED_IO( D_outputs=PIN_D1,PIN_D0 )
10. 
    
11. #define LED1 PIN_D0
12. #define LED2 PIN_D1
13. 
    
14. 
    
15. #use timer(timer=1,tick=100us,bits=32,NOISR)
16. 
    
17. #define TICK_TYPE unsigned int32
18. 
    

• main.c

1. #include <main.h>
2. 
   
3. unsigned int16 count_1_ms=0, count_100_ms=0;
4. 
   
5. TICK_TYPE GetTickDifference(TICK_TYPE currTick, TICK_TYPE prevTick)
6. {
7. return(currTick-prevTick);
8. }
9. 
   
10. void timer_1_tick(void)
11. {
12. //TODO: User Code
13. count_1_ms++;
14. if(count_1_ms>=100) {
15. output_toggle(LED2);
16. count_1_ms=0;
17. count_100_ms++;
18. }
19. if(count_100_ms>=5){
20. output_toggle(LED1);
21. count_100_ms=0;
22. }
23. }
24. 
    
25. 
    
26. void main()
27. {
28. 
    
29. TICK_TYPE CurrentTick,PreviousTick;
30. 
    
31. 
    
32. 
    
33. //Example program using Tick Timer
34. CurrentTick = PreviousTick = get_ticks();
35. 
    
36. while(TRUE)
37. {
38. CurrentTick = get_ticks();
39. 
    
40. if(GetTickDifference(CurrentTick, PreviousTick) >= ((TICK_TYPE)TICKS_PER_SECOND*1)/1000)
41. {
42. timer_1_tick();
43. PreviousTick = CurrentTick;
44. }
45. 
    
46. //TODO: User Code
47. }
48. 
    
49. }

 It will blink LEDs connect to RD0 and RD1 at different rates.

 

RD0 and RD1 at different rates

RD0 and RD1 at different rates

 Click here to download its source file.

Timer 1 Interrupt Example Using Coder Generation Wizard

Timer1 module operates in many modes up to software configuration, internal, gated and external. We can write its source manually or even using the CCS PICC code generation wizard. 

Using Code Generation Wizard

Then it will generate a skeleton code below that we have to add more code manually.

1. #include <main.h>
2. 
   
3. #INT_TIMER1
4. void timer1_isr(void)
5. {
6. 
   
7. }
8. 
   
9. 
   
10. 
    
11. void main()
12. {
13. 
    
14. setup_timer1(TMR_INTERNAL | TMR_DIV_BY_1, 1000);
15. 
    
16. enable_interrupts(INT_TIMER1);
17. enable_interrupts(INTR_GLOBAL);
18. 
    
19. while(TRUE)
20. {
21. //TODO: User Code
22. }
23. 
    
24. }

 Then I need to add more codes both in main function and Timer interrupt service routine "#INT_TIMER1".

 

1. #include <main.h>
2. 
   
3. unsigned int16 timer_1_counts=0;
4. #INT_TIMER1
5. void timer1_isr(void)
6. {
7. output_toggle(PIN_D0);
8. timer_1_counts++;
9. clear_interrupt(INT_TIMER1);
10. }
11. 
    
12. 
    
13. 
    
14. void main()
15. {
16. 
    
17. setup_timer1(TMR_INTERNAL | TMR_DIV_BY_256, 1000);
18. 
    
19. enable_interrupts(INT_TIMER1);
20. enable_interrupts(INTR_GLOBAL);
21. 
    
22. while(TRUE)
23. {
24. //TODO: User Code
25. if(timer_1_counts>=100){
26. output_toggle(pin_d1);
27. timer_1_counts=0;
28. }
29. }
30. 
    
31. }

This source codes will blink pin RD0 and RD1 at different rates. Click here to download its source file.

Change Notify (CN) Interrupt

Change Notify Interrupt (CNI) allow the program to fast response to external event change. For instance a change from logic high to low or vice versa. There are two tactile switches connect to RC13(CN1) and RC14(CN0) respectively. There are no external pull up or pull down resistors. So you need to add more external components to detect input logic change requirement.

TABLE 8-2: INPUT CHANGE NOTIFICATION REGISTER MAP (BITS 15-0)

Fortunately the Change Notify Interrupt (CNI) come with internal pull-up enable feature that we can enable or disable it by software setting. The CNENx and CNPUx special register responsible for this task. 

 

The program below demonstrate a simple use of Change Notify (CN) Interrupt of pin CN0(RC14). The LED connects to pin RD0 keeps blinking at the rate of 500ms in main program's loop. Whenever the CN0 input logic changes to logic low the CNI occurs. It will toggle the LED connects to pin RD1.

• main.c 

1. #include <main.h>
2. 
   
3. /*CN Pull Up Enable Register*/
4. #byte CNPU1=0x0C4;
5. #bit CN0PU=CNPU1.0;
6. /*CN Interrupt Enable Register*/
7. #byte CNIEN1=0x0C0;
8. #bit CN0EN=CNIEN1.0;
9. 
   
10. /*Interrupt Service Routine for CN Interrupt*/
11. #INT_CNI
12. void cni_isr(void)
13. {
14. if(!input(CN0)) output_toggle(LED2);
15. clear_interrupt(INT_CNI);
16. }
17. 
    
18. 
    
19. void main()
20. {
21. /*PortC As Inputs*/
22. set_tris_c(0xFFFF);
23. /*Turn On CN0 PullUp and CN0 Interrupt*/
24. CN0PU=1;
25. CN0EN=1;
26. /*Enable Interrupt*/
27. enable_interrupts(INTR_CN_PIN|PIN_C13);
28. enable_interrupts(INTR_GLOBAL);
29. clear_interrupt(INT_CNI);
30. while(TRUE)
31. {
32. //TODO: User Code
33. output_toggle(LED1);
34. delay_ms(500);
35. }
36. 
    
37. }

•  main.h

1. #include <30F2010.h>
2. #device ICSP=1
3. #use delay(crystal=20000000)
4. 
   
5. #FUSES NOWDT
6. //No Watch Dog Timer
7. #FUSES CKSFSM
8. //Clock Switching is enabled, fail Safe clock monitor is enabled
9. 
   
10. 
    
11. #use FIXED_IO( D_outputs=PIN_D1,PIN_D0 )
12. 
    
13. #define CN1 PIN_C13
14. #define CN0 PIN_C14
15. #define LED1 PIN_D0
16. #define LED2 PIN_D1
17. 
    
18. 
    

 I tested this demo program on my dsPIC30F2010 prototype board. It work fine and very fast. Click here to download this example program.

Now I use all tactile switches connect to RC13 and RC14 to generate Change Notification Interrupt (CNI). Every time the CN interrupts occur it will toggle the LEDs.

• main.c

 

1. #include <main.h>
2. 
   
3. /*CN Pull Up Enable Register*/
4. #byte CNPU1=0x0C4;
5. #bit CN0PU=CNPU1.0;
6. #bit CN1PU=CNPU1.1;
7. /*CN Interrupt Enable Register*/
8. #byte CNIEN1=0x0C0;
9. #bit CN0EN=CNIEN1.0;
10. #bit CN1EN=CNIEN1.1;
11. 
    
12. /*Interrupt Service Routine for CN Interrupt*/
13. #INT_CNI
14. void cni_isr(void)
15. {
16. if(!input(CN0)) output_toggle(LED2);
17. if(!input(CN1)) output_toggle(LED1);
18. clear_interrupt(INT_CNI);
19. }
20. 
    
21. 
    
22. void main()
23. {
24. /*PortC As Inputs*/
25. set_tris_c(0xFFFF);
26. /*Turn On CN0 PullUp and CN0 and CN1 Interrupt*/
27. CN0PU=1;
28. CN0EN=1;
29. CN1PU=1;
30. CN1EN=1;
31. /*Enable Interrupt*/
32. //enable_interrupts(INTR_CN_PIN|PIN_C13);
33. //enable_interrupts(INTR_CN_PIN|PIN_C14);
34. enable_interrupts(INT_CNI);
35. enable_interrupts(INTR_GLOBAL);
36. clear_interrupt(INT_CNI);
37. while(TRUE)
38. {
39. //TODO: User Code
40. }
41. 
    
42. }

I take some special registers of CN interrupt to use in this program because using the CCS PICC built-in library is not enough.

• main.h

1. #include <30F2010.h>
2. #device ICSP=1
3. #use delay(crystal=20000000)
4. 
   
5. #FUSES NOWDT
6. //No Watch Dog Timer
7. #FUSES CKSFSM
8. //Clock Switching is enabled, fail Safe clock monitor is enabled
9. 
   
10. 
    
11. #use FIXED_IO( D_outputs=PIN_D1,PIN_D0 )
12. 
    
13. #define CN1 PIN_C13
14. #define CN0 PIN_C14
15. #define LED1 PIN_D0
16. #define LED2 PIN_D1
17. 
    
18. 
    
19. 
    

There are some bounce while pressing the tactile switches. So it's suitable to add and RC filter circuit to eliminate this noise. Using a software delay in the ISR is a good choice to bypass this noisy bouncing period.

 

Click here to download this program example.