Microcontrollers: Class 3: Interrupts

Microcontrollers
Class 3: Interrupts
March 21, 2011
Outline
Interrupts
External Interrupts
Interrupt-driven Hardware Peripherals

Outline
Interrupts
External Interrupts
Outline
Interrupts
External Interrupts

Interrupts
What are they?
I Functions that get called (automatically) when a certain

condition is true (Interrupt Service Routines)
I Pin-change (external) interrupts, data-ready interrupts,
timer-driven interrupts
I See p. 59 of the datasheet, and read iomx8.h for their names
What are they good for?
I Respond to external stimulus in real-time: user pressed

button? new serial data came in? robot sensed a wall ahead?
I Clean up our code: event-driven programming
Polling
Life before Interrupts
I Wanted to see if a button was pressed, we checked the

button state every time we went around the main loop.
Works great if main loop is faster than our response time.
I OTOH, our receiveByte() command was blocking
it just sat there and waited for data to come in.
I uint8 t receiveByte (void) {
while (!(UCSR0A & BV(RXC0)));/*Wait for data*/
return UDR0; /* return register value */
}
I What does the chip do if no serial data ever comes in?
I Wouldnt it be nice if we could do other stuff and then be
interrupted when the receive-data register is full?
Event-Driven Programming
Brought to you by interrupts...
I Main loop: Does whatever it does, loops forever

I Interrupts handle the (infrequent) events, and then flow
returns back to the main loop
I Further interrupts disabled while in ISR
I Interrupt requests are queued and theres a priority system, so
if two other interrupts fire while youre in an ISR, itll do the
highest-priority one as soon as your ISR is finished.
I (You can enable other interrupts from within your ISR with
sei() if you want them to be pre-emptable.)
I Eventually control returns to the main loop and continues
I How long does a cycle of the main loop take?
Event-Driven Programming
Two styles: lightweight or heavyweight ISRs
I Heavyweight version: When you press the button, the

interrupt function writes out data to the serial line
I Lightweight version: Interrupt function sets a flag and returns.
Main loop tests for this flag and handles the rest of the
function if needed.
I Heavyweight is easier to code, immediate handling, but the
ISRs block further interrupts dont want to spend too much
time here
I Lightweight spends less time in the interrupt routine, easier to
handle prioritizing in mainloop, but the event doesnt run until
youre back in the mainloop. May require global variables.
Outline
Interrupts
External Interrupts
External Interrupts
Examples
I External interrupts are useful for syncronizing your chips

execution with the outside world
I For instance, I have an accelerometer that grounds a pin for
1ms every 10ms when it has a new data sample. Otherwise,
its connected to a pullup.
I One option is to poll that pin with the AVR, but it could miss
it, or get out of sync, or....
I Better is have the hardware watch that pin and throw an
interrupt when the pin is pulled low.
I In the next two examples, well use button presses, but keep in
mind that the trigger could be any external action
External Interrupts
Code Example: Heavyweight
I Send light level over serial when press button

I Heavyweight: do ADC sampling and all within the ISR
I By default, interrupt is configured to trigger when the pin is
low
I While holding low, ISR continues to run
stuck in ISR as long as hold down button
I Advantage: button-press is attended to exactly as it happens
I Disadvantage: spends a lot of time in the ISR other
interrupts will have to wait
External Interrupts
Code Example: Lightweight
I ISR just changes a variable to let the mainloop know

I Notice that variable is defined outside of the main loop so that
the ISR (which is also outside the main loop) can access it
I Configure interrupt to fire only on falling-edge pin change
I If configured for low state as above, the ISR would continually
re-write our variables value, but only transmit data once
youve let go of the button
I Advantage: easy to write debouncing, action handled in the
normal mainloop, ISR doesnt block other interrupts
I Disadvantage: response is not instantaneous
External Interrupts
Summary
I Lightweight or heavyweight, heres what you need to do to

use INT0 and INT1
I Enable the specific interrupt: EIMSK |= BV(INT0);
I Make sure its triggering on the right event:
low, change, rising, falling
I Globally enable interrupts: sei();
I Write your ISRs (double-check the interrupt vector name!)
External Interrupts
Misc Points
I You can use the light/heavy model to prioritize interrupts:
heavies happen immediately and pre-empt, lights happen in
the mainloop
I Can set INT0, INT1 interrupts for rising, falling, toggle, or
low state triggers
I The interrupt pins can still be used as output
can set an interrupt pin high in software to fire interrupts
I Debouncing becomes easier with timers, next class
Other Examples
I Many peripherals use external interrupts to signal when

theyve got data ready (GPS, accelerometer, SD cards, ...)
I IRQs on Compy386!
Pinouts
Pin-Change Interrupts
Interrupts on the Other Pins
I PD2 (our button pin) is special: INT0

I All the other pins have pin-change interrupts associated
with them (p. 70)
I Pin change interrupts only tell you that a pin youre
monitoring has changed state,
you have to handle the rest of the logic in code
I Pin change interrupts are grouped in sets of eight:
(PBn, PCn, PDn)
I You have to select which port youre interested in,
then set a mask for which particular pins
I See datasheet, p. 71 and on
Configuration and Use
I Two-step config example: enable PC interrupt on PB6

