Low-power design patterns in Embedded C - Step-by-Step Execution

Concept Flow - Low-power design patterns

Start

↓

Check system idle?

No→Run normal tasks

Yes↓

Enter low-power mode

↓

Wake-up event?

No→Stay in low-power mode

Yes↓

Handle event

↓

Return to check idle

The system checks if it is idle, enters low-power mode if yes, waits for wake-up events, then handles them before checking idle again.

Execution Sample

Embedded C

while(1) {
  if (system_idle()) {
    enter_low_power_mode();
  }
  handle_events();
}

This loop checks if the system is idle, enters low-power mode if true, then handles any events.

Execution Table

Step	Condition	Result	Action	Power Mode
1	system_idle() == false	No	handle_events()	Active
2	system_idle() == true	Yes	enter_low_power_mode()	Low-power
3	Wake-up event?	No	stay in low_power_mode()	Low-power
4	Wake-up event?	Yes	handle_events()	Active
5	system_idle() == false	No	handle_events()	Active
6	system_idle() == true	Yes	enter_low_power_mode()	Low-power

💡 Infinite loop; system continuously checks idle state and switches power modes accordingly.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6
system_idle()	N/A	false	true	true	false	false	true
Power Mode	Active	Active	Low-power	Low-power	Active	Active	Low-power

Key Moments - 3 Insights

Why does the system enter low-power mode only when system_idle() is true?

Because the condition system_idle() == true triggers enter_low_power_mode() as shown in steps 2 and 6 of the execution_table.

What happens if no wake-up event occurs while in low-power mode?

The system stays in low-power mode, as shown in step 3 where Wake-up event? is No and action is stay in low_power_mode().

Why does the system return to active mode after a wake-up event?

Because handling events requires active mode, so after a wake-up event (step 4), the system calls handle_events() and power mode changes to Active.

Visual Quiz - 3 Questions

Look at the execution_table at Step 2, what action does the system take?

A Stay in active mode

B Handle events

C Enter low-power mode

D Check for wake-up event

💡 Hint

Refer to the 'Action' column at Step 2 in the execution_table.

At which step does the system detect a wake-up event and handle it?

A Step 4

B Step 3

C Step 5

D Step 6

💡 Hint

Check the 'Condition' and 'Action' columns for wake-up event handling in the execution_table.

If system_idle() always returns false, what will be the power mode after Step 5?

A Low-power

B Active

C Unknown

D Sleep

💡 Hint

Look at the variable_tracker for system_idle() and Power Mode values after Step 5.

Concept Snapshot

Low-power design pattern in embedded C:
- Check if system is idle
- If idle, enter low-power mode
- Wait for wake-up events
- On event, handle it and return to active mode
- Repeat continuously
This saves power by sleeping when idle.

Full Transcript

This example shows a common low-power design pattern in embedded C. The system runs an infinite loop checking if it is idle. If idle, it enters low-power mode to save energy. While in low-power mode, it waits for wake-up events. When an event occurs, it wakes up, handles the event, and then checks idle status again. This cycle repeats indefinitely to balance power saving and responsiveness.

Practice

1. Which of the following best describes the purpose of low-power design patterns in embedded C programming?

easy

A. To reduce battery consumption by putting the CPU and peripherals into sleep modes

B. To increase the clock speed of the CPU for faster processing

C. To add more features to the embedded device

D. To improve the graphical user interface responsiveness

Solution

1. Step 1: Understand low-power design patterns

   These patterns focus on saving battery by reducing power use in the CPU and peripherals.

2. Step 2: Compare options to the purpose

   Only To reduce battery consumption by putting the CPU and peripherals into sleep modes talks about reducing battery consumption by sleep modes, which matches the purpose.

3. Final Answer:

   To reduce battery consumption by putting the CPU and peripherals into sleep modes -> Option A

4. Quick Check:

   Low-power design = save battery by sleep modes [OK]

Hint: Low-power means saving battery by sleeping parts [OK]

Common Mistakes:

• Confusing low-power with performance improvement
• Thinking it adds features instead of saving power
• Assuming it improves UI responsiveness

2. Which of the following is the correct way to put the CPU into sleep mode using a standard instruction in embedded C?

