esphome 2025.8.4__py3-none-any.whl → 2025.9.0b1__py3-none-any.whl

esphome/components/light/light_call.cpp

@@ -11,19 +11,21 @@ static const char *const TAG = "light";
 
 // Helper functions to reduce code size for logging
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_WARN
-static void log_validation_warning(const char *name, const char *param_name, float val, float min, float max) {
-  ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, param_name, val, min, max);
+static void log_validation_warning(const char *name, const LogString *param_name, float val, float min, float max) {
+  ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, LOG_STR_ARG(param_name), val, min, max);
 }
 
-static void log_feature_not_supported(const char *name, const char *feature) {
-  ESP_LOGW(TAG, "'%s': %s not supported", name, feature);
+static void log_feature_not_supported(const char *name, const LogString *feature) {
+  ESP_LOGW(TAG, "'%s': %s not supported", name, LOG_STR_ARG(feature));
 }
 
-static void log_color_mode_not_supported(const char *name, const char *feature) {
-  ESP_LOGW(TAG, "'%s': color mode does not support setting %s", name, feature);
+static void log_color_mode_not_supported(const char *name, const LogString *feature) {
+  ESP_LOGW(TAG, "'%s': color mode does not support setting %s", name, LOG_STR_ARG(feature));
 }
 
-static void log_invalid_parameter(const char *name, const char *message) { ESP_LOGW(TAG, "'%s': %s", name, message); }
+static void log_invalid_parameter(const char *name, const LogString *message) {
+  ESP_LOGW(TAG, "'%s': %s", name, LOG_STR_ARG(message));
+}
 #else
 #define log_validation_warning(name, param_name, val, min, max)
 #define log_feature_not_supported(name, feature)
@@ -201,19 +203,19 @@ LightColorValues LightCall::validate_() {
 
   // Brightness exists check
   if (this->has_brightness() && this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS)) {
-    log_feature_not_supported(name, "brightness");
+    log_feature_not_supported(name, LOG_STR("brightness"));
     this->set_flag_(FLAG_HAS_BRIGHTNESS, false);
   }
 
   // Transition length possible check
   if (this->has_transition_() && this->transition_length_ != 0 && !(color_mode & ColorCapability::BRIGHTNESS)) {
-    log_feature_not_supported(name, "transitions");
+    log_feature_not_supported(name, LOG_STR("transitions"));
     this->set_flag_(FLAG_HAS_TRANSITION, false);
   }
 
   // Color brightness exists check
   if (this->has_color_brightness() && this->color_brightness_ > 0.0f && !(color_mode & ColorCapability::RGB)) {
-    log_color_mode_not_supported(name, "RGB brightness");
+    log_color_mode_not_supported(name, LOG_STR("RGB brightness"));
     this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, false);
   }
 
@@ -221,7 +223,7 @@ LightColorValues LightCall::validate_() {
   if ((this->has_red() && this->red_ > 0.0f) || (this->has_green() && this->green_ > 0.0f) ||
       (this->has_blue() && this->blue_ > 0.0f)) {
     if (!(color_mode & ColorCapability::RGB)) {
-      log_color_mode_not_supported(name, "RGB color");
+      log_color_mode_not_supported(name, LOG_STR("RGB color"));
       this->set_flag_(FLAG_HAS_RED, false);
       this->set_flag_(FLAG_HAS_GREEN, false);
       this->set_flag_(FLAG_HAS_BLUE, false);
@@ -231,21 +233,21 @@ LightColorValues LightCall::validate_() {
   // White value exists check
   if (this->has_white() && this->white_ > 0.0f &&
       !(color_mode & ColorCapability::WHITE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
-    log_color_mode_not_supported(name, "white value");
+    log_color_mode_not_supported(name, LOG_STR("white value"));
     this->set_flag_(FLAG_HAS_WHITE, false);
   }
 
   // Color temperature exists check
   if (this->has_color_temperature() &&
       !(color_mode & ColorCapability::COLOR_TEMPERATURE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
-    log_color_mode_not_supported(name, "color temperature");
+    log_color_mode_not_supported(name, LOG_STR("color temperature"));
     this->set_flag_(FLAG_HAS_COLOR_TEMPERATURE, false);
   }
 
   // Cold/warm white value exists check
   if ((this->has_cold_white() && this->cold_white_ > 0.0f) || (this->has_warm_white() && this->warm_white_ > 0.0f)) {
     if (!(color_mode & ColorCapability::COLD_WARM_WHITE)) {
-      log_color_mode_not_supported(name, "cold/warm white value");
+      log_color_mode_not_supported(name, LOG_STR("cold/warm white value"));
       this->set_flag_(FLAG_HAS_COLD_WHITE, false);
       this->set_flag_(FLAG_HAS_WARM_WHITE, false);
     }
@@ -255,7 +257,7 @@ LightColorValues LightCall::validate_() {
   if (this->has_##name_()) { \
     auto val = this->name_##_; \
     if (val < (min) || val > (max)) { \
-      log_validation_warning(name, LOG_STR_LITERAL(upper_name), val, (min), (max)); \
+      log_validation_warning(name, LOG_STR(upper_name), val, (min), (max)); \
       this->name_##_ = clamp(val, (min), (max)); \
     } \
   }
@@ -319,7 +321,7 @@ LightColorValues LightCall::validate_() {
 
   // Flash length check
   if (this->has_flash_() && this->flash_length_ == 0) {
-    log_invalid_parameter(name, "flash length must be greater than zero");
+    log_invalid_parameter(name, LOG_STR("flash length must be greater than zero"));
     this->set_flag_(FLAG_HAS_FLASH, false);
   }
 
@@ -338,13 +340,13 @@ LightColorValues LightCall::validate_() {
   }
 
   if (this->has_effect_() && (this->has_transition_() || this->has_flash_())) {
-    log_invalid_parameter(name, "effect cannot be used with transition/flash");
+    log_invalid_parameter(name, LOG_STR("effect cannot be used with transition/flash"));
     this->set_flag_(FLAG_HAS_TRANSITION, false);
     this->set_flag_(FLAG_HAS_FLASH, false);
   }
 
   if (this->has_flash_() && this->has_transition_()) {
-    log_invalid_parameter(name, "flash cannot be used with transition");
+    log_invalid_parameter(name, LOG_STR("flash cannot be used with transition"));
     this->set_flag_(FLAG_HAS_TRANSITION, false);
   }
 
@@ -361,7 +363,7 @@ LightColorValues LightCall::validate_() {
   }
 
   if (this->has_transition_() && !supports_transition) {
-    log_feature_not_supported(name, "transitions");
+    log_feature_not_supported(name, LOG_STR("transitions"));
     this->set_flag_(FLAG_HAS_TRANSITION, false);
   }
 
@@ -371,7 +373,7 @@ LightColorValues LightCall::validate_() {
   bool target_state = this->has_state() ? this->state_ : v.is_on();
   if (!this->has_flash_() && !target_state) {
     if (this->has_effect_()) {
-      log_invalid_parameter(name, "cannot start effect when turning off");
+      log_invalid_parameter(name, LOG_STR("cannot start effect when turning off"));
       this->set_flag_(FLAG_HAS_EFFECT, false);
     } else if (this->parent_->active_effect_index_ != 0 && explicit_turn_off_request) {
       // Auto turn off effect

esphome/components/light/light_effect.cpp

@@ -0,0 +1,36 @@
+#include "light_effect.h"
+#include "light_state.h"
+
+namespace esphome {
+namespace light {
+
+uint32_t LightEffect::get_index() const {
+  if (this->state_ == nullptr) {
+    return 0;
+  }
+  return this->get_index_in_parent_();
+}
+
+bool LightEffect::is_active() const {
+  if (this->state_ == nullptr) {
+    return false;
+  }
+  return this->get_index() != 0 && this->state_->get_current_effect_index() == this->get_index();
+}
+
+uint32_t LightEffect::get_index_in_parent_() const {
+  if (this->state_ == nullptr) {
+    return 0;
+  }
+
+  const auto &effects = this->state_->get_effects();
+  for (size_t i = 0; i < effects.size(); i++) {
+    if (effects[i] == this) {
+      return i + 1;  // Effects are 1-indexed in the API
+    }
+  }
+  return 0;  // Not found
+}
+
+}  // namespace light
+}  // namespace esphome

esphome/components/light/light_effect.h

@@ -34,9 +34,23 @@ class LightEffect {
     this->init();
   }
 
+  /// Get the index of this effect in the parent light's effect list.
+  /// Returns 0 if not found or not initialized.
+  uint32_t get_index() const;
+
+  /// Check if this effect is currently active.
+  bool is_active() const;
+
+  /// Get a reference to the parent light state.
+  /// Returns nullptr if not initialized.
+  LightState *get_light_state() const { return this->state_; }
+
  protected:
   LightState *state_{nullptr};
   std::string name_;
+
+  /// Internal method to find this effect's index in the parent light's effect list.
+  uint32_t get_index_in_parent_() const;
 };
 
 }  // namespace light

esphome/components/light/light_json_schema.cpp

@@ -36,8 +36,11 @@ static constexpr const char *get_color_mode_json_str(ColorMode mode) {
 
 void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  if (state.supports_effects())
+  if (state.supports_effects()) {
     root["effect"] = state.get_effect_name();
+    root["effect_index"] = state.get_current_effect_index();
+    root["effect_count"] = state.get_effect_count();
+  }
 
   auto values = state.remote_values;
   auto traits = state.get_output()->get_traits();
@@ -160,6 +163,11 @@ void LightJSONSchema::parse_json(LightState &state, LightCall &call, JsonObject
     const char *effect = root["effect"];
     call.set_effect(effect);
   }
+
+  if (root["effect_index"].is<uint32_t>()) {
+    uint32_t effect_index = root["effect_index"];
+    call.set_effect(effect_index);
+  }
 }
 
 }  // namespace light

esphome/components/light/light_state.cpp

@@ -41,7 +41,7 @@ void LightState::setup() {
     case LIGHT_RESTORE_DEFAULT_ON:
     case LIGHT_RESTORE_INVERTED_DEFAULT_OFF:
     case LIGHT_RESTORE_INVERTED_DEFAULT_ON:
-      this->rtc_ = global_preferences->make_preference<LightStateRTCState>(this->get_object_id_hash());
+      this->rtc_ = global_preferences->make_preference<LightStateRTCState>(this->get_preference_hash());
       // Attempt to load from preferences, else fall back to default values
       if (!this->rtc_.load(&recovered)) {
         recovered.state = (this->restore_mode_ == LIGHT_RESTORE_DEFAULT_ON ||
@@ -54,7 +54,7 @@ void LightState::setup() {
       break;
     case LIGHT_RESTORE_AND_OFF:
     case LIGHT_RESTORE_AND_ON:
-      this->rtc_ = global_preferences->make_preference<LightStateRTCState>(this->get_object_id_hash());
+      this->rtc_ = global_preferences->make_preference<LightStateRTCState>(this->get_preference_hash());
       this->rtc_.load(&recovered);
       recovered.state = (this->restore_mode_ == LIGHT_RESTORE_AND_ON);
       break;

esphome/components/light/light_state.h

@@ -164,6 +164,44 @@ class LightState : public EntityBase, public Component {
   /// Add effects for this light state.
   void add_effects(const std::vector<LightEffect *> &effects);
 
+  /// Get the total number of effects available for this light.
+  size_t get_effect_count() const { return this->effects_.size(); }
+
+  /// Get the currently active effect index (0 = no effect, 1+ = effect index).
+  uint32_t get_current_effect_index() const { return this->active_effect_index_; }
+
+  /// Get effect index by name. Returns 0 if effect not found.
+  uint32_t get_effect_index(const std::string &effect_name) const {
+    if (strcasecmp(effect_name.c_str(), "none") == 0) {
+      return 0;
+    }
+    for (size_t i = 0; i < this->effects_.size(); i++) {
+      if (strcasecmp(effect_name.c_str(), this->effects_[i]->get_name().c_str()) == 0) {
+        return i + 1;  // Effects are 1-indexed in active_effect_index_
+      }
+    }
+    return 0;  // Effect not found
+  }
+
+  /// Get effect by index. Returns nullptr if index is invalid.
+  LightEffect *get_effect_by_index(uint32_t index) const {
+    if (index == 0 || index > this->effects_.size()) {
+      return nullptr;
+    }
+    return this->effects_[index - 1];  // Effects are 1-indexed in active_effect_index_
+  }
+
+  /// Get effect name by index. Returns "None" for index 0, empty string for invalid index.
+  std::string get_effect_name_by_index(uint32_t index) const {
+    if (index == 0) {
+      return "None";
+    }
+    if (index > this->effects_.size()) {
+      return "";  // Invalid index
+    }
+    return this->effects_[index - 1]->get_name();
+  }
+
   /// The result of all the current_values_as_* methods have gamma correction applied.
   void current_values_as_binary(bool *binary);
 

esphome/components/lock/__init__.py

@@ -13,7 +13,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -155,6 +155,6 @@ async def lock_is_off_to_code(config, condition_id, template_arg, args):
     return cg.new_Pvariable(condition_id, template_arg, paren, False)
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(lock_ns.using)

esphome/components/lock/lock.h

@@ -15,8 +15,8 @@ class Lock;
 #define LOG_LOCK(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
     } \
     if ((obj)->traits.get_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \

esphome/components/logger/__init__.py

@@ -51,7 +51,7 @@ from esphome.const import (
     PLATFORM_RTL87XX,
     PlatformFramework,
 )
-from esphome.core import CORE, Lambda, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, Lambda, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
 logger_ns = cg.esphome_ns.namespace("logger")
@@ -275,7 +275,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(90.0)
+@coroutine_with_priority(CoroPriority.DIAGNOSTICS)
 async def to_code(config):
     baud_rate = config[CONF_BAUD_RATE]
     level = config[CONF_LEVEL]

esphome/components/logger/logger.cpp

@@ -246,19 +246,40 @@ void Logger::add_on_log_callback(std::function<void(uint8_t, const char *, const
   this->log_callback_.add(std::move(callback));
 }
 float Logger::get_setup_priority() const { return setup_priority::BUS + 500.0f; }
+
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+// ESP8266: PSTR() cannot be used in array initializers, so we need to declare
+// each string separately as a global constant first
+static const char LOG_LEVEL_NONE[] PROGMEM = "NONE";
+static const char LOG_LEVEL_ERROR[] PROGMEM = "ERROR";
+static const char LOG_LEVEL_WARN[] PROGMEM = "WARN";
+static const char LOG_LEVEL_INFO[] PROGMEM = "INFO";
+static const char LOG_LEVEL_CONFIG[] PROGMEM = "CONFIG";
+static const char LOG_LEVEL_DEBUG[] PROGMEM = "DEBUG";
+static const char LOG_LEVEL_VERBOSE[] PROGMEM = "VERBOSE";
+static const char LOG_LEVEL_VERY_VERBOSE[] PROGMEM = "VERY_VERBOSE";
+
+static const LogString *const LOG_LEVELS[] = {
+    reinterpret_cast<const LogString *>(LOG_LEVEL_NONE),    reinterpret_cast<const LogString *>(LOG_LEVEL_ERROR),
+    reinterpret_cast<const LogString *>(LOG_LEVEL_WARN),    reinterpret_cast<const LogString *>(LOG_LEVEL_INFO),
+    reinterpret_cast<const LogString *>(LOG_LEVEL_CONFIG),  reinterpret_cast<const LogString *>(LOG_LEVEL_DEBUG),
+    reinterpret_cast<const LogString *>(LOG_LEVEL_VERBOSE), reinterpret_cast<const LogString *>(LOG_LEVEL_VERY_VERBOSE),
+};
+#else
 static const char *const LOG_LEVELS[] = {"NONE", "ERROR", "WARN", "INFO", "CONFIG", "DEBUG", "VERBOSE", "VERY_VERBOSE"};
+#endif
 
 void Logger::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Logger:\n"
                 "  Max Level: %s\n"
                 "  Initial Level: %s",
-                LOG_LEVELS[ESPHOME_LOG_LEVEL], LOG_LEVELS[this->current_level_]);
+                LOG_STR_ARG(LOG_LEVELS[ESPHOME_LOG_LEVEL]), LOG_STR_ARG(LOG_LEVELS[this->current_level_]));
 #ifndef USE_HOST
   ESP_LOGCONFIG(TAG,
                 "  Log Baud Rate: %" PRIu32 "\n"
                 "  Hardware UART: %s",
-                this->baud_rate_, get_uart_selection_());
+                this->baud_rate_, LOG_STR_ARG(get_uart_selection_()));
 #endif
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   if (this->log_buffer_) {
@@ -267,14 +288,14 @@ void Logger::dump_config() {
 #endif
 
   for (auto &it : this->log_levels_) {
-    ESP_LOGCONFIG(TAG, "  Level for '%s': %s", it.first.c_str(), LOG_LEVELS[it.second]);
+    ESP_LOGCONFIG(TAG, "  Level for '%s': %s", it.first.c_str(), LOG_STR_ARG(LOG_LEVELS[it.second]));
   }
 }
 
 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]);
+    ESP_LOGW(TAG, "Cannot set log level higher than pre-compiled %s", LOG_STR_ARG(LOG_LEVELS[ESPHOME_LOG_LEVEL]));
   }
   this->current_level_ = level;
   this->level_callback_.call(level);

esphome/components/logger/logger.h

@@ -226,7 +226,7 @@ class Logger : public Component {
   }
 
 #ifndef USE_HOST
-  const char *get_uart_selection_();
+  const LogString *get_uart_selection_();
 #endif
 
   // Group 4-byte aligned members first

esphome/components/logger/logger_esp32.cpp

@@ -190,20 +190,28 @@ void HOT Logger::write_msg_(const char *msg) {
 void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
 #endif
 
-const char *const UART_SELECTIONS[] = {
-    "UART0",           "UART1",
+const LogString *Logger::get_uart_selection_() {
+  switch (this->uart_) {
+    case UART_SELECTION_UART0:
+      return LOG_STR("UART0");
+    case UART_SELECTION_UART1:
+      return LOG_STR("UART1");
 #ifdef USE_ESP32_VARIANT_ESP32
-    "UART2",
+    case UART_SELECTION_UART2:
+      return LOG_STR("UART2");
 #endif
 #ifdef USE_LOGGER_USB_CDC
-    "USB_CDC",
+    case UART_SELECTION_USB_CDC:
+      return LOG_STR("USB_CDC");
 #endif
 #ifdef USE_LOGGER_USB_SERIAL_JTAG
-    "USB_SERIAL_JTAG",
+    case UART_SELECTION_USB_SERIAL_JTAG:
+      return LOG_STR("USB_SERIAL_JTAG");
 #endif
-};
-
-const char *Logger::get_uart_selection_() { return UART_SELECTIONS[this->uart_]; }
+    default:
+      return LOG_STR("UNKNOWN");
+  }
+}
 
 }  // namespace esphome::logger
 #endif

esphome/components/logger/logger_esp8266.cpp

@@ -35,9 +35,17 @@ void Logger::pre_setup() {
 
 void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
 
-const char *const UART_SELECTIONS[] = {"UART0", "UART1", "UART0_SWAP"};
-
-const char *Logger::get_uart_selection_() { return UART_SELECTIONS[this->uart_]; }
+const LogString *Logger::get_uart_selection_() {
+  switch (this->uart_) {
+    case UART_SELECTION_UART0:
+      return LOG_STR("UART0");
+    case UART_SELECTION_UART1:
+      return LOG_STR("UART1");
+    case UART_SELECTION_UART0_SWAP:
+    default:
+      return LOG_STR("UART0_SWAP");
+  }
+}
 
 }  // namespace esphome::logger
 #endif

esphome/components/logger/logger_libretiny.cpp

@@ -51,9 +51,19 @@ void Logger::pre_setup() {
 
 void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
 
-const char *const UART_SELECTIONS[] = {"DEFAULT", "UART0", "UART1", "UART2"};
-
-const char *Logger::get_uart_selection_() { return UART_SELECTIONS[this->uart_]; }
+const LogString *Logger::get_uart_selection_() {
+  switch (this->uart_) {
+    case UART_SELECTION_DEFAULT:
+      return LOG_STR("DEFAULT");
+    case UART_SELECTION_UART0:
+      return LOG_STR("UART0");
+    case UART_SELECTION_UART1:
+      return LOG_STR("UART1");
+    case UART_SELECTION_UART2:
+    default:
+      return LOG_STR("UART2");
+  }
+}
 
 }  // namespace esphome::logger
 

esphome/components/logger/logger_rp2040.cpp

@@ -29,9 +29,20 @@ void Logger::pre_setup() {
 
 void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
 
-const char *const UART_SELECTIONS[] = {"UART0", "UART1", "USB_CDC"};
-
-const char *Logger::get_uart_selection_() { return UART_SELECTIONS[this->uart_]; }
+const LogString *Logger::get_uart_selection_() {
+  switch (this->uart_) {
+    case UART_SELECTION_UART0:
+      return LOG_STR("UART0");
+    case UART_SELECTION_UART1:
+      return LOG_STR("UART1");
+#ifdef USE_LOGGER_USB_CDC
+    case UART_SELECTION_USB_CDC:
+      return LOG_STR("USB_CDC");
+#endif
+    default:
+      return LOG_STR("UNKNOWN");
+  }
+}
 
 }  // namespace esphome::logger
 #endif  // USE_RP2040

esphome/components/logger/logger_zephyr.cpp

@@ -54,7 +54,7 @@ void Logger::pre_setup() {
 #endif
     }
     if (!device_is_ready(uart_dev)) {
-      ESP_LOGE(TAG, "%s is not ready.", get_uart_selection_());
+      ESP_LOGE(TAG, "%s is not ready.", LOG_STR_ARG(get_uart_selection_()));
     } else {
       this->uart_dev_ = uart_dev;
     }
@@ -77,9 +77,20 @@ void HOT Logger::write_msg_(const char *msg) {
   uart_poll_out(this->uart_dev_, '\n');
 }
 
-const char *const UART_SELECTIONS[] = {"UART0", "UART1", "USB_CDC"};
-
-const char *Logger::get_uart_selection_() { return UART_SELECTIONS[this->uart_]; }
+const LogString *Logger::get_uart_selection_() {
+  switch (this->uart_) {
+    case UART_SELECTION_UART0:
+      return LOG_STR("UART0");
+    case UART_SELECTION_UART1:
+      return LOG_STR("UART1");
+#ifdef USE_LOGGER_USB_CDC
+    case UART_SELECTION_USB_CDC:
+      return LOG_STR("USB_CDC");
+#endif
+    default:
+      return LOG_STR("UNKNOWN");
+  }
+}
 
 }  // namespace esphome::logger
 

esphome/components/lvgl/defines.py

@@ -451,6 +451,7 @@ CONF_GRID_ROWS = "grid_rows"
 CONF_HEADER_MODE = "header_mode"
 CONF_HOME = "home"
 CONF_INITIAL_FOCUS = "initial_focus"
+CONF_SELECTED_DIGIT = "selected_digit"
 CONF_KEY_CODE = "key_code"
 CONF_KEYPADS = "keypads"
 CONF_LAYOUT = "layout"