ESP32播放WAV：先用低幅测试音确认数字功放输出链

// ---- esp32-i2s-wav-playback.ino ----
// A02: no auto playback. Input file is never presumed to be microphone evidence.
#include <Arduino.h>
#include <SPI.h>
#include <SD.h>
#include <driver/i2s_std.h>
#include <esp_timer.h>
#include "audio_core.h"
#include "playback_gate.h"
using namespace audioio;
constexpr int Bclk=15,Ws=16,Dout=7,Shutdown=17,Arm=4,Play=5,Sck=12,Miso=13,Mosi=11,Cs=10;
constexpr const char* Input="/sd/SYNTH.WAV";
static i2s_chan_handle_t tx=nullptr;
static bool mounted=false;
static PlaybackGate gate;
static unsigned routeMode=0; //0 left,1 right,2 arithmetic average; mono duplicated.
static uint8_t input[1024];
static int32_t slots[512];
static bool enabled(){return gate.armed&&digitalRead(Arm)==LOW;}
static void mute(){digitalWrite(Shutdown,LOW);}
static bool startTX(uint32_t rate){
 i2s_chan_config_t c=I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_AUTO,I2S_ROLE_MASTER);
 c.dma_desc_num=6;c.dma_frame_num=256;c.auto_clear_after_cb=true;
 if(i2s_new_channel(&c,&tx,nullptr)!=ESP_OK)return false;
 i2s_std_config_t s={};s.clk_cfg=I2S_STD_CLK_DEFAULT_CONFIG(rate);
 s.slot_cfg=I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_32BIT,I2S_SLOT_MODE_STEREO);
 s.gpio_cfg.mclk=I2S_GPIO_UNUSED;s.gpio_cfg.bclk=gpio_num_t(Bclk);s.gpio_cfg.ws=gpio_num_t(Ws);s.gpio_cfg.dout=gpio_num_t(Dout);s.gpio_cfg.din=I2S_GPIO_UNUSED;
 return i2s_channel_init_std_mode(tx,&s)==ESP_OK&&i2s_channel_enable(tx)==ESP_OK;
}
static void stopTX(){
 mute();if(tx){i2s_channel_disable(tx);i2s_del_channel(tx);tx=nullptr;}
 pinMode(Bclk,OUTPUT);digitalWrite(Bclk,LOW);pinMode(Ws,OUTPUT);digitalWrite(Ws,LOW);pinMode(Dout,OUTPUT);digitalWrite(Dout,LOW);
}
static bool sendSlots(size_t frames){
 if(!enabled()){mute();return false;}size_t sent=0;size_t want=frames*8;
 esp_err_t e=i2s_channel_write(tx,slots,want,&sent,500);
 if(e!=ESP_OK||sent!=want||!enabled()){
  mute();Serial.printf("TX_ABORT err=%s accepted=%u want=%u arm=%u\n",esp_err_to_name(e),unsigned(sent),unsigned(want),unsigned(enabled()));return false;
 }
 return true;
}
static bool zeros(uint32_t frames){
 memset(slots,0,sizeof(slots));while(frames){size_t k=min(size_t(256),size_t(frames));if(!sendSlots(k))return false;frames-=uint32_t(k);}return true;
}
static void playWav(){
 mute();FILE* f=fopen(Input,"rb");if(!f){Serial.println("OPEN_ABORT: /sd/SYNTH.WAV not found");gate.abort();return;}
 Wav w;const char* error=parse(f,w);
 if(error){Serial.printf("FORMAT_ABORT %s; amp stays muted\n",error);fclose(f);gate.abort();return;}
 Serial.printf("FILE_VALID rate=%lu channels=%u frames=%lu route=%u; acoustic=UNTESTED\n",(unsigned long)w.rate,w.channels,(unsigned long)w.frames,routeMode);
 bool ok=enabled()&&startTX(w.rate);
 if(ok)ok=zeros(1536); // Prime at least the configured DMA capacity with zeros while muted.
 if(ok&&enabled()){
  digitalWrite(Shutdown,HIGH); // External10k pulldown +1k series; driven3.3V selects LEFT.
  delay(20); // Amp datasheet turn-on max7.5ms at stated test conditions; generous software wait, not measured.
  ok=enabled()&&zeros(w.rate/50);
 }
 uint32_t remain=w.frames,queued=0;
 while(ok&&remain){
  size_t k=min(size_t(256),size_t(remain));size_t bytes=k*w.channels*2;
  if(!enabled()||fread(input,1,bytes,f)!=bytes){ok=false;break;}
  for(size_t n=0;n<k;n++){
   int16_t l=int16_t(le16(input+n*w.channels*2));int16_t rr=w.channels==2?int16_t(le16(input+n*4+2)):l;
   int16_t y=output(route(l,rr,routeMode));int32_t word=int32_t(y)*65536;
   slots[2*n]=word;slots[2*n+1]=word; //32bit stereo Philips slots; same routed mono into both.
  }
  ok=sendSlots(k);if(ok){remain-=uint32_t(k);queued+=uint32_t(k);}
 }
 // Sending zeros beyond a ring capacity lets prior data leave the software/DMA pipeline.
 // This is not a hardware audio-completion acknowledgment; headphone/line inputs are forbidden.
 if(ok)ok=zeros(1536+256);
 if(ok){for(unsigned n=0;n<100&&enabled();n++)delay(2);if(!enabled())ok=false;}
 stopTX();if(fclose(f)!=0)ok=false;
 if(!ok){gate.abort();} // An aborted session requires an observed release then fresh ARM.
 Serial.printf("%s queued_frames=%lu expected=%lu; I2S_ACCEPTED_NOT_ACOUSTIC_PROOF\n",ok?"PLAY_FINISHED":"PLAY_ABORTED",(unsigned long)queued,(unsigned long)w.frames);
}
void setup(){
 digitalWrite(Shutdown,LOW);pinMode(Shutdown,OUTPUT); // Hardware10k pulldown keeps reset high-Z muted too.
 pinMode(Arm,INPUT);pinMode(Play,INPUT); //Each external10k to3V3, switch/button toGND.
 Serial.begin(115200);SPI.begin(Sck,Miso,Mosi,Cs);mounted=SD.begin(Cs,SPI,4000000,"/sd",5,false);
 Serial.printf("A02 Arduino3.3.12 IDF%s SD=%s; release ARM and PLAY at boot; ARM then fresh PLAY; l/r/m selects file channel while idle\n",esp_get_idf_version(),mounted?"READY":"FAILED");
}
void loop(){
 uint64_t now=uint64_t(esp_timer_get_time())/1000;
 bool armDown=digitalRead(Arm)==LOW;
 if(!armDown)mute();
 bool wasArmed=gate.armed;
 bool play=gate.update(armDown,digitalRead(Play)==LOW,now);
 if(!wasArmed&&gate.armed)Serial.println("ARMED; observe PLAY released50ms, then fresh PLAY");
 if(Serial.available()){
  int c=Serial.read();if(c=='l')routeMode=0;if(c=='r')routeMode=1;if(c=='m')routeMode=2;
  if(c=='l'||c=='r'||c=='m')Serial.printf("ROUTE=%u (left/right/average); amplifier physical LEFT output\n",routeMode);
 }
 if(play&&enabled()&&mounted)playWav();delay(2);
}

