Periodic interrupt

Necessary knowledge: [HW] Controller module, [HW] User Interface Module, [AVR] Interrupts, [AVR] Counters/Timers, [LIB] Pins, [LIB] Delay, [LIB] Timers, [PRT] Software delay

The goal of this chapter is to demonstrate the usage of the interrupts on the example of the counters. The interrupts are program parts which are reacting to the events taking place in the microcontrollers. They are usually used for quick response to an event, but they can also be used for completing several parallel processes, precisely timed action and saving power. For example, it is possible to make a LED blinking using interruptions, so that blinking frequency does not depend on what is happening in the program at the moment. When the interrupt occur then main program execution stopped and the interrupt priority check of the interrupt vector table happen, after that the program of the interrupt function has been executed. While the interrupt program will be executed then the main program execution continues on the state where it left off.

The following program shows how the counter is set up to make an interrupt. There are 2 LEDs of the Digital i/o module in the program, the state of the red LED is changed periodically with software delay, the state of the green LED is changed when interrupts occur. There is a separate exercise for blinking LED with software delay and it is not explained here. The main goal is to explain the usage of the library of the counters and interrupts.

The following shows the use of interrupts of the xmega controller. In the beginning of the program, the 16-bit counter/timer E1 has been set up. First, the timer period will be set, so the maximum value of the count function TC_SetPeriod. The divider of the counter is 1024 and the value of period is 31249, so when the clock frequency is 32 MHz, the period will be exactly one second. It is easy to calculate with following formula:

period = (32000000 Hz / 1024 / 1) - 1 = 31249

In the beginning of the program, the 16-bit counter/timer 1 has been set up with the function timer1_init_ctc. With this function the counter CTC clear timer on compare match has been set to the mode where the maximum value of the timer is not 216 – 1 but can be selected. In this case the maximum value is set to equal the value of the ICR1 index. The divider of the counter is 1024 and the value of ICR1 is 14400, so when the clock frequency is 14,7456 MHz, the period will be exactly one second. It is easy to calculate with following formula:

f = 14745600 Hz / 1024 / 14400 = 1

After allowing the interrupt to achieve the maximum value of the counter 1, an interrupt must be allowed also at the global level, that means in the microcontroller. For allowing global interrupts, there is a function sei and for forbidding cli. A header file avr/interrupt.h must be included for defining the program part of these functions and interrupts. The program part of the interrupt is defined with macro function ISR, which parameter is the name of the interrupt vector. In this set-up the vector of counter 1’s maximum value achievement interrupt is TIMER1_CAPT_vect.

//
// The HomeLab's example of blinking LED which blinks due to counter interruptings.
// For comparison to the LED blinking due to interrupts, 
// there is a software delay blinking LED working parallel.
//
#include <homelab/pin.h>
#include <homelab/delay.h>
#include <homelab/timer.h>
#include <avr/interrupt.h>
 
//
// Determining the pins of the LEDs.
//
pin led_red   = PIN(C, 5);
pin led_green = PIN(C, 3);
 
//
// Interruption
//
ISR(TIMER1_CAPT_vect)
{
	// Changing the state of the green LED.
	pin_toggle(led_green);
}
 
//
// Main program.
//
int main(void)
{
	// Setting the pins of the LEDs as outputs.
	pin_setup_output(led_red);
	pin_setup_output(led_green);
 
	// Seting the timer up in the CTC mode.	
	timer1_init_ctc(
		TIMER1_PRESCALE_1024,
		TIMER1_CTC_TOP_ICR);
 
	// The maximal value of the timer is 14400, which
	// makes the length of the period 1 s.
	// Formula: 14,7456Mhz / 1024 = 14400
	timer1_set_input_capture_value(14400);
 
	// Allowing interruption of achieving the value.
	timer1_input_capture_interrupt_enable(true);
 
	// Allowing global interruption.
	sei();
 
	// Endless loop.
	while (true)
	{
		// Software delay 1000 ms.
		sw_delay_ms(1000);
 
		// Change of the state of the red LED.
		pin_toggle(led_red);
	}
}

At the start of the program it is seen that regardless of what the microcontroller is doing in the main program, the interrupts are taking place and the green LED is blinking.

If we let the program to work for a couple of minutes, an important aspect occurs, that was not so easily noticeable during software delay exercise. Although the delay in red LED blinking is 1000 ms, the actual time for completing the full cycle is a little bit longer. This is because, the change of the LED’s state, callout of the function of the delay and completion of the cycle are demanding some clock cycles of time for the processor. As a result the blinking of the red LED is always behind from the blinking of the green LED. This is why it is not advised to design clocks and other precise actions with delay but with interruptions of the counter.