Lesson 11 Interrupt with PIC Microcontroller - Mikroc

Interrupt is a very important concept in microcontroller. It notifies the microcontroller of an external/internal event or that a device needs its service.

There are 2 ways that a device can notify the microcontroller for its service;

•    Polling.
•    Interrupt.

In polling the microcontroller keeps monitoring the status of a particular device, when the condition is met, it services the given device. After that it moves to next device until all the devices are serviced.

This method is not efficient as it wastes much of the microcontroller time polling devices that do not need service.

In interrupt, when a device needs service,

• The device will send an interrupt signal to the microcontroller to notify it of its service.
• The microcontroller interrupts whatever it is doing to serve the device on receiving of the interrupt signal.

*** Every interrupt request have an interrupt handler otherwise called Interrupt Service Routine (ISR). The microcontroller runs the ISR on every interrupt request.

*** For every interrupt, there is a fixed location in memory that holds the ADDRESS of its ISR. These group of memory location is called INTERRUPT VECTOR TABLE.

Interrupts can occur either ASYNCHRONUOSLY (External Events) or SYNCHRONUOSLY (usually Timer Interrupt).

STEPS INVOLVED IN EXECUTING AN INTERRUPT

When an interrupt request is made, the microcontroller goes through the following steps:

• It finishes the instruction it is executing and saves the address of the next instruction (program counter) on the stack.
• It jumps to Interrupt Vector Table (IVT), the IVT directs the microcontroller to the address of the ISR.
•  The microcontroller gets the address of the ISR from IVT and jumps to it. It starts to execute the ISR until it reaches the last instruction which is Return from Interrupt Exist.
• Upon executing the Return from Interrupt Exist instruction, the microcontroller returns to the place where it was interrupted and resumes its normal flow of execution.

There are several sources of interrupt for PIC 16/18 microcontrollers. Most commonly used are the:

•  Timer Interrupt.
•  External Interrupt
•  PORTB change Interrupt etc.

We’ll consider the timer interrupt in this tutorial. The registers associated with Timer interrupt in PIC microcontrollers include:

• OPTION REG
• INTCON Register

All interrupts in PIC microcontrollers are enabled/disabled with GIE Bit (Global Interrupt Enable Bit) of INTCON Register. Look up in the device datasheet for more information on INTCON REG

Each interrupt source has 2 bits to control it;

• One Enables it
• The other detects when an interrupt occurs

OPTION REG is an 8 bits wide register. Bits 0 – 2 of OPTION REG is used to set Prescaler Value and bit 3 is used to assign the Prescaler to watchdog timer or timer 0. Prescaler divides down the clock signals used for timing giving reduced overflow rate. Refer to device datasheet for more information

Some of PIC 16 timer interrupts are :

• Timer 0
• Timer 1
• Timer 2

This timer interrupt occurs when the timer overflows. For any Overflow time (time for interrupt to occur) you have to load a value to the Timer register. Let’s consider timer 0 (TMR0) in 16F877A, which is an 8 bit register. It will count up to 255 and then overflow occurs and continue counting from 0. When an overflow occurs (when it changes from 255 to 0), it generates an interrupt if TMR0 interrupt and the GIE bit were ENABLED in the INTCON register. That is; T0IE = 1 (Timer 0 Interrupt Enable), GIE = 1

*** For the same interrupt to re-occur, the completion status has to be cleared that is; T0IF=0 (Timer 0 Interrupt Flag) and the Timer Value reloaded into the timer register.

Note: By loading TMR0 Register we can control the count until an overflow occurs (interrupt takes place)

How to Calculate Value to be loaded into the Timer 0 Register

TMRO value = 256 - t / (T * prescaler value)

t = Overflow Time or Time Interrupt Occurs (in microseconds)  

T (Oscillator Period in Microseconds) =  1 / (Internal Oscillator Frequency)

Internal Oscillator Frequency =  Crystal clock / 4

*** In PIC microcontroller instruction takes 4 clock cycles, that’s why you see crystal clock being divided by 4.

Assuming we have PIC 16F877A microcontroller using an external clock of 8 MHz and we are required to generate 200 microseconds interrupt with a Prescaler value of 2. The TMRO Value will be 56 using the above formula.

Internal Oscillator Frequency = 8MHz / 4  = 2MHz

T (Oscillator Period in Microseconds) =  1 / 2MHz = 0.5microseconds

t = Overflow Time or Time Interrupt Occurs (in microseconds) = 200microseconds  

TMRO value = 256 - 200microsec / (0.5microsec * 2)  = 256-200 = 56

There is a handy tool you can use when working with Timer Interrupt. In fact I can’t recall the last time I went through all this mathematics. Timer Calculator does the magic. It is made by Mikroelektronika http://www.libstock.com/projects/view/398/timer-calculator. It one of my best software from Mikroelektronika. You need just 4 easy steps:

•    Select your device from the device drop down
•    Choose your clock frequency
•    Select the timer interrupt you want
•    Select Interrupt time

After this 4 steps, you click the calculate button and you are home and done. You can copy the generated code to your Main program.

Lets write a program to blink PORTD and PORTB LEDs. PORTD LED will blink every 200ms, PORTB every 1sec using TIMER 0 Interrupt

Mikroc code:

 /**********************************

Project Name :

    Interrupt with PIC Microcontroller

Author : Promise

Description :

    this program demontrates the use of timer0 interrupt

    Interrupt is generated every ms

   the program blinks a led attached to PORTD every 200ms. it also blinks another led at PORTB every second

Test configuration:

   MCU:  PIC 18F45K22

   Oscillator: XT 8.0000 MHz, 8.0000 MHz Crystal

   Dev Board : Easy Pic v7

***********************************/

 volatile  unsigned int count1 = 0 ;

 volatile unsigned int count2= 0 ;

 void Interrupt(){

  if (TMR0IF_bit){

    TMR0IF_bit = 0;

    TMR0L         = 0x06;

    ++count1 ;        // timer configured to generate 1ms periodic ticks

    ++count2 ;

  }

}

void InitTimer0(){

  T0CON         = 0xC2;

  TMR0L         = 0x06;

  GIE_bit         = 1;

  TMR0IE_bit         = 1;

}

void task_1 (){

   if (count1 ==200)    //blinks led every 200ms

      {

       count1 = 0;

       LATD = ~ LATD;

       }

}

void task_2 () {

      if (count2 == 1000)     // blinks every second

      {

         count2 = 0;

         LATB = ~ LATB;

      }

}

void main() {

  TRISD = 0x00;

  TRISB = 0x00;

  // clear output bit

  LATD = 0x00;

  LATB = 0x00;

  

  InitTimer0();

           while (1)  {

              task_1 ();  //blinks every 200ms

              task_2 ();  // blinks every 1 sec

           }

}