ESP32 接 HA Assist：按一下说话，等一句回答播放完

python3 -c 'import base64,secrets; print(base64.b64encode(secrets.token_bytes(32)).decode())'

python3.12 -m venv .venv
. .venv/bin/activate
python -m pip install -r requirements.lock
python -m esphome config esp32-homeassistant-voice-terminal.yaml
python -m esphome compile esp32-homeassistant-voice-terminal.yaml
python -m esphome upload esp32-homeassistant-voice-terminal.yaml --device /dev/cu.YOUR_BRIDGE_PORT
python -m esphome logs esp32-homeassistant-voice-terminal.yaml --device /dev/cu.YOUR_BRIDGE_PORT

clang++ -std=c++17 -Wall -Wextra -Werror -fsanitize=address,undefined tests/host.cpp -o /tmp/a06-gate
/tmp/a06-gate

# ---- esp32-homeassistant-voice-terminal.yaml ----
substitutions:
  node_name: hixinwu-a06
esphome:
  name: ${node_name}
  friendly_name: Hixinwu Assist Button
  min_version: 2026.9.1
  includes:
    - assist_gate.h
  on_boot:
    priority: -100
    then:
      - lambda: id(reply_speaker).set_volume(0.15f);
esp32:
  board: esp32-s3-devkitc-1
  variant: ESP32S3
  flash_size: 8MB
  flash_mode: qio
  flash_frequency: 80MHz
  toolchain: esp-idf
  framework:
    type: esp-idf
    version: 5.5.5
psram:
  mode: octal
  speed: 80MHz
logger:
  hardware_uart: UART0
  baud_rate: 115200
  level: DEBUG
api:
  encryption:
    key: !secret api_key
  reboot_timeout: 0s
ota:
  - platform: esphome
    encryption:
      key: !secret api_key
wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  reboot_timeout: 0s
  ap:
    ssid: "${node_name} Recovery"
    password: !secret fallback_password
    ap_timeout: 90s
captive_portal:
globals:
  - id: ha_voice_ready
    type: bool
    restore_value: false
    initial_value: 'false'
# Separate clock buses use the two S3 I2S controllers. No shared-clock duplex/AEC.
i2s_audio:
  - id: mic_bus
    i2s_lrclk_pin: GPIO4
    i2s_bclk_pin: GPIO5
  - id: speaker_bus
    i2s_lrclk_pin: GPIO16
    i2s_bclk_pin: GPIO15
microphone:
  - platform: i2s_audio
    id: talk_mic
    adc_type: external
    i2s_audio_id: mic_bus
    i2s_din_pin: GPIO6
    pdm: false
    sample_rate: 16000
    bits_per_sample: 32bit
    channel: left
    correct_dc_offset: true
speaker:
  - platform: i2s_audio
    id: reply_speaker
    dac_type: external
    i2s_audio_id: speaker_bus
    i2s_dout_pin: GPIO7
    sample_rate: 16000
    bits_per_sample: 16bit
    channel: mono
    buffer_duration: 250ms
    timeout: 300ms
output:
  - platform: gpio
    id: amp_sd
    pin: GPIO17
  - platform: gpio
    id: session_led
    pin: GPIO18
binary_sensor:
  - platform: gpio
    id: talk_button
    internal: true
    pin:
      number: GPIO10
      mode: INPUT
      inverted: true
text_sensor:
  - platform: template
    id: assist_status
    name: Assist Local State
    update_interval: 1s
    lambda: return {a06::gate().status(id(ha_voice_ready))};
button:
  - platform: template
    name: Cancel Assist Session
    on_press:
      - lambda: |-
          a06::gate().fail();
          id(amp_sd).turn_off();
          id(reply_speaker).stop();
      - voice_assistant.stop:
          id: assist
voice_assistant:
  id: assist
  microphone:
    microphone: talk_mic
    bits_per_sample: 16
    channels: 0
    gain_factor: 1
  speaker: reply_speaker
  use_wake_word: false
  noise_suppression_level: 0
  auto_gain: 0dBFS
  volume_multiplier: 1.0
  on_client_connected:
    - lambda: id(ha_voice_ready) = true;
  on_client_disconnected:
    - lambda: |-
        id(ha_voice_ready) = false;
        a06::gate().disconnected();
        id(amp_sd).turn_off();
        id(reply_speaker).stop();
    - voice_assistant.stop:
        id: assist
  on_start:
    - lambda: a06::gate().pipeline_event();
  on_listening:
    - logger.log: "A06 LISTENING: say one utterance; HA determines end of speech"
  on_stt_end:
    - logger.log: "A06 STT completed (text deliberately not printed)"
  on_tts_stream_start:
    - lambda: |-
        a06::gate().tts_start();
        if (a06::gate().amplifier_enabled()) id(amp_sd).turn_on();
  on_tts_stream_end:
    - lambda: |-
        a06::gate().tts_end();
        id(amp_sd).turn_off();
  on_end:
    - lambda: a06::gate().pipeline_event();
  on_error:
    - lambda: |-
        ESP_LOGW("a06", "Pipeline error code=%s; check HA pipeline log", code.c_str());
        a06::gate().fail();
        id(amp_sd).turn_off();
        id(reply_speaker).stop();
    - voice_assistant.stop:
        id: assist
