esphome 2025.5.1__py3-none-any.whl → 2025.6.0b1__py3-none-any.whl

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -324,10 +324,10 @@ void ESP32ImprovComponent::process_incoming_data_() {
         this->incoming_data_.clear();
     }
   } else if (this->incoming_data_.size() - 2 > length) {
-    ESP_LOGV(TAG, "Too much data received or data malformed; resetting buffer...");
+    ESP_LOGV(TAG, "Too much data received or data malformed; resetting buffer");
     this->incoming_data_.clear();
   } else {
-    ESP_LOGV(TAG, "Waiting for split data packets...");
+    ESP_LOGV(TAG, "Waiting for split data packets");
   }
 }
 

esphome/components/esp32_rmt_led_strip/led_strip.cpp

@@ -22,7 +22,7 @@ static const uint8_t RMT_CLK_DIV = 2;
 #endif
 
 void ESP32RMTLEDStripLightOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ESP32 LED Strip...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   size_t buffer_size = this->get_buffer_size_();
 
@@ -143,7 +143,7 @@ void ESP32RMTLEDStripLightOutput::write_state(light::LightState *state) {
   this->last_refresh_ = now;
   this->mark_shown_();
 
-  ESP_LOGVV(TAG, "Writing RGB values to bus...");
+  ESP_LOGVV(TAG, "Writing RGB values to bus");
 
 #if ESP_IDF_VERSION_MAJOR >= 5
   esp_err_t error = rmt_tx_wait_all_done(this->channel_, 1000);
@@ -247,8 +247,10 @@ light::ESPColorView ESP32RMTLEDStripLightOutput::get_view_internal(int32_t index
 }
 
 void ESP32RMTLEDStripLightOutput::dump_config() {
-  ESP_LOGCONFIG(TAG, "ESP32 RMT LED Strip:");
-  ESP_LOGCONFIG(TAG, "  Pin: %u", this->pin_);
+  ESP_LOGCONFIG(TAG,
+                "ESP32 RMT LED Strip:\n"
+                "  Pin: %u",
+                this->pin_);
 #if ESP_IDF_VERSION_MAJOR >= 5
   ESP_LOGCONFIG(TAG, "  RMT Symbols: %" PRIu32, this->rmt_symbols_);
 #else
@@ -278,9 +280,11 @@ void ESP32RMTLEDStripLightOutput::dump_config() {
       rgb_order = "UNKNOWN";
       break;
   }
-  ESP_LOGCONFIG(TAG, "  RGB Order: %s", rgb_order);
-  ESP_LOGCONFIG(TAG, "  Max refresh rate: %" PRIu32, *this->max_refresh_rate_);
-  ESP_LOGCONFIG(TAG, "  Number of LEDs: %u", this->num_leds_);
+  ESP_LOGCONFIG(TAG,
+                "  RGB Order: %s\n"
+                "  Max refresh rate: %" PRIu32 "\n"
+                "  Number of LEDs: %u",
+                rgb_order, *this->max_refresh_rate_, this->num_leds_);
 }
 
 float ESP32RMTLEDStripLightOutput::get_setup_priority() const { return setup_priority::HARDWARE; }

esphome/components/esp32_rmt_led_strip/light.py

@@ -131,7 +131,9 @@ CONFIG_SCHEMA = cv.All(
                 esp32_idf=192,
                 esp32_s2_idf=192,
                 esp32_s3_idf=192,
+                esp32_p4_idf=192,
                 esp32_c3_idf=96,
+                esp32_c5_idf=96,
                 esp32_c6_idf=96,
                 esp32_h2_idf=96,
             ): cv.All(only_with_new_rmt_driver, cv.int_range(min=2)),
@@ -140,7 +142,9 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_IS_RGBW, default=False): cv.boolean,
             cv.Optional(CONF_IS_WRGB, default=False): cv.boolean,
             cv.Optional(CONF_USE_DMA): cv.All(
-                esp32.only_on_variant(supported=[esp32.const.VARIANT_ESP32S3]),
+                esp32.only_on_variant(
+                    supported=[esp32.const.VARIANT_ESP32S3, esp32.const.VARIANT_ESP32P4]
+                ),
                 cv.only_with_esp_idf,
                 cv.boolean,
             ),

esphome/components/esp32_touch/esp32_touch.cpp