easy

A. enter_sleep_mode();

B. sleep();

C. power_down();

D. __WFI();

Solution

1. Step 1: Identify the standard CPU sleep instruction

   The __WFI() instruction is a common CPU instruction to wait for interrupt and enter sleep mode safely.

2. Step 2: Check other options

   Other options like sleep(), power_down(), enter_sleep_mode() are not standard embedded C instructions.

3. Final Answer:

   __WFI(); -> Option D

4. Quick Check:

   Use __WFI() to sleep CPU [OK]

Hint: Use __WFI() to enter CPU sleep mode [OK]

Common Mistakes:

• Using non-standard function names
• Forgetting the double underscore in __WFI()
• Confusing sleep() with standard CPU instructions

3. Consider the following code snippet in embedded C:

void enter_low_power() {
    disable_peripherals();
    __WFI();
    enable_peripherals();
}

What is the expected behavior when this function runs?

medium

A. The CPU sleeps until an interrupt occurs, peripherals are disabled before sleep and enabled after wake-up

B. The CPU runs continuously without sleeping, peripherals remain disabled

C. The CPU sleeps but peripherals stay enabled, causing high power use

D. The function causes a syntax error and does not compile

Solution

1. Step 1: Analyze the function steps

   First, peripherals are disabled to save power, then __WFI() puts CPU to sleep waiting for interrupt, finally peripherals are re-enabled after waking.

2. Step 2: Understand expected behavior

   The CPU sleeps until an interrupt wakes it, peripherals are off during sleep to save power, then turned back on.

3. Final Answer:

   The CPU sleeps until an interrupt occurs, peripherals are disabled before sleep and enabled after wake-up -> Option A

4. Quick Check:

   Disable peripherals + __WFI() = sleep with low power [OK]

Hint: Disable peripherals before __WFI() to save power during sleep [OK]

Common Mistakes:

• Assuming peripherals stay enabled during sleep
• Thinking CPU does not sleep after __WFI()
• Confusing function behavior with syntax errors

4. The following code is intended to put the CPU into low-power mode, but it does not work as expected:

void sleep_mode() {
    __WFI;
}

What is the error and how to fix it?

medium

A. The function should disable peripherals before __WFI; add disable_peripherals();

B. __WFI is not a valid instruction; replace with sleep();

C. __WFI is missing parentheses; fix by writing __WFI();

D. The function needs a return statement; add return 0;

Solution

1. Step 1: Identify syntax error in __WFI usage

   The code uses __WFI without parentheses, which is incorrect syntax for a function-like instruction.

2. Step 2: Correct the syntax

   Add parentheses to call __WFI as a function: __WFI(); fixes the error.

3. Final Answer:

   __WFI is missing parentheses; fix by writing __WFI(); -> Option C

4. Quick Check:

   __WFI() needs parentheses to call [OK]

Hint: Always use parentheses with __WFI() instruction [OK]

Common Mistakes:

• Omitting parentheses on __WFI
• Replacing __WFI with non-standard functions
• Ignoring peripheral disable step (not syntax error here)

5. You want to design a low-power routine that puts the CPU to sleep only if no peripherals are active. Given the functions are_peripherals_active() returning 1 if active, 0 if not, and __WFI() to sleep, which code snippet correctly implements this logic?

hard

A. if (are_peripherals_active()) { __WFI(); }

B. if (!are_peripherals_active()) { __WFI(); }

C. while (are_peripherals_active()) { __WFI(); }

D. do { __WFI(); } while (are_peripherals_active());

Solution

1. Step 1: Understand the condition to sleep

   The CPU should sleep only if no peripherals are active, so condition is peripherals inactive (0).

2. Step 2: Match condition with code

   Using if (!are_peripherals_active()) means if peripherals are not active, then call __WFI() to sleep.

3. Final Answer:

   if (!are_peripherals_active()) { __WFI(); } -> Option B

4. Quick Check:

   Sleep only if peripherals inactive = if (!active) [OK]

Hint: Sleep only when peripherals inactive: use if (!are_peripherals_active()) [OK]

Common Mistakes:

• Sleeping when peripherals are active
• Using loops causing repeated sleep calls
• Confusing condition negation