Multiple producers single consumer in FreeRTOS - Step-by-Step Execution

Concept Flow - Multiple producers single consumer

Producer 1: Create data

↓

Send data to queue

↓

Producer 2: Create data

↓

Send data to queue

↓

Consumer: Wait for data

↓

Receive data from queue

↓

Process data

↓

Repeat

Multiple producers create data and send it to a shared queue. One consumer waits and receives data from the queue to process it.

Execution Sample

FreeRTOS

void producer1() {
  int data = 1;
  xQueueSend(queue, &data, portMAX_DELAY);
}

void consumer() {
  int received;
  xQueueReceive(queue, &received, portMAX_DELAY);
  process(received);
}

Producer 1 sends data to a queue; consumer waits and receives data from the queue to process it.

Execution Table

Step	Task	Action	Queue State	Output
1	Producer 1	Create data=1	[]	None
2	Producer 1	Send data=1 to queue	[1]	None
3	Producer 2	Create data=2	[1]	None
4	Producer 2	Send data=2 to queue	[1,2]	None
5	Consumer	Wait for data	[1,2]	None
6	Consumer	Receive data=1 from queue	[2]	Process 1
7	Consumer	Wait for data	[2]	None
8	Consumer	Receive data=2 from queue	[]	Process 2
9	Consumer	Wait for data	[]	None
10	Exit	Queue empty, no data to receive	[]	Stop

💡 Queue is empty, consumer waits indefinitely or stops if no more data.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	After Step 8	Final
queue	[]	[1]	[1,2]	[2]	[]	[]
data (Producer 1)	N/A	1	1	1	1	1
data (Producer 2)	N/A	N/A	2	2	2	2
received (Consumer)	N/A	N/A	N/A	1	2	N/A

Key Moments - 3 Insights

Why does the consumer receive data in the order 1 then 2?

Because the queue stores data in FIFO order, the consumer receives the first data sent by Producer 1 before Producer 2's data, as shown in steps 6 and 8.

What happens if the queue is empty when the consumer tries to receive data?

The consumer waits (blocks) until data arrives or stops if no more data is sent, as shown in step 9 and exit note.

Can multiple producers send data at the same time without conflict?

Yes, FreeRTOS queues handle synchronization internally, so multiple producers can safely send data concurrently, as seen in steps 2 and 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the queue state after Producer 2 sends data?

A [1]

B [2]

C [1,2]

D []

💡 Hint

Check the 'Queue State' column at step 4 in the execution table.

At which step does the consumer first receive data from the queue?

A Step 5

B Step 6

C Step 7

D Step 8

💡 Hint

Look at the 'Action' column for the consumer receiving data in the execution table.

If Producer 1 sends data=3 instead of 1, what will be the first data the consumer processes?

A 3

B 2

C 1

D No data

💡 Hint

Refer to the variable_tracker for 'data (Producer 1)' and the queue order in the execution table.

Concept Snapshot

Multiple producers send data to a shared queue.
One consumer receives data in FIFO order.
Producers use xQueueSend; consumer uses xQueueReceive.
Queue handles synchronization safely.
Consumer blocks if queue is empty.
This pattern enables safe data sharing in FreeRTOS.

Full Transcript

In this example, multiple producers create data and send it to a shared FreeRTOS queue. The consumer waits for data and receives it in the order it was sent. The queue stores data in FIFO order, so the consumer processes data in the same order. Producers can send data concurrently without conflicts because the queue manages synchronization internally. If the queue is empty, the consumer waits until new data arrives or stops if no more data is sent. This pattern is useful for safely sharing data between tasks in FreeRTOS.

Practice

1.

In FreeRTOS, when multiple producers send data to a single consumer using a queue, what ensures that data is received in the correct order?

easy

A. The consumer sorts data after receiving it.

B. Each producer uses a separate queue to avoid conflicts.

C. Producers send data only when the consumer is ready.

D. The queue maintains the order of data sent by producers.

Solution

1. Step 1: Understand FreeRTOS queue behavior

   FreeRTOS queues store data in the order it is sent, preserving sequence.

2. Step 2: Analyze producer-consumer interaction

   Multiple producers send data to one queue; the queue keeps data ordered for the consumer.

3. Final Answer:

   The queue maintains the order of data sent by producers. -> Option D

