31/03/2019
What is an Interrupt?
Microcontroller Development
Interrupts
What is an Interrupt?
 An Interrupt is another event which stops or
‘interrupts’ your sequential code.
 When an interrupt occurs, it will stop the
current code, will exit that code and then
commit to executing the interrupt code.
 When the interrupt code is complete, the
program then returns from where it left off
from the original executed code.
3 4
Interfacing Techniques
 Interrupt Driven
– An interfacing technique based on ‘trigger’ events
which lead to:
 Interruption of the flow of the processor program.
 Execution of a special function call the ‘interrupt service
routine’.
– When to use:
 When an immediate response is needed.
 When there are lots of activities that the micro need to
perform, meaning that it can’t afford to waste time.
5 6
 Currently we are coding our Microcontrollers
with sequential code.
– Eg, writing and executing code, line by line.
– Creating Delay loops by repeating same code,
line by line.
– Finishing executing the code, we return to the
start of the loop, line by line.
 With sequential code, we more or less expect
what is going to happen next.
Interfacing Techniques
 Polling
– An interfacing technique based on repeated
checking of a condition to determine if action is
needed. It is implemented by using repetition.
– When to use:
 When there is no need for an immediate response.
 When simple implementation is needed.
– Note: Polling is using sequential code.
Interrupt Sources
 External Interrupts
– External events from the microcontroller which triggers an
Interrupt to occur.
– Triggered by hardware signals connected to the INTn pins
of the microcontroller.
 Internal Interrupt
– Interrupts that are invoked from within the microcontroller
itself. (This to be covered in the next lecture).
– Triggered by the Microcontrollers internal timers, ADC
system, serial communications etc.
1
 31/03/2019

Interrupt Execution Interrupt Execution

 If the interrupt is enabled on the micro, the  Note:

processor:
– Stops the execution of the code. – Microcontorllers can have more than one
– Saves registers on the stack. interrupt. This means an interrupt might be
– Saves the program counter of the stack. interrupted by other interrupts.
– Branches execution to an Interrupt Service Routine, (ISR).
– The ISR deals with the interrupt as required. – The ISR is an asynchronous mechanism. It can
 Eg temperature threshold monitoring system where it may turn on a happen at any moment.
fan once a temperature sensor reaches a certain point.
– When the ISR is exited, all the registers are popped back
onto the stack, including the program counter. This ensures
that the execution of the original code resumes.

7 8

Interrupt Design Interrupt Design

1. When designing a system consider the following 2. Decide on the type of interrupt you need.
questions.
 Is instant response needed?  Edge Triggered: Can be either falling or rising
 Is the micro busy with other processes which may lead to edge.
delays?
 Would a delay be significant enough to effect signals or  Level Triggered: Used in the past for interrupt
timings of the micro? sharing, (multiple devices connected to the
 Are there any external interrupt pins available? same interrupt pin). A device wishing to signal
 If the answer is yes to most of these questions, then you will
an interrupt drives the line to its active level, and
need to design a micro using interrupts. then holds it at that level until serviced, (the PCI
 If the answer is no, then you are probably safe using a the
polling technique. standard uses this).

9 10

Interrupt Design ATMega2560 External Interrupts

3. Decide what you need to happen during the

Interrupt source Port pin
execution of the ISR.
INT0 – INT3 PD0 – PD3
4. Check the datasheet to find out which pins INT4 – INT7 PE4 – PE7
are used as external interrupts. PCINT0
PCINT0:7 PB0:7
5. Check the datasheet to find out which PCINT1
register to use in order to enable and setup PCINT8 PE0
PCINT9:15 PJ0:6
the interrupt.
PCINT2
PCINT16:23 PK0:7
For more, refer to Atmega2560 data sheet
11 12

2
 31/03/2019

AVR Registers and External Interrupts Example – The DDRB Register

 To use an interrupt, you need to set them

up.
 An interrupt must be enabled via a setup
register in order for it to be used.
– Eg, like we setup up PORTA and C to be either
input / output via the DDRx register.

13 14

Global Interrupt Enable Selecting Specific Interrupt

 Bit 2, 1, 0 – PCINT2, PCINT1, PCINT0: External Interrupt Request Enable

– when PCINTn = 0, the corresponding interrupt is masked (ie. not
enabled)
– to enable it, PCINTn must be set
(for example, to enable PCINT2: PCICR = PCICR | 0b00000100)
– to be used in conjunction with SREG (see above) and PCMSKn (see
below)

15 16

Select the Hardware Trigger Interrupt Flag

 Bit 2, 1, 0 – PCIF2, PCIF1, PCIF0: Pin Change Interrupt Flag

 Bit 7:0 – PCINT7:0: Pin Change Enable Mask 7:0
