当您的IoT项目由电源适配器供电时，您不会太关心功耗。但是，如果您要使用电池为项目供电，则需要计算每个MA电流。

ESP32可能是相对功耗较高的设备，具体取决于其处于哪种状态。通常，在通过WiFi传输数据时240mA左右，它的正常操作时约75mA。

这里的解决方案是通过利用深度睡眠模式来降低ESP32的功耗。

ESP32深度睡眠

在深度睡眠模式下，CPU、大多数RAM和所有数字外围设备都可以关闭。芯片唯一保持运行的部分是：

●   ULP协处理器

●   RTC控制器

●   RTC外围设备

●   RTC内存

芯片将消耗约0.15 mA（如果ULP协处理器打开）至10µA。

在深度睡眠模式下，主CPU被关闭，而ULP协处理器可以采用传感器读数，并在必要时唤醒CPU。这种睡眠模式称为ULP传感器监控模式。这对于设计应用程序需要由外部事件或计时器或两者组合唤醒的应用程序很有用，同时保持最少的功耗。

与CPU一起，芯片的主要内存也被禁用。因此，存储在该内存中的所有内容都被删除且无法访问。

由于RTC存储持续供电，因此即使在深度睡眠期间也保留了其内容，并且可以在芯片唤醒后检索。这就是为什么芯片在进入深度睡眠之前将Wi-Fi和蓝牙连接数据存储在RTC内存中的原因。

如果要在重新启动后使用数据，请通过使用RTC_DATA_ATTR属性来定义全局变量，将其存储在RTC内存中。例如，RTC_DATA_ATTR int myVar = 0。

从深度睡眠中出来后，芯片通过复位重新启动，并从一开始就开始执行程序。

与其他睡眠模式不同，系统无法自动进入深度睡眠模式。 esp_deep_sleep_start()函数用于配置唤醒源后立即进入深度睡眠。

ESP32深度睡眠唤醒源

ESP32可以使用多个源从深度睡眠模式唤醒。这些源是：

●   定时器

●   触摸引脚

●   外部唤醒（Ext0＆Ext1）

可以组合多个唤醒源，当触发其中一个源时，芯片将被唤醒。

ESP32唤醒源：定时器

ESP32 RTC控制器具有一个内置定时器，您可以在预定义的时间后用来唤醒ESP32。

此功能在需要时间戳或日常任务的同时保持低功耗的项目中特别有用。

esp_sleep_enable_timer_wakeup(time_in_us)函数用于将计时器配置为唤醒源。

示例代码

让我们使用库中的示例来看看它的工作原理。打开您的Arduino IDE，然后导航到File > Examples > ESP32 > Deep Sleep，然后打开TimerWakeup草图。

该草图演示了最基本的深度睡眠示例，其中定时器是唤醒源，以及如何将数据存储在RTC内存中以在复位后使用它。

1. #define uS_TO_S_FACTOR 1000000ULL  /* Conversion factor for micro seconds to seconds */
   
2. #define TIME_TO_SLEEP  5        /* Time ESP32 will go to sleep (in seconds) */
   
3. 
   
4. RTC_DATA_ATTR int bootCount = 0;
   
5. 
   
6. /*
   
7. Method to print the reason by which ESP32
   
8. has been awaken from sleep
   
9. */
   
10. void print_wakeup_reason(){
    
11.   esp_sleep_wakeup_cause_t wakeup_reason;
    
12. 
    
13.   wakeup_reason = esp_sleep_get_wakeup_cause();
    
14. 
    
15.   switch(wakeup_reason)
    
16.   {
    
17.     case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
    
18.     case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
    
19.     case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
    
20.     case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
    
21.     case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
    
22.     default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
    
23.   }
    
24. }
    
25. 
    
26. void setup(){
    
27.   Serial.begin(115200);
    
28.   delay(1000); //Take some time to open up the Serial Monitor
    
29. 
    
30.   //Increment boot number and print it every reboot
    
31.   ++bootCount;
    
32.   Serial.println("Boot number: " + String(bootCount));
    
33. 
    
34.   //Print the wakeup reason for ESP32
    
35.   print_wakeup_reason();
    
36. 
    
37.   /*
    
38.   First we configure the wake up source
    
39.   We set our ESP32 to wake up every 5 seconds
    
40.   */
    
41.   esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
    
42.   Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP) +
    
