Setting and clearing event bits in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of setting and clearing bits?

Consider the following FreeRTOS code snippet using event groups. What will be the value of uxBits after the operations?

FreeRTOS

EventGroupHandle_t xEventGroup = xEventGroupCreate();
EventBits_t uxBits;

xEventGroupSetBits(xEventGroup, (1 << 0) | (1 << 2));
uxBits = xEventGroupClearBits(xEventGroup, (1 << 0));

// uxBits now holds the bits that were set before clearing
printf("0x%X", (unsigned int)uxBits);

A 0x4

B 0x5

C 0x1

D 0x0

💡 Hint

Remember that xEventGroupClearBits returns the bits set before clearing.

The bits set initially are 0x1 (bit 0) and 0x4 (bit 2), combined as 0x5. Clearing bit 0 returns the original bits before clearing, which is 0x5.

❓ Predict Output

intermediate

What is returned by clearing multiple bits?

Given the following FreeRTOS code, what value is printed (the return value of xEventGroupClearBits)?

FreeRTOS

EventGroupHandle_t xEventGroup = xEventGroupCreate();

xEventGroupSetBits(xEventGroup, (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3));
EventBits_t uxRemaining = xEventGroupClearBits(xEventGroup, (1 << 1) | (1 << 3));

printf("0x%X", (unsigned int)uxRemaining);

A 0x0

B 0xA

C 0x5

D 0xF

💡 Hint

Clear bits 1 and 3 but note what xEventGroupClearBits returns.

The bits set initially are 0xF (bits 0,1,2,3). Clearing bits 1 and 3 returns the bits set before clearing, which is 0xF.

🔧 Debug

advanced

Why does this event bit clearing code cause unexpected behavior?

Examine the code below. Why does the event bit clearing not work as expected?

FreeRTOS

EventGroupHandle_t xEventGroup = xEventGroupCreate();

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

// Attempt to clear bit 2
xEventGroupClearBits(xEventGroup, 2);

EventBits_t uxBits = xEventGroupGetBits(xEventGroup);
printf("0x%X", (unsigned int)uxBits);

A Because xEventGroupClearBits does not clear bits, only sets them

B Because xEventGroupGetBits returns bits before clearing, not after

C Because 2 is used instead of (1 << 2), so bit 1 is cleared instead of bit 2

D Because the event group was not created properly

💡 Hint

Check how bits are represented and cleared.

The code uses 2 instead of (1 << 2). 2 is bit 1, not bit 2. So it clears the wrong bit.

📝 Syntax

advanced

Which option causes a syntax error in setting event bits?

Which of the following code snippets will cause a syntax error when trying to set event bits?

A xEventGroupSetBits(xEventGroup 1 << 3);

B xEventGroupSetBits(xEventGroup, (1 << 3));

C xEventGroupSetBits(xEventGroup, 1 << 3);

