[axp2101] Use walrus operator to avoid double dict lookup

- Merge update() and update_sensors() methods
- Remove unnecessary variable assignments before returns
- Add #ifdef USE_SENSOR guards around sensor-related code
- Restructure number and switch to be directories for better isolation
- Use proper enum codegen helpers for PowerRail enum

.ai/instructions.md

@@ -51,7 +51,79 @@ This document provides essential context for AI models interacting with this pro
 
 *   **Naming Conventions:**
     *   **Python:** Follows PEP 8. Use clear, descriptive names following snake_case.
-    *   **C++:** Follows the Google C++ Style Guide.
+    *   **C++:** Follows the Google C++ Style Guide with these specifics (following clang-tidy conventions):
+        - Function, method, and variable names: `lower_snake_case`
+        - Class/struct/enum names: `UpperCamelCase`
+        - Top-level constants (global/namespace scope): `UPPER_SNAKE_CASE`
+        - Function-local constants: `lower_snake_case`
+        - Protected/private fields: `lower_snake_case_with_trailing_underscore_`
+        - Favor descriptive names over abbreviations
+
+*   **C++ Field Visibility:**
+    *   **Prefer `protected`:** Use `protected` for most class fields to enable extensibility and testing. Fields should be `lower_snake_case_with_trailing_underscore_`.
+    *   **Use `private` for safety-critical cases:** Use `private` visibility when direct field access could introduce bugs or violate invariants:
+        1. **Pointer lifetime issues:** When setters validate and store pointers from known lists to prevent dangling references.
+           ```cpp
+           // Helper to find matching string in vector and return its pointer
+           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;
+           }
+
+           class ClimateDevice {
+            public:
+             void set_custom_fan_modes(std::initializer_list<const char *> modes) {
+               this->custom_fan_modes_ = modes;
+               this->active_custom_fan_mode_ = nullptr;  // Reset when modes change
+             }
+             bool set_custom_fan_mode(const char *mode) {
+               // Find mode in supported list and store that pointer (not the input pointer)
+               const char *validated_mode = vector_find(this->custom_fan_modes_, mode);
+               if (validated_mode != nullptr) {
+                 this->active_custom_fan_mode_ = validated_mode;
+                 return true;
+               }
+               return false;
+             }
+            private:
+             std::vector<const char *> custom_fan_modes_;  // Pointers to string literals in flash
+             const char *active_custom_fan_mode_{nullptr};  // Must point to entry in custom_fan_modes_
+           };
+           ```
+        2. **Invariant coupling:** When multiple fields must remain synchronized to prevent buffer overflows or data corruption.
+           ```cpp
+           class Buffer {
+            public:
+             void resize(size_t new_size) {
+               auto new_data = std::make_unique<uint8_t[]>(new_size);
+               if (this->data_) {
+                 std::memcpy(new_data.get(), this->data_.get(), std::min(this->size_, new_size));
+               }
+               this->data_ = std::move(new_data);
+               this->size_ = new_size;  // Must stay in sync with data_
+             }
+            private:
+             std::unique_ptr<uint8_t[]> data_;
+             size_t size_{0};  // Must match allocated size of data_
+           };
+           ```
+        3. **Resource management:** When setters perform cleanup or registration operations that derived classes might skip.
+    *   **Provide `protected` accessor methods:** When derived classes need controlled access to `private` members.
+
+*   **C++ Preprocessor Directives:**
+    *   **Avoid `#define` for constants:** Using `#define` for constants is discouraged and should be replaced with `const` variables or enums.
+    *   **Use `#define` only for:**
+        - Conditional compilation (`#ifdef`, `#ifndef`)
+        - Compile-time sizes calculated during Python code generation (e.g., configuring `std::array` or `StaticVector` dimensions via `cg.add_define()`)
+
+*   **C++ Additional Conventions:**
+    *   **Member access:** Prefix all class member access with `this->` (e.g., `this->value_` not `value_`)
+    *   **Indentation:** Use spaces (two per indentation level), not tabs
+    *   **Type aliases:** Prefer `using type_t = int;` over `typedef int type_t;`
+    *   **Line length:** Wrap lines at no more than 120 characters
 
 *   **Component Structure:**
     *   **Standard Files:**
@@ -100,8 +172,7 @@ This document provides essential context for AI models interacting with this pro
 
     *   **C++ Class Pattern:**
         ```cpp
-        namespace esphome {
-        namespace my_component {
+        namespace esphome::my_component {
 
         class MyComponent : public Component {
          public:
@@ -117,8 +188,7 @@ This document provides essential context for AI models interacting with this pro
           int param_{0};
         };
 
-        }  // namespace my_component
-        }  // namespace esphome
+        }  // namespace esphome::my_component
         ```
 
     *   **Common Component Examples:**
@@ -368,3 +438,45 @@ This document provides essential context for AI models interacting with this pro
     *   **Python:** When adding a new Python dependency, add it to the appropriate `requirements*.txt` file and `pyproject.toml`.
     *   **C++ / PlatformIO:** When adding a new C++ dependency, add it to `platformio.ini` and use `cg.add_library`.
     *   **Build Flags:** Use `cg.add_build_flag(...)` to add compiler flags.
+
+## 8. Public API and Breaking Changes
+
+*   **Public C++ API:**
+    *   **Components**: Only documented features at [esphome.io](https://esphome.io) are public API. Undocumented `public` members are internal.
+    *   **Core/Base Classes** (`esphome/core/`, `Component`, `Sensor`, etc.): All `public` members are public API.
+    *   **Components with Global Accessors** (`global_api_server`, etc.): All `public` members are public API (except config setters).
+
+*   **Public Python API:**
+    *   All documented configuration options at [esphome.io](https://esphome.io) are public API.
+    *   Python code in `esphome/core/` actively used by existing core components is considered stable API.
+    *   Other Python code is internal unless explicitly documented for external component use.
+
+*   **Breaking Changes Policy:**
+    *   Aim for **6-month deprecation window** when possible
+    *   Clean breaks allowed for: signature changes, deep refactorings, resource constraints
+    *   Must document migration path in PR description (generates release notes)
+    *   Blog post required for core/base class changes or significant architectural changes
+    *   Full details: https://developers.esphome.io/contributing/code/#public-api-and-breaking-changes
+
+*   **Breaking Change Checklist:**
+    - [ ] Clear justification (RAM/flash savings, architectural improvement)
+    - [ ] Explored non-breaking alternatives
+    - [ ] Added deprecation warnings if possible (use `ESPDEPRECATED` macro for C++)
+    - [ ] Documented migration path in PR description with before/after examples
+    - [ ] Updated all internal usage and esphome-docs
+    - [ ] Tested backward compatibility during deprecation period
+
+*   **Deprecation Pattern (C++):**
+    ```cpp
+    // Remove before 2026.6.0
+    ESPDEPRECATED("Use new_method() instead. Removed in 2026.6.0", "2025.12.0")
+    void old_method() { this->new_method(); }
+    ```
+
+*   **Deprecation Pattern (Python):**
+    ```python
+    # Remove before 2026.6.0
+    if CONF_OLD_KEY in config:
+        _LOGGER.warning(f"'{CONF_OLD_KEY}' deprecated, use '{CONF_NEW_KEY}'. Removed in 2026.6.0")
+        config[CONF_NEW_KEY] = config.pop(CONF_OLD_KEY)  # Auto-migrate
+    ```

.github/workflows/auto-label-pr.yml

@@ -22,7 +22,7 @@ jobs:
     if: github.event.action != 'labeled' || github.event.sender.type != 'Bot'
     steps:
       - name: Checkout
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Generate a token
         id: generate-token

.github/workflows/ci-api-proto.yml

@@ -21,7 +21,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Set up Python
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
         with:

.github/workflows/ci-clang-tidy-hash.yml

@@ -21,7 +21,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Set up Python
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0

.github/workflows/ci-docker.yml

@@ -43,7 +43,7 @@ jobs:
           - "docker"
           # - "lint"
     steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Set up Python
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
         with:

.github/workflows/ci-memory-impact-comment.yml

@@ -49,7 +49,7 @@ jobs:
 
       - name: Check out code from base repository
         if: steps.pr.outputs.skip != 'true'
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
           # Always check out from the base repository (esphome/esphome), never from forks
           # Use the PR's target branch to ensure we run trusted code from the main repo

.github/workflows/ci.yml

@@ -36,7 +36,7 @@ jobs:
       cache-key: ${{ steps.cache-key.outputs.key }}
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Generate cache-key
         id: cache-key
         run: echo key="${{ hashFiles('requirements.txt', 'requirements_test.txt', '.pre-commit-config.yaml') }}" >> $GITHUB_OUTPUT
@@ -70,7 +70,7 @@ jobs:
     if: needs.determine-jobs.outputs.python-linters == 'true'
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Restore Python
         uses: ./.github/actions/restore-python
         with:
@@ -91,7 +91,7 @@ jobs:
       - common
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Restore Python
         uses: ./.github/actions/restore-python
         with:
@@ -132,7 +132,7 @@ jobs:
       - common
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Restore Python
         id: restore-python
         uses: ./.github/actions/restore-python
@@ -183,7 +183,7 @@ jobs:
       component-test-batches: ${{ steps.determine.outputs.component-test-batches }}
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
           # Fetch enough history to find the merge base
           fetch-depth: 2
@@ -237,7 +237,7 @@ jobs:
     if: needs.determine-jobs.outputs.integration-tests == 'true'
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Set up Python 3.13
         id: python
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
@@ -273,7 +273,7 @@ jobs:
     if: github.event_name == 'pull_request' && (needs.determine-jobs.outputs.cpp-unit-tests-run-all == 'true' || needs.determine-jobs.outputs.cpp-unit-tests-components != '[]')
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Restore Python
         uses: ./.github/actions/restore-python
@@ -321,7 +321,7 @@ jobs:
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
           # Need history for HEAD~1 to work for checking changed files
           fetch-depth: 2
@@ -400,7 +400,7 @@ jobs:
       GH_TOKEN: ${{ github.token }}
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
           # Need history for HEAD~1 to work for checking changed files
           fetch-depth: 2
@@ -489,7 +489,7 @@ jobs:
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
           # Need history for HEAD~1 to work for checking changed files
           fetch-depth: 2
@@ -577,7 +577,7 @@ jobs:
           version: 1.0
 
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Restore Python
         uses: ./.github/actions/restore-python
         with:
@@ -662,7 +662,7 @@ jobs:
     if: github.event_name == 'pull_request' && !startsWith(github.base_ref, 'beta') && !startsWith(github.base_ref, 'release')
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Restore Python
         uses: ./.github/actions/restore-python
         with:
@@ -688,7 +688,7 @@ jobs:
       skip: ${{ steps.check-script.outputs.skip }}
     steps:
       - name: Check out target branch
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
           ref: ${{ github.base_ref }}
 
@@ -840,7 +840,7 @@ jobs:
       flash_usage: ${{ steps.extract.outputs.flash_usage }}
     steps:
       - name: Check out PR branch
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Restore Python
         uses: ./.github/actions/restore-python
         with:
@@ -908,7 +908,7 @@ jobs:
       GH_TOKEN: ${{ github.token }}
     steps:
       - name: Check out code
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Restore Python
         uses: ./.github/actions/restore-python
         with:

.github/workflows/codeowner-review-request.yml

@@ -21,7 +21,7 @@ permissions:
 jobs:
   request-codeowner-reviews:
     name: Run
-    if: ${{ !github.event.pull_request.draft }}
+    if: ${{ github.repository == 'esphome/esphome' && !github.event.pull_request.draft }}
     runs-on: ubuntu-latest
     steps:
       - name: Request reviews from component codeowners

.github/workflows/codeql.yml

@@ -54,11 +54,11 @@ jobs:
             # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
     steps:
       - name: Checkout repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
         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@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
         with:
           category: "/language:${{matrix.language}}"

.github/workflows/release.yml

@@ -20,7 +20,7 @@ jobs:
       branch_build: ${{ steps.tag.outputs.branch_build }}
       deploy_env: ${{ steps.tag.outputs.deploy_env }}
     steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Get tag
         id: tag
         # yamllint disable rule:line-length
@@ -60,7 +60,7 @@ jobs:
       contents: read
       id-token: write
     steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Set up Python
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
         with:
@@ -92,7 +92,7 @@ jobs:
             os: "ubuntu-24.04-arm"
 
     steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Set up Python
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
         with:
@@ -168,7 +168,7 @@ jobs:
           - ghcr
           - dockerhub
     steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Download digests
         uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0

.github/workflows/sync-device-classes.yml

@@ -13,10 +13,10 @@ jobs:
     if: github.repository == 'esphome/esphome'
     steps:
       - name: Checkout
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Checkout Home Assistant
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
           repository: home-assistant/core
           path: lib/home-assistant

.pre-commit-config.yaml

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

CODEOWNERS

@@ -181,7 +181,7 @@ esphome/components/gdk101/* @Szewcson
 esphome/components/gl_r01_i2c/* @pkejval
 esphome/components/globals/* @esphome/core
 esphome/components/gp2y1010au0f/* @zry98
-esphome/components/gp8403/* @jesserockz
+esphome/components/gp8403/* @jesserockz @sebydocky
 esphome/components/gpio/* @esphome/core
 esphome/components/gpio/one_wire/* @ssieb
 esphome/components/gps/* @coogle @ximex
@@ -206,6 +206,7 @@ esphome/components/hdc2010/* @optimusprimespace @ssieb
 esphome/components/he60r/* @clydebarrow
 esphome/components/heatpumpir/* @rob-deutsch
 esphome/components/hitachi_ac424/* @sourabhjaiswal
+esphome/components/hlk_fm22x/* @OnFreund
 esphome/components/hm3301/* @freekode
 esphome/components/hmac_md5/* @dwmw2
 esphome/components/homeassistant/* @esphome/core @OttoWinter
@@ -290,6 +291,7 @@ esphome/components/mcp23x17_base/* @jesserockz
 esphome/components/mcp23xxx_base/* @jesserockz
 esphome/components/mcp2515/* @danielschramm @mvturnho
 esphome/components/mcp3204/* @rsumner
+esphome/components/mcp3221/* @philippderdiedas
 esphome/components/mcp4461/* @p1ngb4ck
 esphome/components/mcp4728/* @berfenger
 esphome/components/mcp47a1/* @jesserockz
@@ -394,6 +396,7 @@ esphome/components/rpi_dpi_rgb/* @clydebarrow
 esphome/components/rtl87xx/* @kuba2k2
 esphome/components/rtttl/* @glmnet
 esphome/components/runtime_stats/* @bdraco
+esphome/components/rx8130/* @beormund
 esphome/components/safe_mode/* @jsuanet @kbx81 @paulmonigatti
 esphome/components/scd4x/* @martgras @sjtrny
 esphome/components/script/* @esphome/core

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2025.11.0-dev
+PROJECT_NUMBER         = 2025.12.0-dev
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/__main__.py

@@ -741,13 +741,6 @@ def command_vscode(args: ArgsProtocol) -> int | None:
 
 
 def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
-    # Set memory analysis options in config
-    if args.analyze_memory:
-        config.setdefault(CONF_ESPHOME, {})["analyze_memory"] = True
-
-    if args.memory_report:
-        config.setdefault(CONF_ESPHOME, {})["memory_report_file"] = args.memory_report
-
     exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
@@ -1209,17 +1202,6 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
-    parser_compile.add_argument(
-        "--analyze-memory",
-        help="Analyze and display memory usage by component after compilation.",
-        action="store_true",
-    )
-    parser_compile.add_argument(
-        "--memory-report",
-        help="Save memory analysis report to a file (supports .json or .txt).",
-        type=str,
-        metavar="FILE",
-    )
 
     parser_upload = subparsers.add_parser(
         "upload",

esphome/analyze_memory/cli.py

@@ -1,7 +1,6 @@
 """CLI interface for memory analysis with report generation."""
 
 from collections import defaultdict
-import json
 import sys
 
 from . import (
@@ -16,6 +15,11 @@ from . import (
 class MemoryAnalyzerCLI(MemoryAnalyzer):
     """Memory analyzer with CLI-specific report generation."""
 
+    # Symbol size threshold for detailed analysis
+    SYMBOL_SIZE_THRESHOLD: int = (
+        100  # Show symbols larger than this in detailed analysis
+    )
+
     # Column width constants
     COL_COMPONENT: int = 29
     COL_FLASH_TEXT: int = 14
@@ -192,14 +196,21 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                     f"{len(symbols):>{self.COL_CORE_COUNT}} | {percentage:>{self.COL_CORE_PERCENT - 1}.1f}%"
                 )
 
-            # Top 15 largest core symbols
+            # All core symbols above threshold
             lines.append("")
-            lines.append(f"Top 15 Largest {_COMPONENT_CORE} Symbols:")
             sorted_core_symbols = sorted(
                 self._esphome_core_symbols, key=lambda x: x[2], reverse=True
             )
+            large_core_symbols = [
+                (symbol, demangled, size)
+                for symbol, demangled, size in sorted_core_symbols
+                if size > self.SYMBOL_SIZE_THRESHOLD
+            ]
 
-            for i, (symbol, demangled, size) in enumerate(sorted_core_symbols[:15]):
+            lines.append(
+                f"{_COMPONENT_CORE} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_core_symbols)} symbols):"
+            )
+            for i, (symbol, demangled, size) in enumerate(large_core_symbols):
                 lines.append(f"{i + 1}. {demangled} ({size:,} B)")
 
             lines.append("=" * self.TABLE_WIDTH)
@@ -269,13 +280,15 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 lines.append(f"Total size: {comp_mem.flash_total:,} B")
                 lines.append("")
 
-                # Show all symbols > 100 bytes for better visibility
+                # Show all symbols above threshold for better visibility
                 large_symbols = [
-                    (sym, dem, size) for sym, dem, size in sorted_symbols if size > 100
+                    (sym, dem, size)
+                    for sym, dem, size in sorted_symbols
+                    if size > self.SYMBOL_SIZE_THRESHOLD
                 ]
 
                 lines.append(
-                    f"{comp_name} Symbols > 100 B ({len(large_symbols)} symbols):"
+                    f"{comp_name} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_symbols)} symbols):"
                 )
                 for i, (symbol, demangled, size) in enumerate(large_symbols):
                     lines.append(f"{i + 1}. {demangled} ({size:,} B)")
@@ -284,28 +297,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
         return "\n".join(lines)
 
-    def to_json(self) -> str:
-        """Export analysis results as JSON."""
-        data = {
-            "components": {
-                name: {
-                    "text": mem.text_size,
-                    "rodata": mem.rodata_size,
-                    "data": mem.data_size,
-                    "bss": mem.bss_size,
-                    "flash_total": mem.flash_total,
-                    "ram_total": mem.ram_total,
-                    "symbol_count": mem.symbol_count,
-                }
-                for name, mem in self.components.items()
-            },
-            "totals": {
-                "flash": sum(c.flash_total for c in self.components.values()),
-                "ram": sum(c.ram_total for c in self.components.values()),
-            },
-        }
-        return json.dumps(data, indent=2)
-
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:
         """Dump uncategorized symbols for analysis."""
         # Sort by size descending

esphome/components/alarm_control_panel/alarm_control_panel.cpp

@@ -1,6 +1,8 @@
-#include <utility>
-
 #include "alarm_control_panel.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/controller_registry.h"
+
+#include <utility>
 
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
@@ -34,6 +36,9 @@ void AlarmControlPanel::publish_state(AlarmControlPanelState state) {
              LOG_STR_ARG(alarm_control_panel_state_to_string(prev_state)));
     this->current_state_ = state;
     this->state_callback_.call();
+#if defined(USE_ALARM_CONTROL_PANEL) && defined(USE_CONTROLLER_REGISTRY)
+    ControllerRegistry::notify_alarm_control_panel_update(this);
+#endif
     if (state == ACP_STATE_TRIGGERED) {
       this->triggered_callback_.call();
     } else if (state == ACP_STATE_ARMING) {

esphome/components/api/__init__.py

@@ -227,6 +227,7 @@ CONFIG_SCHEMA = cv.All(
                 esp32=8,  # More RAM, can buffer more
                 rp2040=5,  # Limited RAM
                 bk72xx=8,  # Moderate RAM
+                nrf52=8,  # Moderate RAM
                 rtl87xx=8,  # Moderate RAM
                 host=16,  # Abundant resources
                 ln882x=8,  # Moderate RAM
@@ -244,6 +245,9 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
+    # Track controller registration for StaticVector sizing
+    CORE.register_controller()
+
     cg.add(var.set_port(config[CONF_PORT]))
     if config[CONF_PASSWORD]:
         cg.add_define("USE_API_PASSWORD")

esphome/components/api/api.proto

@@ -2147,7 +2147,7 @@ message ListEntitiesEventResponse {
   EntityCategory entity_category = 7;
   string device_class = 8;
 
-  repeated string event_types = 9;
+  repeated string event_types = 9 [(container_pointer_no_template) = "FixedVector<const char *>"];
   uint32 device_id = 10 [(field_ifdef) = "USE_DEVICES"];
 }
 message EventResponse {

esphome/components/api/api_connection.cpp

@@ -476,8 +476,9 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
   auto *light = static_cast<light::LightState *>(entity);
   ListEntitiesLightResponse msg;
   auto traits = light->get_traits();
+  auto supported_modes = traits.get_supported_color_modes();
   // Pass pointer to ColorModeMask so the iterator can encode actual ColorMode enum values
-  msg.supported_color_modes = &traits.get_supported_color_modes();
+  msg.supported_color_modes = &supported_modes;
   if (traits.supports_color_capability(light::ColorCapability::COLOR_TEMPERATURE) ||
       traits.supports_color_capability(light::ColorCapability::COLD_WARM_WHITE)) {
     msg.min_mireds = traits.get_min_mireds();
@@ -1294,11 +1295,11 @@ void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRe
 #endif
 
 #ifdef USE_EVENT
-void APIConnection::send_event(event::Event *event, const std::string &event_type) {
-  this->schedule_message_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE,
-                          EventResponse::ESTIMATED_SIZE);
+void APIConnection::send_event(event::Event *event, const char *event_type) {
+  this->send_message_smart_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE,
+                            EventResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_event_response(event::Event *event, const std::string &event_type, APIConnection *conn,
+uint16_t APIConnection::try_send_event_response(event::Event *event, const char *event_type, APIConnection *conn,
                                                 uint32_t remaining_size, bool is_single) {
   EventResponse resp;
   resp.set_event_type(StringRef(event_type));
@@ -1310,8 +1311,7 @@ uint16_t APIConnection::try_send_event_info(EntityBase *entity, APIConnection *c
   auto *event = static_cast<event::Event *>(entity);
   ListEntitiesEventResponse msg;
   msg.set_device_class(event->get_device_class_ref());
-  for (const auto &event_type : event->get_event_types())
-    msg.event_types.push_back(event_type);
+  msg.event_types = &event->get_event_types();
   return fill_and_encode_entity_info(event, msg, ListEntitiesEventResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
@@ -1468,6 +1468,8 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
   static constexpr auto MANUFACTURER = StringRef::from_lit("Beken");
 #elif defined(USE_LN882X)
   static constexpr auto MANUFACTURER = StringRef::from_lit("Lightning");
+#elif defined(USE_NRF52)
+  static constexpr auto MANUFACTURER = StringRef::from_lit("Nordic Semiconductor");
 #elif defined(USE_RTL87XX)
   static constexpr auto MANUFACTURER = StringRef::from_lit("Realtek");
 #elif defined(USE_HOST)
@@ -1649,9 +1651,7 @@ void APIConnection::DeferredBatch::add_item(EntityBase *entity, MessageCreator c
   // O(n) but optimized for RAM and not performance.
   for (auto &item : items) {
     if (item.entity == entity && item.message_type == message_type) {
-      // Clean up old creator before replacing
-      item.creator.cleanup(message_type);
-      // Move assign the new creator
+      // Replace with new creator
       item.creator = std::move(creator);
       return;
     }
@@ -1821,7 +1821,7 @@ void APIConnection::process_batch_() {
 
   // Handle remaining items more efficiently
   if (items_processed < this->deferred_batch_.size()) {
-    // Remove processed items from the beginning with proper cleanup
+    // Remove processed items from the beginning
     this->deferred_batch_.remove_front(items_processed);
     // Reschedule for remaining items
     this->schedule_batch_();
@@ -1834,10 +1834,10 @@ void APIConnection::process_batch_() {
 uint16_t APIConnection::MessageCreator::operator()(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                    bool is_single, uint8_t message_type) const {
 #ifdef USE_EVENT
-  // Special case: EventResponse uses string pointer
+  // Special case: EventResponse uses const char * pointer
   if (message_type == EventResponse::MESSAGE_TYPE) {
     auto *e = static_cast<event::Event *>(entity);
-    return APIConnection::try_send_event_response(e, *data_.string_ptr, conn, remaining_size, is_single);
+    return APIConnection::try_send_event_response(e, data_.const_char_ptr, conn, remaining_size, is_single);
   }
 #endif
 

esphome/components/api/api_connection.h

@@ -177,7 +177,7 @@ class APIConnection final : public APIServerConnection {
 #endif
 
 #ifdef USE_EVENT
-  void send_event(event::Event *event, const std::string &event_type);
+  void send_event(event::Event *event, const char *event_type);
 #endif
 
 #ifdef USE_UPDATE
@@ -450,7 +450,7 @@ class APIConnection final : public APIServerConnection {
                                                     bool is_single);
 #endif
 #ifdef USE_EVENT
-  static uint16_t try_send_event_response(event::Event *event, const std::string &event_type, APIConnection *conn,
+  static uint16_t try_send_event_response(event::Event *event, const char *event_type, APIConnection *conn,
                                           uint32_t remaining_size, bool is_single);
   static uint16_t try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
@@ -508,10 +508,8 @@ class APIConnection final : public APIServerConnection {
     // Constructor for function pointer
     MessageCreator(MessageCreatorPtr ptr) { data_.function_ptr = ptr; }
 
-    // Constructor for string state capture
-    explicit MessageCreator(const std::string &str_value) { data_.string_ptr = new std::string(str_value); }
-
-    // No destructor - cleanup must be called explicitly with message_type
+    // Constructor for const char * (Event types - no allocation needed)
+    explicit MessageCreator(const char *str_value) { data_.const_char_ptr = str_value; }
 
     // Delete copy operations - MessageCreator should only be moved
     MessageCreator(const MessageCreator &other) = delete;
@@ -523,8 +521,6 @@ class APIConnection final : public APIServerConnection {
     // Move assignment
     MessageCreator &operator=(MessageCreator &&other) noexcept {
       if (this != &other) {
-        // IMPORTANT: Caller must ensure cleanup() was called if this contains a string!
-        // In our usage, this happens in add_item() deduplication and vector::erase()
         data_ = other.data_;
         other.data_.function_ptr = nullptr;
       }
@@ -535,20 +531,10 @@ class APIConnection final : public APIServerConnection {
     uint16_t operator()(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single,
                         uint8_t message_type) const;
 
-    // Manual cleanup method - must be called before destruction for string types
-    void cleanup(uint8_t message_type) {
-#ifdef USE_EVENT
-      if (message_type == EventResponse::MESSAGE_TYPE && data_.string_ptr != nullptr) {
-        delete data_.string_ptr;
-        data_.string_ptr = nullptr;
-      }
-#endif
-    }
-
    private:
     union Data {
       MessageCreatorPtr function_ptr;
-      std::string *string_ptr;
+      const char *const_char_ptr;
     } data_;  // 4 bytes on 32-bit, 8 bytes on 64-bit - same as before
   };
 
@@ -568,42 +554,24 @@ class APIConnection final : public APIServerConnection {
     std::vector<BatchItem> items;
     uint32_t batch_start_time{0};
 
-   private:
-    // Helper to cleanup items from the beginning
-    void cleanup_items_(size_t count) {
-      for (size_t i = 0; i < count; i++) {
-        items[i].creator.cleanup(items[i].message_type);
-      }
-    }
-
-   public:
     DeferredBatch() {
       // Pre-allocate capacity for typical batch sizes to avoid reallocation
       items.reserve(8);
     }
 
-    ~DeferredBatch() {
-      // Ensure cleanup of any remaining items
-      clear();
-    }
-
     // Add item to the batch
     void add_item(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size);
     // Add item to the front of the batch (for high priority messages like ping)
     void add_item_front(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size);
 
-    // Clear all items with proper cleanup
+    // Clear all items
     void clear() {
-      cleanup_items_(items.size());
       items.clear();
       batch_start_time = 0;
     }
 
-    // Remove processed items from the front with proper cleanup
-    void remove_front(size_t count) {
-      cleanup_items_(count);
-      items.erase(items.begin(), items.begin() + count);
-    }
+    // Remove processed items from the front
+    void remove_front(size_t count) { items.erase(items.begin(), items.begin() + count); }
 
     bool empty() const { return items.empty(); }
     size_t size() const { return items.size(); }
@@ -682,21 +650,30 @@ class APIConnection final : public APIServerConnection {
   }
 #endif
 
+  // Helper to check if a message type should bypass batching
+  // Returns true if:
+  // 1. It's an UpdateStateResponse (always send immediately to handle cases where
+  //    the main loop is blocked, e.g., during OTA updates)
+  // 2. It's an EventResponse (events are edge-triggered - every occurrence matters)
+  // 3. OR: User has opted into immediate sending (should_try_send_immediately = true
+  //    AND batch_delay = 0)
+  inline bool should_send_immediately_(uint8_t message_type) const {
+    return (
+#ifdef USE_UPDATE
+        message_type == UpdateStateResponse::MESSAGE_TYPE ||
+#endif
+#ifdef USE_EVENT
+        message_type == EventResponse::MESSAGE_TYPE ||
+#endif
+        (this->flags_.should_try_send_immediately && this->get_batch_delay_ms_() == 0));
+  }
+
   // Helper method to send a message either immediately or via batching
+  // Tries immediate send if should_send_immediately_() returns true and buffer has space
+  // Falls back to batching if immediate send fails or isn't applicable
   bool send_message_smart_(EntityBase *entity, MessageCreatorPtr creator, uint8_t message_type,
                            uint8_t estimated_size) {
-    // Try to send immediately if:
-    // 1. It's an UpdateStateResponse (always send immediately to handle cases where
-    //    the main loop is blocked, e.g., during OTA updates)
-    // 2. OR: We should try to send immediately (should_try_send_immediately = true)
-    //        AND Batch delay is 0 (user has opted in to immediate sending)
-    // 3. AND: Buffer has space available
-    if ((
-#ifdef USE_UPDATE
-            message_type == UpdateStateResponse::MESSAGE_TYPE ||
-#endif
-            (this->flags_.should_try_send_immediately && this->get_batch_delay_ms_() == 0)) &&
-        this->helper_->can_write_without_blocking()) {
+    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
       // Now actually encode and send
       if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true) &&
           this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
@@ -714,6 +691,27 @@ class APIConnection final : public APIServerConnection {
     return this->schedule_message_(entity, creator, message_type, estimated_size);
   }
 
+  // Overload for MessageCreator (used by events which need to capture event_type)
+  bool send_message_smart_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
+    // Try to send immediately if message type should bypass batching and buffer has space
+    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
+      // Now actually encode and send
+      if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true, message_type) &&
+          this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+        // Log the message in verbose mode
+        this->log_proto_message_(entity, creator, message_type);
+#endif
+        return true;
+      }
+
+      // If immediate send failed, fall through to batching
+    }
+
+    // Fall back to scheduled batching
+    return this->schedule_message_(entity, std::move(creator), message_type, estimated_size);
+  }
+
   // Helper function to schedule a deferred message with known message type
   bool schedule_message_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
     this->deferred_batch_.add_item(entity, std::move(creator), message_type, estimated_size);

esphome/components/api/api_pb2.cpp

@@ -2877,8 +2877,8 @@ void ListEntitiesEventResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_uint32(7, static_cast<uint32_t>(this->entity_category));
   buffer.encode_string(8, this->device_class_ref_);
-  for (auto &it : this->event_types) {
-    buffer.encode_string(9, it, true);
+  for (const char *it : *this->event_types) {
+    buffer.encode_string(9, it, strlen(it), true);
   }
 #ifdef USE_DEVICES
   buffer.encode_uint32(10, this->device_id);
@@ -2894,9 +2894,9 @@ void ListEntitiesEventResponse::calculate_size(ProtoSize &size) const {
   size.add_bool(1, this->disabled_by_default);
   size.add_uint32(1, static_cast<uint32_t>(this->entity_category));
   size.add_length(1, this->device_class_ref_.size());
-  if (!this->event_types.empty()) {
-    for (const auto &it : this->event_types) {
-      size.add_length_force(1, it.size());
+  if (!this->event_types->empty()) {
+    for (const char *it : *this->event_types) {
+      size.add_length_force(1, strlen(it));
     }
   }
 #ifdef USE_DEVICES

esphome/components/api/api_pb2.h

@@ -2788,7 +2788,7 @@ class ListEntitiesEventResponse final : public InfoResponseProtoMessage {
 #endif
   StringRef device_class_ref_{};
   void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
-  std::vector<std::string> event_types{};
+  const FixedVector<const char *> *event_types{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP

esphome/components/api/api_pb2_dump.cpp

@@ -2053,7 +2053,7 @@ void ListEntitiesEventResponse::dump_to(std::string &out) const {
   dump_field(out, "disabled_by_default", this->disabled_by_default);
   dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
   dump_field(out, "device_class", this->device_class_ref_);
-  for (const auto &it : this->event_types) {
+  for (const auto &it : *this->event_types) {
     dump_field(out, "event_types", it, 4);
   }
 #ifdef USE_DEVICES

esphome/components/api/api_server.cpp

@@ -5,6 +5,7 @@
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
+#include "esphome/core/controller_registry.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
@@ -34,7 +35,7 @@ APIServer::APIServer() {
 }
 
 void APIServer::setup() {
-  this->setup_controller();
+  ControllerRegistry::register_controller(this);
 
 #ifdef USE_API_NOISE
   uint32_t hash = 88491486UL;
@@ -269,7 +270,7 @@ bool APIServer::check_password(const uint8_t *password_data, size_t password_len
 
 void APIServer::handle_disconnect(APIConnection *conn) {}
 
-// Macro for entities without extra parameters
+// Macro for controller update dispatch
 #define API_DISPATCH_UPDATE(entity_type, entity_name) \
   void APIServer::on_##entity_name##_update(entity_type *obj) { /* NOLINT(bugprone-macro-parentheses) */ \
     if (obj->is_internal()) \
@@ -278,15 +279,6 @@ void APIServer::handle_disconnect(APIConnection *conn) {}
       c->send_##entity_name##_state(obj); \
   }
 
-// Macro for entities with extra parameters (but parameters not used in send)
-#define API_DISPATCH_UPDATE_IGNORE_PARAMS(entity_type, entity_name, ...) \
-  void APIServer::on_##entity_name##_update(entity_type *obj, __VA_ARGS__) { /* NOLINT(bugprone-macro-parentheses) */ \
-    if (obj->is_internal()) \
-      return; \
-    for (auto &c : this->clients_) \
-      c->send_##entity_name##_state(obj); \
-  }
-
 #ifdef USE_BINARY_SENSOR
 API_DISPATCH_UPDATE(binary_sensor::BinarySensor, binary_sensor)
 #endif
