Multiple tasks running concurrently in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this FreeRTOS task scheduling code?

Consider two tasks created with the same priority in FreeRTOS. Each task prints a message and then delays for 100 ticks. What will be the output sequence?

FreeRTOS

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

void Task1(void *pvParameters) {
    while(1) {
        printf("Task 1 running\n");
        vTaskDelay(100);
    }
}

void Task2(void *pvParameters) {
    while(1) {
        printf("Task 2 running\n");
        vTaskDelay(100);
    }
}

int main(void) {
    xTaskCreate(Task1, "Task1", 1000, NULL, 1, NULL);
    xTaskCreate(Task2, "Task2", 1000, NULL, 1, NULL);
    vTaskStartScheduler();
    return 0;
}

A Task 1 running\nTask 2 running\nTask 1 running\nTask 2 running\n... (alternating)

B Task 1 running\nTask 1 running\nTask 1 running\nTask 2 running\nTask 2 running\nTask 2 running\n...

C Task 2 running\nTask 1 running\nTask 2 running\nTask 1 running\n... (alternating)

D Only Task 1 runs repeatedly; Task 2 never runs.

💡 Hint

Tasks with the same priority and equal delay times will share CPU time in a round-robin manner.

Since both tasks have the same priority and call vTaskDelay(100), the scheduler switches between them, resulting in alternating output.

🧠 Conceptual

intermediate

Which FreeRTOS function is used to create a new task?

In FreeRTOS, what is the correct function to create a new task that will run concurrently?

A vTaskRun()

B xTaskCreate()

C vTaskStart()

D xCreateTask()

💡 Hint

Look for the function starting with 'x' that creates tasks.

The function xTaskCreate() is the official FreeRTOS API to create a new task.

🔧 Debug

advanced

Why does this FreeRTOS code cause a stack overflow?

Examine the following task code. Why might it cause a stack overflow?

FreeRTOS

void Task(void *pvParameters) {
    char buffer[1024];
    while(1) {
        // Do some work
        vTaskDelay(10);
    }
}

int main(void) {
    xTaskCreate(Task, "Task", 100, NULL, 1, NULL);
    vTaskStartScheduler();
    return 0;
}

A The stack size (100) is too small for the 1024-byte buffer, causing overflow.

B The task priority is too high, causing stack overflow.

C The task function is missing a return statement, causing overflow.

D vTaskDelay(10) causes the task to never yield, leading to overflow.

💡 Hint

Consider the size of local variables versus the stack size allocated.

The task stack size is set to 100 words, which is too small to hold the 1024-byte local buffer, causing stack overflow.

📝 Syntax

advanced

Identify the syntax error in this FreeRTOS task creation code

Which option contains the correct syntax to create a FreeRTOS task?

A xTaskCreate(TaskFunction, Task, 256, NULL, 2, NULL);

B xTaskCreate(TaskFunction, "Task", 256, NULL, 2);

C xTaskCreate("TaskFunction", "Task", 256, NULL, 2, NULL);

D xTaskCreate(TaskFunction, "Task", 256, NULL, 2, NULL);

💡 Hint

Check the parameter types and count for xTaskCreate.

The first parameter must be a function pointer, the second a string name, and the last parameter is a pointer to receive the task handle (can be NULL). Option D matches this.

🚀 Application

expert

How to ensure two FreeRTOS tasks do not access a shared variable simultaneously?

You have two tasks that both read and write a shared variable. Which method ensures safe concurrent access?

A Increase task priorities so one runs before the other.

B Use vTaskDelay() in both tasks to avoid overlap.

C Use a mutex to lock the variable during access.

D Declare the variable as volatile to prevent conflicts.

💡 Hint

Think about synchronization tools FreeRTOS provides.

A mutex ensures only one task accesses the shared variable at a time, preventing race conditions.

Practice

1. What is the main purpose of running multiple tasks concurrently in FreeRTOS?

easy

A. To allow the program to perform several operations at the same time

B. To make the program run slower

C. To use more memory without benefit

D. To avoid using any delays in the code

Solution

1. Step 1: Understand task concurrency

   Multiple tasks let the program handle different jobs at once, improving efficiency.

2. Step 2: Identify the purpose in FreeRTOS

   FreeRTOS switches between tasks automatically, enabling multitasking.

3. Final Answer:

   To allow the program to perform several operations at the same time -> Option A

4. Quick Check:

   Multiple tasks = multitasking = To allow the program to perform several operations at the same time [OK]

Hint: Multiple tasks mean doing many things at once [OK]

Common Mistakes:

• Thinking tasks slow down the program
• Believing tasks waste memory
• Ignoring the role of delays

2. Which of the following is the correct way to create a task in FreeRTOS?

easy

A. TaskCreate(TaskFunction, "TaskName", stackSize, NULL, priority, NULL);

