Waiting for event bits (AND/OR) in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this FreeRTOS event bits wait example?

Consider the following FreeRTOS code snippet that waits for event bits with AND condition:

EventBits_t bits = xEventGroupWaitBits(
    eventGroup,
    BIT_1 | BIT_2,
    pdFALSE,
    pdTRUE,
    portMAX_DELAY
); 
if ((bits & (BIT_1 | BIT_2)) == (BIT_1 | BIT_2)) {
    printf("Both bits set\n");
} else {
    printf("Bits not set as required\n");
}

Assuming BIT_1 and BIT_2 are set in the event group before this call, what will be printed?

FreeRTOS

EventBits_t bits = xEventGroupWaitBits(
    eventGroup,
    BIT_1 | BIT_2,
    pdFALSE,
    pdTRUE,
    portMAX_DELAY
); 
if ((bits & (BIT_1 | BIT_2)) == (BIT_1 | BIT_2)) {
    printf("Both bits set\n");
} else {
    printf("Bits not set as required\n");
}

A Both bits set

B Bits not set as required

C Compilation error due to incorrect parameters

D Runtime error due to invalid event group handle

💡 Hint

Remember that xEventGroupWaitBits with pdTRUE for the waitForAllBits parameter waits until all bits are set.

The function waits until both BIT_1 and BIT_2 are set because waitForAllBits is pdTRUE. Since both bits are set before the call, the function returns immediately with those bits set, so the condition is true and "Both bits set" is printed.

❓ Predict Output

intermediate

What output does this FreeRTOS event bits wait with OR condition produce?

Given this code snippet:

EventBits_t bits = xEventGroupWaitBits(
    eventGroup,
    BIT_1 | BIT_2,
    pdFALSE,
    pdFALSE,
    portMAX_DELAY
);
if (bits & (BIT_1 | BIT_2)) {
    printf("At least one bit set\n");
} else {
    printf("No bits set\n");
}

If only BIT_2 is set in the event group before the call, what will be printed?

FreeRTOS

EventBits_t bits = xEventGroupWaitBits(
    eventGroup,
    BIT_1 | BIT_2,
    pdFALSE,
    pdFALSE,
    portMAX_DELAY
);
if (bits & (BIT_1 | BIT_2)) {
    printf("At least one bit set\n");
} else {
    printf("No bits set\n");
}

A At least one bit set

B No bits set

C Deadlock because bits never set

D Compilation error due to wrong bitmask

💡 Hint

Check the waitForAllBits parameter and what it means for waiting on bits.

With waitForAllBits set to pdFALSE, the function returns when any of the bits in the mask are set. Since BIT_2 is set, the function returns and the condition is true, printing "At least one bit set".

❓ Predict Output

advanced

What is the output of this FreeRTOS event bits wait with clear on exit?

Analyze this code snippet:

EventBits_t bits = xEventGroupWaitBits(
    eventGroup,
    BIT_1 | BIT_2,
    pdTRUE,
    pdTRUE,
    100 / portTICK_PERIOD_MS
);
printf("Bits before wait: 0x%X\n", bits);
// Assume BIT_1 and BIT_2 were set before the call

What will be printed for "Bits before wait:"?

FreeRTOS

EventBits_t bits = xEventGroupWaitBits(
    eventGroup,
    BIT_1 | BIT_2,
    pdTRUE,
    pdTRUE,
    100 / portTICK_PERIOD_MS
);
printf("Bits before wait: 0x%X\n", bits);

A Bits before wait: 0x0

B Bits before wait: 0x2

C Bits before wait: 0x1

D Bits before wait: 0x3

💡 Hint

Remember that pdTRUE for the clearOnExit parameter clears the bits after returning.

The function returns the bits that were set before clearing them. Since BIT_1 and BIT_2 correspond to bits 0x1 and 0x2, the combined mask is 0x3. So it prints "Bits before wait: 0x3".

❓ Predict Output

advanced

What error occurs if xEventGroupWaitBits is called with NULL event group?

Consider this code:

