ESP32 定时唤醒：采一次温湿度就回去睡觉

// ---- 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/CycleRecord.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
struct CycleRecord { uint32_t magic,version,cycle,success,check; };
inline uint32_t recordCheck(const CycleRecord& r){uint32_t c=0x811c9dc5U;const uint32_t v[]={r.magic,r.version,r.cycle,r.success};for(auto w:v)for(int i=0;i<4;++i){c^=uint8_t(w>>(8*i));c*=16777619U;}return c;}
inline bool recordValid(const CycleRecord& r){return r.magic==0x4c503033U&&r.version==1&&r.success<=r.cycle&&r.check==recordCheck(r);}
inline bool beginCycle(CycleRecord& r,bool expectedDeepWake){bool continued=expectedDeepWake&&recordValid(r)&&r.cycle!=UINT32_MAX;if(!continued)r={0x4c503033U,1,0,0,0};++r.cycle;r.check=recordCheck(r);return continued;}
inline void finishCycle(CycleRecord& r,bool success){if(success&&r.success<r.cycle)++r.success;r.check=recordCheck(r);}

// ---- main/main.cpp ----
// SPDX-License-Identifier: MIT
#include <cstdio>
#include <inttypes.h>
#include "esp_sleep.h"
#include "esp_system.h"
#include "esp_timer.h"
#include "driver/uart.h"
#include "SensorBus.h"
#include "CycleRecord.h"
RTC_DATA_ATTR static CycleRecord record{};
extern "C" void app_main(){
 int64_t start=esp_timer_get_time();auto reset=esp_reset_reason();auto wake=esp_sleep_get_wakeup_cause();
 bool continued=beginCycle(record,reset==ESP_RST_DEEPSLEEP&&wake==ESP_SLEEP_WAKEUP_TIMER);
 printf("L03 reset=%d wake=%d session=%s cycle=%" PRIu32 " prior_success=%" PRIu32 "\n",int(reset),int(wake),continued?"CONTINUED":"NEW",record.cycle,record.success);
 if(!continued)vTaskDelay(pdMS_TO_TICKS(5000)); // first boot/RESET recovery window, not on normal timer wakes
 i2c_master_bus_handle_t bus=nullptr;i2c_master_dev_handle_t dev=nullptr;ShtSample sample;
 esp_err_t e=createBus(&bus);if(e==ESP_OK)e=addDevice(bus,0x44,&dev);if(e==ESP_OK)e=takeSample(dev,sample);
 finishCycle(record,e==ESP_OK&&sample.valid);
 if(e==ESP_OK&&sample.valid)printf("VALID T_mC=%d RH_raw_mPct=%d RH_display_mPct=%d\n",sample.t_mC,sample.rh_raw_mPct,sample.rh_mPct);
 else printf("ERROR I2C=%s CRC_valid=%u T=NA RH=NA; sleep still scheduled\n",esp_err_to_name(e),sample.valid);
 if(dev)ESP_ERROR_CHECK(i2c_master_bus_rm_device(dev));
 if(bus)ESP_ERROR_CHECK(i2c_del_master_bus(bus));
 ESP_ERROR_CHECK(esp_sleep_enable_timer_wakeup(60000000ULL));
 printf("END cycle=%" PRIu32 " success=%" PRIu32 " active_app_us=%" PRId64 " sleep_request_us=60000000; period includes boot+active+sleep\n",record.cycle,record.success,esp_timer_get_time()-start);
 fflush(stdout);ESP_ERROR_CHECK(uart_wait_tx_idle_polling(UART_NUM_0));esp_deep_sleep_start();
}

idf.py --version
idf.py -B build -D IDF_TARGET=esp32s3 build
idf.py -B build -p PORT flash monitor

# ---- tools/verify_cycles.py ----
# SPDX-License-Identifier: MIT
import argparse,csv

def verify(rows,required):
    if len(rows)<required:raise ValueError('not enough actual rows')
    run=rows[0]['run_id']
    if not run:raise ValueError('run_id required')
    previous=None
    for row in rows:
        if row['run_id']!=run:raise ValueError('mixed sessions')
        n=int(row['cycle'])
        if not 1<=n<=0xFFFFFFFF:raise ValueError('cycle must be firmware uint32 range 1..4294967295')
        if previous is not None and n!=previous+1:raise ValueError('nonconsecutive cycle')
        previous=n
        if row['reset']!='DEEPSLEEP' or row['wake']!='TIMER' or row['valid']!='1':raise ValueError('not a successful timer wake')
        if int(row['active_app_us'])<=0:raise ValueError('actual active time required')
    return len(rows)

def main():
    ap=argparse.ArgumentParser();ap.add_argument('csv');ap.add_argument('--required',type=int,default=30);a=ap.parse_args()
    if a.required<1:ap.error('required >=1')
    try:
        with open(a.csv,newline='') as f:n=verify(list(csv.DictReader(f)),a.required)
    except (KeyError,ValueError) as e:ap.error(str(e))
    print('PASS input records:',n,'consecutive valid TIMER/DEEPSLEEP; authenticity and current measurement require original logs')
if __name__=='__main__':main()