From 1be6a5c361d051f9136a825020005a3e05588ba7 Mon Sep 17 00:00:00 2001 From: Pranav Cherukupalli Date: Thu, 29 Jun 2017 13:01:39 +0530 Subject: [PATCH] ESP32: Add DeepSleep examples (#473) *Added a Timer wakeup example *Added a Touch wakeup example *Added an external source wakeup example --- .../ExternalWakeUp/ExternalWakeUp.ino | 82 ++++++++++++++++ .../DeepSleep/TimerWakeUp/TimerWakeUp.ino | 93 +++++++++++++++++++ .../DeepSleep/TouchWakeUp/TouchWakeUp.ino | 93 +++++++++++++++++++ 3 files changed, 268 insertions(+) create mode 100644 libraries/ESP32/examples/DeepSleep/ExternalWakeUp/ExternalWakeUp.ino create mode 100644 libraries/ESP32/examples/DeepSleep/TimerWakeUp/TimerWakeUp.ino create mode 100644 libraries/ESP32/examples/DeepSleep/TouchWakeUp/TouchWakeUp.ino diff --git a/libraries/ESP32/examples/DeepSleep/ExternalWakeUp/ExternalWakeUp.ino b/libraries/ESP32/examples/DeepSleep/ExternalWakeUp/ExternalWakeUp.ino new file mode 100644 index 00000000..b0bd4f90 --- /dev/null +++ b/libraries/ESP32/examples/DeepSleep/ExternalWakeUp/ExternalWakeUp.ino @@ -0,0 +1,82 @@ +/* +Deep Sleep with External Wake Up +===================================== +This code displays how to use deep sleep with +an external trigger as a wake up source and how +to store data in RTC memory to use it over reboots + +This code is under Public Domain License. + +Hardware Connections +====================== +Push Button to GPIO 33 pulled down with a 10K Ohm +resistor + +NOTE: +====== +Only RTC IO can be used as a source for external wake +source. They are pins: 0,2,4,12-15,25-27,32-39. + +Author: +Pranav Cherukupalli +*/ + +#define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex + +RTC_DATA_ATTR int bootCount = 0; + +/* +Method to print the reason by which ESP32 +has been awaken from sleep +*/ +void print_wakeup_reason(){ + esp_deep_sleep_wakeup_cause_t wakeup_reason; + + wakeup_reason = esp_deep_sleep_get_wakeup_cause(); + + switch(wakeup_reason) + { + case 1 : Serial.println("Wakeup caused by external signal using RTC_IO"); break; + case 2 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break; + case 3 : Serial.println("Wakeup caused by timer"); break; + case 4 : Serial.println("Wakeup caused by touchpad"); break; + case 5 : Serial.println("Wakeup caused by ULP program"); break; + default : Serial.println("Wakeup was not caused by deep sleep"); break; + } +} + +void setup(){ + Serial.begin(115200); + delay(1000); //Take some time to open up the Serial Monitor + + //Increment boot number and print it every reboot + ++bootCount; + Serial.println("Boot number: " + String(bootCount)); + + //Print the wakeup reason for ESP32 + print_wakeup_reason(); + + /* + First we configure the wake up source + We set our ESP32 to wake up for an external trigger. + There are two types for ESP32, ext0 and ext1 . + ext0 uses RTC_IO to wakeup thus requires RTC peripherals + to be on while ext1 uses RTC Controller so doesnt need + peripherals to be powered on. + Note that using internal pullups/pulldowns also requires + RTC peripherals to be turned on. + */ + esp_deep_sleep_enable_ext0_wakeup(GPIO_NUM_33,1); //1 = High, 0 = Low + + //If you were to use ext1, you would use it like + //esp_deep_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH); + + //Go to sleep now + Serial.println("Going to sleep now"); + esp_deep_sleep_start(); + Serial.println("This will never be printed"); +} + +void loop(){ + //This is not going to be called +} diff --git a/libraries/ESP32/examples/DeepSleep/TimerWakeUp/TimerWakeUp.ino b/libraries/ESP32/examples/DeepSleep/TimerWakeUp/TimerWakeUp.ino new file mode 100644 index 00000000..b6b6e080 --- /dev/null +++ b/libraries/ESP32/examples/DeepSleep/TimerWakeUp/TimerWakeUp.ino @@ -0,0 +1,93 @@ +/* +Simple Deep Sleep with Timer Wake Up +===================================== +ESP32 offers a deep sleep mode for effective power +saving as power is an important factor for IoT +applications. In this mode CPUs, most of the RAM, +and all the digital peripherals which are clocked +from APB_CLK are powered off. The only parts of +the chip which can still be powered on are: +RTC controller, RTC peripherals ,and RTC memories + +This code displays the most basic deep sleep with +a timer to wake it up and how to store data in +RTC memory to use it over reboots + +This code is under Public Domain License. + +Author: +Pranav Cherukupalli +*/ + +#define uS_TO_S_FACTOR 1000000 /* Conversion factor for micro seconds to seconds */ +#define TIME_TO_SLEEP 5 /* Time ESP32 will go to sleep (in seconds) */ + +RTC_DATA_ATTR int bootCount = 0; + +/* +Method to print the reason by which ESP32 +has been awaken from sleep +*/ +void print_wakeup_reason(){ + esp_deep_sleep_wakeup_cause_t wakeup_reason; + + wakeup_reason = esp_deep_sleep_get_wakeup_cause(); + + switch(wakeup_reason) + { + case 1 : Serial.println("Wakeup caused by external signal using RTC_IO"); break; + case 2 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break; + case 3 : Serial.println("Wakeup caused by timer"); break; + case 4 : Serial.println("Wakeup caused by touchpad"); break; + case 5 : Serial.println("Wakeup caused by ULP program"); break; + default : Serial.println("Wakeup was not caused by deep sleep"); break; + } +} + +void setup(){ + Serial.begin(115200); + delay(1000); //Take some time to open up the Serial Monitor + + //Increment boot number and print it every reboot + ++bootCount; + Serial.println("Boot number: " + String(bootCount)); + + //Print the wakeup reason for ESP32 + print_wakeup_reason(); + + /* + First we configure the wake up source + We set our ESP32 to wake up every 5 seconds + */ + esp_deep_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); + Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP) + + " Seconds"); + + /* + Next we decide what all peripherals to shut down/keep on + By default, ESP32 will automatically power down the peripherals + not needed by the wakeup source, but if you want to be a poweruser + this is for you. Read in detail at the API docs + http://esp-idf.readthedocs.io/en/latest/api-reference/system/deep_sleep.html + Left the line commented as an example of how to configure peripherals. + The line below turns off all RTC peripherals in deep sleep. + */ + //esp_deep_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF); + //Serial.println("Configured all RTC Peripherals to be powered down in sleep"); + + /* + Now that we have setup a wake cause and if needed setup the + peripherals state in deep sleep, we can now start going to + deep sleep. + In the case that no wake up sources were provided but deep + sleep was started, it will sleep forever unless hardware + reset occurs. + */ + Serial.println("Going to sleep now"); + esp_deep_sleep_start(); + Serial.println("This will never be printed"); +} + +void loop(){ + //This is not going to be called +} diff --git a/libraries/ESP32/examples/DeepSleep/TouchWakeUp/TouchWakeUp.ino b/libraries/ESP32/examples/DeepSleep/TouchWakeUp/TouchWakeUp.ino new file mode 100644 index 00000000..5e79f623 --- /dev/null +++ b/libraries/ESP32/examples/DeepSleep/TouchWakeUp/TouchWakeUp.ino @@ -0,0 +1,93 @@ +/* +Deep Sleep with Touch Wake Up +===================================== +This code displays how to use deep sleep with +a touch as a wake up source and how to store data in +RTC memory to use it over reboots + +This code is under Public Domain License. + +Author: +Pranav Cherukupalli +*/ + +#define Threshold 40 /* Greater the value, more the sensitivity */ + +RTC_DATA_ATTR int bootCount = 0; +touch_pad_t touchPin; +/* +Method to print the reason by which ESP32 +has been awaken from sleep +*/ +void print_wakeup_reason(){ + esp_deep_sleep_wakeup_cause_t wakeup_reason; + + wakeup_reason = esp_deep_sleep_get_wakeup_cause(); + + switch(wakeup_reason) + { + case 1 : Serial.println("Wakeup caused by external signal using RTC_IO"); break; + case 2 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break; + case 3 : Serial.println("Wakeup caused by timer"); break; + case 4 : Serial.println("Wakeup caused by touchpad"); break; + case 5 : Serial.println("Wakeup caused by ULP program"); break; + default : Serial.println("Wakeup was not caused by deep sleep"); break; + } +} + +/* +Method to print the touchpad by which ESP32 +has been awaken from sleep +*/ +void print_wakeup_touchpad(){ + touch_pad_t pin; + + touchPin = esp_deep_sleep_get_touchpad_wakeup_status(); + + switch(touchPin) + { + case 0 : Serial.println("Touch detected on GPIO 4"); break; + case 1 : Serial.println("Touch detected on GPIO 0"); break; + case 2 : Serial.println("Touch detected on GPIO 2"); break; + case 3 : Serial.println("Touch detected on GPIO 15"); break; + case 4 : Serial.println("Touch detected on GPIO 13"); break; + case 5 : Serial.println("Touch detected on GPIO 12"); break; + case 6 : Serial.println("Touch detected on GPIO 14"); break; + case 7 : Serial.println("Touch detected on GPIO 27"); break; + case 8 : Serial.println("Touch detected on GPIO 33"); break; + case 9 : Serial.println("Touch detected on GPIO 32"); break; + default : Serial.println("Wakeup not by touchpad"); break; + } +} + +void callback(){ + //placeholder callback function +} + +void setup(){ + Serial.begin(115200); + delay(1000); //Take some time to open up the Serial Monitor + + //Increment boot number and print it every reboot + ++bootCount; + Serial.println("Boot number: " + String(bootCount)); + + //Print the wakeup reason for ESP32 and touchpad too + print_wakeup_reason(); + print_wakeup_touchpad(); + + //Setup interrupt on Touch Pad 3 (GPIO15) + touchAttachInterrupt(T3, callback, Threshold); + + //Configure Touchpad as wakeup source + esp_deep_sleep_enable_touchpad_wakeup(); + + //Go to sleep now + Serial.println("Going to sleep now"); + esp_deep_sleep_start(); + Serial.println("This will never be printed"); +} + +void loop(){ + //This will never be reached +}