ESP32 offers us deep sleep mode for power saving. Power saving is an important factor for IoT applications and saving power we can make an IoT project running with two AA batteries for a year. Deep Sleep is of the CPUs and most of the RAM and peripherals which are clocked from APB_CLK are powered off. The RTC controller, RTC peripherals and RTC memories are parts of the chip which can kept powered on. So, we must remember that both Wi-Fi and Bluetooth are powered off. However, the chip will store Wi-Fi and Bluetooth connection data in the RTC memory (RTC_DATA_ATTR attribute). If we want to store it into the RTC memory then we will define a global variable like RTC_DATA_ATTR int bootCount = 0;.
Our DOIT ESP32 board (which we commonly use in examples on this website), not energy efficient for deep sleep. However, it works.
ESP32 Deep Sleep is a Complicated Topic, Yet We Tried to Make it Easy Enough to Deploy Deep Sleep in Own Project to Save Battery. ESP32 has different power modes such as Active mode, Modem Sleep mode, Light Sleep mode, Deep Sleep mode and Hibernation mode. These five modes can be found on ESP32 Espressif datasheet. Deep Sleep is to put in sleep and we have different modes to wake it up such as timer wake up, touch wake up, and external wake up. GitHub repository of Espressif provided example codes for these three modes :
---
1 | https://github.com/espressif/arduino-esp32/tree/master/libraries/ESP32/examples/DeepSleep |
Now, let us start to start write code our self. Here we go :
1 2 3 4 | #define uS_TO_S_FACTOR 1000000 #define TIME_TO_SLEEP 5 //Time ESP32 will go to sleep (in seconds) RTC_DATA_ATTR int bootCount = 0; |
#define uS_TO_S_FACTOR is a conversion factor for micro seconds to seconds. #define TIME_TO_SLEEP is the time ESP32 will go to sleep (in seconds). We already explained RTC_DATA_ATTR int bootCount = 0;. This will be our void setup() part :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | #define uS_TO_S_FACTOR 1000000 #define TIME_TO_SLEEP 5 RTC_DATA_ATTR int bootCount = 0; void setup(){ Serial.begin(115200); delay(1000); ++bootCount; Serial.println("Boot number: " + String(bootCount)); print_wakeup_reason(); esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP) + " Seconds"); esp_deep_sleep_start(); } |
++bootCount; is to increment boot number on every reboot. There is nothing more complex than usual in the above code, print_wakeup_reason(); is not what we defined yet, we are starting sleep with esp_deep_sleep_start();.
The total esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); line is for 5 seconds timer, in case you have not understood.
Our complete code will be this :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | #define uS_TO_S_FACTOR 1000000 #define TIME_TO_SLEEP 5 RTC_DATA_ATTR int bootCount = 0; void setup(){ Serial.begin(115200); delay(1000); ++bootCount; Serial.println("Boot number: " + String(bootCount)); print_wakeup_reason(); esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP) + " Seconds"); esp_deep_sleep_start(); } void loop(){} void print_wakeup_reason(){ esp_sleep_wakeup_cause_t wakeup_reason; wakeup_reason = esp_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; } } |
The Espressif GitHub repository has improved version of it :
1 | https://github.com/espressif/arduino-esp32/blob/master/libraries/ESP32/examples/DeepSleep/TimerWakeUp/TimerWakeUp.ino |
So, this is example of timer based Deep Sleep. Next example, we will talk about is ESP32 wake-up external wake-up. We have two types of triggers – ext0 when we want to wake-up the chip by one particular pin only and – ext1 – when we have several pins for the wake-up. Example with ext0 (like one push button) is practical. So it is example of ext0, notice the pushbutton is connected with Pin 33 of ESP32 :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 | #define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex RTC_DATA_ATTR int bootCount = 0; void print_wakeup_reason(){ esp_sleep_wakeup_cause_t wakeup_reason; wakeup_reason = esp_sleep_get_wakeup_cause(); switch(wakeup_reason) { case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break; case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break; case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break; case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break; case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break; default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); 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_wakeup_reason(); esp_sleep_enable_ext0_wakeup(GPIO_NUM_33,1); //1 = High, 0 = Low //If you were to use ext1, you would use it like //esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH); 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 } |
What is GPIOs bitmask? For pin 33, 2^33 is 8589934592. When 8589934592) is converted to hexadecimal, we get that value. We can use 0,2,4,12-15,25-27,32-39 numbered pins for external wakeup.
ESP32 Arduino software has some bug which makes the ESP32 goes to sleep and it won’t wake up again. For that reason, adding a delay of around 500ms after waking up and before reading from the RTC memory required.
I found a nice example of timer deep sleep with 2 LEDs :
1 | http://educ8s.tv/esp32-deep-sleep-tutorial/ |
Which is this :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | #define uS_TO_S_FACTOR 1000000 /* Conversion factor for micro seconds to seconds */ #define TIME_TO_SLEEP 3 /* Time ESP32 will go to sleep (in seconds) */ RTC_DATA_ATTR int bootCount = 0; int GREEN_LED_PIN = 25; int YELLOW_LED_PIN = 26; void setup(){ pinMode(GREEN_LED_PIN,OUTPUT); pinMode(YELLOW_LED_PIN,OUTPUT); delay(500); if(bootCount == 0) //Run this only the first time { digitalWrite(YELLOW_LED_PIN,HIGH); bootCount = bootCount+1; }else { digitalWrite(GREEN_LED_PIN,HIGH); } delay(3000); digitalWrite(GREEN_LED_PIN,LOW); digitalWrite(YELLOW_LED_PIN,LOW); esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); esp_deep_sleep_start(); } void loop(){ } |
For the above example, you are using Pin 25 and Pin 26 to attach two LEDs. This ends this guide. We can use the timer and ext0 example with different sensors like DHT11 for timed or logic directed wake-up.
