esphome 2025.4.2__py3-none-any.whl → 2025.5.0__py3-none-any.whl

esphome/components/logger/logger.h

@@ -2,12 +2,19 @@
 
 #include <cstdarg>
 #include <map>
+#ifdef USE_ESP32
+#include <pthread.h>
+#endif
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+#include "task_log_buffer.h"
+#endif
+
 #ifdef USE_ARDUINO
 #if defined(USE_ESP8266) || defined(USE_ESP32)
 #include <HardwareSerial.h>
@@ -26,6 +33,29 @@ namespace esphome {
 
 namespace logger {
 
+// Color and letter constants for log levels
+static const char *const LOG_LEVEL_COLORS[] = {
+    "",                                            // NONE
+    ESPHOME_LOG_BOLD(ESPHOME_LOG_COLOR_RED),       // ERROR
+    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_YELLOW),   // WARNING
+    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_GREEN),    // INFO
+    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_MAGENTA),  // CONFIG
+    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_CYAN),     // DEBUG
+    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_GRAY),     // VERBOSE
+    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_WHITE),    // VERY_VERBOSE
+};
+
+static const char *const LOG_LEVEL_LETTERS[] = {
+    "",    // NONE
+    "E",   // ERROR
+    "W",   // WARNING
+    "I",   // INFO
+    "C",   // CONFIG
+    "D",   // DEBUG
+    "V",   // VERBOSE
+    "VV",  // VERY_VERBOSE
+};
+
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY)
 /** Enum for logging UART selection
  *
@@ -54,10 +84,30 @@ enum UARTSelection {
 };
 #endif  // USE_ESP32 || USE_ESP8266 || USE_RP2040 || USE_LIBRETINY
 
+/**
+ * @brief Logger component for all ESPHome logging.
+ *
+ * This class implements a multi-platform logging system with protection against recursion.
+ *
+ * Recursion Protection Strategy:
+ * - On ESP32: Uses task-specific recursion guards
+ *   * Main task: Uses a dedicated boolean member variable for efficiency
+ *   * Other tasks: Uses pthread TLS with a dynamically allocated key for task-specific state
+ * - On other platforms: Uses a simple global recursion guard
+ *
+ * We use pthread TLS via pthread_key_create to create a unique key for storing
+ * task-specific recursion state, which:
+ * 1. Efficiently handles multiple tasks without locks or mutexes
+ * 2. Works with ESP-IDF's pthread implementation that uses a linked list for TLS variables
+ * 3. Avoids the limitations of the fixed FreeRTOS task local storage slots
+ */
 class Logger : public Component {
  public:
   explicit Logger(uint32_t baud_rate, size_t tx_buffer_size);
-#ifdef USE_LOGGER_USB_CDC
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+  void init_log_buffer(size_t total_buffer_size);
+#endif
+#if defined(USE_LOGGER_USB_CDC) || defined(USE_ESP32)
   void loop() override;
 #endif
   /// Manually set the baud rate for serial, set to 0 to disable.
@@ -69,6 +119,9 @@ class Logger : public Component {
 #ifdef USE_ESP_IDF
   uart_port_t get_uart_num() const { return uart_num_; }
 #endif
+#ifdef USE_ESP32
+  void create_pthread_key() { pthread_key_create(&log_recursion_key_, nullptr); }
+#endif
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY)
   void set_uart_selection(UARTSelection uart_selection) { uart_ = uart_selection; }
   /// Get the UART used by the logger.
@@ -87,7 +140,7 @@ class Logger : public Component {
   void pre_setup();
   void dump_config() override;
 
-  int level_for(const char *tag);
+  inline int 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);
@@ -103,46 +156,66 @@ class Logger : public Component {
 #endif
 
  protected:
-  void write_header_(int level, const char *tag, int line);
-  void write_footer_();
-  void log_message_(int level, const char *tag, int offset = 0);
+  void call_log_callbacks_(int level, const char *tag, const char *msg);
   void write_msg_(const char *msg);
 
-  inline bool is_buffer_full_() const { return this->tx_buffer_at_ >= this->tx_buffer_size_; }
-  inline int buffer_remaining_capacity_() const { return this->tx_buffer_size_ - this->tx_buffer_at_; }
-  inline void reset_buffer_() { this->tx_buffer_at_ = 0; }
-  inline void set_null_terminator_() {
-    // does not increment buffer_at
-    this->tx_buffer_[this->tx_buffer_at_] = '\0';
-  }
-  inline void write_to_buffer_(char value) {
-    if (!this->is_buffer_full_())
-      this->tx_buffer_[this->tx_buffer_at_++] = value;
+  // 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) {
+#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
+    this->write_header_to_buffer_(level, tag, line, nullptr, buffer, buffer_at, buffer_size);
+#endif
+    this->format_body_to_buffer_(buffer, buffer_at, buffer_size, format, args);
+    this->write_footer_to_buffer_(buffer, buffer_at, buffer_size);
+
+    // Always ensure the buffer has a null terminator, even if we need to
+    // overwrite the last character of the actual content
+    if (*buffer_at >= buffer_size) {
+      buffer[buffer_size - 1] = '\0';  // Truncate and ensure null termination
+    } else {
+      buffer[*buffer_at] = '\0';  // Normal case, append null terminator
+    }
   }
-  inline void write_to_buffer_(const char *value, int length) {
-    for (int i = 0; i < length && !this->is_buffer_full_(); i++) {
-      this->tx_buffer_[this->tx_buffer_at_++] = value[i];
+
+  // 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,
+                                                  va_list args) {
+    // Format to tx_buffer and prepare for output
+    this->tx_buffer_at_ = 0;  // Initialize buffer position
+    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, this->tx_buffer_, &this->tx_buffer_at_,
+                                                this->tx_buffer_size_);
+
+    if (this->baud_rate_ > 0) {
+      this->write_msg_(this->tx_buffer_);  // If logging is enabled, write to console
     }
+    this->call_log_callbacks_(level, tag, this->tx_buffer_);
   }
-  inline void vprintf_to_buffer_(const char *format, va_list args) {
-    if (this->is_buffer_full_())
-      return;
-    int remaining = this->buffer_remaining_capacity_();
-    int ret = vsnprintf(this->tx_buffer_ + this->tx_buffer_at_, remaining, format, args);
-    if (ret < 0) {
-      // Encoding error, do not increment 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) {
+    // Calculate available space
+    const int available = buffer_size - *buffer_at;
+    if (available <= 0)
       return;
+
+    // Determine copy length (minimum of remaining capacity and string length)
+    const size_t copy_len = (length < static_cast<size_t>(available)) ? length : available;
+
+    // Copy the data
+    if (copy_len > 0) {
+      memcpy(buffer + *buffer_at, value, copy_len);
+      *buffer_at += copy_len;
     }
-    if (ret >= remaining) {
-      // output was too long, truncated
-      ret = remaining;
-    }
-    this->tx_buffer_at_ += ret;
   }
-  inline void printf_to_buffer_(const char *format, ...) {
+
+  // Format string to explicit buffer with varargs
+  inline void printf_to_buffer_(const char *format, char *buffer, int *buffer_at, int buffer_size, ...) {
     va_list arg;
-    va_start(arg, format);
-    this->vprintf_to_buffer_(format, arg);
+    va_start(arg, buffer_size);
+    this->format_body_to_buffer_(buffer, buffer_at, buffer_size, format, arg);
     va_end(arg);
   }
 
@@ -169,10 +242,112 @@ class Logger : public Component {
   std::map<std::string, int> log_levels_{};
   CallbackManager<void(int, const char *, const char *)> log_callback_{};
   int current_level_{ESPHOME_LOG_LEVEL_VERY_VERBOSE};
-  /// Prevents recursive log calls, if true a log message is already being processed.
-  bool recursion_guard_ = false;
-  void *main_task_ = nullptr;
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+  std::unique_ptr<logger::TaskLogBuffer> log_buffer_;  // Will be initialized with init_log_buffer
+#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_) {
+      return nullptr;  // Main task
+    } else {
+#if defined(USE_ESP32)
+      return pcTaskGetName(current_task);
+#elif defined(USE_LIBRETINY)
+      return pcTaskGetTaskName(current_task);
+#endif
+    }
+  }
+#endif
+
+#ifdef USE_ESP32
+  inline bool HOT check_and_set_task_log_recursion_(bool is_main_task) {
+    if (is_main_task) {
+      const bool was_recursive = main_task_recursion_guard_;
+      main_task_recursion_guard_ = true;
+      return was_recursive;
+    }
+
+    intptr_t current = (intptr_t) pthread_getspecific(log_recursion_key_);
+    if (current != 0)
+      return true;
+
+    pthread_setspecific(log_recursion_key_, (void *) 1);
+    return false;
+  }
+
+  inline void HOT reset_task_log_recursion_(bool is_main_task) {
+    if (is_main_task) {
+      main_task_recursion_guard_ = false;
+      return;
+    }
+
+    pthread_setspecific(log_recursion_key_, (void *) 0);
+  }
+#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) {
+    // Format header
+    if (level < 0)
+      level = 0;
+    if (level > 7)
+      level = 7;
+
+    const char *color = esphome::logger::LOG_LEVEL_COLORS[level];
+    const char *letter = esphome::logger::LOG_LEVEL_LETTERS[level];
+
+#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,
+                              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);
+  }
+
+  inline void HOT format_body_to_buffer_(char *buffer, int *buffer_at, int buffer_size, const char *format,
+                                         va_list args) {
+    // Get remaining capacity in the buffer
+    const int remaining = buffer_size - *buffer_at;
+    if (remaining <= 0)
+      return;
+
+    const int ret = vsnprintf(buffer + *buffer_at, remaining, format, args);
+
+    if (ret < 0) {
+      return;  // Encoding error, do not increment buffer_at
+    }
+
+    // Update buffer_at with the formatted length (handle truncation)
+    int formatted_len = (ret >= remaining) ? remaining : ret;
+    *buffer_at += formatted_len;
+
+    // Remove all trailing newlines right after formatting
+    while (*buffer_at > 0 && buffer[*buffer_at - 1] == '\n') {
+      (*buffer_at)--;
+    }
+  }
+
+  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);
+    this->write_body_to_buffer_(ESPHOME_LOG_RESET_COLOR, RESET_COLOR_LEN, buffer, buffer_at, buffer_size);
+  }
 };
 extern Logger *global_logger;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 

