Why event groups coordinate tasks in FreeRTOS - See It in Action

Why event groups coordinate tasks

📖 Scenario: Imagine you have two tasks in a FreeRTOS system: one reads sensor data, and the other processes it. They need to work together smoothly. Event groups help these tasks know when to start and stop by sharing signals.

🎯 Goal: You will create two tasks that coordinate using an event group. One task will set an event bit when data is ready, and the other will wait for that event bit before processing the data.

📋 What You'll Learn

Create an event group called dataEventGroup

Create two tasks: SensorTask and ProcessingTask

In SensorTask, set event bit 0x01 when data is ready

In ProcessingTask, wait for event bit 0x01 before processing

Print messages to show when each task runs

💡 Why This Matters

🌍 Real World

In real embedded systems, sensors and processors must work together without missing signals. Event groups help tasks wait for each other safely.

💼 Career

Understanding event groups is important for embedded software developers working on real-time systems like IoT devices, automotive controls, and industrial machines.

1

Create the event group

Create an event group called dataEventGroup using xEventGroupCreate().

FreeRTOS

# Create the event group called dataEventGroup
# Your code here

Hint

Use xEventGroupCreate() to make a new event group and assign it to dataEventGroup.

2

Create the two tasks

Create two tasks called SensorTask and ProcessingTask using xTaskCreate(). Use empty functions for now.

FreeRTOS

EventGroupHandle_t dataEventGroup = NULL;
dataEventGroup = xEventGroupCreate();

// Create SensorTask and ProcessingTask with empty functions
// Your code here

Hint

Define two functions named SensorTask and ProcessingTask. Then create them with xTaskCreate().

3

Set and wait for event bits

In SensorTask, set event bit 0x01 using xEventGroupSetBits(dataEventGroup, 0x01). In ProcessingTask, wait for event bit 0x01 using xEventGroupWaitBits(dataEventGroup, 0x01, pdTRUE, pdFALSE, portMAX_DELAY).

FreeRTOS

EventGroupHandle_t dataEventGroup = NULL;
dataEventGroup = xEventGroupCreate();

void SensorTask(void *pvParameters) {
    // Set event bit 0x01 here
    // Your code here
}

void ProcessingTask(void *pvParameters) {
    // Wait for event bit 0x01 here
    // Your code here
}

xTaskCreate(SensorTask, "SensorTask", 1000, NULL, 1, NULL);
xTaskCreate(ProcessingTask, "ProcessingTask", 1000, NULL, 1, NULL);

Hint

Use xEventGroupSetBits() in SensorTask to signal data ready. Use xEventGroupWaitBits() in ProcessingTask to wait for that signal.

4

Print messages to show coordination

Add printf statements in SensorTask to print "SensorTask: Data ready" after setting the event bit, and in ProcessingTask to print "ProcessingTask: Processing data" after waiting for the event bit.

FreeRTOS

EventGroupHandle_t dataEventGroup = NULL;
dataEventGroup = xEventGroupCreate();

void SensorTask(void *pvParameters) {
    xEventGroupSetBits(dataEventGroup, 0x01);
    // Print "SensorTask: Data ready" here
    // Your code here
}

void ProcessingTask(void *pvParameters) {
    xEventGroupWaitBits(dataEventGroup, 0x01, pdTRUE, pdFALSE, portMAX_DELAY);
    // Print "ProcessingTask: Processing data" here
    // Your code here
}

xTaskCreate(SensorTask, "SensorTask", 1000, NULL, 1, NULL);
xTaskCreate(ProcessingTask, "ProcessingTask", 1000, NULL, 1, NULL);

Hint

Use printf to show when each task runs after setting or waiting for the event bit.

Practice

1. What is the main purpose of event groups in FreeRTOS?

easy

A. To handle hardware interrupts directly

B. To create new tasks dynamically

C. To let tasks wait for or signal events using bits

D. To manage memory allocation

Solution

1. Step 1: Understand event groups role

   Event groups use bits to represent events that tasks can wait for or signal.

2. Step 2: Compare with other options

   Creating tasks, managing memory, and handling interrupts are different FreeRTOS features.