@@ -13,7 +13,7 @@ namespace esp32_touch {
 static const char *const TAG = "esp32_touch";
 
 void ESP32TouchComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ESP32 Touch Hub...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   touch_pad_init();
 // set up and enable/start filtering based on ESP32 variant
 #if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
@@ -75,9 +75,11 @@ void ESP32TouchComponent::setup() {
 }
 
 void ESP32TouchComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "Config for ESP32 Touch Hub:");
-  ESP_LOGCONFIG(TAG, "  Meas cycle: %.2fms", this->meas_cycle_ / (8000000.0f / 1000.0f));
-  ESP_LOGCONFIG(TAG, "  Sleep cycle: %.2fms", this->sleep_cycle_ / (150000.0f / 1000.0f));
+  ESP_LOGCONFIG(TAG,
+                "Config for ESP32 Touch Hub:\n"
+                "  Meas cycle: %.2fms\n"
+                "  Sleep cycle: %.2fms",
+                this->meas_cycle_ / (8000000.0f / 1000.0f), this->sleep_cycle_ / (150000.0f / 1000.0f));
 
   const char *lv_s;
   switch (this->low_voltage_reference_) {
@@ -171,10 +173,12 @@ void ESP32TouchComponent::dump_config() {
         filter_mode_s = "UNKNOWN";
         break;
     }
-    ESP_LOGCONFIG(TAG, "  Filter mode: %s", filter_mode_s);
-    ESP_LOGCONFIG(TAG, "  Debounce count: %" PRIu32, this->debounce_count_);
-    ESP_LOGCONFIG(TAG, "  Noise threshold coefficient: %" PRIu32, this->noise_threshold_);
-    ESP_LOGCONFIG(TAG, "  Jitter filter step size: %" PRIu32, this->jitter_step_);
+    ESP_LOGCONFIG(TAG,
+                  "  Filter mode: %s\n"
+                  "  Debounce count: %" PRIu32 "\n"
+                  "  Noise threshold coefficient: %" PRIu32 "\n"
+                  "  Jitter filter step size: %" PRIu32,
+                  filter_mode_s, this->debounce_count_, this->noise_threshold_, this->jitter_step_);
     const char *smooth_level_s;
     switch (this->smooth_level_) {
       case TOUCH_PAD_SMOOTH_OFF:

esphome/components/esp8266/gpio.cpp

@@ -40,6 +40,7 @@ struct ISRPinArg {
   volatile uint32_t *mode_set_reg;
   volatile uint32_t *mode_clr_reg;
   volatile uint32_t *func_reg;
+  volatile uint32_t *control_reg;
   uint32_t mask;
 };
 
@@ -54,6 +55,7 @@ ISRInternalGPIOPin ESP8266GPIOPin::to_isr() const {
     arg->mode_set_reg = &GPES;
     arg->mode_clr_reg = &GPEC;
     arg->func_reg = &GPF(this->pin_);
+    arg->control_reg = &GPC(this->pin_);
     arg->mask = 1 << this->pin_;
   } else {
     arg->in_reg = &GP16I;
@@ -62,6 +64,7 @@ ISRInternalGPIOPin ESP8266GPIOPin::to_isr() const {
     arg->mode_set_reg = &GP16E;
     arg->mode_clr_reg = nullptr;
     arg->func_reg = &GPF16;
+    arg->control_reg = nullptr;
     arg->mask = 1;
   }
   return ISRInternalGPIOPin((void *) arg);
@@ -143,11 +146,17 @@ void IRAM_ATTR ISRInternalGPIOPin::pin_mode(gpio::Flags flags) {
   if (arg->pin < 16) {
     if (flags & gpio::FLAG_OUTPUT) {
       *arg->mode_set_reg = arg->mask;
-    } else {
+      if (flags & gpio::FLAG_OPEN_DRAIN) {
+        *arg->control_reg |= 1 << GPCD;
+      } else {
+        *arg->control_reg &= ~(1 << GPCD);
+      }
+    } else if (flags & gpio::FLAG_INPUT) {
       *arg->mode_clr_reg = arg->mask;
     }
     if (flags & gpio::FLAG_PULLUP) {
       *arg->func_reg |= 1 << GPFPU;
+      *arg->control_reg |= 1 << GPCD;
     } else {
       *arg->func_reg &= ~(1 << GPFPU);
     }

esphome/components/esp8266/preferences.cpp

@@ -169,7 +169,7 @@ class ESP8266Preferences : public ESPPreferences {
 
   void setup() {
     s_flash_storage = new uint32_t[ESP8266_FLASH_STORAGE_SIZE];  // NOLINT
-    ESP_LOGVV(TAG, "Loading preferences from flash...");
+    ESP_LOGVV(TAG, "Loading preferences from flash");
 
     {
       InterruptLock lock;
@@ -235,7 +235,7 @@ class ESP8266Preferences : public ESPPreferences {
     if (s_prevent_write)
       return false;
 
-    ESP_LOGD(TAG, "Saving preferences to flash...");
+    ESP_LOGD(TAG, "Saving");
     SpiFlashOpResult erase_res, write_res = SPI_FLASH_RESULT_OK;
     {
       InterruptLock lock;
@@ -245,11 +245,11 @@ class ESP8266Preferences : public ESPPreferences {
       }
     }
     if (erase_res != SPI_FLASH_RESULT_OK) {
-      ESP_LOGE(TAG, "Erase ESP8266 flash failed!");
+      ESP_LOGE(TAG, "Erasing failed");
       return false;
     }
     if (write_res != SPI_FLASH_RESULT_OK) {
-      ESP_LOGE(TAG, "Write ESP8266 flash failed!");
+      ESP_LOGE(TAG, "Writing failed");
       return false;
     }
 
@@ -258,14 +258,14 @@ class ESP8266Preferences : public ESPPreferences {
   }
 
   bool reset() override {
-    ESP_LOGD(TAG, "Cleaning up preferences in flash...");
+    ESP_LOGD(TAG, "Erasing storage");
     SpiFlashOpResult erase_res;
     {
       InterruptLock lock;
       erase_res = spi_flash_erase_sector(get_esp8266_flash_sector());
     }
     if (erase_res != SPI_FLASH_RESULT_OK) {
-      ESP_LOGE(TAG, "Erase ESP8266 flash failed!");
+      ESP_LOGE(TAG, "Erasing failed");
       return false;
     }
 

esphome/components/esp8266_pwm/esp8266_pwm.cpp

@@ -1,10 +1,10 @@
 #ifdef USE_ESP8266
 
 #include "esp8266_pwm.h"
-#include "esphome/core/macros.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+#include "esphome/core/macros.h"
 
 #include <core_esp8266_waveform.h>
 
@@ -14,7 +14,7 @@ namespace esp8266_pwm {
 static const char *const TAG = "esp8266_pwm";
 
 void ESP8266PWM::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ESP8266 PWM Output...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->pin_->setup();
   this->turn_off();
 }

esphome/components/esp_ldo/__init__.py

@@ -0,0 +1,91 @@
+from esphome.automation import Action, register_action
+import esphome.codegen as cg
+from esphome.components.esp32 import VARIANT_ESP32P4, only_on_variant
+import esphome.config_validation as cv
+from esphome.const import CONF_CHANNEL, CONF_ID, CONF_VOLTAGE
+from esphome.final_validate import full_config
+
+CODEOWNERS = ["@clydebarrow"]
+
+DOMAIN = "esp_ldo"
+
+esp_ldo_ns = cg.esphome_ns.namespace("esp_ldo")
+EspLdo = esp_ldo_ns.class_("EspLdo", cg.Component)
+AdjustAction = esp_ldo_ns.class_("AdjustAction", Action)
+
+CHANNELS = (3, 4)
+CONF_ADJUSTABLE = "adjustable"
+
+adjusted_ids = set()
+
+CONFIG_SCHEMA = cv.All(
+    cv.ensure_list(
+        {
+            cv.GenerateID(): cv.declare_id(EspLdo),
+            cv.Required(CONF_VOLTAGE): cv.All(
+                cv.voltage, cv.float_range(min=0.5, max=2.7)
+            ),
+            cv.Required(CONF_CHANNEL): cv.one_of(*CHANNELS, int=True),
+            cv.Optional(CONF_ADJUSTABLE, default=False): cv.boolean,
+        }
+    ),
+    cv.only_with_esp_idf,
+    only_on_variant(supported=[VARIANT_ESP32P4]),
+)
+
+
+async def to_code(configs):
+    for config in configs:
+        var = cg.new_Pvariable(config[CONF_ID], config[CONF_CHANNEL])
+        await cg.register_component(var, config)
+        cg.add(var.set_voltage(config[CONF_VOLTAGE]))
+        cg.add(var.set_adjustable(config[CONF_ADJUSTABLE]))
+
+
+def final_validate(configs):
+    for channel in CHANNELS:
+        used = [config for config in configs if config[CONF_CHANNEL] == channel]
+        if len(used) > 1:
+            raise cv.Invalid(
+                f"Multiple LDOs configured for channel {channel}. Each channel must be unique.",
+                path=[CONF_CHANNEL, channel],
+            )
+
+    global_config = full_config.get()
+    for w in adjusted_ids:
+        path = global_config.get_path_for_id(w)
+        ldo_conf = global_config.get_config_for_path(path[:-1])
+        if not ldo_conf[CONF_ADJUSTABLE]:
+            raise cv.Invalid(
+                "A non adjustable LDO may not be adjusted.",
+                path,
+            )
+
+
+FINAL_VALIDATE_SCHEMA = final_validate
+
+
+def adjusted_ldo_id(value):
+    value = cv.use_id(EspLdo)(value)
+    adjusted_ids.add(value)
+    return value
+
+
+@register_action(
+    "esp_ldo.voltage.adjust",
+    AdjustAction,
+    cv.Schema(
+        {
+            cv.GenerateID(CONF_ID): adjusted_ldo_id,
+            cv.Required(CONF_VOLTAGE): cv.templatable(
+                cv.All(cv.voltage, cv.float_range(min=0.5, max=2.7))
+            ),
+        }
+    ),
+)
+async def ldo_voltage_adjust_to_code(config, action_id, template_arg, args):
+    parent = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, parent)
+    template_ = await cg.templatable(config[CONF_VOLTAGE], args, cg.float_)
+    cg.add(var.set_voltage(template_))
+    return var

esphome/components/esp_ldo/esp_ldo.cpp

@@ -0,0 +1,43 @@
+#ifdef USE_ESP32_VARIANT_ESP32P4
+#include "esp_ldo.h"
+#include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace esp_ldo {
+
+static const char *const TAG = "esp_ldo";
+void EspLdo::setup() {
+  esp_ldo_channel_config_t config{};
+  config.chan_id = this->channel_;
+  config.voltage_mv = (int) (this->voltage_ * 1000.0f);
+  config.flags.adjustable = this->adjustable_;
+  auto err = esp_ldo_acquire_channel(&config, &this->handle_);
+  if (err != ESP_OK) {
+    auto msg = str_sprintf("Failed to acquire LDO channel %d with voltage %fV", this->channel_, this->voltage_);
+    this->mark_failed(msg.c_str());
+  } else {
+    ESP_LOGD(TAG, "Acquired LDO channel %d with voltage %fV", this->channel_, this->voltage_);
+  }
+}
+void EspLdo::dump_config() {
+  ESP_LOGCONFIG(TAG, "ESP LDO Channel %d:", this->channel_);
+  ESP_LOGCONFIG(TAG, "  Voltage: %fV", this->voltage_);
+  ESP_LOGCONFIG(TAG, "  Adjustable: %s", YESNO(this->adjustable_));
+}
+
+void EspLdo::adjust_voltage(float voltage) {
+  if (!std::isfinite(voltage) || voltage < 0.5f || voltage > 2.7f) {
+    ESP_LOGE(TAG, "Invalid voltage %fV for LDO channel %d", voltage, this->channel_);
+    return;
+  }
+  auto erro = esp_ldo_channel_adjust_voltage(this->handle_, (int) (voltage * 1000.0f));
+  if (erro != ESP_OK) {
+    ESP_LOGE(TAG, "Failed to adjust LDO channel %d to voltage %fV: %s", this->channel_, voltage, esp_err_to_name(erro));
+  }
+}
+
+}  // namespace esp_ldo
+}  // namespace esphome
+
+#endif  // USE_ESP32_VARIANT_ESP32P4

esphome/components/esp_ldo/esp_ldo.h

@@ -0,0 +1,43 @@
+#pragma once
+#ifdef USE_ESP32_VARIANT_ESP32P4
+#include "esphome/core/component.h"
+#include "esphome/core/automation.h"
+#include "esp_ldo_regulator.h"
+
+namespace esphome {
+namespace esp_ldo {
+
+class EspLdo : public Component {
+ public:
+  EspLdo(int channel) : channel_(channel) {}
+
+  void setup() override;
+  void dump_config() override;
+
+  void set_adjustable(bool adjustable) { this->adjustable_ = adjustable; }
+  void set_voltage(float voltage) { this->voltage_ = voltage; }
+  void adjust_voltage(float voltage);
+
+ protected:
+  int channel_;
+  float voltage_{2.7};
+  bool adjustable_{false};
+  esp_ldo_channel_handle_t handle_{};
+};
+
+template<typename... Ts> class AdjustAction : public Action<Ts...> {
+ public:
+  explicit AdjustAction(EspLdo *ldo) : ldo_(ldo) {}
+
+  TEMPLATABLE_VALUE(float, voltage)
+
+  void play(Ts... x) override { this->ldo_->adjust_voltage(this->voltage_.value(x...)); }
+
+ protected:
+  EspLdo *ldo_;
+};
+
+}  // namespace esp_ldo
+}  // namespace esphome
+
+#endif  // USE_ESP32_VARIANT_ESP32P4

esphome/components/esphome/ota/ota_esphome.cpp

@@ -26,7 +26,7 @@ void ESPHomeOTAComponent::setup() {
   ota::register_ota_platform(this);
 #endif
 
-  server_ = socket::socket_ip(SOCK_STREAM, 0);
+  server_ = socket::socket_ip_loop_monitored(SOCK_STREAM, 0);  // monitored for incoming connections
   if (server_ == nullptr) {
     ESP_LOGW(TAG, "Could not create socket");
     this->mark_failed();
@@ -70,9 +70,11 @@ void ESPHomeOTAComponent::setup() {
 }
 
 void ESPHomeOTAComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "Over-The-Air updates:");
-  ESP_LOGCONFIG(TAG, "  Address: %s:%u", network::get_use_address().c_str(), this->port_);
-  ESP_LOGCONFIG(TAG, "  Version: %d", USE_OTA_VERSION);
+  ESP_LOGCONFIG(TAG,
+                "Over-The-Air updates:\n"
+                "  Address: %s:%u\n"
+                "  Version: %d",
+                network::get_use_address().c_str(), this->port_, USE_OTA_VERSION);
 #ifdef USE_OTA_PASSWORD
   if (!this->password_.empty()) {
     ESP_LOGCONFIG(TAG, "  Password configured");
@@ -100,9 +102,12 @@ void ESPHomeOTAComponent::handle_() {
 #endif
 
   if (client_ == nullptr) {
-    struct sockaddr_storage source_addr;
-    socklen_t addr_len = sizeof(source_addr);
-    client_ = server_->accept((struct sockaddr *) &source_addr, &addr_len);
+    // Check if the server socket is ready before accepting
+    if (this->server_->ready()) {
+      struct sockaddr_storage source_addr;
+      socklen_t addr_len = sizeof(source_addr);
+      client_ = server_->accept((struct sockaddr *) &source_addr, &addr_len);
+    }
   }
   if (client_ == nullptr)
     return;
@@ -111,10 +116,12 @@ void ESPHomeOTAComponent::handle_() {
   int err = client_->setsockopt(IPPROTO_TCP, TCP_NODELAY, &enable, sizeof(int));
   if (err != 0) {
     ESP_LOGW(TAG, "Socket could not enable TCP nodelay, errno %d", errno);
+    client_->close();
+    client_ = nullptr;
     return;
   }
 
-  ESP_LOGD(TAG, "Starting update from %s...", this->client_->getpeername().c_str());
+  ESP_LOGD(TAG, "Starting update from %s", this->client_->getpeername().c_str());
   this->status_set_warning();
 #ifdef USE_OTA_STATE_CALLBACK
   this->state_callback_.call(ota::OTA_STARTED, 0.0f, 0);

esphome/components/ethernet/ethernet_component.cpp

@@ -38,7 +38,7 @@ EthernetComponent *global_eth_component;  // NOLINT(cppcoreguidelines-avoid-non-
 EthernetComponent::EthernetComponent() { global_eth_component = this; }
 
 void EthernetComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Ethernet...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (esp_reset_reason() != ESP_RST_DEEPSLEEP) {
     // Delay here to allow power to stabilise before Ethernet is initialized.
     delay(300);  // NOLINT
@@ -245,33 +245,33 @@ void EthernetComponent::loop() {
   switch (this->state_) {
     case EthernetComponentState::STOPPED:
       if (this->started_) {
-        ESP_LOGI(TAG, "Starting ethernet connection");
+        ESP_LOGI(TAG, "Starting connection");
         this->state_ = EthernetComponentState::CONNECTING;
         this->start_connect_();
       }
       break;
     case EthernetComponentState::CONNECTING:
       if (!this->started_) {
-        ESP_LOGI(TAG, "Stopped ethernet connection");
+        ESP_LOGI(TAG, "Stopped connection");
         this->state_ = EthernetComponentState::STOPPED;
       } else if (this->connected_) {
         // connection established
-        ESP_LOGI(TAG, "Connected via Ethernet!");
+        ESP_LOGI(TAG, "Connected");
         this->state_ = EthernetComponentState::CONNECTED;
 
         this->dump_connect_params_();
         this->status_clear_warning();
       } else if (now - this->connect_begin_ > 15000) {
-        ESP_LOGW(TAG, "Connecting via ethernet failed! Re-connecting...");
+        ESP_LOGW(TAG, "Connecting failed; reconnecting");
         this->start_connect_();
       }
       break;
     case EthernetComponentState::CONNECTED:
       if (!this->started_) {
-        ESP_LOGI(TAG, "Stopped ethernet connection");
+        ESP_LOGI(TAG, "Stopped connection");
         this->state_ = EthernetComponentState::STOPPED;
       } else if (!this->connected_) {
-        ESP_LOGW(TAG, "Connection via Ethernet lost! Re-connecting...");
+        ESP_LOGW(TAG, "Connection lost; reconnecting");
         this->state_ = EthernetComponentState::CONNECTING;
         this->start_connect_();
       }
@@ -326,10 +326,12 @@ void EthernetComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "Ethernet:");
   this->dump_connect_params_();
 #ifdef USE_ETHERNET_SPI
-  ESP_LOGCONFIG(TAG, "  CLK Pin: %u", this->clk_pin_);
-  ESP_LOGCONFIG(TAG, "  MISO Pin: %u", this->miso_pin_);
-  ESP_LOGCONFIG(TAG, "  MOSI Pin: %u", this->mosi_pin_);
-  ESP_LOGCONFIG(TAG, "  CS Pin: %u", this->cs_pin_);
+  ESP_LOGCONFIG(TAG,
+                "  CLK Pin: %u\n"
+                "  MISO Pin: %u\n"
+                "  MOSI Pin: %u\n"
+                "  CS Pin: %u",
+                this->clk_pin_, this->miso_pin_, this->mosi_pin_, this->cs_pin_);
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
   if (this->polling_interval_ != 0) {
     ESP_LOGCONFIG(TAG, "  Polling Interval: %lu ms", this->polling_interval_);
@@ -338,15 +340,19 @@ void EthernetComponent::dump_config() {
   {
     ESP_LOGCONFIG(TAG, "  IRQ Pin: %d", this->interrupt_pin_);
   }
-  ESP_LOGCONFIG(TAG, "  Reset Pin: %d", this->reset_pin_);
-  ESP_LOGCONFIG(TAG, "  Clock Speed: %d MHz", this->clock_speed_ / 1000000);
+  ESP_LOGCONFIG(TAG,
+                "  Reset Pin: %d\n"
+                "  Clock Speed: %d MHz",
+                this->reset_pin_, this->clock_speed_ / 1000000);
 #else
   if (this->power_pin_ != -1) {
     ESP_LOGCONFIG(TAG, "  Power Pin: %u", this->power_pin_);
   }
-  ESP_LOGCONFIG(TAG, "  MDC Pin: %u", this->mdc_pin_);
-  ESP_LOGCONFIG(TAG, "  MDIO Pin: %u", this->mdio_pin_);
-  ESP_LOGCONFIG(TAG, "  PHY addr: %u", this->phy_addr_);
+  ESP_LOGCONFIG(TAG,
+                "  MDC Pin: %u\n"
+                "  MDIO Pin: %u\n"
+                "  PHY addr: %u",
+                this->mdc_pin_, this->mdio_pin_, this->phy_addr_);
 #endif
   ESP_LOGCONFIG(TAG, "  Type: %s", eth_type);
 }
@@ -512,16 +518,19 @@ bool EthernetComponent::is_connected() { return this->state_ == EthernetComponen
 void EthernetComponent::dump_connect_params_() {
   esp_netif_ip_info_t ip;
   esp_netif_get_ip_info(this->eth_netif_, &ip);
-  ESP_LOGCONFIG(TAG, "  IP Address: %s", network::IPAddress(&ip.ip).str().c_str());
-  ESP_LOGCONFIG(TAG, "  Hostname: '%s'", App.get_name().c_str());
-  ESP_LOGCONFIG(TAG, "  Subnet: %s", network::IPAddress(&ip.netmask).str().c_str());
-  ESP_LOGCONFIG(TAG, "  Gateway: %s", network::IPAddress(&ip.gw).str().c_str());
-
   const ip_addr_t *dns_ip1 = dns_getserver(0);
   const ip_addr_t *dns_ip2 = dns_getserver(1);
 
-  ESP_LOGCONFIG(TAG, "  DNS1: %s", network::IPAddress(dns_ip1).str().c_str());
-  ESP_LOGCONFIG(TAG, "  DNS2: %s", network::IPAddress(dns_ip2).str().c_str());
+  ESP_LOGCONFIG(TAG,
+                "  IP Address: %s\n"
+                "  Hostname: '%s'\n"
+                "  Subnet: %s\n"
+                "  Gateway: %s\n"
+                "  DNS1: %s\n"
+                "  DNS2: %s",
+                network::IPAddress(&ip.ip).str().c_str(), App.get_name().c_str(),
+                network::IPAddress(&ip.netmask).str().c_str(), network::IPAddress(&ip.gw).str().c_str(),
+                network::IPAddress(dns_ip1).str().c_str(), network::IPAddress(dns_ip2).str().c_str());
 
 #if USE_NETWORK_IPV6
   struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
@@ -533,9 +542,12 @@ void EthernetComponent::dump_connect_params_() {
   }
 #endif /* USE_NETWORK_IPV6 */
 
-  ESP_LOGCONFIG(TAG, "  MAC Address: %s", this->get_eth_mac_address_pretty().c_str());
-  ESP_LOGCONFIG(TAG, "  Is Full Duplex: %s", YESNO(this->get_duplex_mode() == ETH_DUPLEX_FULL));
-  ESP_LOGCONFIG(TAG, "  Link Speed: %u", this->get_link_speed() == ETH_SPEED_100M ? 100 : 10);
+  ESP_LOGCONFIG(TAG,
+                "  MAC Address: %s\n"
+                "  Is Full Duplex: %s\n"
+                "  Link Speed: %u",
+                this->get_eth_mac_address_pretty().c_str(), YESNO(this->get_duplex_mode() == ETH_DUPLEX_FULL),
+                this->get_link_speed() == ETH_SPEED_100M ? 100 : 10);
 }
 
 #ifdef USE_ETHERNET_SPI

esphome/components/ethernet/ethernet_component.h

@@ -56,7 +56,7 @@ class EthernetComponent : public Component {
   void dump_config() override;
   float get_setup_priority() const override;
   bool can_proceed() override;
-  void on_shutdown() override { powerdown(); }
+  void on_powerdown() override { powerdown(); }
   bool is_connected();
 
 #ifdef USE_ETHERNET_SPI

esphome/components/event/__init__.py

@@ -113,6 +113,7 @@ async def register_event(var, config, *, event_types: list[str]):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_event(var))
+    CORE.register_platform_component("event", var)
     await setup_event_core_(var, config, event_types=event_types)
 
 

esphome/components/exposure_notifications/exposure_notifications.cpp

@@ -1,6 +1,6 @@
 #include "exposure_notifications.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 #ifdef USE_ESP32
 

esphome/components/ezo/ezo.cpp

@@ -15,7 +15,7 @@ void EZOSensor::dump_config() {
   LOG_SENSOR("", "EZO", this);
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with EZO circuit failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
 }

esphome/components/ezo_pmp/ezo_pmp.cpp

@@ -41,7 +41,7 @@ static const std::string DOSING_MODE_CONTINUOUS = "Continuous";
 void EzoPMP::dump_config() {
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with EZO-PMP circuit failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
 }

esphome/components/factory_reset/button/factory_reset_button.cpp

@@ -10,7 +10,7 @@ static const char *const TAG = "factory_reset.button";
 
 void FactoryResetButton::dump_config() { LOG_BUTTON("", "Factory Reset Button", this); }
 void FactoryResetButton::press_action() {
-  ESP_LOGI(TAG, "Resetting to factory defaults...");
+  ESP_LOGI(TAG, "Resetting");
   // Let MQTT settle a bit
   delay(100);  // NOLINT
   global_preferences->reset();