4. Quick Check:

   Queue order = correct data sequence [OK]

Hint: Remember: queues keep data order automatically [OK]

Common Mistakes:

• Thinking each producer needs its own queue
• Assuming consumer sorts data
• Believing producers wait for consumer readiness

2.

Which of the following is the correct way to send data to a FreeRTOS queue from a producer task?

QueueHandle_t xQueue;
int data = 10;
// Which function call is correct?

easy

A. xQueueCreate(data, sizeof(xQueue));

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

C. xQueueSend(xQueue, &data, portMAX_DELAY);

D. xQueueDelete(xQueue);

Solution

1. Step 1: Identify the function to send data

   xQueueSend is used to send data to a queue in FreeRTOS.

2. Step 2: Confirm parameters

   xQueueSend takes the queue handle, pointer to data, and wait time (portMAX_DELAY waits indefinitely).

3. Final Answer:

   xQueueSend(xQueue, &data, portMAX_DELAY); -> Option C

4. Quick Check:

   Send data = xQueueSend [OK]

Hint: Use xQueueSend to send, xQueueReceive to receive [OK]

Common Mistakes:

• Using xQueueReceive to send data
• Confusing queue creation with sending
• Deleting queue instead of sending

3.

Consider this FreeRTOS code snippet where two producer tasks send integers to a queue and one consumer task receives them:

QueueHandle_t xQueue = xQueueCreate(5, sizeof(int));

// Producer 1 sends 1
xQueueSend(xQueue, &(int){1}, 0);
// Producer 2 sends 2
xQueueSend(xQueue, &(int){2}, 0);

int receivedValue;
xQueueReceive(xQueue, &receivedValue, 0);
printf("%d", receivedValue);

What will be printed?

medium

A. 1

B. 2

C. 0

D. Compilation error

Solution

1. Step 1: Analyze the order of sending

   Producer 1 sends 1 first, then Producer 2 sends 2 to the queue.

2. Step 2: Understand queue receive behavior

   xQueueReceive reads the first item in the queue, which is 1.

3. Final Answer:

   1 -> Option A

4. Quick Check:

   First sent = first received = 1 [OK]

Hint: Queue returns data in send order, first in first out [OK]

Common Mistakes:

• Assuming last sent is received first
• Thinking receive returns 0 by default
• Confusing send and receive functions

4.

In a FreeRTOS system with multiple producers and one consumer, the consumer task sometimes blocks indefinitely waiting on xQueueReceive. What is the most likely cause?

medium

A. Producers never send data to the queue.

B. The queue size is too large.

C. The consumer uses xQueueSend instead of xQueueReceive.

D. The queue was deleted before receiving.

Solution

1. Step 1: Understand blocking on xQueueReceive

   If the consumer blocks indefinitely, it means no data is available in the queue.

2. Step 2: Identify why no data is available

   Most likely, producers are not sending data, so the queue remains empty.

3. Final Answer:

   Producers never send data to the queue. -> Option A

4. Quick Check:

   No data sent = consumer blocks [OK]

Hint: If consumer blocks, check if producers send data [OK]

Common Mistakes:

• Blaming queue size for blocking
• Mixing send and receive functions
• Ignoring queue deletion effects

5.

You have three producer tasks sending sensor readings to a single consumer task via a FreeRTOS queue. The queue size is 5. If all producers send data rapidly, what is the best way to avoid losing data?

hard

A. Use separate queues for each producer without increasing size.

B. Increase the queue size or use xQueueSendToBack with blocking wait.

C. Make the consumer task sleep longer to batch process data.

D. Delete the queue and recreate it frequently.

Solution

1. Step 1: Understand queue overflow risk

   If producers send data faster than consumer processes, queue fills and data can be lost.

2. Step 2: Choose solution to prevent data loss

   Increasing queue size or blocking send calls (like xQueueSendToBack with wait) lets producers wait instead of losing data.

3. Final Answer:

   Increase the queue size or use xQueueSendToBack with blocking wait. -> Option B

4. Quick Check:

   Prevent overflow = bigger queue or blocking send [OK]

Hint: Avoid data loss by bigger queue or blocking send [OK]

Common Mistakes:

• Using separate queues without consumer changes
• Making consumer sleep longer causes more overflow
• Deleting queue causes data loss