Nested interrupt handling in FreeRTOS - Mini Project: Build & Apply

Nested Interrupt Handling in FreeRTOS

📖 Scenario: You are working on a microcontroller project using FreeRTOS. Your device needs to handle two interrupts: a high priority timer interrupt and a lower priority sensor interrupt. The timer interrupt can occur anytime, even while the sensor interrupt is running. You want to make sure the timer interrupt can interrupt the sensor interrupt (nested interrupts) and both handlers update shared counters safely.

🎯 Goal: Build a simple FreeRTOS program that sets up two interrupt handlers with different priorities. The timer interrupt handler should be able to interrupt the sensor interrupt handler. Both handlers will increment their own counters. You will configure the interrupts, write the handlers, and print the final counts.

📋 What You'll Learn

Create two global counters: timer_count and sensor_count

Configure two interrupts: TIMER_IRQn with higher priority and SENSOR_IRQn with lower priority

Write interrupt handlers TIMER_IRQHandler and SENSOR_IRQHandler that increment their counters

Enable nested interrupts so TIMER_IRQHandler can interrupt SENSOR_IRQHandler

Print the values of timer_count and sensor_count after simulating interrupts

💡 Why This Matters

🌍 Real World

Embedded systems often need to handle multiple interrupts with different priorities. Nested interrupts allow urgent tasks to interrupt less urgent ones, improving responsiveness.

💼 Career

Understanding nested interrupt handling is essential for embedded software engineers working on real-time systems, device drivers, and hardware interfacing.

1

Create global counters for interrupts

Create two global variables called timer_count and sensor_count and initialize both to 0.

FreeRTOS

# Your code here

Need a hint?

Use volatile int for counters because they are changed inside interrupts.

2

Configure interrupt priorities

Write code to set the priority of TIMER_IRQn to 1 (higher priority) and SENSOR_IRQn to 2 (lower priority) using NVIC_SetPriority. Then enable both interrupts with NVIC_EnableIRQ.

FreeRTOS

volatile int timer_count = 0;
volatile int sensor_count = 0;

// Your code here

Need a hint?

Lower number means higher priority in NVIC_SetPriority.

3

Write nested interrupt handlers

Write two interrupt handlers: void TIMER_IRQHandler(void) and void SENSOR_IRQHandler(void). In each handler, increment the respective counter (timer_count or sensor_count). In SENSOR_IRQHandler, enable interrupts at the start to allow nesting by calling __enable_irq(). In TIMER_IRQHandler, just increment the counter.

FreeRTOS

volatile int timer_count = 0;
volatile int sensor_count = 0;

NVIC_SetPriority(TIMER_IRQn, 1);
NVIC_SetPriority(SENSOR_IRQn, 2);
NVIC_EnableIRQ(TIMER_IRQn);
NVIC_EnableIRQ(SENSOR_IRQn);

// Your code here

Need a hint?

Call __enable_irq() inside SENSOR_IRQHandler to allow higher priority interrupts to nest.

4

Simulate interrupts and print counters

Simulate calling SENSOR_IRQHandler() followed by TIMER_IRQHandler() twice. Then print the values of timer_count and sensor_count using printf in the format: "Timer count: X, Sensor count: Y" where X and Y are the counter values.

FreeRTOS

volatile int timer_count = 0;
volatile int sensor_count = 0;

NVIC_SetPriority(TIMER_IRQn, 1);
NVIC_SetPriority(SENSOR_IRQn, 2);
NVIC_EnableIRQ(TIMER_IRQn);
NVIC_EnableIRQ(SENSOR_IRQn);

void TIMER_IRQHandler(void) {
    timer_count++;
}

void SENSOR_IRQHandler(void) {
    __enable_irq();
    sensor_count++;
}

// Your code here

Need a hint?

Call the handlers in the order specified and print the counters with printf.