Semaphore for ISR-to-task signaling in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this ISR-to-task semaphore signaling code?

Consider the following FreeRTOS code snippet where an ISR signals a task using a binary semaphore. What will be the output printed by the task?

FreeRTOS

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

SemaphoreHandle_t xBinarySemaphore;

void vISR_Handler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR(xBinarySemaphore, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void vTaskFunction(void *pvParameters) {
    if(xSemaphoreTake(xBinarySemaphore, portMAX_DELAY) == pdTRUE) {
        printf("Semaphore taken, task running\n");
    } else {
        printf("Failed to take semaphore\n");
    }
    vTaskDelete(NULL);
}

int main(void) {
    xBinarySemaphore = xSemaphoreCreateBinary();
    xTaskCreate(vTaskFunction, "Task", 1000, NULL, 1, NULL);
    vISR_Handler();
    vTaskStartScheduler();
    return 0;
}

A Semaphore taken, task running

B Failed to take semaphore

C No output, task blocked forever

D Compilation error due to missing includes

💡 Hint

Think about what happens when the ISR gives the semaphore before the task tries to take it.

The ISR gives the binary semaphore before the task attempts to take it. Since the semaphore is given, the task successfully takes it and prints "Semaphore taken, task running".

🧠 Conceptual

intermediate

Which statement best describes the use of semaphores for ISR-to-task signaling?

In FreeRTOS, why are semaphores commonly used for signaling from an ISR to a task?

A Semaphores allow the ISR to directly execute task code synchronously.

B Semaphores are used to disable interrupts during task execution.

C Semaphores prevent tasks from running until the ISR finishes execution.

D Semaphores provide a safe way for ISRs to unblock tasks without blocking themselves.

💡 Hint

Consider what ISRs must avoid doing and how tasks can be notified safely.

ISRs must not block or perform long operations. Semaphores allow ISRs to signal tasks safely without blocking, enabling tasks to run when appropriate.

🔧 Debug

advanced

What error occurs in this ISR-to-task semaphore code?

Identify the error in the following code snippet and what happens when the ISR tries to give the semaphore.

FreeRTOS

SemaphoreHandle_t xSem;

void ISR_Handler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGive(xSem); // Incorrect function used
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void Task(void *pvParameters) {
    if(xSemaphoreTake(xSem, portMAX_DELAY) == pdTRUE) {
        // Task code
    }
}

A Runtime error: Semaphore not given from ISR safely

B Compilation error: xSemaphoreGiveFromISR missing

C No error, code runs correctly

D Deadlock because task never unblocks

💡 Hint

Check the function used inside the ISR to give the semaphore.

xSemaphoreGive must not be called from an ISR. Instead, xSemaphoreGiveFromISR must be used. Using xSemaphoreGive in ISR can cause runtime errors or undefined behavior.

📝 Syntax

advanced

Which option correctly signals a binary semaphore from an ISR?

Choose the correct syntax to give a binary semaphore from an ISR in FreeRTOS.

A xSemaphoreGive(xSemaphore);

B xSemaphoreGiveFromISR(xSemaphore, NULL);

C xSemaphoreTakeFromISR(xSemaphore, NULL);

D xSemaphoreGiveFromISR(xSemaphore);

💡 Hint

Remember the function signature requires a pointer to a variable for context switching.

xSemaphoreGiveFromISR requires two parameters: the semaphore handle and a pointer to a BaseType_t variable to indicate if a context switch is needed. Passing NULL is valid if context switch is not needed.

🚀 Application

expert

How many times will the task unblock given this ISR signaling pattern?

A binary semaphore is created and initially empty. The ISR calls xSemaphoreGiveFromISR three times in quick succession before the task attempts to take the semaphore once. How many times will the task unblock if it calls xSemaphoreTake once with portMAX_DELAY?

A The task will unblock three times, once per ISR call.

B The task will unblock twice, because the first give is ignored.

C The task will unblock only once, because the semaphore is binary and cannot count beyond one.

D The task will never unblock because the semaphore was given before task creation.

💡 Hint

Think about the difference between binary and counting semaphores.

A binary semaphore can only hold a maximum count of one. Multiple gives before a take do not accumulate. So the task unblocks only once.

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