interval:
  - interval: 20ms
    then:
      - lambda: |-
          const uint64_t now_ms = static_cast<uint64_t>(esp_timer_get_time()) / 1000ULL;
          auto action = a06::gate().tick(now_ms, id(talk_button).state,
              id(ha_voice_ready), id(assist).is_running(), id(reply_speaker).is_running());
          if (action == a06::Action::START) id(assist).request_start(false, true);
          if (action == a06::Action::STOP) {
            id(amp_sd).turn_off();
            id(reply_speaker).stop();
            id(assist).request_stop();
          }
          if (!a06::gate().amplifier_enabled()) id(amp_sd).turn_off();
          if (a06::gate().indicator_on(now_ms, id(ha_voice_ready))) id(session_led).turn_on();
          else id(session_led).turn_off();

// ---- assist_gate.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <cstdint>
namespace a06 {
enum class Action { NONE, START, STOP };
// Pure policy, called only from ESPHome's main loop; now is esp_timer_get_time()/1000.
class Gate {
 public:
  Action tick(uint64_t now, bool pressed, bool connected, bool running, bool speaker_busy) {
    if (!initialized_) { initialized_=true; raw_=stable_=pressed; edge_at_=now; boot_at_=now; }
    if (pressed!=raw_) { raw_=pressed; edge_at_=now; }
    bool press_edge=false;
    if (raw_!=stable_ && now-edge_at_>=50) {
      stable_=raw_; press_edge=stable_;
      if (!stable_) released_=true;
    }
    if (!raw_ && !stable_ && now-edge_at_>=50 && now-boot_at_>=500) released_=true;
    if (!connected) {
      released_=false; playing_=false;
      if (active_) { active_=false; fault_=true; return Action::STOP; }
      return Action::NONE;
    }
    if (active_) {
      if (running) saw_running_=true;
      if (now-start_at_>=60000) {
        active_=false; playing_=false; fault_=true; released_=false;
        return Action::STOP;
      }
      // RUN_END may precede draining TTS. Only the actual component idle + speaker idle
      // pair ends the session, after observing a running state or an explicit event.
      if ((saw_running_ || event_seen_) && !running && !speaker_busy) {
        active_=false; playing_=false;
      }
      return Action::NONE;
    }
    if (press_edge && released_ && !running && !speaker_busy && now-boot_at_>=500) {
      released_=false; fault_=false; active_=true; playing_=false;
      saw_running_=false; event_seen_=false; start_at_=now;
      return Action::START;
    }
    return Action::NONE;
  }
  void pipeline_event() { if (active_) event_seen_=true; }
  void tts_start() { if (active_) { playing_=true; event_seen_=true; } }
  void tts_end() { playing_=false; if (active_) event_seen_=true; }
  void fail() { fault_=true; active_=false; playing_=false; released_=false; }
  void disconnected() { fail(); }
  bool amplifier_enabled() const { return active_ && playing_ && !fault_; }
  bool active() const { return active_; }
  bool fault() const { return fault_; }
  bool indicator_on(uint64_t now, bool connected) const {
    if (!connected || fault_) return (now/250ULL)%2ULL != 0;
    return active_;
  }
  const char *status(bool connected) const {
    if (!connected) return "HA_OFFLINE";
    if (fault_) return "FAULT_RELEASE_AND_RETRY";
    if (playing_ && active_) return "PLAYING";
    if (active_) return "PIPELINE_ACTIVE";
    return released_ ? "READY" : "RELEASE_BUTTON";
  }
 private:
  bool initialized_=false, raw_=false, stable_=false, released_=false;
  bool active_=false, playing_=false, fault_=false, saw_running_=false, event_seen_=false;
  uint64_t edge_at_=0, boot_at_=0, start_at_=0;
};
// Avoid a custom-type GlobalsComponent before ESPHome inserts user includes.
// One main-loop-owned RAM object; neither restored nor shared across tasks.
inline Gate &gate() { static Gate instance; return instance; }
}  // namespace a06