43.   " Seconds");
    
44. 
    
45.   /*
    
46.   Next we decide what all peripherals to shut down/keep on
    
47.   By default, ESP32 will automatically power down the peripherals
    
48.   not needed by the wakeup source, but if you want to be a poweruser
    
49.   this is for you. Read in detail at the API docs
    
50.   http://esp-idf.readthedocs.io/en/latest/api-reference/system/deep_sleep.html
    
51.   Left the line commented as an example of how to configure peripherals.
    
52.   The line below turns off all RTC peripherals in deep sleep.
    
53.   */
    
54.   //esp_deep_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
    
55.   //Serial.println("Configured all RTC Peripherals to be powered down in sleep");
    
56. 
    
57.   /*
    
58.   Now that we have setup a wake cause and if needed setup the
    
59.   peripherals state in deep sleep, we can now start going to
    
60.   deep sleep.
    
61.   In the case that no wake up sources were provided but deep
    
62.   sleep was started, it will sleep forever unless hardware
    
63.   reset occurs.
    
64.   */
    
65.   Serial.println("Going to sleep now");
    
66.   Serial.flush();
    
67.   esp_deep_sleep_start();
    
68.   Serial.println("This will never be printed");
    
69. }
    
70. 
    
71. void loop(){
    
72.   //This is not going to be called
    
73. }

复制代码

上传草图后，打开串口显示器，将波特率设置为115200 bps。

ESP32每5秒醒来一次，打印出唤醒原因并在串口显示器上启动，然后再次入睡。

现在，按下EN按钮复位ESP32，它应该再次将启动器重置为1，以表明RTC内存已完全擦除。

代码说明

前两行代码定义了ESP32入睡的时间。

此示例使用从微秒到秒的转换系数，因此您可以在time_to_sleep变量中以秒为单位设置睡眠时间。在这里，ESP32进入深度睡眠模式5秒钟。

1. #define uS_TO_S_FACTOR 1000000ULL  /* Conversion factor for micro seconds to seconds */
   
2. #define TIME_TO_SLEEP  5        /* Time ESP32 will go to sleep (in seconds) */

复制代码

如前所述，您可以将数据保存在ESP32的RTC内存（8KB SRAM）中，该内存在深度睡眠期间未删除。但是，当ESP32复位时，它将被删除。

要将数据保存在RTC内存上，您只需要在定义变量之前添加RTC_DATA_ATTR 属性即可。在此示例中，bootCount变量保存在RTC内存中。它将计算ESP32从深度睡眠中醒来的次数。

1. RTC_DATA_ATTR int bootCount = 0;

复制代码

接下来，定义了print_wakeup_reason()函数，该函数打印出ESP32从深度睡眠中唤醒的原因。

1. void print_wakeup_reason(){
   
2.   esp_sleep_wakeup_cause_t wakeup_reason;
   
3. 
   
4.   wakeup_reason = esp_sleep_get_wakeup_cause();
   
5. 
   
6.   switch(wakeup_reason)
   
7.   {
   
8.     case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
   
9.     case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
   
10.     case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
    
11.     case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
    
12.     case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
    
13.     default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
    
14.   }
    
15. }

复制代码

在setup()函数中，我们首先将串口通信初始化。

1. Serial.begin(115200);
   

复制代码

然后将bootCount变量加1，然后打印到串口显示器上，以显示ESP32从深度睡眠中醒来的次数。

1. ++bootCount;
   
2. Serial.println("Boot number: " + String(bootCount));

复制代码

然后调用print_wakeup_reason()函数，但是您也可以调用要执行所需任务的任何函数，例如，读取传感器的值。

1. print_wakeup_reason();
   

复制代码

接下来，我们使用esp_sleep_enable_timer_wakeup(time_in_us)函数配置定时器唤醒源。在这里，ESP32将每5秒醒来一次。

1. esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);

复制代码

最后，通过调用esp_deep_sleep_start()函数来使ESP32进入睡眠模式。

