Event group for task synchronization in FreeRTOS - Mini Project: Build & Apply

Event group for task synchronization

📖 Scenario: You are building a simple FreeRTOS application where two tasks need to synchronize their actions using an event group. This is like two friends agreeing to start a game only when both are ready.

🎯 Goal: Create two tasks that wait for each other using an event group. When both tasks set their event bits, they proceed to print a message indicating synchronization.

📋 What You'll Learn

Create an event group called syncEventGroup

Create two tasks named Task1 and Task2

Each task sets its own event bit: BIT_0 for Task1 and BIT_1 for Task2

Each task waits for both bits BIT_0 | BIT_1 to be set before printing a synchronization message

Print the synchronization message exactly as specified

💡 Why This Matters

🌍 Real World

Event groups are used in embedded systems to coordinate multiple tasks that must wait for each other before proceeding, such as sensor data collection and processing.

💼 Career

Understanding event groups is important for embedded software engineers working with real-time operating systems to ensure tasks run in proper order and synchronize correctly.

1

Create the event group

Create an event group called syncEventGroup using xEventGroupCreate().

FreeRTOS

# Create the event group called syncEventGroup
# Your code here

Hint

Use xEventGroupCreate() to create the event group and assign it to syncEventGroup.

2

Define event bits and create tasks

Define BIT_0 as (1 << 0) and BIT_1 as (1 << 1). Then create two tasks named Task1 and Task2 using xTaskCreate() with empty task functions for now.

FreeRTOS

EventGroupHandle_t syncEventGroup;
syncEventGroup = xEventGroupCreate();

// Define BIT_0 and BIT_1
// Create Task1 and Task2 with empty functions
# Your code here

Hint

Use #define to define bits and xTaskCreate() to create tasks with empty functions.

3

Implement task synchronization logic

In Task1, set BIT_0 in syncEventGroup using xEventGroupSetBits(). Then wait for both BIT_0 and BIT_1 to be set using xEventGroupWaitBits(). Do the same in Task2 but set BIT_1. Use pdFALSE to avoid clearing bits on exit, pdTRUE to wait for all bits, and portMAX_DELAY to wait indefinitely.

FreeRTOS

EventGroupHandle_t syncEventGroup;
syncEventGroup = xEventGroupCreate();

#define BIT_0 (1 << 0)
#define BIT_1 (1 << 1)

void Task1(void *pvParameters) {
    // Set BIT_0 and wait for BIT_0 and BIT_1
    // Your code here
}

void Task2(void *pvParameters) {
    // Set BIT_1 and wait for BIT_0 and BIT_1
    // Your code here
}

xTaskCreate(Task1, "Task1", 1000, NULL, 1, NULL);
xTaskCreate(Task2, "Task2", 1000, NULL, 1, NULL);

Hint

Use xEventGroupSetBits() to set the bit and xEventGroupWaitBits() to wait for both bits without clearing them on exit and blocking indefinitely.

4

Print synchronization messages

After waiting for both bits in Task1, print "Task1 synchronized!". After waiting in Task2, print "Task2 synchronized!". Use printf() for printing.

FreeRTOS

EventGroupHandle_t syncEventGroup;
syncEventGroup = xEventGroupCreate();

#define BIT_0 (1 << 0)
#define BIT_1 (1 << 1)

void Task1(void *pvParameters) {
    xEventGroupSetBits(syncEventGroup, BIT_0);
    xEventGroupWaitBits(syncEventGroup, BIT_0 | BIT_1, pdFALSE, pdTRUE, portMAX_DELAY);
    // Print "Task1 synchronized!"
    // Your code here
}

void Task2(void *pvParameters) {
    xEventGroupSetBits(syncEventGroup, BIT_1);
    xEventGroupWaitBits(syncEventGroup, BIT_0 | BIT_1, pdFALSE, pdTRUE, portMAX_DELAY);
    // Print "Task2 synchronized!"
    // Your code here
}

xTaskCreate(Task1, "Task1", 1000, NULL, 1, NULL);
xTaskCreate(Task2, "Task2", 1000, NULL, 1, NULL);

Hint

Use printf() to print the exact messages after waiting for synchronization.

Practice

1. What is the primary purpose of an event group in FreeRTOS for task synchronization?

easy

A. To allocate memory dynamically for tasks

B. To allow tasks to wait for multiple events using bits

C. To create queues for message passing

D. To manage task priorities automatically

Solution

1. Step 1: Understand event groups in FreeRTOS

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

2. Step 2: Identify the main use of event groups

   They help tasks synchronize by waiting on or setting bits representing events.

3. Final Answer:

   To allow tasks to wait for multiple events using bits -> Option B

4. Quick Check:

   Event groups = wait for multiple events [OK]

Hint: Event groups use bits to sync tasks, not memory or priorities [OK]

Common Mistakes:

• Confusing event groups with queues
• Thinking event groups manage memory
• Assuming event groups change task priorities