esphome/components/logger/task_log_buffer.cpp

@@ -0,0 +1,138 @@
+
+#include "task_log_buffer.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+
+namespace esphome {
+namespace logger {
+
+TaskLogBuffer::TaskLogBuffer(size_t total_buffer_size) {
+  // Store the buffer size
+  this->size_ = total_buffer_size;
+  // Allocate memory for the ring buffer using ESPHome's RAM allocator
+  RAMAllocator<uint8_t> allocator;
+  this->storage_ = allocator.allocate(this->size_);
+  // Create a static ring buffer with RINGBUF_TYPE_NOSPLIT for message integrity
+  this->ring_buffer_ = xRingbufferCreateStatic(this->size_, RINGBUF_TYPE_NOSPLIT, this->storage_, &this->structure_);
+}
+
+TaskLogBuffer::~TaskLogBuffer() {
+  if (this->ring_buffer_ != nullptr) {
+    // Delete the ring buffer
+    vRingbufferDelete(this->ring_buffer_);
+    this->ring_buffer_ = nullptr;
+
+    // Free the allocated memory
+    RAMAllocator<uint8_t> allocator;
+    allocator.deallocate(this->storage_, this->size_);
+    this->storage_ = nullptr;
+  }
+}
+
+bool TaskLogBuffer::borrow_message_main_loop(LogMessage **message, const char **text, void **received_token) {
+  if (message == nullptr || text == nullptr || received_token == nullptr) {
+    return false;
+  }
+
+  size_t item_size = 0;
+  void *received_item = xRingbufferReceive(ring_buffer_, &item_size, 0);
+  if (received_item == nullptr) {
+    return false;
+  }
+
+  LogMessage *msg = static_cast<LogMessage *>(received_item);
+  *message = msg;
+  *text = msg->text_data();
+  *received_token = received_item;
+
+  return true;
+}
+
+void TaskLogBuffer::release_message_main_loop(void *token) {
+  if (token == nullptr) {
+    return;
+  }
+  vRingbufferReturnItem(ring_buffer_, token);
+  // Update counter to mark all messages as processed
+  last_processed_counter_ = message_counter_.load(std::memory_order_relaxed);
+}
+
+bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
+                                             const char *format, va_list args) {
+  // First, calculate the exact length needed using a null buffer (no actual writing)
+  va_list args_copy;
+  va_copy(args_copy, args);
+  int ret = vsnprintf(nullptr, 0, format, args_copy);
+  va_end(args_copy);
+
+  if (ret <= 0) {
+    return false;  // Formatting error or empty message
+  }
+
+  // Calculate actual text length (capped to maximum size)
+  static constexpr size_t MAX_TEXT_SIZE = 255;
+  size_t text_length = (static_cast<size_t>(ret) > MAX_TEXT_SIZE) ? MAX_TEXT_SIZE : ret;
+
+  // Calculate total size needed (header + text length + null terminator)
+  size_t total_size = sizeof(LogMessage) + text_length + 1;
+
+  // Acquire memory directly from the ring buffer
+  void *acquired_memory = nullptr;
+  BaseType_t result = xRingbufferSendAcquire(ring_buffer_, &acquired_memory, total_size, 0);
+
+  if (result != pdTRUE || acquired_memory == nullptr) {
+    return false;  // Failed to acquire memory
+  }
+
+  // Set up the message header in the acquired memory
+  LogMessage *msg = static_cast<LogMessage *>(acquired_memory);
+  msg->level = level;
+  msg->tag = tag;
+  msg->line = line;
+
+  // Store the thread name now instead of waiting until main loop processing
+  // This avoids crashes if the task completes or is deleted between when this message
+  // is enqueued and when it's processed by the main loop
+  const char *thread_name = pcTaskGetName(task_handle);
+  if (thread_name != nullptr) {
+    strncpy(msg->thread_name, thread_name, sizeof(msg->thread_name) - 1);
+    msg->thread_name[sizeof(msg->thread_name) - 1] = '\0';  // Ensure null termination
+  } else {
+    msg->thread_name[0] = '\0';  // Empty string if no thread name
+  }
+
+  // Format the message text directly into the acquired memory
+  // We add 1 to text_length to ensure space for null terminator during formatting
+  char *text_area = msg->text_data();
+  ret = vsnprintf(text_area, text_length + 1, format, args);
+
+  // Handle unexpected formatting error
+  if (ret <= 0) {
+    vRingbufferReturnItem(ring_buffer_, acquired_memory);
+    return false;
+  }
+
+  // Remove trailing newlines
+  while (text_length > 0 && text_area[text_length - 1] == '\n') {
+    text_length--;
+  }
+
+  msg->text_length = text_length;
+  // Complete the send operation with the acquired memory
+  result = xRingbufferSendComplete(ring_buffer_, acquired_memory);
+
+  if (result != pdTRUE) {
+    return false;  // Failed to complete the message send
+  }
+
+  // Message sent successfully, increment the counter
+  message_counter_.fetch_add(1, std::memory_order_relaxed);
+  return true;
+}
+
+}  // namespace logger
+}  // namespace esphome
+
+#endif  // USE_ESPHOME_TASK_LOG_BUFFER

