PIC18 Interrupt Programming
Interrupt Programming
• Contra and compare interrupts versus polling
• Explain the purpose of the ISR
• List all the major interrupts of the PIC18
• Explain the purpose of the IVT
• Enable and disable PIC18 interrupts
• Program the interrupt using c language
Interrupt
• Whenever any device needs the
microcontroller’s service the device notifies it by
sending an interrupt signal. Upon receiving an
interrupt signal, the microcontroller stops
whatever it is doing and serve the device. The
program associated with the interrupt is called
ISR (interrupt service routine) or interrupt
handler.
• Each device can get the attention of the
microcontroller based on the priority assign to it.
• Can ignore a device request for service
Polling
• The microcontroller continuously monitors the status
of a given device; when the status condition met, it
performs the service. After that, it moves on to
monitor the next device until each one is service.
• Cannot assign priority because it checks all devices in
a round-robin fashion.
• Cannot ignore a devices for service
Interrupt Service Routine (ISR)
Interrupt ROM Location (hex)
Power-on-Reset 0000
High Priority Interrupt 0008 (Default upon power-on
reset)
Low Priority Interrupt 0018
Interrupt Vector Table
Fixed Location in Memory
Step in Executing an Interrupt
1. It finishes the instruction it is executing and saves
the address of the next instruction (program
counter) on the stack
2. It jumps to a fixed location in memory (interrupt
vector table (IVT)). The IVT directs the
microcontroller to the address of the ISR
3. The microcontroller gets the address of the ISR
from the IVT and jumps to it. It start to execute
the interrupt service subroutine until it reaches
the last instruction of the subroutine - RETFIE
(Return from Interrupt Exit)
4. Upon executing the RETFIE instruction, the
microcontroller returns to the place where it was
interrupted
Sources of Interrupt
• Each Timers
• 3 interrupts for external hardware. Pin RB0 (INT0),
RB1 (INT1) and RB2 (INT2)
• 2 interrupts for serial communication (Receive and
Transmit)
• The PORTB-Change interrupt (RB4-RB7)
• The ADC
• The CCP
Enable and Disable an Interrupt
BSF INTCON,GIE
BCF INTCON,GIE
Timer Interrupts
Interrupt Flag Bit Register Enable Bit Register
Timer0 TMR0IF INTCON TMR0IE INTCON
Timer1 TMR1IF PIR1 TMR1IE PIE1
Timer2 TMR2IF PIR1 TMR3IE PIE1
Timer3 TMR3IF PIR3 TMR3IE PIE2
Timer Interrupt Flag Bits and Associated Registers
INTCON Register with Timer0 Interrupt Enable and Interrupt Flag
Interrupt vector to control the ISR
Because C18 does not place ISR at IVT automatically, we use
ASM instruction GOTO at IV to transfer control to ISR
#pragma code high_vector=0x0008 //High priority int location
void My_HiVect_int(void)
{
_asm
GOTO my_isr
_endasm
}
#pragma code //end of code
Redirect from 0008 to another program to find interrupt source
and the ISR
#pragma interrupt my_isr //interrupt is a reserved word
void my_isr(void)
{
//C18 places RETFIE here automatically due to interrupt
//keyword
Note : “pragma” , “code” and “interrupts” reserved keyword
EX. Use T0 and T1 to generate square-wave on pins RB1
and RB7, while data being transfer from PC to PD.
#include <P18f458.h>
#define MyPB1bit PORTBbits.RB1 //input switch
#define MyPB1bit PORTBbits.RB7 //input switch
void T0_ISR(void);
void T1_ISR(void);
#pragma interrupt my_isr
void chk_isr(void)
{
If(INTCONbits.TMR0IF==1) //T0 causes int ?
T0_ISR //yes, execute T0 ISR
If(INTCONbits.TMR1IF==1) //T1 causes int ?
T1_ISR //yes, execute T0 ISR
}
#pragma code My_HiPrio=0x0008 //High priority int loc
void My_HiPrio_int(void)
{
_asm
GOTO chk_isr
_endasm
}
#pragma code
void main(void)
{
TRISBbits.TRISB1=0; //PB1 as output;
TRISBbits.TRISB7=0; //PB7 as output;
TRISC = 0xFF //PC as intput;
TRISD = 0x00 //PD as output;
T0CON = 0x00; //T0, 16-bit , no pre-scale
TMR0H = 0x35;
TMR0L = 0x00;
T1CON = 0x08; //T1, 16-bit , no pre-scale
TMR0H = 0x35;
TMR0L = 0x00;
INTCONbits.TMR0IF=0; //clear TF0;
PIR1bits.TMR1IF=0; //clear TF1;
INTCONbits.TMR0IE=1; //enable T0 int;
INTCONbits.TMR1IE=1; //enable T1 int;
INTCONbits.TMR0ON=1; //turn on T0;
INTCONbits.TMR1ON=1; //turn on T1;
INTCONbits.PEIE=1; //enable all pheperal int;
INTCONbits.GIE=1; //enable all int globally;
While(1) //keep looping until int occur
{
PORTD=PORTC //send data fromPC to PD
}
}
void T0_ISR(void)
{
myPB1bit=~myPB1bit; //toggle PB.1;
TMR0H = 0x35;
TMR0L = 0x00;
INTCONbits.TMR0IF=0; //clear TF0;
}
void T1_ISR(void)
{
myPB7bit=~myPB7bit; //toggle PB.7;
TMR1H = 0x35;
TMR1L = 0x00;
INTCONbits.TMR1IF=0; //clear TF1;
}
External Hardware Interrupts
Interrupt Flag Bit Register Enable Bit Register
INT0(RB0) INT0IF INTCON INT0IE INTCON
INT1 (RB1) INT1IF INTCON3 INT1IE INTCON3
INT2 (RB2) INT2IF INTCON3 INT2IE INTCON3
Hardware Interrupt Flag Bits and Associated Registers
Positive-edge-
triggered interrupt
EX. When ↑ (rise-edge) on pin INT0, LED will toggle.
#include <P18f458.h>
#define Mybit PORTBbits.RB7
void chk_isr(void);
void INT0_ISR(void);
#pragma interrupt chk_isr
void chk_isr(void)
{
If(INTCONbits.INT0IF==1 ) //INT0 causes int ?
INT0_ISR(); //yes, execute INT0 prg
}
#pragma code My_HiPrio_Int=0x08 //high-priority int loc
void My_HiPrio_int(void)
{
_asm
GOTO chk_isr
_endasm
}
#pragma code
void main(void)
{
TRISBbits.TRISB7=0; //PB7 as output;
TRISBbits.TRISB0=1; //PB1 as input;
TRISC = 0xFF //PC as intput;
TRISD = 0x00 //PD as output;
INTCONbits.INT0IF=0; //clear TF0;
INTCONbits.INT0IE=1 //enable T0 interrupt
INTCONbits.GIE=1; //enable all int globally;
While(1) //keep looping until int occur
{
PORTD=PORTC //send data fromPC to PD
}
}
void INT0_ISR(void)
{
mybit=~mybit; //toggle mybit;
INTCONbits.INT0IF=0; //clear INT0 flag;
}
Serial Communication Interrupts
Interrupt Flag Bit Register Enable Bit Register
TXIF TXIF PIR1 TXIE PIE1
(Trasmit)
RCIF RCIF PIR1 RCIE PIE1
(Receive)
Serial Port Interrupt Flag Bits and Associated Registers
PIE1 Register Bits Holding TXIE and RCIE
EX. Get data from PD and send to TXREG continuously while
incoming data from serial is send to PB. Assume XTAL 10
MHz and baud rate is 9600.
#include <P18f458.h>
void chk_isr(void);
void TX_ISR(void);
void RC_ISR(void);
#pragma code My_HiPrio_Int=0x08 //high-priority int loc
void My_HiPrio_int(void)
{
_asm
GOTO chk_isr
_endasm
}
#pragma code
#pragma interrupt chk_isr //used for high prioity int
void chk_isr(void)
{
If(PIR1bits.TXIF==1) //Tx causes int ?
TX_ISR(); /yes, execute Tx prg
If(PIR1bits.RCIF==1) //RC causes int ?
RC_ISR(); /yes, execute RC prg
}
void main(void)
{
TRISD = 0xFF //PD as intput;
TRISB = 0x00 //PB as output;
TRISBbits.TRISC6=0; //TX pin output;
TRISBbits.TRISC7=1; //RC pin input;
TXSTA=0x20 //low baud rate, 8-bit
SPBRG=15 //9600 baud rate (XTA =10
RCSTAbits.CREN=1;
RCSTAbits.SPEN=1;
TXSTAbits.TXEN=1;
PIE1bits.RCIE= 1; //enable RC int
PIE1bits.TXIE= 1; //enable TX int
INTCONbits.PIE=1; //enable peripheral int;
INTCONbits.GIE=1; //enable all int globally;
While(1); //keep looping until int occur
}
void TX_ISR(void)
{
TXREG=PORTD;
}
void RC_ISR(void)
{
PORTB=RCREG;
}
}
PORTB-Change Interrupt
Differences Between External Hardware and
PORTB-Change Interrupt
External Hardware PORTB-Change
This (RB0-RB2) interrupts has its own pin Use all four (RB4-RB7) and considered to be
and is independent each other a single interrupt even though it can use up
to four pins
Has it own flag (INTxIF) and independent Single flag only (RBIF)
each other
Can be programmed to trigger on the Cause an interrupt either pin changes
negative or positive edge status from HIGH-LOW or LOW-HIGH
EX. Connect SW1 and SW2 to pins RB4 and RB5
respectively. SW1 and SW2 will change LED1 and LED2.
#include <P18f458.h>
#define LED1 PORTCbits.RC1
#define LED2 PORTCbits.RC2
void chk_isr(void);
void RBINT_ISR(void);
#pragma code My_HiPrio_Int=x08 //high-priority int loc
void My_HiPrio_int(void)
{
_asm
GOTO chk_isr
_endasm
}
#pragma code
#pragma interrupt chk_isr //used for high prio int
void chk_isr(void)
{
If(INTCONbits.RBIF==1 //RBIF causes int ?
RBINT_ISR(); //yes, execute INT0 prg
}
void main(void)
{
TRISCbits.TRISC1=0; //PC4 as output;
TRISCbits.TRISC2=0; //PC5 as ouput;
TRISBbits.TRISB4=1; //PB4 input for int;
TRISBbits.TRISB5=1; //PB5 input for int;
INTCONbits.RBIF=0; //clear RIF;
INTCONbits.RBIE=1; //enable RB int;
INTCONbits.GIE=1; //enable all int globally;
}
void RBINT_ISR(void)
{
LED1 = PORTBbits.RB4;
LED2 = PORTBbits.RB5;
INTCONbits.RBIF=0; //clear RBIF flag;
}
Interrupt Priority
Interrupt ROM Location (hex)
Power-on-Reset 0000
High Priority Interrupt 0008 (Default upon power-on reset)
Low Priority Interrupt 0018
RCON Register
IPR1 Peripheral Interrupt Priority Register
