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

esphome/components/ld2410/ld2410.cpp

@@ -72,17 +72,16 @@ void LD2410Component::dump_config() {
   }
 #endif
   this->read_all_info();
-  ESP_LOGCONFIG(TAG, "  Throttle_ : %ums", this->throttle_);
-  ESP_LOGCONFIG(TAG, "  MAC Address : %s", const_cast<char *>(this->mac_.c_str()));
-  ESP_LOGCONFIG(TAG, "  Firmware Version : %s", const_cast<char *>(this->version_.c_str()));
+  ESP_LOGCONFIG(TAG,
+                "  Throttle_ : %ums\n"
+                "  MAC Address : %s\n"
+                "  Firmware Version : %s",
+                this->throttle_, const_cast<char *>(this->mac_.c_str()), const_cast<char *>(this->version_.c_str()));
 }
 
 void LD2410Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up LD2410...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->read_all_info();
-  ESP_LOGCONFIG(TAG, "Mac Address : %s", const_cast<char *>(this->mac_.c_str()));
-  ESP_LOGCONFIG(TAG, "Firmware Version : %s", const_cast<char *>(this->version_.c_str()));
-  ESP_LOGCONFIG(TAG, "LD2410 setup complete.");
 }
 
 void LD2410Component::read_all_info() {

esphome/components/ld2420/ld2420.cpp

@@ -65,9 +65,11 @@ static const char *const TAG = "ld2420";
 float LD2420Component::get_setup_priority() const { return setup_priority::BUS; }
 
 void LD2420Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "LD2420:");
-  ESP_LOGCONFIG(TAG, "  Firmware Version : %7s", this->ld2420_firmware_ver_);
-  ESP_LOGCONFIG(TAG, "LD2420 Number:");
+  ESP_LOGCONFIG(TAG,
+                "LD2420:\n"
+                "  Firmware Version : %7s\n"
+                "LD2420 Number:",
+                this->ld2420_firmware_ver_);
 #ifdef USE_NUMBER
   LOG_NUMBER(TAG, "  Gate Timeout:", this->gate_timeout_number_);
   LOG_NUMBER(TAG, "  Gate Max Distance:", this->max_gate_distance_number_);
