Critical sections and interrupt disabling in FreeRTOS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a critical section in FreeRTOS?

A critical section is a part of the code where shared resources are accessed and interrupts are temporarily disabled to prevent data corruption or race conditions.

intermediate

How does FreeRTOS disable interrupts to protect critical sections?

FreeRTOS disables interrupts by setting the interrupt mask to a level that prevents context switches and interrupt service routines from running during the critical section.

beginner

Which FreeRTOS API functions are used to enter and exit critical sections?

The functions are taskENTER_CRITICAL() to enter and taskEXIT_CRITICAL() to exit a critical section.

intermediate

Why should critical sections be kept as short as possible?

Because disabling interrupts for too long can delay important tasks and reduce system responsiveness, leading to missed deadlines or system instability.

advanced

What is the difference between taskENTER_CRITICAL() and portDISABLE_INTERRUPTS() in FreeRTOS?

taskENTER_CRITICAL() disables interrupts and also manages nesting of critical sections, while portDISABLE_INTERRUPTS() disables interrupts globally without nesting support.

What is the main purpose of disabling interrupts in a critical section?

A To speed up the CPU

B To allow multiple tasks to run simultaneously

C To prevent data corruption by stopping context switches

D To save power

Disabling interrupts prevents other tasks or interrupt routines from accessing shared resources simultaneously, avoiding data corruption.

Which FreeRTOS function should you call to safely enter a critical section?

A taskENTER_CRITICAL()

B portENABLE_INTERRUPTS()

C vTaskDelay()

D xTaskCreate()

taskENTER_CRITICAL() disables interrupts and manages nesting to protect critical sections.

What happens if a critical section is too long in FreeRTOS?

A More tasks run faster

B System responsiveness decreases

C Memory usage decreases

D Interrupts become more frequent

Long critical sections block interrupts and context switches, reducing system responsiveness.

Which statement is true about taskEXIT_CRITICAL()?

A It re-enables interrupts after a critical section

B It disables interrupts

C It creates a new task

D It delays the current task

taskEXIT_CRITICAL() restores interrupt state to allow normal operation after a critical section.

What is the risk of not disabling interrupts when accessing shared data?

A Automatic task synchronization

B Faster execution

C Lower power consumption

D Data corruption or race conditions

Without disabling interrupts, multiple tasks or ISRs can modify shared data simultaneously, causing errors.

Explain what a critical section is and why interrupt disabling is important in FreeRTOS.

Think about what happens when multiple tasks try to change the same data at the same time.

Describe the difference between taskENTER_CRITICAL() and portDISABLE_INTERRUPTS() and when to use each.

Consider how nesting affects interrupt enabling and disabling.

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