Why scheduling determines real-time behavior in FreeRTOS - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of task scheduling with preemption

Consider two FreeRTOS tasks with different priorities. Task A has higher priority than Task B. Task B starts first and then Task A is created. What will be the output sequence of the print statements?

FreeRTOS

void TaskA(void *pvParameters) {
    for (;;) {
        printf("A\n");
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void TaskB(void *pvParameters) {
    printf("B\n");
    vTaskDelay(pdMS_TO_TICKS(50));
    xTaskCreate(TaskA, "TaskA", 1000, NULL, 2, NULL);
    for (;;) {
        printf("B\n");
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

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

A B\nA\nB\nA\nB\nA\n...

B A\nB\nA\nB\nA\nB\n...

C B\nB\nB\nA\nA\nA\n...

D A\nA\nA\nB\nB\nB\n...

💡 Hint

Remember that higher priority tasks preempt lower priority ones immediately.

Task B starts first and prints "B". When Task A is created with higher priority, it preempts Task B and prints "A". Then Task B resumes after Task A delays, so the output alternates.

🧠 Conceptual

intermediate

Effect of scheduling policy on real-time guarantees

Which scheduling policy in FreeRTOS best ensures that high priority tasks meet their deadlines?

A Random scheduling of tasks

B Round-robin scheduling with equal priority for all tasks

C Cooperative scheduling without preemption

D Preemptive priority-based scheduling

💡 Hint

Think about which policy allows immediate switching to important tasks.

Preemptive priority-based scheduling allows the highest priority task to run immediately, ensuring real-time deadlines are met.

🔧 Debug

advanced

Identify the scheduling issue causing missed deadlines

A FreeRTOS system has a high priority task that sometimes misses its deadline. The code snippet below shows the task creation and delay. What scheduling issue is causing the missed deadline?

FreeRTOS

xTaskCreate(HighPriorityTask, "High", 1000, NULL, 3, NULL);

void HighPriorityTask(void *pvParameters) {
    for (;;) {
        // Critical work
        vTaskDelay(pdMS_TO_TICKS(200));
    }
}

xTaskCreate(LowPriorityTask, "Low", 1000, NULL, 1, NULL);

void LowPriorityTask(void *pvParameters) {
    for (;;) {
        // Long blocking operation
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

A High priority task misses deadline because it uses vTaskDelay too long

B High priority task is starved because low priority task has higher priority

C Low priority task blocks high priority task due to cooperative scheduling

D High priority task is preempted by low priority task due to priority inversion

💡 Hint

Consider how scheduling works when preemption is disabled or cooperative.

If the system uses cooperative scheduling, the low priority task can block the CPU and prevent the high priority task from running, causing missed deadlines.

📝 Syntax

advanced

Identify the syntax error affecting task scheduling

Which option contains a syntax error that will prevent the FreeRTOS scheduler from starting?

FreeRTOS

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

void Task1(void *pvParameters) {
    for (;;) {
        // Task code
    }
}

void Task2(void *pvParameters) {
    for (;;) {
        // Task code
    }
}

A Using void main() instead of int main()

B Missing semicolon after vTaskStartScheduler() call

C Task function missing void parameter type

D Incorrect task priority values (negative numbers)

💡 Hint

Check for missing punctuation that causes compilation failure.

Missing semicolon after vTaskStartScheduler() causes a syntax error preventing compilation and scheduler start.

🚀 Application

expert

Design a scheduling strategy to guarantee real-time response

You have three tasks: SensorRead (high priority), DataProcessing (medium priority), and Logging (low priority). SensorRead must respond within 10ms. DataProcessing can be delayed up to 100ms. Logging is non-critical. Which scheduling approach best guarantees SensorRead meets its deadline?

A Assign SensorRead highest priority with preemptive scheduling; DataProcessing medium priority; Logging lowest priority

B Assign equal priority to all tasks and use round-robin scheduling

C Use cooperative scheduling with SensorRead yielding after completion

D Assign Logging highest priority to reduce CPU idle time

💡 Hint

Think about how priority and preemption affect response time.

Assigning SensorRead the highest priority with preemptive scheduling ensures it runs immediately when ready, meeting the 10ms deadline.

Practice

1. Why is scheduling important in FreeRTOS for real-time behavior?

easy

A. It decides which task runs and when, affecting response time.

B. It controls the memory allocation for tasks.

C. It manages the power consumption of the system.

D. It handles the input/output operations automatically.

Solution

1. Step 1: Understand scheduling role

   Scheduling in FreeRTOS controls task execution order and timing.

2. Step 2: Connect scheduling to real-time

   By deciding which task runs and when, scheduling affects how fast the system reacts to events.

3. Final Answer:

   It decides which task runs and when, affecting response time. -> Option A

4. Quick Check:

   Scheduling controls task timing = It decides which task runs and when, affecting response time. [OK]

Hint: Scheduling controls task timing and response speed [OK]

Common Mistakes:

• Confusing scheduling with memory management
• Thinking scheduling manages power or I/O directly
• Ignoring the impact on response time

2. Which FreeRTOS function is used to start the scheduler?

easy

A. vTaskDelay()

B. xTaskCreate()

C. vTaskStartScheduler()

D. xQueueSend()

Solution

1. Step 1: Identify scheduler start function

   The function to start the FreeRTOS scheduler is vTaskStartScheduler().

2. Step 2: Differentiate from other functions

   xTaskCreate() creates tasks, vTaskDelay() delays tasks, xQueueSend() sends to queues.

3. Final Answer:

   vTaskStartScheduler() -> Option C

4. Quick Check:

   Start scheduler function = vTaskStartScheduler() [OK]

Hint: Scheduler starts with vTaskStartScheduler() function [OK]

Common Mistakes:

• Confusing task creation with scheduler start
• Using delay or queue functions to start scheduler
• Misspelling function names

3. Given two tasks with priorities 3 and 5, which task will FreeRTOS schedule first?

medium

A. Task with priority 5

B. Task created first runs first

C. Both run simultaneously

D. Task with priority 3

Solution

1. Step 1: Understand priority meaning

   In FreeRTOS, higher numeric priority means higher importance.

2. Step 2: Compare priorities 3 and 5

   Priority 5 is higher than 3, so the task with priority 5 runs first.

3. Final Answer:

   Task with priority 5 -> Option A

4. Quick Check:

   Higher priority runs first = Task with priority 5 [OK]

Hint: Higher numeric priority runs before lower [OK]

Common Mistakes:

• Assuming lower number means higher priority
• Thinking tasks run simultaneously
• Believing creation order affects scheduling

4. What is wrong with this FreeRTOS code snippet?

void task1(void *pvParameters) {
  while(1) {
    // do work
  }
}

int main() {
  xTaskCreate(task1, "Task1", 1000, NULL, 1, NULL);
  // Missing scheduler start
  return 0;
}

medium

A. Task stack size is too large.

B. Scheduler is not started, so tasks never run.

C. Task priority is invalid.

D. Task function has wrong signature.

Solution

1. Step 1: Check for scheduler start

   The code creates a task but does not call vTaskStartScheduler(), so no tasks run.

2. Step 2: Verify other parts

   Stack size 1000 and priority 1 are valid; task signature is correct.

3. Final Answer:

   Scheduler is not started, so tasks never run. -> Option B

4. Quick Check:

   Missing scheduler start = Scheduler is not started, so tasks never run. [OK]

Hint: Always call vTaskStartScheduler() after creating tasks [OK]

Common Mistakes:

• Forgetting to start the scheduler
• Thinking stack size or priority causes no run
• Assuming task signature is incorrect

5. How does using task priorities in FreeRTOS help meet real-time deadlines?

hard

A. Priorities automatically optimize CPU clock speed.

B. Priorities reduce memory usage for tasks.

C. Priorities allow tasks to run in parallel on a single core.

D. Higher priority tasks preempt lower ones, ensuring timely execution.

Solution

1. Step 1: Understand preemption by priority

   FreeRTOS scheduler lets higher priority tasks interrupt lower priority ones.

2. Step 2: Connect preemption to deadlines

   This ensures critical tasks run quickly to meet real-time deadlines.

3. Final Answer:

   Higher priority tasks preempt lower ones, ensuring timely execution. -> Option D

4. Quick Check:

   Priority preemption ensures deadlines = Higher priority tasks preempt lower ones, ensuring timely execution. [OK]

Hint: Higher priority tasks run first to meet deadlines [OK]

Common Mistakes:

• Thinking priorities affect memory or CPU speed
• Believing tasks run truly in parallel on one core
• Ignoring preemption's role in timing