Skip to content
Tech Interview Prep
Technical interview guide

Power Management & Low-Power Design

The sleep modes, clock strategies, and wake mechanisms that let a battery-powered device run for months or years on a small cell.

Read
60 min
Practice MCQs
25
Interview Q&A
25
Edition
v3
Editorial status
Reviewed

Scope: Current Zephyr system/device/runtime PM; CMSIS-Core 6 WFI/WFE; CMSIS-RTOS and FreeRTOS tickless guidance reviewed 2026-09-04.

Curated: · Written: · Reviewed:

25 questions

MCQ-1A sensor node runs a 1 s operating cycle. In active mode it draws 120 mW for 40 ms; in idle mode 15 mW for 200 ms; in sleep mode 0.05 mW for 760 ms. Each active→idle transition costs 0.8 mJ, idle→sleep costs 0.2 mJ, and the wake transition back to active costs 1.0 mJ. What is the total energy consumed per cycle?
MCQ-21A sub-GHz sensor node wakes every 10 s to send a 20-byte reading at 250 kbps. Per wake it spends 1.5 ms in crystal startup and 0.8 ms in RX warm-up at 6 mA, 5 ms listening at 6 mA, 3 ms transmitting at 20 mA, and 2 ms in the RX ack window at 6 mA. Sleep current is 0.5 µA. The team is deciding where to optimise. Which statement about the energy budget is correct?
MCQ-22A field sensor runs from a 3.7 V, 2000 mAh Li-ion cell through a buck regulator with 90% efficiency. It wakes every 60 s, runs 5 s at 20 mA, and sleeps at 100 µA. The cell's usable capacity down to the regulator's 3.0 V cutoff is 80% of nominal at the deployment temperature. What runtime should the team expect?
MCQ-3A battery-powered sensor node uses a hypothetical MCU with these modes: Run draws 10 mA; Sleep draws 1 mA, retains RAM and peripheral registers, and wakes in 5 µs; Deep Sleep draws 50 µA, retains RAM but loses peripheral configuration, and wakes in 200 µs; Standby draws 2 µA, retains only the backup domain, and wakes in 2 ms. The node wakes every 10 ms, runs for 1 ms at 10 mA to read an SPI sensor, then idles. After any Deep Sleep wake, firmware must reinitialize the SPI and GPIO, which takes 300 µs at 10 mA. An external event must be serviced within 500 µs of its edge. The team currently uses Deep Sleep for all idle time. What should they do?
MCQ-17A Cortex-M4 sensor node samples a radio every 20 ms. The radio raises its IRQ and the handler must read the FIFO within 3 ms of that edge or the FIFO overruns and the packet is lost. The team moves the node from a 1.8 mA sleep state to a 0.4 mA retention state that keeps SRAM, keeps the radio clocked, and can be exited by any enabled IRQ. The datasheet lists 5 ms exit latency for the retention state. Packets now drop. Why is the retention state the wrong choice here?
MCQ-2A mobile SoC's C2 state costs 40 uJ to enter and exit and cuts static power by 0.9 mW against C1; its exit latency is 150 us. The kernel currently enters C2 whenever the idle predictor expects more than 1 ms of idle. What should decide whether a predicted idle window is worth a C2 entry?
MCQ-4A Linux server's cpuidle driver exposes five idle states, listed from shallowest to deepest: | state | target residency | exit latency | | --- | --- | --- | | C1 | 2 µs | 1 µs | | C2 | 40 µs | 10 µs | | C3 | 100 µs | 40 µs | | C4 | 150 µs | 60 µs | | C5 | 250 µs | 200 µs | A latency-sensitive process holds /dev/cpu_dma_latency open with a 130 µs constraint. The menu governor predicts the next timer event 300 µs away. Which state does the governor select?
MCQ-5A Cortex-M4 firmware runs `while (!rx_ready) __WFI();`. The UART RX interrupt is enabled in the NVIC and is not masked. A byte arrives and the UART interrupt becomes pending just before the CPU executes `__WFI`. The ISR sets `rx_ready = 1` and clears the UART interrupt. What does the CPU do when it executes `__WFI`?
MCQ-6A Cortex-M4 board runs at 48 MHz and 3.3 V. Its main loop is `for (;;) { __WFE(); do_work(); }`. A SysTick handler fires every 1 ms, does a few register writes, and clears the SysTick pending flag before returning. Measured average current is 11 mA; the datasheet gives 12 mA running and 3 µA in WFE sleep. No debugger is attached. Why is the current 11 mA rather than about 3 µA?
MCQ-8A Cortex-M4 sensor node runs from a 3.7 V cell. Between samples it enters a deep-sleep mode that keeps only the always-on domain clocked: a 32 kHz oscillator, the RTC and a wake-up timer; the 16 MHz HSI is stopped. Run current is 9 mA, deep-sleep current is 2.1 µA, and the RTC alarm wakes the core every 30 s. The firmware enables the UART RX interrupt in the NVIC (IRQ 38, priority 0x40) and executes WFI. On the bench the RTC wakes the node on schedule, but a byte arriving on the UART never does: the node only wakes at the next RTC alarm. The UART pins and baud rate are verified good. What is the most likely cause?
MCQ-7An x86-64 kernel's idle loop runs with interrupts enabled: ```c for (;;) { if (runqueue_empty()) asm volatile("hlt"); /* halt until an interrupt */ schedule(); } ``` A task is enqueued by an IPI handler on another core. Under load the loop keeps up, but about once per 10^6 IPIs the enqueued task waits ~2 ms for the next timer tick before `schedule()` runs. A trace of one stall shows, in order: `runqueue_empty()` returns true; the IPI handler runs to completion and enqueues the task; `hlt` executes; the core stays halted until the next timer tick. The core must stay halted whenever the runqueue is empty. Which change closes the window?
MCQ-13An enable signal is produced by combinational logic and can change at any point in the clock period. A designer replaces the synthesis-inserted ICG cell with a plain two-input AND of the clock and the enable. Simulation then shows a narrow spurious pulse on the gated clock whenever the enable falls shortly after the clock rises. Which property of the ICG cell prevents that pulse?
MCQ-10A Zephyr 3.5 sensor hub is mid-way through a 120 ms SPI flash erase when the system PM policy requests suspend. The flash driver marked itself busy with the PM busy mechanism before starting the erase. The suspend entry budget is 50 ms. What is the expected outcome?
MCQ-16A Cortex-M board runs an RTOS with a 1000 Hz tick and tickless idle enabled. The wake-up timer is clocked from a free-running 1 MHz counter. A task blocks for 400 ms; at the moment the kernel arms the wake timer, the counter reads 1,234,000. A UART interrupt wakes the CPU early, and the counter now reads 1,384,000. What must the tickless-idle exit path do to the tick count?
MCQ-14A driver for a DMA-backed SPI controller writes the start bit and then clears the peripheral's clock-enable bit in the same function. Under sustained load about 1 transfer in 50 stalls mid-frame: the DMA transfer-complete interrupt never fires and the SPI busy flag stays set until reset. The reference manual states that the SPI's FIFO drains on the peripheral clock, independent of the bus clock; that the DMA controller sits on an always-on domain and raises transfer-complete when the last byte is written into the FIFO; and that the product's sleep-current budget requires the SPI clock to be gated between transfers. What should the driver do?
MCQ-18A non-coherent ARM64 Ethernet MAC owns 256 RX buffers of 2 KB each, mapped once with dma_map_single(DMA_FROM_DEVICE) and re-posted forever; the driver performs the documented per-packet syncs, calling dma_sync_single_for_cpu before the stack reads a completed buffer and dma_sync_single_for_device before re-posting it. Its system-suspend path is: mask the RX interrupt; clear the control register's receive-enable bit; unmap all 256 buffers, a loop that takes about 30 us on this SoC; return. Clearing the enable bit stops the engine from fetching more descriptors, but this SoC can take up to 400 us to finish the descriptor it has already fetched. Stress testing shows that roughly 1 suspend in 5000 ends with one buffer whose contents changed after the unmap loop returned. What should the suspend path do?
MCQ-9A battery-powered door sensor runs on an MCU whose reset-cause register is read-to-clear and can latch several bits at once: RTC alarm, GPIO (door contact), UART RX, and watchdog. The bootloader reads that register to decide whether to stay in DFU mode, then clears it. The application reads the same register afterwards to classify the wake. Field data shows 4% of wakes logged as 'unknown', and units that wake on both an RTC alarm and a door contact log only the RTC alarm. Which change fixes both symptoms?
MCQ-19An ESP32 node deep-sleeps for 60 s and keeps a struct in RTC slow memory at offset 0x00. v1.2's struct is 20 bytes: magic (0x52455431) at 0x00, version at 0x04, CRC32 at 0x08, boot_count at 0x0C, cal_offset at 0x10. v1.3 inserted a 4-byte field at 0x10, so it reads cal_offset at 0x14: past the end of v1.2's struct, and the OTA left the RTC contents in place. On 3% of units cal_offset now reads 0xFFFFFFFF and the ADC reports full scale, yet boot_count still increments by one on every wake. Units that brown out at 2.4 V during a transmit burst show the same full-scale reading, but their boot_count also reads 0xFFFFFFFF. The RTC domain is fed from the same 3.3 V rail as the core. Which pairing explains both groups?
MCQ-20A battery sensor node sets its independent watchdog timeout to 8.0 s and feeds it at the top of every 2.0 s main-loop iteration. To save power it sleeps for 300 s at a time, waking on an RTC alarm; the last feed before sleep happens 0.1-1.8 s before entry, depending on how long the sensor read takes. Field logs, timestamped to 0.1 s, show watchdog resets at 6.2-7.9 s after sleep entry in every capture, never later; units that disable the watchdog before the same sleep never reset. Which explanation fits these timestamps?
MCQ-15A battery-powered sensor node runs its Cortex-M4 core at 400 MHz from a 1.2 V rail. The same PLL feeds the APB bus, so the UART is clocked at 100 MHz and is configured for 115200 baud. SysTick is driven by the core clock and the RTOS tick is 1 ms. To save power, firmware will drop the core to 200 MHz and the regulator to 1.0 V at runtime. Flash wait states are currently 5 at 400 MHz and 2 at 200 MHz. Which transition plan is correct?
MCQ-12A 3.3 V always-on domain drives a 1.8 V domain whose input buffer uses thin-oxide 1.8 V transistors rated to a 1.98 V maximum input. Both supplies are up, and the driver holds its output at 3.3 V. Which cell is required on this path?
MCQ-25A UPF defines PD_A (VDD_A 0.8 V) and PD_B (VDD_B 1.2 V). A signal drives from PD_A to PD_B. The PST includes rows (A ON, B ON), (A OFF, B ON), (A ON, B OFF), (A OFF, B OFF). The tool reports a violation only for the row (A OFF, B ON). Which fix resolves the reported violation?
MCQ-11When transitioning a power domain containing state retention power gating (SRPG) registers with separate save, restore, and isolation controls into and out of sleep, what is the correct control sequencing?
MCQ-23A coin-cell BLE sensor sleeps at 3 µA. Every 10 s it transmits for 2 ms at 8 mA, then runs its MCU for 30 ms at 1.5 mA. A 1 Ω shunt in the cell's ground path feeds a DMM in DC volts mode with 20 ms integration. What does the DMM report, and what does that hide?
MCQ-24A fleet of 5,000 coin-cell sensors uses an MCU that sleeps at 1.2 µA (25 °C, 3.3 V). Field returns from cold climates show 40% shorter battery life and 8% of units fail to wake after 24 h at −20 °C. On the bench at 25 °C and 3.3 V, every unit wakes and sleep current measures 1.1–1.3 µA. What should the team do next?