Wake-up from sleep with interrupt in Arduino - Deep Dive

Overview - Wake-up from sleep with interrupt

What is it?

Wake-up from sleep with interrupt means putting an Arduino into a low-power sleep mode and using an external event, like a button press or sensor signal, to wake it up. The interrupt is a special signal that tells the Arduino to stop sleeping and start running code again. This helps save battery power when the Arduino doesn't need to do anything until something important happens.

Why it matters

Without this, the Arduino would have to stay awake all the time, using more power and draining batteries faster. Using interrupts to wake up means devices can run longer on small batteries and respond quickly to events without wasting energy. This is important for projects like remote sensors, wearable devices, or anything that needs to save power but still react instantly.

Where it fits

Before learning this, you should understand basic Arduino programming, how to use digital inputs and outputs, and what interrupts are. After this, you can learn about advanced power management, different sleep modes, and combining multiple interrupts or timers for complex projects.

Mental Model

Core Idea

Sleep mode pauses the Arduino to save power, and an interrupt acts like a doorbell that wakes it up instantly when something important happens.

Think of it like...

Imagine the Arduino is like a person taking a nap to save energy. The interrupt is like a phone ringing that wakes the person up immediately to answer it.

┌───────────────┐       Interrupt Signal       ┌───────────────┐
│   Arduino     │────────────────────────────▶│   Awake Mode  │
│   Sleeping    │                            │   Running Code │
└───────────────┘                            └───────────────┘
        ▲                                            │
        │                                            │
        └────────────── Sleep Mode ────────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding Arduino Sleep Modes

Concept: Introduce what sleep modes are and why they save power.

Arduino can enter different sleep modes where it uses less electricity by turning off parts of itself. The simplest is idle mode, and the deepest is power-down mode. In sleep, the Arduino stops running normal code until something wakes it up.

Result

Arduino uses less power and pauses its program until woken.

Knowing sleep modes is key to saving battery life in projects that don't need to run all the time.

2

Foundation

Basics of Interrupts on Arduino

Concept: Explain what interrupts are and how they work.

An interrupt is a signal that tells the Arduino to stop what it's doing and run a special function immediately. This can come from a pin changing state, a timer, or other sources. Interrupts let the Arduino react quickly to events.

Result

Arduino can respond instantly to external signals.

Understanding interrupts is essential to waking the Arduino from sleep without delay.

3

Intermediate

Configuring External Interrupts for Wake-up

🤔Before reading on: do you think any pin can be used to wake the Arduino from sleep, or only specific pins? Commit to your answer.

Concept: Learn which pins support interrupts and how to set them up for wake-up.

Not all Arduino pins can trigger interrupts. Usually, pins 2 and 3 on an Uno support external interrupts. You set up the interrupt to watch for a signal change (like LOW to HIGH) and link it to a function that runs when triggered.

Result

Arduino wakes up when the chosen pin changes state.

Knowing which pins can trigger interrupts prevents confusion and hardware mistakes.

4

Intermediate

Putting Arduino to Sleep and Enabling Interrupts

🤔Before reading on: do you think the Arduino wakes up automatically after sleep time ends, or only when an interrupt occurs? Commit to your answer.

Concept: Combine sleep mode with interrupt setup to enable wake-up.

You write code to put the Arduino into sleep mode and enable the interrupt before sleeping. When the interrupt signal happens, the Arduino wakes up and continues running code after the sleep command.

Result

Arduino sleeps until the interrupt wakes it.

Combining sleep and interrupts is the core technique for power-efficient event-driven programs.

5

Advanced

Debouncing Interrupts to Avoid False Wake-ups

🤔Before reading on: do you think a noisy button press can cause multiple wake-ups or just one? Commit to your answer.

Concept: Learn how to handle noisy signals that cause multiple interrupts.

Physical buttons can cause rapid on/off signals called bouncing. This can trigger many interrupts quickly, waking the Arduino multiple times. To fix this, you add a small delay or check the signal state carefully to ignore extra triggers.

Result

Arduino wakes up only once per button press.

Handling signal noise prevents wasted power and unpredictable behavior.