3. Final Answer:

   To let tasks wait for or signal events using bits -> Option C

4. Quick Check:

   Event groups coordinate tasks by signaling bits [OK]

Hint: Event groups use bits to sync tasks quickly [OK]

Common Mistakes:

• Confusing event groups with task creation
• Thinking event groups manage memory
• Assuming event groups handle interrupts

2. Which of the following is the correct way to create an event group in FreeRTOS?

easy

A. vEventGroupCreate()

B. xEventGroupCreate()

C. xCreateEventGroup()

D. vCreateEventGroup()

Solution

1. Step 1: Recall FreeRTOS naming conventions

   Functions returning handles usually start with 'x' and create functions end with 'Create'.

2. Step 2: Identify correct function

   The correct function to create an event group is xEventGroupCreate().

3. Final Answer:

   xEventGroupCreate() -> Option B

4. Quick Check:

   Event group creation uses xEventGroupCreate() [OK]

Hint: Creation functions start with 'x' and end with 'Create' [OK]

Common Mistakes:

• Using 'v' prefix which is for void functions
• Swapping function name order
• Assuming event groups are created with task functions

3. Given the code snippet:

EventGroupHandle_t xEventGroup = xEventGroupCreate();
const EventBits_t BIT_0 = (1 << 0);
xEventGroupSetBits(xEventGroup, BIT_0);
EventBits_t uxBits = xEventGroupWaitBits(xEventGroup, BIT_0, pdTRUE, pdFALSE, portMAX_DELAY);

What will be the value of uxBits after xEventGroupWaitBits returns?

medium

A. BIT_0

B. portMAX_DELAY

C. 0

D. pdTRUE

Solution

1. Step 1: Understand bit setting and waiting

   BIT_0 is set before waiting, so the wait function will return with BIT_0 set.

2. Step 2: Analyze parameters

   pdTRUE clears the bits after return, but uxBits holds the bits that were set when the function returned.

3. Final Answer:

   BIT_0 -> Option A

4. Quick Check:

   Wait returns bits that were set, here BIT_0 [OK]

Hint: Wait returns bits set before clearing if pdTRUE used [OK]

Common Mistakes:

• Assuming bits clear before return
• Confusing return value with delay constant
• Ignoring bit mask value

4. Identify the error in this FreeRTOS event group usage:

EventGroupHandle_t xEventGroup;
xEventGroupSetBits(xEventGroup, (1 << 1));

medium

A. Event groups cannot set bits directly

B. Bit mask (1 << 1) is invalid

C. xEventGroupSetBits requires a pointer to the event group

D. xEventGroup is not initialized before use

Solution

1. Step 1: Check event group initialization

   xEventGroup is declared but never created or assigned a valid handle.

2. Step 2: Understand function requirements

   xEventGroupSetBits requires a valid event group handle, which is missing here.

3. Final Answer:

   xEventGroup is not initialized before use -> Option D

4. Quick Check:

   Event group must be created before setting bits [OK]

Hint: Always create event group before using it [OK]

Common Mistakes:

• Using uninitialized event group handle
• Misunderstanding bit mask validity
• Passing pointer instead of handle

5. You want two tasks to wait until both have signaled readiness using event groups. Which approach correctly coordinates this?

hard

A. Each task sets a unique bit; both wait for both bits set before proceeding

B. Both tasks set the same bit and wait for that bit to be set

C. Tasks use separate event groups and wait independently

D. Tasks use a global variable instead of event groups

Solution

1. Step 1: Understand event group bits for coordination

   Each task sets a unique bit representing its readiness.

2. Step 2: Wait for both bits set

   Tasks wait for the combination of both bits to be set before continuing.

3. Final Answer:

   Each task sets a unique bit; both wait for both bits set before proceeding -> Option A

4. Quick Check:

   Unique bits per task coordinate readiness [OK]

Hint: Use unique bits per task and wait for all bits [OK]

Common Mistakes:

• Using same bit for multiple tasks
• Using separate event groups losing coordination
• Ignoring event groups and using variables