@@ -304,15 +296,15 @@ API_DISPATCH_UPDATE(light::LightState, light)
 #endif
 
 #ifdef USE_SENSOR
-API_DISPATCH_UPDATE_IGNORE_PARAMS(sensor::Sensor, sensor, float state)
+API_DISPATCH_UPDATE(sensor::Sensor, sensor)
 #endif
 
 #ifdef USE_SWITCH
-API_DISPATCH_UPDATE_IGNORE_PARAMS(switch_::Switch, switch, bool state)
+API_DISPATCH_UPDATE(switch_::Switch, switch)
 #endif
 
 #ifdef USE_TEXT_SENSOR
-API_DISPATCH_UPDATE_IGNORE_PARAMS(text_sensor::TextSensor, text_sensor, const std::string &state)
+API_DISPATCH_UPDATE(text_sensor::TextSensor, text_sensor)
 #endif
 
 #ifdef USE_CLIMATE
@@ -320,7 +312,7 @@ API_DISPATCH_UPDATE(climate::Climate, climate)
 #endif
 
 #ifdef USE_NUMBER
-API_DISPATCH_UPDATE_IGNORE_PARAMS(number::Number, number, float state)
+API_DISPATCH_UPDATE(number::Number, number)
 #endif
 
 #ifdef USE_DATETIME_DATE
@@ -336,11 +328,11 @@ API_DISPATCH_UPDATE(datetime::DateTimeEntity, datetime)
 #endif
 
 #ifdef USE_TEXT
-API_DISPATCH_UPDATE_IGNORE_PARAMS(text::Text, text, const std::string &state)
+API_DISPATCH_UPDATE(text::Text, text)
 #endif
 
 #ifdef USE_SELECT
-API_DISPATCH_UPDATE_IGNORE_PARAMS(select::Select, select, const std::string &state, size_t index)
+API_DISPATCH_UPDATE(select::Select, select)
 #endif
 
 #ifdef USE_LOCK
@@ -356,12 +348,13 @@ API_DISPATCH_UPDATE(media_player::MediaPlayer, media_player)
 #endif
 
 #ifdef USE_EVENT
