Chapter 7: Microcontroller Interrupts and Timers

Chapter 7: Microcontroller Interrupts and

Timers

Interrupts and Timers are critical to microcontroller applications, but they have nothing to do with the C programming language. I can’t think of a good way to progressively discuss C and smoothly mix in these topics so we will stop with the C for a while and look at our hardware. Interrupts and timers will be helpful in making later projects more useful.

C knows nothing about interrupts or timers. These things are machine dependent and specific. While the general concepts will apply to other microcontroller families, the specifics are for the AVR family and specifically for the ATmega169.

Interrupts

We usually use one of two methods in microcontroller software to check to see if an event has occurred: polling and interrupts. Polling occurs when a section of code, usually an infinite loop in main(), looks to see if an event has occurred. For instance, it may check pin 6 to see if the voltage is +3 or 0 (logic true or false), and if +3 do one thing and if 0 do another. If the microcontroller hardware is designed so that pin 6 can be used to interrupt the program, then we don’t have to poll the pin, we can set up the software so that when the pin state we are interested in, say falling from +3v to 0v, an interrupt function will be called.

Interrupts are much like interrupts in daily life. The telephone, for instance, interrupts your activities by its insistent ringing. But imagine how it would be if you had to poll the telephone to receive calls. Periodically, you’d pick up the receiver and say ‘Hello, anybody out there?’ and your caller would shriek, “I’ve been waiting for an hour! Why don’t you check your phone every five minutes like a normal person?” The ringing interrupting workflow might be annoying, but if someone is calling you to tell you that your garage is on fire, you want to know about it immediately.

Microcontrollers respond to interrupts much like you would. Maybe you are reading a book and the phone rings. You use you fingernail to scratch a mark next

109

Chapter 7: Microcontroller Interrupts and Timers

to the line you were reading and dog-ear the page before closing the book. Then you answer the phone and when the call is finished and you’ve put out the fire in your garage, you can refer to the desecrations to your book and go right back to where you left off your reading.

From the hardware perspective an interrupt causes the microcontroller to stop what it is doing, store sufficient data so that later it can get back to what it was doing, look to see which interrupt happened, run the interrupt code, and when finished restore the machine to its state before the interrupt occurred using the previously stored data.

Interrupts are great, but they provide an avenue for some particularly pernicious bugs. For example when your code is reading an integer from memory and since an integer is made of two bytes it gets the first byte, then is stopped by an interrupt that changes the value of the integer before returning control to the part of the code that was reading the integer which then gets the second byte of the integer. The integer will be wrong because it will be made half from the preinterrupt value and half from the post-interrupt value. The crazy making debugging problem is that the interrupt can happen at any time, maybe only very rarely during the integer read. Your system can run like a champ and then locks up for no apparent reason. You don’t want this kind of bug in your pacemaker. You prevent this bug by disabling interrupts before reading variables that can be changed by interrupts then enabling them after you’ve got the correct number.

We’ll study interrupts by using some fairly intense code based on the Butterfly software used to read the joystick. If you compare the software used in this example to the Butterfly software you might think I stole some of it. And you’d be correct. That is one of the central principles of software engineering: if it ain’t nailed down - steal it. Heck, if it is nailed down, get a crowbar and rip it up. It’s also called ‘code reuse’ and you’d be stupid to reinvent the wheel by trying to write something from scratch when you have perfectly good code already available. There are only two reasons to write stuff you can steal, one is that you want to learn by doing, and the other is to avoid a lawsuit - if the software doesn’t specifically state that it can be used, then it is copyrighted. Hopefully, I won’t get sued.

110

Chapter 7: Microcontroller Interrupts and Timers

Some of this code will have concepts that will be explained later. Expect a little confusion. Now may be a good time for a nap.

The Atmega169 data book lists 23 interrupts in Table 22 on page 47. Two of these interrupts, the Pin Change Interrupts: PCI0 and PCI1 are triggered by changes on some of the port pins. Pins on Port E can be configured to trigger a PCI0 interrupt and pins on Port B can be configured to trigger a PCI1 interrupt.

The joystick just happens to be attached to pins on both Port B and Port E making it an ideal candidate to study interrupts with the added benefit that when we get though, we’ll be able to use the joystick like it was intended. The joystick pins map as follows:

---------------------------------------------

---------------------------------------------

PORTB | PORTE B A O D C

=============================================

Where:

A = up

B = down

O = center push

D = left

C = right

111

Chapter 7: Microcontroller Interrupts and Timers

The PCMSK1 register controls, which pins contribute to the interrupt, if a bit is set to 1 the corresponding bit in Port B is enabled to trigger the PCI1 interrupt. A 0 disables the interrupt for a pin. To enable the buttons of interest:

We use ‘x’ to indicate that we don’t care what that bit is. Since some other part of the software might be using that bit, we want to leave it as is. The statement:

PCMSK1 |= ((1<<PINB4)|(1<<PINB6)|(1<<PINB7))

Changes bits 4, 6, and 7 to 1 and leaves the rest of the bits as they were. As a review, remember what the ‘|’ does: 1|1=1, 1|0=1, 0|1=1, and 0|0=0. So the 1 bits will set to one no matter what they were in PCMSK1 and the 0 bits will set the PCMSK1 bit to 1 if it was already 1 and to 0 if it was already 0. If this is still obscure get out the pencil-and-paper-computer and play with it a bit. It is a critical concept for understanding microcontrollers.

We are going to use: (1<<PINB4)|(1<<PINB6)|(1<<PINB7) several places in our code, so let’s look at a new item that will simplify our lives, the #define preprocessor directive. If we put:

#define PINB_MASK ((1<<PINB4)|(1<<PINB6)|(1<<PINB7))

In our code, usually after the #include directives and before the main() function, the preprocessor will substitute ((1<<PINB4)|(1<<PINB6)|(1<<PINB7)) for each occurrence of PINB_MASK in the code. So we can write:

PCMSKB = PINB_MASK;

in our source file but the C compiler will see:

PCMSK1 = ((1<<PINB4)|(1<<PINB6)|(1<<PINB7))

The External Interrupt Mask Register, EIMSK, and External Interrupt Flag Register, EIFR are discussed on page 78 of the data book. We set them to enable the PCI1 interrupt as follows:

112

Chapter 7: Microcontroller Interrupts and Timers

EIFR = (1<<PCIF0)|(1<<PCIF1);

EIMSK = (1<<PCIE0)|(1<<PCIE1);

The program will jump to the interrupt routine when the interrupt is triggered, but where is the interrupt routine? The location is determined by the address ‘vector’ listed in Table 22, page 47 of the data book. We use the following code to access the PCI1 interrupt:

SIGNAL(SIG_PIN_CHANGE1)

{

// Do something

}

SIGNAL is defined in the WinAVR include directory in signal.h, which defines some macros to handle interrupt functions using the gcc compiler. We’ll get to macros later.

Interrupt handling is defined specifically for a particular microcontroller and a particular C compiler and it is not portable like most of C. The original Butterfly code was built using the IAR C compiler and uses this format for interrupts:

#pragma vector = PCINT0_vect __interrupt void PCINT0_interrupt(void)

{

// Do something

}

We’ll get to pragmas later. IAR handles interrupts one-way and WinAVR does it another.

Let’s review:

•We setup a register, PCMSK1, to indicate which port B pins can cause interrupts.

•We setup the External Interrupt Mask Register, EIMSK, and External Interrupt Flag Register, to enable the PCI1 interrupt.

•We provided the SIGNAL(SIG_PIN_CHANGE1) code to be called when the interrupt occurs.

113