Semaphore for ISR-to-task signaling in FreeRTOS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of using a semaphore for ISR-to-task signaling in FreeRTOS?

A semaphore allows an Interrupt Service Routine (ISR) to notify a task that an event has occurred, enabling safe and efficient communication between ISRs and tasks.

beginner

Which FreeRTOS API function is used to give a semaphore from within an ISR?

xSemaphoreGiveFromISR() is used to give (release) a semaphore from an ISR safely.

intermediate

Why must you use the special ISR version of semaphore functions in FreeRTOS?

Because ISRs have different execution context and restrictions, the ISR versions of semaphore functions avoid blocking and use special mechanisms to safely interact with the scheduler.

intermediate

What parameter does xSemaphoreGiveFromISR() use to request a context switch?

It uses a pointer to a BaseType_t variable (usually called pxHigherPriorityTaskWoken) which is set to pdTRUE if giving the semaphore unblocks a higher priority task, signaling a context switch is needed.

beginner

How does a task wait for a semaphore given by an ISR?

The task calls xSemaphoreTake() with a block time to wait until the semaphore is given by the ISR, effectively synchronizing with the interrupt event.

Which function is correct to give a semaphore from an ISR in FreeRTOS?

A xSemaphoreTakeFromISR()

B xSemaphoreGiveFromISR()

C xSemaphoreGive()

D vTaskDelay()

xSemaphoreGiveFromISR() is designed for ISR context and safe to call from an ISR.

What does the pxHigherPriorityTaskWoken parameter do in xSemaphoreGiveFromISR()?

A Returns the semaphore count

B Blocks the ISR until the task runs

C Disables interrupts

D Indicates if a higher priority task was woken and a context switch is needed

It signals if giving the semaphore caused a higher priority task to unblock, so the scheduler can switch context immediately.

Why can't you use xSemaphoreGive() inside an ISR?

A It is slower

B It disables interrupts

C It may block and ISRs cannot block

D It requires a task handle

xSemaphoreGive() can block or use scheduler functions not safe in ISR context.

What is the typical use case for a semaphore in ISR-to-task signaling?

A Notify a task that an interrupt event occurred

B Delay a task

C Create a new task

D Allocate memory

Semaphores are used to signal tasks from ISRs about events like data ready or hardware interrupts.

Which of these is NOT true about semaphores in FreeRTOS?

A Semaphores automatically delete tasks

B Tasks can wait on semaphores to synchronize

C They help coordinate between ISRs and tasks

D They can be given from ISRs using special functions

Semaphores do not delete tasks; they only signal or synchronize.

Explain how a semaphore is used to signal a task from an ISR in FreeRTOS.

Think about how the ISR notifies the task and how the task waits.

Describe why it is important to use ISR-safe semaphore functions instead of normal semaphore functions inside an ISR.

Consider the restrictions of interrupt context.

Practice

1. What is the main purpose of using a semaphore in FreeRTOS for ISR-to-task signaling?

easy

A. To disable interrupts during task execution

B. To create a new task inside an ISR

C. To safely notify a task from an interrupt service routine (ISR)

D. To allocate memory dynamically in an ISR

Solution

1. Step 1: Understand semaphore role in FreeRTOS

   Semaphores are synchronization tools used to signal between tasks or between ISRs and tasks.

2. Step 2: Identify ISR-to-task signaling purpose

   In FreeRTOS, semaphores let an ISR notify a task safely without blocking or complex synchronization.

3. Final Answer:

   To safely notify a task from an interrupt service routine (ISR) -> Option C

4. Quick Check:

   Semaphore signals task from ISR = A [OK]

Hint: Semaphores signal tasks from ISRs safely [OK]

Common Mistakes:

• Thinking semaphores create tasks
• Confusing semaphores with disabling interrupts
• Using semaphores for memory allocation

2. Which FreeRTOS function is used inside an ISR to give a semaphore to a task?

easy

A. xSemaphoreGiveFromISR()

B. xSemaphoreTakeFromISR()

C. xSemaphoreCreateFromISR()

D. xSemaphoreGive()

Solution

1. Step 1: Recall ISR-safe semaphore functions

   FreeRTOS provides special functions for ISR context to avoid blocking and ensure safety.