-// Event is a special case - it's the only entity that passes extra parameters to the send method
-void APIServer::on_event(event::Event *obj, const std::string &event_type) {
+// Event is a special case - unlike other entities with simple state fields,
+// events store their state in a member accessed via obj->get_last_event_type()
+void APIServer::on_event(event::Event *obj) {
   if (obj->is_internal())
     return;
   for (auto &c : this->clients_)
-    c->send_event(obj, event_type);
+    c->send_event(obj, obj->get_last_event_type());
 }
 #endif
 

esphome/components/api/api_server.h

@@ -72,19 +72,19 @@ class APIServer : public Component, public Controller {
   void on_light_update(light::LightState *obj) override;
 #endif
 #ifdef USE_SENSOR
-  void on_sensor_update(sensor::Sensor *obj, float state) override;
+  void on_sensor_update(sensor::Sensor *obj) override;
 #endif
 #ifdef USE_SWITCH
-  void on_switch_update(switch_::Switch *obj, bool state) override;
+  void on_switch_update(switch_::Switch *obj) override;
 #endif
 #ifdef USE_TEXT_SENSOR
-  void on_text_sensor_update(text_sensor::TextSensor *obj, const std::string &state) override;
+  void on_text_sensor_update(text_sensor::TextSensor *obj) override;
 #endif
 #ifdef USE_CLIMATE
   void on_climate_update(climate::Climate *obj) override;
 #endif
 #ifdef USE_NUMBER
-  void on_number_update(number::Number *obj, float state) override;
+  void on_number_update(number::Number *obj) override;
 #endif
 #ifdef USE_DATETIME_DATE
   void on_date_update(datetime::DateEntity *obj) override;
@@ -96,10 +96,10 @@ class APIServer : public Component, public Controller {
   void on_datetime_update(datetime::DateTimeEntity *obj) override;
 #endif
 #ifdef USE_TEXT
-  void on_text_update(text::Text *obj, const std::string &state) override;
+  void on_text_update(text::Text *obj) override;
 #endif
 #ifdef USE_SELECT
-  void on_select_update(select::Select *obj, const std::string &state, size_t index) override;
+  void on_select_update(select::Select *obj) override;
 #endif
 #ifdef USE_LOCK
   void on_lock_update(lock::Lock *obj) override;
@@ -141,7 +141,7 @@ class APIServer : public Component, public Controller {
   void on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj) override;
 #endif
 #ifdef USE_EVENT
-  void on_event(event::Event *obj, const std::string &event_type) override;
+  void on_event(event::Event *obj) override;
 #endif
 #ifdef USE_UPDATE
   void on_update(update::UpdateEntity *obj) override;

esphome/components/api/custom_api_device.h

@@ -9,11 +9,11 @@
 namespace esphome::api {
 
 #ifdef USE_API_SERVICES
-template<typename T, typename... Ts> class CustomAPIDeviceService : public UserServiceBase<Ts...> {
+template<typename T, typename... Ts> class CustomAPIDeviceService : public UserServiceDynamic<Ts...> {
  public:
   CustomAPIDeviceService(const std::string &name, const std::array<std::string, sizeof...(Ts)> &arg_names, T *obj,
                          void (T::*callback)(Ts...))
-      : UserServiceBase<Ts...>(name, arg_names), obj_(obj), callback_(callback) {}
+      : UserServiceDynamic<Ts...>(name, arg_names), obj_(obj), callback_(callback) {}
 
  protected:
   void execute(Ts... x) override { (this->obj_->*this->callback_)(x...); }  // NOLINT

esphome/components/api/user_services.h

@@ -23,11 +23,13 @@ template<typename T> T get_execute_arg_value(const ExecuteServiceArgument &arg);
 
 template<typename T> enums::ServiceArgType to_service_arg_type();
 
+// Base class for YAML-defined services (most common case)
+// Stores only pointers to string literals in flash - no heap allocation
 template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
  public:
-  UserServiceBase(std::string name, const std::array<std::string, sizeof...(Ts)> &arg_names)
-      : name_(std::move(name)), arg_names_(arg_names) {
-    this->key_ = fnv1_hash(this->name_);
+  UserServiceBase(const char *name, const std::array<const char *, sizeof...(Ts)> &arg_names)
+      : name_(name), arg_names_(arg_names) {
+    this->key_ = fnv1_hash(name);
   }
 
   ListEntitiesServicesResponse encode_list_service_response() override {
@@ -47,7 +49,7 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
   bool execute_service(const ExecuteServiceRequest &req) override {
     if (req.key != this->key_)
       return false;
-    if (req.args.size() != this->arg_names_.size())
+    if (req.args.size() != sizeof...(Ts))
       return false;
     this->execute_(req.args, typename gens<sizeof...(Ts)>::type());
     return true;
@@ -59,14 +61,60 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
     this->execute((get_execute_arg_value<Ts>(args[S]))...);
   }
 
-  std::string name_;
+  // Pointers to string literals in flash - no heap allocation
+  const char *name_;
+  std::array<const char *, sizeof...(Ts)> arg_names_;
   uint32_t key_{0};
+};
+
+// Separate class for custom_api_device services (rare case)
+// Stores copies of runtime-generated names
+template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor {
+ public:
+  UserServiceDynamic(std::string name, const std::array<std::string, sizeof...(Ts)> &arg_names)
+      : name_(std::move(name)), arg_names_(arg_names) {
+    this->key_ = fnv1_hash(this->name_.c_str());
+  }
+
+  ListEntitiesServicesResponse encode_list_service_response() override {
+    ListEntitiesServicesResponse msg;
+    msg.set_name(StringRef(this->name_));
+    msg.key = this->key_;
+    std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
+    msg.args.init(sizeof...(Ts));
+    for (size_t i = 0; i < sizeof...(Ts); i++) {
+      auto &arg = msg.args.emplace_back();
+      arg.type = arg_types[i];
+      arg.set_name(StringRef(this->arg_names_[i]));
+    }
+    return msg;
+  }
+
+  bool execute_service(const ExecuteServiceRequest &req) override {
+    if (req.key != this->key_)
+      return false;
+    if (req.args.size() != sizeof...(Ts))
+      return false;
+    this->execute_(req.args, typename gens<sizeof...(Ts)>::type());
+    return true;
+  }
+
+ protected:
+  virtual void execute(Ts... x) = 0;
+  template<typename ArgsContainer, int... S> void execute_(const ArgsContainer &args, seq<S...> type) {
+    this->execute((get_execute_arg_value<Ts>(args[S]))...);
+  }
+
+  // Heap-allocated strings for runtime-generated names
+  std::string name_;
   std::array<std::string, sizeof...(Ts)> arg_names_;
+  uint32_t key_{0};
 };
 
 template<typename... Ts> class UserServiceTrigger : public UserServiceBase<Ts...>, public Trigger<Ts...> {
  public:
-  UserServiceTrigger(const std::string &name, const std::array<std::string, sizeof...(Ts)> &arg_names)
+  // Constructor for static names (YAML-defined services - used by code generator)
+  UserServiceTrigger(const char *name, const std::array<const char *, sizeof...(Ts)> &arg_names)
       : UserServiceBase<Ts...>(name, arg_names) {}
 
  protected:

esphome/components/axp2101/__init__.py

@@ -0,0 +1,29 @@
+"""AXP2101 Power Management IC component for ESPHome."""
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c
+from esphome.const import CONF_ID
+
+CODEOWNERS = ["@esphome/core"]
+DEPENDENCIES = ["i2c"]
+MULTI_CONF = True
+
+axp2101_ns = cg.esphome_ns.namespace("axp2101")
+AXP2101Component = axp2101_ns.class_("AXP2101Component", cg.PollingComponent, i2c.I2CDevice)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(AXP2101Component),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x34))
+)
+
+
+async def to_code(config):
+    """Generate code for the AXP2101 component."""
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)

esphome/components/axp2101/axp2101.cpp

@@ -0,0 +1,369 @@
+/**
+ * @file axp2101.cpp
+ * @brief Implementation of AXP2101 Power Management IC Component
+ */
+#include "axp2101.h"
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+
+namespace esphome {
+namespace axp2101 {
+
+static const char *const TAG = "axp2101";
+
+// Temperature conversion constant (from datasheet)
+static const float TEMP_CONVERSION_FACTOR = 0.1f;
+static const float TEMP_OFFSET = -267.15f;
+
+void AXP2101Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up AXP2101...");
+
+  // Read chip ID to verify communication
+  uint8_t chip_id;
+  if (!this->read_byte(AXP2101_IC_TYPE, &chip_id)) {
+    ESP_LOGE(TAG, "Failed to read chip ID");
+    this->mark_failed();
+    return;
+  }
+
+  ESP_LOGD(TAG, "Chip ID: 0x%02X", chip_id);
+
+  // Enable ADC channels for monitoring
+  // Enable battery voltage, VBUS, VSYS, and temperature measurements
+  uint8_t adc_ctrl = 0xFF;  // Enable all ADC channels
+  if (!this->write_byte(AXP2101_ADC_CHANNEL_CTRL, adc_ctrl)) {
+    ESP_LOGW(TAG, "Failed to configure ADC channels");
+  }
+
+  ESP_LOGCONFIG(TAG, "AXP2101 setup complete");
+}
+
+void AXP2101Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "AXP2101:");
+  LOG_I2C_DEVICE(this);
+
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication with AXP2101 failed!");
+    return;
+  }
+
+#ifdef USE_SENSOR
+  // Log sensor configuration
+  LOG_SENSOR("  ", "Battery Voltage", this->battery_voltage_sensor_);
+  LOG_SENSOR("  ", "Battery Level", this->battery_level_sensor_);
+  LOG_SENSOR("  ", "VBUS Voltage", this->vbus_voltage_sensor_);
+  LOG_SENSOR("  ", "VSYS Voltage", this->vsys_voltage_sensor_);
+  LOG_SENSOR("  ", "Die Temperature", this->die_temperature_sensor_);
+#endif
+}
+
+void AXP2101Component::update() {
+#ifdef USE_SENSOR
+  if (this->battery_voltage_sensor_ != nullptr) {
+    this->battery_voltage_sensor_->publish_state(this->read_battery_voltage() / 1000.0f);
+  }
+
+  if (this->battery_level_sensor_ != nullptr) {
+    this->battery_level_sensor_->publish_state(this->read_battery_level());
+  }
+
+  if (this->vbus_voltage_sensor_ != nullptr) {
+    this->vbus_voltage_sensor_->publish_state(this->read_vbus_voltage() / 1000.0f);
+  }
+
+  if (this->vsys_voltage_sensor_ != nullptr) {
+    this->vsys_voltage_sensor_->publish_state(this->read_vsys_voltage() / 1000.0f);
+  }
+
+  if (this->die_temperature_sensor_ != nullptr) {
+    this->die_temperature_sensor_->publish_state(this->read_die_temperature());
+  }
+#endif
+}
+
+bool AXP2101Component::set_register_bit(uint8_t reg, uint8_t bit) {
+  uint8_t value;
+  if (!this->read_byte(reg, &value)) {
+    return false;
+  }
+  value |= (1 << bit);
+  return this->write_byte(reg, value);
+}
+
+bool AXP2101Component::clear_register_bit(uint8_t reg, uint8_t bit) {
+  uint8_t value;
+  if (!this->read_byte(reg, &value)) {
+    return false;
+  }
+  value &= ~(1 << bit);
+  return this->write_byte(reg, value);
+}
+
+bool AXP2101Component::get_register_bit(uint8_t reg, uint8_t bit) {
+  uint8_t value;
+  if (!this->read_byte(reg, &value)) {
+    return false;
+  }
+  return (value & (1 << bit)) != 0;
+}
+
+uint16_t AXP2101Component::read_register_h5l8(uint8_t high_reg, uint8_t low_reg) {
+  uint8_t high, low;
+  if (!this->read_byte(high_reg, &high) || !this->read_byte(low_reg, &low)) {
+    return 0;
+  }
+  return ((high & 0x1F) << 8) | low;
+}
+
+uint16_t AXP2101Component::read_register_h6l8(uint8_t high_reg, uint8_t low_reg) {
+  uint8_t high, low;
+  if (!this->read_byte(high_reg, &high) || !this->read_byte(low_reg, &low)) {
+    return 0;
+  }
+  return ((high & 0x3F) << 8) | low;
+}
+
+bool AXP2101Component::get_rail_enable_info(PowerRail rail, uint8_t &reg, uint8_t &bit) {
+  // DCDC rails are controlled by DC_ONOFF_DVM_CTRL register
+  if (rail >= DCDC1 && rail <= DCDC5) {
+    reg = AXP2101_DC_ONOFF_DVM_CTRL;
+    bit = static_cast<uint8_t>(rail);  // DCDC1=bit0, DCDC2=bit1, etc.
+    return true;
+  }
+
+  // LDO rails are controlled by LDO_ONOFF_CTRL0 and LDO_ONOFF_CTRL1
+  if (rail >= ALDO1 && rail <= DLDO2) {
+    if (rail <= BLDO2) {
+      reg = AXP2101_LDO_ONOFF_CTRL0;
+      bit = static_cast<uint8_t>(rail - ALDO1);  // ALDO1=bit0, ALDO2=bit1, etc.
+    } else {
+      reg = AXP2101_LDO_ONOFF_CTRL1;
+      bit = static_cast<uint8_t>(rail - CPUSLDO);  // CPUSLDO=bit0, DLDO1=bit1, DLDO2=bit2
+    }
+    return true;
+  }
+
+  return false;
+}
+
+bool AXP2101Component::get_rail_voltage_info(PowerRail rail, uint8_t &reg, uint16_t &min_mv, uint16_t &max_mv,
+                                              uint16_t &step_mv) {
+  switch (rail) {
+    case DCDC1:
+      reg = AXP2101_DC_VOL0_CTRL;
+      min_mv = 1500;
+      max_mv = 3400;
+      step_mv = 100;
+      return true;
+
+    case DCDC2:
+    case DCDC3:
+    case DCDC4:
+      // These have dual ranges, handle in calculate methods
+      reg = AXP2101_DC_VOL1_CTRL + (rail - DCDC2);
+      min_mv = 500;
+      max_mv = 1540;
+      step_mv = 10;
+      return true;
+
+    case DCDC5:
+      reg = AXP2101_DC_VOL4_CTRL;
+      min_mv = 1400;
+      max_mv = 3700;
+      step_mv = 100;
+      return true;
+
+    case ALDO1:
+    case ALDO2:
+    case ALDO3:
+    case ALDO4:
+      reg = AXP2101_ALDO1_VOL_CTRL + (rail - ALDO1);
+      min_mv = 500;
+      max_mv = 3500;
+      step_mv = 100;
+      return true;
+
+    case BLDO1:
+    case BLDO2:
+      reg = AXP2101_BLDO1_VOL_CTRL + (rail - BLDO1);
+      min_mv = 500;
+      max_mv = 3500;
+      step_mv = 100;
+      return true;
+
+    case CPUSLDO:
+      reg = AXP2101_CPUSLDO_VOL_CTRL;
+      min_mv = 500;
+      max_mv = 1400;
+      step_mv = 50;
+      return true;
+
+    case DLDO1:
+    case DLDO2:
+      reg = AXP2101_DLDO1_VOL_CTRL + (rail - DLDO1);
+      min_mv = 500;
+      max_mv = 3400;
+      step_mv = 100;
+      return true;
+
+    default:
+      return false;
+  }
+}
+
+uint8_t AXP2101Component::calculate_voltage_register_value(PowerRail rail, uint16_t millivolts) {
+  // Special handling for DCDC2, DCDC3, DCDC4 with dual ranges
+  if (rail == DCDC2 || rail == DCDC3 || rail == DCDC4) {
+    if (millivolts >= 500 && millivolts <= 1200) {
+      // Range 1: 500-1200mV in 10mV steps
+      return static_cast<uint8_t>((millivolts - 500) / 10);
+    } else if (millivolts >= 1220 && millivolts <= 1540) {
+      // Range 2: 1220-1540mV in 20mV steps
+      return static_cast<uint8_t>(70 + (millivolts - 1220) / 20);
+    } else if (rail == DCDC3 && millivolts >= 1600 && millivolts <= 3400) {
+      // DCDC3 has an extended range
+      return static_cast<uint8_t>(87 + (millivolts - 1600) / 100);
+    }
+    return 0;  // Invalid voltage
+  }
+
+  // Special handling for DCDC4 extended range
+  if (rail == DCDC4 && millivolts >= 1600 && millivolts <= 1840) {
+    return static_cast<uint8_t>(87 + (millivolts - 1600) / 20);
+  }
+
+  // Standard calculation for other rails
+  uint8_t reg;
+  uint16_t min_mv, max_mv, step_mv;
+  if (!this->get_rail_voltage_info(rail, reg, min_mv, max_mv, step_mv)) {
+    return 0;
+  }
+
+  if (millivolts < min_mv || millivolts > max_mv) {
+    return 0;  // Out of range
+  }
+
+  if ((millivolts - min_mv) % step_mv != 0) {
+    return 0;  // Not aligned to step size
+  }
+
+  return static_cast<uint8_t>((millivolts - min_mv) / step_mv);
+}
+
+uint16_t AXP2101Component::calculate_millivolts_from_register(PowerRail rail, uint8_t reg_value) {
+  // Special handling for DCDC2, DCDC3, DCDC4 with dual ranges
+  if (rail == DCDC2 || rail == DCDC3 || rail == DCDC4) {
+    if (reg_value <= 70) {
+      // Range 1: 500-1200mV in 10mV steps
+      return 500 + (reg_value * 10);
+    } else if (reg_value <= 86) {
+      // Range 2: 1220-1540mV in 20mV steps
+      return 1220 + ((reg_value - 70) * 20);
+    } else if (rail == DCDC3 && reg_value <= 105) {
+      // DCDC3 extended range: 1600-3400mV in 100mV steps
+      return 1600 + ((reg_value - 87) * 100);
+    } else if (rail == DCDC4 && reg_value <= 99) {
+      // DCDC4 extended range: 1600-1840mV in 20mV steps
+      return 1600 + ((reg_value - 87) * 20);
+    }
+    return 0;  // Invalid
+  }
+
+  // Standard calculation for other rails
+  uint8_t reg;
+  uint16_t min_mv, max_mv, step_mv;
+  if (!this->get_rail_voltage_info(rail, reg, min_mv, max_mv, step_mv)) {
+    return 0;
+  }
+
+  return min_mv + (reg_value * step_mv);
+}
+
+bool AXP2101Component::enable_power_rail(PowerRail rail) {
+  uint8_t reg, bit;
+  if (!this->get_rail_enable_info(rail, reg, bit)) {
+    return false;
+  }
+  return this->set_register_bit(reg, bit);
+}
+
+bool AXP2101Component::disable_power_rail(PowerRail rail) {
+  uint8_t reg, bit;
+  if (!this->get_rail_enable_info(rail, reg, bit)) {
+    return false;
+  }
+  return this->clear_register_bit(reg, bit);
+}
+
+bool AXP2101Component::is_power_rail_enabled(PowerRail rail) {
+  uint8_t reg, bit;
+  if (!this->get_rail_enable_info(rail, reg, bit)) {
+    return false;
+  }
+  return this->get_register_bit(reg, bit);
+}
+
+bool AXP2101Component::set_rail_voltage(PowerRail rail, uint16_t millivolts) {
+  uint8_t reg;
+  uint16_t min_mv, max_mv, step_mv;
+  if (!this->get_rail_voltage_info(rail, reg, min_mv, max_mv, step_mv)) {
+    ESP_LOGE(TAG, "Invalid power rail");
+    return false;
+  }
+
+  uint8_t value = this->calculate_voltage_register_value(rail, millivolts);
+  if (value == 0 && millivolts != 0) {
+    ESP_LOGE(TAG, "Invalid voltage %u mV for rail", millivolts);
+    return false;
+  }
+
+  return this->write_byte(reg, value);
+}
+
+uint16_t AXP2101Component::get_rail_voltage(PowerRail rail) {
+  uint8_t reg;
+  uint16_t min_mv, max_mv, step_mv;
+  if (!this->get_rail_voltage_info(rail, reg, min_mv, max_mv, step_mv)) {
+    return 0;
+  }
+
+  uint8_t value;
+  if (!this->read_byte(reg, &value)) {
+    return 0;
+  }
+
+  return this->calculate_millivolts_from_register(rail, value & 0x7F);
+}
+
+uint16_t AXP2101Component::read_battery_voltage() {
+  // 1 LSB = 1mV
+  return this->read_register_h5l8(AXP2101_ADC_DATA_RELUST0, AXP2101_ADC_DATA_RELUST1);
+}
+
+uint16_t AXP2101Component::read_vbus_voltage() {
+  // 1 LSB = 1mV
+  return this->read_register_h5l8(AXP2101_ADC_DATA_RELUST4, AXP2101_ADC_DATA_RELUST5);
+}
+
+uint16_t AXP2101Component::read_vsys_voltage() {
+  // 1 LSB = 1mV
+  return this->read_register_h6l8(AXP2101_ADC_DATA_RELUST6, AXP2101_ADC_DATA_RELUST7);
+}
+
+float AXP2101Component::read_die_temperature() {
+  // Temperature conversion: T = raw * 0.1 - 267.15
+  return (this->read_register_h6l8(AXP2101_ADC_DATA_RELUST8, AXP2101_ADC_DATA_RELUST9) * TEMP_CONVERSION_FACTOR) +
+         TEMP_OFFSET;
+}
+
+uint8_t AXP2101Component::read_battery_level() {
+  uint8_t level;
+  if (!this->read_byte(AXP2101_BAT_PERCENT_DATA, &level)) {
+    return 0;
+  }
+  return level > 100 ? 100 : level;
+}
+
+
+}  // namespace axp2101
+}  // namespace esphome

esphome/components/axp2101/axp2101.h

@@ -0,0 +1,175 @@
+/**
+ * @file axp2101.h
+ * @brief AXP2101 Power Management IC Component
+ *
+ * This component provides access to the AXP2101 PMIC which includes:
+ * - 5 DCDC regulators (DCDC1-5)
+ * - 11 LDO regulators (ALDO1-4, BLDO1-2, CPUSLDO, DLDO1-2)
+ * - Battery management and charging
+ * - ADC monitoring (battery voltage, current, temperature, etc.)
+ */
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/sensor/sensor.h"
+
+namespace esphome {
+namespace axp2101 {
+
+// Register addresses
+static const uint8_t AXP2101_STATUS1 = 0x00;
+static const uint8_t AXP2101_STATUS2 = 0x01;
+static const uint8_t AXP2101_IC_TYPE = 0x03;
+static const uint8_t AXP2101_COMMON_CONFIG = 0x10;
+static const uint8_t AXP2101_BATFET_CTRL = 0x12;
+static const uint8_t AXP2101_MIN_SYS_VOL_CTRL = 0x14;
+static const uint8_t AXP2101_INPUT_VOL_LIMIT_CTRL = 0x15;
+static const uint8_t AXP2101_INPUT_CUR_LIMIT_CTRL = 0x16;
+static const uint8_t AXP2101_PWRON_STATUS = 0x20;
+static const uint8_t AXP2101_PWROFF_STATUS = 0x21;
+static const uint8_t AXP2101_PWROFF_EN = 0x22;
+
+// ADC control and data registers
+static const uint8_t AXP2101_ADC_CHANNEL_CTRL = 0x30;
+static const uint8_t AXP2101_ADC_DATA_RELUST0 = 0x34;  // Battery voltage high
+static const uint8_t AXP2101_ADC_DATA_RELUST1 = 0x35;  // Battery voltage low
+static const uint8_t AXP2101_ADC_DATA_RELUST2 = 0x36;  // TS voltage high
+static const uint8_t AXP2101_ADC_DATA_RELUST3 = 0x37;  // TS voltage low
+static const uint8_t AXP2101_ADC_DATA_RELUST4 = 0x38;  // VBUS voltage high
+static const uint8_t AXP2101_ADC_DATA_RELUST5 = 0x39;  // VBUS voltage low
+static const uint8_t AXP2101_ADC_DATA_RELUST6 = 0x3A;  // VSYS voltage high
+static const uint8_t AXP2101_ADC_DATA_RELUST7 = 0x3B;  // VSYS voltage low
+static const uint8_t AXP2101_ADC_DATA_RELUST8 = 0x3C;  // Die temperature high
+static const uint8_t AXP2101_ADC_DATA_RELUST9 = 0x3D;  // Die temperature low
+
+// Interrupt registers
+static const uint8_t AXP2101_INTEN1 = 0x40;
+static const uint8_t AXP2101_INTEN2 = 0x41;
+static const uint8_t AXP2101_INTEN3 = 0x42;
+static const uint8_t AXP2101_INTSTS1 = 0x48;
+static const uint8_t AXP2101_INTSTS2 = 0x49;
+static const uint8_t AXP2101_INTSTS3 = 0x4A;
+
+// Charging configuration registers
+static const uint8_t AXP2101_CHARGE_GAUGE_WDT_CTRL = 0x18;
+static const uint8_t AXP2101_IPRECHG_SET = 0x61;
+static const uint8_t AXP2101_ICC_CHG_SET = 0x62;
+static const uint8_t AXP2101_ITERM_CHG_SET_CTRL = 0x63;
+static const uint8_t AXP2101_CV_CHG_VOL_SET = 0x64;
+static const uint8_t AXP2101_CHARGE_TIMEOUT_SET_CTRL = 0x67;
+static const uint8_t AXP2101_BAT_DET_CTRL = 0x68;
+static const uint8_t AXP2101_CHGLED_SET_CTRL = 0x69;
+static const uint8_t AXP2101_BTN_BAT_CHG_VOL_SET = 0x6A;
+
+// DCDC control registers
+static const uint8_t AXP2101_DC_ONOFF_DVM_CTRL = 0x80;
+static const uint8_t AXP2101_DC_VOL0_CTRL = 0x82;  // DCDC1
+static const uint8_t AXP2101_DC_VOL1_CTRL = 0x83;  // DCDC2
+static const uint8_t AXP2101_DC_VOL2_CTRL = 0x84;  // DCDC3
+static const uint8_t AXP2101_DC_VOL3_CTRL = 0x85;  // DCDC4
+static const uint8_t AXP2101_DC_VOL4_CTRL = 0x86;  // DCDC5
+
+// LDO control registers
+static const uint8_t AXP2101_LDO_ONOFF_CTRL0 = 0x90;
+static const uint8_t AXP2101_LDO_ONOFF_CTRL1 = 0x91;
+static const uint8_t AXP2101_ALDO1_VOL_CTRL = 0x92;
+static const uint8_t AXP2101_ALDO2_VOL_CTRL = 0x93;
+static const uint8_t AXP2101_ALDO3_VOL_CTRL = 0x94;
+static const uint8_t AXP2101_ALDO4_VOL_CTRL = 0x95;
+static const uint8_t AXP2101_BLDO1_VOL_CTRL = 0x96;
+static const uint8_t AXP2101_BLDO2_VOL_CTRL = 0x97;
+static const uint8_t AXP2101_CPUSLDO_VOL_CTRL = 0x98;
+static const uint8_t AXP2101_DLDO1_VOL_CTRL = 0x99;
+static const uint8_t AXP2101_DLDO2_VOL_CTRL = 0x9A;
+
+// Battery gauge registers
+static const uint8_t AXP2101_BAT_PARAMS = 0xA1;
+static const uint8_t AXP2101_BAT_GAUGE_CTRL = 0xA2;
+static const uint8_t AXP2101_BAT_PERCENT_DATA = 0xA4;
+
+// Power rail identifiers
+enum PowerRail {
+  DCDC1 = 0,
+  DCDC2,
+  DCDC3,
+  DCDC4,
+  DCDC5,
+  ALDO1,
+  ALDO2,
+  ALDO3,
+  ALDO4,
+  BLDO1,
+  BLDO2,
+  CPUSLDO,
+  DLDO1,
+  DLDO2,
+};
+
+/**
+ * @brief Main AXP2101 component class
+ *
+ * This component handles communication with the AXP2101 PMIC via I2C.
+ * It provides methods for power rail control, voltage adjustment,
+ * and monitoring of various parameters.
+ */
+class AXP2101Component : public PollingComponent, public i2c::I2CDevice {
+ public:
+  void setup() override;
+  void dump_config() override;
+  void update() override;
+  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+
+#ifdef USE_SENSOR
+  // Sensor setters
+  void set_battery_voltage_sensor(sensor::Sensor *sensor) { this->battery_voltage_sensor_ = sensor; }
+  void set_battery_current_sensor(sensor::Sensor *sensor) { this->battery_current_sensor_ = sensor; }
+  void set_battery_level_sensor(sensor::Sensor *sensor) { this->battery_level_sensor_ = sensor; }
+  void set_vbus_voltage_sensor(sensor::Sensor *sensor) { this->vbus_voltage_sensor_ = sensor; }
+  void set_vsys_voltage_sensor(sensor::Sensor *sensor) { this->vsys_voltage_sensor_ = sensor; }
+  void set_die_temperature_sensor(sensor::Sensor *sensor) { this->die_temperature_sensor_ = sensor; }
+#endif
+
+  // Power rail control methods
+  bool enable_power_rail(PowerRail rail);
+  bool disable_power_rail(PowerRail rail);
+  bool is_power_rail_enabled(PowerRail rail);
+
+  // Voltage control methods
+  bool set_rail_voltage(PowerRail rail, uint16_t millivolts);
+  uint16_t get_rail_voltage(PowerRail rail);
+
+  // ADC reading methods
+  uint16_t read_battery_voltage();
+  uint16_t read_vbus_voltage();
+  uint16_t read_vsys_voltage();
+  float read_die_temperature();
+  uint8_t read_battery_level();
+
+ protected:
+  // Helper methods for register access
+  bool set_register_bit(uint8_t reg, uint8_t bit);
+  bool clear_register_bit(uint8_t reg, uint8_t bit);
+  bool get_register_bit(uint8_t reg, uint8_t bit);
+  uint16_t read_register_h5l8(uint8_t high_reg, uint8_t low_reg);
+  uint16_t read_register_h6l8(uint8_t high_reg, uint8_t low_reg);
+
+  // Power rail helper methods
+  bool get_rail_enable_info(PowerRail rail, uint8_t &reg, uint8_t &bit);
+  bool get_rail_voltage_info(PowerRail rail, uint8_t &reg, uint16_t &min_mv, uint16_t &max_mv, uint16_t &step_mv);
+  uint8_t calculate_voltage_register_value(PowerRail rail, uint16_t millivolts);
+  uint16_t calculate_millivolts_from_register(PowerRail rail, uint8_t reg_value);
+
+#ifdef USE_SENSOR
+  // Sensor pointers (optional)
+  sensor::Sensor *battery_voltage_sensor_{nullptr};
+  sensor::Sensor *battery_current_sensor_{nullptr};
+  sensor::Sensor *battery_level_sensor_{nullptr};
+  sensor::Sensor *vbus_voltage_sensor_{nullptr};
+  sensor::Sensor *vsys_voltage_sensor_{nullptr};
+  sensor::Sensor *die_temperature_sensor_{nullptr};
+#endif
+};
+
+}  // namespace axp2101
+}  // namespace esphome

