Add has_buffered_data() function to ESPADFSpeaker class

Co-authored-by: Abílio Costa <abmantis@users.noreply.github.com>

CODEOWNERS

@@ -100,6 +100,7 @@ esphome/components/esp32_can/* @Sympatron
 esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
+esphome/components/esp_adf/* @jesserockz
 esphome/components/ethernet_info/* @gtjadsonsantos
 esphome/components/exposure_notifications/* @OttoWinter
 esphome/components/ezo/* @ssieb

esphome/__main__.py

@@ -514,7 +514,7 @@ def command_clean(args, config):
 def command_dashboard(args):
     from esphome.dashboard import dashboard
 
-    return dashboard.start_web_server(args)
+    return dashboard.start_dashboard(args)
 
 
 def command_update_all(args):

esphome/components/esp_adf/__init__.py

@@ -0,0 +1,102 @@
+import os
+
+import esphome.config_validation as cv
+import esphome.codegen as cg
+import esphome.final_validate as fv
+
+from esphome.components import esp32
+
+from esphome.const import CONF_ID, CONF_BOARD
+
+CODEOWNERS = ["@jesserockz"]
+DEPENDENCIES = ["esp32"]
+
+CONF_ESP_ADF_ID = "esp_adf_id"
+CONF_ESP_ADF = "esp_adf"
+
+esp_adf_ns = cg.esphome_ns.namespace("esp_adf")
+ESPADF = esp_adf_ns.class_("ESPADF", cg.Component)
+ESPADFPipeline = esp_adf_ns.class_("ESPADFPipeline", cg.Parented.template(ESPADF))
+
+SUPPORTED_BOARDS = {
+    "esp32s3box": "CONFIG_ESP32_S3_BOX_BOARD",
+    "esp32s3boxlite": "CONFIG_ESP32_S3_BOX_LITE_BOARD",
+    "esp32s3box3": "CONFIG_ESP32_S3_BOX_3_BOARD",
+}
+
+
+def _default_board(config):
+    config = config.copy()
+    if board := config.get(CONF_BOARD) is None:
+        board = esp32.get_board()
+        if board in SUPPORTED_BOARDS:
+            config[CONF_BOARD] = board
+    return config
+
+
+def final_validate_usable_board(platform: str):
+    def _validate(adf_config):
+        board = adf_config.get(CONF_BOARD)
+        if board not in SUPPORTED_BOARDS:
+            raise cv.Invalid(f"Board {board} is not supported by esp-adf {platform}")
+        return adf_config
+
+    return cv.Schema(
+        {cv.Required(CONF_ESP_ADF_ID): fv.id_declaration_match_schema(_validate)},
+        extra=cv.ALLOW_EXTRA,
+    )
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ESPADF),
+            cv.Optional(CONF_BOARD): cv.string_strict,
+        }
+    ),
+    _default_board,
+    cv.only_with_esp_idf,
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+
+    cg.add_define("USE_ESP_ADF")
+
+    cg.add_platformio_option("build_unflags", "-Wl,--end-group")
+
+    esp32.add_idf_component(
+        name="esp-adf",
+        repo="https://github.com/espressif/esp-adf",
+        path="components",
+        ref="v2.5",
+        components=["*"],
+        submodules=["components/esp-sr", "components/esp-adf-libs"],
+    )
+
+    esp32.add_idf_component(
+        name="esp-dsp",
+        repo="https://github.com/espressif/esp-dsp",
+        ref="v1.2.0",
+    )
+
+    cg.add_platformio_option(
+        "board_build.embed_txtfiles", "components/dueros_service/duer_profile"
+    )
+
+    if board := config.get(CONF_BOARD):
+        cg.add_define("USE_ESP_ADF_BOARD")
+
+        esp32.add_idf_sdkconfig_option(SUPPORTED_BOARDS[board], True)
+
+        esp32.add_extra_script(
+            "pre",
+            "apply_adf_patches.py",
+            os.path.join(os.path.dirname(__file__), "apply_adf_patches.py.script"),
+        )
+        esp32.add_extra_build_file(
+            "esp_adf_patches/idf_v4.4_freertos.patch",
+            "https://github.com/espressif/esp-adf/raw/v2.5/idf_patches/idf_v4.4_freertos.patch",
+        )

esphome/components/esp_adf/apply_adf_patches.py.script

@@ -0,0 +1,23 @@
+from os.path import join, isfile
+
+Import("env")
+
+FRAMEWORK_DIR = env.PioPlatform().get_package_dir("framework-espidf")
+patchflag_path = join(FRAMEWORK_DIR, ".adf-patching-done")
+
+PROJECT_DIR = env.get('PROJECT_DIR')
+
+PATCH_FILE = join(PROJECT_DIR, "esp_adf_patches", "idf_v4.4_freertos.patch")
+
+# patch file only if we didn't do it before
+if not isfile(patchflag_path):
+    print(PATCH_FILE)
+    assert isfile(PATCH_FILE)
+
+    env.Execute("patch -p1 -d %s -i %s" % (FRAMEWORK_DIR, PATCH_FILE))
+
+    def _touch(path):
+        with open(path, "w") as fp:
+            fp.write("")
+
+    env.Execute(lambda *args, **kwargs: _touch(patchflag_path))

esphome/components/esp_adf/esp_adf.cpp

@@ -0,0 +1,30 @@
+#include "esp_adf.h"
+#include "esphome/core/defines.h"
+
+#ifdef USE_ESP_IDF
+
+#ifdef USE_ESP_ADF_BOARD
+#include <board.h>
+#endif
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace esp_adf {
+
+static const char *const TAG = "esp_adf";
+
+void ESPADF::setup() {
+#ifdef USE_ESP_ADF_BOARD
+  ESP_LOGI(TAG, "Start codec chip");
+  audio_board_handle_t board_handle = audio_board_init();
+  audio_hal_ctrl_codec(board_handle->audio_hal, AUDIO_HAL_CODEC_MODE_BOTH, AUDIO_HAL_CTRL_START);
+#endif
+}
+
+float ESPADF::get_setup_priority() const { return setup_priority::HARDWARE; }
+
+}  // namespace esp_adf
+}  // namespace esphome
+
+#endif  // USE_ESP_IDF

esphome/components/esp_adf/esp_adf.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#ifdef USE_ESP_IDF
+
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace esp_adf {
+
+static const size_t BUFFER_SIZE = 1024;
+
+enum class TaskEventType : uint8_t {
+  STARTING = 0,
+  STARTED,
+  RUNNING,
+  STOPPING,
+  STOPPED,
+  WARNING = 255,
+};
+
+struct TaskEvent {
+  TaskEventType type;
+  esp_err_t err;
+};
+
+struct CommandEvent {
+  bool stop;
+};
+
+struct DataEvent {
+  bool stop;
+  size_t len;
+  uint8_t data[BUFFER_SIZE];
+};
+
+class ESPADF;
+
+class ESPADFPipeline : public Parented<ESPADF> {};
+
+class ESPADF : public Component {
+ public:
+  void setup() override;
+
+  float get_setup_priority() const override;
+
+  void lock() { this->lock_.lock(); }
+  bool try_lock() { return this->lock_.try_lock(); }
+  void unlock() { this->lock_.unlock(); }
+
+ protected:
+  Mutex lock_;
+};
+
+}  // namespace esp_adf
+}  // namespace esphome
+
+#endif  // USE_ESP_IDF

esphome/components/esp_adf/microphone/__init__.py

@@ -0,0 +1,41 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import microphone
+from esphome.const import CONF_ID
+
+from .. import (
+    CONF_ESP_ADF_ID,
+    ESPADF,
+    ESPADFPipeline,
+    esp_adf_ns,
+    final_validate_usable_board,
+)
+
+AUTO_LOAD = ["esp_adf"]
+CONFLICTS_WITH = ["i2s_audio"]
+DEPENDENCIES = ["esp32"]
+
+ESPADFMicrophone = esp_adf_ns.class_(
+    "ESPADFMicrophone", ESPADFPipeline, microphone.Microphone, cg.Component
+)
+
+
+CONFIG_SCHEMA = cv.All(
+    microphone.MICROPHONE_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(ESPADFMicrophone),
+            cv.GenerateID(CONF_ESP_ADF_ID): cv.use_id(ESPADF),
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+    cv.only_with_esp_idf,
+)
+
+FINAL_VALIDATE_SCHEMA = final_validate_usable_board("microphone")
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await cg.register_parented(var, config[CONF_ESP_ADF_ID])
+
+    await microphone.register_microphone(var, config)

esphome/components/esp_adf/microphone/esp_adf_microphone.cpp

@@ -0,0 +1,336 @@
+#include "esp_adf_microphone.h"
+
+#ifdef USE_ESP_IDF
+
+#include <driver/i2s.h>
+
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+#include <algorithm_stream.h>
+#include <audio_element.h>
+#include <audio_hal.h>
+#include <audio_pipeline.h>
+#include <filter_resample.h>
+#include <i2s_stream.h>
+#include <raw_stream.h>
+#include <recorder_sr.h>
+
+#include <board.h>
+
+namespace esphome {
+namespace esp_adf {
+
+static const char *const TAG = "esp_adf.microphone";
+
+void ESPADFMicrophone::setup() {
+  this->ring_buffer_ = rb_create(8000, sizeof(int16_t));
+  if (this->ring_buffer_ == nullptr) {
+    ESP_LOGW(TAG, "Could not allocate ring buffer.");
+    this->mark_failed();
+    return;
+  }
+
+  this->read_event_queue_ = xQueueCreate(20, sizeof(TaskEvent));
+  this->read_command_queue_ = xQueueCreate(20, sizeof(CommandEvent));
+}
+
+void ESPADFMicrophone::start() {
+  if (this->is_failed())
+    return;
+  if (this->state_ == microphone::STATE_STOPPING) {
+    ESP_LOGW(TAG, "Microphone is stopping, cannot start.");
+    return;
+  }
+  this->state_ = microphone::STATE_STARTING;
+}
+void ESPADFMicrophone::start_() {
+  if (!this->parent_->try_lock()) {
+    return;
+  }
+
+  xTaskCreate(ESPADFMicrophone::read_task, "read_task", 8192, (void *) this, 0, &this->read_task_handle_);
+}
+
+void ESPADFMicrophone::read_task(void *params) {
+  ESPADFMicrophone *this_mic = (ESPADFMicrophone *) params;
+  TaskEvent event;
+
+  ExternalRAMAllocator<int16_t> allocator(ExternalRAMAllocator<int16_t>::ALLOW_FAILURE);
+  int16_t *buffer = allocator.allocate(BUFFER_SIZE / sizeof(int16_t));
+  if (buffer == nullptr) {
+    event.type = TaskEventType::WARNING;
+    event.err = ESP_ERR_NO_MEM;
+    xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
+
+    event.type = TaskEventType::STOPPED;
+    event.err = ESP_OK;
+    xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
+
+    while (true) {
+      delay(10);
+    }
+    return;
+  }
+
+  event.type = TaskEventType::STARTING;
+  xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
+
+  audio_pipeline_cfg_t pipeline_cfg = {
+      .rb_size = 8 * 1024,
+  };
+  audio_pipeline_handle_t pipeline = audio_pipeline_init(&pipeline_cfg);
+
+  i2s_driver_config_t i2s_config = {
+      .mode = (i2s_mode_t) (I2S_MODE_MASTER | I2S_MODE_RX),
+      .sample_rate = 16000,
+      .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
+      .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
+      .communication_format = I2S_COMM_FORMAT_STAND_I2S,
+      .intr_alloc_flags = ESP_INTR_FLAG_LEVEL2 | ESP_INTR_FLAG_IRAM,
+      .dma_buf_count = 8,
+      .dma_buf_len = 128,
+      .use_apll = false,
+      .tx_desc_auto_clear = true,
+      .fixed_mclk = 0,
+      .mclk_multiple = I2S_MCLK_MULTIPLE_256,
+      .bits_per_chan = I2S_BITS_PER_CHAN_DEFAULT,
+  };
+
+  i2s_stream_cfg_t i2s_cfg = {
+      .type = AUDIO_STREAM_READER,
+      .i2s_config = i2s_config,
+      .i2s_port = static_cast<i2s_port_t>(CODEC_ADC_I2S_PORT),
+      .use_alc = false,
+      .volume = 0,
+      .out_rb_size = I2S_STREAM_RINGBUFFER_SIZE,
+      .task_stack = I2S_STREAM_TASK_STACK,
+      .task_core = I2S_STREAM_TASK_CORE,
+      .task_prio = I2S_STREAM_TASK_PRIO,
+      .stack_in_ext = false,
+      .multi_out_num = 0,
+      .uninstall_drv = true,
+      .need_expand = false,
+      .expand_src_bits = I2S_BITS_PER_SAMPLE_16BIT,
+  };
+  audio_element_handle_t i2s_stream_reader = i2s_stream_init(&i2s_cfg);
+
+  rsp_filter_cfg_t rsp_cfg = {
+      .src_rate = 16000,
+      .src_ch = 2,
+      .dest_rate = 16000,
+      .dest_bits = 16,
+      .dest_ch = 1,
+      .src_bits = I2S_BITS_PER_SAMPLE_16BIT,
+      .mode = RESAMPLE_DECODE_MODE,
+      .max_indata_bytes = RSP_FILTER_BUFFER_BYTE,
+      .out_len_bytes = RSP_FILTER_BUFFER_BYTE,
+      .type = ESP_RESAMPLE_TYPE_AUTO,
+      .complexity = 2,
+      .down_ch_idx = 0,
+      .prefer_flag = ESP_RSP_PREFER_TYPE_SPEED,
+      .out_rb_size = RSP_FILTER_RINGBUFFER_SIZE,
+      .task_stack = RSP_FILTER_TASK_STACK,
+      .task_core = RSP_FILTER_TASK_CORE,
+      .task_prio = RSP_FILTER_TASK_PRIO,
+      .stack_in_ext = true,
+  };
+  audio_element_handle_t filter = rsp_filter_init(&rsp_cfg);
+
+  algorithm_stream_cfg_t algo_cfg = {
+      .input_type = ALGORITHM_STREAM_INPUT_TYPE1,
+      .task_stack = 10 * 1024,
+      .task_prio = ALGORITHM_STREAM_TASK_PERIOD,
+      .task_core = ALGORITHM_STREAM_PINNED_TO_CORE,
+      .out_rb_size = ALGORITHM_STREAM_RINGBUFFER_SIZE,
+      .stack_in_ext = true,
+      .rec_linear_factor = 1,
+      .ref_linear_factor = 1,
+      .debug_input = false,
+      .swap_ch = false,
+      // .algo_mask = ALGORITHM_STREAM_USE_AGC,
+      // .algo_mask = (ALGORITHM_STREAM_USE_AEC | ALGORITHM_STREAM_USE_AGC | ALGORITHM_STREAM_USE_NS),
+      // .algo_mask = (ALGORITHM_STREAM_USE_AGC | ALGORITHM_STREAM_USE_NS),
+      .algo_mask = (ALGORITHM_STREAM_USE_AEC | ALGORITHM_STREAM_USE_NS),
+      // .algo_mask = (ALGORITHM_STREAM_USE_NS),
+      .sample_rate = 16000,
+      .mic_ch = 1,
+      .agc_gain = 10,
+      .aec_low_cost = false,
+  };
+
+  // audio_element_handle_t algo_stream = algo_stream_init(&algo_cfg);
+
+  raw_stream_cfg_t raw_cfg = {
+      .type = AUDIO_STREAM_READER,
+      .out_rb_size = 8 * 1024,
+  };
+  audio_element_handle_t raw_read = raw_stream_init(&raw_cfg);
+
+  audio_pipeline_register(pipeline, i2s_stream_reader, "i2s");
+  audio_pipeline_register(pipeline, filter, "filter");
+  // audio_pipeline_register(pipeline, algo_stream, "algo");
+  audio_pipeline_register(pipeline, raw_read, "raw");
+
+  const char *link_tag[4] = {
+      "i2s",
+      "filter",
+      // "algo",
+      "raw",
+  };
+  audio_pipeline_link(pipeline, &link_tag[0], 3);
+
+  audio_pipeline_run(pipeline);
+
+  event.type = TaskEventType::STARTED;
+  xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
+
+  CommandEvent command_event;
+
+  while (true) {
+    if (xQueueReceive(this_mic->read_command_queue_, &command_event, 0) == pdTRUE) {
+      if (command_event.stop) {
+        // Stop signal from main thread
+        break;
+      }
+    }
+
+    int bytes_read = raw_stream_read(raw_read, (char *) buffer, BUFFER_SIZE);
+
+    if (bytes_read == -2 || bytes_read == 0) {
+      // No data in buffers to read.
+      continue;
+    } else if (bytes_read < 0) {
+      event.type = TaskEventType::WARNING;
+      event.err = bytes_read;
+      xQueueSend(this_mic->read_event_queue_, &event, 0);
+      continue;
+    }
+
+    event.type = TaskEventType::RUNNING;
+    event.err = bytes_read;
+    xQueueSend(this_mic->read_event_queue_, &event, 0);
+
+    int available = rb_bytes_available(this_mic->ring_buffer_);
+    if (available < bytes_read) {
+      rb_read(this_mic->ring_buffer_, nullptr, bytes_read - available, 0);
+    }
+    rb_write(this_mic->ring_buffer_, (char *) buffer, bytes_read, 0);
+  }
+
+  allocator.deallocate(buffer, BUFFER_SIZE / sizeof(int16_t));
+
+  audio_pipeline_stop(pipeline);
+  audio_pipeline_wait_for_stop(pipeline);
+  audio_pipeline_terminate(pipeline);
+
+  event.type = TaskEventType::STOPPING;
+  xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
+
+  audio_pipeline_unregister(pipeline, i2s_stream_reader);
+  audio_pipeline_unregister(pipeline, filter);
+  // audio_pipeline_unregister(pipeline, algo_stream);
+  audio_pipeline_unregister(pipeline, raw_read);
+
+  audio_pipeline_deinit(pipeline);
+  audio_element_deinit(i2s_stream_reader);
+  audio_element_deinit(filter);
+  // audio_element_deinit(algo_stream);
+  audio_element_deinit(raw_read);
+
+  event.type = TaskEventType::STOPPED;
+  xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
+
+  while (true) {
+    delay(10);
+  }
+}
+
+void ESPADFMicrophone::stop() {
+  if (this->state_ == microphone::STATE_STOPPED || this->state_ == microphone::STATE_STOPPING || this->is_failed())
+    return;
+  this->state_ = microphone::STATE_STOPPING;
+  CommandEvent command_event;
+  command_event.stop = true;
+  xQueueSendToFront(this->read_command_queue_, &command_event, portMAX_DELAY);
+  ESP_LOGD(TAG, "Stopping microphone");
+}
+
+size_t ESPADFMicrophone::read(int16_t *buf, size_t len) {
+  if (rb_bytes_available(this->ring_buffer_) == 0) {
+    return 0;  // No data
+  }
+  int bytes_read = rb_read(this->ring_buffer_, (char *) buf, len, 0);
+
+  if (bytes_read == -4 || bytes_read == -2 || bytes_read == 0) {
+    // No data in buffers to read.
+    return 0;
+  } else if (bytes_read < 0) {
+    ESP_LOGW(TAG, "Error reading from I2S microphone %s (%d)", esp_err_to_name(bytes_read), bytes_read);
+    this->status_set_warning();
+    return 0;
+  }
+  this->status_clear_warning();
+
+  return bytes_read;
+}
+
+void ESPADFMicrophone::read_() {
+  std::vector<int16_t> samples;
+  samples.resize(BUFFER_SIZE);
+  this->read(samples.data(), samples.size());
+
+  this->data_callbacks_.call(samples);
+}
+
+void ESPADFMicrophone::watch_() {
+  TaskEvent event;
+  if (xQueueReceive(this->read_event_queue_, &event, 0) == pdTRUE) {
+    switch (event.type) {
+      case TaskEventType::STARTING:
+      case TaskEventType::STOPPING:
+        break;
+      case TaskEventType::STARTED:
+        ESP_LOGD(TAG, "Microphone started");
+        this->state_ = microphone::STATE_RUNNING;
+        break;
+      case TaskEventType::RUNNING:
+        this->status_clear_warning();
+        // ESP_LOGD(TAG, "Putting %d bytes into ring buffer", event.err);
+        break;
+      case TaskEventType::STOPPED:
+        this->parent_->unlock();
+        this->state_ = microphone::STATE_STOPPED;
+        vTaskDelete(this->read_task_handle_);
+        this->read_task_handle_ = nullptr;
+        ESP_LOGD(TAG, "Microphone stopped");
+        break;
+      case TaskEventType::WARNING:
+        ESP_LOGW(TAG, "Error writing to pipeline: %s", esp_err_to_name(event.err));
+        this->status_set_warning();
+        break;
+    }
+  }
+}
+
+void ESPADFMicrophone::loop() {
+  this->watch_();
+  switch (this->state_) {
+    case microphone::STATE_STOPPED:
+    case microphone::STATE_STOPPING:
+      break;
+    case microphone::STATE_STARTING:
+      this->start_();
+      break;
+    case microphone::STATE_RUNNING:
+      if (this->data_callbacks_.size() > 0) {
+        this->read_();
+      }
+      break;
+  }
+}
+
+}  // namespace esp_adf
+}  // namespace esphome
+
+#endif  // USE_ESP_IDF

esphome/components/esp_adf/microphone/esp_adf_microphone.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#ifdef USE_ESP_IDF
+
+#include "../esp_adf.h"
+
+#include "esphome/components/microphone/microphone.h"
+#include "esphome/core/component.h"
+
+#include <ringbuf.h>
+
+namespace esphome {
+namespace esp_adf {
+
+class ESPADFMicrophone : public ESPADFPipeline, public microphone::Microphone, public Component {
+ public:
+  void setup() override;
+  void start() override;
+  void stop() override;
+
+  void loop() override;
+
+  size_t read(int16_t *buf, size_t len) override;
+
+ protected:
+  void start_();
+  void read_();
+  void watch_();
+
+  static void read_task(void *params);
+
+  ringbuf_handle_t ring_buffer_;
+
+  TaskHandle_t read_task_handle_{nullptr};
+  QueueHandle_t read_event_queue_;
+  QueueHandle_t read_command_queue_;
+};
+
+}  // namespace esp_adf
+}  // namespace esphome
+
+#endif  // USE_ESP_IDF

esphome/components/esp_adf/speaker/__init__.py

@@ -0,0 +1,41 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import speaker
+from esphome.const import CONF_ID
+
+from .. import (
+    CONF_ESP_ADF_ID,
+    ESPADF,
+    ESPADFPipeline,
+    esp_adf_ns,
+    final_validate_usable_board,
+)
+
+AUTO_LOAD = ["esp_adf"]
+CONFLICTS_WITH = ["i2s_audio"]
+DEPENDENCIES = ["esp32"]
+
+ESPADFSpeaker = esp_adf_ns.class_(
+    "ESPADFSpeaker", ESPADFPipeline, speaker.Speaker, cg.Component
+)
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ESPADFSpeaker),
+            cv.GenerateID(CONF_ESP_ADF_ID): cv.use_id(ESPADF),
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+    cv.only_with_esp_idf,
+)
+
+FINAL_VALIDATE_SCHEMA = final_validate_usable_board("speaker")
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await cg.register_parented(var, config[CONF_ESP_ADF_ID])
+
+    await speaker.register_speaker(var, config)

esphome/components/esp_adf/speaker/esp_adf_speaker.cpp

@@ -0,0 +1,274 @@
+#include "esp_adf_speaker.h"
+
+#ifdef USE_ESP_IDF
+
+#include <driver/i2s.h>
+
+#include "esphome/core/application.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+#include <audio_hal.h>
+#include <filter_resample.h>
+#include <i2s_stream.h>
+#include <raw_stream.h>
+
+namespace esphome {
+namespace esp_adf {
+
+static const size_t BUFFER_COUNT = 50;
+
+static const char *const TAG = "esp_adf.speaker";
+
+void ESPADFSpeaker::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up ESP ADF Speaker...");
+
+  this->buffer_queue_ = xQueueCreate(BUFFER_COUNT, sizeof(DataEvent));
+  this->event_queue_ = xQueueCreate(20, sizeof(TaskEvent));
+}
+
+void ESPADFSpeaker::start() { this->state_ = speaker::STATE_STARTING; }
+void ESPADFSpeaker::start_() {
+  if (!this->parent_->try_lock()) {
+    return;  // Waiting for another i2s component to return lock
+  }
+
+  xTaskCreate(ESPADFSpeaker::player_task, "speaker_task", 8192, (void *) this, 0, &this->player_task_handle_);
+}
+
+void ESPADFSpeaker::player_task(void *params) {
+  ESPADFSpeaker *this_speaker = (ESPADFSpeaker *) params;
+
+  TaskEvent event;
+  event.type = TaskEventType::STARTING;
+  xQueueSend(this_speaker->event_queue_, &event, portMAX_DELAY);
+
+  i2s_driver_config_t i2s_config = {
+      .mode = (i2s_mode_t) (I2S_MODE_MASTER | I2S_MODE_TX),
+      .sample_rate = 16000,
+      .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
+      .channel_format = I2S_CHANNEL_FMT_ONLY_RIGHT,
+      .communication_format = I2S_COMM_FORMAT_STAND_I2S,
+      .intr_alloc_flags = ESP_INTR_FLAG_LEVEL2 | ESP_INTR_FLAG_IRAM,
+      .dma_buf_count = 8,
+      .dma_buf_len = 1024,
+      .use_apll = false,
+      .tx_desc_auto_clear = true,
+      .fixed_mclk = 0,
+      .mclk_multiple = I2S_MCLK_MULTIPLE_256,
+      .bits_per_chan = I2S_BITS_PER_CHAN_DEFAULT,
+  };
+
+  audio_pipeline_cfg_t pipeline_cfg = {
+      .rb_size = 8 * 1024,
+  };
+  audio_pipeline_handle_t pipeline = audio_pipeline_init(&pipeline_cfg);
+
+  i2s_stream_cfg_t i2s_cfg = {
+      .type = AUDIO_STREAM_WRITER,
+      .i2s_config = i2s_config,
+      .i2s_port = I2S_NUM_0,
+      .use_alc = false,
+      .volume = 0,
+      .out_rb_size = I2S_STREAM_RINGBUFFER_SIZE,
+      .task_stack = I2S_STREAM_TASK_STACK,
+      .task_core = I2S_STREAM_TASK_CORE,
+      .task_prio = I2S_STREAM_TASK_PRIO,
+      .stack_in_ext = false,
+      .multi_out_num = 0,
+      .uninstall_drv = true,
+      .need_expand = false,
+      .expand_src_bits = I2S_BITS_PER_SAMPLE_16BIT,
+  };
+  audio_element_handle_t i2s_stream_writer = i2s_stream_init(&i2s_cfg);
+
+  rsp_filter_cfg_t rsp_cfg = {
+      .src_rate = 16000,
+      .src_ch = 1,
+      .dest_rate = 16000,
+      .dest_bits = 16,
+      .dest_ch = 2,
+      .src_bits = 16,
+      .mode = RESAMPLE_DECODE_MODE,
+      .max_indata_bytes = RSP_FILTER_BUFFER_BYTE,
+      .out_len_bytes = RSP_FILTER_BUFFER_BYTE,
+      .type = ESP_RESAMPLE_TYPE_AUTO,
+      .complexity = 2,
+      .down_ch_idx = 0,
+      .prefer_flag = ESP_RSP_PREFER_TYPE_SPEED,
+      .out_rb_size = RSP_FILTER_RINGBUFFER_SIZE,
+      .task_stack = RSP_FILTER_TASK_STACK,
+      .task_core = RSP_FILTER_TASK_CORE,
+      .task_prio = RSP_FILTER_TASK_PRIO,
+      .stack_in_ext = true,
+  };
+  audio_element_handle_t filter = rsp_filter_init(&rsp_cfg);
+
+  raw_stream_cfg_t raw_cfg = {
+      .type = AUDIO_STREAM_WRITER,
+      .out_rb_size = 8 * 1024,
+  };
+  audio_element_handle_t raw_write = raw_stream_init(&raw_cfg);
+
+  audio_pipeline_register(pipeline, raw_write, "raw");
+  audio_pipeline_register(pipeline, filter, "filter");
+  audio_pipeline_register(pipeline, i2s_stream_writer, "i2s");
+
+  const char *link_tag[3] = {
+      "raw",
+      // "filter",
+      "i2s",
+  };
+  audio_pipeline_link(pipeline, &link_tag[0], 2);
+
+  audio_pipeline_run(pipeline);
+
+  DataEvent data_event;
+
+  event.type = TaskEventType::STARTED;
+  xQueueSend(this_speaker->event_queue_, &event, 0);
+
+  uint32_t last_received = millis();
+
+  while (true) {
+    if (xQueueReceive(this_speaker->buffer_queue_, &data_event, 0) != pdTRUE) {
+      if (millis() - last_received > 500) {
+        // No audio for 500ms, stop
+        break;
+      } else {
+        continue;
+      }
+    }
+    if (data_event.stop) {
+      // Stop signal from main thread
+      while (xQueueReceive(this_speaker->buffer_queue_, &data_event, 0) == pdTRUE) {
+        // Flush queue
+      }
+      break;
+    }
+
+    size_t remaining = data_event.len;
+    size_t current = 0;
+    if (remaining > 0)
+      last_received = millis();
+
+    while (remaining > 0) {
+      int bytes_written = raw_stream_write(raw_write, (char *) data_event.data + current, remaining);
+      if (bytes_written == ESP_FAIL) {
+        event = {.type = TaskEventType::WARNING, .err = ESP_FAIL};
+        xQueueSend(this_speaker->event_queue_, &event, 0);
+        continue;
+      }
+
+      remaining -= bytes_written;
+      current += bytes_written;
+    }
+
+    event.type = TaskEventType::RUNNING;
+    xQueueSend(this_speaker->event_queue_, &event, 0);
+  }
+
+  audio_pipeline_stop(pipeline);
+  audio_pipeline_wait_for_stop(pipeline);
+  audio_pipeline_terminate(pipeline);
+
+  event.type = TaskEventType::STOPPING;
+  xQueueSend(this_speaker->event_queue_, &event, portMAX_DELAY);
+
+  audio_pipeline_unregister(pipeline, i2s_stream_writer);
+  audio_pipeline_unregister(pipeline, filter);
+  audio_pipeline_unregister(pipeline, raw_write);
+
+  audio_pipeline_deinit(pipeline);
+  audio_element_deinit(i2s_stream_writer);
+  audio_element_deinit(filter);
+  audio_element_deinit(raw_write);
+
+  event.type = TaskEventType::STOPPED;
+  xQueueSend(this_speaker->event_queue_, &event, portMAX_DELAY);
+
+  while (true) {
+    delay(10);
+  }
+}
+
+void ESPADFSpeaker::stop() {
+  if (this->state_ == speaker::STATE_STOPPED)
+    return;
+  if (this->state_ == speaker::STATE_STARTING) {
+    this->state_ = speaker::STATE_STOPPED;
+    return;
+  }
+  this->state_ = speaker::STATE_STOPPING;
+  DataEvent data;
+  data.stop = true;
+  xQueueSendToFront(this->buffer_queue_, &data, portMAX_DELAY);
+}
+
+void ESPADFSpeaker::watch_() {
+  TaskEvent event;
+  if (xQueueReceive(this->event_queue_, &event, 0) == pdTRUE) {
+    switch (event.type) {
+      case TaskEventType::STARTING:
+      case TaskEventType::STOPPING:
+        break;
+      case TaskEventType::STARTED:
+        this->state_ = speaker::STATE_RUNNING;
+        break;
+      case TaskEventType::RUNNING:
+        this->status_clear_warning();
+        break;
+      case TaskEventType::STOPPED:
+        this->parent_->unlock();
+        this->state_ = speaker::STATE_STOPPED;
+        vTaskDelete(this->player_task_handle_);
+        this->player_task_handle_ = nullptr;
+        break;
+      case TaskEventType::WARNING:
+        ESP_LOGW(TAG, "Error writing to pipeline: %s", esp_err_to_name(event.err));
+        this->status_set_warning();
+        break;
+    }
+  }
+}
+
+void ESPADFSpeaker::loop() {
+  this->watch_();
+  switch (this->state_) {
+    case speaker::STATE_STARTING:
+      this->start_();
+      break;
+    case speaker::STATE_RUNNING:
+    case speaker::STATE_STOPPING:
+    case speaker::STATE_STOPPED:
+      break;
+  }
+}
+
+size_t ESPADFSpeaker::play(const uint8_t *data, size_t length) {
+  if (this->state_ != speaker::STATE_RUNNING && this->state_ != speaker::STATE_STARTING) {
+    this->start();
+  }
+  size_t remaining = length;
+  size_t index = 0;
+  while (remaining > 0) {
+    DataEvent event;
+    event.stop = false;
+    size_t to_send_length = std::min(remaining, BUFFER_SIZE);
+    event.len = to_send_length;
+    memcpy(event.data, data + index, to_send_length);
+    if (xQueueSend(this->buffer_queue_, &event, 0) != pdTRUE) {
+      return index;  // Queue full
+    }
+    remaining -= to_send_length;
+    index += to_send_length;
+  }
+  return index;
+}
+
+bool ESPADFSpeaker::has_buffered_data() const { return uxQueueMessagesWaiting(this->buffer_queue_) > 0; }
+
+}  // namespace esp_adf
+}  // namespace esphome
+
+#endif  // USE_ESP_IDF

esphome/components/esp_adf/speaker/esp_adf_speaker.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#ifdef USE_ESP_IDF
+
+#include "../esp_adf.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+
+#include "esphome/components/speaker/speaker.h"
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+
+#include <audio_element.h>
+#include <audio_pipeline.h>
+
+namespace esphome {
+namespace esp_adf {
+
+class ESPADFSpeaker : public ESPADFPipeline, public speaker::Speaker, public Component {
+ public:
+  float get_setup_priority() const override { return esphome::setup_priority::LATE; }
+
+  void setup() override;
+  void loop() override;
+
+  void start() override;
+  void stop() override;
+
+  size_t play(const uint8_t *data, size_t length) override;
+
+  bool has_buffered_data() const override;
+
+ protected:
+  void start_();
+  void watch_();
+
+  static void player_task(void *params);
+
+  TaskHandle_t player_task_handle_{nullptr};
+  QueueHandle_t buffer_queue_;
+  QueueHandle_t event_queue_;
+};
+
+}  // namespace esp_adf
+}  // namespace esphome
+
+#endif  // USE_ESP_IDF

esphome/components/i2s_audio/__init__.py

@@ -10,7 +10,6 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
     VARIANT_ESP32C3,
-    VARIANT_ESP32C6,
 )
 
 CODEOWNERS = ["@jesserockz"]
@@ -39,7 +38,6 @@ I2S_PORTS = {
     VARIANT_ESP32S2: 1,
     VARIANT_ESP32S3: 2,
     VARIANT_ESP32C3: 1,
-    VARIANT_ESP32C6: 1,
 }
 
 CONFIG_SCHEMA = cv.Schema(

esphome/components/mqtt/mqtt_client.cpp

@@ -147,7 +147,7 @@ void MQTTClientComponent::dump_config() {
     ESP_LOGCONFIG(TAG, "  Availability: '%s'", this->availability_.topic.c_str());
   }
 }
-bool MQTTClientComponent::can_proceed() { return this->is_connected(); }
+bool MQTTClientComponent::can_proceed() { return network::is_disabled() || this->is_connected(); }
 
 void MQTTClientComponent::start_dnslookup_() {
   for (auto &subscription : this->subscriptions_) {

esphome/components/network/util.cpp

@@ -29,6 +29,14 @@ bool is_connected() {
   return false;
 }
 
+bool is_disabled() {
+#ifdef USE_WIFI
+  if (wifi::global_wifi_component != nullptr)
+    return wifi::global_wifi_component->is_disabled();
+#endif
+  return false;
+}
+
 network::IPAddress get_ip_address() {
 #ifdef USE_ETHERNET
   if (ethernet::global_eth_component != nullptr)

esphome/components/network/util.h

@@ -8,6 +8,8 @@ namespace network {
 
 /// Return whether the node is connected to the network (through wifi, eth, ...)
 bool is_connected();
+/// Return whether the network is disabled (only wifi for now)
+bool is_disabled();
 /// Get the active network hostname
 std::string get_use_address();
 IPAddress get_ip_address();

esphome/components/wifi/wifi_component.cpp

@@ -389,6 +389,10 @@ void WiFiComponent::print_connect_params_() {
   bssid_t bssid = wifi_bssid();
 
   ESP_LOGCONFIG(TAG, "  Local MAC: %s", get_mac_address_pretty().c_str());
+  if (this->is_disabled()) {
+    ESP_LOGCONFIG(TAG, "  WiFi is disabled!");
+    return;
+  }
   ESP_LOGCONFIG(TAG, "  SSID: " LOG_SECRET("'%s'"), wifi_ssid().c_str());
   ESP_LOGCONFIG(TAG, "  IP Address: %s", wifi_sta_ip().str().c_str());
   ESP_LOGCONFIG(TAG, "  BSSID: " LOG_SECRET("%02X:%02X:%02X:%02X:%02X:%02X"), bssid[0], bssid[1], bssid[2], bssid[3],

esphome/core/defines.h

@@ -64,6 +64,7 @@
 // IDF-specific feature flags
 #ifdef USE_ESP_IDF
 #define USE_MQTT_IDF_ENQUEUE
+#define USE_ESP_ADF
 #endif
 
 // ESP32-specific feature flags

esphome/dashboard/core.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import threading
+from typing import TYPE_CHECKING
+
+from ..zeroconf import DiscoveredImport
+from .entries import DashboardEntry
+from .settings import DashboardSettings
+
+if TYPE_CHECKING:
+    from .status.mdns import MDNSStatus
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def list_dashboard_entries() -> list[DashboardEntry]:
+    """List all dashboard entries."""
+    return DASHBOARD.settings.entries()
+
+
+class ESPHomeDashboard:
+    """Class that represents the dashboard."""
+
+    __slots__ = (
+        "loop",
+        "ping_result",
+        "import_result",
+        "stop_event",
+        "ping_request",
+        "mqtt_ping_request",
+        "mdns_status",
+        "settings",
+    )
+
+    def __init__(self) -> None:
+        """Initialize the ESPHomeDashboard."""
+        self.loop: asyncio.AbstractEventLoop | None = None
+        self.ping_result: dict[str, bool | None] = {}
+        self.import_result: dict[str, DiscoveredImport] = {}
+        self.stop_event = threading.Event()
+        self.ping_request: asyncio.Event | None = None
+        self.mqtt_ping_request = threading.Event()
+        self.mdns_status: MDNSStatus | None = None
+        self.settings: DashboardSettings = DashboardSettings()
+
+    async def async_setup(self) -> None:
+        """Setup the dashboard."""
+        self.loop = asyncio.get_running_loop()
+        self.ping_request = asyncio.Event()
+
+    async def async_run(self) -> None:
+        """Run the dashboard."""
+        settings = self.settings
+        mdns_task: asyncio.Task | None = None
+        ping_status_task: asyncio.Task | None = None
+
+        if settings.status_use_ping:
+            from .status.ping import PingStatus
+
+            ping_status = PingStatus()
+            ping_status_task = asyncio.create_task(ping_status.async_run())
+        else:
+            from .status.mdns import MDNSStatus
+
+            mdns_status = MDNSStatus()
+            await mdns_status.async_refresh_hosts()
+            self.mdns_status = mdns_status
+            mdns_task = asyncio.create_task(mdns_status.async_run())
+
+        if settings.status_use_mqtt:
+            from .status.mqtt import MqttStatusThread
+
+            status_thread_mqtt = MqttStatusThread()
+            status_thread_mqtt.start()
+
+        shutdown_event = asyncio.Event()
+        try:
+            await shutdown_event.wait()
+        finally:
+            _LOGGER.info("Shutting down...")
+            self.stop_event.set()
+            self.ping_request.set()
+            if ping_status_task:
+                ping_status_task.cancel()
+            if mdns_task:
+                mdns_task.cancel()
+            if settings.status_use_mqtt:
+                status_thread_mqtt.join()
+                self.mqtt_ping_request.set()
+            await asyncio.sleep(0)
+
+
+DASHBOARD = ESPHomeDashboard()

esphome/dashboard/entries.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import os
+
+from esphome import const
+from esphome.storage_json import StorageJSON, ext_storage_path
+
+
+class DashboardEntry:
+    """Represents a single dashboard entry.
+
+    This class is thread-safe and read-only.
+    """
+
+    __slots__ = ("path", "_storage", "_loaded_storage")
+
+    def __init__(self, path: str) -> None:
+        """Initialize the DashboardEntry."""
+        self.path = path
+        self._storage = None
+        self._loaded_storage = False
+
+    def __repr__(self):
+        """Return the representation of this entry."""
+        return (
+            f"DashboardEntry({self.path} "
+            f"address={self.address} "
+            f"web_port={self.web_port} "
+            f"name={self.name} "
+            f"no_mdns={self.no_mdns})"
+        )
+
+    @property
+    def filename(self):
+        """Return the filename of this entry."""
+        return os.path.basename(self.path)
+
+    @property
+    def storage(self) -> StorageJSON | None:
+        """Return the StorageJSON object for this entry."""
+        if not self._loaded_storage:
+            self._storage = StorageJSON.load(ext_storage_path(self.filename))
+            self._loaded_storage = True
+        return self._storage
+
+    @property
+    def address(self):
+        """Return the address of this entry."""
+        if self.storage is None:
+            return None
+        return self.storage.address
+
+    @property
+    def no_mdns(self):
+        """Return the no_mdns of this entry."""
+        if self.storage is None:
+            return None
+        return self.storage.no_mdns
+
+    @property
+    def web_port(self):
+        """Return the web port of this entry."""
+        if self.storage is None:
+            return None
+        return self.storage.web_port
+
+    @property
+    def name(self):
+        """Return the name of this entry."""
+        if self.storage is None:
+            return self.filename.replace(".yml", "").replace(".yaml", "")
+        return self.storage.name
+
+    @property
+    def friendly_name(self):
+        """Return the friendly name of this entry."""
+        if self.storage is None:
+            return self.name
+        return self.storage.friendly_name
+
+    @property
+    def comment(self):
+        """Return the comment of this entry."""
+        if self.storage is None:
+            return None
+        return self.storage.comment
+
+    @property
+    def target_platform(self):
+        """Return the target platform of this entry."""
+        if self.storage is None:
+            return None
+        return self.storage.target_platform
+
+    @property
+    def update_available(self):
+        """Return if an update is available for this entry."""
+        if self.storage is None:
+            return True
+        return self.update_old != self.update_new
+
+    @property
+    def update_old(self):
+        if self.storage is None:
+            return ""
+        return self.storage.esphome_version or ""
+
+    @property
+    def update_new(self):
+        return const.__version__
+
+    @property
+    def loaded_integrations(self):
+        if self.storage is None:
+            return []
+        return self.storage.loaded_integrations

esphome/dashboard/settings.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import hmac
+import os
+from pathlib import Path
+
+from esphome import util
+from esphome.core import CORE
+from esphome.helpers import get_bool_env
+from esphome.storage_json import ext_storage_path
+
+from .entries import DashboardEntry
+from .util import password_hash
+
+
+class DashboardSettings:
+    """Settings for the dashboard."""
+
+    def __init__(self):
+        self.config_dir = ""
+        self.password_hash = ""
+        self.username = ""
+        self.using_password = False
+        self.on_ha_addon = False
+        self.cookie_secret = None
+        self.absolute_config_dir = None
+        self._entry_cache: dict[
+            str, tuple[tuple[int, int, float, int], DashboardEntry]
+        ] = {}
+
+    def parse_args(self, args):
+        self.on_ha_addon: bool = args.ha_addon
+        password: str = args.password or os.getenv("PASSWORD", "")
+        if not self.on_ha_addon:
+            self.username: str = args.username or os.getenv("USERNAME", "")
+            self.using_password = bool(password)
+        if self.using_password:
+            self.password_hash = password_hash(password)
+        self.config_dir: str = args.configuration
+        self.absolute_config_dir: Path = Path(self.config_dir).resolve()
+        CORE.config_path = os.path.join(self.config_dir, ".")
+
+    @property
+    def relative_url(self):
+        return os.getenv("ESPHOME_DASHBOARD_RELATIVE_URL", "/")
+
+    @property
+    def status_use_ping(self):
+        return get_bool_env("ESPHOME_DASHBOARD_USE_PING")
+
+    @property
+    def status_use_mqtt(self):
+        return get_bool_env("ESPHOME_DASHBOARD_USE_MQTT")
+
+    @property
+    def using_ha_addon_auth(self):
+        if not self.on_ha_addon:
+            return False
+        return not get_bool_env("DISABLE_HA_AUTHENTICATION")
+
+    @property
+    def using_auth(self):
+        return self.using_password or self.using_ha_addon_auth
+
+    @property
+    def streamer_mode(self):
+        return get_bool_env("ESPHOME_STREAMER_MODE")
+
+    def check_password(self, username, password):
+        if not self.using_auth:
+            return True
+        if username != self.username:
+            return False
+
+        # Compare password in constant running time (to prevent timing attacks)
+        return hmac.compare_digest(self.password_hash, password_hash(password))
+
+    def rel_path(self, *args):
+        joined_path = os.path.join(self.config_dir, *args)
+        # Raises ValueError if not relative to ESPHome config folder
+        Path(joined_path).resolve().relative_to(self.absolute_config_dir)
+        return joined_path
+
+    def list_yaml_files(self) -> list[str]:
+        return util.list_yaml_files([self.config_dir])
+
+    def entries(self) -> list[DashboardEntry]:
+        """Fetch all dashboard entries, thread-safe."""
+        path_to_cache_key: dict[str, tuple[int, int, float, int]] = {}
+        #
+        # The cache key is (inode, device, mtime, size)
+        # which allows us to avoid locking since it ensures
+        # every iteration of this call will always return the newest
+        # items from disk at the cost of a stat() call on each
+        # file which is much faster than reading the file
+        # for the cache hit case which is the common case.
+        #
+        # Because there is no lock the cache may
+        # get built more than once but that's fine as its still
+        # thread-safe and results in orders of magnitude less
+        # reads from disk than if we did not cache at all and
+        # does not have a lock contention issue.
+        #
+        for file in self.list_yaml_files():
+            try:
+                # Prefer the json storage path if it exists
+                stat = os.stat(ext_storage_path(os.path.basename(file)))
+            except OSError:
+                try:
+                    # Fallback to the yaml file if the storage
+                    # file does not exist or could not be generated
+                    stat = os.stat(file)
+                except OSError:
+                    # File was deleted, ignore
+                    continue
+            path_to_cache_key[file] = (
+                stat.st_ino,
+                stat.st_dev,
+                stat.st_mtime,
+                stat.st_size,
+            )
+
+        entry_cache = self._entry_cache
+
+        # Remove entries that no longer exist
+        removed: list[str] = []
+        for file in entry_cache:
+            if file not in path_to_cache_key:
+                removed.append(file)
+
+        for file in removed:
+            entry_cache.pop(file)
+
+        dashboard_entries: list[DashboardEntry] = []
+        for file, cache_key in path_to_cache_key.items():
+            if cached_entry := entry_cache.get(file):
+                entry_key, dashboard_entry = cached_entry
+                if entry_key == cache_key:
+                    dashboard_entries.append(dashboard_entry)
+                    continue
+
+            dashboard_entry = DashboardEntry(file)
+            dashboard_entries.append(dashboard_entry)
+            entry_cache[file] = (cache_key, dashboard_entry)
+
+        return dashboard_entries

esphome/dashboard/status/mdns.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import asyncio
+
+from esphome.zeroconf import (
+    ESPHOME_SERVICE_TYPE,
+    AsyncEsphomeZeroconf,
+    DashboardBrowser,
+    DashboardImportDiscovery,
+    DashboardStatus,
+)
+
+from ..core import DASHBOARD, list_dashboard_entries
+
+
+class MDNSStatus:
+    """Class that updates the mdns status."""
+
+    def __init__(self) -> None:
+        """Initialize the MDNSStatus class."""
+        super().__init__()
+        self.aiozc: AsyncEsphomeZeroconf | None = None
+        # This is the current mdns state for each host (True, False, None)
+        self.host_mdns_state: dict[str, bool | None] = {}
+        # This is the hostnames to filenames mapping
+        self.host_name_to_filename: dict[str, str] = {}
+        self.filename_to_host_name: dict[str, str] = {}
+        # This is a set of host names to track (i.e no_mdns = false)
+        self.host_name_with_mdns_enabled: set[set] = set()
+        self._loop = asyncio.get_running_loop()
+
+    def filename_to_host_name_thread_safe(self, filename: str) -> str | None:
+        """Resolve a filename to an address in a thread-safe manner."""
+        return self.filename_to_host_name.get(filename)
+
+    async def async_resolve_host(self, host_name: str) -> str | None:
+        """Resolve a host name to an address in a thread-safe manner."""
+        if aiozc := self.aiozc:
+            return await aiozc.async_resolve_host(host_name)
+        return None
+
+    async def async_refresh_hosts(self):
+        """Refresh the hosts to track."""
+        entries = await self._loop.run_in_executor(None, list_dashboard_entries)
+        host_name_with_mdns_enabled = self.host_name_with_mdns_enabled
+        host_mdns_state = self.host_mdns_state
+        host_name_to_filename = self.host_name_to_filename
+        filename_to_host_name = self.filename_to_host_name
+        ping_result = DASHBOARD.ping_result
+
+        for entry in entries:
+            name = entry.name
+            # If no_mdns is set, remove it from the set
+            if entry.no_mdns:
+                host_name_with_mdns_enabled.discard(name)
+                continue
+
+            # We are tracking this host
+            host_name_with_mdns_enabled.add(name)
+            filename = entry.filename
+
+            # If we just adopted/imported this host, we likely
+            # already have a state for it, so we should make sure
+            # to set it so the dashboard shows it as online
+            if name in host_mdns_state:
+                ping_result[filename] = host_mdns_state[name]
+
+            # Make sure the mapping is up to date
+            # so when we get an mdns update we can map it back
+            # to the filename
+            host_name_to_filename[name] = filename
+            filename_to_host_name[filename] = name
+
+    async def async_run(self) -> None:
+        dashboard = DASHBOARD
+
+        aiozc = AsyncEsphomeZeroconf()
+        self.aiozc = aiozc
+        host_mdns_state = self.host_mdns_state
+        host_name_to_filename = self.host_name_to_filename
+        host_name_with_mdns_enabled = self.host_name_with_mdns_enabled
+        ping_result = dashboard.ping_result
+
+        def on_update(dat: dict[str, bool | None]) -> None:
+            """Update the global PING_RESULT dict."""
+            for name, result in dat.items():
+                host_mdns_state[name] = result
+                if name in host_name_with_mdns_enabled:
+                    filename = host_name_to_filename[name]
+                    ping_result[filename] = result
+
+        stat = DashboardStatus(on_update)
+        imports = DashboardImportDiscovery()
+        dashboard.import_result = imports.import_state
+
+        browser = DashboardBrowser(
+            aiozc.zeroconf,
+            ESPHOME_SERVICE_TYPE,
+            [stat.browser_callback, imports.browser_callback],
+        )
+
+        while not dashboard.stop_event.is_set():
+            await self.async_refresh_hosts()
+            await dashboard.ping_request.wait()
+            dashboard.ping_request.clear()
+
+        await browser.async_cancel()
+        await aiozc.async_close()
+        self.aiozc = None

esphome/dashboard/status/mqtt.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import binascii
+import json
+import os
+import threading
+
+from esphome import mqtt
+
+from ..core import DASHBOARD, list_dashboard_entries
+
+
+class MqttStatusThread(threading.Thread):
+    """Status thread to get the status of the devices via MQTT."""
+
+    def run(self) -> None:
+        """Run the status thread."""
+        dashboard = DASHBOARD
+        entries = list_dashboard_entries()
+
+        config = mqtt.config_from_env()
+        topic = "esphome/discover/#"
+
+        def on_message(client, userdata, msg):
+            nonlocal entries
+
+            payload = msg.payload.decode(errors="backslashreplace")
+            if len(payload) > 0:
+                data = json.loads(payload)
+                if "name" not in data:
+                    return
+                for entry in entries:
+                    if entry.name == data["name"]:
+                        dashboard.ping_result[entry.filename] = True
+                        return
+
+        def on_connect(client, userdata, flags, return_code):
+            client.publish("esphome/discover", None, retain=False)
+
+        mqttid = str(binascii.hexlify(os.urandom(6)).decode())
+
+        client = mqtt.prepare(
+            config,
+            [topic],
+            on_message,
+            on_connect,
+            None,
+            None,
+            f"esphome-dashboard-{mqttid}",
+        )
+        client.loop_start()
+
+        while not dashboard.stop_event.wait(2):
+            # update entries
+            entries = list_dashboard_entries()
+
+            # will be set to true on on_message
+            for entry in entries:
+                if entry.no_mdns:
+                    dashboard.ping_result[entry.filename] = False
+
+            client.publish("esphome/discover", None, retain=False)
+            dashboard.mqtt_ping_request.wait()
+            dashboard.mqtt_ping_request.clear()
+
+        client.disconnect()
+        client.loop_stop()

esphome/dashboard/status/ping.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import cast
+
+from ..core import DASHBOARD
+from ..entries import DashboardEntry
+from ..core import list_dashboard_entries
+from ..util import chunked
+
+
+async def _async_ping_host(host: str) -> bool:
+    """Ping a host."""
+    ping_command = ["ping", "-n" if os.name == "nt" else "-c", "1"]
+    process = await asyncio.create_subprocess_exec(
+        *ping_command,
+        host,
+        stdin=asyncio.subprocess.DEVNULL,
+        stdout=asyncio.subprocess.DEVNULL,
+        stderr=asyncio.subprocess.DEVNULL,
+        close_fds=False,
+    )
+    await process.wait()
+    return process.returncode == 0
+
+
+class PingStatus:
+    def __init__(self) -> None:
+        """Initialize the PingStatus class."""
+        super().__init__()
+        self._loop = asyncio.get_running_loop()
+
+    async def async_run(self) -> None:
+        """Run the ping status."""
+        dashboard = DASHBOARD
+
+        while not dashboard.stop_event.is_set():
+            # Only ping if the dashboard is open
+            await dashboard.ping_request.wait()
+            dashboard.ping_result.clear()
+            entries = await self._loop.run_in_executor(None, list_dashboard_entries)
+            to_ping: list[DashboardEntry] = [
+                entry for entry in entries if entry.address is not None
+            ]
+            for ping_group in chunked(to_ping, 16):
+                ping_group = cast(list[DashboardEntry], ping_group)
+                results = await asyncio.gather(
+                    *(_async_ping_host(entry.address) for entry in ping_group),
+                    return_exceptions=True,
+                )
+                for entry, result in zip(ping_group, results):
+                    if isinstance(result, Exception):
+                        result = False
+                    elif isinstance(result, BaseException):
+                        raise result
+                    dashboard.ping_result[entry.filename] = result

esphome/dashboard/util.py

@@ -1,5 +1,9 @@
 import hashlib
 import unicodedata
+from collections.abc import Iterable
+from functools import partial
+from itertools import islice
+from typing import Any
 
 from esphome.const import ALLOWED_NAME_CHARS
 
@@ -30,3 +34,19 @@ def friendly_name_slugify(value):
         .strip("-")
     )
     return "".join(c for c in value if c in ALLOWED_NAME_CHARS)
+
+
+def take(take_num: int, iterable: Iterable) -> list[Any]:
+    """Return first n items of the iterable as a list.
+
+    From itertools recipes
+    """
+    return list(islice(iterable, take_num))
+
+
+def chunked(iterable: Iterable, chunked_num: int) -> Iterable[Any]:
+    """Break *iterable* into lists of length *n*.
+
+    From more-itertools
+    """
+    return iter(partial(take, chunked_num, iter(iterable)), [])

esphome/espota2.py

@@ -1,10 +1,13 @@
+from __future__ import annotations
+
+import gzip
 import hashlib
+import io
 import logging
 import random
 import socket
 import sys
 import time
-import gzip
 
 from esphome.core import EsphomeError
 from esphome.helpers import is_ip_address, resolve_ip_address
@@ -40,6 +43,10 @@ MAGIC_BYTES = [0x6C, 0x26, 0xF7, 0x5C, 0x45]
 
 FEATURE_SUPPORTS_COMPRESSION = 0x01
 
+
+UPLOAD_BLOCK_SIZE = 8192
+UPLOAD_BUFFER_SIZE = UPLOAD_BLOCK_SIZE * 8
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -184,7 +191,9 @@ def send_check(sock, data, msg):
         raise OTAError(f"Error sending {msg}: {err}") from err
 
 
-def perform_ota(sock, password, file_handle, filename):
+def perform_ota(
+    sock: socket.socket, password: str, file_handle: io.IOBase, filename: str
+) -> None:
     file_contents = file_handle.read()
     file_size = len(file_contents)
     _LOGGER.info("Uploading %s (%s bytes)", filename, file_size)
@@ -254,14 +263,16 @@ def perform_ota(sock, password, file_handle, filename):
     sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 0)
     # Limit send buffer (usually around 100kB) in order to have progress bar
     # show the actual progress
-    sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 8192)
+
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, UPLOAD_BUFFER_SIZE)
     # Set higher timeout during upload
-    sock.settimeout(20.0)
+    sock.settimeout(30.0)
+    start_time = time.perf_counter()
 
     offset = 0
     progress = ProgressBar()
     while True:
-        chunk = upload_contents[offset : offset + 1024]
+        chunk = upload_contents[offset : offset + UPLOAD_BLOCK_SIZE]
         if not chunk:
             break
         offset += len(chunk)
@@ -277,8 +288,9 @@ def perform_ota(sock, password, file_handle, filename):
 
     # Enable nodelay for last checks
     sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+    duration = time.perf_counter() - start_time
 
-    _LOGGER.info("Waiting for result...")
+    _LOGGER.info("Upload took %.2f seconds, waiting for result...", duration)
 
     receive_exactly(sock, 1, "receive OK", RESPONSE_RECEIVE_OK)
     receive_exactly(sock, 1, "Update end", RESPONSE_UPDATE_END_OK)

esphome/zeroconf.py

@@ -1,22 +1,21 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 from dataclasses import dataclass
 from typing import Callable
 
-from zeroconf import (
-    IPVersion,
-    ServiceBrowser,
-    ServiceInfo,
-    ServiceStateChange,
-    Zeroconf,
-)
+from zeroconf import IPVersion, ServiceInfo, ServiceStateChange, Zeroconf
+from zeroconf.asyncio import AsyncServiceBrowser, AsyncServiceInfo, AsyncZeroconf
 
 from esphome.storage_json import StorageJSON, ext_storage_path
 
 _LOGGER = logging.getLogger(__name__)
 
 
+_BACKGROUND_TASKS: set[asyncio.Task] = set()
+
+
 class HostResolver(ServiceInfo):
     """Resolve a host name to an IP address."""
 
@@ -65,7 +64,7 @@ class DiscoveredImport:
     network: str
 
 
-class DashboardBrowser(ServiceBrowser):
+class DashboardBrowser(AsyncServiceBrowser):
     """A class to browse for ESPHome nodes."""
 
 
@@ -94,7 +93,28 @@ class DashboardImportDiscovery:
             # Ignore updates for devices that are not in the import state
             return
 
-        info = zeroconf.get_service_info(service_type, name)
+        info = AsyncServiceInfo(
+            service_type,
+            name,
+        )
+        if info.load_from_cache(zeroconf):
+            self._process_service_info(name, info)
+            return
+        task = asyncio.create_task(
+            self._async_process_service_info(zeroconf, info, service_type, name)
+        )
+        _BACKGROUND_TASKS.add(task)
+        task.add_done_callback(_BACKGROUND_TASKS.discard)
+
+    async def _async_process_service_info(
+        self, zeroconf: Zeroconf, info: AsyncServiceInfo, service_type: str, name: str
+    ) -> None:
+        """Process a service info."""
+        if await info.async_request(zeroconf):
+            self._process_service_info(name, info)
+
+    def _process_service_info(self, name: str, info: ServiceInfo) -> None:
+        """Process a service info."""
         _LOGGER.debug("-> resolved info: %s", info)
         if info is None:
             return
@@ -146,14 +166,32 @@ class DashboardImportDiscovery:
                 )
 
 
+def _make_host_resolver(host: str) -> HostResolver:
+    """Create a new HostResolver for the given host name."""
+    name = host.partition(".")[0]
+    info = HostResolver(ESPHOME_SERVICE_TYPE, f"{name}.{ESPHOME_SERVICE_TYPE}")
+    return info
+
+
 class EsphomeZeroconf(Zeroconf):
     def resolve_host(self, host: str, timeout: float = 3.0) -> str | None:
         """Resolve a host name to an IP address."""
-        name = host.partition(".")[0]
-        info = HostResolver(ESPHOME_SERVICE_TYPE, f"{name}.{ESPHOME_SERVICE_TYPE}")
+        info = _make_host_resolver(host)
         if (
             info.load_from_cache(self)
             or (timeout and info.request(self, timeout * 1000))
         ) and (addresses := info.ip_addresses_by_version(IPVersion.V4Only)):
             return str(addresses[0])
         return None
+
+
+class AsyncEsphomeZeroconf(AsyncZeroconf):
+    async def async_resolve_host(self, host: str, timeout: float = 3.0) -> str | None:
+        """Resolve a host name to an IP address."""
+        info = _make_host_resolver(host)
+        if (
+            info.load_from_cache(self.zeroconf)
+            or (timeout and await info.async_request(self.zeroconf, timeout * 1000))
+        ) and (addresses := info.ip_addresses_by_version(IPVersion.V4Only)):
+            return str(addresses[0])
+        return None

requirements.txt

@@ -10,8 +10,8 @@ platformio==6.1.11  # When updating platformio, also update Dockerfile
 esptool==4.6.2
 click==8.1.7
 esphome-dashboard==20231107.0
-aioesphomeapi==18.4.0
-zeroconf==0.126.0
+aioesphomeapi==18.4.1
+zeroconf==0.127.0
 
 # esp-idf requires this, but doesn't bundle it by default
 # https://github.com/espressif/esp-idf/blob/220590d599e134d7a5e7f1e683cc4550349ffbf8/requirements.txt#L24

script/bump-version.py

@@ -45,7 +45,7 @@ def sub(path, pattern, repl, expected_count=1):
     content, count = re.subn(pattern, repl, content, flags=re.MULTILINE)
     if expected_count is not None:
         assert count == expected_count, f"Pattern {pattern} replacement failed!"
-    with open(path, "wt") as fh:
+    with open(path, "w") as fh:
         fh.write(content)
 
 

tests/unit_tests/test_cpp_generator.py

@@ -1,4 +1,4 @@
-from typing import Iterator
+from collections.abc import Iterator
 
 import math
 

tests/unit_tests/test_cpp_helpers.py

@@ -1,5 +1,5 @@
 import pytest
-from mock import Mock
+from unittest.mock import Mock
 
 from esphome import cpp_helpers as ch
 from esphome import const