Hard real-time vs soft real-time in FreeRTOS - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Hard Real-Time Systems

Which statement best describes a hard real-time system?

A A system where every deadline must be met strictly, or the system fails.

B A system where missing a deadline occasionally is acceptable without serious consequences.

C A system that processes tasks without any timing constraints.

D A system that prioritizes tasks randomly without deadlines.

💡 Hint

Think about what happens if a deadline is missed in safety-critical systems.

Hard real-time systems require strict adherence to deadlines. Missing a deadline can cause system failure or hazards.

❓ Predict Output

intermediate

Task Priority Impact on Deadline in FreeRTOS

Consider two FreeRTOS tasks: TaskA with priority 3 and TaskB with priority 2. TaskA must complete within 10ms. What happens if TaskB runs longer than expected?

What is the likely outcome regarding TaskA's deadline?

FreeRTOS

void TaskA(void *pvParameters) {
  // Critical task
  for(;;) {
    // Must finish within 10ms
    vTaskDelay(pdMS_TO_TICKS(5));
    // Perform critical work
  }
}

void TaskB(void *pvParameters) {
  for(;;) {
    // Runs longer than expected
    vTaskDelay(pdMS_TO_TICKS(20));
  }
}

A TaskA may miss its deadline if TaskB blocks system resources.

B TaskA will always meet its deadline because it has higher priority.

C TaskB will preempt TaskA causing TaskA to miss its deadline.

D Both tasks run simultaneously without affecting each other.

💡 Hint

Remember how FreeRTOS schedules tasks based on priority.

In FreeRTOS, higher priority tasks preempt lower priority ones. TaskA with priority 3 will run before TaskB with priority 2, so TaskA meets its deadline.

❓ Predict Output

advanced

Soft Real-Time Deadline Miss Behavior

In a soft real-time system, what is the typical behavior when a task misses its deadline?

Consider this FreeRTOS task code snippet:

void SoftTask(void *pvParameters) {
  for(;;) {
    // Simulate variable processing time
    vTaskDelay(pdMS_TO_TICKS(rand() % 15));
    // Process data
  }
}

A The system halts immediately upon deadline miss.

B The system raises a hard fault and resets.

C The task is killed and restarted automatically.

D The task continues running; occasional deadline misses are tolerated.

💡 Hint

Soft real-time systems allow some flexibility in timing.

Soft real-time systems tolerate occasional deadline misses without catastrophic failure; tasks continue running.

🧠 Conceptual

advanced

Choosing Between Hard and Soft Real-Time

Which scenario best requires a hard real-time system?

A A weather app updating forecasts every hour.

B A video streaming app where occasional frame drops are acceptable.

C An industrial robot arm controlling precise movements in a factory.

D A background file backup process running overnight.

💡 Hint

Think about when timing failures cause physical harm or damage.

Industrial robots require strict timing to avoid accidents, so hard real-time is necessary.

🔧 Debug

expert

Diagnosing Deadline Miss in FreeRTOS Hard Real-Time Task

A FreeRTOS hard real-time task sometimes misses its deadline. Which of the following code snippets is the most likely cause?

void HardTask(void *pvParameters) {
  for(;;) {
    // Critical work
    vTaskDelay(pdMS_TO_TICKS(5));
    // Heavy processing
    for(int i=0; i<1000000; i++) {
      // Busy wait
    }
  }
}

A The busy wait loop blocks the CPU, preventing timely task switching.

B The task priority is too high, causing starvation of other tasks.

C The vTaskDelay call causes the task to run too often.

D The task uses too little CPU time, so deadlines are missed.

💡 Hint

Consider how busy waiting affects multitasking in FreeRTOS.

Busy waiting blocks the CPU, preventing other tasks from running and causing deadline misses in hard real-time tasks.

Practice

1. Which statement best describes a hard real-time system in FreeRTOS?

easy

A. Tasks can miss deadlines occasionally without major issues.

B. Tasks run only when the CPU is idle.

C. Tasks must meet deadlines strictly without any misses.

D. Tasks have no timing constraints.

Solution

1. Step 1: Understand hard real-time definition

   Hard real-time means deadlines are strict and must never be missed.

2. Step 2: Compare options with definition

   The statement 'Tasks must meet deadlines strictly without any misses' matches the definition of hard real-time.

3. Final Answer:

   Tasks must meet deadlines strictly without any misses. -> Option C

4. Quick Check:

   Hard real-time = strict deadlines [OK]

