I am testing my Sleep Mode sketch using a button that triggers a Pin change interrupt for the sleep mode.
If the button is pressed until the microcontroller goes to sleep, everything works fine -->the microcontroller wakes up after the button is released.
BUT, if the button is released before the microcontroller goes to sleep, the microcontroller won't wake up if the button is pressed again.
Can someone explain me this "behaviour" of the microcontroller?
I am using an Arduino Uno.
//Sleep-Modus
#include <avr/sleep.h>//this AVR library contains the methods that controls the sleep modes
// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 8; // the number of the pushbutton pin
// Variables will change:
int buttonState; // the current reading from the input pin
int lastButtonState = LOW; // the previous reading from the input pin
// the following variables are unsigned long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
unsigned long lastDebounceTime = 0; // the last time the output pin was toggled
unsigned long debounceDelay = 50; // the debounce time; increase if the output flickers
void setup() {
pinMode(2,INPUT_PULLUP);
pinMode(buttonPin, INPUT_PULLUP);
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}
void loop() {
delay(300);
// read the state of the switch into a local variable:
int reading = digitalRead(buttonPin);
// check to see if you just pressed the button
// (i.e. the input went from LOW to HIGH), and you've waited
// long enough since the last press to ignore any noise:
// If the switch changed, due to noise or pressing:
if (reading != lastButtonState) {
// reset the debouncing timer
lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > debounceDelay) {
// whatever the reading is at, it's been there for longer
// than the debounce delay, so take it as the actual current state:
// if the button state has changed:
if (reading != buttonState) {
buttonState = reading;
}
Serial.println("going to sleep");
delay(100);
sleepSetup(); //now we see ~27 mA until pin 2 is connected to GND
}
lastButtonState = reading;
}
void sleepSetup()
{
sleep_enable();
attachInterrupt(0, pinInterrupt, CHANGE);//Set pin 2 as interrupt and attach Interrupt Service Routine (ISR)
set_sleep_mode(SLEEP_MODE_PWR_DOWN);//define power down sleep mode
sleep_cpu();//Set sleep enable (SE) bit, this puts the ATmega to sleep
sleep_disable();//this is important. It is possible that the interrupt is called between executing "attachInterrupt(...)" and sleep_CPU() in the main loop
//if that happens without the sleep_disable() in the ISR, the ISR would be called, the interrupt detached and the device put to sleep.
//since the interrupt would be disabled at that point, there would be no way to wake the device up anymore.
//by putting sleep_disable() in the ISR, sleep_cpu() would not be effective during that loop, i.e. the main loop would run one more time
//and then properly attach the interrupt before hitting the sleep_cpu() a second time. At that point the device would go to sleep, but
//the interrupt would now be activated, i.e. wake-up can be induced.
Serial.println("just woke up!");//When it wakes up due to the interrupt the program continues with the instruction following sleep_cpu()
}
void pinInterrupt()//ISR
{
detachInterrupt(0);//disable the interrupt. This effectively debounces the interrupt mechanism to prevent multiple interrupt calls.
}
