Producer-consumer pattern in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Producer-Consumer Queue Example

What will be the output of this FreeRTOS producer-consumer example code snippet?

FreeRTOS

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

QueueHandle_t queue;

void producer(void *params) {
    int count = 1;
    while (count <= 3) {
        xQueueSend(queue, &count, portMAX_DELAY);
        printf("Produced: %d\n", count);
        count++;
        vTaskDelay(pdMS_TO_TICKS(10));
    }
    vTaskDelete(NULL);
}

void consumer(void *params) {
    int received;
    for (int i = 0; i < 3; i++) {
        xQueueReceive(queue, &received, portMAX_DELAY);
        printf("Consumed: %d\n", received);
    }
    vTaskDelete(NULL);
}

int main() {
    queue = xQueueCreate(3, sizeof(int));
    xTaskCreate(producer, "Producer", 1000, NULL, 1, NULL);
    xTaskCreate(consumer, "Consumer", 1000, NULL, 1, NULL);
    vTaskStartScheduler();
    return 0;
}

A No output because tasks never run due to missing scheduler start

B

Consumed: 1
Consumed: 2
Consumed: 3
Produced: 1
Produced: 2
Produced: 3

C

Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
Produced: 3
Consumed: 3

D

Produced: 1
Produced: 2
Produced: 3
Consumed: 1
Consumed: 2
Consumed: 3

💡 Hint

Consider task scheduling with equal priority tasks and the effect of vTaskDelay in the producer.

Both tasks have the same priority. The producer sends an item, prints, then delays (yielding). The consumer receives and prints it, then blocks on the next receive. The producer wakes and repeats, resulting in interleaved output.

🧠 Conceptual

intermediate

Queue Length in Producer-Consumer Pattern

In a FreeRTOS producer-consumer pattern, if the queue length is set to 5 and the producer tries to send 7 items without the consumer running, what happens?

A The producer discards the 6th and 7th items silently

B The producer blocks on the 6th item until the consumer receives an item

C The producer overwrites the oldest item in the queue when full

D The producer crashes due to queue overflow

💡 Hint

Think about how FreeRTOS queues handle full conditions with blocking.

FreeRTOS queues block the sending task when the queue is full if a block time is specified (like portMAX_DELAY). The producer will wait until the consumer removes an item before sending more.

🔧 Debug

advanced

Identify the Bug in Producer-Consumer Synchronization

What is the main problem in this FreeRTOS producer-consumer code snippet? void producer(void *params) { int count = 0; while(1) { xQueueSend(queue, &count, 0); count++; vTaskDelay(pdMS_TO_TICKS(100)); } } void consumer(void *params) { int data; while(1) { if(xQueueReceive(queue, &data, 0)) { printf("Consumed %d\n", data); } } }

A Consumer uses zero block time causing it to miss items if queue is empty

B Producer uses zero block time causing it to block indefinitely

C Queue is not created before tasks start

D Producer increments count after sending causing off-by-one error

💡 Hint

Check the block time parameters in xQueueSend and xQueueReceive calls.

The consumer uses zero block time in xQueueReceive, so it busy-waits (polls) when the queue is empty instead of blocking efficiently. This wastes CPU cycles and is poor practice.

📝 Syntax

advanced

Syntax Error in FreeRTOS Producer-Consumer Code

Which option contains the correct syntax for creating a queue and starting the scheduler in FreeRTOS?

A

queue = xQueueCreate(5, sizeof(int));
vTaskStartScheduler

B

queue = xQueueCreate(5, sizeof(int))
vTaskStartScheduler()

C

queue = xQueueCreate(5, int);
vTaskStartScheduler();

D

queue = xQueueCreate(5, sizeof(int));
vTaskStartScheduler();

💡 Hint

Check for missing semicolons and correct sizeof usage.

Option D correctly uses semicolons and sizeof(int) to create the queue and calls vTaskStartScheduler with parentheses.

🚀 Application

expert

Designing a Priority Producer-Consumer System

You want to design a FreeRTOS producer-consumer system where the consumer always processes high-priority items before low-priority ones. Which approach is best?

A Use two separate queues for high and low priority items; consumer checks high-priority queue first

B Use a queue with priority field and sort items inside the queue automatically

C Use a single queue and rely on task priority to process items in order

D Use a mutex to lock the queue when high-priority items arrive

💡 Hint

Think about how FreeRTOS queues work and how to prioritize data processing.

FreeRTOS queues do not sort items automatically. Using two queues allows the consumer to check the high-priority queue first, ensuring those items are processed before low-priority ones.