6

Expert

Using ISR and Sleep Modes Together Safely

🤔Before reading on: do you think you can run complex code inside an interrupt service routine (ISR), or should it be very short? Commit to your answer.

Concept: Understand best practices for writing interrupt code and sleep interaction.

Interrupt Service Routines (ISRs) should be very short and fast because they pause the main program. Complex code or functions like Serial.print inside ISRs can cause errors. Also, after waking, the Arduino resumes where it left off, so careful design is needed to avoid bugs.

Result

Stable, efficient wake-up behavior without crashes or delays.

Knowing ISR limits avoids common bugs and ensures reliable wake-up handling.

Under the Hood

When the Arduino enters sleep mode, its CPU clock is stopped or slowed, and many internal modules are powered down to save energy. The microcontroller hardware monitors interrupt pins independently. When an interrupt signal occurs, the hardware immediately wakes the CPU, saves the current state, and runs the interrupt service routine. After the ISR finishes, the CPU resumes normal operation from where it paused.

Why designed this way?

This design balances power saving with responsiveness. By allowing hardware interrupts to wake the CPU, the Arduino can stay in very low power states without missing important events. Alternatives like polling would waste power and be slower to respond. The interrupt-driven wake-up is a standard embedded systems approach for efficient event handling.

┌───────────────┐
│   CPU Clock   │───┐
│   Stopped     │   │
└───────────────┘   │
                    ▼
┌───────────────┐  Interrupt Signal
│ Interrupt     │─────────────────────┐
│ Hardware      │                     │
└───────────────┘                     │
        │                             │
        ▼                             │
┌───────────────┐                    │
│ Wake CPU      │◀───────────────────┘
│ Run ISR       │
└───────────────┘
        │
        ▼
┌───────────────┐
│ Resume Normal │
│ Execution     │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: do you think any Arduino pin can be used to wake from sleep with an interrupt? Commit to yes or no.

Common Belief: I can use any digital pin to wake the Arduino from sleep with an interrupt.

Reality: Only specific pins support external interrupts that can wake the Arduino, usually pins 2 and 3 on an Uno.

Why it matters: Trying to use unsupported pins leads to the Arduino never waking up, causing confusion and wasted debugging time.

Quick: do you think the Arduino runs the main code while sleeping? Commit to yes or no.

Common Belief: The Arduino continues running code normally while in sleep mode.

Reality: In sleep mode, the Arduino pauses the main program and only wakes to run code when an interrupt occurs.

Why it matters: Expecting code to run during sleep causes bugs where nothing happens until wake-up.

Quick: do you think you can put long code inside an interrupt service routine? Commit to yes or no.

Common Belief: It's fine to run complex or slow code inside an interrupt service routine (ISR).

Reality: ISRs must be very short and fast; long code can cause crashes or missed interrupts.

Why it matters: Misusing ISRs leads to unstable programs and hard-to-find bugs.

Quick: do you think a noisy button press causes only one interrupt? Commit to yes or no.

Common Belief: A single button press triggers only one interrupt wake-up.

Reality: Physical buttons often cause multiple rapid interrupts due to bouncing, requiring debouncing techniques.

Why it matters: Ignoring bouncing wastes power and causes erratic behavior.

Expert Zone

1

Some Arduino boards support pin change interrupts on many pins, but these behave differently and require different handling than external interrupts.

2

Sleep modes vary in depth and what peripherals remain active; choosing the right mode balances power saving and wake-up sources.

3

Using volatile variables and disabling interrupts carefully is crucial to avoid race conditions between ISRs and main code.

When NOT to use

Wake-up with interrupts is not suitable when precise timing or multiple simultaneous events must be handled; in such cases, using timers or real-time operating systems (RTOS) is better.

Production Patterns

In real devices, wake-up interrupts are combined with debouncing hardware, watchdog timers, and state machines to create robust, low-power event-driven systems.

Connections

Event-driven programming

Wake-up interrupts are a hardware-level example of event-driven programming where code runs in response to events.

Understanding interrupts helps grasp how event-driven software frameworks react to user actions or sensor inputs.

