esphome 2025.6.2__py3-none-any.whl → 2025.7.0b1__py3-none-any.whl

esphome/components/logger/__init__.py

@@ -16,7 +16,12 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32S3,
 )
 from esphome.components.libretiny import get_libretiny_component, get_libretiny_family
-from esphome.components.libretiny.const import COMPONENT_BK72XX, COMPONENT_RTL87XX
+from esphome.components.libretiny.const import (
+    COMPONENT_BK72XX,
+    COMPONENT_LN882X,
+    COMPONENT_RTL87XX,
+)
+from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ARGS,
@@ -35,8 +40,10 @@ from esphome.const import (
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
+    PLATFORM_LN882X,
     PLATFORM_RP2040,
     PLATFORM_RTL87XX,
+    PlatformFramework,
 )
 from esphome.core import CORE, Lambda, coroutine_with_priority
 
@@ -100,6 +107,7 @@ UART_SELECTION_ESP8266 = [UART0, UART0_SWAP, UART1]
 
 UART_SELECTION_LIBRETINY = {
     COMPONENT_BK72XX: [DEFAULT, UART1, UART2],
+    COMPONENT_LN882X: [DEFAULT, UART0, UART1, UART2],
     COMPONENT_RTL87XX: [DEFAULT, UART0, UART1, UART2],
 }
 
@@ -184,7 +192,9 @@ CONFIG_SCHEMA = cv.All(
         {
             cv.GenerateID(): cv.declare_id(Logger),
             cv.Optional(CONF_BAUD_RATE, default=115200): cv.positive_int,
-            cv.Optional(CONF_TX_BUFFER_SIZE, default=512): cv.validate_bytes,
+            cv.Optional(CONF_TX_BUFFER_SIZE, default=512): cv.All(
+                cv.validate_bytes, cv.int_range(min=160, max=65535)
+            ),
             cv.Optional(CONF_DEASSERT_RTS_DTR, default=False): cv.boolean,
             cv.SplitDefault(
                 CONF_TASK_LOG_BUFFER_SIZE,
@@ -215,6 +225,7 @@ CONFIG_SCHEMA = cv.All(
                 esp32_p4_idf=USB_SERIAL_JTAG,
                 rp2040=USB_CDC,
                 bk72xx=DEFAULT,
+                ln882x=DEFAULT,
                 rtl87xx=DEFAULT,
             ): cv.All(
                 cv.only_on(
@@ -223,6 +234,7 @@ CONFIG_SCHEMA = cv.All(
                         PLATFORM_ESP32,
                         PLATFORM_RP2040,
                         PLATFORM_BK72XX,
+                        PLATFORM_LN882X,
                         PLATFORM_RTL87XX,
                     ]
                 ),
@@ -324,7 +336,10 @@ async def to_code(config):
     if CORE.using_arduino:
         if config[CONF_HARDWARE_UART] == USB_CDC:
             cg.add_build_flag("-DARDUINO_USB_CDC_ON_BOOT=1")
-            if CORE.is_esp32 and get_esp32_variant() == VARIANT_ESP32C3:
+            if CORE.is_esp32 and get_esp32_variant() in (
+                VARIANT_ESP32C3,
+                VARIANT_ESP32C6,
+            ):
                 cg.add_build_flag("-DARDUINO_USB_MODE=1")
 
     if CORE.using_esp_idf:
@@ -431,3 +446,25 @@ async def logger_set_level_to_code(config, action_id, template_arg, args):
 
     lambda_ = await cg.process_lambda(Lambda(text), args, return_type=cg.void)
     return cg.new_Pvariable(action_id, template_arg, lambda_)
+
+
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "logger_esp32.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
+        },
+        "logger_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
+        "logger_host.cpp": {PlatformFramework.HOST_NATIVE},
+        "logger_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},
+        "logger_libretiny.cpp": {
+            PlatformFramework.BK72XX_ARDUINO,
+            PlatformFramework.RTL87XX_ARDUINO,
+            PlatformFramework.LN882X_ARDUINO,
+        },
+        "task_log_buffer.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
+        },
+    }
+)

esphome/components/logger/logger.cpp

