Critical sections and interrupt disabling in FreeRTOS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to enter a critical section using FreeRTOS API.

FreeRTOS

taskENTER_CRITICAL();
// Critical code here
[1]();

Drag options to blanks, or click blank then click option'

AtaskEXIT_CRITICAL

BtaskENTER_CRITICAL

CtaskENTER_CRITICAL()

DtaskEXIT_CRITICAL()

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting the parentheses when calling the function.

Using the enter function instead of the exit function.

You must call taskEXIT_CRITICAL() with parentheses to exit the critical section properly.

2fill in blank

medium

Complete the code to disable interrupts in FreeRTOS.

FreeRTOS

[1]();
// Critical code here
portENABLE_INTERRUPTS();

Drag options to blanks, or click blank then click option'

AportDISABLE_INTERRUPTS

BportENABLE_INTERRUPTS()

CportDISABLE_INTERRUPTS()

DportENABLE_INTERRUPTS

Attempts:

3 left

💡 Hint

Common Mistakes

Calling the enable interrupts function instead of disable.

Omitting parentheses when calling the function.

Use portDISABLE_INTERRUPTS() with parentheses to disable interrupts before critical code.

3fill in blank

hard

Fix the error in the code to properly exit a critical section.

FreeRTOS

taskENTER_CRITICAL();
// Critical code
[1];

Drag options to blanks, or click blank then click option'

AtaskEXIT_CRITICAL

BtaskEXIT_CRITICAL()

CtaskENTER_CRITICAL()

DtaskENTER_CRITICAL

Attempts:

3 left

💡 Hint

Common Mistakes

Missing parentheses causing the function not to execute.

Using the enter function instead of exit.

The function taskEXIT_CRITICAL() must be called with parentheses to properly exit the critical section.

4fill in blank

hard

Fill both blanks to create a critical section that disables interrupts and then enables them.

FreeRTOS

void critical_function() {
    [1]();
    // Critical code here
    [2]();
}

Drag options to blanks, or click blank then click option'

AportDISABLE_INTERRUPTS

BportENABLE_INTERRUPTS

CtaskENTER_CRITICAL

DtaskEXIT_CRITICAL

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing enter/exit critical section functions with interrupt macros.

Forgetting parentheses on function calls.

Use portDISABLE_INTERRUPTS() to disable interrupts and portENABLE_INTERRUPTS() to enable them after the critical code.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps task names to their priority if priority is above 3.

FreeRTOS

task_priorities = { [1]: [2] for [1] in tasks if [2] > 3 }

Drag options to blanks, or click blank then click option'

Atask.name

Btask.priority

Ctask

Dpriority

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined variables like 'priority' instead of 'task.priority'.

Mixing keys and values incorrectly in the comprehension.

The comprehension iterates over task in tasks, maps task.name to task.priority, and filters where task.priority is greater than 3.

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