esphome 2025.5.2__py3-none-any.whl → 2025.6.0b2__py3-none-any.whl

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();

esphome/components/factory_reset/switch/factory_reset_switch.cpp

@@ -14,7 +14,7 @@ void FactoryResetSwitch::write_state(bool state) {
   this->publish_state(false);
 
   if (state) {
-    ESP_LOGI(TAG, "Resetting to factory defaults...");
+    ESP_LOGI(TAG, "Resetting");
     // Let MQTT settle a bit
     delay(100);  // NOLINT
     global_preferences->reset();

esphome/components/fan/__init__.py

@@ -296,6 +296,7 @@ async def register_fan(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_fan(var))
+    CORE.register_platform_component("fan", var)
     await setup_fan_core_(var, config)
 
 

esphome/components/fan/fan.cpp

@@ -41,39 +41,48 @@ void FanCall::perform() {
 void FanCall::validate_() {
   auto traits = this->parent_.get_traits();
 
-  if (this->speed_.has_value())
+  if (this->speed_.has_value()) {
     this->speed_ = clamp(*this->speed_, 1, traits.supported_speed_count());
 
-  if (this->binary_state_.has_value() && *this->binary_state_) {
-    // when turning on, if neither current nor new speed available, set speed to 100%
-    if (traits.supports_speed() && !this->parent_.state && this->parent_.speed == 0 && !this->speed_.has_value()) {
-      this->speed_ = traits.supported_speed_count();
+    // https://developers.home-assistant.io/docs/core/entity/fan/#preset-modes
+    // "Manually setting a speed must disable any set preset mode"
+    this->preset_mode_.clear();
+  }
+
+  if (!this->preset_mode_.empty()) {
+    const auto &preset_modes = traits.supported_preset_modes();
+    if (preset_modes.find(this->preset_mode_) == preset_modes.end()) {
+      ESP_LOGW(TAG, "%s: Preset mode '%s' not supported", this->parent_.get_name().c_str(), this->preset_mode_.c_str());
+      this->preset_mode_.clear();
     }
   }
 
+  // when turning on...
+  if (!this->parent_.state && this->binary_state_.has_value() &&
+      *this->binary_state_
+      // ..,and no preset mode will be active...
+      && this->preset_mode_.empty() &&
+      this->parent_.preset_mode.empty()
+      // ...and neither current nor new speed is available...
+      && traits.supports_speed() && this->parent_.speed == 0 && !this->speed_.has_value()) {
+    // ...set speed to 100%
+    this->speed_ = traits.supported_speed_count();
+  }
+
   if (this->oscillating_.has_value() && !traits.supports_oscillation()) {
-    ESP_LOGW(TAG, "'%s' - This fan does not support oscillation!", this->parent_.get_name().c_str());
+    ESP_LOGW(TAG, "%s: Oscillation not supported", this->parent_.get_name().c_str());
     this->oscillating_.reset();
   }
 
   if (this->speed_.has_value() && !traits.supports_speed()) {
-    ESP_LOGW(TAG, "'%s' - This fan does not support speeds!", this->parent_.get_name().c_str());
+    ESP_LOGW(TAG, "%s: Speed control not supported", this->parent_.get_name().c_str());
     this->speed_.reset();
   }
 
   if (this->direction_.has_value() && !traits.supports_direction()) {
-    ESP_LOGW(TAG, "'%s' - This fan does not support directions!", this->parent_.get_name().c_str());
+    ESP_LOGW(TAG, "%s: Direction control not supported", this->parent_.get_name().c_str());
     this->direction_.reset();
   }
-
-  if (!this->preset_mode_.empty()) {
-    const auto &preset_modes = traits.supported_preset_modes();
-    if (preset_modes.find(this->preset_mode_) == preset_modes.end()) {
-      ESP_LOGW(TAG, "'%s' - This fan does not support preset mode '%s'!", this->parent_.get_name().c_str(),
-               this->preset_mode_.c_str());
-      this->preset_mode_.clear();
-    }
-  }
 }
 
 FanCall FanRestoreState::to_call(Fan &fan) {
@@ -189,8 +198,10 @@ void Fan::dump_traits_(const char *tag, const char *prefix) {
   auto traits = this->get_traits();
 
   if (traits.supports_speed()) {
-    ESP_LOGCONFIG(tag, "%s  Speed: YES", prefix);
-    ESP_LOGCONFIG(tag, "%s  Speed count: %d", prefix, traits.supported_speed_count());
+    ESP_LOGCONFIG(tag,
+                  "%s  Speed: YES\n"
+                  "%s  Speed count: %d",
+                  prefix, prefix, traits.supported_speed_count());
   }
   if (traits.supports_oscillation()) {
     ESP_LOGCONFIG(tag, "%s  Oscillation: YES", prefix);

esphome/components/fastled_base/fastled_light.cpp

@@ -9,7 +9,7 @@ namespace fastled_base {
 static const char *const TAG = "fastled";
 
 void FastLEDLightOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up FastLED light...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->controller_->init();
   this->controller_->setLeds(this->leds_, this->num_leds_);
   this->effect_data_ = new uint8_t[this->num_leds_];  // NOLINT
@@ -18,9 +18,11 @@ void FastLEDLightOutput::setup() {
   }
 }
 void FastLEDLightOutput::dump_config() {
-  ESP_LOGCONFIG(TAG, "FastLED light:");
-  ESP_LOGCONFIG(TAG, "  Num LEDs: %u", this->num_leds_);
-  ESP_LOGCONFIG(TAG, "  Max refresh rate: %u", *this->max_refresh_rate_);
+  ESP_LOGCONFIG(TAG,
+                "FastLED light:\n"
+                "  Num LEDs: %u\n"
+                "  Max refresh rate: %u",
+                this->num_leds_, *this->max_refresh_rate_);
 }
 void FastLEDLightOutput::write_state(light::LightState *state) {
   // protect from refreshing too often
@@ -33,7 +35,7 @@ void FastLEDLightOutput::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");
   this->controller_->showLeds(this->state_parent_->current_values.get_brightness() * 255);
 }
 

esphome/components/fingerprint_grow/fingerprint_grow.cpp

@@ -57,7 +57,7 @@ void FingerprintGrowComponent::update() {
 }
 
 void FingerprintGrowComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Grow Fingerprint Reader...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   this->has_sensing_pin_ = (this->sensing_pin_ != nullptr);
   this->has_power_pin_ = (this->sensor_power_pin_ != nullptr);
@@ -534,11 +534,13 @@ void FingerprintGrowComponent::sensor_sleep_() {
 }
 
 void FingerprintGrowComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "GROW_FINGERPRINT_READER:");
-  ESP_LOGCONFIG(TAG, "  System Identifier Code: 0x%.4X", this->system_identifier_code_);
-  ESP_LOGCONFIG(TAG, "  Touch Sensing Pin: %s",
-                this->has_sensing_pin_ ? this->sensing_pin_->dump_summary().c_str() : "None");
-  ESP_LOGCONFIG(TAG, "  Sensor Power Pin: %s",
+  ESP_LOGCONFIG(TAG,
+                "GROW_FINGERPRINT_READER:\n"
+                "  System Identifier Code: 0x%.4X\n"
+                "  Touch Sensing Pin: %s\n"
+                "  Sensor Power Pin: %s",
+                this->system_identifier_code_,
+                this->has_sensing_pin_ ? this->sensing_pin_->dump_summary().c_str() : "None",
                 this->has_power_pin_ ? this->sensor_power_pin_->dump_summary().c_str() : "None");
   if (this->idle_period_to_sleep_ms_ < UINT32_MAX) {
     ESP_LOGCONFIG(TAG, "  Idle Period to Sleep: %" PRIu32 " ms", this->idle_period_to_sleep_ms_);