Power management in mobile devices

Wake-up interrupts are a fundamental technique used in smartphones and wearables to save battery life.

Knowing Arduino wake-up interrupts reveals the basic principle behind how complex devices conserve energy.

Human reflexes in biology

Interrupt-driven wake-up is like a reflex where the body reacts instantly to stimuli without conscious thought.

Seeing interrupts as biological reflexes helps appreciate their speed and efficiency in embedded systems.

Common Pitfalls

#1 Using a non-interrupt pin to wake the Arduino.

Wrong approach:

attachInterrupt(digitalPinToInterrupt(5), wakeUp, RISING); // Pin 5 is not interrupt-capable on Uno

Correct approach:

attachInterrupt(digitalPinToInterrupt(2), wakeUp, RISING); // Use pin 2 which supports interrupts

Root cause:

Misunderstanding which pins support hardware interrupts on the Arduino board.

#2 Running long code inside the interrupt service routine.

Wrong approach:

void wakeUp() { Serial.println("Woke up!"); delay(1000); }

Correct approach:

volatile bool woke = false;
void wakeUp() { woke = true; } // ISR only sets a flag
// Main code handles printing and delay

Root cause:

Not knowing ISRs must be short and avoid functions like Serial.print or delay.

#3 Not debouncing a button causing multiple wake-ups.

Wrong approach:

attachInterrupt(digitalPinToInterrupt(2), wakeUp, CHANGE); // No debounce logic

Correct approach:

Use a debounce method like checking millis() or hardware debounce circuit before accepting wake-up.

Root cause:

Ignoring physical signal noise and bouncing in mechanical switches.

Key Takeaways

Sleep mode lets the Arduino save power by pausing its work until something important happens.

Interrupts are special signals that can wake the Arduino instantly from sleep to handle events.

Only certain pins support interrupts that can wake the Arduino, so choosing the right pin is crucial.

Interrupt service routines must be short and fast to keep the program stable and responsive.

Debouncing is necessary to avoid multiple wake-ups from noisy signals like button presses.

Practice

1. What is the main purpose of using an interrupt to wake an Arduino from sleep mode?

easy

A. To allow the Arduino to respond immediately to an external event while saving power

B. To make the Arduino run faster during normal operation

C. To reset the Arduino automatically after a delay

D. To increase the Arduino's memory capacity

Solution

1. Step 1: Understand sleep mode purpose

   Arduino sleep mode reduces power consumption by stopping most activities.

2. Step 2: Role of interrupts in sleep mode

   Interrupts allow the Arduino to wake up immediately when an external event occurs, saving power while staying responsive.

3. Final Answer:

   To allow the Arduino to respond immediately to an external event while saving power -> Option A

4. Quick Check:

   Interrupt wakes Arduino from sleep to save power [OK]

Hint: Interrupts wake Arduino instantly during sleep to save power [OK]

Common Mistakes:

• Thinking interrupts speed up normal running
• Confusing interrupts with reset functions
• Believing interrupts increase memory

2. Which of the following is the correct way to attach an interrupt to pin 2 that triggers on a RISING signal?

easy

A. attachInterrupt(2, ISR, FALLING);

B. attachInterrupt(digitalPinToInterrupt(2), ISR, RISING);

C. attachInterrupt(digitalPinToInterrupt(3), ISR, CHANGE);

D. attachInterrupt(2, ISR, LOW);

Solution

1. Step 1: Use digitalPinToInterrupt() for pin mapping

   Pin 2 must be converted using digitalPinToInterrupt(2) for portability.

2. Step 2: Set correct trigger mode

   RISING triggers interrupt when signal goes from LOW to HIGH.

3. Final Answer:

   attachInterrupt(digitalPinToInterrupt(2), ISR, RISING); -> Option B

4. Quick Check:

   Correct pin and RISING trigger = attachInterrupt(digitalPinToInterrupt(2), ISR, RISING); [OK]

Hint: Always use digitalPinToInterrupt(pin) with correct trigger [OK]

Common Mistakes:

