ESP32-S3离线唤醒词：先跑通WakeNet，再测误触发

python3 tools/inspect_models.py build/srmodels/srmodels.bin --expect wn9_hiesp --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 "A04"
#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);}
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);
        
        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(),blue_until=0;command_gate_t gate={0};
#if COMMANDS
    srmodel_list_t *models=arg;char *mn_name=esp_srmodel_filter(models,ESP_MN_PREFIX,ESP_MN_ENGLISH);
    if(!mn_name||strcmp(mn_name,"mn7_en")){fail("expected mn7_en");vTaskDelete(NULL);return;}
    const esp_mn_iface_t *mn=esp_mn_handle_from_name(mn_name);model_iface_data_t *md=mn?mn->create(mn_name,5000):NULL;
    if(!md||mn->get_samp_rate(md)!=16000){fail("MultiNet create/rate");vTaskDelete(NULL);return;}
    int chunks=mn->get_samp_chunksize(md),fill=0;int16_t *block=heap_caps_malloc(chunks*2,MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT);
    if(chunks<=0||chunks>4096||!block||esp_mn_commands_alloc(mn,md)!=ESP_OK||esp_mn_commands_add(1,"turn on the light")!=ESP_OK||esp_mn_commands_add(2,"turn off the light")!=ESP_OK||esp_mn_commands_update()!=NULL){fail("MultiNet command graph/allocation");vTaskDelete(NULL);return;}
    mn->print_active_speech_commands(md);ESP_LOGI(TAG,"MODEL=%s; id1=turn on the light; id2=turn off the light; local LED only",mn_name);
#endif
    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;
        
        if(res->wakeup_state==WAKENET_DETECTED){
            if(atomic_load(&failed)){break;}
            ESP_LOGI(TAG,"WAKE software_fetch_us=%llu model_index=%d word=%d trigger_channel=%d; physical=UNTESTED",(unsigned long long)t,res->wakenet_model_index,res->wake_word_index,res->trigger_channel_id);
#if COMMANDS
            if(!gate.active){command_wake(&gate,t);fill=0;mn->clean(md);}
#else
            blue_until=t+1000000ULL;
#endif
        }
#if COMMANDS
        bool was_active=gate.active;command_tick(&gate,t);
        if(was_active&&!gate.active){mn->clean(md);fill=0;ESP_LOGI(TAG,"COMMAND_WINDOW_TIMEOUT wall8s; LED state unchanged");}
        if(gate.active){
            for(int i=0;i<res->data_size/2&&gate.active&&!atomic_load(&failed);i++){
                block[fill++]=res->data[i];if(fill!=chunks)continue;fill=0;
                command_tick(&gate,now_us());if(!gate.active){mn->clean(md);break;}
                esp_mn_state_t state=mn->detect(md,block);
                if(atomic_load(&failed)){break;} // detect may have blocked across a feed fault.
                if(state==ESP_MN_STATE_DETECTED){esp_mn_results_t *result=mn->get_results(md);bool accepted=false;
                    uint64_t decision_us=now_us();
                    if(atomic_load(&failed)){break;} // includes get_results and clock observation.
                    if(result&&result->num>0&&isfinite(result->prob[0])&&result->prob[0]>=0.7f)accepted=command_accept(&gate,result->command_id[0],decision_us);
                    if(atomic_load(&failed)){break;}
                    ESP_LOGI(TAG,"COMMAND detected accepted=%d id=%d probability=%f; not physical LED proof",accepted,result&&result->num?result->command_id[0]:-1,result&&result->num?result->prob[0]:0.0);
                    gate.active=false;mn->clean(md);
                }else if(state==ESP_MN_STATE_TIMEOUT){gate.active=false;mn->clean(md);ESP_LOGI(TAG,"COMMAND model timeout; no action");}
            }
        }
        if(atomic_load(&failed)){break;} // final normal-output gate; an in-flight I2C call cannot be revoked.
        if(board_leds(gate.led_on,gate.active)!=ESP_OK){fail("LED expander transaction");break;}
#else
        if(atomic_load(&failed)){break;} // no new normal LED call after observed fault.
        (void)gate;if(board_leds(false,t<blue_until)!=ESP_OK){fail("LED expander transaction");break;}
#endif
    }
    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=true;
    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->wakenet_model_name=esp_srmodel_filter(models,ESP_WN_PREFIX,"hiesp");if(!cfg->wakenet_model_name||strcmp(cfg->wakenet_model_name,"wn9_hiesp")){fail("expected wn9_hiesp");return;}
    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);
    
    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;}
    while(!atomic_load(&failed)){vTaskDelay(pdMS_TO_TICKS(1000));} ESP_LOGE(TAG,"latched fault; RESET after hardware/config 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