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.

Practice

1.

In FreeRTOS, what is the main role of the queue in the producer-consumer pattern?

easy

A. To create new tasks dynamically

B. To handle interrupts directly

C. To manage memory allocation for tasks

D. To safely transfer data between producer and consumer tasks

Solution

1. Step 1: Understand the producer-consumer pattern

   The pattern involves one task producing data and another consuming it, requiring safe data sharing.

2. Step 2: Identify the role of the queue in FreeRTOS

   The queue acts as a safe buffer that holds data items, ensuring tasks do not access the same data simultaneously.

3. Final Answer:

   To safely transfer data between producer and consumer tasks -> Option D

4. Quick Check:

   Queue = Safe data transfer [OK]

Hint: Queues safely pass data between tasks without conflicts [OK]

Common Mistakes:

• Thinking queues create tasks
• Confusing queues with memory management
• Assuming queues handle interrupts

2.

Which of the following is the correct FreeRTOS API call for a producer task to send data to a queue?

void producerTask(void *params) {
    int data = 10;
    // Send data to queue here
}

easy

A. xQueueSend(queueHandle, &data, portMAX_DELAY);

B. xQueueReceive(queueHandle, &data, portMAX_DELAY);

C. xTaskCreate(queueHandle, &data, portMAX_DELAY);

D. vTaskDelay(queueHandle);

Solution

1. Step 1: Identify the correct API for sending data to a queue

   FreeRTOS uses xQueueSend() to send data from a producer to a queue.

2. Step 2: Check other options for correctness

   xQueueReceive() is for receiving data, xTaskCreate() creates tasks, and vTaskDelay() delays tasks, so they are incorrect here.

3. Final Answer:

   xQueueSend(queueHandle, &data, portMAX_DELAY); -> Option A

4. Quick Check:

   Send data = xQueueSend [OK]

Hint: Use xQueueSend to put data into the queue [OK]

Common Mistakes:

• Using xQueueReceive to send data
• Confusing task creation with queue operations
• Using delay functions instead of queue functions

3.

Consider this FreeRTOS code snippet where a producer sends integers 1 to 3 to a queue and a consumer receives them:

int data;
for (int i = 1; i <= 3; i++) {
    xQueueSend(queueHandle, &i, 0);
}
for (int j = 0; j < 3; j++) {
    xQueueReceive(queueHandle, &data, 0);
    printf("%d ", data);
}

What will be the output?

medium

A. 1 2 3

B. 3 2 1

C. 0 0 0

D. Compilation error

Solution

1. Step 1: Analyze the producer loop

   The producer sends values 1, 2, and 3 in order to the queue without delay.

2. Step 2: Analyze the consumer loop

   The consumer receives three values from the queue and prints them in the order received.

3. Final Answer:

   1 2 3 -> Option A

4. Quick Check:

   Queue preserves order = 1 2 3 [OK]

Hint: Queue keeps order; output matches sent sequence [OK]

Common Mistakes:

• Assuming queue reverses order
• Expecting zeros due to uninitialized data
• Thinking code won't compile

4.

Identify the bug in this FreeRTOS consumer task code that causes it to never receive data:

void consumerTask(void *params) {
    int receivedData;
    while(1) {
        if(xQueueReceive(queueHandle, &receivedData, 0) == pdFALSE) {
            // No data received
            continue;
        }
        processData(receivedData);
    }
}

medium

A. The loop should use vTaskDelay instead of continue

B. The receive timeout is zero, causing missed data

C. The processData function is missing

D. The queue handle is not initialized

Solution

1. Step 1: Understand xQueueReceive timeout parameter

   A zero timeout means the call returns immediately if no data is available, possibly missing data if producer is slower.

2. Step 2: Identify why data is never received

   Because the consumer never waits, it may loop too fast and miss data arriving slightly later.

3. Final Answer:

   The receive timeout is zero, causing missed data -> Option B

4. Quick Check:

   Timeout 0 means no wait = missed data [OK]

Hint: Use non-zero timeout to wait for data [OK]

Common Mistakes:

• Ignoring timeout effect on receive
• Assuming missing queue handle causes this
• Thinking processData absence causes no receive

5.

You want to implement a producer-consumer system where the producer sends sensor readings every 100ms, and the consumer processes them. Which FreeRTOS queue configuration and task design is best to avoid data loss and ensure timely processing?

hard

A. Use a queue with length 5 and consumer uses zero timeout on receive

B. Use a queue with length 1 and zero receive timeout in consumer

C. Use a queue with length 10 and consumer waits with portMAX_DELAY on receive

D. Use no queue and share a global variable with no synchronization

Solution

1. Step 1: Consider queue length for buffering

   A queue length of 10 allows buffering multiple sensor readings if consumer is busy, preventing data loss.

2. Step 2: Consider consumer receive timeout

   Using portMAX_DELAY makes consumer wait indefinitely for data, ensuring it processes every reading.

3. Final Answer:

   Use a queue with length 10 and consumer waits with portMAX_DELAY on receive -> Option C

4. Quick Check:

   Buffer + wait = no data loss [OK]

Hint: Use bigger queue and wait on receive to avoid loss [OK]

Common Mistakes:

• Using too small queue causing data overwrite
• Using zero timeout causing missed data
• Sharing data without synchronization