2. Step 2: Identify the correct ISR semaphore give function

   The function to give a semaphore from an ISR is xSemaphoreGiveFromISR().

3. Final Answer:

   xSemaphoreGiveFromISR() -> Option A

4. Quick Check:

   Give semaphore from ISR = xSemaphoreGiveFromISR() [OK]

Hint: ISR uses xSemaphoreGiveFromISR() to signal tasks [OK]

Common Mistakes:

• Using xSemaphoreGive() inside ISR (not safe)
• Confusing take and give functions
• Assuming xSemaphoreCreateFromISR() exists

3. Given the code snippet below, what will be the output printed by the task?

SemaphoreHandle_t xSemaphore;

void ISR_Handler() {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR(xSemaphore, &xHigherPriorityTaskWoken);
}

void TaskFunction(void *pvParameters) {
    if (xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdTRUE) {
        printf("Semaphore received\n");
    }
}

medium

A. Semaphore received twice

B. No output

C. Runtime error

D. Semaphore received

Solution

1. Step 1: Analyze ISR giving semaphore

   The ISR calls xSemaphoreGiveFromISR() which releases the semaphore.

2. Step 2: Analyze task waiting on semaphore

   The task waits indefinitely with xSemaphoreTake() and prints "Semaphore received" when it gets the semaphore.

3. Final Answer:

   Semaphore received -> Option D

4. Quick Check:

   Task prints after semaphore take = C [OK]

Hint: Task prints after successful semaphore take [OK]

Common Mistakes:

• Thinking semaphore is given twice
• Assuming no output if ISR runs
• Expecting runtime error without initialization

4. Identify the error in the following ISR code snippet for giving a semaphore:

void ISR_Handler() {
    xSemaphoreGive(xSemaphore);
}

medium

A. xSemaphoreGive() cannot be called from an ISR

B. Semaphore must be taken before giving

C. ISR must not use semaphores

D. xSemaphoreGive() requires a pointer argument

Solution

1. Step 1: Check function suitability for ISR

   xSemaphoreGive() is not safe to call inside an ISR because it may block or cause race conditions.

2. Step 2: Identify correct ISR function

   Use xSemaphoreGiveFromISR() inside ISRs to safely give semaphores.

3. Final Answer:

   xSemaphoreGive() cannot be called from an ISR -> Option A

4. Quick Check:

   Use xSemaphoreGiveFromISR() in ISR, not xSemaphoreGive() [OK]

Hint: Use xSemaphoreGiveFromISR() inside ISR, not xSemaphoreGive() [OK]

Common Mistakes:

• Calling xSemaphoreGive() inside ISR
• Ignoring ISR context restrictions
• Assuming semaphore must be taken before giving

5. You want a task to respond immediately when a hardware interrupt occurs. Which sequence correctly uses a semaphore for ISR-to-task signaling in FreeRTOS?

hard

A. Create counting semaphore; task calls xSemaphoreGive(); ISR calls xSemaphoreTakeFromISR()

B. Create binary semaphore; ISR calls xSemaphoreGiveFromISR(); task calls xSemaphoreTake() with portMAX_DELAY

C. Create mutex; ISR calls xSemaphoreGive(); task calls xSemaphoreTake() with zero timeout

D. Create binary semaphore; task calls xSemaphoreGiveFromISR(); ISR calls xSemaphoreTake()

Solution

1. Step 1: Identify correct semaphore type and usage

   Binary semaphore is suitable for signaling events from ISR to task.

2. Step 2: Confirm correct function calls and order

   ISR must call xSemaphoreGiveFromISR() to signal; task waits with xSemaphoreTake() blocking indefinitely (portMAX_DELAY) until signaled.

3. Final Answer:

   Create binary semaphore; ISR calls xSemaphoreGiveFromISR(); task calls xSemaphoreTake() with portMAX_DELAY -> Option B

4. Quick Check:

   Binary semaphore + ISR give + task take = A [OK]

Hint: ISR gives semaphore, task takes with infinite wait [OK]

Common Mistakes:

• Using mutex instead of semaphore
• Calling give in task and take in ISR
• Using zero timeout causing missed signals