B. createTask(TaskFunction, "TaskName", stackSize, NULL, priority, NULL);

C. xTaskCreate(TaskFunction, "TaskName", stackSize, NULL, priority, NULL);

D. xCreateTask(TaskFunction, "TaskName", stackSize, NULL, priority, NULL);

Solution

1. Step 1: Recall FreeRTOS task creation function

   The correct function to create a task is xTaskCreate.

2. Step 2: Match the exact syntax

   xTaskCreate(TaskFunction, "TaskName", stackSize, NULL, priority, NULL); matches the correct function name and parameters.

3. Final Answer:

   xTaskCreate(TaskFunction, "TaskName", stackSize, NULL, priority, NULL); -> Option C

4. Quick Check:

   Task creation function = xTaskCreate = xTaskCreate(TaskFunction, "TaskName", stackSize, NULL, priority, NULL); [OK]

Hint: Remember the function starts with 'xTaskCreate' [OK]

Common Mistakes:

• Using incorrect function names like createTask
• Mixing up parameter order
• Missing the 'x' prefix in function name

3. Consider this FreeRTOS code snippet:

void Task1(void *pvParameters) {
  for (;;) {
    printf("Task1 running\n");
    vTaskDelay(pdMS_TO_TICKS(1000));
  }
}

void Task2(void *pvParameters) {
  for (;;) {
    printf("Task2 running\n");
    vTaskDelay(pdMS_TO_TICKS(500));
  }
}

What will be the output pattern when both tasks run concurrently?

medium

A. Task1 prints every 1 second; Task2 prints every 0.5 seconds

B. Task1 and Task2 print at the same time every 1 second

C. Task1 prints every 0.5 seconds; Task2 prints every 1 second

D. Only Task1 prints because Task2 is blocked

Solution

1. Step 1: Analyze vTaskDelay timing for Task1

   Task1 delays 1000 ms (1 second) between prints.

2. Step 2: Analyze vTaskDelay timing for Task2

   Task2 delays 500 ms (0.5 seconds) between prints.

3. Step 3: Understand concurrent execution

   Both tasks run independently, so Task2 prints twice as often as Task1.

4. Final Answer:

   Task1 prints every 1 second; Task2 prints every 0.5 seconds -> Option A

5. Quick Check:

   Delays control print rate = Task1 prints every 1 second; Task2 prints every 0.5 seconds [OK]

Hint: Check each task's delay time to predict print frequency [OK]

Common Mistakes:

• Assuming tasks print simultaneously
• Mixing up delay times
• Thinking one task blocks the other

4. Given this code snippet, what is the error?

void TaskA(void *pvParameters) {
  while(1) {
    // Do something
    vTaskDelay(1000);
  }
}

xTaskCreate(TaskA, "TaskA", 1000, NULL, 1, NULL);

medium

A. Task function must return int, not void

B. vTaskDelay requires delay in ticks, not milliseconds

C. Stack size 1000 is too small

D. Task name must be longer than 5 characters

Solution

1. Step 1: Check vTaskDelay parameter

   vTaskDelay expects delay in ticks, not milliseconds.

2. Step 2: Identify correct delay usage

   Use pdMS_TO_TICKS(1000) to convert 1000 ms to ticks.

3. Final Answer:

   vTaskDelay requires delay in ticks, not milliseconds -> Option B

4. Quick Check:

   Delay unit must be ticks = vTaskDelay requires delay in ticks, not milliseconds [OK]

Hint: Use pdMS_TO_TICKS() to convert ms to ticks for vTaskDelay [OK]

Common Mistakes:

• Passing milliseconds directly to vTaskDelay
• Wrong return type for task function
• Incorrect stack size assumptions

5. You want two tasks to print messages alternately every 500 ms without overlapping prints. Which approach ensures this behavior in FreeRTOS?

hard

A. Use global variables without any synchronization

B. Use vTaskDelay with different delay times for each task

C. Run both tasks at the same priority without synchronization

D. Use a binary semaphore to synchronize tasks before printing

Solution

1. Step 1: Understand the need for synchronization

   To avoid overlapping prints, tasks must coordinate access to the printing resource.

2. Step 2: Identify synchronization method

   A binary semaphore allows one task to print while the other waits, alternating access.

3. Step 3: Evaluate other options

   Different delays or same priority without sync can cause overlapping prints; global variables alone don't prevent conflicts.

4. Final Answer:

   Use a binary semaphore to synchronize tasks before printing -> Option D

5. Quick Check:

   Synchronization via semaphore = Use a binary semaphore to synchronize tasks before printing [OK]

Hint: Use semaphores to control shared resource access [OK]

Common Mistakes:

• Relying only on delays for synchronization
• Ignoring task priority effects
• Not using any synchronization mechanism