• Using pin number directly without digitalPinToInterrupt()
• Choosing wrong trigger mode like FALLING or LOW
• Attaching interrupt to wrong pin number

3. What will be the output on the serial monitor after running this code if a button connected to pin 2 is pressed once?

void ISR() {
  Serial.println("Woke up!");
}

void setup() {
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(2), ISR, RISING);
  sleep_enable();
  sleep_mode();
  Serial.println("Sleeping...");
}

void loop() {
  // Empty loop
}

medium

A. No output at all

B. Woke up!\nSleeping...

C. Sleeping... (no further output)

D. Sleeping...\nWoke up!

Solution

1. Step 1: Analyze print locations

   "Sleeping..." prints after sleep_mode(), so it executes after waking up.

2. Step 2: ISR execution order

   ISR prints "Woke up!" immediately upon interrupt, before resuming code after sleep_mode().

3. Final Answer:

   Sleeping...\nWoke up! -> Option D

4. Quick Check:

   Code after sleep_mode() runs after ISR, so output order is Sleeping... then Woke up! [OK]

Hint: ISR runs immediately on interrupt, but code after sleep_mode() runs after ISR [OK]

Common Mistakes:

• Thinking "Sleeping..." prints before sleep
• Believing no output after wake
• Expecting Sleeping... before ISR

4. Identify the error in this code snippet that tries to wake Arduino from sleep on pin 3 interrupt:

void ISR() {
  // Empty ISR
}

void setup() {
  attachInterrupt(3, ISR, FALLING);
  sleep_enable();
  sleep_mode();
}

void loop() {
  // Empty
}

medium

A. attachInterrupt() uses pin number directly instead of digitalPinToInterrupt()

B. ISR function should not be empty

C. sleep_mode() should be called inside loop()

D. sleep_enable() must be called after sleep_mode()

Solution

1. Step 1: Check attachInterrupt() usage

   Pin number must be converted with digitalPinToInterrupt(pin) for correct interrupt mapping.

2. Step 2: Validate other parts

   Empty ISR is allowed; sleep_mode() can be in setup; sleep_enable() must be before sleep_mode().

3. Final Answer:

   attachInterrupt() uses pin number directly instead of digitalPinToInterrupt() -> Option A

4. Quick Check:

   Pin mapping requires digitalPinToInterrupt() [OK]

Hint: Always convert pin with digitalPinToInterrupt() in attachInterrupt() [OK]

Common Mistakes:

• Not using digitalPinToInterrupt() for pin mapping
• Thinking ISR must have code
• Misplacing sleep_enable() call

5. You want to put your Arduino to sleep and wake it up only when a button connected to pin 4 is pressed. Which sequence correctly implements this behavior?

hard

A. attachInterrupt(digitalPinToInterrupt(4), wakeISR, LOW); sleep_enable(); sleep_mode();

B. attachInterrupt(4, wakeISR, RISING); sleep_disable(); sleep_mode();

C. attachInterrupt(digitalPinToInterrupt(4), wakeISR, FALLING); sleep_enable(); sleep_mode();

D. attachInterrupt(digitalPinToInterrupt(4), wakeISR, CHANGE); sleep_enable(); sleep_disable();

Solution

1. Step 1: Attach interrupt correctly

   Use digitalPinToInterrupt(4) and FALLING trigger for button press (assuming active LOW button).

2. Step 2: Enable sleep and enter sleep mode

   Call sleep_enable() before sleep_mode() to allow waking on interrupt.

3. Final Answer:

   attachInterrupt(digitalPinToInterrupt(4), wakeISR, FALLING); sleep_enable(); sleep_mode(); -> Option C

4. Quick Check:

   Correct pin, trigger, and sleep calls = attachInterrupt(digitalPinToInterrupt(4), wakeISR, FALLING); sleep_enable(); sleep_mode(); [OK]

Hint: Use digitalPinToInterrupt() with sleep_enable() before sleep_mode() [OK]

Common Mistakes:

• Using sleep_disable() before sleep_mode()
• Wrong trigger mode like LOW or CHANGE for button press
• Not enabling sleep before entering sleep_mode()