Deferred interrupt processing architecture in FreeRTOS - Mini Project: Build & Apply

Deferred Interrupt Processing with FreeRTOS

📖 Scenario: You are building a simple embedded system using FreeRTOS. The system reads data from a sensor that triggers an interrupt when new data is ready. To keep the interrupt fast and responsive, you will use deferred interrupt processing by handling the heavy work in a FreeRTOS task instead of inside the interrupt.

🎯 Goal: Create a FreeRTOS program that uses an interrupt service routine (ISR) to notify a task to process sensor data. The ISR will only send a notification, and the task will do the actual data processing.

📋 What You'll Learn

Create a global variable sensor_data_ready initialized to 0

Create a FreeRTOS task called SensorTask that waits for a notification

Create an ISR function called SensorISR_Handler that sets sensor_data_ready to 1 and notifies SensorTask

In SensorTask, clear sensor_data_ready and print "Processing sensor data..." when notified

💡 Why This Matters

🌍 Real World

Deferred interrupt processing is used in embedded systems to keep interrupts fast and responsive by moving heavy work to tasks.

💼 Career

Understanding this architecture is important for embedded software engineers working with real-time operating systems like FreeRTOS.

1

Create the initial data setup

Create a global variable called sensor_data_ready and set it to 0.

FreeRTOS

# Create a global variable sensor_data_ready and set it to 0
# Your code here

Need a hint?

Use volatile int sensor_data_ready = 0; to declare the variable.

2

Create the FreeRTOS task

Create a FreeRTOS task function called SensorTask that runs an infinite loop and waits for a notification using ulTaskNotifyTake. Inside the loop, check if sensor_data_ready is 1, then clear it to 0.

FreeRTOS

volatile int sensor_data_ready = 0;

// Create SensorTask function
// Your code here

Need a hint?

Use ulTaskNotifyTake(pdTRUE, portMAX_DELAY) to wait for notification.

3

Create the ISR to notify the task

Create an ISR function called SensorISR_Handler that sets sensor_data_ready to 1 and uses vTaskNotifyGiveFromISR to notify SensorTask. Assume SensorTaskHandle is the task handle for SensorTask.

FreeRTOS

volatile int sensor_data_ready = 0;

void SensorTask(void *pvParameters) {
    for (;;) {
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        if (sensor_data_ready == 1) {
            sensor_data_ready = 0;
            // Processing will be done in next step
        }
    }
}

TaskHandle_t SensorTaskHandle = NULL;

// Create ISR function SensorISR_Handler
// Your code here

Need a hint?

Use vTaskNotifyGiveFromISR and portYIELD_FROM_ISR to notify the task safely from ISR.

4

Print output when processing sensor data

Inside SensorTask, after clearing sensor_data_ready, add a printf statement to print exactly "Processing sensor data...".

FreeRTOS

volatile int sensor_data_ready = 0;

void SensorTask(void *pvParameters) {
    for (;;) {
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        if (sensor_data_ready == 1) {
            sensor_data_ready = 0;
            // Print "Processing sensor data..." here
            // Your code here
        }
    }
}

TaskHandle_t SensorTaskHandle = NULL;

void SensorISR_Handler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    sensor_data_ready = 1;
    vTaskNotifyGiveFromISR(SensorTaskHandle, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

Need a hint?

Use printf("Processing sensor data...\n"); to print the message.