Hint: Hard real-time means no deadline misses allowed [OK]

Common Mistakes:

• Confusing hard real-time with soft real-time
• Thinking tasks run only when CPU is idle
• Ignoring timing constraints

2. Which FreeRTOS API function is used to delay a task for a specific time period?

easy

A. vTaskDelay()

B. xTaskCreate()

C. vTaskStartScheduler()

D. xQueueSend()

Solution

1. Step 1: Identify delay function in FreeRTOS

   vTaskDelay() pauses a task for a given tick count, controlling timing.

2. Step 2: Check other options

   xTaskCreate() creates tasks, vTaskStartScheduler() starts the OS, xQueueSend() sends to queues.

3. Final Answer:

   vTaskDelay() -> Option A

4. Quick Check:

   Delay task = vTaskDelay() [OK]

Hint: Delay tasks with vTaskDelay() in FreeRTOS [OK]

Common Mistakes:

• Confusing task creation with delay
• Using scheduler start as delay
• Mixing queue functions with delays

3. Consider this FreeRTOS task priority setup:

Task A priority = 3
Task B priority = 2
Task C priority = 1

If Task A blocks for 100ms using vTaskDelay(), which task runs next?

medium

A. Task A again immediately

B. Task B

C. Task C

D. No task runs until Task A finishes delay

Solution

1. Step 1: Understand task priorities and blocking

   Task A has highest priority (3) but blocks for 100ms, so it is not ready.

2. Step 2: Identify next highest priority ready task

   Task B has priority 2 and is ready, so it runs next.

3. Final Answer:

   Task B -> Option B

4. Quick Check:

   Next task after blocking = highest ready priority [OK]

Hint: Next runs highest priority ready task after delay [OK]

Common Mistakes:

• Assuming blocked task runs immediately
• Ignoring task priorities
• Thinking no task runs during delay

4. Identify the error in this FreeRTOS code snippet for a hard real-time task:

void vTaskFunction(void *pvParameters) {
  while(1) {
    // Critical processing
    vTaskDelay(1000);
  }
}

What is the problem?

medium

A. vTaskDelay should be replaced with vTaskDelete.

B. The task function lacks a return statement.

C. The infinite loop will crash FreeRTOS.

D. Using vTaskDelay causes deadline misses in hard real-time tasks.

Solution

1. Step 1: Analyze vTaskDelay in hard real-time context

   vTaskDelay pauses the task, which can cause missing strict deadlines in hard real-time.

2. Step 2: Check other options for correctness

   Return statement is not needed in infinite loop, infinite loops are normal, vTaskDelete deletes task, not delay.

3. Final Answer:

   Using vTaskDelay causes deadline misses in hard real-time tasks. -> Option D

4. Quick Check:

   Hard real-time tasks avoid vTaskDelay [OK]

Hint: Hard real-time tasks avoid delays that cause misses [OK]

Common Mistakes:

• Thinking infinite loops crash FreeRTOS
• Confusing vTaskDelay with task deletion
• Expecting return in infinite loops

5. You need to design a FreeRTOS system where some tasks must never miss deadlines (hard real-time), and others can miss occasionally (soft real-time). Which approach best achieves this?

hard

A. Assign highest priorities to hard real-time tasks and use vTaskDelay carefully for soft real-time tasks.

B. Use vTaskDelay for all tasks to simplify timing.

C. Assign equal priorities to all tasks and rely on round-robin scheduling.

D. Run hard real-time tasks only when soft real-time tasks are idle.

Solution

1. Step 1: Understand priority and delay roles in FreeRTOS

   Hard real-time tasks need highest priority to avoid preemption and deadline misses.

2. Step 2: Use vTaskDelay carefully for soft real-time tasks

   Soft real-time tasks can tolerate delays, so vTaskDelay helps manage their timing without affecting hard real-time tasks.

3. Step 3: Evaluate other options

   Equal priorities or running hard real-time tasks only when soft are idle do not guarantee deadlines.

4. Final Answer:

   Assign highest priorities to hard real-time tasks and use vTaskDelay carefully for soft real-time tasks. -> Option A

5. Quick Check:

   Priority + careful delay = mixed real-time system [OK]

Hint: Prioritize hard real-time tasks highest, delay soft tasks [OK]

Common Mistakes:

• Giving equal priority to all tasks
• Using delays in hard real-time tasks
• Running hard real-time tasks only after soft tasks