ESP32 要一直在线也能省电吗？试试自动 Light-sleep

idf.py --version
idf.py -B build-auto -D IDF_TARGET=esp32s3 -D SDKCONFIG=sdkconfig.auto -D L09_AUTOSLEEP=1 build
idf.py -B build-auto -D SDKCONFIG=sdkconfig.auto -p YOUR_PORT flash monitor
idf.py -B build-baseline -D IDF_TARGET=esp32s3 -D SDKCONFIG=sdkconfig.baseline -D L09_AUTOSLEEP=0 build
idf.py -B build-baseline -D SDKCONFIG=sdkconfig.baseline -p YOUR_PORT flash monitor

// ---- main/main.cpp ----
// SPDX-License-Identifier: MIT
#include <cstdio>
#include <cstring>
#include <inttypes.h>
#include <atomic>
#include "sdkconfig.h"
#include "esp_pm.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "esp_timer.h"
#include "esp_random.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "lwip/sockets.h"
#include "credentials.h"
#include "CommandModel.h"
static_assert(CONFIG_PM_ENABLE&&CONFIG_FREERTOS_USE_TICKLESS_IDLE,"automatic sleep requires PM and tickless");
static const char* TAG="L09";static QueueHandle_t requests;static std::atomic<bool> online{false};static std::atomic<uint32_t> drops{0};
struct Event {bool edge;int socket;struct sockaddr_in peer;L09Request request;};
static void owner(void*){
 L09Model model{};model.session=(uint64_t(esp_random())<<32)|esp_random();if(!model.session)model.session=1;L09Button button{};int64_t heartbeat=esp_timer_get_time();
 for(;;){
  Event event{};bool got=xQueueReceive(requests,&event,pdMS_TO_TICKS(100))==pdTRUE;const uint64_t now=uint64_t(esp_timer_get_time());
  // 100ms polling leaves >=3 idle ticks at HZ100; both variants do identical work.
  // This is not GPIO light-sleep wake: a short pulse entirely between polls can be missed.
  if(button.tick(gpio_get_level(GPIO_NUM_5)==0,now)){model.button();gpio_set_level(GPIO_NUM_4,model.led);}
  if(got&&!event.edge){
   char reply[150];int n=0;
   if(event.request.session==0){n=snprintf(reply,sizeof reply,"HELLO %016" PRIx64 " mode=%d online=%u\n",model.session,L09_AUTOSLEEP,online.load());}
   else{L09Model::Reply snapshot{};auto result=model.apply(event.request,snapshot);if(result==L09Model::NEW||result==L09Model::DUPLICATE){gpio_set_level(GPIO_NUM_4,model.led);n=snprintf(reply,sizeof reply,"1 %016" PRIx64 " %" PRIu32 " %u %" PRIu32 " %u %" PRIu64 "\n",model.session,snapshot.seq,snapshot.led,snapshot.buttons,unsigned(result==L09Model::DUPLICATE),now);if(result==L09Model::NEW&&event.request.op==L09Request::LOCKS)ESP_ERROR_CHECK(esp_pm_dump_locks(stdout));}else n=snprintf(reply,sizeof reply,"REJECT %u\n",unsigned(result));}
   if(n>0&&n<int(sizeof reply)&&sendto(event.socket,reply,size_t(n),0,reinterpret_cast<sockaddr*>(&event.peer),sizeof event.peer)<0)ESP_LOGW(TAG,"reply failed errno=%d; host must not count ACK",errno);
  }
  if(esp_timer_get_time()-heartbeat>=60000000){heartbeat=esp_timer_get_time();ESP_LOGI(TAG,"ONLINE=%u mode=%d LED_latch=%u input_count=%" PRIu32 " queue_drop=%" PRIu32 "; no physical sleep/current proof",online.load(),L09_AUTOSLEEP,model.led,model.buttonCount,drops.load());}
 }
}
static void udp(void*){
 const int fd=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);if(fd<0){ESP_LOGE(TAG,"socket errno=%d",errno);vTaskDelete(nullptr);return;}
 timeval tv{1,0};setsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof tv);tv={0,100000};setsockopt(fd,SOL_SOCKET,SO_SNDTIMEO,&tv,sizeof tv);
 sockaddr_in bindAddress{};bindAddress.sin_family=AF_INET;bindAddress.sin_port=htons(45679);bindAddress.sin_addr.s_addr=htonl(INADDR_ANY);
 if(bind(fd,reinterpret_cast<sockaddr*>(&bindAddress),sizeof bindAddress)<0){ESP_LOGE(TAG,"bind errno=%d",errno);close(fd);vTaskDelete(nullptr);return;}
 for(;;){char bytes[96];Event event{};event.socket=fd;socklen_t length=sizeof event.peer;int n=recvfrom(fd,bytes,sizeof bytes,0,reinterpret_cast<sockaddr*>(&event.peer),&length);if(n<0){if(errno!=EAGAIN&&errno!=EWOULDBLOCK)ESP_LOGW(TAG,"recv errno=%d",errno);continue;}if(n==6&&!memcmp(bytes,"HELLO\n",6)){event.request.session=0;}else if(!l09Parse(bytes,size_t(n),event.request))continue;if(xQueueSend(requests,&event,0)!=pdTRUE)drops.fetch_add(1);}
}
static void wifiEvent(void*,esp_event_base_t base,int32_t id,void* data){
 if(base==WIFI_EVENT&&id==WIFI_EVENT_STA_START){esp_err_t e=esp_wifi_connect();if(e!=ESP_OK)ESP_LOGW(TAG,"connect start %s",esp_err_to_name(e));}
 if(base==WIFI_EVENT&&id==WIFI_EVENT_STA_DISCONNECTED){online.store(false);auto* event=static_cast<wifi_event_sta_disconnected_t*>(data);ESP_LOGW(TAG,"disconnected reason=%u; reconnect worker",event->reason);}
 if(base==IP_EVENT&&id==IP_EVENT_STA_GOT_IP){online.store(true);auto* event=static_cast<ip_event_got_ip_t*>(data);ESP_LOGI(TAG,"IP=" IPSTR " PM requested, actual connection/sleep not inferred",IP2STR(&event->ip_info.ip));}
}
static void reconnect(void*){for(;;){vTaskDelay(pdMS_TO_TICKS(10000));if(!online.load()){esp_err_t e=esp_wifi_connect();if(e!=ESP_OK)ESP_LOGW(TAG,"retry %s",esp_err_to_name(e));}}}
extern "C" void app_main(){
 esp_pm_config_t pm{160,40,L09_AUTOSLEEP!=0};ESP_ERROR_CHECK(esp_pm_configure(&pm));esp_pm_config_t actual{};ESP_ERROR_CHECK(esp_pm_get_configuration(&actual));ESP_LOGI(TAG,"PM max=%d min=%d autoLS=%u tickless=%d idleTicks=%d; configuration is not measured sleep",actual.max_freq_mhz,actual.min_freq_mhz,actual.light_sleep_enable,CONFIG_FREERTOS_USE_TICKLESS_IDLE,CONFIG_FREERTOS_IDLE_TIME_BEFORE_SLEEP);
 requests=xQueueCreate(8,sizeof(Event));if(!requests){ESP_LOGE(TAG,"queue allocation failed");return;}
 gpio_config_t led{};led.pin_bit_mask=1ULL<<4;led.mode=GPIO_MODE_OUTPUT;ESP_ERROR_CHECK(gpio_config(&led));gpio_set_level(GPIO_NUM_4,0);
 gpio_config_t input{};input.pin_bit_mask=1ULL<<5;input.mode=GPIO_MODE_INPUT;input.intr_type=GPIO_INTR_DISABLE;ESP_ERROR_CHECK(gpio_config(&input));
 if(xTaskCreate(owner,"owner",4096,nullptr,5,nullptr)!=pdPASS){ESP_LOGE(TAG,"owner task allocation failed");return;}
 const char* ssid=l09_ssid();const char* password=l09_password();if(!ssid[0]){ESP_LOGW(TAG,"CONFIG_DISABLED: fill credentials.c locally; input still runs; no network result");return;}
 if(strlen(ssid)>31||strlen(password)>63){ESP_LOGE(TAG,"CONFIG_INVALID");return;}
 ESP_ERROR_CHECK(nvs_flash_init());ESP_ERROR_CHECK(esp_netif_init());ESP_ERROR_CHECK(esp_event_loop_create_default());if(!esp_netif_create_default_wifi_sta()){ESP_LOGE(TAG,"netif allocation failed");return;}
 ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT,ESP_EVENT_ANY_ID,wifiEvent,nullptr));ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT,IP_EVENT_STA_GOT_IP,wifiEvent,nullptr));
 wifi_init_config_t init=WIFI_INIT_CONFIG_DEFAULT();ESP_ERROR_CHECK(esp_wifi_init(&init));ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));wifi_config_t config{};strlcpy(reinterpret_cast<char*>(config.sta.ssid),ssid,sizeof config.sta.ssid);strlcpy(reinterpret_cast<char*>(config.sta.password),password,sizeof config.sta.password);config.sta.listen_interval=3;ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA,&config));ESP_ERROR_CHECK(esp_wifi_start());ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_MIN_MODEM));
 if(xTaskCreate(udp,"udp",4096,nullptr,4,nullptr)!=pdPASS||xTaskCreate(reconnect,"reconnect",3072,nullptr,3,nullptr)!=pdPASS)ESP_LOGE(TAG,"network task allocation failed; do not count service ready");
 // No manual esp_light_sleep_start, no user PM lock held across idle, no SNTP/OTA.
}