// ---- audio_core.h ----
#pragma once
// Original MIT code. Same header is compiled on ESP32 and in the desktop fixtures.
#include <stdint.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
namespace audioio {
constexpr uint32_t Rate=32000, CaptureFrames=Rate*10, MaxFile=8*1024*1024;
inline uint16_t le16(const uint8_t* p){return uint16_t(p[0])|(uint16_t(p[1])<<8);}
inline uint32_t le32(const uint8_t* p){return uint32_t(p[0])|(uint32_t(p[1])<<8)|(uint32_t(p[2])<<16)|(uint32_t(p[3])<<24);}
inline void put16(uint8_t* p,uint16_t n){p[0]=uint8_t(n);p[1]=uint8_t(n>>8);}
inline void put32(uint8_t* p,uint32_t n){for(unsigned i=0;i<4;i++)p[i]=uint8_t(n>>(8*i));}
inline bool rateOK(uint32_t n){return n==16000||n==32000||n==48000;}
inline void header(uint8_t* h,uint32_t rate,uint16_t channels,uint32_t bytes){
 memset(h,0,44);memcpy(h,"RIFF",4);put32(h+4,36+bytes);memcpy(h+8,"WAVEfmt ",8);put32(h+16,16);
 put16(h+20,1);put16(h+22,channels);put32(h+24,rate);put32(h+28,rate*channels*2);put16(h+32,channels*2);put16(h+34,16);memcpy(h+36,"data",4);put32(h+40,bytes);
}
struct Wav {uint32_t rate=0,offset=0,bytes=0,frames=0;uint16_t channels=0;};
// Bounded, little-endian RIFF/WAVE PCM16 subset. Unknown chunks are skipped with padding.
inline const char* parse(FILE* f,Wav& w){
 w=Wav{};if(!f||fseek(f,0,SEEK_END))return "SEEK";long end=ftell(f);if(end<44||uint64_t(end)>MaxFile)return "FILE_SIZE";
 if(fseek(f,0,SEEK_SET))return "SEEK";uint8_t h[12];if(fread(h,1,12,f)!=12)return "READ";
 if(memcmp(h,"RIFF",4)||memcmp(h+8,"WAVE",4))return "RIFF_WAVE";
 if(uint64_t(le32(h+4))+8!=uint64_t(end))return "RIFF_SIZE";
 bool fmt=false,data=false;uint32_t pos=12;
 while(pos<uint32_t(end)){
  if(uint32_t(end)-pos<8||fseek(f,long(pos),SEEK_SET))return "CHUNK_HEADER";
  uint8_t c[8];if(fread(c,1,8,f)!=8)return "READ";uint32_t n=le32(c+4);uint64_t next=uint64_t(pos)+8+n+(n&1u);
  if(next>uint64_t(end))return "CHUNK_BOUNDS";
  if(!memcmp(c,"fmt ",4)){
   if(fmt||data||n!=16)return "FMT_SUBSET";uint8_t v[16];if(fread(v,1,16,f)!=16)return "READ";
   uint16_t ch=le16(v+2),align=le16(v+12);uint32_t rate=le32(v+4);
   if(le16(v)!=1||le16(v+14)!=16||(ch!=1&&ch!=2)||!rateOK(rate)||align!=ch*2||le32(v+8)!=rate*align)return "PCM_SUBSET";
   w.rate=rate;w.channels=ch;fmt=true;
  }else if(!memcmp(c,"data",4)){
   if(!fmt||data||!n||n%(w.channels*2))return "DATA_SUBSET";
   w.offset=pos+8;w.bytes=n;w.frames=n/(w.channels*2);data=true;
   if(w.frames>15*w.rate)return "DURATION_LIMIT";
  }
  pos=uint32_t(next);
 }
 if(!fmt||!data)return "MISSING_CHUNK";if(fseek(f,long(w.offset),SEEK_SET))return "SEEK";return nullptr;
}
// A 24-bit signed microphone word occupies bits31..8 of the captured left 32-bit slot.
inline int32_t mic24(uint32_t slot){uint32_t n=slot>>8;return n&0x800000u?int32_t(n)-16777216:int32_t(n);}
struct CaptureDSP {
 int64_t dcQ16=0;uint32_t clipped=0;int32_t peak24=0;
 // DC EMA alpha=1/1024 at32kHz (~5Hz corner); gainQ8=256 means unity.
 int16_t sample(uint32_t slot,uint16_t gainQ8=256,bool removeDC=true){
  int32_t x=mic24(slot);int32_t a=x<0?-x:x;if(a>peak24)peak24=a;
  if(removeDC){dcQ16+=(int64_t(x)*65536-dcQ16)/1024;x-=int32_t(dcQ16/65536);}
  int64_t y=int64_t(x)*gainQ8/65536;
  if(y>32767){y=32767;clipped++;}if(y< -32768){y=-32768;clipped++;}return int16_t(y);
 }
};
// Fixed -24.08dB attenuation, then hard limit. This is not acoustic-volume calibration.
inline int16_t output(int16_t sample){int32_t n=int32_t(sample)/16;if(n>2048)n=2048;if(n< -2048)n=-2048;return int16_t(n);}
inline int16_t route(int16_t left,int16_t right,unsigned mode){return mode==0?left:mode==1?right:int16_t((int32_t(left)+right)/2);}
struct Press {
 bool raw=false,stable=false,released=false,initialized=false;uint64_t at=0;
 bool update(bool down,uint64_t now){
  if(!initialized){initialized=true;raw=stable=down;at=now;return false;}
  if(down!=raw){raw=down;at=now;}
  if(now-at<50)return false;
  if(!raw)released=true;
  if(raw==stable)return false;stable=raw;
  if(stable&&released){released=false;return true;}return false;
 }
};
}

