esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

esphome/components/voice_assistant/voice_assistant.cpp

@@ -18,14 +18,25 @@ static const char *const TAG = "voice_assistant";
 #endif
 
 static const size_t SAMPLE_RATE_HZ = 16000;
-static const size_t INPUT_BUFFER_SIZE = 32 * SAMPLE_RATE_HZ / 1000;  // 32ms * 16kHz / 1000ms
-static const size_t BUFFER_SIZE = 512 * SAMPLE_RATE_HZ / 1000;
-static const size_t SEND_BUFFER_SIZE = INPUT_BUFFER_SIZE * sizeof(int16_t);
+
+static const size_t RING_BUFFER_SAMPLES = 512 * SAMPLE_RATE_HZ / 1000;  // 512 ms * 16 kHz/ 1000 ms
+static const size_t RING_BUFFER_SIZE = RING_BUFFER_SAMPLES * sizeof(int16_t);
+static const size_t SEND_BUFFER_SAMPLES = 32 * SAMPLE_RATE_HZ / 1000;  // 32ms * 16kHz / 1000ms
+static const size_t SEND_BUFFER_SIZE = SEND_BUFFER_SAMPLES * sizeof(int16_t);
 static const size_t RECEIVE_SIZE = 1024;
 static const size_t SPEAKER_BUFFER_SIZE = 16 * RECEIVE_SIZE;
 
 VoiceAssistant::VoiceAssistant() { global_voice_assistant = this; }
 
