Critical sections and interrupt disabling in FreeRTOS

Introduction

Critical sections help protect important code from being interrupted. This keeps data safe and programs running smoothly.

When you need to update shared data without interference from other tasks or interrupts.

When you want to prevent an interrupt from causing problems during a sensitive operation.

When multiple tasks might access the same resource and you want to avoid conflicts.

When you want to make sure a sequence of instructions runs all at once without being stopped.

When you want to keep the system stable by controlling when interrupts can happen.

Syntax

FreeRTOS

taskENTER_CRITICAL();
// critical code here
taskEXIT_CRITICAL();

taskENTER_CRITICAL() disables interrupts to protect the code inside.

taskEXIT_CRITICAL() re-enables interrupts after the critical code finishes.

Examples

This example safely increases a shared variable without interruption.

FreeRTOS

taskENTER_CRITICAL();
sharedVariable++;
taskEXIT_CRITICAL();

Protects multiple updates to shared resources as one atomic operation.

FreeRTOS

taskENTER_CRITICAL();
// update multiple shared resources
resource1 = newValue1;
resource2 = newValue2;
taskEXIT_CRITICAL();

Wraps a function call that changes shared data to avoid interruptions.

FreeRTOS

taskENTER_CRITICAL();
// critical section with function call
updateSharedData();
taskEXIT_CRITICAL();

Sample Program

This program shows how to safely increase a shared counter using a critical section to disable interrupts during the update.

FreeRTOS

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

volatile int sharedCounter = 0;

void incrementCounter() {
    taskENTER_CRITICAL();
    sharedCounter++;
    taskEXIT_CRITICAL();
}

int main() {
    printf("Before increment: %d\n", sharedCounter);
    incrementCounter();
    printf("After increment: %d\n", sharedCounter);
    return 0;
}

Important Notes

Always keep critical sections as short as possible to avoid slowing down the system.

Do not call blocking functions inside critical sections because it can cause system problems.

Use critical sections only when necessary to protect shared data or hardware access.

Summary

Critical sections stop interrupts to protect important code.

Use taskENTER_CRITICAL() and taskEXIT_CRITICAL() to mark critical sections.

Keep critical sections short and simple for best system performance.

Practice

1. What is the main purpose of using taskENTER_CRITICAL() and taskEXIT_CRITICAL() in FreeRTOS?

easy

A. To prevent interrupts during a critical section of code

B. To start and stop a task scheduler

C. To allocate memory dynamically

D. To create a new task

Solution

1. Step 1: Understand critical sections in FreeRTOS

   Critical sections are used to protect code that must not be interrupted to avoid data corruption or race conditions.

2. Step 2: Role of taskENTER_CRITICAL() and taskEXIT_CRITICAL()

   These functions disable and enable interrupts respectively, marking the start and end of a critical section.

3. Final Answer:

   To prevent interrupts during a critical section of code -> Option A

4. Quick Check:

   Critical sections stop interrupts = A [OK]

Hint: Critical sections disable interrupts to protect code [OK]

Common Mistakes:

• Confusing critical sections with task creation
• Thinking they manage memory
• Assuming they start the scheduler

2. Which of the following is the correct syntax to mark the start of a critical section in FreeRTOS?

easy

A. taskEXIT_CRITICAL();

B. vTaskStartCritical();

C. taskENTER_CRITICAL();

D. xTaskDisableInterrupts();

Solution

1. Step 1: Identify the function to enter critical section

   The correct FreeRTOS API to disable interrupts and enter a critical section is taskENTER_CRITICAL().

2. Step 2: Check other options for correctness

   taskEXIT_CRITICAL() exits the critical section, others are not valid FreeRTOS functions.

3. Final Answer:

   taskENTER_CRITICAL(); -> Option C

4. Quick Check:

   Enter critical section = taskENTER_CRITICAL() [OK]

Hint: Enter critical section with taskENTER_CRITICAL() [OK]

Common Mistakes:

• Using taskEXIT_CRITICAL() to start critical section
• Inventing non-existent functions
• Confusing function names

3. Consider the following FreeRTOS code snippet:

taskENTER_CRITICAL();
sharedVariable++;
taskEXIT_CRITICAL();

What is the effect of this code on sharedVariable?

medium

A. It increments sharedVariable safely without interruption

B. It causes a syntax error due to missing semicolons

C. It increments sharedVariable but allows interrupts during increment

D. It resets sharedVariable to zero

Solution

1. Step 1: Analyze the critical section usage

   The code disables interrupts before incrementing sharedVariable and re-enables them after, protecting the increment operation.

2. Step 2: Understand the effect on sharedVariable

   This ensures the increment is atomic and safe from concurrent access or interrupts.

3. Final Answer:

   It increments sharedVariable safely without interruption -> Option A

4. Quick Check:

   Critical section protects increment = D [OK]

Hint: Critical section makes increment safe from interrupts [OK]

Common Mistakes:

• Thinking interrupts are allowed during increment
• Assuming syntax errors where none exist
• Believing variable resets to zero

4. Identify the problem in this FreeRTOS code snippet:

taskENTER_CRITICAL();
sharedCounter++;
// Missing taskEXIT_CRITICAL();

medium

A. No problem, code is correct

B. sharedCounter is not incremented

C. Syntax error due to missing semicolon

D. Interrupts remain disabled causing system issues

Solution

1. Step 1: Check for matching critical section calls

   The code calls taskENTER_CRITICAL() but does not call taskEXIT_CRITICAL() to re-enable interrupts.

2. Step 2: Understand consequences of missing exit

   Interrupts remain disabled indefinitely, which can cause system to freeze or miss important events.

3. Final Answer:

   Interrupts remain disabled causing system issues -> Option D

4. Quick Check:

   Missing taskEXIT_CRITICAL() disables interrupts forever = A [OK]

Hint: Always pair taskENTER_CRITICAL() with taskEXIT_CRITICAL() [OK]

Common Mistakes:

• Ignoring missing exit call
• Assuming increment fails
• Thinking code has syntax errors

5. You have a shared resource accessed by multiple tasks and interrupts. Which approach best protects the resource while keeping system responsiveness high?

hard

A. Use long critical sections with taskENTER_CRITICAL() and taskEXIT_CRITICAL() around all resource access

B. Use short critical sections only around the minimal code that accesses the resource

C. Disable all interrupts globally for the entire program runtime

D. Avoid using critical sections and rely on task delays

Solution

1. Step 1: Understand impact of critical section length

   Long critical sections block interrupts for too long, reducing system responsiveness.

2. Step 2: Best practice for protecting shared resources

   Short critical sections minimize interrupt blocking while protecting shared data safely.

3. Final Answer:

   Use short critical sections only around the minimal code that accesses the resource -> Option B

4. Quick Check:

   Short critical sections = better responsiveness [OK]

Hint: Keep critical sections short for best performance [OK]

Common Mistakes:

• Using long critical sections unnecessarily
• Disabling interrupts globally
• Ignoring synchronization needs