Merge branch 'dev' into combine_logs

# Conflicts:
#	esphome/components/hlw8012/hlw8012.cpp
#	esphome/components/sonoff_d1/sonoff_d1.cpp
#	esphome/components/xiaomi_xmwsdj04mmc/xiaomi_xmwsdj04mmc.cpp

.ai/instructions.md

@@ -293,12 +293,6 @@ This document provides essential context for AI models interacting with this pro
     *   **Configuration Design:** Aim for simplicity with sensible defaults, while allowing for advanced customization.
     *   **Embedded Systems Optimization:** ESPHome targets resource-constrained microcontrollers. Be mindful of flash size and RAM usage.
 
-        **Why Heap Allocation Matters:**
-
-        ESP devices run for months with small heaps shared between Wi-Fi, BLE, LWIP, and application code. Over time, repeated allocations of different sizes fragment the heap. Failures happen when the largest contiguous block shrinks, even if total free heap is still large. We have seen field crashes caused by this.
-
-        **Heap allocation after `setup()` should be avoided unless absolutely unavoidable.** Every allocation/deallocation cycle contributes to fragmentation. ESPHome treats runtime heap allocation as a long-term reliability bug, not a performance issue. Helpers that hide allocation (`std::string`, `std::to_string`, string-returning helpers) are being deprecated and replaced with buffer and view based APIs.
-
         **STL Container Guidelines:**
 
         ESPHome runs on embedded systems with limited resources. Choose containers carefully:
@@ -328,15 +322,15 @@ This document provides essential context for AI models interacting with this pro
            std::array<uint8_t, 256> buffer;
            ```
 
-        2. **Compile-time-known fixed sizes with vector-like API:** Use `StaticVector` from `esphome/core/helpers.h` for compile-time fixed size with `push_back()` interface (no dynamic allocation).
+        2. **Compile-time-known fixed sizes with vector-like API:** Use `StaticVector` from `esphome/core/helpers.h` for fixed-size stack allocation with `push_back()` interface.
            ```cpp
            // Bad - generates STL realloc code (_M_realloc_insert)
            std::vector<ServiceRecord> services;
            services.reserve(5);  // Still includes reallocation machinery
 
-           // Good - compile-time fixed size, no dynamic allocation
-           StaticVector<ServiceRecord, MAX_SERVICES> services;
-           services.push_back(record1);
+           // Good - compile-time fixed size, stack allocated, no reallocation machinery
+           StaticVector<ServiceRecord, MAX_SERVICES> services;  // Allocates all MAX_SERVICES on stack
+           services.push_back(record1);  // Tracks count but all slots allocated
            ```
            Use `cg.add_define("MAX_SERVICES", count)` to set the size from Python configuration.
            Like `std::array` but with vector-like API (`push_back()`, `size()`) and no STL reallocation code.
@@ -378,21 +372,22 @@ This document provides essential context for AI models interacting with this pro
            ```
            Linear search on small datasets (1-16 elements) is often faster than hashing/tree overhead, but this depends on lookup frequency and access patterns. For frequent lookups in hot code paths, the O(1) vs O(n) complexity difference may still matter even for small datasets. `std::vector` with simple structs is usually fine—it's the heavy containers (`map`, `set`, `unordered_map`) that should be avoided for small datasets unless profiling shows otherwise.
 
-        5. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices.
-
-        6. **Detection:** Look for these patterns in compiler output:
+        5. **Detection:** Look for these patterns in compiler output:
            - Large code sections with STL symbols (vector, map, set)
            - `alloc`, `realloc`, `dealloc` in symbol names
            - `_M_realloc_insert`, `_M_default_append` (vector reallocation)
            - Red-black tree code (`rb_tree`, `_Rb_tree`)
            - Hash table infrastructure (`unordered_map`, `hash`)
 
-        **Prioritize optimization effort for:**
+        **When to optimize:**
         - Core components (API, network, logger)
         - Widely-used components (mdns, wifi, ble)
         - Components causing flash size complaints
 
-        Note: Avoiding heap allocation after `setup()` is always required regardless of component type. The prioritization above is about the effort spent on container optimization (e.g., migrating from `std::vector` to `StaticVector`).
+        **When not to optimize:**
+        - Single-use niche components
+        - Code where readability matters more than bytes
+        - Already using appropriate containers
 
     *   **State Management:** Use `CORE.data` for component state that needs to persist during configuration generation. Avoid module-level mutable globals.
 

.clang-tidy.hash

@@ -1 +1 @@
-d272a88e8ca28ae9340a9a03295a566432a52cb696501908f57764475bf7ca65
+94557f94be073390342833aff12ef8676a8b597db5fa770a5a1232e9425cb48f

.pre-commit-config.yaml

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

CODEOWNERS

@@ -135,7 +135,7 @@ esphome/components/display_menu_base/* @numo68
 esphome/components/dps310/* @kbx81
 esphome/components/ds1307/* @badbadc0ffee
 esphome/components/ds2484/* @mrk-its
-esphome/components/dsmr/* @glmnet @PolarGoose @zuidwijk
+esphome/components/dsmr/* @glmnet @zuidwijk
 esphome/components/duty_time/* @dudanov
 esphome/components/ee895/* @Stock-M
 esphome/components/ektf2232/touchscreen/* @jesserockz
@@ -249,7 +249,6 @@ esphome/components/ina260/* @mreditor97
 esphome/components/ina2xx_base/* @latonita
 esphome/components/ina2xx_i2c/* @latonita
 esphome/components/ina2xx_spi/* @latonita
-esphome/components/infrared/* @kbx81
 esphome/components/inkbird_ibsth1_mini/* @fkirill
 esphome/components/inkplate/* @jesserockz @JosipKuci
 esphome/components/integration/* @OttoWinter
@@ -396,7 +395,6 @@ esphome/components/radon_eye_rd200/* @jeffeb3
 esphome/components/rc522/* @glmnet
 esphome/components/rc522_i2c/* @glmnet
 esphome/components/rc522_spi/* @glmnet
-esphome/components/rd03d/* @jasstrong
 esphome/components/resampler/speaker/* @kahrendt
 esphome/components/restart/* @esphome/core
 esphome/components/rf_bridge/* @jesserockz

esphome/__main__.py

@@ -62,9 +62,6 @@ from esphome.util import (
 
 _LOGGER = logging.getLogger(__name__)
 
-# Maximum buffer size for serial log reading to prevent unbounded memory growth
-SERIAL_BUFFER_MAX_SIZE = 65536
-
 # Special non-component keys that appear in configs
 _NON_COMPONENT_KEYS = frozenset(
     {
@@ -434,37 +431,25 @@ def run_miniterm(config: ConfigType, port: str, args) -> int:
     while tries < 5:
         try:
             with ser:
-                buffer = b""
-                ser.timeout = 0.1  # 100ms timeout for non-blocking reads
                 while True:
                     try:
-                        # Read all available data and timestamp it
-                        chunk = ser.read(ser.in_waiting or 1)
-                        if not chunk:
-                            continue
-                        time_ = datetime.now()
-                        milliseconds = time_.microsecond // 1000
-                        time_str = f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}.{milliseconds:03}]"
-
-                        # Add to buffer and process complete lines
-                        # Limit buffer size to prevent unbounded memory growth
-                        # if device sends data without newlines
-                        buffer += chunk
-                        if len(buffer) > SERIAL_BUFFER_MAX_SIZE:
-                            buffer = buffer[-SERIAL_BUFFER_MAX_SIZE:]
-                        while b"\n" in buffer:
-                            raw_line, buffer = buffer.split(b"\n", 1)
-                            line = raw_line.replace(b"\r", b"").decode(
-                                "utf8", "backslashreplace"
-                            )
-                            safe_print(parser.parse_line(line, time_str))
-
-                            backtrace_state = platformio_api.process_stacktrace(
-                                config, line, backtrace_state=backtrace_state
-                            )
+                        raw = ser.readline()
                     except serial.SerialException:
                         _LOGGER.error("Serial port closed!")
                         return 0
+                    line = (
+                        raw.replace(b"\r", b"")
+                        .replace(b"\n", b"")
+                        .decode("utf8", "backslashreplace")
+                    )
+                    time_ = datetime.now()
+                    nanoseconds = time_.microsecond // 1000
+                    time_str = f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}.{nanoseconds:03}]"
+                    safe_print(parser.parse_line(line, time_str))
+
+                    backtrace_state = platformio_api.process_stacktrace(
+                        config, line, backtrace_state=backtrace_state
+                    )
         except serial.SerialException:
             tries += 1
             time.sleep(1)
@@ -1032,7 +1017,6 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:
         idedata.objdump_path,
         idedata.readelf_path,
         external_components,
-        idedata=idedata,
     )
     analyzer.analyze()
 

esphome/analyze_memory/__init__.py

@@ -22,7 +22,6 @@ from .helpers import (
     map_section_name,
     parse_symbol_line,
 )
-from .toolchain import find_tool, run_tool
 
 if TYPE_CHECKING:
     from esphome.platformio_api import IDEData
@@ -54,9 +53,6 @@ _NAMESPACE_STD = "std::"
 # Type alias for symbol information: (symbol_name, size, component)
 SymbolInfoType = tuple[str, int, str]
 
-# RAM sections - symbols in these sections consume RAM
-RAM_SECTIONS = frozenset([".data", ".bss"])
-
 
 @dataclass
 class MemorySection:
@@ -64,20 +60,7 @@ class MemorySection:
 
     name: str
     symbols: list[SymbolInfoType] = field(default_factory=list)
-    total_size: int = 0  # Actual section size from ELF headers
-    symbol_size: int = 0  # Sum of symbol sizes (may be less than total_size)
-
-
-@dataclass
-class SDKSymbol:
-    """Represents a symbol from an SDK library that's not in the ELF symbol table."""
-
-    name: str
-    size: int
-    library: str  # Name of the .a file (e.g., "libpp.a")
-    section: str  # ".bss" or ".data"
-    is_local: bool  # True if static/local symbol (lowercase in nm output)
-    demangled: str = ""  # Demangled name (populated after analysis)
+    total_size: int = 0
 
 
 @dataclass
@@ -135,10 +118,6 @@ class MemoryAnalyzer:
         self.objdump_path = objdump_path or "objdump"
         self.readelf_path = readelf_path or "readelf"
         self.external_components = external_components or set()
-        self._idedata = idedata
-
-        # Derive nm path from objdump path using shared toolchain utility
-        self.nm_path = find_tool("nm", self.objdump_path)
 
         self.sections: dict[str, MemorySection] = {}
         self.components: dict[str, ComponentMemory] = defaultdict(
@@ -149,25 +128,15 @@ class MemoryAnalyzer:
         self._esphome_core_symbols: list[
             tuple[str, str, int]
         ] = []  # Track core symbols
-        # Track symbols for all components: (symbol_name, demangled, size, section)
-        self._component_symbols: dict[str, list[tuple[str, str, int, str]]] = (
-            defaultdict(list)
-        )
-        # Track RAM symbols separately for detailed analysis: (symbol_name, demangled, size, section)
-        self._ram_symbols: dict[str, list[tuple[str, str, int, str]]] = defaultdict(
+        self._component_symbols: dict[str, list[tuple[str, str, int]]] = defaultdict(
             list
-        )
-        # Track ELF symbol names for SDK cross-reference
-        self._elf_symbol_names: set[str] = set()
-        # SDK symbols not in ELF (static/local symbols from closed-source libs)
-        self._sdk_symbols: list[SDKSymbol] = []
+        )  # Track symbols for all components
 
     def analyze(self) -> dict[str, ComponentMemory]:
         """Analyze the ELF file and return component memory usage."""
         self._parse_sections()
         self._parse_symbols()
         self._categorize_symbols()
-        self._analyze_sdk_libraries()
         return dict(self.components)
 
     def _parse_sections(self) -> None:
@@ -221,8 +190,6 @@ class MemoryAnalyzer:
                 continue
 
             self.sections[section].symbols.append((name, size, ""))
-            self.sections[section].symbol_size += size
-            self._elf_symbol_names.add(name)
             seen_addresses.add(address)
 
     def _categorize_symbols(self) -> None:
@@ -266,13 +233,8 @@ class MemoryAnalyzer:
                 if size > 0:
                     demangled = self._demangle_symbol(symbol_name)
                     self._component_symbols[component].append(
-                        (symbol_name, demangled, size, section_name)
+                        (symbol_name, demangled, size)
                     )
-                    # Track RAM symbols separately for detailed RAM analysis
-                    if section_name in RAM_SECTIONS:
-                        self._ram_symbols[component].append(
-                            (symbol_name, demangled, size, section_name)
-                        )
 
     def _identify_component(self, symbol_name: str) -> str:
         """Identify which component a symbol belongs to."""
@@ -366,247 +328,6 @@ class MemoryAnalyzer:
 
         return "Other Core"
 
-    def get_unattributed_ram(self) -> tuple[int, int, int]:
-        """Get unattributed RAM sizes (SDK/framework overhead).
-
-        Returns:
-            Tuple of (unattributed_bss, unattributed_data, total_unattributed)
-            These are bytes in RAM sections that have no corresponding symbols.
-        """
-        bss_section = self.sections.get(".bss")
-        data_section = self.sections.get(".data")
-
-        unattributed_bss = 0
-        unattributed_data = 0
-
-        if bss_section:
-            unattributed_bss = max(0, bss_section.total_size - bss_section.symbol_size)
-        if data_section:
-            unattributed_data = max(
-                0, data_section.total_size - data_section.symbol_size
-            )
-
-        return unattributed_bss, unattributed_data, unattributed_bss + unattributed_data
-
-    def _find_sdk_library_dirs(self) -> list[Path]:
-        """Find SDK library directories based on platform.
-
-        Returns:
-            List of paths to SDK library directories containing .a files.
-        """
-        sdk_dirs: list[Path] = []
-
-        if self._idedata is None:
-            return sdk_dirs
-
-        # Get the CC path to determine the framework location
-        cc_path = getattr(self._idedata, "cc_path", None)
-        if not cc_path:
-            return sdk_dirs
-
-        cc_path = Path(cc_path)
-
-        # For ESP8266 Arduino framework
-        # CC is like: ~/.platformio/packages/toolchain-xtensa/bin/xtensa-lx106-elf-gcc
-        # SDK libs are in: ~/.platformio/packages/framework-arduinoespressif8266/tools/sdk/lib/
-        if "xtensa-lx106" in str(cc_path):
-            platformio_dir = cc_path.parent.parent.parent
-            esp8266_sdk = (
-                platformio_dir
-                / "framework-arduinoespressif8266"
-                / "tools"
-                / "sdk"
-                / "lib"
-            )
-            if esp8266_sdk.exists():
-                sdk_dirs.append(esp8266_sdk)
-                # Also check for NONOSDK subdirectories (closed-source libs)
-                sdk_dirs.extend(
-                    subdir
-                    for subdir in esp8266_sdk.iterdir()
-                    if subdir.is_dir() and subdir.name.startswith("NONOSDK")
-                )
-
-        # For ESP32 IDF framework
-        # CC is like: ~/.platformio/packages/toolchain-xtensa-esp-elf/bin/xtensa-esp32-elf-gcc
-        # or: ~/.platformio/packages/toolchain-riscv32-esp/bin/riscv32-esp-elf-gcc
-        elif "xtensa-esp" in str(cc_path) or "riscv32-esp" in str(cc_path):
-            # Detect ESP32 variant from CC path or defines
-            variant = self._detect_esp32_variant()
-            if variant:
-                platformio_dir = cc_path.parent.parent.parent
-                espidf_dir = platformio_dir / "framework-espidf" / "components"
-                if espidf_dir.exists():
-                    # Find all directories named after the variant that contain .a files
-                    # This handles various ESP-IDF library layouts:
-                    # - components/*/lib/<variant>/
-                    # - components/*/<variant>/
-                    # - components/*/lib/lib/<variant>/
-                    # - components/*/*/lib_*/<variant>/
-                    sdk_dirs.extend(
-                        variant_dir
-                        for variant_dir in espidf_dir.rglob(variant)
-                        if variant_dir.is_dir() and any(variant_dir.glob("*.a"))
-                    )
-
-        return sdk_dirs
-
-    def _detect_esp32_variant(self) -> str | None:
-        """Detect ESP32 variant from idedata defines.
-
-        Returns:
-            Variant string like 'esp32', 'esp32s2', 'esp32c3', etc. or None.
-        """
-        if self._idedata is None:
-            return None
-
-        defines = getattr(self._idedata, "defines", [])
-        if not defines:
-            return None
-
-        # ESPHome always adds USE_ESP32_VARIANT_xxx defines
-        variant_prefix = "USE_ESP32_VARIANT_"
-        for define in defines:
-            if define.startswith(variant_prefix):
-                # Extract variant name and convert to lowercase
-                # USE_ESP32_VARIANT_ESP32 -> esp32
-                # USE_ESP32_VARIANT_ESP32S3 -> esp32s3
-                return define[len(variant_prefix) :].lower()
-
-        return None
-
-    def _parse_sdk_library(
-        self, lib_path: Path
-    ) -> tuple[list[tuple[str, int, str, bool]], set[str]]:
-        """Parse a single SDK library for symbols.
-
-        Args:
-            lib_path: Path to the .a library file
-
-        Returns:
-            Tuple of:
-            - List of BSS/DATA symbols: (symbol_name, size, section, is_local)
-            - Set of global BSS/DATA symbol names (for checking if RAM is linked)
-        """
-        ram_symbols: list[tuple[str, int, str, bool]] = []
-        global_ram_symbols: set[str] = set()
-
-        result = run_tool([self.nm_path, "--size-sort", str(lib_path)], timeout=10)
-        if result is None:
-            return ram_symbols, global_ram_symbols
-
-        for line in result.stdout.splitlines():
-            parts = line.split()
-            if len(parts) < 3:
-                continue
-
-            try:
-                size = int(parts[0], 16)
-                sym_type = parts[1]
-                name = parts[2]
-
-                # Only collect BSS (b/B) and DATA (d/D) for RAM analysis
-                if sym_type in ("b", "B"):
-                    section = ".bss"
-                    is_local = sym_type == "b"
-                    ram_symbols.append((name, size, section, is_local))
-                    # Track global RAM symbols (B/D) for linking check
-                    if sym_type == "B":
-                        global_ram_symbols.add(name)
-                elif sym_type in ("d", "D"):
-                    section = ".data"
-                    is_local = sym_type == "d"
-                    ram_symbols.append((name, size, section, is_local))
-                    if sym_type == "D":
-                        global_ram_symbols.add(name)
-            except (ValueError, IndexError):
-                continue
-
-        return ram_symbols, global_ram_symbols
-
-    def _analyze_sdk_libraries(self) -> None:
-        """Analyze SDK libraries to find symbols not in the ELF.
-
-        This finds static/local symbols from closed-source SDK libraries
-        that consume RAM but don't appear in the final ELF symbol table.
-        Only includes symbols from libraries that have RAM actually linked
-        (at least one global BSS/DATA symbol in the ELF).
-        """
-        sdk_dirs = self._find_sdk_library_dirs()
-        if not sdk_dirs:
-            _LOGGER.debug("No SDK library directories found")
-            return
-
-        _LOGGER.debug("Analyzing SDK libraries in %d directories", len(sdk_dirs))
-
-        # Track seen symbols to avoid duplicates from multiple SDK versions
-        seen_symbols: set[str] = set()
-
-        for sdk_dir in sdk_dirs:
-            for lib_path in sorted(sdk_dir.glob("*.a")):
-                lib_name = lib_path.name
-                ram_symbols, global_ram_symbols = self._parse_sdk_library(lib_path)
-
-                # Check if this library's RAM is actually linked by seeing if any
-                # of its global BSS/DATA symbols appear in the ELF
-                if not global_ram_symbols & self._elf_symbol_names:
-                    # No RAM from this library is in the ELF - skip it
-                    continue
-
-                for name, size, section, is_local in ram_symbols:
-                    # Skip if already in ELF or already seen from another lib
-                    if name in self._elf_symbol_names or name in seen_symbols:
-                        continue
-
-                    # Only track symbols with non-zero size
-                    if size > 0:
-                        self._sdk_symbols.append(
-                            SDKSymbol(
-                                name=name,
-                                size=size,
-                                library=lib_name,
-                                section=section,
-                                is_local=is_local,
-                            )
-                        )
-                        seen_symbols.add(name)
-
-        # Demangle SDK symbols for better readability
-        if self._sdk_symbols:
-            sdk_names = [sym.name for sym in self._sdk_symbols]
-            demangled_map = batch_demangle(sdk_names, objdump_path=self.objdump_path)
-            for sym in self._sdk_symbols:
-                sym.demangled = demangled_map.get(sym.name, sym.name)
-
-        # Sort by size descending for reporting
-        self._sdk_symbols.sort(key=lambda s: s.size, reverse=True)
-
-        total_sdk_ram = sum(s.size for s in self._sdk_symbols)
-        _LOGGER.debug(
-            "Found %d SDK symbols not in ELF, totaling %d bytes",
-            len(self._sdk_symbols),
-            total_sdk_ram,
-        )
-
-    def get_sdk_ram_symbols(self) -> list[SDKSymbol]:
-        """Get SDK symbols that consume RAM but aren't in the ELF symbol table.
-
-        Returns:
-            List of SDKSymbol objects sorted by size descending.
-        """
-        return self._sdk_symbols
-
-    def get_sdk_ram_by_library(self) -> dict[str, list[SDKSymbol]]:
-        """Get SDK RAM symbols grouped by library.
-
-        Returns:
-            Dictionary mapping library name to list of symbols.
-        """
-        by_lib: dict[str, list[SDKSymbol]] = defaultdict(list)
-        for sym in self._sdk_symbols:
-            by_lib[sym.library].append(sym)
-        return dict(by_lib)
-
 
 if __name__ == "__main__":
     from .cli import main

esphome/analyze_memory/cli.py

@@ -1,24 +1,16 @@
 """CLI interface for memory analysis with report generation."""
 
-from __future__ import annotations
-
 from collections import defaultdict
-from collections.abc import Callable
 import sys
-from typing import TYPE_CHECKING
 
 from . import (
     _COMPONENT_API,
     _COMPONENT_CORE,
     _COMPONENT_PREFIX_ESPHOME,
     _COMPONENT_PREFIX_EXTERNAL,
-    RAM_SECTIONS,
     MemoryAnalyzer,
 )
 
-if TYPE_CHECKING:
-    from . import ComponentMemory
-
 
 class MemoryAnalyzerCLI(MemoryAnalyzer):
     """Memory analyzer with CLI-specific report generation."""
@@ -27,8 +19,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
     SYMBOL_SIZE_THRESHOLD: int = (
         100  # Show symbols larger than this in detailed analysis
     )
-    # Lower threshold for RAM symbols (RAM is more constrained)
-    RAM_SYMBOL_SIZE_THRESHOLD: int = 24
 
     # Column width constants
     COL_COMPONENT: int = 29
@@ -93,60 +83,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
         COL_CORE_PERCENT,
     )
 
-    def _add_section_header(self, lines: list[str], title: str) -> None:
-        """Add a section header with title centered between separator lines."""
-        lines.append("")
-        lines.append("=" * self.TABLE_WIDTH)
-        lines.append(title.center(self.TABLE_WIDTH))
-        lines.append("=" * self.TABLE_WIDTH)
-        lines.append("")
-
-    def _add_top_consumers(
-        self,
-        lines: list[str],
-        title: str,
-        components: list[tuple[str, ComponentMemory]],
-        get_size: Callable[[ComponentMemory], int],
-        total: int,
-        memory_type: str,
-        limit: int = 25,
-    ) -> None:
-        """Add a formatted list of top memory consumers to the report.
-
-        Args:
-            lines: List of report lines to append the output to.
-            title: Section title to print before the list.
-            components: Sequence of (name, ComponentMemory) tuples to analyze.
-            get_size: Callable that takes a ComponentMemory and returns the
-                size in bytes to use for ranking and display.
-            total: Total size in bytes for computing percentage usage.
-            memory_type: Label for the memory region (e.g., "flash" or "RAM").
-            limit: Maximum number of components to include in the list.
-        """
-        lines.append("")
-        lines.append(f"{title}:")
-        for i, (name, mem) in enumerate(components[:limit]):
-            size = get_size(mem)
-            if size > 0:
-                percentage = (size / total * 100) if total > 0 else 0
-                lines.append(
-                    f"{i + 1}. {name} ({size:,} B) - {percentage:.1f}% of analyzed {memory_type}"
-                )
-
-    def _format_symbol_with_section(
-        self, demangled: str, size: int, section: str | None = None
-    ) -> str:
-        """Format a symbol entry, optionally adding a RAM section label.
-
-        If section is one of the RAM sections (.data or .bss), a label like
-        " [data]" or " [bss]" is appended. For non-RAM sections or when
-        section is None, no section label is added.
-        """
-        section_label = ""
-        if section in RAM_SECTIONS:
-            section_label = f" [{section[1:]}]"  # .data -> [data], .bss -> [bss]
-        return f"{demangled} ({size:,} B){section_label}"
-
     def generate_report(self, detailed: bool = False) -> str:
         """Generate a formatted memory report."""
         components = sorted(
@@ -187,70 +123,43 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
             f"{total_flash:>{self.COL_TOTAL_FLASH - 2},} B | {total_ram:>{self.COL_TOTAL_RAM - 2},} B"
         )
 
-        # Show unattributed RAM (SDK/framework overhead)
-        unattributed_bss, unattributed_data, unattributed_total = (
-            self.get_unattributed_ram()
-        )
-        if unattributed_total > 0:
-            lines.append("")
-            lines.append(
-                f"Unattributed RAM: {unattributed_total:,} B (SDK/framework overhead)"
-            )
-            if unattributed_bss > 0 and unattributed_data > 0:
+        # Top consumers
+        lines.append("")
+        lines.append("Top Flash Consumers:")
+        for i, (name, mem) in enumerate(components[:25]):
+            if mem.flash_total > 0:
+                percentage = (
+                    (mem.flash_total / total_flash * 100) if total_flash > 0 else 0
+                )
                 lines.append(
-                    f"  .bss: {unattributed_bss:,} B | .data: {unattributed_data:,} B"
+                    f"{i + 1}. {name} ({mem.flash_total:,} B) - {percentage:.1f}% of analyzed flash"
                 )
 
-            # Show SDK symbol breakdown if available
-            sdk_by_lib = self.get_sdk_ram_by_library()
-            if sdk_by_lib:
-                lines.append("")
-                lines.append("SDK library breakdown (static symbols not in ELF):")
-                # Sort libraries by total size
-                lib_totals = [
-                    (lib, sum(s.size for s in syms), syms)
-                    for lib, syms in sdk_by_lib.items()
-                ]
-                lib_totals.sort(key=lambda x: x[1], reverse=True)
-
-                for lib_name, lib_total, syms in lib_totals:
-                    if lib_total == 0:
-                        continue
-                    lines.append(f"  {lib_name}: {lib_total:,} B")
-                    # Show top symbols from this library
-                    for sym in sorted(syms, key=lambda s: s.size, reverse=True)[:3]:
-                        section_label = sym.section.lstrip(".")
-                        # Use demangled name (falls back to original if not demangled)
-                        display_name = sym.demangled or sym.name
-                        if len(display_name) > 50:
-                            display_name = f"{display_name[:47]}..."
-                        lines.append(
-                            f"    {sym.size:>6,} B [{section_label}] {display_name}"
-                        )
-
-        # Top consumers
-        self._add_top_consumers(
-            lines,
-            "Top Flash Consumers",
-            components,
-            lambda m: m.flash_total,
-            total_flash,
-            "flash",
-        )
-
+        lines.append("")
+        lines.append("Top RAM Consumers:")
         ram_components = sorted(components, key=lambda x: x[1].ram_total, reverse=True)
-        self._add_top_consumers(
-            lines,
-            "Top RAM Consumers",
-            ram_components,
-            lambda m: m.ram_total,
-            total_ram,
-            "RAM",
+        for i, (name, mem) in enumerate(ram_components[:25]):
+            if mem.ram_total > 0:
+                percentage = (mem.ram_total / total_ram * 100) if total_ram > 0 else 0
+                lines.append(
+                    f"{i + 1}. {name} ({mem.ram_total:,} B) - {percentage:.1f}% of analyzed RAM"
+                )
+
+        lines.append("")
+        lines.append(
+            "Note: This analysis covers symbols in the ELF file. Some runtime allocations may not be included."
         )
+        lines.append("=" * self.TABLE_WIDTH)
 
         # Add ESPHome core detailed analysis if there are core symbols
         if self._esphome_core_symbols:
-            self._add_section_header(lines, f"{_COMPONENT_CORE} Detailed Analysis")
+            lines.append("")
+            lines.append("=" * self.TABLE_WIDTH)
+            lines.append(
+                f"{_COMPONENT_CORE} Detailed Analysis".center(self.TABLE_WIDTH)
+            )
+            lines.append("=" * self.TABLE_WIDTH)
+            lines.append("")
 
             # Group core symbols by subcategory
             core_subcategories: dict[str, list[tuple[str, str, int]]] = defaultdict(
@@ -302,11 +211,7 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 f"{_COMPONENT_CORE} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_core_symbols)} symbols):"
             )
             for i, (symbol, demangled, size) in enumerate(large_core_symbols):
-                # Core symbols only track (symbol, demangled, size) without section info,
-                # so we don't show section labels here
-                lines.append(
-                    f"{i + 1}. {self._format_symbol_with_section(demangled, size)}"
-                )
+                lines.append(f"{i + 1}. {demangled} ({size:,} B)")
 
             lines.append("=" * self.TABLE_WIDTH)
 
@@ -362,7 +267,11 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
             for comp_name, comp_mem in components_to_analyze:
                 if not (comp_symbols := self._component_symbols.get(comp_name, [])):
                     continue
-                self._add_section_header(lines, f"{comp_name} Detailed Analysis")
+                lines.append("")
+                lines.append("=" * self.TABLE_WIDTH)
+                lines.append(f"{comp_name} Detailed Analysis".center(self.TABLE_WIDTH))
+                lines.append("=" * self.TABLE_WIDTH)
+                lines.append("")
 
                 # Sort symbols by size
                 sorted_symbols = sorted(comp_symbols, key=lambda x: x[2], reverse=True)
@@ -373,69 +282,19 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
                 # Show all symbols above threshold for better visibility
                 large_symbols = [
-                    (sym, dem, size, sec)
-                    for sym, dem, size, sec in sorted_symbols
+                    (sym, dem, size)
+                    for sym, dem, size in sorted_symbols
                     if size > self.SYMBOL_SIZE_THRESHOLD
                 ]
 
                 lines.append(
                     f"{comp_name} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_symbols)} symbols):"
                 )
-                for i, (symbol, demangled, size, section) in enumerate(large_symbols):
-                    lines.append(
-                        f"{i + 1}. {self._format_symbol_with_section(demangled, size, section)}"
-                    )
+                for i, (symbol, demangled, size) in enumerate(large_symbols):
+                    lines.append(f"{i + 1}. {demangled} ({size:,} B)")
 
                 lines.append("=" * self.TABLE_WIDTH)
 
-        # Detailed RAM analysis by component (at end, before RAM strings analysis)
-        self._add_section_header(lines, "RAM Symbol Analysis by Component")
-
-        # Show top 15 RAM consumers with their large symbols
-        for name, mem in ram_components[:15]:
-            if mem.ram_total == 0:
-                continue
-            ram_syms = self._ram_symbols.get(name, [])
-            if not ram_syms:
-                continue
-
-            # Sort by size descending
-            sorted_ram_syms = sorted(ram_syms, key=lambda x: x[2], reverse=True)
-            large_ram_syms = [
-                s for s in sorted_ram_syms if s[2] > self.RAM_SYMBOL_SIZE_THRESHOLD
-            ]
-
-            lines.append(f"{name} ({mem.ram_total:,} B total RAM):")
-
-            # Show breakdown by section type
-            data_size = sum(s[2] for s in ram_syms if s[3] == ".data")
-            bss_size = sum(s[2] for s in ram_syms if s[3] == ".bss")
-            lines.append(f"  .data (initialized): {data_size:,} B")
-            lines.append(f"  .bss (uninitialized): {bss_size:,} B")
-
-            if large_ram_syms:
-                lines.append(
-                    f"  Symbols > {self.RAM_SYMBOL_SIZE_THRESHOLD} B ({len(large_ram_syms)}):"
-                )
-                for symbol, demangled, size, section in large_ram_syms[:10]:
-                    # Format section label consistently by stripping leading dot
-                    section_label = section.lstrip(".") if section else ""
-                    # Add ellipsis if name is truncated
-                    demangled_display = (
-                        f"{demangled[:70]}..." if len(demangled) > 70 else demangled
-                    )
-                    lines.append(
-                        f"    {size:>6,} B [{section_label}] {demangled_display}"
-                    )
-                if len(large_ram_syms) > 10:
-                    lines.append(f"    ... and {len(large_ram_syms) - 10} more")
-            lines.append("")
-
-        lines.append(
-            "Note: This analysis covers symbols in the ELF file. Some runtime allocations may not be included."
-        )
-        lines.append("=" * self.TABLE_WIDTH)
-
         return "\n".join(lines)
 
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:

esphome/analyze_memory/const.py

@@ -7,13 +7,11 @@ ESPHOME_COMPONENT_PATTERN = re.compile(r"esphome::([a-zA-Z0-9_]+)::")
 
 # Section mapping for ELF file sections
 # Maps standard section names to their various platform-specific variants
-# Note: Order matters! More specific patterns (.bss) must come before general ones (.dram)
-# because ESP-IDF uses names like ".dram0.bss" which would match ".dram" otherwise
 SECTION_MAPPING = {
     ".text": frozenset([".text", ".iram"]),
     ".rodata": frozenset([".rodata"]),
-    ".bss": frozenset([".bss"]),  # Must be before .data to catch ".dram0.bss"
     ".data": frozenset([".data", ".dram"]),
+    ".bss": frozenset([".bss"]),
 }
 
 # Section to ComponentMemory attribute mapping
@@ -90,77 +88,6 @@ SYMBOL_PATTERNS = {
         "sys_mbox_new",
         "sys_arch_mbox_tryfetch",
     ],
-    # LibreTiny/Beken BK7231 radio calibration
-    "bk_radio_cal": [
-        "bk7011_",
-        "calibration_main",
-        "gcali_",
-        "rwnx_cal",
-    ],
-    # LibreTiny/Beken WiFi MAC layer
-    "bk_wifi_mac": [
-        "rxu_",  # RX upper layer
-        "txu_",  # TX upper layer
-        "txl_",  # TX lower layer
-        "rxl_",  # RX lower layer
-        "scanu_",  # Scan unit
-        "mm_hw_",  # MAC management hardware
-        "mm_bcn",  # MAC management beacon
-        "mm_tim",  # MAC management TIM
-        "mm_check",  # MAC management checks
-        "sm_connect",  # Station management
-        "me_beacon",  # Management entity beacon
-        "me_build",  # Management entity build
-        "hapd_",  # Host AP daemon
-        "chan_pre_",  # Channel management
-        "handle_probe_",  # Probe handling
-    ],
-    # LibreTiny/Beken system control
-    "bk_system": [
-        "sctrl_",  # System control
-        "icu_ctrl",  # Interrupt control unit
-        "gdma_ctrl",  # DMA control
-        "mpb_ctrl",  # MPB control
-        "uf2_",  # UF2 OTA
-        "bkreg_",  # Beken registers
-    ],
-    # LibreTiny/Beken BLE stack
-    "bk_ble": [
-        "gapc_",  # GAP client
-        "gattc_",  # GATT client
-        "attc_",  # ATT client
-        "attmdb_",  # ATT database
-        "atts_",  # ATT server
-        "l2cc_",  # L2CAP
-        "prf_env",  # Profile environment
-    ],
-    # LibreTiny/Beken scheduler
-    "bk_scheduler": [
-        "sch_plan_",  # Scheduler plan
-        "sch_prog_",  # Scheduler program
-        "sch_arb_",  # Scheduler arbiter
-    ],
-    # LibreTiny/Beken DMA descriptors
-    "bk_dma": [
-        "rx_payload_desc",
-        "rx_dma_hdrdesc",
-        "tx_hw_desc",
-        "host_event_data",
-        "host_cmd_data",
-    ],
-    # ARM EABI compiler runtime (LibreTiny uses ARM Cortex-M)
-    "arm_runtime": [
-        "__aeabi_",
-        "__adddf3",
-        "__subdf3",
-        "__muldf3",
-        "__divdf3",
-        "__addsf3",
-        "__subsf3",
-        "__mulsf3",
-        "__divsf3",
-        "__gnu_unwind",
-    ],
     "xtensa": ["xt_", "_xt_", "xPortEnterCriticalTimeout"],
     "heap": ["heap_", "multi_heap"],
     "spi_flash": ["spi_flash"],
@@ -855,22 +782,7 @@ SYMBOL_PATTERNS = {
     "math_internal": ["__mdiff", "__lshift", "__mprec_tens", "quorem"],
     "character_class": ["__chclass"],
     "camellia": ["camellia_", "camellia_feistel"],
-    "crypto_tables": [
-        "FSb",
-        "FSb2",
-        "FSb3",
-        "FSb4",
-        "Te0",  # AES encryption table
-        "Td0",  # AES decryption table
-        "crc32_table",  # CRC32 lookup table
-        "crc_tab",  # CRC lookup table
-    ],
-    "crypto_hash": [
-        "SHA1Transform",  # SHA1 hash function
-        "MD5Transform",  # MD5 hash function
-        "SHA256",
-        "SHA512",
-    ],
+    "crypto_tables": ["FSb", "FSb2", "FSb3", "FSb4"],
     "event_buffer": ["g_eb_list_desc", "eb_space"],
     "base_node": ["base_node_", "base_node_add_handler"],
     "file_descriptor": ["s_fd_table"],

esphome/analyze_memory/toolchain.py

@@ -5,10 +5,6 @@ from __future__ import annotations
 import logging
 from pathlib import Path
 import subprocess
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from collections.abc import Sequence
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -59,35 +55,3 @@ def find_tool(
 
     _LOGGER.warning("Could not find %s tool", tool_name)
     return None
-
-
-def run_tool(
-    cmd: Sequence[str],
-    timeout: int = 30,
-) -> subprocess.CompletedProcess[str] | None:
-    """Run a toolchain command and return the result.
-
-    Args:
-        cmd: Command and arguments to run
-        timeout: Timeout in seconds
-
-    Returns:
-        CompletedProcess on success, None on failure
-    """
-    try:
-        return subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-            check=False,
-        )
-    except subprocess.TimeoutExpired:
-        _LOGGER.warning("Command timed out: %s", " ".join(cmd))
-        return None
-    except FileNotFoundError:
-        _LOGGER.warning("Command not found: %s", cmd[0])
-        return None
-    except OSError as e:
-        _LOGGER.warning("Failed to run command %s: %s", cmd[0], e)
-        return None

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -1,3 +1,5 @@
+#ifdef USE_ARDUINO
+
 #include "ac_dimmer.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -7,12 +9,12 @@
 #ifdef USE_ESP8266
 #include <core_esp8266_waveform.h>
 #endif
-
-#ifdef USE_ESP32
-#include "hw_timer_esp_idf.h"
+#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+#include <esp32-hal-timer.h>
 #endif
 
-namespace esphome::ac_dimmer {
+namespace esphome {
+namespace ac_dimmer {
 
 static const char *const TAG = "ac_dimmer";
 
@@ -25,14 +27,7 @@ static AcDimmerDataStore *all_dimmers[32];  // NOLINT(cppcoreguidelines-avoid-no
 /// However other factors like gate driver propagation time
 /// are also considered and a really low value is not important
 /// See also: https://github.com/esphome/issues/issues/1632
-static constexpr uint32_t GATE_ENABLE_TIME = 50;
-
-#ifdef USE_ESP32
-/// Timer frequency in Hz (1 MHz = 1µs resolution)
-static constexpr uint32_t TIMER_FREQUENCY_HZ = 1000000;
-/// Timer interrupt interval in microseconds
-static constexpr uint64_t TIMER_INTERVAL_US = 50;
-#endif
+static const uint32_t GATE_ENABLE_TIME = 50;
 
 /// Function called from timer interrupt
 /// Input is current time in microseconds (micros())
@@ -159,7 +154,7 @@ void IRAM_ATTR HOT AcDimmerDataStore::s_gpio_intr(AcDimmerDataStore *store) {
 #ifdef USE_ESP32
 // ESP32 implementation, uses basically the same code but needs to wrap
 // timer_interrupt() function to auto-reschedule
-static HWTimer *dimmer_timer = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static hw_timer_t *dimmer_timer = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 void IRAM_ATTR HOT AcDimmerDataStore::s_timer_intr() { timer_interrupt(); }
 #endif
 
@@ -199,15 +194,15 @@ void AcDimmer::setup() {
   setTimer1Callback(&timer_interrupt);
 #endif
 #ifdef USE_ESP32
-  dimmer_timer = timer_begin(TIMER_FREQUENCY_HZ);
-  timer_attach_interrupt(dimmer_timer, &AcDimmerDataStore::s_timer_intr);
+  // timer frequency of 1mhz
+  dimmer_timer = timerBegin(1000000);
+  timerAttachInterrupt(dimmer_timer, &AcDimmerDataStore::s_timer_intr);
   // For ESP32, we can't use dynamic interval calculation because the timerX functions
   // are not callable from ISR (placed in flash storage).
   // Here we just use an interrupt firing every 50 µs.
-  timer_alarm(dimmer_timer, TIMER_INTERVAL_US, true, 0);
+  timerAlarm(dimmer_timer, 50, true, 0);
 #endif
 }
-
 void AcDimmer::write_state(float state) {
   state = std::acos(1 - (2 * state)) / std::numbers::pi;  // RMS power compensation
   auto new_value = static_cast<uint16_t>(roundf(state * 65535));
@@ -215,7 +210,6 @@ void AcDimmer::write_state(float state) {
     this->store_.init_cycle = this->init_with_half_cycle_;
   this->store_.value = new_value;
 }
-
 void AcDimmer::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "AcDimmer:\n"
@@ -236,4 +230,7 @@ void AcDimmer::dump_config() {
   ESP_LOGV(TAG, "  Estimated Frequency: %.3fHz", 1e6f / this->store_.cycle_time_us / 2);
 }
 
-}  // namespace esphome::ac_dimmer
+}  // namespace ac_dimmer
+}  // namespace esphome
+
+#endif  // USE_ARDUINO

esphome/components/ac_dimmer/ac_dimmer.h

@@ -1,10 +1,13 @@
 #pragma once
 
+#ifdef USE_ARDUINO
+
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/components/output/float_output.h"
 
-namespace esphome::ac_dimmer {
+namespace esphome {
+namespace ac_dimmer {
 
 enum DimMethod { DIM_METHOD_LEADING_PULSE = 0, DIM_METHOD_LEADING, DIM_METHOD_TRAILING };
 
@@ -61,4 +64,7 @@ class AcDimmer : public output::FloatOutput, public Component {
   DimMethod method_;
 };
 
-}  // namespace esphome::ac_dimmer
+}  // namespace ac_dimmer
+}  // namespace esphome
+
+#endif  // USE_ARDUINO

esphome/components/ac_dimmer/hw_timer_esp_idf.cpp

@@ -1,152 +0,0 @@
-#ifdef USE_ESP32
-
-#include "hw_timer_esp_idf.h"
-
-#include "freertos/FreeRTOS.h"
-#include "esphome/core/log.h"
-
-#include "driver/gptimer.h"
-#include "esp_clk_tree.h"
-#include "soc/clk_tree_defs.h"
-
-static const char *const TAG = "hw_timer_esp_idf";
-
-namespace esphome::ac_dimmer {
-
-// GPTimer divider constraints from ESP-IDF documentation
-static constexpr uint32_t GPTIMER_DIVIDER_MIN = 2;
-static constexpr uint32_t GPTIMER_DIVIDER_MAX = 65536;
-
-using voidFuncPtr = void (*)();
-using voidFuncPtrArg = void (*)(void *);
-
-struct InterruptConfigT {
-  voidFuncPtr fn{nullptr};
-  void *arg{nullptr};
-};
-
-struct HWTimer {
-  gptimer_handle_t timer_handle{nullptr};
-  InterruptConfigT interrupt_handle{};
-  bool timer_started{false};
-};
-
-HWTimer *timer_begin(uint32_t frequency) {
-  esp_err_t err = ESP_OK;
-  uint32_t counter_src_hz = 0;
-  uint32_t divider = 0;
-  soc_module_clk_t clk;
-  for (auto clk_candidate : SOC_GPTIMER_CLKS) {
-    clk = clk_candidate;
-    esp_clk_tree_src_get_freq_hz(clk, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &counter_src_hz);
-    divider = counter_src_hz / frequency;
-    if ((divider >= GPTIMER_DIVIDER_MIN) && (divider <= GPTIMER_DIVIDER_MAX)) {
-      break;
-    } else {
-      divider = 0;
-    }
-  }
-
-  if (divider == 0) {
-    ESP_LOGE(TAG, "Resolution not possible; aborting");
-    return nullptr;
-  }
-
-  gptimer_config_t config = {
-      .clk_src = static_cast<gptimer_clock_source_t>(clk),
-      .direction = GPTIMER_COUNT_UP,
-      .resolution_hz = frequency,
-      .flags = {.intr_shared = true},
-  };
-
-  HWTimer *timer = new HWTimer();
-
-  err = gptimer_new_timer(&config, &timer->timer_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "GPTimer creation failed; error %d", err);
-    delete timer;
-    return nullptr;
-  }
-
-  err = gptimer_enable(timer->timer_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "GPTimer enable failed; error %d", err);
-    gptimer_del_timer(timer->timer_handle);
-    delete timer;
-    return nullptr;
-  }
-
-  err = gptimer_start(timer->timer_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "GPTimer start failed; error %d", err);
-    gptimer_disable(timer->timer_handle);
-    gptimer_del_timer(timer->timer_handle);
-    delete timer;
-    return nullptr;
-  }
-
-  timer->timer_started = true;
-  return timer;
-}
-
-bool IRAM_ATTR timer_fn_wrapper(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *args) {
-  auto *isr = static_cast<InterruptConfigT *>(args);
-  if (isr->fn) {
-    if (isr->arg) {
-      reinterpret_cast<voidFuncPtrArg>(isr->fn)(isr->arg);
-    } else {
-      isr->fn();
-    }
-  }
-  // Return false to indicate that no higher-priority task was woken and no context switch is requested.
-  return false;
-}
-
-static void timer_attach_interrupt_functional_arg(HWTimer *timer, void (*user_func)(void *), void *arg) {
-  if (timer == nullptr) {
-    ESP_LOGE(TAG, "Timer handle is nullptr");
-    return;
-  }
-  gptimer_event_callbacks_t cbs = {
-      .on_alarm = timer_fn_wrapper,
-  };
-
-  timer->interrupt_handle.fn = reinterpret_cast<voidFuncPtr>(user_func);
-  timer->interrupt_handle.arg = arg;
-
-  if (timer->timer_started) {
-    gptimer_stop(timer->timer_handle);
-  }
-  gptimer_disable(timer->timer_handle);
-  esp_err_t err = gptimer_register_event_callbacks(timer->timer_handle, &cbs, &timer->interrupt_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Timer Attach Interrupt failed; error %d", err);
-  }
-  gptimer_enable(timer->timer_handle);
-  if (timer->timer_started) {
-    gptimer_start(timer->timer_handle);
-  }
-}
-
-void timer_attach_interrupt(HWTimer *timer, voidFuncPtr user_func) {
-  timer_attach_interrupt_functional_arg(timer, reinterpret_cast<voidFuncPtrArg>(user_func), nullptr);
-}
-
-void timer_alarm(HWTimer *timer, uint64_t alarm_value, bool autoreload, uint64_t reload_count) {
-  if (timer == nullptr) {
-    ESP_LOGE(TAG, "Timer handle is nullptr");
-    return;
-  }
-  gptimer_alarm_config_t alarm_cfg = {
-      .alarm_count = alarm_value,
-      .reload_count = reload_count,
-      .flags = {.auto_reload_on_alarm = autoreload},
-  };
-  esp_err_t err = gptimer_set_alarm_action(timer->timer_handle, &alarm_cfg);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Timer Alarm Write failed; error %d", err);
-  }
-}
-
-}  // namespace esphome::ac_dimmer
-#endif

esphome/components/ac_dimmer/hw_timer_esp_idf.h

@@ -1,17 +0,0 @@
-#pragma once
-#ifdef USE_ESP32
-
-#include "driver/gptimer_types.h"
-
-namespace esphome::ac_dimmer {
-
-struct HWTimer;
-
-HWTimer *timer_begin(uint32_t frequency);
-
-void timer_attach_interrupt(HWTimer *timer, void (*user_func)());
-void timer_alarm(HWTimer *timer, uint64_t alarm_value, bool autoreload, uint64_t reload_count);
-
-}  // namespace esphome::ac_dimmer
-
-#endif

esphome/components/ac_dimmer/output.py

@@ -32,6 +32,7 @@ CONFIG_SCHEMA = cv.All(
             ),
         }
     ).extend(cv.COMPONENT_SCHEMA),
+    cv.only_with_arduino,
 )
 
 

esphome/components/airthings_ble/airthings_listener.cpp

@@ -20,8 +20,7 @@ bool AirthingsListener::parse_device(const esp32_ble_tracker::ESPBTDevice &devic
       sn |= ((uint32_t) it.data[2] << 16);
       sn |= ((uint32_t) it.data[3] << 24);
 
-      char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-      ESP_LOGD(TAG, "Found AirThings device Serial:%" PRIu32 " (MAC: %s)", sn, device.address_str_to(addr_buf));
+      ESP_LOGD(TAG, "Found AirThings device Serial:%" PRIu32 " (MAC: %s)", sn, device.address_str().c_str());
       return true;
     }
   }

esphome/components/airthings_wave_base/airthings_wave_base.cpp

@@ -1,5 +1,4 @@
 #include "airthings_wave_base.h"
-#include "esphome/components/esp32_ble/ble_uuid.h"
 
 // All information related to reading battery information came from the sensors.airthings_wave
 // project by Sverre Hamre (https://github.com/sverrham/sensor.airthings_wave)
@@ -94,10 +93,8 @@ void AirthingsWaveBase::update() {
 bool AirthingsWaveBase::request_read_values_() {
   auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->sensors_data_characteristic_uuid_);
   if (chr == nullptr) {
-    char service_buf[esp32_ble::UUID_STR_LEN];
-    char char_buf[esp32_ble::UUID_STR_LEN];
-    ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_str(service_buf),
-             this->sensors_data_characteristic_uuid_.to_str(char_buf));
+    ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_string().c_str(),
+             this->sensors_data_characteristic_uuid_.to_string().c_str());
     return false;
   }
 
@@ -120,20 +117,17 @@ bool AirthingsWaveBase::request_battery_() {
 
   auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->access_control_point_characteristic_uuid_);
   if (chr == nullptr) {
-    char service_buf[esp32_ble::UUID_STR_LEN];
-    char char_buf[esp32_ble::UUID_STR_LEN];
     ESP_LOGW(TAG, "No access control point characteristic found at service %s char %s",
-             this->service_uuid_.to_str(service_buf), this->access_control_point_characteristic_uuid_.to_str(char_buf));
+             this->service_uuid_.to_string().c_str(),
+             this->access_control_point_characteristic_uuid_.to_string().c_str());
     return false;
   }
 
   auto *descr = this->parent()->get_descriptor(this->service_uuid_, this->access_control_point_characteristic_uuid_,
                                                CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR_UUID);
   if (descr == nullptr) {
-    char service_buf[esp32_ble::UUID_STR_LEN];
-    char char_buf[esp32_ble::UUID_STR_LEN];
-    ESP_LOGW(TAG, "No CCC descriptor found at service %s char %s", this->service_uuid_.to_str(service_buf),
-             this->access_control_point_characteristic_uuid_.to_str(char_buf));
+    ESP_LOGW(TAG, "No CCC descriptor found at service %s char %s", this->service_uuid_.to_string().c_str(),
+             this->access_control_point_characteristic_uuid_.to_string().c_str());
     return false;
   }
 

esphome/components/alpha3/alpha3.h

@@ -15,8 +15,10 @@ namespace alpha3 {
 namespace espbt = esphome::esp32_ble_tracker;
 
 static const espbt::ESPBTUUID ALPHA3_GENI_SERVICE_UUID = espbt::ESPBTUUID::from_uint16(0xfe5d);
-static const espbt::ESPBTUUID ALPHA3_GENI_CHARACTERISTIC_UUID = espbt::ESPBTUUID::from_raw(
-    {0xa9, 0x7b, 0xb8, 0x85, 0x00, 0x1a, 0x28, 0xaa, 0x2a, 0x43, 0x6e, 0x03, 0xd1, 0xff, 0x9c, 0x85});
+static const espbt::ESPBTUUID ALPHA3_GENI_CHARACTERISTIC_UUID =
+    espbt::ESPBTUUID::from_raw({static_cast<char>(0xa9), 0x7b, static_cast<char>(0xb8), static_cast<char>(0x85), 0x0,
+                                0x1a, 0x28, static_cast<char>(0xaa), 0x2a, 0x43, 0x6e, 0x3, static_cast<char>(0xd1),
+                                static_cast<char>(0xff), static_cast<char>(0x9c), static_cast<char>(0x85)});
 static const int16_t GENI_RESPONSE_HEADER_LENGTH = 13;
 static const size_t GENI_RESPONSE_TYPE_LENGTH = 8;
 

esphome/components/api/api.proto

@@ -66,8 +66,6 @@ service APIConnection {
 
   rpc zwave_proxy_frame(ZWaveProxyFrame) returns (void) {}
   rpc zwave_proxy_request(ZWaveProxyRequest) returns (void) {}
-
-  rpc infrared_rf_transmit_raw_timings(InfraredRFTransmitRawTimingsRequest) returns (void) {}
 }
 
 
@@ -765,7 +763,7 @@ message SubscribeHomeassistantServicesRequest {
 
 message HomeassistantServiceMap {
   string key = 1;
-  string value = 2;
+  string value = 2 [(no_zero_copy) = true];
 }
 
 message HomeassistantActionRequest {
@@ -781,7 +779,7 @@ message HomeassistantActionRequest {
   bool is_event = 5;
   uint32 call_id = 6 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES"];
   bool wants_response = 7 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
-  string response_template = 8 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
+  string response_template = 8 [(no_zero_copy) = true, (field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
 }
 
 // Message sent by Home Assistant to ESPHome with service call response data
@@ -2439,49 +2437,3 @@ message ZWaveProxyRequest {
   ZWaveProxyRequestType type = 1;
   bytes data = 2;
 }
-
-// ==================== INFRARED ====================
-// Note: Feature and capability flag enums are defined in
-// esphome/components/infrared/infrared.h
-
-// Listing of infrared instances
-message ListEntitiesInfraredResponse {
-  option (id) = 135;
-  option (base_class) = "InfoResponseProtoMessage";
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_INFRARED";
-
-  string object_id = 1;
-  fixed32 key = 2;
-  string name = 3;
-  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON"];
-  bool disabled_by_default = 5;
-  EntityCategory entity_category = 6;
-  uint32 device_id = 7 [(field_ifdef) = "USE_DEVICES"];
-  uint32 capabilities = 8;  // Bitfield of InfraredCapabilityFlags
-}
-
-// Command to transmit infrared/RF data using raw timings
-message InfraredRFTransmitRawTimingsRequest {
-  option (id) = 136;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_IR_RF";
-
-  uint32 device_id = 1 [(field_ifdef) = "USE_DEVICES"];
-  fixed32 key = 2;                                       // Key identifying the transmitter instance
-  uint32 carrier_frequency = 3;                          // Carrier frequency in Hz
-  uint32 repeat_count = 4;                               // Number of times to transmit (1 = once, 2 = twice, etc.)
-  repeated sint32 timings = 5 [packed = true, (packed_buffer) = true];  // Raw timings in microseconds (zigzag-encoded): positive = mark (LED/TX on), negative = space (LED/TX off)
-}
-
-// Event message for received infrared/RF data
-message InfraredRFReceiveEvent {
-  option (id) = 137;
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_IR_RF";
-  option (no_delay) = true;
-
-  uint32 device_id = 1 [(field_ifdef) = "USE_DEVICES"];
-  fixed32 key = 2;                                    // Key identifying the receiver instance
-  repeated sint32 timings = 3 [packed = true, (container_pointer_no_template) = "std::vector<int32_t>"];  // Raw timings in microseconds (zigzag-encoded): alternating mark/space periods
-}

esphome/components/api/api_connection.cpp

@@ -46,9 +46,6 @@
 #ifdef USE_WATER_HEATER
 #include "esphome/components/water_heater/water_heater.h"
 #endif
-#ifdef USE_INFRARED
-#include "esphome/components/infrared/infrared.h"
-#endif
 
 namespace esphome::api {
 
@@ -104,14 +101,16 @@ APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *pa
 #if defined(USE_API_PLAINTEXT) && defined(USE_API_NOISE)
   auto &noise_ctx = parent->get_noise_ctx();
   if (noise_ctx.has_psk()) {
-    this->helper_ = std::unique_ptr<APIFrameHelper>{new APINoiseFrameHelper(std::move(sock), noise_ctx)};
+    this->helper_ =
+        std::unique_ptr<APIFrameHelper>{new APINoiseFrameHelper(std::move(sock), noise_ctx, &this->client_info_)};
   } else {
-    this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock))};
+    this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock), &this->client_info_)};
   }
 #elif defined(USE_API_PLAINTEXT)
-  this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock))};
+  this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock), &this->client_info_)};
 #elif defined(USE_API_NOISE)
-  this->helper_ = std::unique_ptr<APIFrameHelper>{new APINoiseFrameHelper(std::move(sock), parent->get_noise_ctx())};
+  this->helper_ = std::unique_ptr<APIFrameHelper>{
+      new APINoiseFrameHelper(std::move(sock), parent->get_noise_ctx(), &this->client_info_)};
 #else
 #error "No frame helper defined"
 #endif
@@ -132,9 +131,8 @@ void APIConnection::start() {
     this->fatal_error_with_log_(LOG_STR("Helper init failed"), err);
     return;
   }
-  // Initialize client name with peername (IP address) until Hello message provides actual name
-  const char *peername = this->helper_->get_client_peername();
-  this->helper_->set_client_name(peername, strlen(peername));
+  this->client_info_.peername = helper_->getpeername();
+  this->client_info_.name = this->client_info_.peername;
 }
 
 APIConnection::~APIConnection() {
@@ -254,7 +252,8 @@ void APIConnection::loop() {
     // Disconnect if not responded within 2.5*keepalive
     if (now - this->last_traffic_ > KEEPALIVE_DISCONNECT_TIMEOUT) {
       on_fatal_error();
-      this->log_client_(ESPHOME_LOG_LEVEL_WARN, LOG_STR("is unresponsive; disconnecting"));
+      ESP_LOGW(TAG, "%s (%s) is unresponsive; disconnecting", this->client_info_.name.c_str(),
+               this->client_info_.peername.c_str());
     }
   } else if (now - this->last_traffic_ > KEEPALIVE_TIMEOUT_MS && !this->flags_.remove) {
     // Only send ping if we're not disconnecting
@@ -288,7 +287,7 @@ bool APIConnection::send_disconnect_response(const DisconnectRequest &msg) {
   // remote initiated disconnect_client
   // don't close yet, we still need to send the disconnect response
   // close will happen on next loop
-  this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("disconnected"));
+  ESP_LOGD(TAG, "%s (%s) disconnected", this->client_info_.name.c_str(), this->client_info_.peername.c_str());
   this->flags_.next_close = true;
   DisconnectResponse resp;
   return this->send_message(resp, DisconnectResponse::MESSAGE_TYPE);
@@ -379,7 +378,7 @@ uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConne
                                                     bool is_single) {
   auto *binary_sensor = static_cast<binary_sensor::BinarySensor *>(entity);
   ListEntitiesBinarySensorResponse msg;
-  msg.device_class = binary_sensor->get_device_class_ref();
+  msg.set_device_class(binary_sensor->get_device_class_ref());
   msg.is_status_binary_sensor = binary_sensor->is_status_binary_sensor();
   return fill_and_encode_entity_info(binary_sensor, msg, ListEntitiesBinarySensorResponse::MESSAGE_TYPE, conn,
                                      remaining_size, is_single);
@@ -411,7 +410,7 @@ uint16_t APIConnection::try_send_cover_info(EntityBase *entity, APIConnection *c
   msg.supports_position = traits.get_supports_position();
   msg.supports_tilt = traits.get_supports_tilt();
   msg.supports_stop = traits.get_supports_stop();
-  msg.device_class = cover->get_device_class_ref();
+  msg.set_device_class(cover->get_device_class_ref());
   return fill_and_encode_entity_info(cover, msg, ListEntitiesCoverResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
@@ -446,7 +445,7 @@ uint16_t APIConnection::try_send_fan_state(EntityBase *entity, APIConnection *co
   if (traits.supports_direction())
     msg.direction = static_cast<enums::FanDirection>(fan->direction);
   if (traits.supports_preset_modes() && fan->has_preset_mode())
-    msg.preset_mode = fan->get_preset_mode();
+    msg.set_preset_mode(StringRef(fan->get_preset_mode()));
   return fill_and_encode_entity_state(fan, msg, FanStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -502,7 +501,7 @@ uint16_t APIConnection::try_send_light_state(EntityBase *entity, APIConnection *
   resp.cold_white = values.get_cold_white();
   resp.warm_white = values.get_warm_white();
   if (light->supports_effects()) {
-    resp.effect = light->get_effect_name();
+    resp.set_effect(light->get_effect_name_ref());
   }
   return fill_and_encode_entity_state(light, resp, LightStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -525,8 +524,7 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
     effects_list.init(light_effects.size() + 1);
     effects_list.push_back("None");
     for (auto *effect : light_effects) {
-      // c_str() is safe as effect names are null-terminated strings from codegen
-      effects_list.push_back(effect->get_name().c_str());
+      effects_list.push_back(effect->get_name());
     }
   }
   msg.effects = &effects_list;
@@ -585,10 +583,10 @@ uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *
                                              bool is_single) {
   auto *sensor = static_cast<sensor::Sensor *>(entity);
   ListEntitiesSensorResponse msg;
-  msg.unit_of_measurement = sensor->get_unit_of_measurement_ref();
+  msg.set_unit_of_measurement(sensor->get_unit_of_measurement_ref());
   msg.accuracy_decimals = sensor->get_accuracy_decimals();
   msg.force_update = sensor->get_force_update();
-  msg.device_class = sensor->get_device_class_ref();
+  msg.set_device_class(sensor->get_device_class_ref());
   msg.state_class = static_cast<enums::SensorStateClass>(sensor->get_state_class());
   return fill_and_encode_entity_info(sensor, msg, ListEntitiesSensorResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
@@ -615,7 +613,7 @@ uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *
   auto *a_switch = static_cast<switch_::Switch *>(entity);
   ListEntitiesSwitchResponse msg;
   msg.assumed_state = a_switch->assumed_state();
-  msg.device_class = a_switch->get_device_class_ref();
+  msg.set_device_class(a_switch->get_device_class_ref());
   return fill_and_encode_entity_info(a_switch, msg, ListEntitiesSwitchResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
@@ -640,7 +638,7 @@ uint16_t APIConnection::try_send_text_sensor_state(EntityBase *entity, APIConnec
                                                    bool is_single) {
   auto *text_sensor = static_cast<text_sensor::TextSensor *>(entity);
   TextSensorStateResponse resp;
-  resp.state = StringRef(text_sensor->state);
+  resp.set_state(StringRef(text_sensor->state));
   resp.missing_state = !text_sensor->has_state();
   return fill_and_encode_entity_state(text_sensor, resp, TextSensorStateResponse::MESSAGE_TYPE, conn, remaining_size,
                                       is_single);
@@ -649,7 +647,7 @@ uint16_t APIConnection::try_send_text_sensor_info(EntityBase *entity, APIConnect
                                                   bool is_single) {
   auto *text_sensor = static_cast<text_sensor::TextSensor *>(entity);
   ListEntitiesTextSensorResponse msg;
-  msg.device_class = text_sensor->get_device_class_ref();
+  msg.set_device_class(text_sensor->get_device_class_ref());
   return fill_and_encode_entity_info(text_sensor, msg, ListEntitiesTextSensorResponse::MESSAGE_TYPE, conn,
                                      remaining_size, is_single);
 }
@@ -679,13 +677,13 @@ uint16_t APIConnection::try_send_climate_state(EntityBase *entity, APIConnection
   if (traits.get_supports_fan_modes() && climate->fan_mode.has_value())
     resp.fan_mode = static_cast<enums::ClimateFanMode>(climate->fan_mode.value());
   if (!traits.get_supported_custom_fan_modes().empty() && climate->has_custom_fan_mode()) {
-    resp.custom_fan_mode = climate->get_custom_fan_mode();
+    resp.set_custom_fan_mode(StringRef(climate->get_custom_fan_mode()));
   }
   if (traits.get_supports_presets() && climate->preset.has_value()) {
     resp.preset = static_cast<enums::ClimatePreset>(climate->preset.value());
   }
   if (!traits.get_supported_custom_presets().empty() && climate->has_custom_preset()) {
-    resp.custom_preset = climate->get_custom_preset();
+    resp.set_custom_preset(StringRef(climate->get_custom_preset()));
   }
   if (traits.get_supports_swing_modes())
     resp.swing_mode = static_cast<enums::ClimateSwingMode>(climate->swing_mode);
@@ -770,9 +768,9 @@ uint16_t APIConnection::try_send_number_info(EntityBase *entity, APIConnection *
                                              bool is_single) {
   auto *number = static_cast<number::Number *>(entity);
   ListEntitiesNumberResponse msg;
-  msg.unit_of_measurement = number->traits.get_unit_of_measurement_ref();
+  msg.set_unit_of_measurement(number->traits.get_unit_of_measurement_ref());
   msg.mode = static_cast<enums::NumberMode>(number->traits.get_mode());
-  msg.device_class = number->traits.get_device_class_ref();
+  msg.set_device_class(number->traits.get_device_class_ref());
   msg.min_value = number->traits.get_min_value();
   msg.max_value = number->traits.get_max_value();
   msg.step = number->traits.get_step();
@@ -885,7 +883,7 @@ uint16_t APIConnection::try_send_text_state(EntityBase *entity, APIConnection *c
                                             bool is_single) {
   auto *text = static_cast<text::Text *>(entity);
   TextStateResponse resp;
-  resp.state = StringRef(text->state);
+  resp.set_state(StringRef(text->state));
   resp.missing_state = !text->has_state();
   return fill_and_encode_entity_state(text, resp, TextStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -897,7 +895,7 @@ uint16_t APIConnection::try_send_text_info(EntityBase *entity, APIConnection *co
   msg.mode = static_cast<enums::TextMode>(text->traits.get_mode());
   msg.min_length = text->traits.get_min_length();
   msg.max_length = text->traits.get_max_length();
-  msg.pattern = text->traits.get_pattern_ref();
+  msg.set_pattern(text->traits.get_pattern_ref());
   return fill_and_encode_entity_info(text, msg, ListEntitiesTextResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
@@ -918,7 +916,7 @@ uint16_t APIConnection::try_send_select_state(EntityBase *entity, APIConnection
                                               bool is_single) {
   auto *select = static_cast<select::Select *>(entity);
   SelectStateResponse resp;
-  resp.state = select->current_option();
+  resp.set_state(StringRef(select->current_option()));
   resp.missing_state = !select->has_state();
   return fill_and_encode_entity_state(select, resp, SelectStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -943,7 +941,7 @@ uint16_t APIConnection::try_send_button_info(EntityBase *entity, APIConnection *
                                              bool is_single) {
   auto *button = static_cast<button::Button *>(entity);
   ListEntitiesButtonResponse msg;
-  msg.device_class = button->get_device_class_ref();
+  msg.set_device_class(button->get_device_class_ref());
   return fill_and_encode_entity_info(button, msg, ListEntitiesButtonResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
@@ -1012,7 +1010,7 @@ uint16_t APIConnection::try_send_valve_info(EntityBase *entity, APIConnection *c
   auto *valve = static_cast<valve::Valve *>(entity);
   ListEntitiesValveResponse msg;
   auto traits = valve->get_traits();
-  msg.device_class = valve->get_device_class_ref();
+  msg.set_device_class(valve->get_device_class_ref());
   msg.assumed_state = traits.get_is_assumed_state();
   msg.supports_position = traits.get_supports_position();
   msg.supports_stop = traits.get_supports_stop();
@@ -1057,7 +1055,7 @@ uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnec
   for (auto &supported_format : traits.get_supported_formats()) {
     msg.supported_formats.emplace_back();
     auto &media_format = msg.supported_formats.back();
-    media_format.format = StringRef(supported_format.format);
+    media_format.set_format(StringRef(supported_format.format));
     media_format.sample_rate = supported_format.sample_rate;
     media_format.num_channels = supported_format.num_channels;
     media_format.purpose = static_cast<enums::MediaPlayerFormatPurpose>(supported_format.purpose);
@@ -1267,8 +1265,8 @@ bool APIConnection::send_voice_assistant_get_configuration_response(const VoiceA
   for (auto &wake_word : config.available_wake_words) {
     resp.available_wake_words.emplace_back();
     auto &resp_wake_word = resp.available_wake_words.back();
-    resp_wake_word.id = StringRef(wake_word.id);
-    resp_wake_word.wake_word = StringRef(wake_word.wake_word);
+    resp_wake_word.set_id(StringRef(wake_word.id));
+    resp_wake_word.set_wake_word(StringRef(wake_word.wake_word));
     for (const auto &lang : wake_word.trained_languages) {
       resp_wake_word.trained_languages.push_back(lang);
     }
@@ -1283,8 +1281,8 @@ bool APIConnection::send_voice_assistant_get_configuration_response(const VoiceA
 
     resp.available_wake_words.emplace_back();
     auto &resp_wake_word = resp.available_wake_words.back();
-    resp_wake_word.id = StringRef(wake_word.id);
-    resp_wake_word.wake_word = StringRef(wake_word.wake_word);
+    resp_wake_word.set_id(StringRef(wake_word.id));
+    resp_wake_word.set_wake_word(StringRef(wake_word.wake_word));
     for (const auto &lang : wake_word.trained_languages) {
       resp_wake_word.trained_languages.push_back(lang);
     }
@@ -1418,15 +1416,14 @@ void APIConnection::on_water_heater_command_request(const WaterHeaterCommandRequ
 #endif
 
 #ifdef USE_EVENT
-void APIConnection::send_event(event::Event *event, StringRef event_type) {
-  // get_last_event_type() returns StringRef pointing to null-terminated string literals from codegen
-  this->send_message_smart_(event, MessageCreator(event_type.c_str()), EventResponse::MESSAGE_TYPE,
+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, StringRef 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.event_type = event_type;
+  resp.set_event_type(StringRef(event_type));
   return fill_and_encode_entity_state(event, resp, EventResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 
@@ -1434,42 +1431,13 @@ uint16_t APIConnection::try_send_event_info(EntityBase *entity, APIConnection *c
                                             bool is_single) {
   auto *event = static_cast<event::Event *>(entity);
   ListEntitiesEventResponse msg;
-  msg.device_class = event->get_device_class_ref();
+  msg.set_device_class(event->get_device_class_ref());
   msg.event_types = &event->get_event_types();
   return fill_and_encode_entity_info(event, msg, ListEntitiesEventResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
 #endif
 
-#ifdef USE_IR_RF
-void APIConnection::infrared_rf_transmit_raw_timings(const InfraredRFTransmitRawTimingsRequest &msg) {
-  // TODO: When RF is implemented, add a field to the message to distinguish IR vs RF
-  // and dispatch to the appropriate entity type based on that field.
-#ifdef USE_INFRARED
-  ENTITY_COMMAND_MAKE_CALL(infrared::Infrared, infrared, infrared)
-  call.set_carrier_frequency(msg.carrier_frequency);
-  call.set_raw_timings_packed(msg.timings_data_, msg.timings_length_, msg.timings_count_);
-  call.set_repeat_count(msg.repeat_count);
-  call.perform();
-#endif
-}
-
-void APIConnection::send_infrared_rf_receive_event(const InfraredRFReceiveEvent &msg) {
-  this->send_message(msg, InfraredRFReceiveEvent::MESSAGE_TYPE);
-}
-#endif
-
-#ifdef USE_INFRARED
-uint16_t APIConnection::try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                               bool is_single) {
-  auto *infrared = static_cast<infrared::Infrared *>(entity);
-  ListEntitiesInfraredResponse msg;
-  msg.capabilities = infrared->get_capability_flags();
-  return fill_and_encode_entity_info(infrared, msg, ListEntitiesInfraredResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
-}
-#endif
-
 #ifdef USE_UPDATE
 bool APIConnection::send_update_state(update::UpdateEntity *update) {
   return this->send_message_smart_(update, &APIConnection::try_send_update_state, UpdateStateResponse::MESSAGE_TYPE,
@@ -1486,11 +1454,11 @@ uint16_t APIConnection::try_send_update_state(EntityBase *entity, APIConnection
       resp.has_progress = true;
       resp.progress = update->update_info.progress;
     }
-    resp.current_version = StringRef(update->update_info.current_version);
-    resp.latest_version = StringRef(update->update_info.latest_version);
-    resp.title = StringRef(update->update_info.title);
-    resp.release_summary = StringRef(update->update_info.summary);
-    resp.release_url = StringRef(update->update_info.release_url);
+    resp.set_current_version(StringRef(update->update_info.current_version));
+    resp.set_latest_version(StringRef(update->update_info.latest_version));
+    resp.set_title(StringRef(update->update_info.title));
+    resp.set_release_summary(StringRef(update->update_info.summary));
+    resp.set_release_url(StringRef(update->update_info.release_url));
   }
   return fill_and_encode_entity_state(update, resp, UpdateStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1498,7 +1466,7 @@ uint16_t APIConnection::try_send_update_info(EntityBase *entity, APIConnection *
                                              bool is_single) {
   auto *update = static_cast<update::UpdateEntity *>(entity);
   ListEntitiesUpdateResponse msg;
-  msg.device_class = update->get_device_class_ref();
+  msg.set_device_class(update->get_device_class_ref());
   return fill_and_encode_entity_info(update, msg, ListEntitiesUpdateResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
@@ -1536,10 +1504,9 @@ void APIConnection::complete_authentication_() {
   }
 
   this->flags_.connection_state = static_cast<uint8_t>(ConnectionState::AUTHENTICATED);
-  this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("connected"));
+  ESP_LOGD(TAG, "%s (%s) connected", this->client_info_.name.c_str(), this->client_info_.peername.c_str());
 #ifdef USE_API_CLIENT_CONNECTED_TRIGGER
-  this->parent_->get_client_connected_trigger()->trigger(std::string(this->helper_->get_client_name()),
-                                                         std::string(this->helper_->get_client_peername()));
+  this->parent_->get_client_connected_trigger()->trigger(this->client_info_.name, this->client_info_.peername);
 #endif
 #ifdef USE_HOMEASSISTANT_TIME
   if (homeassistant::global_homeassistant_time != nullptr) {
@@ -1554,19 +1521,19 @@ void APIConnection::complete_authentication_() {
 }
 
 bool APIConnection::send_hello_response(const HelloRequest &msg) {
-  // Copy client name with truncation if needed (set_client_name handles truncation)
-  this->helper_->set_client_name(msg.client_info.c_str(), msg.client_info.size());
+  this->client_info_.name.assign(msg.client_info.c_str(), msg.client_info.size());
+  this->client_info_.peername = this->helper_->getpeername();
   this->client_api_version_major_ = msg.api_version_major;
   this->client_api_version_minor_ = msg.api_version_minor;
-  ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %" PRIu32 ".%" PRIu32, this->helper_->get_client_name(),
-           this->helper_->get_client_peername(), this->client_api_version_major_, this->client_api_version_minor_);
+  ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %" PRIu32 ".%" PRIu32, this->client_info_.name.c_str(),
+           this->client_info_.peername.c_str(), this->client_api_version_major_, this->client_api_version_minor_);
 
   HelloResponse resp;
   resp.api_version_major = 1;
   resp.api_version_minor = 14;
   // Send only the version string - the client only logs this for debugging and doesn't use it otherwise
-  resp.server_info = ESPHOME_VERSION_REF;
-  resp.name = StringRef(App.get_name());
+  resp.set_server_info(ESPHOME_VERSION_REF);
+  resp.set_name(StringRef(App.get_name()));
 
   // Auto-authenticate - password auth was removed in ESPHome 2026.1.0
   this->complete_authentication_();
@@ -1581,24 +1548,24 @@ bool APIConnection::send_ping_response(const PingRequest &msg) {
 
 bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
   DeviceInfoResponse resp{};
-  resp.name = StringRef(App.get_name());
-  resp.friendly_name = StringRef(App.get_friendly_name());
+  resp.set_name(StringRef(App.get_name()));
+  resp.set_friendly_name(StringRef(App.get_friendly_name()));
 #ifdef USE_AREAS
-  resp.suggested_area = StringRef(App.get_area());
+  resp.set_suggested_area(StringRef(App.get_area()));
 #endif
   // Stack buffer for MAC address (XX:XX:XX:XX:XX:XX\0 = 18 bytes)
   char mac_address[18];
   uint8_t mac[6];
   get_mac_address_raw(mac);
   format_mac_addr_upper(mac, mac_address);
-  resp.mac_address = StringRef(mac_address);
+  resp.set_mac_address(StringRef(mac_address));
 
-  resp.esphome_version = ESPHOME_VERSION_REF;
+  resp.set_esphome_version(ESPHOME_VERSION_REF);
 
   // Stack buffer for build time string
   char build_time_str[Application::BUILD_TIME_STR_SIZE];
   App.get_build_time_string(build_time_str);
-  resp.compilation_time = StringRef(build_time_str);
+  resp.set_compilation_time(StringRef(build_time_str));
 
   // Manufacturer string - define once, handle ESP8266 PROGMEM separately
 #if defined(USE_ESP8266) || defined(USE_ESP32)
@@ -1622,10 +1589,10 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
   static const char MANUFACTURER_PROGMEM[] PROGMEM = ESPHOME_MANUFACTURER;
   char manufacturer_buf[sizeof(MANUFACTURER_PROGMEM)];
   memcpy_P(manufacturer_buf, MANUFACTURER_PROGMEM, sizeof(MANUFACTURER_PROGMEM));
-  resp.manufacturer = StringRef(manufacturer_buf, sizeof(MANUFACTURER_PROGMEM) - 1);
+  resp.set_manufacturer(StringRef(manufacturer_buf, sizeof(MANUFACTURER_PROGMEM) - 1));
 #else
   static constexpr auto MANUFACTURER = StringRef::from_lit(ESPHOME_MANUFACTURER);
-  resp.manufacturer = MANUFACTURER;
+  resp.set_manufacturer(MANUFACTURER);
 #endif
 #undef ESPHOME_MANUFACTURER
 
@@ -1633,10 +1600,10 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
   static const char MODEL_PROGMEM[] PROGMEM = ESPHOME_BOARD;
   char model_buf[sizeof(MODEL_PROGMEM)];
   memcpy_P(model_buf, MODEL_PROGMEM, sizeof(MODEL_PROGMEM));
-  resp.model = StringRef(model_buf, sizeof(MODEL_PROGMEM) - 1);
+  resp.set_model(StringRef(model_buf, sizeof(MODEL_PROGMEM) - 1));
 #else
   static constexpr auto MODEL = StringRef::from_lit(ESPHOME_BOARD);
-  resp.model = MODEL;
+  resp.set_model(MODEL);
 #endif
 #ifdef USE_DEEP_SLEEP
   resp.has_deep_sleep = deep_sleep::global_has_deep_sleep;
@@ -1649,13 +1616,13 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
   char project_version_buf[sizeof(PROJECT_VERSION_PROGMEM)];
   memcpy_P(project_name_buf, PROJECT_NAME_PROGMEM, sizeof(PROJECT_NAME_PROGMEM));
   memcpy_P(project_version_buf, PROJECT_VERSION_PROGMEM, sizeof(PROJECT_VERSION_PROGMEM));
-  resp.project_name = StringRef(project_name_buf, sizeof(PROJECT_NAME_PROGMEM) - 1);
-  resp.project_version = StringRef(project_version_buf, sizeof(PROJECT_VERSION_PROGMEM) - 1);
+  resp.set_project_name(StringRef(project_name_buf, sizeof(PROJECT_NAME_PROGMEM) - 1));
+  resp.set_project_version(StringRef(project_version_buf, sizeof(PROJECT_VERSION_PROGMEM) - 1));
 #else
   static constexpr auto PROJECT_NAME = StringRef::from_lit(ESPHOME_PROJECT_NAME);
   static constexpr auto PROJECT_VERSION = StringRef::from_lit(ESPHOME_PROJECT_VERSION);
-  resp.project_name = PROJECT_NAME;
-  resp.project_version = PROJECT_VERSION;
+  resp.set_project_name(PROJECT_NAME);
+  resp.set_project_version(PROJECT_VERSION);
 #endif
 #endif
 #ifdef USE_WEBSERVER
@@ -1666,7 +1633,7 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
   // Stack buffer for Bluetooth MAC address (XX:XX:XX:XX:XX:XX\0 = 18 bytes)
   char bluetooth_mac[18];
   bluetooth_proxy::global_bluetooth_proxy->get_bluetooth_mac_address_pretty(bluetooth_mac);
-  resp.bluetooth_mac_address = StringRef(bluetooth_mac);
+  resp.set_bluetooth_mac_address(StringRef(bluetooth_mac));
 #endif
 #ifdef USE_VOICE_ASSISTANT
   resp.voice_assistant_feature_flags = voice_assistant::global_voice_assistant->get_feature_flags();
@@ -1685,7 +1652,7 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
       break;
     auto &device_info = resp.devices[device_index++];
     device_info.device_id = device->get_device_id();
-    device_info.name = StringRef(device->get_name());
+    device_info.set_name(StringRef(device->get_name()));
     device_info.area_id = device->get_area_id();
   }
 #endif
@@ -1696,7 +1663,7 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
       break;
     auto &area_info = resp.areas[area_index++];
     area_info.area_id = area->get_area_id();
-    area_info.name = StringRef(area->get_name());
+    area_info.set_name(StringRef(area->get_name()));
   }
 #endif
 
@@ -1725,18 +1692,10 @@ void APIConnection::on_home_assistant_state_response(const HomeAssistantStateRes
       continue;
     }
 
-    // Create null-terminated state for callback (parse_number needs null-termination)
-    // HA state max length is 255, so 256 byte buffer covers all cases
-    char state_buf[256];
-    size_t copy_len = msg.state.size();
-    if (copy_len >= sizeof(state_buf)) {
-      copy_len = sizeof(state_buf) - 1;  // Truncate to leave space for null terminator
-    }
-    if (copy_len > 0) {
-      memcpy(state_buf, msg.state.c_str(), copy_len);
-    }
-    state_buf[copy_len] = '\0';
-    it.callback(StringRef(state_buf, copy_len));
+    // Create temporary string for callback (callback takes const std::string &)
+    // Handle empty state
+    std::string state(!msg.state.empty() ? msg.state.c_str() : "", msg.state.size());
+    it.callback(state);
   }
 }
 #endif
@@ -1775,7 +1734,7 @@ void APIConnection::send_execute_service_response(uint32_t call_id, bool success
   ExecuteServiceResponse resp;
   resp.call_id = call_id;
   resp.success = success;
-  resp.error_message = error_message;
+  resp.set_error_message(error_message);
   this->send_message(resp, ExecuteServiceResponse::MESSAGE_TYPE);
 }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
@@ -1784,7 +1743,7 @@ void APIConnection::send_execute_service_response(uint32_t call_id, bool success
   ExecuteServiceResponse resp;
   resp.call_id = call_id;
   resp.success = success;
-  resp.error_message = error_message;
+  resp.set_error_message(error_message);
   resp.response_data = response_data;
   resp.response_data_len = response_data_len;
   this->send_message(resp, ExecuteServiceResponse::MESSAGE_TYPE);
@@ -1853,30 +1812,10 @@ bool APIConnection::try_to_clear_buffer(bool log_out_of_space) {
   return false;
 }
 bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
-  const bool is_log_message = (message_type == SubscribeLogsResponse::MESSAGE_TYPE);
-
-  if (!this->try_to_clear_buffer(!is_log_message)) {
+  if (!this->try_to_clear_buffer(message_type != SubscribeLogsResponse::MESSAGE_TYPE)) {  // SubscribeLogsResponse
     return false;
   }
 
-  // Toggle Nagle's algorithm based on message type to prevent log messages from
-  // filling the TCP send buffer and crowding out important state updates.
-  //
-  // This honors the `no_delay` proto option - SubscribeLogsResponse is the only
-  // message with `option (no_delay) = false;` in api.proto, indicating it should
-  // allow Nagle coalescing. This option existed since 2019 but was never implemented.
-  //
-  // - Log messages: Enable Nagle (NODELAY=false) so small log packets coalesce
-  //   into fewer, larger packets. They flush naturally via TCP delayed ACK timer
-  //   (~200ms), buffer filling, or when a state update triggers a flush.
-  //
-  // - All other messages (state updates, responses): Disable Nagle (NODELAY=true)
-  //   for immediate delivery. These are time-sensitive and should not be delayed.
-  //
-  // This must be done proactively BEFORE the buffer fills up - checking buffer
-  // state here would be too late since we'd already be in a degraded state.
-  this->helper_->set_nodelay(!is_log_message);
-
   APIError err = this->helper_->write_protobuf_packet(message_type, buffer);
   if (err == APIError::WOULD_BLOCK)
     return false;
@@ -1889,7 +1828,7 @@ bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
 }
 void APIConnection::on_no_setup_connection() {
   this->on_fatal_error();
-  this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("no connection setup"));
+  ESP_LOGD(TAG, "%s (%s) no connection setup", this->client_info_.name.c_str(), this->client_info_.peername.c_str());
 }
 void APIConnection::on_fatal_error() {
   this->helper_->close();
@@ -2089,7 +2028,7 @@ uint16_t APIConnection::MessageCreator::operator()(EntityBase *entity, APIConnec
   // 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, StringRef(data_.const_char_ptr), conn, remaining_size, is_single);
+    return APIConnection::try_send_event_response(e, data_.const_char_ptr, conn, remaining_size, is_single);
   }
 #endif
 
@@ -2125,10 +2064,10 @@ void APIConnection::process_state_subscriptions_() {
 
   const auto &it = subs[this->state_subs_at_];
   SubscribeHomeAssistantStateResponse resp;
-  resp.entity_id = StringRef(it.entity_id);
+  resp.set_entity_id(StringRef(it.entity_id));
 
   // Avoid string copy by using the const char* pointer if it exists
-  resp.attribute = it.attribute != nullptr ? StringRef(it.attribute) : StringRef("");
+  resp.set_attribute(it.attribute != nullptr ? StringRef(it.attribute) : StringRef(""));
 
   resp.once = it.once;
   if (this->send_message(resp, SubscribeHomeAssistantStateResponse::MESSAGE_TYPE)) {
@@ -2137,13 +2076,8 @@ void APIConnection::process_state_subscriptions_() {
 }
 #endif  // USE_API_HOMEASSISTANT_STATES
 
-void APIConnection::log_client_(int level, const LogString *message) {
-  esp_log_printf_(level, TAG, __LINE__, ESPHOME_LOG_FORMAT("%s (%s): %s"), this->helper_->get_client_name(),
-                  this->helper_->get_client_peername(), LOG_STR_ARG(message));
-}
-
 void APIConnection::log_warning_(const LogString *message, APIError err) {
-  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->helper_->get_client_name(), this->helper_->get_client_peername(),
+  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->client_info_.name.c_str(), this->client_info_.peername.c_str(),
            LOG_STR_ARG(message), LOG_STR_ARG(api_error_to_logstr(err)), errno);
 }
 

esphome/components/api/api_connection.h

@@ -9,13 +9,18 @@
 #include "esphome/core/application.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
-#include "esphome/core/string_ref.h"
 
 #include <functional>
 #include <vector>
 
 namespace esphome::api {
 
+// Client information structure
+struct ClientInfo {
+  std::string name;      // Client name from Hello message
+  std::string peername;  // IP:port from socket
+};
+
 // Keepalive timeout in milliseconds
 static constexpr uint32_t KEEPALIVE_TIMEOUT_MS = 60000;
 // Maximum number of entities to process in a single batch during initial state/info sending
@@ -172,13 +177,8 @@ class APIConnection final : public APIServerConnection {
   void on_water_heater_command_request(const WaterHeaterCommandRequest &msg) override;
 #endif
 
-#ifdef USE_IR_RF
-  void infrared_rf_transmit_raw_timings(const InfraredRFTransmitRawTimingsRequest &msg) override;
-  void send_infrared_rf_receive_event(const InfraredRFReceiveEvent &msg);
-#endif
-
 #ifdef USE_EVENT
-  void send_event(event::Event *event, StringRef event_type);
+  void send_event(event::Event *event, const char *event_type);
 #endif
 
 #ifdef USE_UPDATE
@@ -279,9 +279,8 @@ class APIConnection final : public APIServerConnection {
   bool try_to_clear_buffer(bool log_out_of_space);
   bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) override;
 
-  const char *get_name() const { return this->helper_->get_client_name(); }
-  /// Get peer name (IP address) - cached at connection init time
-  const char *get_peername() const { return this->helper_->get_client_peername(); }
+  const std::string &get_name() const { return this->client_info_.name; }
+  const std::string &get_peername() const { return this->client_info_.peername; }
 
  protected:
   // Helper function to handle authentication completion
@@ -322,16 +321,16 @@ class APIConnection final : public APIServerConnection {
     // Buffer must remain in scope until encode_message_to_buffer is called
     char object_id_buf[OBJECT_ID_MAX_LEN];
     if (!conn->client_supports_api_version(1, 14)) {
-      msg.object_id = entity->get_object_id_to(object_id_buf);
+      msg.set_object_id(entity->get_object_id_to(object_id_buf));
     }
 
     if (entity->has_own_name()) {
-      msg.name = entity->get_name();
+      msg.set_name(entity->get_name());
     }
 
     // Set common EntityBase properties
 #ifdef USE_ENTITY_ICON
-    msg.icon = entity->get_icon_ref();
+    msg.set_icon(entity->get_icon_ref());
 #endif
     msg.disabled_by_default = entity->is_disabled_by_default();
     msg.entity_category = static_cast<enums::EntityCategory>(entity->get_entity_category());
@@ -473,12 +472,8 @@ class APIConnection final : public APIServerConnection {
   static uint16_t try_send_water_heater_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single);
 #endif
-#ifdef USE_INFRARED
-  static uint16_t try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                         bool is_single);
-#endif
 #ifdef USE_EVENT
-  static uint16_t try_send_event_response(event::Event *event, StringRef 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
@@ -531,7 +526,10 @@ class APIConnection final : public APIServerConnection {
   std::unique_ptr<camera::CameraImageReader> image_reader_;
 #endif
 
-  // Group 3: 4-byte types
+  // Group 3: Client info struct (24 bytes on 32-bit: 2 strings × 12 bytes each)
+  ClientInfo client_info_;
+
+  // Group 4: 4-byte types
   uint32_t last_traffic_;
 #ifdef USE_API_HOMEASSISTANT_STATES
   int state_subs_at_ = -1;
@@ -758,8 +756,6 @@ class APIConnection final : public APIServerConnection {
     return this->schedule_batch_();
   }
 
-  // Helper function to log client messages with name and peername
-  void log_client_(int level, const LogString *message);
   // Helper function to log API errors with errno
   void log_warning_(const LogString *message, APIError err);
   // Helper to handle fatal errors with logging

esphome/components/api/api_frame_helper.cpp

@@ -1,5 +1,6 @@
 #include "api_frame_helper.h"
 #ifdef USE_API
+#include "api_connection.h"  // For ClientInfo struct
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
@@ -15,11 +16,8 @@ static const char *const TAG = "api.frame_helper";
 // Maximum bytes to log in hex format (168 * 3 = 504, under TX buffer size of 512)
 static constexpr size_t API_MAX_LOG_BYTES = 168;
 
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-#define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
-#else
-#define HELPER_LOG(msg, ...) ((void) 0)
-#endif
+#define HELPER_LOG(msg, ...) \
+  ESP_LOGVV(TAG, "%s (%s): " msg, this->client_info_->name.c_str(), this->client_info_->peername.c_str(), ##__VA_ARGS__)
 
 #ifdef HELPER_LOG_PACKETS
 #define LOG_PACKET_RECEIVED(buffer) \
@@ -245,8 +243,6 @@ APIError APIFrameHelper::init_common_() {
     HELPER_LOG("Bad state for init %d", (int) state_);
     return APIError::BAD_STATE;
   }
-  // Cache peername now while socket is valid - needed for error logging after socket failure
-  this->socket_->getpeername_to(this->client_peername_);
   int err = this->socket_->setblocking(false);
   if (err != 0) {
     state_ = State::FAILED;

esphome/components/api/api_frame_helper.h

@@ -33,10 +33,10 @@ static constexpr uint16_t MAX_MESSAGE_SIZE = 32768;  // 32 KiB for ESP32 and oth
 // Must be >= MAX_INITIAL_PER_BATCH in api_connection.h (enforced by static_assert there)
 static constexpr size_t MAX_MESSAGES_PER_BATCH = 34;
 
-class ProtoWriteBuffer;
+// Forward declaration
+struct ClientInfo;
 
-// Max client name length (e.g., "Home Assistant 2026.1.0.dev0" = 28 chars)
-static constexpr size_t CLIENT_INFO_NAME_MAX_LEN = 32;
+class ProtoWriteBuffer;
 
 struct ReadPacketBuffer {
   const uint8_t *data;  // Points directly into frame helper's rx_buf_ (valid until next read_packet call)
@@ -86,23 +86,14 @@ const LogString *api_error_to_logstr(APIError err);
 class APIFrameHelper {
  public:
   APIFrameHelper() = default;
-  explicit APIFrameHelper(std::unique_ptr<socket::Socket> socket) : socket_(std::move(socket)) {}
-
-  // Get client name (null-terminated)
-  const char *get_client_name() const { return this->client_name_; }
-  // Get client peername/IP (null-terminated, cached at init time for availability after socket failure)
-  const char *get_client_peername() const { return this->client_peername_; }
-  // Set client name from buffer with length (truncates if needed)
-  void set_client_name(const char *name, size_t len) {
-    size_t copy_len = std::min(len, sizeof(this->client_name_) - 1);
-    memcpy(this->client_name_, name, copy_len);
-    this->client_name_[copy_len] = '\0';
-  }
+  explicit APIFrameHelper(std::unique_ptr<socket::Socket> socket, const ClientInfo *client_info)
+      : socket_(std::move(socket)), client_info_(client_info) {}
   virtual ~APIFrameHelper() = default;
   virtual APIError init() = 0;
   virtual APIError loop();
   virtual APIError read_packet(ReadPacketBuffer *buffer) = 0;
   bool can_write_without_blocking() { return this->state_ == State::DATA && this->tx_buf_count_ == 0; }
+  std::string getpeername() { return socket_->getpeername(); }
   int getpeername(struct sockaddr *addr, socklen_t *addrlen) { return socket_->getpeername(addr, addrlen); }
   APIError close() {
     state_ = State::CLOSED;
@@ -120,27 +111,6 @@ class APIFrameHelper {
     }
     return APIError::OK;
   }
-  /// Toggle TCP_NODELAY socket option to control Nagle's algorithm.
-  ///
-  /// This is used to allow log messages to coalesce (Nagle enabled) while keeping
-  /// state updates low-latency (NODELAY enabled). Without this, many small log
-  /// packets fill the TCP send buffer, crowding out important state updates.
-  ///
-  /// State is tracked to minimize setsockopt() overhead - on lwip_raw (ESP8266/RP2040)
-  /// this is just a boolean assignment; on other platforms it's a lightweight syscall.
-  ///
-  /// @param enable true to enable NODELAY (disable Nagle), false to enable Nagle
-  /// @return true if successful or already in desired state
-  bool set_nodelay(bool enable) {
-    if (this->nodelay_enabled_ == enable)
-      return true;
-    int val = enable ? 1 : 0;
-    int err = this->socket_->setsockopt(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
-    if (err == 0) {
-      this->nodelay_enabled_ = enable;
-    }
-    return err == 0;
-  }
   virtual APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) = 0;
   // Write multiple protobuf messages in a single operation
   // messages contains (message_type, offset, length) for each message in the buffer
@@ -216,10 +186,9 @@ class APIFrameHelper {
   std::array<std::unique_ptr<SendBuffer>, API_MAX_SEND_QUEUE> tx_buf_;
   std::vector<uint8_t> rx_buf_;
 
-  // Client name buffer - stores name from Hello message or initial peername
-  char client_name_[CLIENT_INFO_NAME_MAX_LEN]{};
-  // Cached peername/IP address - captured at init time for availability after socket failure
-  char client_peername_[socket::SOCKADDR_STR_LEN]{};
+  // Pointer to client info (4 bytes on 32-bit)
+  // Note: The pointed-to ClientInfo object must outlive this APIFrameHelper instance.
+  const ClientInfo *client_info_{nullptr};
 
   // Group smaller types together
   uint16_t rx_buf_len_ = 0;
@@ -229,10 +198,7 @@ class APIFrameHelper {
   uint8_t tx_buf_head_{0};
   uint8_t tx_buf_tail_{0};
   uint8_t tx_buf_count_{0};
-  // Tracks TCP_NODELAY state to minimize setsockopt() calls. Initialized to true
-  // since init_common_() enables NODELAY. Used by set_nodelay() to allow log
-  // messages to coalesce while keeping state updates low-latency.
-  bool nodelay_enabled_{true};
+  // 8 bytes total, 0 bytes padding
 
   // Common initialization for both plaintext and noise protocols
   APIError init_common_();

esphome/components/api/api_frame_helper_noise.cpp

@@ -27,11 +27,8 @@ static constexpr size_t PROLOGUE_INIT_LEN = 12;  // strlen("NoiseAPIInit")
 // Maximum bytes to log in hex format (168 * 3 = 504, under TX buffer size of 512)
 static constexpr size_t API_MAX_LOG_BYTES = 168;
 
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-#define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
-#else
-#define HELPER_LOG(msg, ...) ((void) 0)
-#endif
+#define HELPER_LOG(msg, ...) \
+  ESP_LOGVV(TAG, "%s (%s): " msg, this->client_info_->name.c_str(), this->client_info_->peername.c_str(), ##__VA_ARGS__)
 
 #ifdef HELPER_LOG_PACKETS
 #define LOG_PACKET_RECEIVED(buffer) \

esphome/components/api/api_frame_helper_noise.h

@@ -9,8 +9,8 @@ namespace esphome::api {
 
 class APINoiseFrameHelper final : public APIFrameHelper {
  public:
-  APINoiseFrameHelper(std::unique_ptr<socket::Socket> socket, APINoiseContext &ctx)
-      : APIFrameHelper(std::move(socket)), ctx_(ctx) {
+  APINoiseFrameHelper(std::unique_ptr<socket::Socket> socket, APINoiseContext &ctx, const ClientInfo *client_info)
+      : APIFrameHelper(std::move(socket), client_info), ctx_(ctx) {
     // Noise header structure:
     // Pos 0: indicator (0x01)
     // Pos 1-2: encrypted payload size (16-bit big-endian)

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -1,6 +1,7 @@
 #include "api_frame_helper_plaintext.h"
 #ifdef USE_API
 #ifdef USE_API_PLAINTEXT
+#include "api_connection.h"  // For ClientInfo struct
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
@@ -20,11 +21,8 @@ static const char *const TAG = "api.plaintext";
 // Maximum bytes to log in hex format (168 * 3 = 504, under TX buffer size of 512)
 static constexpr size_t API_MAX_LOG_BYTES = 168;
 
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-#define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
-#else
-#define HELPER_LOG(msg, ...) ((void) 0)
-#endif
+#define HELPER_LOG(msg, ...) \
+  ESP_LOGVV(TAG, "%s (%s): " msg, this->client_info_->name.c_str(), this->client_info_->peername.c_str(), ##__VA_ARGS__)
 
 #ifdef HELPER_LOG_PACKETS
 #define LOG_PACKET_RECEIVED(buffer) \

esphome/components/api/api_frame_helper_plaintext.h

@@ -7,7 +7,8 @@ namespace esphome::api {
 
 class APIPlaintextFrameHelper final : public APIFrameHelper {
  public:
-  explicit APIPlaintextFrameHelper(std::unique_ptr<socket::Socket> socket) : APIFrameHelper(std::move(socket)) {
+  APIPlaintextFrameHelper(std::unique_ptr<socket::Socket> socket, const ClientInfo *client_info)
+      : APIFrameHelper(std::move(socket), client_info) {
     // Plaintext header structure (worst case):
     // Pos 0: indicator (0x00)
     // Pos 1-3: payload size varint (up to 3 bytes)

esphome/components/api/api_options.proto

@@ -27,6 +27,7 @@ extend google.protobuf.MessageOptions {
 extend google.protobuf.FieldOptions {
     optional string field_ifdef = 1042;
     optional uint32 fixed_array_size = 50007;
+    optional bool no_zero_copy = 50008 [default=false];
     optional bool fixed_array_skip_zero = 50009 [default=false];
     optional string fixed_array_size_define = 50010;
     optional string fixed_array_with_length_define = 50011;
@@ -79,15 +80,4 @@ extend google.protobuf.FieldOptions {
     // Example: [(container_pointer_no_template) = "light::ColorModeMask"]
     //   generates: const light::ColorModeMask *supported_color_modes{};
     optional string container_pointer_no_template = 50014;
-
-    // packed_buffer: Expose raw packed buffer instead of decoding into container
-    // When set on a packed repeated field, the generated code stores a pointer
-    // to the raw protobuf buffer instead of decoding values. This enables
-    // zero-copy passthrough when the consumer can decode on-demand.
-    // The field must be a packed repeated field (packed=true).
-    // Generates three fields:
-    //   - const uint8_t *<field>_data_{nullptr};
-    //   - uint16_t <field>_length_{0};
-    //   - uint16_t <field>_count_{0};
-    optional bool packed_buffer = 50015 [default=false];
 }

esphome/components/api/api_pb2.h

@@ -315,12 +315,15 @@ enum ZWaveProxyRequestType : uint32_t {
 class InfoResponseProtoMessage : public ProtoMessage {
  public:
   ~InfoResponseProtoMessage() override = default;
-  StringRef object_id{};
+  StringRef object_id_ref_{};
+  void set_object_id(const StringRef &ref) { this->object_id_ref_ = ref; }
   uint32_t key{0};
-  StringRef name{};
+  StringRef name_ref_{};
+  void set_name(const StringRef &ref) { this->name_ref_ = ref; }
   bool disabled_by_default{false};
 #ifdef USE_ENTITY_ICON
-  StringRef icon{};
+  StringRef icon_ref_{};
+  void set_icon(const StringRef &ref) { this->icon_ref_ = ref; }
 #endif
   enums::EntityCategory entity_category{};
 #ifdef USE_DEVICES
@@ -378,8 +381,10 @@ class HelloResponse final : public ProtoMessage {
 #endif
   uint32_t api_version_major{0};
   uint32_t api_version_minor{0};
-  StringRef server_info{};
-  StringRef name{};
+  StringRef server_info_ref_{};
+  void set_server_info(const StringRef &ref) { this->server_info_ref_ = ref; }
+  StringRef name_ref_{};
+  void set_name(const StringRef &ref) { this->name_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -457,7 +462,8 @@ class DeviceInfoRequest final : public ProtoMessage {
 class AreaInfo final : public ProtoMessage {
  public:
   uint32_t area_id{0};
-  StringRef name{};
+  StringRef name_ref_{};
+  void set_name(const StringRef &ref) { this->name_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -471,7 +477,8 @@ class AreaInfo final : public ProtoMessage {
 class DeviceInfo final : public ProtoMessage {
  public:
   uint32_t device_id{0};
-  StringRef name{};
+  StringRef name_ref_{};
+  void set_name(const StringRef &ref) { this->name_ref_ = ref; }
   uint32_t area_id{0};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -489,19 +496,26 @@ class DeviceInfoResponse final : public ProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "device_info_response"; }
 #endif
-  StringRef name{};
-  StringRef mac_address{};
-  StringRef esphome_version{};
-  StringRef compilation_time{};
-  StringRef model{};
+  StringRef name_ref_{};
+  void set_name(const StringRef &ref) { this->name_ref_ = ref; }
+  StringRef mac_address_ref_{};
+  void set_mac_address(const StringRef &ref) { this->mac_address_ref_ = ref; }
+  StringRef esphome_version_ref_{};
+  void set_esphome_version(const StringRef &ref) { this->esphome_version_ref_ = ref; }
+  StringRef compilation_time_ref_{};
+  void set_compilation_time(const StringRef &ref) { this->compilation_time_ref_ = ref; }
+  StringRef model_ref_{};
+  void set_model(const StringRef &ref) { this->model_ref_ = ref; }
 #ifdef USE_DEEP_SLEEP
   bool has_deep_sleep{false};
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  StringRef project_name{};
+  StringRef project_name_ref_{};
+  void set_project_name(const StringRef &ref) { this->project_name_ref_ = ref; }
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  StringRef project_version{};
+  StringRef project_version_ref_{};
+  void set_project_version(const StringRef &ref) { this->project_version_ref_ = ref; }
 #endif
 #ifdef USE_WEBSERVER
   uint32_t webserver_port{0};
@@ -509,16 +523,20 @@ class DeviceInfoResponse final : public ProtoMessage {
 #ifdef USE_BLUETOOTH_PROXY
   uint32_t bluetooth_proxy_feature_flags{0};
 #endif
-  StringRef manufacturer{};
-  StringRef friendly_name{};
+  StringRef manufacturer_ref_{};
+  void set_manufacturer(const StringRef &ref) { this->manufacturer_ref_ = ref; }
+  StringRef friendly_name_ref_{};
+  void set_friendly_name(const StringRef &ref) { this->friendly_name_ref_ = ref; }
 #ifdef USE_VOICE_ASSISTANT
   uint32_t voice_assistant_feature_flags{0};
 #endif
 #ifdef USE_AREAS
-  StringRef suggested_area{};
+  StringRef suggested_area_ref_{};
+  void set_suggested_area(const StringRef &ref) { this->suggested_area_ref_ = ref; }
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  StringRef bluetooth_mac_address{};
+  StringRef bluetooth_mac_address_ref_{};
+  void set_bluetooth_mac_address(const StringRef &ref) { this->bluetooth_mac_address_ref_ = ref; }
 #endif
 #ifdef USE_API_NOISE
   bool api_encryption_supported{false};
@@ -593,7 +611,8 @@ class ListEntitiesBinarySensorResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_binary_sensor_response"; }
 #endif
-  StringRef device_class{};
+  StringRef device_class_ref_{};
+  void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
   bool is_status_binary_sensor{false};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -632,7 +651,8 @@ class ListEntitiesCoverResponse final : public InfoResponseProtoMessage {
   bool assumed_state{false};
   bool supports_position{false};
   bool supports_tilt{false};
-  StringRef device_class{};
+  StringRef device_class_ref_{};
+  void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
   bool supports_stop{false};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -713,7 +733,8 @@ class FanStateResponse final : public StateResponseProtoMessage {
   bool oscillating{false};
   enums::FanDirection direction{};
   int32_t speed_level{0};
-  StringRef preset_mode{};
+  StringRef preset_mode_ref_{};
+  void set_preset_mode(const StringRef &ref) { this->preset_mode_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -787,7 +808,8 @@ class LightStateResponse final : public StateResponseProtoMessage {
   float color_temperature{0.0f};
   float cold_white{0.0f};
   float warm_white{0.0f};
-  StringRef effect{};
+  StringRef effect_ref_{};
+  void set_effect(const StringRef &ref) { this->effect_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -847,10 +869,12 @@ class ListEntitiesSensorResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_sensor_response"; }
 #endif
-  StringRef unit_of_measurement{};
+  StringRef unit_of_measurement_ref_{};
+  void set_unit_of_measurement(const StringRef &ref) { this->unit_of_measurement_ref_ = ref; }
   int32_t accuracy_decimals{0};
   bool force_update{false};
-  StringRef device_class{};
+  StringRef device_class_ref_{};
+  void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
   enums::SensorStateClass state_class{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -887,7 +911,8 @@ class ListEntitiesSwitchResponse final : public InfoResponseProtoMessage {
   const char *message_name() const override { return "list_entities_switch_response"; }
 #endif
   bool assumed_state{false};
-  StringRef device_class{};
+  StringRef device_class_ref_{};
+  void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -937,7 +962,8 @@ class ListEntitiesTextSensorResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_text_sensor_response"; }
 #endif
-  StringRef device_class{};
+  StringRef device_class_ref_{};
+  void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -953,7 +979,8 @@ class TextSensorStateResponse final : public StateResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "text_sensor_state_response"; }
 #endif
-  StringRef state{};
+  StringRef state_ref_{};
+  void set_state(const StringRef &ref) { this->state_ref_ = ref; }
   bool missing_state{false};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -1052,8 +1079,9 @@ class SubscribeHomeassistantServicesRequest final : public ProtoMessage {
 };
 class HomeassistantServiceMap final : public ProtoMessage {
  public:
-  StringRef key{};
-  StringRef value{};
+  StringRef key_ref_{};
+  void set_key(const StringRef &ref) { this->key_ref_ = ref; }
+  std::string value{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1069,7 +1097,8 @@ class HomeassistantActionRequest final : public ProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "homeassistant_action_request"; }
 #endif
-  StringRef service{};
+  StringRef service_ref_{};
+  void set_service(const StringRef &ref) { this->service_ref_ = ref; }
   FixedVector<HomeassistantServiceMap> data{};
   FixedVector<HomeassistantServiceMap> data_template{};
   FixedVector<HomeassistantServiceMap> variables{};
@@ -1081,7 +1110,7 @@ class HomeassistantActionRequest final : public ProtoMessage {
   bool wants_response{false};
 #endif
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  StringRef response_template{};
+  std::string response_template{};
 #endif
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -1137,8 +1166,10 @@ class SubscribeHomeAssistantStateResponse final : public ProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "subscribe_home_assistant_state_response"; }
 #endif
-  StringRef entity_id{};
-  StringRef attribute{};
+  StringRef entity_id_ref_{};
+  void set_entity_id(const StringRef &ref) { this->entity_id_ref_ = ref; }
+  StringRef attribute_ref_{};
+  void set_attribute(const StringRef &ref) { this->attribute_ref_ = ref; }
   bool once{false};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -1199,7 +1230,8 @@ class GetTimeResponse final : public ProtoDecodableMessage {
 #ifdef USE_API_USER_DEFINED_ACTIONS
 class ListEntitiesServicesArgument final : public ProtoMessage {
  public:
-  StringRef name{};
+  StringRef name_ref_{};
+  void set_name(const StringRef &ref) { this->name_ref_ = ref; }
   enums::ServiceArgType type{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -1216,7 +1248,8 @@ class ListEntitiesServicesResponse final : public ProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_services_response"; }
 #endif
-  StringRef name{};
+  StringRef name_ref_{};
+  void set_name(const StringRef &ref) { this->name_ref_ = ref; }
   uint32_t key{0};
   FixedVector<ListEntitiesServicesArgument> args{};
   enums::SupportsResponseType supports_response{};
@@ -1285,7 +1318,8 @@ class ExecuteServiceResponse final : public ProtoMessage {
 #endif
   uint32_t call_id{0};
   bool success{false};
-  StringRef error_message{};
+  StringRef error_message_ref_{};
+  void set_error_message(const StringRef &ref) { this->error_message_ref_ = ref; }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
   const uint8_t *response_data{nullptr};
   uint16_t response_data_len{0};
@@ -1403,9 +1437,11 @@ class ClimateStateResponse final : public StateResponseProtoMessage {
   enums::ClimateAction action{};
   enums::ClimateFanMode fan_mode{};
   enums::ClimateSwingMode swing_mode{};
-  StringRef custom_fan_mode{};
+  StringRef custom_fan_mode_ref_{};
+  void set_custom_fan_mode(const StringRef &ref) { this->custom_fan_mode_ref_ = ref; }
   enums::ClimatePreset preset{};
-  StringRef custom_preset{};
+  StringRef custom_preset_ref_{};
+  void set_custom_preset(const StringRef &ref) { this->custom_preset_ref_ = ref; }
   float current_humidity{0.0f};
   float target_humidity{0.0f};
   void encode(ProtoWriteBuffer buffer) const override;
@@ -1528,9 +1564,11 @@ class ListEntitiesNumberResponse final : public InfoResponseProtoMessage {
   float min_value{0.0f};
   float max_value{0.0f};
   float step{0.0f};
-  StringRef unit_of_measurement{};
+  StringRef unit_of_measurement_ref_{};
+  void set_unit_of_measurement(const StringRef &ref) { this->unit_of_measurement_ref_ = ref; }
   enums::NumberMode mode{};
-  StringRef device_class{};
+  StringRef device_class_ref_{};
+  void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1597,7 +1635,8 @@ class SelectStateResponse final : public StateResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "select_state_response"; }
 #endif
-  StringRef state{};
+  StringRef state_ref_{};
+  void set_state(const StringRef &ref) { this->state_ref_ = ref; }
   bool missing_state{false};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -1696,7 +1735,8 @@ class ListEntitiesLockResponse final : public InfoResponseProtoMessage {
   bool assumed_state{false};
   bool supports_open{false};
   bool requires_code{false};
-  StringRef code_format{};
+  StringRef code_format_ref_{};
+  void set_code_format(const StringRef &ref) { this->code_format_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1749,7 +1789,8 @@ class ListEntitiesButtonResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_button_response"; }
 #endif
-  StringRef device_class{};
+  StringRef device_class_ref_{};
+  void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1777,7 +1818,8 @@ class ButtonCommandRequest final : public CommandProtoMessage {
 #ifdef USE_MEDIA_PLAYER
 class MediaPlayerSupportedFormat final : public ProtoMessage {
  public:
-  StringRef format{};
+  StringRef format_ref_{};
+  void set_format(const StringRef &ref) { this->format_ref_ = ref; }
   uint32_t sample_rate{0};
   uint32_t num_channels{0};
   enums::MediaPlayerFormatPurpose purpose{};
@@ -2382,10 +2424,12 @@ class VoiceAssistantRequest final : public ProtoMessage {
   const char *message_name() const override { return "voice_assistant_request"; }
 #endif
   bool start{false};
-  StringRef conversation_id{};
+  StringRef conversation_id_ref_{};
+  void set_conversation_id(const StringRef &ref) { this->conversation_id_ref_ = ref; }
   uint32_t flags{0};
   VoiceAssistantAudioSettings audio_settings{};
-  StringRef wake_word_phrase{};
+  StringRef wake_word_phrase_ref_{};
+  void set_wake_word_phrase(const StringRef &ref) { this->wake_word_phrase_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2516,8 +2560,10 @@ class VoiceAssistantAnnounceFinished final : public ProtoMessage {
 };
 class VoiceAssistantWakeWord final : public ProtoMessage {
  public:
-  StringRef id{};
-  StringRef wake_word{};
+  StringRef id_ref_{};
+  void set_id(const StringRef &ref) { this->id_ref_ = ref; }
+  StringRef wake_word_ref_{};
+  void set_wake_word(const StringRef &ref) { this->wake_word_ref_ = ref; }
   std::vector<std::string> trained_languages{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -2657,7 +2703,8 @@ class ListEntitiesTextResponse final : public InfoResponseProtoMessage {
 #endif
   uint32_t min_length{0};
   uint32_t max_length{0};
-  StringRef pattern{};
+  StringRef pattern_ref_{};
+  void set_pattern(const StringRef &ref) { this->pattern_ref_ = ref; }
   enums::TextMode mode{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -2674,7 +2721,8 @@ class TextStateResponse final : public StateResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "text_state_response"; }
 #endif
-  StringRef state{};
+  StringRef state_ref_{};
+  void set_state(const StringRef &ref) { this->state_ref_ = ref; }
   bool missing_state{false};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -2818,7 +2866,8 @@ class ListEntitiesEventResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_event_response"; }
 #endif
-  StringRef device_class{};
+  StringRef device_class_ref_{};
+  void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
   const FixedVector<const char *> *event_types{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -2835,7 +2884,8 @@ class EventResponse final : public StateResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "event_response"; }
 #endif
-  StringRef event_type{};
+  StringRef event_type_ref_{};
+  void set_event_type(const StringRef &ref) { this->event_type_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2853,7 +2903,8 @@ class ListEntitiesValveResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_valve_response"; }
 #endif
-  StringRef device_class{};
+  StringRef device_class_ref_{};
+  void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
   bool assumed_state{false};
   bool supports_position{false};
   bool supports_stop{false};
@@ -2959,7 +3010,8 @@ class ListEntitiesUpdateResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_update_response"; }
 #endif
-  StringRef device_class{};
+  StringRef device_class_ref_{};
+  void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2979,11 +3031,16 @@ class UpdateStateResponse final : public StateResponseProtoMessage {
   bool in_progress{false};
   bool has_progress{false};
   float progress{0.0f};
-  StringRef current_version{};
-  StringRef latest_version{};
-  StringRef title{};
-  StringRef release_summary{};
-  StringRef release_url{};
+  StringRef current_version_ref_{};
+  void set_current_version(const StringRef &ref) { this->current_version_ref_ = ref; }
+  StringRef latest_version_ref_{};
+  void set_latest_version(const StringRef &ref) { this->latest_version_ref_ = ref; }
+  StringRef title_ref_{};
+  void set_title(const StringRef &ref) { this->title_ref_ = ref; }
+  StringRef release_summary_ref_{};
+  void set_release_summary(const StringRef &ref) { this->release_summary_ref_ = ref; }
+  StringRef release_url_ref_{};
+  void set_release_url(const StringRef &ref) { this->release_url_ref_ = ref; }
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -3049,70 +3106,5 @@ class ZWaveProxyRequest final : public ProtoDecodableMessage {
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
 #endif
-#ifdef USE_INFRARED
-class ListEntitiesInfraredResponse final : public InfoResponseProtoMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 135;
-  static constexpr uint8_t ESTIMATED_SIZE = 44;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_infrared_response"; }
-#endif
-  uint32_t capabilities{0};
-  void encode(ProtoWriteBuffer buffer) const override;
-  void calculate_size(ProtoSize &size) const override;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  void dump_to(std::string &out) const override;
-#endif
-
- protected:
-};
-#endif
-#ifdef USE_IR_RF
-class InfraredRFTransmitRawTimingsRequest final : public ProtoDecodableMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 136;
-  static constexpr uint8_t ESTIMATED_SIZE = 220;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "infrared_rf_transmit_raw_timings_request"; }
-#endif
-#ifdef USE_DEVICES
-  uint32_t device_id{0};
-#endif
-  uint32_t key{0};
-  uint32_t carrier_frequency{0};
-  uint32_t repeat_count{0};
-  const uint8_t *timings_data_{nullptr};
-  uint16_t timings_length_{0};
-  uint16_t timings_count_{0};
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  void dump_to(std::string &out) const override;
-#endif
-
- protected:
-  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
-  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
-  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
-};
-class InfraredRFReceiveEvent final : public ProtoMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 137;
-  static constexpr uint8_t ESTIMATED_SIZE = 17;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "infrared_rf_receive_event"; }
-#endif
-#ifdef USE_DEVICES
-  uint32_t device_id{0};
-#endif
-  uint32_t key{0};
-  const std::vector<int32_t> *timings{};
-  void encode(ProtoWriteBuffer buffer) const override;
-  void calculate_size(ProtoSize &size) const override;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  void dump_to(std::string &out) const override;
-#endif
-
- protected:
-};
-#endif
 
 }  // namespace esphome::api

esphome/components/api/api_pb2_service.cpp

@@ -621,17 +621,6 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       this->on_water_heater_command_request(msg);
       break;
     }
-#endif
-#ifdef USE_IR_RF
-    case InfraredRFTransmitRawTimingsRequest::MESSAGE_TYPE: {
-      InfraredRFTransmitRawTimingsRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      ESP_LOGVV(TAG, "on_infrared_rf_transmit_raw_timings_request: %s", msg.dump().c_str());
-#endif
-      this->on_infrared_rf_transmit_raw_timings_request(msg);
-      break;
-    }
 #endif
     default:
       break;
@@ -830,11 +819,6 @@ void APIServerConnection::on_z_wave_proxy_frame(const ZWaveProxyFrame &msg) { th
 #ifdef USE_ZWAVE_PROXY
 void APIServerConnection::on_z_wave_proxy_request(const ZWaveProxyRequest &msg) { this->zwave_proxy_request(msg); }
 #endif
-#ifdef USE_IR_RF
-void APIServerConnection::on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg) {
-  this->infrared_rf_transmit_raw_timings(msg);
-}
-#endif
 
 void APIServerConnection::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {
   // Check authentication/connection requirements for messages

esphome/components/api/api_pb2_service.h

@@ -217,11 +217,6 @@ class APIServerConnectionBase : public ProtoService {
 #ifdef USE_ZWAVE_PROXY
   virtual void on_z_wave_proxy_request(const ZWaveProxyRequest &value){};
 #endif
-
-#ifdef USE_IR_RF
-  virtual void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &value){};
-#endif
-
  protected:
   void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;
 };
@@ -352,9 +347,6 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_ZWAVE_PROXY
   virtual void zwave_proxy_request(const ZWaveProxyRequest &msg) = 0;
-#endif
-#ifdef USE_IR_RF
-  virtual void infrared_rf_transmit_raw_timings(const InfraredRFTransmitRawTimingsRequest &msg) = 0;
 #endif
  protected:
   void on_hello_request(const HelloRequest &msg) override;
@@ -481,9 +473,6 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_ZWAVE_PROXY
   void on_z_wave_proxy_request(const ZWaveProxyRequest &msg) override;
-#endif
-#ifdef USE_IR_RF
-  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg) override;
 #endif
   void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;
 };

esphome/components/api/api_server.cpp

@@ -125,18 +125,15 @@ void APIServer::loop() {
       if (!sock)
         break;
 
-      char peername[socket::SOCKADDR_STR_LEN];
-      sock->getpeername_to(peername);
-
       // Check if we're at the connection limit
       if (this->clients_.size() >= this->max_connections_) {
-        ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, peername);
+        ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, sock->getpeername().c_str());
         // Immediately close - socket destructor will handle cleanup
         sock.reset();
         continue;
       }
 
-      ESP_LOGD(TAG, "Accept %s", peername);
+      ESP_LOGD(TAG, "Accept %s", sock->getpeername().c_str());
 
       auto *conn = new APIConnection(std::move(sock), this);
       this->clients_.emplace_back(conn);
@@ -169,7 +166,8 @@ void APIServer::loop() {
     // Network is down - disconnect all clients
     for (auto &client : this->clients_) {
       client->on_fatal_error();
-      client->log_client_(ESPHOME_LOG_LEVEL_WARN, LOG_STR("Network down; disconnect"));
+      ESP_LOGW(TAG, "%s (%s): Network down; disconnect", client->client_info_.name.c_str(),
+               client->client_info_.peername.c_str());
     }
     // Continue to process and clean up the clients below
   }
@@ -186,16 +184,13 @@ void APIServer::loop() {
     }
 
     // Rare case: handle disconnection
+#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
+    this->client_disconnected_trigger_->trigger(client->client_info_.name, client->client_info_.peername);
+#endif
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
     this->unregister_active_action_calls_for_connection(client.get());
 #endif
-    ESP_LOGV(TAG, "Remove connection %s", client->get_name());
-
-#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    // Save client info before removal for the trigger
-    std::string client_name(client->get_name());
-    std::string client_peername(client->get_peername());
-#endif
+    ESP_LOGV(TAG, "Remove connection %s", client->client_info_.name.c_str());
 
     // Swap with the last element and pop (avoids expensive vector shifts)
     if (client_index < this->clients_.size() - 1) {
@@ -208,11 +203,6 @@ void APIServer::loop() {
       this->status_set_warning();
       this->last_connected_ = App.get_loop_component_start_time();
     }
-
-#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    // Fire trigger after client is removed so api.connected reflects the true state
-    this->client_disconnected_trigger_->trigger(client_name, client_peername);
-#endif
     // Don't increment client_index since we need to process the swapped element
   }
 }
@@ -347,21 +337,6 @@ void APIServer::on_zwave_proxy_request(const esphome::api::ProtoMessage &msg) {
 }
 #endif
 
-#ifdef USE_IR_RF
-void APIServer::send_infrared_rf_receive_event([[maybe_unused]] uint32_t device_id, uint32_t key,
-                                               const std::vector<int32_t> *timings) {
-  InfraredRFReceiveEvent resp{};
-#ifdef USE_DEVICES
-  resp.device_id = device_id;
-#endif
-  resp.key = key;
-  resp.timings = timings;
-
-  for (auto &c : this->clients_)
-    c->send_infrared_rf_receive_event(resp);
-}
-#endif
-
 #ifdef USE_ALARM_CONTROL_PANEL
 API_DISPATCH_UPDATE(alarm_control_panel::AlarmControlPanel, alarm_control_panel)
 #endif
@@ -413,8 +388,8 @@ void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef
 
 #ifdef USE_API_HOMEASSISTANT_STATES
 // Helper to add subscription (reduces duplication)
-void APIServer::add_state_subscription_(const char *entity_id, const char *attribute, std::function<void(StringRef)> f,
-                                        bool once) {
+void APIServer::add_state_subscription_(const char *entity_id, const char *attribute,
+                                        std::function<void(std::string)> f, bool once) {
   this->state_subs_.push_back(HomeAssistantStateSubscription{
       .entity_id = entity_id, .attribute = attribute, .callback = std::move(f), .once = once,
       // entity_id_dynamic_storage and attribute_dynamic_storage remain nullptr (no heap allocation)
@@ -423,7 +398,7 @@ void APIServer::add_state_subscription_(const char *entity_id, const char *attri
 
 // Helper to add subscription with heap-allocated strings (reduces duplication)
 void APIServer::add_state_subscription_(std::string entity_id, optional<std::string> attribute,
-                                        std::function<void(StringRef)> f, bool once) {
+                                        std::function<void(std::string)> f, bool once) {
   HomeAssistantStateSubscription sub;
   // Allocate heap storage for the strings
   sub.entity_id_dynamic_storage = std::make_unique<std::string>(std::move(entity_id));
@@ -443,43 +418,23 @@ void APIServer::add_state_subscription_(std::string entity_id, optional<std::str
 
 // New const char* overload (for internal components - zero allocation)
 void APIServer::subscribe_home_assistant_state(const char *entity_id, const char *attribute,
-                                               std::function<void(StringRef)> f) {
+                                               std::function<void(std::string)> f) {
   this->add_state_subscription_(entity_id, attribute, std::move(f), false);
 }
 
 void APIServer::get_home_assistant_state(const char *entity_id, const char *attribute,
-                                         std::function<void(StringRef)> f) {
+                                         std::function<void(std::string)> f) {
   this->add_state_subscription_(entity_id, attribute, std::move(f), true);
 }
 
-// std::string overload with StringRef callback (zero-allocation callback)
+// Existing std::string overload (for custom_api_device.h - heap allocation)
 void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                               std::function<void(StringRef)> f) {
+                                               std::function<void(std::string)> f) {
   this->add_state_subscription_(std::move(entity_id), std::move(attribute), std::move(f), false);
 }
 
 void APIServer::get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                         std::function<void(StringRef)> f) {
-  this->add_state_subscription_(std::move(entity_id), std::move(attribute), std::move(f), true);
-}
-
-// Legacy helper: wraps std::string callback and delegates to StringRef version
-void APIServer::add_state_subscription_(std::string entity_id, optional<std::string> attribute,
-                                        std::function<void(const std::string &)> f, bool once) {
-  // Wrap callback to convert StringRef -> std::string, then delegate
-  this->add_state_subscription_(std::move(entity_id), std::move(attribute),
-                                std::function<void(StringRef)>([f = std::move(f)](StringRef state) { f(state.str()); }),
-                                once);
-}
-
-// Legacy std::string overload (for custom_api_device.h - converts StringRef to std::string)
-void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                               std::function<void(const std::string &)> f) {
-  this->add_state_subscription_(std::move(entity_id), std::move(attribute), std::move(f), false);
-}
-
-void APIServer::get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                         std::function<void(const std::string &)> f) {
+                                         std::function<void(std::string)> f) {
   this->add_state_subscription_(std::move(entity_id), std::move(attribute), std::move(f), true);
 }
 
@@ -639,14 +594,6 @@ bool APIServer::teardown() {
 #define USE_API_ACTION_CALL_TIMEOUT_MS 30000  // NOLINT
 #endif
 
-// SSO-friendly action call key - hex format guarantees max 11 chars ("ac_ffffffff")
-// which fits in any std::string SSO buffer (typically 12-15 bytes)
-static inline std::string make_action_call_key(uint32_t id) {
-  char buf[12];
-  size_t len = snprintf(buf, sizeof(buf), "ac_%x", id);
-  return std::string(buf, len);
-}
-
 uint32_t APIServer::register_active_action_call(uint32_t client_call_id, APIConnection *conn) {
   uint32_t action_call_id = this->next_action_call_id_++;
   // Handle wraparound (skip 0 as it means "no call")
@@ -656,17 +603,18 @@ uint32_t APIServer::register_active_action_call(uint32_t client_call_id, APIConn
   this->active_action_calls_.push_back({action_call_id, client_call_id, conn});
 
   // Schedule automatic cleanup after timeout (client will have given up by then)
-  this->set_timeout(make_action_call_key(action_call_id), USE_API_ACTION_CALL_TIMEOUT_MS, [this, action_call_id]() {
-    ESP_LOGD(TAG, "Action call %u timed out", action_call_id);
-    this->unregister_active_action_call(action_call_id);
-  });
+  this->set_timeout(str_sprintf("action_call_%u", action_call_id), USE_API_ACTION_CALL_TIMEOUT_MS,
+                    [this, action_call_id]() {
+                      ESP_LOGD(TAG, "Action call %u timed out", action_call_id);
+                      this->unregister_active_action_call(action_call_id);
+                    });
 
   return action_call_id;
 }
 
 void APIServer::unregister_active_action_call(uint32_t action_call_id) {
   // Cancel the timeout for this action call
-  this->cancel_timeout(make_action_call_key(action_call_id));
+  this->cancel_timeout(str_sprintf("action_call_%u", action_call_id));
 
   // Swap-and-pop is more efficient than remove_if for unordered vectors
   for (size_t i = 0; i < this->active_action_calls_.size(); i++) {
@@ -683,7 +631,7 @@ void APIServer::unregister_active_action_calls_for_connection(APIConnection *con
   for (size_t i = 0; i < this->active_action_calls_.size();) {
     if (this->active_action_calls_[i].connection == conn) {
       // Cancel the timeout for this action call
-      this->cancel_timeout(make_action_call_key(this->active_action_calls_[i].action_call_id));
+      this->cancel_timeout(str_sprintf("action_call_%u", this->active_action_calls_[i].action_call_id));
 
       std::swap(this->active_action_calls_[i], this->active_action_calls_.back());
       this->active_action_calls_.pop_back();

esphome/components/api/api_server.h

@@ -10,7 +10,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/controller.h"
 #include "esphome/core/log.h"
-#include "esphome/core/string_ref.h"
 #include "list_entities.h"
 #include "subscribe_state.h"
 #ifdef USE_LOGGER
@@ -185,9 +184,6 @@ class APIServer : public Component,
 #ifdef USE_ZWAVE_PROXY
   void on_zwave_proxy_request(const esphome::api::ProtoMessage &msg);
 #endif
-#ifdef USE_IR_RF
-  void send_infrared_rf_receive_event(uint32_t device_id, uint32_t key, const std::vector<int32_t> *timings);
-#endif
 
   bool is_connected(bool state_subscription_only = false) const;
 
@@ -195,7 +191,7 @@ class APIServer : public Component,
   struct HomeAssistantStateSubscription {
     const char *entity_id;  // Pointer to flash (internal) or heap (external)
     const char *attribute;  // Pointer to flash or nullptr (nullptr means no attribute)
-    std::function<void(StringRef)> callback;
+    std::function<void(std::string)> callback;
     bool once;
 
     // Dynamic storage for external components using std::string API (custom_api_device.h)
@@ -205,20 +201,14 @@ class APIServer : public Component,
   };
 
   // New const char* overload (for internal components - zero allocation)
-  void subscribe_home_assistant_state(const char *entity_id, const char *attribute, std::function<void(StringRef)> f);
-  void get_home_assistant_state(const char *entity_id, const char *attribute, std::function<void(StringRef)> f);
+  void subscribe_home_assistant_state(const char *entity_id, const char *attribute, std::function<void(std::string)> f);
+  void get_home_assistant_state(const char *entity_id, const char *attribute, std::function<void(std::string)> f);
 
-  // std::string overload with StringRef callback (for custom_api_device.h with zero-allocation callback)
+  // Existing std::string overload (for custom_api_device.h - heap allocation)
   void subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                      std::function<void(StringRef)> f);
+                                      std::function<void(std::string)> f);
   void get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                std::function<void(StringRef)> f);
-
-  // Legacy std::string overload (for custom_api_device.h - converts StringRef to std::string for callback)
-  void subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                      std::function<void(const std::string &)> f);
-  void get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                std::function<void(const std::string &)> f);
+                                std::function<void(std::string)> f);
 
   const std::vector<HomeAssistantStateSubscription> &get_state_subs() const;
 #endif
@@ -242,13 +232,10 @@ class APIServer : public Component,
 #endif  // USE_API_NOISE
 #ifdef USE_API_HOMEASSISTANT_STATES
   // Helper methods to reduce code duplication
-  void add_state_subscription_(const char *entity_id, const char *attribute, std::function<void(StringRef)> f,
+  void add_state_subscription_(const char *entity_id, const char *attribute, std::function<void(std::string)> f,
                                bool once);
-  void add_state_subscription_(std::string entity_id, optional<std::string> attribute, std::function<void(StringRef)> f,
-                               bool once);
-  // Legacy helper: wraps std::string callback and delegates to StringRef version
   void add_state_subscription_(std::string entity_id, optional<std::string> attribute,
-                               std::function<void(const std::string &)> f, bool once);
+                               std::function<void(std::string)> f, bool once);
 #endif  // USE_API_HOMEASSISTANT_STATES
   // Pointers and pointer-like types first (4 bytes each)
   std::unique_ptr<socket::Socket> socket_ = nullptr;

esphome/components/api/custom_api_device.h

@@ -122,36 +122,21 @@ class CustomAPIDevice {
    *   subscribe_homeassistant_state(&CustomNativeAPI::on_state_changed, "climate.kitchen", "current_temperature");
    * }
    *
-   * void on_state_changed(StringRef state) {
-   *   // State of climate.kitchen current_temperature is `state`
-   *   // Use state.c_str() for C string, state.str() for std::string
+   * void on_state_changed(std::string state) {
+   *   // State of sensor.weather_forecast is `state`
    * }
    * ```
    *
    * @tparam T The class type creating the service, automatically deduced from the function pointer.
-   * @param callback The member function to call when the entity state changes (zero-allocation).
+   * @param callback The member function to call when the entity state changes.
    * @param entity_id The entity_id to track.
    * @param attribute The entity state attribute to track.
    */
   template<typename T>
-  void subscribe_homeassistant_state(void (T::*callback)(StringRef), const std::string &entity_id,
-                                     const std::string &attribute = "") {
-    auto f = std::bind(callback, (T *) this, std::placeholders::_1);
-    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), std::move(f));
-  }
-
-  /** Subscribe to the state (or attribute state) of an entity from Home Assistant (legacy std::string version).
-   *
-   * @deprecated Use the StringRef overload for zero-allocation callbacks. Will be removed in 2027.1.0.
-   */
-  template<typename T>
-  ESPDEPRECATED("Use void callback(StringRef) instead. Will be removed in 2027.1.0.", "2026.1.0")
   void subscribe_homeassistant_state(void (T::*callback)(std::string), const std::string &entity_id,
                                      const std::string &attribute = "") {
     auto f = std::bind(callback, (T *) this, std::placeholders::_1);
-    // Explicit type to disambiguate overload resolution
-    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute),
-                                                      std::function<void(const std::string &)>(f));
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), f);
   }
 
   /** Subscribe to the state (or attribute state) of an entity from Home Assistant.
@@ -163,45 +148,23 @@ class CustomAPIDevice {
    *   subscribe_homeassistant_state(&CustomNativeAPI::on_state_changed, "sensor.weather_forecast");
    * }
    *
-   * void on_state_changed(const std::string &entity_id, StringRef state) {
+   * void on_state_changed(std::string entity_id, std::string state) {
    *   // State of `entity_id` is `state`
    * }
    * ```
    *
    * @tparam T The class type creating the service, automatically deduced from the function pointer.
-   * @param callback The member function to call when the entity state changes (zero-allocation for state).
+   * @param callback The member function to call when the entity state changes.
    * @param entity_id The entity_id to track.
    * @param attribute The entity state attribute to track.
    */
   template<typename T>
-  void subscribe_homeassistant_state(void (T::*callback)(const std::string &, StringRef), const std::string &entity_id,
-                                     const std::string &attribute = "") {
-    auto f = std::bind(callback, (T *) this, entity_id, std::placeholders::_1);
-    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), std::move(f));
-  }
-
-  /** Subscribe to the state (or attribute state) of an entity from Home Assistant (legacy std::string version).
-   *
-   * @deprecated Use the StringRef overload for zero-allocation callbacks. Will be removed in 2027.1.0.
-   */
-  template<typename T>
-  ESPDEPRECATED("Use void callback(const std::string &, StringRef) instead. Will be removed in 2027.1.0.", "2026.1.0")
   void subscribe_homeassistant_state(void (T::*callback)(std::string, std::string), const std::string &entity_id,
                                      const std::string &attribute = "") {
     auto f = std::bind(callback, (T *) this, entity_id, std::placeholders::_1);
-    // Explicit type to disambiguate overload resolution
-    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute),
-                                                      std::function<void(const std::string &)>(f));
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), f);
   }
 #else
-  template<typename T>
-  void subscribe_homeassistant_state(void (T::*callback)(StringRef), const std::string &entity_id,
-                                     const std::string &attribute = "") {
-    static_assert(sizeof(T) == 0,
-                  "subscribe_homeassistant_state() requires 'homeassistant_states: true' in the 'api:' section "
-                  "of your YAML configuration");
-  }
-
   template<typename T>
   void subscribe_homeassistant_state(void (T::*callback)(std::string), const std::string &entity_id,
                                      const std::string &attribute = "") {
@@ -210,14 +173,6 @@ class CustomAPIDevice {
                   "of your YAML configuration");
   }
 
-  template<typename T>
-  void subscribe_homeassistant_state(void (T::*callback)(const std::string &, StringRef), const std::string &entity_id,
-                                     const std::string &attribute = "") {
-    static_assert(sizeof(T) == 0,
-                  "subscribe_homeassistant_state() requires 'homeassistant_states: true' in the 'api:' section "
-                  "of your YAML configuration");
-  }
-
   template<typename T>
   void subscribe_homeassistant_state(void (T::*callback)(std::string, std::string), const std::string &entity_id,
                                      const std::string &attribute = "") {
@@ -240,7 +195,7 @@ class CustomAPIDevice {
    */
   void call_homeassistant_service(const std::string &service_name) {
     HomeassistantActionRequest resp;
-    resp.service = StringRef(service_name);
+    resp.set_service(StringRef(service_name));
     global_api_server->send_homeassistant_action(resp);
   }
 
@@ -260,12 +215,12 @@ class CustomAPIDevice {
    */
   void call_homeassistant_service(const std::string &service_name, const std::map<std::string, std::string> &data) {
     HomeassistantActionRequest resp;
-    resp.service = StringRef(service_name);
+    resp.set_service(StringRef(service_name));
     resp.data.init(data.size());
     for (auto &it : data) {
       auto &kv = resp.data.emplace_back();
-      kv.key = StringRef(it.first);
-      kv.value = StringRef(it.second);  // data map lives until send completes
+      kv.set_key(StringRef(it.first));
+      kv.value = it.second;
     }
     global_api_server->send_homeassistant_action(resp);
   }
@@ -282,7 +237,7 @@ class CustomAPIDevice {
    */
   void fire_homeassistant_event(const std::string &event_name) {
     HomeassistantActionRequest resp;
-    resp.service = StringRef(event_name);
+    resp.set_service(StringRef(event_name));
     resp.is_event = true;
     global_api_server->send_homeassistant_action(resp);
   }
@@ -302,13 +257,13 @@ class CustomAPIDevice {
    */
   void fire_homeassistant_event(const std::string &service_name, const std::map<std::string, std::string> &data) {
     HomeassistantActionRequest resp;
-    resp.service = StringRef(service_name);
+    resp.set_service(StringRef(service_name));
     resp.is_event = true;
     resp.data.init(data.size());
     for (auto &it : data) {
       auto &kv = resp.data.emplace_back();
-      kv.key = StringRef(it.first);
-      kv.value = StringRef(it.second);  // data map lives until send completes
+      kv.set_key(StringRef(it.first));
+      kv.value = it.second;
     }
     global_api_server->send_homeassistant_action(resp);
   }

esphome/components/api/homeassistant_service.h

@@ -147,23 +147,13 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
   void play(const Ts &...x) override {
     HomeassistantActionRequest resp;
     std::string service_value = this->service_.value(x...);
-    resp.service = StringRef(service_value);
+    resp.set_service(StringRef(service_value));
     resp.is_event = this->flags_.is_event;
-
-    // Local storage for lambda-evaluated strings - lives until after send
-    FixedVector<std::string> data_storage;
-    FixedVector<std::string> data_template_storage;
-    FixedVector<std::string> variables_storage;
-
-    this->populate_service_map(resp.data, this->data_, data_storage, x...);
-    this->populate_service_map(resp.data_template, this->data_template_, data_template_storage, x...);
-    this->populate_service_map(resp.variables, this->variables_, variables_storage, x...);
+    this->populate_service_map(resp.data, this->data_, x...);
+    this->populate_service_map(resp.data_template, this->data_template_, x...);
+    this->populate_service_map(resp.variables, this->variables_, x...);
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-    // IMPORTANT: Declare at outer scope so it lives until send_homeassistant_action returns.
-    std::string response_template_value;
-#endif
     if (this->flags_.wants_status) {
       // Generate a unique call ID for this service call
       static uint32_t call_id_counter = 1;
@@ -174,8 +164,8 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
         resp.wants_response = true;
         // Set response template if provided
         if (this->flags_.has_response_template) {
-          response_template_value = this->response_template_.value(x...);
-          resp.response_template = StringRef(response_template_value);
+          std::string response_template_value = this->response_template_.value(x...);
+          resp.response_template = response_template_value;
         }
       }
 #endif
@@ -215,31 +205,12 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
   }
 
   template<typename VectorType, typename SourceType>
-  static void populate_service_map(VectorType &dest, SourceType &source, FixedVector<std::string> &value_storage,
-                                   Ts... x) {
+  static void populate_service_map(VectorType &dest, SourceType &source, Ts... x) {
     dest.init(source.size());
-
-    // Count non-static strings to allocate exact storage needed
-    size_t lambda_count = 0;
-    for (const auto &it : source) {
-      if (!it.value.is_static_string()) {
-        lambda_count++;
-      }
-    }
-    value_storage.init(lambda_count);
-
     for (auto &it : source) {
       auto &kv = dest.emplace_back();
-      kv.key = StringRef(it.key);
-
-      if (it.value.is_static_string()) {
-        // Static string from YAML - zero allocation
-        kv.value = StringRef(it.value.get_static_string());
-      } else {
-        // Lambda evaluation - store result, reference it
-        value_storage.push_back(it.value.value(x...));
-        kv.value = StringRef(value_storage.back());
-      }
+      kv.set_key(StringRef(it.key));
+      kv.value = it.value.value(x...);
     }
   }
 

esphome/components/api/list_entities.cpp

@@ -76,9 +76,6 @@ LIST_ENTITIES_HANDLER(alarm_control_panel, alarm_control_panel::AlarmControlPane
 #ifdef USE_WATER_HEATER
 LIST_ENTITIES_HANDLER(water_heater, water_heater::WaterHeater, ListEntitiesWaterHeaterResponse)
 #endif
-#ifdef USE_INFRARED
-LIST_ENTITIES_HANDLER(infrared, infrared::Infrared, ListEntitiesInfraredResponse)
-#endif
 #ifdef USE_EVENT
 LIST_ENTITIES_HANDLER(event, event::Event, ListEntitiesEventResponse)
 #endif

esphome/components/api/list_entities.h

@@ -85,9 +85,6 @@ class ListEntitiesIterator : public ComponentIterator {
 #ifdef USE_WATER_HEATER
   bool on_water_heater(water_heater::WaterHeater *entity) override;
 #endif
-#ifdef USE_INFRARED
-  bool on_infrared(infrared::Infrared *entity) override;
-#endif
 #ifdef USE_EVENT
   bool on_event(event::Event *entity) override;
 #endif

esphome/components/api/proto.h

@@ -39,24 +39,6 @@ inline constexpr int64_t decode_zigzag64(uint64_t value) {
   return (value & 1) ? static_cast<int64_t>(~(value >> 1)) : static_cast<int64_t>(value >> 1);
 }
 
-/// Count number of varints in a packed buffer
-inline uint16_t count_packed_varints(const uint8_t *data, size_t len) {
-  uint16_t count = 0;
-  while (len > 0) {
-    // Skip varint bytes until we find one without continuation bit
-    while (len > 0 && (*data & 0x80)) {
-      data++;
-      len--;
-    }
-    if (len > 0) {
-      data++;
-      len--;
-      count++;
-    }
-  }
-  return count;
-}
-
 /*
  * StringRef Ownership Model for API Protocol Messages
  * ===================================================
@@ -72,16 +54,16 @@ inline uint16_t count_packed_varints(const uint8_t *data, size_t len) {
  * 3. Global/static strings: StringRef(GLOBAL_CONSTANT) - Always safe
  * 4. Local variables: Safe ONLY if encoding happens before function returns:
  *    std::string temp = compute_value();
- *    msg.field = StringRef(temp);
+ *    msg.set_field(StringRef(temp));
  *    return this->send_message(msg);  // temp is valid during encoding
  *
  * Unsafe Patterns (WILL cause crashes/corruption):
- * 1. Temporaries: msg.field = StringRef(obj.get_string()) // get_string() returns by value
- * 2. Concatenation: msg.field = StringRef(str1 + str2) // Result is temporary
+ * 1. Temporaries: msg.set_field(StringRef(obj.get_string())) // get_string() returns by value
+ * 2. Concatenation: msg.set_field(StringRef(str1 + str2)) // Result is temporary
  *
  * For unsafe patterns, store in a local variable first:
  *    std::string temp = get_string();  // or str1 + str2
- *    msg.field = StringRef(temp);
+ *    msg.set_field(StringRef(temp));
  *
  * The send_*_response pattern ensures proper lifetime management by encoding
  * within the same function scope where temporaries are created.
@@ -198,10 +180,9 @@ class ProtoVarInt {
   uint64_t value_;
 };
 
-// Forward declarations for decode_to_message, encode_message and encode_packed_sint32
-class ProtoDecodableMessage;
+// Forward declaration for decode_to_message and encode_to_writer
 class ProtoMessage;
-class ProtoSize;
+class ProtoDecodableMessage;
 
 class ProtoLengthDelimited {
  public:
@@ -353,8 +334,6 @@ class ProtoWriteBuffer {
   void encode_sint64(uint32_t field_id, int64_t value, bool force = false) {
     this->encode_uint64(field_id, encode_zigzag64(value), force);
   }
-  /// Encode a packed repeated sint32 field (zero-copy from vector)
-  void encode_packed_sint32(uint32_t field_id, const std::vector<int32_t> &values);
   void encode_message(uint32_t field_id, const ProtoMessage &value);
   std::vector<uint8_t> *get_buffer() const { return buffer_; }
 
@@ -362,6 +341,9 @@ class ProtoWriteBuffer {
   std::vector<uint8_t> *buffer_;
 };
 
+// Forward declaration
+class ProtoSize;
+
 class ProtoMessage {
  public:
   virtual ~ProtoMessage() = default;
@@ -810,43 +792,8 @@ class ProtoSize {
       }
     }
   }
-
-  /**
-   * @brief Calculate size of a packed repeated sint32 field
-   */
-  inline void add_packed_sint32(uint32_t field_id_size, const std::vector<int32_t> &values) {
-    if (values.empty())
-      return;
-
-    size_t packed_size = 0;
-    for (int value : values) {
-      packed_size += varint(encode_zigzag32(value));
-    }
-
-    // field_id + length varint + packed data
-    total_size_ += field_id_size + varint(static_cast<uint32_t>(packed_size)) + static_cast<uint32_t>(packed_size);
-  }
 };
 
-// Implementation of encode_packed_sint32 - must be after ProtoSize is defined
-inline void ProtoWriteBuffer::encode_packed_sint32(uint32_t field_id, const std::vector<int32_t> &values) {
-  if (values.empty())
-    return;
-
-  // Calculate packed size
-  size_t packed_size = 0;
-  for (int value : values) {
-    packed_size += ProtoSize::varint(encode_zigzag32(value));
-  }
-
-  // Write tag (LENGTH_DELIMITED) + length + all zigzag-encoded values
-  this->encode_field_raw(field_id, WIRE_TYPE_LENGTH_DELIMITED);
-  this->encode_varint_raw(packed_size);
-  for (int value : values) {
-    this->encode_varint_raw(encode_zigzag32(value));
-  }
-}
-
 // Implementation of encode_message - must be after ProtoMessage is defined
 inline void ProtoWriteBuffer::encode_message(uint32_t field_id, const ProtoMessage &value) {
   this->encode_field_raw(field_id, 2);  // type 2: Length-delimited message

esphome/components/api/subscribe_state.h

@@ -79,9 +79,6 @@ class InitialStateIterator : public ComponentIterator {
 #ifdef USE_WATER_HEATER
   bool on_water_heater(water_heater::WaterHeater *entity) override;
 #endif
-#ifdef USE_INFRARED
-  bool on_infrared(infrared::Infrared *infrared) override { return true; };
-#endif
 #ifdef USE_EVENT
   bool on_event(event::Event *event) override { return true; };
 #endif

esphome/components/api/user_services.h

@@ -46,7 +46,7 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
 
   ListEntitiesServicesResponse encode_list_service_response() override {
     ListEntitiesServicesResponse msg;
-    msg.name = StringRef(this->name_);
+    msg.set_name(StringRef(this->name_));
     msg.key = this->key_;
     msg.supports_response = this->supports_response_;
     std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
@@ -54,7 +54,7 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
     for (size_t i = 0; i < sizeof...(Ts); i++) {
       auto &arg = msg.args.emplace_back();
       arg.type = arg_types[i];
-      arg.name = StringRef(this->arg_names_[i]);
+      arg.set_name(StringRef(this->arg_names_[i]));
     }
     return msg;
   }
@@ -108,7 +108,7 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
 
   ListEntitiesServicesResponse encode_list_service_response() override {
     ListEntitiesServicesResponse msg;
-    msg.name = StringRef(this->name_);
+    msg.set_name(StringRef(this->name_));
     msg.key = this->key_;
     msg.supports_response = enums::SUPPORTS_RESPONSE_NONE;  // Dynamic services don't support responses yet
     std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
@@ -116,7 +116,7 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
     for (size_t i = 0; i < sizeof...(Ts); i++) {
       auto &arg = msg.args.emplace_back();
       arg.type = arg_types[i];
-      arg.name = StringRef(this->arg_names_[i]);
+      arg.set_name(StringRef(this->arg_names_[i]));
     }
     return msg;
   }

esphome/components/aqi/abstract_aqi_calculator.h

@@ -6,7 +6,7 @@ namespace esphome::aqi {
 
 class AbstractAQICalculator {
  public:
-  virtual uint16_t get_aqi(float pm2_5_value, float pm10_0_value) = 0;
+  virtual uint16_t get_aqi(uint16_t pm2_5_value, uint16_t pm10_0_value) = 0;
 };
 
 }  // namespace esphome::aqi

esphome/components/aqi/aqi_calculator.h

@@ -1,7 +1,6 @@
 #pragma once
 
-#include <cmath>
-#include <limits>
+#include <climits>
 #include "abstract_aqi_calculator.h"
 
 // https://document.airnow.gov/technical-assistance-document-for-the-reporting-of-daily-air-quailty.pdf
@@ -10,41 +9,39 @@ namespace esphome::aqi {
 
 class AQICalculator : public AbstractAQICalculator {
  public:
-  uint16_t get_aqi(float pm2_5_value, float pm10_0_value) override {
-    float pm2_5_index = calculate_index(pm2_5_value, PM2_5_GRID);
-    float pm10_0_index = calculate_index(pm10_0_value, PM10_0_GRID);
+  uint16_t get_aqi(uint16_t pm2_5_value, uint16_t pm10_0_value) override {
+    int pm2_5_index = calculate_index_(pm2_5_value, pm2_5_calculation_grid_);
+    int pm10_0_index = calculate_index_(pm10_0_value, pm10_0_calculation_grid_);
 
-    return static_cast<uint16_t>(std::round((pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index));
+    return (pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index;
   }
 
  protected:
-  static constexpr int NUM_LEVELS = 6;
+  static const int AMOUNT_OF_LEVELS = 6;
 
-  static constexpr int INDEX_GRID[NUM_LEVELS][2] = {{0, 50}, {51, 100}, {101, 150}, {151, 200}, {201, 300}, {301, 500}};
+  int index_grid_[AMOUNT_OF_LEVELS][2] = {{0, 50}, {51, 100}, {101, 150}, {151, 200}, {201, 300}, {301, 500}};
 
-  static constexpr float PM2_5_GRID[NUM_LEVELS][2] = {{0.0f, 9.0f},     {9.1f, 35.4f},
-                                                      {35.5f, 55.4f},   {55.5f, 125.4f},
-                                                      {125.5f, 225.4f}, {225.5f, std::numeric_limits<float>::max()}};
+  int pm2_5_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 9},    {10, 35},   {36, 55},
+                                                      {56, 125}, {126, 225}, {226, INT_MAX}};
 
-  static constexpr float PM10_0_GRID[NUM_LEVELS][2] = {{0.0f, 54.0f},    {55.0f, 154.0f},
-                                                       {155.0f, 254.0f}, {255.0f, 354.0f},
-                                                       {355.0f, 424.0f}, {425.0f, std::numeric_limits<float>::max()}};
+  int pm10_0_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 54},    {55, 154},  {155, 254},
+                                                       {255, 354}, {355, 424}, {425, INT_MAX}};
 
-  static float calculate_index(float value, const float array[NUM_LEVELS][2]) {
-    int grid_index = get_grid_index(value, array);
+  int calculate_index_(uint16_t value, int array[AMOUNT_OF_LEVELS][2]) {
+    int grid_index = get_grid_index_(value, array);
     if (grid_index == -1) {
-      return -1.0f;
+      return -1;
     }
-    float aqi_lo = INDEX_GRID[grid_index][0];
-    float aqi_hi = INDEX_GRID[grid_index][1];
-    float conc_lo = array[grid_index][0];
-    float conc_hi = array[grid_index][1];
+    int aqi_lo = index_grid_[grid_index][0];
+    int aqi_hi = index_grid_[grid_index][1];
+    int conc_lo = array[grid_index][0];
+    int conc_hi = array[grid_index][1];
 
     return (value - conc_lo) * (aqi_hi - aqi_lo) / (conc_hi - conc_lo) + aqi_lo;
   }
 
-  static int get_grid_index(float value, const float array[NUM_LEVELS][2]) {
-    for (int i = 0; i < NUM_LEVELS; i++) {
+  int get_grid_index_(uint16_t value, int array[AMOUNT_OF_LEVELS][2]) {
+    for (int i = 0; i < AMOUNT_OF_LEVELS; i++) {
       if (value >= array[i][0] && value <= array[i][1]) {
         return i;
       }

esphome/components/aqi/aqi_sensor.cpp

@@ -1,51 +0,0 @@
-#include "aqi_sensor.h"
-#include "esphome/core/log.h"
-
-namespace esphome::aqi {
-
-static const char *const TAG = "aqi";
-
-void AQISensor::setup() {
-  if (this->pm_2_5_sensor_ != nullptr) {
-    this->pm_2_5_sensor_->add_on_state_callback([this](float value) {
-      this->pm_2_5_value_ = value;
-      // Defer calculation to avoid double-publishing if both sensors update in the same loop
-      this->defer("update", [this]() { this->calculate_aqi_(); });
-    });
-  }
-  if (this->pm_10_0_sensor_ != nullptr) {
-    this->pm_10_0_sensor_->add_on_state_callback([this](float value) {
-      this->pm_10_0_value_ = value;
-      this->defer("update", [this]() { this->calculate_aqi_(); });
-    });
-  }
-}
-
-void AQISensor::dump_config() {
-  ESP_LOGCONFIG(TAG, "AQI Sensor:");
-  ESP_LOGCONFIG(TAG, "  Calculation Type: %s", this->aqi_calc_type_ == AQI_TYPE ? "AQI" : "CAQI");
-  if (this->pm_2_5_sensor_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  PM2.5 Sensor: '%s'", this->pm_2_5_sensor_->get_name().c_str());
-  }
-  if (this->pm_10_0_sensor_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  PM10 Sensor: '%s'", this->pm_10_0_sensor_->get_name().c_str());
-  }
-  LOG_SENSOR("  ", "AQI", this);
-}
-
-void AQISensor::calculate_aqi_() {
-  if (std::isnan(this->pm_2_5_value_) || std::isnan(this->pm_10_0_value_)) {
-    return;
-  }
-
-  AbstractAQICalculator *calculator = this->aqi_calculator_factory_.get_calculator(this->aqi_calc_type_);
-  if (calculator == nullptr) {
-    ESP_LOGW(TAG, "Unknown AQI calculator type");
-    return;
-  }
-
-  uint16_t aqi = calculator->get_aqi(this->pm_2_5_value_, this->pm_10_0_value_);
-  this->publish_state(aqi);
-}
-
-}  // namespace esphome::aqi

esphome/components/aqi/aqi_sensor.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
-#include "aqi_calculator_factory.h"
-
-namespace esphome::aqi {
-
-class AQISensor : public sensor::Sensor, public Component {
- public:
-  void setup() override;
-  void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
-  void set_pm_2_5_sensor(sensor::Sensor *sensor) { this->pm_2_5_sensor_ = sensor; }
-  void set_pm_10_0_sensor(sensor::Sensor *sensor) { this->pm_10_0_sensor_ = sensor; }
-  void set_aqi_calculation_type(AQICalculatorType type) { this->aqi_calc_type_ = type; }
-
- protected:
-  void calculate_aqi_();
-
-  sensor::Sensor *pm_2_5_sensor_{nullptr};
-  sensor::Sensor *pm_10_0_sensor_{nullptr};
-  AQICalculatorType aqi_calc_type_{AQI_TYPE};
-  AQICalculatorFactory aqi_calculator_factory_;
-
-  float pm_2_5_value_{NAN};
-  float pm_10_0_value_{NAN};
-};
-
-}  // namespace esphome::aqi

esphome/components/aqi/caqi_calculator.h

@@ -1,47 +1,44 @@
 #pragma once
 
-#include <cmath>
-#include <limits>
+#include "esphome/core/log.h"
 #include "abstract_aqi_calculator.h"
 
 namespace esphome::aqi {
 
 class CAQICalculator : public AbstractAQICalculator {
  public:
-  uint16_t get_aqi(float pm2_5_value, float pm10_0_value) override {
-    float pm2_5_index = calculate_index(pm2_5_value, PM2_5_GRID);
-    float pm10_0_index = calculate_index(pm10_0_value, PM10_0_GRID);
+  uint16_t get_aqi(uint16_t pm2_5_value, uint16_t pm10_0_value) override {
+    int pm2_5_index = calculate_index_(pm2_5_value, pm2_5_calculation_grid_);
+    int pm10_0_index = calculate_index_(pm10_0_value, pm10_0_calculation_grid_);
 
-    return static_cast<uint16_t>(std::round((pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index));
+    return (pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index;
   }
 
  protected:
-  static constexpr int NUM_LEVELS = 5;
+  static const int AMOUNT_OF_LEVELS = 5;
 
-  static constexpr int INDEX_GRID[NUM_LEVELS][2] = {{0, 25}, {26, 50}, {51, 75}, {76, 100}, {101, 400}};
+  int index_grid_[AMOUNT_OF_LEVELS][2] = {{0, 25}, {26, 50}, {51, 75}, {76, 100}, {101, 400}};
 
-  static constexpr float PM2_5_GRID[NUM_LEVELS][2] = {
-      {0.0f, 15.0f}, {15.1f, 30.0f}, {30.1f, 55.0f}, {55.1f, 110.0f}, {110.1f, std::numeric_limits<float>::max()}};
+  int pm2_5_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 15}, {16, 30}, {31, 55}, {56, 110}, {111, 400}};
 
-  static constexpr float PM10_0_GRID[NUM_LEVELS][2] = {
-      {0.0f, 25.0f}, {25.1f, 50.0f}, {50.1f, 90.0f}, {90.1f, 180.0f}, {180.1f, std::numeric_limits<float>::max()}};
+  int pm10_0_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 25}, {26, 50}, {51, 90}, {91, 180}, {181, 400}};
 
-  static float calculate_index(float value, const float array[NUM_LEVELS][2]) {
-    int grid_index = get_grid_index(value, array);
+  int calculate_index_(uint16_t value, int array[AMOUNT_OF_LEVELS][2]) {
+    int grid_index = get_grid_index_(value, array);
     if (grid_index == -1) {
-      return -1.0f;
+      return -1;
     }
 
-    float aqi_lo = INDEX_GRID[grid_index][0];
-    float aqi_hi = INDEX_GRID[grid_index][1];
-    float conc_lo = array[grid_index][0];
-    float conc_hi = array[grid_index][1];
+    int aqi_lo = index_grid_[grid_index][0];
+    int aqi_hi = index_grid_[grid_index][1];
+    int conc_lo = array[grid_index][0];
+    int conc_hi = array[grid_index][1];
 
     return (value - conc_lo) * (aqi_hi - aqi_lo) / (conc_hi - conc_lo) + aqi_lo;
   }
 
-  static int get_grid_index(float value, const float array[NUM_LEVELS][2]) {
-    for (int i = 0; i < NUM_LEVELS; i++) {
+  int get_grid_index_(uint16_t value, int array[AMOUNT_OF_LEVELS][2]) {
+    for (int i = 0; i < AMOUNT_OF_LEVELS; i++) {
       if (value >= array[i][0] && value <= array[i][1]) {
         return i;
       }

esphome/components/aqi/sensor.py

@@ -1,51 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_PM_2_5,
-    CONF_PM_10_0,
-    DEVICE_CLASS_AQI,
-    STATE_CLASS_MEASUREMENT,
-)
-
-from . import AQI_CALCULATION_TYPE, CONF_CALCULATION_TYPE, aqi_ns
-
-CODEOWNERS = ["@jasstrong"]
-DEPENDENCIES = ["sensor"]
-
-UNIT_INDEX = "index"
-
-AQISensor = aqi_ns.class_("AQISensor", sensor.Sensor, cg.Component)
-
-CONFIG_SCHEMA = (
-    sensor.sensor_schema(
-        AQISensor,
-        unit_of_measurement=UNIT_INDEX,
-        accuracy_decimals=0,
-        device_class=DEVICE_CLASS_AQI,
-        state_class=STATE_CLASS_MEASUREMENT,
-    )
-    .extend(
-        {
-            cv.Required(CONF_PM_2_5): cv.use_id(sensor.Sensor),
-            cv.Required(CONF_PM_10_0): cv.use_id(sensor.Sensor),
-            cv.Required(CONF_CALCULATION_TYPE): cv.enum(
-                AQI_CALCULATION_TYPE, upper=True
-            ),
-        }
-    )
-    .extend(cv.COMPONENT_SCHEMA)
-)
-
-
-async def to_code(config):
-    var = await sensor.new_sensor(config)
-    await cg.register_component(var, config)
-
-    pm_2_5_sensor = await cg.get_variable(config[CONF_PM_2_5])
-    cg.add(var.set_pm_2_5_sensor(pm_2_5_sensor))
-
-    pm_10_0_sensor = await cg.get_variable(config[CONF_PM_10_0])
-    cg.add(var.set_pm_10_0_sensor(pm_10_0_sensor))
-
-    cg.add(var.set_aqi_calculation_type(config[CONF_CALCULATION_TYPE]))

esphome/components/async_tcp/__init__.py

@@ -1,50 +1,37 @@
-# Async TCP client support for all platforms
+# Dummy integration to allow relying on AsyncTCP
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome.const import (
+    PLATFORM_BK72XX,
+    PLATFORM_ESP32,
+    PLATFORM_ESP8266,
+    PLATFORM_LN882X,
+    PLATFORM_RTL87XX,
+)
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
-DEPENDENCIES = ["network"]
 
-
-def AUTO_LOAD() -> list[str]:
-    # Socket component needed for platforms using socket-based implementation
-    # ESP32, ESP8266, RP2040, and LibreTiny use AsyncTCP libraries, others use sockets
-    if (
-        not CORE.is_esp32
-        and not CORE.is_esp8266
-        and not CORE.is_rp2040
-        and not CORE.is_libretiny
-    ):
-        return ["socket"]
-    return []
-
-
-# Support all platforms - Arduino/ESP-IDF get libraries, other platforms use socket implementation
-CONFIG_SCHEMA = cv.Schema({})
+CONFIG_SCHEMA = cv.All(
+    cv.Schema({}),
+    cv.only_with_arduino,
+    cv.only_on(
+        [
+            PLATFORM_ESP32,
+            PLATFORM_ESP8266,
+            PLATFORM_BK72XX,
+            PLATFORM_LN882X,
+            PLATFORM_RTL87XX,
+        ]
+    ),
+)
 
 
 @coroutine_with_priority(CoroPriority.NETWORK_TRANSPORT)
 async def to_code(config):
-    if CORE.is_esp32:
-        # https://github.com/ESP32Async/AsyncTCP
-        from esphome.components.esp32 import add_idf_component
-
-        add_idf_component(name="esp32async/asynctcp", ref="3.4.91")
-    elif CORE.is_libretiny:
+    if CORE.is_esp32 or CORE.is_libretiny:
         # https://github.com/ESP32Async/AsyncTCP
         cg.add_library("ESP32Async/AsyncTCP", "3.4.5")
     elif CORE.is_esp8266:
         # https://github.com/ESP32Async/ESPAsyncTCP
         cg.add_library("ESP32Async/ESPAsyncTCP", "2.0.0")
-    elif CORE.is_rp2040:
-        # https://github.com/khoih-prog/AsyncTCP_RP2040W
-        cg.add_library("khoih-prog/AsyncTCP_RP2040W", "1.2.0")
-    # Other platforms (host, etc) use socket-based implementation
-
-
-def FILTER_SOURCE_FILES() -> list[str]:
-    # Exclude socket implementation for platforms that use AsyncTCP libraries
-    if CORE.is_esp32 or CORE.is_esp8266 or CORE.is_rp2040 or CORE.is_libretiny:
-        return ["async_tcp_socket.cpp"]
-    return []

esphome/components/async_tcp/async_tcp.h

@@ -1,16 +0,0 @@
-#pragma once
-#include "esphome/core/defines.h"
-
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
-// Use AsyncTCP library for ESP32 (Arduino or ESP-IDF) and LibreTiny
-#include <AsyncTCP.h>
-#elif defined(USE_ESP8266)
-// Use ESPAsyncTCP library for ESP8266 (always Arduino)
-#include <ESPAsyncTCP.h>
-#elif defined(USE_RP2040)
-// Use AsyncTCP_RP2040W library for RP2040
-#include <AsyncTCP_RP2040W.h>
-#else
-// Use socket-based implementation for other platforms
-#include "async_tcp_socket.h"
-#endif

esphome/components/async_tcp/async_tcp_socket.cpp

@@ -1,162 +0,0 @@
-#include "async_tcp_socket.h"
-
-#if !defined(USE_ESP32) && !defined(USE_ESP8266) && !defined(USE_RP2040) && !defined(USE_LIBRETINY) && \
-    (defined(USE_SOCKET_IMPL_LWIP_SOCKETS) || defined(USE_SOCKET_IMPL_BSD_SOCKETS))
-
-#include "esphome/components/network/util.h"
-#include "esphome/core/log.h"
-#include <cerrno>
-#include <sys/select.h>
-
-namespace esphome::async_tcp {
-
-static const char *const TAG = "async_tcp";
-
-// Read buffer size matches TCP MSS (1500 MTU - 40 bytes IP/TCP headers).
-// This implementation only runs on ESP-IDF and host which have ample stack.
-static constexpr size_t READ_BUFFER_SIZE = 1460;
-
-bool AsyncClient::connect(const char *host, uint16_t port) {
-  if (connected_ || connecting_) {
-    ESP_LOGW(TAG, "Already connected/connecting");
-    return false;
-  }
-
-  // Resolve address
-  struct sockaddr_storage addr;
-  socklen_t addrlen = esphome::socket::set_sockaddr((struct sockaddr *) &addr, sizeof(addr), host, port);
-  if (addrlen == 0) {
-    ESP_LOGE(TAG, "Invalid address: %s", host);
-    if (error_cb_)
-      error_cb_(error_arg_, this, -1);
-    return false;
-  }
-
-  // Create socket with loop monitoring
-  int family = ((struct sockaddr *) &addr)->sa_family;
-  socket_ = esphome::socket::socket_loop_monitored(family, SOCK_STREAM, IPPROTO_TCP);
-  if (!socket_) {
-    ESP_LOGE(TAG, "Failed to create socket");
-    if (error_cb_)
-      error_cb_(error_arg_, this, -1);
-    return false;
-  }
-
-  socket_->setblocking(false);
-
-  int err = socket_->connect((struct sockaddr *) &addr, addrlen);
-  if (err == 0) {
-    // Connection succeeded immediately (rare, but possible for localhost)
-    connected_ = true;
-    if (connect_cb_)
-      connect_cb_(connect_arg_, this);
-    return true;
-  }
-  if (errno != EINPROGRESS) {
-    ESP_LOGE(TAG, "Connect failed: %d", errno);
-    close();
-    if (error_cb_)
-      error_cb_(error_arg_, this, errno);
-    return false;
-  }
-
-  connecting_ = true;
-  return true;
-}
-
-void AsyncClient::close() {
-  socket_.reset();
-  bool was_connected = connected_;
-  connected_ = false;
-  connecting_ = false;
-  if (was_connected && disconnect_cb_)
-    disconnect_cb_(disconnect_arg_, this);
-}
-
-size_t AsyncClient::write(const char *data, size_t len) {
-  if (!socket_ || !connected_)
-    return 0;
-
-  ssize_t sent = socket_->write(data, len);
-  if (sent < 0) {
-    if (errno != EAGAIN && errno != EWOULDBLOCK) {
-      ESP_LOGE(TAG, "Write error: %d", errno);
-      close();
-      if (error_cb_)
-        error_cb_(error_arg_, this, errno);
-    }
-    return 0;
-  }
-  return sent;
-}
-
-void AsyncClient::loop() {
-  if (!socket_)
-    return;
-
-  if (connecting_) {
-    // For connecting, we need to check writability, not readability
-    // The Application's select() only monitors read FDs, so we do our own check here
-    // For ESP platforms lwip_select() might be faster, but this code isn't used
-    // on those platforms anyway. If it was, we'd fix the Application select()
-    // to report writability instead of doing it this way.
-    int fd = socket_->get_fd();
-    if (fd < 0) {
-      ESP_LOGW(TAG, "Invalid socket fd");
-      close();
-      return;
-    }
-
-    fd_set writefds;
-    FD_ZERO(&writefds);
-    FD_SET(fd, &writefds);
-
-    struct timeval tv = {0, 0};
-    int ret = select(fd + 1, nullptr, &writefds, nullptr, &tv);
-
-    if (ret > 0 && FD_ISSET(fd, &writefds)) {
-      int error = 0;
-      socklen_t len = sizeof(error);
-      if (socket_->getsockopt(SOL_SOCKET, SO_ERROR, &error, &len) == 0 && error == 0) {
-        connecting_ = false;
-        connected_ = true;
-        if (connect_cb_)
-          connect_cb_(connect_arg_, this);
-      } else {
-        ESP_LOGW(TAG, "Connection failed: %d", error);
-        close();
-        if (error_cb_)
-          error_cb_(error_arg_, this, error);
-      }
-    } else if (ret < 0) {
-      ESP_LOGE(TAG, "Select error: %d", errno);
-      close();
-      if (error_cb_)
-        error_cb_(error_arg_, this, errno);
-    }
-  } else if (connected_) {
-    // For connected sockets, use the Application's select() results
-    if (!socket_->ready())
-      return;
-
-    uint8_t buf[READ_BUFFER_SIZE];
-    ssize_t len = socket_->read(buf, READ_BUFFER_SIZE);
-
-    if (len == 0) {
-      ESP_LOGI(TAG, "Connection closed by peer");
-      close();
-    } else if (len > 0) {
-      if (data_cb_)
-        data_cb_(data_arg_, this, buf, len);
-    } else if (errno != EAGAIN && errno != EWOULDBLOCK) {
-      ESP_LOGW(TAG, "Read error: %d", errno);
-      close();
-      if (error_cb_)
-        error_cb_(error_arg_, this, errno);
-    }
-  }
-}
-
-}  // namespace esphome::async_tcp
-
-#endif

esphome/components/async_tcp/async_tcp_socket.h

@@ -1,73 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#if !defined(USE_ESP32) && !defined(USE_ESP8266) && !defined(USE_RP2040) && !defined(USE_LIBRETINY) && \
-    (defined(USE_SOCKET_IMPL_LWIP_SOCKETS) || defined(USE_SOCKET_IMPL_BSD_SOCKETS))
-
-#include "esphome/components/socket/socket.h"
-#include <functional>
-#include <memory>
-#include <string>
-#include <utility>
-
-namespace esphome::async_tcp {
-
-/// AsyncClient API for platforms using sockets (ESP-IDF, host, etc.)
-/// NOTE: This class is NOT thread-safe. All methods must be called from the main loop.
-class AsyncClient {
- public:
-  using AcConnectHandler = std::function<void(void *, AsyncClient *)>;
-  using AcDataHandler = std::function<void(void *, AsyncClient *, void *data, size_t len)>;
-  using AcErrorHandler = std::function<void(void *, AsyncClient *, int8_t error)>;
-
-  AsyncClient() = default;
-  ~AsyncClient() = default;
-
-  [[nodiscard]] bool connect(const char *host, uint16_t port);
-  void close();
-  [[nodiscard]] bool connected() const { return connected_; }
-  size_t write(const char *data, size_t len);
-
-  void onConnect(AcConnectHandler cb, void *arg = nullptr) {  // NOLINT(readability-identifier-naming)
-    connect_cb_ = std::move(cb);
-    connect_arg_ = arg;
-  }
-  void onDisconnect(AcConnectHandler cb, void *arg = nullptr) {  // NOLINT(readability-identifier-naming)
-    disconnect_cb_ = std::move(cb);
-    disconnect_arg_ = arg;
-  }
-  /// Set data callback. NOTE: data pointer is only valid during callback execution.
-  void onData(AcDataHandler cb, void *arg = nullptr) {  // NOLINT(readability-identifier-naming)
-    data_cb_ = std::move(cb);
-    data_arg_ = arg;
-  }
-  void onError(AcErrorHandler cb, void *arg = nullptr) {  // NOLINT(readability-identifier-naming)
-    error_cb_ = std::move(cb);
-    error_arg_ = arg;
-  }
-
-  // Must be called from loop()
-  void loop();
-
- private:
-  std::unique_ptr<esphome::socket::Socket> socket_;
-
-  AcConnectHandler connect_cb_{nullptr};
-  void *connect_arg_{nullptr};
-  AcConnectHandler disconnect_cb_{nullptr};
-  void *disconnect_arg_{nullptr};
-  AcDataHandler data_cb_{nullptr};
-  void *data_arg_{nullptr};
-  AcErrorHandler error_cb_{nullptr};
-  void *error_arg_{nullptr};
-
-  bool connected_{false};
-  bool connecting_{false};
-};
-
-}  // namespace esphome::async_tcp
-
-// Expose AsyncClient in global namespace to match library behavior
-using esphome::async_tcp::AsyncClient;  // NOLINT(google-global-names-in-headers)
-#endif

esphome/components/atc_mithermometer/atc_mithermometer.cpp

@@ -21,9 +21,7 @@ bool ATCMiThermometer::parse_device(const esp32_ble_tracker::ESPBTDevice &device
     ESP_LOGVV(TAG, "parse_device(): unknown MAC address.");
     return false;
   }
-  char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-  const char *addr_str = device.address_str_to(addr_buf);
-  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", addr_str);
+  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", device.address_str().c_str());
 
   bool success = false;
   for (auto &service_data : device.get_service_datas()) {
@@ -34,7 +32,7 @@ bool ATCMiThermometer::parse_device(const esp32_ble_tracker::ESPBTDevice &device
     if (!(parse_message_(service_data.data, *res))) {
       continue;
     }
-    if (!(report_results_(res, addr_str))) {
+    if (!(report_results_(res, device.address_str()))) {
       continue;
     }
     if (res->temperature.has_value() && this->temperature_ != nullptr)
@@ -105,13 +103,13 @@ bool ATCMiThermometer::parse_message_(const std::vector<uint8_t> &message, Parse
   return true;
 }
 
-bool ATCMiThermometer::report_results_(const optional<ParseResult> &result, const char *address) {
+bool ATCMiThermometer::report_results_(const optional<ParseResult> &result, const std::string &address) {
   if (!result.has_value()) {
     ESP_LOGVV(TAG, "report_results(): no results available.");
     return false;
   }
 
-  ESP_LOGD(TAG, "Got ATC MiThermometer (%s):", address);
+  ESP_LOGD(TAG, "Got ATC MiThermometer (%s):", address.c_str());
 
   if (result->temperature.has_value()) {
     ESP_LOGD(TAG, "  Temperature: %.1f °C", *result->temperature);

esphome/components/atc_mithermometer/atc_mithermometer.h

@@ -41,7 +41,7 @@ class ATCMiThermometer : public Component, public esp32_ble_tracker::ESPBTDevice
 
   optional<ParseResult> parse_header_(const esp32_ble_tracker::ServiceData &service_data);
   bool parse_message_(const std::vector<uint8_t> &message, ParseResult &result);
-  bool report_results_(const optional<ParseResult> &result, const char *address);
+  bool report_results_(const optional<ParseResult> &result, const std::string &address);
 };
 
 }  // namespace atc_mithermometer

esphome/components/atm90e32/atm90e32.cpp

@@ -227,15 +227,14 @@ void ATM90E32Component::log_calibration_status_() {
   }
 
   if (offset_mismatch) {
-    ESP_LOGW(TAG, "[CALIBRATION][%s] ", cs);
     ESP_LOGW(TAG,
-             "[CALIBRATION][%s] ===================== Offset mismatch: using flash values =====================", cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] ------------------------------------------------------------------------------",
-             cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] | Phase |   offset_voltage   |   offset_current   |", cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] |       |  config  |  flash  |  config  |  flash  |", cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] ------------------------------------------------------------------------------",
-             cs);
+             "[CALIBRATION][%s] \n"
+             "[CALIBRATION][%s] ===================== Offset mismatch: using flash values =====================\n"
+             "[CALIBRATION][%s] ------------------------------------------------------------------------------\n"
+             "[CALIBRATION][%s] | Phase |   offset_voltage   |   offset_current   |\n"
+             "[CALIBRATION][%s] |       |  config  |  flash  |  config  |  flash  |\n"
+             "[CALIBRATION][%s] ------------------------------------------------------------------------------",
+             cs, cs, cs, cs, cs, cs);
     for (uint8_t phase = 0; phase < 3; ++phase) {
       ESP_LOGW(TAG, "[CALIBRATION][%s] |   %c   |  %6d  | %6d  |  %6d  | %6d  |", cs, 'A' + phase,
                this->config_offset_phase_[phase].voltage_offset_, this->offset_phase_[phase].voltage_offset_,
@@ -245,15 +244,14 @@ void ATM90E32Component::log_calibration_status_() {
              "[CALIBRATION][%s] ===============================================================================", cs);
   }
   if (power_mismatch) {
-    ESP_LOGW(TAG, "[CALIBRATION][%s] ", cs);
     ESP_LOGW(TAG,
-             "[CALIBRATION][%s] ================= Power offset mismatch: using flash values =================", cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] ------------------------------------------------------------------------------",
-             cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] | Phase | offset_active_power|offset_reactive_power|", cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] |       |  config  |  flash  |  config  |  flash  |", cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] ------------------------------------------------------------------------------",
-             cs);
+             "[CALIBRATION][%s] \n"
+             "[CALIBRATION][%s] ================= Power offset mismatch: using flash values =================\n"
+             "[CALIBRATION][%s] ------------------------------------------------------------------------------\n"
+             "[CALIBRATION][%s] | Phase | offset_active_power|offset_reactive_power|\n"
+             "[CALIBRATION][%s] |       |  config  |  flash  |  config  |  flash  |\n"
+             "[CALIBRATION][%s] ------------------------------------------------------------------------------",
+             cs, cs, cs, cs, cs, cs);
     for (uint8_t phase = 0; phase < 3; ++phase) {
       ESP_LOGW(TAG, "[CALIBRATION][%s] |   %c   |  %6d  | %6d  |  %6d  | %6d  |", cs, 'A' + phase,
                this->config_power_offset_phase_[phase].active_power_offset,
@@ -265,15 +263,14 @@ void ATM90E32Component::log_calibration_status_() {
              "[CALIBRATION][%s] ===============================================================================", cs);
   }
   if (gain_mismatch) {
-    ESP_LOGW(TAG, "[CALIBRATION][%s] ", cs);
     ESP_LOGW(TAG,
-             "[CALIBRATION][%s] ====================== Gain mismatch: using flash values =====================", cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] ------------------------------------------------------------------------------",
-             cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] | Phase |    voltage_gain    |    current_gain    |", cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] |       |  config  |  flash  |  config  |  flash  |", cs);
-    ESP_LOGW(TAG, "[CALIBRATION][%s] ------------------------------------------------------------------------------",
-             cs);
+             "[CALIBRATION][%s] \n"
+             "[CALIBRATION][%s] ====================== Gain mismatch: using flash values =====================\n"
+             "[CALIBRATION][%s] ------------------------------------------------------------------------------\n"
+             "[CALIBRATION][%s] | Phase |    voltage_gain    |    current_gain    |\n"
+             "[CALIBRATION][%s] |       |  config  |  flash  |  config  |  flash  |\n"
+             "[CALIBRATION][%s] ------------------------------------------------------------------------------",
+             cs, cs, cs, cs, cs, cs);
     for (uint8_t phase = 0; phase < 3; ++phase) {
       ESP_LOGW(TAG, "[CALIBRATION][%s] |   %c   |  %6u  | %6u  |  %6u  | %6u  |", cs, 'A' + phase,
                this->config_gain_phase_[phase].voltage_gain, this->gain_phase_[phase].voltage_gain,
@@ -286,11 +283,13 @@ void ATM90E32Component::log_calibration_status_() {
     ESP_LOGI(TAG, "[CALIBRATION][%s] Power & Voltage/Current offset calibration is disabled. Using config file values.",
              cs);
   } else if (this->restored_offset_calibration_ && !offset_mismatch) {
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ============== Restored offset calibration from memory ==============", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
+    ESP_LOGI(TAG,
+             "[CALIBRATION][%s]\n"
+             "[CALIBRATION][%s] ============== Restored offset calibration from memory ==============\n"
+             "[CALIBRATION][%s] --------------------------------------------------------------\n"
+             "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |\n"
+             "[CALIBRATION][%s] --------------------------------------------------------------",
+             cs, cs, cs, cs, cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase,
                this->offset_phase_[phase].voltage_offset_, this->offset_phase_[phase].current_offset_);
@@ -299,11 +298,13 @@ void ATM90E32Component::log_calibration_status_() {
   }
 
   if (this->restored_power_offset_calibration_ && !power_mismatch) {
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ============ Restored power offset calibration from memory ============", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
+    ESP_LOGI(TAG,
+             "[CALIBRATION][%s]\n"
+             "[CALIBRATION][%s] ============ Restored power offset calibration from memory ============\n"
+             "[CALIBRATION][%s] ---------------------------------------------------------------------\n"
+             "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |\n"
+             "[CALIBRATION][%s] ---------------------------------------------------------------------",
+             cs, cs, cs, cs, cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase,
                this->power_offset_phase_[phase].active_power_offset,
@@ -314,17 +315,21 @@ void ATM90E32Component::log_calibration_status_() {
   if (!this->enable_gain_calibration_) {
     ESP_LOGI(TAG, "[CALIBRATION][%s] Gain calibration is disabled. Using config file values.", cs);
   } else if (this->restored_gain_calibration_ && !gain_mismatch) {
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ============ Restoring saved gain calibrations to registers ============", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | voltage_gain | current_gain |", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
+    ESP_LOGI(TAG,
+             "[CALIBRATION][%s]\n"
+             "[CALIBRATION][%s] ============ Restoring saved gain calibrations to registers ============\n"
+             "[CALIBRATION][%s] ---------------------------------------------------------------------\n"
+             "[CALIBRATION][%s] | Phase | voltage_gain | current_gain |\n"
+             "[CALIBRATION][%s] ---------------------------------------------------------------------",
+             cs, cs, cs, cs, cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |    %6u    |    %6u    |", cs, 'A' + phase,
                this->gain_phase_[phase].voltage_gain, this->gain_phase_[phase].current_gain);
     }
-    ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\\n", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] Gain calibration loaded and verified successfully.\n", cs);
+    ESP_LOGI(TAG,
+             "[CALIBRATION][%s] =====================================================================\n"
+             "[CALIBRATION][%s] Gain calibration loaded and verified successfully.\n",
+             cs, cs);
   }
   this->calibration_message_printed_ = true;
 }
@@ -580,14 +585,14 @@ void ATM90E32Component::run_gain_calibrations() {
   float ref_currents[3] = {this->get_reference_current(0), this->get_reference_current(1),
                            this->get_reference_current(2)};
 
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ========================= Gain Calibration  =========================", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
   ESP_LOGI(
       TAG,
-      "[CALIBRATION][%s] | Phase | V_meas (V) | I_meas (A) | V_ref | I_ref  | V_gain (old→new) | I_gain (old→new) |",
-      cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
+      "[CALIBRATION][%s]\n"
+      "[CALIBRATION][%s] ========================= Gain Calibration  =========================\n"
+      "[CALIBRATION][%s] ---------------------------------------------------------------------\n"
+      "[CALIBRATION][%s] | Phase | V_meas (V) | I_meas (A) | V_ref | I_ref  | V_gain (old→new) | I_gain (old→new) |\n"
+      "[CALIBRATION][%s] ---------------------------------------------------------------------",
+      cs, cs, cs, cs, cs);
 
   for (uint8_t phase = 0; phase < 3; phase++) {
     float measured_voltage = this->get_phase_voltage_avg_(phase);
@@ -718,11 +723,13 @@ void ATM90E32Component::run_offset_calibrations() {
     return;
   }
 
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ======================== Offset Calibration ========================", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ------------------------------------------------------------------", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ------------------------------------------------------------------", cs);
+  ESP_LOGI(TAG,
+           "[CALIBRATION][%s]\n"
+           "[CALIBRATION][%s] ======================== Offset Calibration ========================\n"
+           "[CALIBRATION][%s] ------------------------------------------------------------------\n"
+           "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |\n"
+           "[CALIBRATION][%s] ------------------------------------------------------------------",
+           cs, cs, cs, cs, cs);
 
   for (uint8_t phase = 0; phase < 3; phase++) {
     int16_t voltage_offset = calibrate_offset(phase, true);
@@ -749,11 +756,13 @@ void ATM90E32Component::run_power_offset_calibrations() {
     return;
   }
 
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ===================== Power Offset Calibration =====================", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
+  ESP_LOGI(TAG,
+           "[CALIBRATION][%s]\n"
+           "[CALIBRATION][%s] ===================== Power Offset Calibration =====================\n"
+           "[CALIBRATION][%s] ---------------------------------------------------------------------\n"
+           "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |\n"
+           "[CALIBRATION][%s] ---------------------------------------------------------------------",
+           cs, cs, cs, cs, cs);
 
   for (uint8_t phase = 0; phase < 3; ++phase) {
     int16_t active_offset = calibrate_power_offset(phase, false);
@@ -953,10 +962,12 @@ void ATM90E32Component::restore_power_offset_calibrations_() {
 void ATM90E32Component::clear_gain_calibrations() {
   const char *cs = this->cs_summary_.c_str();
   if (!this->using_saved_calibrations_) {
-    ESP_LOGI(TAG, "[CALIBRATION][%s] No stored gain calibrations to clear. Current values:", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ----------------------------------------------------------", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | voltage_gain | current_gain |", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ----------------------------------------------------------", cs);
+    ESP_LOGI(TAG,
+             "[CALIBRATION][%s] No stored gain calibrations to clear. Current values:\n"
+             "[CALIBRATION][%s] ----------------------------------------------------------\n"
+             "[CALIBRATION][%s] | Phase | voltage_gain | current_gain |\n"
+             "[CALIBRATION][%s] ----------------------------------------------------------",
+             cs, cs, cs, cs);
     for (int phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |    %6u    |    %6u    |", cs, 'A' + phase,
                this->gain_phase_[phase].voltage_gain, this->gain_phase_[phase].current_gain);
@@ -965,10 +976,12 @@ void ATM90E32Component::clear_gain_calibrations() {
     return;
   }
 
-  ESP_LOGI(TAG, "[CALIBRATION][%s] Clearing stored gain calibrations and restoring config-defined values", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ----------------------------------------------------------", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | voltage_gain | current_gain |", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ----------------------------------------------------------", cs);
+  ESP_LOGI(TAG,
+           "[CALIBRATION][%s] Clearing stored gain calibrations and restoring config-defined values\n"
+           "[CALIBRATION][%s] ----------------------------------------------------------\n"
+           "[CALIBRATION][%s] | Phase | voltage_gain | current_gain |\n"
+           "[CALIBRATION][%s] ----------------------------------------------------------",
+           cs, cs, cs, cs);
 
   for (int phase = 0; phase < 3; phase++) {
     uint16_t voltage_gain = this->phase_[phase].voltage_gain_;
@@ -1002,10 +1015,12 @@ void ATM90E32Component::clear_gain_calibrations() {
 void ATM90E32Component::clear_offset_calibrations() {
   const char *cs = this->cs_summary_.c_str();
   if (!this->restored_offset_calibration_) {
-    ESP_LOGI(TAG, "[CALIBRATION][%s] No stored offset calibrations to clear. Current values:", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
+    ESP_LOGI(TAG,
+             "[CALIBRATION][%s] No stored offset calibrations to clear. Current values:\n"
+             "[CALIBRATION][%s] --------------------------------------------------------------\n"
+             "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |\n"
+             "[CALIBRATION][%s] --------------------------------------------------------------",
+             cs, cs, cs, cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase,
                this->offset_phase_[phase].voltage_offset_, this->offset_phase_[phase].current_offset_);
@@ -1014,10 +1029,12 @@ void ATM90E32Component::clear_offset_calibrations() {
     return;
   }
 
-  ESP_LOGI(TAG, "[CALIBRATION][%s] Clearing stored offset calibrations and restoring config-defined values", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
+  ESP_LOGI(TAG,
+           "[CALIBRATION][%s] Clearing stored offset calibrations and restoring config-defined values\n"
+           "[CALIBRATION][%s] --------------------------------------------------------------\n"
+           "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |\n"
+           "[CALIBRATION][%s] --------------------------------------------------------------",
+           cs, cs, cs, cs);
 
   for (uint8_t phase = 0; phase < 3; phase++) {
     int16_t voltage_offset =
@@ -1044,10 +1061,12 @@ void ATM90E32Component::clear_offset_calibrations() {
 void ATM90E32Component::clear_power_offset_calibrations() {
   const char *cs = this->cs_summary_.c_str();
   if (!this->restored_power_offset_calibration_) {
-    ESP_LOGI(TAG, "[CALIBRATION][%s] No stored power offsets to clear. Current values:", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |", cs);
-    ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
+    ESP_LOGI(TAG,
+             "[CALIBRATION][%s] No stored power offsets to clear. Current values:\n"
+             "[CALIBRATION][%s] ---------------------------------------------------------------------\n"
+             "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |\n"
+             "[CALIBRATION][%s] ---------------------------------------------------------------------",
+             cs, cs, cs, cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase,
                this->power_offset_phase_[phase].active_power_offset,
@@ -1057,10 +1076,12 @@ void ATM90E32Component::clear_power_offset_calibrations() {
     return;
   }
 
-  ESP_LOGI(TAG, "[CALIBRATION][%s] Clearing stored power offsets and restoring config-defined values", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |", cs);
-  ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
+  ESP_LOGI(TAG,
+           "[CALIBRATION][%s] Clearing stored power offsets and restoring config-defined values\n"
+           "[CALIBRATION][%s] ---------------------------------------------------------------------\n"
+           "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |\n"
+           "[CALIBRATION][%s] ---------------------------------------------------------------------",
+           cs, cs, cs, cs);
 
   for (uint8_t phase = 0; phase < 3; phase++) {
     int16_t active_offset =

esphome/components/atm90e32/button/atm90e32_button.cpp

@@ -13,9 +13,10 @@ void ATM90E32GainCalibrationButton::press_action() {
     return;
   }
 
-  ESP_LOGI(TAG, "%s", this->get_name().c_str());
   ESP_LOGI(TAG,
-           "[CALIBRATION] Use gain_ct: & gain_voltage: under each phase_x: in your config file to save these values");
+           "%s\n"
+           "[CALIBRATION] Use gain_ct: & gain_voltage: under each phase_x: in your config file to save these values",
+           this->get_name().c_str());
   this->parent_->run_gain_calibrations();
 }
 
@@ -35,10 +36,12 @@ void ATM90E32OffsetCalibrationButton::press_action() {
     return;
   }
 
-  ESP_LOGI(TAG, "%s", this->get_name().c_str());
-  ESP_LOGI(TAG, "[CALIBRATION] **NOTE: CTs and ACVs must be 0 during this process. USB power only**");
-  ESP_LOGI(TAG, "[CALIBRATION] Use offset_voltage: & offset_current: under each phase_x: in your config file to save "
-                "these values");
+  ESP_LOGI(TAG,
+           "%s\n"
+           "[CALIBRATION] **NOTE: CTs and ACVs must be 0 during this process. USB power only**\n"
+           "[CALIBRATION] Use offset_voltage: & offset_current: under each phase_x: in your config file to save "
+           "these values",
+           this->get_name().c_str());
   this->parent_->run_offset_calibrations();
 }
 
@@ -58,10 +61,12 @@ void ATM90E32PowerOffsetCalibrationButton::press_action() {
     return;
   }
 
-  ESP_LOGI(TAG, "%s", this->get_name().c_str());
-  ESP_LOGI(TAG, "[CALIBRATION] **NOTE: CTs must be 0 during this process. Voltage reference should be present**");
-  ESP_LOGI(TAG, "[CALIBRATION] Use offset_active_power: & offset_reactive_power: under each phase_x: in your config "
-                "file to save these values");
+  ESP_LOGI(TAG,
+           "%s\n"
+           "[CALIBRATION] **NOTE: CTs must be 0 during this process. Voltage reference should be present**\n"
+           "[CALIBRATION] Use offset_active_power: & offset_reactive_power: under each phase_x: in your config "
+           "file to save these values",
+           this->get_name().c_str());
   this->parent_->run_power_offset_calibrations();
 }
 

esphome/components/b_parasite/b_parasite.cpp

@@ -22,8 +22,7 @@ bool BParasite::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
     ESP_LOGVV(TAG, "parse_device(): unknown MAC address.");
     return false;
   }
-  char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", device.address_str_to(addr_buf));
+  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", device.address_str().c_str());
   const auto &service_datas = device.get_service_datas();
   if (service_datas.size() != 1) {
     ESP_LOGE(TAG, "Unexpected service_datas size (%d)", service_datas.size());

esphome/components/bedjet/bedjet_hub.cpp

@@ -193,9 +193,8 @@ bool BedJetHub::discover_characteristics_() {
       result = false;
     } else if (descr->uuid.get_uuid().len != ESP_UUID_LEN_16 ||
                descr->uuid.get_uuid().uuid.uuid16 != ESP_GATT_UUID_CHAR_CLIENT_CONFIG) {
-      char uuid_buf[espbt::UUID_STR_LEN];
       ESP_LOGW(TAG, "Config descriptor 0x%x (uuid %s) is not a client config char uuid", this->char_handle_status_,
-               descr->uuid.to_str(uuid_buf));
+               descr->uuid.to_string().c_str());
       result = false;
     } else {
       this->config_descr_status_ = descr->handle;

esphome/components/bedjet/climate/bedjet_climate.cpp

@@ -164,21 +164,21 @@ void BedJetClimate::control(const ClimateCall &call) {
       return;
     }
   } else if (call.has_custom_preset()) {
-    auto preset = call.get_custom_preset();
+    const char *preset = call.get_custom_preset();
     bool result;
 
-    if (preset == "M1") {
+    if (strcmp(preset, "M1") == 0) {
       result = this->parent_->button_memory1();
-    } else if (preset == "M2") {
+    } else if (strcmp(preset, "M2") == 0) {
       result = this->parent_->button_memory2();
-    } else if (preset == "M3") {
+    } else if (strcmp(preset, "M3") == 0) {
       result = this->parent_->button_memory3();
-    } else if (preset == "LTD HT") {
+    } else if (strcmp(preset, "LTD HT") == 0) {
       result = this->parent_->button_heat();
-    } else if (preset == "EXT HT") {
+    } else if (strcmp(preset, "EXT HT") == 0) {
       result = this->parent_->button_ext_heat();
     } else {
-      ESP_LOGW(TAG, "Unsupported preset: %.*s", (int) preset.size(), preset.c_str());
+      ESP_LOGW(TAG, "Unsupported preset: %s", preset);
       return;
     }
 
@@ -208,11 +208,10 @@ void BedJetClimate::control(const ClimateCall &call) {
       this->set_fan_mode_(fan_mode);
     }
   } else if (call.has_custom_fan_mode()) {
-    auto fan_mode = call.get_custom_fan_mode();
-    auto fan_index = bedjet_fan_speed_to_step(fan_mode.c_str());
+    const char *fan_mode = call.get_custom_fan_mode();
+    auto fan_index = bedjet_fan_speed_to_step(fan_mode);
     if (fan_index <= 19) {
-      ESP_LOGV(TAG, "[%s] Converted fan mode %.*s to bedjet fan step %d", this->get_name().c_str(),
-               (int) fan_mode.size(), fan_mode.c_str(), fan_index);
+      ESP_LOGV(TAG, "[%s] Converted fan mode %s to bedjet fan step %d", this->get_name().c_str(), fan_mode, fan_index);
       bool result = this->parent_->set_fan_index(fan_index);
       if (result) {
         this->set_custom_fan_mode_(fan_mode);

esphome/components/ble_client/automation.h

@@ -186,10 +186,8 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
       case ESP_GATTC_SEARCH_CMPL_EVT: {
         auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
         if (chr == nullptr) {
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          char service_buf[esp32_ble::UUID_STR_LEN];
           esph_log_w("ble_write_action", "Characteristic %s was not found in service %s",
-                     this->char_uuid_.to_str(char_buf), this->service_uuid_.to_str(service_buf));
+                     this->char_uuid_.to_string().c_str(), this->service_uuid_.to_string().c_str());
           break;
         }
         this->char_handle_ = chr->handle;
@@ -201,13 +199,11 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
           this->write_type_ = ESP_GATT_WRITE_TYPE_NO_RSP;
           esph_log_d(Automation::TAG, "Write type: ESP_GATT_WRITE_TYPE_NO_RSP");
         } else {
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          esph_log_e(Automation::TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
+          esph_log_e(Automation::TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_string().c_str());
           break;
         }
         this->node_state = espbt::ClientState::ESTABLISHED;
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        esph_log_d(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
+        esph_log_d(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_string().c_str(),
                    ble_client_->address_str());
         break;
       }

esphome/components/ble_client/output/ble_binary_output.cpp

@@ -9,15 +9,12 @@ static const char *const TAG = "ble_binary_output";
 
 void BLEBinaryOutput::dump_config() {
   ESP_LOGCONFIG(TAG, "BLE Binary Output:");
-  char service_buf[esp32_ble::UUID_STR_LEN];
-  char char_buf[esp32_ble::UUID_STR_LEN];
-  this->service_uuid_.to_str(service_buf);
-  this->char_uuid_.to_str(char_buf);
   ESP_LOGCONFIG(TAG,
                 "  MAC address        : %s\n"
                 "  Service UUID       : %s\n"
                 "  Characteristic UUID: %s",
-                this->parent_->address_str(), service_buf, char_buf);
+                this->parent_->address_str(), this->service_uuid_.to_string().c_str(),
+                this->char_uuid_.to_string().c_str());
   LOG_BINARY_OUTPUT(this);
 }
 
@@ -27,10 +24,8 @@ void BLEBinaryOutput::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
     case ESP_GATTC_SEARCH_CMPL_EVT: {
       auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
       if (chr == nullptr) {
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        char service_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGW(TAG, "Characteristic %s was not found in service %s", this->char_uuid_.to_str(char_buf),
-                 this->service_uuid_.to_str(service_buf));
+        ESP_LOGW(TAG, "Characteristic %s was not found in service %s", this->char_uuid_.to_string().c_str(),
+                 this->service_uuid_.to_string().c_str());
         break;
       }
       this->char_handle_ = chr->handle;
@@ -42,24 +37,20 @@ void BLEBinaryOutput::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
         this->write_type_ = ESP_GATT_WRITE_TYPE_NO_RSP;
         ESP_LOGD(TAG, "Write type: ESP_GATT_WRITE_TYPE_NO_RSP");
       } else {
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGE(TAG, "Characteristic %s does not allow writing with%s response", this->char_uuid_.to_str(char_buf),
+        ESP_LOGE(TAG, "Characteristic %s does not allow writing with%s response", this->char_uuid_.to_string().c_str(),
                  this->require_response_ ? "" : "out");
         break;
       }
       this->node_state = espbt::ClientState::ESTABLISHED;
-      char char_buf[esp32_ble::UUID_STR_LEN];
-      ESP_LOGD(TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
+      ESP_LOGD(TAG, "Found characteristic %s on device %s", this->char_uuid_.to_string().c_str(),
                this->parent()->address_str());
       this->node_state = espbt::ClientState::ESTABLISHED;
       break;
     }
     case ESP_GATTC_WRITE_CHAR_EVT: {
       if (param->write.handle == this->char_handle_) {
-        if (param->write.status != 0) {
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          ESP_LOGW(TAG, "[%s] Write error, status=%d", this->char_uuid_.to_str(char_buf), param->write.status);
-        }
+        if (param->write.status != 0)
+          ESP_LOGW(TAG, "[%s] Write error, status=%d", this->char_uuid_.to_string().c_str(), param->write.status);
       }
       break;
     }
@@ -69,19 +60,18 @@ void BLEBinaryOutput::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
 }
 
 void BLEBinaryOutput::write_state(bool state) {
-  char char_buf[esp32_ble::UUID_STR_LEN];
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
     ESP_LOGW(TAG, "[%s] Not connected to BLE client.  State update can not be written.",
-             this->char_uuid_.to_str(char_buf));
+             this->char_uuid_.to_string().c_str());
     return;
   }
   uint8_t state_as_uint = (uint8_t) state;
-  ESP_LOGV(TAG, "[%s] Write State: %d", this->char_uuid_.to_str(char_buf), state_as_uint);
+  ESP_LOGV(TAG, "[%s] Write State: %d", this->char_uuid_.to_string().c_str(), state_as_uint);
   esp_err_t err =
       esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->char_handle_,
                                sizeof(state_as_uint), &state_as_uint, this->write_type_, ESP_GATT_AUTH_REQ_NONE);
   if (err != ESP_GATT_OK)
-    ESP_LOGW(TAG, "[%s] Write error, err=%d", this->char_uuid_.to_str(char_buf), err);
+    ESP_LOGW(TAG, "[%s] Write error, err=%d", this->char_uuid_.to_string().c_str(), err);
 }
 
 }  // namespace esphome::ble_client

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -18,17 +18,14 @@ void BLESensor::loop() {
 
 void BLESensor::dump_config() {
   LOG_SENSOR("", "BLE Sensor", this);
-  char service_buf[esp32_ble::UUID_STR_LEN];
-  char char_buf[esp32_ble::UUID_STR_LEN];
-  char descr_buf[esp32_ble::UUID_STR_LEN];
   ESP_LOGCONFIG(TAG,
                 "  MAC address        : %s\n"
                 "  Service UUID       : %s\n"
                 "  Characteristic UUID: %s\n"
                 "  Descriptor UUID    : %s\n"
                 "  Notifications      : %s",
-                this->parent()->address_str(), this->service_uuid_.to_str(service_buf),
-                this->char_uuid_.to_str(char_buf), this->descr_uuid_.to_str(descr_buf), YESNO(this->notify_));
+                this->parent()->address_str(), this->service_uuid_.to_string().c_str(),
+                this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
 
@@ -54,10 +51,8 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
       if (chr == nullptr) {
         this->status_set_warning();
         this->publish_state(NAN);
-        char service_buf[esp32_ble::UUID_STR_LEN];
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_str(service_buf),
-                 this->char_uuid_.to_str(char_buf));
+        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_string().c_str(),
+                 this->char_uuid_.to_string().c_str());
         break;
       }
       this->handle = chr->handle;
@@ -66,12 +61,9 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
         if (descr == nullptr) {
           this->status_set_warning();
           this->publish_state(NAN);
-          char service_buf[esp32_ble::UUID_STR_LEN];
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          char descr_buf[esp32_ble::UUID_STR_LEN];
           ESP_LOGW(TAG, "No sensor descriptor found at service %s char %s descr %s",
-                   this->service_uuid_.to_str(service_buf), this->char_uuid_.to_str(char_buf),
-                   this->descr_uuid_.to_str(descr_buf));
+                   this->service_uuid_.to_string().c_str(), this->char_uuid_.to_string().c_str(),
+                   this->descr_uuid_.to_string().c_str());
           break;
         }
         this->handle = descr->handle;
@@ -117,8 +109,7 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
           break;
         }
         this->node_state = espbt::ClientState::ESTABLISHED;
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGD(TAG, "Register for notify on %s complete", this->char_uuid_.to_str(char_buf));
+        ESP_LOGD(TAG, "Register for notify on %s complete", this->char_uuid_.to_string().c_str());
       }
       break;
     }

esphome/components/ble_client/text_sensor/automation.h

@@ -21,7 +21,7 @@ class BLETextSensorNotifyTrigger : public Trigger<std::string>, public BLETextSe
         if (param->notify.conn_id != this->sensor_->parent()->get_conn_id() ||
             param->notify.handle != this->sensor_->handle)
           break;
-        this->trigger(std::string(reinterpret_cast<const char *>(param->notify.value), param->notify.value_len));
+        this->trigger(this->sensor_->parse_data(param->notify.value, param->notify.value_len));
       }
       default:
         break;

esphome/components/ble_client/text_sensor/ble_text_sensor.cpp

@@ -11,6 +11,8 @@ namespace esphome::ble_client {
 
 static const char *const TAG = "ble_text_sensor";
 
+static const std::string EMPTY = "";
+
 void BLETextSensor::loop() {
   // Parent BLEClientNode has a loop() method, but this component uses
   // polling via update() and BLE callbacks so loop isn't needed
@@ -19,17 +21,14 @@ void BLETextSensor::loop() {
 
 void BLETextSensor::dump_config() {
   LOG_TEXT_SENSOR("", "BLE Text Sensor", this);
-  char service_buf[esp32_ble::UUID_STR_LEN];
-  char char_buf[esp32_ble::UUID_STR_LEN];
-  char descr_buf[esp32_ble::UUID_STR_LEN];
   ESP_LOGCONFIG(TAG,
                 "  MAC address        : %s\n"
                 "  Service UUID       : %s\n"
                 "  Characteristic UUID: %s\n"
                 "  Descriptor UUID    : %s\n"
                 "  Notifications      : %s",
-                this->parent()->address_str(), this->service_uuid_.to_str(service_buf),
-                this->char_uuid_.to_str(char_buf), this->descr_uuid_.to_str(descr_buf), YESNO(this->notify_));
+                this->parent()->address_str(), this->service_uuid_.to_string().c_str(),
+                this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
 
@@ -45,7 +44,7 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
     }
     case ESP_GATTC_CLOSE_EVT: {
       this->status_set_warning();
-      this->publish_state("");
+      this->publish_state(EMPTY);
       break;
     }
     case ESP_GATTC_SEARCH_CMPL_EVT: {
@@ -53,11 +52,9 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
       if (chr == nullptr) {
         this->status_set_warning();
-        this->publish_state("");
-        char service_buf[esp32_ble::UUID_STR_LEN];
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_str(service_buf),
-                 this->char_uuid_.to_str(char_buf));
+        this->publish_state(EMPTY);
+        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_string().c_str(),
+                 this->char_uuid_.to_string().c_str());
         break;
       }
       this->handle = chr->handle;
@@ -65,13 +62,10 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         auto *descr = chr->get_descriptor(this->descr_uuid_);
         if (descr == nullptr) {
           this->status_set_warning();
-          this->publish_state("");
-          char service_buf[esp32_ble::UUID_STR_LEN];
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          char descr_buf[esp32_ble::UUID_STR_LEN];
+          this->publish_state(EMPTY);
           ESP_LOGW(TAG, "No sensor descriptor found at service %s char %s descr %s",
-                   this->service_uuid_.to_str(service_buf), this->char_uuid_.to_str(char_buf),
-                   this->descr_uuid_.to_str(descr_buf));
+                   this->service_uuid_.to_string().c_str(), this->char_uuid_.to_string().c_str(),
+                   this->descr_uuid_.to_string().c_str());
           break;
         }
         this->handle = descr->handle;
@@ -97,7 +91,7 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
           break;
         }
         this->status_clear_warning();
-        this->publish_state(reinterpret_cast<const char *>(param->read.value), param->read.value_len);
+        this->publish_state(this->parse_data(param->read.value, param->read.value_len));
       }
       break;
     }
@@ -106,7 +100,7 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         break;
       ESP_LOGV(TAG, "[%s] ESP_GATTC_NOTIFY_EVT: handle=0x%x, value=0x%x", this->get_name().c_str(),
                param->notify.handle, param->notify.value[0]);
-      this->publish_state(reinterpret_cast<const char *>(param->notify.value), param->notify.value_len);
+      this->publish_state(this->parse_data(param->notify.value, param->notify.value_len));
       break;
     }
     case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
@@ -119,6 +113,11 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
   }
 }
 
+std::string BLETextSensor::parse_data(uint8_t *value, uint16_t value_len) {
+  std::string text(value, value + value_len);
+  return text;
+}
+
 void BLETextSensor::update() {
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
     ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->get_name().c_str());
@@ -133,7 +132,7 @@ void BLETextSensor::update() {
                                         ESP_GATT_AUTH_REQ_NONE);
   if (status) {
     this->status_set_warning();
-    this->publish_state("");
+    this->publish_state(EMPTY);
     ESP_LOGW(TAG, "[%s] Error sending read request for sensor, status=%d", this->get_name().c_str(), status);
   }
 }

esphome/components/ble_client/text_sensor/ble_text_sensor.h

@@ -29,6 +29,7 @@ class BLETextSensor : public text_sensor::TextSensor, public PollingComponent, p
   void set_descr_uuid32(uint32_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
   void set_descr_uuid128(uint8_t *uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
   void set_enable_notify(bool notify) { this->notify_ = notify; }
+  std::string parse_data(uint8_t *value, uint16_t value_len);
   uint16_t handle;
 
  protected:

esphome/components/ble_scanner/ble_scanner.h

@@ -1,8 +1,7 @@
 #pragma once
 
-#include <cinttypes>
-#include <cstdio>
 #include <ctime>
+#include <string>
 
 #include "esphome/core/component.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
@@ -16,13 +15,17 @@ namespace ble_scanner {
 class BLEScanner : public text_sensor::TextSensor, public esp32_ble_tracker::ESPBTDeviceListener, public Component {
  public:
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override {
-    // Format JSON using stack buffer to avoid heap allocations from string concatenation
-    char buf[128];
-    char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-    snprintf(buf, sizeof(buf), "{\"timestamp\":%" PRId64 ",\"address\":\"%s\",\"rssi\":%d,\"name\":\"%s\"}",
-             static_cast<int64_t>(::time(nullptr)), device.address_str_to(addr_buf), device.get_rssi(),
-             device.get_name().c_str());
-    this->publish_state(buf);
+    this->publish_state("{\"timestamp\":" + to_string(::time(nullptr)) +
+                        ","
+                        "\"address\":\"" +
+                        device.address_str() +
+                        "\","
+                        "\"rssi\":" +
+                        to_string(device.get_rssi()) +
+                        ","
+                        "\"name\":\"" +
+                        device.get_name() + "\"}");
+
     return true;
   }
   void dump_config() override;

esphome/components/bme68x_bsec2_i2c/bme68x_bsec2_i2c.cpp

@@ -31,11 +31,7 @@ void BME68xBSEC2I2CComponent::dump_config() {
   BME68xBSEC2Component::dump_config();
 }
 
-uint32_t BME68xBSEC2I2CComponent::get_hash() {
-  char buf[22];  // "bme68x_bsec_state_" (18) + uint8_t max (3) + null
-  snprintf(buf, sizeof(buf), "bme68x_bsec_state_%u", this->address_);
-  return fnv1_hash(buf);
-}
+uint32_t BME68xBSEC2I2CComponent::get_hash() { return fnv1_hash("bme68x_bsec_state_" + to_string(this->address_)); }
 
 int8_t BME68xBSEC2I2CComponent::read_bytes_wrapper(uint8_t a_register, uint8_t *data, uint32_t len, void *intfPtr) {
   ESP_LOGVV(TAG, "read_bytes_wrapper: reg = %u", a_register);

esphome/components/bthome_mithermometer/bthome_ble.cpp

@@ -4,7 +4,6 @@
 #include "esphome/core/log.h"
 
 #include <array>
-#include <span>
 
 #ifdef USE_ESP32
 
@@ -13,14 +12,15 @@ namespace bthome_mithermometer {
 
 static const char *const TAG = "bthome_mithermometer";
 
-static const char *format_mac_address(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buffer, uint64_t address) {
+static std::string format_mac_address(uint64_t address) {
   std::array<uint8_t, MAC_ADDRESS_SIZE> mac{};
   for (size_t i = 0; i < MAC_ADDRESS_SIZE; i++) {
     mac[i] = (address >> ((MAC_ADDRESS_SIZE - 1 - i) * 8)) & 0xFF;
   }
 
-  format_mac_addr_upper(mac.data(), buffer.data());
-  return buffer.data();
+  char buffer[MAC_ADDRESS_SIZE * 3];
+  format_mac_addr_upper(mac.data(), buffer);
+  return buffer;
 }
 
 static bool get_bthome_value_length(uint8_t obj_type, size_t &value_length) {
@@ -127,9 +127,8 @@ static bool get_bthome_value_length(uint8_t obj_type, size_t &value_length) {
 }
 
 void BTHomeMiThermometer::dump_config() {
-  char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
   ESP_LOGCONFIG(TAG, "BTHome MiThermometer");
-  ESP_LOGCONFIG(TAG, "  MAC Address: %s", format_mac_address(addr_buf, this->address_));
+  ESP_LOGCONFIG(TAG, "  MAC Address: %s", format_mac_address(this->address_).c_str());
   LOG_SENSOR("  ", "Temperature", this->temperature_);
   LOG_SENSOR("  ", "Humidity", this->humidity_);
   LOG_SENSOR("  ", "Battery Level", this->battery_level_);
@@ -173,9 +172,8 @@ bool BTHomeMiThermometer::handle_service_data_(const esp32_ble_tracker::ServiceD
     return false;
   }
 
-  char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
   if (is_encrypted) {
-    ESP_LOGV(TAG, "Ignoring encrypted BTHome frame from %s", device.address_str_to(addr_buf));
+    ESP_LOGV(TAG, "Ignoring encrypted BTHome frame from %s", device.address_str().c_str());
     return false;
   }
 
@@ -195,7 +193,7 @@ bool BTHomeMiThermometer::handle_service_data_(const esp32_ble_tracker::ServiceD
   }
 
   if (source_address != this->address_) {
-    ESP_LOGVV(TAG, "BTHome frame from unexpected device %s", format_mac_address(addr_buf, source_address));
+    ESP_LOGVV(TAG, "BTHome frame from unexpected device %s", format_mac_address(source_address).c_str());
     return false;
   }
 
@@ -288,7 +286,7 @@ bool BTHomeMiThermometer::handle_service_data_(const esp32_ble_tracker::ServiceD
   }
 
   if (reported) {
-    ESP_LOGD(TAG, "BTHome data%sfrom %s", is_trigger_based ? " (triggered) " : " ", device.address_str_to(addr_buf));
+    ESP_LOGD(TAG, "BTHome data%sfrom %s", is_trigger_based ? " (triggered) " : " ", device.address_str().c_str());
   }
 
   return reported;

esphome/components/captive_portal/__init__.py

@@ -7,7 +7,6 @@ from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_AP,
-    CONF_COMPRESSION,
     CONF_ID,
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
@@ -44,7 +43,6 @@ CONFIG_SCHEMA = cv.All(
             cv.GenerateID(CONF_WEB_SERVER_BASE_ID): cv.use_id(
                 web_server_base.WebServerBase
             ),
-            cv.Optional(CONF_COMPRESSION, default="br"): cv.one_of("br", "gzip"),
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.only_on(
@@ -98,9 +96,6 @@ async def to_code(config):
     await cg.register_component(var, config)
     cg.add_define("USE_CAPTIVE_PORTAL")
 
-    if config[CONF_COMPRESSION] == "gzip":
-        cg.add_define("USE_CAPTIVE_PORTAL_GZIP")
-
     if CORE.using_arduino:
         if CORE.is_esp8266:
             cg.add_library("DNSServer", None)

esphome/components/captive_portal/captive_index.h

@@ -3,9 +3,9 @@
 
 #include "esphome/core/hal.h"
 
-namespace esphome::captive_portal {
+namespace esphome {
+namespace captive_portal {
 
-#ifdef USE_CAPTIVE_PORTAL_GZIP
 const uint8_t INDEX_GZ[] PROGMEM = {
     0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x95, 0x16, 0x6b, 0x8f, 0xdb, 0x36, 0xf2, 0x7b, 0x7e,
     0x05, 0x8f, 0x49, 0xbb, 0x52, 0xb3, 0x7a, 0x7a, 0xed, 0x6c, 0x24, 0x51, 0x45, 0x9a, 0xbb, 0xa2, 0x05, 0x9a, 0x36,
@@ -85,71 +85,5 @@ const uint8_t INDEX_GZ[] PROGMEM = {
     0xa7, 0x18, 0x06, 0x7a, 0xcd, 0x05, 0x8c, 0x61, 0x8c, 0x82, 0x25, 0x3a, 0x79, 0x75, 0xb2, 0xf6, 0xc4, 0xaf, 0x68,
     0xfc, 0xda, 0xd1, 0xf8, 0xe9, 0xa3, 0xe1, 0xa6, 0xfb, 0x1f, 0x53, 0x58, 0x46, 0xb2, 0xf9, 0x0a, 0x00, 0x00};
 
-#else  // Brotli (default, smaller)
-const uint8_t INDEX_BR[] PROGMEM = {
-    0x1b, 0xf8, 0x0a, 0x00, 0x64, 0x5a, 0xd3, 0xfa, 0xe7, 0xf3, 0x62, 0xd8, 0x06, 0x1b, 0xe9, 0x6a, 0x8a, 0x81, 0x2b,
-    0xb5, 0x49, 0x14, 0x37, 0xdc, 0x9e, 0x1a, 0xcb, 0x56, 0x87, 0xfb, 0xff, 0xf7, 0x73, 0x75, 0x12, 0x0a, 0xd6, 0x48,
-    0x84, 0xc6, 0x21, 0xa4, 0x6d, 0xb5, 0x71, 0xef, 0x13, 0xbe, 0x4e, 0x54, 0xf1, 0x64, 0x8f, 0x3f, 0xcc, 0x9a, 0x78,
-    0xa5, 0x89, 0x25, 0xb3, 0xda, 0x2c, 0xa2, 0x32, 0x9c, 0x57, 0x07, 0x56, 0xbc, 0x34, 0x13, 0xff, 0x5c, 0x0a, 0xa1,
-    0x67, 0x82, 0xb8, 0x6b, 0x4c, 0x76, 0x31, 0x6c, 0xe3, 0x40, 0x46, 0xea, 0xb0, 0xd4, 0xf4, 0x3b, 0x02, 0x65, 0x18,
-    0xa4, 0xaf, 0xac, 0x6d, 0x55, 0xd6, 0xbe, 0x59, 0x66, 0x7a, 0x7c, 0x60, 0xb2, 0x83, 0x33, 0x23, 0xc9, 0x79, 0x82,
-    0x47, 0xb4, 0x28, 0xf4, 0x24, 0xb5, 0x23, 0x5a, 0x44, 0xe1, 0xc3, 0x27, 0x04, 0xe8, 0x0c, 0xdd, 0xb4, 0xd0, 0x8c,
-    0xfb, 0x10, 0x39, 0x93, 0x04, 0x2a, 0x66, 0x18, 0x4b, 0x74, 0xca, 0x31, 0x7f, 0xb2, 0xe5, 0x45, 0xc1, 0xdd, 0x72,
-    0x49, 0xff, 0x0e, 0xb3, 0xf0, 0x93, 0x18, 0xab, 0x68, 0xad, 0xe1, 0x9d, 0xe4, 0x29, 0xc0, 0xe3, 0x63, 0x54, 0x61,
-    0x1b, 0x45, 0xb9, 0x6c, 0x23, 0x0f, 0x99, 0x7f, 0x8e, 0x69, 0xaa, 0xc1, 0xb8, 0x4e, 0x42, 0x9c, 0xc5, 0x6e, 0x69,
-    0x40, 0x0e, 0x4f, 0x97, 0xd3, 0x23, 0x18, 0xf5, 0xc8, 0x75, 0x73, 0xb5, 0xbd, 0x46, 0x8a, 0x97, 0x7d, 0x83, 0xe4,
-    0x29, 0x72, 0x73, 0xc1, 0x39, 0x8e, 0x7e, 0x84, 0x39, 0x66, 0x57, 0xc6, 0x85, 0x19, 0x8b, 0xf2, 0x4d, 0xd9, 0xfe,
-    0x75, 0xa9, 0xe1, 0x2b, 0x21, 0x81, 0x58, 0x51, 0x99, 0xbc, 0xa4, 0x0b, 0x10, 0x6f, 0x86, 0x17, 0x0b, 0x92, 0x00,
-    0x11, 0x6f, 0x3b, 0xa4, 0xa4, 0x11, 0x7e, 0x0b, 0x97, 0x85, 0x23, 0x0c, 0x01, 0x6f, 0x2a, 0x18, 0xc6, 0xbe, 0x3d,
-    0x77, 0x1a, 0xe6, 0x00, 0x5c, 0x1a, 0x14, 0x47, 0xc6, 0xcc, 0xcc, 0x52, 0xbe, 0x04, 0x19, 0x31, 0x05, 0x46, 0xa0,
-    0xc3, 0x69, 0x0c, 0x60, 0xb7, 0x14, 0x57, 0xa0, 0x92, 0xbf, 0xb7, 0x0c, 0xd8, 0x3a, 0x79, 0x09, 0x99, 0xc9, 0x71,
-    0x88, 0x01, 0x8b, 0xa5, 0x61, 0x0a, 0xb5, 0xe8, 0xc7, 0x71, 0xe7, 0x70, 0x79, 0xb6, 0xe4, 0x01, 0xfc, 0x1a, 0x4a,
-    0x7b, 0x60, 0x6e, 0xef, 0x95, 0x62, 0x59, 0x28, 0xb5, 0x25, 0x56, 0x15, 0xe7, 0xca, 0xad, 0x32, 0xe6, 0xf7, 0x01,
-    0x31, 0x34, 0x87, 0x93, 0x0b, 0x9b, 0x9d, 0x26, 0xff, 0xe5, 0x92, 0xad, 0x6f, 0xb8, 0x3b, 0x16, 0xc1, 0xa0, 0x5a,
-    0x4f, 0x52, 0x0b, 0x2b, 0xc1, 0xa7, 0x95, 0x7b, 0x24, 0x51, 0xd3, 0xb3, 0x23, 0x62, 0x0b, 0xcc, 0xa0, 0x58, 0xa7,
-    0x64, 0x45, 0x2f, 0x0b, 0xdd, 0x1d, 0x97, 0x82, 0x1f, 0xcc, 0x64, 0xdb, 0xd3, 0xf4, 0xb0, 0x8b, 0xc8, 0xcf, 0x15,
-    0x81, 0x8b, 0xa1, 0x9d, 0xf8, 0xfc, 0xec, 0x49, 0x40, 0x12, 0x01, 0x09, 0x51, 0xf3, 0x73, 0x18, 0x24, 0x97, 0x55,
-    0x85, 0x6a, 0x92, 0x1a, 0xf5, 0x5a, 0x05, 0x54, 0x1f, 0x27, 0x0a, 0xa8, 0xa1, 0x94, 0x58, 0x78, 0x7d, 0x87, 0xa8,
-    0xdb, 0x13, 0x66, 0x20, 0x5e, 0x43, 0x18, 0x7a, 0xbb, 0x16, 0x16, 0x07, 0xc8, 0xab, 0x10, 0xe2, 0x50, 0xb9, 0xb1,
-    0xd8, 0x21, 0xc8, 0x4a, 0x2e, 0x99, 0x0e, 0x23, 0x52, 0xc6, 0xcb, 0x29, 0x84, 0x91, 0x03, 0xb1, 0xe2, 0x4c, 0x1d,
-    0x22, 0xd3, 0xc8, 0x79, 0x00, 0x8b, 0x8b, 0x88, 0x1e, 0x29, 0xd3, 0xae, 0x10, 0x15, 0x22, 0x6d, 0xb0, 0x87, 0x6f,
-    0x27, 0x2e, 0x7c, 0xc2, 0x7a, 0x61, 0xbd, 0x22, 0xe5, 0x5f, 0xdd, 0x7b, 0x00, 0x04, 0xf2, 0x7d, 0x5a, 0x03, 0x38,
-    0x1f, 0x69, 0x6d, 0x0b, 0xfb, 0xec, 0x45, 0xfe, 0x8b, 0x7f, 0xec, 0x7b, 0xad, 0xc2, 0x33, 0xf1, 0x9e, 0x9c, 0x71,
-    0xd9, 0xe8, 0x5e, 0x8f, 0xd4, 0xee, 0x87, 0x45, 0x6c, 0xe2, 0x12, 0xf8, 0xb8, 0xc5, 0xee, 0x43, 0xa6, 0x37, 0x91,
-    0xb5, 0x2c, 0x2f, 0xe9, 0xe8, 0x24, 0xd0, 0x45, 0xc1, 0x0c, 0x7c, 0xf0, 0xb2, 0xb5, 0x2d, 0x10, 0x36, 0x7e, 0x18,
-    0x7c, 0x79, 0x82, 0x69, 0x3d, 0x35, 0xca, 0x52, 0xee, 0xc9, 0xb5, 0x65, 0xa4, 0xa1, 0xfd, 0x70, 0x7e, 0xe0, 0x7d,
-    0x67, 0xf9, 0xa1, 0x71, 0xd2, 0x08, 0x74, 0x33, 0x5f, 0x69, 0xa4, 0x59, 0x03, 0xfd, 0xf8, 0xf0, 0x70, 0x1a, 0x50,
-    0x43, 0xfb, 0x61, 0xf0, 0x38, 0x18, 0x88, 0x85, 0x36, 0x23, 0x06, 0x4f, 0x02, 0xbb, 0x78, 0x1a, 0xaa, 0xd2, 0x02,
-    0x5e, 0xa0, 0x74, 0x30, 0xc8, 0x7a, 0x66, 0xab, 0xd9, 0x43, 0x99, 0x45, 0xb7, 0x0c, 0x5c, 0xec, 0xc8, 0x03, 0x0e,
-    0x0b, 0xca, 0x4a, 0x22, 0x48, 0xfb, 0xb7, 0x3d, 0x82, 0x07, 0x8d, 0x1b, 0x21, 0x87, 0x4d, 0x57, 0xa4, 0x5b, 0xd4,
-    0xe3, 0x88, 0x02, 0xc4, 0x81, 0xf9, 0x47, 0xe4, 0xbf, 0x3e, 0x39, 0xbb, 0x4f, 0x7e, 0x91, 0x63, 0x98, 0x97, 0xe4,
-    0x52, 0x01, 0x58, 0xba, 0x32, 0xbf, 0xae, 0xff, 0x45, 0xa1, 0xbc, 0x9b, 0xa4, 0x09, 0x0e, 0x79, 0xc0, 0x41, 0x86,
-    0x52, 0x88, 0x55, 0x39, 0x9d, 0xb6, 0xed, 0x35, 0x68, 0x29, 0xfa, 0xe6, 0x6c, 0x3d, 0x0a, 0xcd, 0x6a, 0x28, 0xfd,
-    0x65, 0x24, 0xce, 0x38, 0x98, 0x01, 0xd9, 0x3f, 0x1b, 0x4c, 0xc4, 0x5c, 0x1d, 0xaa, 0x21, 0x78, 0x67, 0xaf, 0x55,
-    0x72, 0x34, 0xf8, 0x1b, 0x03, 0x21, 0x27, 0x08, 0xbd, 0x59, 0x60, 0x48, 0x0d, 0xe2, 0x56, 0x9b, 0x30, 0x92, 0x8f,
-    0x67, 0x8a, 0x7f, 0x20, 0xbd, 0x2d, 0xfd, 0xc5, 0xb0, 0xa6, 0xaa, 0x77, 0x75, 0x26, 0x33, 0x2f, 0x20, 0x2a, 0xab,
-    0x5c, 0xd1, 0x3b, 0xda, 0xb2, 0x4c, 0xa4, 0x86, 0x25, 0x8d, 0x49, 0x05, 0xaf, 0x7a, 0xa8, 0xd4, 0x9c, 0x0d, 0xd3,
-    0x38, 0xa6, 0x5c, 0x29, 0x6b, 0x16, 0x27, 0x07, 0xf1, 0xbe, 0xe2, 0x24, 0xc1, 0x8d, 0x25, 0x76, 0xbc, 0xf6, 0x0d,
-    0xc2, 0x94, 0x25, 0xb8, 0xf3, 0x07, 0x9a, 0x49, 0xf4, 0x89, 0x82, 0x4d, 0x51, 0xb1, 0x96, 0x61, 0x62, 0x8d, 0xc8,
-    0x61, 0x65, 0x0d, 0x14, 0x34, 0x02, 0x65, 0x94, 0xcc, 0x1d, 0x85, 0x00, 0x0f, 0x1a, 0x57, 0x68, 0x15, 0xcf, 0xa4,
-    0xa2, 0x7d, 0x6d, 0x53, 0x60, 0xce, 0x5c, 0x61, 0x82, 0x17, 0x32, 0xc1, 0x87, 0x02, 0x0c, 0x91, 0x85, 0x57, 0x51,
-    0xbe, 0xb2, 0x38, 0x9f, 0x3d, 0x2a, 0x52, 0x5a, 0xad, 0xba, 0x46, 0x9e, 0x3c, 0x8a, 0xa0, 0x46, 0x15, 0xf4, 0x59,
-    0x74, 0x5f, 0x2a, 0xae, 0x96, 0x56, 0xf0, 0x54, 0x39, 0xaf, 0xac, 0x2a, 0xb9, 0xad, 0x32, 0x50, 0xc9, 0xc1, 0xee,
-    0xd2, 0x0d, 0x34, 0xaa, 0x98, 0x4d, 0x6d, 0x3d, 0xc6, 0xb9, 0x5b, 0x00, 0x5f, 0xea, 0xda, 0x16, 0xa6, 0x08, 0x43,
-    0x58, 0x4d, 0x8d, 0x07, 0x55, 0x62, 0x81, 0x44, 0xcc, 0x31, 0x04, 0x4b, 0x4c, 0x8b, 0x3e, 0xff, 0xd8, 0xf6, 0x65,
-    0x19, 0xa1, 0x94, 0x62, 0x65, 0x0a, 0xdd, 0x60, 0x38, 0xd3, 0xbe, 0x0d, 0xa3, 0x99, 0xd5, 0x37, 0x68, 0xa1, 0x71,
-    0xa3, 0x41, 0xe7, 0xbe, 0x9d, 0x72, 0x84, 0x75, 0xb6, 0x8d, 0x98, 0xd6, 0xb8, 0x2d, 0x43, 0x85, 0x5d, 0xf9, 0xca,
-    0xc3, 0x96, 0xa5, 0xa6, 0xe7, 0x50, 0x88, 0x6b, 0x84, 0x58, 0x44, 0x45, 0x20, 0xdf, 0x1e, 0x5a, 0xc9, 0xce, 0x42,
-    0x2a, 0x1f, 0x3e, 0x3c, 0x7b, 0x68, 0x3c, 0x34, 0x8b, 0x36, 0xba, 0x1f, 0xce, 0x0f, 0xa0, 0x60, 0x37, 0x5f, 0x1a,
-    0x03, 0x2b, 0x86, 0x29, 0x45, 0x7b, 0xb4, 0xb7, 0x06, 0x68, 0x17, 0x7e, 0x13, 0x76, 0x91, 0x4d, 0x27, 0xee, 0xbc,
-    0x7e, 0x80, 0xc2, 0x66, 0xac, 0xc6, 0xbf, 0xeb, 0x7f, 0xd7, 0x84, 0x79, 0xf3, 0xf1, 0xde, 0xec, 0xa6, 0x93, 0xa8,
-    0x13, 0x3b, 0x4a, 0x81, 0xfa, 0x11, 0x1e, 0x4a, 0xd2, 0x50, 0x2a, 0xea, 0x9a, 0xc2, 0x37, 0x08, 0xed, 0x01, 0xf5,
-    0xa2, 0xd5, 0x32, 0x29, 0x49, 0xc4, 0x1a, 0x11, 0xc0, 0xda, 0x24, 0x28, 0x84, 0x38, 0x60, 0x80, 0xcf, 0xd0, 0x45,
-    0x83, 0xa7, 0xca, 0x52, 0x5c, 0xac, 0x23, 0x01};
-
-// Backwards compatibility alias
-#define INDEX_GZ INDEX_BR
-
-#endif  // USE_CAPTIVE_PORTAL_GZIP
-
-}  // namespace esphome::captive_portal
+}  // namespace captive_portal
+}  // namespace esphome

esphome/components/captive_portal/captive_portal.cpp

@@ -54,13 +54,8 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
            "  SSID='%s'\n"
            "  Password=" LOG_SECRET("'%s'"),
            ssid.c_str(), psk.c_str());
-#ifdef USE_ESP8266
-  // ESP8266 is single-threaded, call directly
-  wifi::global_wifi_component->save_wifi_sta(ssid, psk);
-#else
   // Defer save to main loop thread to avoid NVS operations from HTTP thread
   this->defer([ssid, psk]() { wifi::global_wifi_component->save_wifi_sta(ssid, psk); });
-#endif
   request->redirect(ESPHOME_F("/?save"));
 }
 
@@ -112,11 +107,7 @@ void CaptivePortal::handleRequest(AsyncWebServerRequest *req) {
 #else
   auto *response = req->beginResponse_P(200, ESPHOME_F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
 #endif
-#ifdef USE_CAPTIVE_PORTAL_GZIP
   response->addHeader(ESPHOME_F("Content-Encoding"), ESPHOME_F("gzip"));
-#else
-  response->addHeader(ESPHOME_F("Content-Encoding"), ESPHOME_F("br"));
-#endif
   req->send(response);
 }
 

esphome/components/cc1101/__init__.py

@@ -264,7 +264,6 @@ async def to_code(config):
             var.get_packet_trigger(),
             [
                 (cg.std_vector.template(cg.uint8), "x"),
-                (cg.float_, "freq_offset"),
                 (cg.float_, "rssi"),
                 (cg.uint8, "lqi"),
             ],

esphome/components/cc1101/cc1101.cpp

@@ -140,10 +140,7 @@ void CC1101Component::setup() {
     this->write_(static_cast<Register>(i));
   }
   this->set_output_power(this->output_power_requested_);
-  if (!this->enter_rx_()) {
-    this->mark_failed();
-    return;
-  }
+  this->strobe_(Command::RX);
 
   // Defer pin mode setup until after all components have completed setup()
   // This handles the case where remote_transmitter runs after CC1101 and changes pin mode
@@ -166,7 +163,8 @@ void CC1101Component::loop() {
     ESP_LOGW(TAG, "RX FIFO overflow, flushing");
     this->enter_idle_();
     this->strobe_(Command::FRX);
-    this->enter_rx_();
+    this->strobe_(Command::RX);
+    this->wait_for_state_(State::RX);
     return;
   }
 
@@ -183,28 +181,28 @@ void CC1101Component::loop() {
     ESP_LOGW(TAG, "Invalid packet: rx_bytes %u, payload_length %u", rx_bytes, payload_length);
     this->enter_idle_();
     this->strobe_(Command::FRX);
-    this->enter_rx_();
+    this->strobe_(Command::RX);
+    this->wait_for_state_(State::RX);
     return;
   }
   this->packet_.resize(payload_length);
   this->read_(Register::FIFO, this->packet_.data(), payload_length);
 
   // Read status from registers (more reliable than FIFO status bytes due to timing issues)
-  this->read_(Register::FREQEST);
   this->read_(Register::RSSI);
   this->read_(Register::LQI);
-  float freq_offset = static_cast<int8_t>(this->state_.FREQEST) * (XTAL_FREQUENCY / (1 << 14));
   float rssi = (this->state_.RSSI * RSSI_STEP) - RSSI_OFFSET;
   bool crc_ok = (this->state_.LQI & STATUS_CRC_OK_MASK) != 0;
   uint8_t lqi = this->state_.LQI & STATUS_LQI_MASK;
   if (this->state_.CRC_EN == 0 || crc_ok) {
-    this->packet_trigger_->trigger(this->packet_, freq_offset, rssi, lqi);
+    this->packet_trigger_->trigger(this->packet_, rssi, lqi);
   }
 
   // Return to rx
   this->enter_idle_();
   this->strobe_(Command::FRX);
-  this->enter_rx_();
+  this->strobe_(Command::RX);
+  this->wait_for_state_(State::RX);
 }
 
 void CC1101Component::dump_config() {
@@ -235,8 +233,9 @@ void CC1101Component::begin_tx() {
   if (this->gdo0_pin_ != nullptr) {
     this->gdo0_pin_->pin_mode(gpio::FLAG_OUTPUT);
   }
-  if (!this->enter_tx_()) {
-    ESP_LOGW(TAG, "Failed to enter TX state!");
+  this->strobe_(Command::TX);
+  if (!this->wait_for_state_(State::TX, 50)) {
+    ESP_LOGW(TAG, "Timed out waiting for TX state!");
   }
 }
 
@@ -245,9 +244,7 @@ void CC1101Component::begin_rx() {
   if (this->gdo0_pin_ != nullptr) {
     this->gdo0_pin_->pin_mode(gpio::FLAG_INPUT);
   }
-  if (!this->enter_rx_()) {
-    ESP_LOGW(TAG, "Failed to enter RX state!");
-  }
+  this->strobe_(Command::RX);
 }
 
 void CC1101Component::reset() {
@@ -273,33 +270,11 @@ bool CC1101Component::wait_for_state_(State target_state, uint32_t timeout_ms) {
   return false;
 }
 
-bool CC1101Component::enter_calibrated_(State target_state, Command cmd) {
-  // The PLL must be recalibrated until PLL lock is achieved
-  for (uint8_t retries = PLL_LOCK_RETRIES; retries > 0; retries--) {
-    this->strobe_(cmd);
-    if (!this->wait_for_state_(target_state)) {
-      return false;
-    }
-    this->read_(Register::FSCAL1);
-    if (this->state_.FSCAL1 != FSCAL1_PLL_NOT_LOCKED) {
-      return true;
-    }
-    ESP_LOGW(TAG, "PLL lock failed, retrying calibration");
-    this->enter_idle_();
-  }
-  ESP_LOGE(TAG, "PLL lock failed after retries");
-  return false;
-}
-
 void CC1101Component::enter_idle_() {
   this->strobe_(Command::IDLE);
   this->wait_for_state_(State::IDLE);
 }
 
-bool CC1101Component::enter_rx_() { return this->enter_calibrated_(State::RX, Command::RX); }
-
-bool CC1101Component::enter_tx_() { return this->enter_calibrated_(State::TX, Command::TX); }
-
 uint8_t CC1101Component::strobe_(Command cmd) {
   uint8_t index = static_cast<uint8_t>(cmd);
   if (cmd < Command::RES || cmd > Command::NOP) {
@@ -361,26 +336,18 @@ CC1101Error CC1101Component::transmit_packet(const std::vector<uint8_t> &packet)
     this->write_(Register::FIFO, static_cast<uint8_t>(packet.size()));
   }
   this->write_(Register::FIFO, packet.data(), packet.size());
-
-  // Calibrate PLL
-  if (!this->enter_calibrated_(State::FSTXON, Command::FSTXON)) {
-    ESP_LOGW(TAG, "PLL lock failed during TX");
-    this->enter_idle_();
-    this->enter_rx_();
-    return CC1101Error::PLL_LOCK;
-  }
-
-  // Transmit packet
   this->strobe_(Command::TX);
   if (!this->wait_for_state_(State::IDLE, 1000)) {
     ESP_LOGW(TAG, "TX timeout");
     this->enter_idle_();
-    this->enter_rx_();
+    this->strobe_(Command::RX);
+    this->wait_for_state_(State::RX);
     return CC1101Error::TIMEOUT;
   }
 
   // Return to rx
-  this->enter_rx_();
+  this->strobe_(Command::RX);
+  this->wait_for_state_(State::RX);
   return CC1101Error::NONE;
 }
 
@@ -437,7 +404,7 @@ void CC1101Component::set_frequency(float value) {
     this->write_(Register::FREQ2);
     this->write_(Register::FREQ1);
     this->write_(Register::FREQ0);
-    this->enter_rx_();
+    this->strobe_(Command::RX);
   }
 }
 
@@ -464,7 +431,7 @@ void CC1101Component::set_channel(uint8_t value) {
   if (this->initialized_) {
     this->enter_idle_();
     this->write_(Register::CHANNR);
-    this->enter_rx_();
+    this->strobe_(Command::RX);
   }
 }
 
@@ -533,7 +500,7 @@ void CC1101Component::set_modulation_type(Modulation value) {
     this->set_output_power(this->output_power_requested_);
     this->write_(Register::MDMCFG2);
     this->write_(Register::FREND0);
-    this->enter_rx_();
+    this->strobe_(Command::RX);
   }
 }
 

esphome/components/cc1101/cc1101.h

@@ -9,7 +9,7 @@
 
 namespace esphome::cc1101 {
 
-enum class CC1101Error { NONE = 0, TIMEOUT, PARAMS, CRC_ERROR, FIFO_OVERFLOW, PLL_LOCK };
+enum class CC1101Error { NONE = 0, TIMEOUT, PARAMS, CRC_ERROR, FIFO_OVERFLOW };
 
 class CC1101Component : public Component,
                         public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
@@ -73,7 +73,7 @@ class CC1101Component : public Component,
 
   // Packet mode operations
   CC1101Error transmit_packet(const std::vector<uint8_t> &packet);
-  Trigger<std::vector<uint8_t>, float, float, uint8_t> *get_packet_trigger() const { return this->packet_trigger_; }
+  Trigger<std::vector<uint8_t>, float, uint8_t> *get_packet_trigger() const { return this->packet_trigger_; }
 
  protected:
   uint16_t chip_id_{0};
@@ -89,8 +89,7 @@ class CC1101Component : public Component,
   InternalGPIOPin *gdo0_pin_{nullptr};
 
   // Packet handling
-  Trigger<std::vector<uint8_t>, float, float, uint8_t> *packet_trigger_{
-      new Trigger<std::vector<uint8_t>, float, float, uint8_t>()};
+  Trigger<std::vector<uint8_t>, float, uint8_t> *packet_trigger_{new Trigger<std::vector<uint8_t>, float, uint8_t>()};
   std::vector<uint8_t> packet_;
 
   // Low-level Helpers
@@ -103,10 +102,7 @@ class CC1101Component : public Component,
 
   // State Management
   bool wait_for_state_(State target_state, uint32_t timeout_ms = 100);
-  bool enter_calibrated_(State target_state, Command cmd);
   void enter_idle_();
-  bool enter_rx_();
-  bool enter_tx_();
 };
 
 // Action Wrappers

esphome/components/cc1101/cc1101defs.h

@@ -9,9 +9,6 @@ static constexpr float XTAL_FREQUENCY = 26000000;
 static constexpr float RSSI_OFFSET = 74.0f;
 static constexpr float RSSI_STEP = 0.5f;
 
-static constexpr uint8_t FSCAL1_PLL_NOT_LOCKED = 0x3F;
-static constexpr uint8_t PLL_LOCK_RETRIES = 3;
-
 static constexpr uint8_t STATUS_CRC_OK_MASK = 0x80;
 static constexpr uint8_t STATUS_LQI_MASK = 0x7F;
 

esphome/components/ch422g/ch422g.cpp

@@ -93,9 +93,7 @@ bool CH422GComponent::read_inputs_() {
 bool CH422GComponent::write_reg_(uint8_t reg, uint8_t value) {
   auto err = this->bus_->write_readv(reg, &value, 1, nullptr, 0);
   if (err != i2c::ERROR_OK) {
-    char buf[64];
-    snprintf(buf, sizeof(buf), "write failed for register 0x%X, error %d", reg, err);
-    this->status_set_warning(buf);
+    this->status_set_warning(str_sprintf("write failed for register 0x%X, error %d", reg, err).c_str());
     return false;
   }
   this->status_clear_warning();
@@ -106,9 +104,7 @@ uint8_t CH422GComponent::read_reg_(uint8_t reg) {
   uint8_t value;
   auto err = this->bus_->write_readv(reg, nullptr, 0, &value, 1);
   if (err != i2c::ERROR_OK) {
-    char buf[64];
-    snprintf(buf, sizeof(buf), "read failed for register 0x%X, error %d", reg, err);
-    this->status_set_warning(buf);
+    this->status_set_warning(str_sprintf("read failed for register 0x%X, error %d", reg, err).c_str());
     return 0;
   }
   this->status_clear_warning();

esphome/components/climate/climate.cpp

@@ -682,19 +682,19 @@ bool Climate::set_fan_mode_(ClimateFanMode mode) {
   return set_primary_mode(this->fan_mode, this->custom_fan_mode_, mode);
 }
 
-bool Climate::set_custom_fan_mode_(const char *mode, size_t len) {
+bool Climate::set_custom_fan_mode_(const char *mode) {
   auto traits = this->get_traits();
-  return set_custom_mode<ClimateFanMode>(this->custom_fan_mode_, this->fan_mode,
-                                         traits.find_custom_fan_mode_(mode, len), this->has_custom_fan_mode());
+  return set_custom_mode<ClimateFanMode>(this->custom_fan_mode_, this->fan_mode, traits.find_custom_fan_mode_(mode),
+                                         this->has_custom_fan_mode());
 }
 
 void Climate::clear_custom_fan_mode_() { this->custom_fan_mode_ = nullptr; }
 
 bool Climate::set_preset_(ClimatePreset preset) { return set_primary_mode(this->preset, this->custom_preset_, preset); }
 
-bool Climate::set_custom_preset_(const char *preset, size_t len) {
+bool Climate::set_custom_preset_(const char *preset) {
   auto traits = this->get_traits();
-  return set_custom_mode<ClimatePreset>(this->custom_preset_, this->preset, traits.find_custom_preset_(preset, len),
+  return set_custom_mode<ClimatePreset>(this->custom_preset_, this->preset, traits.find_custom_preset_(preset),
                                         this->has_custom_preset());
 }
 

esphome/components/climate/climate.h

@@ -5,7 +5,6 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/preferences.h"
-#include "esphome/core/string_ref.h"
 #include "climate_mode.h"
 #include "climate_traits.h"
 
@@ -111,8 +110,8 @@ class ClimateCall {
   const optional<ClimateFanMode> &get_fan_mode() const;
   const optional<ClimateSwingMode> &get_swing_mode() const;
   const optional<ClimatePreset> &get_preset() const;
-  StringRef get_custom_fan_mode() const { return StringRef::from_maybe_nullptr(this->custom_fan_mode_); }
-  StringRef get_custom_preset() const { return StringRef::from_maybe_nullptr(this->custom_preset_); }
+  const char *get_custom_fan_mode() const { return this->custom_fan_mode_; }
+  const char *get_custom_preset() const { return this->custom_preset_; }
   bool has_custom_fan_mode() const { return this->custom_fan_mode_ != nullptr; }
   bool has_custom_preset() const { return this->custom_preset_ != nullptr; }
 
@@ -267,11 +266,11 @@ class Climate : public EntityBase {
   /// The active swing mode of the climate device.
   ClimateSwingMode swing_mode{CLIMATE_SWING_OFF};
 
-  /// Get the active custom fan mode (read-only access). Returns StringRef.
-  StringRef get_custom_fan_mode() const { return StringRef::from_maybe_nullptr(this->custom_fan_mode_); }
+  /// Get the active custom fan mode (read-only access).
+  const char *get_custom_fan_mode() const { return this->custom_fan_mode_; }
 
-  /// Get the active custom preset (read-only access). Returns StringRef.
-  StringRef get_custom_preset() const { return StringRef::from_maybe_nullptr(this->custom_preset_); }
+  /// Get the active custom preset (read-only access).
+  const char *get_custom_preset() const { return this->custom_preset_; }
 
  protected:
   friend ClimateCall;
@@ -281,9 +280,7 @@ class Climate : public EntityBase {
   bool set_fan_mode_(ClimateFanMode mode);
 
   /// Set custom fan mode. Reset primary fan mode. Return true if fan mode has been changed.
-  bool set_custom_fan_mode_(const char *mode) { return this->set_custom_fan_mode_(mode, strlen(mode)); }
-  bool set_custom_fan_mode_(const char *mode, size_t len);
-  bool set_custom_fan_mode_(StringRef mode) { return this->set_custom_fan_mode_(mode.c_str(), mode.size()); }
+  bool set_custom_fan_mode_(const char *mode);
   /// Clear custom fan mode.
   void clear_custom_fan_mode_();
 
@@ -291,9 +288,7 @@ class Climate : public EntityBase {
   bool set_preset_(ClimatePreset preset);
 
   /// Set custom preset. Reset primary preset. Return true if preset has been changed.
-  bool set_custom_preset_(const char *preset) { return this->set_custom_preset_(preset, strlen(preset)); }
-  bool set_custom_preset_(const char *preset, size_t len);
-  bool set_custom_preset_(StringRef preset) { return this->set_custom_preset_(preset.c_str(), preset.size()); }
+  bool set_custom_preset_(const char *preset);
   /// Clear custom preset.
   void clear_custom_preset_();
 

esphome/components/copy/fan/copy_fan.cpp

@@ -8,24 +8,20 @@ static const char *const TAG = "copy.fan";
 
 void CopyFan::setup() {
   source_->add_on_state_callback([this]() {
-    this->copy_state_from_source_();
+    this->state = source_->state;
+    this->oscillating = source_->oscillating;
+    this->speed = source_->speed;
+    this->direction = source_->direction;
+    this->set_preset_mode_(source_->get_preset_mode());
     this->publish_state();
   });
 
-  this->copy_state_from_source_();
-  this->publish_state();
-}
-
-void CopyFan::copy_state_from_source_() {
   this->state = source_->state;
   this->oscillating = source_->oscillating;
   this->speed = source_->speed;
   this->direction = source_->direction;
-  if (source_->has_preset_mode()) {
-    this->set_preset_mode_(source_->get_preset_mode());
-  } else {
-    this->clear_preset_mode_();
-  }
+  this->set_preset_mode_(source_->get_preset_mode());
+  this->publish_state();
 }
 
 void CopyFan::dump_config() { LOG_FAN("", "Copy Fan", this); }

esphome/components/copy/fan/copy_fan.h

@@ -16,7 +16,7 @@ class CopyFan : public fan::Fan, public Component {
 
  protected:
   void control(const fan::FanCall &call) override;
-  void copy_state_from_source_();
+  ;
 
   fan::Fan *source_;
 };

esphome/components/dallas_temp/dallas_temp.cpp

@@ -31,8 +31,8 @@ void DallasTemperatureSensor::dump_config() {
     ESP_LOGW(TAG, "  Unable to select an address");
     return;
   }
-  LOG_ONE_WIRE_DEVICE(this);
   ESP_LOGCONFIG(TAG, "  Resolution: %u bits", this->resolution_);
+  LOG_ONE_WIRE_DEVICE(this);
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/debug/debug_component.cpp

@@ -28,23 +28,24 @@ void DebugComponent::dump_config() {
 #endif  // defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
 #endif  // USE_SENSOR
 
-  char device_info_buffer[DEVICE_INFO_BUFFER_SIZE];
+  std::string device_info;
+  device_info.reserve(256);
   ESP_LOGD(TAG, "ESPHome version %s", ESPHOME_VERSION);
-  size_t pos = buf_append(device_info_buffer, DEVICE_INFO_BUFFER_SIZE, 0, "%s", ESPHOME_VERSION);
+  device_info += ESPHOME_VERSION;
 
   this->free_heap_ = get_free_heap_();
   ESP_LOGD(TAG, "Free Heap Size: %" PRIu32 " bytes", this->free_heap_);
 
-  pos = get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>(device_info_buffer), pos);
+  get_device_info_(device_info);
 
 #ifdef USE_TEXT_SENSOR
   if (this->device_info_ != nullptr) {
-    this->device_info_->publish_state(device_info_buffer, pos);
+    if (device_info.length() > 255)
+      device_info.resize(255);
+    this->device_info_->publish_state(device_info);
   }
   if (this->reset_reason_ != nullptr) {
-    char reset_reason_buffer[RESET_REASON_BUFFER_SIZE];
-    this->reset_reason_->publish_state(
-        get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE>(reset_reason_buffer)));
+    this->reset_reason_->publish_state(get_reset_reason_());
   }
 #endif  // USE_TEXT_SENSOR
 

esphome/components/debug/debug_component.h

@@ -4,13 +4,6 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/macros.h"
-#include <span>
-#include <cstdarg>
-#include <cstdio>
-#include <algorithm>
-#ifdef USE_ESP8266
-#include <pgmspace.h>
-#endif
 
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
@@ -22,44 +15,6 @@
 namespace esphome {
 namespace debug {
 
-static constexpr size_t DEVICE_INFO_BUFFER_SIZE = 256;
-static constexpr size_t RESET_REASON_BUFFER_SIZE = 128;
-
-#ifdef USE_ESP8266
-// ESP8266: Use vsnprintf_P to keep format strings in flash (PROGMEM)
-// Format strings must be wrapped with PSTR() macro
-inline size_t buf_append_p(char *buf, size_t size, size_t pos, PGM_P fmt, ...) {
-  if (pos >= size) {
-    return size;
-  }
-  va_list args;
-  va_start(args, fmt);
-  int written = vsnprintf_P(buf + pos, size - pos, fmt, args);
-  va_end(args);
-  if (written < 0) {
-    return pos;  // encoding error
-  }
-  return std::min(pos + static_cast<size_t>(written), size);
-}
-#define buf_append(buf, size, pos, fmt, ...) buf_append_p(buf, size, pos, PSTR(fmt), ##__VA_ARGS__)
-#else
-/// Safely append formatted string to buffer, returning new position (capped at size)
-__attribute__((format(printf, 4, 5))) inline size_t buf_append(char *buf, size_t size, size_t pos, const char *fmt,
-                                                               ...) {
-  if (pos >= size) {
-    return size;
-  }
-  va_list args;
-  va_start(args, fmt);
-  int written = vsnprintf(buf + pos, size - pos, fmt, args);
-  va_end(args);
-  if (written < 0) {
-    return pos;  // encoding error
-  }
-  return std::min(pos + static_cast<size_t>(written), size);
-}
-#endif
-
 class DebugComponent : public PollingComponent {
  public:
   void loop() override;
@@ -126,10 +81,10 @@ class DebugComponent : public PollingComponent {
   text_sensor::TextSensor *reset_reason_{nullptr};
 #endif  // USE_TEXT_SENSOR
 
-  const char *get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer);
-  const char *get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer);
+  std::string get_reset_reason_();
+  std::string get_wakeup_cause_();
   uint32_t get_free_heap_();
-  size_t get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE> buffer, size_t pos);
+  void get_device_info_(std::string &device_info);
   void update_platform_();
 };
 

esphome/components/debug/debug_esp32.cpp

@@ -58,29 +58,24 @@ void DebugComponent::on_shutdown() {
   global_preferences->sync();
 }
 
-const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
-  char *buf = buffer.data();
-  const size_t size = RESET_REASON_BUFFER_SIZE;
-
+std::string DebugComponent::get_reset_reason_() {
+  std::string reset_reason;
   unsigned reason = esp_reset_reason();
   if (reason < sizeof(RESET_REASONS) / sizeof(RESET_REASONS[0])) {
+    reset_reason = RESET_REASONS[reason];
     if (reason == ESP_RST_SW) {
       auto pref = global_preferences->make_preference(REBOOT_MAX_LEN, fnv1_hash(REBOOT_KEY + App.get_name()));
-      char reboot_source[REBOOT_MAX_LEN]{};
-      if (pref.load(&reboot_source)) {
-        reboot_source[REBOOT_MAX_LEN - 1] = '\0';
-        snprintf(buf, size, "Reboot request from %s", reboot_source);
-      } else {
-        snprintf(buf, size, "%s", RESET_REASONS[reason]);
+      char buffer[REBOOT_MAX_LEN]{};
+      if (pref.load(&buffer)) {
+        buffer[REBOOT_MAX_LEN - 1] = '\0';
+        reset_reason = "Reboot request from " + std::string(buffer);
       }
-    } else {
-      snprintf(buf, size, "%s", RESET_REASONS[reason]);
     }
   } else {
-    snprintf(buf, size, "unknown source");
+    reset_reason = "unknown source";
   }
-  ESP_LOGD(TAG, "Reset Reason: %s", buf);
-  return buf;
+  ESP_LOGD(TAG, "Reset Reason: %s", reset_reason.c_str());
+  return reset_reason;
 }
 
 static const char *const WAKEUP_CAUSES[] = {
@@ -99,7 +94,7 @@ static const char *const WAKEUP_CAUSES[] = {
     "BT",
 };
 
-const char *DebugComponent::get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
+std::string DebugComponent::get_wakeup_cause_() {
   const char *wake_reason;
   unsigned reason = esp_sleep_get_wakeup_cause();
   if (reason < sizeof(WAKEUP_CAUSES) / sizeof(WAKEUP_CAUSES[0])) {
@@ -108,7 +103,6 @@ const char *DebugComponent::get_wakeup_cause_(std::span<char, RESET_REASON_BUFFE
     wake_reason = "unknown source";
   }
   ESP_LOGD(TAG, "Wakeup Reason: %s", wake_reason);
-  // Return the static string directly - no need to copy to buffer
   return wake_reason;
 }
 
@@ -142,10 +136,7 @@ static constexpr ChipFeature CHIP_FEATURES[] = {
     {CHIP_FEATURE_WIFI_BGN, "2.4GHz WiFi"},
 };
 
-size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE> buffer, size_t pos) {
-  constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
-  char *buf = buffer.data();
-
+void DebugComponent::get_device_info_(std::string &device_info) {
 #if defined(USE_ARDUINO)
   const char *flash_mode;
   switch (ESP.getFlashChipMode()) {  // NOLINT(readability-static-accessed-through-instance)
@@ -170,66 +161,68 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
     default:
       flash_mode = "UNKNOWN";
   }
-  uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT
-  uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT
-  ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed, flash_mode);
-  pos = buf_append(buf, size, pos, "|Flash: %" PRIu32 "kB Speed:%" PRIu32 "MHz Mode:%s", flash_size, flash_speed,
-                   flash_mode);
+  ESP_LOGD(TAG, "Flash Chip: Size=%ukB Speed=%uMHz Mode=%s",
+           ESP.getFlashChipSize() / 1024,                                                   // NOLINT
+           ESP.getFlashChipSpeed() / 1000000, flash_mode);                                  // NOLINT
+  device_info += "|Flash: " + to_string(ESP.getFlashChipSize() / 1024) +                    // NOLINT
+                 "kB Speed:" + to_string(ESP.getFlashChipSpeed() / 1000000) + "MHz Mode:";  // NOLINT
+  device_info += flash_mode;
 #endif
 
   esp_chip_info_t info;
   esp_chip_info(&info);
   const char *model = ESPHOME_VARIANT;
+  std::string features;
 
-  // Build features string
-  pos = buf_append(buf, size, pos, "|Chip: %s Features:", model);
-  bool first_feature = true;
+  // Check each known feature bit
   for (const auto &feature : CHIP_FEATURES) {
     if (info.features & feature.bit) {
-      pos = buf_append(buf, size, pos, "%s%s", first_feature ? "" : ", ", feature.name);
-      first_feature = false;
+      features += feature.name;
+      features += ", ";
       info.features &= ~feature.bit;
     }
   }
-  if (info.features != 0) {
-    pos = buf_append(buf, size, pos, "%sOther:0x%" PRIx32, first_feature ? "" : ", ", info.features);
-  }
-  ESP_LOGD(TAG, "Chip: Model=%s, Cores=%u, Revision=%u", model, info.cores, info.revision);
-  pos = buf_append(buf, size, pos, " Cores:%u Revision:%u", info.cores, info.revision);
-
-  uint32_t cpu_freq_mhz = arch_get_cpu_freq_hz() / 1000000;
-  ESP_LOGD(TAG, "CPU Frequency: %" PRIu32 " MHz", cpu_freq_mhz);
-  pos = buf_append(buf, size, pos, "|CPU Frequency: %" PRIu32 " MHz", cpu_freq_mhz);
+  if (info.features != 0)
+    features += "Other:" + format_hex(info.features);
+  ESP_LOGD(TAG, "Chip: Model=%s, Features=%s Cores=%u, Revision=%u", model, features.c_str(), info.cores,
+           info.revision);
+  device_info += "|Chip: ";
+  device_info += model;
+  device_info += " Features:";
+  device_info += features;
+  device_info += " Cores:" + to_string(info.cores);
+  device_info += " Revision:" + to_string(info.revision);
+  device_info += str_sprintf("|CPU Frequency: %" PRIu32 " MHz", arch_get_cpu_freq_hz() / 1000000);
+  ESP_LOGD(TAG, "CPU Frequency: %" PRIu32 " MHz", arch_get_cpu_freq_hz() / 1000000);
 
   // Framework detection
+  device_info += "|Framework: ";
 #ifdef USE_ARDUINO
   ESP_LOGD(TAG, "Framework: Arduino");
-  pos = buf_append(buf, size, pos, "|Framework: Arduino");
+  device_info += "Arduino";
 #elif defined(USE_ESP32)
   ESP_LOGD(TAG, "Framework: ESP-IDF");
-  pos = buf_append(buf, size, pos, "|Framework: ESP-IDF");
+  device_info += "ESP-IDF";
 #else
   ESP_LOGW(TAG, "Framework: UNKNOWN");
-  pos = buf_append(buf, size, pos, "|Framework: UNKNOWN");
+  device_info += "UNKNOWN";
 #endif
 
   ESP_LOGD(TAG, "ESP-IDF Version: %s", esp_get_idf_version());
-  pos = buf_append(buf, size, pos, "|ESP-IDF: %s", esp_get_idf_version());
+  device_info += "|ESP-IDF: ";
+  device_info += esp_get_idf_version();
 
-  uint8_t mac[6];
-  get_mac_address_raw(mac);
-  ESP_LOGD(TAG, "EFuse MAC: %02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
-  pos = buf_append(buf, size, pos, "|EFuse MAC: %02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4],
-                   mac[5]);
+  std::string mac = get_mac_address_pretty();
+  ESP_LOGD(TAG, "EFuse MAC: %s", mac.c_str());
+  device_info += "|EFuse MAC: ";
+  device_info += mac;
 
-  char reason_buffer[RESET_REASON_BUFFER_SIZE];
-  const char *reset_reason = get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE>(reason_buffer));
-  pos = buf_append(buf, size, pos, "|Reset: %s", reset_reason);
+  device_info += "|Reset: ";
+  device_info += get_reset_reason_();
 
-  const char *wakeup_cause = get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE>(reason_buffer));
-  pos = buf_append(buf, size, pos, "|Wakeup: %s", wakeup_cause);
-
-  return pos;
+  std::string wakeup_reason = this->get_wakeup_cause_();
+  device_info += "|Wakeup: ";
+  device_info += wakeup_reason;
 }
 
 void DebugComponent::update_platform_() {

esphome/components/debug/debug_esp8266.cpp

@@ -8,31 +8,19 @@ namespace debug {
 
 static const char *const TAG = "debug";
 
-const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
-  char *buf = buffer.data();
+std::string DebugComponent::get_reset_reason_() {
 #if !defined(CLANG_TIDY)
-  String reason = ESP.getResetReason();  // NOLINT
-  snprintf_P(buf, RESET_REASON_BUFFER_SIZE, PSTR("%s"), reason.c_str());
-  return buf;
+  return ESP.getResetReason().c_str();
 #else
-  buf[0] = '\0';
-  return buf;
-#endif
-}
-
-const char *DebugComponent::get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
-  // ESP8266 doesn't have detailed wakeup cause like ESP32
   return "";
+#endif
 }
 
 uint32_t DebugComponent::get_free_heap_() {
   return ESP.getFreeHeap();  // NOLINT(readability-static-accessed-through-instance)
 }
 
-size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE> buffer, size_t pos) {
-  constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
-  char *buf = buffer.data();
-
+void DebugComponent::get_device_info_(std::string &device_info) {
   const char *flash_mode;
   switch (ESP.getFlashChipMode()) {  // NOLINT(readability-static-accessed-through-instance)
     case FM_QIO:
@@ -50,45 +38,42 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
     default:
       flash_mode = "UNKNOWN";
   }
-  uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT
-  uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT
-  ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed, flash_mode);
-  pos = buf_append(buf, size, pos, "|Flash: %" PRIu32 "kB Speed:%" PRIu32 "MHz Mode:%s", flash_size, flash_speed,
-                   flash_mode);
+  ESP_LOGD(TAG, "Flash Chip: Size=%ukB Speed=%uMHz Mode=%s",
+           ESP.getFlashChipSize() / 1024,                                                   // NOLINT
+           ESP.getFlashChipSpeed() / 1000000, flash_mode);                                  // NOLINT
+  device_info += "|Flash: " + to_string(ESP.getFlashChipSize() / 1024) +                    // NOLINT
+                 "kB Speed:" + to_string(ESP.getFlashChipSpeed() / 1000000) + "MHz Mode:";  // NOLINT
+  device_info += flash_mode;
 
 #if !defined(CLANG_TIDY)
-  char reason_buffer[RESET_REASON_BUFFER_SIZE];
-  const char *reset_reason = get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE>(reason_buffer));
-  uint32_t chip_id = ESP.getChipId();
-  uint8_t boot_version = ESP.getBootVersion();
-  uint8_t boot_mode = ESP.getBootMode();
-  uint8_t cpu_freq = ESP.getCpuFreqMHz();
-  uint32_t flash_chip_id = ESP.getFlashChipId();
-
+  auto reset_reason = get_reset_reason_();
   ESP_LOGD(TAG,
-           "Chip ID: 0x%08" PRIX32 "\n"
+           "Chip ID: 0x%08X\n"
            "SDK Version: %s\n"
            "Core Version: %s\n"
            "Boot Version=%u Mode=%u\n"
            "CPU Frequency: %u\n"
-           "Flash Chip ID=0x%08" PRIX32 "\n"
+           "Flash Chip ID=0x%08X\n"
            "Reset Reason: %s\n"
            "Reset Info: %s",
-           chip_id, ESP.getSdkVersion(), ESP.getCoreVersion().c_str(), boot_version, boot_mode, cpu_freq, flash_chip_id,
-           reset_reason, ESP.getResetInfo().c_str());
+           ESP.getChipId(), ESP.getSdkVersion(), ESP.getCoreVersion().c_str(), ESP.getBootVersion(), ESP.getBootMode(),
+           ESP.getCpuFreqMHz(), ESP.getFlashChipId(), reset_reason.c_str(), ESP.getResetInfo().c_str());
 
-  pos = buf_append(buf, size, pos, "|Chip: 0x%08" PRIX32, chip_id);
-  pos = buf_append(buf, size, pos, "|SDK: %s", ESP.getSdkVersion());
-  pos = buf_append(buf, size, pos, "|Core: %s", ESP.getCoreVersion().c_str());
-  pos = buf_append(buf, size, pos, "|Boot: %u", boot_version);
-  pos = buf_append(buf, size, pos, "|Mode: %u", boot_mode);
-  pos = buf_append(buf, size, pos, "|CPU: %u", cpu_freq);
-  pos = buf_append(buf, size, pos, "|Flash: 0x%08" PRIX32, flash_chip_id);
-  pos = buf_append(buf, size, pos, "|Reset: %s", reset_reason);
-  pos = buf_append(buf, size, pos, "|%s", ESP.getResetInfo().c_str());
+  device_info += "|Chip: 0x" + format_hex(ESP.getChipId());
+  device_info += "|SDK: ";
+  device_info += ESP.getSdkVersion();
+  device_info += "|Core: ";
+  device_info += ESP.getCoreVersion().c_str();
+  device_info += "|Boot: ";
+  device_info += to_string(ESP.getBootVersion());
+  device_info += "|Mode: " + to_string(ESP.getBootMode());
+  device_info += "|CPU: " + to_string(ESP.getCpuFreqMHz());
+  device_info += "|Flash: 0x" + format_hex(ESP.getFlashChipId());
+  device_info += "|Reset: ";
+  device_info += reset_reason;
+  device_info += "|";
+  device_info += ESP.getResetInfo().c_str();
 #endif
-
-  return pos;
 }
 
 void DebugComponent::update_platform_() {

esphome/components/debug/debug_host.cpp

@@ -5,13 +5,11 @@
 namespace esphome {
 namespace debug {
 
-const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) { return ""; }
-
-const char *DebugComponent::get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) { return ""; }
+std::string DebugComponent::get_reset_reason_() { return ""; }
 
 uint32_t DebugComponent::get_free_heap_() { return INT_MAX; }
 
-size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE> buffer, size_t pos) { return pos; }
+void DebugComponent::get_device_info_(std::string &device_info) {}
 
 void DebugComponent::update_platform_() {}
 

esphome/components/debug/debug_libretiny.cpp

@@ -7,43 +7,31 @@ namespace debug {
 
 static const char *const TAG = "debug";
 
-const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
-  // Return the static string directly
-  return lt_get_reboot_reason_name(lt_get_reboot_reason());
-}
-
-const char *DebugComponent::get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) { return ""; }
+std::string DebugComponent::get_reset_reason_() { return lt_get_reboot_reason_name(lt_get_reboot_reason()); }
 
 uint32_t DebugComponent::get_free_heap_() { return lt_heap_get_free(); }
 
-size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE> buffer, size_t pos) {
-  constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
-  char *buf = buffer.data();
-
-  char reason_buffer[RESET_REASON_BUFFER_SIZE];
-  const char *reset_reason = get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE>(reason_buffer));
-  uint32_t flash_kib = lt_flash_get_size() / 1024;
-  uint32_t ram_kib = lt_ram_get_size() / 1024;
-  uint32_t mac_id = lt_cpu_get_mac_id();
-
+void DebugComponent::get_device_info_(std::string &device_info) {
+  std::string reset_reason = get_reset_reason_();
   ESP_LOGD(TAG,
            "LibreTiny Version: %s\n"
            "Chip: %s (%04x) @ %u MHz\n"
-           "Chip ID: 0x%06" PRIX32 "\n"
+           "Chip ID: 0x%06X\n"
            "Board: %s\n"
-           "Flash: %" PRIu32 " KiB / RAM: %" PRIu32 " KiB\n"
+           "Flash: %u KiB / RAM: %u KiB\n"
            "Reset Reason: %s",
-           lt_get_version(), lt_cpu_get_model_name(), lt_cpu_get_model(), lt_cpu_get_freq_mhz(), mac_id,
-           lt_get_board_code(), flash_kib, ram_kib, reset_reason);
+           lt_get_version(), lt_cpu_get_model_name(), lt_cpu_get_model(), lt_cpu_get_freq_mhz(), lt_cpu_get_mac_id(),
+           lt_get_board_code(), lt_flash_get_size() / 1024, lt_ram_get_size() / 1024, reset_reason.c_str());
 
-  pos = buf_append(buf, size, pos, "|Version: %s", LT_BANNER_STR + 10);
-  pos = buf_append(buf, size, pos, "|Reset Reason: %s", reset_reason);
-  pos = buf_append(buf, size, pos, "|Chip Name: %s", lt_cpu_get_model_name());
-  pos = buf_append(buf, size, pos, "|Chip ID: 0x%06" PRIX32, mac_id);
-  pos = buf_append(buf, size, pos, "|Flash: %" PRIu32 " KiB", flash_kib);
-  pos = buf_append(buf, size, pos, "|RAM: %" PRIu32 " KiB", ram_kib);
-
-  return pos;
+  device_info += "|Version: ";
+  device_info += LT_BANNER_STR + 10;
+  device_info += "|Reset Reason: ";
+  device_info += reset_reason;
+  device_info += "|Chip Name: ";
+  device_info += lt_cpu_get_model_name();
+  device_info += "|Chip ID: 0x" + format_hex(lt_cpu_get_mac_id());
+  device_info += "|Flash: " + to_string(lt_flash_get_size() / 1024) + " KiB";
+  device_info += "|RAM: " + to_string(lt_ram_get_size() / 1024) + " KiB";
 }
 
 void DebugComponent::update_platform_() {

esphome/components/debug/debug_rp2040.cpp

@@ -7,21 +7,13 @@ namespace debug {
 
 static const char *const TAG = "debug";
 
-const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) { return ""; }
-
-const char *DebugComponent::get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) { return ""; }
+std::string DebugComponent::get_reset_reason_() { return ""; }
 
 uint32_t DebugComponent::get_free_heap_() { return rp2040.getFreeHeap(); }
 
-size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE> buffer, size_t pos) {
-  constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
-  char *buf = buffer.data();
-
-  uint32_t cpu_freq = rp2040.f_cpu();
-  ESP_LOGD(TAG, "CPU Frequency: %" PRIu32, cpu_freq);
-  pos = buf_append(buf, size, pos, "|CPU Frequency: %" PRIu32, cpu_freq);
-
-  return pos;
+void DebugComponent::get_device_info_(std::string &device_info) {
+  ESP_LOGD(TAG, "CPU Frequency: %u", rp2040.f_cpu());
+  device_info += "CPU Frequency: " + to_string(rp2040.f_cpu());
 }
 
 void DebugComponent::update_platform_() {}

esphome/components/debug/debug_zephyr.cpp

@@ -15,14 +15,14 @@ static const char *const TAG = "debug";
 constexpr std::uintptr_t MBR_PARAM_PAGE_ADDR = 0xFFC;
 constexpr std::uintptr_t MBR_BOOTLOADER_ADDR = 0xFF8;
 
-static size_t append_reset_reason(char *buf, size_t size, size_t pos, bool set, const char *reason) {
+static void show_reset_reason(std::string &reset_reason, bool set, const char *reason) {
   if (!set) {
-    return pos;
+    return;
   }
-  if (pos > 0) {
-    pos = buf_append(buf, size, pos, ", ");
+  if (!reset_reason.empty()) {
+    reset_reason += ", ";
   }
-  return buf_append(buf, size, pos, "%s", reason);
+  reset_reason += reason;
 }
 
 static inline uint32_t read_mem_u32(uintptr_t addr) {
@@ -56,47 +56,33 @@ static inline uint32_t sd_version_get() {
   return 0;
 }
 
-const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
-  char *buf = buffer.data();
-  const size_t size = RESET_REASON_BUFFER_SIZE;
-
+std::string DebugComponent::get_reset_reason_() {
   uint32_t cause;
   auto ret = hwinfo_get_reset_cause(&cause);
   if (ret) {
     ESP_LOGE(TAG, "Unable to get reset cause: %d", ret);
-    buf[0] = '\0';
-    return buf;
+    return "";
   }
-  size_t pos = 0;
+  std::string reset_reason;
 
-  pos = append_reset_reason(buf, size, pos, cause & RESET_PIN, "External pin");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_SOFTWARE, "Software reset");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_BROWNOUT, "Brownout (drop in voltage)");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_POR, "Power-on reset (POR)");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_WATCHDOG, "Watchdog timer expiration");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_DEBUG, "Debug event");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_SECURITY, "Security violation");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_LOW_POWER_WAKE, "Waking up from low power mode");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_CPU_LOCKUP, "CPU lock-up detected");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_PARITY, "Parity error");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_PLL, "PLL error");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_CLOCK, "Clock error");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_HARDWARE, "Hardware reset");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_USER, "User reset");
-  pos = append_reset_reason(buf, size, pos, cause & RESET_TEMPERATURE, "Temperature reset");
+  show_reset_reason(reset_reason, cause & RESET_PIN, "External pin");
+  show_reset_reason(reset_reason, cause & RESET_SOFTWARE, "Software reset");
+  show_reset_reason(reset_reason, cause & RESET_BROWNOUT, "Brownout (drop in voltage)");
+  show_reset_reason(reset_reason, cause & RESET_POR, "Power-on reset (POR)");
+  show_reset_reason(reset_reason, cause & RESET_WATCHDOG, "Watchdog timer expiration");
+  show_reset_reason(reset_reason, cause & RESET_DEBUG, "Debug event");
+  show_reset_reason(reset_reason, cause & RESET_SECURITY, "Security violation");
+  show_reset_reason(reset_reason, cause & RESET_LOW_POWER_WAKE, "Waking up from low power mode");
+  show_reset_reason(reset_reason, cause & RESET_CPU_LOCKUP, "CPU lock-up detected");
+  show_reset_reason(reset_reason, cause & RESET_PARITY, "Parity error");
+  show_reset_reason(reset_reason, cause & RESET_PLL, "PLL error");
+  show_reset_reason(reset_reason, cause & RESET_CLOCK, "Clock error");
+  show_reset_reason(reset_reason, cause & RESET_HARDWARE, "Hardware reset");
+  show_reset_reason(reset_reason, cause & RESET_USER, "User reset");
+  show_reset_reason(reset_reason, cause & RESET_TEMPERATURE, "Temperature reset");
 
-  // Ensure null termination if nothing was written
-  if (pos == 0) {
-    buf[0] = '\0';
-  }
-
-  ESP_LOGD(TAG, "Reset Reason: %s", buf);
-  return buf;
-}
-
-const char *DebugComponent::get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
-  // Zephyr doesn't have detailed wakeup cause like ESP32
-  return "";
+  ESP_LOGD(TAG, "Reset Reason: %s", reset_reason.c_str());
+  return reset_reason;
 }
 
 uint32_t DebugComponent::get_free_heap_() { return INT_MAX; }
@@ -132,183 +118,175 @@ void DebugComponent::log_partition_info_() {
   flash_area_foreach(fa_cb, nullptr);
 }
 
-size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE> buffer, size_t pos) {
-  constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
-  char *buf = buffer.data();
+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) {
+    supply += "Normal voltage.";
+  } else {
+    supply += "High voltage.";
+  }
+  ESP_LOGD(TAG, "%s", supply.c_str());
+  device_info += "|" + supply;
 
-  // Main supply status
-  const char *supply_status =
-      (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_NORMAL) ? "Normal voltage." : "High voltage.";
-  ESP_LOGD(TAG, "Main supply status: %s", supply_status);
-  pos = buf_append(buf, size, pos, "|Main supply status: %s", supply_status);
-
-  // Regulator stage 0
+  std::string reg0 = "Regulator stage 0: ";
   if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_HIGH) {
-    const char *reg0_type = nrf_power_dcdcen_vddh_get(NRF_POWER) ? "DC/DC" : "LDO";
-    const char *reg0_voltage;
+    reg0 += nrf_power_dcdcen_vddh_get(NRF_POWER) ? "DC/DC" : "LDO";
+    reg0 += ", ";
     switch (NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) {
       case (UICR_REGOUT0_VOUT_DEFAULT << UICR_REGOUT0_VOUT_Pos):
-        reg0_voltage = "1.8V (default)";
+        reg0 += "1.8V (default)";
         break;
       case (UICR_REGOUT0_VOUT_1V8 << UICR_REGOUT0_VOUT_Pos):
-        reg0_voltage = "1.8V";
+        reg0 += "1.8V";
         break;
       case (UICR_REGOUT0_VOUT_2V1 << UICR_REGOUT0_VOUT_Pos):
-        reg0_voltage = "2.1V";
+        reg0 += "2.1V";
         break;
       case (UICR_REGOUT0_VOUT_2V4 << UICR_REGOUT0_VOUT_Pos):
-        reg0_voltage = "2.4V";
+        reg0 += "2.4V";
         break;
       case (UICR_REGOUT0_VOUT_2V7 << UICR_REGOUT0_VOUT_Pos):
-        reg0_voltage = "2.7V";
+        reg0 += "2.7V";
         break;
       case (UICR_REGOUT0_VOUT_3V0 << UICR_REGOUT0_VOUT_Pos):
-        reg0_voltage = "3.0V";
+        reg0 += "3.0V";
         break;
       case (UICR_REGOUT0_VOUT_3V3 << UICR_REGOUT0_VOUT_Pos):
-        reg0_voltage = "3.3V";
+        reg0 += "3.3V";
         break;
       default:
-        reg0_voltage = "???V";
+        reg0 += "???V";
     }
-    ESP_LOGD(TAG, "Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
-    pos = buf_append(buf, size, pos, "|Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
   } else {
-    ESP_LOGD(TAG, "Regulator stage 0: disabled");
-    pos = buf_append(buf, size, pos, "|Regulator stage 0: disabled");
+    reg0 += "disabled";
   }
+  ESP_LOGD(TAG, "%s", reg0.c_str());
+  device_info += "|" + reg0;
 
-  // Regulator stage 1
-  const char *reg1_type = nrf_power_dcdcen_get(NRF_POWER) ? "DC/DC" : "LDO";
-  ESP_LOGD(TAG, "Regulator stage 1: %s", reg1_type);
-  pos = buf_append(buf, size, pos, "|Regulator stage 1: %s", reg1_type);
+  std::string reg1 = "Regulator stage 1: ";
+  reg1 += nrf_power_dcdcen_get(NRF_POWER) ? "DC/DC" : "LDO";
+  ESP_LOGD(TAG, "%s", reg1.c_str());
+  device_info += "|" + reg1;
 
-  // USB power state
-  const char *usb_state;
+  std::string usb_power = "USB power state: ";
   if (nrf_power_usbregstatus_vbusdet_get(NRF_POWER)) {
     if (nrf_power_usbregstatus_outrdy_get(NRF_POWER)) {
-      usb_state = "ready";
+      /**< From the power viewpoint, USB is ready for working. */
+      usb_power += "ready";
     } else {
-      usb_state = "connected (regulator is not ready)";
+      /**< The USB power is detected, but USB power regulator is not ready. */
+      usb_power += "connected (regulator is not ready)";
     }
   } else {
-    usb_state = "disconnected";
+    /**< No power on USB lines detected. */
+    usb_power += "disconected";
   }
-  ESP_LOGD(TAG, "USB power state: %s", usb_state);
-  pos = buf_append(buf, size, pos, "|USB power state: %s", usb_state);
+  ESP_LOGD(TAG, "%s", usb_power.c_str());
+  device_info += "|" + usb_power;
 
-  // Power-fail comparator
   bool enabled;
-  nrf_power_pof_thr_t pof_thr = nrf_power_pofcon_get(NRF_POWER, &enabled);
+  nrf_power_pof_thr_t pof_thr;
+
+  pof_thr = nrf_power_pofcon_get(NRF_POWER, &enabled);
+  std::string pof = "Power-fail comparator: ";
   if (enabled) {
-    const char *pof_voltage;
     switch (pof_thr) {
       case POWER_POFCON_THRESHOLD_V17:
-        pof_voltage = "1.7V";
+        pof += "1.7V";
         break;
       case POWER_POFCON_THRESHOLD_V18:
-        pof_voltage = "1.8V";
+        pof += "1.8V";
         break;
       case POWER_POFCON_THRESHOLD_V19:
-        pof_voltage = "1.9V";
+        pof += "1.9V";
         break;
       case POWER_POFCON_THRESHOLD_V20:
-        pof_voltage = "2.0V";
+        pof += "2.0V";
         break;
       case POWER_POFCON_THRESHOLD_V21:
-        pof_voltage = "2.1V";
+        pof += "2.1V";
         break;
       case POWER_POFCON_THRESHOLD_V22:
-        pof_voltage = "2.2V";
+        pof += "2.2V";
         break;
       case POWER_POFCON_THRESHOLD_V23:
-        pof_voltage = "2.3V";
+        pof += "2.3V";
         break;
       case POWER_POFCON_THRESHOLD_V24:
-        pof_voltage = "2.4V";
+        pof += "2.4V";
         break;
       case POWER_POFCON_THRESHOLD_V25:
-        pof_voltage = "2.5V";
+        pof += "2.5V";
         break;
       case POWER_POFCON_THRESHOLD_V26:
-        pof_voltage = "2.6V";
+        pof += "2.6V";
         break;
       case POWER_POFCON_THRESHOLD_V27:
-        pof_voltage = "2.7V";
+        pof += "2.7V";
         break;
       case POWER_POFCON_THRESHOLD_V28:
-        pof_voltage = "2.8V";
-        break;
-      default:
-        pof_voltage = "???V";
+        pof += "2.8V";
         break;
     }
 
     if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_HIGH) {
-      const char *vddh_voltage;
+      pof += ", VDDH: ";
       switch (nrf_power_pofcon_vddh_get(NRF_POWER)) {
         case NRF_POWER_POFTHRVDDH_V27:
-          vddh_voltage = "2.7V";
+          pof += "2.7V";
           break;
         case NRF_POWER_POFTHRVDDH_V28:
-          vddh_voltage = "2.8V";
+          pof += "2.8V";
           break;
         case NRF_POWER_POFTHRVDDH_V29:
-          vddh_voltage = "2.9V";
+          pof += "2.9V";
           break;
         case NRF_POWER_POFTHRVDDH_V30:
-          vddh_voltage = "3.0V";
+          pof += "3.0V";
           break;
         case NRF_POWER_POFTHRVDDH_V31:
-          vddh_voltage = "3.1V";
+          pof += "3.1V";
           break;
         case NRF_POWER_POFTHRVDDH_V32:
-          vddh_voltage = "3.2V";
+          pof += "3.2V";
           break;
         case NRF_POWER_POFTHRVDDH_V33:
-          vddh_voltage = "3.3V";
+          pof += "3.3V";
           break;
         case NRF_POWER_POFTHRVDDH_V34:
-          vddh_voltage = "3.4V";
+          pof += "3.4V";
           break;
         case NRF_POWER_POFTHRVDDH_V35:
-          vddh_voltage = "3.5V";
+          pof += "3.5V";
           break;
         case NRF_POWER_POFTHRVDDH_V36:
-          vddh_voltage = "3.6V";
+          pof += "3.6V";
           break;
         case NRF_POWER_POFTHRVDDH_V37:
-          vddh_voltage = "3.7V";
+          pof += "3.7V";
           break;
         case NRF_POWER_POFTHRVDDH_V38:
-          vddh_voltage = "3.8V";
+          pof += "3.8V";
           break;
         case NRF_POWER_POFTHRVDDH_V39:
-          vddh_voltage = "3.9V";
+          pof += "3.9V";
           break;
         case NRF_POWER_POFTHRVDDH_V40:
-          vddh_voltage = "4.0V";
+          pof += "4.0V";
           break;
         case NRF_POWER_POFTHRVDDH_V41:
-          vddh_voltage = "4.1V";
+          pof += "4.1V";
           break;
         case NRF_POWER_POFTHRVDDH_V42:
-          vddh_voltage = "4.2V";
-          break;
-        default:
-          vddh_voltage = "???V";
+          pof += "4.2V";
           break;
       }
-      ESP_LOGD(TAG, "Power-fail comparator: %s, VDDH: %s", pof_voltage, vddh_voltage);
-      pos = buf_append(buf, size, pos, "|Power-fail comparator: %s, VDDH: %s", pof_voltage, vddh_voltage);
-    } else {
-      ESP_LOGD(TAG, "Power-fail comparator: %s", pof_voltage);
-      pos = buf_append(buf, size, pos, "|Power-fail comparator: %s", pof_voltage);
     }
   } else {
-    ESP_LOGD(TAG, "Power-fail comparator: disabled");
-    pos = buf_append(buf, size, pos, "|Power-fail comparator: disabled");
+    pof += "disabled";
   }
+  ESP_LOGD(TAG, "%s", pof.c_str());
+  device_info += "|" + pof;
 
   auto package = [](uint32_t value) {
     switch (value) {
@@ -322,8 +300,6 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
     return "Unspecified";
   };
 
-  char mac_pretty[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-  get_mac_address_pretty_into_buffer(mac_pretty);
   ESP_LOGD(TAG,
            "Code page size: %u, code size: %u, device id: 0x%08x%08x\n"
            "Encryption root: 0x%08x%08x%08x%08x, Identity Root: 0x%08x%08x%08x%08x\n"
@@ -332,10 +308,10 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
            "RAM: %ukB, Flash: %ukB, production test: %sdone",
            NRF_FICR->CODEPAGESIZE, NRF_FICR->CODESIZE, NRF_FICR->DEVICEID[1], NRF_FICR->DEVICEID[0], NRF_FICR->ER[0],
            NRF_FICR->ER[1], NRF_FICR->ER[2], NRF_FICR->ER[3], NRF_FICR->IR[0], NRF_FICR->IR[1], NRF_FICR->IR[2],
-           NRF_FICR->IR[3], (NRF_FICR->DEVICEADDRTYPE & 0x1 ? "Random" : "Public"), mac_pretty, NRF_FICR->INFO.PART,
-           NRF_FICR->INFO.VARIANT >> 24 & 0xFF, NRF_FICR->INFO.VARIANT >> 16 & 0xFF, NRF_FICR->INFO.VARIANT >> 8 & 0xFF,
-           NRF_FICR->INFO.VARIANT & 0xFF, package(NRF_FICR->INFO.PACKAGE), NRF_FICR->INFO.RAM, NRF_FICR->INFO.FLASH,
-           (NRF_FICR->PRODTEST[0] == 0xBB42319F ? "" : "not "));
+           NRF_FICR->IR[3], (NRF_FICR->DEVICEADDRTYPE & 0x1 ? "Random" : "Public"), get_mac_address_pretty().c_str(),
+           NRF_FICR->INFO.PART, NRF_FICR->INFO.VARIANT >> 24 & 0xFF, NRF_FICR->INFO.VARIANT >> 16 & 0xFF,
+           NRF_FICR->INFO.VARIANT >> 8 & 0xFF, NRF_FICR->INFO.VARIANT & 0xFF, package(NRF_FICR->INFO.PACKAGE),
+           NRF_FICR->INFO.RAM, NRF_FICR->INFO.FLASH, (NRF_FICR->PRODTEST[0] == 0xBB42319F ? "" : "not "));
   bool n_reset_enabled = NRF_UICR->PSELRESET[0] == NRF_UICR->PSELRESET[1] &&
                          (NRF_UICR->PSELRESET[0] & UICR_PSELRESET_CONNECT_Msk) == UICR_PSELRESET_CONNECT_Connected
                                                                                       << UICR_PSELRESET_CONNECT_Pos;
@@ -397,8 +373,6 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
            "NRFFW %s\n"
            "NRFHW %s",
            uicr(NRF_UICR->NRFFW, 13).c_str(), uicr(NRF_UICR->NRFHW, 12).c_str());
-
-  return pos;
 }
 
 void DebugComponent::update_platform_() {}

esphome/components/deep_sleep/deep_sleep_esp32.cpp

@@ -26,7 +26,7 @@ namespace deep_sleep {
 // - ext0: Single pin wakeup using RTC GPIO (esp_sleep_enable_ext0_wakeup)
 // - ext1: Multiple pin wakeup (esp_sleep_enable_ext1_wakeup)
 // - Touch: Touch pad wakeup (esp_sleep_enable_touchpad_wakeup)
-// - GPIO wakeup: GPIO wakeup for RTC pins (esp_deep_sleep_enable_gpio_wakeup)
+// - GPIO wakeup: GPIO wakeup for non-RTC pins (esp_deep_sleep_enable_gpio_wakeup)
 
 static const char *const TAG = "deep_sleep";
 
@@ -127,14 +127,22 @@ void DeepSleepComponent::deep_sleep_() {
     defined(USE_ESP32_VARIANT_ESP32C61)
   if (this->wakeup_pin_ != nullptr) {
     const auto gpio_pin = gpio_num_t(this->wakeup_pin_->get_pin());
-    // Make sure GPIO is in input mode, not all RTC GPIO pins are input by default
-    gpio_set_direction(gpio_pin, GPIO_MODE_INPUT);
+    if (this->wakeup_pin_->get_flags() & gpio::FLAG_PULLUP) {
+      gpio_sleep_set_pull_mode(gpio_pin, GPIO_PULLUP_ONLY);
+    } else if (this->wakeup_pin_->get_flags() & gpio::FLAG_PULLDOWN) {
+      gpio_sleep_set_pull_mode(gpio_pin, GPIO_PULLDOWN_ONLY);
+    }
+    gpio_sleep_set_direction(gpio_pin, GPIO_MODE_INPUT);
+    gpio_hold_en(gpio_pin);
+#if !SOC_GPIO_SUPPORT_HOLD_SINGLE_IO_IN_DSLP
+    // Some ESP32 variants support holding a single GPIO during deep sleep without this function
+    // For those variants, gpio_hold_en() is sufficient to hold the pin state during deep sleep
+    gpio_deep_sleep_hold_en();
+#endif
     bool level = !this->wakeup_pin_->is_inverted();
     if (this->wakeup_pin_mode_ == WAKEUP_PIN_MODE_INVERT_WAKEUP && this->wakeup_pin_->digital_read()) {
       level = !level;
     }
-    // Internal pullup/pulldown resistors are enabled automatically, when
-    // ESP_SLEEP_GPIO_ENABLE_INTERNAL_RESISTORS is set (by default it is)
     esp_deep_sleep_enable_gpio_wakeup(1 << this->wakeup_pin_->get_pin(),
                                       static_cast<esp_deepsleep_gpio_wake_up_mode_t>(level));
   }

esphome/components/display_menu_base/menu_item.cpp

@@ -42,8 +42,7 @@ std::string MenuItemSelect::get_value_text() const {
     result = this->value_getter_.value()(this);
   } else {
     if (this->select_var_ != nullptr) {
-      auto option = this->select_var_->current_option();
-      result.assign(option.c_str(), option.size());
+      result = this->select_var_->current_option();
     }
   }
 

esphome/components/dsmr/__init__.py

@@ -4,7 +4,7 @@ from esphome.components import uart
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_RECEIVE_TIMEOUT, CONF_UART_ID
 
-CODEOWNERS = ["@glmnet", "@zuidwijk", "@PolarGoose"]
+CODEOWNERS = ["@glmnet", "@zuidwijk"]
 
 MULTI_CONF = True
 
@@ -61,6 +61,7 @@ CONFIG_SCHEMA = cv.All(
             ): cv.positive_time_period_milliseconds,
         }
     ).extend(uart.UART_DEVICE_SCHEMA),
+    cv.only_with_arduino,
 )
 
 
@@ -82,7 +83,7 @@ async def to_code(config):
     cg.add_build_flag("-DDSMR_WATER_MBUS_ID=" + str(config[CONF_WATER_MBUS_ID]))
 
     # DSMR Parser
-    cg.add_library("esphome/dsmr_parser", "1.0.0")
+    cg.add_library("glmnet/Dsmr", "0.8")
 
     # Crypto
-    cg.add_library("polargoose/Crypto-no-arduino", "0.4.0")
+    cg.add_library("rweather/Crypto", "0.4.0")

esphome/components/dsmr/dsmr.cpp

@@ -1,3 +1,5 @@
+#ifdef USE_ARDUINO
+
 #include "dsmr.h"
 #include "esphome/core/log.h"
 
@@ -5,7 +7,8 @@
 #include <Crypto.h>
 #include <GCM.h>
 
-namespace esphome::dsmr {
+namespace esphome {
+namespace dsmr {
 
 static const char *const TAG = "dsmr";
 
@@ -254,9 +257,9 @@ bool Dsmr::parse_telegram() {
   ESP_LOGV(TAG, "Trying to parse telegram");
   this->stop_requesting_data_();
 
-  const auto &res = dsmr_parser::P1Parser::parse(
-      data, this->telegram_, this->bytes_read_, false,
-      this->crc_check_);  // Parse telegram according to data definition. Ignore unknown values.
+  ::dsmr::ParseResult<void> res =
+      ::dsmr::P1Parser::parse(&data, this->telegram_, this->bytes_read_, false,
+                              this->crc_check_);  // Parse telegram according to data definition. Ignore unknown values.
   if (res.err) {
     // Parsing error, show it
     auto err_str = res.fullError(this->telegram_, this->telegram_ + this->bytes_read_);
@@ -268,7 +271,7 @@ bool Dsmr::parse_telegram() {
 
     // publish the telegram, after publishing the sensors so it can also trigger action based on latest values
     if (this->s_telegram_ != nullptr) {
-      this->s_telegram_->publish_state(this->telegram_, this->bytes_read_);
+      this->s_telegram_->publish_state(std::string(this->telegram_, this->bytes_read_));
     }
     return true;
   }
@@ -326,4 +329,7 @@ void Dsmr::set_decryption_key(const std::string &decryption_key) {
   }
 }
 
-}  // namespace esphome::dsmr
+}  // namespace dsmr
+}  // namespace esphome
+
+#endif  // USE_ARDUINO

esphome/components/dsmr/dsmr.h

@@ -1,17 +1,24 @@
 #pragma once
 
+#ifdef USE_ARDUINO
+
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/text_sensor/text_sensor.h"
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/log.h"
-#include <dsmr_parser/fields.h>
-#include <dsmr_parser/parser.h>
+#include "esphome/core/defines.h"
+
+// don't include <dsmr.h> because it puts everything in global namespace
+#include <dsmr/parser.h>
+#include <dsmr/fields.h>
+
 #include <vector>
 
-namespace esphome::dsmr {
+namespace esphome {
+namespace dsmr {
 
-using namespace dsmr_parser::fields;
+using namespace ::dsmr::fields;
 
 // DSMR_**_LIST generated by ESPHome and written in esphome/core/defines
 
@@ -37,8 +44,8 @@ using namespace dsmr_parser::fields;
 #define DSMR_DATA_SENSOR(s) s
 #define DSMR_COMMA ,
 
-using MyData = dsmr_parser::ParsedData<DSMR_TEXT_SENSOR_LIST(DSMR_DATA_SENSOR, DSMR_COMMA)
-                                           DSMR_BOTH DSMR_SENSOR_LIST(DSMR_DATA_SENSOR, DSMR_COMMA)>;
+using MyData = ::dsmr::ParsedData<DSMR_TEXT_SENSOR_LIST(DSMR_DATA_SENSOR, DSMR_COMMA)
+                                      DSMR_BOTH DSMR_SENSOR_LIST(DSMR_DATA_SENSOR, DSMR_COMMA)>;
 
 class Dsmr : public Component, public uart::UARTDevice {
  public:
@@ -133,4 +140,7 @@ class Dsmr : public Component, public uart::UARTDevice {
   std::vector<uint8_t> decryption_key_{};
   bool crc_check_;
 };
-}  // namespace esphome::dsmr
+}  // namespace dsmr
+}  // namespace esphome
+
+#endif  // USE_ARDUINO

esphome/components/dsmr/sensor.py

@@ -3,34 +3,27 @@ from esphome.components import sensor
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
-    DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_CURRENT,
-    DEVICE_CLASS_DURATION,
     DEVICE_CLASS_ENERGY,
-    DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_GAS,
     DEVICE_CLASS_POWER,
-    DEVICE_CLASS_REACTIVE_POWER,
     DEVICE_CLASS_VOLTAGE,
     DEVICE_CLASS_WATER,
     STATE_CLASS_MEASUREMENT,
     STATE_CLASS_TOTAL_INCREASING,
     UNIT_AMPERE,
     UNIT_CUBIC_METER,
-    UNIT_HERTZ,
-    UNIT_KILOVOLT_AMPS,
     UNIT_KILOVOLT_AMPS_REACTIVE,
     UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
     UNIT_KILOWATT,
     UNIT_KILOWATT_HOURS,
-    UNIT_SECOND,
     UNIT_VOLT,
 )
 
 from . import CONF_DSMR_ID, Dsmr
 
 AUTO_LOAD = ["dsmr"]
-UNIT_GIGA_JOULE = "GJ"
+
 
 CONFIG_SCHEMA = cv.Schema(
     {
@@ -53,18 +46,6 @@ CONFIG_SCHEMA = cv.Schema(
             device_class=DEVICE_CLASS_ENERGY,
             state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
-        cv.Optional("energy_delivered_tariff3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_delivered_tariff4"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
         cv.Optional("energy_returned_lux"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOWATT_HOURS,
             accuracy_decimals=3,
@@ -83,82 +64,14 @@ CONFIG_SCHEMA = cv.Schema(
             device_class=DEVICE_CLASS_ENERGY,
             state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
-        cv.Optional("energy_returned_tariff3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_returned_tariff4"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_delivered_tariff1_ch"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_delivered_tariff2_ch"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_returned_tariff1_ch"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_returned_tariff2_ch"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
         cv.Optional("total_imported_energy"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
         ),
-        cv.Optional("reactive_energy_delivered_tariff1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
-            accuracy_decimals=3,
-        ),
-        cv.Optional("reactive_energy_delivered_tariff2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
-            accuracy_decimals=3,
-        ),
-        cv.Optional("reactive_energy_delivered_tariff3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
-            accuracy_decimals=3,
-        ),
-        cv.Optional("reactive_energy_delivered_tariff4"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
-            accuracy_decimals=3,
-        ),
         cv.Optional("total_exported_energy"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
             accuracy_decimals=3,
         ),
-        cv.Optional("reactive_energy_returned_tariff1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
-            accuracy_decimals=3,
-        ),
-        cv.Optional("reactive_energy_returned_tariff2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
-            accuracy_decimals=3,
-        ),
-        cv.Optional("reactive_energy_returned_tariff3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
-            accuracy_decimals=3,
-        ),
-        cv.Optional("reactive_energy_returned_tariff4"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
-            accuracy_decimals=3,
-        ),
         cv.Optional("power_delivered"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOWATT,
             accuracy_decimals=3,
@@ -171,195 +84,61 @@ CONFIG_SCHEMA = cv.Schema(
             device_class=DEVICE_CLASS_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
-        cv.Optional("power_delivered_ch"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("power_returned_ch"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
         cv.Optional("reactive_power_delivered"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
             accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("reactive_power_returned"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
             accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("electricity_threshold"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT,
             accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("electricity_switch_position"): sensor.sensor_schema(
             accuracy_decimals=3,
-            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("electricity_failures"): sensor.sensor_schema(
             accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("electricity_long_failures"): sensor.sensor_schema(
             accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("electricity_sags_l1"): sensor.sensor_schema(
             accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("electricity_sags_l2"): sensor.sensor_schema(
             accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("electricity_sags_l3"): sensor.sensor_schema(
             accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("electricity_swells_l1"): sensor.sensor_schema(
             accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("electricity_swells_l2"): sensor.sensor_schema(
             accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("electricity_swells_l3"): sensor.sensor_schema(
             accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_sag_time_l1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_SECOND,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_DURATION,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_sag_time_l2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_SECOND,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_DURATION,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_sag_time_l3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_SECOND,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_DURATION,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_sag_l1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_sag_l2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_sag_l3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_swell_time_l1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_SECOND,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_DURATION,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_swell_time_l2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_SECOND,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_DURATION,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_swell_time_l3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_SECOND,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_DURATION,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_swell_l1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_swell_l2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_swell_l3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("current_l1"): sensor.sensor_schema(
             unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=3,
+            accuracy_decimals=1,
             device_class=DEVICE_CLASS_CURRENT,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("current_l2"): sensor.sensor_schema(
             unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=3,
+            accuracy_decimals=1,
             device_class=DEVICE_CLASS_CURRENT,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("current_l3"): sensor.sensor_schema(
             unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("current"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("current_n"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("current_sum"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("current_fuse_l1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("current_fuse_l2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("current_fuse_l3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=3,
+            accuracy_decimals=1,
             device_class=DEVICE_CLASS_CURRENT,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
@@ -402,93 +181,51 @@ CONFIG_SCHEMA = cv.Schema(
         cv.Optional("reactive_power_delivered_l1"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
             accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("reactive_power_delivered_l2"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
             accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("reactive_power_delivered_l3"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
             accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("reactive_power_returned_l1"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
             accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("reactive_power_returned_l2"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
             accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("reactive_power_returned_l3"): sensor.sensor_schema(
             unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
             accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("voltage_l1"): sensor.sensor_schema(
             unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=3,
+            accuracy_decimals=1,
             device_class=DEVICE_CLASS_VOLTAGE,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("voltage_l2"): sensor.sensor_schema(
             unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=3,
+            accuracy_decimals=1,
             device_class=DEVICE_CLASS_VOLTAGE,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional("voltage_l3"): sensor.sensor_schema(
             unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=3,
+            accuracy_decimals=1,
             device_class=DEVICE_CLASS_VOLTAGE,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
-        cv.Optional("voltage_avg_l1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_avg_l2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_avg_l3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("frequency"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_HERTZ,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_FREQUENCY,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("abs_power"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
         cv.Optional("gas_delivered"): sensor.sensor_schema(
             unit_of_measurement=UNIT_CUBIC_METER,
             accuracy_decimals=3,
@@ -507,109 +244,6 @@ CONFIG_SCHEMA = cv.Schema(
             device_class=DEVICE_CLASS_WATER,
             state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
-        cv.Optional("thermal_delivered"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_GIGA_JOULE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("sub_delivered"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_CUBIC_METER,
-            accuracy_decimals=3,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("gas_device_type"): sensor.sensor_schema(
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("gas_valve_position"): sensor.sensor_schema(
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("thermal_device_type"): sensor.sensor_schema(
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("thermal_valve_position"): sensor.sensor_schema(
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("water_device_type"): sensor.sensor_schema(
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("water_valve_position"): sensor.sensor_schema(
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("sub_device_type"): sensor.sensor_schema(
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("sub_valve_position"): sensor.sensor_schema(
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("apparent_delivery_power"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("apparent_delivery_power_l1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("apparent_delivery_power_l2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("apparent_delivery_power_l3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("apparent_return_power"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("apparent_return_power_l1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("apparent_return_power_l2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("apparent_return_power_l3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("active_demand_power"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("active_demand_abs"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
         cv.Optional(
             "active_energy_import_current_average_demand"
         ): sensor.sensor_schema(
@@ -618,90 +252,6 @@ CONFIG_SCHEMA = cv.Schema(
             device_class=DEVICE_CLASS_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
-        cv.Optional(
-            "active_energy_export_current_average_demand"
-        ): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(
-            "reactive_energy_import_current_average_demand"
-        ): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(
-            "reactive_energy_export_current_average_demand"
-        ): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(
-            "apparent_energy_import_current_average_demand"
-        ): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(
-            "apparent_energy_export_current_average_demand"
-        ): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("active_energy_import_last_completed_demand"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("active_energy_export_last_completed_demand"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(
-            "reactive_energy_import_last_completed_demand"
-        ): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(
-            "reactive_energy_export_last_completed_demand"
-        ): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_REACTIVE_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(
-            "apparent_energy_import_last_completed_demand"
-        ): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(
-            "apparent_energy_export_last_completed_demand"
-        ): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOVOLT_AMPS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_APPARENT_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
         cv.Optional(
             "active_energy_import_maximum_demand_running_month"
         ): sensor.sensor_schema(
@@ -718,14 +268,6 @@ CONFIG_SCHEMA = cv.Schema(
             device_class=DEVICE_CLASS_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
-        cv.Optional("fw_core_version"): sensor.sensor_schema(
-            accuracy_decimals=3,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("fw_module_version"): sensor.sensor_schema(
-            accuracy_decimals=3,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/dsmr/text_sensor.py

@@ -18,15 +18,11 @@ CONFIG_SCHEMA = cv.Schema(
         cv.Optional("electricity_failure_log"): text_sensor.text_sensor_schema(),
         cv.Optional("message_short"): text_sensor.text_sensor_schema(),
         cv.Optional("message_long"): text_sensor.text_sensor_schema(),
-        cv.Optional("equipment_id"): text_sensor.text_sensor_schema(),
         cv.Optional("gas_equipment_id"): text_sensor.text_sensor_schema(),
-        cv.Optional("gas_equipment_id_be"): text_sensor.text_sensor_schema(),
         cv.Optional("thermal_equipment_id"): text_sensor.text_sensor_schema(),
         cv.Optional("water_equipment_id"): text_sensor.text_sensor_schema(),
         cv.Optional("sub_equipment_id"): text_sensor.text_sensor_schema(),
         cv.Optional("gas_delivered_text"): text_sensor.text_sensor_schema(),
-        cv.Optional("fw_core_checksum"): text_sensor.text_sensor_schema(),
-        cv.Optional("fw_module_checksum"): text_sensor.text_sensor_schema(),
         cv.Optional("telegram"): text_sensor.text_sensor_schema().extend(
             {cv.Optional(CONF_INTERNAL, default=True): cv.boolean}
         ),

esphome/components/e131/e131.cpp

@@ -82,9 +82,8 @@ void E131Component::add_effect(E131AddressableLightEffect *light_effect) {
     return;
   }
 
-  auto effect_name = light_effect->get_name();
-  ESP_LOGD(TAG, "Registering '%.*s' for universes %d-%d.", (int) effect_name.size(), effect_name.c_str(),
-           light_effect->get_first_universe(), light_effect->get_last_universe());
+  ESP_LOGD(TAG, "Registering '%s' for universes %d-%d.", light_effect->get_name(), light_effect->get_first_universe(),
+           light_effect->get_last_universe());
 
   light_effects_.push_back(light_effect);
 
@@ -99,9 +98,8 @@ void E131Component::remove_effect(E131AddressableLightEffect *light_effect) {
     return;
   }
 
-  auto effect_name = light_effect->get_name();
-  ESP_LOGD(TAG, "Unregistering '%.*s' for universes %d-%d.", (int) effect_name.size(), effect_name.c_str(),
-           light_effect->get_first_universe(), light_effect->get_last_universe());
+  ESP_LOGD(TAG, "Unregistering '%s' for universes %d-%d.", light_effect->get_name(), light_effect->get_first_universe(),
+           light_effect->get_last_universe());
 
   // Swap with last element and pop for O(1) removal (order doesn't matter)
   *it = light_effects_.back();

esphome/components/e131/e131_addressable_light_effect.cpp

@@ -58,9 +58,8 @@ bool E131AddressableLightEffect::process_(int universe, const E131Packet &packet
       std::min(it->size(), std::min(output_offset + get_lights_per_universe(), output_offset + packet.count - 1));
   auto *input_data = packet.values + 1;
 
-  auto effect_name = get_name();
-  ESP_LOGV(TAG, "Applying data for '%.*s' on %d universe, for %" PRId32 "-%d.", (int) effect_name.size(),
-           effect_name.c_str(), universe, output_offset, output_end);
+  ESP_LOGV(TAG, "Applying data for '%s' on %d universe, for %" PRId32 "-%d.", get_name(), universe, output_offset,
+           output_end);
 
   switch (channels_) {
     case E131_MONO:

esphome/components/es8388/es8388.cpp

@@ -116,8 +116,9 @@ void ES8388::setup() {
   if (this->dac_output_select_ != nullptr) {
     auto dac_power = this->get_dac_power();
     if (dac_power.has_value()) {
-      if (this->dac_output_select_->has_index(dac_power.value())) {
-        this->dac_output_select_->publish_state(dac_power.value());
+      auto dac_power_str = this->dac_output_select_->at(dac_power.value());
+      if (dac_power_str.has_value()) {
+        this->dac_output_select_->publish_state(dac_power_str.value());
       } else {
         ESP_LOGW(TAG, "Unknown DAC output power value: %d", dac_power.value());
       }
@@ -126,8 +127,9 @@ void ES8388::setup() {
   if (this->adc_input_mic_select_ != nullptr) {
     auto mic_input = this->get_mic_input();
     if (mic_input.has_value()) {
-      if (this->adc_input_mic_select_->has_index(mic_input.value())) {
-        this->adc_input_mic_select_->publish_state(mic_input.value());
+      auto mic_input_str = this->adc_input_mic_select_->at(mic_input.value());
+      if (mic_input_str.has_value()) {
+        this->adc_input_mic_select_->publish_state(mic_input_str.value());
       } else {
         ESP_LOGW(TAG, "Unknown ADC input mic value: %d", mic_input.value());
       }

esphome/components/esp32/__init__.py

@@ -20,7 +20,6 @@ from esphome.const import (
     CONF_IGNORE_EFUSE_MAC_CRC,
     CONF_LOG_LEVEL,
     CONF_NAME,
-    CONF_OTA,
     CONF_PATH,
     CONF_PLATFORM_VERSION,
     CONF_PLATFORMIO_OPTIONS,
@@ -621,18 +620,11 @@ def final_validate(config):
             )
         )
     if advanced[CONF_ENABLE_OTA_ROLLBACK]:
-        # "disabled: false" means safe mode *is* enabled.
-        safe_mode_config = full_config.get(CONF_SAFE_MODE, {CONF_DISABLED: True})
-        safe_mode_enabled = not safe_mode_config[CONF_DISABLED]
-        ota_enabled = CONF_OTA in full_config
-        # Both need to be enabled for rollback to work
-        if not (ota_enabled and safe_mode_enabled):
-            # But only warn if ota is even possible
-            if ota_enabled:
-                _LOGGER.warning(
-                    "OTA rollback requires safe_mode, disabling rollback support"
-                )
-            # disable the rollback feature anyway since it can't be used.
+        safe_mode_config = full_config.get(CONF_SAFE_MODE)
+        if safe_mode_config is None or safe_mode_config.get(CONF_DISABLED, False):
+            _LOGGER.warning(
+                "OTA rollback requires safe_mode, disabling rollback support"
+            )
             advanced[CONF_ENABLE_OTA_ROLLBACK] = False
     if errs:
         raise cv.MultipleInvalid(errs)

esphome/components/esp32_ble/ble_uuid.cpp

@@ -39,36 +39,36 @@ ESPBTUUID ESPBTUUID::from_raw_reversed(const uint8_t *data) {
     ret.uuid_.uuid.uuid128[ESP_UUID_LEN_128 - 1 - i] = data[i];
   return ret;
 }
-ESPBTUUID ESPBTUUID::from_raw(const char *data, size_t length) {
+ESPBTUUID ESPBTUUID::from_raw(const std::string &data) {
   ESPBTUUID ret;
-  if (length == 4) {
+  if (data.length() == 4) {
     // 16-bit UUID as 4-character hex string
-    auto parsed = parse_hex<uint16_t>(data, length);
+    auto parsed = parse_hex<uint16_t>(data);
     if (parsed.has_value()) {
       ret.uuid_.len = ESP_UUID_LEN_16;
       ret.uuid_.uuid.uuid16 = parsed.value();
     }
-  } else if (length == 8) {
+  } else if (data.length() == 8) {
     // 32-bit UUID as 8-character hex string
-    auto parsed = parse_hex<uint32_t>(data, length);
+    auto parsed = parse_hex<uint32_t>(data);
     if (parsed.has_value()) {
       ret.uuid_.len = ESP_UUID_LEN_32;
       ret.uuid_.uuid.uuid32 = parsed.value();
     }
-  } else if (length == 16) {  // how we can have 16 byte length string reprezenting 128 bit uuid??? needs to be
-                              // investigated (lack of time)
+  } else if (data.length() == 16) {  // how we can have 16 byte length string reprezenting 128 bit uuid??? needs to be
+                                     // investigated (lack of time)
     ret.uuid_.len = ESP_UUID_LEN_128;
-    memcpy(ret.uuid_.uuid.uuid128, reinterpret_cast<const uint8_t *>(data), 16);
-  } else if (length == 36) {
+    memcpy(ret.uuid_.uuid.uuid128, (uint8_t *) data.data(), 16);
+  } else if (data.length() == 36) {
     // If the length of the string is 36 bytes then we will assume it is a long hex string in
     // UUID format.
     ret.uuid_.len = ESP_UUID_LEN_128;
     int n = 0;
-    for (size_t i = 0; i < length; i += 2) {
-      if (data[i] == '-')
+    for (uint i = 0; i < data.length(); i += 2) {
+      if (data.c_str()[i] == '-')
         i++;
-      uint8_t msb = data[i];
-      uint8_t lsb = data[i + 1];
+      uint8_t msb = data.c_str()[i];
+      uint8_t lsb = data.c_str()[i + 1];
 
       if (msb > '9')
         msb -= 7;
@@ -77,7 +77,7 @@ ESPBTUUID ESPBTUUID::from_raw(const char *data, size_t length) {
       ret.uuid_.uuid.uuid128[15 - n++] = ((msb & 0x0F) << 4) | (lsb & 0x0F);
     }
   } else {
-    ESP_LOGE(TAG, "ERROR: UUID value not 2, 4, 16 or 36 bytes - %s", data);
+    ESP_LOGE(TAG, "ERROR: UUID value not 2, 4, 16 or 36 bytes - %s", data.c_str());
   }
   return ret;
 }
@@ -143,7 +143,7 @@ bool ESPBTUUID::operator==(const ESPBTUUID &uuid) const {
   return this->as_128bit() == uuid.as_128bit();
 }
 esp_bt_uuid_t ESPBTUUID::get_uuid() const { return this->uuid_; }
-const char *ESPBTUUID::to_str(std::span<char, UUID_STR_LEN> output) const {
+void ESPBTUUID::to_str(std::span<char, UUID_STR_LEN> output) const {
   char *pos = output.data();
 
   switch (this->uuid_.len) {
@@ -155,7 +155,7 @@ const char *ESPBTUUID::to_str(std::span<char, UUID_STR_LEN> output) const {
       *pos++ = format_hex_pretty_char((this->uuid_.uuid.uuid16 >> 4) & 0x0F);
       *pos++ = format_hex_pretty_char(this->uuid_.uuid.uuid16 & 0x0F);
       *pos = '\0';
-      return output.data();
+      return;
 
     case ESP_UUID_LEN_32:
       *pos++ = '0';
@@ -164,7 +164,7 @@ const char *ESPBTUUID::to_str(std::span<char, UUID_STR_LEN> output) const {
         *pos++ = format_hex_pretty_char((this->uuid_.uuid.uuid32 >> shift) & 0x0F);
       }
       *pos = '\0';
-      return output.data();
+      return;
 
     default:
     case ESP_UUID_LEN_128:
@@ -178,7 +178,7 @@ const char *ESPBTUUID::to_str(std::span<char, UUID_STR_LEN> output) const {
         }
       }
       *pos = '\0';
-      return output.data();
+      return;
   }
 }
 std::string ESPBTUUID::to_string() const {