Low-power design patterns in Embedded C

Introduction

Low-power design patterns help save battery life in embedded devices by reducing energy use. They make devices run longer without charging.

When building battery-powered sensors that need to last months or years.

In wearable devices like fitness trackers to extend usage time.

For remote IoT devices where changing batteries is hard.

In portable gadgets like handheld meters to save power.

When designing smart home devices that run continuously.

Syntax

Embedded C

void enter_low_power_mode(void) {
    // Prepare device for low power
    disable_unused_peripherals();
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
    sleep_enable();
    sleep_cpu();
    sleep_disable();
    // Wake up and resume normal operation
}

This example shows a common pattern to enter a low-power sleep mode.

Functions like disable_unused_peripherals() help reduce power by turning off parts not needed.

Examples

Disabling peripherals that are not needed reduces power consumption.

Embedded C

void disable_unused_peripherals(void) {
    // Turn off ADC, timers, etc. to save power
    ADCSRA &= ~(1 << ADEN); // Disable ADC
    TIMSK0 = 0; // Disable Timer0 interrupts
}

Using a lighter sleep mode lets the CPU wake up faster but saves less power.

Embedded C

void enter_sleep_mode(void) {
    set_sleep_mode(SLEEP_MODE_IDLE); // Light sleep mode
    sleep_enable();
    sleep_cpu();
    sleep_disable();
}

Interrupts can wake the device from sleep to handle events.

Embedded C

void wake_up_isr(void) {
    // Interrupt service routine to wake up from sleep
    // Usually empty, just needed to exit sleep
}

Sample Program

This program puts the device into a deep sleep mode to save power. It wakes up only when an external interrupt occurs (like a button press). This is a common low-power design pattern in embedded systems.

Embedded C

#include <avr/sleep.h>
#include <avr/interrupt.h>

volatile int awake = 0;

ISR(INT0_vect) {
    awake = 1; // Set flag when interrupt occurs
}

void disable_unused_peripherals(void) {
    ADCSRA &= ~(1 << ADEN); // Disable ADC
    TIMSK0 = 0; // Disable Timer0 interrupts
}

void enter_low_power_mode(void) {
    disable_unused_peripherals();
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
    sleep_enable();
    sei(); // Enable interrupts
    sleep_cpu();
    sleep_disable();
}

int main(void) {
    // Configure INT0 pin as input with interrupt
    EIMSK |= (1 << INT0); // Enable INT0 interrupt
    EICRA |= (1 << ISC01); // Falling edge triggers INT0

    while (1) {
        if (!awake) {
            enter_low_power_mode();
        } else {
            // Device woke up, do work
            // ...
            awake = 0; // Reset flag
        }
    }
    return 0;
}

Important Notes

Always disable peripherals you don't need before sleeping to save maximum power.

Choose the sleep mode based on how much power you want to save and how fast you need to wake up.

Interrupts are essential to wake the device from low-power modes.

Summary

Low-power design patterns help embedded devices save battery by sleeping when idle.

Disabling unused parts and using sleep modes reduces energy use.

Interrupts wake the device to handle important events without wasting power.