语音前端AFE做什么？先把降噪和VAD结果看见

python3 tools/inspect_wav.py A03_q_000_RAW.WAV
python3 tools/inspect_wav.py A03_q_000_AFE.WAV
python3 tools/check_recording.py --output /tmp/a03-commit-check
python3 tools/inspect_models.py build/srmodels/srmodels.bin --expect '' --model-root managed_components/espressif__esp-sr/model

// ---- main/main.c ----
// Copyright2026 hixinwu. SPDX-License-Identifier: MIT
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdatomic.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "esp_heap_caps.h"
#include "esp_afe_sr_iface.h"
#include "esp_afe_sr_models.h"
#include "esp_mn_models.h"
#include "esp_mn_speech_commands.h"
#include "board_audio.h"
#include "speech_state.h"
#define PROJECT_ID "A03"
#define COMMANDS 0
static const char *TAG=PROJECT_ID;
static const esp_afe_sr_iface_t *afe;
static esp_afe_sr_data_t *ad;
static atomic_bool failed;
static int feed_n;
static uint64_t now_us(void){return (uint64_t)esp_timer_get_time();}
static void fail(const char *why){atomic_store(&failed,true);ESP_LOGE(TAG,"FAULT %s; no inferred hardware result; RESET after repair",why);}

#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
#define SAMPLES 160000u
#define MAX_EVENTS 2000u
static int16_t *raw_capture,*out_capture;
typedef struct{uint32_t sample;uint32_t samples;uint64_t software_us;int vad;float volume;} event_t;
static event_t *events;
static atomic_bool capturing;
static atomic_uint generation,raw_done,out_done,event_done;
static atomic_ullong raw_first_us,out_first_us;
static uint32_t raw_pos,out_pos,event_pos,raw_gen,out_gen;
static void raw_save(const int16_t *data,size_t n){
    if(atomic_load(&failed)||!atomic_load(&capturing)){return;}
    unsigned gen=atomic_load(&generation);if(raw_gen!=gen){raw_gen=gen;raw_pos=0;}
    if(raw_pos==SAMPLES){return;}
    if(raw_pos==0)atomic_store(&raw_first_us,now_us());
    if(n>SAMPLES-raw_pos){n=SAMPLES-raw_pos;}
    memcpy(raw_capture+raw_pos,data,n*2);raw_pos+=n;if(!atomic_load(&failed))atomic_store(&raw_done,raw_pos);
}
static void processed_save(const afe_fetch_result_t *res,uint64_t t){
    if(atomic_load(&failed)||!atomic_load(&capturing)){return;}
    unsigned gen=atomic_load(&generation);if(out_gen!=gen){out_gen=gen;out_pos=0;event_pos=0;}
    if(out_pos==SAMPLES){return;}
    if(out_pos==0)atomic_store(&out_first_us,t);
    size_t n=res->data_size/2;if(n>SAMPLES-out_pos)n=SAMPLES-out_pos;
    if(event_pos==MAX_EVENTS){fail("event capture capacity");return;}
    events[event_pos++]=(event_t){.sample=out_pos,.samples=n,.software_us=t,.vad=res->vad_state,.volume=res->data_volume};
    memcpy(out_capture+out_pos,res->data,n*2);out_pos+=n;if(!atomic_load(&failed)){atomic_store(&event_done,event_pos);atomic_store(&out_done,out_pos);}
}
static void le16(uint8_t*p,uint16_t n){p[0]=n;p[1]=n>>8;}
static void le32(uint8_t*p,uint32_t n){le16(p,n);le16(p+2,n>>16);}
static bool wav_commit(const char *part,const char *done,const int16_t *data){
    int fd=open(part,O_CREAT|O_EXCL|O_WRONLY,0600);if(fd<0)return false;FILE*f=fdopen(fd,"wb");if(!f){close(fd);return false;}
    uint8_t h[44]={0};memcpy(h,"RIFF",4);le32(h+4,36+SAMPLES*2);memcpy(h+8,"WAVEfmt ",8);le32(h+16,16);le16(h+20,1);le16(h+22,1);le32(h+24,16000);le32(h+28,32000);le16(h+32,2);le16(h+34,16);memcpy(h+36,"data",4);le32(h+40,SAMPLES*2);
    bool ok=fwrite(h,1,44,f)==44&&fwrite(data,2,SAMPLES,f)==SAMPLES;
    if(ok){ok=fflush(f)==0;}
    if(ok){ok=fsync(fileno(f))==0;}
    if(fclose(f)!=0){ok=false;}
    if(ok){ok=rename(part,done)==0;}
    return ok;
}
static bool file_absent(const char*p){struct stat st;if(stat(p,&st)==0)return false;return errno==ENOENT;}
static bool save_record(char condition){
    if(atomic_load(&failed)){return false;}
    char rp[64],rw[64],op[64],ow[64],cp[64],cw[64];int seq;
    for(seq=0;seq<1000;seq++){snprintf(rp,sizeof(rp),"/sd/A03_%c_%03d_RAW.part",condition,seq);snprintf(rw,sizeof(rw),"/sd/A03_%c_%03d_RAW.WAV",condition,seq);snprintf(op,sizeof(op),"/sd/A03_%c_%03d_AFE.part",condition,seq);snprintf(ow,sizeof(ow),"/sd/A03_%c_%03d_AFE.WAV",condition,seq);snprintf(cp,sizeof(cp),"/sd/A03_%c_%03d_EVENTS.part",condition,seq);snprintf(cw,sizeof(cw),"/sd/A03_%c_%03d_EVENTS.csv",condition,seq);if(file_absent(rp)&&file_absent(rw)&&file_absent(op)&&file_absent(ow)&&file_absent(cp)&&file_absent(cw))break;}
    if(seq==1000)return false;
    // Each file commits independently. This is NOT a transaction across the three files.
    if(atomic_load(&failed)||!wav_commit(rp,rw,raw_capture)){return false;}
    if(atomic_load(&failed)||!wav_commit(op,ow,out_capture)){return false;}
    if(atomic_load(&failed)){return false;} // completed earlier files are retained, not rolled back.
    int fd=open(cp,O_CREAT|O_EXCL|O_WRONLY,0600);if(fd<0)return false;FILE*f=fdopen(fd,"w");if(!f){close(fd);return false;}
    bool ok=fprintf(f,"output_sample,output_samples,software_fetch_us,vad_state,volume_library_db\n")>0;
    for(unsigned i=0;i<atomic_load(&event_done)&&ok&&!atomic_load(&failed);i++){event_t *a=events+i;ok=fprintf(f,"%u,%u,%llu,%d,%f\n",(unsigned)a->sample,(unsigned)a->samples,(unsigned long long)a->software_us,a->vad,(double)a->volume)>0;}
    if(ok){ok=fflush(f)==0;}
    if(ok){ok=fsync(fileno(f))==0;}
    if(fclose(f)!=0){ok=false;}
    if(atomic_load(&failed)){ok=false;}
    if(ok){ok=rename(cp,cw)==0;}
    if(atomic_load(&failed)){ok=false;}
    if(ok)ESP_LOGI(TAG,"FILES_SW_COMMITTED raw=%s afe=%s events=%s raw_first_us=%llu fetch_first_us=%llu; not aligned/acoustic proof",rw,ow,cw,atomic_load(&raw_first_us),atomic_load(&out_first_us));
    return ok;
}
static void feed_task(void *arg){
    (void)arg;int16_t *stereo=heap_caps_malloc(feed_n*4,MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT),*mono=heap_caps_malloc(feed_n*2,MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
    if(!stereo||!mono){fail("feed allocation");vTaskDelete(NULL);return;}
    size_t discarded=0;while(discarded<8000&&!atomic_load(&failed)){if(board_audio_read(stereo,feed_n)!=ESP_OK){fail("startup read/short read");break;}discarded+=feed_n;}
    // Driver runs during model creation. Discard startup samples and fence its old overflows.
    const uint32_t baseline=board_audio_lost();
    while(!atomic_load(&failed)){
        if(board_audio_read(stereo,feed_n)!=ESP_OK||board_audio_lost()!=baseline){fail("read/short read/RX queue overflow");break;}
        if(atomic_load(&failed)){break;}
        for(int i=0;i<feed_n;i++)mono[i]=mic1(stereo,i);
        raw_save(mono,feed_n);
        if(atomic_load(&failed)){break;}
        if(afe->feed(ad,mono)<0){fail("AFE feed");break;}
    }
    free(stereo);free(mono);vTaskDelete(NULL);
}
static void fetch_task(void *arg){
    (void)arg;uint64_t last=now_us();
    while(!atomic_load(&failed)){afe_fetch_result_t*res=afe->fetch_with_delay(ad,pdMS_TO_TICKS(100));uint64_t t=now_us();
        if(atomic_load(&failed)){break;} // fetch may have waited while feed failed.
        if(!res){if(t-last>2000000ULL)fail("AFE no fetch >2s");continue;}
        if(res->ret_value!=ESP_OK||!res->data||res->data_size<=0||res->data_size%2){fail("AFE fetch/size");break;}last=t;processed_save(res,t);
    }board_leds(true,false);vTaskDelete(NULL);
}
void app_main(void){
    ESP_LOGI(TAG,"IDF5.5.5 / SR2.4.7 / Korvo2 MAIN V3.0 N16R8; no WiFi/cloud; PA stays OFF");
    ESP_ERROR_CHECK(board_audio_init());srmodel_list_t *models=esp_srmodel_init("model");if(!models){fail("model partition init");return;}
    afe_config_t *cfg=afe_config_init("M",models,AFE_TYPE_SR,AFE_MODE_LOW_COST);if(!cfg){fail("AFE config");return;}
    cfg->aec_init=false;cfg->se_init=false;cfg->ns_init=true;cfg->vad_init=true;cfg->agc_init=false;cfg->wakenet_init=false;
    cfg->afe_ns_mode=AFE_NS_MODE_WEBRTC;cfg->vad_model_name=NULL;cfg->afe_linear_gain=1.0f;cfg->memory_alloc_mode=AFE_MEMORY_ALLOC_MORE_PSRAM;
    
    cfg=afe_config_check(cfg);if(cfg->aec_init||cfg->pcm_config.total_ch_num!=1||cfg->pcm_config.ref_num!=0){fail("unexpected AFE reference format");return;}
    afe=esp_afe_handle_from_config(cfg);ad=afe?afe->create_from_config(cfg):NULL;afe_config_free(cfg);if(!ad){fail("AFE create");return;}
    feed_n=afe->get_feed_chunksize(ad);if(feed_n<=0||feed_n>4096||afe->get_feed_channel_num(ad)!=1||afe->get_samp_rate(ad)!=16000){fail("AFE shape");return;}
    afe->print_pipeline(ad);ESP_LOGI(TAG,"feed samples/chunk=%d; ES7210 MIC1/MIC2 stereo16 → first MIC only M; no R/AEC",feed_n);
    ESP_ERROR_CHECK(board_sd_mount());raw_capture=heap_caps_malloc(SAMPLES*2,MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT);out_capture=heap_caps_malloc(SAMPLES*2,MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT);events=heap_caps_malloc(MAX_EVENTS*sizeof(event_t),MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT);if(!raw_capture||!out_capture||!events){fail("capture PSRAM allocation");return;}fcntl(STDIN_FILENO,F_SETFL,O_NONBLOCK);
    if(xTaskCreatePinnedToCore(feed_task,"mic-feed",6144,NULL,5,NULL,0)!=pdPASS||xTaskCreatePinnedToCore(fetch_task,"afe-fetch",8192,models,4,NULL,1)!=pdPASS){fail("task create");return;}
    char condition=0;uint64_t began=0;ESP_LOGI(TAG,"type q then Enter for quiet, n then Enter for noise;10s each; never synthetic capture");
    while(!atomic_load(&failed)){
        int c=getchar();if(c==EOF)clearerr(stdin);
        if(atomic_load(&failed)){break;} // no new capture/commit after an observed feed/fetch fault.
        if((c=='q'||c=='n')&&!atomic_load(&capturing)){condition=c;atomic_store(&raw_done,0);atomic_store(&out_done,0);atomic_store(&event_done,0);atomic_fetch_add(&generation,1);began=now_us();atomic_store(&capturing,true);ESP_LOGI(TAG,"CAPTURE %c started; independent first-sample fences, not sample aligned",condition);}
        if(atomic_load(&capturing)&&atomic_load(&raw_done)==SAMPLES&&atomic_load(&out_done)==SAMPLES){atomic_store(&capturing,false);if(atomic_load(&failed)){break;}if(!save_record(condition)){fail("file commit; keep existing .part/independent completed files; do not retry overwrite");break;}}
        if(atomic_load(&capturing)&&now_us()-began>20000000ULL){atomic_store(&capturing,false);fail("capture incomplete20s");break;}vTaskDelay(pdMS_TO_TICKS(20));
    }atomic_store(&capturing,false);ESP_LOGE(TAG,"latched fault; partial RAM not saved as a successful recording; RESET after repair");
}

// ---- main/board_audio.c ----
// Copyright 2026 hixinwu. SPDX-License-Identifier: MIT
#include "board_audio.h"
#include "driver/i2c_master.h"
#include "driver/i2s_std.h"
#include "driver/gpio.h"
#include "driver/sdmmc_host.h"
#include "esp_vfs_fat.h"
#include "sdmmc_cmd.h"
#include "esp_codec_dev.h"
#include "esp_codec_dev_defaults.h"
#include "esp_check.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
static i2c_master_bus_handle_t bus;
static i2c_master_dev_handle_t io;
static i2s_chan_handle_t rx;
static uint32_t lost;
static const char *TAG="BOARD_V3_0";
static bool IRAM_ATTR overflow(i2s_chan_handle_t h,i2s_event_data_t *e,void *u){
    (void)h;(void)e;(void)u;__atomic_fetch_add(&lost,1,__ATOMIC_RELAXED);return false;
}
static esp_err_t reg_read(uint8_t reg,uint8_t *value){return i2c_master_transmit_receive(io,&reg,1,value,1,100);}
static esp_err_t reg_write(uint8_t reg,uint8_t value){uint8_t b[]={reg,value};return i2c_master_transmit(io,b,2,100);}
esp_err_t board_leds(bool red,bool blue){
    uint8_t out;ESP_RETURN_ON_ERROR(reg_read(1,&out),TAG,"TCA output read");
    out=(out&~0xc0)|(red?0x40:0)|(blue?0x80:0);return reg_write(1,out);
}
uint32_t board_audio_lost(void){return __atomic_load_n(&lost,__ATOMIC_RELAXED);}
/* P0 and GPIO48 share PA_CTRL. Only MCU reset does not reset TCA latches.
 * First release MCU drive, then release the expander, preload LOW, finally drive.
 * Speaker is disconnected in this recipe; no seamless mute/electrical guarantee. */
static esp_err_t board_io_claim(void){
    ESP_RETURN_ON_ERROR(gpio_set_direction(GPIO_NUM_48,GPIO_MODE_INPUT),TAG,"PA release MCU");
    ESP_RETURN_ON_ERROR(gpio_set_pull_mode(GPIO_NUM_48,GPIO_FLOATING),TAG,"PA no MCU pull");
    i2c_master_bus_config_t b={.i2c_port=I2C_NUM_0,.sda_io_num=17,.scl_io_num=18,.clk_source=I2C_CLK_SRC_DEFAULT,.glitch_ignore_cnt=7,.flags.enable_internal_pullup=true};
    ESP_RETURN_ON_ERROR(i2c_new_master_bus(&b,&bus),TAG,"I2C");
    // V3.0 TCA9554 has A2:A0=000. No blind fallback to different board revisions.
    ESP_RETURN_ON_ERROR(i2c_master_probe(bus,0x20,100),TAG,"TCA9554 absent");
    i2c_device_config_t dc={.dev_addr_length=I2C_ADDR_BIT_LEN_7,.device_address=0x20,.scl_speed_hz=100000};
    ESP_RETURN_ON_ERROR(i2c_master_bus_add_device(bus,&dc,&io),TAG,"TCA add");
    uint8_t out,dir;ESP_RETURN_ON_ERROR(reg_read(1,&out),TAG,"TCA latch");
    // P5 LOW powers peripherals (SD), P6/P7 initially OFF; preserve other latches.
    ESP_RETURN_ON_ERROR(reg_write(1,out&~0xe0),TAG,"TCA initial levels");
    ESP_RETURN_ON_ERROR(reg_read(3,&dir),TAG,"TCA direction");
    ESP_RETURN_ON_ERROR(reg_write(3,(dir&~0xe0)|1),TAG,"TCA outputs; P0 input");
    ESP_RETURN_ON_ERROR(reg_read(3,&dir),TAG,"TCA verify P0 input");
    if(!(dir&1)){return ESP_ERR_INVALID_STATE;}
    ESP_RETURN_ON_ERROR(gpio_set_level(GPIO_NUM_48,0),TAG,"PA preload OFF");
    ESP_RETURN_ON_ERROR(gpio_set_direction(GPIO_NUM_48,GPIO_MODE_OUTPUT),TAG,"PA claim MCU output LOW");
    return ESP_OK;
}
esp_err_t board_audio_init(void){
    ESP_RETURN_ON_ERROR(board_io_claim(),TAG,"PA/TCA ownership");
    ESP_RETURN_ON_ERROR(i2c_master_probe(bus,0x40,100),TAG,"ES7210 absent");
    i2s_chan_config_t cc=I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0,I2S_ROLE_MASTER);cc.dma_desc_num=8;cc.dma_frame_num=256;
    ESP_RETURN_ON_ERROR(i2s_new_channel(&cc,NULL,&rx),TAG,"I2S channel");
    i2s_std_config_t sc={.clk_cfg=I2S_STD_CLK_DEFAULT_CONFIG(16000),.slot_cfg=I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT,I2S_SLOT_MODE_STEREO),.gpio_cfg={.mclk=16,.bclk=9,.ws=45,.dout=I2S_GPIO_UNUSED,.din=10}};
    ESP_RETURN_ON_ERROR(i2s_channel_init_std_mode(rx,&sc),TAG,"STD stereo16");
    i2s_event_callbacks_t cb={.on_recv_q_ovf=overflow};ESP_RETURN_ON_ERROR(i2s_channel_register_event_callback(rx,&cb,NULL),TAG,"overflow callback");
    audio_codec_i2s_cfg_t data_cfg={.port=I2S_NUM_0,.rx_handle=rx};
    const audio_codec_data_if_t *data=audio_codec_new_i2s_data(&data_cfg);
    // Codec API uses 8-bit control address 0x80; raw master probe above uses 7-bit0x40.
    audio_codec_i2c_cfg_t ctrl_cfg={.port=I2C_NUM_0,.addr=ES7210_CODEC_DEFAULT_ADDR,.bus_handle=bus};
    const audio_codec_ctrl_if_t *ctrl=audio_codec_new_i2c_ctrl(&ctrl_cfg);
    es7210_codec_cfg_t adc_cfg={.ctrl_if=ctrl,.mic_selected=ES7210_SEL_MIC1|ES7210_SEL_MIC2,.master_mode=false};
    const audio_codec_if_t *adc=es7210_codec_new(&adc_cfg);
    if(!data||!ctrl||!adc)return ESP_ERR_NO_MEM;
    esp_codec_dev_cfg_t dev_cfg={.dev_type=ESP_CODEC_DEV_TYPE_IN,.codec_if=adc,.data_if=data};
    esp_codec_dev_handle_t dev=esp_codec_dev_new(&dev_cfg);if(!dev)return ESP_ERR_NO_MEM;
    esp_codec_dev_sample_info_t fs={.sample_rate=16000,.channel=2,.bits_per_sample=16,.channel_mask=3};
    if(esp_codec_dev_open(dev,&fs)!=ESP_CODEC_DEV_OK)return ESP_FAIL;
    if(esp_codec_dev_set_in_gain(dev,24.0f)!=ESP_CODEC_DEV_OK)return ESP_FAIL;
    // Direct channel read below checks actual byte count, not only codec wrapper status.
    return ESP_OK;
}
esp_err_t board_audio_read(int16_t *stereo,size_t frames){
    size_t bytes=0,want=frames*2*sizeof(int16_t);esp_err_t e=i2s_channel_read(rx,stereo,want,&bytes,500);
    return e==ESP_OK&&bytes==want?ESP_OK:(e==ESP_OK?ESP_ERR_INVALID_SIZE:e);
}
esp_err_t board_sd_mount(void){
    sdmmc_host_t host=SDMMC_HOST_DEFAULT();host.max_freq_khz=SDMMC_FREQ_DEFAULT;
    sdmmc_slot_config_t slot=SDMMC_SLOT_CONFIG_DEFAULT();slot.width=1;slot.clk=15;slot.cmd=7;slot.d0=4;slot.d1=GPIO_NUM_NC;slot.d2=GPIO_NUM_NC;slot.d3=GPIO_NUM_NC;
    esp_vfs_fat_sdmmc_mount_config_t cfg={.format_if_mount_failed=false,.max_files=4,.allocation_unit_size=16384};sdmmc_card_t *card=NULL;
    return esp_vfs_fat_sdmmc_mount("/sd",&host,&slot,&cfg,&card);
}