esphome/components/logger/task_log_buffer.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#include "esphome/core/helpers.h"
+
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+#include <cstddef>
+#include <cstring>
+#include <memory>
+#include <atomic>
+#include <freertos/FreeRTOS.h>
+#include <freertos/ringbuf.h>
+
+namespace esphome {
+namespace logger {
+
+class TaskLogBuffer {
+ public:
+  // Structure for a log message header (text data follows immediately after)
+  struct LogMessage {
+    const char *tag;       // We store the pointer, assuming tags are static
+    char thread_name[16];  // Store thread name directly (only used for non-main threads)
+    uint16_t text_length;  // Length of the message text (up to ~64KB)
+    uint16_t line;         // Source code line number
+    uint8_t level;         // Log level (0-7)
+
+    // Methods for accessing message contents
+    inline char *text_data() { return reinterpret_cast<char *>(this) + sizeof(LogMessage); }
+
+    inline const char *text_data() const { return reinterpret_cast<const char *>(this) + sizeof(LogMessage); }
+  };
+
+  // Constructor that takes a total buffer size
+  explicit TaskLogBuffer(size_t total_buffer_size);
+  ~TaskLogBuffer();
+
+  // NOT thread-safe - borrow a message from the ring buffer, only call from main loop
+  bool borrow_message_main_loop(LogMessage **message, const char **text, void **received_token);
+
+  // NOT thread-safe - release a message buffer and update the counter, only call from main loop
+  void release_message_main_loop(void *token);
+
+  // Thread-safe - send a message to the ring buffer from any thread
+  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
+                                const char *format, va_list args);
+
+  // Check if there are messages ready to be processed using an atomic counter for performance
+  inline bool HOT has_messages() const {
+    return message_counter_.load(std::memory_order_relaxed) != last_processed_counter_;
+  }
+
+  // Get the total buffer size in bytes
+  inline size_t size() const { return size_; }
+
+ private:
+  RingbufHandle_t ring_buffer_{nullptr};  // FreeRTOS ring buffer handle
+  StaticRingbuffer_t structure_;          // Static structure for the ring buffer
+  uint8_t *storage_{nullptr};             // Pointer to allocated memory
+  size_t size_{0};                        // Size of allocated memory
+
+  // Atomic counter for message tracking (only differences matter)
+  std::atomic<uint16_t> message_counter_{0};    // Incremented when messages are committed
+  mutable uint16_t last_processed_counter_{0};  // Tracks last processed message
+};
+
+}  // namespace logger
+}  // namespace esphome
+
+#endif  // USE_ESPHOME_TASK_LOG_BUFFER