// ---- playback_gate.h ----
#pragma once
#include "audio_core.h"
namespace audioio {
struct PlaybackGate {
 Press armPress,playPress;bool armed=false;
 bool update(bool armDown,bool playDown,uint64_t now){
  if(!armDown)armed=false;
  if(armPress.update(armDown,now)){armed=true;playPress=Press{};}
  bool press=playPress.update(playDown,now);
  return armed&&armDown&&press;
 }
 void abort(){armed=false;armPress=Press{};playPress=Press{};}
};
}

arduino-cli version
arduino-cli core list
FQBN='esp32:esp32:esp32s3:FlashSize=8M,PSRAM=opi,FlashMode=qio,PartitionScheme=default_8MB,CDCOnBoot=default,USBMode=hwcdc'
arduino-cli compile --fqbn "$FQBN" --build-path build --warnings all .
arduino-cli upload --fqbn "$FQBN" --input-dir build --port PORT .
arduino-cli monitor --port PORT --config baudrate=115200

clang++ -std=c++17 -Wall -Wextra -Werror -fsanitize=address,undefined -fno-omit-frame-pointer tests/host.cpp -o /tmp/audioio-check
/tmp/audioio-check
python3 tools/audio_tool.py self-test --checker /tmp/audioio-check
python3 tools/audio_tool.py tone SYNTH.WAV --rate 32000
python3 tools/audio_tool.py inspect SYNTH.WAV
python3 tools/waveform.py SYNTH.WAV synthetic-first100ms.svg
/tmp/audioio-check SYNTH.WAV

python3 tests/preflight_body.py --output /tmp/a02-preflight-check

git clone https://github.com/arduino/ctags.git .ctags-src
git -C .ctags-src checkout abc8fca7499f44c725122881cd380a88c37abe0e
cd .ctags-src
./configure CC=clang CFLAGS='-O2 -arch arm64' --prefix="$PWD/../.ctags-native"
make -j2 CFLAGS='-O2 -arch arm64 -include dirent.h'
make install
cd ..
.ctags-native/bin/ctags --version
arduino-cli compile --fqbn "$FQBN" --build-path build --verbose --build-property "runtime.tools.ctags.path=$PWD/.ctags-native/bin" --build-property "runtime.tools.ctags-5.8-arduino11.path=$PWD/.ctags-native/bin" .