【IoT】ESP32 Arduino 超低功耗模式 Deep-sleep

84 阅读 0 评论 56 点赞

我是靠谱客的博主失眠世界，最近开发中收集的这篇文章主要介绍【IoT】ESP32 Arduino 超低功耗模式 Deep-sleep，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

背景：

低功耗是对 IoT 产品的最基本要求，也是一款好产品走向市场的基础，功耗评估显得尤为重要。

一、基础资源简析

ESP32 支持 Deep-sleep 低功耗模式，通过配置 RTC 外设和 ULP 协处理器的工作模式，可以满足多种应用场景下的低功耗需求。

在 Deep-sleep 模式时，所有由 APB_CLK 驱动的外设、CPU 和 RAM 将掉电，RTC_CLK 继续工作；
RTC 控制器、RTC 外设、ULP 协处理器、RTC 快速内存和 RTC 慢速内存可以不掉电，具体取决于应用程序中的唤醒源设置。

硬件资源：

RTC 外设 – 片上温度传感器、ADC、RTC GPIO 和 touchpad
ULP 协处理器 – 可在 Deep-sleep 模式下，进行简单的数据采集或作为一种唤醒源，协处理器可以访问 RTC 慢速内存和 RTC 寄存器
RTC 快速内存 – 芯片从 Deep-sleep 模式下唤醒后不会马上执行 bootloader，而是会先执行存放在 RTC 快速内存中的 esp_wake_deep_sleep() 函数
RTC 慢速内存 – 存放 ULP 协处理器和 wake stub 代码访问的数据

Deep-sleep 模式下支持的唤醒源包括：

1、定时器
2、touchpad
3、Ext(0)：RTC IO 中某个指定 GPIO 满足指定电平即唤醒
4、Ext(1)：RTC IO 中某些指定 GPIO 同时满足指定电平即唤醒
5、ULP 协处理器

二、示例

1、定时器唤醒：6uA 左右

调用 esp_deep_sleep_enable_timer_wakeup(sleep_time_us) 函数，设置 Deep-sleep 时间
调用 esp_deep_sleep_start() 函数，进入 Deep-sleep 模式
此时需要周期性唤醒 ESP32，不能充分利用 ESP32 的低功耗性能，但可以进行复杂的传感器数据采集

/*
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 <cherukupallip@gmail.com>
*/

#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*2);
  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
}

2、Touchpad：36uA 左右

设置作为唤醒源的 touchpad
调用 esp_deep_sleep_enable_touchpad_wakeup() 函数使能 touchpad 唤醒，然后调用 esp_deep_sleep_start() 函数进入 Deep-sleep 模式

/*
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 <cherukupallip@gmail.com>
*/

#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
}

3、GPIO 唤醒：6uA 左右

调用 rtc_gpio_pulldown_en(MY_RTC_WAKEUP_IO) 函数或 rtc_gpio_pullup_en(MY_RTC_WAKEUP_IO) 函数，设置内部下拉或上拉类型
调用 esp_deep_sleep_enable_ext0_wakeup(MY_RTC_WAKEUP_IO, WAKEUP_IO_LEVEL) 函数或 esp_deep_sleep_enable_ext1_wakeup(WAKEUP_PIN_MASK, WAKEUP_TYPE) 函数，设置从 Deep-sleep 模式下唤醒的 RTC GPIO 电压条件
调用 esp_deep_sleep_start() 函数进入 Deep-sleep 模式

/*
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 <cherukupallip@gmail.com>
*/

#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_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;
  }
}

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

  Serial.printf("Boot number: %d ", 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_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);

  //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
}

4、ULP 协处理器

用户根据 ULP 指令集，自行编写需要 ULP 协处理器在 Deep-sleep 模式下执行的汇编代码，完整流程如下：

芯片 boot 启动后，从 RTC_SLOW_MEMORY 读取芯片在 Deep-sleep 模式期间 ULP 协处理器采集的数据，并上传数据
调用 ulp_process_macros_and_load() 函数，将汇编程序代码拷贝至 RTC_SLOW_MEMORY
调用 ulp_run(ADDRESS) 函数启动 ULP 协处理器，执行 RTC_SLOW_MEMORY 中的代码
调用 esp_deep_sleep_start() 函数，进入 Deep-sleep 模式

为了便于用户使用 ULP 协处理器进行数据采集与存储，IoT Solution 中增加了 ulp_monitor 模块，可直接调用 C 函数运行协处理器

ulp_monitor 模块的使用流程如下:

芯片 boot 启动后，从 RTC_SLOW_MEMORY 读取 ULP 协处理器在芯片 Deep-sleep 模式期间采集的数据，并上传数据
调用 ulp_monitor_init(ULP_PROGRAM_ADDR, ULP_DATA_ADDR) 函数，设置 ULP 协处理器的程序运行地址与数据保存地址
调用 ulp_add_adc_monitor 函数或 ulp_add_temprature_monitor 函数，添加 ULP 协处理器采集的数据类型和唤醒条件（可同时添加）
调用 ulp_monitor_start 函数设置测量频率，并启动 ULP 协处理器
调用 esp_deep_sleep_start() 函数，进入 Deep-sleep 模式。目前，ULP 协处理只支持片上温度传感器和 ADC 数据的采集
该方式可以在低功耗情况下频繁地采集数据，从而降低对传感器的要求

refer：

https://blog.csdn.net/espressif/article/details/79360365