Interrupts

Interrupts differ from exceptions in a variety of ways but their operation anduse is largely similar and they are also handled by the same interruptcontroller. Whereas exceptions are defined by the Cortex-M architecture,interrupts are always vendor (and often even chip) specific implementations,both in naming and functionality.

Interrupts do allow for a lot of flexibility which needs to be accounted forwhen attempting to use them in an advanced way. We will not cover those uses inthis book, however it is a good idea to keep the following in mind:

  • Interrupts have programmable priorities which determine their handlers' execution order
  • Interrupts can nest and preempt, i.e. execution of an interrupt handler might be interrupted by another higher-priority interrupt
  • In general the reason causing the interrupt to trigger needs to be cleared to prevent re-entering the interrupt handler endlessly

The general initialization steps at runtime are always the same:

  • Setup the peripheral(s) to generate interrupts requests at the desired occasions
  • Set the desired priority of the interrupt handler in the interrupt controller
  • Enable the interrupt handler in the interrupt controller

Similarly to exceptions, the cortex-m-rt crate provides an interruptattribute to declare interrupt handlers. The available interrupts (andtheir position in the interrupt handler table) are usually automaticallygenerated via svd2rust from a SVD description.

  1. // Interrupt handler for the Timer2 interrupt
  2. #[interrupt]
  3. fn TIM2() {
  4.     // ..
  5.     // Clear reason for the generated interrupt request
  6. }

Interrupt handlers look like plain functions (except for the lack of arguments)similar to exception handlers. However they can not be called directly by otherparts of the firmware due to the special calling conventions. It is howeverpossible to generate interrupt requests in software to trigger a diversion tothe interrupt handler.

Similar to exception handlers it is also possible to declare static mutvariables inside the interrupt handlers for safe state keeping.

  1. #[interrupt]
  2. fn TIM2() {
  3.     static mut COUNT: u32 = 0;
  5.     // `COUNT` has type `&mut u32` and it's safe to use
  6.     *COUNT += 1;
  7. }

For a more detailed description about the mechanisms demonstrated here pleaserefer to the exceptions section.