外设也要睡：控制传感器和屏幕电源时要检查什么？

// ---- main/PowerSequence.h ----
// SPDX-License-Identifier: MIT
#pragma once
// This exact policy is used by the firmware and host fixture. IO cleanup must
// release bus/device and float both signal pads before requesting rail OFF.
template<class IO> bool runPowerCycle(IO& io){
 bool ok=io.startSensor();if(ok)ok=io.readSensor();
 bool closed=io.stopSensor();ok=ok&&closed;
 if(!ok)return false;
 ok=io.startDisplay();if(ok)ok=io.drawDisplay();
 if(ok)io.viewWindow();
 bool slept=io.displayOff();bool released=io.stopDisplay();
 return ok&&slept&&released;
}

// ---- main/main.cpp ----
// SPDX-License-Identifier: MIT
#include <cstdio>
#include <cstring>
#include <initializer_list>
#include <inttypes.h>
#include "esp_sleep.h"
#include "esp_timer.h"
#include "driver/gpio.h"
#include "driver/i2c_master.h"
#include "driver/uart.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "ShtSample.h"
#include "PowerSequence.h"
struct Channel {gpio_num_t en,sda,scl;int port;uint8_t address;int waitMs;i2c_master_bus_handle_t bus=nullptr;i2c_master_dev_handle_t dev=nullptr;};
static void waitMs(int ms){vTaskDelay(pdMS_TO_TICKS(ms));}
static void floatPad(gpio_num_t pin){ESP_ERROR_CHECK(gpio_set_direction(pin,GPIO_MODE_DISABLE));ESP_ERROR_CHECK(gpio_set_pull_mode(pin,GPIO_FLOATING));}
static void offPads(Channel& c){floatPad(c.sda);floatPad(c.scl);}
static bool start(Channel& c){
 ESP_ERROR_CHECK(gpio_set_level(c.en,1));printf("REQUEST ON EN%d; wait_ms=%d (measure TP6; no rail feedback)\n",int(c.en),c.waitMs);waitMs(c.waitMs);
 i2c_master_bus_config_t b{};b.i2c_port=c.port;b.sda_io_num=c.sda;b.scl_io_num=c.scl;b.clk_source=I2C_CLK_SRC_DEFAULT;b.glitch_ignore_cnt=7;b.flags.enable_internal_pullup=false;
 esp_err_t e=i2c_new_master_bus(&b,&c.bus);i2c_device_config_t d{};d.device_address=c.address;d.dev_addr_length=I2C_ADDR_BIT_LEN_7;d.scl_speed_hz=100000;
 if(e==ESP_OK){e=i2c_master_bus_add_device(c.bus,&d,&c.dev);}
 printf("INIT EN%d api=%s\n",int(c.en),esp_err_to_name(e));return e==ESP_OK;
}
static bool stop(Channel& c){
 bool ok=true;if(c.dev){auto e=i2c_master_bus_rm_device(c.dev);ok=e==ESP_OK;if(ok)c.dev=nullptr;}
 if(c.bus){auto e=i2c_del_master_bus(c.bus);ok=(e==ESP_OK)&&ok;if(e==ESP_OK)c.bus=nullptr;}
 // All requests above are synchronous, no outstanding transactions/callbacks.
 // Even driver cleanup failure must not leave pads driving a powered-off module.
 offPads(c);ESP_ERROR_CHECK(gpio_set_level(c.en,0));printf("REQUEST HIZ SDA%d/SCL%d -> OFF EN%d; discharge_wait_ms=100\n",int(c.sda),int(c.scl),int(c.en));waitMs(100);return ok;
}
static esp_err_t tx(Channel& c,const uint8_t* p,size_t n){return c.dev?i2c_master_transmit(c.dev,p,n,200):ESP_ERR_INVALID_STATE;}
// Native SSD1306, 128x64, I2C=0x3D, horizontal addressing, 1024-byte framebuffer.
static uint8_t frame[1024];
static void pixel(int x,int y){if(x>=0&&x<128&&y>=0&&y<64)frame[x+(y/8)*128]|=uint8_t(1u<<(y&7));}
static void number(int value,int x,int y){
 static const uint8_t digits[10][5]={{0x3e,0x51,0x49,0x45,0x3e},{0,0x42,0x7f,0x40,0},{0x42,0x61,0x51,0x49,0x46},{0x21,0x41,0x45,0x4b,0x31},{0x18,0x14,0x12,0x7f,0x10},{0x27,0x45,0x45,0x45,0x39},{0x3c,0x4a,0x49,0x49,0x30},{1,0x71,9,5,3},{0x36,0x49,0x49,0x49,0x36},{6,0x49,0x49,0x29,0x1e}};
 char text[16];snprintf(text,sizeof text,"%d",value);for(const char* p=text;*p;++p,x+=12)for(int col=0;col<5;col++)for(int row=0;row<7;row++)if((*p=='-'?row==3:digits[*p-'0'][col]&(1u<<row)))for(int dx=0;dx<2;dx++)for(int dy=0;dy<2;dy++)pixel(x+col*2+dx,y+row*2+dy);
}
struct Hardware {
 Channel sensor{GPIO_NUM_5,GPIO_NUM_8,GPIO_NUM_9,0,0x44,20},display{GPIO_NUM_6,GPIO_NUM_17,GPIO_NUM_18,1,0x3d,100};ShtSample sample{};
 bool startSensor(){return start(sensor);}bool stopSensor(){return stop(sensor);}bool startDisplay(){return start(display);}bool stopDisplay(){return stop(display);}
 bool readSensor(){uint8_t cmd=0xfd,b[6];esp_err_t e=tx(sensor,&cmd,1);if(e==ESP_OK){waitMs(10);e=i2c_master_receive(sensor.dev,b,6,200);}if(e==ESP_OK)sample=decodeSht(b);printf("SAMPLE api=%s valid=%u t_mC=%d rh_mPct=%d\n",esp_err_to_name(e),sample.valid,sample.t_mC,sample.rh_mPct);return e==ESP_OK&&sample.valid;}
 bool drawDisplay(){
  const uint8_t init[]={0,0xae,0xd5,0x80,0xa8,63,0xd3,0,0x40,0x8d,0x14,0x20,0,0xa1,0xc8,0xda,0x12,0x81,0x7f,0xd9,0xf1,0xdb,0x20,0xa4,0xa6,0x2e,0x21,0,127,0x22,0,7};
  esp_err_t e=tx(display,init,sizeof init);memset(frame,0,sizeof frame);number(sample.t_mC/100,12,8);number(sample.rh_mPct/100,12,36);
  // Top integer is T in 0.1 C, bottom is RH in 0.1%; row markers distinguish them.
  for(int x=0;x<5;x++){pixel(x,8);pixel(x,36);pixel(x,40);}
  for(int p=0;p<8&&e==ESP_OK;p++){uint8_t b[129];b[0]=0x40;memcpy(b+1,frame+128*p,128);e=tx(display,b,sizeof b);}if(e==ESP_OK){const uint8_t on[]={0,0xaf};e=tx(display,on,sizeof on);}printf("OLED transfer=%s; visual result pending\n",esp_err_to_name(e));return e==ESP_OK;
 }
 void viewWindow(){waitMs(3000);}bool displayOff(){if(!display.dev)return false;const uint8_t off[]={0,0xae,0x8d,0x10};return tx(display,off,sizeof off)==ESP_OK;}
};
extern "C" void app_main(){
 int64_t began=esp_timer_get_time();Hardware io;
 // 100k external EN-to-GND per EVM is required during ROM/boot/deep sleep.
 for(auto pin:{GPIO_NUM_5,GPIO_NUM_6}){ESP_ERROR_CHECK(gpio_set_level(pin,0));ESP_ERROR_CHECK(gpio_set_direction(pin,GPIO_MODE_OUTPUT));ESP_ERROR_CHECK(gpio_set_pull_mode(pin,GPIO_FLOATING));}
 offPads(io.sensor);offPads(io.display);waitMs(2000);bool ok=runPowerCycle(io);
 if(!ok){puts("FAULT: rails requested OFF; stay awake, verify VOUT/signals and reset after repair");return;}
 ESP_ERROR_CHECK(esp_sleep_enable_timer_wakeup(60000000ULL));printf("SLEEP active_app_us=%" PRId64 " request_us=60000000; current/rail voltage unmeasured\n",esp_timer_get_time()-began);fflush(stdout);ESP_ERROR_CHECK(uart_wait_tx_idle_polling(UART_NUM_0));esp_deep_sleep_start();
}