EventBits_t bits = xEventGroupWaitBits(
    NULL,
    BIT_1,
    pdFALSE,
    pdTRUE,
    portMAX_DELAY
);
printf("Bits: 0x%X\n", bits);

What will happen when this code runs?

FreeRTOS

EventBits_t bits = xEventGroupWaitBits(
    NULL,
    BIT_1,
    pdFALSE,
    pdTRUE,
    portMAX_DELAY
);
printf("Bits: 0x%X\n", bits);

A Prints Bits: 0x1

B Prints Bits: 0x0

C Runtime error or crash due to NULL event group handle

D Compilation error due to NULL parameter

💡 Hint

Check what happens if the event group handle is invalid or NULL.

Passing NULL as the event group handle is invalid and will cause a runtime error or crash because the function tries to access memory through a NULL pointer.

🧠 Conceptual

expert

How many bits are set in the event group after this sequence?

Given an event group initially with no bits set, the following calls are made:

xEventGroupSetBits(eventGroup, BIT_1);
xEventGroupSetBits(eventGroup, BIT_2);
EventBits_t bits = xEventGroupWaitBits(
    eventGroup,
    BIT_1 | BIT_2 | BIT_3,
    pdTRUE,
    pdFALSE,
    0
);
// After this, how many bits remain set in the event group?

FreeRTOS

xEventGroupSetBits(eventGroup, BIT_1);
xEventGroupSetBits(eventGroup, BIT_2);
EventBits_t bits = xEventGroupWaitBits(
    eventGroup,
    BIT_1 | BIT_2 | BIT_3,
    pdTRUE,
    pdFALSE,
    0
);

A 1 bit remains set (BIT_3)

B 2 bits remain set (BIT_1 and BIT_2)

C 0 bits remain set

D 3 bits remain set (BIT_1, BIT_2, BIT_3)

💡 Hint

Consider the clearOnExit parameter and the bits set before the wait.

The wait is for all bits BIT_1, BIT_2, and BIT_3 with clearOnExit set to pdFALSE. Since BIT_3 is not set, the wait times out immediately (timeout=0). No bits are cleared. So BIT_1 and BIT_2 remain set.

Practice

1. What does waiting for event bits in FreeRTOS allow a task to do?

easy

A. Pause execution until specific event bits are set

B. Run continuously without interruption

C. Automatically clear all event bits on start

D. Create new event bits dynamically

Solution

1. Step 1: Understand event bits purpose

   Event bits are signals that tasks can wait for to synchronize actions.

2. Step 2: Identify what waiting means

   Waiting means the task pauses until the required bits are set.

3. Final Answer:

   Pause execution until specific event bits are set -> Option A

4. Quick Check:

   Waiting for event bits = pause task until bits set [OK]

Hint: Waiting means pausing until bits signal event [OK]

Common Mistakes:

• Thinking waiting means running continuously
• Confusing event bits with task creation
• Assuming bits clear automatically on start

2. Which of the following is the correct syntax to wait for event bits using AND mode in FreeRTOS?

easy

A. xEventGroupClearBits(eventGroup, bitsToWaitFor);

B. xEventGroupWaitBits(eventGroup, bitsToWaitFor, clearOnExit, pdFALSE, timeout);

C. xEventGroupWaitBits(eventGroup, bitsToWaitFor, clearOnExit, pdTRUE, timeout);

D. xEventGroupSetBits(eventGroup, bitsToWaitFor);

Solution

1. Step 1: Identify the AND mode parameter

   The fourth parameter is pdTRUE to wait for all bits (AND mode).

2. Step 2: Confirm function usage

   xEventGroupWaitBits waits for bits with parameters: event group, bits, clear flag, wait mode, timeout.

3. Final Answer:

   xEventGroupWaitBits(eventGroup, bitsToWaitFor, clearOnExit, pdTRUE, timeout); -> Option C

4. Quick Check:

   pdTRUE means AND mode in wait bits [OK]

Hint: pdTRUE means wait for all bits (AND) [OK]

Common Mistakes:

• Using pdFALSE for AND mode
• Confusing SetBits with WaitBits
• Mixing up clearOnExit parameter

3. Given the code snippet:

