明明 Deep-sleep 却耗电很高？先量整块开发板

idf.py -B build-board -D SDKCONFIG=sdkconfig.board -D 'SDKCONFIG_DEFAULTS=sdkconfig.defaults;config/board.defaults' -D IDF_TARGET=esp32s3 build
idf.py -B build-sensor -D SDKCONFIG=sdkconfig.sensor -D 'SDKCONFIG_DEFAULTS=sdkconfig.defaults;config/sensor.defaults' -D IDF_TARGET=esp32s3 build
idf.py -B build-oled -D SDKCONFIG=sdkconfig.oled -D 'SDKCONFIG_DEFAULTS=sdkconfig.defaults;config/oled.defaults' -D IDF_TARGET=esp32s3 build

// ---- main/ShtSample.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
struct ShtSample { bool valid=false;int t_mC=0;int rh_raw_mPct=0;int rh_mPct=0; };
inline uint8_t shtCrc(const uint8_t* b){uint8_t c=0xff;for(int k=0;k<2;++k){c^=b[k];for(int j=0;j<8;++j)c=(c&0x80)?uint8_t((c<<1)^0x31):uint8_t(c<<1);}return c;}
inline ShtSample decodeSht(const uint8_t b[6]){ShtSample s;if(shtCrc(b)!=b[2]||shtCrc(b+3)!=b[5])return s;uint16_t t=(uint16_t(b[0])<<8)|b[1],h=(uint16_t(b[3])<<8)|b[4];s.valid=true;s.t_mC=-45000+int(175000LL*t/65535);s.rh_raw_mPct=-6000+int(125000LL*h/65535);s.rh_mPct=s.rh_raw_mPct<0?0:(s.rh_raw_mPct>100000?100000:s.rh_raw_mPct);return s;}

// ---- main/SensorBus.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include "driver/i2c_master.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "ShtSample.h"
inline esp_err_t createBus(i2c_master_bus_handle_t* bus){i2c_master_bus_config_t c{};c.i2c_port=I2C_NUM_0;c.sda_io_num=GPIO_NUM_8;c.scl_io_num=GPIO_NUM_9;c.clk_source=I2C_CLK_SRC_DEFAULT;c.glitch_ignore_cnt=7;c.flags.enable_internal_pullup=false;return i2c_new_master_bus(&c,bus);}
inline esp_err_t addDevice(i2c_master_bus_handle_t bus,uint8_t addr,i2c_master_dev_handle_t* dev){i2c_device_config_t c{};c.dev_addr_length=I2C_ADDR_BIT_LEN_7;c.device_address=addr;c.scl_speed_hz=100000;return i2c_master_bus_add_device(bus,&c,dev);}
inline esp_err_t takeSample(i2c_master_dev_handle_t dev,ShtSample& sample){sample={};uint8_t cmd=0xfd,b[6];esp_err_t e=i2c_master_transmit(dev,&cmd,1,100);if(e!=ESP_OK)return e;vTaskDelay(pdMS_TO_TICKS(10));e=i2c_master_receive(dev,b,6,100);if(e==ESP_OK)sample=decodeSht(b);return e;}