1. esp_deep_sleep_start();
   

复制代码

在此草图中，ESP32在setup()函数本身中进入深度睡眠，因此它永远不会达到loop()函数。因此，loop()函数是空的。

1. void loop(){
   
2.   //This is not going to be called
   
3. }

复制代码

ESP32唤醒源：触摸引脚

您可以使用以下触摸引脚从深度睡眠中唤醒ESP32。

使用触摸引脚唤醒ESP32很简单。在Arduino IDE中，您只需要使用esp_sleep_enable_touchpad_wakeup()函数。

硬件连接

让我们将线缆连接到GPIO＃15（触摸＃3），该线缆将充当触摸唤醒源。 您可以将任何导电物体连接到电线、铝箔、导电布、导电涂料等，并将其转换为触摸面板。

示例代码

让我们使用库中的示例来看看它的工作原理。 打开您的Arduino IDE，然后导航到File > Examples > ESP32 > Deep Sleep，然后打开TouchWakeup草图。

该草图演示了最基本的深度睡眠示例，触摸作为唤醒源以及如何将数据存储在RTC内存中以在重新启动后使用它。

1. #define Threshold 40 /* Greater the value, more the sensitivity */
   
2. 
   
3. RTC_DATA_ATTR int bootCount = 0;
   
4. touch_pad_t touchPin;
   
5. /*
   
6. Method to print the reason by which ESP32
   
7. has been awaken from sleep
   
8. */
   
9. void print_wakeup_reason(){
   
10.   esp_sleep_wakeup_cause_t wakeup_reason;
    
11. 
    
12.   wakeup_reason = esp_sleep_get_wakeup_cause();
    
13. 
    
14.   switch(wakeup_reason)
    
15.   {
    
16.     case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
    
17.     case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
    
18.     case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
    
19.     case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
    
20.     case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
    
21.     default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
    
22.   }
    
23. }
    
24. 
    
25. /*
    
26. Method to print the touchpad by which ESP32
    
27. has been awaken from sleep
    
28. */
    
29. void print_wakeup_touchpad(){
    
30.   touchPin = esp_sleep_get_touchpad_wakeup_status();
    
31. 
    
32.   switch(touchPin)
    
33.   {
    
34.     case 0  : Serial.println("Touch detected on GPIO 4"); break;
    
35.     case 1  : Serial.println("Touch detected on GPIO 0"); break;
    
36.     case 2  : Serial.println("Touch detected on GPIO 2"); break;
    
37.     case 3  : Serial.println("Touch detected on GPIO 15"); break;
    
38.     case 4  : Serial.println("Touch detected on GPIO 13"); break;
    
39.     case 5  : Serial.println("Touch detected on GPIO 12"); break;
    
40.     case 6  : Serial.println("Touch detected on GPIO 14"); break;
    
41.     case 7  : Serial.println("Touch detected on GPIO 27"); break;
    
42.     case 8  : Serial.println("Touch detected on GPIO 33"); break;
    
43.     case 9  : Serial.println("Touch detected on GPIO 32"); break;
    
44.     default : Serial.println("Wakeup not by touchpad"); break;
    
45.   }
    
46. }
    
47. 
    
48. void callback(){
    
49.   //placeholder callback function
    
50. }
    
51. 
    
52. void setup(){
    
53.   Serial.begin(115200);
    
54.   delay(1000); //Take some time to open up the Serial Monitor
    
55. 
    
56.   //Increment boot number and print it every reboot
    
57.   ++bootCount;
    
58.   Serial.println("Boot number: " + String(bootCount));
    
59. 
    
60.   //Print the wakeup reason for ESP32 and touchpad too
    
61.   print_wakeup_reason();
    
62.   print_wakeup_touchpad();
    
63. 
    
64.   //Setup interrupt on Touch Pad 3 (GPIO15)
    
65.   touchAttachInterrupt(T3, callback, Threshold);
    
66. 
    
67.   //Configure Touchpad as wakeup source
    
68.   esp_sleep_enable_touchpad_wakeup();
    
69. 
    
70.   //Go to sleep now
    
71.   Serial.println("Going to sleep now");
    
72.   esp_deep_sleep_start();
    
73.   Serial.println("This will never be printed");
    
74. }
    
