Producer-consumer pattern in FreeRTOS - Step-by-Step Execution

Concept Flow - Producer-consumer pattern

Producer Task

↓

Produce Data

↓

Send to Queue

↓

Consumer Task

↓

Receive from Queue

↓

Consume Data

↓

Repeat

The producer creates data and sends it to a queue. The consumer waits for data from the queue and processes it.

Execution Sample

FreeRTOS

void producer(void *pvParameters) {
  int count = 0;
  while(1) {
    xQueueSend(queue, &count, portMAX_DELAY);
    count++;
  }
}

void consumer(void *pvParameters) {
  int received;
  while(1) {
    xQueueReceive(queue, &received, portMAX_DELAY);
    // process received
  }
}

Producer sends incrementing numbers to a queue; consumer receives and processes them.

Execution Table

Step	Task	Action	Queue State	Data Sent/Received	Output
1	Producer	Produce 0	[]	0
2	Producer	Send 0 to queue	[0]	0
3	Consumer	Receive from queue	[]	0	Process 0
4	Producer	Produce 1	[]	1
5	Producer	Send 1 to queue	[1]	1
6	Consumer	Receive from queue	[]	1	Process 1
7	Producer	Produce 2	[]	2
8	Producer	Send 2 to queue	[2]	2
9	Consumer	Receive from queue	[]	2	Process 2
10	Producer	Produce 3	[]	3
11	Producer	Send 3 to queue	[3]	3
12	Consumer	Receive from queue	[]	3	Process 3
13	Exit	Stop after 4 cycles	[]		End of trace

💡 Stopped after 4 produce-consume cycles for demonstration

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
count (Producer)	0	1	2	3	4	4
received (Consumer)	N/A	0	1	2	3	3
queue	empty	[0]	empty	[1]	empty	empty

Key Moments - 3 Insights

Why does the consumer wait when the queue is empty?

Because xQueueReceive uses portMAX_DELAY, the consumer blocks until data arrives, as shown in execution_table rows 3, 6, 9, and 12.

What happens if the producer tries to send when the queue is full?

In this example, the queue size is large enough, but normally xQueueSend would block or fail; here, the producer always succeeds because the consumer removes items promptly (see queue state in execution_table).

Why does the queue alternate between empty and having one item?

Because the producer sends one item, then the consumer receives it before the next send, so the queue never holds more than one item at a time (see queue state column).

Visual Quiz - 3 Questions

Look at the execution_table at step 5. What is the queue state after the producer sends data?

A [1]

B []

C [0,1]

D [0]

💡 Hint

Check the 'Queue State' column at step 5 in the execution_table.

At which step does the consumer first receive data?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Task' and 'Action' columns to find when consumer receives data.

If the producer increments count by 2 instead of 1, how would the 'Data Sent/Received' column change at step 8?

A It would show 3

B It would show 2

C It would show 4

D It would show 1

💡 Hint

Check how count increments affect data sent at each produce step in variable_tracker.

Concept Snapshot

Producer-consumer pattern in FreeRTOS:
- Producer task creates data and sends it to a queue.
- Consumer task waits and receives data from the queue.
- Use xQueueSend and xQueueReceive for communication.
- Consumer blocks if queue empty; producer blocks if queue full.
- Ensures safe data exchange between tasks.

Full Transcript

This visual execution shows the producer-consumer pattern in FreeRTOS. The producer task creates data (an incrementing count) and sends it to a queue using xQueueSend. The consumer task waits for data using xQueueReceive and processes it. The queue acts as a safe buffer between tasks. The execution table traces each step: producing data, sending to queue, receiving from queue, and processing. Variables like count and received change as data flows. Key moments clarify why the consumer waits when the queue is empty and how the queue state changes. The visual quiz tests understanding of queue states and data flow. This pattern helps tasks communicate safely and efficiently in embedded systems.