+void VoiceAssistant::setup() {
+  this->mic_source_->add_data_callback([this](const std::vector<uint8_t> &data) {
+    std::shared_ptr<RingBuffer> temp_ring_buffer = this->ring_buffer_;
+    if (this->ring_buffer_.use_count() > 1) {
+      temp_ring_buffer->write((void *) data.data(), data.size());
+    }
+  });
+}
+
 float VoiceAssistant::get_setup_priority() const { return setup_priority::AFTER_CONNECTION; }
 
 bool VoiceAssistant::start_udp_socket_() {
@@ -72,12 +83,8 @@ bool VoiceAssistant::start_udp_socket_() {
 }
 
 bool VoiceAssistant::allocate_buffers_() {
-  if (this->send_buffer_ != nullptr) {
-    return true;  // Already allocated
-  }
-
 #ifdef USE_SPEAKER
-  if (this->speaker_ != nullptr) {
+  if ((this->speaker_ != nullptr) && (this->speaker_buffer_ == nullptr)) {
     ExternalRAMAllocator<uint8_t> speaker_allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
     this->speaker_buffer_ = speaker_allocator.allocate(SPEAKER_BUFFER_SIZE);
     if (this->speaker_buffer_ == nullptr) {
@@ -87,28 +94,21 @@ bool VoiceAssistant::allocate_buffers_() {
   }
 #endif
 
-  ExternalRAMAllocator<int16_t> allocator(ExternalRAMAllocator<int16_t>::ALLOW_FAILURE);
-  this->input_buffer_ = allocator.allocate(INPUT_BUFFER_SIZE);
-  if (this->input_buffer_ == nullptr) {
-    ESP_LOGW(TAG, "Could not allocate input buffer");
-    return false;
-  }
-
-#ifdef USE_ESP_ADF
-  this->vad_instance_ = vad_create(VAD_MODE_4);
-#endif
-
-  this->ring_buffer_ = RingBuffer::create(BUFFER_SIZE * sizeof(int16_t));
-  if (this->ring_buffer_ == nullptr) {
-    ESP_LOGW(TAG, "Could not allocate ring buffer");
-    return false;
+  if (this->ring_buffer_.use_count() == 0) {
+    this->ring_buffer_ = RingBuffer::create(RING_BUFFER_SIZE);
+    if (this->ring_buffer_.use_count() == 0) {
+      ESP_LOGE(TAG, "Could not allocate ring buffer");
+      return false;
+    }
   }
 
-  ExternalRAMAllocator<uint8_t> send_allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
-  this->send_buffer_ = send_allocator.allocate(SEND_BUFFER_SIZE);
-  if (send_buffer_ == nullptr) {
-    ESP_LOGW(TAG, "Could not allocate send buffer");
-    return false;
+  if (this->send_buffer_ == nullptr) {
+    ExternalRAMAllocator<uint8_t> send_allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+    this->send_buffer_ = send_allocator.allocate(SEND_BUFFER_SIZE);
+    if (send_buffer_ == nullptr) {
+      ESP_LOGW(TAG, "Could not allocate send buffer");
+      return false;
+    }
   }
 
   return true;
@@ -119,10 +119,6 @@ void VoiceAssistant::clear_buffers_() {
     memset(this->send_buffer_, 0, SEND_BUFFER_SIZE);
   }
 
-  if (this->input_buffer_ != nullptr) {
-    memset(this->input_buffer_, 0, INPUT_BUFFER_SIZE * sizeof(int16_t));
-  }
-
   if (this->ring_buffer_ != nullptr) {
     this->ring_buffer_->reset();
   }
@@ -139,25 +135,15 @@ void VoiceAssistant::clear_buffers_() {
 }
 
 void VoiceAssistant::deallocate_buffers_() {
-  ExternalRAMAllocator<uint8_t> send_deallocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
-  send_deallocator.deallocate(this->send_buffer_, SEND_BUFFER_SIZE);
-  this->send_buffer_ = nullptr;
-
-  if (this->ring_buffer_ != nullptr) {
-    this->ring_buffer_.reset();
-    this->ring_buffer_ = nullptr;
+  if (this->send_buffer_ != nullptr) {
+    ExternalRAMAllocator<uint8_t> send_deallocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+    send_deallocator.deallocate(this->send_buffer_, SEND_BUFFER_SIZE);
+    this->send_buffer_ = nullptr;
   }
 
-#ifdef USE_ESP_ADF
-  if (this->vad_instance_ != nullptr) {
-    vad_destroy(this->vad_instance_);
-    this->vad_instance_ = nullptr;
+  if (this->ring_buffer_.use_count() > 0) {
+    this->ring_buffer_.reset();
   }
-#endif
-
-  ExternalRAMAllocator<int16_t> input_deallocator(ExternalRAMAllocator<int16_t>::ALLOW_FAILURE);
-  input_deallocator.deallocate(this->input_buffer_, INPUT_BUFFER_SIZE);
-  this->input_buffer_ = nullptr;
 
 #ifdef USE_SPEAKER
   if ((this->speaker_ != nullptr) && (this->speaker_buffer_ != nullptr)) {
@@ -173,26 +159,10 @@ void VoiceAssistant::reset_conversation_id() {
   ESP_LOGD(TAG, "reset conversation ID");
 }
 
-int VoiceAssistant::read_microphone_() {
-  size_t bytes_read = 0;
-  if (this->mic_->is_running()) {  // Read audio into input buffer
-    bytes_read = this->mic_->read(this->input_buffer_, INPUT_BUFFER_SIZE * sizeof(int16_t));
-    if (bytes_read == 0) {
-      memset(this->input_buffer_, 0, INPUT_BUFFER_SIZE * sizeof(int16_t));
-      return 0;
-    }
-    // Write audio into ring buffer
-    this->ring_buffer_->write((void *) this->input_buffer_, bytes_read);
-  } else {
-    ESP_LOGD(TAG, "microphone not running");
-  }
-  return bytes_read;
-}
-
 void VoiceAssistant::loop() {
   if (this->api_client_ == nullptr && this->state_ != State::IDLE && this->state_ != State::STOP_MICROPHONE &&
       this->state_ != State::STOPPING_MICROPHONE) {
-    if (this->mic_->is_running() || this->state_ == State::STARTING_MICROPHONE) {
+    if (this->mic_source_->is_running() || this->state_ == State::STARTING_MICROPHONE) {
       this->set_state_(State::STOP_MICROPHONE, State::IDLE);
     } else {
       this->set_state_(State::IDLE, State::IDLE);
@@ -206,16 +176,9 @@ void VoiceAssistant::loop() {
     case State::IDLE: {
       if (this->continuous_ && this->desired_state_ == State::IDLE) {
         this->idle_trigger_->trigger();
-#ifdef USE_ESP_ADF
-        if (this->use_wake_word_) {
-          this->set_state_(State::START_MICROPHONE, State::WAIT_FOR_VAD);
-        } else
-#endif
-        {
-          this->set_state_(State::START_MICROPHONE, State::START_PIPELINE);
-        }
+        this->set_state_(State::START_MICROPHONE, State::START_PIPELINE);
       } else {
-        this->high_freq_.stop();
+        this->deallocate_buffers_();
       }
       break;
     }
@@ -230,53 +193,20 @@ void VoiceAssistant::loop() {
       }
       this->clear_buffers_();
 
-      this->mic_->start();
-      this->high_freq_.start();
+      this->mic_source_->start();
       this->set_state_(State::STARTING_MICROPHONE);
       break;
     }
     case State::STARTING_MICROPHONE: {
-      if (this->mic_->is_running()) {
+      if (this->mic_source_->is_running()) {
         this->set_state_(this->desired_state_);
       }
       break;
     }
-#ifdef USE_ESP_ADF
-    case State::WAIT_FOR_VAD: {
-      this->read_microphone_();
-      ESP_LOGD(TAG, "Waiting for speech...");
-      this->set_state_(State::WAITING_FOR_VAD);
-      break;
-    }
-    case State::WAITING_FOR_VAD: {
-      size_t bytes_read = this->read_microphone_();
-      if (bytes_read > 0) {
-        vad_state_t vad_state =
-            vad_process(this->vad_instance_, this->input_buffer_, SAMPLE_RATE_HZ, VAD_FRAME_LENGTH_MS);
-        if (vad_state == VAD_SPEECH) {
-          if (this->vad_counter_ < this->vad_threshold_) {
-            this->vad_counter_++;
-          } else {
-            ESP_LOGD(TAG, "VAD detected speech");
-            this->set_state_(State::START_PIPELINE, State::STREAMING_MICROPHONE);
-
-            // Reset for next time
-            this->vad_counter_ = 0;
-          }
-        } else {
-          if (this->vad_counter_ > 0) {
-            this->vad_counter_--;
-          }
-        }
-      }
-      break;
-    }
-#endif
     case State::START_PIPELINE: {
-      this->read_microphone_();
       ESP_LOGD(TAG, "Requesting start...");
       uint32_t flags = 0;
-      if (this->use_wake_word_)
+      if (!this->continue_conversation_ && this->use_wake_word_)
         flags |= api::enums::VOICE_ASSISTANT_REQUEST_USE_WAKE_WORD;
       if (this->silence_detection_)
         flags |= api::enums::VOICE_ASSISTANT_REQUEST_USE_VAD;
@@ -306,11 +236,9 @@ void VoiceAssistant::loop() {
       break;
     }
     case State::STARTING_PIPELINE: {
-      this->read_microphone_();
       break;  // State changed when udp server port received
     }
     case State::STREAMING_MICROPHONE: {
-      this->read_microphone_();
       size_t available = this->ring_buffer_->available();
       while (available >= SEND_BUFFER_SIZE) {
         size_t read_bytes = this->ring_buffer_->read((void *) this->send_buffer_, SEND_BUFFER_SIZE, 0);
@@ -334,8 +262,8 @@ void VoiceAssistant::loop() {
       break;
     }
     case State::STOP_MICROPHONE: {
-      if (this->mic_->is_running()) {
-        this->mic_->stop();
+      if (this->mic_source_->is_running()) {
+        this->mic_source_->stop();
         this->set_state_(State::STOPPING_MICROPHONE);
       } else {
         this->set_state_(this->desired_state_);
@@ -343,7 +271,7 @@ void VoiceAssistant::loop() {
       break;
     }
     case State::STOPPING_MICROPHONE: {
-      if (this->mic_->is_stopped()) {
+      if (this->mic_source_->is_stopped()) {
         this->set_state_(this->desired_state_);
       }
       break;
@@ -387,6 +315,25 @@ void VoiceAssistant::loop() {
 #ifdef USE_MEDIA_PLAYER
       if (this->media_player_ != nullptr) {
         playing = (this->media_player_->state == media_player::MediaPlayerState::MEDIA_PLAYER_STATE_ANNOUNCING);
+
+        if (playing && this->media_player_wait_for_announcement_start_) {
+          // Announcement has started playing, wait for it to finish
+          this->media_player_wait_for_announcement_start_ = false;
+          this->media_player_wait_for_announcement_end_ = true;
+        }
+
+        if (!playing && this->media_player_wait_for_announcement_end_) {
+          // Announcement has finished playing
+          this->media_player_wait_for_announcement_end_ = false;
+          this->cancel_timeout("playing");
+          ESP_LOGD(TAG, "Announcement finished playing");
+          this->set_state_(State::RESPONSE_FINISHED, State::RESPONSE_FINISHED);
+
+          api::VoiceAssistantAnnounceFinished msg;
+          msg.success = true;
+          this->api_client_->send_voice_assistant_announce_finished(msg);
+          break;
+        }
       }
 #endif
       if (playing) {
@@ -417,7 +364,11 @@ void VoiceAssistant::loop() {
         this->tts_stream_end_trigger_->trigger();
       }
 #endif
-      this->set_state_(State::IDLE, State::IDLE);
+      if (this->continue_conversation_) {
+        this->set_state_(State::START_MICROPHONE, State::START_PIPELINE);
+      } else {
+        this->set_state_(State::IDLE, State::IDLE);
+      }
       break;
     }
     default:
@@ -527,7 +478,7 @@ void VoiceAssistant::start_streaming() {
   ESP_LOGD(TAG, "Client started, streaming microphone");
   this->audio_mode_ = AUDIO_MODE_API;
 
-  if (this->mic_->is_running()) {
+  if (this->mic_source_->is_running()) {
     this->set_state_(State::STREAMING_MICROPHONE, State::STREAMING_MICROPHONE);
   } else {
     this->set_state_(State::START_MICROPHONE, State::STREAMING_MICROPHONE);
@@ -557,7 +508,7 @@ void VoiceAssistant::start_streaming(struct sockaddr_storage *addr, uint16_t por
     return;
   }
 
-  if (this->mic_->is_running()) {
+  if (this->mic_source_->is_running()) {
     this->set_state_(State::STREAMING_MICROPHONE, State::STREAMING_MICROPHONE);
   } else {
     this->set_state_(State::START_MICROPHONE, State::STREAMING_MICROPHONE);
@@ -574,19 +525,14 @@ void VoiceAssistant::request_start(bool continuous, bool silence_detection) {
   if (this->state_ == State::IDLE) {
     this->continuous_ = continuous;
     this->silence_detection_ = silence_detection;
-#ifdef USE_ESP_ADF
-    if (this->use_wake_word_) {
-      this->set_state_(State::START_MICROPHONE, State::WAIT_FOR_VAD);
-    } else
-#endif
-    {
-      this->set_state_(State::START_MICROPHONE, State::START_PIPELINE);
-    }
+
+    this->set_state_(State::START_MICROPHONE, State::START_PIPELINE);
   }
 }
 
 void VoiceAssistant::request_stop() {
   this->continuous_ = false;
+  this->continue_conversation_ = false;
 
   switch (this->state_) {
     case State::IDLE:
@@ -611,6 +557,16 @@ void VoiceAssistant::request_stop() {
       this->signal_stop_();
       break;
     case State::STREAMING_RESPONSE:
+#ifdef USE_MEDIA_PLAYER
+      // Stop any ongoing media player announcement
+      if (this->media_player_ != nullptr) {
+        this->media_player_->make_call()
+            .set_command(media_player::MEDIA_PLAYER_COMMAND_STOP)
+            .set_announcement(true)
+            .perform();
+      }
+#endif
+      break;
     case State::RESPONSE_FINISHED:
       break;  // Let the incoming audio stream finish then it will go to idle.
   }
@@ -628,9 +584,9 @@ void VoiceAssistant::signal_stop_() {
 }
 
 void VoiceAssistant::start_playback_timeout_() {
-  this->set_timeout("playing", 100, [this]() {
+  this->set_timeout("playing", 2000, [this]() {
     this->cancel_timeout("speaker-timeout");
-    this->set_state_(State::IDLE, State::IDLE);
+    this->set_state_(State::RESPONSE_FINISHED, State::RESPONSE_FINISHED);
 
     api::VoiceAssistantAnnounceFinished msg;
     msg.success = true;
@@ -679,6 +635,8 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
       for (auto arg : msg.data) {
         if (arg.name == "conversation_id") {
           this->conversation_id_ = std::move(arg.value);
+        } else if (arg.name == "continue_conversation") {
+          this->continue_conversation_ = (arg.value == "1");
         }
       }
       this->defer([this]() { this->intent_end_trigger_->trigger(); });
@@ -722,6 +680,9 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
 #ifdef USE_MEDIA_PLAYER
         if (this->media_player_ != nullptr) {
           this->media_player_->make_call().set_media_url(url).set_announcement(true).perform();
+
+          this->media_player_wait_for_announcement_start_ = true;
+          this->media_player_wait_for_announcement_end_ = false;
           // Start the playback timeout, as the media player state isn't immediately updated
           this->start_playback_timeout_();
         }
@@ -734,21 +695,13 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
     }
     case api::enums::VOICE_ASSISTANT_RUN_END: {
       ESP_LOGD(TAG, "Assist Pipeline ended");
-      if ((this->state_ == State::STARTING_PIPELINE) || (this->state_ == State::AWAITING_RESPONSE)) {
-        // Pipeline ended before starting microphone
-        // Or there wasn't a TTS start event ("nevermind")
+      if ((this->state_ == State::START_PIPELINE) || (this->state_ == State::STARTING_PIPELINE) ||
+          (this->state_ == State::STREAMING_MICROPHONE)) {
+        // Microphone is running, stop it
+        this->set_state_(State::STOP_MICROPHONE, State::IDLE);
+      } else if (this->state_ == State::AWAITING_RESPONSE) {
+        // No TTS start event ("nevermind")
         this->set_state_(State::IDLE, State::IDLE);
-      } else if (this->state_ == State::STREAMING_MICROPHONE) {
-        this->ring_buffer_->reset();
-#ifdef USE_ESP_ADF
-        if (this->use_wake_word_) {
-          // No need to stop the microphone since we didn't use the speaker
-          this->set_state_(State::WAIT_FOR_VAD, State::WAITING_FOR_VAD);
-        } else
-#endif
-        {
-          this->set_state_(State::IDLE, State::IDLE);
-        }
       }
       this->defer([this]() { this->end_trigger_->trigger(); });
       break;
@@ -888,14 +841,87 @@ void VoiceAssistant::on_announce(const api::VoiceAssistantAnnounceRequest &msg)
 #ifdef USE_MEDIA_PLAYER
   if (this->media_player_ != nullptr) {
     this->tts_start_trigger_->trigger(msg.text);
-    this->media_player_->make_call().set_media_url(msg.media_id).set_announcement(true).perform();
-    this->set_state_(State::STREAMING_RESPONSE, State::STREAMING_RESPONSE);
+    if (!msg.preannounce_media_id.empty()) {
+      this->media_player_->make_call().set_media_url(msg.preannounce_media_id).set_announcement(true).perform();
+    }
+    // Enqueueing a URL with an empty playlist will still play the file immediately
+    this->media_player_->make_call()
+        .set_command(media_player::MEDIA_PLAYER_COMMAND_ENQUEUE)
+        .set_media_url(msg.media_id)
+        .set_announcement(true)
+        .perform();
+    this->continue_conversation_ = msg.start_conversation;
+
+    this->media_player_wait_for_announcement_start_ = true;
+    this->media_player_wait_for_announcement_end_ = false;
+    // Start the playback timeout, as the media player state isn't immediately updated
+    this->start_playback_timeout_();
+
+    if (this->continuous_) {
+      this->set_state_(State::STOP_MICROPHONE, State::STREAMING_RESPONSE);
+    } else {
+      this->set_state_(State::STREAMING_RESPONSE, State::STREAMING_RESPONSE);
+    }
+
     this->tts_end_trigger_->trigger(msg.media_id);
     this->end_trigger_->trigger();
   }
 #endif
 }
 
+void VoiceAssistant::on_set_configuration(const std::vector<std::string> &active_wake_words) {
+#ifdef USE_MICRO_WAKE_WORD
+  if (this->micro_wake_word_) {
+    // Disable all wake words first
+    for (auto &model : this->micro_wake_word_->get_wake_words()) {
+      model->disable();
+    }
+
+    // Enable only active wake words
+    for (auto ww_id : active_wake_words) {
+      for (auto &model : this->micro_wake_word_->get_wake_words()) {
+        if (model->get_id() == ww_id) {
+          model->enable();
+          ESP_LOGD(TAG, "Enabled wake word: %s (id=%s)", model->get_wake_word().c_str(), model->get_id().c_str());
+        }
+      }
+    }
+  }
+#endif
+};
+
+const Configuration &VoiceAssistant::get_configuration() {
+  this->config_.available_wake_words.clear();
+  this->config_.active_wake_words.clear();
+
+#ifdef USE_MICRO_WAKE_WORD
+  if (this->micro_wake_word_) {
+    this->config_.max_active_wake_words = 1;
+
+    for (auto &model : this->micro_wake_word_->get_wake_words()) {
+      if (model->is_enabled()) {
+        this->config_.active_wake_words.push_back(model->get_id());
+      }
+
+      WakeWord wake_word;
+      wake_word.id = model->get_id();
+      wake_word.wake_word = model->get_wake_word();
+      for (const auto &lang : model->get_trained_languages()) {
+        wake_word.trained_languages.push_back(lang);
+      }
+      this->config_.available_wake_words.push_back(std::move(wake_word));
+    }
+  } else {
+#endif
+    // No microWakeWord
+    this->config_.max_active_wake_words = 0;
+#ifdef USE_MICRO_WAKE_WORD
+  }
+#endif
+
+  return this->config_;
+};
+
 VoiceAssistant *global_voice_assistant = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace voice_assistant

esphome/components/voice_assistant/voice_assistant.h

@@ -11,18 +11,17 @@
 
 #include "esphome/components/api/api_connection.h"
 #include "esphome/components/api/api_pb2.h"
-#include "esphome/components/microphone/microphone.h"
-#ifdef USE_SPEAKER
-#include "esphome/components/speaker/speaker.h"
-#endif
+#include "esphome/components/microphone/microphone_source.h"
 #ifdef USE_MEDIA_PLAYER
 #include "esphome/components/media_player/media_player.h"
 #endif
-#include "esphome/components/socket/socket.h"
-
-#ifdef USE_ESP_ADF
-#include <esp_vad.h>
+#ifdef USE_MICRO_WAKE_WORD
+#include "esphome/components/micro_wake_word/micro_wake_word.h"
+#endif
+#ifdef USE_SPEAKER
+#include "esphome/components/speaker/speaker.h"
 #endif
+#include "esphome/components/socket/socket.h"
 
 #include <unordered_map>
 #include <vector>
@@ -41,6 +40,7 @@ enum VoiceAssistantFeature : uint32_t {
   FEATURE_API_AUDIO = 1 << 2,
   FEATURE_TIMERS = 1 << 3,
   FEATURE_ANNOUNCE = 1 << 4,
+  FEATURE_START_CONVERSATION = 1 << 5,
 };
 
 enum class State {
@@ -95,12 +95,16 @@ class VoiceAssistant : public Component {
   VoiceAssistant();
 
   void loop() override;
+  void setup() override;
   float get_setup_priority() const override;
   void start_streaming();
   void start_streaming(struct sockaddr_storage *addr, uint16_t port);
   void failed_to_start();
 
-  void set_microphone(microphone::Microphone *mic) { this->mic_ = mic; }
+  void set_microphone_source(microphone::MicrophoneSource *mic_source) { this->mic_source_ = mic_source; }
+#ifdef USE_MICRO_WAKE_WORD
+  void set_micro_wake_word(micro_wake_word::MicroWakeWord *mww) { this->micro_wake_word_ = mww; }
+#endif
 #ifdef USE_SPEAKER
   void set_speaker(speaker::Speaker *speaker) {
     this->speaker_ = speaker;
@@ -140,6 +144,7 @@ class VoiceAssistant : public Component {
 #ifdef USE_MEDIA_PLAYER
     if (this->media_player_ != nullptr) {
       flags |= VoiceAssistantFeature::FEATURE_ANNOUNCE;
+      flags |= VoiceAssistantFeature::FEATURE_START_CONVERSATION;
     }
 #endif
 
@@ -153,17 +158,14 @@ class VoiceAssistant : public Component {
   void on_audio(const api::VoiceAssistantAudio &msg);
   void on_timer_event(const api::VoiceAssistantTimerEventResponse &msg);
   void on_announce(const api::VoiceAssistantAnnounceRequest &msg);
-  void on_set_configuration(const std::vector<std::string> &active_wake_words){};
-  const Configuration &get_configuration() { return this->config_; };
+  void on_set_configuration(const std::vector<std::string> &active_wake_words);
+  const Configuration &get_configuration();
 
   bool is_running() const { return this->state_ != State::IDLE; }
   void set_continuous(bool continuous) { this->continuous_ = continuous; }
   bool is_continuous() const { return this->continuous_; }
 
   void set_use_wake_word(bool use_wake_word) { this->use_wake_word_ = use_wake_word; }
-#ifdef USE_ESP_ADF
-  void set_vad_threshold(uint8_t vad_threshold) { this->vad_threshold_ = vad_threshold; }
-#endif
 
   void set_noise_suppression_level(uint8_t noise_suppression_level) {
     this->noise_suppression_level_ = noise_suppression_level;
@@ -212,7 +214,6 @@ class VoiceAssistant : public Component {
   void clear_buffers_();
   void deallocate_buffers_();
 
-  int read_microphone_();
   void set_state_(State state);
   void set_state_(State state, State desired_state);
   void signal_stop_();
@@ -254,7 +255,7 @@ class VoiceAssistant : public Component {
   bool has_timers_{false};
   bool timer_tick_running_{false};
 
-  microphone::Microphone *mic_{nullptr};
+  microphone::MicrophoneSource *mic_source_{nullptr};
 #ifdef USE_SPEAKER
   void write_speaker_();
   speaker::Speaker *speaker_{nullptr};
@@ -267,6 +268,8 @@ class VoiceAssistant : public Component {
 #endif
 #ifdef USE_MEDIA_PLAYER
   media_player::MediaPlayer *media_player_{nullptr};
+  bool media_player_wait_for_announcement_start_{false};
+  bool media_player_wait_for_announcement_end_{false};
 #endif
 
   bool local_output_{false};
@@ -275,14 +278,7 @@ class VoiceAssistant : public Component {
 
   std::string wake_word_{""};
 
-  HighFrequencyLoopRequester high_freq_;
-
-#ifdef USE_ESP_ADF
-  vad_handle_t vad_instance_;
-  uint8_t vad_threshold_{5};
-  uint8_t vad_counter_{0};
-#endif
-  std::unique_ptr<RingBuffer> ring_buffer_;
+  std::shared_ptr<RingBuffer> ring_buffer_;
 
   bool use_wake_word_;
   uint8_t noise_suppression_level_;
@@ -291,11 +287,12 @@ class VoiceAssistant : public Component {
   uint32_t conversation_timeout_;
 
   uint8_t *send_buffer_{nullptr};
-  int16_t *input_buffer_{nullptr};
 
   bool continuous_{false};
   bool silence_detection_;
 
+  bool continue_conversation_{false};
+
   State state_{State::IDLE};
   State desired_state_{State::IDLE};
 
@@ -304,6 +301,10 @@ class VoiceAssistant : public Component {
   bool start_udp_socket_();
 
   Configuration config_{};
+
+#ifdef USE_MICRO_WAKE_WORD
+  micro_wake_word::MicroWakeWord *micro_wake_word_{nullptr};
+#endif
 };
 
 template<typename... Ts> class StartAction : public Action<Ts...>, public Parented<VoiceAssistant> {

esphome/components/waveshare_epaper/display.py

@@ -70,12 +70,16 @@ WaveshareEPaper4P2InBV2 = waveshare_epaper_ns.class_(
 WaveshareEPaper4P2InBV2BWR = waveshare_epaper_ns.class_(
     "WaveshareEPaper4P2InBV2BWR", WaveshareEPaperBWR
 )
+WaveshareEPaper5P65InF = waveshare_epaper_ns.class_(
+    "WaveshareEPaper5P65InF", WaveshareEPaper7C
+)
 WaveshareEPaper5P8In = waveshare_epaper_ns.class_(
     "WaveshareEPaper5P8In", WaveshareEPaper
 )
 WaveshareEPaper5P8InV2 = waveshare_epaper_ns.class_(
     "WaveshareEPaper5P8InV2", WaveshareEPaper
 )
+GDEY0583T81 = waveshare_epaper_ns.class_("GDEY0583T81", WaveshareEPaper)
 WaveshareEPaper7P3InF = waveshare_epaper_ns.class_(
     "WaveshareEPaper7P3InF", WaveshareEPaper7C
 )
@@ -150,8 +154,10 @@ MODELS = {
     "4.20in": ("b", WaveshareEPaper4P2In),
     "4.20in-bv2": ("b", WaveshareEPaper4P2InBV2),
     "4.20in-bv2-bwr": ("b", WaveshareEPaper4P2InBV2BWR),
+    "5.65in-f": ("b", WaveshareEPaper5P65InF),
     "5.83in": ("b", WaveshareEPaper5P8In),
     "5.83inv2": ("b", WaveshareEPaper5P8InV2),
+    "gdey0583t81": ("c", GDEY0583T81),
     "7.30in-f": ("b", WaveshareEPaper7P3InF),
     "7.50in": ("b", WaveshareEPaper7P5In),
     "7.50in-bv2": ("b", WaveshareEPaper7P5InBV2),