75. 
    
76. void loop(){
    
77.   //This will never be reached
    
78. }

复制代码

上传草图后，打开串口显示器，将波特率设置为115200bps。

现在，当触摸引脚时，ESP32将在串口显示器上显示启动次数、唤醒原因以及触摸哪个GPIO。

代码说明

第一行代码将触摸引脚的阈值设置为40。阈值越高，灵敏度越高。您可以根据项目更改此值。

1. #define Threshold 40 /* Greater the value, more the sensitivity */
   

复制代码

如前所述，您可以将数据保存在ESP32的RTC内存（8KB SRAM）中，该内存在深度睡眠期间未删除。但是，当ESP32复位时，它将被删除。

要将数据保存在RTC内存上，您只需要在定义变量之前添加RTC_DATA_ATTR属性即可。在此示例中，BbootCount变量保存在RTC内存中。它将计算ESP32从深度睡眠中唤醒的次数。

1. RTC_DATA_ATTR int bootCount = 0;

复制代码

在此之后，定义了一个名为touch_pad_t（枚举类型）的touchPin变量，后来将帮助我们打印哪个GPIO从睡眠中唤醒ESP32。

1. touch_pad_t touchPin;

复制代码

接下来，定义了print_wakeup_reason()函数，该函数打印出ESP32从深度睡眠中唤醒的原因。

1. void print_wakeup_reason(){
   
2.   esp_sleep_wakeup_cause_t wakeup_reason;
   
3. 
   
4.   wakeup_reason = esp_sleep_get_wakeup_cause();
   
5. 
   
6.   switch(wakeup_reason)
   
7.   {
   
8.     case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
   
9.     case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
   
10.     case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
    
11.     case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
    
12.     case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
    
13.     default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
    
14.   }
    
15. }

复制代码

还定义了print_wakeup_touchpad()函数，该函数是打印ESP32从深度睡眠中唤醒的GPIO编号。

1. void print_wakeup_touchpad(){
   
2.   touchPin = esp_sleep_get_touchpad_wakeup_status();
   
3. 
   
4.   switch(touchPin)
   
5.   {
   
6.     case 0  : Serial.println("Touch detected on GPIO 4"); break;
   
7.     case 1  : Serial.println("Touch detected on GPIO 0"); break;
   
8.     case 2  : Serial.println("Touch detected on GPIO 2"); break;
   
9.     case 3  : Serial.println("Touch detected on GPIO 15"); break;
   
10.     case 4  : Serial.println("Touch detected on GPIO 13"); break;
    
11.     case 5  : Serial.println("Touch detected on GPIO 12"); break;
    
12.     case 6  : Serial.println("Touch detected on GPIO 14"); break;
    
13.     case 7  : Serial.println("Touch detected on GPIO 27"); break;
    
14.     case 8  : Serial.println("Touch detected on GPIO 33"); break;
    
15.     case 9  : Serial.println("Touch detected on GPIO 32"); break;
    
16.     default : Serial.println("Wakeup not by touchpad"); break;
    
17.   }
    
18. }

复制代码

接下来，定义了一个callback()函数。这不过是中断服务例程（ISR），每当触发中断时，它都会调用。但是不幸的是，如果ESP32处于深度睡眠状态，则不会执行此函数。因此，此函数留为空。

1. void callback(){
   
2.   //placeholder callback function
   
3. }

复制代码

在setup()函数中，我们首先初始化串口通信。

1. Serial.begin(115200);

复制代码

然后将bootCount 变量自增1，并打印到串口显示器上，以显示ESP32从深度睡眠中醒来的次数。

1. ++bootCount;
   
2. Serial.println("Boot number: " + String(bootCount));

复制代码

然后调用print_wakeup_reason()和print_wakeup_touchpad()函数，但是您也可以调用要执行所需任务的任何函数，例如，读取传感器的值。

1. print_wakeup_reason();
   
2. print_wakeup_touchpad();

复制代码

现在，中断必须连接到带有所需灵敏度阈值的触摸引脚之一。在这里，中断附着在触摸引脚3（GPIO15）上。