esphome/components/axp2101/number/__init__.py

@@ -0,0 +1,90 @@
+"""Number support for AXP2101 voltage control."""
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import number
+from esphome.const import CONF_ID, UNIT_VOLT
+
+from .. import AXP2101Component, axp2101_ns
+
+CODEOWNERS = ["@esphome/core"]
+DEPENDENCIES = ["axp2101"]
+
+CONF_AXP2101_ID = "axp2101_id"
+CONF_POWER_RAIL = "power_rail"
+
+AXP2101Number = axp2101_ns.class_("AXP2101Number", number.Number, cg.Component)
+
+# Power rail enum matching the PowerRail enum in C++
+PowerRail = axp2101_ns.enum("PowerRail")
+POWER_RAILS = {
+    "DCDC1": PowerRail.DCDC1,
+    "DCDC2": PowerRail.DCDC2,
+    "DCDC3": PowerRail.DCDC3,
+    "DCDC4": PowerRail.DCDC4,
+    "DCDC5": PowerRail.DCDC5,
+    "ALDO1": PowerRail.ALDO1,
+    "ALDO2": PowerRail.ALDO2,
+    "ALDO3": PowerRail.ALDO3,
+    "ALDO4": PowerRail.ALDO4,
+    "BLDO1": PowerRail.BLDO1,
+    "BLDO2": PowerRail.BLDO2,
+    "CPUSLDO": PowerRail.CPUSLDO,
+    "DLDO1": PowerRail.DLDO1,
+    "DLDO2": PowerRail.DLDO2,
+}
+
+# Voltage ranges for each power rail (in millivolts)
+VOLTAGE_RANGES = {
+    "DCDC1": {"min": 1500, "max": 3400, "step": 100},
+    "DCDC2": {"min": 500, "max": 1540, "step": 10},
+    "DCDC3": {"min": 500, "max": 3400, "step": 10},
+    "DCDC4": {"min": 500, "max": 1840, "step": 10},
+    "DCDC5": {"min": 1400, "max": 3700, "step": 100},
+    "ALDO1": {"min": 500, "max": 3500, "step": 100},
+    "ALDO2": {"min": 500, "max": 3500, "step": 100},
+    "ALDO3": {"min": 500, "max": 3500, "step": 100},
+    "ALDO4": {"min": 500, "max": 3500, "step": 100},
+    "BLDO1": {"min": 500, "max": 3500, "step": 100},
+    "BLDO2": {"min": 500, "max": 3500, "step": 100},
+    "CPUSLDO": {"min": 500, "max": 1400, "step": 50},
+    "DLDO1": {"min": 500, "max": 3400, "step": 100},
+    "DLDO2": {"min": 500, "max": 3400, "step": 100},
+}
+
+
+def validate_voltage_range(config):
+    """Validate that voltage is within the allowed range for the power rail."""
+    rail = config[CONF_POWER_RAIL]
+    ranges = VOLTAGE_RANGES[rail]
+
+    # Update the number schema with the correct min/max/step
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    number.number_schema(
+        AXP2101Number,
+        unit_of_measurement=UNIT_VOLT,
+    ).extend(
+        {
+            cv.GenerateID(CONF_AXP2101_ID): cv.use_id(AXP2101Component),
+            cv.Required(CONF_POWER_RAIL): cv.enum(POWER_RAILS, upper=True),
+        }
+    ),
+    validate_voltage_range,
+)
+
+
+async def to_code(config):
+    """Generate code for AXP2101 number."""
+    paren = await cg.get_variable(config[CONF_AXP2101_ID])
+    var = await number.new_number(config, min_value=0.5, max_value=3.7, step=0.01)
+    await cg.register_component(var, config)
+
+    cg.add(var.set_parent(paren))
+    cg.add(var.set_power_rail(config[CONF_POWER_RAIL]))
+
+    # Set rail-specific voltage range
+    rail = config[CONF_POWER_RAIL]
+    ranges = VOLTAGE_RANGES[rail]
+    cg.add(var.set_voltage_range(ranges["min"], ranges["max"], ranges["step"]))

esphome/components/axp2101/number/axp2101_number.cpp

@@ -0,0 +1,101 @@
+/**
+ * @file axp2101_number.cpp
+ * @brief Implementation of AXP2101 number component
+ */
+#include "axp2101_number.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace axp2101 {
+
+static const char *const TAG = "axp2101.number";
+
+static const char *power_rail_to_string(PowerRail rail) {
+  switch (rail) {
+    case DCDC1:
+      return "DCDC1";
+    case DCDC2:
+      return "DCDC2";
+    case DCDC3:
+      return "DCDC3";
+    case DCDC4:
+      return "DCDC4";
+    case DCDC5:
+      return "DCDC5";
+    case ALDO1:
+      return "ALDO1";
+    case ALDO2:
+      return "ALDO2";
+    case ALDO3:
+      return "ALDO3";
+    case ALDO4:
+      return "ALDO4";
+    case BLDO1:
+      return "BLDO1";
+    case BLDO2:
+      return "BLDO2";
+    case CPUSLDO:
+      return "CPUSLDO";
+    case DLDO1:
+      return "DLDO1";
+    case DLDO2:
+      return "DLDO2";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+void AXP2101Number::setup() {
+  if (this->parent_ == nullptr) {
+    ESP_LOGE(TAG, "Parent not set!");
+    this->mark_failed();
+    return;
+  }
+
+  // Read current voltage and publish initial state
+  uint16_t current_mv = this->parent_->get_rail_voltage(this->rail_);
+  if (current_mv > 0) {
+    float current_v = current_mv / 1000.0f;
+    this->publish_state(current_v);
+  }
+}
+
+void AXP2101Number::dump_config() {
+  LOG_NUMBER("", "AXP2101 Number", this);
+  ESP_LOGCONFIG(TAG, "  Power Rail: %s", power_rail_to_string(this->rail_));
+  ESP_LOGCONFIG(TAG, "  Voltage Range: %.2f-%.2fV (step: %.3fV)", this->min_mv_ / 1000.0f, this->max_mv_ / 1000.0f,
+                this->step_mv_ / 1000.0f);
+}
+
+void AXP2101Number::control(float value) {
+  if (this->parent_ == nullptr) {
+    ESP_LOGE(TAG, "Parent not set!");
+    return;
+  }
+
+  // Convert volts to millivolts
+  uint16_t millivolts = static_cast<uint16_t>(value * 1000.0f);
+
+  // Validate range
+  if (millivolts < this->min_mv_ || millivolts > this->max_mv_) {
+    ESP_LOGW(TAG, "Voltage %.3fV out of range for %s (%.2f-%.2fV)", value, power_rail_to_string(this->rail_),
+             this->min_mv_ / 1000.0f, this->max_mv_ / 1000.0f);
+    return;
+  }
+
+  // Round to nearest step
+  uint16_t offset = millivolts - this->min_mv_;
+  uint16_t steps = (offset + this->step_mv_ / 2) / this->step_mv_;
+  millivolts = this->min_mv_ + (steps * this->step_mv_);
+
+  if (this->parent_->set_rail_voltage(this->rail_, millivolts)) {
+    float actual_v = millivolts / 1000.0f;
+    this->publish_state(actual_v);
+    ESP_LOGD(TAG, "Set %s voltage to %.3fV", power_rail_to_string(this->rail_), actual_v);
+  } else {
+    ESP_LOGE(TAG, "Failed to set %s voltage to %.3fV", power_rail_to_string(this->rail_), value);
+  }
+}
+
+}  // namespace axp2101
+}  // namespace esphome

esphome/components/axp2101/number/axp2101_number.h

@@ -0,0 +1,44 @@
+/**
+ * @file axp2101_number.h
+ * @brief Number component for AXP2101 voltage control
+ */
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/number/number.h"
+#include "../axp2101.h"
+
+namespace esphome {
+namespace axp2101 {
+
+/**
+ * @brief Number component for controlling AXP2101 power rail voltages
+ *
+ * This number component allows setting the output voltage of individual
+ * power rails (DCDCs and LDOs).
+ */
+class AXP2101Number : public number::Number, public Component {
+ public:
+  void set_parent(AXP2101Component *parent) { this->parent_ = parent; }
+  void set_power_rail(PowerRail rail) { this->rail_ = rail; }
+  void set_voltage_range(uint16_t min_mv, uint16_t max_mv, uint16_t step_mv) {
+    this->min_mv_ = min_mv;
+    this->max_mv_ = max_mv;
+    this->step_mv_ = step_mv;
+  }
+
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  void control(float value) override;
+
+  AXP2101Component *parent_;
+  PowerRail rail_;
+  uint16_t min_mv_{500};
+  uint16_t max_mv_{3500};
+  uint16_t step_mv_{100};
+};
+
+}  // namespace axp2101
+}  // namespace esphome

esphome/components/axp2101/sensor.py

@@ -0,0 +1,86 @@
+"""Sensor support for AXP2101."""
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor
+from esphome.const import (
+    CONF_BATTERY_LEVEL,
+    CONF_BATTERY_VOLTAGE,
+    CONF_ID,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_PERCENT,
+    UNIT_VOLT,
+)
+
+from . import AXP2101Component, axp2101_ns
+
+DEPENDENCIES = ["axp2101"]
+
+CONF_AXP2101_ID = "axp2101_id"
+CONF_VBUS_VOLTAGE = "vbus_voltage"
+CONF_VSYS_VOLTAGE = "vsys_voltage"
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_AXP2101_ID): cv.use_id(AXP2101Component),
+        cv.Optional(CONF_BATTERY_VOLTAGE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=3,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(
+            unit_of_measurement=UNIT_PERCENT,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_BATTERY,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_VBUS_VOLTAGE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=3,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_VSYS_VOLTAGE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=3,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_CELSIUS,
+            accuracy_decimals=1,
+            device_class=DEVICE_CLASS_TEMPERATURE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+    }
+)
+
+
+async def to_code(config):
+    """Generate code for AXP2101 sensors."""
+    paren = await cg.get_variable(config[CONF_AXP2101_ID])
+
+    if conf := config.get(CONF_BATTERY_VOLTAGE):
+        sens = await sensor.new_sensor(conf)
+        cg.add(paren.set_battery_voltage_sensor(sens))
+
+    if conf := config.get(CONF_BATTERY_LEVEL):
+        sens = await sensor.new_sensor(conf)
+        cg.add(paren.set_battery_level_sensor(sens))
+
+    if conf := config.get(CONF_VBUS_VOLTAGE):
+        sens = await sensor.new_sensor(conf)
+        cg.add(paren.set_vbus_voltage_sensor(sens))
+
+    if conf := config.get(CONF_VSYS_VOLTAGE):
+        sens = await sensor.new_sensor(conf)
+        cg.add(paren.set_vsys_voltage_sensor(sens))
+
+    if conf := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(conf)
+        cg.add(paren.set_die_temperature_sensor(sens))

esphome/components/axp2101/switch/__init__.py

@@ -0,0 +1,52 @@
+"""Switch support for AXP2101 power rail control."""
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import switch
+from esphome.const import CONF_ID
+
+from .. import AXP2101Component, axp2101_ns
+
+CODEOWNERS = ["@esphome/core"]
+
+DEPENDENCIES = ["axp2101"]
+
+CONF_AXP2101_ID = "axp2101_id"
+CONF_POWER_RAIL = "power_rail"
+
+AXP2101Switch = axp2101_ns.class_("AXP2101Switch", switch.Switch, cg.Component)
+
+# Power rail enum matching the PowerRail enum in C++
+PowerRail = axp2101_ns.enum("PowerRail")
+POWER_RAILS = {
+    "DCDC1": PowerRail.DCDC1,
+    "DCDC2": PowerRail.DCDC2,
+    "DCDC3": PowerRail.DCDC3,
+    "DCDC4": PowerRail.DCDC4,
+    "DCDC5": PowerRail.DCDC5,
+    "ALDO1": PowerRail.ALDO1,
+    "ALDO2": PowerRail.ALDO2,
+    "ALDO3": PowerRail.ALDO3,
+    "ALDO4": PowerRail.ALDO4,
+    "BLDO1": PowerRail.BLDO1,
+    "BLDO2": PowerRail.BLDO2,
+    "CPUSLDO": PowerRail.CPUSLDO,
+    "DLDO1": PowerRail.DLDO1,
+    "DLDO2": PowerRail.DLDO2,
+}
+
+CONFIG_SCHEMA = switch.switch_schema(AXP2101Switch).extend(
+    {
+        cv.GenerateID(CONF_AXP2101_ID): cv.use_id(AXP2101Component),
+        cv.Required(CONF_POWER_RAIL): cv.enum(POWER_RAILS, upper=True),
+    }
+)
+
+
+async def to_code(config):
+    """Generate code for AXP2101 switch."""
+    paren = await cg.get_variable(config[CONF_AXP2101_ID])
+    var = await switch.new_switch(config)
+    await cg.register_component(var, config)
+
+    cg.add(var.set_parent(paren))
+    cg.add(var.set_power_rail(config[CONF_POWER_RAIL]))

esphome/components/axp2101/switch/axp2101_switch.cpp

@@ -0,0 +1,74 @@
+/**
+ * @file axp2101_switch.cpp
+ * @brief Implementation of AXP2101 switch component
+ */
+#include "axp2101_switch.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace axp2101 {
+
+static const char *const TAG = "axp2101.switch";
+
+static const char *power_rail_to_string(PowerRail rail) {
+  switch (rail) {
+    case DCDC1:
+      return "DCDC1";
+    case DCDC2:
+      return "DCDC2";
+    case DCDC3:
+      return "DCDC3";
+    case DCDC4:
+      return "DCDC4";
+    case DCDC5:
+      return "DCDC5";
+    case ALDO1:
+      return "ALDO1";
+    case ALDO2:
+      return "ALDO2";
+    case ALDO3:
+      return "ALDO3";
+    case ALDO4:
+      return "ALDO4";
+    case BLDO1:
+      return "BLDO1";
+    case BLDO2:
+      return "BLDO2";
+    case CPUSLDO:
+      return "CPUSLDO";
+    case DLDO1:
+      return "DLDO1";
+    case DLDO2:
+      return "DLDO2";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+void AXP2101Switch::dump_config() {
+  LOG_SWITCH("", "AXP2101 Switch", this);
+  ESP_LOGCONFIG(TAG, "  Power Rail: %s", power_rail_to_string(this->rail_));
+}
+
+void AXP2101Switch::write_state(bool state) {
+  if (this->parent_ == nullptr) {
+    ESP_LOGE(TAG, "Parent not set!");
+    return;
+  }
+
+  bool success;
+  if (state) {
+    success = this->parent_->enable_power_rail(this->rail_);
+  } else {
+    success = this->parent_->disable_power_rail(this->rail_);
+  }
+
+  if (success) {
+    this->publish_state(state);
+  } else {
+    ESP_LOGE(TAG, "Failed to %s power rail %s", state ? "enable" : "disable", power_rail_to_string(this->rail_));
+  }
+}
+
+}  // namespace axp2101
+}  // namespace esphome

esphome/components/axp2101/switch/axp2101_switch.h

@@ -0,0 +1,34 @@
+/**
+ * @file axp2101_switch.h
+ * @brief Switch component for AXP2101 power rail control
+ */
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/switch/switch.h"
+#include "../axp2101.h"
+
+namespace esphome {
+namespace axp2101 {
+
+/**
+ * @brief Switch component for controlling AXP2101 power rails
+ *
+ * This switch allows enabling/disabling individual power rails (DCDCs and LDOs).
+ */
+class AXP2101Switch : public switch_::Switch, public Component {
+ public:
+  void set_parent(AXP2101Component *parent) { this->parent_ = parent; }
+  void set_power_rail(PowerRail rail) { this->rail_ = rail; }
+
+  void dump_config() override;
+
+ protected:
+  void write_state(bool state) override;
+
+  AXP2101Component *parent_;
+  PowerRail rail_;
+};
+
+}  // namespace axp2101
+}  // namespace esphome

esphome/components/binary_sensor/automation.cpp

@@ -1,12 +1,11 @@
 #include "automation.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 static const char *const TAG = "binary_sensor.automation";
 
