ESP32 做 CO₂ 桌面提醒器：用 SCD41 看通风变化

arduino-cli compile --profile s3-n8r8 .
arduino-cli upload --profile s3-n8r8 --port PORT .
arduino-cli monitor --port PORT --config baudrate=115200

// SPDX-License-Identifier: MIT
#include <Arduino.h>
#include <Wire.h>
#include <SensirionI2cScd4x.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "co2_state.h"
constexpr uint8_t LED_PIN=4;
SensirionI2cScd4x sensor;
Adafruit_SSD1306 screen(128,64,&Wire,-1,100000UL,100000UL);
s03::State state;
bool running=false,screen_ok=false;
uint64_t last_poll=0,last_screen=0,last_retry=0;
uint32_t sequence=0;
float last_t=NAN,last_rh=NAN;
static void report_error(const char* phase,int16_t error){
 char text[96];errorToString(error,text,sizeof(text));
 Serial.printf("ERROR phase=%s code=%d detail=%s; no valid new sample\n",phase,error,text);
 state.fail();
}
static bool start_sensor(){
 // This example never issues FRC, factory reset or persist_settings.
 int16_t error=sensor.stopPeriodicMeasurement(); // driver waits required 500ms
 if(error){report_error("stop",error);return false;}
 error=sensor.reinit();if(error){report_error("reinit",error);return false;}
 uint64_t serial=0;error=sensor.getSerialNumber(serial);
 if(error){report_error("serial",error);return false;}
 error=sensor.setAutomaticSelfCalibrationEnabled(0);
 if(error){report_error("ASC-off",error);return false;}
 uint16_t asc=1;error=sensor.getAutomaticSelfCalibrationEnabled(asc);
 if(error||asc!=0){if(error)report_error("ASC-readback",error);else state.fail();return false;}
 error=sensor.startPeriodicMeasurement();if(error){report_error("start",error);return false;}
 state.start(s03::now_ms());
 Serial.printf("START serial=%04lx%08lx ASC=0 RAM-only settle_ms=%lu first data requires ready\n",(unsigned long)(serial>>32),(unsigned long)serial,(unsigned long)s03::SETTLE_MS);
 return true;
}
void setup(){
 pinMode(LED_PIN,OUTPUT);digitalWrite(LED_PIN,LOW);Serial.begin(115200);
 Wire.begin(8,9,100000);Wire.setTimeOut(50);
 screen_ok=screen.begin(SSD1306_SWITCHCAPVCC,0x3D,true,false);
 if(screen_ok){screen.clearDisplay();screen.setTextColor(SSD1306_WHITE);screen.setTextSize(1);screen.setCursor(0,0);screen.println("S03 starting...");screen.display();}
 else Serial.println("OLED allocation/init failed; serial and local LED continue");
 sensor.begin(Wire,SCD41_I2C_ADDR_62);delay(30);
 running=start_sensor();last_retry=s03::now_ms();
}
void loop(){
 uint64_t now=s03::now_ms();
 if(!running&&(now-last_retry)>=10000){last_retry=now;running=start_sensor();}
 if(running&&(now-last_poll)>=500){
  last_poll=now;bool ready=false;int16_t error=sensor.getDataReadyStatus(ready);
  if(error)report_error("ready",error);
  else if(ready){
   uint16_t co2=0;float t=NAN,rh=NAN;error=sensor.readMeasurement(co2,t,rh);
   if(error)report_error("read",error);
   else if(state.accept(s03::now_ms(),co2,t,rh)){
    last_t=t;last_rh=rh;
    Serial.printf("sample,%lu,%llu,%u,%.2f,%.2f,%s,ASC_OFF\n",(unsigned long)++sequence,(unsigned long long)s03::now_ms(),co2,t,rh,state.label(s03::now_ms()));
   }else Serial.println("INVALID sample rejected");
  }
 }
 now=s03::now_ms();digitalWrite(LED_PIN,state.led(now)?HIGH:LOW);
 if((now-last_screen)>=1000){
  last_screen=now;Serial.printf("status,%llu,%s,age_ms=%llu; physical outputs unverified\n",(unsigned long long)now,state.label(now),state.seen?(unsigned long long)(now-state.last):0ULL);
  if(screen_ok){
   screen.clearDisplay();screen.setCursor(0,0);screen.printf("S03 %s\n",state.label(now));
   if(state.seen){screen.printf("%s CO2 %u ppm\n",state.fresh(now)?"FRESH":"LAST",state.ppm);screen.printf("T %.1f C RH %.1f%%\n",last_t,last_rh);screen.printf("age %llu s\n",(unsigned long long)((now-state.last)/1000));}
   else screen.println("CO2 -- ppm");
   screen.println("ASC off / RAM only");screen.println("demo on1200 off1000");screen.display();
  }
 }
 delay(5);
}

// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
#include <math.h>
#ifdef ESP_PLATFORM
#include "esp_timer.h"
#endif
namespace s03 {
constexpr uint32_t SETTLE_MS=180000, STALE_MS=15000;
#ifdef ESP_PLATFORM
// Convert the full IDF boot-time value before any narrowing; resets on reboot.
inline uint64_t now_ms(){return static_cast<uint64_t>(esp_timer_get_time())/1000ULL;}
#endif
struct State {
 uint64_t started=0,last=0; uint16_t ppm=0; bool seen=false,error=false,remind=false;
 void start(uint64_t now){*this=State();started=now;}
 void fail(){error=true;remind=false;}
 bool settled(uint64_t now)const{return now>=started&&now-started>=SETTLE_MS;}
 bool accept(uint64_t now,uint16_t co2,float temperature,float rh){
  if(co2==0||co2>40000||!isfinite(temperature)||!isfinite(rh)||rh<0||rh>100){fail();return false;}
  ppm=co2;last=now;seen=true;error=false;
  if(settled(now)){if(ppm>=1200)remind=true;else if(ppm<=1000)remind=false;}
  return true;
 }
 bool fresh(uint64_t now)const{return seen&&!error&&now>=last&&now-last<=STALE_MS;}
 const char* label(uint64_t now)const{
  if(error)return "READ_ERROR";
  if(!seen)return now>=started&&now-started>STALE_MS?"NO_SAMPLE":"WAIT_READY";
  if(!fresh(now))return "STALE";
  if(!settled(now))return "SETTLING";
  return remind?"VENT_REMIND":"OBSERVE";
 }
 bool fault(uint64_t now)const{return error||(seen?!fresh(now):(now>=started&&now-started>STALE_MS));}
 bool led(uint64_t now)const{return fault(now)?((now/250)%2):fresh(now)&&settled(now)&&remind;}
};
}

clang++ -std=c++17 -Wall -Wextra -Werror host_check.cpp -o /tmp/s03-host
/tmp/s03-host
clang++ -std=c++17 -DESP_PLATFORM -Itests/stubs tests/production_loop.cpp -o /tmp/s03-loop
/tmp/s03-loop