1. touchAttachInterrupt(T3, callback, Threshold);
   

复制代码

接下来，我们使用esp_sleep_enable_touchpad_wakeup()函数配置触摸唤醒源。

1. esp_sleep_enable_touchpad_wakeup();
   

复制代码

最后，调用esp_deep_sleep_start()函数使ESP32进入睡眠。

1. esp_deep_sleep_start();
   

复制代码

在此草图中，ESP32在setup()函数中进入深度睡眠，因此它永远不会达到loop()函数。因此，loop()函数为空。

1. void loop(){
   
2.   //This is not going to be called
   
3. }

复制代码

ESP32唤醒源：外部唤醒

有两种外部触发器可以从深度睡眠中唤醒ESP32。

●    ext0  - 仅通过特定的GPIO引脚唤醒芯片时使用此功能。

●    ext1  - 当您想使用多个GPIO引脚唤醒芯片时，请使用此功能。

如果您想使用中断引脚从深度睡眠中唤醒ESP32，则必须使用所谓的RTC_GPIO引脚。这些GPIO被连接到RTC低功耗系统，因此当ESP32处于深度睡眠状态时，可以使用它们。

RTC_GPIO引脚是：

ext0外部唤醒源

当RTC_GPIO引脚之一更改其逻辑电平时，ESP32可以配置为从深度睡眠中唤醒。

esp_sleep_enable_ext0_wakeup(GPIO_PIN, LOGIC_LEVEL)函数用于启用此唤醒源。此函数需要两个参数。第一个是GPIO引脚编号，第二个是我们要触发唤醒的逻辑电平（低或高）。

由于ext0使用RTC IO唤醒ESP32，因此在深度睡眠期间，RTC外围设备保持运行。

而且，由于启用了RTC IO模块，因此您可以利用内部下拉或下拉电阻。他们需要在调用esp_deep_sleep_start()函数之前使用rtc_gpio_pullup_en()和rtc_gpio_pulldown_en()函数进行配置。

硬件连接

我们使用一个10k下拉电阻将按钮连接到GPIO＃33。

示例代码

让我们使用库中的示例来看看它的工作原理。打开您的Arduino IDE，然后导航到File > Examples > ESP32 > Deep Sleep，然后打开ExternalWakeUp草图。

该草图展示了最基本的深度睡眠示例，其中ext0作为唤醒源。

1. #define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex
   
2. 
   
3. RTC_DATA_ATTR int bootCount = 0;
   
4. 
   
5. /*
   
6. Method to print the reason by which ESP32
   
7. has been awaken from sleep
   
8. */
   
9. void print_wakeup_reason(){
   
10.   esp_sleep_wakeup_cause_t wakeup_reason;
    
11. 
    
12.   wakeup_reason = esp_sleep_get_wakeup_cause();
    
13. 
    
14.   switch(wakeup_reason)
    
15.   {
    
16.     case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
    
17.     case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
    
18.     case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
    
19.     case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
    
20.     case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
    
21.     default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
    
22.   }
    
23. }
    
24. 
    
25. void setup(){
    
26.   Serial.begin(115200);
    
27.   delay(1000); //Take some time to open up the Serial Monitor
    
28. 
    
29.   //Increment boot number and print it every reboot
    
30.   ++bootCount;
    
31.   Serial.println("Boot number: " + String(bootCount));
    
32. 
    
33.   //Print the wakeup reason for ESP32
    
34.   print_wakeup_reason();
    
35. 
    
36.   /*
    
37.   First we configure the wake up source
    
38.   We set our ESP32 to wake up for an external trigger.
    
39.   There are two types for ESP32, ext0 and ext1 .
    
40.   ext0 uses RTC_IO to wakeup thus requires RTC peripherals
    
41.   to be on while ext1 uses RTC Controller so doesnt need
    
42.   peripherals to be powered on.
    
43.   Note that using internal pullups/pulldowns also requires
    
44.   RTC peripherals to be turned on.
    
45.   */
    
46.   esp_sleep_enable_ext0_wakeup(GPIO_NUM_33,1); //1 = High, 0 = Low
    
47. 
    
48.   //If you were to use ext1, you would use it like
    
49.   //esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);
    
50. 
    
51.   //Go to sleep now
    
52.   Serial.println("Going to sleep now");
    
53.   esp_deep_sleep_start();
    
54.   Serial.println("This will never be printed");
    
55. }
    