// ---- main/main.cpp ----
// SPDX-License-Identifier: MIT
#include <cstdio>
#include <inttypes.h>
#include "sdkconfig.h"
#include "esp_sleep.h"
#include "esp_system.h"
#include "esp_timer.h"
#include "driver/uart.h"
#include "SensorBus.h"
static esp_err_t command(i2c_master_dev_handle_t dev,const uint8_t* c,size_t n){return i2c_master_transmit(dev,c,n,200);}
static esp_err_t oledPattern(i2c_master_dev_handle_t dev){
 // SSD1306 128x64, internal charge pump; 0x00 command stream, 0x40 data stream.
 const uint8_t init[]={0x00,0xae,0xd5,0x80,0xa8,0x3f,0xd3,0x00,0x40,0x8d,0x14,0x20,0x00,0xa1,0xc8,0xda,0x12,0x81,0x7f,0xd9,0xf1,0xdb,0x20,0xa4,0xa6,0x2e,0x21,0,127,0x22,0,7};
 esp_err_t e=command(dev,init,sizeof init);if(e!=ESP_OK)return e;
 uint8_t data[129];data[0]=0x40;for(int x=1;x<=128;++x)data[x]=(x&1)?0x55:0xaa;
 for(int page=0;page<8&&e==ESP_OK;++page)e=command(dev,data,sizeof data);
 if(e==ESP_OK){const uint8_t on[]={0x00,0xaf};e=command(dev,on,sizeof on);}return e;
}
extern "C" void app_main(){
 int64_t start=esp_timer_get_time();printf("L02 load=%d reset=%d wake=%d; no radio; board 5V boundary\n",CONFIG_HX_LOAD,int(esp_reset_reason()),int(esp_sleep_get_wakeup_cause()));
 vTaskDelay(pdMS_TO_TICKS(3000)); // same explicit active plateau for all three cases
 i2c_master_bus_handle_t bus=nullptr;i2c_master_dev_handle_t sensor=nullptr,oled=nullptr;bool ready=true;
 if(CONFIG_HX_LOAD>0){
  esp_err_t e=createBus(&bus);if(e==ESP_OK)e=addDevice(bus,0x44,&sensor);
  ShtSample sample;if(e==ESP_OK)e=takeSample(sensor,sample);
  ready=e==ESP_OK&&sample.valid;printf("SHT api=%s valid=%u; no stale value\n",esp_err_to_name(e),sample.valid);
  if(CONFIG_HX_LOAD==2){
   e=bus?addDevice(bus,0x3d,&oled):ESP_ERR_INVALID_STATE;
   if(e==ESP_OK)e=oledPattern(oled);
   ready=ready&&e==ESP_OK;printf("OLED pattern transfer=%s; visual result requires observation\n",esp_err_to_name(e));
   vTaskDelay(pdMS_TO_TICKS(1000));
   // Controlled sleep condition: display OFF and charge pump OFF, still powered.
   const uint8_t off[]={0x00,0xae,0x8d,0x10};esp_err_t offResult=oled?command(oled,off,sizeof off):ESP_ERR_INVALID_STATE;
   ready=ready&&offResult==ESP_OK;printf("OLED off/pump-off transfer=%s; not supply isolation\n",esp_err_to_name(offResult));
  }else vTaskDelay(pdMS_TO_TICKS(1000));
 }else vTaskDelay(pdMS_TO_TICKS(1000));
 if(oled)ESP_ERROR_CHECK(i2c_master_bus_rm_device(oled));
 if(sensor)ESP_ERROR_CHECK(i2c_master_bus_rm_device(sensor));
 if(bus)ESP_ERROR_CHECK(i2c_del_master_bus(bus));
 if(!ready){puts("INVALID comparison: peripheral failure; remain awake for diagnosis, no valid sleep-current baseline");return;}
 ESP_ERROR_CHECK(esp_sleep_enable_timer_wakeup(30000000ULL));
 printf("SLEEP_REQUEST active_app_us=%" PRId64 " timer_us=30000000; boot time excluded, current unmeasured\n",esp_timer_get_time()-start);fflush(stdout);ESP_ERROR_CHECK(uart_wait_tx_idle_polling(UART_NUM_0));esp_deep_sleep_start();
}

# ---- tools/integrate.py ----
# SPDX-License-Identifier: MIT
"""Integrate normalized samples. Outputs are calculations, never fabricated measurements."""
import argparse,csv,json,math
from pathlib import Path

def integrate(rows,max_gap):
    samples=[]
    for row in rows:
        t,i,v=(float(row[k]) for k in ('time_s','current_mA','voltage_V'))
        if not all(math.isfinite(x) for x in (t,i,v)) or t<0 or i<0 or v<=0:
            raise ValueError('finite t>=0, current>=0, voltage>0 required; inspect offset rather than silently clipping')
        if samples and t<=samples[-1][0]:raise ValueError('time must strictly increase')
        samples.append((t,i,v))
    if len(samples)<2:raise ValueError('at least two real samples required; empty template is not a result')
    charge=energy=0.0;gap_max=0.0
    for (t0,i0,v0),(t1,i1,v1) in zip(samples,samples[1:]):
        dt=t1-t0
        if dt>max_gap:raise ValueError('sample gap exceeds explicit --max-gap-s; do not bridge missing data')
        gap_max=max(gap_max,dt);charge+=(i0+i1)*0.5*dt;energy+=(i0*v0+i1*v1)*0.5*dt
    seconds=samples[-1][0]-samples[0][0]
    return dict(duration_s=seconds,charge_mC=charge,charge_mAh=charge/3600,energy_mJ=energy,energy_Wh=energy/3600000,average_mA=charge/seconds,sampled_peak_mA=max(s[1] for s in samples),max_gap_s=gap_max,samples=len(samples),method='trapezoids over actual timestamps; sampled peak is bandwidth-limited')

def main():
    ap=argparse.ArgumentParser();ap.add_argument('csv');ap.add_argument('--max-gap-s',type=float,required=True);a=ap.parse_args()
    if not math.isfinite(a.max_gap_s) or a.max_gap_s<=0:ap.error('positive finite max-gap-s required')
    try:
        with open(a.csv,newline='',encoding='utf-8-sig') as f:r=integrate(csv.DictReader(f),a.max_gap_s)
    except (ValueError,KeyError) as e:ap.error(str(e))
    r['input']=str(Path(a.csv));print(json.dumps(r,ensure_ascii=False,indent=2))
if __name__=='__main__':main()

python3 tools/normalize_csv.py raw.csv samples-normalized.csv --time-column "实际时间列名" --time-unit us --current-column "实际电流列名" --current-unit uA --voltage-v 实测板端电压
python3 tools/integrate.py samples-normalized.csv --max-gap-s 0.001
python3 tests/integration_test.py
python3 tools/integrate.py tests/fixtures/SYNTHETIC-constant.csv --max-gap-s 1