[max7219digit] support flip_x when rotate_chip is 90° or 270° (#6109)

Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>

.github/workflows/ci.yml

@@ -180,6 +180,7 @@ jobs:
       memory_impact: ${{ steps.determine.outputs.memory-impact }}
       cpp-unit-tests-run-all: ${{ steps.determine.outputs.cpp-unit-tests-run-all }}
       cpp-unit-tests-components: ${{ steps.determine.outputs.cpp-unit-tests-components }}
+      component-test-batches: ${{ steps.determine.outputs.component-test-batches }}
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
@@ -191,6 +192,11 @@ jobs:
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
           cache-key: ${{ needs.common.outputs.cache-key }}
+      - name: Restore components graph cache
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        with:
+          path: .temp/components_graph.json
+          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}
       - name: Determine which tests to run
         id: determine
         env:
@@ -214,6 +220,13 @@ jobs:
           echo "memory-impact=$(echo "$output" | jq -c '.memory_impact')" >> $GITHUB_OUTPUT
           echo "cpp-unit-tests-run-all=$(echo "$output" | jq -r '.cpp_unit_tests_run_all')" >> $GITHUB_OUTPUT
           echo "cpp-unit-tests-components=$(echo "$output" | jq -c '.cpp_unit_tests_components')" >> $GITHUB_OUTPUT
+          echo "component-test-batches=$(echo "$output" | jq -c '.component_test_batches')" >> $GITHUB_OUTPUT
+      - name: Save components graph cache
+        if: github.ref == 'refs/heads/dev'
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        with:
+          path: .temp/components_graph.json
+          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}
 
   integration-tests:
     name: Run integration tests
@@ -458,7 +471,7 @@ jobs:
       GH_TOKEN: ${{ github.token }}
     strategy:
       fail-fast: false
-      max-parallel: 1
+      max-parallel: 2
       matrix:
         include:
           - id: clang-tidy
@@ -536,59 +549,18 @@ jobs:
         run: script/ci-suggest-changes
         if: always()
 
-  test-build-components-splitter:
-    name: Split components for intelligent grouping (40 weighted per batch)
-    runs-on: ubuntu-24.04
-    needs:
-      - common
-      - determine-jobs
-    if: github.event_name == 'pull_request' && fromJSON(needs.determine-jobs.outputs.component-test-count) > 0
-    outputs:
-      matrix: ${{ steps.split.outputs.components }}
-    steps:
-      - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
-      - name: Split components intelligently based on bus configurations
-        id: split
-        run: |
-          . venv/bin/activate
-
-          # Use intelligent splitter that groups components with same bus configs
-          components='${{ needs.determine-jobs.outputs.changed-components-with-tests }}'
-
-          # Only isolate directly changed components when targeting dev branch
-          # For beta/release branches, group everything for faster CI
-          if [[ "${{ github.base_ref }}" == beta* ]] || [[ "${{ github.base_ref }}" == release* ]]; then
-            directly_changed='[]'
-            echo "Target branch: ${{ github.base_ref }} - grouping all components"
-          else
-            directly_changed='${{ needs.determine-jobs.outputs.directly-changed-components-with-tests }}'
-            echo "Target branch: ${{ github.base_ref }} - isolating directly changed components"
-          fi
-
-          echo "Splitting components intelligently..."
-          output=$(python3 script/split_components_for_ci.py --components "$components" --directly-changed "$directly_changed" --batch-size 40 --output github)
-
-          echo "$output" >> $GITHUB_OUTPUT
-
   test-build-components-split:
     name: Test components batch (${{ matrix.components }})
     runs-on: ubuntu-24.04
     needs:
       - common
       - determine-jobs
-      - test-build-components-splitter
     if: github.event_name == 'pull_request' && fromJSON(needs.determine-jobs.outputs.component-test-count) > 0
     strategy:
       fail-fast: false
       max-parallel: ${{ (startsWith(github.base_ref, 'beta') || startsWith(github.base_ref, 'release')) && 8 || 4 }}
       matrix:
-        components: ${{ fromJson(needs.test-build-components-splitter.outputs.matrix) }}
+        components: ${{ fromJson(needs.determine-jobs.outputs.component-test-batches) }}
     steps:
       - name: Show disk space
         run: |
@@ -980,7 +952,6 @@ jobs:
       - clang-tidy-nosplit
       - clang-tidy-split
       - determine-jobs
-      - test-build-components-splitter
       - test-build-components-split
       - pre-commit-ci-lite
       - memory-impact-target-branch

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@4e94bd11f71e507f7f87df81788dff88d1dacbfb # v4.31.0
+        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@4e94bd11f71e507f7f87df81788dff88d1dacbfb # v4.31.0
+        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           category: "/language:${{matrix.language}}"

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.2
+    rev: v0.14.3
     hooks:
       # Run the linter.
       - id: ruff

CODEOWNERS

@@ -155,6 +155,7 @@ esphome/components/esp32_ble_tracker/* @bdraco
 esphome/components/esp32_camera_web_server/* @ayufan
 esphome/components/esp32_can/* @Sympatron
 esphome/components/esp32_hosted/* @swoboda1337
+esphome/components/esp32_hosted/update/* @swoboda1337
 esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
@@ -479,6 +480,7 @@ esphome/components/template/fan/* @ssieb
 esphome/components/text/* @mauritskorse
 esphome/components/thermostat/* @kbx81
 esphome/components/time/* @esphome/core
+esphome/components/tinyusb/* @kbx81
 esphome/components/tlc5947/* @rnauber
 esphome/components/tlc5971/* @IJIJI
 esphome/components/tm1621/* @Philippe12

esphome/__main__.py

@@ -207,14 +207,14 @@ def choose_upload_log_host(
                     if has_mqtt_logging():
                         resolved.append("MQTT")
 
-                    if has_api() and has_non_ip_address():
+                    if has_api() and has_non_ip_address() and has_resolvable_address():
                         resolved.extend(_resolve_with_cache(CORE.address, purpose))
 
                 elif purpose == Purpose.UPLOADING:
                     if has_ota() and has_mqtt_ip_lookup():
                         resolved.append("MQTTIP")
 
-                    if has_ota() and has_non_ip_address():
+                    if has_ota() and has_non_ip_address() and has_resolvable_address():
                         resolved.extend(_resolve_with_cache(CORE.address, purpose))
             else:
                 resolved.append(device)
@@ -318,7 +318,17 @@ def has_resolvable_address() -> bool:
     """Check if CORE.address is resolvable (via mDNS, DNS, or is an IP address)."""
     # Any address (IP, mDNS hostname, or regular DNS hostname) is resolvable
     # The resolve_ip_address() function in helpers.py handles all types via AsyncResolver
-    return CORE.address is not None
+    if CORE.address is None:
+        return False
+
+    if has_ip_address():
+        return True
+
+    if has_mdns():
+        return True
+
+    # .local mDNS hostnames are only resolvable if mDNS is enabled
+    return not CORE.address.endswith(".local")
 
 
 def mqtt_get_ip(config: ConfigType, username: str, password: str, client_id: str):

esphome/automation.py

@@ -15,7 +15,7 @@ from esphome.const import (
     CONF_TYPE_ID,
     CONF_UPDATE_INTERVAL,
 )
-from esphome.core import ID
+from esphome.core import ID, Lambda
 from esphome.cpp_generator import (
     LambdaExpression,
     MockObj,
@@ -182,7 +182,7 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
             value = cv.Schema([extra_validators])(value)
         if single:
             if len(value) != 1:
-                raise cv.Invalid("Cannot have more than 1 automation for templates")
+                raise cv.Invalid("This trigger allows only a single automation")
             return value[0]
         return value
 
@@ -310,6 +310,30 @@ async def for_condition_to_code(
     return var
 
 
+@register_condition(
+    "component.is_idle",
+    LambdaCondition,
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(cg.Component),
+        }
+    ),
+)
+async def component_is_idle_condition_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    comp = await cg.get_variable(config[CONF_ID])
+    lambda_ = await cg.process_lambda(
+        Lambda(f"return {comp}->is_idle();"), args, return_type=bool
+    )
+    return new_lambda_pvariable(
+        condition_id, lambda_, StatelessLambdaCondition, template_arg
+    )
+
+
 @register_action(
     "delay", DelayAction, cv.templatable(cv.positive_time_period_milliseconds)
 )

esphome/components/api/api.proto

@@ -425,7 +425,7 @@ message ListEntitiesFanResponse {
   bool disabled_by_default = 9;
   string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 11;
-  repeated string supported_preset_modes = 12 [(container_pointer) = "std::set"];
+  repeated string supported_preset_modes = 12 [(container_pointer_no_template) = "std::vector<const char *>"];
   uint32 device_id = 13 [(field_ifdef) = "USE_DEVICES"];
 }
 // Deprecated in API version 1.6 - only used in deprecated fields
@@ -1000,9 +1000,9 @@ message ListEntitiesClimateResponse {
   bool supports_action = 12; // Deprecated: use feature_flags
   repeated ClimateFanMode supported_fan_modes = 13 [(container_pointer_no_template) = "climate::ClimateFanModeMask"];
   repeated ClimateSwingMode supported_swing_modes = 14 [(container_pointer_no_template) = "climate::ClimateSwingModeMask"];
-  repeated string supported_custom_fan_modes = 15 [(container_pointer) = "std::vector"];
+  repeated string supported_custom_fan_modes = 15 [(container_pointer_no_template) = "std::vector<const char *>"];
   repeated ClimatePreset supported_presets = 16 [(container_pointer_no_template) = "climate::ClimatePresetMask"];
-  repeated string supported_custom_presets = 17 [(container_pointer) = "std::vector"];
+  repeated string supported_custom_presets = 17 [(container_pointer_no_template) = "std::vector<const char *>"];
   bool disabled_by_default = 18;
   string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 20;

esphome/components/api/api_connection.cpp

@@ -423,7 +423,7 @@ uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *con
   msg.supports_speed = traits.supports_speed();
   msg.supports_direction = traits.supports_direction();
   msg.supported_speed_count = traits.supported_speed_count();
-  msg.supported_preset_modes = &traits.supported_preset_modes_for_api_();
+  msg.supported_preset_modes = &traits.supported_preset_modes();
   return fill_and_encode_entity_info(fan, msg, ListEntitiesFanResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::fan_command(const FanCommandRequest &msg) {
@@ -637,14 +637,14 @@ uint16_t APIConnection::try_send_climate_state(EntityBase *entity, APIConnection
   }
   if (traits.get_supports_fan_modes() && climate->fan_mode.has_value())
     resp.fan_mode = static_cast<enums::ClimateFanMode>(climate->fan_mode.value());
-  if (!traits.get_supported_custom_fan_modes().empty() && climate->custom_fan_mode.has_value()) {
-    resp.set_custom_fan_mode(StringRef(climate->custom_fan_mode.value()));
+  if (!traits.get_supported_custom_fan_modes().empty() && climate->has_custom_fan_mode()) {
+    resp.set_custom_fan_mode(StringRef(climate->get_custom_fan_mode()));
   }
   if (traits.get_supports_presets() && climate->preset.has_value()) {
     resp.preset = static_cast<enums::ClimatePreset>(climate->preset.value());
   }
-  if (!traits.get_supported_custom_presets().empty() && climate->custom_preset.has_value()) {
-    resp.set_custom_preset(StringRef(climate->custom_preset.value()));
+  if (!traits.get_supported_custom_presets().empty() && climate->has_custom_preset()) {
+    resp.set_custom_preset(StringRef(climate->get_custom_preset()));
   }
   if (traits.get_supports_swing_modes())
     resp.swing_mode = static_cast<enums::ClimateSwingMode>(climate->swing_mode);

esphome/components/api/api_frame_helper_noise.cpp

@@ -434,8 +434,7 @@ APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, st
     return APIError::OK;
   }
 
-  std::vector<uint8_t> *raw_buffer = buffer.get_buffer();
-  uint8_t *buffer_data = raw_buffer->data();  // Cache buffer pointer
+  uint8_t *buffer_data = buffer.get_buffer()->data();
 
   this->reusable_iovs_.clear();
   this->reusable_iovs_.reserve(packets.size());

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -230,8 +230,7 @@ APIError APIPlaintextFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer
     return APIError::OK;
   }
 
-  std::vector<uint8_t> *raw_buffer = buffer.get_buffer();
-  uint8_t *buffer_data = raw_buffer->data();  // Cache buffer pointer
+  uint8_t *buffer_data = buffer.get_buffer()->data();
 
   this->reusable_iovs_.clear();
   this->reusable_iovs_.reserve(packets.size());

esphome/components/api/api_pb2.cpp

@@ -355,8 +355,8 @@ void ListEntitiesFanResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(10, this->icon_ref_);
 #endif
   buffer.encode_uint32(11, static_cast<uint32_t>(this->entity_category));
-  for (const auto &it : *this->supported_preset_modes) {
-    buffer.encode_string(12, it, true);
+  for (const char *it : *this->supported_preset_modes) {
+    buffer.encode_string(12, it, strlen(it), true);
   }
 #ifdef USE_DEVICES
   buffer.encode_uint32(13, this->device_id);
@@ -376,8 +376,8 @@ void ListEntitiesFanResponse::calculate_size(ProtoSize &size) const {
 #endif
   size.add_uint32(1, static_cast<uint32_t>(this->entity_category));
   if (!this->supported_preset_modes->empty()) {
-    for (const auto &it : *this->supported_preset_modes) {
-      size.add_length_force(1, it.size());
+    for (const char *it : *this->supported_preset_modes) {
+      size.add_length_force(1, strlen(it));
     }
   }
 #ifdef USE_DEVICES
@@ -1179,14 +1179,14 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   for (const auto &it : *this->supported_swing_modes) {
     buffer.encode_uint32(14, static_cast<uint32_t>(it), true);
   }
-  for (const auto &it : *this->supported_custom_fan_modes) {
-    buffer.encode_string(15, it, true);
+  for (const char *it : *this->supported_custom_fan_modes) {
+    buffer.encode_string(15, it, strlen(it), true);
   }
   for (const auto &it : *this->supported_presets) {
     buffer.encode_uint32(16, static_cast<uint32_t>(it), true);
   }
-  for (const auto &it : *this->supported_custom_presets) {
-    buffer.encode_string(17, it, true);
+  for (const char *it : *this->supported_custom_presets) {
+    buffer.encode_string(17, it, strlen(it), true);
   }
   buffer.encode_bool(18, this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
@@ -1229,8 +1229,8 @@ void ListEntitiesClimateResponse::calculate_size(ProtoSize &size) const {
     }
   }
   if (!this->supported_custom_fan_modes->empty()) {
-    for (const auto &it : *this->supported_custom_fan_modes) {
-      size.add_length_force(1, it.size());
+    for (const char *it : *this->supported_custom_fan_modes) {
+      size.add_length_force(1, strlen(it));
     }
   }
   if (!this->supported_presets->empty()) {
@@ -1239,8 +1239,8 @@ void ListEntitiesClimateResponse::calculate_size(ProtoSize &size) const {
     }
   }
   if (!this->supported_custom_presets->empty()) {
-    for (const auto &it : *this->supported_custom_presets) {
-      size.add_length_force(2, it.size());
+    for (const char *it : *this->supported_custom_presets) {
+      size.add_length_force(2, strlen(it));
     }
   }
   size.add_bool(2, this->disabled_by_default);

esphome/components/api/api_pb2.h

@@ -725,7 +725,7 @@ class ListEntitiesFanResponse final : public InfoResponseProtoMessage {
   bool supports_speed{false};
   bool supports_direction{false};
   int32_t supported_speed_count{0};
-  const std::set<std::string> *supported_preset_modes{};
+  const std::vector<const char *> *supported_preset_modes{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1384,9 +1384,9 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
   bool supports_action{false};
   const climate::ClimateFanModeMask *supported_fan_modes{};
   const climate::ClimateSwingModeMask *supported_swing_modes{};
-  const std::vector<std::string> *supported_custom_fan_modes{};
+  const std::vector<const char *> *supported_custom_fan_modes{};
   const climate::ClimatePresetMask *supported_presets{};
-  const std::vector<std::string> *supported_custom_presets{};
+  const std::vector<const char *> *supported_custom_presets{};
   float visual_current_temperature_step{0.0f};
   bool supports_current_humidity{false};
   bool supports_target_humidity{false};

esphome/components/bedjet/bedjet_const.h

@@ -100,7 +100,6 @@ enum BedjetCommand : uint8_t {
 static const uint8_t BEDJET_FAN_SPEED_COUNT = 20;
 
 static constexpr const char *const BEDJET_FAN_STEP_NAMES[BEDJET_FAN_SPEED_COUNT] = BEDJET_FAN_STEP_NAMES_;
-static const std::string BEDJET_FAN_STEP_NAME_STRINGS[BEDJET_FAN_SPEED_COUNT] = BEDJET_FAN_STEP_NAMES_;
 
 }  // namespace bedjet
 }  // namespace esphome

esphome/components/bedjet/climate/bedjet_climate.cpp

@@ -8,15 +8,15 @@ namespace bedjet {
 
 using namespace esphome::climate;
 
-static const std::string *bedjet_fan_step_to_fan_mode(const uint8_t fan_step) {
+static const char *bedjet_fan_step_to_fan_mode(const uint8_t fan_step) {
   if (fan_step < BEDJET_FAN_SPEED_COUNT)
-    return &BEDJET_FAN_STEP_NAME_STRINGS[fan_step];
+    return BEDJET_FAN_STEP_NAMES[fan_step];
   return nullptr;
 }
 
-static uint8_t bedjet_fan_speed_to_step(const std::string &fan_step_percent) {
+static uint8_t bedjet_fan_speed_to_step(const char *fan_step_percent) {
   for (int i = 0; i < BEDJET_FAN_SPEED_COUNT; i++) {
-    if (fan_step_percent == BEDJET_FAN_STEP_NAME_STRINGS[i]) {
+    if (strcmp(BEDJET_FAN_STEP_NAMES[i], fan_step_percent) == 0) {
       return i;
     }
   }
@@ -48,7 +48,7 @@ void BedJetClimate::dump_config() {
     ESP_LOGCONFIG(TAG, "   - %s", LOG_STR_ARG(climate_fan_mode_to_string(mode)));
   }
   for (const auto &mode : traits.get_supported_custom_fan_modes()) {
-    ESP_LOGCONFIG(TAG, "   - %s (c)", mode.c_str());
+    ESP_LOGCONFIG(TAG, "   - %s (c)", mode);
   }
 
   ESP_LOGCONFIG(TAG, "  Supported presets:");
@@ -56,7 +56,7 @@ void BedJetClimate::dump_config() {
     ESP_LOGCONFIG(TAG, "   - %s", LOG_STR_ARG(climate_preset_to_string(preset)));
   }
   for (const auto &preset : traits.get_supported_custom_presets()) {
-    ESP_LOGCONFIG(TAG, "   - %s (c)", preset.c_str());
+    ESP_LOGCONFIG(TAG, "   - %s (c)", preset);
   }
 }
 
@@ -79,7 +79,7 @@ void BedJetClimate::reset_state_() {
   this->target_temperature = NAN;
   this->current_temperature = NAN;
   this->preset.reset();
-  this->custom_preset.reset();
+  this->clear_custom_preset_();
   this->publish_state();
 }
 
@@ -120,7 +120,7 @@ void BedJetClimate::control(const ClimateCall &call) {
     if (button_result) {
       this->mode = mode;
       // We're using (custom) preset for Turbo, EXT HT, & M1-3 presets, so changing climate mode will clear those
-      this->custom_preset.reset();
+      this->clear_custom_preset_();
       this->preset.reset();
     }
   }
@@ -144,8 +144,7 @@ void BedJetClimate::control(const ClimateCall &call) {
 
       if (result) {
         this->mode = CLIMATE_MODE_HEAT;
-        this->preset = CLIMATE_PRESET_BOOST;
-        this->custom_preset.reset();
+        this->set_preset_(CLIMATE_PRESET_BOOST);
       }
     } else if (preset == CLIMATE_PRESET_NONE && this->preset.has_value()) {
       if (this->mode == CLIMATE_MODE_HEAT && this->preset == CLIMATE_PRESET_BOOST) {
@@ -153,7 +152,7 @@ void BedJetClimate::control(const ClimateCall &call) {
         result = this->parent_->send_button(heat_button(this->heating_mode_));
         if (result) {
           this->preset.reset();
-          this->custom_preset.reset();
+          this->clear_custom_preset_();
         }
       } else {
         ESP_LOGD(TAG, "Ignoring preset '%s' call; with current mode '%s' and preset '%s'",
@@ -164,28 +163,27 @@ void BedJetClimate::control(const ClimateCall &call) {
       ESP_LOGW(TAG, "Unsupported preset: %d", preset);
       return;
     }
-  } else if (call.get_custom_preset().has_value()) {
-    std::string preset = *call.get_custom_preset();
+  } else if (call.has_custom_preset()) {
+    const char *preset = call.get_custom_preset();
     bool result;
 
-    if (preset == "M1") {
+    if (strcmp(preset, "M1") == 0) {
       result = this->parent_->button_memory1();
-    } else if (preset == "M2") {
+    } else if (strcmp(preset, "M2") == 0) {
       result = this->parent_->button_memory2();
-    } else if (preset == "M3") {
+    } else if (strcmp(preset, "M3") == 0) {
       result = this->parent_->button_memory3();
-    } else if (preset == "LTD HT") {
+    } else if (strcmp(preset, "LTD HT") == 0) {
       result = this->parent_->button_heat();
-    } else if (preset == "EXT HT") {
+    } else if (strcmp(preset, "EXT HT") == 0) {
       result = this->parent_->button_ext_heat();
     } else {
-      ESP_LOGW(TAG, "Unsupported preset: %s", preset.c_str());
+      ESP_LOGW(TAG, "Unsupported preset: %s", preset);
       return;
     }
 
     if (result) {
-      this->custom_preset = preset;
-      this->preset.reset();
+      this->set_custom_preset_(preset);
     }
   }
 
@@ -207,19 +205,16 @@ void BedJetClimate::control(const ClimateCall &call) {
     }
 
     if (result) {
-      this->fan_mode = fan_mode;
-      this->custom_fan_mode.reset();
+      this->set_fan_mode_(fan_mode);
     }
-  } else if (call.get_custom_fan_mode().has_value()) {
-    auto fan_mode = *call.get_custom_fan_mode();
+  } else if (call.has_custom_fan_mode()) {
+    const char *fan_mode = call.get_custom_fan_mode();
     auto fan_index = bedjet_fan_speed_to_step(fan_mode);
     if (fan_index <= 19) {
-      ESP_LOGV(TAG, "[%s] Converted fan mode %s to bedjet fan step %d", this->get_name().c_str(), fan_mode.c_str(),
-               fan_index);
+      ESP_LOGV(TAG, "[%s] Converted fan mode %s to bedjet fan step %d", this->get_name().c_str(), fan_mode, fan_index);
       bool result = this->parent_->set_fan_index(fan_index);
       if (result) {
-        this->custom_fan_mode = fan_mode;
-        this->fan_mode.reset();
+        this->set_custom_fan_mode_(fan_mode);
       }
     }
   }
@@ -245,7 +240,7 @@ void BedJetClimate::on_status(const BedjetStatusPacket *data) {
 
   const auto *fan_mode_name = bedjet_fan_step_to_fan_mode(data->fan_step);
   if (fan_mode_name != nullptr) {
-    this->custom_fan_mode = *fan_mode_name;
+    this->set_custom_fan_mode_(fan_mode_name);
   }
 
   // TODO: Get biorhythm data to determine which preset (M1-3) is running, if any.
@@ -255,7 +250,7 @@ void BedJetClimate::on_status(const BedjetStatusPacket *data) {
       this->mode = CLIMATE_MODE_OFF;
       this->action = CLIMATE_ACTION_IDLE;
       this->fan_mode = CLIMATE_FAN_OFF;
-      this->custom_preset.reset();
+      this->clear_custom_preset_();
       this->preset.reset();
       break;
 
@@ -266,7 +261,7 @@ void BedJetClimate::on_status(const BedjetStatusPacket *data) {
       if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
         this->set_custom_preset_("LTD HT");
       } else {
-        this->custom_preset.reset();
+        this->clear_custom_preset_();
       }
       break;
 
@@ -275,7 +270,7 @@ void BedJetClimate::on_status(const BedjetStatusPacket *data) {
       this->action = CLIMATE_ACTION_HEATING;
       this->preset.reset();
       if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
-        this->custom_preset.reset();
+        this->clear_custom_preset_();
       } else {
         this->set_custom_preset_("EXT HT");
       }
@@ -284,20 +279,19 @@ void BedJetClimate::on_status(const BedjetStatusPacket *data) {
     case MODE_COOL:
       this->mode = CLIMATE_MODE_FAN_ONLY;
       this->action = CLIMATE_ACTION_COOLING;
-      this->custom_preset.reset();
+      this->clear_custom_preset_();
       this->preset.reset();
       break;
 
     case MODE_DRY:
       this->mode = CLIMATE_MODE_DRY;
       this->action = CLIMATE_ACTION_DRYING;
-      this->custom_preset.reset();
+      this->clear_custom_preset_();
       this->preset.reset();
       break;
 
     case MODE_TURBO:
-      this->preset = CLIMATE_PRESET_BOOST;
-      this->custom_preset.reset();
+      this->set_preset_(CLIMATE_PRESET_BOOST);
       this->mode = CLIMATE_MODE_HEAT;
       this->action = CLIMATE_ACTION_HEATING;
       break;

esphome/components/bedjet/climate/bedjet_climate.h

@@ -50,21 +50,13 @@ class BedJetClimate : public climate::Climate, public BedJetClient, public Polli
         // Climate doesn't have a "TURBO" mode, but we can use the BOOST preset instead.
         climate::CLIMATE_PRESET_BOOST,
     });
+    // String literals are stored in rodata and valid for program lifetime
     traits.set_supported_custom_presets({
-        // We could fetch biodata from bedjet and set these names that way.
-        // But then we have to invert the lookup in order to send the right preset.
-        // For now, we can leave them as M1-3 to match the remote buttons.
-        // EXT HT added to match remote button.
-        "EXT HT",
+        this->heating_mode_ == HEAT_MODE_EXTENDED ? "LTD HT" : "EXT HT",
         "M1",
         "M2",
         "M3",
     });
-    if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
-      traits.add_supported_custom_preset("LTD HT");
-    } else {
-      traits.add_supported_custom_preset("EXT HT");
-    }
     traits.set_visual_min_temperature(19.0);
     traits.set_visual_max_temperature(43.0);
     traits.set_visual_temperature_step(1.0);

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -77,6 +77,9 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
         }
       } else {
         this->node_state = espbt::ClientState::ESTABLISHED;
+        // For non-notify characteristics, trigger an immediate read after service discovery
+        // to avoid peripherals disconnecting due to inactivity
+        this->update();
       }
       break;
     }

esphome/components/ble_client/text_sensor/ble_text_sensor.cpp

@@ -79,6 +79,9 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         }
       } else {
         this->node_state = espbt::ClientState::ESTABLISHED;
+        // For non-notify characteristics, trigger an immediate read after service discovery
+        // to avoid peripherals disconnecting due to inactivity
+        this->update();
       }
       break;
     }

esphome/components/climate/climate.cpp

@@ -50,21 +50,21 @@ void ClimateCall::perform() {
     const LogString *mode_s = climate_mode_to_string(*this->mode_);
     ESP_LOGD(TAG, "  Mode: %s", LOG_STR_ARG(mode_s));
   }
-  if (this->custom_fan_mode_.has_value()) {
+  if (this->custom_fan_mode_ != nullptr) {
     this->fan_mode_.reset();
-    ESP_LOGD(TAG, " Custom Fan: %s", this->custom_fan_mode_.value().c_str());
+    ESP_LOGD(TAG, " Custom Fan: %s", this->custom_fan_mode_);
   }
   if (this->fan_mode_.has_value()) {
-    this->custom_fan_mode_.reset();
+    this->custom_fan_mode_ = nullptr;
     const LogString *fan_mode_s = climate_fan_mode_to_string(*this->fan_mode_);
     ESP_LOGD(TAG, "  Fan: %s", LOG_STR_ARG(fan_mode_s));
   }
-  if (this->custom_preset_.has_value()) {
+  if (this->custom_preset_ != nullptr) {
     this->preset_.reset();
-    ESP_LOGD(TAG, " Custom Preset: %s", this->custom_preset_.value().c_str());
+    ESP_LOGD(TAG, " Custom Preset: %s", this->custom_preset_);
   }
   if (this->preset_.has_value()) {
-    this->custom_preset_.reset();
+    this->custom_preset_ = nullptr;
     const LogString *preset_s = climate_preset_to_string(*this->preset_);
     ESP_LOGD(TAG, "  Preset: %s", LOG_STR_ARG(preset_s));
   }
@@ -96,11 +96,10 @@ void ClimateCall::validate_() {
       this->mode_.reset();
     }
   }
-  if (this->custom_fan_mode_.has_value()) {
-    auto custom_fan_mode = *this->custom_fan_mode_;
-    if (!traits.supports_custom_fan_mode(custom_fan_mode)) {
-      ESP_LOGW(TAG, "  Fan Mode %s not supported", custom_fan_mode.c_str());
-      this->custom_fan_mode_.reset();
+  if (this->custom_fan_mode_ != nullptr) {
+    if (!traits.supports_custom_fan_mode(this->custom_fan_mode_)) {
+      ESP_LOGW(TAG, "  Fan Mode %s not supported", this->custom_fan_mode_);
+      this->custom_fan_mode_ = nullptr;
     }
   } else if (this->fan_mode_.has_value()) {
     auto fan_mode = *this->fan_mode_;
@@ -109,11 +108,10 @@ void ClimateCall::validate_() {
       this->fan_mode_.reset();
     }
   }
-  if (this->custom_preset_.has_value()) {
-    auto custom_preset = *this->custom_preset_;
-    if (!traits.supports_custom_preset(custom_preset)) {
-      ESP_LOGW(TAG, "  Preset %s not supported", custom_preset.c_str());
-      this->custom_preset_.reset();
+  if (this->custom_preset_ != nullptr) {
+    if (!traits.supports_custom_preset(this->custom_preset_)) {
+      ESP_LOGW(TAG, "  Preset %s not supported", this->custom_preset_);
+      this->custom_preset_ = nullptr;
     }
   } else if (this->preset_.has_value()) {
     auto preset = *this->preset_;
@@ -186,26 +184,29 @@ ClimateCall &ClimateCall::set_mode(const std::string &mode) {
 
 ClimateCall &ClimateCall::set_fan_mode(ClimateFanMode fan_mode) {
   this->fan_mode_ = fan_mode;
-  this->custom_fan_mode_.reset();
+  this->custom_fan_mode_ = nullptr;
   return *this;
 }
 
-ClimateCall &ClimateCall::set_fan_mode(const std::string &fan_mode) {
+ClimateCall &ClimateCall::set_fan_mode(const char *custom_fan_mode) {
+  // Check if it's a standard enum mode first
   for (const auto &mode_entry : CLIMATE_FAN_MODES_BY_STR) {
-    if (str_equals_case_insensitive(fan_mode, mode_entry.str)) {
-      this->set_fan_mode(static_cast<ClimateFanMode>(mode_entry.value));
+    if (str_equals_case_insensitive(custom_fan_mode, mode_entry.str)) {
+      return this->set_fan_mode(static_cast<ClimateFanMode>(mode_entry.value));
+    }
+  }
+  // Find the matching pointer from parent climate device
+  if (const char *mode_ptr = this->parent_->find_custom_fan_mode_(custom_fan_mode)) {
+    this->custom_fan_mode_ = mode_ptr;
+    this->fan_mode_.reset();
     return *this;
   }
-  }
-  if (this->parent_->get_traits().supports_custom_fan_mode(fan_mode)) {
-    this->custom_fan_mode_ = fan_mode;
-    this->fan_mode_.reset();
-  } else {
-    ESP_LOGW(TAG, "'%s' - Unrecognized fan mode %s", this->parent_->get_name().c_str(), fan_mode.c_str());
-  }
+  ESP_LOGW(TAG, "'%s' - Unrecognized fan mode %s", this->parent_->get_name().c_str(), custom_fan_mode);
   return *this;
 }
 
+ClimateCall &ClimateCall::set_fan_mode(const std::string &fan_mode) { return this->set_fan_mode(fan_mode.c_str()); }
+
 ClimateCall &ClimateCall::set_fan_mode(optional<std::string> fan_mode) {
   if (fan_mode.has_value()) {
     this->set_fan_mode(fan_mode.value());
@@ -215,26 +216,29 @@ ClimateCall &ClimateCall::set_fan_mode(optional<std::string> fan_mode) {
 
 ClimateCall &ClimateCall::set_preset(ClimatePreset preset) {
   this->preset_ = preset;
-  this->custom_preset_.reset();
+  this->custom_preset_ = nullptr;
   return *this;
 }
 
-ClimateCall &ClimateCall::set_preset(const std::string &preset) {
+ClimateCall &ClimateCall::set_preset(const char *custom_preset) {
+  // Check if it's a standard enum preset first
   for (const auto &preset_entry : CLIMATE_PRESETS_BY_STR) {
-    if (str_equals_case_insensitive(preset, preset_entry.str)) {
-      this->set_preset(static_cast<ClimatePreset>(preset_entry.value));
+    if (str_equals_case_insensitive(custom_preset, preset_entry.str)) {
+      return this->set_preset(static_cast<ClimatePreset>(preset_entry.value));
+    }
+  }
+  // Find the matching pointer from parent climate device
+  if (const char *preset_ptr = this->parent_->find_custom_preset_(custom_preset)) {
+    this->custom_preset_ = preset_ptr;
+    this->preset_.reset();
     return *this;
   }
-  }
-  if (this->parent_->get_traits().supports_custom_preset(preset)) {
-    this->custom_preset_ = preset;
-    this->preset_.reset();
-  } else {
-    ESP_LOGW(TAG, "'%s' - Unrecognized preset %s", this->parent_->get_name().c_str(), preset.c_str());
-  }
+  ESP_LOGW(TAG, "'%s' - Unrecognized preset %s", this->parent_->get_name().c_str(), custom_preset);
   return *this;
 }
 
+ClimateCall &ClimateCall::set_preset(const std::string &preset) { return this->set_preset(preset.c_str()); }
+
 ClimateCall &ClimateCall::set_preset(optional<std::string> preset) {
   if (preset.has_value()) {
     this->set_preset(preset.value());
@@ -287,8 +291,6 @@ const optional<ClimateMode> &ClimateCall::get_mode() const { return this->mode_;
 const optional<ClimateFanMode> &ClimateCall::get_fan_mode() const { return this->fan_mode_; }
 const optional<ClimateSwingMode> &ClimateCall::get_swing_mode() const { return this->swing_mode_; }
 const optional<ClimatePreset> &ClimateCall::get_preset() const { return this->preset_; }
-const optional<std::string> &ClimateCall::get_custom_fan_mode() const { return this->custom_fan_mode_; }
-const optional<std::string> &ClimateCall::get_custom_preset() const { return this->custom_preset_; }
 
 ClimateCall &ClimateCall::set_target_temperature_high(optional<float> target_temperature_high) {
   this->target_temperature_high_ = target_temperature_high;
@@ -317,13 +319,13 @@ ClimateCall &ClimateCall::set_mode(optional<ClimateMode> mode) {
 
 ClimateCall &ClimateCall::set_fan_mode(optional<ClimateFanMode> fan_mode) {
   this->fan_mode_ = fan_mode;
-  this->custom_fan_mode_.reset();
+  this->custom_fan_mode_ = nullptr;
   return *this;
 }
 
 ClimateCall &ClimateCall::set_preset(optional<ClimatePreset> preset) {
   this->preset_ = preset;
-  this->custom_preset_.reset();
+  this->custom_preset_ = nullptr;
   return *this;
 }
 
@@ -382,13 +384,13 @@ void Climate::save_state_() {
     state.uses_custom_fan_mode = false;
     state.fan_mode = this->fan_mode.value();
   }
-  if (!traits.get_supported_custom_fan_modes().empty() && custom_fan_mode.has_value()) {
+  if (!traits.get_supported_custom_fan_modes().empty() && this->has_custom_fan_mode()) {
     state.uses_custom_fan_mode = true;
     const auto &supported = traits.get_supported_custom_fan_modes();
     // std::vector maintains insertion order
     size_t i = 0;
-    for (const auto &mode : supported) {
-      if (mode == custom_fan_mode) {
+    for (const char *mode : supported) {
+      if (strcmp(mode, this->custom_fan_mode_) == 0) {
         state.custom_fan_mode = i;
         break;
       }
@@ -399,13 +401,13 @@ void Climate::save_state_() {
     state.uses_custom_preset = false;
     state.preset = this->preset.value();
   }
-  if (!traits.get_supported_custom_presets().empty() && custom_preset.has_value()) {
+  if (!traits.get_supported_custom_presets().empty() && this->has_custom_preset()) {
     state.uses_custom_preset = true;
     const auto &supported = traits.get_supported_custom_presets();
     // std::vector maintains insertion order
     size_t i = 0;
-    for (const auto &preset : supported) {
-      if (preset == custom_preset) {
+    for (const char *preset : supported) {
+      if (strcmp(preset, this->custom_preset_) == 0) {
         state.custom_preset = i;
         break;
       }
@@ -430,14 +432,14 @@ void Climate::publish_state() {
   if (traits.get_supports_fan_modes() && this->fan_mode.has_value()) {
     ESP_LOGD(TAG, "  Fan Mode: %s", LOG_STR_ARG(climate_fan_mode_to_string(this->fan_mode.value())));
   }
-  if (!traits.get_supported_custom_fan_modes().empty() && this->custom_fan_mode.has_value()) {
-    ESP_LOGD(TAG, "  Custom Fan Mode: %s", this->custom_fan_mode.value().c_str());
+  if (!traits.get_supported_custom_fan_modes().empty() && this->has_custom_fan_mode()) {
+    ESP_LOGD(TAG, "  Custom Fan Mode: %s", this->custom_fan_mode_);
   }
   if (traits.get_supports_presets() && this->preset.has_value()) {
     ESP_LOGD(TAG, "  Preset: %s", LOG_STR_ARG(climate_preset_to_string(this->preset.value())));
   }
-  if (!traits.get_supported_custom_presets().empty() && this->custom_preset.has_value()) {
-    ESP_LOGD(TAG, "  Custom Preset: %s", this->custom_preset.value().c_str());
+  if (!traits.get_supported_custom_presets().empty() && this->has_custom_preset()) {
+    ESP_LOGD(TAG, "  Custom Preset: %s", this->custom_preset_);
   }
   if (traits.get_supports_swing_modes()) {
     ESP_LOGD(TAG, "  Swing Mode: %s", LOG_STR_ARG(climate_swing_mode_to_string(this->swing_mode)));
@@ -527,7 +529,7 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   if (this->uses_custom_fan_mode) {
     if (this->custom_fan_mode < traits.get_supported_custom_fan_modes().size()) {
       call.fan_mode_.reset();
-      call.custom_fan_mode_ = *std::next(traits.get_supported_custom_fan_modes().cbegin(), this->custom_fan_mode);
+      call.custom_fan_mode_ = traits.get_supported_custom_fan_modes()[this->custom_fan_mode];
     }
   } else if (traits.supports_fan_mode(this->fan_mode)) {
     call.set_fan_mode(this->fan_mode);
@@ -535,7 +537,7 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   if (this->uses_custom_preset) {
     if (this->custom_preset < traits.get_supported_custom_presets().size()) {
       call.preset_.reset();
-      call.custom_preset_ = *std::next(traits.get_supported_custom_presets().cbegin(), this->custom_preset);
+      call.custom_preset_ = traits.get_supported_custom_presets()[this->custom_preset];
     }
   } else if (traits.supports_preset(this->preset)) {
     call.set_preset(this->preset);
@@ -562,20 +564,20 @@ void ClimateDeviceRestoreState::apply(Climate *climate) {
   if (this->uses_custom_fan_mode) {
     if (this->custom_fan_mode < traits.get_supported_custom_fan_modes().size()) {
       climate->fan_mode.reset();
-      climate->custom_fan_mode = *std::next(traits.get_supported_custom_fan_modes().cbegin(), this->custom_fan_mode);
+      climate->custom_fan_mode_ = traits.get_supported_custom_fan_modes()[this->custom_fan_mode];
     }
   } else if (traits.supports_fan_mode(this->fan_mode)) {
     climate->fan_mode = this->fan_mode;
-    climate->custom_fan_mode.reset();
+    climate->clear_custom_fan_mode_();
   }
   if (this->uses_custom_preset) {
     if (this->custom_preset < traits.get_supported_custom_presets().size()) {
       climate->preset.reset();
-      climate->custom_preset = *std::next(traits.get_supported_custom_presets().cbegin(), this->custom_preset);
+      climate->custom_preset_ = traits.get_supported_custom_presets()[this->custom_preset];
     }
   } else if (traits.supports_preset(this->preset)) {
     climate->preset = this->preset;
-    climate->custom_preset.reset();
+    climate->clear_custom_preset_();
   }
   if (traits.supports_swing_mode(this->swing_mode)) {
     climate->swing_mode = this->swing_mode;
@@ -583,28 +585,107 @@ void ClimateDeviceRestoreState::apply(Climate *climate) {
   climate->publish_state();
 }
 
-template<typename T1, typename T2> bool set_alternative(optional<T1> &dst, optional<T2> &alt, const T1 &src) {
-  bool is_changed = alt.has_value();
-  alt.reset();
-  if (is_changed || dst != src) {
-    dst = src;
-    is_changed = true;
+/** Template helper for setting primary modes (fan_mode, preset) with mutual exclusion.
+ *
+ * Climate devices have mutually exclusive mode pairs:
+ *   - fan_mode (enum) vs custom_fan_mode_ (const char*)
+ *   - preset (enum) vs custom_preset_ (const char*)
+ *
+ * Only one mode in each pair can be active at a time. This helper ensures setting a primary
+ * mode automatically clears its corresponding custom mode.
+ *
+ * Example state transitions:
+ *   Before: custom_fan_mode_="Turbo", fan_mode=nullopt
+ *   Call:   set_fan_mode_(CLIMATE_FAN_HIGH)
+ *   After:  custom_fan_mode_=nullptr,   fan_mode=CLIMATE_FAN_HIGH
+ *
+ * @param primary The primary mode optional (fan_mode or preset)
+ * @param custom_ptr Reference to the custom mode pointer (custom_fan_mode_ or custom_preset_)
+ * @param value The new primary mode value to set
+ * @return true if state changed, false if already set to this value
+ */
+template<typename T> bool set_primary_mode(optional<T> &primary, const char *&custom_ptr, T value) {
+  // Clear the custom mode (mutual exclusion)
+  bool changed = custom_ptr != nullptr;
+  custom_ptr = nullptr;
+  // Set the primary mode
+  if (changed || !primary.has_value() || primary.value() != value) {
+    primary = value;
+    return true;
   }
-  return is_changed;
+  return false;
+}
+
+/** Template helper for setting custom modes (custom_fan_mode_, custom_preset_) with mutual exclusion.
+ *
+ * This helper ensures setting a custom mode automatically clears its corresponding primary mode.
+ * It also validates that the custom mode exists in the device's supported modes (lifetime safety).
+ *
+ * Example state transitions:
+ *   Before: fan_mode=CLIMATE_FAN_HIGH, custom_fan_mode_=nullptr
+ *   Call:   set_custom_fan_mode_("Turbo")
+ *   After:  fan_mode=nullopt,          custom_fan_mode_="Turbo" (pointer from traits)
+ *
+ * Lifetime Safety:
+ *   - found_ptr must come from traits.find_custom_*_mode_()
+ *   - Only pointers found in traits are stored, ensuring they remain valid
+ *   - Prevents dangling pointers from temporary strings
+ *
+ * @param custom_ptr Reference to the custom mode pointer to set
+ * @param primary The primary mode optional to clear
+ * @param found_ptr The validated pointer from traits (nullptr if not found)
+ * @param has_custom Whether a custom mode is currently active
+ * @return true if state changed, false otherwise
+ */
+template<typename T>
+bool set_custom_mode(const char *&custom_ptr, optional<T> &primary, const char *found_ptr, bool has_custom) {
+  if (found_ptr != nullptr) {
+    // Clear the primary mode (mutual exclusion)
+    bool changed = primary.has_value();
+    primary.reset();
+    // Set the custom mode (pointer is validated by caller from traits)
+    if (changed || custom_ptr != found_ptr) {
+      custom_ptr = found_ptr;
+      return true;
+    }
+    return false;
+  }
+  // Mode not found in supported modes, clear it if currently set
+  if (has_custom) {
+    custom_ptr = nullptr;
+    return true;
+  }
+  return false;
 }
 
 bool Climate::set_fan_mode_(ClimateFanMode mode) {
-  return set_alternative(this->fan_mode, this->custom_fan_mode, mode);
+  return set_primary_mode(this->fan_mode, this->custom_fan_mode_, mode);
 }
 