56. 
    
57. void loop(){
    
58.   //This is not going to be called
    
59. }

复制代码

上传草图后，打开串口显示器，将波特率设置为115200bps。

现在，当您按下按钮时，ESP32将显示启动计数并在串口显示器上唤醒原因。尝试几次，观看每次按钮时的启动计数增加。另请注意，ext0使用RTC IO唤醒ESP32。

代码说明

第一行代码设置位掩码。 ext0外部唤醒不需要它，因此您可以暂时忽略它。我们将在ext1外部唤醒代码解释中了解这一点。

1. #define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex

复制代码

如前所述，您可以将数据保存在ESP32的RTC内存（8KB SRAM）中，该内存在深度睡眠期间未删除。但是，当ESP32复位时，它将被删除。

要将数据保存在RTC内存上，您只需要在定义变量之前添加RTC_DATA_ATTR属性即可。在此示例中，bootCount变量保存在RTC内存中。它将计算ESP32从深度睡眠中唤醒的次数。

1. RTC_DATA_ATTR int bootCount = 0;

复制代码

接下来，定义了print_wakeup_reason()函数，该函数打印出ESP32从深度睡眠中唤醒的原因。

1. void print_wakeup_reason(){
   
2.   esp_sleep_wakeup_cause_t wakeup_reason;
   
3. 
   
4.   wakeup_reason = esp_sleep_get_wakeup_cause();
   
5. 
   
6.   switch(wakeup_reason)
   
7.   {
   
8.     case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
   
9.     case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
   
10.     case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
    
11.     case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
    
12.     case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
    
13.     default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
    
14.   }
    
15. }

复制代码

在setup()函数中，我们首先初始化串口通信。

1. Serial.begin(115200);

复制代码

然后将bootCount变量自增1，并打印到串口显示器上，以显示ESP32从深度睡眠中醒来的次数。

1. ++bootCount;
   
2. Serial.println("Boot number: " + String(bootCount));

复制代码

然后调用print_wakeup_reason()函数，但是您可以调用要执行所需任务的任何函数，例如，读取传感器的值。

1. print_wakeup_reason();

复制代码

现在，使用esp_sleep_enable_ext0_wakeup(GPIO_PIN, LOGIC_LEVEL) 函数来配置ext0外部唤醒源。此函数需要两个参数。第一个是GPIO引脚编号，第二个是我们要触发唤醒的逻辑电平（低或高）。在此示例中，当GPIO＃33的逻辑电平变高时，ESP32被唤醒。

1. esp_sleep_enable_ext0_wakeup(GPIO_NUM_33,1);
   

复制代码

最后，调用esp_deep_sleep_start()函数来使ESP32进入睡眠。

1. esp_deep_sleep_start();
   

复制代码

在此草图中，ESP32在setup()函数中进入深度睡眠，因此它永远不会达到loop()函数。因此，loop()函数为空。

1. void loop(){
   
2.   //This is not going to be called
   
3. }

复制代码

ext1外部唤醒源

ESP32可以配置为使用多个引脚从深度睡眠中唤醒。请记住，这些引脚必须是RTC GPIO引脚。

由于ext1唤醒源使用RTC控制器，因此不需要RTC外围设备和RTC内存。这时内部上拉和下拉电阻将不可用。

为了使用内部上拉和下拉电阻，我们需要在睡眠期间请求RTC外围设备持续供电，并在输入睡眠之前使用rtc_gpio_pullup_en()和rtc_gpio_pulldown_en()配置上拉/下拉电阻。

esp_sleep_enable_ext1_wakeup(BUTTON_PIN_MASK, LOGIC_LEVEL)函数用于启用此唤醒源。该函数需要两个参数。第一个是一个掩码，它告诉我们要使用哪些引脚，第二个参数可以是下面提到的两个逻辑电平之一，以触发唤醒：

