Why interrupt handling is critical in RTOS in FreeRTOS

Introduction

Interrupt handling lets the system quickly respond to important events. In a real-time operating system (RTOS), this is critical to keep tasks running on time and avoid delays.

When a sensor sends data that needs immediate processing.

When a user presses a button that should trigger an instant action.

When a communication message arrives and must be handled right away.

When a timer reaches a set value and triggers a scheduled task.

When an error or fault occurs that requires quick attention.

Syntax

FreeRTOS

void ISR_Handler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    // Clear interrupt flag
    // Handle interrupt event
    // Optionally notify a task
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

The ISR (Interrupt Service Routine) must be short and fast.

Use special FreeRTOS functions like portYIELD_FROM_ISR() to switch tasks safely.

Examples

This ISR handles a button press and notifies a task to process it.

FreeRTOS

void Button_ISR(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    // Clear button interrupt flag
    // Notify task that button was pressed
    vTaskNotifyGiveFromISR(buttonTaskHandle, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

This ISR handles a timer event quickly and safely.

FreeRTOS

void Timer_ISR(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    // Clear timer interrupt flag
    // Increment a counter or set a flag
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

Sample Program

This program creates a task that waits for a timer interrupt notification. When the timer ISR runs, it notifies the task to toggle an LED (simulated by printing).

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include <stdio.h>

TaskHandle_t ledTaskHandle;

void LED_Task(void *pvParameters) {
    for(;;) {
        // Wait for notification from ISR
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        // Toggle LED here
        // (Simulated by print)
        printf("LED toggled\n");
    }
}

void Timer_ISR(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    // Clear timer interrupt flag (simulated)
    // Notify LED task
    vTaskNotifyGiveFromISR(ledTaskHandle, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

int main(void) {
    xTaskCreate(LED_Task, "LED Task", 1000, NULL, 1, &ledTaskHandle);
    vTaskStartScheduler();
    return 0;
}

Important Notes

Keep ISRs short to avoid blocking other important tasks.

Use FreeRTOS ISR-safe functions to communicate with tasks.

Interrupts help RTOS meet timing deadlines by reacting immediately.

Summary

Interrupt handling lets RTOS respond fast to events.

ISRs should be quick and use FreeRTOS-safe calls.

This keeps tasks running smoothly and on time.