// ---- main/CommandModel.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <cstdint>
#include <cstddef>
#include <cstring>
#include <cstdio>
#include <limits>
struct L09Request {uint64_t session=0;uint32_t sequence=0;enum Op{GET,ON,OFF,LOCKS}op=GET;};
inline bool l09Decimal(const char* s,size_t n,uint32_t& value){if(!n||n>10||(n>1&&s[0]=='0'))return false;uint64_t v=0;for(size_t i=0;i<n;++i){if(s[i]<'0'||s[i]>'9')return false;v=v*10+s[i]-'0';if(v>UINT32_MAX)return false;}if(!v)return false;value=uint32_t(v);return true;}
inline bool l09Parse(const char* b,size_t n,L09Request& out){
 if(!b||n<24||n>48||b[n-1]!='\n'||std::memchr(b,0,n))return false;
 if(b[0]!='1'||b[1]!=' '||b[18]!=' ')return false;
 uint64_t session=0;for(size_t i=2;i<18;++i){unsigned v=b[i]>='0'&&b[i]<='9'?unsigned(b[i]-'0'):b[i]>='a'&&b[i]<='f'?unsigned(b[i]-'a'+10):16;if(v==16)return false;session=(session<<4)|v;}
 size_t sep=19;while(sep<n&&b[sep]!=' ')++sep;uint32_t seq=0;if(sep>=n||!l09Decimal(b+19,sep-19,seq))return false;
 const char* op=b+sep+1;size_t len=n-sep-2;L09Request::Op type;if(len==3&&!std::memcmp(op,"GET",3))type=L09Request::GET;else if(len==2&&!std::memcmp(op,"ON",2))type=L09Request::ON;else if(len==3&&!std::memcmp(op,"OFF",3))type=L09Request::OFF;else if(len==5&&!std::memcmp(op,"LOCKS",5))type=L09Request::LOCKS;else return false;
 if(!session){return false;}
 out={session,seq,type};return true;
}
struct L09Model {
 uint64_t session=0;uint32_t last=0,buttonCount=0,accepted=0;bool led=false;
 struct Reply {uint32_t seq;bool led;uint32_t buttons;L09Request::Op op;};Reply cache[16]{};unsigned cursor=0;
 enum Result{NEW,DUPLICATE,WRONG_BOOT,STALE,EXHAUSTED};
 Result apply(const L09Request& q,Reply& reply){
  if(q.session!=session)return WRONG_BOOT;
  for(const auto& old:cache)if(old.seq==q.sequence){if(old.op!=q.op)return STALE;reply=old;return DUPLICATE;}
  if(q.sequence<=last){return STALE;}
  if(last==UINT32_MAX){return EXHAUSTED;}
  if(q.op==L09Request::ON)led=true;else if(q.op==L09Request::OFF)led=false;
  last=q.sequence;++accepted;reply={q.sequence,led,buttonCount,q.op};cache[cursor++%16]=reply;return NEW;
 }
 void button(){led=!led;++buttonCount;}
};
struct L09Button {
 bool raw=false,stable=false,initialized=false;uint64_t changed=0;
 bool tick(bool pressed,uint64_t now){if(!initialized||pressed!=raw||now<changed){initialized=true;raw=pressed;changed=now;return false;}if(now-changed>=30000&&stable!=raw){stable=raw;return stable;}return false;}
};

// ---- main/credentials.h ----
// SPDX-License-Identifier: MIT
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
const char* l09_ssid(void);
const char* l09_password(void);
#ifdef __cplusplus
}
#endif

// ---- main/credentials.c ----
// SPDX-License-Identifier: MIT
// Trusted isolated LAN only. Fill locally, rebuild, do not publish credentials.
// Separate translation unit deliberately keeps the real network path compiled
// in the safe empty-config build (no link time optimization).
#include "credentials.h"
const char* l09_ssid(void){return "";}
const char* l09_password(void){return "";}

python3 host/probe.py NODE_IP --mode auto --count 100 --period 1 --output auto-rtt.csv
python3 host/analyze.py auto-rtt.csv
python3 host/probe.py NODE_IP --mode baseline --count 100 --period 1 --output baseline-rtt.csv
python3 host/analyze.py baseline-rtt.csv