esphome/components/lvgl/__init__.py

@@ -2,6 +2,7 @@ import logging
 
 from esphome.automation import build_automation, register_action, validate_automation
 import esphome.codegen as cg
+from esphome.components.const import CONF_DRAW_ROUNDING
 from esphome.components.display import Display
 import esphome.config_validation as cv
 from esphome.const import (
@@ -17,14 +18,14 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_TYPE,
 )
-from esphome.core import CORE, ID
+from esphome.core import CORE, ID, Lambda
 from esphome.cpp_generator import MockObj
 from esphome.final_validate import full_config
 from esphome.helpers import write_file_if_changed
 
 from . import defines as df, helpers, lv_validation as lvalid
-from .automation import disp_update, focused_widgets, update_to_code
-from .defines import CONF_DRAW_ROUNDING, add_define
+from .automation import disp_update, focused_widgets, refreshed_widgets, update_to_code
+from .defines import add_define
 from .encoders import (
     ENCODERS_CONFIG,
     encoders_to_code,
@@ -239,6 +240,13 @@ def final_validation(configs):
                     "A non adjustable arc may not be focused",
                     path,
                 )
+        for w in refreshed_widgets:
+            path = global_config.get_path_for_id(w)
+            widget_conf = global_config.get_config_for_path(path[:-1])
+            if not any(isinstance(v, Lambda) for v in widget_conf.values()):
+                raise cv.Invalid(
+                    f"Widget '{w}' does not have any templated properties to refresh",
+                )
 
 
 async def to_code(configs):
