esphome 2025.4.2__py3-none-any.whl → 2025.5.0b3__py3-none-any.whl

esphome/components/micro_wake_word/micro_wake_word.cpp

@@ -1,5 +1,4 @@
 #include "micro_wake_word.h"
-#include "streaming_model.h"
 
 #ifdef USE_ESP_IDF
 
@@ -7,41 +6,55 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-#include <frontend.h>
-#include <frontend_util.h>
+#include "esphome/components/audio/audio_transfer_buffer.h"
 
-#include <tensorflow/lite/core/c/common.h>
-#include <tensorflow/lite/micro/micro_interpreter.h>
-#include <tensorflow/lite/micro/micro_mutable_op_resolver.h>
-
-#include <cmath>
+#ifdef USE_OTA
+#include "esphome/components/ota/ota_backend.h"
+#endif
 
 namespace esphome {
 namespace micro_wake_word {
 
 static const char *const TAG = "micro_wake_word";
 
-static const size_t SAMPLE_RATE_HZ = 16000;  // 16 kHz
-static const size_t BUFFER_LENGTH = 64;      // 0.064 seconds
-static const size_t BUFFER_SIZE = SAMPLE_RATE_HZ / 1000 * BUFFER_LENGTH;
-static const size_t INPUT_BUFFER_SIZE = 16 * SAMPLE_RATE_HZ / 1000;  // 16ms * 16kHz / 1000ms
+static const ssize_t DETECTION_QUEUE_LENGTH = 5;
+
+static const size_t DATA_TIMEOUT_MS = 50;
+
+static const uint32_t RING_BUFFER_DURATION_MS = 120;
+
+static const uint32_t INFERENCE_TASK_STACK_SIZE = 3072;
+static const UBaseType_t INFERENCE_TASK_PRIORITY = 3;
+
+enum EventGroupBits : uint32_t {
+  COMMAND_STOP = (1 << 0),  // Signals the inference task should stop
+
+  TASK_STARTING = (1 << 3),
+  TASK_RUNNING = (1 << 4),
+  TASK_STOPPING = (1 << 5),
+  TASK_STOPPED = (1 << 6),
+
+  ERROR_MEMORY = (1 << 9),
+  ERROR_INFERENCE = (1 << 10),
+
+  WARNING_FULL_RING_BUFFER = (1 << 13),
+
+  ERROR_BITS = ERROR_MEMORY | ERROR_INFERENCE,
+  ALL_BITS = 0xfffff,  // 24 total bits available in an event group
+};
 
 float MicroWakeWord::get_setup_priority() const { return setup_priority::AFTER_CONNECTION; }
 
 static const LogString *micro_wake_word_state_to_string(State state) {
   switch (state) {
-    case State::IDLE:
-      return LOG_STR("IDLE");
-    case State::START_MICROPHONE:
-      return LOG_STR("START_MICROPHONE");
-    case State::STARTING_MICROPHONE:
-      return LOG_STR("STARTING_MICROPHONE");
+    case State::STARTING:
+      return LOG_STR("STARTING");
     case State::DETECTING_WAKE_WORD:
       return LOG_STR("DETECTING_WAKE_WORD");
-    case State::STOP_MICROPHONE:
-      return LOG_STR("STOP_MICROPHONE");
-    case State::STOPPING_MICROPHONE:
-      return LOG_STR("STOPPING_MICROPHONE");
+    case State::STOPPING:
+      return LOG_STR("STOPPING");
+    case State::STOPPED:
+      return LOG_STR("STOPPED");
     default:
       return LOG_STR("UNKNOWN");
   }
@@ -51,7 +64,7 @@ void MicroWakeWord::dump_config() {
   ESP_LOGCONFIG(TAG, "microWakeWord:");
   ESP_LOGCONFIG(TAG, "  models:");
   for (auto &model : this->wake_word_models_) {
-    model.log_model_config();
+    model->log_model_config();
   }
 #ifdef USE_MICRO_WAKE_WORD_VAD
   this->vad_model_->log_model_config();
@@ -61,308 +74,318 @@ void MicroWakeWord::dump_config() {
 void MicroWakeWord::setup() {
   ESP_LOGCONFIG(TAG, "Setting up microWakeWord...");
 
-  if (!this->register_streaming_ops_(this->streaming_op_resolver_)) {
+  this->frontend_config_.window.size_ms = FEATURE_DURATION_MS;
+  this->frontend_config_.window.step_size_ms = this->features_step_size_;
+  this->frontend_config_.filterbank.num_channels = PREPROCESSOR_FEATURE_SIZE;
+  this->frontend_config_.filterbank.lower_band_limit = FILTERBANK_LOWER_BAND_LIMIT;
+  this->frontend_config_.filterbank.upper_band_limit = FILTERBANK_UPPER_BAND_LIMIT;
+  this->frontend_config_.noise_reduction.smoothing_bits = NOISE_REDUCTION_SMOOTHING_BITS;
+  this->frontend_config_.noise_reduction.even_smoothing = NOISE_REDUCTION_EVEN_SMOOTHING;
+  this->frontend_config_.noise_reduction.odd_smoothing = NOISE_REDUCTION_ODD_SMOOTHING;
+  this->frontend_config_.noise_reduction.min_signal_remaining = NOISE_REDUCTION_MIN_SIGNAL_REMAINING;
+  this->frontend_config_.pcan_gain_control.enable_pcan = PCAN_GAIN_CONTROL_ENABLE_PCAN;
+  this->frontend_config_.pcan_gain_control.strength = PCAN_GAIN_CONTROL_STRENGTH;
+  this->frontend_config_.pcan_gain_control.offset = PCAN_GAIN_CONTROL_OFFSET;
+  this->frontend_config_.pcan_gain_control.gain_bits = PCAN_GAIN_CONTROL_GAIN_BITS;
+  this->frontend_config_.log_scale.enable_log = LOG_SCALE_ENABLE_LOG;
+  this->frontend_config_.log_scale.scale_shift = LOG_SCALE_SCALE_SHIFT;
+
+  this->event_group_ = xEventGroupCreate();
+  if (this->event_group_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to create event group");
     this->mark_failed();
     return;
   }
 
-  ESP_LOGCONFIG(TAG, "Micro Wake Word initialized");
+  this->detection_queue_ = xQueueCreate(DETECTION_QUEUE_LENGTH, sizeof(DetectionEvent));
+  if (this->detection_queue_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to create detection event queue");
+    this->mark_failed();
+    return;
+  }
 
-  this->frontend_config_.window.size_ms = FEATURE_DURATION_MS;
-  this->frontend_config_.window.step_size_ms = this->features_step_size_;
-  this->frontend_config_.filterbank.num_channels = PREPROCESSOR_FEATURE_SIZE;
-  this->frontend_config_.filterbank.lower_band_limit = 125.0;
-  this->frontend_config_.filterbank.upper_band_limit = 7500.0;
-  this->frontend_config_.noise_reduction.smoothing_bits = 10;
-  this->frontend_config_.noise_reduction.even_smoothing = 0.025;
-  this->frontend_config_.noise_reduction.odd_smoothing = 0.06;
-  this->frontend_config_.noise_reduction.min_signal_remaining = 0.05;
-  this->frontend_config_.pcan_gain_control.enable_pcan = 1;
-  this->frontend_config_.pcan_gain_control.strength = 0.95;
-  this->frontend_config_.pcan_gain_control.offset = 80.0;
-  this->frontend_config_.pcan_gain_control.gain_bits = 21;
-  this->frontend_config_.log_scale.enable_log = 1;
-  this->frontend_config_.log_scale.scale_shift = 6;
-}
+  this->microphone_source_->add_data_callback([this](const std::vector<uint8_t> &data) {
+    if (this->state_ == State::STOPPED) {
+      return;
+    }
+    std::shared_ptr<RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
+    if (this->ring_buffer_.use_count() > 1) {
+      size_t bytes_free = temp_ring_buffer->free();
 
-void MicroWakeWord::add_wake_word_model(const uint8_t *model_start, float probability_cutoff,
-                                        size_t sliding_window_average_size, const std::string &wake_word,
-                                        size_t tensor_arena_size) {
-  this->wake_word_models_.emplace_back(model_start, probability_cutoff, sliding_window_average_size, wake_word,
-                                       tensor_arena_size);
+      if (bytes_free < data.size()) {
+        xEventGroupSetBits(this->event_group_, EventGroupBits::WARNING_FULL_RING_BUFFER);
+        temp_ring_buffer->reset();
+      }
+      temp_ring_buffer->write((void *) data.data(), data.size());
+    }
+  });
+
+#ifdef USE_OTA
+  ota::get_global_ota_callback()->add_on_state_callback(
+      [this](ota::OTAState state, float progress, uint8_t error, ota::OTAComponent *comp) {
+        if (state == ota::OTA_STARTED) {
+          this->suspend_task_();
+        } else if (state == ota::OTA_ERROR) {
+          this->resume_task_();
+        }
+      });
+#endif
+  ESP_LOGCONFIG(TAG, "Micro Wake Word initialized");
 }
 
-#ifdef USE_MICRO_WAKE_WORD_VAD
-void MicroWakeWord::add_vad_model(const uint8_t *model_start, float probability_cutoff, size_t sliding_window_size,
-                                  size_t tensor_arena_size) {
-  this->vad_model_ = make_unique<VADModel>(model_start, probability_cutoff, sliding_window_size, tensor_arena_size);
-}
-#endif
+void MicroWakeWord::inference_task(void *params) {
+  MicroWakeWord *this_mww = (MicroWakeWord *) params;
 
-void MicroWakeWord::loop() {
-  switch (this->state_) {
-    case State::IDLE:
-      break;
-    case State::START_MICROPHONE:
-      ESP_LOGD(TAG, "Starting Microphone");
-      this->microphone_->start();
-      this->set_state_(State::STARTING_MICROPHONE);
-      this->high_freq_.start();
-      break;
-    case State::STARTING_MICROPHONE:
-      if (this->microphone_->is_running()) {
-        this->set_state_(State::DETECTING_WAKE_WORD);
-      }
-      break;
-    case State::DETECTING_WAKE_WORD:
-      while (!this->has_enough_samples_()) {
-        this->read_microphone_();
+  xEventGroupSetBits(this_mww->event_group_, EventGroupBits::TASK_STARTING);
+
+  {  // Ensures any C++ objects fall out of scope to deallocate before deleting the task
+
+    const size_t new_bytes_to_process =
+        this_mww->microphone_source_->get_audio_stream_info().ms_to_bytes(this_mww->features_step_size_);
+    std::unique_ptr<audio::AudioSourceTransferBuffer> audio_buffer;
+    int8_t features_buffer[PREPROCESSOR_FEATURE_SIZE];
+
+    if (!(xEventGroupGetBits(this_mww->event_group_) & ERROR_BITS)) {
+      // Allocate audio transfer buffer
+      audio_buffer = audio::AudioSourceTransferBuffer::create(new_bytes_to_process);
+
+      if (audio_buffer == nullptr) {
+        xEventGroupSetBits(this_mww->event_group_, EventGroupBits::ERROR_MEMORY);
       }
-      this->update_model_probabilities_();
-      if (this->detect_wake_words_()) {
-        ESP_LOGD(TAG, "Wake Word '%s' Detected", (this->detected_wake_word_).c_str());
-        this->detected_ = true;
-        this->set_state_(State::STOP_MICROPHONE);
+    }
+
+    if (!(xEventGroupGetBits(this_mww->event_group_) & ERROR_BITS)) {
+      // Allocate ring buffer
+      std::shared_ptr<RingBuffer> temp_ring_buffer = RingBuffer::create(
+          this_mww->microphone_source_->get_audio_stream_info().ms_to_bytes(RING_BUFFER_DURATION_MS));
+      if (temp_ring_buffer.use_count() == 0) {
+        xEventGroupSetBits(this_mww->event_group_, EventGroupBits::ERROR_MEMORY);
       }
-      break;
-    case State::STOP_MICROPHONE:
-      ESP_LOGD(TAG, "Stopping Microphone");
-      this->microphone_->stop();
-      this->set_state_(State::STOPPING_MICROPHONE);
-      this->high_freq_.stop();
-      this->unload_models_();
-      this->deallocate_buffers_();
-      break;
-    case State::STOPPING_MICROPHONE:
-      if (this->microphone_->is_stopped()) {
-        this->set_state_(State::IDLE);
-        if (this->detected_) {
-          this->wake_word_detected_trigger_->trigger(this->detected_wake_word_);
-          this->detected_ = false;
-          this->detected_wake_word_ = "";
+      audio_buffer->set_source(temp_ring_buffer);
+      this_mww->ring_buffer_ = temp_ring_buffer;
+    }
+
+    if (!(xEventGroupGetBits(this_mww->event_group_) & ERROR_BITS)) {
+      this_mww->microphone_source_->start();
+      xEventGroupSetBits(this_mww->event_group_, EventGroupBits::TASK_RUNNING);
+
+      while (!(xEventGroupGetBits(this_mww->event_group_) & COMMAND_STOP)) {
+        audio_buffer->transfer_data_from_source(pdMS_TO_TICKS(DATA_TIMEOUT_MS));
+
+        if (audio_buffer->available() < new_bytes_to_process) {
+          // Insufficient data to generate new spectrogram features, read more next iteration
+          continue;
         }
+
+        // Generate new spectrogram features
+        uint32_t processed_samples = this_mww->generate_features_(
+            (int16_t *) audio_buffer->get_buffer_start(), audio_buffer->available() / sizeof(int16_t), features_buffer);
+        audio_buffer->decrease_buffer_length(processed_samples * sizeof(int16_t));
+
+        // Run inference using the new spectorgram features
+        if (!this_mww->update_model_probabilities_(features_buffer)) {
+          xEventGroupSetBits(this_mww->event_group_, EventGroupBits::ERROR_INFERENCE);
+          break;
+        }
+
+        // Process each model's probabilities and possibly send a Detection Event to the queue
+        this_mww->process_probabilities_();
       }
-      break;
+    }
   }
-}
 
-void MicroWakeWord::start() {
-  if (!this->is_ready()) {
-    ESP_LOGW(TAG, "Wake word detection can't start as the component hasn't been setup yet");
-    return;
-  }
+  xEventGroupSetBits(this_mww->event_group_, EventGroupBits::TASK_STOPPING);
 
-  if (this->is_failed()) {
-    ESP_LOGW(TAG, "Wake word component is marked as failed. Please check setup logs");
-    return;
-  }
+  this_mww->unload_models_();
+  this_mww->microphone_source_->stop();
+  FrontendFreeStateContents(&this_mww->frontend_state_);
 
-  if (!this->load_models_() || !this->allocate_buffers_()) {
-    ESP_LOGE(TAG, "Failed to load the wake word model(s) or allocate buffers");
-    this->status_set_error();
-  } else {
-    this->status_clear_error();
+  xEventGroupSetBits(this_mww->event_group_, EventGroupBits::TASK_STOPPED);
+  while (true) {
+    // Continuously delay until the main loop deletes the task
+    delay(10);
   }
+}
 
-  if (this->status_has_error()) {
-    ESP_LOGW(TAG, "Wake word component has an error. Please check logs");
-    return;
+std::vector<WakeWordModel *> MicroWakeWord::get_wake_words() {
+  std::vector<WakeWordModel *> external_wake_word_models;
+  for (auto *model : this->wake_word_models_) {
+    if (!model->get_internal_only()) {
+      external_wake_word_models.push_back(model);
+    }
   }
+  return external_wake_word_models;
+}
 
-  if (this->state_ != State::IDLE) {
-    ESP_LOGW(TAG, "Wake word is already running");
-    return;
-  }
+void MicroWakeWord::add_wake_word_model(WakeWordModel *model) { this->wake_word_models_.push_back(model); }
 
-  this->reset_states_();
-  this->set_state_(State::START_MICROPHONE);
+#ifdef USE_MICRO_WAKE_WORD_VAD
+void MicroWakeWord::add_vad_model(const uint8_t *model_start, uint8_t probability_cutoff, size_t sliding_window_size,
+                                  size_t tensor_arena_size) {
+  this->vad_model_ = make_unique<VADModel>(model_start, probability_cutoff, sliding_window_size, tensor_arena_size);
 }
+#endif
 
-void MicroWakeWord::stop() {
-  if (this->state_ == State::IDLE) {
-    ESP_LOGW(TAG, "Wake word is already stopped");
-    return;
-  }
-  if (this->state_ == State::STOPPING_MICROPHONE) {
-    ESP_LOGW(TAG, "Wake word is already stopping");
-    return;
+void MicroWakeWord::suspend_task_() {
+  if (this->inference_task_handle_ != nullptr) {
+    vTaskSuspend(this->inference_task_handle_);
   }
-  this->set_state_(State::STOP_MICROPHONE);
 }
 
-void MicroWakeWord::set_state_(State state) {
-  ESP_LOGD(TAG, "State changed from %s to %s", LOG_STR_ARG(micro_wake_word_state_to_string(this->state_)),
-           LOG_STR_ARG(micro_wake_word_state_to_string(state)));
-  this->state_ = state;
+void MicroWakeWord::resume_task_() {
+  if (this->inference_task_handle_ != nullptr) {
+    vTaskResume(this->inference_task_handle_);
+  }
 }
 
-size_t MicroWakeWord::read_microphone_() {
-  size_t bytes_read = this->microphone_->read(this->input_buffer_, INPUT_BUFFER_SIZE * sizeof(int16_t));
-  if (bytes_read == 0) {
-    return 0;
-  }
+void MicroWakeWord::loop() {
+  uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
 
-  size_t bytes_free = this->ring_buffer_->free();
+  if (event_group_bits & EventGroupBits::ERROR_MEMORY) {
+    xEventGroupClearBits(this->event_group_, EventGroupBits::ERROR_MEMORY);
+    ESP_LOGE(TAG, "Encountered an error allocating buffers");
+  }
 
-  if (bytes_free < bytes_read) {
-    ESP_LOGW(TAG,
-             "Not enough free bytes in ring buffer to store incoming audio data (free bytes=%d, incoming bytes=%d). "
-             "Resetting the ring buffer. Wake word detection accuracy will be reduced.",
-             bytes_free, bytes_read);
+  if (event_group_bits & EventGroupBits::ERROR_INFERENCE) {
+    xEventGroupClearBits(this->event_group_, EventGroupBits::ERROR_INFERENCE);
+    ESP_LOGE(TAG, "Encountered an error while performing an inference");
+  }
 
-    this->ring_buffer_->reset();
+  if (event_group_bits & EventGroupBits::WARNING_FULL_RING_BUFFER) {
+    xEventGroupClearBits(this->event_group_, EventGroupBits::WARNING_FULL_RING_BUFFER);
+    ESP_LOGW(TAG, "Not enough free bytes in ring buffer to store incoming audio data. Resetting the ring buffer. Wake "
+                  "word detection accuracy will temporarily be reduced.");
   }
 
-  return this->ring_buffer_->write((void *) this->input_buffer_, bytes_read);
-}
+  if (event_group_bits & EventGroupBits::TASK_STARTING) {
+    ESP_LOGD(TAG, "Inference task has started, attempting to allocate memory for buffers");
+    xEventGroupClearBits(this->event_group_, EventGroupBits::TASK_STARTING);
+  }
 
-bool MicroWakeWord::allocate_buffers_() {
-  ExternalRAMAllocator<int16_t> audio_samples_allocator(ExternalRAMAllocator<int16_t>::ALLOW_FAILURE);
+  if (event_group_bits & EventGroupBits::TASK_RUNNING) {
+    ESP_LOGD(TAG, "Inference task is running");
 
-  if (this->input_buffer_ == nullptr) {
-    this->input_buffer_ = audio_samples_allocator.allocate(INPUT_BUFFER_SIZE * sizeof(int16_t));
-    if (this->input_buffer_ == nullptr) {
-      ESP_LOGE(TAG, "Could not allocate input buffer");
-      return false;
-    }
+    xEventGroupClearBits(this->event_group_, EventGroupBits::TASK_RUNNING);
+    this->set_state_(State::DETECTING_WAKE_WORD);
   }
 
-  if (this->preprocessor_audio_buffer_ == nullptr) {
-    this->preprocessor_audio_buffer_ = audio_samples_allocator.allocate(this->new_samples_to_get_());
-    if (this->preprocessor_audio_buffer_ == nullptr) {
-      ESP_LOGE(TAG, "Could not allocate the audio preprocessor's buffer.");
-      return false;
-    }
+  if (event_group_bits & EventGroupBits::TASK_STOPPING) {
+    ESP_LOGD(TAG, "Inference task is stopping, deallocating buffers");
+    xEventGroupClearBits(this->event_group_, EventGroupBits::TASK_STOPPING);
   }
 
-  if (this->ring_buffer_ == nullptr) {
-    this->ring_buffer_ = RingBuffer::create(BUFFER_SIZE * sizeof(int16_t));
-    if (this->ring_buffer_ == nullptr) {
-      ESP_LOGE(TAG, "Could not allocate ring buffer");
-      return false;
-    }
+  if ((event_group_bits & EventGroupBits::TASK_STOPPED)) {
+    ESP_LOGD(TAG, "Inference task is finished, freeing task resources");
+    vTaskDelete(this->inference_task_handle_);
+    this->inference_task_handle_ = nullptr;
+    xEventGroupClearBits(this->event_group_, ALL_BITS);
+    xQueueReset(this->detection_queue_);
+    this->set_state_(State::STOPPED);
   }
 
-  return true;
-}
-
-void MicroWakeWord::deallocate_buffers_() {
-  ExternalRAMAllocator<int16_t> audio_samples_allocator(ExternalRAMAllocator<int16_t>::ALLOW_FAILURE);
-  audio_samples_allocator.deallocate(this->input_buffer_, INPUT_BUFFER_SIZE * sizeof(int16_t));
-  this->input_buffer_ = nullptr;
-  audio_samples_allocator.deallocate(this->preprocessor_audio_buffer_, this->new_samples_to_get_());
-  this->preprocessor_audio_buffer_ = nullptr;
-}
-
-bool MicroWakeWord::load_models_() {
-  // Setup preprocesor feature generator
-  if (!FrontendPopulateState(&this->frontend_config_, &this->frontend_state_, AUDIO_SAMPLE_FREQUENCY)) {
-    ESP_LOGD(TAG, "Failed to populate frontend state");
-    FrontendFreeStateContents(&this->frontend_state_);
-    return false;
+  if ((this->pending_start_) && (this->state_ == State::STOPPED)) {
+    this->set_state_(State::STARTING);
+    this->pending_start_ = false;
   }
 
-  // Setup streaming models
-  for (auto &model : this->wake_word_models_) {
-    if (!model.load_model(this->streaming_op_resolver_)) {
-      ESP_LOGE(TAG, "Failed to initialize a wake word model.");
-      return false;
-    }
-  }
-#ifdef USE_MICRO_WAKE_WORD_VAD
-  if (!this->vad_model_->load_model(this->streaming_op_resolver_)) {
-    ESP_LOGE(TAG, "Failed to initialize VAD model.");
-    return false;
+  if ((this->pending_stop_) && (this->state_ == State::DETECTING_WAKE_WORD)) {
+    this->set_state_(State::STOPPING);
+    this->pending_stop_ = false;
   }
-#endif
 
-  return true;
-}
+  switch (this->state_) {
+    case State::STARTING:
+      if ((this->inference_task_handle_ == nullptr) && !this->status_has_error()) {
+        // Setup preprocesor feature generator. If done in the task, it would lock the task to its initial core, as it
+        // uses floating point operations.
+        if (!FrontendPopulateState(&this->frontend_config_, &this->frontend_state_,
+                                   this->microphone_source_->get_audio_stream_info().get_sample_rate())) {
+          this->status_momentary_error(
+              "Failed to allocate buffers for spectrogram feature processor, attempting again in 1 second", 1000);
+          return;
+        }
 
-void MicroWakeWord::unload_models_() {
-  FrontendFreeStateContents(&this->frontend_state_);
+        xTaskCreate(MicroWakeWord::inference_task, "mww", INFERENCE_TASK_STACK_SIZE, (void *) this,
+                    INFERENCE_TASK_PRIORITY, &this->inference_task_handle_);
 
-  for (auto &model : this->wake_word_models_) {
-    model.unload_model();
+        if (this->inference_task_handle_ == nullptr) {
+          FrontendFreeStateContents(&this->frontend_state_);  // Deallocate frontend state
+          this->status_momentary_error("Task failed to start, attempting again in 1 second", 1000);
+        }
+      }
+      break;
+    case State::DETECTING_WAKE_WORD: {
+      DetectionEvent detection_event;
+      while (xQueueReceive(this->detection_queue_, &detection_event, 0)) {
+        if (detection_event.blocked_by_vad) {
+          ESP_LOGD(TAG, "Wake word model predicts '%s', but VAD model doesn't.", detection_event.wake_word->c_str());
+        } else {
+          constexpr float uint8_to_float_divisor =
+              255.0f;  // Converting a quantized uint8 probability to floating point
+          ESP_LOGD(TAG, "Detected '%s' with sliding average probability is %.2f and max probability is %.2f",
+                   detection_event.wake_word->c_str(), (detection_event.average_probability / uint8_to_float_divisor),
+                   (detection_event.max_probability / uint8_to_float_divisor));
+          this->wake_word_detected_trigger_->trigger(*detection_event.wake_word);
+          if (this->stop_after_detection_) {
+            this->stop();
+          }
+        }
+      }
+      break;
+    }
+    case State::STOPPING:
+      xEventGroupSetBits(this->event_group_, EventGroupBits::COMMAND_STOP);
+      break;
+    case State::STOPPED:
+      break;
   }
-#ifdef USE_MICRO_WAKE_WORD_VAD
-  this->vad_model_->unload_model();
-#endif
 }
 
-void MicroWakeWord::update_model_probabilities_() {
-  int8_t audio_features[PREPROCESSOR_FEATURE_SIZE];
-
-  if (!this->generate_features_for_window_(audio_features)) {
+void MicroWakeWord::start() {
+  if (!this->is_ready()) {
+    ESP_LOGW(TAG, "Wake word detection can't start as the component hasn't been setup yet");
     return;
   }
 
-  // Increase the counter since the last positive detection
-  this->ignore_windows_ = std::min(this->ignore_windows_ + 1, 0);
-
-  for (auto &model : this->wake_word_models_) {
-    // Perform inference
-    model.perform_streaming_inference(audio_features);
+  if (this->is_failed()) {
+    ESP_LOGW(TAG, "Wake word component is marked as failed. Please check setup logs");
+    return;
   }
-#ifdef USE_MICRO_WAKE_WORD_VAD
-  this->vad_model_->perform_streaming_inference(audio_features);
-#endif
-}
 
-bool MicroWakeWord::detect_wake_words_() {
-  // Verify we have processed samples since the last positive detection
-  if (this->ignore_windows_ < 0) {
-    return false;
+  if (this->is_running()) {
+    ESP_LOGW(TAG, "Wake word detection is already running");
+    return;
   }
 
-#ifdef USE_MICRO_WAKE_WORD_VAD
-  bool vad_state = this->vad_model_->determine_detected();
-#endif
-
-  for (auto &model : this->wake_word_models_) {
-    if (model.determine_detected()) {
-#ifdef USE_MICRO_WAKE_WORD_VAD
-      if (vad_state) {
-#endif
-        this->detected_wake_word_ = model.get_wake_word();
-        return true;
-#ifdef USE_MICRO_WAKE_WORD_VAD
-      } else {
-        ESP_LOGD(TAG, "Wake word model predicts %s, but VAD model doesn't.", model.get_wake_word().c_str());
-      }
-#endif
-    }
-  }
+  ESP_LOGD(TAG, "Starting wake word detection");
 
-  return false;
+  this->pending_start_ = true;
+  this->pending_stop_ = false;
 }
 
-bool MicroWakeWord::has_enough_samples_() {
-  return this->ring_buffer_->available() >=
-         (this->features_step_size_ * (AUDIO_SAMPLE_FREQUENCY / 1000)) * sizeof(int16_t);
-}
+void MicroWakeWord::stop() {
+  if (this->state_ == STOPPED)
+    return;
 
-bool MicroWakeWord::generate_features_for_window_(int8_t features[PREPROCESSOR_FEATURE_SIZE]) {
-  // Ensure we have enough new audio samples in the ring buffer for a full window
-  if (!this->has_enough_samples_()) {
-    return false;
-  }
+  ESP_LOGD(TAG, "Stopping wake word detection");
 
-  size_t bytes_read = this->ring_buffer_->read((void *) (this->preprocessor_audio_buffer_),
-                                               this->new_samples_to_get_() * sizeof(int16_t), pdMS_TO_TICKS(200));
+  this->pending_start_ = false;
+  this->pending_stop_ = true;
+}
 
-  if (bytes_read == 0) {
-    ESP_LOGE(TAG, "Could not read data from Ring Buffer");
-  } else if (bytes_read < this->new_samples_to_get_() * sizeof(int16_t)) {
-    ESP_LOGD(TAG, "Partial Read of Data by Model");
-    ESP_LOGD(TAG, "Could only read %d bytes when required %d bytes ", bytes_read,
-             (int) (this->new_samples_to_get_() * sizeof(int16_t)));
-    return false;
+void MicroWakeWord::set_state_(State state) {
+  if (this->state_ != state) {
+    ESP_LOGD(TAG, "State changed from %s to %s", LOG_STR_ARG(micro_wake_word_state_to_string(this->state_)),
+             LOG_STR_ARG(micro_wake_word_state_to_string(state)));
+    this->state_ = state;
   }
+}
 
-  size_t num_samples_read;
-  struct FrontendOutput frontend_output = FrontendProcessSamples(
-      &this->frontend_state_, this->preprocessor_audio_buffer_, this->new_samples_to_get_(), &num_samples_read);
+size_t MicroWakeWord::generate_features_(int16_t *audio_buffer, size_t samples_available,
+                                         int8_t features_buffer[PREPROCESSOR_FEATURE_SIZE]) {
+  size_t processed_samples = 0;
+  struct FrontendOutput frontend_output =
+      FrontendProcessSamples(&this->frontend_state_, audio_buffer, samples_available, &processed_samples);
 
   for (size_t i = 0; i < frontend_output.size; ++i) {
     // These scaling values are set to match the TFLite audio frontend int8 output.
@@ -372,8 +395,8 @@ bool MicroWakeWord::generate_features_for_window_(int8_t features[PREPROCESSOR_F
     // for historical reasons, to match up with the output of other feature
     // generators.
     // The process is then further complicated when we quantize the model. This
-    // means we have to scale the 0.0 to 26.0 real values to the -128 to 127
-    // signed integer numbers.
+    // means we have to scale the 0.0 to 26.0 real values to the -128 (INT8_MIN)
+    // to 127 (INT8_MAX) signed integer numbers.
     // All this means that to get matching values from our integer feature
     // output into the tensor input, we have to perform:
     // input = (((feature / 25.6) / 26.0) * 256) - 128
@@ -382,74 +405,63 @@ bool MicroWakeWord::generate_features_for_window_(int8_t features[PREPROCESSOR_F
     constexpr int32_t value_scale = 256;
     constexpr int32_t value_div = 666;  // 666 = 25.6 * 26.0 after rounding
     int32_t value = ((frontend_output.values[i] * value_scale) + (value_div / 2)) / value_div;
-    value -= 128;
-    if (value < -128) {
-      value = -128;
-    }
-    if (value > 127) {
-      value = 127;
-    }
-    features[i] = value;
+
+    value += INT8_MIN;  // Adds a -128; i.e., subtracts 128
+    features_buffer[i] = static_cast<int8_t>(clamp<int32_t>(value, INT8_MIN, INT8_MAX));
   }
 
-  return true;
+  return processed_samples;
+}
+
+void MicroWakeWord::process_probabilities_() {
+#ifdef USE_MICRO_WAKE_WORD_VAD
+  DetectionEvent vad_state = this->vad_model_->determine_detected();
+
+  this->vad_state_ = vad_state.detected;  // atomic write, so thread safe
+#endif
+
+  for (auto &model : this->wake_word_models_) {
+    if (model->get_unprocessed_probability_status()) {
+      // Only detect wake words if there is a new probability since the last check
+      DetectionEvent wake_word_state = model->determine_detected();
+      if (wake_word_state.detected) {
+#ifdef USE_MICRO_WAKE_WORD_VAD
+        if (vad_state.detected) {
+#endif
+          xQueueSend(this->detection_queue_, &wake_word_state, portMAX_DELAY);
+          model->reset_probabilities();
+#ifdef USE_MICRO_WAKE_WORD_VAD
+        } else {
+          wake_word_state.blocked_by_vad = true;
+          xQueueSend(this->detection_queue_, &wake_word_state, portMAX_DELAY);
+        }
+#endif
+      }
+    }
+  }
 }
 
-void MicroWakeWord::reset_states_() {
-  ESP_LOGD(TAG, "Resetting buffers and probabilities");
-  this->ring_buffer_->reset();
-  this->ignore_windows_ = -MIN_SLICES_BEFORE_DETECTION;
+void MicroWakeWord::unload_models_() {
   for (auto &model : this->wake_word_models_) {
-    model.reset_probabilities();
+    model->unload_model();
   }
 #ifdef USE_MICRO_WAKE_WORD_VAD
-  this->vad_model_->reset_probabilities();
+  this->vad_model_->unload_model();
 #endif
 }
 
-bool MicroWakeWord::register_streaming_ops_(tflite::MicroMutableOpResolver<20> &op_resolver) {
-  if (op_resolver.AddCallOnce() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddVarHandle() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddReshape() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddReadVariable() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddStridedSlice() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddConcatenation() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddAssignVariable() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddConv2D() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddMul() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddAdd() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddMean() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddFullyConnected() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddLogistic() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddQuantize() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddDepthwiseConv2D() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddAveragePool2D() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddMaxPool2D() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddPad() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddPack() != kTfLiteOk)
-    return false;
-  if (op_resolver.AddSplitV() != kTfLiteOk)
-    return false;
-
-  return true;
+bool MicroWakeWord::update_model_probabilities_(const int8_t audio_features[PREPROCESSOR_FEATURE_SIZE]) {
+  bool success = true;
+
+  for (auto &model : this->wake_word_models_) {
+    // Perform inference
+    success = success & model->perform_streaming_inference(audio_features);
+  }
+#ifdef USE_MICRO_WAKE_WORD_VAD
+  success = success & this->vad_model_->perform_streaming_inference(audio_features);
+#endif
+
+  return success;
 }
 
 }  // namespace micro_wake_word