不用机械按钮：用 ESP32-S3 做一个触摸开关

// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
struct TouchCalibration {
  static constexpr unsigned SAMPLES=64;
  unsigned count=0;
  uint64_t sum=0;
  uint32_t lo=UINT32_MAX,hi=0,baseline=0,on=0,off=0;
  bool failed=false;
  void add(uint32_t raw) {
    if(count>=SAMPLES||failed)return;
    if(raw==0||raw==UINT32_MAX){failed=true;return;}
    sum+=raw;if(raw<lo)lo=raw;if(raw>hi)hi=raw;++count;
  }
  bool finish() {
    if(failed||count!=SAMPLES)return false;
    baseline=uint32_t(sum/SAMPLES);
    uint64_t noise=hi-lo;
    // Starting heuristics, not measured universal thresholds.
    if(noise>baseline/5){failed=true;return false;}
    uint64_t on_delta=baseline/4,off_delta=baseline/10;
    if(on_delta<noise*6)on_delta=noise*6;
    if(off_delta<noise*3)off_delta=noise*3;
    if(on_delta<100)on_delta=100;
    if(off_delta<50)off_delta=50;
    uint64_t a=uint64_t(baseline)+on_delta,b=uint64_t(baseline)+off_delta;
    if(a>=UINT32_MAX||b>=a){failed=true;return false;}
    on=uint32_t(a);off=uint32_t(b);return true;
  }
};
class TouchGate {
 public:
  enum Event{NONE,DOWN,UP,INVALID};
  TouchGate(uint32_t on,uint32_t off):on_(on),off_(off){}
  Event update(uint32_t raw){
    if(raw==0||raw==UINT32_MAX){active_=false;run_=0;return INVALID;}
    bool candidate=active_?(raw<=off_):(raw>=on_);
    if(!candidate){run_=0;return NONE;}
    if(++run_<5)return NONE;
    run_=0;active_=!active_;return active_?DOWN:UP;
  }
  bool active()const{return active_;}
 private:
  uint32_t on_,off_;
  bool active_=false;
  uint8_t run_=0;
};

// One-time startup phase; bounded 20ms sampling still uses uint32 subtraction.
class TouchSchedule {
 public:
  void reset(uint32_t now){started_=last_sample_=now;settled_=false;}
  bool sample_due(uint32_t now){
    if(!settled_){
      if(uint32_t(now-started_)<2000)return false;
      settled_=true;
    }
    if(uint32_t(now-last_sample_)<20)return false;
    last_sample_=now;return true;
  }
  bool settled()const{return settled_;}
 private:
  uint32_t started_=0,last_sample_=0;
  bool settled_=false;
};

// ---- touch_config.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
// Keep false for the first recorded experiment. After measuring both ranges,
// choose baseline < OFF < ON with idle_max < OFF < ON < touch_min.
constexpr bool USE_MANUAL_THRESHOLDS=false;
constexpr uint32_t MANUAL_ON=0;  // Replace only with your own measured choice.
constexpr uint32_t MANUAL_OFF=0;

// ---- esp32-s3-touch-switch.ino ----
// SPDX-License-Identifier: MIT
#include <Arduino.h>
#include "TouchLogic.h"
#include "touch_config.h"
#if !defined(CONFIG_IDF_TARGET_ESP32S3)
#error "This experiment is locked to ESP32-S3; do not copy its touch direction to other chips."
#endif
constexpr int TOUCH_PIN=6, LED_PIN=4;
TouchCalibration calibration;
TouchGate gate(1,0);
bool ready=false,fault=false,led=false;
TouchSchedule schedule;
uint32_t lastLog=0;

void restartCalibration(){
  calibration=TouchCalibration{};gate=TouchGate(1,0);
  ready=false;fault=false;led=false;digitalWrite(LED_PIN,LOW);
  uint32_t now=millis();schedule.reset(now);lastLog=now;
  Serial.println("CAL release electrode; settle 2000 ms then 64 samples at 20 ms");
}
void setup(){
  pinMode(LED_PIN,OUTPUT);digitalWrite(LED_PIN,LOW);
  Serial.begin(115200);
  restartCalibration();
}
void loop(){
  for(unsigned n=0;n<8&&Serial.available()>0;++n){
    if(Serial.read()=='c')restartCalibration();
  }
  uint32_t now=millis();
  if(fault||!schedule.sample_due(now)){delay(1);return;}
  uint32_t raw=touchRead(TOUCH_PIN); // ESP32-S3: uint32_t raw increases with touch.
  if(!ready){
    calibration.add(raw);
    if(calibration.failed){fault=true;Serial.println("FAULT raw invalid; inspect wiring then release and send c");}
    else if(calibration.count==TouchCalibration::SAMPLES){
      if(!calibration.finish()){
        fault=true;Serial.println("FAULT noisy/overflow calibration; release electrode and send c");
      }else{
        if(USE_MANUAL_THRESHOLDS){
          if(MANUAL_ON<=MANUAL_OFF||MANUAL_OFF<=calibration.baseline||MANUAL_ON==UINT32_MAX){
            fault=true;Serial.println("FAULT manual thresholds require baseline < OFF < ON < UINT32_MAX");
          }else{calibration.on=MANUAL_ON;calibration.off=MANUAL_OFF;}
        }
        if(!fault){
          gate=TouchGate(calibration.on,calibration.off);ready=true;
          Serial.printf("READY baseline=%lu idle_min=%lu idle_max=%lu ON=%lu OFF=%lu\n",
            (unsigned long)calibration.baseline,(unsigned long)calibration.lo,
            (unsigned long)calibration.hi,(unsigned long)calibration.on,(unsigned long)calibration.off);
          Serial.println("ms,raw,baseline,on,off,touch_active,led_latch");
        }
      }
    }
  }else{
    auto event=gate.update(raw);
    if(event==TouchGate::INVALID){
      fault=true;led=false;digitalWrite(LED_PIN,LOW);
      Serial.println("FAULT raw invalid LED=0; release and send c");
    }else if(event==TouchGate::DOWN){
      led=!led;digitalWrite(LED_PIN,led?HIGH:LOW);
      Serial.printf("TOUCH_DOWN led_latch=%d\n",led);
    }else if(event==TouchGate::UP){Serial.println("TOUCH_UP");}
    if(uint32_t(now-lastLog)>=100){
      lastLog=now;
      Serial.printf("%lu,%lu,%lu,%lu,%lu,%d,%d\n",(unsigned long)now,(unsigned long)raw,
        (unsigned long)calibration.baseline,(unsigned long)calibration.on,
        (unsigned long)calibration.off,gate.active(),led);
    }
  }
  delay(1);
}

arduino-cli compile --fqbn 'esp32:esp32:esp32s3:FlashSize=8M,PSRAM=opi,FlashMode=qio,PartitionScheme=default_8MB,CDCOnBoot=default,USBMode=hwcdc' .
clang++ -std=c++17 -Wall -Wextra -Werror tests/touch_test.cpp -o /tmp/p10-test
/tmp/p10-test
clang++ -std=c++17 -DCONFIG_IDF_TARGET_ESP32S3 -Itests/stubs tests/production_loop.cpp -o /tmp/p10-loop
/tmp/p10-loop