Idle mode behavior in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this idle mode simulation code?

Consider this embedded C code snippet simulating entering idle mode and waking up on an interrupt. What will be printed?

Embedded C

#include <stdio.h>
#include <stdbool.h>

volatile bool idle = false;

void enter_idle_mode() {
    idle = true;
    printf("Entering idle mode...\n");
}

void wake_up() {
    if (idle) {
        idle = false;
        printf("Woke up from idle mode!\n");
    }
}

int main() {
    enter_idle_mode();
    wake_up();
    wake_up();
    return 0;
}

A

Entering idle mode...
Woke up from idle mode!

B

Entering idle mode...
Woke up from idle mode!
Woke up from idle mode!

C

Woke up from idle mode!
Entering idle mode...

D

Entering idle mode...

💡 Hint

Think about the state of the idle variable after waking up once.

The code sets idle to true when entering idle mode. The first wake_up() call detects idle == true, prints the wake-up message, and sets idle to false. The second wake_up() call finds idle == false, so it prints nothing.

🧠 Conceptual

intermediate

Which statement best describes idle mode behavior in embedded systems?

Choose the statement that correctly explains what happens when an embedded system enters idle mode.

A The CPU stops executing instructions and all peripherals are powered off.

B The CPU halts execution but peripherals and interrupts remain active to wake the CPU.

C The CPU continues running at full speed but ignores interrupts until idle mode ends.

D The system resets all registers and restarts the program from the beginning.

💡 Hint

Think about how the CPU can wake up from idle mode.

In idle mode, the CPU stops executing instructions to save power, but peripherals and interrupts remain active. This allows the CPU to wake up when an interrupt occurs.

🔧 Debug

advanced

Why does this idle mode code fail to wake up on interrupt?

Examine the code below. It is supposed to enter idle mode and wake up on an interrupt, but it never wakes up. What is the cause?

Embedded C

volatile bool idle = false;

void enter_idle_mode() {
    idle = true;
    // CPU enters idle mode here
}

void interrupt_handler() {
    idle = false;
}

int main() {
    enter_idle_mode();
    while (idle) {
        // wait for interrupt
    }
    printf("Woke up!\n");
    return 0;
}

A The idle flag is not declared volatile, so the compiler optimizes the loop incorrectly.

B The interrupt handler does not clear the idle flag, so the loop never ends.

C The CPU never actually enters idle mode because there is no instruction to halt it.

D The main function does not enable interrupts before entering idle mode.

💡 Hint

Think about what is missing to actually stop the CPU.

The code sets the idle flag but never executes an instruction to halt the CPU (like __WFI() or __WFE()). Without halting, the CPU keeps running and the interrupt may never occur as expected.

📝 Syntax

advanced

What error does this idle mode code produce?

Identify the error in this embedded C code snippet related to idle mode.

Embedded C

void enter_idle_mode() {
    idle = true;
    __WFI();
}

A SyntaxError: missing semicolon after 'idle = true'

B TypeError: __WFI is not a function

C RuntimeError: idle variable not declared

D No error, code runs correctly

💡 Hint

Check the line endings carefully.

The line idle = true is missing a semicolon at the end, causing a syntax error.

🚀 Application

expert

How many times will the CPU wake up in this idle mode loop?

Given the code below, how many times will the CPU print "Woke up!" before the program ends?

Embedded C

#include <stdio.h>
#include <stdbool.h>

volatile bool idle = false;
int wake_count = 0;

void enter_idle_mode() {
    idle = true;
    // Simulate CPU halt
}

void interrupt_handler() {
    if (wake_count < 3) {
        idle = false;
        wake_count++;
    }
}

int main() {
    for (int i = 0; i < 5; i++) {
        enter_idle_mode();
        interrupt_handler();
        if (!idle) {
            printf("Woke up!\n");
        }
    }
    return 0;
}

A 0

B 5

C 2

D 3

💡 Hint

Look at how wake_count limits waking up.

The interrupt handler only clears idle and increments wake_count if wake_count < 3. So the CPU wakes up exactly 3 times, printing "Woke up!" three times.