@@ -111,7 +113,7 @@ int LD2420Component::get_firmware_int_(const char *version_string) {
 }
 
 void LD2420Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up LD2420...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->set_config_mode(true) == LD2420_ERROR_TIMEOUT) {
     ESP_LOGE(TAG, "LD2420 module has failed to respond, check baud rate and serial connections.");
     this->mark_failed();
@@ -158,7 +160,7 @@ void LD2420Component::apply_config_action() {
     ESP_LOGCONFIG(TAG, "No configuration change detected");
     return;
   }
-  ESP_LOGCONFIG(TAG, "Reconfiguring LD2420...");
+  ESP_LOGCONFIG(TAG, "Reconfiguring LD2420");
   if (this->set_config_mode(true) == LD2420_ERROR_TIMEOUT) {
     ESP_LOGE(TAG, "LD2420 module has failed to respond, check baud rate and serial connections.");
     this->mark_failed();
@@ -180,7 +182,7 @@ void LD2420Component::apply_config_action() {
 }
 
 void LD2420Component::factory_reset_action() {
-  ESP_LOGCONFIG(TAG, "Setting factory defaults...");
+  ESP_LOGCONFIG(TAG, "Setting factory defaults");
   if (this->set_config_mode(true) == LD2420_ERROR_TIMEOUT) {
     ESP_LOGE(TAG, "LD2420 module has failed to respond, check baud rate and serial connections.");
     this->mark_failed();
@@ -209,7 +211,7 @@ void LD2420Component::factory_reset_action() {
 }
 
 void LD2420Component::restart_module_action() {
-  ESP_LOGCONFIG(TAG, "Restarting LD2420 module...");
+  ESP_LOGCONFIG(TAG, "Restarting LD2420 module");
   this->send_module_restart();
   this->set_timeout(250, [this]() {
     this->set_config_mode(true);

esphome/components/ld2450/ld2450.cpp

@@ -109,7 +109,7 @@ static inline std::string format_version(uint8_t *buffer) {
 LD2450Component::LD2450Component() {}
 
 void LD2450Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up HLK-LD2450...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 #ifdef USE_NUMBER
   if (this->presence_timeout_number_ != nullptr) {
     this->pref_ = global_preferences->make_preference<float>(this->presence_timeout_number_->get_object_id_hash());
@@ -188,9 +188,11 @@ void LD2450Component::dump_config() {
 #ifdef USE_NUMBER
   LOG_NUMBER("  ", "PresenceTimeoutNumber", this->presence_timeout_number_);
 #endif
-  ESP_LOGCONFIG(TAG, "  Throttle : %ums", this->throttle_);
-  ESP_LOGCONFIG(TAG, "  MAC Address : %s", const_cast<char *>(this->mac_.c_str()));
-  ESP_LOGCONFIG(TAG, "  Firmware version : %s", const_cast<char *>(this->version_.c_str()));
+  ESP_LOGCONFIG(TAG,
+                "  Throttle : %ums\n"
+                "  MAC Address : %s\n"
+                "  Firmware version : %s",
+                this->throttle_, const_cast<char *>(this->mac_.c_str()), const_cast<char *>(this->version_.c_str()));
 }
 
 void LD2450Component::loop() {

esphome/components/ld2450/sensor.py

@@ -6,6 +6,8 @@ from esphome.const import (
     CONF_DISTANCE,
     CONF_RESOLUTION,
     CONF_SPEED,
+    CONF_X,
+    CONF_Y,
     DEVICE_CLASS_DISTANCE,
     DEVICE_CLASS_SPEED,
     UNIT_DEGREES,
@@ -19,8 +21,6 @@ DEPENDENCIES = ["ld2450"]
 CONF_MOVING_TARGET_COUNT = "moving_target_count"
 CONF_STILL_TARGET_COUNT = "still_target_count"
 CONF_TARGET_COUNT = "target_count"
-CONF_X = "x"
-CONF_Y = "y"
 
 ICON_ACCOUNT_GROUP = "mdi:account-group"
 ICON_ACCOUNT_SWITCH = "mdi:account-switch"

esphome/components/ledc/ledc_output.cpp

@@ -46,11 +46,13 @@ inline ledc_mode_t get_speed_mode(uint8_t) { return LEDC_LOW_SPEED_MODE; }
 #endif
 #endif
 
-float ledc_max_frequency_for_bit_depth(uint8_t bit_depth) { return CLOCK_FREQUENCY / float(1 << bit_depth); }
+float ledc_max_frequency_for_bit_depth(uint8_t bit_depth) {
+  return static_cast<float>(CLOCK_FREQUENCY) / static_cast<float>(1 << bit_depth);
+}
 
 float ledc_min_frequency_for_bit_depth(uint8_t bit_depth, bool low_frequency) {
   const float max_div_num = ((1 << MAX_RES_BITS) - 1) / (low_frequency ? 32.0f : 256.0f);
-  return CLOCK_FREQUENCY / (max_div_num * float(1 << bit_depth));
+  return static_cast<float>(CLOCK_FREQUENCY) / (max_div_num * static_cast<float>(1 << bit_depth));
 }
 
 optional<uint8_t> ledc_bit_depth_for_frequency(float frequency) {
@@ -100,13 +102,13 @@ esp_err_t configure_timer_frequency(ledc_mode_t speed_mode, ledc_timer_t timer_n
 
 #ifdef USE_ESP_IDF
 constexpr int ledc_angle_to_htop(float angle, uint8_t bit_depth) {
-  return static_cast<int>(angle * ((1U << bit_depth) - 1) / 360.);
+  return static_cast<int>(angle * ((1U << bit_depth) - 1) / 360.0f);
 }
 #endif  // USE_ESP_IDF
 
 void LEDCOutput::write_state(float state) {
-  if (!initialized_) {
-    ESP_LOGW(TAG, "LEDC output hasn't been initialized yet!");
+  if (!this->initialized_) {
+    ESP_LOGW(TAG, "Not yet initialized");
     return;
   }
 
@@ -122,8 +124,8 @@ void LEDCOutput::write_state(float state) {
   ledcWrite(this->channel_, duty);
 #endif
 #ifdef USE_ESP_IDF
-  auto speed_mode = get_speed_mode(channel_);
-  auto chan_num = static_cast<ledc_channel_t>(channel_ % 8);
+  auto speed_mode = get_speed_mode(this->channel_);
+  auto chan_num = static_cast<ledc_channel_t>(this->channel_ % 8);
   int hpoint = ledc_angle_to_htop(this->phase_angle_, this->bit_depth_);
   if (duty == max_duty) {
     ledc_stop(speed_mode, chan_num, 1);
@@ -137,7 +139,7 @@ void LEDCOutput::write_state(float state) {
 }
 
 void LEDCOutput::setup() {
-  ESP_LOGV(TAG, "Entering setup...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 #ifdef USE_ARDUINO
   this->update_frequency(this->frequency_);
   this->turn_off();
@@ -145,9 +147,9 @@ void LEDCOutput::setup() {
   ledcAttachPin(this->pin_->get_pin(), this->channel_);
 #endif
 #ifdef USE_ESP_IDF
-  auto speed_mode = get_speed_mode(channel_);
-  auto timer_num = static_cast<ledc_timer_t>((channel_ % 8) / 2);
-  auto chan_num = static_cast<ledc_channel_t>(channel_ % 8);
+  auto speed_mode = get_speed_mode(this->channel_);
+  auto timer_num = static_cast<ledc_timer_t>((this->channel_ % 8) / 2);
+  auto chan_num = static_cast<ledc_channel_t>(this->channel_ % 8);
 
   esp_err_t timer_init_result =
       configure_timer_frequency(speed_mode, timer_num, chan_num, this->channel_, this->bit_depth_, this->frequency_);
@@ -163,26 +165,28 @@ void LEDCOutput::setup() {
   ESP_LOGV(TAG, "Angle of %.1f° results in hpoint %u", this->phase_angle_, hpoint);
 
   ledc_channel_config_t chan_conf{};
-  chan_conf.gpio_num = pin_->get_pin();
+  chan_conf.gpio_num = this->pin_->get_pin();
   chan_conf.speed_mode = speed_mode;
   chan_conf.channel = chan_num;
   chan_conf.intr_type = LEDC_INTR_DISABLE;
   chan_conf.timer_sel = timer_num;
-  chan_conf.duty = inverted_ == pin_->is_inverted() ? 0 : (1U << bit_depth_);
+  chan_conf.duty = this->inverted_ == this->pin_->is_inverted() ? 0 : (1U << this->bit_depth_);
   chan_conf.hpoint = hpoint;
   ledc_channel_config(&chan_conf);
-  initialized_ = true;
+  this->initialized_ = true;
   this->status_clear_error();
 #endif
 }
 
 void LEDCOutput::dump_config() {
-  ESP_LOGCONFIG(TAG, "LEDC Output:");
+  ESP_LOGCONFIG(TAG, "Output:");
   LOG_PIN("  Pin ", this->pin_);
-  ESP_LOGCONFIG(TAG, "  LEDC Channel: %u", this->channel_);
-  ESP_LOGCONFIG(TAG, "  PWM Frequency: %.1f Hz", this->frequency_);
-  ESP_LOGCONFIG(TAG, "  Phase angle: %.1f°", this->phase_angle_);
-  ESP_LOGCONFIG(TAG, "  Bit depth: %u", this->bit_depth_);
+  ESP_LOGCONFIG(TAG,
+                "  Channel: %u\n"
+                "  PWM Frequency: %.1f Hz\n"
+                "  Phase angle: %.1f°\n"
+                "  Bit depth: %u",
+                this->channel_, this->frequency_, this->phase_angle_, this->bit_depth_);
   ESP_LOGV(TAG, "  Max frequency for bit depth: %f", ledc_max_frequency_for_bit_depth(this->bit_depth_));
   ESP_LOGV(TAG, "  Min frequency for bit depth: %f",
            ledc_min_frequency_for_bit_depth(this->bit_depth_, (this->frequency_ < 100)));
@@ -205,17 +209,17 @@ void LEDCOutput::update_frequency(float frequency) {
   this->bit_depth_ = bit_depth_opt.value_or(8);
   this->frequency_ = frequency;
 #ifdef USE_ARDUINO
-  ESP_LOGV(TAG, "Using Arduino API - Trying to define channel, frequency and bit depth...");
+  ESP_LOGV(TAG, "Using Arduino API - Trying to define channel, frequency and bit depth");
   u_int32_t configured_frequency = 0;
 
   // Configure LEDC channel, frequency and bit depth with fallback
   int attempt_count_max = SETUP_ATTEMPT_COUNT_MAX;
   while (attempt_count_max > 0 && configured_frequency == 0) {
-    ESP_LOGV(TAG, "Trying initialize channel %u with frequency %.1f and bit depth of %u...", this->channel_,
-             this->frequency_, this->bit_depth_);
+    ESP_LOGV(TAG, "Initializing channel %u with frequency %.1f and bit depth of %u", this->channel_, this->frequency_,
+             this->bit_depth_);
     configured_frequency = ledcSetup(this->channel_, frequency, this->bit_depth_);
     if (configured_frequency != 0) {
-      initialized_ = true;
+      this->initialized_ = true;
       this->status_clear_error();
       ESP_LOGV(TAG, "Configured frequency: %u with bit depth: %u", configured_frequency, this->bit_depth_);
     } else {
@@ -236,14 +240,14 @@ void LEDCOutput::update_frequency(float frequency) {
 
 #endif  // USE_ARDUINO
 #ifdef USE_ESP_IDF
-  if (!initialized_) {
-    ESP_LOGW(TAG, "LEDC output hasn't been initialized yet!");
+  if (!this->initialized_) {
+    ESP_LOGW(TAG, "Not yet initialized");
     return;
   }
 
-  auto speed_mode = get_speed_mode(channel_);
-  auto timer_num = static_cast<ledc_timer_t>((channel_ % 8) / 2);
-  auto chan_num = static_cast<ledc_channel_t>(channel_ % 8);
+  auto speed_mode = get_speed_mode(this->channel_);
+  auto timer_num = static_cast<ledc_timer_t>((this->channel_ % 8) / 2);
+  auto chan_num = static_cast<ledc_channel_t>(this->channel_ % 8);
 
   esp_err_t timer_init_result =
       configure_timer_frequency(speed_mode, timer_num, chan_num, this->channel_, this->bit_depth_, this->frequency_);

esphome/components/libretiny/const.py

@@ -1,5 +1,5 @@
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable
 
 import esphome.codegen as cg
 

esphome/components/libretiny/preferences.cpp

@@ -1,8 +1,8 @@
 #ifdef USE_LIBRETINY
 
-#include "esphome/core/preferences.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/preferences.h"
 #include <flashdb.h>
 #include <cstring>
 #include <vector>
@@ -101,7 +101,7 @@ class LibreTinyPreferences : public ESPPreferences {
     if (s_pending_save.empty())
       return true;
 
-    ESP_LOGD(TAG, "Saving %d preferences to flash...", s_pending_save.size());
+    ESP_LOGV(TAG, "Saving %d items...", s_pending_save.size());
     // goal try write all pending saves even if one fails
     int cached = 0, written = 0, failed = 0;
     fdb_err_t last_err = FDB_NO_ERR;
@@ -129,11 +129,10 @@ class LibreTinyPreferences : public ESPPreferences {
       }
       s_pending_save.erase(s_pending_save.begin() + i);
     }
-    ESP_LOGD(TAG, "Saving %d preferences to flash: %d cached, %d written, %d failed", cached + written + failed, cached,
-             written, failed);
+    ESP_LOGD(TAG, "Writing %d items: %d cached, %d written, %d failed", cached + written + failed, cached, written,
+             failed);
     if (failed > 0) {
-      ESP_LOGE(TAG, "Error saving %d preferences to flash. Last error=%d for key=%s", failed, last_err,
-               last_key.c_str());
+      ESP_LOGE(TAG, "Writing %d items failed. Last error=%d for key=%s", failed, last_err, last_key.c_str());
     }
 
     return failed == 0;
@@ -158,7 +157,7 @@ class LibreTinyPreferences : public ESPPreferences {
   }
 
   bool reset() override {
-    ESP_LOGD(TAG, "Cleaning up preferences in flash...");
+    ESP_LOGD(TAG, "Erasing storage");
     s_pending_save.clear();
 
     fdb_kv_set_default(&db);

esphome/components/light/__init__.py

@@ -37,7 +37,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
     CONF_WHITE,
 )
-from esphome.core import coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.cpp_generator import MockObjClass
 from esphome.cpp_helpers import setup_entity
 
@@ -270,6 +270,7 @@ async def setup_light_core_(light_var, output_var, config):
 async def register_light(output_var, config):
     light_var = cg.new_Pvariable(config[CONF_ID], output_var)
     cg.add(cg.App.register_light(light_var))
+    CORE.register_platform_component("light", light_var)
     await cg.register_component(light_var, config)
     await setup_light_core_(light_var, output_var, config)
 

esphome/components/light/esp_hsv_color.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/helpers.h"
 #include "esphome/core/color.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace light {

esphome/components/light/light_state.cpp

@@ -18,7 +18,7 @@ LightCall LightState::toggle() { return this->make_call().set_state(!this->remot
 LightCall LightState::make_call() { return LightCall(this); }
 
 void LightState::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up light '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->get_name().c_str());
 
   this->output_->setup_state(this);
   for (auto *effect : this->effects_) {
@@ -91,12 +91,16 @@ void LightState::setup() {
 void LightState::dump_config() {
   ESP_LOGCONFIG(TAG, "Light '%s'", this->get_name().c_str());
   if (this->get_traits().supports_color_capability(ColorCapability::BRIGHTNESS)) {
-    ESP_LOGCONFIG(TAG, "  Default Transition Length: %.1fs", this->default_transition_length_ / 1e3f);
-    ESP_LOGCONFIG(TAG, "  Gamma Correct: %.2f", this->gamma_correct_);
+    ESP_LOGCONFIG(TAG,
+                  "  Default Transition Length: %.1fs\n"
+                  "  Gamma Correct: %.2f",
+                  this->default_transition_length_ / 1e3f, this->gamma_correct_);
   }
   if (this->get_traits().supports_color_capability(ColorCapability::COLOR_TEMPERATURE)) {
-    ESP_LOGCONFIG(TAG, "  Min Mireds: %.1f", this->get_traits().get_min_mireds());
-    ESP_LOGCONFIG(TAG, "  Max Mireds: %.1f", this->get_traits().get_max_mireds());
+    ESP_LOGCONFIG(TAG,
+                  "  Min Mireds: %.1f\n"
+                  "  Max Mireds: %.1f",
+                  this->get_traits().get_min_mireds(), this->get_traits().get_max_mireds());
   }
 }
 void LightState::loop() {

esphome/components/light/light_transformer.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/helpers.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 #include "light_color_values.h"
 
 namespace esphome {

esphome/components/lightwaverf/LwTx.cpp

@@ -8,8 +8,8 @@
 #include "LwTx.h"
 #include <cstring>
 #include <Arduino.h>
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace lightwaverf {

esphome/components/lightwaverf/lightwaverf.cpp

@@ -14,7 +14,7 @@ static const bool DEFAULT_INVERT = false;
 static const uint32_t DEFAULT_TICK = 330;
 
 void LightWaveRF::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Lightwave RF...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   this->lwtx_.lwtx_setup(pin_tx_, DEFAULT_REPEAT, DEFAULT_INVERT, DEFAULT_TICK);
   this->lwrx_.lwrx_setup(pin_rx_);

esphome/components/lilygo_t5_47/touchscreen/lilygo_t5_47_touchscreen.cpp

@@ -24,7 +24,7 @@ static const uint8_t READ_TOUCH[1] = {0x07};
   }
 
 void LilygoT547Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Lilygo T5 4.7 Touchscreen...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->interrupt_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
   this->interrupt_pin_->setup();
 

esphome/components/lock/__init__.py

@@ -115,6 +115,7 @@ async def register_lock(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_lock(var))
+    CORE.register_platform_component("lock", var)
     await _setup_lock_core(var, config)
 
 

esphome/components/lock/lock.h

@@ -2,9 +2,9 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
-#include "esphome/core/preferences.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/preferences.h"
 #include <set>
 
 namespace esphome {

esphome/components/logger/__init__.py

@@ -8,8 +8,10 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32,
     VARIANT_ESP32C2,
     VARIANT_ESP32C3,
+    VARIANT_ESP32C5,
     VARIANT_ESP32C6,
     VARIANT_ESP32H2,
+    VARIANT_ESP32P4,
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
 )
@@ -88,8 +90,10 @@ UART_SELECTION_ESP32 = {
     VARIANT_ESP32S3: [UART0, UART1, USB_CDC, USB_SERIAL_JTAG],
     VARIANT_ESP32C3: [UART0, UART1, USB_CDC, USB_SERIAL_JTAG],
     VARIANT_ESP32C2: [UART0, UART1],
+    VARIANT_ESP32C5: [UART0, UART1, USB_CDC, USB_SERIAL_JTAG],
     VARIANT_ESP32C6: [UART0, UART1, USB_CDC, USB_SERIAL_JTAG],
     VARIANT_ESP32H2: [UART0, UART1, USB_CDC, USB_SERIAL_JTAG],
+    VARIANT_ESP32P4: [UART0, UART1, USB_CDC, USB_SERIAL_JTAG],
 }
 
 UART_SELECTION_ESP8266 = [UART0, UART0_SWAP, UART1]
@@ -205,8 +209,10 @@ CONFIG_SCHEMA = cv.All(
                 esp32_s3_idf=USB_SERIAL_JTAG,
                 esp32_c3_arduino=USB_CDC,
                 esp32_c3_idf=USB_SERIAL_JTAG,
+                esp32_c5_idf=USB_SERIAL_JTAG,
                 esp32_c6_arduino=USB_CDC,
                 esp32_c6_idf=USB_SERIAL_JTAG,
+                esp32_p4_idf=USB_SERIAL_JTAG,
                 rp2040=USB_CDC,
                 bk72xx=DEFAULT,
                 rtl87xx=DEFAULT,

esphome/components/logger/logger.cpp

@@ -221,12 +221,16 @@ float Logger::get_setup_priority() const { return setup_priority::BUS + 500.0f;
 static const char *const LOG_LEVELS[] = {"NONE", "ERROR", "WARN", "INFO", "CONFIG", "DEBUG", "VERBOSE", "VERY_VERBOSE"};
 
 void Logger::dump_config() {
-  ESP_LOGCONFIG(TAG, "Logger:");
-  ESP_LOGCONFIG(TAG, "  Max Level: %s", LOG_LEVELS[ESPHOME_LOG_LEVEL]);
-  ESP_LOGCONFIG(TAG, "  Initial Level: %s", LOG_LEVELS[this->current_level_]);
+  ESP_LOGCONFIG(TAG,
+                "Logger:\n"
+                "  Max Level: %s\n"
+                "  Initial Level: %s",
+                LOG_LEVELS[ESPHOME_LOG_LEVEL], LOG_LEVELS[this->current_level_]);
 #ifndef USE_HOST
-  ESP_LOGCONFIG(TAG, "  Log Baud Rate: %" PRIu32, this->baud_rate_);
-  ESP_LOGCONFIG(TAG, "  Hardware UART: %s", get_uart_selection_());
+  ESP_LOGCONFIG(TAG,
+                "  Log Baud Rate: %" PRIu32 "\n"
+                "  Hardware UART: %s",
+                this->baud_rate_, get_uart_selection_());
 #endif
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   if (this->log_buffer_) {

esphome/components/logger/logger.h

@@ -212,9 +212,9 @@ class Logger : public Component {
   }
 
   // Format string to explicit buffer with varargs
-  inline void printf_to_buffer_(const char *format, char *buffer, int *buffer_at, int buffer_size, ...) {
+  inline void printf_to_buffer_(char *buffer, int *buffer_at, int buffer_size, const char *format, ...) {
     va_list arg;
-    va_start(arg, buffer_size);
+    va_start(arg, format);
     this->format_body_to_buffer_(buffer, buffer_at, buffer_size, format, arg);
     va_end(arg);
   }
@@ -312,13 +312,13 @@ class Logger : public Component {
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
     if (thread_name != nullptr) {
       // Non-main task with thread name
-      this->printf_to_buffer_("%s[%s][%s:%03u]%s[%s]%s: ", buffer, buffer_at, buffer_size, color, letter, tag, line,
+      this->printf_to_buffer_(buffer, buffer_at, buffer_size, "%s[%s][%s:%03u]%s[%s]%s: ", color, letter, tag, line,
                               ESPHOME_LOG_BOLD(ESPHOME_LOG_COLOR_RED), thread_name, color);
       return;
     }
 #endif
     // Main task or non ESP32/LibreTiny platform
-    this->printf_to_buffer_("%s[%s][%s:%03u]: ", buffer, buffer_at, buffer_size, color, letter, tag, line);
+    this->printf_to_buffer_(buffer, buffer_at, buffer_size, "%s[%s][%s:%03u]: ", color, letter, tag, line);
   }
 
   inline void HOT format_body_to_buffer_(char *buffer, int *buffer_at, int buffer_size, const char *format,

esphome/components/logger/logger_esp32.cpp

@@ -18,12 +18,12 @@
 #endif
 #endif
 
-#include "freertos/FreeRTOS.h"
 #include "esp_idf_version.h"
+#include "freertos/FreeRTOS.h"
 
+#include <fcntl.h>
 #include <cstdint>
 #include <cstdio>
-#include <fcntl.h>
 
 #endif  // USE_ESP_IDF
 
@@ -174,11 +174,11 @@ void Logger::pre_setup() {
 #ifdef USE_ESP_IDF
 void HOT Logger::write_msg_(const char *msg) {
   if (
-#if defined(USE_ESP32_VARIANT_ESP32S2)
+#if defined(USE_LOGGER_USB_CDC) && !defined(USE_LOGGER_USB_SERIAL_JTAG)
       this->uart_ == UART_SELECTION_USB_CDC
-#elif defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32H2)
+#elif defined(USE_LOGGER_USB_SERIAL_JTAG) && !defined(USE_LOGGER_USB_CDC)
       this->uart_ == UART_SELECTION_USB_SERIAL_JTAG
-#elif defined(USE_ESP32_VARIANT_ESP32S3)
+#elif defined(USE_LOGGER_USB_CDC) && defined(USE_LOGGER_USB_SERIAL_JTAG)
       this->uart_ == UART_SELECTION_USB_CDC || this->uart_ == UART_SELECTION_USB_SERIAL_JTAG
 #else
       /* DISABLES CODE */ (false)  // NOLINT

esphome/components/ltr390/ltr390.cpp

@@ -148,7 +148,7 @@ void LTR390Component::read_mode_(int mode_index) {
 }
 
 void LTR390Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ltr390...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // reset
   std::bitset<8> ctrl = this->reg(LTR390_MAIN_CTRL).get();
@@ -187,10 +187,13 @@ void LTR390Component::setup() {
 
 void LTR390Component::dump_config() {
   LOG_I2C_DEVICE(this);
-  ESP_LOGCONFIG(TAG, "  ALS Gain: X%.0f", GAINVALUES[this->gain_als_]);
-  ESP_LOGCONFIG(TAG, "  ALS Resolution: %u-bit", RESOLUTION_BITS[this->res_als_]);
-  ESP_LOGCONFIG(TAG, "  UV Gain: X%.0f", GAINVALUES[this->gain_uv_]);
-  ESP_LOGCONFIG(TAG, "  UV Resolution: %u-bit", RESOLUTION_BITS[this->res_uv_]);
+  ESP_LOGCONFIG(TAG,
+                "  ALS Gain: X%.0f\n"
+                "  ALS Resolution: %u-bit\n"
+                "  UV Gain: X%.0f\n"
+                "  UV Resolution: %u-bit",
+                GAINVALUES[this->gain_als_], RESOLUTION_BITS[this->res_als_], GAINVALUES[this->gain_uv_],
+                RESOLUTION_BITS[this->res_uv_]);
 }
 
 void LTR390Component::update() {

esphome/components/ltr501/ltr501.cpp

@@ -1,7 +1,7 @@
 #include "ltr501.h"
 #include "esphome/core/application.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 using esphome::i2c::ErrorCode;
 
@@ -74,7 +74,7 @@ static float get_ps_gain_coeff(PsGain501 gain) {
 }
 
 void LTRAlsPs501Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up LTR-501/301/558");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // As per datasheet we need to wait at least 100ms after power on to get ALS chip responsive
   this->set_timeout(100, [this]() { this->state_ = State::DELAYED_SETUP; });
 }
@@ -94,16 +94,21 @@ void LTRAlsPs501Component::dump_config() {
   };
 
   LOG_I2C_DEVICE(this);
-  ESP_LOGCONFIG(TAG, "  Device type: %s", get_device_type(this->ltr_type_));
-  ESP_LOGCONFIG(TAG, "  Automatic mode: %s", ONOFF(this->automatic_mode_enabled_));
-  ESP_LOGCONFIG(TAG, "  Gain: %.0fx", get_gain_coeff(this->gain_));
-  ESP_LOGCONFIG(TAG, "  Integration time: %d ms", get_itime_ms(this->integration_time_));
-  ESP_LOGCONFIG(TAG, "  Measurement repeat rate: %d ms", get_meas_time_ms(this->repeat_rate_));
-  ESP_LOGCONFIG(TAG, "  Glass attenuation factor: %f", this->glass_attenuation_factor_);
-  ESP_LOGCONFIG(TAG, "  Proximity gain: %.0fx", get_ps_gain_coeff(this->ps_gain_));
-  ESP_LOGCONFIG(TAG, "  Proximity cooldown time: %d s", this->ps_cooldown_time_s_);
-  ESP_LOGCONFIG(TAG, "  Proximity high threshold: %d", this->ps_threshold_high_);
-  ESP_LOGCONFIG(TAG, "  Proximity low threshold: %d", this->ps_threshold_low_);
+  ESP_LOGCONFIG(TAG,
+                "  Device type: %s\n"
+                "  Automatic mode: %s\n"
+                "  Gain: %.0fx\n"
+                "  Integration time: %d ms\n"
+                "  Measurement repeat rate: %d ms\n"
+                "  Glass attenuation factor: %f\n"
+                "  Proximity gain: %.0fx\n"
+                "  Proximity cooldown time: %d s\n"
+                "  Proximity high threshold: %d\n"
+                "  Proximity low threshold: %d",
+                get_device_type(this->ltr_type_), ONOFF(this->automatic_mode_enabled_), get_gain_coeff(this->gain_),
+                get_itime_ms(this->integration_time_), get_meas_time_ms(this->repeat_rate_),
+                this->glass_attenuation_factor_, get_ps_gain_coeff(this->ps_gain_), this->ps_cooldown_time_s_,
+                this->ps_threshold_high_, this->ps_threshold_low_);
 
   LOG_UPDATE_INTERVAL(this);
 
@@ -113,7 +118,7 @@ void LTRAlsPs501Component::dump_config() {
   LOG_SENSOR("  ", "Actual gain", this->actual_gain_sensor_);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with I2C LTR-501/301/558 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 
@@ -306,7 +311,7 @@ void LTRAlsPs501Component::configure_als_() {
 
   uint8_t tries = MAX_TRIES;
   do {
-    ESP_LOGV(TAG, "Waiting for ALS device to become active...");
+    ESP_LOGV(TAG, "Waiting for ALS device to become active");
     delay(2);
     als_ctrl.raw = this->reg((uint8_t) CommandRegisters::ALS_CONTR).get();
   } while (!als_ctrl.als_mode_active && tries--);  // while active mode is not set - keep waiting