@@ -323,7 +331,7 @@ async def to_code(configs):
             displays,
             frac,
             config[df.CONF_FULL_REFRESH],
-            config[df.CONF_DRAW_ROUNDING],
+            config[CONF_DRAW_ROUNDING],
             config[df.CONF_RESUME_ON_INPUT],
         )
         await cg.register_component(lv_component, config)
@@ -413,7 +421,7 @@ LVGL_SCHEMA = cv.All(
                     df.CONF_DEFAULT_FONT, default="montserrat_14"
                 ): lvalid.lv_font,
                 cv.Optional(df.CONF_FULL_REFRESH, default=False): cv.boolean,
-                cv.Optional(df.CONF_DRAW_ROUNDING, default=2): cv.positive_int,
+                cv.Optional(CONF_DRAW_ROUNDING, default=2): cv.positive_int,
                 cv.Optional(CONF_BUFFER_SIZE, default="100%"): cv.percentage,
                 cv.Optional(df.CONF_LOG_LEVEL, default="WARN"): cv.one_of(
                     *df.LV_LOG_LEVELS, upper=True

esphome/components/lvgl/automation.py

@@ -35,7 +35,13 @@ from .lvcode import (
     lv_obj,
     lvgl_comp,
 )
-from .schemas import DISP_BG_SCHEMA, LIST_ACTION_SCHEMA, LVGL_SCHEMA, base_update_schema
+from .schemas import (
+    ALL_STYLES,
+    DISP_BG_SCHEMA,
+    LIST_ACTION_SCHEMA,
+    LVGL_SCHEMA,
+    base_update_schema,
+)
 from .types import (
     LV_STATE,
     LvglAction,
@@ -57,6 +63,7 @@ from .widgets import (
 
 # Record widgets that are used in a focused action here
 focused_widgets = set()
+refreshed_widgets = set()
 
 
 async def action_to_code(
@@ -361,3 +368,45 @@ async def obj_update_to_code(config, action_id, template_arg, args):
     return await action_to_code(
         widgets, do_update, action_id, template_arg, args, config
     )
+
+
+def validate_refresh_config(config):
+    for w in config:
+        refreshed_widgets.add(w[CONF_ID])
+    return config
+
+
+@automation.register_action(
+    "lvgl.widget.refresh",
+    ObjUpdateAction,
+    cv.All(
+        cv.ensure_list(
+            cv.maybe_simple_value(
+                {
+                    cv.Required(CONF_ID): cv.use_id(lv_obj_t),
+                },
+                key=CONF_ID,
+            )
+        ),
+        validate_refresh_config,
+    ),
+)
+async def obj_refresh_to_code(config, action_id, template_arg, args):
+    widget = await get_widgets(config)
+
+    async def do_refresh(widget: Widget):
+        # only update style properties that might have changed, i.e. are templated
+        config = {k: v for k, v in widget.config.items() if isinstance(v, Lambda)}
+        await set_obj_properties(widget, config)
+        # must pass all widget-specific options here, even if not templated, but only do so if at least one is
+        # templated. First filter out common style properties.
+        config = {k: v for k, v in widget.config.items() if k not in ALL_STYLES}
+        if any(isinstance(v, Lambda) for v in config.values()):
+            await widget.type.to_code(widget, config)
+            if (
+                widget.type.w_type.value_property is not None
+                and widget.type.w_type.value_property in config
+            ):
+                lv.event_send(widget.obj, UPDATE_EVENT, nullptr)
+
+    return await action_to_code(widget, do_refresh, action_id, template_arg, args)

esphome/components/lvgl/defines.py

@@ -424,7 +424,6 @@ CONF_DEFAULT_FONT = "default_font"
 CONF_DEFAULT_GROUP = "default_group"
 CONF_DIR = "dir"
 CONF_DISPLAYS = "displays"
-CONF_DRAW_ROUNDING = "draw_rounding"
 CONF_EDITING = "editing"
 CONF_ENCODERS = "encoders"
 CONF_END_ANGLE = "end_angle"

esphome/components/lvgl/lvgl_esphome.cpp

@@ -434,7 +434,11 @@ void LvglComponent::setup() {
   auto height = display->get_height();
   size_t buffer_pixels = width * height / this->buffer_frac_;
   auto buf_bytes = buffer_pixels * LV_COLOR_DEPTH / 8;
-  auto *buffer = lv_custom_mem_alloc(buf_bytes);  // NOLINT
+  void *buffer = nullptr;
+  if (this->buffer_frac_ >= 4)
+    buffer = malloc(buf_bytes);  // NOLINT
+  if (buffer == nullptr)
+    buffer = lv_custom_mem_alloc(buf_bytes);  // NOLINT
   if (buffer == nullptr) {
     this->mark_failed();
     this->status_set_error("Memory allocation failure");

esphome/components/lvgl/text/__init__.py

@@ -19,9 +19,8 @@ from ..widgets import get_widgets, wait_for_widgets
 
 LVGLText = lvgl_ns.class_("LVGLText", text.Text)
 
-CONFIG_SCHEMA = text.TEXT_SCHEMA.extend(
+CONFIG_SCHEMA = text.text_schema(LVGLText).extend(
     {
-        cv.GenerateID(): cv.declare_id(LVGLText),
         cv.Required(CONF_WIDGET): cv.use_id(LvText),
     }
 )