Critical sections and interrupt disabling in FreeRTOS - Step-by-Step Execution

Concept Flow - Critical sections and interrupt disabling

Start Task

↓

Disable Interrupts

↓

Enter Critical Section

↓

Execute Critical Code

↓

Exit Critical Section

↓

Enable Interrupts

↓

Continue Task Execution

The task disables interrupts to enter a critical section, runs code safely, then re-enables interrupts to continue.

Execution Sample

FreeRTOS

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

This code disables interrupts to protect critical code, then re-enables interrupts after.

Execution Table

Step	Action	Interrupt State	Description
1	Call taskENTER_CRITICAL()	Disabled	Interrupts disabled, entering critical section
2	Execute critical code	Disabled	Critical code runs safely without interruption
3	Call taskEXIT_CRITICAL()	Enabled	Interrupts re-enabled, exiting critical section
4	Continue normal task	Enabled	Task continues with interrupts enabled

💡 Interrupts re-enabled after critical section, allowing normal operation

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
Interrupts	Enabled	Disabled	Disabled	Enabled	Enabled
InCriticalSection	False	True	True	False	False

Key Moments - 3 Insights

Why do interrupts need to be disabled in a critical section?

Interrupts are disabled (see Step 1 in execution_table) to prevent other code from interrupting and causing data corruption during the critical code execution.

What happens if interrupts are not re-enabled after the critical section?

If interrupts stay disabled (not shown in Step 3), the system cannot respond to important events, causing system malfunction or freezes.

Can critical sections be nested?

Yes, FreeRTOS supports nesting by counting entries; interrupts are only re-enabled after the last taskEXIT_CRITICAL() call (not shown in this simple trace).

Visual Quiz - 3 Questions

Look at the execution_table, what is the interrupt state during Step 2?

A Enabled

B Partially enabled

C Disabled

D Unknown

💡 Hint

Check the 'Interrupt State' column for Step 2 in the execution_table.

At which step are interrupts re-enabled?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look for 'taskEXIT_CRITICAL()' in the Action column and see the Interrupt State change.

If interrupts were not disabled at Step 1, what risk would occur?

A Task would run faster

B Critical code might be interrupted causing data corruption

C System would disable itself

D No effect

💡 Hint

Refer to the key_moments explanation about why interrupts are disabled.

Concept Snapshot

taskENTER_CRITICAL() disables interrupts to protect critical code.
taskEXIT_CRITICAL() re-enables interrupts after.
Use critical sections to avoid data corruption.
Interrupts must be re-enabled to keep system responsive.
Nesting is supported by FreeRTOS internally.

Full Transcript

In FreeRTOS, critical sections protect code from interruption by disabling interrupts using taskENTER_CRITICAL(). This ensures the critical code runs safely without interference. After the critical code finishes, taskEXIT_CRITICAL() re-enables interrupts so the system can respond to events again. Interrupts start enabled, get disabled at Step 1, stay disabled during critical code at Step 2, and are re-enabled at Step 3. If interrupts were not disabled, other code could interrupt and cause data corruption. Also, interrupts must be re-enabled after the critical section to avoid system freezes. FreeRTOS supports nested critical sections by counting entries and only enabling interrupts after the last exit call.

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