EventBits_t bits = xEventGroupWaitBits(eventGroup, BIT_1 | BIT_2, pdTRUE, pdFALSE, 1000);

What does bits contain if only BIT_1 is set in the event group before the call?

medium

A. Only BIT_1 set in bits

B. Both BIT_1 and BIT_2 set in bits

C. Zero (no bits set)

D. Function blocks indefinitely

Solution

1. Step 1: Understand wait mode pdFALSE

   pdFALSE means OR mode: wait for any bit set.

2. Step 2: Check which bits are set before call

   Only BIT_1 is set, but the third parameter is pdTRUE (clearOnExit), and the fourth parameter is pdFALSE (waitForAll = false), so the function waits for any bit set.

3. Step 3: Analyze the code

   However, the third parameter is pdTRUE (clearOnExit), so bits are cleared on exit. But since waitForAll is pdFALSE, the function returns when any bit is set.

4. Step 4: But the question is what bits contains if only BIT_1 is set before call

   Since waitForAll is false, the function returns immediately with bits containing BIT_1 set.

5. Final Answer:

   Only BIT_1 set in bits -> Option A

6. Quick Check:

   OR mode returns bits set among requested [OK]

Hint: pdFALSE means OR mode, returns any set bits [OK]

Common Mistakes:

• Assuming both bits must be set for return
• Thinking function blocks if not all bits set
• Confusing pdTRUE and pdFALSE meanings

4. Identify the error in this code snippet:

EventBits_t bits = xEventGroupWaitBits(eventGroup, BIT_1 | BIT_2, pdTRUE, pdTRUE, 500);

What is wrong?

medium

A. pdTRUE for waitForAll means wait for all bits, but clearOnExit should be false to avoid clearing

B. pdTRUE for clearOnExit clears bits on exit, which is valid; no error

C. Using pdTRUE for both clearOnExit and waitForAll bits is correct

D. pdTRUE for waitForAll is invalid; must be pdFALSE

Solution

1. Step 1: Understand clearOnExit parameter

   pdTRUE means bits are cleared when function returns.

2. Step 2: Understand waitForAll parameter

   pdTRUE means wait for all bits (AND mode), which is valid.

3. Final Answer:

   pdTRUE for clearOnExit clears bits on exit, which is valid; no error -> Option B

4. Quick Check:

   clearOnExit pdTRUE is allowed and common [OK]

Hint: clearOnExit pdTRUE clears bits on return, allowed [OK]

Common Mistakes:

• Thinking clearOnExit pdTRUE is always wrong
• Confusing waitForAll with clearOnExit
• Assuming pdTRUE for waitForAll is invalid

5. You want a task to wait until both BIT_1 and BIT_2 are set, then clear those bits automatically on exit. Which call achieves this correctly?

hard

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

B. xEventGroupWaitBits(eventGroup, BIT_1 | BIT_2, pdFALSE, pdFALSE, portMAX_DELAY);

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

D. xEventGroupWaitBits(eventGroup, BIT_1 | BIT_2, pdTRUE, pdTRUE, portMAX_DELAY);

Solution

1. Step 1: Identify wait for all bits

   Fourth parameter pdTRUE means wait for all bits (AND mode).

2. Step 2: Identify clear bits on exit

   Third parameter pdTRUE means clear bits on exit.

3. Step 3: Match parameters to options

   xEventGroupWaitBits(eventGroup, BIT_1 | BIT_2, pdTRUE, pdTRUE, portMAX_DELAY); uses clearOnExit = pdTRUE and waitForAll = pdTRUE, correct for requirement.

4. Final Answer:

   xEventGroupWaitBits(eventGroup, BIT_1 | BIT_2, pdTRUE, pdTRUE, portMAX_DELAY); -> Option D

5. Quick Check:

   Clear bits and wait all bits = clearOnExit pdTRUE, waitForAll pdTRUE [OK]

Hint: clearOnExit and waitForAll both pdTRUE for AND + clear [OK]

Common Mistakes:

• Mixing up clearOnExit and waitForAll parameters
• Using pdFALSE for waitForAll when AND needed
• Not setting timeout to wait indefinitely