esphome 2025.7.5__py3-none-any.whl → 2025.8.0b1__py3-none-any.whl

esphome/components/homeassistant/switch/homeassistant_switch.cpp

@@ -40,17 +40,21 @@ void HomeassistantSwitch::write_state(bool state) {
     return;
   }
 
+  static constexpr auto SERVICE_ON = StringRef::from_lit("homeassistant.turn_on");
+  static constexpr auto SERVICE_OFF = StringRef::from_lit("homeassistant.turn_off");
+  static constexpr auto ENTITY_ID_KEY = StringRef::from_lit("entity_id");
+
   api::HomeassistantServiceResponse resp;
   if (state) {
-    resp.service = "homeassistant.turn_on";
+    resp.set_service(SERVICE_ON);
   } else {
-    resp.service = "homeassistant.turn_off";
+    resp.set_service(SERVICE_OFF);
   }
 
-  api::HomeassistantServiceMap entity_id_kv;
-  entity_id_kv.key = "entity_id";
+  resp.data.emplace_back();
+  auto &entity_id_kv = resp.data.back();
+  entity_id_kv.set_key(ENTITY_ID_KEY);
   entity_id_kv.value = this->entity_id_;
-  resp.data.push_back(entity_id_kv);
 
   api::global_api_server->send_homeassistant_service_call(resp);
 }

esphome/components/honeywellabp/honeywellabp.cpp

@@ -9,10 +9,7 @@ static const char *const TAG = "honeywellabp";
 const float MIN_COUNT = 1638.4;   // 1638 counts (10% of 2^14 counts or 0x0666)
 const float MAX_COUNT = 14745.6;  // 14745 counts (90% of 2^14 counts or 0x3999)
 