-void binary_sensor::MultiClickTrigger::on_state_(bool state) {
+void MultiClickTrigger::on_state_(bool state) {
   // Handle duplicate events
   if (state == this->last_state_) {
     return;
@@ -67,7 +66,7 @@ void binary_sensor::MultiClickTrigger::on_state_(bool state) {
 
   *this->at_index_ = *this->at_index_ + 1;
 }
-void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
+void MultiClickTrigger::schedule_cooldown_() {
   ESP_LOGV(TAG, "Multi Click: Invalid length of press, starting cooldown of %" PRIu32 " ms", this->invalid_cooldown_);
   this->is_in_cooldown_ = true;
   this->set_timeout("cooldown", this->invalid_cooldown_, [this]() {
@@ -79,7 +78,7 @@ void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
   this->cancel_timeout("is_valid");
   this->cancel_timeout("is_not_valid");
 }
-void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
+void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
   if (min_length == 0) {
     this->is_valid_ = true;
     return;
@@ -90,19 +89,19 @@ void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
     this->is_valid_ = true;
   });
 }
-void binary_sensor::MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
+void MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
   this->set_timeout("is_not_valid", max_length, [this]() {
     ESP_LOGV(TAG, "Multi Click: You waited too long to %s.", this->parent_->state ? "RELEASE" : "PRESS");
     this->is_valid_ = false;
     this->schedule_cooldown_();
   });
 }
-void binary_sensor::MultiClickTrigger::cancel() {
+void MultiClickTrigger::cancel() {
   ESP_LOGV(TAG, "Multi Click: Sequence explicitly cancelled.");
   this->is_valid_ = false;
   this->schedule_cooldown_();
 }
-void binary_sensor::MultiClickTrigger::trigger_() {
+void MultiClickTrigger::trigger_() {
   ESP_LOGV(TAG, "Multi Click: Hooray, multi click is valid. Triggering!");
   this->at_index_.reset();
   this->cancel_timeout("trigger");
@@ -118,5 +117,4 @@ bool match_interval(uint32_t min_length, uint32_t max_length, uint32_t length) {
     return length >= min_length && length <= max_length;
   }
 }
-}  // namespace binary_sensor
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/automation.h

@@ -9,8 +9,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 
-namespace esphome {
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 struct MultiClickTriggerEvent {
   bool state;
@@ -172,5 +171,4 @@ template<typename... Ts> class BinarySensorInvalidateAction : public Action<Ts..
   BinarySensor *sensor_;
 };
 
-}  // namespace binary_sensor
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/binary_sensor.cpp

@@ -1,9 +1,9 @@
 #include "binary_sensor.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 static const char *const TAG = "binary_sensor";
 
@@ -37,6 +37,9 @@ void BinarySensor::send_state_internal(bool new_state) {
   // Note that set_state_ de-dups and will only trigger callbacks if the state has actually changed
   if (this->set_state_(new_state)) {
     ESP_LOGD(TAG, "'%s': New state is %s", this->get_name().c_str(), ONOFF(new_state));
+#if defined(USE_BINARY_SENSOR) && defined(USE_CONTROLLER_REGISTRY)
+    ControllerRegistry::notify_binary_sensor_update(this);
+#endif
   }
 }
 
@@ -58,6 +61,4 @@ void BinarySensor::add_filters(std::initializer_list<Filter *> filters) {
 }
 bool BinarySensor::is_status_binary_sensor() const { return false; }
 
-}  // namespace binary_sensor
-
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/binary_sensor.h

@@ -6,9 +6,7 @@
 
 #include <initializer_list>
 
-namespace esphome {
-
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 class BinarySensor;
 void log_binary_sensor(const char *tag, const char *prefix, const char *type, BinarySensor *obj);
@@ -70,5 +68,4 @@ class BinarySensorInitiallyOff : public BinarySensor {
   bool has_state() const override { return true; }
 };
 
-}  // namespace binary_sensor
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/filter.cpp

@@ -2,9 +2,7 @@
 
 #include "binary_sensor.h"
 
-namespace esphome {
-
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 static const char *const TAG = "sensor.filter";
 
@@ -132,6 +130,4 @@ optional<bool> SettleFilter::new_value(bool value) {
 
 float SettleFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-}  // namespace binary_sensor
-
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/filter.h

@@ -4,9 +4,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
-namespace esphome {
-
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 class BinarySensor;
 
@@ -139,6 +137,4 @@ class SettleFilter : public Filter, public Component {
   bool steady_{true};
 };
 
-}  // namespace binary_sensor
-
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/bl0940/number/calibration_number.cpp

@@ -9,7 +9,7 @@ static const char *const TAG = "bl0940.number";
 void CalibrationNumber::setup() {
   float value = 0.0f;
   if (this->restore_value_) {
-    this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
     if (!this->pref_.load(&value)) {
       value = 0.0f;
     }

esphome/components/ble_client/__init__.py

@@ -15,6 +15,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_VALUE,
 )
+from esphome.core import ID
 
 AUTO_LOAD = ["esp32_ble_client"]
 CODEOWNERS = ["@buxtronix", "@clydebarrow"]
@@ -198,7 +199,12 @@ async def ble_write_to_code(config, action_id, template_arg, args):
         templ = await cg.templatable(value, args, cg.std_vector.template(cg.uint8))
         cg.add(var.set_value_template(templ))
     else:
-        cg.add(var.set_value_simple(value))
+        # Generate static array in flash to avoid RAM copy
+        if isinstance(value, bytes):
+            value = list(value)
+        arr_id = ID(f"{action_id}_data", is_declaration=True, type=cg.uint8)
+        arr = cg.static_const_array(arr_id, cg.ArrayInitializer(*value))
+        cg.add(var.set_value_simple(arr, len(value)))
 
     if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
         cg.add(

esphome/components/ble_client/automation.h

@@ -96,11 +96,8 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   BLEClientWriteAction(BLEClient *ble_client) {
     ble_client->register_ble_node(this);
     ble_client_ = ble_client;
-    this->construct_simple_value_();
   }
 
-  ~BLEClientWriteAction() { this->destroy_simple_value_(); }
-
   void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
   void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
   void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
@@ -110,17 +107,14 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
 
   void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
-    this->destroy_simple_value_();
-    this->value_.template_func = func;
-    this->has_simple_value_ = false;
+    this->value_.func = func;
+    this->len_ = -1;  // Sentinel value indicates template mode
   }
 
-  void set_value_simple(const std::vector<uint8_t> &value) {
-    if (!this->has_simple_value_) {
-      this->construct_simple_value_();
-    }
-    this->value_.simple = value;
-    this->has_simple_value_ = true;
+  // Store pointer to static data in flash (no RAM copy)
+  void set_value_simple(const uint8_t *data, size_t len) {
+    this->value_.data = data;
+    this->len_ = len;  // Length >= 0 indicates static mode
   }
 
   void play(const Ts &...x) override {}
@@ -128,7 +122,14 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   void play_complex(const Ts &...x) override {
     this->num_running_++;
     this->var_ = std::make_tuple(x...);
-    auto value = this->has_simple_value_ ? this->value_.simple : this->value_.template_func(x...);
+    std::vector<uint8_t> value;
+    if (this->len_ >= 0) {
+      // Static mode: copy from flash to vector
+      value.assign(this->value_.data, this->value_.data + this->len_);
+    } else {
+      // Template mode: call function
+      value = this->value_.func(x...);
+    }
     // on write failure, continue the automation chain rather than stopping so that e.g. disconnect can work.
     if (!write(value))
       this->play_next_(x...);
@@ -201,21 +202,11 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   }
 
  private:
-  void construct_simple_value_() { new (&this->value_.simple) std::vector<uint8_t>(); }
-
-  void destroy_simple_value_() {
-    if (this->has_simple_value_) {
-      this->value_.simple.~vector();
-    }
-  }
-
   BLEClient *ble_client_;
-  bool has_simple_value_ = true;
+  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
   union Value {
-    std::vector<uint8_t> simple;
-    std::vector<uint8_t> (*template_func)(Ts...);
-    Value() {}   // trivial constructor
-    ~Value() {}  // trivial destructor - we manage lifetime via discriminator
+    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
+    const uint8_t *data;                  // Pointer to static data in flash
   } value_;
   espbt::ESPBTUUID service_uuid_;
   espbt::ESPBTUUID char_uuid_;

esphome/components/canbus/__init__.py

@@ -4,7 +4,7 @@ from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_TRIGGER_ID
-from esphome.core import CORE
+from esphome.core import CORE, ID
 
 CODEOWNERS = ["@mvturnho", "@danielschramm"]
 IS_PLATFORM_COMPONENT = True
@@ -176,5 +176,8 @@ async def canbus_action_to_code(config, action_id, template_arg, args):
     else:
         if isinstance(data, bytes):
             data = [int(x) for x in data]
-        cg.add(var.set_data_static(data))
+        # Generate static array in flash to avoid RAM copy
+        arr_id = ID(f"{action_id}_data", is_declaration=True, type=cg.uint8)
+        arr = cg.static_const_array(arr_id, cg.ArrayInitializer(*data))
+        cg.add(var.set_data_static(arr, len(data)))
     return var

esphome/components/canbus/canbus.h

@@ -112,13 +112,16 @@ class Canbus : public Component {
 
 template<typename... Ts> class CanbusSendAction : public Action<Ts...>, public Parented<Canbus> {
  public:
-  void set_data_template(const std::function<std::vector<uint8_t>(Ts...)> func) {
-    this->data_func_ = func;
-    this->static_ = false;
+  void set_data_template(std::vector<uint8_t> (*func)(Ts...)) {
+    // Stateless lambdas (generated by ESPHome) implicitly convert to function pointers
+    this->data_.func = func;
+    this->len_ = -1;  // Sentinel value indicates template mode
   }
-  void set_data_static(const std::vector<uint8_t> &data) {
-    this->data_static_ = data;
-    this->static_ = true;
+
+  // Store pointer to static data in flash (no RAM copy)
+  void set_data_static(const uint8_t *data, size_t len) {
+    this->data_.data = data;
+    this->len_ = len;  // Length >= 0 indicates static mode
   }
 
   void set_can_id(uint32_t can_id) { this->can_id_ = can_id; }
@@ -133,21 +136,26 @@ template<typename... Ts> class CanbusSendAction : public Action<Ts...>, public P
     auto can_id = this->can_id_.has_value() ? *this->can_id_ : this->parent_->can_id_;
     auto use_extended_id =
         this->use_extended_id_.has_value() ? *this->use_extended_id_ : this->parent_->use_extended_id_;
-    if (this->static_) {
-      this->parent_->send_data(can_id, use_extended_id, this->remote_transmission_request_, this->data_static_);
+    std::vector<uint8_t> data;
+    if (this->len_ >= 0) {
+      // Static mode: copy from flash to vector
+      data.assign(this->data_.data, this->data_.data + this->len_);
     } else {
-      auto val = this->data_func_(x...);
-      this->parent_->send_data(can_id, use_extended_id, this->remote_transmission_request_, val);
+      // Template mode: call function
+      data = this->data_.func(x...);
     }
+    this->parent_->send_data(can_id, use_extended_id, this->remote_transmission_request_, data);
   }
 
  protected:
   optional<uint32_t> can_id_{};
   optional<bool> use_extended_id_{};
   bool remote_transmission_request_{false};
-  bool static_{false};
-  std::function<std::vector<uint8_t>(Ts...)> data_func_{};
-  std::vector<uint8_t> data_static_{};
+  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
+  union Data {
+    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
+    const uint8_t *data;                  // Pointer to static data in flash
+  } data_;
 };
 
 class CanbusTrigger : public Trigger<std::vector<uint8_t>, uint32_t, bool>, public Component {

esphome/components/captive_portal/__init__.py

@@ -1,9 +1,12 @@
+import logging
+
 import esphome.codegen as cg
 from esphome.components import web_server_base
 from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_AP,
     CONF_ID,
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
@@ -14,6 +17,10 @@ from esphome.const import (
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+_LOGGER = logging.getLogger(__name__)
 
 
 def AUTO_LOAD() -> list[str]:
@@ -50,6 +57,27 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
+def _final_validate(config: ConfigType) -> ConfigType:
+    full_config = fv.full_config.get()
+    wifi_conf = full_config.get("wifi")
+
+    if wifi_conf is None:
+        # This shouldn't happen due to DEPENDENCIES = ["wifi"], but check anyway
+        raise cv.Invalid("Captive portal requires the wifi component to be configured")
+
+    if CONF_AP not in wifi_conf:
+        _LOGGER.warning(
+            "Captive portal is enabled but no WiFi AP is configured. "
+            "The captive portal will not be accessible. "
+            "Add 'ap:' to your WiFi configuration to enable the captive portal."
+        )
+
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 @coroutine_with_priority(CoroPriority.CAPTIVE_PORTAL)
 async def to_code(config):
     paren = await cg.get_variable(config[CONF_WEB_SERVER_BASE_ID])

esphome/components/climate/climate.cpp

@@ -1,4 +1,6 @@
 #include "climate.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/controller_registry.h"
 #include "esphome/core/macros.h"
 
 namespace esphome {
@@ -463,6 +465,9 @@ void Climate::publish_state() {
 
   // Send state to frontend
   this->state_callback_.call(*this);
+#if defined(USE_CLIMATE) && defined(USE_CONTROLLER_REGISTRY)
+  ControllerRegistry::notify_climate_update(this);
+#endif
   // Save state
   this->save_state_();
 }

esphome/components/const/__init__.py

@@ -8,6 +8,8 @@ BYTE_ORDER_BIG = "big_endian"
 
 CONF_COLOR_DEPTH = "color_depth"
 CONF_DRAW_ROUNDING = "draw_rounding"
+CONF_ENABLED = "enabled"
+CONF_IGNORE_NOT_FOUND = "ignore_not_found"
 CONF_ON_RECEIVE = "on_receive"
 CONF_ON_STATE_CHANGE = "on_state_change"
 CONF_REQUEST_HEADERS = "request_headers"

esphome/components/cover/automation.h

@@ -4,8 +4,7 @@
 #include "esphome/core/automation.h"
 #include "cover.h"
 
-namespace esphome {
-namespace cover {
+namespace esphome::cover {
 
 template<typename... Ts> class OpenAction : public Action<Ts...> {
  public:
@@ -131,5 +130,4 @@ class CoverClosedTrigger : public Trigger<> {
   }
 };
 
-}  // namespace cover
-}  // namespace esphome
+}  // namespace esphome::cover

esphome/components/cover/cover.cpp

@@ -1,9 +1,12 @@
 #include "cover.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/controller_registry.h"
+
 #include <strings.h>
+
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace cover {
+namespace esphome::cover {
 
 static const char *const TAG = "cover";
 
@@ -169,6 +172,9 @@ void Cover::publish_state(bool save) {
   ESP_LOGD(TAG, "  Current Operation: %s", cover_operation_to_str(this->current_operation));
 
   this->state_callback_.call();
+#if defined(USE_COVER) && defined(USE_CONTROLLER_REGISTRY)
+  ControllerRegistry::notify_cover_update(this);
+#endif
 
   if (save) {
     CoverRestoreState restore{};
@@ -205,5 +211,4 @@ void CoverRestoreState::apply(Cover *cover) {
   cover->publish_state();
 }
 
-}  // namespace cover
-}  // namespace esphome
+}  // namespace esphome::cover

esphome/components/cover/cover.h

@@ -7,8 +7,7 @@
 
 #include "cover_traits.h"
 
-namespace esphome {
-namespace cover {
+namespace esphome::cover {
 
 const extern float COVER_OPEN;
 const extern float COVER_CLOSED;
@@ -157,5 +156,4 @@ class Cover : public EntityBase, public EntityBase_DeviceClass {
   ESPPreferenceObject rtc_;
 };
 
-}  // namespace cover
-}  // namespace esphome
+}  // namespace esphome::cover

esphome/components/cover/cover_traits.h

@@ -1,7 +1,6 @@
 #pragma once
 
-namespace esphome {
-namespace cover {
+namespace esphome::cover {
 
 class CoverTraits {
  public:
@@ -26,5 +25,4 @@ class CoverTraits {
   bool supports_stop_{false};
 };
 
-}  // namespace cover
-}  // namespace esphome
+}  // namespace esphome::cover

esphome/components/dashboard_import/dashboard_import.cpp

@@ -3,10 +3,10 @@
 namespace esphome {
 namespace dashboard_import {
 
-static std::string g_package_import_url;  // NOLINT
+static const char *g_package_import_url = "";  // NOLINT
 
-const std::string &get_package_import_url() { return g_package_import_url; }
-void set_package_import_url(std::string url) { g_package_import_url = std::move(url); }
+const char *get_package_import_url() { return g_package_import_url; }
+void set_package_import_url(const char *url) { g_package_import_url = url; }
 
 }  // namespace dashboard_import
 }  // namespace esphome

esphome/components/dashboard_import/dashboard_import.h

@@ -1,12 +1,10 @@
 #pragma once
 
-#include <string>
-
 namespace esphome {
 namespace dashboard_import {
 
-const std::string &get_package_import_url();
-void set_package_import_url(std::string url);
+const char *get_package_import_url();
+void set_package_import_url(const char *url);
 
 }  // namespace dashboard_import
 }  // namespace esphome

esphome/components/datetime/date_entity.cpp

@@ -1,5 +1,6 @@
 #include "date_entity.h"
-
+#include "esphome/core/defines.h"
+#include "esphome/core/controller_registry.h"
 #ifdef USE_DATETIME_DATE
 
 #include "esphome/core/log.h"
@@ -32,6 +33,9 @@ void DateEntity::publish_state() {
   this->set_has_state(true);
   ESP_LOGD(TAG, "'%s': Sending date %d-%d-%d", this->get_name().c_str(), this->year_, this->month_, this->day_);
   this->state_callback_.call();
+#if defined(USE_DATETIME_DATE) && defined(USE_CONTROLLER_REGISTRY)
+  ControllerRegistry::notify_date_update(this);
+#endif
 }
 
 DateCall DateEntity::make_call() { return DateCall(this); }

esphome/components/datetime/datetime_entity.cpp

@@ -1,5 +1,6 @@
 #include "datetime_entity.h"
-
+#include "esphome/core/defines.h"
+#include "esphome/core/controller_registry.h"
 #ifdef USE_DATETIME_DATETIME
 
 #include "esphome/core/log.h"
@@ -48,6 +49,9 @@ void DateTimeEntity::publish_state() {
   ESP_LOGD(TAG, "'%s': Sending datetime %04u-%02u-%02u %02d:%02d:%02d", this->get_name().c_str(), this->year_,
            this->month_, this->day_, this->hour_, this->minute_, this->second_);
   this->state_callback_.call();
+#if defined(USE_DATETIME_DATETIME) && defined(USE_CONTROLLER_REGISTRY)
+  ControllerRegistry::notify_datetime_update(this);
+#endif
 }
 
 DateTimeCall DateTimeEntity::make_call() { return DateTimeCall(this); }

esphome/components/datetime/time_entity.cpp

@@ -1,5 +1,6 @@
 #include "time_entity.h"
-
+#include "esphome/core/defines.h"
+#include "esphome/core/controller_registry.h"
 #ifdef USE_DATETIME_TIME
 
 #include "esphome/core/log.h"
@@ -29,6 +30,9 @@ void TimeEntity::publish_state() {
   ESP_LOGD(TAG, "'%s': Sending time %02d:%02d:%02d", this->get_name().c_str(), this->hour_, this->minute_,
            this->second_);
   this->state_callback_.call();
+#if defined(USE_DATETIME_TIME) && defined(USE_CONTROLLER_REGISTRY)
+  ControllerRegistry::notify_time_update(this);
+#endif
 }
 
 TimeCall TimeEntity::make_call() { return TimeCall(this); }

esphome/components/debug/__init__.py

@@ -59,6 +59,7 @@ async def to_code(config):
         zephyr_add_prj_conf("SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL", True)
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
+    cg.add_define("USE_DEBUG")
 
 
 FILTER_SOURCE_FILES = filter_source_files_from_platform(

esphome/components/debug/debug_component.cpp

@@ -49,9 +49,9 @@ void DebugComponent::dump_config() {
   }
 #endif  // USE_TEXT_SENSOR
 
-#ifdef USE_ESP32
-  this->log_partition_info_();  // Log partition information for ESP32
-#endif                          // USE_ESP32
+#if defined(USE_ESP32) || defined(USE_ZEPHYR)
+  this->log_partition_info_();  // Log partition information
+#endif
 }
 
 void DebugComponent::loop() {

esphome/components/debug/debug_component.h

@@ -62,19 +62,19 @@ class DebugComponent : public PollingComponent {
   sensor::Sensor *cpu_frequency_sensor_{nullptr};
 #endif  // USE_SENSOR
 
-#ifdef USE_ESP32
+#if defined(USE_ESP32) || defined(USE_ZEPHYR)
   /**
    * @brief Logs information about the device's partition table.
    *
-   * This function iterates through the ESP32's partition table and logs details
+   * This function iterates through the partition table and logs details
    * about each partition, including its name, type, subtype, starting address,
    * and size. The information is useful for diagnosing issues related to flash
    * memory or verifying the partition configuration dynamically at runtime.
    *
-   * Only available when compiled for ESP32 platforms.
+   * Only available when compiled for ESP32 and ZEPHYR platforms.
    */
   void log_partition_info_();
-#endif  // USE_ESP32
+#endif
 
 #ifdef USE_TEXT_SENSOR
   text_sensor::TextSensor *device_info_{nullptr};

esphome/components/debug/debug_zephyr.cpp

@@ -5,6 +5,7 @@
 #include <zephyr/drivers/hwinfo.h>
 #include <hal/nrf_power.h>
 #include <cstdint>
+#include <zephyr/storage/flash_map.h>
 
 #define BOOTLOADER_VERSION_REGISTER NRF_TIMER2->CC[0]
 
@@ -86,6 +87,37 @@ std::string DebugComponent::get_reset_reason_() {
 
 uint32_t DebugComponent::get_free_heap_() { return INT_MAX; }
 
+static void fa_cb(const struct flash_area *fa, void *user_data) {
+#if CONFIG_FLASH_MAP_LABELS
+  const char *fa_label = flash_area_label(fa);
+
+  if (fa_label == nullptr) {
+    fa_label = "-";
+  }
+  ESP_LOGCONFIG(TAG, "%2d   0x%0*" PRIxPTR "   %-26s  %-24.24s  0x%-10x 0x%-12x", (int) fa->fa_id,
+                sizeof(uintptr_t) * 2, (uintptr_t) fa->fa_dev, fa->fa_dev->name, fa_label, (uint32_t) fa->fa_off,
+                fa->fa_size);
+#else
+  ESP_LOGCONFIG(TAG, "%2d   0x%0*" PRIxPTR "   %-26s  0x%-10x 0x%-12x", (int) fa->fa_id, sizeof(uintptr_t) * 2,
+                (uintptr_t) fa->fa_dev, fa->fa_dev->name, (uint32_t) fa->fa_off, fa->fa_size);
+#endif
+}
+
+void DebugComponent::log_partition_info_() {
+#if CONFIG_FLASH_MAP_LABELS
+  ESP_LOGCONFIG(TAG, "ID | Device     | Device Name               "
+                     "| Label                   | Offset     | Size");
+  ESP_LOGCONFIG(TAG, "--------------------------------------------"
+                     "-----------------------------------------------");
+#else
+  ESP_LOGCONFIG(TAG, "ID | Device     | Device Name               "
+                     "| Offset     | Size");
+  ESP_LOGCONFIG(TAG, "-----------------------------------------"
+                     "------------------------------");
+#endif
+  flash_area_foreach(fa_cb, nullptr);
+}
+
 void DebugComponent::get_device_info_(std::string &device_info) {
   std::string supply = "Main supply status: ";
   if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_NORMAL) {

esphome/components/demo/demo_select.h

@@ -8,7 +8,7 @@ namespace demo {
 
 class DemoSelect : public select::Select, public Component {
  protected:
-  void control(const std::string &value) override { this->publish_state(value); }
+  void control(size_t index) override { this->publish_state(index); }
 };
 
 }  // namespace demo

esphome/components/display/display.h

@@ -176,7 +176,117 @@ class Display;
 class DisplayPage;
 class DisplayOnPageChangeTrigger;
 
-using display_writer_t = std::function<void(Display &)>;
+/** Optimized display writer that uses function pointers for stateless lambdas.
+ *
+ * Similar to TemplatableValue but specialized for display writer callbacks.
+ * Saves ~8 bytes per stateless lambda on 32-bit platforms (16 bytes std::function → ~8 bytes discriminator+pointer).
+ *
+ * Supports both:
+ * - Stateless lambdas (from YAML) → function pointer (4 bytes)
+ * - Stateful lambdas/std::function (from C++ code) → std::function* (heap allocated)
+ *
+ * @tparam T The display type (e.g., Display, Nextion, GPIOLCDDisplay)
+ */
+template<typename T> class DisplayWriter {
+ public:
+  DisplayWriter() : type_(NONE) {}
+
+  // For stateless lambdas (convertible to function pointer): use function pointer (4 bytes)
+  template<typename F>
+  DisplayWriter(F f) requires std::invocable<F, T &> && std::convertible_to<F, void (*)(T &)>
+      : type_(STATELESS_LAMBDA) {
+    this->stateless_f_ = f;  // Implicit conversion to function pointer
+  }
+
+  // For stateful lambdas and std::function (not convertible to function pointer): use std::function* (heap allocated)
+  // This handles backwards compatibility with external components
+  template<typename F>
+  DisplayWriter(F f) requires std::invocable<F, T &> &&(!std::convertible_to<F, void (*)(T &)>) : type_(LAMBDA) {
+    this->f_ = new std::function<void(T &)>(std::move(f));
+  }
+
+  // Copy constructor
+  DisplayWriter(const DisplayWriter &other) : type_(other.type_) {
+    if (type_ == LAMBDA) {
+      this->f_ = new std::function<void(T &)>(*other.f_);
+    } else if (type_ == STATELESS_LAMBDA) {
+      this->stateless_f_ = other.stateless_f_;
+    }
+  }
+
+  // Move constructor
+  DisplayWriter(DisplayWriter &&other) noexcept : type_(other.type_) {
+    if (type_ == LAMBDA) {
+      this->f_ = other.f_;
+      other.f_ = nullptr;
+    } else if (type_ == STATELESS_LAMBDA) {
+      this->stateless_f_ = other.stateless_f_;
+    }
+    other.type_ = NONE;
+  }
+
+  // Assignment operators
+  DisplayWriter &operator=(const DisplayWriter &other) {
+    if (this != &other) {
+      this->~DisplayWriter();
+      new (this) DisplayWriter(other);
+    }
+    return *this;
+  }
+
+  DisplayWriter &operator=(DisplayWriter &&other) noexcept {
+    if (this != &other) {
+      this->~DisplayWriter();
+      new (this) DisplayWriter(std::move(other));
+    }
+    return *this;
+  }
+
+  ~DisplayWriter() {
+    if (type_ == LAMBDA) {
+      delete this->f_;
+    }
+    // STATELESS_LAMBDA/NONE: no cleanup needed (function pointer or empty)
+  }
+
+  bool has_value() const { return this->type_ != NONE; }
+
+  void call(T &display) const {
+    switch (this->type_) {
+      case STATELESS_LAMBDA:
+        this->stateless_f_(display);  // Direct function pointer call
+        break;
+      case LAMBDA:
+        (*this->f_)(display);  // std::function call
+        break;
+      case NONE:
+      default:
+        break;
+    }
+  }
+
+  // Operator() for convenience
+  void operator()(T &display) const { this->call(display); }
+
+  // Operator* for backwards compatibility with (*writer_)(*this) pattern
+  DisplayWriter &operator*() { return *this; }
+  const DisplayWriter &operator*() const { return *this; }
+
+ protected:
+  enum : uint8_t {
+    NONE,
+    LAMBDA,
+    STATELESS_LAMBDA,
+  } type_;
+
+  union {
+    std::function<void(T &)> *f_;
+    void (*stateless_f_)(T &);
+  };
+};
+
+// Type alias for Display writer - uses optimized DisplayWriter instead of std::function
+using display_writer_t = DisplayWriter<Display>;
 
 #define LOG_DISPLAY(prefix, type, obj) \
   if ((obj) != nullptr) { \
@@ -678,7 +788,7 @@ class Display : public PollingComponent {
   void sort_triangle_points_by_y_(int *x1, int *y1, int *x2, int *y2, int *x3, int *y3);
 
   DisplayRotation rotation_{DISPLAY_ROTATION_0_DEGREES};
-  optional<display_writer_t> writer_{};
+  display_writer_t writer_{};
   DisplayPage *page_{nullptr};
   DisplayPage *previous_page_{nullptr};
   std::vector<DisplayOnPageChangeTrigger *> on_page_change_triggers_;

esphome/components/ds1307/ds1307.cpp

@@ -23,7 +23,7 @@ void DS1307Component::dump_config() {
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
-  ESP_LOGCONFIG(TAG, "  Timezone: '%s'", this->timezone_.c_str());
+  RealTimeClock::dump_config();
 }
 
 float DS1307Component::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/es8388/select/adc_input_mic_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace es8388 {
 
-void ADCInputMicSelect::control(const std::string &value) {
-  this->publish_state(value);
-  this->parent_->set_adc_input_mic(static_cast<AdcInputMicLine>(this->index_of(value).value()));
+void ADCInputMicSelect::control(size_t index) {
+  this->publish_state(index);
+  this->parent_->set_adc_input_mic(static_cast<AdcInputMicLine>(index));
 }
 
 }  // namespace es8388

esphome/components/es8388/select/adc_input_mic_select.h

@@ -8,7 +8,7 @@ namespace es8388 {
 
 class ADCInputMicSelect : public select::Select, public Parented<ES8388> {
  protected:
-  void control(const std::string &value) override;
+  void control(size_t index) override;
 };
 
 }  // namespace es8388

esphome/components/es8388/select/dac_output_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace es8388 {
 
-void DacOutputSelect::control(const std::string &value) {
-  this->publish_state(value);
-  this->parent_->set_dac_output(static_cast<DacOutputLine>(this->index_of(value).value()));
+void DacOutputSelect::control(size_t index) {
+  this->publish_state(index);
+  this->parent_->set_dac_output(static_cast<DacOutputLine>(index));
 }
 
 }  // namespace es8388

esphome/components/es8388/select/dac_output_select.h

@@ -8,7 +8,7 @@ namespace es8388 {
 
 class DacOutputSelect : public select::Select, public Parented<ES8388> {
  protected:
-  void control(const std::string &value) override;
+  void control(size_t index) override;
 };
 
 }  // namespace es8388

esphome/components/esp32/__init__.py

@@ -334,12 +334,14 @@ def _is_framework_url(source: str) -> str:
 #  - https://github.com/espressif/arduino-esp32/releases
 ARDUINO_FRAMEWORK_VERSION_LOOKUP = {
     "recommended": cv.Version(3, 3, 2),
-    "latest": cv.Version(3, 3, 2),
-    "dev": cv.Version(3, 3, 2),
+    "latest": cv.Version(3, 3, 4),
+    "dev": cv.Version(3, 3, 4),
 }
 ARDUINO_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(3, 3, 2): cv.Version(55, 3, 31, "1"),
-    cv.Version(3, 3, 1): cv.Version(55, 3, 31, "1"),
+    cv.Version(3, 3, 4): cv.Version(55, 3, 31, "2"),
+    cv.Version(3, 3, 3): cv.Version(55, 3, 31, "2"),
+    cv.Version(3, 3, 2): cv.Version(55, 3, 31, "2"),
+    cv.Version(3, 3, 1): cv.Version(55, 3, 31, "2"),
     cv.Version(3, 3, 0): cv.Version(55, 3, 30, "2"),
     cv.Version(3, 2, 1): cv.Version(54, 3, 21, "2"),
     cv.Version(3, 2, 0): cv.Version(54, 3, 20),
@@ -357,8 +359,8 @@ ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
     "dev": cv.Version(5, 5, 1),
 }
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(5, 5, 1): cv.Version(55, 3, 31, "1"),
-    cv.Version(5, 5, 0): cv.Version(55, 3, 31, "1"),
+    cv.Version(5, 5, 1): cv.Version(55, 3, 31, "2"),
+    cv.Version(5, 5, 0): cv.Version(55, 3, 31, "2"),
     cv.Version(5, 4, 3): cv.Version(55, 3, 32),
     cv.Version(5, 4, 2): cv.Version(54, 3, 21, "2"),
     cv.Version(5, 4, 1): cv.Version(54, 3, 21, "2"),
@@ -373,14 +375,15 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
 # The platform-espressif32 version
 #  - https://github.com/pioarduino/platform-espressif32/releases
 PLATFORM_VERSION_LOOKUP = {
-    "recommended": cv.Version(55, 3, 31, "1"),
-    "latest": cv.Version(55, 3, 31, "1"),
-    "dev": cv.Version(55, 3, 31, "1"),
+    "recommended": cv.Version(55, 3, 31, "2"),
+    "latest": cv.Version(55, 3, 31, "2"),
+    "dev": cv.Version(55, 3, 31, "2"),
 }
 
 
-def _check_versions(value):
-    value = value.copy()
+def _check_versions(config):
+    config = config.copy()
+    value = config[CONF_FRAMEWORK]
 
     if value[CONF_VERSION] in PLATFORM_VERSION_LOOKUP:
         if CONF_SOURCE in value or CONF_PLATFORM_VERSION in value:
@@ -445,7 +448,7 @@ def _check_versions(value):
             "If there are connectivity or build issues please remove the manual version."
         )
 
-    return value
+    return config
 
 
 def _parse_platform_version(value):
@@ -495,6 +498,8 @@ def final_validate(config):
     from esphome.components.psram import DOMAIN as PSRAM_DOMAIN
 
     errs = []
+    conf_fw = config[CONF_FRAMEWORK]
+    advanced = conf_fw[CONF_ADVANCED]
     full_config = fv.full_config.get()
     if pio_options := full_config[CONF_ESPHOME].get(CONF_PLATFORMIO_OPTIONS):
         pio_flash_size_key = "board_upload.flash_size"
@@ -511,22 +516,14 @@ def final_validate(config):
                     f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
                 )
             )
-    if (
-        config[CONF_VARIANT] != VARIANT_ESP32
-        and CONF_ADVANCED in (conf_fw := config[CONF_FRAMEWORK])
-        and CONF_IGNORE_EFUSE_MAC_CRC in conf_fw[CONF_ADVANCED]
-    ):
+    if config[CONF_VARIANT] != VARIANT_ESP32 and advanced[CONF_IGNORE_EFUSE_MAC_CRC]:
         errs.append(
             cv.Invalid(
                 f"'{CONF_IGNORE_EFUSE_MAC_CRC}' is not supported on {config[CONF_VARIANT]}",
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_IGNORE_EFUSE_MAC_CRC],
             )
         )
-    if (
-        config.get(CONF_FRAMEWORK, {})
-        .get(CONF_ADVANCED, {})
-        .get(CONF_EXECUTE_FROM_PSRAM)
-    ):
+    if advanced[CONF_EXECUTE_FROM_PSRAM]:
         if config[CONF_VARIANT] != VARIANT_ESP32S3:
             errs.append(
                 cv.Invalid(
@@ -542,6 +539,17 @@ def final_validate(config):
                 )
             )
 
+    if (
+        config[CONF_FLASH_SIZE] == "32MB"
+        and "ota" in full_config
+        and not advanced[CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES]
+    ):
+        errs.append(
+            cv.Invalid(
+                f"OTA with 32MB flash requires '{CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES}' to be set in the '{CONF_ADVANCED}' section of the esp32 configuration",
+                path=[CONF_FLASH_SIZE],
+            )
+        )
     if errs:
         raise cv.MultipleInvalid(errs)
 
@@ -596,89 +604,74 @@ def _validate_idf_component(config: ConfigType) -> ConfigType:
 
 FRAMEWORK_ESP_IDF = "esp-idf"
 FRAMEWORK_ARDUINO = "arduino"
-FRAMEWORK_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.Optional(CONF_TYPE, default=FRAMEWORK_ARDUINO): cv.one_of(
-                FRAMEWORK_ESP_IDF, FRAMEWORK_ARDUINO
-            ),
-            cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
-            cv.Optional(CONF_RELEASE): cv.string_strict,
-            cv.Optional(CONF_SOURCE): cv.string_strict,
-            cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
-            cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
-                cv.string_strict: cv.string_strict
-            },
-            cv.Optional(CONF_LOG_LEVEL, default="ERROR"): cv.one_of(
-                *LOG_LEVELS_IDF, upper=True
-            ),
-            cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
-                {
-                    cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
-                        *ASSERTION_LEVELS, upper=True
-                    ),
-                    cv.Optional(CONF_COMPILER_OPTIMIZATION, default="SIZE"): cv.one_of(
-                        *COMPILER_OPTIMIZATIONS, upper=True
-                    ),
-                    cv.Optional(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES): cv.boolean,
-                    cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
-                    cv.Optional(
-                        CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False
-                    ): cv.boolean,
-                    cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC): cv.boolean,
-                    # DHCP server is needed for WiFi AP mode. When WiFi component is used,
-                    # it will handle disabling DHCP server when AP is not configured.
-                    # Default to false (disabled) when WiFi is not used.
-                    cv.OnlyWithout(
-                        CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_ENABLE_LWIP_MDNS_QUERIES, default=True
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, default=True
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, default=True
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_DISABLE_LIBC_LOCKS_IN_IRAM, default=True
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_DISABLE_VFS_SUPPORT_TERMIOS, default=True
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_DISABLE_VFS_SUPPORT_SELECT, default=True
-                    ): 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(
-                cv.All(
-                    cv.Schema(
-                        {
-                            cv.Required(CONF_NAME): cv.string_strict,
-                            cv.Optional(CONF_SOURCE): cv.git_ref,
-                            cv.Optional(CONF_REF): cv.string,
-                            cv.Optional(CONF_PATH): cv.string,
-                            cv.Optional(CONF_REFRESH): cv.All(
-                                cv.string, cv.source_refresh
-                            ),
-                        }
-                    ),
-                    _validate_idf_component,
-                )
-            ),
-        }
-    ),
-    _check_versions,
+FRAMEWORK_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_TYPE): cv.one_of(FRAMEWORK_ESP_IDF, FRAMEWORK_ARDUINO),
+        cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
+        cv.Optional(CONF_RELEASE): cv.string_strict,
+        cv.Optional(CONF_SOURCE): cv.string_strict,
+        cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
+        cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
+            cv.string_strict: cv.string_strict
+        },
+        cv.Optional(CONF_LOG_LEVEL, default="ERROR"): cv.one_of(
+            *LOG_LEVELS_IDF, upper=True
+        ),
+        cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
+            {
+                cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
+                    *ASSERTION_LEVELS, upper=True
+                ),
+                cv.Optional(CONF_COMPILER_OPTIMIZATION, default="SIZE"): cv.one_of(
+                    *COMPILER_OPTIMIZATIONS, upper=True
+                ),
+                cv.Optional(
+                    CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES, default=False
+                ): cv.boolean,
+                cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
+                cv.Optional(CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False): cv.boolean,
+                cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC, default=False): cv.boolean,
+                # DHCP server is needed for WiFi AP mode. When WiFi component is used,
+                # it will handle disabling DHCP server when AP is not configured.
+                # Default to false (disabled) when WiFi is not used.
+                cv.OnlyWithout(
+                    CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
+                ): cv.boolean,
+                cv.Optional(CONF_ENABLE_LWIP_MDNS_QUERIES, default=True): cv.boolean,
+                cv.Optional(
+                    CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
+                ): cv.boolean,
+                cv.Optional(
+                    CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, default=True
+                ): cv.boolean,
+                cv.Optional(
+                    CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, default=True
+                ): cv.boolean,
+                cv.Optional(CONF_DISABLE_LIBC_LOCKS_IN_IRAM, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_VFS_SUPPORT_TERMIOS, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_VFS_SUPPORT_SELECT, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_VFS_SUPPORT_DIR, default=True): cv.boolean,
+                cv.Optional(CONF_EXECUTE_FROM_PSRAM, default=False): 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(
+            cv.All(
+                cv.Schema(
+                    {
+                        cv.Required(CONF_NAME): cv.string_strict,
+                        cv.Optional(CONF_SOURCE): cv.git_ref,
+                        cv.Optional(CONF_REF): cv.string,
+                        cv.Optional(CONF_PATH): cv.string,
+                        cv.Optional(CONF_REFRESH): cv.All(cv.string, cv.source_refresh),
+                    }
+                ),
+                _validate_idf_component,
+            )
+        ),
+    }
 )
 
 
@@ -741,11 +734,11 @@ def _show_framework_migration_message(name: str, variant: str) -> None:
 
 
 def _set_default_framework(config):
+    config = config.copy()
     if CONF_FRAMEWORK not in config:
-        config = config.copy()
-
-        variant = config[CONF_VARIANT]
         config[CONF_FRAMEWORK] = FRAMEWORK_SCHEMA({})
+    if CONF_TYPE not in config[CONF_FRAMEWORK]:
+        variant = config[CONF_VARIANT]
         if variant in ARDUINO_ALLOWED_VARIANTS:
             config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ARDUINO
             _show_framework_migration_message(
@@ -785,6 +778,7 @@ CONFIG_SCHEMA = cv.All(
     ),
     _detect_variant,
     _set_default_framework,
+    _check_versions,
     set_core_data,
     cv.has_at_least_one_key(CONF_BOARD, CONF_VARIANT),
 )
@@ -803,9 +797,7 @@ def _configure_lwip_max_sockets(conf: dict) -> None:
     from esphome.components.socket import KEY_SOCKET_CONSUMERS
 
     # Check if user manually specified CONFIG_LWIP_MAX_SOCKETS
-    user_max_sockets = conf.get(CONF_SDKCONFIG_OPTIONS, {}).get(
-        "CONFIG_LWIP_MAX_SOCKETS"
-    )
+    user_max_sockets = conf[CONF_SDKCONFIG_OPTIONS].get("CONFIG_LWIP_MAX_SOCKETS")
 
     socket_consumers: dict[str, int] = CORE.data.get(KEY_SOCKET_CONSUMERS, {})
     total_sockets = sum(socket_consumers.values())
@@ -975,23 +967,18 @@ async def to_code(config):
     # WiFi component handles its own optimization when AP mode is not used
     # When using Arduino with Ethernet, DHCP server functions must be available
     # for the Network library to compile, even if not actively used
-    if (
-        CONF_ENABLE_LWIP_DHCP_SERVER in advanced
-        and not advanced[CONF_ENABLE_LWIP_DHCP_SERVER]
-        and not (
-            conf[CONF_TYPE] == FRAMEWORK_ARDUINO
-            and "ethernet" in CORE.loaded_integrations
-        )
+    if advanced.get(CONF_ENABLE_LWIP_DHCP_SERVER) is False and not (
+        conf[CONF_TYPE] == FRAMEWORK_ARDUINO and "ethernet" in CORE.loaded_integrations
     ):
         add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
-    if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, True):
+    if not advanced[CONF_ENABLE_LWIP_MDNS_QUERIES]:
         add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
-    if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
+    if not advanced[CONF_ENABLE_LWIP_BRIDGE_INTERFACE]:
         add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
 
     _configure_lwip_max_sockets(conf)
 
-    if advanced.get(CONF_EXECUTE_FROM_PSRAM, False):
+    if advanced[CONF_EXECUTE_FROM_PSRAM]:
         add_idf_sdkconfig_option("CONFIG_SPIRAM_FETCH_INSTRUCTIONS", True)
         add_idf_sdkconfig_option("CONFIG_SPIRAM_RODATA", True)
 
@@ -1002,23 +989,22 @@ async def to_code(config):
     # - select() on 4 sockets: ~190μs (Arduino/core locking) vs ~235μs (ESP-IDF default)
     # - Up to 200% slower under load when all operations queue through tcpip_thread
     # Enabling this makes ESP-IDF socket performance match Arduino framework.
-    if advanced.get(CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, True):
+    if advanced[CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING]:
         add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_CORE_LOCKING", True)
-    if advanced.get(CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, True):
+    if advanced[CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY]:
         add_idf_sdkconfig_option("CONFIG_LWIP_CHECK_THREAD_SAFETY", True)
 
     # Disable placing libc locks in IRAM to save RAM
     # This is safe for ESPHome since no IRAM ISRs (interrupts that run while cache is disabled)
     # use libc lock APIs. Saves approximately 1.3KB (1,356 bytes) of IRAM.
-    if advanced.get(CONF_DISABLE_LIBC_LOCKS_IN_IRAM, True):
+    if advanced[CONF_DISABLE_LIBC_LOCKS_IN_IRAM]:
         add_idf_sdkconfig_option("CONFIG_LIBC_LOCKS_PLACE_IN_IRAM", False)
 
     # Disable VFS support for termios (terminal I/O functions)
     # ESPHome doesn't use termios functions on ESP32 (only used in host UART driver).
     # Saves approximately 1.8KB of flash when disabled (default).
     add_idf_sdkconfig_option(
-        "CONFIG_VFS_SUPPORT_TERMIOS",
-        not advanced.get(CONF_DISABLE_VFS_SUPPORT_TERMIOS, True),
+        "CONFIG_VFS_SUPPORT_TERMIOS", not advanced[CONF_DISABLE_VFS_SUPPORT_TERMIOS]
     )
 
     # Disable VFS support for select() with file descriptors
@@ -1032,8 +1018,7 @@ async def to_code(config):
     else:
         # No component needs it - allow user to control (default: disabled)
         add_idf_sdkconfig_option(
-            "CONFIG_VFS_SUPPORT_SELECT",
-            not advanced.get(CONF_DISABLE_VFS_SUPPORT_SELECT, True),
+            "CONFIG_VFS_SUPPORT_SELECT", not advanced[CONF_DISABLE_VFS_SUPPORT_SELECT]
         )
 
     # Disable VFS support for directory functions (opendir, readdir, mkdir, etc.)
@@ -1046,8 +1031,7 @@ async def to_code(config):
     else:
         # No component needs it - allow user to control (default: disabled)
         add_idf_sdkconfig_option(
-            "CONFIG_VFS_SUPPORT_DIR",
-            not advanced.get(CONF_DISABLE_VFS_SUPPORT_DIR, True),
+            "CONFIG_VFS_SUPPORT_DIR", not advanced[CONF_DISABLE_VFS_SUPPORT_DIR]
         )
 
     cg.add_platformio_option("board_build.partitions", "partitions.csv")
@@ -1061,7 +1045,7 @@ async def to_code(config):
             add_idf_sdkconfig_option(flag, assertion_level == key)
 
     add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
-    compiler_optimization = advanced.get(CONF_COMPILER_OPTIMIZATION)
+    compiler_optimization = advanced[CONF_COMPILER_OPTIMIZATION]
     for key, flag in COMPILER_OPTIMIZATIONS.items():
         add_idf_sdkconfig_option(flag, compiler_optimization == key)
 
@@ -1070,18 +1054,20 @@ async def to_code(config):
         conf[CONF_ADVANCED][CONF_ENABLE_LWIP_ASSERT],
     )
 
-    if advanced.get(CONF_IGNORE_EFUSE_MAC_CRC):
+    if advanced[CONF_IGNORE_EFUSE_MAC_CRC]:
         add_idf_sdkconfig_option("CONFIG_ESP_MAC_IGNORE_MAC_CRC_ERROR", True)
         add_idf_sdkconfig_option("CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE", False)
-    if advanced.get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
+    if advanced[CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES]:
         _LOGGER.warning(
             "Using experimental features in ESP-IDF may result in unexpected failures."
         )
         add_idf_sdkconfig_option("CONFIG_IDF_EXPERIMENTAL_FEATURES", True)
+        if config[CONF_FLASH_SIZE] == "32MB":
+            add_idf_sdkconfig_option(
+                "CONFIG_BOOTLOADER_CACHE_32BIT_ADDR_QUAD_FLASH", True
+            )
 
-    cg.add_define(
-        "ESPHOME_LOOP_TASK_STACK_SIZE", advanced.get(CONF_LOOP_TASK_STACK_SIZE)
-    )
+    cg.add_define("ESPHOME_LOOP_TASK_STACK_SIZE", advanced[CONF_LOOP_TASK_STACK_SIZE])
 
     cg.add_define(
         "USE_ESP_IDF_VERSION_CODE",

esphome/components/esp32_ble/ble.cpp

@@ -96,10 +96,6 @@ void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->advertising_set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void ESP32BLE::advertising_set_manufacturer_data(std::span<const uint8_t> data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
   this->advertising_start();
@@ -638,11 +634,13 @@ void ESP32BLE::dump_config() {
         io_capability_s = "invalid";
         break;
     }
+    char mac_s[18];
+    format_mac_addr_upper(mac_address, mac_s);
     ESP_LOGCONFIG(TAG,
                   "BLE:\n"
                   "  MAC address: %s\n"
                   "  IO Capability: %s",
-                  format_mac_address_pretty(mac_address).c_str(), io_capability_s);
+                  mac_s, io_capability_s);
   } else {
     ESP_LOGCONFIG(TAG, "Bluetooth stack is not enabled");
   }

esphome/components/esp32_ble/ble.h

@@ -118,7 +118,6 @@ class ESP32BLE : public Component {
   void advertising_start();
   void advertising_set_service_data(const std::vector<uint8_t> &data);
   void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
-  void advertising_set_manufacturer_data(std::span<const uint8_t> data);
   void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
   void advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name);
   void advertising_add_service_uuid(ESPBTUUID uuid);

esphome/components/esp32_ble/ble_advertising.cpp

@@ -59,10 +59,6 @@ void BLEAdvertising::set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void BLEAdvertising::set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void BLEAdvertising::set_manufacturer_data(std::span<const uint8_t> data) {
   delete[] this->advertising_data_.p_manufacturer_data;
   this->advertising_data_.p_manufacturer_data = nullptr;
   this->advertising_data_.manufacturer_len = data.size();

esphome/components/esp32_ble/ble_advertising.h

@@ -37,7 +37,6 @@ class BLEAdvertising {
   void set_scan_response(bool scan_response) { this->scan_response_ = scan_response; }
   void set_min_preferred_interval(uint16_t interval) { this->advertising_data_.min_interval = interval; }
   void set_manufacturer_data(const std::vector<uint8_t> &data);
-  void set_manufacturer_data(std::span<const uint8_t> data);
   void set_appearance(uint16_t appearance) { this->advertising_data_.appearance = appearance; }
   void set_service_data(const std::vector<uint8_t> &data);
   void set_service_data(std::span<const uint8_t> data);

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -1,6 +1,5 @@
 #include "esp32_ble_beacon.h"
 #include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -15,10 +15,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;
@@ -30,10 +27,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;

esphome/components/esp32_ble_tracker/automation.h

@@ -10,7 +10,7 @@ namespace esphome::esp32_ble_tracker {
 class ESPBTAdvertiseTrigger : public Trigger<const ESPBTDevice &>, public ESPBTDeviceListener {
  public:
   explicit ESPBTAdvertiseTrigger(ESP32BLETracker *parent) { parent->register_listener(this); }
-  void set_addresses(const std::vector<uint64_t> &addresses) { this->address_vec_ = addresses; }
+  void set_addresses(std::initializer_list<uint64_t> addresses) { this->address_vec_ = addresses; }
 
   bool parse_device(const ESPBTDevice &device) override {
     uint64_t u64_addr = device.address_uint64();

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -336,7 +336,7 @@ void ESP32ImprovComponent::process_incoming_data_() {
         this->connecting_sta_ = sta;
 
         wifi::global_wifi_component->set_sta(sta);
-        wifi::global_wifi_component->start_connecting(sta, false);
+        wifi::global_wifi_component->start_connecting(sta);
         this->set_state_(improv::STATE_PROVISIONING);
         ESP_LOGD(TAG, "Received Improv Wi-Fi settings ssid=%s, password=" LOG_SECRET("%s"), command.ssid.c_str(),
                  command.password.c_str());

esphome/components/ethernet/ethernet_component.cpp

@@ -381,7 +381,10 @@ void EthernetComponent::dump_config() {
       break;
   }
 
-  ESP_LOGCONFIG(TAG, "Ethernet:");
+  ESP_LOGCONFIG(TAG,
+                "Ethernet:\n"
+                "  Connected: %s",
+                YESNO(this->is_connected()));
   this->dump_connect_params_();
 #ifdef USE_ETHERNET_SPI
   ESP_LOGCONFIG(TAG,
@@ -418,8 +421,6 @@ void EthernetComponent::dump_config() {
 
 float EthernetComponent::get_setup_priority() const { return setup_priority::WIFI; }
 
-bool EthernetComponent::can_proceed() { return this->is_connected(); }
-
 network::IPAddresses EthernetComponent::get_ip_addresses() {
   network::IPAddresses addresses;
   esp_netif_ip_info_t ip;

esphome/components/ethernet/ethernet_component.h

@@ -58,7 +58,6 @@ class EthernetComponent : public Component {
   void loop() override;
   void dump_config() override;
   float get_setup_priority() const override;
-  bool can_proceed() override;
   void on_powerdown() override { powerdown(); }
   bool is_connected();
 

esphome/components/event/event.cpp

@@ -1,5 +1,6 @@
 #include "event.h"
-
+#include "esphome/core/defines.h"
+#include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -8,11 +9,11 @@ namespace event {
 static const char *const TAG = "event";
 
 void Event::trigger(const std::string &event_type) {
-  // Linear search - faster than std::set for small datasets (1-5 items typical)
-  const std::string *found = nullptr;
-  for (const auto &type : this->types_) {
-    if (type == event_type) {
-      found = &type;
+  // Linear search with strcmp - faster than std::set for small datasets (1-5 items typical)
+  const char *found = nullptr;
+  for (const char *type : this->types_) {
+    if (strcmp(type, event_type.c_str()) == 0) {
+      found = type;
       break;
     }
   }
@@ -20,9 +21,28 @@ void Event::trigger(const std::string &event_type) {
     ESP_LOGE(TAG, "'%s': invalid event type for trigger(): %s", this->get_name().c_str(), event_type.c_str());
     return;
   }
-  last_event_type = found;
-  ESP_LOGD(TAG, "'%s' Triggered event '%s'", this->get_name().c_str(), last_event_type->c_str());
+  this->last_event_type_ = found;
+  ESP_LOGD(TAG, "'%s' Triggered event '%s'", this->get_name().c_str(), this->last_event_type_);
   this->event_callback_.call(event_type);
+#if defined(USE_EVENT) && defined(USE_CONTROLLER_REGISTRY)
+  ControllerRegistry::notify_event(this);
+#endif
+}
+
+void Event::set_event_types(const FixedVector<const char *> &event_types) {
+  this->types_.init(event_types.size());
+  for (const char *type : event_types) {
+    this->types_.push_back(type);
+  }
+  this->last_event_type_ = nullptr;  // Reset when types change
+}
+
+void Event::set_event_types(const std::vector<const char *> &event_types) {
+  this->types_.init(event_types.size());
+  for (const char *type : event_types) {
+    this->types_.push_back(type);
+  }
+  this->last_event_type_ = nullptr;  // Reset when types change
 }
 
 void Event::add_on_event_callback(std::function<void(const std::string &event_type)> &&callback) {

esphome/components/event/event.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include <cstring>
 #include <string>
+#include <vector>
 
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
@@ -22,16 +24,39 @@ namespace event {
 
 class Event : public EntityBase, public EntityBase_DeviceClass {
  public:
-  const std::string *last_event_type;
-
   void trigger(const std::string &event_type);
-  void set_event_types(const std::initializer_list<std::string> &event_types) { this->types_ = event_types; }
-  const FixedVector<std::string> &get_event_types() const { return this->types_; }
+
+  /// Set the event types supported by this event (from initializer list).
+  void set_event_types(std::initializer_list<const char *> event_types) {
+    this->types_ = event_types;
+    this->last_event_type_ = nullptr;  // Reset when types change
+  }
+  /// Set the event types supported by this event (from FixedVector).
+  void set_event_types(const FixedVector<const char *> &event_types);
+  /// Set the event types supported by this event (from vector).
+  void set_event_types(const std::vector<const char *> &event_types);
+
+  // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
+  void set_event_types(std::initializer_list<std::string> event_types) = delete;
+  void set_event_types(const FixedVector<std::string> &event_types) = delete;
+  void set_event_types(const std::vector<std::string> &event_types) = delete;
+
+  /// Return the event types supported by this event.
+  const FixedVector<const char *> &get_event_types() const { return this->types_; }
+
+  /// Return the last triggered event type (pointer to string in types_), or nullptr if no event triggered yet.
+  const char *get_last_event_type() const { return this->last_event_type_; }
+
   void add_on_event_callback(std::function<void(const std::string &event_type)> &&callback);
 
  protected:
   CallbackManager<void(const std::string &event_type)> event_callback_;
-  FixedVector<std::string> types_;
+  FixedVector<const char *> types_;
+
+ private:
+  /// Last triggered event type - must point to entry in types_ to ensure valid lifetime.
+  /// Set by trigger() after validation, reset to nullptr when types_ changes.
+  const char *last_event_type_{nullptr};
 };
 
 }  // namespace event

esphome/components/fan/fan.cpp

@@ -1,4 +1,6 @@
 #include "fan.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -181,6 +183,9 @@ void Fan::publish_state() {
     ESP_LOGD(TAG, "  Preset Mode: %s", preset);
   }
   this->state_callback_.call();
+#if defined(USE_FAN) && defined(USE_CONTROLLER_REGISTRY)
+  ControllerRegistry::notify_fan_update(this);
+#endif
   this->save_state_();
 }
 
@@ -231,7 +236,7 @@ void Fan::save_state_() {
   state.direction = this->direction;
 
   const char *preset = this->get_preset_mode();
-  if (traits.supports_preset_modes() && preset != nullptr) {
+  if (preset != nullptr) {
     const auto &preset_modes = traits.supported_preset_modes();
     // Find index of current preset mode (pointer comparison is safe since preset is from traits)
     for (size_t i = 0; i < preset_modes.size(); i++) {

esphome/components/font/__init__.py

@@ -36,7 +36,6 @@ from esphome.const import (
     CONF_WEIGHT,
 )
 from esphome.core import CORE, HexInt
-from esphome.helpers import cpp_string_escape
 from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
@@ -50,7 +49,6 @@ font_ns = cg.esphome_ns.namespace("font")
 
 Font = font_ns.class_("Font")
 Glyph = font_ns.class_("Glyph")
-GlyphData = font_ns.struct("GlyphData")
 
 CONF_BPP = "bpp"
 CONF_EXTRAS = "extras"
@@ -463,7 +461,7 @@ FONT_SCHEMA = cv.Schema(
             )
         ),
         cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
-        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(GlyphData),
+        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(Glyph),
     },
 )
 
@@ -488,6 +486,8 @@ class GlyphInfo:
 
 
 def glyph_to_glyphinfo(glyph, font, size, bpp):
+    # Convert to 32 bit unicode codepoint
+    glyph = ord(glyph)
     scale = 256 // (1 << bpp)
     if not font.is_scalable:
         sizes = [pt_to_px(x.size) for x in font.available_sizes]
@@ -583,22 +583,15 @@ async def to_code(config):
 
     # Create the glyph table that points to data in the above array.
     glyph_initializer = [
-        cg.StructInitializer(
-            GlyphData,
-            (
-                "a_char",
-                cg.RawExpression(f"(const uint8_t *){cpp_string_escape(x.glyph)}"),
-            ),
-            (
-                "data",
-                cg.RawExpression(f"{str(prog_arr)} + {str(y - len(x.bitmap_data))}"),
-            ),
-            ("advance", x.advance),
-            ("offset_x", x.offset_x),
-            ("offset_y", x.offset_y),
-            ("width", x.width),
-            ("height", x.height),
-        )
+        [
+            x.glyph,
+            prog_arr + (y - len(x.bitmap_data)),
+            x.advance,
+            x.offset_x,
+            x.offset_y,
+            x.width,
+            x.height,
+        ]
         for (x, y) in zip(
             glyph_args, list(accumulate([len(x.bitmap_data) for x in glyph_args]))
         )

esphome/components/font/font.cpp

@@ -6,133 +6,245 @@
 
 namespace esphome {
 namespace font {
-
 static const char *const TAG = "font";
 
-const uint8_t *Glyph::get_char() const { return this->glyph_data_->a_char; }
-// Compare the char at the string position with this char.
-// Return true if this char is less than or equal the other.
-bool Glyph::compare_to(const uint8_t *str) const {
-  // 1 -> this->char_
-  // 2 -> str
-  for (uint32_t i = 0;; i++) {
-    if (this->glyph_data_->a_char[i] == '\0')
-      return true;
-    if (str[i] == '\0')
-      return false;
-    if (this->glyph_data_->a_char[i] > str[i])
-      return false;
-    if (this->glyph_data_->a_char[i] < str[i])
-      return true;
+#ifdef USE_LVGL_FONT
+const uint8_t *Font::get_glyph_bitmap(const lv_font_t *font, uint32_t unicode_letter) {
+  auto *fe = (Font *) font->dsc;
+  const auto *gd = fe->get_glyph_data_(unicode_letter);
+  if (gd == nullptr) {
+    return nullptr;
   }
-  // this should not happen
-  return false;
-}
-int Glyph::match_length(const uint8_t *str) const {
-  for (uint32_t i = 0;; i++) {
-    if (this->glyph_data_->a_char[i] == '\0')
-      return i;
-    if (str[i] != this->glyph_data_->a_char[i])
-      return 0;
-  }
-  // this should not happen
-  return 0;
-}
-void Glyph::scan_area(int *x1, int *y1, int *width, int *height) const {
-  *x1 = this->glyph_data_->offset_x;
-  *y1 = this->glyph_data_->offset_y;
-  *width = this->glyph_data_->width;
-  *height = this->glyph_data_->height;
+  return gd->data;
 }
 
-Font::Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+bool Font::get_glyph_dsc_cb(const lv_font_t *font, lv_font_glyph_dsc_t *dsc, uint32_t unicode_letter, uint32_t next) {
+  auto *fe = (Font *) font->dsc;
+  const auto *gd = fe->get_glyph_data_(unicode_letter);
+  if (gd == nullptr) {
+    return false;
+  }
+  dsc->adv_w = gd->advance;
+  dsc->ofs_x = gd->offset_x;
+  dsc->ofs_y = fe->height_ - gd->height - gd->offset_y - fe->lv_font_.base_line;
+  dsc->box_w = gd->width;
+  dsc->box_h = gd->height;
+  dsc->is_placeholder = 0;
+  dsc->bpp = fe->get_bpp();
+  return true;
+}
+
+const Glyph *Font::get_glyph_data_(uint32_t unicode_letter) {
+  if (unicode_letter == this->last_letter_ && this->last_letter_ != 0)
+    return this->last_data_;
+  auto *glyph = this->find_glyph(unicode_letter);
+  if (glyph == nullptr) {
+    return nullptr;
+  }
+  this->last_data_ = glyph;
+  this->last_letter_ = unicode_letter;
+  return glyph;
+}
+#endif
+
+/**
+ *  Attempt to extract a 32 bit Unicode codepoint from a UTF-8 string.
+ *  If successful, return the codepoint and set the length to the number of bytes read.
+ *  If the end of the string has been reached and a valid codepoint has not been found, return 0 and set the length to
+ * 0.
+ *
+ * @param utf8_str The input string
+ * @param length Pointer to length storage
+ * @return The extracted code point
+ */
+static uint32_t extract_unicode_codepoint(const char *utf8_str, size_t *length) {
+  // Safely cast to uint8_t* for correct bitwise operations on bytes
+  const uint8_t *current = reinterpret_cast<const uint8_t *>(utf8_str);
+  uint32_t code_point = 0;
+  uint8_t c1 = *current++;
+
+  // check for end of string
+  if (c1 == 0) {
+    *length = 0;
+    return 0;
+  }
+
+  // --- 1-Byte Sequence: 0xxxxxxx (ASCII) ---
+  if (c1 < 0x80) {
+    // Valid ASCII byte.
+    code_point = c1;
+    // Optimization: No need to check for continuation bytes.
+  }
+  // --- 2-Byte Sequence: 110xxxxx 10xxxxxx ---
+  else if ((c1 & 0xE0) == 0xC0) {
+    uint8_t c2 = *current++;
+
+    // Error Check 1: Check if c2 is a valid continuation byte (10xxxxxx)
+    if ((c2 & 0xC0) != 0x80) {
+      *length = 0;
+      return 0;
+    }
+
+    code_point = (c1 & 0x1F) << 6;
+    code_point |= (c2 & 0x3F);
+
+    // Error Check 2: Overlong check (2-byte must be > 0x7F)
+    if (code_point <= 0x7F) {
+      *length = 0;
+      return 0;
+    }
+  }
+  // --- 3-Byte Sequence: 1110xxxx 10xxxxxx 10xxxxxx ---
+  else if ((c1 & 0xF0) == 0xE0) {
+    uint8_t c2 = *current++;
+    uint8_t c3 = *current++;
+
+    // Error Check 1: Check continuation bytes
+    if (((c2 & 0xC0) != 0x80) || ((c3 & 0xC0) != 0x80)) {
+      *length = 0;
+      return 0;
+    }
+
+    code_point = (c1 & 0x0F) << 12;
+    code_point |= (c2 & 0x3F) << 6;
+    code_point |= (c3 & 0x3F);
+
+    // Error Check 2: Overlong check (3-byte must be > 0x7FF)
+    // Also check for surrogates (0xD800-0xDFFF)
+    if (code_point <= 0x7FF || (code_point >= 0xD800 && code_point <= 0xDFFF)) {
+      *length = 0;
+      return 0;
+    }
+  }
+  // --- 4-Byte Sequence: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx ---
+  else if ((c1 & 0xF8) == 0xF0) {
+    uint8_t c2 = *current++;
+    uint8_t c3 = *current++;
+    uint8_t c4 = *current++;
+
+    // Error Check 1: Check continuation bytes
+    if (((c2 & 0xC0) != 0x80) || ((c3 & 0xC0) != 0x80) || ((c4 & 0xC0) != 0x80)) {
+      *length = 0;
+      return 0;
+    }
+
+    code_point = (c1 & 0x07) << 18;
+    code_point |= (c2 & 0x3F) << 12;
+    code_point |= (c3 & 0x3F) << 6;
+    code_point |= (c4 & 0x3F);
+
+    // Error Check 2: Overlong check (4-byte must be > 0xFFFF)
+    // Also check for valid Unicode range (must be <= 0x10FFFF)
+    if (code_point <= 0xFFFF || code_point > 0x10FFFF) {
+      *length = 0;
+      return 0;
+    }
+  }
+  // --- Invalid leading byte (e.g., 10xxxxxx or 11111xxx) ---
+  else {
+    *length = 0;
+    return 0;
+  }
+  *length = current - reinterpret_cast<const uint8_t *>(utf8_str);
+  return code_point;
+}
+
+Font::Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
            uint8_t bpp)
-    : baseline_(baseline),
+    : glyphs_(ConstVector(data, data_nr)),
+      baseline_(baseline),
       height_(height),
       descender_(descender),
       linegap_(height - baseline - descender),
       xheight_(xheight),
       capheight_(capheight),
       bpp_(bpp) {
-  glyphs_.reserve(data_nr);
-  for (int i = 0; i < data_nr; ++i)
-    glyphs_.emplace_back(&data[i]);
+#ifdef USE_LVGL_FONT
+  this->lv_font_.dsc = this;
+  this->lv_font_.line_height = this->get_height();
+  this->lv_font_.base_line = this->lv_font_.line_height - this->get_baseline();
+  this->lv_font_.get_glyph_dsc = get_glyph_dsc_cb;
+  this->lv_font_.get_glyph_bitmap = get_glyph_bitmap;
+  this->lv_font_.subpx = LV_FONT_SUBPX_NONE;
+  this->lv_font_.underline_position = -1;
+  this->lv_font_.underline_thickness = 1;
+#endif
 }
-int Font::match_next_glyph(const uint8_t *str, int *match_length) {
+
+const Glyph *Font::find_glyph(uint32_t codepoint) const {
   int lo = 0;
   int hi = this->glyphs_.size() - 1;
   while (lo != hi) {
     int mid = (lo + hi + 1) / 2;
-    if (this->glyphs_[mid].compare_to(str)) {
+    if (this->glyphs_[mid].is_less_or_equal(codepoint)) {
       lo = mid;
     } else {
       hi = mid - 1;
     }
   }
-  *match_length = this->glyphs_[lo].match_length(str);
-  if (*match_length <= 0)
-    return -1;
-  return lo;
+  auto *result = &this->glyphs_[lo];
+  if (result->code_point == codepoint)
+    return result;
+  return nullptr;
 }
+
 #ifdef USE_DISPLAY
 void Font::measure(const char *str, int *width, int *x_offset, int *baseline, int *height) {
   *baseline = this->baseline_;
   *height = this->height_;
-  int i = 0;
   int min_x = 0;
   bool has_char = false;
   int x = 0;
-  while (str[i] != '\0') {
-    int match_length;
-    int glyph_n = this->match_next_glyph((const uint8_t *) str + i, &match_length);
-    if (glyph_n < 0) {
+  for (;;) {
+    size_t length;
+    auto code_point = extract_unicode_codepoint(str, &length);
+    if (length == 0)
+      break;
+    str += length;
+    auto *glyph = this->find_glyph(code_point);
+    if (glyph == nullptr) {
       // Unknown char, skip
-      if (!this->get_glyphs().empty())
-        x += this->get_glyphs()[0].glyph_data_->advance;
-      i++;
+      if (!this->glyphs_.empty())
+        x += this->glyphs_[0].advance;
       continue;
     }
 
-    const Glyph &glyph = this->glyphs_[glyph_n];
     if (!has_char) {
-      min_x = glyph.glyph_data_->offset_x;
+      min_x = glyph->offset_x;
     } else {
-      min_x = std::min(min_x, x + glyph.glyph_data_->offset_x);
+      min_x = std::min(min_x, x + glyph->offset_x);
     }
-    x += glyph.glyph_data_->advance;
+    x += glyph->advance;
 
-    i += match_length;
     has_char = true;
   }
   *x_offset = min_x;
   *width = x - min_x;
 }
+
 void Font::print(int x_start, int y_start, display::Display *display, Color color, const char *text, Color background) {
-  int i = 0;
   int x_at = x_start;
-  int scan_x1, scan_y1, scan_width, scan_height;
-  while (text[i] != '\0') {
-    int match_length;
-    int glyph_n = this->match_next_glyph((const uint8_t *) text + i, &match_length);
-    if (glyph_n < 0) {
+  for (;;) {
+    size_t length;
+    auto code_point = extract_unicode_codepoint(text, &length);
+    if (length == 0)
+      break;
+    text += length;
+    auto *glyph = this->find_glyph(code_point);
+    if (glyph == nullptr) {
       // Unknown char, skip
-      ESP_LOGW(TAG, "Encountered character without representation in font: '%c'", text[i]);
-      if (!this->get_glyphs().empty()) {
-        uint8_t glyph_width = this->get_glyphs()[0].glyph_data_->advance;
-        display->filled_rectangle(x_at, y_start, glyph_width, this->height_, color);
+      ESP_LOGW(TAG, "Codepoint 0x%08" PRIx32 " not found in font", code_point);
+      if (!this->glyphs_.empty()) {
+        uint8_t glyph_width = this->glyphs_[0].advance;
+        display->rectangle(x_at, y_start, glyph_width, this->height_, color);
         x_at += glyph_width;
       }
-
-      i++;
       continue;
     }
 
-    const Glyph &glyph = this->get_glyphs()[glyph_n];
-    glyph.scan_area(&scan_x1, &scan_y1, &scan_width, &scan_height);
-
-    const uint8_t *data = glyph.glyph_data_->data;
-    const int max_x = x_at + scan_x1 + scan_width;
-    const int max_y = y_start + scan_y1 + scan_height;
+    const uint8_t *data = glyph->data;
+    const int max_x = x_at + glyph->offset_x + glyph->width;
+    const int max_y = y_start + glyph->offset_y + glyph->height;
 
     uint8_t bitmask = 0;
     uint8_t pixel_data = 0;
@@ -145,10 +257,10 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
     auto b_g = (float) background.g;
     auto b_b = (float) background.b;
     auto b_w = (float) background.w;
-    for (int glyph_y = y_start + scan_y1; glyph_y != max_y; glyph_y++) {
-      for (int glyph_x = x_at + scan_x1; glyph_x != max_x; glyph_x++) {
+    for (int glyph_y = y_start + glyph->offset_y; glyph_y != max_y; glyph_y++) {
+      for (int glyph_x = x_at + glyph->offset_x; glyph_x != max_x; glyph_x++) {
         uint8_t pixel = 0;
-        for (int bit_num = 0; bit_num != this->bpp_; bit_num++) {
+        for (uint8_t bit_num = 0; bit_num != this->bpp_; bit_num++) {
           if (bitmask == 0) {
             pixel_data = progmem_read_byte(data++);
             bitmask = 0x80;
@@ -168,12 +280,9 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
         }
       }
     }
-    x_at += glyph.glyph_data_->advance;
-
-    i += match_length;
+    x_at += glyph->advance;
   }
 }
 #endif
-
 }  // namespace font
 }  // namespace esphome

esphome/components/font/font.h

@@ -6,14 +6,30 @@
 #ifdef USE_DISPLAY
 #include "esphome/components/display/display.h"
 #endif
+#ifdef USE_LVGL_FONT
+#include <lvgl.h>
+#endif
 
 namespace esphome {
 namespace font {
 
 class Font;
 
-struct GlyphData {
-  const uint8_t *a_char;
+class Glyph {
+ public:
+  constexpr Glyph(uint32_t code_point, const uint8_t *data, int advance, int offset_x, int offset_y, int width,
+                  int height)
+      : code_point(code_point),
+        data(data),
+        advance(advance),
+        offset_x(offset_x),
+        offset_y(offset_y),
+        width(width),
+        height(height) {}
+
+  bool is_less_or_equal(uint32_t other) const { return this->code_point <= other; }
+
+  const uint32_t code_point;
   const uint8_t *data;
   int advance;
   int offset_x;
@@ -22,26 +38,6 @@ struct GlyphData {
   int height;
 };
 
-class Glyph {
- public:
-  Glyph(const GlyphData *data) : glyph_data_(data) {}
-
-  const uint8_t *get_char() const;
-
-  bool compare_to(const uint8_t *str) const;
-
-  int match_length(const uint8_t *str) const;
-
-  void scan_area(int *x1, int *y1, int *width, int *height) const;
-
-  const GlyphData *get_glyph_data() const { return this->glyph_data_; }
-
- protected:
-  friend Font;
-
-  const GlyphData *glyph_data_;
-};
-
 class Font
 #ifdef USE_DISPLAY
     : public display::BaseFont
@@ -50,8 +46,8 @@ class Font
  public:
   /** Construct the font with the given glyphs.
    *
-   * @param data A vector of glyphs, must be sorted lexicographically.
-   * @param data_nr The number of glyphs in data.
+   * @param data A list of glyphs, must be sorted lexicographically.
+   * @param data_nr The number of glyphs
    * @param baseline The y-offset from the top of the text to the baseline.
    * @param height The y-offset from the top of the text to the bottom.
    * @param descender The y-offset from the baseline to the lowest stroke in the font (e.g. from letters like g or p).
@@ -59,10 +55,10 @@ class Font
    * @param capheight The height of capital letters, usually measured at the "X" glyph.
    * @param bpp The bits per pixel used for this font. Used to read data out of the glyph bitmaps.
    */
-  Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+  Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
        uint8_t bpp = 1);
 
-  int match_next_glyph(const uint8_t *str, int *match_length);
+  const Glyph *find_glyph(uint32_t codepoint) const;
 
 #ifdef USE_DISPLAY
   void print(int x_start, int y_start, display::Display *display, Color color, const char *text,
@@ -77,11 +73,14 @@ class Font
   inline int get_xheight() { return this->xheight_; }
   inline int get_capheight() { return this->capheight_; }
   inline int get_bpp() { return this->bpp_; }
+#ifdef USE_LVGL_FONT
+  const lv_font_t *get_lv_font() const { return &this->lv_font_; }
+#endif
 
-  const std::vector<Glyph, RAMAllocator<Glyph>> &get_glyphs() const { return glyphs_; }
+  const ConstVector<Glyph> &get_glyphs() const { return glyphs_; }
 
  protected:
-  std::vector<Glyph, RAMAllocator<Glyph>> glyphs_;
+  ConstVector<Glyph> glyphs_;
   int baseline_;
   int height_;
   int descender_;
@@ -89,6 +88,14 @@ class Font
   int xheight_;
   int capheight_;
   uint8_t bpp_;  // bits per pixel
+#ifdef USE_LVGL_FONT
+  lv_font_t lv_font_{};
+  static const uint8_t *get_glyph_bitmap(const lv_font_t *font, uint32_t unicode_letter);
+  static bool get_glyph_dsc_cb(const lv_font_t *font, lv_font_glyph_dsc_t *dsc, uint32_t unicode_letter, uint32_t next);
+  const Glyph *get_glyph_data_(uint32_t unicode_letter);
+  uint32_t last_letter_{};
+  const Glyph *last_data_{};
+#endif
 };
 
 }  // namespace font

esphome/components/gdk101/gdk101.cpp

@@ -62,7 +62,6 @@ void GDK101Component::dump_config() {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 #ifdef USE_SENSOR
-  LOG_SENSOR("  ", "Firmware Version", this->fw_version_sensor_);
   LOG_SENSOR("  ", "Average Radaition Dose per 1 minute", this->rad_1m_sensor_);
   LOG_SENSOR("  ", "Average Radaition Dose per 10 minutes", this->rad_10m_sensor_);
   LOG_SENSOR("  ", "Status", this->status_sensor_);
@@ -72,6 +71,10 @@ void GDK101Component::dump_config() {
 #ifdef USE_BINARY_SENSOR
   LOG_BINARY_SENSOR("  ", "Vibration Status", this->vibration_binary_sensor_);
 #endif  // USE_BINARY_SENSOR
+
+#ifdef USE_TEXT_SENSOR
+  LOG_TEXT_SENSOR("  ", "Firmware Version", this->fw_version_text_sensor_);
+#endif  // USE_TEXT_SENSOR
 }
 
 float GDK101Component::get_setup_priority() const { return setup_priority::DATA; }
@@ -153,18 +156,18 @@ bool GDK101Component::read_status_(uint8_t *data) {
 }
 
 bool GDK101Component::read_fw_version_(uint8_t *data) {
-#ifdef USE_SENSOR
-  if (this->fw_version_sensor_ != nullptr) {
+#ifdef USE_TEXT_SENSOR
+  if (this->fw_version_text_sensor_ != nullptr) {
     if (!this->read_bytes(GDK101_REG_READ_FIRMWARE, data, 2)) {
       ESP_LOGE(TAG, "Updating GDK101 failed!");
       return false;
     }
 
-    const float fw_version = data[0] + (data[1] / 10.0f);
+    const std::string fw_version_str = str_sprintf("%d.%d", data[0], data[1]);
 
-    this->fw_version_sensor_->publish_state(fw_version);
+    this->fw_version_text_sensor_->publish_state(fw_version_str);
   }
-#endif  // USE_SENSOR
+#endif  // USE_TEXT_SENSOR
   return true;
 }
 

esphome/components/gdk101/gdk101.h

@@ -8,6 +8,9 @@
 #ifdef USE_BINARY_SENSOR
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #endif  // USE_BINARY_SENSOR
+#ifdef USE_TEXT_SENSOR
+#include "esphome/components/text_sensor/text_sensor.h"
+#endif  // USE_TEXT_SENSOR
 #include "esphome/components/i2c/i2c.h"
 
 namespace esphome {
@@ -25,12 +28,14 @@ class GDK101Component : public PollingComponent, public i2c::I2CDevice {
   SUB_SENSOR(rad_1m)
   SUB_SENSOR(rad_10m)
   SUB_SENSOR(status)
-  SUB_SENSOR(fw_version)
   SUB_SENSOR(measurement_duration)
 #endif  // USE_SENSOR
 #ifdef USE_BINARY_SENSOR
   SUB_BINARY_SENSOR(vibration)
 #endif  // USE_BINARY_SENSOR
+#ifdef USE_TEXT_SENSOR
+  SUB_TEXT_SENSOR(fw_version)
+#endif  // USE_TEXT_SENSOR
 
  public:
   void setup() override;

esphome/components/gdk101/sensor.py

@@ -40,9 +40,8 @@ CONFIG_SCHEMA = cv.Schema(
             device_class=DEVICE_CLASS_EMPTY,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
-        cv.Optional(CONF_VERSION): sensor.sensor_schema(
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            accuracy_decimals=1,
+        cv.Optional(CONF_VERSION): cv.invalid(
+            "The 'version' option has been moved to the `text_sensor` component."
         ),
         cv.Optional(CONF_STATUS): sensor.sensor_schema(
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
@@ -71,10 +70,6 @@ async def to_code(config):
         sens = await sensor.new_sensor(radiation_dose_per_10m)
         cg.add(hub.set_rad_10m_sensor(sens))
 
-    if version_config := config.get(CONF_VERSION):
-        sens = await sensor.new_sensor(version_config)
-        cg.add(hub.set_fw_version_sensor(sens))
-
     if status_config := config.get(CONF_STATUS):
         sens = await sensor.new_sensor(status_config)
         cg.add(hub.set_status_sensor(sens))

esphome/components/gdk101/text_sensor.py

@@ -0,0 +1,23 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_VERSION, ENTITY_CATEGORY_DIAGNOSTIC, ICON_CHIP
+
+from . import CONF_GDK101_ID, GDK101Component
+
+DEPENDENCIES = ["gdk101"]
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_GDK101_ID): cv.use_id(GDK101Component),
+        cv.Required(CONF_VERSION): text_sensor.text_sensor_schema(
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC, icon=ICON_CHIP
+        ),
+    }
+)
+
+
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_GDK101_ID])
+    var = await text_sensor.new_text_sensor(config[CONF_VERSION])
+    cg.add(hub.set_fw_version_text_sensor(var))

esphome/components/gp8403/__init__.py

@@ -1,19 +1,25 @@
 import esphome.codegen as cg
 from esphome.components import i2c
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_VOLTAGE
+from esphome.const import CONF_ID, CONF_MODEL, CONF_VOLTAGE
 
-CODEOWNERS = ["@jesserockz"]
+CODEOWNERS = ["@jesserockz", "@sebydocky"]
 DEPENDENCIES = ["i2c"]
 MULTI_CONF = True
 
 gp8403_ns = cg.esphome_ns.namespace("gp8403")
-GP8403 = gp8403_ns.class_("GP8403", cg.Component, i2c.I2CDevice)
+GP8403Component = gp8403_ns.class_("GP8403Component", cg.Component, i2c.I2CDevice)
 
 GP8403Voltage = gp8403_ns.enum("GP8403Voltage")
+GP8403Model = gp8403_ns.enum("GP8403Model")
 
 CONF_GP8403_ID = "gp8403_id"
 
+MODELS = {
+    "GP8403": GP8403Model.GP8403,
+    "GP8413": GP8403Model.GP8413,
+}
+
 VOLTAGES = {
     "5V": GP8403Voltage.GP8403_VOLTAGE_5V,
     "10V": GP8403Voltage.GP8403_VOLTAGE_10V,
@@ -22,7 +28,8 @@ VOLTAGES = {
 CONFIG_SCHEMA = (
     cv.Schema(
         {
-            cv.GenerateID(): cv.declare_id(GP8403),
+            cv.GenerateID(): cv.declare_id(GP8403Component),
+            cv.Optional(CONF_MODEL, default="GP8403"): cv.enum(MODELS, upper=True),
             cv.Required(CONF_VOLTAGE): cv.enum(VOLTAGES, upper=True),
         }
     )
@@ -35,5 +42,5 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)
-
+    cg.add(var.set_model(config[CONF_MODEL]))
     cg.add(var.set_voltage(config[CONF_VOLTAGE]))

esphome/components/gp8403/gp8403.cpp

@@ -8,16 +8,48 @@ namespace gp8403 {
 static const char *const TAG = "gp8403";
 
 static const uint8_t RANGE_REGISTER = 0x01;
+static const uint8_t OUTPUT_REGISTER = 0x02;
 
-void GP8403::setup() { this->write_register(RANGE_REGISTER, (uint8_t *) (&this->voltage_), 1); }
+const LogString *model_to_string(GP8403Model model) {
+  switch (model) {
+    case GP8403Model::GP8403:
+      return LOG_STR("GP8403");
+    case GP8403Model::GP8413:
+      return LOG_STR("GP8413");
+  }
+  return LOG_STR("Unknown");
+};
 
-void GP8403::dump_config() {
+void GP8403Component::setup() { this->write_register(RANGE_REGISTER, (uint8_t *) (&this->voltage_), 1); }
+
+void GP8403Component::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "GP8403:\n"
-                "  Voltage: %dV",
-                this->voltage_ == GP8403_VOLTAGE_5V ? 5 : 10);
+                "  Voltage: %dV\n"
+                "  Model: %s",
+                this->voltage_ == GP8403_VOLTAGE_5V ? 5 : 10, LOG_STR_ARG(model_to_string(this->model_)));
   LOG_I2C_DEVICE(this);
 }
 
+void GP8403Component::write_state(float state, uint8_t channel) {
+  uint16_t val = 0;
+  switch (this->model_) {
+    case GP8403Model::GP8403:
+      val = ((uint16_t) (4095 * state)) << 4;
+      break;
+    case GP8403Model::GP8413:
+      val = ((uint16_t) (32767 * state)) << 1;
+      break;
+    default:
+      ESP_LOGE(TAG, "Unknown model %s", LOG_STR_ARG(model_to_string(this->model_)));
+      return;
+  }
+  ESP_LOGV(TAG, "Calculated DAC value: %" PRIu16, val);
+  i2c::ErrorCode err = this->write_register(OUTPUT_REGISTER + (2 * channel), (uint8_t *) &val, 2);
+  if (err != i2c::ERROR_OK) {
+    ESP_LOGE(TAG, "Error writing to %s, code %d", LOG_STR_ARG(model_to_string(this->model_)), err);
+  }
+}
+
 }  // namespace gp8403
 }  // namespace esphome

esphome/components/gp8403/gp8403.h

@@ -11,15 +11,24 @@ enum GP8403Voltage {
   GP8403_VOLTAGE_10V = 0x11,
 };
 
-class GP8403 : public Component, public i2c::I2CDevice {
+enum GP8403Model {
+  GP8403,
+  GP8413,
+};
+
+class GP8403Component : public Component, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void set_model(GP8403Model model) { this->model_ = model; }
   void set_voltage(gp8403::GP8403Voltage voltage) { this->voltage_ = voltage; }
 
+  void write_state(float state, uint8_t channel);
+
  protected:
   GP8403Voltage voltage_;
+  GP8403Model model_{GP8403Model::GP8403};
 };
 
 }  // namespace gp8403

esphome/components/gp8403/output/__init__.py

@@ -3,7 +3,7 @@ from esphome.components import i2c, output
 import esphome.config_validation as cv
 from esphome.const import CONF_CHANNEL, CONF_ID
 
-from .. import CONF_GP8403_ID, GP8403, gp8403_ns
+from .. import CONF_GP8403_ID, GP8403Component, gp8403_ns
 
 DEPENDENCIES = ["gp8403"]
 
@@ -14,7 +14,7 @@ GP8403Output = gp8403_ns.class_(
 CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
     {
         cv.GenerateID(): cv.declare_id(GP8403Output),
-        cv.GenerateID(CONF_GP8403_ID): cv.use_id(GP8403),
+        cv.GenerateID(CONF_GP8403_ID): cv.use_id(GP8403Component),
         cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=1),
     }
 ).extend(cv.COMPONENT_SCHEMA)

esphome/components/gp8403/output/gp8403_output.cpp

@@ -7,8 +7,6 @@ namespace gp8403 {
 
 static const char *const TAG = "gp8403.output";
 
-static const uint8_t OUTPUT_REGISTER = 0x02;
-
 void GP8403Output::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "GP8403 Output:\n"
@@ -16,13 +14,7 @@ void GP8403Output::dump_config() {
                 this->channel_);
 }
 
-void GP8403Output::write_state(float state) {
-  uint16_t value = ((uint16_t) (state * 4095)) << 4;
-  i2c::ErrorCode err = this->parent_->write_register(OUTPUT_REGISTER + (2 * this->channel_), (uint8_t *) &value, 2);
-  if (err != i2c::ERROR_OK) {
-    ESP_LOGE(TAG, "Error writing to GP8403, code %d", err);
-  }
-}
+void GP8403Output::write_state(float state) { this->parent_->write_state(state, this->channel_); }
 
 }  // namespace gp8403
 }  // namespace esphome

esphome/components/gp8403/output/gp8403_output.h

@@ -8,13 +8,11 @@
 namespace esphome {
 namespace gp8403 {
 
-class GP8403Output : public Component, public output::FloatOutput, public Parented<GP8403> {
+class GP8403Output : public Component, public output::FloatOutput, public Parented<GP8403Component> {
  public:
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::DATA - 1; }
-
   void set_channel(uint8_t channel) { this->channel_ = channel; }
-
   void write_state(float state) override;
 
  protected:

esphome/components/graph/graph.cpp

@@ -235,7 +235,7 @@ void GraphLegend::init(Graph *g) {
       std::string valstr =
           value_accuracy_to_string(trace->sensor_->get_state(), trace->sensor_->get_accuracy_decimals());
       if (this->units_) {
-        valstr += trace->sensor_->get_unit_of_measurement();
+        valstr += trace->sensor_->get_unit_of_measurement_ref();
       }
       this->font_value_->measure(valstr.c_str(), &fw, &fos, &fbl, &fh);
       if (fw > valw)
@@ -371,7 +371,7 @@ void Graph::draw_legend(display::Display *buff, uint16_t x_offset, uint16_t y_of
       std::string valstr =
           value_accuracy_to_string(trace->sensor_->get_state(), trace->sensor_->get_accuracy_decimals());
       if (legend_->units_) {
-        valstr += trace->sensor_->get_unit_of_measurement();
+        valstr += trace->sensor_->get_unit_of_measurement_ref();
       }
       buff->printf(xv, yv, legend_->font_value_, trace->get_line_color(), TextAlign::TOP_CENTER, "%s", valstr.c_str());
       ESP_LOGV(TAG, "    value: %s", valstr.c_str());