– Each PCINT7:0 bit selects whether pin change interrupt is
enabled on the corresponding I/O pin
– If PCINT7:0 is set and the PCIE0 bit in PCICR is set, pin change
interrupt is enabled on the corresponding I/O pin.
– If PCINT7:0 is cleared, pin change interrupt on the corresponding
I/O pin is disabled. INT1 and INT0 require the presence of an I/O
clock
17
2,1,0
– When a logic change on any corresponding PCINT pin triggers
an interrupt request, PCIFn becomes set (one).
– If the I-bit in SREG and the PCIEn bit in PCICR are set (one), the
MCU will jump to the corresponding Interrupt Vector.
– The flag is cleared when the interrupt routine is executed.
Alternatively, the flag can be cleared by writing a logical one to it.
18

3
 31/03/2019

/*================ intEx1.c ======================================

PURPOSE - code to test external interrupts
- every time PCINT1 is triggered the onboard LED is turned on for 1 second */
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

Datasheet #include <util/delay.h>

//user-defined function for the initialisation of the external interrupt PCINT0
void pcint0_init(void);
//============== Executive Loop ============================================
volatile unsigned char PinChange = 0; //global variable
int main(void)
 Refer to ATMega 2506 Datasheet. {//--- User initializations.
DDRB = 0xFE; //NOTE: configure only PB0 (PCINT0) as input and
– Page 112 PORTB = 0x01; //activate its pull up resistor, and turn off LED
DDRA = 0xFF; //Port A set as output

int1_init(); //initialise registers to enable PCINT0

//PORTB = 0x08; //use with the debugging routine (see end of code)
while(1)
{
if(PinChange) //Check if pin change detected
{
PORTA |= 0x80;
_delay_ms(1000);
PORTA &= ~0x80;
PinChange = 0; // Reset pin change detection
}

19 }
20
}

//user-defined function for the initialisation of the external interrupt PCINT0

void pcint0_init(void)
{
cli(); //SREG = 0
PCICR |= (1 << PCIE0);
PCMSK0 |= (1 << PCINT0); //Port B, pin 0
PCIFR |= (1 << PCIF0);
sei(); //SREG = 1 Code Notes
}

//interrupt-service routine
ISR(PCINT0_vect)  All the registers presented above, are already defined in the
{
header file iomxx0_1.h (this header file is included
PinChange = 1;
PCIFR = PCIFR | (1 << PCIF0); //re-arm the interrupt
automatically by the Arduino, based on your chosen
} microcontroller platform)
 To use PCINT0, you need to configure any pin on PORTB as
//for debugging purposes only : to make sure that you actually get into the ISR
//make sure that you also comment out the PORTB outputs in the while loop
an input, and enable the pull up resistor
/*ISR(PCINT0_vect) – DDRB = 0xFE;
{ //NOTE: configure PB0 (PCINT0) as input and activate only its pull up
//counter++; resistor
PORTB |= 0x80; – PORTB = 0x01;
PCIFR = PCIFR | (1 << PCIF1); //re-arm the interrupt
}*/
 One can not pass parameters to the interrupt function. This
means that the only way to be able to modify the value of a
variable from the interrupt is by using volatile global variables.
A volatile global variable is declared outside main() and can
be accessed from any function of the program.
21 22

Code Notes iomxx0_1.h file

 (1 << PCIE0); is based on the definition of PCIE0  Demonstration where this file is located.
constant in iomxx0_1.h, which is as follows:
– #define PCIE2 2
 C:\<install location>\Arduino\hardware\tools\avr\avr\include\avr
– #define PCIE1 1
– #define PCIE0 0
 (1 << PCIE0); means that 1 is shifted left 0
positions (PCIE0 is 0), hence 0000 0001 becomes
0000 0001 and when OR’ing with PCICR, it sets bit
0 to 1, hence enabling the PCINT1 interrupt.
 Interrupts are serviced when moving from the state
from a high ‘1’ to low ‘0’.
23 24

4

Code Notes
 cli(); and sei(); are predefined and take care
of the clearing and setting of the global
interrupt enable pin.
 At the end of an ISR, you need to re-arm
the interrupt by setting the corresponding
interrupt enable bit. For PCINT0:
– PCIFR = PCIFR | (1 << PCIF0);
 Note how short the ISR is.
25
Hex Keypad
27
31/03/2019
Hex Keypad
 For Practical 4, the Hex Keypad is to be connected
to the Mega2560 Basic Shield.
 The keypad will be used to type alphanumeric
values into the microcontroller.
 These values are then to be displayed on the LCD.
 The LCD must be set in 4 BIT MODE.
 Communication via the keypad to the
microcontroller shall use the ISR.
26
Next Lecture: Timers
 For the next lecture, we will be using the
microcontrollers internal interrupts to create
programmable timers.
28