D ;)3 << 1 ,puorGtnevEx(stiBteSpuorGtnevEx

💡 Hint

Look for missing commas or parentheses.

Option A is missing a comma between the function arguments, causing a syntax error.

🚀 Application

expert

How many bits remain set after this sequence of operations?

Given the following sequence of FreeRTOS event group operations, how many bits remain set at the end?

FreeRTOS

EventGroupHandle_t xEventGroup = xEventGroupCreate();

xEventGroupSetBits(xEventGroup, (1 << 0) | (1 << 1) | (1 << 2));
xEventGroupClearBits(xEventGroup, (1 << 1));
xEventGroupSetBits(xEventGroup, (1 << 3));
xEventGroupClearBits(xEventGroup, (1 << 0) | (1 << 2));

EventBits_t uxBits = xEventGroupGetBits(xEventGroup);
printf("%u", (unsigned int)__builtin_popcount(uxBits));

A 1

B 3

C 2

D 4

💡 Hint

Track each set and clear operation carefully.

Initially bits 0,1,2 set. Clear bit 1 leaves bits 0 and 2. Set bit 3 adds bit 3. Clear bits 0 and 2 leaves only bit 3 set. So only 1 bit remains set.

Practice

1. What is the primary purpose of xEventGroupSetBits() in FreeRTOS?

easy

A. To create a new event group

B. To clear (reset) specific bits in an event group

C. To set (signal) specific bits in an event group

D. To delete an existing event group

Solution

1. Step 1: Understand the function name

   xEventGroupSetBits() suggests setting bits, which means signaling events.

2. Step 2: Compare with other functions

   xEventGroupClearBits() is used to clear bits, so setting bits is done by xEventGroupSetBits().

3. Final Answer:

   To set (signal) specific bits in an event group -> Option C

4. Quick Check:

   Set bits = signal events [OK]

Hint: Set bits means signal events, clear bits means reset [OK]

Common Mistakes:

• Confusing setting bits with clearing bits
• Thinking it creates or deletes event groups
• Mixing up function names

2. Which of the following is the correct syntax to clear bits 0x03 in an event group named myEventGroup?

easy

A. xEventGroupClear(myEventGroup, 0x03);

B. xEventGroupSetBits(myEventGroup, 0x03);

C. xClearEventBits(myEventGroup, 0x03);

D. xEventGroupClearBits(myEventGroup, 0x03);

Solution

1. Step 1: Identify the correct function for clearing bits

   The function to clear bits is xEventGroupClearBits().

2. Step 2: Check the syntax

   The correct syntax is xEventGroupClearBits(eventGroupHandle, bitsToClear);. xEventGroupClearBits(myEventGroup, 0x03); matches this exactly.

3. Final Answer:

   xEventGroupClearBits(myEventGroup, 0x03); -> Option D

4. Quick Check:

   Clear bits syntax = xEventGroupClearBits(handle, bits) [OK]

Hint: Clear bits uses xEventGroupClearBits with group and bit mask [OK]

Common Mistakes:

• Using xEventGroupSetBits to clear bits
• Using incorrect function names
• Missing parameters or wrong order

3. Given the code snippet:

EventBits_t bits;
bits = xEventGroupSetBits(myEventGroup, 0x05);
bits = xEventGroupClearBits(myEventGroup, 0x01);

What is the value of bits after these calls if the initial bits were 0x00?

medium

A. 0x00

B. 0x05

C. 0x04

D. 0x01

Solution

1. Step 1: First call - xEventGroupSetBits(myEventGroup, 0x05)

   Initial event group: 0x00. Returns bits BEFORE setting: 0x00 (event group becomes 0x05). bits = 0x00.

2. Step 2: Second call - xEventGroupClearBits(myEventGroup, 0x01)

   Event group now: 0x05. Returns bits BEFORE clearing: 0x05 (event group becomes 0x04). bits = 0x05.

3. Final Answer:

   0x00 -> Option A

4. Quick Check:

   Return value = pre-operation bits [OK]

Hint: xEventGroupSetBits/ClearBits return bits BEFORE operation [OK]

Common Mistakes:

• Confusing return value (pre-op) with post-op event group state
• Miscalculating bitwise operations on event group
• Forgetting return value overwrites 'bits' each call

4. Identify the error in this code snippet:

EventGroupHandle_t myEventGroup;
myEventGroup = xEventGroupCreate();
xEventGroupClearBits(0x01, myEventGroup);

medium

A. Arguments to xEventGroupClearBits are reversed

B. xEventGroupCreate() returns void, not a handle

C. xEventGroupClearBits requires a pointer, not a value

D. Missing include for FreeRTOS headers

Solution

1. Step 1: Check function parameter order

   xEventGroupClearBits() expects (EventGroupHandle_t, EventBits_t). The code passes (0x01, myEventGroup), which is reversed.

2. Step 2: Confirm return type of xEventGroupCreate()

   xEventGroupCreate() returns an EventGroupHandle_t, so assignment is correct.

3. Final Answer:

   Arguments to xEventGroupClearBits are reversed -> Option A

4. Quick Check:

   Function parameters order matters [OK]

Hint: Check parameter order carefully for FreeRTOS API calls [OK]

Common Mistakes:

• Swapping parameters in API calls
• Assuming wrong return types
• Ignoring compiler warnings

5. You want to signal two events represented by bits 0x01 and 0x04, then immediately clear bit 0x01 without affecting others. Which sequence correctly achieves this?

hard

A. xEventGroupClearBits(myEventGroup, 0x05); xEventGroupSetBits(myEventGroup, 0x01);

B. xEventGroupSetBits(myEventGroup, 0x05); xEventGroupClearBits(myEventGroup, 0x01);

C. xEventGroupSetBits(myEventGroup, 0x01); xEventGroupClearBits(myEventGroup, 0x04);

D. xEventGroupClearBits(myEventGroup, 0x01); xEventGroupSetBits(myEventGroup, 0x05);

Solution

1. Step 1: Set bits 0x01 and 0x04 together

   Setting bits 0x05 (binary 0101) signals both events at once.

2. Step 2: Clear only bit 0x01

   Clearing bit 0x01 removes that event signal but leaves 0x04 set.

3. Final Answer:

   xEventGroupSetBits(myEventGroup, 0x05); xEventGroupClearBits(myEventGroup, 0x01); -> Option B

4. Quick Check:

   Set both bits then clear one bit [OK]

Hint: Set all bits first, then clear only the unwanted bit [OK]

Common Mistakes:

• Clearing bits before setting them
• Clearing wrong bits
• Not combining bits correctly