2. Which of the following is the correct function to wait for bits in an event group in FreeRTOS?

easy

A. xEventGroupClearBits()

B. xEventGroupSetBits()

C. xEventGroupWaitBits()

D. xEventGroupCreate()

Solution

1. Step 1: Recall FreeRTOS event group functions

   xEventGroupWaitBits() is used to wait for specific bits to be set.

2. Step 2: Differentiate from other functions

   xEventGroupSetBits() sets bits, ClearBits clears bits, Create creates the group.

3. Final Answer:

   xEventGroupWaitBits() -> Option C

4. Quick Check:

   Wait for bits = xEventGroupWaitBits() [OK]

Hint: Wait uses xEventGroupWaitBits(), set uses xEventGroupSetBits() [OK]

Common Mistakes:

• Using xEventGroupSetBits() to wait
• Confusing create with wait functions
• Mixing clear bits with wait bits

3. Given the following code snippet, what will be the value of bits after xEventGroupWaitBits() returns?

EventBits_t bits;
bits = xEventGroupWaitBits(eventGroup, BIT_0 | BIT_1, pdTRUE, pdFALSE, portMAX_DELAY);

Assume BIT_0 and BIT_1 are both set in eventGroup before the call.

medium

A. Only BIT_0 set

B. Only BIT_1 set

C. No bits set

D. Both BIT_0 and BIT_1 set

Solution

1. Step 1: Understand xEventGroupWaitBits parameters

   The function waits for BIT_0 or BIT_1 to be set, clears bits on exit (pdTRUE), and does not wait for all bits (pdFALSE).

2. Step 2: Analyze the bits set before call

   Both BIT_0 and BIT_1 are set, so the function returns with both bits set in the return value.

3. Final Answer:

   Both BIT_0 and BIT_1 set -> Option D

4. Quick Check:

   WaitBits returns bits set before clearing [OK]

Hint: WaitBits returns bits set before clearing them [OK]

Common Mistakes:

• Assuming only one bit is returned
• Ignoring bits cleared on exit
• Confusing wait for all bits with wait for any

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

EventGroupHandle_t eventGroup = xEventGroupCreate();

void Task1(void *pvParameters) {
    xEventGroupWaitBits(eventGroup, BIT_0, pdFALSE, pdTRUE, portMAX_DELAY);
    // Task code
}

void Task2(void *pvParameters) {
    xEventGroupSetBits(eventGroup, BIT_0);
}

medium

A. Not checking if eventGroup creation succeeded

B. Using portMAX_DELAY as wait time

C. Using pdFALSE for clearOnExit in xEventGroupWaitBits

D. Setting bits before event group creation

Solution

1. Step 1: Check event group creation

   xEventGroupCreate() can return NULL if creation fails; code does not check this.

2. Step 2: Verify other parameters

   Using pdFALSE for clearOnExit is valid; portMAX_DELAY is valid; bits are set after creation.

3. Final Answer:

   Not checking if eventGroup creation succeeded -> Option A

4. Quick Check:

   Always check event group creation success [OK]

Hint: Always verify event group creation returned non-NULL [OK]

Common Mistakes:

• Ignoring NULL return from xEventGroupCreate
• Misusing clearOnExit parameter
• Setting bits before creating event group

5. You want two tasks to synchronize so that Task A waits until Task B signals both BIT_0 and BIT_1. Which xEventGroupWaitBits() call correctly waits for both bits before continuing?

hard

A. xEventGroupWaitBits(eventGroup, BIT_0 | BIT_1, pdTRUE, pdTRUE, portMAX_DELAY);

B. xEventGroupWaitBits(eventGroup, BIT_0 & BIT_1, pdTRUE, pdTRUE, portMAX_DELAY);

C. xEventGroupWaitBits(eventGroup, BIT_0 | BIT_1, pdTRUE, pdFALSE, portMAX_DELAY);

D. xEventGroupWaitBits(eventGroup, BIT_0 & BIT_1, pdFALSE, pdFALSE, portMAX_DELAY);

Solution

1. Step 1: Understand wait for all bits parameter

   The fourth parameter (xWaitForAllBits) must be pdTRUE to wait for both bits together.

2. Step 2: Check bit mask and parameters

   Use BIT_0 | BIT_1 to specify both bits; pdTRUE for clearOnExit clears bits after wait.

3. Final Answer:

   xEventGroupWaitBits(eventGroup, BIT_0 | BIT_1, pdTRUE, pdTRUE, portMAX_DELAY); -> Option A

4. Quick Check:

   Wait for all bits = xEventGroupWaitBits with xWaitForAllBits = pdTRUE [OK]

Hint: Set xWaitForAllBits to pdTRUE to wait for all bits [OK]

Common Mistakes:

• Using bitwise AND (&) instead of OR (|) for bit mask
• Setting xWaitForAllBits to pdFALSE when waiting for all bits
• Confusing clearOnExit with wait for all bits