I enable PORTB/PC0 interrupt: PCICR |= BV(PCIE0);
I monitor PCINT6 via interrupt: PCMSK0 |= BV(PCINT6);
I PC interrupts fire on any change in the state of
any of the monitored pins
I In your ISR(PCINT0 vect), you need to test which pin raised
the interrupt using normal methods: PINB & BV(PB6)
I Example in pinChangeInterruptDemo.c
Summary
I Unlike the special external interrupts, PC interrupts use

aggregated interrupt vectors
I If any of the monitored pins in PB change state,
the ISR is called
I You have to:
enable the overall PC interrupt
configure the pin mask to select which pins are monitored
handle the remaining logic in your ISR
globally enable interrupts: sei();
I Not bad for managing 23 potential interrupts!
I Troubleshooting: did you get the interrupt vector name right?
Did you sei()?
Outline
Interrupts
External Interrupts
Interrupt-driven USART
A Better Serial Reader

I Remember what we did before: blocking serial reads
I What happens if your robot loses serial connection?
I Better: have interrupt deal with incoming serial data
I Heavyweight: read & process the new serial data within the
interrupt
I Lightweight: just store the data, set a flag indicating it needs
processing
I Complications: the lightweight approach needs a buffer
a place to store the incoming serial data as it arrives
Heavyweight Serial Example
I Mainloop transmits alphabet over serial

(just to give it something to do)
I But its interrupted every time we type something
I As before, define an ISR() and enable the interrupt call
I The Gotcha: Need to read in the UDR0 (serial data register)
to clear the interrupt flag. Otherwise, it just keeps calling the
interrupt routine. (p. 189)
Lightweight Serial Example
I Mainloop transmits alphabet over serial, checks to see if it

should advance LED
I Here the ISR just fills up a buffer with the incoming data
I Buffer lets you handle a bunch of data when you can
(pretend that our mainloop took a while or something)
I Or you could handle it all at once
I For more interesting buffers, google FIFO ring or
circular buffer
Transmit Version?
I Sure!
I Imagine you were sending short bits of bursty data, too much
for the serial baudrate
I Create an ISR thats triggered by the USART TX interrupt,
so that every time a transmission is complete, the next begins
I In ISR, check to see if your transmit buffer has entries. If it
does, transmit them and advance the buffer.
I In your mainloop, you just need to put your data into the
buffer the ISR will take care of sending it along when it can
Interrupt-driven ADC
More of the same thing...
I Without belaboring the point, just like there are USART RX

and USART TX vectors, there is an ADC interrupt vector
I If you want the maximum sample rate from the ADC, this is
the way to get it
I Set up the ADC as before in free-running mode tied to an
internal clock source
I ISR(ADC){ ... } and read in or process your data
I Bam!
Other Hardware Peripheral Interrupts
For later reference

I See p. 59 for list of all interrupt vectors
I See iomx8.h for their macro defines
I Whole bunch of timer-related interrupts well get to these
next class when we cover the hardware timers
I I2C and SPI data interrupts like USART TX
I EEPROM write complete (it takes time)
I Even RESET works internally using its own interrupt
(you can set this in software by writing low to PC6!)
Homework
Response-time Tester Game
I Start with the LEDs off

I Wait a while then flash the LEDs
I Using a for loop with a delay, start counting elapsed time
I When button pressed (use an interrupt) spit out the elapsed
time over serial
Ghetto Oscope in Ten Lines of Code
I Every time you get a value on the ADC, send it out over serial
I This should be all configuration your mainloop can be empty
I The rest is code on your computer.
Next Class
Timers!
I Weve been doing a lot of for loops with delays in them
I Want a hardware-based way to count time or waste time
I Timers and counters!
I Its even better the timers can fire off interrupts
The End
Outline

Microcontrollers: Class 3: Interrupts

Uploaded by

Copyright:

Available Formats

Microcontrollers: Class 3: Interrupts

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Microcontrollers: Class 3: Interrupts

Uploaded by

Copyright:

Available Formats

Microcontrollers

March 21, 2011

Interrupt-driven Hardware Peripherals

Interrupt-driven Hardware Peripherals

Interrupt-driven Hardware Peripherals

What are they?

I Functions that get called (automatically) when a certain

What are they good for?

I Respond to external stimulus in real-time: user pressed

Life before Interrupts

I Wanted to see if a button was pressed, we checked the

Brought to you by interrupts...

I Main loop: Does whatever it does, loops forever

Two styles: lightweight or heavyweight ISRs

I Heavyweight version: When you press the button, the

Interrupt-driven Hardware Peripherals

I External interrupts are useful for syncronizing your chips

Code Example: Heavyweight

I Send light level over serial when press button

Code Example: Lightweight

I ISR just changes a variable to let the mainloop know

I Lightweight or heavyweight, heres what you need to do to

I Many peripherals use external interrupts to signal when

Interrupts on the Other Pins

I PD2 (our button pin) is special: INT0

Configuration and Use

I Two-step config example: enable PC interrupt on PB6

I Unlike the special external interrupts, PC interrupts use

Interrupt-driven Hardware Peripherals

A Better Serial Reader

Heavyweight Serial Example

I Mainloop transmits alphabet over serial

Lightweight Serial Example

I Mainloop transmits alphabet over serial, checks to see if it

More of the same thing...

I Without belaboring the point, just like there are USART RX

For later reference

Response-time Tester Game

I Start with the LEDs off

Ghetto Oscope in Ten Lines of Code

You might also like