-bool Climate::set_custom_fan_mode_(const std::string &mode) {
-  return set_alternative(this->custom_fan_mode, this->fan_mode, mode);
+bool Climate::set_custom_fan_mode_(const char *mode) {
+  auto traits = this->get_traits();
+  return set_custom_mode<ClimateFanMode>(this->custom_fan_mode_, this->fan_mode, traits.find_custom_fan_mode_(mode),
+                                         this->has_custom_fan_mode());
 }
 
-bool Climate::set_preset_(ClimatePreset preset) { return set_alternative(this->preset, this->custom_preset, preset); }
+void Climate::clear_custom_fan_mode_() { this->custom_fan_mode_ = nullptr; }
 
-bool Climate::set_custom_preset_(const std::string &preset) {
-  return set_alternative(this->custom_preset, this->preset, preset);
+bool Climate::set_preset_(ClimatePreset preset) { return set_primary_mode(this->preset, this->custom_preset_, preset); }
+
+bool Climate::set_custom_preset_(const char *preset) {
+  auto traits = this->get_traits();
+  return set_custom_mode<ClimatePreset>(this->custom_preset_, this->preset, traits.find_custom_preset_(preset),
+                                        this->has_custom_preset());
+}
+
+void Climate::clear_custom_preset_() { this->custom_preset_ = nullptr; }
+
+const char *Climate::find_custom_fan_mode_(const char *custom_fan_mode) {
+  return this->get_traits().find_custom_fan_mode_(custom_fan_mode);
+}
+
+const char *Climate::find_custom_preset_(const char *custom_preset) {
+  return this->get_traits().find_custom_preset_(custom_preset);
 }
 
 void Climate::dump_traits_(const char *tag) {
@@ -656,8 +737,8 @@ void Climate::dump_traits_(const char *tag) {
   }
   if (!traits.get_supported_custom_fan_modes().empty()) {
     ESP_LOGCONFIG(tag, "  Supported custom fan modes:");
-    for (const std::string &s : traits.get_supported_custom_fan_modes())
-      ESP_LOGCONFIG(tag, "  - %s", s.c_str());
+    for (const char *s : traits.get_supported_custom_fan_modes())
+      ESP_LOGCONFIG(tag, "  - %s", s);
   }
   if (!traits.get_supported_presets().empty()) {
     ESP_LOGCONFIG(tag, "  Supported presets:");
@@ -666,8 +747,8 @@ void Climate::dump_traits_(const char *tag) {
   }
   if (!traits.get_supported_custom_presets().empty()) {
     ESP_LOGCONFIG(tag, "  Supported custom presets:");
-    for (const std::string &s : traits.get_supported_custom_presets())
-      ESP_LOGCONFIG(tag, "  - %s", s.c_str());
+    for (const char *s : traits.get_supported_custom_presets())
+      ESP_LOGCONFIG(tag, "  - %s", s);
   }
   if (!traits.get_supported_swing_modes().empty()) {
     ESP_LOGCONFIG(tag, "  Supported swing modes:");

esphome/components/climate/climate.h

@@ -77,6 +77,8 @@ class ClimateCall {
   ClimateCall &set_fan_mode(const std::string &fan_mode);
   /// Set the fan mode of the climate device based on a string.
   ClimateCall &set_fan_mode(optional<std::string> fan_mode);
+  /// Set the custom fan mode of the climate device.
+  ClimateCall &set_fan_mode(const char *custom_fan_mode);
   /// Set the swing mode of the climate device.
   ClimateCall &set_swing_mode(ClimateSwingMode swing_mode);
   /// Set the swing mode of the climate device.
@@ -91,6 +93,8 @@ class ClimateCall {
   ClimateCall &set_preset(const std::string &preset);
   /// Set the preset of the climate device based on a string.
   ClimateCall &set_preset(optional<std::string> preset);
+  /// Set the custom preset of the climate device.
+  ClimateCall &set_preset(const char *custom_preset);
 
   void perform();
 
@@ -103,8 +107,10 @@ class ClimateCall {
   const optional<ClimateFanMode> &get_fan_mode() const;
   const optional<ClimateSwingMode> &get_swing_mode() const;
   const optional<ClimatePreset> &get_preset() const;
-  const optional<std::string> &get_custom_fan_mode() const;
-  const optional<std::string> &get_custom_preset() const;
+  const char *get_custom_fan_mode() const { return this->custom_fan_mode_; }
+  const char *get_custom_preset() const { return this->custom_preset_; }
+  bool has_custom_fan_mode() const { return this->custom_fan_mode_ != nullptr; }
+  bool has_custom_preset() const { return this->custom_preset_ != nullptr; }
 
  protected:
   void validate_();
@@ -118,8 +124,10 @@ class ClimateCall {
   optional<ClimateFanMode> fan_mode_;
   optional<ClimateSwingMode> swing_mode_;
   optional<ClimatePreset> preset_;
-  optional<std::string> custom_fan_mode_;
-  optional<std::string> custom_preset_;
+
+ private:
+  const char *custom_fan_mode_{nullptr};
+  const char *custom_preset_{nullptr};
 };
 
 /// Struct used to save the state of the climate device in restore memory.
@@ -212,6 +220,12 @@ class Climate : public EntityBase {
   void set_visual_min_humidity_override(float visual_min_humidity_override);
   void set_visual_max_humidity_override(float visual_max_humidity_override);
 
+  /// Check if a custom fan mode is currently active.
+  bool has_custom_fan_mode() const { return this->custom_fan_mode_ != nullptr; }
+
+  /// Check if a custom preset is currently active.
+  bool has_custom_preset() const { return this->custom_preset_ != nullptr; }
+
   /// The current temperature of the climate device, as reported from the integration.
   float current_temperature{NAN};
 
@@ -238,12 +252,6 @@ class Climate : public EntityBase {
   /// The active preset of the climate device.
   optional<ClimatePreset> preset;
 
-  /// The active custom fan mode of the climate device.
-  optional<std::string> custom_fan_mode;
-
-  /// The active custom preset mode of the climate device.
-  optional<std::string> custom_preset;
-
   /// The active mode of the climate device.
   ClimateMode mode{CLIMATE_MODE_OFF};
 
@@ -253,20 +261,37 @@ class Climate : public EntityBase {
   /// The active swing mode of the climate device.
   ClimateSwingMode swing_mode{CLIMATE_SWING_OFF};
 
+  /// Get the active custom fan mode (read-only access).
+  const char *get_custom_fan_mode() const { return this->custom_fan_mode_; }
+
+  /// Get the active custom preset (read-only access).
+  const char *get_custom_preset() const { return this->custom_preset_; }
+
  protected:
   friend ClimateCall;
+  friend struct ClimateDeviceRestoreState;
 
   /// Set fan mode. Reset custom fan mode. Return true if fan mode has been changed.
   bool set_fan_mode_(ClimateFanMode mode);
 
   /// Set custom fan mode. Reset primary fan mode. Return true if fan mode has been changed.
-  bool set_custom_fan_mode_(const std::string &mode);
+  bool set_custom_fan_mode_(const char *mode);
+  /// Clear custom fan mode.
+  void clear_custom_fan_mode_();
 
   /// Set preset. Reset custom preset. Return true if preset has been changed.
   bool set_preset_(ClimatePreset preset);
 
   /// Set custom preset. Reset primary preset. Return true if preset has been changed.
-  bool set_custom_preset_(const std::string &preset);
+  bool set_custom_preset_(const char *preset);
+  /// Clear custom preset.
+  void clear_custom_preset_();
+
+  /// Find and return the matching custom fan mode pointer from traits, or nullptr if not found.
+  const char *find_custom_fan_mode_(const char *custom_fan_mode);
+
+  /// Find and return the matching custom preset pointer from traits, or nullptr if not found.
+  const char *find_custom_preset_(const char *custom_preset);
 
   /** Get the default traits of this climate device.
    *
@@ -303,6 +328,21 @@ class Climate : public EntityBase {
   optional<float> visual_current_temperature_step_override_{};
   optional<float> visual_min_humidity_override_{};
   optional<float> visual_max_humidity_override_{};
+
+ private:
+  /** The active custom fan mode (private - enforces use of safe setters).
+   *
+   * Points to an entry in traits.supported_custom_fan_modes_ or nullptr.
+   * Use get_custom_fan_mode() to read, set_custom_fan_mode_() to modify.
+   */
+  const char *custom_fan_mode_{nullptr};
+
+  /** The active custom preset (private - enforces use of safe setters).
+   *
+   * Points to an entry in traits.supported_custom_presets_ or nullptr.
+   * Use get_custom_preset() to read, set_custom_preset_() to modify.
+   */
+  const char *custom_preset_{nullptr};
 };
 
 }  // namespace climate

esphome/components/climate/climate_traits.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstring>
 #include <vector>
 #include "climate_mode.h"
 #include "esphome/core/finite_set_mask.h"
@@ -18,16 +19,25 @@ using ClimateSwingModeMask =
     FiniteSetMask<ClimateSwingMode, DefaultBitPolicy<ClimateSwingMode, CLIMATE_SWING_HORIZONTAL + 1>>;
 using ClimatePresetMask = FiniteSetMask<ClimatePreset, DefaultBitPolicy<ClimatePreset, CLIMATE_PRESET_ACTIVITY + 1>>;
 
-// Lightweight linear search for small vectors (1-20 items)
+// Lightweight linear search for small vectors (1-20 items) of const char* pointers
 // Avoids std::find template overhead
-template<typename T> inline bool vector_contains(const std::vector<T> &vec, const T &value) {
-  for (const auto &item : vec) {
-    if (item == value)
+inline bool vector_contains(const std::vector<const char *> &vec, const char *value) {
+  for (const char *item : vec) {
+    if (strcmp(item, value) == 0)
       return true;
   }
   return false;
 }
 
+// Find and return matching pointer from vector, or nullptr if not found
+inline const char *vector_find(const std::vector<const char *> &vec, const char *value) {
+  for (const char *item : vec) {
+    if (strcmp(item, value) == 0)
+      return item;
+  }
+  return nullptr;
+}
+
 /** This class contains all static data for climate devices.
  *
  * All climate devices must support these features:
@@ -55,7 +65,11 @@ template<typename T> inline bool vector_contains(const std::vector<T> &vec, cons
  *  - temperature step - the step with which to increase/decrease target temperature.
  *     This also affects with how many decimal places the temperature is shown
  */
+class Climate;  // Forward declaration
+
 class ClimateTraits {
+  friend class Climate;  // Allow Climate to access protected find methods
+
  public:
   /// Get/set feature flags (see ClimateFeatures enum in climate_mode.h)
   uint32_t get_feature_flags() const { return this->feature_flags_; }
@@ -128,47 +142,61 @@ class ClimateTraits {
 
   void set_supported_fan_modes(ClimateFanModeMask modes) { this->supported_fan_modes_ = modes; }
   void add_supported_fan_mode(ClimateFanMode mode) { this->supported_fan_modes_.insert(mode); }
-  void add_supported_custom_fan_mode(const std::string &mode) { this->supported_custom_fan_modes_.push_back(mode); }
   bool supports_fan_mode(ClimateFanMode fan_mode) const { return this->supported_fan_modes_.count(fan_mode); }
   bool get_supports_fan_modes() const {
     return !this->supported_fan_modes_.empty() || !this->supported_custom_fan_modes_.empty();
   }
   const ClimateFanModeMask &get_supported_fan_modes() const { return this->supported_fan_modes_; }
 
-  void set_supported_custom_fan_modes(std::vector<std::string> supported_custom_fan_modes) {
-    this->supported_custom_fan_modes_ = std::move(supported_custom_fan_modes);
+  void set_supported_custom_fan_modes(std::initializer_list<const char *> modes) {
+    this->supported_custom_fan_modes_ = modes;
   }
-  void set_supported_custom_fan_modes(std::initializer_list<std::string> modes) {
+  void set_supported_custom_fan_modes(const std::vector<const char *> &modes) {
     this->supported_custom_fan_modes_ = modes;
   }
   template<size_t N> void set_supported_custom_fan_modes(const char *const (&modes)[N]) {
     this->supported_custom_fan_modes_.assign(modes, modes + N);
   }
-  const std::vector<std::string> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
-  bool supports_custom_fan_mode(const std::string &custom_fan_mode) const {
+
+  // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
+  void set_supported_custom_fan_modes(const std::vector<std::string> &modes) = delete;
+  void set_supported_custom_fan_modes(std::initializer_list<std::string> modes) = delete;
+
+  const std::vector<const char *> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
+  bool supports_custom_fan_mode(const char *custom_fan_mode) const {
     return vector_contains(this->supported_custom_fan_modes_, custom_fan_mode);
   }
+  bool supports_custom_fan_mode(const std::string &custom_fan_mode) const {
+    return this->supports_custom_fan_mode(custom_fan_mode.c_str());
+  }
 
   void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
   void add_supported_preset(ClimatePreset preset) { this->supported_presets_.insert(preset); }
-  void add_supported_custom_preset(const std::string &preset) { this->supported_custom_presets_.push_back(preset); }
   bool supports_preset(ClimatePreset preset) const { return this->supported_presets_.count(preset); }
   bool get_supports_presets() const { return !this->supported_presets_.empty(); }
   const ClimatePresetMask &get_supported_presets() const { return this->supported_presets_; }
 
-  void set_supported_custom_presets(std::vector<std::string> supported_custom_presets) {
-    this->supported_custom_presets_ = std::move(supported_custom_presets);
+  void set_supported_custom_presets(std::initializer_list<const char *> presets) {
+    this->supported_custom_presets_ = presets;
   }
-  void set_supported_custom_presets(std::initializer_list<std::string> presets) {
+  void set_supported_custom_presets(const std::vector<const char *> &presets) {
     this->supported_custom_presets_ = presets;
   }
   template<size_t N> void set_supported_custom_presets(const char *const (&presets)[N]) {
     this->supported_custom_presets_.assign(presets, presets + N);
   }
-  const std::vector<std::string> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
-  bool supports_custom_preset(const std::string &custom_preset) const {
+
+  // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
+  void set_supported_custom_presets(const std::vector<std::string> &presets) = delete;
+  void set_supported_custom_presets(std::initializer_list<std::string> presets) = delete;
+
+  const std::vector<const char *> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
+  bool supports_custom_preset(const char *custom_preset) const {
     return vector_contains(this->supported_custom_presets_, custom_preset);
   }
+  bool supports_custom_preset(const std::string &custom_preset) const {
+    return this->supports_custom_preset(custom_preset.c_str());
+  }
 
   void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
   void add_supported_swing_mode(ClimateSwingMode mode) { this->supported_swing_modes_.insert(mode); }
@@ -227,6 +255,18 @@ class ClimateTraits {
     }
   }
 
+  /// Find and return the matching custom fan mode pointer from supported modes, or nullptr if not found
+  /// This is protected as it's an implementation detail - use Climate::find_custom_fan_mode_() instead
+  const char *find_custom_fan_mode_(const char *custom_fan_mode) const {
+    return vector_find(this->supported_custom_fan_modes_, custom_fan_mode);
+  }
+
+  /// Find and return the matching custom preset pointer from supported presets, or nullptr if not found
+  /// This is protected as it's an implementation detail - use Climate::find_custom_preset_() instead
+  const char *find_custom_preset_(const char *custom_preset) const {
+    return vector_find(this->supported_custom_presets_, custom_preset);
+  }
+
   uint32_t feature_flags_{0};
   float visual_min_temperature_{10};
   float visual_max_temperature_{30};
@@ -239,8 +279,17 @@ class ClimateTraits {
   climate::ClimateFanModeMask supported_fan_modes_;
   climate::ClimateSwingModeMask supported_swing_modes_;
   climate::ClimatePresetMask supported_presets_;
-  std::vector<std::string> supported_custom_fan_modes_;
-  std::vector<std::string> supported_custom_presets_;
+
+  /** Custom mode storage using const char* pointers to eliminate std::string overhead.
+   *
+   * Pointers must remain valid for the ClimateTraits lifetime. Safe patterns:
+   *  - String literals: set_supported_custom_fan_modes({"Turbo", "Silent"})
+   *  - Static const data: static const char* MODE = "Eco";
+   *
+   * Climate class setters validate pointers are from these vectors before storing.
+   */
+  std::vector<const char *> supported_custom_fan_modes_;
+  std::vector<const char *> supported_custom_presets_;
 };
 
 }  // namespace climate

esphome/components/const/__init__.py

@@ -11,4 +11,5 @@ CONF_DRAW_ROUNDING = "draw_rounding"
 CONF_ON_RECEIVE = "on_receive"
 CONF_ON_STATE_CHANGE = "on_state_change"
 CONF_REQUEST_HEADERS = "request_headers"
+CONF_ROWS = "rows"
 CONF_USE_PSRAM = "use_psram"

esphome/components/dallas_temp/dallas_temp.cpp

@@ -70,7 +70,7 @@ bool DallasTemperatureSensor::read_scratch_pad_() {
 }
 
 void DallasTemperatureSensor::setup() {
-  if (!this->check_address_())
+  if (!this->check_address_or_index_())
     return;
   if (!this->read_scratch_pad_())
     return;

esphome/components/debug/debug_zephyr.cpp

@@ -8,8 +8,7 @@
 
 #define BOOTLOADER_VERSION_REGISTER NRF_TIMER2->CC[0]
 
-namespace esphome {
-namespace debug {
+namespace esphome::debug {
 
 static const char *const TAG = "debug";
 constexpr std::uintptr_t MBR_PARAM_PAGE_ADDR = 0xFFC;
@@ -281,14 +280,18 @@ void DebugComponent::get_device_info_(std::string &device_info) {
            NRF_FICR->INFO.VARIANT & 0xFF, package(NRF_FICR->INFO.PACKAGE));
   ESP_LOGD(TAG, "RAM: %ukB, Flash: %ukB, production test: %sdone", NRF_FICR->INFO.RAM, NRF_FICR->INFO.FLASH,
            (NRF_FICR->PRODTEST[0] == 0xBB42319F ? "" : "not "));
+  bool n_reset_enabled = NRF_UICR->PSELRESET[0] == NRF_UICR->PSELRESET[1] &&
+                         (NRF_UICR->PSELRESET[0] & UICR_PSELRESET_CONNECT_Msk) == UICR_PSELRESET_CONNECT_Connected
+                                                                                      << UICR_PSELRESET_CONNECT_Pos;
   ESP_LOGD(
       TAG, "GPIO as NFC pins: %s, GPIO as nRESET pin: %s",
       YESNO((NRF_UICR->NFCPINS & UICR_NFCPINS_PROTECT_Msk) == (UICR_NFCPINS_PROTECT_NFC << UICR_NFCPINS_PROTECT_Pos)),
-      YESNO(((NRF_UICR->PSELRESET[0] & UICR_PSELRESET_CONNECT_Msk) !=
-             (UICR_PSELRESET_CONNECT_Connected << UICR_PSELRESET_CONNECT_Pos)) ||
-            ((NRF_UICR->PSELRESET[1] & UICR_PSELRESET_CONNECT_Msk) !=
-             (UICR_PSELRESET_CONNECT_Connected << UICR_PSELRESET_CONNECT_Pos))));
-
+      YESNO(n_reset_enabled));
+  if (n_reset_enabled) {
+    uint8_t port = (NRF_UICR->PSELRESET[0] & UICR_PSELRESET_PORT_Msk) >> UICR_PSELRESET_PORT_Pos;
+    uint8_t pin = (NRF_UICR->PSELRESET[0] & UICR_PSELRESET_PIN_Msk) >> UICR_PSELRESET_PIN_Pos;
+    ESP_LOGD(TAG, "nRESET port P%u.%02u", port, pin);
+  }
 #ifdef USE_BOOTLOADER_MCUBOOT
   ESP_LOGD(TAG, "bootloader: mcuboot");
 #else
@@ -322,10 +325,22 @@ void DebugComponent::get_device_info_(std::string &device_info) {
 #endif
   }
 #endif
+  auto uicr = [](volatile uint32_t *data, uint8_t size) {
+    std::string res;
+    char buf[sizeof(uint32_t) * 2 + 1];
+    for (size_t i = 0; i < size; i++) {
+      if (i > 0) {
+        res += ' ';
+      }
+      res += format_hex_pretty<uint32_t>(data[i], '\0', false);
+    }
+    return res;
+  };
+  ESP_LOGD(TAG, "NRFFW %s", uicr(NRF_UICR->NRFFW, 13).c_str());
+  ESP_LOGD(TAG, "NRFHW %s", uicr(NRF_UICR->NRFHW, 12).c_str());
 }
 
 void DebugComponent::update_platform_() {}
 
-}  // namespace debug
-}  // namespace esphome
+}  // namespace esphome::debug
 #endif

esphome/components/demo/demo_climate.h

@@ -28,16 +28,16 @@ class DemoClimate : public climate::Climate, public Component {
         this->mode = climate::CLIMATE_MODE_AUTO;
         this->action = climate::CLIMATE_ACTION_COOLING;
         this->fan_mode = climate::CLIMATE_FAN_HIGH;
-        this->custom_preset = {"My Preset"};
+        this->set_custom_preset_("My Preset");
         break;
       case DemoClimateType::TYPE_3:
         this->current_temperature = 21.5;
         this->target_temperature_low = 21.0;
         this->target_temperature_high = 22.5;
         this->mode = climate::CLIMATE_MODE_HEAT_COOL;
-        this->custom_fan_mode = {"Auto Low"};
+        this->set_custom_fan_mode_("Auto Low");
         this->swing_mode = climate::CLIMATE_SWING_HORIZONTAL;
-        this->preset = climate::CLIMATE_PRESET_AWAY;
+        this->set_preset_(climate::CLIMATE_PRESET_AWAY);
         break;
     }
     this->publish_state();
@@ -58,23 +58,19 @@ class DemoClimate : public climate::Climate, public Component {
       this->target_temperature_high = *call.get_target_temperature_high();
     }
     if (call.get_fan_mode().has_value()) {
-      this->fan_mode = *call.get_fan_mode();
-      this->custom_fan_mode.reset();
+      this->set_fan_mode_(*call.get_fan_mode());
     }
     if (call.get_swing_mode().has_value()) {
       this->swing_mode = *call.get_swing_mode();
     }
-    if (call.get_custom_fan_mode().has_value()) {
-      this->custom_fan_mode = *call.get_custom_fan_mode();
-      this->fan_mode.reset();
+    if (call.has_custom_fan_mode()) {
+      this->set_custom_fan_mode_(call.get_custom_fan_mode());
     }
     if (call.get_preset().has_value()) {
-      this->preset = *call.get_preset();
-      this->custom_preset.reset();
+      this->set_preset_(*call.get_preset());
     }
-    if (call.get_custom_preset().has_value()) {
-      this->custom_preset = *call.get_custom_preset();
-      this->preset.reset();
+    if (call.has_custom_preset()) {
+      this->set_custom_preset_(call.get_custom_preset());
     }
     this->publish_state();
   }

esphome/components/display/display.h

@@ -210,7 +210,7 @@ class Display : public PollingComponent {
   /// Fill the entire screen with the given color.
   virtual void fill(Color color);
   /// Clear the entire screen by filling it with OFF pixels.
-  void clear();
+  virtual void clear();
 
   /// Get the calculated width of the display in pixels with rotation applied.
   virtual int get_width() { return this->get_width_internal(); }

esphome/components/e131/e131.cpp

@@ -3,6 +3,8 @@
 #include "e131_addressable_light_effect.h"
 #include "esphome/core/log.h"
 
+#include <algorithm>
+
 namespace esphome {
 namespace e131 {
 
@@ -76,14 +78,14 @@ void E131Component::loop() {
 }
 
 void E131Component::add_effect(E131AddressableLightEffect *light_effect) {
-  if (light_effects_.count(light_effect)) {
+  if (std::find(light_effects_.begin(), light_effects_.end(), light_effect) != light_effects_.end()) {
     return;
   }
 
   ESP_LOGD(TAG, "Registering '%s' for universes %d-%d.", light_effect->get_name(), light_effect->get_first_universe(),
            light_effect->get_last_universe());
 
-  light_effects_.insert(light_effect);
+  light_effects_.push_back(light_effect);
 
   for (auto universe = light_effect->get_first_universe(); universe <= light_effect->get_last_universe(); ++universe) {
     join_(universe);
@@ -91,14 +93,17 @@ void E131Component::add_effect(E131AddressableLightEffect *light_effect) {
 }
 
 void E131Component::remove_effect(E131AddressableLightEffect *light_effect) {
-  if (!light_effects_.count(light_effect)) {
+  auto it = std::find(light_effects_.begin(), light_effects_.end(), light_effect);
+  if (it == light_effects_.end()) {
     return;
   }
 
   ESP_LOGD(TAG, "Unregistering '%s' for universes %d-%d.", light_effect->get_name(), light_effect->get_first_universe(),
            light_effect->get_last_universe());
 
-  light_effects_.erase(light_effect);
+  // Swap with last element and pop for O(1) removal (order doesn't matter)
+  *it = light_effects_.back();
+  light_effects_.pop_back();
 
   for (auto universe = light_effect->get_first_universe(); universe <= light_effect->get_last_universe(); ++universe) {
     leave_(universe);

esphome/components/e131/e131.h

@@ -7,7 +7,6 @@
 #include <cinttypes>
 #include <map>
 #include <memory>
-#include <set>
 #include <vector>
 
 namespace esphome {
@@ -47,9 +46,8 @@ class E131Component : public esphome::Component {
 
   E131ListenMethod listen_method_{E131_MULTICAST};
   std::unique_ptr<socket::Socket> socket_;
-  std::set<E131AddressableLightEffect *> light_effects_;
+  std::vector<E131AddressableLightEffect *> light_effects_;
   std::map<int, int> universe_consumers_;
-  std::map<int, E131Packet> universe_packets_;
 };
 
 }  // namespace e131

esphome/components/epaper_spi/display.py

@@ -1,21 +1,35 @@
+import importlib
+import pkgutil
+
 from esphome import core, pins
 import esphome.codegen as cg
 from esphome.components import display, spi
+from esphome.components.mipi import flatten_sequence, map_sequence
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BUSY_PIN,
+    CONF_CS_PIN,
+    CONF_DATA_RATE,
     CONF_DC_PIN,
+    CONF_DIMENSIONS,
+    CONF_ENABLE_PIN,
+    CONF_HEIGHT,
     CONF_ID,
+    CONF_INIT_SEQUENCE,
     CONF_LAMBDA,
     CONF_MODEL,
-    CONF_PAGES,
     CONF_RESET_DURATION,
     CONF_RESET_PIN,
+    CONF_WIDTH,
 )
 
+from . import models
+
 AUTO_LOAD = ["split_buffer"]
 DEPENDENCIES = ["spi"]
 
+CONF_INIT_SEQUENCE_ID = "init_sequence_id"
+
 epaper_spi_ns = cg.esphome_ns.namespace("epaper_spi")
 EPaperBase = epaper_spi_ns.class_(
     "EPaperBase", cg.PollingComponent, spi.SPIDevice, display.DisplayBuffer
@@ -24,29 +38,78 @@ EPaperBase = epaper_spi_ns.class_(
 EPaperSpectraE6 = epaper_spi_ns.class_("EPaperSpectraE6", EPaperBase)
 EPaper7p3InSpectraE6 = epaper_spi_ns.class_("EPaper7p3InSpectraE6", EPaperSpectraE6)
 
-MODELS = {
-    "7.3in-spectra-e6": EPaper7p3InSpectraE6,
-}
 
+# Import all models dynamically from the models package
+for module_info in pkgutil.iter_modules(models.__path__):
+    importlib.import_module(f".models.{module_info.name}", package=__package__)
 
-CONFIG_SCHEMA = cv.All(
-    display.FULL_DISPLAY_SCHEMA.extend(
+MODELS = models.EpaperModel.models
+
+DIMENSION_SCHEMA = cv.Schema(
     {
-            cv.GenerateID(): cv.declare_id(EPaperBase),
-            cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_MODEL): cv.one_of(*MODELS, lower=True, space="-"),
-            cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
-            cv.Optional(CONF_BUSY_PIN): pins.gpio_input_pin_schema,
-            cv.Optional(CONF_RESET_DURATION): cv.All(
+        cv.Required(CONF_WIDTH): cv.int_,
+        cv.Required(CONF_HEIGHT): cv.int_,
+    }
+)
+
+
+def model_schema(config):
+    model = MODELS[config[CONF_MODEL]]
+    class_name = epaper_spi_ns.class_(model.class_name, EPaperBase)
+    cv_dimensions = cv.Optional if model.get_default(CONF_WIDTH) else cv.Required
+    return (
+        display.FULL_DISPLAY_SCHEMA.extend(
+            spi.spi_device_schema(
+                cs_pin_required=False,
+                default_mode="MODE0",
+                default_data_rate=model.get_default(CONF_DATA_RATE, 10_000_000),
+            )
+        )
+        .extend(
+            {
+                model.option(pin): pins.gpio_output_pin_schema
+                for pin in (CONF_RESET_PIN, CONF_CS_PIN, CONF_BUSY_PIN)
+            }
+        )
+        .extend(
+            {
+                cv.Required(CONF_MODEL): cv.one_of(model.name, upper=True),
+                model.option(CONF_DC_PIN, fallback=None): pins.gpio_output_pin_schema,
+                cv.GenerateID(): cv.declare_id(class_name),
+                cv.GenerateID(CONF_INIT_SEQUENCE_ID): cv.declare_id(cg.uint8),
+                cv_dimensions(CONF_DIMENSIONS): DIMENSION_SCHEMA,
+                model.option(CONF_ENABLE_PIN): cv.ensure_list(
+                    pins.gpio_output_pin_schema
+                ),
+                model.option(CONF_INIT_SEQUENCE, cv.UNDEFINED): cv.ensure_list(
+                    map_sequence
+                ),
+                model.option(CONF_RESET_DURATION, cv.UNDEFINED): cv.All(
                     cv.positive_time_period_milliseconds,
                     cv.Range(max=core.TimePeriod(milliseconds=500)),
                 ),
             }
         )
-    .extend(cv.polling_component_schema("60s"))
-    .extend(spi.spi_device_schema()),
-    cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
-)
+    )
+
+
+def customise_schema(config):
+    """
+    Create a customised config schema for a specific model and validate the configuration.
+    :param config: The configuration dictionary to validate
+    :return: The validated configuration dictionary
+    :raises cv.Invalid: If the configuration is invalid
+    """
+    config = cv.Schema(
+        {
+            cv.Required(CONF_MODEL): cv.one_of(*MODELS, upper=True),
+        },
+        extra=cv.ALLOW_EXTRA,
+    )(config)
+    return model_schema(config)(config)
+
+
+CONFIG_SCHEMA = customise_schema
 
 FINAL_VALIDATE_SCHEMA = spi.final_validate_device_schema(
     "epaper_spi", require_miso=False, require_mosi=True
@@ -56,8 +119,23 @@ FINAL_VALIDATE_SCHEMA = spi.final_validate_device_schema(
 async def to_code(config):
     model = MODELS[config[CONF_MODEL]]
 
-    rhs = model.new()
-    var = cg.Pvariable(config[CONF_ID], rhs, model)
+    init_sequence = config.get(CONF_INIT_SEQUENCE)
+    if init_sequence is None:
+        init_sequence = model.get_init_sequence(config)
+    init_sequence = flatten_sequence(init_sequence)
+    init_sequence_length = len(init_sequence)
+    init_sequence_id = cg.static_const_array(
+        config[CONF_INIT_SEQUENCE_ID], init_sequence
+    )
+    width, height = model.get_dimensions(config)
+    var = cg.new_Pvariable(
+        config[CONF_ID],
+        model.name,
+        width,
+        height,
+        init_sequence_id,
+        init_sequence_length,
+    )
 
     await display.register_display(var, config)
     await spi.register_spi_device(var, config)

esphome/components/epaper_spi/epaper_spi.cpp

@@ -8,33 +8,20 @@ namespace esphome::epaper_spi {
 
 static const char *const TAG = "epaper_spi";
 
-static const LogString *epaper_state_to_string(EPaperState state) {
-  switch (state) {
-    case EPaperState::IDLE:
-      return LOG_STR("IDLE");
-    case EPaperState::UPDATE:
-      return LOG_STR("UPDATE");
-    case EPaperState::RESET:
-      return LOG_STR("RESET");
-    case EPaperState::INITIALISE:
-      return LOG_STR("INITIALISE");
-    case EPaperState::TRANSFER_DATA:
-      return LOG_STR("TRANSFER_DATA");
-    case EPaperState::POWER_ON:
-      return LOG_STR("POWER_ON");
-    case EPaperState::REFRESH_SCREEN:
-      return LOG_STR("REFRESH_SCREEN");
-    case EPaperState::POWER_OFF:
-      return LOG_STR("POWER_OFF");
-    case EPaperState::DEEP_SLEEP:
-      return LOG_STR("DEEP_SLEEP");
-    default:
-      return LOG_STR("UNKNOWN");
-  }
+static constexpr const char *const EPAPER_STATE_STRINGS[] = {
+    "IDLE",        "UPDATE",     "RESET",         "RESET_END",
+
+    "SHOULD_WAIT", "INITIALISE", "TRANSFER_DATA", "POWER_ON",  "REFRESH_SCREEN", "POWER_OFF", "DEEP_SLEEP",
+};
+
+const char *EPaperBase::epaper_state_to_string_() {
+  if (auto idx = static_cast<unsigned>(this->state_); idx < std::size(EPAPER_STATE_STRINGS))
+    return EPAPER_STATE_STRINGS[idx];
+  return "Unknown";
 }
 
 void EPaperBase::setup() {
-  if (!this->init_buffer_(this->get_buffer_length())) {
+  if (!this->init_buffer_(this->buffer_length_)) {
     this->mark_failed("Failed to initialise buffer");
     return;
   }
@@ -50,7 +37,7 @@ bool EPaperBase::init_buffer_(size_t buffer_length) {
   return true;
 }
 
-void EPaperBase::setup_pins_() {
+void EPaperBase::setup_pins_() const {
   this->dc_pin_->setup();  // OUTPUT
   this->dc_pin_->digital_write(false);
 
@@ -81,11 +68,7 @@ void EPaperBase::data(uint8_t value) {
 // write a command followed by zero or more bytes of data.
 // The command is the first byte, length is the length of data only in the second byte, followed by the data.
 // [COMMAND, LENGTH, DATA...]
-void EPaperBase::cmd_data(const uint8_t *data) {
-  const uint8_t command = data[0];
-  const uint8_t length = data[1];
-  const uint8_t *ptr = data + 2;
-
+void EPaperBase::cmd_data(uint8_t command, const uint8_t *ptr, size_t length) {
   ESP_LOGVV(TAG, "Command: 0x%02X, Length: %d, Data: %s", command, length,
             format_hex_pretty(ptr, length, '.', false).c_str());
 
@@ -99,91 +82,146 @@ void EPaperBase::cmd_data(const uint8_t *data) {
   this->disable();
 }
 
-bool EPaperBase::is_idle_() {
+bool EPaperBase::is_idle_() const {
   if (this->busy_pin_ == nullptr) {
     return true;
   }
-  return this->busy_pin_->digital_read();
+  return !this->busy_pin_->digital_read();
 }
 
-void EPaperBase::reset() {
+bool EPaperBase::reset_() const {
   if (this->reset_pin_ != nullptr) {
+    if (this->state_ == EPaperState::RESET) {
       this->reset_pin_->digital_write(false);
-    this->disable_loop();
-    this->set_timeout(this->reset_duration_, [this] {
-      this->reset_pin_->digital_write(true);
-      this->set_timeout(20, [this] { this->enable_loop(); });
-    });
+      return false;
     }
+    this->reset_pin_->digital_write(true);
+  }
+  return true;
 }
 
 void EPaperBase::update() {
-  if (!this->state_queue_.empty()) {
-    ESP_LOGE(TAG, "Display update already in progress - %s",
-             LOG_STR_ARG(epaper_state_to_string(this->state_queue_.front())));
+  if (this->state_ != EPaperState::IDLE) {
+    ESP_LOGE(TAG, "Display already in state %s", epaper_state_to_string_());
     return;
   }
-
-  this->state_queue_.push(EPaperState::UPDATE);
-  this->state_queue_.push(EPaperState::RESET);
-  this->state_queue_.push(EPaperState::INITIALISE);
-  this->state_queue_.push(EPaperState::TRANSFER_DATA);
-  this->state_queue_.push(EPaperState::POWER_ON);
-  this->state_queue_.push(EPaperState::REFRESH_SCREEN);
-  this->state_queue_.push(EPaperState::POWER_OFF);
-  this->state_queue_.push(EPaperState::DEEP_SLEEP);
-  this->state_queue_.push(EPaperState::IDLE);
-
+  this->set_state_(EPaperState::RESET);
   this->enable_loop();
 }
 
+void EPaperBase::wait_for_idle_(bool should_wait) {
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  if (should_wait) {
+    this->waiting_for_idle_start_ = millis();
+    this->waiting_for_idle_last_print_ = this->waiting_for_idle_start_;
+  }
+#endif
+  this->waiting_for_idle_ = should_wait;
+}
+
+/**
+ * Called during the loop task.
+ * First defer for any pending delays, then check if we are waiting for the display to become idle.
+ * If not waiting for idle, process the state machine.
+ */
+
 void EPaperBase::loop() {
+  auto now = millis();
+  if (this->delay_until_ != 0) {
+    // using modulus arithmetic to handle wrap-around
+    int diff = now - this->delay_until_;
+    if (diff < 0) {
+      return;
+    }
+    this->delay_until_ = 0;
+  }
   if (this->waiting_for_idle_) {
     if (this->is_idle_()) {
       this->waiting_for_idle_ = false;
+      ESP_LOGV(TAG, "Screen now idle after %u ms", (unsigned) (millis() - this->waiting_for_idle_start_));
     } else {
-      if (App.get_loop_component_start_time() - this->waiting_for_idle_last_print_ >= 1000) {
-        ESP_LOGV(TAG, "Waiting for idle");
-        this->waiting_for_idle_last_print_ = App.get_loop_component_start_time();
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+      if (now - this->waiting_for_idle_last_print_ >= 1000) {
+        ESP_LOGV(TAG, "Waiting for idle in state %s", this->epaper_state_to_string_());
+        this->waiting_for_idle_last_print_ = millis();
       }
+#endif
       return;
     }
   }
+  this->process_state_();
+}
 
-  auto state = this->state_queue_.front();
-
-  switch (state) {
+/**
+ * Process the state machine.
+ * Typical state sequence:
+ * IDLE -> RESET -> RESET_END -> UPDATE -> INITIALISE -> TRANSFER_DATA -> POWER_ON -> REFRESH_SCREEN -> POWER_OFF ->
+ * DEEP_SLEEP -> IDLE
+ *
+ * Should a subclassed class need to override this, the method will need to be made virtual.
+ */
+void EPaperBase::process_state_() {
+  ESP_LOGV(TAG, "Process state entered in state %s", epaper_state_to_string_());
+  switch (this->state_) {
+    default:
+      ESP_LOGD(TAG, "Display is in unhandled state %s", epaper_state_to_string_());
+      this->disable_loop();
+      break;
     case EPaperState::IDLE:
       this->disable_loop();
       break;
+    case EPaperState::RESET:
+    case EPaperState::RESET_END:
+      if (this->reset_()) {
+        this->set_state_(EPaperState::UPDATE);
+      } else {
+        this->set_state_(EPaperState::RESET_END);
+      }
+      break;
     case EPaperState::UPDATE:
       this->do_update_();  // Calls ESPHome (current page) lambda
-      break;
-    case EPaperState::RESET:
-      this->reset();
+      this->set_state_(EPaperState::INITIALISE);
       break;
     case EPaperState::INITIALISE:
       this->initialise_();
+      this->set_state_(EPaperState::TRANSFER_DATA);
       break;
     case EPaperState::TRANSFER_DATA:
       if (!this->transfer_data()) {
         return;  // Not done yet, come back next loop
       }
+      this->set_state_(EPaperState::POWER_ON);
       break;
     case EPaperState::POWER_ON:
       this->power_on();
+      this->set_state_(EPaperState::REFRESH_SCREEN);
       break;
     case EPaperState::REFRESH_SCREEN:
       this->refresh_screen();
+      this->set_state_(EPaperState::POWER_OFF);
       break;
     case EPaperState::POWER_OFF:
       this->power_off();
+      this->set_state_(EPaperState::DEEP_SLEEP);
       break;
     case EPaperState::DEEP_SLEEP:
       this->deep_sleep();
+      this->set_state_(EPaperState::IDLE);
       break;
   }
-  this->state_queue_.pop();
+}
+
+void EPaperBase::set_state_(EPaperState state, uint16_t delay) {
+  ESP_LOGV(TAG, "Exit state %s", this->epaper_state_to_string_());
+  this->state_ = state;
+  this->wait_for_idle_(state > EPaperState::SHOULD_WAIT);
+  if (delay != 0) {
+    this->delay_until_ = millis() + delay;
+  } else {
+    this->delay_until_ = 0;
+  }
+  ESP_LOGV(TAG, "Enter state %s, delay %u, wait_for_idle=%s", this->epaper_state_to_string_(), delay,
+           TRUEFALSE(this->waiting_for_idle_));
 }
 
 void EPaperBase::start_command_() {
@@ -203,25 +241,39 @@ void EPaperBase::on_safe_shutdown() { this->deep_sleep(); }
 
 void EPaperBase::initialise_() {
   size_t index = 0;
-  const auto &sequence = this->init_sequence_;
-  const size_t sequence_size = this->init_sequence_length_;
-  while (index != sequence_size) {
-    if (sequence_size - index < 2) {
+
+  auto *sequence = this->init_sequence_;
+  auto length = this->init_sequence_length_;
+  while (index != length) {
+    if (length - index < 2) {
       this->mark_failed("Malformed init sequence");
       return;
     }
-    const auto *ptr = sequence + index;
-    const uint8_t length = ptr[1];
-    if (sequence_size - index < length + 2) {
-      this->mark_failed("Malformed init sequence");
+    const uint8_t cmd = sequence[index++];
+    if (const uint8_t x = sequence[index++]; x == DELAY_FLAG) {
+      ESP_LOGV(TAG, "Delay %dms", cmd);
+      delay(cmd);
+    } else {
+      const uint8_t num_args = x & 0x7F;
+      if (length - index < num_args) {
+        ESP_LOGE(TAG, "Malformed init sequence, cmd = %X, num_args = %u", cmd, num_args);
+        this->mark_failed();
         return;
       }
-
-    this->cmd_data(ptr);
-    index += length + 2;
+      ESP_LOGV(TAG, "Command %02X, length %d", cmd, num_args);
+      this->cmd_data(cmd, sequence + index, num_args);
+      index += num_args;
     }
+  }
+}
 
-  this->power_on();
+void EPaperBase::dump_config() {
+  LOG_DISPLAY("", "E-Paper SPI", this);
+  ESP_LOGCONFIG(TAG, "  Model: %s", this->name_);
+  LOG_PIN("  Reset Pin: ", this->reset_pin_);
+  LOG_PIN("  DC Pin: ", this->dc_pin_);
+  LOG_PIN("  Busy Pin: ", this->busy_pin_);
+  LOG_UPDATE_INTERVAL(this);
 }
 
 }  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi.h

@@ -8,36 +8,48 @@
 #include <queue>
 
 namespace esphome::epaper_spi {
+using namespace display;
 
 enum class EPaperState : uint8_t {
-  IDLE,
-  UPDATE,
-  RESET,
-  INITIALISE,
-  TRANSFER_DATA,
-  POWER_ON,
-  REFRESH_SCREEN,
-  POWER_OFF,
-  DEEP_SLEEP,
+  IDLE,       // not doing anything
+  UPDATE,     // update the buffer
+  RESET,      // drive reset low (active)
+  RESET_END,  // drive reset high (inactive)
+
+  SHOULD_WAIT,     // states higher than this should wait for the display to be not busy
+  INITIALISE,      // send the init sequence
+  TRANSFER_DATA,   // transfer data to the display
+  POWER_ON,        // power on the display
+  REFRESH_SCREEN,  // send refresh command
+  POWER_OFF,       // power off the display
+  DEEP_SLEEP,      // deep sleep the display
 };
 
-static const uint8_t MAX_TRANSFER_TIME = 10;  // Transfer in 10ms blocks to allow the loop to run
+static constexpr uint8_t MAX_TRANSFER_TIME = 10;  // Transfer in 10ms blocks to allow the loop to run
+static constexpr uint8_t DELAY_FLAG = 0xFF;
 
-class EPaperBase : public display::DisplayBuffer,
+class EPaperBase : public DisplayBuffer,
                    public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
                                          spi::DATA_RATE_2MHZ> {
  public:
-  EPaperBase(const uint8_t *init_sequence, const size_t init_sequence_length)
-      : init_sequence_length_(init_sequence_length), init_sequence_(init_sequence) {}
+  EPaperBase(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
+             size_t init_sequence_length, DisplayType display_type = DISPLAY_TYPE_BINARY)
+      : name_(name),
+        width_(width),
+        height_(height),
+        init_sequence_(init_sequence),
+        init_sequence_length_(init_sequence_length),
+        display_type_(display_type) {}
   void set_dc_pin(GPIOPin *dc_pin) { dc_pin_ = dc_pin; }
   float get_setup_priority() const override;
   void set_reset_pin(GPIOPin *reset) { this->reset_pin_ = reset; }
   void set_busy_pin(GPIOPin *busy) { this->busy_pin_ = busy; }
   void set_reset_duration(uint32_t reset_duration) { this->reset_duration_ = reset_duration; }
+  void dump_config() override;
 
   void command(uint8_t value);
   void data(uint8_t value);
-  void cmd_data(const uint8_t *data);
+  void cmd_data(uint8_t command, const uint8_t *ptr, size_t length);
 
   void update() override;
   void loop() override;
@@ -46,48 +58,84 @@ class EPaperBase : public display::DisplayBuffer,
 
   void on_safe_shutdown() override;
 
+  DisplayType get_display_type() override { return this->display_type_; };
+
  protected:
-  bool is_idle_();
-  void setup_pins_();
-  virtual void reset();
+  int get_height_internal() override { return this->height_; };
+  int get_width_internal() override { return this->width_; };
+  void process_state_();
+
+  const char *epaper_state_to_string_();
+  bool is_idle_() const;
+  void setup_pins_() const;
+  bool reset_() const;
   void initialise_();
+  void wait_for_idle_(bool should_wait);
   bool init_buffer_(size_t buffer_length);
 
   virtual int get_width_controller() { return this->get_width_internal(); };
-  virtual void deep_sleep() = 0;
+
+  /**
+   * Methods that must be implemented by concrete classes to control the display
+   */
   /**
    * Send data to the device via SPI
-   * @return true if done, false if should be called next loop
+   * @return true if done, false if it should be called next loop
    */
   virtual bool transfer_data() = 0;
+  /**
+   * Refresh the screen after data transfer
+   */
   virtual void refresh_screen() = 0;
 
+  /**
+   * Power the display on
+   */
   virtual void power_on() = 0;
+  /**
+   * Power the display off
+   */
   virtual void power_off() = 0;
-  virtual uint32_t get_buffer_length() = 0;
+
+  /**
+   * Place the display into deep sleep
+   */
+  virtual void deep_sleep() = 0;
+
+  void set_state_(EPaperState state, uint16_t delay = 0);
 
   void start_command_();
   void end_command_();
   void start_data_();
   void end_data_();
 
-  const size_t init_sequence_length_{0};
+  // properties initialised in the constructor
+  const char *name_;
+  uint16_t width_;
+  uint16_t height_;
+  const uint8_t *init_sequence_;
+  size_t init_sequence_length_;
+  DisplayType display_type_;
 
-  size_t current_data_index_{0};
+  size_t buffer_length_{};
+  size_t current_data_index_{0};  // used by data transfer to track progress
   uint32_t reset_duration_{200};
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  uint32_t transfer_start_time_{};
   uint32_t waiting_for_idle_last_print_{0};
+  uint32_t waiting_for_idle_start_{0};
+#endif
 
-  GPIOPin *dc_pin_;
-  GPIOPin *busy_pin_{nullptr};
-  GPIOPin *reset_pin_{nullptr};
-
-  const uint8_t *init_sequence_{nullptr};
+  GPIOPin *dc_pin_{};
+  GPIOPin *busy_pin_{};
+  GPIOPin *reset_pin_{};
 
   bool waiting_for_idle_{false};
+  uint32_t delay_until_{0};
 
   split_buffer::SplitBuffer buffer_;
 
-  std::queue<EPaperState> state_queue_{{EPaperState::IDLE}};
+  EPaperState state_{EPaperState::IDLE};
 };
 
 }  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi_model_7p3in_spectra_e6.cpp

@@ -1,42 +0,0 @@
-#include "epaper_spi_model_7p3in_spectra_e6.h"
-
-namespace esphome::epaper_spi {
-
-static constexpr const char *const TAG = "epaper_spi.7.3in-spectra-e6";
-
-void EPaper7p3InSpectraE6::power_on() {
-  ESP_LOGI(TAG, "Power on");
-  this->command(0x04);
-  this->waiting_for_idle_ = true;
-}
-
-void EPaper7p3InSpectraE6::power_off() {
-  ESP_LOGI(TAG, "Power off");
-  this->command(0x02);
-  this->data(0x00);
-  this->waiting_for_idle_ = true;
-}
-
-void EPaper7p3InSpectraE6::refresh_screen() {
-  ESP_LOGI(TAG, "Refresh");
-  this->command(0x12);
-  this->data(0x00);
-  this->waiting_for_idle_ = true;
-}
-
-void EPaper7p3InSpectraE6::deep_sleep() {
-  ESP_LOGI(TAG, "Deep sleep");
-  this->command(0x07);
-  this->data(0xA5);
-}
-
-void EPaper7p3InSpectraE6::dump_config() {
-  LOG_DISPLAY("", "E-Paper SPI", this);
-  ESP_LOGCONFIG(TAG, "  Model: 7.3in Spectra E6");
-  LOG_PIN("  Reset Pin: ", this->reset_pin_);
-  LOG_PIN("  DC Pin: ", this->dc_pin_);
-  LOG_PIN("  Busy Pin: ", this->busy_pin_);
-  LOG_UPDATE_INTERVAL(this);
-}
-
-}  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi_model_7p3in_spectra_e6.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include "epaper_spi_spectra_e6.h"
-
-namespace esphome::epaper_spi {
-
-class EPaper7p3InSpectraE6 : public EPaperSpectraE6 {
-  static constexpr const uint16_t WIDTH = 800;
-  static constexpr const uint16_t HEIGHT = 480;
-  // clang-format off
-
-  // Command, data length, data
-  static constexpr uint8_t INIT_SEQUENCE[] = {
-    0xAA, 6, 0x49, 0x55, 0x20, 0x08, 0x09, 0x18,
-    0x01, 1, 0x3F,
-    0x00, 2, 0x5F, 0x69,
-    0x03, 4, 0x00, 0x54, 0x00, 0x44,
-    0x05, 4, 0x40, 0x1F, 0x1F, 0x2C,
-    0x06, 4, 0x6F, 0x1F, 0x17, 0x49,
-    0x08, 4, 0x6F, 0x1F, 0x1F, 0x22,
-    0x30, 1, 0x03,
-    0x50, 1, 0x3F,
-    0x60, 2, 0x02, 0x00,
-    0x61, 4, WIDTH / 256, WIDTH % 256, HEIGHT / 256, HEIGHT % 256,
-    0x84, 1, 0x01,
-    0xE3, 1, 0x2F,
-  };
-  // clang-format on
-
- public:
-  EPaper7p3InSpectraE6() : EPaperSpectraE6(INIT_SEQUENCE, sizeof(INIT_SEQUENCE)) {}
-
-  void dump_config() override;
-
- protected:
-  int get_width_internal() override { return WIDTH; };
-  int get_height_internal() override { return HEIGHT; };
-
-  void refresh_screen() override;
-  void power_on() override;
-  void power_off() override;
-  void deep_sleep() override;
-};
-
-}  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi_spectra_e6.cpp

@@ -1,135 +1,166 @@
 #include "epaper_spi_spectra_e6.h"
 
+#include <algorithm>
+
 #include "esphome/core/log.h"
 
 namespace esphome::epaper_spi {
-
 static constexpr const char *const TAG = "epaper_spi.6c";
+static constexpr size_t MAX_TRANSFER_SIZE = 128;
+static constexpr unsigned char GRAY_THRESHOLD = 50;
 
-static inline uint8_t color_to_hex(Color color) {
-  if (color.red > 127) {
-    if (color.green > 170) {
-      if (color.blue > 127) {
-        return 0x1;  // White
-      } else {
-        return 0x2;  // Yellow
+enum E6Color {
+  BLACK,
+  WHITE,
+  YELLOW,
+  RED,
+  SKIP_1,
+  BLUE,
+  GREEN,
+  CYAN,
+  SKIP_2,
+};
+
+static uint8_t color_to_hex(Color color) {
+  // --- Step 1: Check for Grayscale (Black or White) ---
+  // We define "grayscale" as a color where the min and max components
+  // are close to each other.
+  unsigned char max_rgb = std::max({color.r, color.g, color.b});
+  unsigned char min_rgb = std::min({color.r, color.g, color.b});
+
+  if ((max_rgb - min_rgb) < GRAY_THRESHOLD) {
+    // It's a shade of gray. Map to BLACK or WHITE.
+    // We split the luminance at the halfway point (382 = (255*3)/2)
+    if ((static_cast<int>(color.r) + color.g + color.b) > 382) {
+      return WHITE;
     }
-    } else {
-      return 0x3;  // Red (or Magenta)
+    return BLACK;
   }
-  } else {
-    if (color.green > 127) {
-      if (color.blue > 127) {
-        return 0x5;  // Cyan -> Blue
-      } else {
-        return 0x6;  // Green
+  // --- Step 2: Check for Primary/Secondary Colors ---
+  // If it's not gray, it's a color. We check which components are
+  // "on" (over 128) vs "off". This divides the RGB cube into 8 corners.
+  bool r_on = (color.r > 128);
+  bool g_on = (color.g > 128);
+  bool b_on = (color.b > 128);
+
+  if (r_on && g_on && !b_on) {
+    return YELLOW;
   }
-    } else {
-      if (color.blue > 127) {
-        return 0x5;  // Blue
-      } else {
-        return 0x0;  // Black
+  if (r_on && !g_on && !b_on) {
+    return RED;
   }
+  if (!r_on && g_on && !b_on) {
+    return GREEN;
   }
+  if (!r_on && !g_on && b_on) {
+    return BLUE;
   }
+  // Handle "impure" colors (Cyan, Magenta)
+  if (!r_on && g_on && b_on) {
+    // Cyan (G+B) -> Closest is Green or Blue. Pick Green.
+    return GREEN;
+  }
+  if (r_on && !g_on) {
+    // Magenta (R+B) -> Closest is Red or Blue. Pick Red.
+    return RED;
+  }
+  // Handle the remaining corners (White-ish, Black-ish)
+  if (r_on) {
+    // All high (but not gray) -> White
+    return WHITE;
+  }
+  // !r_on && !g_on && !b_on
+  // All low (but not gray) -> Black
+  return BLACK;
+}
+
+void EPaperSpectraE6::power_on() {
+  ESP_LOGD(TAG, "Power on");
+  this->command(0x04);
+}
+
+void EPaperSpectraE6::power_off() {
+  ESP_LOGD(TAG, "Power off");
+  this->command(0x02);
+  this->data(0x00);
+}
+
+void EPaperSpectraE6::refresh_screen() {
+  ESP_LOGD(TAG, "Refresh");
+  this->command(0x12);
+  this->data(0x00);
+}
+
+void EPaperSpectraE6::deep_sleep() {
+  ESP_LOGD(TAG, "Deep sleep");
+  this->command(0x07);
+  this->data(0xA5);
 }
 
 void EPaperSpectraE6::fill(Color color) {
-  uint8_t pixel_color;
-  if (color.is_on()) {
-    pixel_color = color_to_hex(color);
-  } else {
-    pixel_color = 0x1;
-  }
+  auto pixel_color = color_to_hex(color);
 
-  // We store 8 bitset<3> in 3 bytes
-  // | byte 1 | byte 2 | byte 3 |
-  // |aaabbbaa|abbbaaab|bbaaabbb|
-  uint8_t byte_1 = pixel_color << 5 | pixel_color << 2 | pixel_color >> 1;
-  uint8_t byte_2 = pixel_color << 7 | pixel_color << 4 | pixel_color << 1 | pixel_color >> 2;
-  uint8_t byte_3 = pixel_color << 6 | pixel_color << 3 | pixel_color << 0;
-
-  const size_t buffer_length = this->get_buffer_length();
-  for (size_t i = 0; i < buffer_length; i += 3) {
-    this->buffer_[i + 0] = byte_1;
-    this->buffer_[i + 1] = byte_2;
-    this->buffer_[i + 2] = byte_3;
-  }
+  // We store 2 pixels per byte
+  this->buffer_.fill(pixel_color + (pixel_color << 4));
 }
 
-uint32_t EPaperSpectraE6::get_buffer_length() {
-  // 6 colors buffer, 1 pixel = 3 bits, we will store 8 pixels in 24 bits = 3 bytes
-  return this->get_width_controller() * this->get_height_internal() / 8u * 3u;
+void EPaperSpectraE6::clear() {
+  // clear buffer to white, just like real paper.
+  this->fill(COLOR_ON);
 }
 
 void HOT EPaperSpectraE6::draw_absolute_pixel_internal(int x, int y, Color color) {
-  if (x >= this->get_width_internal() || y >= this->get_height_internal() || x < 0 || y < 0)
+  if (x >= this->width_ || y >= this->height_ || x < 0 || y < 0)
     return;
 
-  uint8_t pixel_bits = color_to_hex(color);
+  auto pixel_bits = color_to_hex(color);
   uint32_t pixel_position = x + y * this->get_width_controller();
-  uint32_t first_bit_position = pixel_position * 3;
-  uint32_t byte_position = first_bit_position / 8u;
-  uint32_t byte_subposition = first_bit_position % 8u;
-
-  if (byte_subposition <= 5) {
-    this->buffer_[byte_position] = (this->buffer_[byte_position] & (0xFF ^ (0b111 << (5 - byte_subposition)))) |
-                                   (pixel_bits << (5 - byte_subposition));
+  uint32_t byte_position = pixel_position / 2;
+  auto original = this->buffer_[byte_position];
+  if ((pixel_position & 1) != 0) {
+    this->buffer_[byte_position] = (original & 0xF0) | pixel_bits;
   } else {
-    this->buffer_[byte_position] = (this->buffer_[byte_position] & (0xFF ^ (0b111 >> (byte_subposition - 5)))) |
-                                   (pixel_bits >> (byte_subposition - 5));
-
-    this->buffer_[byte_position + 1] =
-        (this->buffer_[byte_position + 1] & (0xFF ^ (0xFF & (0b111 << (13 - byte_subposition))))) |
-        (pixel_bits << (13 - byte_subposition));
+    this->buffer_[byte_position] = (original & 0x0F) | (pixel_bits << 4);
   }
 }
 
 bool HOT EPaperSpectraE6::transfer_data() {
   const uint32_t start_time = App.get_loop_component_start_time();
+  const size_t buffer_length = this->buffer_length_;
   if (this->current_data_index_ == 0) {
-    ESP_LOGV(TAG, "Sending data");
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+    this->transfer_start_time_ = millis();
+#endif
+    ESP_LOGV(TAG, "Start sending data at %ums", (unsigned) millis());
     this->command(0x10);
   }
 
-  uint8_t bytes_to_send[4]{0};
-  const size_t buffer_length = this->get_buffer_length();
-  for (size_t i = this->current_data_index_; i < buffer_length; i += 3) {
-    const uint32_t triplet = encode_uint24(this->buffer_[i + 0], this->buffer_[i + 1], this->buffer_[i + 2]);
-    // 8 pixels are stored in 3 bytes
-    // |aaabbbaa|abbbaaab|bbaaabbb|
-    // | byte 1 | byte 2 | byte 3 |
-    bytes_to_send[0] = ((triplet >> 17) & 0b01110000) | ((triplet >> 18) & 0b00000111);
-    bytes_to_send[1] = ((triplet >> 11) & 0b01110000) | ((triplet >> 12) & 0b00000111);
-    bytes_to_send[2] = ((triplet >> 5) & 0b01110000) | ((triplet >> 6) & 0b00000111);
-    bytes_to_send[3] = ((triplet << 1) & 0b01110000) | ((triplet << 0) & 0b00000111);
+  size_t buf_idx = 0;
+  uint8_t bytes_to_send[MAX_TRANSFER_SIZE];
+  while (this->current_data_index_ != buffer_length) {
+    bytes_to_send[buf_idx++] = this->buffer_[this->current_data_index_++];
 
+    if (buf_idx == sizeof bytes_to_send) {
       this->start_data_();
-    this->write_array(bytes_to_send, sizeof(bytes_to_send));
+      this->write_array(bytes_to_send, buf_idx);
       this->end_data_();
+      ESP_LOGV(TAG, "Wrote %d bytes at %ums", buf_idx, (unsigned) millis());
+      buf_idx = 0;
 
       if (millis() - start_time > MAX_TRANSFER_TIME) {
         // Let the main loop run and come back next loop
-      this->current_data_index_ = i + 3;
         return false;
       }
     }
+  }
   // Finished the entire dataset
+  if (buf_idx != 0) {
+    this->start_data_();
+    this->write_array(bytes_to_send, buf_idx);
+    this->end_data_();
+  }
   this->current_data_index_ = 0;
+  ESP_LOGV(TAG, "Sent data in %" PRIu32 " ms", millis() - this->transfer_start_time_);
   return true;
 }
-
-void EPaperSpectraE6::reset() {
-  if (this->reset_pin_ != nullptr) {
-    this->disable_loop();
-    this->reset_pin_->digital_write(true);
-    this->set_timeout(20, [this] {
-      this->reset_pin_->digital_write(false);
-      delay(2);
-      this->reset_pin_->digital_write(true);
-      this->set_timeout(20, [this] { this->enable_loop(); });
-    });
-  }
-}
-
 }  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi_spectra_e6.h

@@ -6,18 +6,23 @@ namespace esphome::epaper_spi {
 
 class EPaperSpectraE6 : public EPaperBase {
  public:
-  EPaperSpectraE6(const uint8_t *init_sequence, const size_t init_sequence_length)
-      : EPaperBase(init_sequence, init_sequence_length) {}
+  EPaperSpectraE6(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
+                  size_t init_sequence_length)
+      : EPaperBase(name, width, height, init_sequence, init_sequence_length, DISPLAY_TYPE_COLOR) {
+    this->buffer_length_ = width * height / 2;  // 2 pixels per byte
+  }
 
-  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
   void fill(Color color) override;
+  void clear() override;
 
  protected:
+  void refresh_screen() override;
+  void power_on() override;
+  void power_off() override;
+  void deep_sleep() override;
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
-  uint32_t get_buffer_length() override;
 
   bool transfer_data() override;
-  void reset() override;
 };
 
 }  // namespace esphome::epaper_spi

esphome/components/epaper_spi/models/__init__.py

@@ -0,0 +1,65 @@
+from typing import Any, Self
+
+import esphome.config_validation as cv
+from esphome.const import CONF_DIMENSIONS, CONF_HEIGHT, CONF_WIDTH
+
+
+class EpaperModel:
+    models: dict[str, Self] = {}
+
+    def __init__(
+        self,
+        name: str,
+        class_name: str,
+        initsequence=None,
+        **defaults,
+    ):
+        name = name.upper()
+        self.name = name
+        self.class_name = class_name
+        self.initsequence = initsequence
+        self.defaults = defaults
+        EpaperModel.models[name] = self
+
+    def get_default(self, key, fallback: Any = False) -> Any:
+        return self.defaults.get(key, fallback)
+
+    def get_init_sequence(self, config: dict):
+        return self.initsequence
+
+    def option(self, name, fallback=cv.UNDEFINED) -> cv.Optional | cv.Required:
+        if fallback is None and self.get_default(name, None) is None:
+            return cv.Required(name)
+        return cv.Optional(name, default=self.get_default(name, fallback))
+
+    def get_dimensions(self, config) -> tuple[int, int]:
+        if CONF_DIMENSIONS in config:
+            # Explicit dimensions, just use as is
+            dimensions = config[CONF_DIMENSIONS]
+            if isinstance(dimensions, dict):
+                width = dimensions[CONF_WIDTH]
+                height = dimensions[CONF_HEIGHT]
+            else:
+                (width, height) = dimensions
+
+        else:
+            # Default dimensions, use model defaults
+            width = self.get_default(CONF_WIDTH)
+            height = self.get_default(CONF_HEIGHT)
+        return width, height
+
+    def extend(self, name, **kwargs) -> "EpaperModel":
+        """
+        Extend the current model with additional parameters or a modified init sequence.
+        Parameters supplied here will override the defaults of the current model.
+        if the initsequence is not provided, the current model's initsequence will be used.
+        If add_init_sequence is provided, it will be appended to the current initsequence.
+        :param name:
+        :param kwargs:
+        :return:
+        """
+        initsequence = list(kwargs.pop("initsequence", self.initsequence) or ())
+        initsequence.extend(kwargs.pop("add_init_sequence", ()))
+        defaults = self.defaults.copy()
+        defaults.update(kwargs)
+        return self.__class__(name, initsequence=tuple(initsequence), **defaults)

esphome/components/epaper_spi/models/spectra_e6.py

@@ -0,0 +1,51 @@
+from typing import Any
+
+from . import EpaperModel
+
+
+class SpectraE6(EpaperModel):
+    def __init__(self, name, class_name="EPaperSpectraE6", **kwargs):
+        super().__init__(name, class_name, **kwargs)
+
+    # fmt: off
+    def get_init_sequence(self, config: dict):
+        width, height = self.get_dimensions(config)
+        return (
+            (0xAA, 0x49, 0x55, 0x20, 0x08, 0x09, 0x18,),
+            (0x01, 0x3F,),
+            (0x00, 0x5F, 0x69,),
+            (0x03, 0x00, 0x54, 0x00, 0x44,),
+            (0x05, 0x40, 0x1F, 0x1F, 0x2C,),
+            (0x06, 0x6F, 0x1F, 0x17, 0x49,),
+            (0x08, 0x6F, 0x1F, 0x1F, 0x22,),
+            (0x30, 0x03,),
+            (0x50, 0x3F,),
+            (0x60, 0x02, 0x00,),
+            (0x61, width // 256, width % 256, height // 256, height % 256,),
+            (0x84, 0x01,),
+            (0xE3, 0x2F,),
+        )
+
+    def get_default(self, key, fallback: Any = False) -> Any:
+        return self.defaults.get(key, fallback)
+
+
+spectra_e6 = SpectraE6("spectra-e6")
+
+spectra_e6.extend(
+    "Seeed-reTerminal-E1002",
+    width=800,
+    height=480,
+    data_rate="20MHz",
+    cs_pin=10,
+    dc_pin=11,
+    reset_pin=12,
+    busy_pin={
+        "number": 13,
+        "inverted": True,
+        "mode": {
+            "input": True,
+            "pullup": True,
+        },
+    },
+)

esphome/components/esp32/__init__.py

@@ -558,6 +558,7 @@ CONF_DISABLE_LIBC_LOCKS_IN_IRAM = "disable_libc_locks_in_iram"
 CONF_DISABLE_VFS_SUPPORT_TERMIOS = "disable_vfs_support_termios"
 CONF_DISABLE_VFS_SUPPORT_SELECT = "disable_vfs_support_select"
 CONF_DISABLE_VFS_SUPPORT_DIR = "disable_vfs_support_dir"
+CONF_LOOP_TASK_STACK_SIZE = "loop_task_stack_size"
 
 # VFS requirement tracking
 # Components that need VFS features can call require_vfs_select() or require_vfs_dir()
@@ -654,6 +655,9 @@ FRAMEWORK_SCHEMA = cv.All(
                     ): cv.boolean,
                     cv.Optional(CONF_DISABLE_VFS_SUPPORT_DIR, default=True): cv.boolean,
                     cv.Optional(CONF_EXECUTE_FROM_PSRAM): cv.boolean,
+                    cv.Optional(CONF_LOOP_TASK_STACK_SIZE, default=8192): cv.int_range(
+                        min=8192, max=32768
+                    ),
                 }
             ),
             cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
@@ -926,6 +930,10 @@ async def to_code(config):
                 f"VERSION_CODE({framework_ver.major}, {framework_ver.minor}, {framework_ver.patch})"
             ),
         )
+        add_idf_sdkconfig_option(
+            "CONFIG_ARDUINO_LOOP_STACK_SIZE",
+            conf[CONF_ADVANCED][CONF_LOOP_TASK_STACK_SIZE],
+        )
         add_idf_sdkconfig_option("CONFIG_AUTOSTART_ARDUINO", True)
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_PSK_MODES", True)
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True)
@@ -1071,6 +1079,10 @@ async def to_code(config):
         )
         add_idf_sdkconfig_option("CONFIG_IDF_EXPERIMENTAL_FEATURES", True)
 
+    cg.add_define(
+        "ESPHOME_LOOP_TASK_STACK_SIZE", advanced.get(CONF_LOOP_TASK_STACK_SIZE)
+    )
+
     cg.add_define(
         "USE_ESP_IDF_VERSION_CODE",
         cg.RawExpression(

esphome/components/esp32/core.cpp

@@ -1,5 +1,6 @@
 #ifdef USE_ESP32
 
+#include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "preferences.h"
@@ -96,7 +97,11 @@ void loop_task(void *pv_params) {
 
 extern "C" void app_main() {
   esp32::setup_preferences();
-  xTaskCreate(loop_task, "loopTask", 8192, nullptr, 1, &loop_task_handle);
+#if CONFIG_FREERTOS_UNICORE
+  xTaskCreate(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1, &loop_task_handle);
+#else
+  xTaskCreatePinnedToCore(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1, &loop_task_handle, 1);
+#endif
 }
 #endif  // USE_ESP_IDF
 

esphome/components/esp32_ble/__init__.py

@@ -7,6 +7,7 @@ from typing import Any
 
 from esphome import automation
 import esphome.codegen as cg
+from esphome.components import socket
 from esphome.components.esp32 import add_idf_sdkconfig_option, const, get_esp32_variant
 import esphome.config_validation as cv
 from esphome.const import (
@@ -21,6 +22,7 @@ from esphome.core import CORE, CoroPriority, TimePeriod, coroutine_with_priority
 import esphome.final_validate as fv
 
 DEPENDENCIES = ["esp32"]
+AUTO_LOAD = ["socket"]
 CODEOWNERS = ["@jesserockz", "@Rapsssito", "@bdraco"]
 DOMAIN = "esp32_ble"
 
@@ -481,6 +483,11 @@ async def to_code(config):
         cg.add(var.set_name(name))
     await cg.register_component(var, config)
 
+    # BLE uses the socket wake_loop_threadsafe() mechanism to wake the main loop from BLE tasks
+    # This enables low-latency (~12μs) BLE event processing instead of waiting for
+    # select() timeout (0-16ms). The wake socket is shared across all components.
+    socket.require_wake_loop_threadsafe()
+
     # Define max connections for use in C++ code (e.g., ble_server.h)
     max_connections = config.get(CONF_MAX_CONNECTIONS, DEFAULT_MAX_CONNECTIONS)
     cg.add_define("USE_ESP32_BLE_MAX_CONNECTIONS", max_connections)

esphome/components/esp32_ble/ble.cpp

@@ -31,6 +31,26 @@ namespace esphome::esp32_ble {
 
 static const char *const TAG = "esp32_ble";
 
+// GAP event groups for deduplication across gap_event_handler and dispatch_gap_event_
+#define GAP_SCAN_COMPLETE_EVENTS \
+  case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT: \
+  case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT: \
+  case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT
+
+#define GAP_ADV_COMPLETE_EVENTS \
+  case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT: \
+  case ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT: \
+  case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT: \
+  case ESP_GAP_BLE_ADV_START_COMPLETE_EVT: \
+  case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT
+
+#define GAP_SECURITY_EVENTS \
+  case ESP_GAP_BLE_AUTH_CMPL_EVT: \
+  case ESP_GAP_BLE_SEC_REQ_EVT: \
+  case ESP_GAP_BLE_PASSKEY_NOTIF_EVT: \
+  case ESP_GAP_BLE_PASSKEY_REQ_EVT: \
+  case ESP_GAP_BLE_NC_REQ_EVT
+
 void ESP32BLE::setup() {
   global_ble = this;
   if (!ble_pre_setup_()) {
@@ -414,60 +434,48 @@ void ESP32BLE::loop() {
             break;
 
           // Scan complete events
-          case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
-          case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
-          case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
+          GAP_SCAN_COMPLETE_EVENTS:
+          // Advertising complete events
+          GAP_ADV_COMPLETE_EVENTS:
+          // RSSI complete event
+          case ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT:
+          // Security events
+          GAP_SECURITY_EVENTS:
+            ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
+#ifdef ESPHOME_ESP32_BLE_GAP_EVENT_HANDLER_COUNT
+            {
+              esp_ble_gap_cb_param_t *param;
+              // clang-format off
+              switch (gap_event) {
                 // All three scan complete events have the same structure with just status
                 // The scan_complete struct matches ESP-IDF's layout exactly, so this reinterpret_cast is safe
                 // This is verified at compile-time by static_assert checks in ble_event.h
                 // The struct already contains our copy of the status (copied in BLEEvent constructor)
-            ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
-#ifdef ESPHOME_ESP32_BLE_GAP_EVENT_HANDLER_COUNT
-            for (auto *gap_handler : this->gap_event_handlers_) {
-              gap_handler->gap_event_handler(
-                  gap_event, reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.scan_complete));
-            }
-#endif
+                GAP_SCAN_COMPLETE_EVENTS:
+                  param = reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.scan_complete);
                   break;
 
-          // Advertising complete events
-          case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
-          case ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT:
-          case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
-          case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
-          case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT:
                 // All advertising complete events have the same structure with just status
-            ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
-#ifdef ESPHOME_ESP32_BLE_GAP_EVENT_HANDLER_COUNT
-            for (auto *gap_handler : this->gap_event_handlers_) {
-              gap_handler->gap_event_handler(
-                  gap_event, reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.adv_complete));
-            }
-#endif
+                GAP_ADV_COMPLETE_EVENTS:
+                  param = reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.adv_complete);
                   break;
 
-          // RSSI complete event
                 case ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT:
-            ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
-#ifdef ESPHOME_ESP32_BLE_GAP_EVENT_HANDLER_COUNT
-            for (auto *gap_handler : this->gap_event_handlers_) {
-              gap_handler->gap_event_handler(
-                  gap_event, reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.read_rssi_complete));
-            }
-#endif
+                  param = reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.read_rssi_complete);
                   break;
 
-          // Security events
-          case ESP_GAP_BLE_AUTH_CMPL_EVT:
-          case ESP_GAP_BLE_SEC_REQ_EVT:
-          case ESP_GAP_BLE_PASSKEY_NOTIF_EVT:
-          case ESP_GAP_BLE_PASSKEY_REQ_EVT:
-          case ESP_GAP_BLE_NC_REQ_EVT:
-            ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
-#ifdef ESPHOME_ESP32_BLE_GAP_EVENT_HANDLER_COUNT
+                GAP_SECURITY_EVENTS:
+                  param = reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.security);
+                  break;
+
+                default:
+                  break;
+              }
+              // clang-format on
+              // Dispatch to all registered handlers
               for (auto *gap_handler : this->gap_event_handlers_) {
-              gap_handler->gap_event_handler(
-                  gap_event, reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.security));
+                gap_handler->gap_event_handler(gap_event, param);
+              }
             }
 #endif
             break;
@@ -547,26 +555,24 @@ void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_pa
     // Queue GAP events that components need to handle
     // Scanning events - used by esp32_ble_tracker
     case ESP_GAP_BLE_SCAN_RESULT_EVT:
-    case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
-    case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
-    case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
+    GAP_SCAN_COMPLETE_EVENTS:
     // Advertising events - used by esp32_ble_beacon and esp32_ble server
-    case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
-    case ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT:
-    case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
-    case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
-    case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT:
+    GAP_ADV_COMPLETE_EVENTS:
     // Connection events - used by ble_client
     case ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT:
-    // Security events - used by ble_client and bluetooth_proxy
-    case ESP_GAP_BLE_AUTH_CMPL_EVT:
-    case ESP_GAP_BLE_SEC_REQ_EVT:
-    case ESP_GAP_BLE_PASSKEY_NOTIF_EVT:
-    case ESP_GAP_BLE_PASSKEY_REQ_EVT:
-    case ESP_GAP_BLE_NC_REQ_EVT:
       enqueue_ble_event(event, param);
       return;
 
+    // Security events - used by ble_client and bluetooth_proxy
+    // These are rare but interactive (pairing/bonding), so notify immediately
+    GAP_SECURITY_EVENTS:
+      enqueue_ble_event(event, param);
+      // Wake up main loop to process security event immediately
+#if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
+      App.wake_loop_threadsafe();
+#endif
+      return;
+
     // Ignore these GAP events as they are not relevant for our use case
     case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
     case ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT:
@@ -584,6 +590,10 @@ void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_pa
 void ESP32BLE::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
                                    esp_ble_gatts_cb_param_t *param) {
   enqueue_ble_event(event, gatts_if, param);
+  // Wake up main loop to process GATT event immediately
+#if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
+  App.wake_loop_threadsafe();
+#endif
 }
 #endif
 
@@ -591,6 +601,10 @@ void ESP32BLE::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gat
 void ESP32BLE::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                    esp_ble_gattc_cb_param_t *param) {
   enqueue_ble_event(event, gattc_if, param);
+  // Wake up main loop to process GATT event immediately
+#if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
+  App.wake_loop_threadsafe();
+#endif
 }
 #endif
 

esphome/components/esp32_ble/ble.h

@@ -162,6 +162,11 @@ class ESP32BLE : public Component {
   void advertising_init_();
 #endif
 
+  // BLE uses the core wake_loop_threadsafe() mechanism to wake the main event loop
+  // from BLE tasks. This enables low-latency (~12μs) event processing instead of
+  // waiting for select() timeout (0-16ms). The wake socket is shared with other
+  // components that need this functionality.
+
  private:
   template<typename... Args> friend void enqueue_ble_event(Args... args);
 

esphome/components/esp32_camera/__init__.py

@@ -4,6 +4,7 @@ from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import i2c
 from esphome.components.esp32 import add_idf_component
+from esphome.components.psram import DOMAIN as psram_domain
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BRIGHTNESS,
@@ -26,10 +27,9 @@ import esphome.final_validate as fv
 
 _LOGGER = logging.getLogger(__name__)
 
+AUTO_LOAD = ["camera"]
 DEPENDENCIES = ["esp32"]
 
-AUTO_LOAD = ["camera", "psram"]
-
 esp32_camera_ns = cg.esphome_ns.namespace("esp32_camera")
 ESP32Camera = esp32_camera_ns.class_("ESP32Camera", cg.PollingComponent, cg.EntityBase)
 ESP32CameraImageData = esp32_camera_ns.struct("CameraImageData")
@@ -163,6 +163,14 @@ CONF_ON_IMAGE = "on_image"
 
 camera_range_param = cv.int_range(min=-2, max=2)
 
+
+def validate_fb_location_(value):
+    validator = cv.enum(ENUM_FB_LOCATION, upper=True)
+    if value.lower() == psram_domain:
+        validator = cv.All(validator, cv.requires_component(psram_domain))
+    return validator(value)
+
+
 CONFIG_SCHEMA = cv.All(
     cv.ENTITY_BASE_SCHEMA.extend(
         {
@@ -236,9 +244,9 @@ CONFIG_SCHEMA = cv.All(
                 cv.framerate, cv.Range(min=0, max=1)
             ),
             cv.Optional(CONF_FRAME_BUFFER_COUNT, default=1): cv.int_range(min=1, max=2),
-            cv.Optional(CONF_FRAME_BUFFER_LOCATION, default="PSRAM"): cv.enum(
-                ENUM_FB_LOCATION, upper=True
-            ),
+            cv.Optional(
+                CONF_FRAME_BUFFER_LOCATION, default="PSRAM"
+            ): validate_fb_location_,
             cv.Optional(CONF_ON_STREAM_START): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(

esphome/components/esp32_hosted/update/__init__.py

@@ -0,0 +1,78 @@
+import hashlib
+from typing import Any
+
+import esphome.codegen as cg
+from esphome.components import esp32, update
+import esphome.config_validation as cv
+from esphome.const import CONF_PATH, CONF_RAW_DATA_ID
+from esphome.core import CORE, HexInt
+
+CODEOWNERS = ["@swoboda1337"]
+AUTO_LOAD = ["sha256", "watchdog"]
+DEPENDENCIES = ["esp32_hosted"]
+
+CONF_SHA256 = "sha256"
+
+esp32_hosted_ns = cg.esphome_ns.namespace("esp32_hosted")
+Esp32HostedUpdate = esp32_hosted_ns.class_(
+    "Esp32HostedUpdate", update.UpdateEntity, cg.Component
+)
+
+
+def _validate_sha256(value: Any) -> str:
+    value = cv.string_strict(value)
+    if len(value) != 64:
+        raise cv.Invalid("SHA256 must be 64 hexadecimal characters")
+    try:
+        bytes.fromhex(value)
+    except ValueError as e:
+        raise cv.Invalid(f"SHA256 must be valid hexadecimal: {e}") from e
+    return value
+
+
+CONFIG_SCHEMA = cv.All(
+    update.update_schema(Esp32HostedUpdate, device_class="firmware").extend(
+        {
+            cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
+            cv.Required(CONF_PATH): cv.file_,
+            cv.Required(CONF_SHA256): _validate_sha256,
+        }
+    ),
+    esp32.only_on_variant(
+        supported=[
+            esp32.const.VARIANT_ESP32H2,
+            esp32.const.VARIANT_ESP32P4,
+        ]
+    ),
+)
+
+
+def _validate_firmware(config: dict[str, Any]) -> None:
+    path = CORE.relative_config_path(config[CONF_PATH])
+    with open(path, "rb") as f:
+        firmware_data = f.read()
+    calculated = hashlib.sha256(firmware_data).hexdigest()
+    expected = config[CONF_SHA256].lower()
+    if calculated != expected:
+        raise cv.Invalid(
+            f"SHA256 mismatch for {config[CONF_PATH]}: expected {expected}, got {calculated}"
+        )
+
+
+FINAL_VALIDATE_SCHEMA = _validate_firmware
+
+
+async def to_code(config: dict[str, Any]) -> None:
+    var = await update.new_update(config)
+
+    path = config[CONF_PATH]
+    with open(CORE.relative_config_path(path), "rb") as f:
+        firmware_data = f.read()
+    rhs = [HexInt(x) for x in firmware_data]
+    prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
+
+    sha256_bytes = bytes.fromhex(config[CONF_SHA256])
+    cg.add(var.set_firmware_sha256([HexInt(b) for b in sha256_bytes]))
+    cg.add(var.set_firmware_data(prog_arr))
+    cg.add(var.set_firmware_size(len(firmware_data)))
+    await cg.register_component(var, config)

esphome/components/esp32_hosted/update/esp32_hosted_update.cpp

@@ -0,0 +1,164 @@
+#if defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32P4)
+#include "esp32_hosted_update.h"
+#include "esphome/components/watchdog/watchdog.h"
+#include "esphome/components/sha256/sha256.h"
+#include "esphome/core/application.h"
+#include "esphome/core/log.h"
+#include <esp_image_format.h>
+#include <esp_app_desc.h>
+#include <esp_hosted.h>
+
+extern "C" {
+#include <esp_hosted_ota.h>
+}
+
+namespace esphome::esp32_hosted {
+
+static const char *const TAG = "esp32_hosted.update";
+
+// older coprocessor firmware versions have a 1500-byte limit per RPC call
+constexpr size_t CHUNK_SIZE = 1500;
+
+void Esp32HostedUpdate::setup() {
+  this->update_info_.title = "ESP32 Hosted Coprocessor";
+
+  // get coprocessor version
+  esp_hosted_coprocessor_fwver_t ver_info;
+  if (esp_hosted_get_coprocessor_fwversion(&ver_info) == ESP_OK) {
+    this->update_info_.current_version = str_sprintf("%d.%d.%d", ver_info.major1, ver_info.minor1, ver_info.patch1);
+  } else {
+    this->update_info_.current_version = "unknown";
+  }
+  ESP_LOGD(TAG, "Coprocessor version: %s", this->update_info_.current_version.c_str());
+
+  // get image version
+  const int app_desc_offset = sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t);
+  if (this->firmware_size_ >= app_desc_offset + sizeof(esp_app_desc_t)) {
+    esp_app_desc_t *app_desc = (esp_app_desc_t *) (this->firmware_data_ + app_desc_offset);
+    if (app_desc->magic_word == ESP_APP_DESC_MAGIC_WORD) {
+      ESP_LOGD(TAG, "Firmware version: %s", app_desc->version);
+      ESP_LOGD(TAG, "Project name: %s", app_desc->project_name);
+      ESP_LOGD(TAG, "Build date: %s", app_desc->date);
+      ESP_LOGD(TAG, "Build time: %s", app_desc->time);
+      ESP_LOGD(TAG, "IDF version: %s", app_desc->idf_ver);
+      this->update_info_.latest_version = app_desc->version;
+      if (this->update_info_.latest_version != this->update_info_.current_version) {
+        this->state_ = update::UPDATE_STATE_AVAILABLE;
+      } else {
+        this->state_ = update::UPDATE_STATE_NO_UPDATE;
+      }
+    } else {
+      ESP_LOGW(TAG, "Invalid app description magic word: 0x%08x (expected 0x%08x)", app_desc->magic_word,
+               ESP_APP_DESC_MAGIC_WORD);
+      this->state_ = update::UPDATE_STATE_NO_UPDATE;
+    }
+  } else {
+    ESP_LOGW(TAG, "Firmware too small to contain app description");
+    this->state_ = update::UPDATE_STATE_NO_UPDATE;
+  }
+
+  // publish state
+  this->status_clear_error();
+  this->publish_state();
+}
+
+void Esp32HostedUpdate::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "ESP32 Hosted Update:\n"
+                "  Current Version: %s\n"
+                "  Latest Version: %s\n"
+                "  Latest Size: %zu bytes",
+                this->update_info_.current_version.c_str(), this->update_info_.latest_version.c_str(),
+                this->firmware_size_);
+}
+
+void Esp32HostedUpdate::perform(bool force) {
+  if (this->state_ != update::UPDATE_STATE_AVAILABLE && !force) {
+    ESP_LOGW(TAG, "Update not available");
+    return;
+  }
+
+  if (this->firmware_data_ == nullptr || this->firmware_size_ == 0) {
+    ESP_LOGE(TAG, "No firmware data available");
+    return;
+  }
+
+  sha256::SHA256 hasher;
+  hasher.init();
+  hasher.add(this->firmware_data_, this->firmware_size_);
+  hasher.calculate();
+  if (!hasher.equals_bytes(this->firmware_sha256_.data())) {
+    this->status_set_error("SHA256 verification failed");
+    this->publish_state();
+    return;
+  }
+
+  ESP_LOGI(TAG, "Starting OTA update (%zu bytes)", this->firmware_size_);
+
+  watchdog::WatchdogManager watchdog(20000);
+  update::UpdateState prev_state = this->state_;
+  this->state_ = update::UPDATE_STATE_INSTALLING;
+  this->update_info_.has_progress = false;
+  this->publish_state();
+
+  esp_err_t err = esp_hosted_slave_ota_begin();  // NOLINT
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "Failed to begin OTA: %s", esp_err_to_name(err));
+    this->state_ = prev_state;
+    this->status_set_error("Failed to begin OTA");
+    this->publish_state();
+    return;
+  }
+
+  uint8_t chunk[CHUNK_SIZE];
+  const uint8_t *data_ptr = this->firmware_data_;
+  size_t remaining = this->firmware_size_;
+  while (remaining > 0) {
+    size_t chunk_size = std::min(remaining, static_cast<size_t>(CHUNK_SIZE));
+    memcpy(chunk, data_ptr, chunk_size);
+    err = esp_hosted_slave_ota_write(chunk, chunk_size);  // NOLINT
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "Failed to write OTA data: %s", esp_err_to_name(err));
+      esp_hosted_slave_ota_end();  // NOLINT
+      this->state_ = prev_state;
+      this->status_set_error("Failed to write OTA data");
+      this->publish_state();
+      return;
+    }
+    data_ptr += chunk_size;
+    remaining -= chunk_size;
+    App.feed_wdt();
+  }
+
+  err = esp_hosted_slave_ota_end();  // NOLINT
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "Failed to end OTA: %s", esp_err_to_name(err));
+    this->state_ = prev_state;
+    this->status_set_error("Failed to end OTA");
+    this->publish_state();
+    return;
+  }
+
+  // activate new firmware
+  err = esp_hosted_slave_ota_activate();  // NOLINT
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "Failed to activate OTA: %s", esp_err_to_name(err));
+    this->state_ = prev_state;
+    this->status_set_error("Failed to activate OTA");
+    this->publish_state();
+    return;
+  }
+
+  // update state
+  ESP_LOGI(TAG, "OTA update successful");
+  this->state_ = update::UPDATE_STATE_NO_UPDATE;
+  this->status_clear_error();
+  this->publish_state();
+
+  // schedule a restart to ensure everything is in sync
+  ESP_LOGI(TAG, "Restarting in 1 second");
+  this->set_timeout(1000, []() { App.safe_reboot(); });
+}
+
+}  // namespace esphome::esp32_hosted
+#endif

esphome/components/esp32_hosted/update/esp32_hosted_update.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#if defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32P4)
+
+#include "esphome/core/component.h"
+#include "esphome/components/update/update_entity.h"
+#include <array>
+
+namespace esphome::esp32_hosted {
+
+class Esp32HostedUpdate : public update::UpdateEntity, public Component {
+ public:
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+
+  void perform(bool force) override;
+  void check() override {}
+
+  void set_firmware_data(const uint8_t *data) { this->firmware_data_ = data; }
+  void set_firmware_size(size_t size) { this->firmware_size_ = size; }
+  void set_firmware_sha256(const std::array<uint8_t, 32> &sha256) { this->firmware_sha256_ = sha256; }
+
+ protected:
+  const uint8_t *firmware_data_{nullptr};
+  size_t firmware_size_{0};
+  std::array<uint8_t, 32> firmware_sha256_;
+};
+
+}  // namespace esphome::esp32_hosted
+
+#endif

esphome/components/esphome/ota/ota_esphome.cpp

@@ -281,19 +281,15 @@ void ESPHomeOTAComponent::handle_data_() {
 #endif
 
   // Acknowledge auth OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_AUTH_OK;
-  this->writeall_(buf, 1);
+  this->write_byte_(ota::OTA_RESPONSE_AUTH_OK);
 
   // Read size, 4 bytes MSB first
   if (!this->readall_(buf, 4)) {
     this->log_read_error_(LOG_STR("size"));
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
-  ota_size = 0;
-  for (uint8_t i = 0; i < 4; i++) {
-    ota_size <<= 8;
-    ota_size |= buf[i];
-  }
+  ota_size = (static_cast<size_t>(buf[0]) << 24) | (static_cast<size_t>(buf[1]) << 16) |
+             (static_cast<size_t>(buf[2]) << 8) | buf[3];
   ESP_LOGV(TAG, "Size is %u bytes", ota_size);
 
   // Now that we've passed authentication and are actually
@@ -313,8 +309,7 @@ void ESPHomeOTAComponent::handle_data_() {
   update_started = true;
 
   // Acknowledge prepare OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_UPDATE_PREPARE_OK;
-  this->writeall_(buf, 1);
+  this->write_byte_(ota::OTA_RESPONSE_UPDATE_PREPARE_OK);
 
   // Read binary MD5, 32 bytes
   if (!this->readall_(buf, 32)) {
@@ -326,8 +321,7 @@ void ESPHomeOTAComponent::handle_data_() {
   this->backend_->set_update_md5(sbuf);
 
   // Acknowledge MD5 OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_BIN_MD5_OK;
-  this->writeall_(buf, 1);
+  this->write_byte_(ota::OTA_RESPONSE_BIN_MD5_OK);
 
   while (total < ota_size) {
     // TODO: timeout check
@@ -354,8 +348,7 @@ void ESPHomeOTAComponent::handle_data_() {
     total += read;
 #if USE_OTA_VERSION == 2
     while (size_acknowledged + OTA_BLOCK_SIZE <= total || (total == ota_size && size_acknowledged < ota_size)) {
-      buf[0] = ota::OTA_RESPONSE_CHUNK_OK;
-      this->writeall_(buf, 1);
+      this->write_byte_(ota::OTA_RESPONSE_CHUNK_OK);
       size_acknowledged += OTA_BLOCK_SIZE;
     }
 #endif
@@ -374,8 +367,7 @@ void ESPHomeOTAComponent::handle_data_() {
   }
 
   // Acknowledge receive OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_RECEIVE_OK;
-  this->writeall_(buf, 1);
+  this->write_byte_(ota::OTA_RESPONSE_RECEIVE_OK);
 
   error_code = this->backend_->end();
   if (error_code != ota::OTA_RESPONSE_OK) {
@@ -384,8 +376,7 @@ void ESPHomeOTAComponent::handle_data_() {
   }
 
   // Acknowledge Update end OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_UPDATE_END_OK;
-  this->writeall_(buf, 1);
+  this->write_byte_(ota::OTA_RESPONSE_UPDATE_END_OK);
 
   // Read ACK
   if (!this->readall_(buf, 1) || buf[0] != ota::OTA_RESPONSE_OK) {
@@ -404,8 +395,7 @@ void ESPHomeOTAComponent::handle_data_() {
   App.safe_reboot();
 
 error:
-  buf[0] = static_cast<uint8_t>(error_code);
-  this->writeall_(buf, 1);
+  this->write_byte_(static_cast<uint8_t>(error_code));
   this->cleanup_connection_();
 
   if (this->backend_ != nullptr && update_started) {

esphome/components/esphome/ota/ota_esphome.h

@@ -53,6 +53,7 @@ class ESPHomeOTAComponent : public ota::OTAComponent {
 #endif  // USE_OTA_PASSWORD
   bool readall_(uint8_t *buf, size_t len);
   bool writeall_(const uint8_t *buf, size_t len);
+  inline bool write_byte_(uint8_t byte) { return this->writeall_(&byte, 1); }
 
   bool try_read_(size_t to_read, const LogString *desc);
   bool try_write_(size_t to_write, const LogString *desc);

esphome/components/espnow/__init__.py

@@ -1,6 +1,6 @@
 from esphome import automation, core
 import esphome.codegen as cg
-from esphome.components import wifi
+from esphome.components import socket, wifi
 from esphome.components.udp import CONF_ON_RECEIVE
 import esphome.config_validation as cv
 from esphome.const import (
@@ -17,6 +17,7 @@ from esphome.core import CORE, HexInt
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@jesserockz"]
+AUTO_LOAD = ["socket"]
 
 byte_vector = cg.std_vector.template(cg.uint8)
 peer_address_t = cg.std_ns.class_("array").template(cg.uint8, 6)
@@ -120,6 +121,10 @@ async def to_code(config):
     if CORE.using_arduino:
         cg.add_library("WiFi", None)
 
+    # ESP-NOW uses wake_loop_threadsafe() to wake the main loop from ESP-NOW callbacks
+    # This enables low-latency event processing instead of waiting for select() timeout
+    socket.require_wake_loop_threadsafe()
+
     cg.add_define("USE_ESPNOW")
     if wifi_channel := config.get(CONF_CHANNEL):
         cg.add(var.set_wifi_channel(wifi_channel))

esphome/components/espnow/espnow_component.cpp

@@ -4,6 +4,7 @@
 
 #include "espnow_err.h"
 
+#include "esphome/core/application.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/log.h"
 
@@ -97,6 +98,11 @@ void on_send_report(const uint8_t *mac_addr, esp_now_send_status_t status)
   // Push the packet to the queue
   global_esp_now->receive_packet_queue_.push(packet);
   // Push always because we're the only producer and the pool ensures we never exceed queue size
+
+  // Wake main loop immediately to process ESP-NOW send event instead of waiting for select() timeout
+#if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
+  App.wake_loop_threadsafe();
+#endif
 }
 
 void on_data_received(const esp_now_recv_info_t *info, const uint8_t *data, int size) {
@@ -114,6 +120,11 @@ void on_data_received(const esp_now_recv_info_t *info, const uint8_t *data, int
   // Push the packet to the queue
   global_esp_now->receive_packet_queue_.push(packet);
   // Push always because we're the only producer and the pool ensures we never exceed queue size
+
+  // Wake main loop immediately to process ESP-NOW receive event instead of waiting for select() timeout
+#if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
+  App.wake_loop_threadsafe();
+#endif
 }
 
 ESPNowComponent::ESPNowComponent() { global_esp_now = this; }

esphome/components/fan/fan.cpp

@@ -51,7 +51,14 @@ void FanCall::validate_() {
 
   if (!this->preset_mode_.empty()) {
     const auto &preset_modes = traits.supported_preset_modes();
-    if (preset_modes.find(this->preset_mode_) == preset_modes.end()) {
+    bool found = false;
+    for (const auto &mode : preset_modes) {
+      if (strcmp(mode, this->preset_mode_.c_str()) == 0) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
       ESP_LOGW(TAG, "%s: Preset mode '%s' not supported", this->parent_.get_name().c_str(), this->preset_mode_.c_str());
       this->preset_mode_.clear();
     }
@@ -92,11 +99,12 @@ FanCall FanRestoreState::to_call(Fan &fan) {
   call.set_speed(this->speed);
   call.set_direction(this->direction);
 
-  if (fan.get_traits().supports_preset_modes()) {
+  auto traits = fan.get_traits();
+  if (traits.supports_preset_modes()) {
     // Use stored preset index to get preset name
-    const auto &preset_modes = fan.get_traits().supported_preset_modes();
+    const auto &preset_modes = traits.supported_preset_modes();
     if (this->preset_mode < preset_modes.size()) {
-      call.set_preset_mode(*std::next(preset_modes.begin(), this->preset_mode));
+      call.set_preset_mode(preset_modes[this->preset_mode]);
     }
   }
   return call;
@@ -107,11 +115,12 @@ void FanRestoreState::apply(Fan &fan) {
   fan.speed = this->speed;
   fan.direction = this->direction;
 
-  if (fan.get_traits().supports_preset_modes()) {
+  auto traits = fan.get_traits();
+  if (traits.supports_preset_modes()) {
     // Use stored preset index to get preset name
-    const auto &preset_modes = fan.get_traits().supported_preset_modes();
+    const auto &preset_modes = traits.supported_preset_modes();
     if (this->preset_mode < preset_modes.size()) {
-      fan.preset_mode = *std::next(preset_modes.begin(), this->preset_mode);
+      fan.preset_mode = preset_modes[this->preset_mode];
     }
   }
   fan.publish_state();
@@ -182,18 +191,25 @@ void Fan::save_state_() {
     return;
   }
 
+  auto traits = this->get_traits();
+
   FanRestoreState state{};
   state.state = this->state;
   state.oscillating = this->oscillating;
   state.speed = this->speed;
   state.direction = this->direction;
 
-  if (this->get_traits().supports_preset_modes() && !this->preset_mode.empty()) {
-    const auto &preset_modes = this->get_traits().supported_preset_modes();
+  if (traits.supports_preset_modes() && !this->preset_mode.empty()) {
+    const auto &preset_modes = traits.supported_preset_modes();
     // Store index of current preset mode
-    auto preset_iterator = preset_modes.find(this->preset_mode);
-    if (preset_iterator != preset_modes.end())
-      state.preset_mode = std::distance(preset_modes.begin(), preset_iterator);
+    size_t i = 0;
+    for (const auto &mode : preset_modes) {
+      if (strcmp(mode, this->preset_mode.c_str()) == 0) {
+        state.preset_mode = i;
+        break;
+      }
+      i++;
+    }
   }
 
   this->rtc_.save(&state);
@@ -216,8 +232,8 @@ void Fan::dump_traits_(const char *tag, const char *prefix) {
   }
   if (traits.supports_preset_modes()) {
     ESP_LOGCONFIG(tag, "%s  Supported presets:", prefix);
-    for (const std::string &s : traits.supported_preset_modes())
-      ESP_LOGCONFIG(tag, "%s    - %s", prefix, s.c_str());
+    for (const char *s : traits.supported_preset_modes())
+      ESP_LOGCONFIG(tag, "%s    - %s", prefix, s);
   }
 }
 

esphome/components/fan/fan_traits.h

@@ -1,15 +1,9 @@
-#include <set>
-#include <utility>
-
 #pragma once
 
-namespace esphome {
+#include <vector>
+#include <initializer_list>
 
-#ifdef USE_API
-namespace api {
-class APIConnection;
-}  // namespace api
-#endif
+namespace esphome {
 
 namespace fan {
 
@@ -36,27 +30,27 @@ class FanTraits {
   /// Set whether this fan supports changing direction
   void set_direction(bool direction) { this->direction_ = direction; }
   /// Return the preset modes supported by the fan.
-  std::set<std::string> supported_preset_modes() const { return this->preset_modes_; }
-  /// Set the preset modes supported by the fan.
-  void set_supported_preset_modes(const std::set<std::string> &preset_modes) { this->preset_modes_ = preset_modes; }
+  const std::vector<const char *> &supported_preset_modes() const { return this->preset_modes_; }
+  /// Set the preset modes supported by the fan (from initializer list).
+  void set_supported_preset_modes(std::initializer_list<const char *> preset_modes) {
+    this->preset_modes_ = preset_modes;
+  }
+  /// Set the preset modes supported by the fan (from vector).
+  void set_supported_preset_modes(const std::vector<const char *> &preset_modes) { this->preset_modes_ = preset_modes; }
+
+  // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
+  void set_supported_preset_modes(const std::vector<std::string> &preset_modes) = delete;
+  void set_supported_preset_modes(std::initializer_list<std::string> preset_modes) = delete;
+
   /// Return if preset modes are supported
   bool supports_preset_modes() const { return !this->preset_modes_.empty(); }
 
  protected:
-#ifdef USE_API
-  // The API connection is a friend class to access internal methods
-  friend class api::APIConnection;
-  // This method returns a reference to the internal preset modes set.
-  // It is used by the API to avoid copying data when encoding messages.
-  // Warning: Do not use this method outside of the API connection code.
-  // It returns a reference to internal data that can be invalidated.
-  const std::set<std::string> &supported_preset_modes_for_api_() const { return this->preset_modes_; }
-#endif
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};
   int speed_count_{};
-  std::set<std::string> preset_modes_{};
+  std::vector<const char *> preset_modes_{};
 };
 
 }  // namespace fan

esphome/components/gpio/binary_sensor/__init__.py

@@ -39,6 +39,7 @@ CONFIG_SCHEMA = (
             # due to hardware limitations or lack of reliable interrupt support. This ensures
             # stable operation on these platforms. Future maintainers should verify platform
             # capabilities before changing this default behavior.
+            # nrf52 has no gpio interrupts implemented yet
             cv.SplitDefault(
                 CONF_USE_INTERRUPT,
                 bk72xx=False,
@@ -46,7 +47,7 @@ CONFIG_SCHEMA = (
                 esp8266=True,
                 host=True,
                 ln882x=False,
-                nrf52=True,
+                nrf52=False,
                 rp2040=True,
                 rtl87xx=False,
             ): cv.boolean,
@@ -94,6 +95,8 @@ async def to_code(config):
         )
         use_interrupt = False
 
-    cg.add(var.set_use_interrupt(use_interrupt))
     if use_interrupt:
         cg.add(var.set_interrupt_type(config[CONF_INTERRUPT_TYPE]))
+    else:
+        # Only generate call when disabling interrupts (default is true)
+        cg.add(var.set_use_interrupt(use_interrupt))

esphome/components/hbridge/fan/hbridge_fan.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <set>
-
 #include "esphome/core/automation.h"
 #include "esphome/components/output/binary_output.h"
 #include "esphome/components/output/float_output.h"
@@ -22,7 +20,7 @@ class HBridgeFan : public Component, public fan::Fan {
   void set_pin_a(output::FloatOutput *pin_a) { pin_a_ = pin_a; }
   void set_pin_b(output::FloatOutput *pin_b) { pin_b_ = pin_b; }
   void set_enable_pin(output::FloatOutput *enable) { enable_ = enable; }
-  void set_preset_modes(const std::set<std::string> &presets) { preset_modes_ = presets; }
+  void set_preset_modes(std::initializer_list<const char *> presets) { preset_modes_ = presets; }
 
   void setup() override;
   void dump_config() override;
@@ -38,7 +36,7 @@ class HBridgeFan : public Component, public fan::Fan {
   int speed_count_{};
   DecayMode decay_mode_{DECAY_MODE_SLOW};
   fan::FanTraits traits_;
-  std::set<std::string> preset_modes_{};
+  std::vector<const char *> preset_modes_{};
 
   void control(const fan::FanCall &call) override;
   void write_state_();

esphome/components/i2c/__init__.py

@@ -2,11 +2,18 @@ import logging
 
 from esphome import pins
 import esphome.codegen as cg
+from esphome.components.zephyr import (
+    zephyr_add_overlay,
+    zephyr_add_prj_conf,
+    zephyr_data,
+)
+from esphome.components.zephyr.const import KEY_BOARD
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ADDRESS,
     CONF_FREQUENCY,
+    CONF_I2C,
     CONF_I2C_ID,
     CONF_ID,
     CONF_SCAN,
@@ -15,10 +22,12 @@ from esphome.const import (
     CONF_TIMEOUT,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
+    PLATFORM_NRF52,
     PLATFORM_RP2040,
     PlatformFramework,
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.cpp_generator import MockObj
 import esphome.final_validate as fv
 
 LOGGER = logging.getLogger(__name__)
@@ -28,6 +37,7 @@ I2CBus = i2c_ns.class_("I2CBus")
 InternalI2CBus = i2c_ns.class_("InternalI2CBus", I2CBus)
 ArduinoI2CBus = i2c_ns.class_("ArduinoI2CBus", InternalI2CBus, cg.Component)
 IDFI2CBus = i2c_ns.class_("IDFI2CBus", InternalI2CBus, cg.Component)
+ZephyrI2CBus = i2c_ns.class_("ZephyrI2CBus", I2CBus, cg.Component)
 I2CDevice = i2c_ns.class_("I2CDevice")
 
 
@@ -41,6 +51,8 @@ def _bus_declare_type(value):
         return cv.declare_id(ArduinoI2CBus)(value)
     if CORE.using_esp_idf:
         return cv.declare_id(IDFI2CBus)(value)
+    if CORE.using_zephyr:
+        return cv.declare_id(ZephyrI2CBus)(value)
     raise NotImplementedError
 
 
@@ -62,22 +74,69 @@ CONFIG_SCHEMA = cv.All(
             cv.SplitDefault(CONF_SCL_PULLUP_ENABLED, esp32_idf=True): cv.All(
                 cv.only_with_esp_idf, cv.boolean
             ),
-            cv.Optional(CONF_FREQUENCY, default="50kHz"): cv.All(
-                cv.frequency, cv.Range(min=0, min_included=False)
+            cv.SplitDefault(
+                CONF_FREQUENCY,
+                esp32="50kHz",
+                esp8266="50kHz",
+                rp2040="50kHz",
+                nrf52="100kHz",
+            ): cv.All(
+                cv.frequency,
+                cv.Range(min=0, min_included=False),
+            ),
+            cv.Optional(CONF_TIMEOUT): cv.All(
+                cv.only_with_framework(["arduino", "esp-idf"]),
+                cv.positive_time_period,
             ),
-            cv.Optional(CONF_TIMEOUT): cv.positive_time_period,
             cv.Optional(CONF_SCAN, default=True): cv.boolean,
         }
     ).extend(cv.COMPONENT_SCHEMA),
-    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_RP2040]),
+    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_RP2040, PLATFORM_NRF52]),
     validate_config,
 )
 
 
+def _final_validate(config):
+    full_config = fv.full_config.get()[CONF_I2C]
+    if CORE.using_zephyr and len(full_config) > 1:
+        raise cv.Invalid("Second i2c is not implemented on Zephyr yet")
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 @coroutine_with_priority(CoroPriority.BUS)
 async def to_code(config):
     cg.add_global(i2c_ns.using)
     cg.add_define("USE_I2C")
+    if CORE.using_zephyr:
+        zephyr_add_prj_conf("I2C", True)
+        i2c = "i2c0"
+        if zephyr_data()[KEY_BOARD] in ["xiao_ble"]:
+            i2c = "i2c1"
+        zephyr_add_overlay(
+            f"""
+                &pinctrl {{
+                    {i2c}_default: {i2c}_default {{
+                        group1 {{
+                            psels = <NRF_PSEL(TWIM_SDA, {config[CONF_SDA] // 32}, {config[CONF_SDA] % 32})>,
+                                <NRF_PSEL(TWIM_SCL, {config[CONF_SCL] // 32}, {config[CONF_SCL] % 32})>;
+                        }};
+                    }};
+                    {i2c}_sleep: {i2c}_sleep {{
+                        group1 {{
+                            psels = <NRF_PSEL(TWIM_SDA, {config[CONF_SDA] // 32}, {config[CONF_SDA] % 32})>,
+                                <NRF_PSEL(TWIM_SCL, {config[CONF_SCL] // 32}, {config[CONF_SCL] % 32})>;
+                            low-power-enable;
+                        }};
+                    }};
+                }};
+            """
+        )
+        var = cg.new_Pvariable(
+            config[CONF_ID], MockObj(f"DEVICE_DT_GET(DT_NODELABEL({i2c}))")
+        )
+    else:
         var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
@@ -197,5 +256,6 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
             PlatformFramework.LN882X_ARDUINO,
         },
         "i2c_bus_esp_idf.cpp": {PlatformFramework.ESP32_IDF},
+        "i2c_bus_zephyr.cpp": {PlatformFramework.NRF52_ZEPHYR},
     }
 )

esphome/components/i2c/i2c.cpp

@@ -1,6 +1,7 @@
 #include "i2c.h"
 
 #include "esphome/core/defines.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 #include <memory>
 
@@ -23,6 +24,8 @@ void I2CBus::i2c_scan_() {
     } else if (err == ERROR_UNKNOWN) {
       scan_results_.emplace_back(address, false);
     }
+    // it takes 16sec to scan on nrf52. It prevents board reset.
+    arch_feed_wdt();
   }
 #if defined(USE_ESP32) && defined(USE_LOGGER)
   esp_log_level_set("*", previous);

esphome/components/i2c/i2c_bus_zephyr.cpp

@@ -0,0 +1,133 @@
+#ifdef USE_ZEPHYR
+
+#include "i2c_bus_zephyr.h"
+#include <zephyr/drivers/i2c.h>
+#include "esphome/core/log.h"
+
+namespace esphome::i2c {
+
+static const char *const TAG = "i2c.zephyr";
+
+void ZephyrI2CBus::setup() {
+  if (!device_is_ready(this->i2c_dev_)) {
+    ESP_LOGE(TAG, "I2C dev is not ready.");
+    mark_failed();
+    return;
+  }
+
+  int ret = i2c_configure(this->i2c_dev_, this->dev_config_);
+  if (ret < 0) {
+    ESP_LOGE(TAG, "I2C: Failed to configure device");
+  }
+
+  this->recovery_result_ = i2c_recover_bus(this->i2c_dev_);
+  if (this->recovery_result_ != 0) {
+    ESP_LOGE(TAG, "I2C recover bus failed, err %d", this->recovery_result_);
+  }
+  if (this->scan_) {
+    ESP_LOGV(TAG, "Scanning I2C bus for active devices...");
+    this->i2c_scan_();
+  }
+}
+
+void ZephyrI2CBus::dump_config() {
+  auto get_speed = [](uint32_t dev_config) {
+    switch (I2C_SPEED_GET(dev_config)) {
+      case I2C_SPEED_STANDARD:
+        return "100 kHz";
+      case I2C_SPEED_FAST:
+        return "400 kHz";
+      case I2C_SPEED_FAST_PLUS:
+        return "1 MHz";
+      case I2C_SPEED_HIGH:
+        return "3.4 MHz";
+      case I2C_SPEED_ULTRA:
+        return "5 MHz";
+    }
+    return "unknown";
+  };
+  ESP_LOGCONFIG(TAG,
+                "I2C Bus:\n"
+                "  SDA Pin: GPIO%u\n"
+                "  SCL Pin: GPIO%u\n"
+                "  Frequency: %s\n"
+                "  Name: %s",
+                this->sda_pin_, this->scl_pin_, get_speed(this->dev_config_), this->i2c_dev_->name);
+
+  if (this->recovery_result_ != 0) {
+    ESP_LOGCONFIG(TAG, "  Recovery: failed, err %d", this->recovery_result_);
+  } else {
+    ESP_LOGCONFIG(TAG, "  Recovery: bus successfully recovered");
+  }
+  if (this->scan_) {
+    ESP_LOGI(TAG, "Results from I2C bus scan:");
+    if (scan_results_.empty()) {
+      ESP_LOGI(TAG, "Found no I2C devices!");
+    } else {
+      for (const auto &s : scan_results_) {
+        if (s.second) {
+          ESP_LOGI(TAG, "Found I2C device at address 0x%02X", s.first);
+        } else {
+          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
+        }
+      }
+    }
+  }
+}
+
+ErrorCode ZephyrI2CBus::write_readv(uint8_t address, const uint8_t *write_buffer, size_t write_count,
+                                    uint8_t *read_buffer, size_t read_count) {
+  if (!device_is_ready(this->i2c_dev_)) {
+    return ERROR_NOT_INITIALIZED;
+  }
+
+  i2c_msg msgs[2]{};
+  size_t cnt = 0;
+  uint8_t dst = 0x00;  // dummy data to not use random value
+
+  if (read_count == 0 && write_count == 0) {
+    msgs[cnt].buf = &dst;
+    msgs[cnt].len = 0U;
+    msgs[cnt++].flags = I2C_MSG_WRITE;
+  } else {
+    if (write_count) {
+      // the same struct is used for read/write — const cast is fine; data isn't modified
+      msgs[cnt].buf = const_cast<uint8_t *>(write_buffer);
+      msgs[cnt].len = write_count;
+      msgs[cnt++].flags = I2C_MSG_WRITE;
+    }
+    if (read_count) {
+      msgs[cnt].buf = const_cast<uint8_t *>(read_buffer);
+      msgs[cnt].len = read_count;
+      msgs[cnt++].flags = I2C_MSG_READ | I2C_MSG_RESTART;
+    }
+  }
+
+  msgs[cnt - 1].flags |= I2C_MSG_STOP;
+
+  auto err = i2c_transfer(this->i2c_dev_, msgs, cnt, address);
+
+  if (err == -EIO) {
+    return ERROR_NOT_ACKNOWLEDGED;
+  }
+
+  if (err != 0) {
+    ESP_LOGE(TAG, "i2c transfer error %d", err);
+    return ERROR_UNKNOWN;
+  }
+
+  return ERROR_OK;
+}
+
+void ZephyrI2CBus::set_frequency(uint32_t frequency) {
+  this->dev_config_ &= ~I2C_SPEED_MASK;
+  if (frequency >= 400000) {
+    this->dev_config_ |= I2C_SPEED_SET(I2C_SPEED_FAST);
+  } else {
+    this->dev_config_ |= I2C_SPEED_SET(I2C_SPEED_STANDARD);
+  }
+}
+
+}  // namespace esphome::i2c
+
+#endif

esphome/components/i2c/i2c_bus_zephyr.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#ifdef USE_ZEPHYR
+
+#include "i2c_bus.h"
+#include "esphome/core/component.h"
+
+struct device;
+
+namespace esphome::i2c {
+
+class ZephyrI2CBus : public InternalI2CBus, public Component {
+ public:
+  explicit ZephyrI2CBus(const device *i2c_dev) : i2c_dev_(i2c_dev) {}
+  void setup() override;
+  void dump_config() override;
+  ErrorCode write_readv(uint8_t address, const uint8_t *write_buffer, size_t write_count, uint8_t *read_buffer,
+                        size_t read_count) override;
+  float get_setup_priority() const override { return setup_priority::BUS; }
+
+  void set_scan(bool scan) { scan_ = scan; }
+  void set_sda_pin(uint8_t sda_pin) { this->sda_pin_ = sda_pin; }
+  void set_scl_pin(uint8_t scl_pin) { this->scl_pin_ = scl_pin; }
+  void set_frequency(uint32_t frequency);
+
+  int get_port() const override { return 0; }
+
+ protected:
+  const device *i2c_dev_;
+  int recovery_result_ = 0;
+  uint8_t sda_pin_{};
+  uint8_t scl_pin_{};
+  uint32_t dev_config_{};
+};
+
+}  // namespace esphome::i2c
+
+#endif

esphome/components/image/__init__.py

@@ -671,10 +671,15 @@ async def write_image(config, all_frames=False):
     resize = config.get(CONF_RESIZE)
     if is_svg_file(path):
         # Local import so use of non-SVG files needn't require cairosvg installed
+        from pyexpat import ExpatError
+        from xml.etree.ElementTree import ParseError
+
         from cairosvg import svg2png
+        from cairosvg.helpers import PointError
 
         if not resize:
             resize = (None, None)
+        try:
             with open(path, "rb") as file:
                 image = svg2png(
                     file_obj=file,
@@ -683,6 +688,16 @@ async def write_image(config, all_frames=False):
                 )
             image = Image.open(io.BytesIO(image))
             width, height = image.size
+        except (
+            ValueError,
+            ParseError,
+            IndexError,
+            ExpatError,
+            AttributeError,
+            TypeError,
+            PointError,
+        ) as e:
+            raise core.EsphomeError(f"Could not load SVG image {path}: {e}") from e
     else:
         image = Image.open(path)
         width, height = image.size

esphome/components/image/image.cpp

@@ -125,7 +125,7 @@ lv_img_dsc_t *Image::get_lv_img_dsc() {
 
       case IMAGE_TYPE_RGB:
 #if LV_COLOR_DEPTH == 32
-        switch (this->transparent_) {
+        switch (this->transparency_) {
           case TRANSPARENCY_ALPHA_CHANNEL:
             this->dsc_.header.cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
             break;
@@ -156,7 +156,8 @@ lv_img_dsc_t *Image::get_lv_img_dsc() {
             break;
         }
 #else
-        this->dsc_.header.cf = this->transparent_ == TRANSPARENCY_ALPHA_CHANNEL ? LV_IMG_CF_RGB565A8 : LV_IMG_CF_RGB565;
+        this->dsc_.header.cf =
+            this->transparency_ == TRANSPARENCY_ALPHA_CHANNEL ? LV_IMG_CF_RGB565A8 : LV_IMG_CF_RGB565;
 #endif
         break;
     }

esphome/components/inkplate/display.py

@@ -20,8 +20,7 @@ import esphome.final_validate as fv
 
 from .const import INKPLATE_10_CUSTOM_WAVEFORMS, WAVEFORMS
 
-DEPENDENCIES = ["i2c", "esp32"]
-AUTO_LOAD = ["psram"]
+DEPENDENCIES = ["i2c", "esp32", "psram"]
 
 CONF_DISPLAY_DATA_0_PIN = "display_data_0_pin"
 CONF_DISPLAY_DATA_1_PIN = "display_data_1_pin"

esphome/components/lvgl/__init__.py

@@ -41,10 +41,7 @@ from .lv_validation import lv_bool, lv_images_used
 from .lvcode import LvContext, LvglComponent, lvgl_static
 from .schemas import (
     DISP_BG_SCHEMA,
-    FLEX_OBJ_SCHEMA,
     FULL_STYLE_SCHEMA,
-    GRID_CELL_SCHEMA,
-    LAYOUT_SCHEMAS,
     WIDGET_TYPES,
     any_widget_schema,
     container_schema,
@@ -58,7 +55,7 @@ from .types import (
     FontEngine,
     IdleTrigger,
     ObjUpdateAction,
-    PauseTrigger,
+    PlainTrigger,
     lv_font_t,
     lv_group_t,
     lv_style_t,
@@ -78,6 +75,7 @@ from .widgets.button import button_spec
 from .widgets.buttonmatrix import buttonmatrix_spec
 from .widgets.canvas import canvas_spec
 from .widgets.checkbox import checkbox_spec
+from .widgets.container import container_spec
 from .widgets.dropdown import dropdown_spec
 from .widgets.img import img_spec
 from .widgets.keyboard import keyboard_spec
@@ -130,20 +128,10 @@ for w_type in (
     tileview_spec,
     qr_code_spec,
     canvas_spec,
+    container_spec,
 ):
     WIDGET_TYPES[w_type.name] = w_type
 
-WIDGET_SCHEMA = any_widget_schema()
-
-LAYOUT_SCHEMAS[df.TYPE_GRID] = {
-    cv.Optional(df.CONF_WIDGETS): cv.ensure_list(any_widget_schema(GRID_CELL_SCHEMA))
-}
-LAYOUT_SCHEMAS[df.TYPE_FLEX] = {
-    cv.Optional(df.CONF_WIDGETS): cv.ensure_list(any_widget_schema(FLEX_OBJ_SCHEMA))
-}
-LAYOUT_SCHEMAS[df.TYPE_NONE] = {
-    cv.Optional(df.CONF_WIDGETS): cv.ensure_list(any_widget_schema())
-}
 for w_type in WIDGET_TYPES.values():
     register_action(
         f"lvgl.{w_type.name}.update",
@@ -151,6 +139,13 @@ for w_type in WIDGET_TYPES.values():
         create_modify_schema(w_type),
     )(update_to_code)
 
+SIMPLE_TRIGGERS = (
+    df.CONF_ON_PAUSE,
+    df.CONF_ON_RESUME,
+    df.CONF_ON_DRAW_START,
+    df.CONF_ON_DRAW_END,
+)
+
 
 def as_macro(macro, value):
     if value is None:
@@ -244,9 +239,9 @@ def final_validation(configs):
         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()):
+            if not any(isinstance(v, (Lambda, dict)) for v in widget_conf.values()):
                 raise cv.Invalid(
-                    f"Widget '{w}' does not have any templated properties to refresh",
+                    f"Widget '{w}' does not have any dynamic properties to refresh",
                 )
 
 
@@ -366,16 +361,16 @@ async def to_code(configs):
                     conf[CONF_TRIGGER_ID], lv_component, templ
                 )
                 await build_automation(idle_trigger, [], conf)
-            for conf in config.get(df.CONF_ON_PAUSE, ()):
-                pause_trigger = cg.new_Pvariable(
-                    conf[CONF_TRIGGER_ID], lv_component, True
+            for trigger_name in SIMPLE_TRIGGERS:
+                if conf := config.get(trigger_name):
+                    trigger_var = cg.new_Pvariable(conf[CONF_TRIGGER_ID])
+                    await build_automation(trigger_var, [], conf)
+                    cg.add(
+                        getattr(
+                            lv_component,
+                            f"set_{trigger_name.removeprefix('on_')}_trigger",
+                        )(trigger_var)
                     )
-                await build_automation(pause_trigger, [], conf)
-            for conf in config.get(df.CONF_ON_RESUME, ()):
-                resume_trigger = cg.new_Pvariable(
-                    conf[CONF_TRIGGER_ID], lv_component, False
-                )
-                await build_automation(resume_trigger, [], conf)
             await add_on_boot_triggers(config.get(CONF_ON_BOOT, ()))
 
     # This must be done after all widgets are created
@@ -403,7 +398,7 @@ def display_schema(config):
 def add_hello_world(config):
     if df.CONF_WIDGETS not in config and CONF_PAGES not in config:
         LOGGER.info("No pages or widgets configured, creating default hello_world page")
-        config[df.CONF_WIDGETS] = cv.ensure_list(WIDGET_SCHEMA)(get_hello_world())
+        config[df.CONF_WIDGETS] = any_widget_schema()(get_hello_world())
     return config
 
 
@@ -443,22 +438,16 @@ LVGL_SCHEMA = cv.All(
                         ),
                     }
                 ),
-                cv.Optional(df.CONF_ON_PAUSE): validate_automation(
+                cv.Optional(CONF_PAGES): cv.ensure_list(container_schema(page_spec)),
+                **{
+                    cv.Optional(x): validate_automation(
                         {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PauseTrigger),
-                    }
-                ),
-                cv.Optional(df.CONF_ON_RESUME): validate_automation(
-                    {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PauseTrigger),
-                    }
-                ),
-                cv.Exclusive(df.CONF_WIDGETS, CONF_PAGES): cv.ensure_list(
-                    WIDGET_SCHEMA
-                ),
-                cv.Exclusive(CONF_PAGES, CONF_PAGES): cv.ensure_list(
-                    container_schema(page_spec)
-                ),
+                            cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PlainTrigger),
+                        },
+                        single=True,
+                    )
+                    for x in SIMPLE_TRIGGERS
+                },
                 cv.Optional(df.CONF_MSGBOXES): cv.ensure_list(MSGBOX_SCHEMA),
                 cv.Optional(df.CONF_PAGE_WRAP, default=True): lv_bool,
                 cv.Optional(df.CONF_TOP_LAYER): container_schema(obj_spec),

esphome/components/lvgl/automation.py

@@ -137,7 +137,11 @@ async def lvgl_is_idle(config, condition_id, template_arg, args):
     lvgl = config[CONF_LVGL_ID]
     timeout = await lv_milliseconds.process(config[CONF_TIMEOUT])
     async with LambdaContext(LVGL_COMP_ARG, return_type=cg.bool_) as context:
-        lv_add(ReturnStatement(lvgl_comp.is_idle(timeout)))
+        lv_add(
+            ReturnStatement(
+                lv_expr.disp_get_inactive_time(lvgl_comp.get_disp()) > timeout
+            )
+        )
     var = cg.new_Pvariable(
         condition_id,
         TemplateArguments(LvglComponent, *template_arg),
@@ -400,7 +404,8 @@ async def obj_refresh_to_code(config, action_id, template_arg, args):
         # 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()):
+        # Check if v is a Lambda or a dict, implying it is dynamic
+        if any(isinstance(v, (Lambda, dict)) for v in config.values()):
             await widget.type.to_code(widget, config)
             if (
                 widget.type.w_type.value_property is not None

esphome/components/lvgl/binary_sensor/__init__.py

@@ -31,7 +31,7 @@ async def to_code(config):
             lvgl_static.add_event_cb(
                 widget.obj,
                 await pressed_ctx.get_lambda(),
-                LV_EVENT.PRESSING,
+                LV_EVENT.PRESSED,
                 LV_EVENT.RELEASED,
             )
         )

esphome/components/lvgl/defines.py

@@ -394,6 +394,8 @@ LV_FLEX_ALIGNMENTS = LvConstant(
     "SPACE_BETWEEN",
 )
 
+LV_FLEX_CROSS_ALIGNMENTS = LV_FLEX_ALIGNMENTS.extend("STRETCH")
+
 LV_MENU_MODES = LvConstant(
     "LV_MENU_HEADER_",
     "TOP_FIXED",
@@ -436,6 +438,7 @@ CONF_BUTTONS = "buttons"
 CONF_BYTE_ORDER = "byte_order"
 CONF_CHANGE_RATE = "change_rate"
 CONF_CLOSE_BUTTON = "close_button"
+CONF_CONTAINER = "container"
 CONF_CONTROL = "control"
 CONF_DEFAULT_FONT = "default_font"
 CONF_DEFAULT_GROUP = "default_group"
@@ -483,6 +486,8 @@ CONF_MSGBOXES = "msgboxes"
 CONF_OBJ = "obj"
 CONF_ONE_CHECKED = "one_checked"
 CONF_ONE_LINE = "one_line"
+CONF_ON_DRAW_START = "on_draw_start"
+CONF_ON_DRAW_END = "on_draw_end"
 CONF_ON_PAUSE = "on_pause"
 CONF_ON_RESUME = "on_resume"
 CONF_ON_SELECT = "on_select"

esphome/components/lvgl/layout.py

@@ -0,0 +1,357 @@
+import re
+
+import esphome.config_validation as cv
+from esphome.const import CONF_HEIGHT, CONF_TYPE, CONF_WIDTH
+
+from .defines import (
+    CONF_FLEX_ALIGN_CROSS,
+    CONF_FLEX_ALIGN_MAIN,
+    CONF_FLEX_ALIGN_TRACK,
+    CONF_FLEX_FLOW,
+    CONF_FLEX_GROW,
+    CONF_GRID_CELL_COLUMN_POS,
+    CONF_GRID_CELL_COLUMN_SPAN,
+    CONF_GRID_CELL_ROW_POS,
+    CONF_GRID_CELL_ROW_SPAN,
+    CONF_GRID_CELL_X_ALIGN,
+    CONF_GRID_CELL_Y_ALIGN,
+    CONF_GRID_COLUMN_ALIGN,
+    CONF_GRID_COLUMNS,
+    CONF_GRID_ROW_ALIGN,
+    CONF_GRID_ROWS,
+    CONF_LAYOUT,
+    CONF_PAD_COLUMN,
+    CONF_PAD_ROW,
+    CONF_WIDGETS,
+    FLEX_FLOWS,
+    LV_CELL_ALIGNMENTS,
+    LV_FLEX_ALIGNMENTS,
+    LV_FLEX_CROSS_ALIGNMENTS,
+    LV_GRID_ALIGNMENTS,
+    TYPE_FLEX,
+    TYPE_GRID,
+    TYPE_NONE,
+    LvConstant,
+)
+from .lv_validation import padding, size
+
+cell_alignments = LV_CELL_ALIGNMENTS.one_of
+grid_alignments = LV_GRID_ALIGNMENTS.one_of
+flex_alignments = LV_FLEX_ALIGNMENTS.one_of
+
+FLEX_LAYOUT_SCHEMA = {
+    cv.Required(CONF_TYPE): cv.one_of(TYPE_FLEX, lower=True),
+    cv.Optional(CONF_FLEX_FLOW, default="row_wrap"): FLEX_FLOWS.one_of,
+    cv.Optional(CONF_FLEX_ALIGN_MAIN, default="start"): flex_alignments,
+    cv.Optional(
+        CONF_FLEX_ALIGN_CROSS, default="start"
+    ): LV_FLEX_CROSS_ALIGNMENTS.one_of,
+    cv.Optional(CONF_FLEX_ALIGN_TRACK, default="start"): flex_alignments,
+    cv.Optional(CONF_PAD_ROW): padding,
+    cv.Optional(CONF_PAD_COLUMN): padding,
+    cv.Optional(CONF_FLEX_GROW): cv.int_,
+}
+
+FLEX_HV_STYLE = {
+    CONF_FLEX_ALIGN_MAIN: "LV_FLEX_ALIGN_SPACE_EVENLY",
+    CONF_FLEX_ALIGN_TRACK: "LV_FLEX_ALIGN_CENTER",
+    CONF_FLEX_ALIGN_CROSS: "LV_FLEX_ALIGN_CENTER",
+    CONF_TYPE: TYPE_FLEX,
+}
+
+FLEX_OBJ_SCHEMA = {
+    cv.Optional(CONF_FLEX_GROW): cv.int_,
+}
+
+
+def flex_hv_schema(dir):
+    dir = CONF_HEIGHT if dir == "horizontal" else CONF_WIDTH
+    return {
+        cv.Optional(CONF_FLEX_GROW, default=1): cv.int_,
+        cv.Optional(dir, default="100%"): size,
+    }
+
+
+def grid_free_space(value):
+    value = cv.Upper(value)
+    if value.startswith("FR(") and value.endswith(")"):
+        value = value.removesuffix(")").removeprefix("FR(")
+        return f"LV_GRID_FR({cv.positive_int(value)})"
+    raise cv.Invalid("must be a size in pixels, CONTENT or FR(nn)")
+
+
+grid_spec = cv.Any(size, LvConstant("LV_GRID_", "CONTENT").one_of, grid_free_space)
+
+GRID_CELL_SCHEMA = {
+    cv.Optional(CONF_GRID_CELL_ROW_POS): cv.positive_int,
+    cv.Optional(CONF_GRID_CELL_COLUMN_POS): cv.positive_int,
+    cv.Optional(CONF_GRID_CELL_ROW_SPAN, default=1): cv.positive_int,
+    cv.Optional(CONF_GRID_CELL_COLUMN_SPAN, default=1): cv.positive_int,
+    cv.Optional(CONF_GRID_CELL_X_ALIGN): grid_alignments,
+    cv.Optional(CONF_GRID_CELL_Y_ALIGN): grid_alignments,
+}
+
+
+class Layout:
+    """
+    Define properties for a layout
+    The base class is layout "none"
+    """
+
+    def get_type(self):
+        return TYPE_NONE
+
+    def get_layout_schemas(self, config: dict) -> tuple:
+        """
+        Get the layout and child schema for a given widget based on its layout type.
+        """
+        return None, {}
+
+    def validate(self, config):
+        """
+        Validate the layout configuration. This is called late in the schema validation
+        :param config: The input configuration
+        :return: The validated configuration
+        """
+        return config
+
+
+class FlexLayout(Layout):
+    def get_type(self):
+        return TYPE_FLEX
+
+    def get_layout_schemas(self, config: dict) -> tuple:
+        layout = config.get(CONF_LAYOUT)
+        if not isinstance(layout, dict) or layout.get(CONF_TYPE) != TYPE_FLEX:
+            return None, {}
+        child_schema = FLEX_OBJ_SCHEMA
+        if grow := layout.get(CONF_FLEX_GROW):
+            child_schema = {cv.Optional(CONF_FLEX_GROW, default=grow): cv.int_}
+        # Polyfill to implement stretch alignment for flex containers
+        # LVGL does not support this natively, so we add a 100% size property to the children in the cross-axis
+        if layout.get(CONF_FLEX_ALIGN_CROSS) == "LV_FLEX_ALIGN_STRETCH":
+            dimension = (
+                CONF_WIDTH
+                if "COLUMN" in layout[CONF_FLEX_FLOW].upper()
+                else CONF_HEIGHT
+            )
+            child_schema[cv.Optional(dimension, default="100%")] = size
+        return FLEX_LAYOUT_SCHEMA, child_schema
+
+    def validate(self, config):
+        """
+        Perform validation on the container and its children for this layout
+        :param config:
+        :return:
+        """
+        return config
+
+
+class DirectionalLayout(FlexLayout):
+    def __init__(self, direction: str, flow):
+        """
+        :param direction: "horizontal" or "vertical"
+        :param flow: "row" or "column"
+        """
+        super().__init__()
+        self.direction = direction
+        self.flow = flow
+
+    def get_type(self):
+        return self.direction
+
+    def get_layout_schemas(self, config: dict) -> tuple:
+        if config.get(CONF_LAYOUT, "").lower() != self.direction:
+            return None, {}
+        return cv.one_of(self.direction, lower=True), flex_hv_schema(self.direction)
+
+    def validate(self, config):
+        assert config[CONF_LAYOUT].lower() == self.direction
+        config[CONF_LAYOUT] = {
+            **FLEX_HV_STYLE,
+            CONF_FLEX_FLOW: "LV_FLEX_FLOW_" + self.flow.upper(),
+        }
+        return config
+
+
+class GridLayout(Layout):
+    _GRID_LAYOUT_REGEX = re.compile(r"^\s*(\d+)\s*x\s*(\d+)\s*$")
+
+    def get_type(self):
+        return TYPE_GRID
+
+    def get_layout_schemas(self, config: dict) -> tuple:
+        layout = config.get(CONF_LAYOUT)
+        if isinstance(layout, str):
+            if GridLayout._GRID_LAYOUT_REGEX.match(layout):
+                return (
+                    cv.string,
+                    {
+                        cv.Optional(CONF_GRID_CELL_ROW_POS): cv.positive_int,
+                        cv.Optional(CONF_GRID_CELL_COLUMN_POS): cv.positive_int,
+                        cv.Optional(
+                            CONF_GRID_CELL_ROW_SPAN, default=1
+                        ): cv.positive_int,
+                        cv.Optional(
+                            CONF_GRID_CELL_COLUMN_SPAN, default=1
+                        ): cv.positive_int,
+                        cv.Optional(
+                            CONF_GRID_CELL_X_ALIGN, default="center"
+                        ): grid_alignments,
+                        cv.Optional(
+                            CONF_GRID_CELL_Y_ALIGN, default="center"
+                        ): grid_alignments,
+                    },
+                )
+            # Not a valid grid layout string
+            return None, {}
+
+        if not isinstance(layout, dict) or layout.get(CONF_TYPE) != TYPE_GRID:
+            return None, {}
+        return (
+            {
+                cv.Required(CONF_TYPE): cv.one_of(TYPE_GRID, lower=True),
+                cv.Required(CONF_GRID_ROWS): [grid_spec],
+                cv.Required(CONF_GRID_COLUMNS): [grid_spec],
+                cv.Optional(CONF_GRID_COLUMN_ALIGN): grid_alignments,
+                cv.Optional(CONF_GRID_ROW_ALIGN): grid_alignments,
+                cv.Optional(CONF_PAD_ROW): padding,
+                cv.Optional(CONF_PAD_COLUMN): padding,
+            },
+            {
+                cv.Optional(CONF_GRID_CELL_ROW_POS): cv.positive_int,
+                cv.Optional(CONF_GRID_CELL_COLUMN_POS): cv.positive_int,
+                cv.Optional(CONF_GRID_CELL_ROW_SPAN, default=1): cv.positive_int,
+                cv.Optional(CONF_GRID_CELL_COLUMN_SPAN, default=1): cv.positive_int,
+                cv.Optional(CONF_GRID_CELL_X_ALIGN): grid_alignments,
+                cv.Optional(CONF_GRID_CELL_Y_ALIGN): grid_alignments,
+            },
+        )
+
+    def validate(self, config: dict):
+        """
+        Validate the grid layout.
+        The `layout:` key may be a dictionary with `rows` and `columns` keys, or a string in the format "rows x columns".
+        Either all cells must have a row and column,
+        or none, in which case the grid layout is auto-generated.
+        :param config:
+        :return: The config updated with auto-generated values
+        """
+        layout = config.get(CONF_LAYOUT)
+        if isinstance(layout, str):
+            # If the layout is a string, assume it is in the format "rows x columns", implying
+            # a grid layout with the specified number of rows and columns each with CONTENT sizing.
+            layout = layout.strip()
+            match = GridLayout._GRID_LAYOUT_REGEX.match(layout)
+            if match:
+                rows = int(match.group(1))
+                cols = int(match.group(2))
+                layout = {
+                    CONF_TYPE: TYPE_GRID,
+                    CONF_GRID_ROWS: ["LV_GRID_FR(1)"] * rows,
+                    CONF_GRID_COLUMNS: ["LV_GRID_FR(1)"] * cols,
+                }
+                config[CONF_LAYOUT] = layout
+            else:
+                raise cv.Invalid(
+                    f"Invalid grid layout format: {config}, expected 'rows x columns'",
+                    [CONF_LAYOUT],
+                )
+        # should be guaranteed to be a dict at this point
+        assert isinstance(layout, dict)
+        assert layout.get(CONF_TYPE) == TYPE_GRID
+        rows = len(layout[CONF_GRID_ROWS])
+        columns = len(layout[CONF_GRID_COLUMNS])
+        used_cells = [[None] * columns for _ in range(rows)]
+        for index, widget in enumerate(config.get(CONF_WIDGETS, [])):
+            _, w = next(iter(widget.items()))
+            if (CONF_GRID_CELL_COLUMN_POS in w) != (CONF_GRID_CELL_ROW_POS in w):
+                raise cv.Invalid(
+                    "Both row and column positions must be specified, or both omitted",
+                    [CONF_WIDGETS, index],
+                )
+            if CONF_GRID_CELL_ROW_POS in w:
+                row = w[CONF_GRID_CELL_ROW_POS]
+                column = w[CONF_GRID_CELL_COLUMN_POS]
+            else:
+                try:
+                    row, column = next(
+                        (r_idx, c_idx)
+                        for r_idx, row in enumerate(used_cells)
+                        for c_idx, value in enumerate(row)
+                        if value is None
+                    )
+                except StopIteration:
+                    raise cv.Invalid(
+                        "No free cells available in grid layout", [CONF_WIDGETS, index]
+                    ) from None
+                w[CONF_GRID_CELL_ROW_POS] = row
+                w[CONF_GRID_CELL_COLUMN_POS] = column
+
+            for i in range(w[CONF_GRID_CELL_ROW_SPAN]):
+                for j in range(w[CONF_GRID_CELL_COLUMN_SPAN]):
+                    if row + i >= rows or column + j >= columns:
+                        raise cv.Invalid(
+                            f"Cell at {row}/{column} span {w[CONF_GRID_CELL_ROW_SPAN]}x{w[CONF_GRID_CELL_COLUMN_SPAN]} "
+                            f"exceeds grid size {rows}x{columns}",
+                            [CONF_WIDGETS, index],
+                        )
+                    if used_cells[row + i][column + j] is not None:
+                        raise cv.Invalid(
+                            f"Cell span {row + i}/{column + j} already occupied by widget at index {used_cells[row + i][column + j]}",
+                            [CONF_WIDGETS, index],
+                        )
+                    used_cells[row + i][column + j] = index
+
+        return config
+
+
+LAYOUT_CLASSES = (
+    FlexLayout(),
+    GridLayout(),
+    DirectionalLayout("horizontal", "row"),
+    DirectionalLayout("vertical", "column"),
+)
+LAYOUT_CHOICES = [x.get_type() for x in LAYOUT_CLASSES]
+
+
+def append_layout_schema(schema, config: dict):
+    """
+    Get the child layout schema for a given widget based on its layout type.
+    :param config: The config to check
+    :return: A schema for the layout including a widgets key
+    """
+    # Local import to avoid circular dependencies
+    if CONF_WIDGETS not in config:
+        if CONF_LAYOUT in config:
+            raise cv.Invalid(
+                f"Layout {config[CONF_LAYOUT]} requires a {CONF_WIDGETS} key",
+                [CONF_LAYOUT],
+            )
+        return schema
+
+    from .schemas import any_widget_schema
+
+    if CONF_LAYOUT not in config:
+        # If no layout is specified, return the schema as is
+        return schema.extend({cv.Optional(CONF_WIDGETS): any_widget_schema()})
+
+    for layout_class in LAYOUT_CLASSES:
+        layout_schema, child_schema = layout_class.get_layout_schemas(config)
+        if layout_schema:
+            layout_schema = cv.Schema(
+                {
+                    cv.Required(CONF_LAYOUT): layout_schema,
+                    cv.Required(CONF_WIDGETS): any_widget_schema(child_schema),
+                }
+            )
+            layout_schema.add_extra(layout_class.validate)
+            return layout_schema.extend(schema)
+
+    # If no layout class matched, return a default schema
+    return cv.Schema(
+        {
+            cv.Optional(CONF_LAYOUT): cv.one_of(*LAYOUT_CHOICES, lower=True),
+            cv.Optional(CONF_WIDGETS): any_widget_schema(),
+        }
+    )

esphome/components/lvgl/lv_validation.py

@@ -1,3 +1,4 @@
+import re
 from typing import TYPE_CHECKING, Any
 
 import esphome.codegen as cg
@@ -246,6 +247,8 @@ def pixels_or_percent_validator(value):
         return ["pixels", "..%"]
     if isinstance(value, str) and value.lower().endswith("px"):
         value = cv.int_(value[:-2])
+    if isinstance(value, str) and re.match(r"^lv_pct\((\d+)\)$", value):
+        return value
     value = cv.Any(cv.int_, cv.percentage)(value)
     if isinstance(value, int):
         return value

esphome/components/lvgl/lvcode.py

@@ -299,6 +299,7 @@ class LvExpr(MockLv):
 
 # Top level mock for generic lv_ calls to be recorded
 lv = MockLv("lv_")
+LV = MockLv("LV_")
 # Just generate an expression
 lv_expr = LvExpr("lv_")
 # Mock for lv_obj_ calls
@@ -327,7 +328,7 @@ def lv_assign(target, expression):
     lv_add(AssignmentExpression("", "", target, expression))
 
 
-def lv_Pvariable(type, name):
+def lv_Pvariable(type, name) -> MockObj:
     """
     Create but do not initialise a pointer variable
     :param type: Type of the variable target
@@ -343,7 +344,7 @@ def lv_Pvariable(type, name):
     return var
 
 
-def lv_variable(type, name):
+def lv_variable(type, name) -> MockObj:
     """
     Create but do not initialise a variable
     :param type: Type of the variable target

esphome/components/lvgl/lvgl_esphome.cpp

@@ -82,6 +82,18 @@ static void rounder_cb(lv_disp_drv_t *disp_drv, lv_area_t *area) {
   area->y2 = (area->y2 + draw_rounding) / draw_rounding * draw_rounding - 1;
 }
 
+void LvglComponent::monitor_cb(lv_disp_drv_t *disp_drv, uint32_t time, uint32_t px) {
+  ESP_LOGVV(TAG, "Draw end: %" PRIu32 " pixels in %" PRIu32 " ms", px, time);
+  auto *comp = static_cast<LvglComponent *>(disp_drv->user_data);
+  comp->draw_end_();
+}
+
+void LvglComponent::render_start_cb(lv_disp_drv_t *disp_drv) {
+  ESP_LOGVV(TAG, "Draw start");
+  auto *comp = static_cast<LvglComponent *>(disp_drv->user_data);
+  comp->draw_start_();
+}
+
 lv_event_code_t lv_api_event;     // NOLINT
 lv_event_code_t lv_update_event;  // NOLINT
 void LvglComponent::dump_config() {
@@ -101,7 +113,10 @@ void LvglComponent::set_paused(bool paused, bool show_snow) {
     lv_disp_trig_activity(this->disp_);  // resets the inactivity time
     lv_obj_invalidate(lv_scr_act());
   }
-  this->pause_callbacks_.call(paused);
+  if (paused && this->pause_callback_ != nullptr)
+    this->pause_callback_->trigger();
+  if (!paused && this->resume_callback_ != nullptr)
+    this->resume_callback_->trigger();
 }
 
 void LvglComponent::esphome_lvgl_init() {
@@ -156,6 +171,7 @@ bool LvPageType::is_showing() const { return this->parent_->get_current_page() =
 void LvglComponent::draw_buffer_(const lv_area_t *area, lv_color_t *ptr) {
   auto width = lv_area_get_width(area);
   auto height = lv_area_get_height(area);
+  auto height_rounded = (height + this->draw_rounding - 1) / this->draw_rounding * this->draw_rounding;
   auto x1 = area->x1;
   auto y1 = area->y1;
   lv_color_t *dst = this->rotate_buf_;
@@ -163,13 +179,13 @@ void LvglComponent::draw_buffer_(const lv_area_t *area, lv_color_t *ptr) {
     case display::DISPLAY_ROTATION_90_DEGREES:
       for (lv_coord_t x = height; x-- != 0;) {
         for (lv_coord_t y = 0; y != width; y++) {
-          dst[y * height + x] = *ptr++;
+          dst[y * height_rounded + x] = *ptr++;
         }
       }
       y1 = x1;
       x1 = this->disp_drv_.ver_res - area->y1 - height;
-      width = height;
-      height = lv_area_get_width(area);
+      height = width;
+      width = height_rounded;
       break;
 
     case display::DISPLAY_ROTATION_180_DEGREES:
@@ -185,13 +201,13 @@ void LvglComponent::draw_buffer_(const lv_area_t *area, lv_color_t *ptr) {
     case display::DISPLAY_ROTATION_270_DEGREES:
       for (lv_coord_t x = 0; x != height; x++) {
         for (lv_coord_t y = width; y-- != 0;) {
-          dst[y * height + x] = *ptr++;
+          dst[y * height_rounded + x] = *ptr++;
         }
       }
       x1 = y1;
       y1 = this->disp_drv_.hor_res - area->x1 - width;
-      width = height;
-      height = lv_area_get_width(area);
+      height = width;
+      width = height_rounded;
       break;
 
     default:
@@ -225,13 +241,6 @@ IdleTrigger::IdleTrigger(LvglComponent *parent, TemplatableValue<uint32_t> timeo
   });
 }
 
-PauseTrigger::PauseTrigger(LvglComponent *parent, TemplatableValue<bool> paused) : paused_(std::move(paused)) {
-  parent->add_on_pause_callback([this](bool pausing) {
-    if (this->paused_.value() == pausing)
-      this->trigger();
-  });
-}
-
 #ifdef USE_LVGL_TOUCHSCREEN
 LVTouchListener::LVTouchListener(uint16_t long_press_time, uint16_t long_press_repeat_time, LvglComponent *parent) {
   this->set_parent(parent);
@@ -435,8 +444,10 @@ LvglComponent::LvglComponent(std::vector<display::Display *> displays, float buf
 
 void LvglComponent::setup() {
   auto *display = this->displays_[0];
-  auto width = display->get_width();
-  auto height = display->get_height();
+  auto rounding = this->draw_rounding;
+  // cater for displays with dimensions that don't divide by the required rounding
+  auto width = (display->get_width() + rounding - 1) / rounding * rounding;
+  auto height = (display->get_height() + rounding - 1) / rounding * rounding;
   auto frac = this->buffer_frac_;
   if (frac == 0)
     frac = 1;
@@ -461,9 +472,8 @@ void LvglComponent::setup() {
   }
   this->buffer_frac_ = frac;
   lv_disp_draw_buf_init(&this->draw_buf_, buffer, nullptr, buffer_pixels);
-  this->disp_drv_.hor_res = width;
-  this->disp_drv_.ver_res = height;
-  // this->setup_driver_(display->get_width(), display->get_height());
+  this->disp_drv_.hor_res = display->get_width();
+  this->disp_drv_.ver_res = display->get_height();
   lv_disp_drv_update(this->disp_, &this->disp_drv_);
   this->rotation = display->get_rotation();
   if (this->rotation != display::DISPLAY_ROTATION_0_DEGREES) {
@@ -474,6 +484,12 @@ void LvglComponent::setup() {
       return;
     }
   }
+  if (this->draw_start_callback_ != nullptr) {
+    this->disp_drv_.render_start_cb = render_start_cb;
+  }
+  if (this->draw_end_callback_ != nullptr) {
+    this->disp_drv_.monitor_cb = monitor_cb;
+  }
 #if LV_USE_LOG
   lv_log_register_print_cb([](const char *buf) {
     auto next = strchr(buf, ')');
@@ -502,8 +518,9 @@ void LvglComponent::loop() {
   if (this->paused_) {
     if (this->show_snow_)
       this->write_random_();
-  }
+  } else {
     lv_timer_handler_run_in_period(5);
+  }
 }
 
 #ifdef USE_LVGL_ANIMIMG

esphome/components/lvgl/lvgl_esphome.h

@@ -171,9 +171,10 @@ class LvglComponent : public PollingComponent {
   void add_on_idle_callback(std::function<void(uint32_t)> &&callback) {
     this->idle_callbacks_.add(std::move(callback));
   }
-  void add_on_pause_callback(std::function<void(bool)> &&callback) { this->pause_callbacks_.add(std::move(callback)); }
+
+  static void monitor_cb(lv_disp_drv_t *disp_drv, uint32_t time, uint32_t px);
+  static void render_start_cb(lv_disp_drv_t *disp_drv);
   void dump_config() override;
-  bool is_idle(uint32_t idle_ms) { return lv_disp_get_inactive_time(this->disp_) > idle_ms; }
   lv_disp_t *get_disp() { return this->disp_; }
   lv_obj_t *get_scr_act() { return lv_disp_get_scr_act(this->disp_); }
   // Pause or resume the display.
@@ -213,12 +214,20 @@ class LvglComponent : public PollingComponent {
   size_t draw_rounding{2};
 
   display::DisplayRotation rotation{display::DISPLAY_ROTATION_0_DEGREES};
+  void set_pause_trigger(Trigger<> *trigger) { this->pause_callback_ = trigger; }
+  void set_resume_trigger(Trigger<> *trigger) { this->resume_callback_ = trigger; }
+  void set_draw_start_trigger(Trigger<> *trigger) { this->draw_start_callback_ = trigger; }
+  void set_draw_end_trigger(Trigger<> *trigger) { this->draw_end_callback_ = trigger; }
 
  protected:
+  // these functions are never called unless the callbacks are non-null since the
+  // LVGL callbacks that call them are not set unless the start/end callbacks are non-null
+  void draw_start_() const { this->draw_start_callback_->trigger(); }
+  void draw_end_() const { this->draw_end_callback_->trigger(); }
+
   void write_random_();
   void draw_buffer_(const lv_area_t *area, lv_color_t *ptr);
   void flush_cb_(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p);
-
   std::vector<display::Display *> displays_{};
   size_t buffer_frac_{1};
   bool full_refresh_{};
@@ -235,7 +244,10 @@ class LvglComponent : public PollingComponent {
   std::map<lv_group_t *, lv_obj_t *> focus_marks_{};
 
   CallbackManager<void(uint32_t)> idle_callbacks_{};
-  CallbackManager<void(bool)> pause_callbacks_{};
+  Trigger<> *pause_callback_{};
+  Trigger<> *resume_callback_{};
+  Trigger<> *draw_start_callback_{};
+  Trigger<> *draw_end_callback_{};
   lv_color_t *rotate_buf_{};
 };
 
@@ -248,14 +260,6 @@ class IdleTrigger : public Trigger<> {
   bool is_idle_{};
 };
 
-class PauseTrigger : public Trigger<> {
- public:
-  explicit PauseTrigger(LvglComponent *parent, TemplatableValue<bool> paused);
-
- protected:
-  TemplatableValue<bool> paused_;
-};
-
 template<typename... Ts> class LvglAction : public Action<Ts...>, public Parented<LvglComponent> {
  public:
   explicit LvglAction(std::function<void(LvglComponent *)> &&lamb) : action_(std::move(lamb)) {}

esphome/components/lvgl/schemas.py

@@ -12,17 +12,21 @@ from esphome.const import (
     CONF_TEXT,
     CONF_TIME,
     CONF_TRIGGER_ID,
-    CONF_TYPE,
     CONF_X,
     CONF_Y,
 )
 from esphome.core import TimePeriod
 from esphome.core.config import StartupTrigger
-from esphome.schema_extractors import SCHEMA_EXTRACT
 
 from . import defines as df, lv_validation as lvalid
-from .defines import CONF_TIME_FORMAT, LV_GRAD_DIR, TYPE_GRID
-from .helpers import add_lv_use, requires_component, validate_printf
+from .defines import CONF_TIME_FORMAT, LV_GRAD_DIR
+from .helpers import requires_component, validate_printf
+from .layout import (
+    FLEX_OBJ_SCHEMA,
+    GRID_CELL_SCHEMA,
+    append_layout_schema,
+    grid_alignments,
+)
 from .lv_validation import lv_color, lv_font, lv_gradient, lv_image, opacity
 from .lvcode import LvglComponent, lv_event_t_ptr
 from .types import (
@@ -72,11 +76,9 @@ def _validate_text(value):
 
 
 # A schema for text properties
-TEXT_SCHEMA = cv.Schema(
-    {
+TEXT_SCHEMA = {
     cv.Optional(CONF_TEXT): _validate_text,
-    }
-)
+}
 
 LIST_ACTION_SCHEMA = cv.ensure_list(
     cv.maybe_simple_value(
@@ -136,7 +138,7 @@ STYLE_PROPS = {
     "arc_opa": lvalid.opacity,
     "arc_color": lvalid.lv_color,
     "arc_rounded": lvalid.lv_bool,
-    "arc_width": lvalid.lv_positive_int,
+    "arc_width": lvalid.pixels,
     "anim_time": lvalid.lv_milliseconds,
     "bg_color": lvalid.lv_color,
     "bg_grad": lv_gradient,
@@ -223,10 +225,6 @@ STYLE_REMAP = {
     "image_recolor_opa": "img_recolor_opa",
 }
 
-cell_alignments = df.LV_CELL_ALIGNMENTS.one_of
-grid_alignments = df.LV_GRID_ALIGNMENTS.one_of
-flex_alignments = df.LV_FLEX_ALIGNMENTS.one_of
-
 # Complete object style schema
 STYLE_SCHEMA = cv.Schema({cv.Optional(k): v for k, v in STYLE_PROPS.items()}).extend(
     {
@@ -266,10 +264,8 @@ def part_schema(parts):
     :param parts:  The parts to include
     :return: The schema
     """
-    return (
-        cv.Schema({cv.Optional(part): STATE_SCHEMA for part in parts})
-        .extend(STATE_SCHEMA)
-        .extend(FLAG_SCHEMA)
+    return STATE_SCHEMA.extend(FLAG_SCHEMA).extend(
+        {cv.Optional(part): STATE_SCHEMA for part in parts}
     )
 
 
@@ -277,10 +273,10 @@ def automation_schema(typ: LvType):
     events = df.LV_EVENT_TRIGGERS + df.SWIPE_TRIGGERS
     if typ.has_on_value:
         events = events + (CONF_ON_VALUE,)
-    args = typ.get_arg_type() if isinstance(typ, LvType) else []
+    args = typ.get_arg_type()
     args.append(lv_event_t_ptr)
-    return cv.Schema(
-        {
+    return {
+        **{
             cv.Optional(event): validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
@@ -289,14 +285,11 @@ def automation_schema(typ: LvType):
                 }
             )
             for event in events
-        }
-    ).extend(
-        {
+        },
         cv.Optional(CONF_ON_BOOT): validate_automation(
             {cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StartupTrigger)}
-            )
+        ),
     }
-    )
 
 
 def base_update_schema(widget_type, parts):
@@ -335,75 +328,17 @@ def obj_schema(widget_type: WidgetType):
     """
     return (
         part_schema(widget_type.parts)
-        .extend(LAYOUT_SCHEMA)
         .extend(ALIGN_TO_SCHEMA)
         .extend(automation_schema(widget_type.w_type))
         .extend(
-            cv.Schema(
             {
                 cv.Optional(CONF_STATE): SET_STATE_SCHEMA,
                 cv.Optional(CONF_GROUP): cv.use_id(lv_group_t),
             }
         )
     )
-    )
 
 
-def _validate_grid_layout(config):
-    layout = config[df.CONF_LAYOUT]
-    rows = len(layout[df.CONF_GRID_ROWS])
-    columns = len(layout[df.CONF_GRID_COLUMNS])
-    used_cells = [[None] * columns for _ in range(rows)]
-    for index, widget in enumerate(config[df.CONF_WIDGETS]):
-        _, w = next(iter(widget.items()))
-        if (df.CONF_GRID_CELL_COLUMN_POS in w) != (df.CONF_GRID_CELL_ROW_POS in w):
-            # pylint: disable=raise-missing-from
-            raise cv.Invalid(
-                "Both row and column positions must be specified, or both omitted",
-                [df.CONF_WIDGETS, index],
-            )
-        if df.CONF_GRID_CELL_ROW_POS in w:
-            row = w[df.CONF_GRID_CELL_ROW_POS]
-            column = w[df.CONF_GRID_CELL_COLUMN_POS]
-        else:
-            try:
-                row, column = next(
-                    (r_idx, c_idx)
-                    for r_idx, row in enumerate(used_cells)
-                    for c_idx, value in enumerate(row)
-                    if value is None
-                )
-            except StopIteration:
-                # pylint: disable=raise-missing-from
-                raise cv.Invalid(
-                    "No free cells available in grid layout", [df.CONF_WIDGETS, index]
-                )
-            w[df.CONF_GRID_CELL_ROW_POS] = row
-            w[df.CONF_GRID_CELL_COLUMN_POS] = column
-
-        for i in range(w[df.CONF_GRID_CELL_ROW_SPAN]):
-            for j in range(w[df.CONF_GRID_CELL_COLUMN_SPAN]):
-                if row + i >= rows or column + j >= columns:
-                    # pylint: disable=raise-missing-from
-                    raise cv.Invalid(
-                        f"Cell at {row}/{column} span {w[df.CONF_GRID_CELL_ROW_SPAN]}x{w[df.CONF_GRID_CELL_COLUMN_SPAN]} "
-                        f"exceeds grid size {rows}x{columns}",
-                        [df.CONF_WIDGETS, index],
-                    )
-                if used_cells[row + i][column + j] is not None:
-                    # pylint: disable=raise-missing-from
-                    raise cv.Invalid(
-                        f"Cell span {row + i}/{column + j} already occupied by widget at index {used_cells[row + i][column + j]}",
-                        [df.CONF_WIDGETS, index],
-                    )
-                used_cells[row + i][column + j] = index
-
-    return config
-
-
-LAYOUT_SCHEMAS = {}
-LAYOUT_VALIDATORS = {TYPE_GRID: _validate_grid_layout}
-
 ALIGN_TO_SCHEMA = {
     cv.Optional(df.CONF_ALIGN_TO): cv.Schema(
         {
@@ -416,57 +351,6 @@ ALIGN_TO_SCHEMA = {
 }
 
 
-def grid_free_space(value):
-    value = cv.Upper(value)
-    if value.startswith("FR(") and value.endswith(")"):
-        value = value.removesuffix(")").removeprefix("FR(")
-        return f"LV_GRID_FR({cv.positive_int(value)})"
-    raise cv.Invalid("must be a size in pixels, CONTENT or FR(nn)")
-
-
-grid_spec = cv.Any(
-    lvalid.size, df.LvConstant("LV_GRID_", "CONTENT").one_of, grid_free_space
-)
-
-LAYOUT_SCHEMA = {
-    cv.Optional(df.CONF_LAYOUT): cv.typed_schema(
-        {
-            df.TYPE_GRID: {
-                cv.Required(df.CONF_GRID_ROWS): [grid_spec],
-                cv.Required(df.CONF_GRID_COLUMNS): [grid_spec],
-                cv.Optional(df.CONF_GRID_COLUMN_ALIGN): grid_alignments,
-                cv.Optional(df.CONF_GRID_ROW_ALIGN): grid_alignments,
-                cv.Optional(df.CONF_PAD_ROW): lvalid.padding,
-                cv.Optional(df.CONF_PAD_COLUMN): lvalid.padding,
-            },
-            df.TYPE_FLEX: {
-                cv.Optional(
-                    df.CONF_FLEX_FLOW, default="row_wrap"
-                ): df.FLEX_FLOWS.one_of,
-                cv.Optional(df.CONF_FLEX_ALIGN_MAIN, default="start"): flex_alignments,
-                cv.Optional(df.CONF_FLEX_ALIGN_CROSS, default="start"): flex_alignments,
-                cv.Optional(df.CONF_FLEX_ALIGN_TRACK, default="start"): flex_alignments,
-                cv.Optional(df.CONF_PAD_ROW): lvalid.padding,
-                cv.Optional(df.CONF_PAD_COLUMN): lvalid.padding,
-            },
-        },
-        lower=True,
-    )
-}
-
-GRID_CELL_SCHEMA = {
-    cv.Optional(df.CONF_GRID_CELL_ROW_POS): cv.positive_int,
-    cv.Optional(df.CONF_GRID_CELL_COLUMN_POS): cv.positive_int,
-    cv.Optional(df.CONF_GRID_CELL_ROW_SPAN, default=1): cv.positive_int,
-    cv.Optional(df.CONF_GRID_CELL_COLUMN_SPAN, default=1): cv.positive_int,
-    cv.Optional(df.CONF_GRID_CELL_X_ALIGN): grid_alignments,
-    cv.Optional(df.CONF_GRID_CELL_Y_ALIGN): grid_alignments,
-}
-
-FLEX_OBJ_SCHEMA = {
-    cv.Optional(df.CONF_FLEX_GROW): cv.int_,
-}
-
 DISP_BG_SCHEMA = cv.Schema(
     {
         cv.Optional(df.CONF_DISP_BG_IMAGE): cv.Any(
@@ -498,48 +382,11 @@ ALL_STYLES = {
 }
 
 
-def container_validator(schema, widget_type: WidgetType):
-    """
-    Create a validator for a container given the widget type
-    :param schema: Base schema to extend
-    :param widget_type:
-    :return:
-    """
-
-    def validator(value):
-        if w_sch := widget_type.schema:
-            if isinstance(w_sch, dict):
-                w_sch = cv.Schema(w_sch)
-            # order is important here to preserve extras
-            result = w_sch.extend(schema)
-        else:
-            result = schema
-        ltype = df.TYPE_NONE
-        if value and (layout := value.get(df.CONF_LAYOUT)):
-            if not isinstance(layout, dict):
-                raise cv.Invalid("Layout value must be a dict")
-            ltype = layout.get(CONF_TYPE)
-            if not ltype:
-                raise (cv.Invalid("Layout schema requires type:"))
-            add_lv_use(ltype)
-        if value == SCHEMA_EXTRACT:
-            return result
-        result = result.extend(
-            LAYOUT_SCHEMAS.get(ltype.lower(), LAYOUT_SCHEMAS[df.TYPE_NONE])
-        )
-        value = result(value)
-        if layout_validator := LAYOUT_VALIDATORS.get(ltype):
-            value = layout_validator(value)
-        return value
-
-    return validator
-
-
 def container_schema(widget_type: WidgetType, extras=None):
     """
     Create a schema for a container widget of a given type. All obj properties are available, plus
     the extras passed in, plus any defined for the specific widget being specified.
-    :param widget_type:     The widget type, e.g. "img"
+    :param widget_type:     The widget type, e.g. "image"
     :param extras:  Additional options to be made available, e.g. layout properties for children
     :return: The schema for this type of widget.
     """
@@ -549,31 +396,49 @@ def container_schema(widget_type: WidgetType, extras=None):
     if extras:
         schema = schema.extend(extras)
     # Delayed evaluation for recursion
-    return container_validator(schema, widget_type)
 
+    schema = schema.extend(widget_type.schema)
 
-def widget_schema(widget_type: WidgetType, extras=None):
-    """
-    Create a schema for a given widget type
-    :param widget_type: The name of the widget
-    :param extras:
-    :return:
-    """
-    validator = container_schema(widget_type, extras=extras)
-    if required := widget_type.required_component:
-        validator = cv.All(validator, requires_component(required))
-    return cv.Exclusive(widget_type.name, df.CONF_WIDGETS), validator
+    def validator(value):
+        return append_layout_schema(schema, value)(value)
 
-
-# All widget schemas must be defined before this is called.
+    return validator
 
 
 def any_widget_schema(extras=None):
     """
-    Generate schemas for all possible LVGL widgets. This is what implements the ability to have a list of any kind of
+    Dynamically generate schemas for all possible LVGL widgets. This is what implements the ability to have a list of any kind of
     widget under the widgets: key.
 
     :param extras: Additional schema to be applied to each generated one
-    :return:
+    :return: A validator for the Widgets key
     """
-    return cv.Any(dict(widget_schema(wt, extras) for wt in WIDGET_TYPES.values()))
+
+    def validator(value):
+        if isinstance(value, dict):
+            # Convert to list
+            value = [{k: v} for k, v in value.items()]
+        if not isinstance(value, list):
+            raise cv.Invalid("Expected a list of widgets")
+        result = []
+        for index, entry in enumerate(value):
+            if not isinstance(entry, dict) or len(entry) != 1:
+                raise cv.Invalid(
+                    "Each widget must be a dictionary with a single key", path=[index]
+                )
+            [(key, value)] = entry.items()
+            # Validate the widget against its schema
+            widget_type = WIDGET_TYPES.get(key)
+            if not widget_type:
+                raise cv.Invalid(f"Unknown widget type: {key}", path=[index])
+            container_validator = container_schema(widget_type, extras=extras)
+            if required := widget_type.required_component:
+                container_validator = cv.All(
+                    container_validator, requires_component(required)
+                )
+            # Apply custom validation
+            value = widget_type.validate(value or {})
+            result.append({key: container_validator(value)})
+        return result
+
+    return validator

esphome/components/lvgl/types.py

@@ -1,8 +1,10 @@
 import sys
 
 from esphome import automation, codegen as cg
+from esphome.config_validation import Schema
 from esphome.const import CONF_MAX_VALUE, CONF_MIN_VALUE, CONF_TEXT, CONF_VALUE
 from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.cpp_types import esphome_ns
 
 from .defines import lvgl_ns
 from .lvcode import lv_expr
@@ -42,8 +44,11 @@ lv_event_code_t = cg.global_ns.enum("lv_event_code_t")
 lv_indev_type_t = cg.global_ns.enum("lv_indev_type_t")
 lv_key_t = cg.global_ns.enum("lv_key_t")
 FontEngine = lvgl_ns.class_("FontEngine")
+PlainTrigger = esphome_ns.class_("Trigger<>", automation.Trigger.template())
+DrawEndTrigger = esphome_ns.class_(
+    "Trigger<uint32_t, uint32_t>", automation.Trigger.template(cg.uint32, cg.uint32)
+)
 IdleTrigger = lvgl_ns.class_("IdleTrigger", automation.Trigger.template())
-PauseTrigger = lvgl_ns.class_("PauseTrigger", automation.Trigger.template())
 ObjUpdateAction = lvgl_ns.class_("ObjUpdateAction", automation.Action)
 LvglCondition = lvgl_ns.class_("LvglCondition", automation.Condition)
 LvglAction = lvgl_ns.class_("LvglAction", automation.Action)
@@ -131,13 +136,13 @@ class WidgetType:
         self.lv_name = lv_name or name
         self.w_type = w_type
         self.parts = parts
-        if schema is None:
-            self.schema = {}
-        else:
+        if not isinstance(schema, Schema):
+            schema = Schema(schema or {})
         self.schema = schema
         if modify_schema is None:
-            self.modify_schema = self.schema
-        else:
+            modify_schema = schema
+        if not isinstance(modify_schema, Schema):
+            modify_schema = Schema(modify_schema)
         self.modify_schema = modify_schema
         self.mock_obj = MockObj(f"lv_{self.lv_name}", "_")
 
@@ -159,7 +164,6 @@ class WidgetType:
         :param config: Its configuration
         :return: Generated code as a list of text lines
         """
-        return []
 
     async def obj_creator(self, parent: MockObjClass, config: dict):
         """
@@ -170,6 +174,13 @@ class WidgetType:
         """
         return lv_expr.call(f"{self.lv_name}_create", parent)
 
+    def on_create(self, var: MockObj, config: dict):
+        """
+        Called from to_code when the widget is created, to set up any initial properties
+        :param var: The variable representing the widget
+        :param config: Its configuration
+        """
+
     def get_uses(self):
         """
         Get a list of other widgets used by this one
@@ -189,6 +200,14 @@ class WidgetType:
     def get_scale(self, config: dict):
         return 1.0
 
+    def validate(self, value):
+        """
+        Provides an opportunity for custom validation for a given widget type
+        :param value:
+        :return:
+        """
+        return value
+
 
 class NumberType(WidgetType):
     def get_max(self, config: dict):

esphome/components/lvgl/widgets/__init__.py

@@ -339,7 +339,10 @@ async def set_obj_properties(w: Widget, config):
         if layout_type == TYPE_FLEX:
             lv_obj.set_flex_flow(w.obj, literal(layout[CONF_FLEX_FLOW]))
             main = literal(layout[CONF_FLEX_ALIGN_MAIN])
-            cross = literal(layout[CONF_FLEX_ALIGN_CROSS])
+            cross = layout[CONF_FLEX_ALIGN_CROSS]
+            if cross == "LV_FLEX_ALIGN_STRETCH":
+                cross = "LV_FLEX_ALIGN_CENTER"
+            cross = literal(cross)
             track = literal(layout[CONF_FLEX_ALIGN_TRACK])
             lv_obj.set_flex_align(w.obj, main, cross, track)
     parts = collect_parts(config)
@@ -446,9 +449,11 @@ async def widget_to_code(w_cnfig, w_type: WidgetType, parent):
     if spec.is_compound():
         var = cg.new_Pvariable(wid)
         lv_add(var.set_obj(creator))
+        spec.on_create(var.obj, w_cnfig)
     else:
         var = lv_Pvariable(lv_obj_t, wid)
         lv_assign(var, creator)
+        spec.on_create(var, w_cnfig)
 
     w = Widget.create(wid, var, spec, w_cnfig)
     if theme := theme_widget_map.get(w_type):

esphome/components/lvgl/widgets/buttonmatrix.py

@@ -1,8 +1,9 @@
 from esphome import automation
 import esphome.codegen as cg
+from esphome.components.const import CONF_ROWS
 from esphome.components.key_provider import KeyProvider
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_ITEMS, CONF_ROWS, CONF_TEXT, CONF_WIDTH
+from esphome.const import CONF_ID, CONF_ITEMS, CONF_TEXT, CONF_WIDTH
 from esphome.cpp_generator import MockObj
 
 from ..automation import action_to_code

esphome/components/lvgl/widgets/canvas.py

@@ -33,7 +33,7 @@ from ..lv_validation import (
     pixels,
     size,
 )
-from ..lvcode import LocalVariable, lv, lv_assign
+from ..lvcode import LocalVariable, lv, lv_assign, lv_expr
 from ..schemas import STYLE_PROPS, STYLE_REMAP, TEXT_SCHEMA, point_schema
 from ..types import LvType, ObjUpdateAction, WidgetType
 from . import Widget, get_widgets
@@ -70,11 +70,14 @@ class CanvasType(WidgetType):
         width = config[CONF_WIDTH]
         height = config[CONF_HEIGHT]
         use_alpha = "_ALPHA" if config[CONF_TRANSPARENT] else ""
+        buf_size = literal(
+            f"LV_CANVAS_BUF_SIZE_TRUE_COLOR{use_alpha}({width}, {height})"
+        )
+        with LocalVariable("buf", cg.void, lv_expr.custom_mem_alloc(buf_size)) as buf:
+            cg.add(cg.RawExpression(f"memset({buf}, 0, {buf_size});"))
             lv.canvas_set_buffer(
                 w.obj,
-            lv.custom_mem_alloc(
-                literal(f"LV_CANVAS_BUF_SIZE_TRUE_COLOR{use_alpha}({width}, {height})")
-            ),
+                buf,
                 width,
                 height,
                 literal(f"LV_IMG_CF_TRUE_COLOR{use_alpha}"),
@@ -156,18 +159,15 @@ async def canvas_set_pixel(config, action_id, template_arg, args):
     )
 
 
-DRAW_SCHEMA = cv.Schema(
-    {
+DRAW_SCHEMA = {
     cv.GenerateID(CONF_ID): cv.use_id(lv_canvas_t),
     cv.Required(CONF_X): pixels,
     cv.Required(CONF_Y): pixels,
-    }
-)
-DRAW_OPA_SCHEMA = DRAW_SCHEMA.extend(
-    {
+}
+DRAW_OPA_SCHEMA = {
+    **DRAW_SCHEMA,
     cv.Optional(CONF_OPA): opacity,
-    }
-)
+}
 
 
 async def draw_to_code(config, dsc_type, props, do_draw, action_id, template_arg, args):
@@ -221,12 +221,14 @@ RECT_PROPS = {
 @automation.register_action(
     "lvgl.canvas.draw_rectangle",
     ObjUpdateAction,
-    DRAW_SCHEMA.extend(
+    cv.Schema(
         {
+            **DRAW_OPA_SCHEMA,
             cv.Required(CONF_WIDTH): cv.templatable(cv.int_),
             cv.Required(CONF_HEIGHT): cv.templatable(cv.int_),
-        },
-    ).extend({cv.Optional(prop): STYLE_PROPS[prop] for prop in RECT_PROPS}),
+            **{cv.Optional(prop): STYLE_PROPS[prop] for prop in RECT_PROPS},
+        }
+    ),
 )
 async def canvas_draw_rect(config, action_id, template_arg, args):
     width = await pixels.process(config[CONF_WIDTH])
@@ -258,13 +260,14 @@ TEXT_PROPS = {
 @automation.register_action(
     "lvgl.canvas.draw_text",
     ObjUpdateAction,
-    TEXT_SCHEMA.extend(DRAW_OPA_SCHEMA)
-    .extend(
+    cv.Schema(
         {
+            **TEXT_SCHEMA,
+            **DRAW_OPA_SCHEMA,
             cv.Required(CONF_MAX_WIDTH): cv.templatable(cv.int_),
+            **{cv.Optional(prop): STYLE_PROPS[f"text_{prop}"] for prop in TEXT_PROPS},
         },
-    )
-    .extend({cv.Optional(prop): STYLE_PROPS[f"text_{prop}"] for prop in TEXT_PROPS}),
+    ),
 )
 async def canvas_draw_text(config, action_id, template_arg, args):
     text = await lv_text.process(config[CONF_TEXT])
@@ -290,13 +293,15 @@ IMG_PROPS = {
 @automation.register_action(
     "lvgl.canvas.draw_image",
     ObjUpdateAction,
-    DRAW_OPA_SCHEMA.extend(
+    cv.Schema(
         {
+            **DRAW_OPA_SCHEMA,
             cv.Required(CONF_SRC): lv_image,
             cv.Optional(CONF_PIVOT_X, default=0): pixels,
             cv.Optional(CONF_PIVOT_Y, default=0): pixels,
-        },
-    ).extend({cv.Optional(prop): validator for prop, validator in IMG_PROPS.items()}),
+            **{cv.Optional(prop): validator for prop, validator in IMG_PROPS.items()},
+        }
+    ),
 )
 async def canvas_draw_image(config, action_id, template_arg, args):
     src = await lv_image.process(config[CONF_SRC])
@@ -333,8 +338,9 @@ LINE_PROPS = {
             cv.GenerateID(CONF_ID): cv.use_id(lv_canvas_t),
             cv.Optional(CONF_OPA): opacity,
             cv.Required(CONF_POINTS): cv.ensure_list(point_schema),
-        },
-    ).extend({cv.Optional(prop): validator for prop, validator in LINE_PROPS.items()}),
+            **{cv.Optional(prop): validator for prop, validator in LINE_PROPS.items()},
+        }
+    ),
 )
 async def canvas_draw_line(config, action_id, template_arg, args):
     points = [
@@ -360,8 +366,9 @@ async def canvas_draw_line(config, action_id, template_arg, args):
         {
             cv.GenerateID(CONF_ID): cv.use_id(lv_canvas_t),
             cv.Required(CONF_POINTS): cv.ensure_list(point_schema),
+            **{cv.Optional(prop): STYLE_PROPS[prop] for prop in RECT_PROPS},
         },
-    ).extend({cv.Optional(prop): STYLE_PROPS[prop] for prop in RECT_PROPS}),
+    ),
 )
 async def canvas_draw_polygon(config, action_id, template_arg, args):
     points = [
@@ -392,13 +399,15 @@ ARC_PROPS = {
 @automation.register_action(
     "lvgl.canvas.draw_arc",
     ObjUpdateAction,
-    DRAW_OPA_SCHEMA.extend(
+    cv.Schema(
         {
+            **DRAW_OPA_SCHEMA,
             cv.Required(CONF_RADIUS): pixels,
             cv.Required(CONF_START_ANGLE): lv_angle_degrees,
             cv.Required(CONF_END_ANGLE): lv_angle_degrees,
+            **{cv.Optional(prop): validator for prop, validator in ARC_PROPS.items()},
         }
-    ).extend({cv.Optional(prop): validator for prop, validator in ARC_PROPS.items()}),
+    ),
 )
 async def canvas_draw_arc(config, action_id, template_arg, args):
     radius = await size.process(config[CONF_RADIUS])

esphome/components/lvgl/widgets/checkbox.py

@@ -17,11 +17,10 @@ class CheckboxType(WidgetType):
             CONF_CHECKBOX,
             LvBoolean("lv_checkbox_t"),
             (CONF_MAIN, CONF_INDICATOR),
-            TEXT_SCHEMA.extend(
             {
+                **TEXT_SCHEMA,
                 Optional(CONF_PAD_COLUMN): padding,
-                }
-            ),
+            },
         )
 
     async def to_code(self, w: Widget, config):

esphome/components/lvgl/widgets/container.py

@@ -0,0 +1,39 @@
+import esphome.config_validation as cv
+from esphome.const import CONF_HEIGHT, CONF_WIDTH
+from esphome.cpp_generator import MockObj
+
+from ..defines import CONF_CONTAINER, CONF_MAIN, CONF_OBJ, CONF_SCROLLBAR
+from ..lv_validation import size
+from ..lvcode import lv
+from ..types import WidgetType, lv_obj_t
+
+CONTAINER_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_HEIGHT, default="100%"): size,
+        cv.Optional(CONF_WIDTH, default="100%"): size,
+    }
+)
+
+
+class ContainerType(WidgetType):
+    """
+    A simple container widget that can hold other widgets and which defaults to a 100% size.
+    Made from an obj with all styles removed
+    """
+
+    def __init__(self):
+        super().__init__(
+            CONF_CONTAINER,
+            lv_obj_t,
+            (CONF_MAIN, CONF_SCROLLBAR),
+            schema=CONTAINER_SCHEMA,
+            modify_schema={},
+            lv_name=CONF_OBJ,
+        )
+        self.styles = {}
+
+    def on_create(self, var: MockObj, config: dict):
+        lv.obj_remove_style_all(var)
+
+
+container_spec = ContainerType()

esphome/components/lvgl/widgets/label.py

@@ -23,12 +23,11 @@ class LabelType(WidgetType):
             CONF_LABEL,
             LvText("lv_label_t"),
             (CONF_MAIN, CONF_SCROLLBAR, CONF_SELECTED),
-            TEXT_SCHEMA.extend(
             {
+                **TEXT_SCHEMA,
                 cv.Optional(CONF_RECOLOR): lv_bool,
                 cv.Optional(CONF_LONG_MODE): LV_LONG_MODES.one_of,
-                }
-            ),
+            },
         )
 
     async def to_code(self, w: Widget, config):

esphome/components/lvgl/widgets/qrcode.py

@@ -14,13 +14,12 @@ CONF_QRCODE = "qrcode"
 CONF_DARK_COLOR = "dark_color"
 CONF_LIGHT_COLOR = "light_color"
 
-QRCODE_SCHEMA = TEXT_SCHEMA.extend(
-    {
+QRCODE_SCHEMA = {
+    **TEXT_SCHEMA,
     cv.Optional(CONF_DARK_COLOR, default="black"): lv_color,
     cv.Optional(CONF_LIGHT_COLOR, default="white"): lv_color,
     cv.Required(CONF_SIZE): cv.int_,
-    }
-)
+}
 
 
 class QrCodeType(WidgetType):

esphome/components/lvgl/widgets/textarea.py

@@ -21,15 +21,14 @@ CONF_TEXTAREA = "textarea"
 
 lv_textarea_t = LvText("lv_textarea_t")
 
-TEXTAREA_SCHEMA = TEXT_SCHEMA.extend(
-    {
+TEXTAREA_SCHEMA = {
+    **TEXT_SCHEMA,
     cv.Optional(CONF_PLACEHOLDER_TEXT): lv_text,
     cv.Optional(CONF_ACCEPTED_CHARS): lv_text,
     cv.Optional(CONF_ONE_LINE): lv_bool,
     cv.Optional(CONF_PASSWORD_MODE): lv_bool,
     cv.Optional(CONF_MAX_LENGTH): lv_int,
-    }
-)
+}
 
 
 class TextareaType(WidgetType):

esphome/components/matrix_keypad/__init__.py

@@ -1,8 +1,9 @@
 from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import key_provider
+from esphome.components.const import CONF_ROWS
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_ON_KEY, CONF_PIN, CONF_ROWS, CONF_TRIGGER_ID
+from esphome.const import CONF_ID, CONF_ON_KEY, CONF_PIN, CONF_TRIGGER_ID
 
 CODEOWNERS = ["@ssieb"]
 

esphome/components/max7219digit/max7219digit.cpp

@@ -271,7 +271,11 @@ void MAX7219Component::send64pixels(uint8_t chip, const uint8_t pixels[8]) {
         }
       }
     } else if (this->orientation_ == 1) {
+      if (this->flip_x_) {
+        b = pixels[7 - col];
+      } else {
         b = pixels[col];
+      }
     } else if (this->orientation_ == 2) {
       for (uint8_t i = 0; i < 8; i++) {
         if (this->flip_x_) {
@@ -282,9 +286,13 @@ void MAX7219Component::send64pixels(uint8_t chip, const uint8_t pixels[8]) {
       }
     } else {
       for (uint8_t i = 0; i < 8; i++) {
+        if (this->flip_x_) {
+          b |= ((pixels[col] >> i) & 1) << (7 - i);
+        } else {
           b |= ((pixels[7 - col] >> i) & 1) << (7 - i);
         }
       }
+    }
     // send this byte to display at selected chip
     if (this->invert_) {
       this->send_byte_(col + 1, ~b);

esphome/components/micro_wake_word/__init__.py

@@ -7,7 +7,7 @@ from urllib.parse import urljoin
 from esphome import automation, external_files, git
 from esphome.automation import register_action, register_condition
 import esphome.codegen as cg
-from esphome.components import esp32, microphone
+from esphome.components import esp32, microphone, socket
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_FILE,
@@ -32,6 +32,7 @@ _LOGGER = logging.getLogger(__name__)
 
 CODEOWNERS = ["@kahrendt", "@jesserockz"]
 DEPENDENCIES = ["microphone"]
+AUTO_LOAD = ["socket"]
 DOMAIN = "micro_wake_word"
 
 
@@ -443,6 +444,10 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
+    # Enable wake_loop_threadsafe() for low-latency wake word detection
+    # The inference task queues detection events that need immediate processing
+    socket.require_wake_loop_threadsafe()
+
     mic_source = await microphone.microphone_source_to_code(config[CONF_MICROPHONE])
     cg.add(var.set_microphone_source(mic_source))
 

esphome/components/micro_wake_word/micro_wake_word.cpp

@@ -2,6 +2,7 @@
 
 #ifdef USE_ESP_IDF
 
+#include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -426,6 +427,12 @@ void MicroWakeWord::process_probabilities_() {
         if (vad_state.detected) {
 #endif
           xQueueSend(this->detection_queue_, &wake_word_state, portMAX_DELAY);
+
+          // Wake main loop immediately to process wake word detection
+#if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
+          App.wake_loop_threadsafe();
+#endif
+
           model->reset_probabilities();
 #ifdef USE_MICRO_WAKE_WORD_VAD
         } else {

esphome/components/midea/ac_adapter.cpp

@@ -8,9 +8,9 @@ namespace midea {
 namespace ac {
 
 const char *const Constants::TAG = "midea";
-const std::string Constants::FREEZE_PROTECTION = "freeze protection";
-const std::string Constants::SILENT = "silent";
-const std::string Constants::TURBO = "turbo";
+const char *const Constants::FREEZE_PROTECTION = "freeze protection";
+const char *const Constants::SILENT = "silent";
+const char *const Constants::TURBO = "turbo";
 
 ClimateMode Converters::to_climate_mode(MideaMode mode) {
   switch (mode) {
@@ -108,7 +108,7 @@ bool Converters::is_custom_midea_fan_mode(MideaFanMode mode) {
   }
 }
 
-const std::string &Converters::to_custom_climate_fan_mode(MideaFanMode mode) {
+const char *Converters::to_custom_climate_fan_mode(MideaFanMode mode) {
   switch (mode) {
     case MideaFanMode::FAN_SILENT:
       return Constants::SILENT;
@@ -117,8 +117,8 @@ const std::string &Converters::to_custom_climate_fan_mode(MideaFanMode mode) {
   }
 }
 
-MideaFanMode Converters::to_midea_fan_mode(const std::string &mode) {
-  if (mode == Constants::SILENT)
+MideaFanMode Converters::to_midea_fan_mode(const char *mode) {
+  if (strcmp(mode, Constants::SILENT) == 0)
     return MideaFanMode::FAN_SILENT;
   return MideaFanMode::FAN_TURBO;
 }
@@ -151,9 +151,9 @@ ClimatePreset Converters::to_climate_preset(MideaPreset preset) {
 
 bool Converters::is_custom_midea_preset(MideaPreset preset) { return preset == MideaPreset::PRESET_FREEZE_PROTECTION; }
 
-const std::string &Converters::to_custom_climate_preset(MideaPreset preset) { return Constants::FREEZE_PROTECTION; }
+const char *Converters::to_custom_climate_preset(MideaPreset preset) { return Constants::FREEZE_PROTECTION; }
 
-MideaPreset Converters::to_midea_preset(const std::string &preset) { return MideaPreset::PRESET_FREEZE_PROTECTION; }
+MideaPreset Converters::to_midea_preset(const char *preset) { return MideaPreset::PRESET_FREEZE_PROTECTION; }
 
 void Converters::to_climate_traits(ClimateTraits &traits, const dudanov::midea::ac::Capabilities &capabilities) {
   if (capabilities.supportAutoMode())
@@ -169,7 +169,7 @@ void Converters::to_climate_traits(ClimateTraits &traits, const dudanov::midea::
   if (capabilities.supportEcoPreset())
     traits.add_supported_preset(ClimatePreset::CLIMATE_PRESET_ECO);
   if (capabilities.supportFrostProtectionPreset())
-    traits.add_supported_custom_preset(Constants::FREEZE_PROTECTION);
+    traits.set_supported_custom_presets({Constants::FREEZE_PROTECTION});
 }
 
 }  // namespace ac

esphome/components/midea/ac_adapter.h

@@ -20,9 +20,9 @@ using MideaPreset = dudanov::midea::ac::Preset;
 class Constants {
  public:
   static const char *const TAG;
-  static const std::string FREEZE_PROTECTION;
-  static const std::string SILENT;
-  static const std::string TURBO;
+  static const char *const FREEZE_PROTECTION;
+  static const char *const SILENT;
+  static const char *const TURBO;
 };
 
 class Converters {
@@ -32,15 +32,15 @@ class Converters {
   static MideaSwingMode to_midea_swing_mode(ClimateSwingMode mode);
   static ClimateSwingMode to_climate_swing_mode(MideaSwingMode mode);
   static MideaPreset to_midea_preset(ClimatePreset preset);
-  static MideaPreset to_midea_preset(const std::string &preset);
+  static MideaPreset to_midea_preset(const char *preset);
   static bool is_custom_midea_preset(MideaPreset preset);
   static ClimatePreset to_climate_preset(MideaPreset preset);
-  static const std::string &to_custom_climate_preset(MideaPreset preset);
+  static const char *to_custom_climate_preset(MideaPreset preset);
   static MideaFanMode to_midea_fan_mode(ClimateFanMode fan_mode);
-  static MideaFanMode to_midea_fan_mode(const std::string &fan_mode);
+  static MideaFanMode to_midea_fan_mode(const char *fan_mode);
   static bool is_custom_midea_fan_mode(MideaFanMode fan_mode);
   static ClimateFanMode to_climate_fan_mode(MideaFanMode fan_mode);
-  static const std::string &to_custom_climate_fan_mode(MideaFanMode fan_mode);
+  static const char *to_custom_climate_fan_mode(MideaFanMode fan_mode);
   static void to_climate_traits(ClimateTraits &traits, const dudanov::midea::ac::Capabilities &capabilities);
 };
 

esphome/components/midea/air_conditioner.cpp

@@ -64,13 +64,13 @@ void AirConditioner::control(const ClimateCall &call) {
     ctrl.mode = Converters::to_midea_mode(call.get_mode().value());
   if (call.get_preset().has_value()) {
     ctrl.preset = Converters::to_midea_preset(call.get_preset().value());
-  } else if (call.get_custom_preset().has_value()) {
-    ctrl.preset = Converters::to_midea_preset(call.get_custom_preset().value());
+  } else if (call.has_custom_preset()) {
+    ctrl.preset = Converters::to_midea_preset(call.get_custom_preset());
   }
   if (call.get_fan_mode().has_value()) {
     ctrl.fanMode = Converters::to_midea_fan_mode(call.get_fan_mode().value());
-  } else if (call.get_custom_fan_mode().has_value()) {
-    ctrl.fanMode = Converters::to_midea_fan_mode(call.get_custom_fan_mode().value());
+  } else if (call.has_custom_fan_mode()) {
+    ctrl.fanMode = Converters::to_midea_fan_mode(call.get_custom_fan_mode());
   }
   this->base_.control(ctrl);
 }
@@ -84,7 +84,9 @@ ClimateTraits AirConditioner::traits() {
   traits.set_supported_modes(this->supported_modes_);
   traits.set_supported_swing_modes(this->supported_swing_modes_);
   traits.set_supported_presets(this->supported_presets_);
+  if (!this->supported_custom_presets_.empty())
     traits.set_supported_custom_presets(this->supported_custom_presets_);
+  if (!this->supported_custom_fan_modes_.empty())
     traits.set_supported_custom_fan_modes(this->supported_custom_fan_modes_);
   /* + MINIMAL SET OF CAPABILITIES */
   traits.add_supported_fan_mode(ClimateFanMode::CLIMATE_FAN_AUTO);

esphome/components/midea/air_conditioner.h

@@ -46,8 +46,8 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   void set_supported_modes(ClimateModeMask modes) { this->supported_modes_ = modes; }
   void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
   void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
-  void set_custom_presets(const std::vector<std::string> &presets) { this->supported_custom_presets_ = presets; }
-  void set_custom_fan_modes(const std::vector<std::string> &modes) { this->supported_custom_fan_modes_ = modes; }
+  void set_custom_presets(std::initializer_list<const char *> presets) { this->supported_custom_presets_ = presets; }
+  void set_custom_fan_modes(std::initializer_list<const char *> modes) { this->supported_custom_fan_modes_ = modes; }
 
  protected:
   void control(const ClimateCall &call) override;
@@ -55,8 +55,8 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   ClimateModeMask supported_modes_{};
   ClimateSwingModeMask supported_swing_modes_{};
   ClimatePresetMask supported_presets_{};
-  std::vector<std::string> supported_custom_presets_{};
-  std::vector<std::string> supported_custom_fan_modes_{};
+  std::vector<const char *> supported_custom_presets_{};
+  std::vector<const char *> supported_custom_fan_modes_{};
   Sensor *outdoor_sensor_{nullptr};
   Sensor *humidity_sensor_{nullptr};
   Sensor *power_sensor_{nullptr};

esphome/components/mipi/__init__.py

@@ -218,6 +218,21 @@ def map_sequence(value):
     return tuple(value)
 
 
+def flatten_sequence(sequence: tuple | list):
+    """
+    Flatten an init sequence into a single list of bytes.
+    :param sequence:  The list of tuples
+    :return: a list of bytes
+    """
+    return sum(
+        tuple(
+            (x[1], 0xFF) if x[0] == DELAY_FLAG else (x[0], len(x) - 1) + x[1:]
+            for x in sequence
+        ),
+        (),
+    )
+
+
 def delay(ms):
     return DELAY_FLAG, ms
 
@@ -456,13 +471,7 @@ class DriverChip:
 
         # Flatten the sequence into a list of bytes, with the length of each command
         # or the delay flag inserted where needed
-        return sum(
-            tuple(
-                (x[1], 0xFF) if x[0] == DELAY_FLAG else (x[0], len(x) - 1) + x[1:]
-                for x in sequence
-            ),
-            (),
-        ), madctl
+        return flatten_sequence(sequence), madctl
 
 
 def requires_buffer(config) -> bool:

esphome/components/mopeka_std_check/mopeka_std_check.cpp

@@ -72,7 +72,7 @@ bool MopekaStdCheck::parse_device(const esp32_ble_tracker::ESPBTDevice &device)
 
   const u_int8_t hardware_id = mopeka_data->data_1 & 0xCF;
   if (static_cast<SensorType>(hardware_id) != STANDARD && static_cast<SensorType>(hardware_id) != XL &&
-      static_cast<SensorType>(hardware_id) != ETRAILER) {
+      static_cast<SensorType>(hardware_id) != ETRAILER && static_cast<SensorType>(hardware_id) != STANDARD_ALT) {
     ESP_LOGE(TAG, "[%s] Unsupported Sensor Type (0x%X)", device.address_str().c_str(), hardware_id);
     return false;
   }

esphome/components/mopeka_std_check/mopeka_std_check.h

@@ -15,6 +15,7 @@ namespace mopeka_std_check {
 enum SensorType {
   STANDARD = 0x02,
   XL = 0x03,
+  STANDARD_ALT = 0x44,
   ETRAILER = 0x46,
 };
 

esphome/components/mqtt/__init__.py

@@ -3,7 +3,7 @@ import re
 from esphome import automation
 from esphome.automation import Condition
 import esphome.codegen as cg
-from esphome.components import logger
+from esphome.components import logger, socket
 from esphome.components.esp32 import add_idf_sdkconfig_option
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
@@ -66,6 +66,9 @@ DEPENDENCIES = ["network"]
 def AUTO_LOAD():
     if CORE.is_esp8266 or CORE.is_libretiny:
         return ["async_tcp", "json"]
+    # ESP32 needs socket for wake_loop_threadsafe()
+    if CORE.is_esp32:
+        return ["json", "socket"]
     return ["json"]
 
 
@@ -213,8 +216,6 @@ def validate_fingerprint(value):
 
 def _consume_mqtt_sockets(config: ConfigType) -> ConfigType:
     """Register socket needs for MQTT component."""
-    from esphome.components import socket
-
     # MQTT needs 1 socket for the broker connection
     socket.consume_sockets(1, "mqtt")(config)
     return config
@@ -341,6 +342,11 @@ async def to_code(config):
         # https://github.com/heman/async-mqtt-client/blob/master/library.json
         cg.add_library("heman/AsyncMqttClient-esphome", "2.0.0")
 
+    # MQTT on ESP32 uses wake_loop_threadsafe() to wake the main loop from the MQTT event handler
+    # This enables low-latency MQTT event processing instead of waiting for select() timeout
+    if CORE.is_esp32:
+        socket.require_wake_loop_threadsafe()
+
     cg.add_define("USE_MQTT")
     cg.add_global(mqtt_ns.using)
 

esphome/components/mqtt/mqtt_backend_esp32.cpp

@@ -190,6 +190,11 @@ void MQTTBackendESP32::mqtt_event_handler(void *handler_args, esp_event_base_t b
   if (instance) {
     auto event = *static_cast<esp_mqtt_event_t *>(event_data);
     instance->mqtt_events_.emplace(event);
+
+    // Wake main loop immediately to process MQTT event instead of waiting for select() timeout
+#if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
+    App.wake_loop_threadsafe();
+#endif
   }
 }
 

esphome/components/mqtt/mqtt_climate.cpp

@@ -357,8 +357,8 @@ bool MQTTClimateComponent::publish_state_() {
           payload = "unknown";
       }
     }
-    if (this->device_->custom_preset.has_value())
-      payload = this->device_->custom_preset.value();
+    if (this->device_->has_custom_preset())
+      payload = this->device_->get_custom_preset();
     if (!this->publish(this->get_preset_state_topic(), payload))
       success = false;
   }
@@ -429,8 +429,8 @@ bool MQTTClimateComponent::publish_state_() {
           payload = "unknown";
       }
     }
-    if (this->device_->custom_fan_mode.has_value())
-      payload = this->device_->custom_fan_mode.value();
+    if (this->device_->has_custom_fan_mode())
+      payload = this->device_->get_custom_fan_mode();
     if (!this->publish(this->get_fan_mode_state_topic(), payload))
       success = false;
   }

esphome/components/network/__init__.py

@@ -55,6 +55,7 @@ CONFIG_SCHEMA = cv.Schema(
             esp32=False,
             rp2040=False,
             bk72xx=False,
+            host=False,
         ): cv.All(
             cv.boolean,
             cv.Any(
@@ -64,6 +65,7 @@ CONFIG_SCHEMA = cv.Schema(
                     esp8266_arduino=cv.Version(0, 0, 0),
                     rp2040_arduino=cv.Version(0, 0, 0),
                     bk72xx_arduino=cv.Version(1, 7, 0),
+                    host=cv.Version(0, 0, 0),
                 ),
                 cv.boolean_false,
             ),

esphome/components/nextion/nextion.cpp

@@ -323,6 +323,8 @@ void Nextion::loop() {
       this->set_touch_sleep_timeout(this->touch_sleep_timeout_);
     }
 
+    this->set_auto_wake_on_touch(this->connection_state_.auto_wake_on_touch_);
+
     this->connection_state_.ignore_is_setup_ = false;
   }
 

esphome/components/nrf52/__init__.py

@@ -290,6 +290,7 @@ def show_logs(config: ConfigType, args, devices: list[str]) -> bool:
             address = ble_device.address
         else:
             return True
+
     if is_mac_address(address):
         asyncio.run(logger_connect(address))
         return True

esphome/components/one_wire/__init__.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.const import CONF_ADDRESS
+from esphome.const import CONF_ADDRESS, CONF_INDEX
 
 CODEOWNERS = ["@ssieb"]
 
@@ -21,7 +21,8 @@ def one_wire_device_schema():
     return cv.Schema(
         {
             cv.GenerateID(CONF_ONE_WIRE_ID): cv.use_id(OneWireBus),
-            cv.Optional(CONF_ADDRESS): cv.hex_uint64_t,
+            cv.Exclusive(CONF_ADDRESS, "index_or_address"): cv.hex_uint64_t,
+            cv.Exclusive(CONF_INDEX, "index_or_address"): cv.uint8_t,
         }
     )
 
@@ -37,3 +38,5 @@ async def register_one_wire_device(var, config):
     cg.add(var.set_one_wire_bus(parent))
     if (address := config.get(CONF_ADDRESS)) is not None:
         cg.add(var.set_address(address))
+    if (index := config.get(CONF_INDEX)) is not None:
+        cg.add(var.set_index(index))

esphome/components/one_wire/one_wire.cpp

@@ -18,10 +18,20 @@ bool OneWireDevice::send_command_(uint8_t cmd) {
   return true;
 }
 
-bool OneWireDevice::check_address_() {
+bool OneWireDevice::check_address_or_index_() {
   if (this->address_ != 0)
     return true;
   auto devices = this->bus_->get_devices();
+
+  if (this->index_ != INDEX_NOT_SET) {
+    if (this->index_ >= devices.size()) {
+      ESP_LOGE(TAG, "Index %d out of range, only %d devices found", this->index_, devices.size());
+      return false;
+    }
+    this->address_ = devices[this->index_];
+    return true;
+  }
+
   if (devices.empty()) {
     ESP_LOGE(TAG, "No devices, can't auto-select address");
     return false;

esphome/components/one_wire/one_wire.h

@@ -17,6 +17,8 @@ class OneWireDevice {
   /// @param address of the device
   void set_address(uint64_t address) { this->address_ = address; }
 
+  void set_index(uint8_t index) { this->index_ = index; }
+
   /// @brief store the pointer to the OneWireBus to use
   /// @param bus pointer to the OneWireBus object
   void set_one_wire_bus(OneWireBus *bus) { this->bus_ = bus; }
@@ -25,13 +27,16 @@ class OneWireDevice {
   const std::string &get_address_name();
 
  protected:
+  static constexpr uint8_t INDEX_NOT_SET = 255;
+
   uint64_t address_{0};
+  uint8_t index_{INDEX_NOT_SET};
   OneWireBus *bus_{nullptr};  ///< pointer to OneWireBus instance
   std::string address_name_;
 
   /// @brief find an address if necessary
   /// should be called from setup
-  bool check_address_();
+  bool check_address_or_index_();
 
   /// @brief send command on the bus
   /// @param cmd command to send

esphome/components/psram/__init__.py

@@ -1,4 +1,5 @@
 import logging
+import textwrap
 
 import esphome.codegen as cg
 from esphome.components.esp32 import (
@@ -104,6 +105,17 @@ def get_config_schema(config):
     if not speeds:
         raise cv.Invalid("PSRAM is not supported on this chip")
     modes = SPIRAM_MODES[variant]
+    if CONF_MODE not in config and len(modes) != 1:
+        raise (
+            cv.Invalid(
+                textwrap.dedent(
+                    f"""
+                        {variant} requires PSRAM mode selection; one of {", ".join(modes)}
+                        Selection of the wrong mode for the board will cause a runtime failure to initialise PSRAM
+                    """
+                )
+            )
+        )
     return cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(PsramComponent),