-void HONEYWELLABPSensor::setup() {
-  ESP_LOGD(TAG, "Setting up Honeywell ABP Sensor ");
-  this->spi_setup();
-}
+void HONEYWELLABPSensor::setup() { this->spi_setup(); }
 
 uint8_t HONEYWELLABPSensor::readsensor_() {
   // Polls the sensor for new data.

esphome/components/host/__init__.py

@@ -7,6 +7,7 @@ from esphome.const import (
     KEY_TARGET_FRAMEWORK,
     KEY_TARGET_PLATFORM,
     PLATFORM_HOST,
+    ThreadModel,
 )
 from esphome.core import CORE
 
@@ -43,6 +44,7 @@ async def to_code(config):
     cg.add_define("USE_ESPHOME_HOST_MAC_ADDRESS", config[CONF_MAC_ADDRESS].parts)
     cg.add_build_flag("-std=gnu++20")
     cg.add_define("ESPHOME_BOARD", "host")
+    cg.add_define(ThreadModel.MULTI_ATOMICS)
     cg.add_platformio_option("platform", "platformio/native")
     cg.add_platformio_option("lib_ldf_mode", "off")
     cg.add_platformio_option("lib_compat_mode", "strict")

esphome/components/hte501/hte501.cpp

@@ -8,7 +8,6 @@ namespace hte501 {
 static const char *const TAG = "hte501";
 
 void HTE501Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t address[] = {0x70, 0x29};
   this->write(address, 2, false);
   uint8_t identification[9];

esphome/components/http_request/__init__.py

@@ -70,9 +70,8 @@ def validate_url(value):
 def validate_ssl_verification(config):
     error_message = ""
 
-    if CORE.is_esp32:
-        if not CORE.using_esp_idf and config[CONF_VERIFY_SSL]:
-            error_message = "ESPHome supports certificate verification only via ESP-IDF"
+    if CORE.is_esp32 and not CORE.using_esp_idf and config[CONF_VERIFY_SSL]:
+        error_message = "ESPHome supports certificate verification only via ESP-IDF"
 
     if CORE.is_rp2040 and config[CONF_VERIFY_SSL]:
         error_message = "ESPHome does not support certificate verification on RP2040"

esphome/components/http_request/http_request_idf.cpp

@@ -157,8 +157,8 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(std::string url, std::str
   container->status_code = esp_http_client_get_status_code(client);
   container->feed_wdt();
   container->set_response_headers(user_data.response_headers);
+  container->duration_ms = millis() - start;
   if (is_success(container->status_code)) {
-    container->duration_ms = millis() - start;
     return container;
   }
 
@@ -191,8 +191,8 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(std::string url, std::str
       container->feed_wdt();
       container->status_code = esp_http_client_get_status_code(client);
       container->feed_wdt();
+      container->duration_ms = millis() - start;
       if (is_success(container->status_code)) {
-        container->duration_ms = millis() - start;
         return container;
       }
 

esphome/components/htu21d/htu21d.cpp

@@ -18,8 +18,6 @@ static const uint8_t HTU21D_READHEATER_REG_CMD = 0x11;  /**< Read Heater Control
 static const uint8_t HTU21D_REG_HTRE_BIT = 0x02;        /**< Control Register Heater Bit */
 
 void HTU21DComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   if (!this->write_bytes(HTU21D_REGISTER_RESET, nullptr, 0)) {
     this->mark_failed();
     return;

esphome/components/htu31d/htu31d.cpp

@@ -75,8 +75,6 @@ uint8_t compute_crc(uint32_t value) {
  * I2C.
  */
 void HTU31DComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   if (!this->reset_()) {
     this->mark_failed();
     return;

esphome/components/hx711/hx711.cpp

@@ -8,7 +8,6 @@ namespace hx711 {
 static const char *const TAG = "hx711";
 
 void HX711Sensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
   this->sck_pin_->setup();
   this->dout_pin_->setup();
   this->sck_pin_->digital_write(false);

esphome/components/hydreon_rgxx/hydreon_rgxx.cpp

@@ -41,7 +41,6 @@ void HydreonRGxxComponent::dump_config() {
 }
 
 void HydreonRGxxComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   while (this->available() != 0) {
     this->read();
   }

esphome/components/hydreon_rgxx/sensor.py

@@ -66,11 +66,10 @@ PROTOCOL_NAMES = {
 
 def _validate(config):
     for conf, models in SUPPORTED_OPTIONS.items():
-        if conf in config:
-            if config[CONF_MODEL] not in models:
-                raise cv.Invalid(
-                    f"{conf} is only available on {' and '.join(models)}, not {config[CONF_MODEL]}"
-                )
+        if conf in config and config[CONF_MODEL] not in models:
+            raise cv.Invalid(
+                f"{conf} is only available on {' and '.join(models)}, not {config[CONF_MODEL]}"
+            )
     return config
 
 

esphome/components/i2c/i2c_bus.h

@@ -94,7 +94,7 @@ class I2CBus {
  protected:
   /// @brief Scans the I2C bus for devices. Devices presence is kept in an array of std::pair
   /// that contains the address and the corresponding bool presence flag.
-  void i2c_scan_() {
+  virtual void i2c_scan() {
     for (uint8_t address = 8; address < 120; address++) {
       auto err = writev(address, nullptr, 0);
       if (err == ERROR_OK) {

esphome/components/i2c/i2c_bus_arduino.cpp

@@ -13,7 +13,6 @@ namespace i2c {
 static const char *const TAG = "i2c.arduino";
 
 void ArduinoI2CBus::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   recover_();
 
 #if defined(USE_ESP32)
@@ -42,7 +41,7 @@ void ArduinoI2CBus::setup() {
   this->initialized_ = true;
   if (this->scan_) {
     ESP_LOGV(TAG, "Scanning bus for active devices");
-    this->i2c_scan_();
+    this->i2c_scan();
   }
 }
 

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -1,6 +1,7 @@
 #ifdef USE_ESP_IDF
 
 #include "i2c_bus_esp_idf.h"
+#include <driver/gpio.h>
 #include <cinttypes>
 #include <cstring>
 #include "esphome/core/application.h"
@@ -18,22 +19,72 @@ namespace i2c {
 static const char *const TAG = "i2c.idf";
 
 void IDFI2CBus::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   static i2c_port_t next_port = I2C_NUM_0;
-  port_ = next_port;
-#if SOC_HP_I2C_NUM > 1
-  next_port = (next_port == I2C_NUM_0) ? I2C_NUM_1 : I2C_NUM_MAX;
+  this->port_ = next_port;
+  if (this->port_ == I2C_NUM_MAX) {
+    ESP_LOGE(TAG, "No more than %u buses supported", I2C_NUM_MAX);
+    this->mark_failed();
+    return;
+  }
+
+  if (this->timeout_ > 13000) {
+    ESP_LOGW(TAG, "Using max allowed timeout: 13 ms");
+    this->timeout_ = 13000;
+  }
+
+  this->recover_();
+
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2)
+  next_port = (i2c_port_t) (next_port + 1);
+
+  i2c_master_bus_config_t bus_conf{};
+  memset(&bus_conf, 0, sizeof(bus_conf));
+  bus_conf.sda_io_num = gpio_num_t(sda_pin_);
+  bus_conf.scl_io_num = gpio_num_t(scl_pin_);
+  bus_conf.i2c_port = this->port_;
+  bus_conf.glitch_ignore_cnt = 7;
+#if SOC_LP_I2C_SUPPORTED
+  if (this->port_ < SOC_HP_I2C_NUM) {
+    bus_conf.clk_source = I2C_CLK_SRC_DEFAULT;
+  } else {
+    bus_conf.lp_source_clk = LP_I2C_SCLK_DEFAULT;
+  }
 #else
-  next_port = I2C_NUM_MAX;
+  bus_conf.clk_source = I2C_CLK_SRC_DEFAULT;
 #endif
+  bus_conf.flags.enable_internal_pullup = sda_pullup_enabled_ || scl_pullup_enabled_;
+  esp_err_t err = i2c_new_master_bus(&bus_conf, &this->bus_);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "i2c_new_master_bus failed: %s", esp_err_to_name(err));
+    this->mark_failed();
+    return;
+  }
 
-  if (port_ == I2C_NUM_MAX) {
-    ESP_LOGE(TAG, "No more than %u buses supported", SOC_HP_I2C_NUM);
+  i2c_device_config_t dev_conf{};
+  memset(&dev_conf, 0, sizeof(dev_conf));
+  dev_conf.dev_addr_length = I2C_ADDR_BIT_LEN_7;
+  dev_conf.device_address = I2C_DEVICE_ADDRESS_NOT_USED;
+  dev_conf.scl_speed_hz = this->frequency_;
+  dev_conf.scl_wait_us = this->timeout_;
+  err = i2c_master_bus_add_device(this->bus_, &dev_conf, &this->dev_);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "i2c_master_bus_add_device failed: %s", esp_err_to_name(err));
     this->mark_failed();
     return;
   }
 
-  recover_();
+  this->initialized_ = true;
+
+  if (this->scan_) {
+    ESP_LOGV(TAG, "Scanning for devices");
+    this->i2c_scan();
+  }
+#else
+#if SOC_HP_I2C_NUM > 1
+  next_port = (next_port == I2C_NUM_0) ? I2C_NUM_1 : I2C_NUM_MAX;
+#else
+  next_port = I2C_NUM_MAX;
+#endif
 
   i2c_config_t conf{};
   memset(&conf, 0, sizeof(conf));
@@ -53,11 +104,7 @@ void IDFI2CBus::setup() {
     this->mark_failed();
     return;
   }
-  if (timeout_ > 0) {  // if timeout specified in yaml:
-    if (timeout_ > 13000) {
-      ESP_LOGW(TAG, "i2c timeout of %" PRIu32 "us greater than max of 13ms on esp-idf, setting to max", timeout_);
-      timeout_ = 13000;
-    }
+  if (timeout_ > 0) {
     err = i2c_set_timeout(port_, timeout_ * 80);  // unit: APB 80MHz clock cycle
     if (err != ESP_OK) {
       ESP_LOGW(TAG, "i2c_set_timeout failed: %s", esp_err_to_name(err));
@@ -73,12 +120,15 @@ void IDFI2CBus::setup() {
     this->mark_failed();
     return;
   }
+
   initialized_ = true;
   if (this->scan_) {
     ESP_LOGV(TAG, "Scanning bus for active devices");
-    this->i2c_scan_();
+    this->i2c_scan();
   }
+#endif
 }
+
 void IDFI2CBus::dump_config() {
   ESP_LOGCONFIG(TAG, "I2C Bus:");
   ESP_LOGCONFIG(TAG,
@@ -101,13 +151,13 @@ void IDFI2CBus::dump_config() {
       break;
   }
   if (this->scan_) {
-    ESP_LOGI(TAG, "Results from bus scan:");
+    ESP_LOGCONFIG(TAG, "Results from bus scan:");
     if (scan_results_.empty()) {
-      ESP_LOGI(TAG, "Found no devices");
+      ESP_LOGCONFIG(TAG, "Found no devices");
     } else {
       for (const auto &s : scan_results_) {
         if (s.second) {
-          ESP_LOGI(TAG, "Found device at address 0x%02X", s.first);
+          ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
           ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
         }
@@ -116,6 +166,17 @@ void IDFI2CBus::dump_config() {
   }
 }
 
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2)
+void IDFI2CBus::i2c_scan() {
+  for (uint8_t address = 8; address < 120; address++) {
+    auto err = i2c_master_probe(this->bus_, address, 20);
+    if (err == ESP_OK) {
+      this->scan_results_.emplace_back(address, true);
+    }
+  }
+}
+#endif
+
 ErrorCode IDFI2CBus::readv(uint8_t address, ReadBuffer *buffers, size_t cnt) {
   // logging is only enabled with vv level, if warnings are shown the caller
   // should log them
@@ -123,6 +184,74 @@ ErrorCode IDFI2CBus::readv(uint8_t address, ReadBuffer *buffers, size_t cnt) {
     ESP_LOGVV(TAG, "i2c bus not initialized!");
     return ERROR_NOT_INITIALIZED;
   }
+
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2)
+  i2c_operation_job_t jobs[cnt + 4];
+  uint8_t read = (address << 1) | I2C_MASTER_READ;
+  size_t last = 0, num = 0;
+
+  jobs[num].command = I2C_MASTER_CMD_START;
+  num++;
+
+  jobs[num].command = I2C_MASTER_CMD_WRITE;
+  jobs[num].write.ack_check = true;
+  jobs[num].write.data = &read;
+  jobs[num].write.total_bytes = 1;
+  num++;
+
+  // find the last valid index
+  for (size_t i = 0; i < cnt; i++) {
+    const auto &buf = buffers[i];
+    if (buf.len == 0) {
+      continue;
+    }
+    last = i;
+  }
+
+  for (size_t i = 0; i < cnt; i++) {
+    const auto &buf = buffers[i];
+    if (buf.len == 0) {
+      continue;
+    }
+    if (i == last) {
+      // the last byte read before stop should always be a nack,
+      // split the last read if len is larger than 1
+      if (buf.len > 1) {
+        jobs[num].command = I2C_MASTER_CMD_READ;
+        jobs[num].read.ack_value = I2C_ACK_VAL;
+        jobs[num].read.data = (uint8_t *) buf.data;
+        jobs[num].read.total_bytes = buf.len - 1;
+        num++;
+      }
+      jobs[num].command = I2C_MASTER_CMD_READ;
+      jobs[num].read.ack_value = I2C_NACK_VAL;
+      jobs[num].read.data = (uint8_t *) buf.data + buf.len - 1;
+      jobs[num].read.total_bytes = 1;
+      num++;
+    } else {
+      jobs[num].command = I2C_MASTER_CMD_READ;
+      jobs[num].read.ack_value = I2C_ACK_VAL;
+      jobs[num].read.data = (uint8_t *) buf.data;
+      jobs[num].read.total_bytes = buf.len;
+      num++;
+    }
+  }
+
+  jobs[num].command = I2C_MASTER_CMD_STOP;
+  num++;
+
+  esp_err_t err = i2c_master_execute_defined_operations(this->dev_, jobs, num, 20);
+  if (err == ESP_ERR_INVALID_STATE) {
+    ESP_LOGVV(TAG, "RX from %02X failed: not acked", address);
+    return ERROR_NOT_ACKNOWLEDGED;
+  } else if (err == ESP_ERR_TIMEOUT) {
+    ESP_LOGVV(TAG, "RX from %02X failed: timeout", address);
+    return ERROR_TIMEOUT;
+  } else if (err != ESP_OK) {
+    ESP_LOGVV(TAG, "RX from %02X failed: %s", address, esp_err_to_name(err));
+    return ERROR_UNKNOWN;
+  }
+#else
   i2c_cmd_handle_t cmd = i2c_cmd_link_create();
   esp_err_t err = i2c_master_start(cmd);
   if (err != ESP_OK) {
@@ -168,6 +297,7 @@ ErrorCode IDFI2CBus::readv(uint8_t address, ReadBuffer *buffers, size_t cnt) {
     ESP_LOGVV(TAG, "RX from %02X failed: %s", address, esp_err_to_name(err));
     return ERROR_UNKNOWN;
   }
+#endif
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
   char debug_buf[4];
@@ -185,6 +315,7 @@ ErrorCode IDFI2CBus::readv(uint8_t address, ReadBuffer *buffers, size_t cnt) {
 
   return ERROR_OK;
 }
+
 ErrorCode IDFI2CBus::writev(uint8_t address, WriteBuffer *buffers, size_t cnt, bool stop) {
   // logging is only enabled with vv level, if warnings are shown the caller
   // should log them
@@ -207,6 +338,49 @@ ErrorCode IDFI2CBus::writev(uint8_t address, WriteBuffer *buffers, size_t cnt, b
   ESP_LOGVV(TAG, "0x%02X TX %s", address, debug_hex.c_str());
 #endif
 
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2)
+  i2c_operation_job_t jobs[cnt + 3];
+  uint8_t write = (address << 1) | I2C_MASTER_WRITE;
+  size_t num = 0;
+
+  jobs[num].command = I2C_MASTER_CMD_START;
+  num++;
+
+  jobs[num].command = I2C_MASTER_CMD_WRITE;
+  jobs[num].write.ack_check = true;
+  jobs[num].write.data = &write;
+  jobs[num].write.total_bytes = 1;
+  num++;
+
+  for (size_t i = 0; i < cnt; i++) {
+    const auto &buf = buffers[i];
+    if (buf.len == 0) {
+      continue;
+    }
+    jobs[num].command = I2C_MASTER_CMD_WRITE;
+    jobs[num].write.ack_check = true;
+    jobs[num].write.data = (uint8_t *) buf.data;
+    jobs[num].write.total_bytes = buf.len;
+    num++;
+  }
+
+  if (stop) {
+    jobs[num].command = I2C_MASTER_CMD_STOP;
+    num++;
+  }
+
+  esp_err_t err = i2c_master_execute_defined_operations(this->dev_, jobs, num, 20);
+  if (err == ESP_ERR_INVALID_STATE) {
+    ESP_LOGVV(TAG, "TX to %02X failed: not acked", address);
+    return ERROR_NOT_ACKNOWLEDGED;
+  } else if (err == ESP_ERR_TIMEOUT) {
+    ESP_LOGVV(TAG, "TX to %02X failed: timeout", address);
+    return ERROR_TIMEOUT;
+  } else if (err != ESP_OK) {
+    ESP_LOGVV(TAG, "TX to %02X failed: %s", address, esp_err_to_name(err));
+    return ERROR_UNKNOWN;
+  }
+#else
   i2c_cmd_handle_t cmd = i2c_cmd_link_create();
   esp_err_t err = i2c_master_start(cmd);
   if (err != ESP_OK) {
@@ -252,6 +426,7 @@ ErrorCode IDFI2CBus::writev(uint8_t address, WriteBuffer *buffers, size_t cnt, b
     ESP_LOGVV(TAG, "TX to %02X failed: %s", address, esp_err_to_name(err));
     return ERROR_UNKNOWN;
   }
+#endif
   return ERROR_OK;
 }
 

esphome/components/i2c/i2c_bus_esp_idf.h

@@ -2,9 +2,14 @@
 
 #ifdef USE_ESP_IDF
 
-#include <driver/i2c.h>
+#include "esp_idf_version.h"
 #include "esphome/core/component.h"
 #include "i2c_bus.h"
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2)
+#include <driver/i2c_master.h>
+#else
+#include <driver/i2c.h>
+#endif
 
 namespace esphome {
 namespace i2c {
@@ -38,6 +43,11 @@ class IDFI2CBus : public InternalI2CBus, public Component {
   RecoveryCode recovery_result_;
 
  protected:
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2)
+  i2c_master_dev_handle_t dev_;
+  i2c_master_bus_handle_t bus_;
+  void i2c_scan() override;
+#endif
   i2c_port_t port_;
   uint8_t sda_pin_;
   bool sda_pullup_enabled_;

esphome/components/i2s_audio/__init__.py

@@ -1,6 +1,6 @@
 from esphome import pins
 import esphome.codegen as cg
-from esphome.components.esp32 import get_esp32_variant
+from esphome.components.esp32 import add_idf_sdkconfig_option, get_esp32_variant
 from esphome.components.esp32.const import (
     VARIANT_ESP32,
     VARIANT_ESP32C3,
@@ -243,10 +243,7 @@ def _final_validate(_):
 
 
 def use_legacy():
-    if CORE.using_esp_idf:
-        if not _use_legacy_driver:
-            return False
-    return True
+    return not (CORE.using_esp_idf and not _use_legacy_driver)
 
 
 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -258,6 +255,10 @@ async def to_code(config):
     if use_legacy():
         cg.add_define("USE_I2S_LEGACY")
 
+    # Helps avoid callbacks being skipped due to processor load
+    if CORE.using_esp_idf:
+        add_idf_sdkconfig_option("CONFIG_I2S_ISR_IRAM_SAFE", True)
+
     cg.add(var.set_lrclk_pin(config[CONF_I2S_LRCLK_PIN]))
     if CONF_I2S_BCLK_PIN in config:
         cg.add(var.set_bclk_pin(config[CONF_I2S_BCLK_PIN]))

esphome/components/i2s_audio/i2s_audio.cpp

@@ -10,8 +10,6 @@ namespace i2s_audio {
 static const char *const TAG = "i2s_audio";
 
 void I2SAudioComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   static i2s_port_t next_port_num = I2S_NUM_0;
   if (next_port_num >= SOC_I2S_NUM) {
     ESP_LOGE(TAG, "Too many components");

esphome/components/i2s_audio/media_player/i2s_audio_media_player.cpp

@@ -119,10 +119,7 @@ void I2SAudioMediaPlayer::set_volume_(float volume, bool publish) {
     this->volume = volume;
 }
 
-void I2SAudioMediaPlayer::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-  this->state = media_player::MEDIA_PLAYER_STATE_IDLE;
-}
+void I2SAudioMediaPlayer::setup() { this->state = media_player::MEDIA_PLAYER_STATE_IDLE; }
 
 void I2SAudioMediaPlayer::loop() {
   switch (this->i2s_state_) {

esphome/components/i2s_audio/microphone/__init__.py

@@ -44,9 +44,8 @@ PDM_VARIANTS = [esp32.const.VARIANT_ESP32, esp32.const.VARIANT_ESP32S3]
 def _validate_esp32_variant(config):
     variant = esp32.get_esp32_variant()
     if config[CONF_ADC_TYPE] == "external":
-        if config[CONF_PDM]:
-            if variant not in PDM_VARIANTS:
-                raise cv.Invalid(f"{variant} does not support PDM")
+        if config[CONF_PDM] and variant not in PDM_VARIANTS:
+            raise cv.Invalid(f"{variant} does not support PDM")
         return config
     if config[CONF_ADC_TYPE] == "internal":
         if variant not in INTERNAL_ADC_VARIANTS:
@@ -122,9 +121,8 @@ CONFIG_SCHEMA = cv.All(
 
 
 def _final_validate(config):
-    if not use_legacy():
-        if config[CONF_ADC_TYPE] == "internal":
-            raise cv.Invalid("Internal ADC is only compatible with legacy i2s driver.")
+    if not use_legacy() and config[CONF_ADC_TYPE] == "internal":
+        raise cv.Invalid("Internal ADC is only compatible with legacy i2s driver.")
 
 
 FINAL_VALIDATE_SCHEMA = _final_validate

esphome/components/i2s_audio/microphone/i2s_audio_microphone.cpp

@@ -37,7 +37,6 @@ enum MicrophoneEventGroupBits : uint32_t {
 };
 
 void I2SAudioMicrophone::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
 #ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_ADC
   if (this->adc_) {

esphome/components/i2s_audio/microphone/i2s_audio_microphone.h

@@ -36,8 +36,8 @@ class I2SAudioMicrophone : public I2SAudioIn, public microphone::Microphone, pub
 
 #ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_ADC
-  void set_adc_channel(adc1_channel_t channel) {
-    this->adc_channel_ = channel;
+  void set_adc_channel(adc_channel_t channel) {
+    this->adc_channel_ = (adc1_channel_t) channel;
     this->adc_ = true;
   }
 #endif