Sinhgad College of Engineering
Dept. of Information Technology
Class - SE
Processor Architecture (214451)
Unit-3: PIC Microcontroller Interrupts
Faculty – Prof. Madhukar V. Nimbalkar
[email protected] 9890586765
Introduction
Interrupts can be defined as asynchronous request for
service by peripherals to processor.
Interrupts are mechanisms which enable instant response
to events such as counter overflow, pin change, data
received, etc.
In normal mode, microcontroller executes the main
program as long as there are no occurrences that would
cause an interrupt.
Upon interrupt, microcontroller stops the execution of
main program and commences the special part of the
program(ISR) which will analyze and handle the interrupt.
The PIC uCs
PIC18 interrupts
PIC can serve multiple devices using mechanisms of
Polling
PIC continuously monitors the status of each device
Each device get the attention of the CPU as the same
level of priority
Wastes u-Controllers time by polling devices that do not
need service.
Interrupt
Devices get the attention of the CPU only when it needs
a service
Can service many devices with different level of
priorities
The PIC uCs
Interrupt service routine (ISR)
When an interrupt is invoked
the uC runs the Interrupt
Service Routine(ISR)
Interrupt vector table holds
the address of ISRs
Power-on Reset 0000h
High priority interrupt
0008h
Low priority interrupt
0018h
The PIC uCs
Steps in executing an interrupt
Upon activation of interrupt the microcontroller
Finishes executing the current instruction
Pushes the PC of next instruction in the stack
Jumps to the interrupt vector table to get the address
of ISR and jumps to it
Begin executing the ISR instructions to the last
instruction of ISR (RETFIE)
Executes RETFIE
Pops the PC from the stack
Starts to execute from the address of that PC
The PIC uCs
Sources of interrupts in PIC18
External hardware interrupts USART Interrupts
Pin RB0(INT0),RB1(INT1), Receive Interrupt
RB2(INT2) Transmit Interrupt
PORTB change (RB4- RB7) A/D Conversion Complete
Peripheral Interrupts Interrupt
Timers Overflow Interrupt LCD Interrupt.
Timer0 , Timer1 ,Timer2 Data EEPROM Write
Comparator Change Complete Interrupt
Interrupt SSP Interrupt
Parallel Slave Port Interrupt CAN Interrupt
CCP Interrupt Bus Collision Interrupt
ETC…….
All are Maskable & Vectored Interrupts
The PIC uCs
Enabling and disabling an interrupt
When the PIC is powered on (or resets)
All interrupts are masked (disabled)
The default ISR address is 0008h
No interrupt priorities for interrupts
The PIC uCs
Enabling and disabling an interrupt
In general, interrupt sources have three bits to control their
operation. They are:
Flag bit
to indicate that an interrupt event occurred
Enable bit
that allows program execution to branch to the
interrupt vector address when the Flag bit is set
Priority bit
to select high priority or low priority
The PIC uCs
Steps in enabling an interrupt
Set the GIE bit from INTCON register
Set the IE bit for that interrupt
If the interrupt is one of the peripheral (timers 1,2 , serial, etc. )
set PEIE bit from INTCON register
The PIC uCs
Assigning priorities to an interrupt
Set the IPEN bit, bit7 from RCON register
Use P - priority bit for that interrupt to assign either HIGH or LOW
priority
P = 1, HIGH priority
P = 0, LOW priority
To enable priority interrupts (when IPEN = 1), set GIE / GIEH bit of
INTCON reg. = 1 for HIGH priority interrupts &
set PEIE / GIEL bit of INTCON reg. = 0 for LOW priority interrupts
For INT0 interrupt – no priority bit because it is having default high
priority
The PIC uCs
PIC18 interrupts
The PIC18FXX8 devices have multiple interrupt sources and an
interrupt priority feature that allows each interrupt source to
be assigned a high priority level or a low priority level.
The high priority interrupt vector is at 000008h and the low
priority interrupt vector is at 000018h.
High priority interrupt events will override any low priority
interrupts that may be in progress.
There are 13 registers that are used to control interrupt
operation. These registers are:
RCON
INTCON, INTCON2, INTCON3
PIR1, PIR2, PIR3
PIE1, PIE2, PIE3
IPR1, IPR2, IPR3
The PIC uCs
RCON,INTCON, INTCON2, INTCON3
The PIC uCs
RCON – Reset Control Register
The PIC uCs
INTCON – Interrupt Control Register
The PIC uCs
INTCON2 – Interrupt Control Register2
The PIC uCs
INTCON3 – Interrupt Control Register3
The PIC uCs
PIR1, PIE1, IPR1
Used to programme TMR1, TMR2, CCP, SSP,USART- TX,
USART – RC, ADC, PSP Peripheral Interrupts
The PIC uCs
PIR1 – Peripheral Interrupt Request Register1
The PIC uCs
PIE1 – Peripheral Interrupt Enable Register1
The PIC uCs
IPR1 – Peripheral Interrupt Priority Register1
The PIC uCs
PIR2, PIE2, IPR2
Used to programme ECCP, TMR3, LVD, BCL, EEPROM-
Write, CM Peripheral Interrupts
The PIC uCs
PIR2 – Peripheral Interrupt Request Register2
The PIC uCs
PIE2 – Peripheral Interrupt Enable Register2
The PIC uCs
IPR2 – Peripheral Interrupt Priority Register2
The PIC uCs
PIR3, PIE3, IPR3
Used to programme CAN Invalid message, CAN Bus
Wakeup, CAN Error, Transmit Buffer 0,1,2, Receive
Buffer 0,1 Peripheral Interrupts
The PIC uCs
PIR3 – Peripheral Interrupt Request Register3
The PIC uCs
PIE3 – Peripheral Interrupt Enable Register3
The PIC uCs
IPR3 – Peripheral Interrupt Priority Register3
The PIC uCs
The PIC uCs
The PIC uCs
PIC18F Interrupt Logic for TIMER Interrupts
without priorities
The PIC uCs
PIC18F Interrupt Logic – Detailed Diagram
The PIC uCs
The PIC uCs
The PIC uCs
The PIC uCs
The PIC uCs
Program organization in Assembly
The PIC uCs
Embedded C - #pragma section directive
Assembler allows placing code/data at a specific ROM address using ORG
directive.
To do the same in Embedded C , use #pragma section directive, where
Section is portion of an application (code/data) that can be assigned specific
memory address location. In case of on-chip ROM program memory, section
can be either code or romdata
#pragma code– used for program with executable instructions &
#pragma romdata – used for fixed data such as strings and look-up tables.
Ex. }
#include <p18f458.h> #pragma code msdelay = 0X30
#pragma code main = 0X50 Void msdelay
Void msdelay {
Void main (void)
{ }
The PIC uCs
The PIC uCs
The PIC uCs
The PIC uCs
The PIC uCs
The PIC uCs
The PIC uCs
Programming timer using interrupt
Write down a program to generate a square wave
on RB5 of frequency 1KHz by using Timer 0
interrupt method ,while data is being transferred
from PORTC to PORTD.
RB5 Square Wave = 1KHz
By Interrupt Method
P18F452
PORTC PORTD
The PIC uCs
Program
# include <p18f452.h> #pragma interrupt HighISR
#define mybit PORTBbits.RB5 void HighISR(void)
void T0_ISR(void) {
#pragma code HighVector=0x08 if (INTCONbits.TMR0IF==1)
void HighVector(void) T0_ISR();
{ }
_asm void T0_ISR (void)
GOTO HighISR {
_endasm mybit = ~mybit;
} TMR0H = 0xFE;
TMR0L=0x0C;
INTCONbits.TMR0IF=0;
}
The PIC uCs
void main (void)
{
TRISBbits.TRISB5 = 0; // Make RB5 as output pin
TRISC=0xFF; // Make Port C as Input
TRISD =0x00; // Make Port D as output
T0CON = 0x08; // Timer 0, 16 bit mode , no pre-scaler
TMR0H=0xFE; // for freq. = 1 KHz , Delay = 0.5 ms, count = FE0C
TMR0L=0x0C;
INTCONbits.TMR0IF=0; // Timer overflow bit
INTCONbits.GIE=1; // enable all interrupts globally
INTCONbits.PEIE=1 // enable all peripheral interrupt
INTCONbits.TMR0IE=1; // enable Timer 0 Interrupt
T0CONbits.TMRON=1 ; // start timer 0
while (1) //keep looping until interrupt comes
{
PORTD= PORTC
}
}
The PIC uCs
Programming timer using interrupt
Write an Embedded C program for Timer programming ISR based
buzzer on/off.
RB5
Buzzer
P18F452
The PIC uCs
Program
# include <p18f452.h> #pragma interrupt HighISR
#define mybit PORTBbits.RB5 void HighISR(void)
void T0_ISR(void) {
#pragma code HighVector=0x08 if (INTCONbits.TMR0IF==1)
void HighVector(void) T0_ISR();
{ }
_asm void T0_ISR (void)
GOTO HighISR {
_endasm mybit = ~mybit;
} TMR0H = 0xFE;
TMR0L=0x0C;
INTCONbits.TMR0IF=0;
}
The PIC uCs
void main (void)
{
TRISBbits.TRISB5 = 0; // Make RB5 as output pin
T0CON = 0x08; // Timer 0, 16 bit mode , no pre-scaler
TMR0H=0xFE; // Delay = 0.5 ms, count = FE0C
TMR0L=0x0C;
INTCONbits.TMR0IF=0; // Timer overflow bit
INTCONbits.GIE=1; // enable all interrupts globally
INTCONbits.PEIE=1 // enable all peripheral interrupt
INTCONbits.TMR0IE=1; // enable Timer 0 Interrupt
T0CONbits.TMRON=1 ; // start timer 0
while (1) //keep looping until interrupt comes
}
The PIC uCs
Programming external hardware interrupt
Connect a switch to INT0 (RB0) and an LED to PIN RB7.
Every time INT0 is activated, it toggles the LED while at the
same time data is transferred from PORTC to PORTD
NOTE: By default or on power on reset, INT0,INT1 and INT2
are positive edge triggered.
SW(INT0/RB0) LED (RB7)
Port C Port D
The PIC uCs
Program
#include <p18f452.h> #pragma code
#define mybit PORTBbits.RB7 My_HiPrio_Int=0x0008
void chk_isr(void); void My_HiPrio_Int (void)
void INT0_ISR(void); {
_asm
# pragma interrupt chk_isr GOTO chk_isr
void chk_isr(void) _endasm
{ }
if (INTCONbits.INT0IF==1) Void INT0_ISR(void)
INT0_ISR(); {
} mybit=~mybit;
INTCONbits.INT0IF=0;
}
The PIC uCs
void main(void)
{
TRISBbits.TRISB7=0;
TRISBbits.TRISB0=1;
TRISC =0xFF;
TRISD=0;
INTCONbits.INT0IF=0; // clear INT01
INTCONbits.INT0IE=1; //Enable INT0 interrupt
INTCONbits.GIE=1; //enable all interrupts
While(1) //keep looping until interrupt comes
{
PORTD=PORTC;
}
}
The PIC uCs
Programming external hardware interrupt
Write an Embedded C program for External interrupt input
switch press, output at relay.
NOTE: By default or on power on reset, INT0,INT1 and INT2
are positive edge triggered.
SW(INT0/RB0) RELAY (RB7)
The PIC uCs
Program
#include <p18f452.h> #pragma code
#define mybit PORTBbits.RB7 My_HiPrio_Int=0x0008
void chk_isr(void); void My_HiPrio_Int (void)
void INT0_ISR(void); {
_asm
# pragma interrupt chk_isr GOTO chk_isr
void chk_isr(void) _endasm
{ }
if (INTCONbits.INT0IF==1) Void INT0_ISR(void)
INT0_ISR(); {
} mybit=~mybit;
INTCONbits.INT0IF=0;
}
The PIC uCs
void main(void)
{
TRISBbits.TRISB7=0;
TRISBbits.TRISB0=1;
INTCONbits.INT0IF=0; // clear TF1
INTCONbits.INT0IE=1; //Enable Timer0 interrupt
INTCONbits.GIE=1; //enable all interrupts
While(1) //keep looping until interrupt comes
The PIC uCs
PORTB change interrupt
Connect SW1 and SW2 to pins RB4 and RB5
respectively. Upon activation of SW1 and
SW2 will result in changing the state of LED1
and LED2 respectively.
SW1(RB4) LED1(RC4)
SW2(RB5) LED2(RC5)
The PIC uCs
Program
#include <p18f458.h>
#define LED1 PORTCbits.RC4 #pragma code
#define LED2 PORTCbits.RC5 My_HiPrio_Int=0x0008
void My_HiPrio_Int (void)
void chk_isr(void); {
void RBINT_ISR(void); _asm
GOTO chk_isr
# pragma interrupt chk_isr _endasm
void chk_isr(void) }
{
if (INTCONbits.RBIF==1) Void RBINT_ISR(void)
RBINT_ISR(); {
} LED1=PORTBbits.RB4;
LED2=PORTBbits.RB5;
INTCONbits.RBIF=0;
}
The PIC uCs
void main(void)
{
TRISCbits.TRISC4=0;
TRISCbits.TRISC5=0;
TRISBbits.TRISB4=1;
TRISBbits.TRISB5=1;
INTCONbits.RBIF=0; // clear RBIF
INTCONbits.RBIE=1; //Enable RB interrupt
INTCONbits.GIE=1; //enable all interrupts
While(1); //keep looping until interrupt comes
}
The PIC uCs