// ---- main/board_audio.h ----
#pragma once
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "esp_err.h"
esp_err_t board_audio_init(void);
esp_err_t board_audio_read(int16_t *stereo,size_t frames);
uint32_t board_audio_lost(void);
esp_err_t board_leds(bool red,bool blue);
esp_err_t board_sd_mount(void);

// ---- main/speech_state.h ----
// Copyright 2026 hixinwu. SPDX-License-Identifier: MIT
#pragma once
#include <stdbool.h>
#include <stdint.h>
typedef struct{bool active;bool led_on;uint64_t until;} command_gate_t;
static inline void command_wake(command_gate_t *g,uint64_t now){if(!g->active){g->active=true;g->until=now+8000000ULL;}}
static inline void command_tick(command_gate_t *g,uint64_t now){if(g->active&&now>=g->until)g->active=false;}
static inline bool command_accept(command_gate_t *g,int id,uint64_t now){command_tick(g,now);if(!g->active||!(id==1||id==2))return false;g->led_on=id==1;g->active=false;return true;}
static inline int16_t mic1(const int16_t *stereo,unsigned frame){return stereo[2*frame];}

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

clang -std=c11 -Wall -Wextra -Werror -fsanitize=address,undefined -fno-omit-frame-pointer -I main tests/state.c -o /tmp/speech-state
/tmp/speech-state

python tools/check_fault_boundaries.py --out /tmp/NEW-speech-fault-boundaries
python tools/check_pa_ownership.py --out /tmp/NEW-speech-pa-order