●    如果选定的引脚其中之一为高电平（ESP_EXT1_WAKEUP_ANY_HIGH），这时会唤醒。

●    如果所有选定的引脚都低电平（ESP_EXT1_WAKEUP_ALL_LOW），这时会唤醒。

位掩码（bitmask）

理解位掩码的最简单方法是以二进制格式编写它。您可以看到位编号基于普通的GPIO编号。最低显着的位（LSB）代表GPIO＃0，最显着的位（MSB）代表GPIO＃39。

●    0代表掩码的引脚

●    1表示将启用作为唤醒源的引脚

因此，如果您想启用GPIO唤醒，则必须将1写入其相应位置，剩余引脚写0。最后，您必须将其转换为十六进制。

例如，如果您想将GPIO＃32和GPIO＃33用作外部唤醒源，则位掩码将是这样：

硬件连接

让我们使用10K下拉电阻将两个按钮连接到GPIO＃33和GPIO＃32。

示例代码

让我们使用库中相同的外部效果示例来看看它的工作原理。再次打开您的Arduino IDE，然后导航到File > Examples > ESP32 > Deep Sleep，然后打开ExternalWakeup草图。

让我们对草图进行三个更改，以使其对我们有效：

1.  更改BUTTON_PIN_BITMASK常数

2.  注释掉ext0的代码

3.  取消注释ext1的代码

1. #define BUTTON_PIN_BITMASK 0x300000000
   
2. 
   
3. RTC_DATA_ATTR int bootCount = 0;
   
4. 
   
5. /*
   
6. Method to print the reason by which ESP32
   
7. has been awaken from sleep
   
8. */
   
9. void print_wakeup_reason(){
   
10.   esp_sleep_wakeup_cause_t wakeup_reason;
    
11. 
    
12.   wakeup_reason = esp_sleep_get_wakeup_cause();
    
13. 
    
14.   switch(wakeup_reason)
    
15.   {
    
16.     case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
    
17.     case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
    
18.     case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
    
19.     case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
    
20.     case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
    
21.     default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
    
22.   }
    
23. }
    
24. 
    
25. void setup(){
    
26.   Serial.begin(115200);
    
27.   delay(1000); //Take some time to open up the Serial Monitor
    
28. 
    
29.   //Increment boot number and print it every reboot
    
30.   ++bootCount;
    
31.   Serial.println("Boot number: " + String(bootCount));
    
32. 
    
33.   //Print the wakeup reason for ESP32
    
34.   print_wakeup_reason();
    
35. 
    
36.   /*
    
37.   First we configure the wake up source
    
38.   We set our ESP32 to wake up for an external trigger.
    
39.   There are two types for ESP32, ext0 and ext1 .
    
40.   ext0 uses RTC_IO to wakeup thus requires RTC peripherals
    
41.   to be on while ext1 uses RTC Controller so doesnt need
    
42.   peripherals to be powered on.
    
43.   Note that using internal pullups/pulldowns also requires
    
44.   RTC peripherals to be turned on.
    
45.   */
    
46.   //esp_sleep_enable_ext0_wakeup(GPIO_NUM_33,1); //1 = High, 0 = Low
    
47. 
    
48.   //If you were to use ext1, you would use it like
    
49.   esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);
    
50. 
    
51.   //Go to sleep now
    
52.   Serial.println("Going to sleep now");
    
53.   esp_deep_sleep_start();
    
54.   Serial.println("This will never be printed");
    
55. }
    
56. 
    
57. void loop(){
    
58.   //This is not going to be called
    
59. }

复制代码

上传草图后，打开串口显示器，将波特率设置为115200 bps。

现在，当您按下按钮时，您将在串口显示器上看到如下结果。 另请注意，ext1使用RTC控制器唤醒ESP32。

代码说明

此代码与Ext0代码相同，除了以下两个更改。

在代码开始时，定义了位掩码。 由于我们在示例中使用了PIN gpio＃32和GPIO＃33，因此相应的掩码位置为1，右侧32个0，左侧为6个0。

1. #define BUTTON_PIN_BITMASK 0x300000000

复制代码

最后，启用ext1作为唤醒源。

1. esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);

复制代码