@@ -24,7 +24,7 @@ static const char *const TAG = "logger";
 //    - Messages are serialized through main loop for proper console output
 //    - Fallback to emergency console logging only if ring buffer is full
 //  - WITHOUT task log buffer: Only emergency console output, no callbacks
-void HOT Logger::log_vprintf_(int level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
+void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
   if (level > this->level_for(tag))
     return;
 
@@ -46,8 +46,13 @@ void HOT Logger::log_vprintf_(int level, const char *tag, int line, const char *
   bool message_sent = false;
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   // For non-main tasks, queue the message for callbacks - but only if we have any callbacks registered
-  message_sent = this->log_buffer_->send_message_thread_safe(static_cast<uint8_t>(level), tag,
-                                                             static_cast<uint16_t>(line), current_task, format, args);
+  message_sent =
+      this->log_buffer_->send_message_thread_safe(level, tag, static_cast<uint16_t>(line), current_task, format, args);
+  if (message_sent) {
+    // Enable logger loop to process the buffered message
+    // This is safe to call from any context including ISRs
+    this->enable_loop_soon_any_context();
+  }
 #endif  // USE_ESPHOME_TASK_LOG_BUFFER
 
   // Emergency console logging for non-main tasks when ring buffer is full or disabled
@@ -58,7 +63,7 @@ void HOT Logger::log_vprintf_(int level, const char *tag, int line, const char *
     // Maximum size for console log messages (includes null terminator)
     static const size_t MAX_CONSOLE_LOG_MSG_SIZE = 144;
     char console_buffer[MAX_CONSOLE_LOG_MSG_SIZE];  // MUST be stack allocated for thread safety
-    int buffer_at = 0;                              // Initialize buffer position
+    uint16_t buffer_at = 0;                         // Initialize buffer position
     this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, console_buffer, &buffer_at,
                                                 MAX_CONSOLE_LOG_MSG_SIZE);
     this->write_msg_(console_buffer);
@@ -69,7 +74,7 @@ void HOT Logger::log_vprintf_(int level, const char *tag, int line, const char *
 }
 #else
 // Implementation for all other platforms
-void HOT Logger::log_vprintf_(int level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
+void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
@@ -85,7 +90,26 @@ void HOT Logger::log_vprintf_(int level, const char *tag, int line, const char *
 #ifdef USE_STORE_LOG_STR_IN_FLASH
 // Implementation for ESP8266 with flash string support.
 // Note: USE_STORE_LOG_STR_IN_FLASH is only defined for ESP8266.
-void Logger::log_vprintf_(int level, const char *tag, int line, const __FlashStringHelper *format,
+//
+// This function handles format strings stored in flash memory (PROGMEM) to save RAM.
+// The buffer is used in a special way to avoid allocating extra memory:
+//
+// Memory layout during execution:
+// Step 1: Copy format string from flash to buffer
+//         tx_buffer_: [format_string][null][.....................]
+//         tx_buffer_at_: ------------------^
+//         msg_start: saved here -----------^
+//
+// Step 2: format_log_to_buffer_with_terminator_ reads format string from beginning
+//         and writes formatted output starting at msg_start position
+//         tx_buffer_: [format_string][null][formatted_message][null]
+//         tx_buffer_at_: -------------------------------------^
+//
+// Step 3: Output the formatted message (starting at msg_start)
+//         write_msg_ and callbacks receive: this->tx_buffer_ + msg_start
+//         which points to: [formatted_message][null]
+//
+void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __FlashStringHelper *format,
                           va_list args) {  // NOLINT
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
@@ -116,13 +140,15 @@ void Logger::log_vprintf_(int level, const char *tag, int line, const __FlashStr
   if (this->baud_rate_ > 0) {
     this->write_msg_(this->tx_buffer_ + msg_start);
   }
-  this->log_callback_.call(level, tag, this->tx_buffer_ + msg_start);
+  size_t msg_length =
+      this->tx_buffer_at_ - msg_start;  // Don't subtract 1 - tx_buffer_at_ is already at the null terminator position
+  this->log_callback_.call(level, tag, this->tx_buffer_ + msg_start, msg_length);
 
   global_recursion_guard_ = false;
 }
 #endif  // USE_STORE_LOG_STR_IN_FLASH
 
-inline int Logger::level_for(const char *tag) {
+inline uint8_t Logger::level_for(const char *tag) {
   auto it = this->log_levels_.find(tag);
   if (it != this->log_levels_.end())
     return it->second;
@@ -139,6 +165,10 @@ Logger::Logger(uint32_t baud_rate, size_t tx_buffer_size) : baud_rate_(baud_rate
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
 void Logger::init_log_buffer(size_t total_buffer_size) {
   this->log_buffer_ = esphome::make_unique<logger::TaskLogBuffer>(total_buffer_size);
+
+  // Start with loop disabled when using task buffer (unless using USB CDC)
+  // The loop will be enabled automatically when messages arrive
+  this->disable_loop_when_buffer_empty_();
 }
 #endif
 
@@ -176,7 +206,8 @@ void Logger::loop() {
                                   this->tx_buffer_size_);
       this->write_footer_to_buffer_(this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
       this->tx_buffer_[this->tx_buffer_at_] = '\0';
-      this->log_callback_.call(message->level, message->tag, this->tx_buffer_);
+      size_t msg_len = this->tx_buffer_at_;  // We already know the length from tx_buffer_at_
+      this->log_callback_.call(message->level, message->tag, this->tx_buffer_, msg_len);
       // At this point all the data we need from message has been transferred to the tx_buffer
       // so we can release the message to allow other tasks to use it as soon as possible.
       this->log_buffer_->release_message_main_loop(received_token);
@@ -189,19 +220,23 @@ void Logger::loop() {
         this->write_msg_(this->tx_buffer_);
       }
     }
+  } else {
+    // No messages to process, disable loop if appropriate
+    // This reduces overhead when there's no async logging activity
+    this->disable_loop_when_buffer_empty_();
   }
 #endif
 }
 #endif
 
 void Logger::set_baud_rate(uint32_t baud_rate) { this->baud_rate_ = baud_rate; }
-void Logger::set_log_level(const std::string &tag, int log_level) { this->log_levels_[tag] = log_level; }
+void Logger::set_log_level(const std::string &tag, uint8_t log_level) { this->log_levels_[tag] = log_level; }
 
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY)
 UARTSelection Logger::get_uart() const { return this->uart_; }
 #endif
 
-void Logger::add_on_log_callback(std::function<void(int, const char *, const char *)> &&callback) {
+void Logger::add_on_log_callback(std::function<void(uint8_t, const char *, const char *, size_t)> &&callback) {
   this->log_callback_.add(std::move(callback));
 }
 float Logger::get_setup_priority() const { return setup_priority::BUS + 500.0f; }
@@ -230,7 +265,7 @@ void Logger::dump_config() {
   }
 }
 
-void Logger::set_log_level(int level) {
+void Logger::set_log_level(uint8_t level) {
   if (level > ESPHOME_LOG_LEVEL) {
     level = ESPHOME_LOG_LEVEL;
     ESP_LOGW(TAG, "Cannot set log level higher than pre-compiled %s", LOG_LEVELS[ESPHOME_LOG_LEVEL]);

esphome/components/logger/logger.h

@@ -61,7 +61,7 @@ static const char *const LOG_LEVEL_LETTERS[] = {
  *
  * Advanced configuration (pin selection, etc) is not supported.
  */
-enum UARTSelection {
+enum UARTSelection : uint8_t {
 #ifdef USE_LIBRETINY
   UART_SELECTION_DEFAULT = 0,
   UART_SELECTION_UART0,
@@ -129,10 +129,10 @@ class Logger : public Component {
 #endif
 
   /// Set the default log level for this logger.
-  void set_log_level(int level);
+  void set_log_level(uint8_t level);
   /// Set the log level of the specified tag.
-  void set_log_level(const std::string &tag, int log_level);
-  int get_log_level() { return this->current_level_; }
+  void set_log_level(const std::string &tag, uint8_t log_level);
+  uint8_t get_log_level() { return this->current_level_; }
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
@@ -140,19 +140,20 @@ class Logger : public Component {
   void pre_setup();
   void dump_config() override;
 
-  inline int level_for(const char *tag);
+  inline uint8_t level_for(const char *tag);
 
   /// Register a callback that will be called for every log message sent
-  void add_on_log_callback(std::function<void(int, const char *, const char *)> &&callback);
+  void add_on_log_callback(std::function<void(uint8_t, const char *, const char *, size_t)> &&callback);
 
   // add a listener for log level changes
-  void add_listener(std::function<void(int)> &&callback) { this->level_callback_.add(std::move(callback)); }
+  void add_listener(std::function<void(uint8_t)> &&callback) { this->level_callback_.add(std::move(callback)); }
 
   float get_setup_priority() const override;
 
-  void log_vprintf_(int level, const char *tag, int line, const char *format, va_list args);  // NOLINT
+  void log_vprintf_(uint8_t level, const char *tag, int line, const char *format, va_list args);  // NOLINT
 #ifdef USE_STORE_LOG_STR_IN_FLASH
-  void log_vprintf_(int level, const char *tag, int line, const __FlashStringHelper *format, va_list args);  // NOLINT
+  void log_vprintf_(uint8_t level, const char *tag, int line, const __FlashStringHelper *format,
+                    va_list args);  // NOLINT
 #endif
 
  protected:
@@ -160,8 +161,9 @@ class Logger : public Component {
 
   // Format a log message with printf-style arguments and write it to a buffer with header, footer, and null terminator
   // It's the caller's responsibility to initialize buffer_at (typically to 0)
-  inline void HOT format_log_to_buffer_with_terminator_(int level, const char *tag, int line, const char *format,
-                                                        va_list args, char *buffer, int *buffer_at, int buffer_size) {
+  inline void HOT format_log_to_buffer_with_terminator_(uint8_t level, const char *tag, int line, const char *format,
+                                                        va_list args, char *buffer, uint16_t *buffer_at,
+                                                        uint16_t buffer_size) {
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
     this->write_header_to_buffer_(level, tag, line, this->get_thread_name_(), buffer, buffer_at, buffer_size);
 #else
@@ -180,7 +182,7 @@ class Logger : public Component {
   }
 
   // Helper to format and send a log message to both console and callbacks
-  inline void HOT log_message_to_buffer_and_send_(int level, const char *tag, int line, const char *format,
+  inline void HOT log_message_to_buffer_and_send_(uint8_t level, const char *tag, int line, const char *format,
                                                   va_list args) {
     // Format to tx_buffer and prepare for output
     this->tx_buffer_at_ = 0;  // Initialize buffer position
@@ -190,15 +192,16 @@ class Logger : public Component {
     if (this->baud_rate_ > 0) {
       this->write_msg_(this->tx_buffer_);  // If logging is enabled, write to console
     }
-    this->log_callback_.call(level, tag, this->tx_buffer_);
+    this->log_callback_.call(level, tag, this->tx_buffer_, this->tx_buffer_at_);
   }
 
   // Write the body of the log message to the buffer
-  inline void write_body_to_buffer_(const char *value, size_t length, char *buffer, int *buffer_at, int buffer_size) {
+  inline void write_body_to_buffer_(const char *value, size_t length, char *buffer, uint16_t *buffer_at,
+                                    uint16_t buffer_size) {
     // Calculate available space
-    const int available = buffer_size - *buffer_at;
-    if (available <= 0)
+    if (*buffer_at >= buffer_size)
       return;
+    const uint16_t available = buffer_size - *buffer_at;
 
     // Determine copy length (minimum of remaining capacity and string length)
     const size_t copy_len = (length < static_cast<size_t>(available)) ? length : available;
@@ -211,7 +214,7 @@ class Logger : public Component {
   }
 
   // Format string to explicit buffer with varargs
-  inline void printf_to_buffer_(char *buffer, int *buffer_at, int buffer_size, const char *format, ...) {
+  inline void printf_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size, const char *format, ...) {
     va_list arg;
     va_start(arg, format);
     this->format_body_to_buffer_(buffer, buffer_at, buffer_size, format, arg);
@@ -222,41 +225,50 @@ class Logger : public Component {
   const char *get_uart_selection_();
 #endif
 
+  // Group 4-byte aligned members first
   uint32_t baud_rate_;
   char *tx_buffer_{nullptr};
-  int tx_buffer_at_{0};
-  int tx_buffer_size_{0};
-#if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040)
-  UARTSelection uart_{UART_SELECTION_UART0};
-#endif
-#ifdef USE_LIBRETINY
-  UARTSelection uart_{UART_SELECTION_DEFAULT};
-#endif
 #ifdef USE_ARDUINO
   Stream *hw_serial_{nullptr};
 #endif
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
+  void *main_task_ = nullptr;  // Only used for thread name identification
+#endif
+#ifdef USE_ESP32
+  // Task-specific recursion guards:
+  // - Main task uses a dedicated member variable for efficiency
+  // - Other tasks use pthread TLS with a dynamically created key via pthread_key_create
+  pthread_key_t log_recursion_key_;  // 4 bytes
+#endif
 #ifdef USE_ESP_IDF
-  uart_port_t uart_num_;
+  uart_port_t uart_num_;  // 4 bytes (enum defaults to int size)
 #endif
-  std::map<std::string, int> log_levels_{};
-  CallbackManager<void(int, const char *, const char *)> log_callback_{};
-  int current_level_{ESPHOME_LOG_LEVEL_VERY_VERBOSE};
+
+  // Large objects (internally aligned)
+  std::map<std::string, uint8_t> log_levels_{};
+  CallbackManager<void(uint8_t, const char *, const char *, size_t)> log_callback_{};
+  CallbackManager<void(uint8_t)> level_callback_{};
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   std::unique_ptr<logger::TaskLogBuffer> log_buffer_;  // Will be initialized with init_log_buffer
 #endif
+
+  // Group smaller types together at the end
+  uint16_t tx_buffer_at_{0};
+  uint16_t tx_buffer_size_{0};
+  uint8_t current_level_{ESPHOME_LOG_LEVEL_VERY_VERBOSE};
+#if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040)
+  UARTSelection uart_{UART_SELECTION_UART0};
+#endif
+#ifdef USE_LIBRETINY
+  UARTSelection uart_{UART_SELECTION_DEFAULT};
+#endif
 #ifdef USE_ESP32
-  // Task-specific recursion guards:
-  // - Main task uses a dedicated member variable for efficiency
-  // - Other tasks use pthread TLS with a dynamically created key via pthread_key_create
   bool main_task_recursion_guard_{false};
-  pthread_key_t log_recursion_key_;
 #else
   bool global_recursion_guard_{false};  // Simple global recursion guard for single-task platforms
 #endif
-  CallbackManager<void(int)> level_callback_{};
 
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
-  void *main_task_ = nullptr;  // Only used for thread name identification
   const char *HOT get_thread_name_() {
     TaskHandle_t current_task = xTaskGetCurrentTaskHandle();
     if (current_task == main_task_) {
@@ -297,11 +309,10 @@ class Logger : public Component {
   }
 #endif
 
-  inline void HOT write_header_to_buffer_(int level, const char *tag, int line, const char *thread_name, char *buffer,
-                                          int *buffer_at, int buffer_size) {
+  inline void HOT write_header_to_buffer_(uint8_t level, const char *tag, int line, const char *thread_name,
+                                          char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
     // Format header
-    if (level < 0)
-      level = 0;
+    // uint8_t level is already bounded 0-255, just ensure it's <= 7
     if (level > 7)
       level = 7;
 
@@ -320,12 +331,12 @@ class Logger : public Component {
     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,
+  inline void HOT format_body_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size, const char *format,
                                          va_list args) {
     // Get remaining capacity in the buffer
-    const int remaining = buffer_size - *buffer_at;
-    if (remaining <= 0)
+    if (*buffer_at >= buffer_size)
       return;
+    const uint16_t remaining = buffer_size - *buffer_at;
 
     const int ret = vsnprintf(buffer + *buffer_at, remaining, format, args);
 
@@ -334,7 +345,7 @@ class Logger : public Component {
     }
 
     // Update buffer_at with the formatted length (handle truncation)
-    int formatted_len = (ret >= remaining) ? remaining : ret;
+    uint16_t formatted_len = (ret >= remaining) ? remaining : ret;
     *buffer_at += formatted_len;
 
     // Remove all trailing newlines right after formatting
@@ -343,18 +354,38 @@ class Logger : public Component {
     }
   }
 
-  inline void HOT write_footer_to_buffer_(char *buffer, int *buffer_at, int buffer_size) {
-    static const int RESET_COLOR_LEN = strlen(ESPHOME_LOG_RESET_COLOR);
+  inline void HOT write_footer_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
+    static constexpr uint16_t RESET_COLOR_LEN = sizeof(ESPHOME_LOG_RESET_COLOR) - 1;
     this->write_body_to_buffer_(ESPHOME_LOG_RESET_COLOR, RESET_COLOR_LEN, buffer, buffer_at, buffer_size);
   }
+
+#ifdef USE_ESP32
+  // Disable loop when task buffer is empty (with USB CDC check)
+  inline void disable_loop_when_buffer_empty_() {
+    // Thread safety note: This is safe even if another task calls enable_loop_soon_any_context()
+    // concurrently. If that happens between our check and disable_loop(), the enable request
+    // will be processed on the next main loop iteration since:
+    // - disable_loop() takes effect immediately
+    // - enable_loop_soon_any_context() sets a pending flag that's checked at loop start
+#if defined(USE_LOGGER_USB_CDC) && defined(USE_ARDUINO)
+    // Only disable if not using USB CDC (which needs loop for connection detection)
+    if (this->uart_ != UART_SELECTION_USB_CDC) {
+      this->disable_loop();
+    }
+#else
+    // No USB CDC support, always safe to disable
+    this->disable_loop();
+#endif
+  }
+#endif
 };
 extern Logger *global_logger;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-class LoggerMessageTrigger : public Trigger<int, const char *, const char *> {
+class LoggerMessageTrigger : public Trigger<uint8_t, const char *, const char *> {
  public:
-  explicit LoggerMessageTrigger(Logger *parent, int level) {
+  explicit LoggerMessageTrigger(Logger *parent, uint8_t level) {
     this->level_ = level;
-    parent->add_on_log_callback([this](int level, const char *tag, const char *message) {
+    parent->add_on_log_callback([this](uint8_t level, const char *tag, const char *message, size_t message_len) {
       if (level <= this->level_) {
         this->trigger(level, tag, message);
       }
@@ -362,7 +393,7 @@ class LoggerMessageTrigger : public Trigger<int, const char *, const char *> {
   }
 
  protected:
-  int level_;
+  uint8_t level_;
 };
 
 }  // namespace logger

esphome/components/logger/logger_esp32.cpp

@@ -83,9 +83,7 @@ void init_uart(uart_port_t uart_num, uint32_t baud_rate, int tx_buffer_size) {
   uart_config.parity = UART_PARITY_DISABLE;
   uart_config.stop_bits = UART_STOP_BITS_1;
   uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
   uart_config.source_clk = UART_SCLK_DEFAULT;
-#endif
   uart_param_config(uart_num, &uart_config);
   const int uart_buffer_size = tx_buffer_size;
   // Install UART driver using an event queue here
@@ -186,7 +184,9 @@ void HOT Logger::write_msg_(const char *msg) {
   ) {
     puts(msg);
   } else {
-    uart_write_bytes(this->uart_num_, msg, strlen(msg));
+    // Use tx_buffer_at_ if msg points to tx_buffer_, otherwise fall back to strlen
+    size_t len = (msg == this->tx_buffer_) ? this->tx_buffer_at_ : strlen(msg);
+    uart_write_bytes(this->uart_num_, msg, len);
     uart_write_bytes(this->uart_num_, "\n", 1);
   }
 }

esphome/components/lps22/lps22.cpp

@@ -0,0 +1,75 @@
+#include "lps22.h"
+
+namespace esphome {
+namespace lps22 {
+
+static constexpr const char *const TAG = "lps22";
+
+static constexpr uint8_t WHO_AM_I = 0x0F;
+static constexpr uint8_t LPS22HB_ID = 0xB1;
+static constexpr uint8_t LPS22HH_ID = 0xB3;
+static constexpr uint8_t CTRL_REG2 = 0x11;
+static constexpr uint8_t CTRL_REG2_ONE_SHOT_MASK = 0b1;
+static constexpr uint8_t STATUS = 0x27;
+static constexpr uint8_t STATUS_T_DA_MASK = 0b10;
+static constexpr uint8_t STATUS_P_DA_MASK = 0b01;
+static constexpr uint8_t TEMP_L = 0x2b;
+static constexpr uint8_t PRES_OUT_XL = 0x28;
+static constexpr uint8_t REF_P_XL = 0x28;
+static constexpr uint8_t READ_ATTEMPTS = 10;
+static constexpr uint8_t READ_INTERVAL = 5;
+static constexpr float PRESSURE_SCALE = 1.0f / 4096.0f;
+static constexpr float TEMPERATURE_SCALE = 0.01f;
+
+void LPS22Component::setup() {
+  uint8_t value = 0x00;
+  this->read_register(WHO_AM_I, &value, 1);
+  if (value != LPS22HB_ID && value != LPS22HH_ID) {
+    ESP_LOGW(TAG, "device IDs as %02x, which isn't a known LPS22HB or LPS22HH ID", value);
+    this->mark_failed();
+  }
+}
+
+void LPS22Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "LPS22:");
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
+  LOG_I2C_DEVICE(this);
+  LOG_UPDATE_INTERVAL(this);
+}
+
+void LPS22Component::update() {
+  uint8_t value = 0x00;
+  this->read_register(CTRL_REG2, &value, 1);
+  value |= CTRL_REG2_ONE_SHOT_MASK;
+  this->write_register(CTRL_REG2, &value, 1);
+  this->set_retry(READ_INTERVAL, READ_ATTEMPTS, [this](uint8_t _) { return this->try_read_(); });
+}
+
+RetryResult LPS22Component::try_read_() {
+  uint8_t value = 0x00;
+  this->read_register(STATUS, &value, 1);
+  const uint8_t expected_status_mask = STATUS_T_DA_MASK | STATUS_P_DA_MASK;
+  if ((value & expected_status_mask) != expected_status_mask) {
+    ESP_LOGD(TAG, "STATUS not ready: %x", value);
+    return RetryResult::RETRY;
+  }
+
+  if (this->temperature_sensor_ != nullptr) {
+    uint8_t t_buf[2]{0};
+    this->read_register(TEMP_L, t_buf, 2);
+    int16_t encoded = static_cast<int16_t>(encode_uint16(t_buf[1], t_buf[0]));
+    float temp = TEMPERATURE_SCALE * static_cast<float>(encoded);
+    this->temperature_sensor_->publish_state(temp);
+  }
+  if (this->pressure_sensor_ != nullptr) {
+    uint8_t p_buf[3]{0};
+    this->read_register(PRES_OUT_XL, p_buf, 3);
+    uint32_t p_lsb = encode_uint24(p_buf[2], p_buf[1], p_buf[0]);
+    this->pressure_sensor_->publish_state(PRESSURE_SCALE * static_cast<float>(p_lsb));
+  }
+  return RetryResult::DONE;
+}
+
+}  // namespace lps22
+}  // namespace esphome

esphome/components/lps22/lps22.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace lps22 {
+
+class LPS22Component : public sensor::Sensor, public PollingComponent, public i2c::I2CDevice {
+ public:
+  void set_temperature_sensor(sensor::Sensor *temperature_sensor) { this->temperature_sensor_ = temperature_sensor; }
+  void set_pressure_sensor(sensor::Sensor *pressure_sensor) { this->pressure_sensor_ = pressure_sensor; }
+
+  void setup() override;
+  void update() override;
+  void dump_config() override;
+
+ protected:
+  sensor::Sensor *temperature_sensor_{nullptr};
+  sensor::Sensor *pressure_sensor_{nullptr};
+
+  RetryResult try_read_();
+};
+
+}  // namespace lps22
+}  // namespace esphome