ESP32 省电模式怎么选？从一直在线到每小时上报一次

idf.py --version
idf.py -B build-manual -D SDKCONFIG=sdkconfig.manual -D 'SDKCONFIG_DEFAULTS=sdkconfig.defaults;config/manual.defaults' -D IDF_TARGET=esp32s3 build
idf.py -B build-awake -D SDKCONFIG=sdkconfig.awake -D 'SDKCONFIG_DEFAULTS=sdkconfig.defaults;config/awake.defaults' -D IDF_TARGET=esp32s3 build
idf.py -B build-deep -D SDKCONFIG=sdkconfig.deep -D 'SDKCONFIG_DEFAULTS=sdkconfig.defaults;config/deep.defaults' -D IDF_TARGET=esp32s3 build
idf.py -B build-automatic -D SDKCONFIG=sdkconfig.automatic -D 'SDKCONFIG_DEFAULTS=sdkconfig.defaults;config/automatic.defaults' -D IDF_TARGET=esp32s3 build

// ---- main/Policy.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
enum class Choice { ONLINE_AUTO, DEEP_TIMER, DEEP_LEVEL, KEEP_AWAKE };
inline Choice choose(bool remoteWhileIdle,bool periodic,bool levelCanWait,bool losesRamOK){
 if(remoteWhileIdle)return Choice::ONLINE_AUTO;
 if(!losesRamOK)return Choice::KEEP_AWAKE;
 if(periodic)return Choice::DEEP_TIMER;
 if(levelCanWait)return Choice::DEEP_LEVEL;
 return Choice::KEEP_AWAKE;
}
inline const char* choiceName(Choice c){switch(c){case Choice::ONLINE_AUTO:return "ONLINE_AUTO";case Choice::DEEP_TIMER:return "DEEP_TIMER";case Choice::DEEP_LEVEL:return "DEEP_LEVEL";default:return "KEEP_AWAKE";}}

// ---- main/main.cpp ----
// SPDX-License-Identifier: MIT
#include <cstdio>
#include <cstring>
#include <inttypes.h>
#include <atomic>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_sleep.h"
#include "esp_system.h"
#include "esp_timer.h"
#include "esp_pm.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "nvs_flash.h"
#include "driver/uart.h"
#include "Policy.h"
RTC_DATA_ATTR static uint32_t deepCycles=0;
static std::atomic<bool> online{false}, disconnected{false};
static void event(void*,esp_event_base_t base,int32_t id,void*){
 if(base==IP_EVENT&&id==IP_EVENT_STA_GOT_IP)online.store(true);
 if(base==WIFI_EVENT&&id==WIFI_EVENT_STA_DISCONNECTED){online.store(false);disconnected.store(true);}
}
static bool startWifi(){
 if(std::strlen(CONFIG_HX_SSID)==0){puts("CONFIG: empty SSID; no STA attempt, no online result");return false;}
 esp_err_t e=nvs_flash_init();if(e!=ESP_OK){printf("NVS error=%s; no erase\n",esp_err_to_name(e));return false;}
 ESP_ERROR_CHECK(esp_netif_init());ESP_ERROR_CHECK(esp_event_loop_create_default());
 if(!esp_netif_create_default_wifi_sta()){puts("STOP netif allocation");return false;}
 wifi_init_config_t init=WIFI_INIT_CONFIG_DEFAULT();ESP_ERROR_CHECK(esp_wifi_init(&init));
 ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT,ESP_EVENT_ANY_ID,event,nullptr));
 ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT,IP_EVENT_STA_GOT_IP,event,nullptr));
 wifi_config_t c{};std::snprintf((char*)c.sta.ssid,sizeof c.sta.ssid,"%s",CONFIG_HX_SSID);std::snprintf((char*)c.sta.password,sizeof c.sta.password,"%s",CONFIG_HX_PASSWORD);
 ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA,&c));
 ESP_ERROR_CHECK(esp_wifi_start());ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_MIN_MODEM));return true;
}
extern "C" void app_main(){
 const int mode=CONFIG_HX_MODE;int localLoops=0;
 if(esp_reset_reason()!=ESP_RST_DEEPSLEEP)deepCycles=0;
 printf("L01 mode=%d reset=%d wake=%d RTC_deep_cycles=%" PRIu32 " localLoops=%d\n",mode,int(esp_reset_reason()),int(esp_sleep_get_wakeup_cause()),deepCycles,localLoops);
 printf("policy remote=%s hourly=%s contact=%s\n",choiceName(choose(true,false,false,true)),choiceName(choose(false,true,false,true)),choiceName(choose(false,false,true,true)));
 // No automatic sleep for the three offline comparisons, even though PM is compiled in.
 esp_pm_config_t pm{};pm.max_freq_mhz=240;pm.min_freq_mhz=80;pm.light_sleep_enable=mode==3;
 ESP_ERROR_CHECK(esp_pm_configure(&pm));
 if(mode==3){
  bool configured=startWifi(),attempting=false;uint64_t began=0,lastEnd=0,lastPrint=0;
  for(;;){
   uint64_t now=uint64_t(esp_timer_get_time()/1000);
   if(disconnected.exchange(false)){attempting=false;lastEnd=now;}
   if(configured&&!online.load()&&!attempting&&now-lastEnd>=5000){esp_err_t e=esp_wifi_connect();attempting=e==ESP_OK;began=now;lastEnd=now;printf("STA attempt api=%s\n",esp_err_to_name(e));}
   if(attempting&&now-began>=15000){esp_wifi_disconnect();attempting=false;lastEnd=now;puts("STA timeout; retry after >=5s");}
   if(online.load())attempting=false;
   if(now-lastPrint>=10000){lastPrint=now;printf("AUTO policy enabled, IP_event_online=%u; actual idle sleep/current/latency unmeasured\n",online.load());}
   vTaskDelay(pdMS_TO_TICKS(100));
  }
 }
 vTaskDelay(pdMS_TO_TICKS(3000)); // maintenance window before the offline comparison
 for(;;){
  ++localLoops;
  printf("before mode=%d localLoops=%d\n",mode,localLoops);fflush(stdout);
  if(mode==0){vTaskDelay(pdMS_TO_TICKS(5000));puts("awake: task delay returned; PM automatic sleep disabled");}
  else{
   ESP_ERROR_CHECK(esp_sleep_enable_timer_wakeup(5000000ULL));
   ESP_ERROR_CHECK(uart_wait_tx_idle_polling(UART_NUM_0));
   if(mode==1){esp_err_t e=esp_light_sleep_start();printf("manual returned=%s localLoops=%d wake=%d\n",esp_err_to_name(e),localLoops,int(esp_sleep_get_wakeup_cause()));if(e!=ESP_OK)vTaskDelay(pdMS_TO_TICKS(1000));}
   else{if(deepCycles!=UINT32_MAX)++deepCycles;puts("deep: next successful timer wake starts app_main again");fflush(stdout);esp_deep_sleep_start();}
  }
 }
}

c++ -std=c++17 -Wall -Wextra -Werror tests/policy_test.cpp -o /tmp/l01-policy
/tmp/l01-policy