Wake-up from sleep with interrupt in Arduino - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to put the Arduino into sleep mode.

Arduino

void setup() {
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), wakeUp, [1]);
}

void loop() {
  sleep_enable();
  sleep_cpu();
  sleep_disable();
}

void wakeUp() {
  // This function will be called when interrupt occurs
}

Drag options to blanks, or click blank then click option'

AFALLING

BRISING

CCHANGE

DLOW

Attempts:

3 left

💡 Hint

Common Mistakes

Using RISING instead of FALLING causes the interrupt not to trigger on button press.

Not using digitalPinToInterrupt() for the pin number.

The interrupt is set to trigger on the FALLING edge, which means when the button connected to pin 2 is pressed (goes from HIGH to LOW).

2fill in blank

medium

Complete the code to enable sleep mode using the correct sleep mode constant.

Arduino

#include <avr/sleep.h>

void setup() {
  set_sleep_mode([1]);
}

void loop() {
  sleep_enable();
  sleep_cpu();
  sleep_disable();
}

Drag options to blanks, or click blank then click option'

ASLEEP_MODE_IDLE

BSLEEP_MODE_PWR_DOWN

CSLEEP_MODE_ADC

DSLEEP_MODE_STANDBY

Attempts:

3 left

💡 Hint

Common Mistakes

Using SLEEP_MODE_IDLE which does not save much power.

Forgetting to include .

SLEEP_MODE_PWR_DOWN is the deepest sleep mode that turns off most of the Arduino's functions to save power.

3fill in blank

hard

Fix the error in the interrupt service routine to correctly wake the Arduino from sleep.

Arduino

void wakeUp() {
  [1]();
}

Drag options to blanks, or click blank then click option'

Asleep_cpu

Bsleep_enable

Csleep_disable

DattachInterrupt

Attempts:

3 left

💡 Hint

Common Mistakes

Calling sleep_enable() inside the ISR causes the Arduino to stay asleep.

Calling attachInterrupt() inside the ISR is incorrect.

The wakeUp function should disable sleep mode by calling sleep_disable() to resume normal operation.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps pin numbers to their sleep modes if the pin number is greater than 3.

Arduino

const int pins[] = {2, 3, 4, 5};
std::map<int, int> pinSleepModes = [1];

// Example: pinSleepModes = {4: SLEEP_MODE_PWR_DOWN, 5: SLEEP_MODE_IDLE}

// Fill the blanks below

for (int pin : pins) {
  if (pin [2] 3) {
    pinSleepModes[pin] = SLEEP_MODE_PWR_DOWN;
  }
}

Drag options to blanks, or click blank then click option'

Astd::map<int, int>()

B>

C<

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect comparison operators like '<' or '=='.

Not initializing the map before using it.

We initialize an empty map with std::map() and check if pin is greater than 3 to add it to the map.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps pin names to their sleep modes only if the mode is SLEEP_MODE_PWR_DOWN.

Arduino

std::map<std::string, int> pinModes = {
  {"pin2", SLEEP_MODE_IDLE},
  {"pin3", SLEEP_MODE_PWR_DOWN},
  {"pin4", SLEEP_MODE_PWR_DOWN}
};

std::map<std::string, int> filteredModes = {
  [1]: [2] for (const auto& [[3], mode] : pinModes) if (mode == SLEEP_MODE_PWR_DOWN)
};

Drag options to blanks, or click blank then click option'

Apin

Bmode

Ckey

Dfirst

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent variable names that don't match the loop unpacking.

Not filtering by the correct sleep mode.

We use 'key' as the variable for the pin name and 'mode' for the sleep mode. The comprehension maps key to mode for modes equal to SLEEP_MODE_PWR_DOWN.

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()