Merge branch 'object_id_no_ram' into no_send_object_id

Co-authored-by: Claude <noreply@anthropic.com>

CODEOWNERS

@@ -91,6 +91,7 @@ esphome/components/bmp3xx_spi/* @latonita
 esphome/components/bmp581/* @kahrendt
 esphome/components/bp1658cj/* @Cossid
 esphome/components/bp5758d/* @Cossid
+esphome/components/bthome_mithermometer/* @nagyrobi
 esphome/components/button/* @esphome/core
 esphome/components/bytebuffer/* @clydebarrow
 esphome/components/camera/* @bdraco @DT-art1

esphome/__main__.py

@@ -431,33 +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()
-                        nanoseconds = time_.microsecond // 1000
-                        time_str = f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}.{nanoseconds:03}]"
-
-                        # Add to buffer and process complete lines
-                        buffer += chunk
-                        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)
@@ -788,13 +780,6 @@ def command_vscode(args: ArgsProtocol) -> int | None:
 
 
 def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
-    # Set memory analysis options in config
-    if args.analyze_memory:
-        config.setdefault(CONF_ESPHOME, {})["analyze_memory"] = True
-
-    if args.memory_report:
-        config.setdefault(CONF_ESPHOME, {})["memory_report_file"] = args.memory_report
-
     exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
@@ -1278,17 +1263,6 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
-    parser_compile.add_argument(
-        "--analyze-memory",
-        help="Analyze and display memory usage by component after compilation.",
-        action="store_true",
-    )
-    parser_compile.add_argument(
-        "--memory-report",
-        help="Save memory analysis report to a file (supports .json or .txt).",
-        type=str,
-        metavar="FILE",
-    )
 
     parser_upload = subparsers.add_parser(
         "upload",

esphome/analyze_memory/cli.py

@@ -1,7 +1,6 @@
 """CLI interface for memory analysis with report generation."""
 
 from collections import defaultdict
-import json
 import sys
 
 from . import (
@@ -298,28 +297,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
         return "\n".join(lines)
 
-    def to_json(self) -> str:
-        """Export analysis results as JSON."""
-        data = {
-            "components": {
-                name: {
-                    "text": mem.text_size,
-                    "rodata": mem.rodata_size,
-                    "data": mem.data_size,
-                    "bss": mem.bss_size,
-                    "flash_total": mem.flash_total,
-                    "ram_total": mem.ram_total,
-                    "symbol_count": mem.symbol_count,
-                }
-                for name, mem in self.components.items()
-            },
-            "totals": {
-                "flash": sum(c.flash_total for c in self.components.values()),
-                "ram": sum(c.ram_total for c in self.components.values()),
-            },
-        }
-        return json.dumps(data, indent=2)
-
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:
         """Dump uncategorized symbols for analysis."""
         # Sort by size descending

esphome/components/a01nyub/a01nyub.cpp

@@ -30,9 +30,7 @@ void A01nyubComponent::check_buffer_() {
       ESP_LOGV(TAG, "Distance from sensor: %f mm, %f m", distance, meters);
       this->publish_state(meters);
     } else {
-      char hex_buf[format_hex_pretty_size(4)];
-      ESP_LOGW(TAG, "Invalid data read from sensor: %s",
-               format_hex_pretty_to(hex_buf, this->buffer_.data(), this->buffer_.size()));
+      ESP_LOGW(TAG, "Invalid data read from sensor: %s", format_hex_pretty(this->buffer_).c_str());
     }
   } else {
     ESP_LOGW(TAG, "checksum failed: %02x != %02x", checksum, this->buffer_[3]);

esphome/components/a02yyuw/a02yyuw.cpp

@@ -29,9 +29,7 @@ void A02yyuwComponent::check_buffer_() {
       ESP_LOGV(TAG, "Distance from sensor: %f mm", distance);
       this->publish_state(distance);
     } else {
-      char hex_buf[format_hex_pretty_size(4)];
-      ESP_LOGW(TAG, "Invalid data read from sensor: %s",
-               format_hex_pretty_to(hex_buf, this->buffer_.data(), this->buffer_.size()));
+      ESP_LOGW(TAG, "Invalid data read from sensor: %s", format_hex_pretty(this->buffer_).c_str());
     }
   } else {
     ESP_LOGW(TAG, "checksum failed: %02x != %02x", checksum, this->buffer_[3]);

esphome/components/addressable_light/addressable_light_display.h

@@ -25,13 +25,11 @@ class AddressableLightDisplay : public display::DisplayBuffer {
       if (enabled_ && !enabled) {  // enabled -> disabled
         // - Tell the parent light to refresh, effectively wiping the display. Also
         //   restores the previous effect (if any).
-        if (this->last_effect_index_.has_value()) {
-          light_state_->make_call().set_effect(*this->last_effect_index_).perform();
-        }
+        light_state_->make_call().set_effect(this->last_effect_).perform();
 
       } else if (!enabled_ && enabled) {  // disabled -> enabled
-        // - Save the current effect index.
-        this->last_effect_index_ = light_state_->get_current_effect_index();
+        // - Save the current effect.
+        this->last_effect_ = light_state_->get_effect_name();
         // - Disable any current effect.
         light_state_->make_call().set_effect(0).perform();
       }
@@ -58,7 +56,7 @@ class AddressableLightDisplay : public display::DisplayBuffer {
   int32_t width_;
   int32_t height_;
   std::vector<Color> addressable_light_buffer_;
-  optional<uint32_t> last_effect_index_;
+  optional<std::string> last_effect_;
   optional<std::function<int(int, int)>> pixel_mapper_f_;
 };
 }  // namespace addressable_light

esphome/components/api/api.proto

@@ -747,7 +747,7 @@ message NoiseEncryptionSetKeyRequest {
   option (source) = SOURCE_CLIENT;
   option (ifdef) = "USE_API_NOISE";
 
-  bytes key = 1;
+  bytes key = 1 [(pointer_to_buffer) = true];
 }
 
 message NoiseEncryptionSetKeyResponse {
@@ -796,7 +796,7 @@ message HomeassistantActionResponse {
   uint32 call_id = 1; // Matches the call_id from HomeassistantActionRequest
   bool success = 2; // Whether the service call succeeded
   string error_message = 3; // Error message if success = false
-  bytes response_data = 4 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
+  bytes response_data = 4 [(pointer_to_buffer) = true, (field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
 }
 
 // ==================== IMPORT HOME ASSISTANT STATES ====================
@@ -1292,7 +1292,7 @@ message ListEntitiesSirenResponse {
 
   string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
   bool disabled_by_default = 6;
-  repeated string tones = 7 [(container_pointer_no_template) = "FixedVector<const char *>"];
+  repeated string tones = 7;
   bool supports_duration = 8;
   bool supports_volume = 9;
   EntityCategory entity_category = 10;
@@ -1692,7 +1692,7 @@ message BluetoothGATTWriteRequest {
   uint32 handle = 2;
   bool response = 3;
 
-  bytes data = 4;
+  bytes data = 4 [(pointer_to_buffer) = true];
 }
 
 message BluetoothGATTReadDescriptorRequest {
@@ -1712,7 +1712,7 @@ message BluetoothGATTWriteDescriptorRequest {
   uint64 address = 1;
   uint32 handle = 2;
 
-  bytes data = 3;
+  bytes data = 3 [(pointer_to_buffer) = true];
 }
 
 message BluetoothGATTNotifyRequest {
@@ -1937,7 +1937,7 @@ message VoiceAssistantAudio {
   option (source) = SOURCE_BOTH;
   option (ifdef) = "USE_VOICE_ASSISTANT";
 
-  bytes data = 1 [(pointer_to_buffer) = true];
+  bytes data = 1;
   bool end = 2;
 }
 

esphome/components/api/api_connection.cpp

@@ -101,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
@@ -129,10 +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
-  char peername[socket::PEERNAME_MAX_LEN];
-  size_t len = this->helper_->getpeername_to(peername);
-  this->helper_->set_client_name(peername, len);
+  this->client_info_.peername = helper_->getpeername();
+  this->client_info_.name = this->client_info_.peername;
 }
 
 APIConnection::~APIConnection() {
@@ -252,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
@@ -286,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);
@@ -1503,12 +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
-  char peername_buf[socket::PEERNAME_MAX_LEN];
-  this->helper_->getpeername_to(peername_buf);
-  this->parent_->get_client_connected_trigger()->trigger(std::string(this->helper_->get_client_name()),
-                                                         std::string(peername_buf));
+  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) {
@@ -1523,14 +1521,12 @@ 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;
-  char peername[socket::PEERNAME_MAX_LEN];
-  this->helper_->getpeername_to(peername);
-  ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %" PRIu32 ".%" PRIu32, this->helper_->get_client_name(),
-           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;
@@ -1715,18 +1711,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_len;
-    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, 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
@@ -1761,20 +1749,20 @@ void APIConnection::execute_service(const ExecuteServiceRequest &msg) {
   // the action list. This ensures async actions (delays, waits) complete first.
 }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-void APIConnection::send_execute_service_response(uint32_t call_id, bool success, StringRef error_message) {
+void APIConnection::send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message) {
   ExecuteServiceResponse resp;
   resp.call_id = call_id;
   resp.success = success;
-  resp.set_error_message(error_message);
+  resp.set_error_message(StringRef(error_message));
   this->send_message(resp, ExecuteServiceResponse::MESSAGE_TYPE);
 }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-void APIConnection::send_execute_service_response(uint32_t call_id, bool success, StringRef error_message,
+void APIConnection::send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message,
                                                   const uint8_t *response_data, size_t response_data_len) {
   ExecuteServiceResponse resp;
   resp.call_id = call_id;
   resp.success = success;
-  resp.set_error_message(error_message);
+  resp.set_error_message(StringRef(error_message));
   resp.response_data = response_data;
   resp.response_data_len = response_data_len;
   this->send_message(resp, ExecuteServiceResponse::MESSAGE_TYPE);
@@ -1860,12 +1848,12 @@ bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
 #ifdef USE_API_PASSWORD
 void APIConnection::on_unauthenticated_access() {
   this->on_fatal_error();
-  this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("no authentication"));
+  ESP_LOGD(TAG, "%s (%s) no authentication", this->client_info_.name.c_str(), this->client_info_.peername.c_str());
 }
 #endif
 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();
@@ -2113,18 +2101,9 @@ void APIConnection::process_state_subscriptions_() {
 }
 #endif  // USE_API_HOMEASSISTANT_STATES
 
-void APIConnection::log_client_(int level, const LogString *message) {
-  char peername[socket::PEERNAME_MAX_LEN];
-  this->helper_->getpeername_to(peername);
-  esp_log_printf_(level, TAG, __LINE__, ESPHOME_LOG_FORMAT("%s (%s): %s"), this->helper_->get_client_name(), peername,
-                  LOG_STR_ARG(message));
-}
-
 void APIConnection::log_warning_(const LogString *message, APIError err) {
-  char peername[socket::PEERNAME_MAX_LEN];
-  this->helper_->getpeername_to(peername);
-  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->helper_->get_client_name(), peername, LOG_STR_ARG(message),
-           LOG_STR_ARG(api_error_to_logstr(err)), errno);
+  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);
 }
 
 }  // namespace esphome::api

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
@@ -229,9 +234,9 @@ class APIConnection final : public APIServerConnection {
 #ifdef USE_API_USER_DEFINED_ACTIONS
   void execute_service(const ExecuteServiceRequest &msg) override;
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-  void send_execute_service_response(uint32_t call_id, bool success, StringRef error_message);
+  void send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  void send_execute_service_response(uint32_t call_id, bool success, StringRef error_message,
+  void send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message,
                                      const uint8_t *response_data, size_t response_data_len);
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES
@@ -285,11 +290,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) into a stack buffer - avoids heap allocation
-  size_t get_peername_to(std::span<char, socket::PEERNAME_MAX_LEN> buf) const {
-    return this->helper_->getpeername_to(buf);
-  }
+  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
@@ -535,7 +537,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;
@@ -762,8 +767,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"
@@ -12,34 +13,12 @@ namespace esphome::api {
 
 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, ...) \
-  do { \
-    char peername__[socket::PEERNAME_MAX_LEN]; \
-    this->socket_->getpeername_to(peername__); \
-    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername__, ##__VA_ARGS__); \
-  } while (0)
-#else
-#define HELPER_LOG(msg, ...) ((void) 0)
-#endif
+  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) \
-  do { \
-    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
-    ESP_LOGVV(TAG, "Received frame: %s", \
-              format_hex_pretty_to(hex_buf_, (buffer).data(), \
-                                   (buffer).size() < API_MAX_LOG_BYTES ? (buffer).size() : API_MAX_LOG_BYTES)); \
-  } while (0)
-#define LOG_PACKET_SENDING(data, len) \
-  do { \
-    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
-    ESP_LOGVV(TAG, "Sending raw: %s", \
-              format_hex_pretty_to(hex_buf_, data, (len) < API_MAX_LOG_BYTES ? (len) : API_MAX_LOG_BYTES)); \
-  } while (0)
+#define LOG_PACKET_RECEIVED(buffer) ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(buffer).c_str())
+#define LOG_PACKET_SENDING(data, len) ESP_LOGVV(TAG, "Sending raw: %s", format_hex_pretty(data, len).c_str())
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
 #define LOG_PACKET_SENDING(data, len) ((void) 0)

esphome/components/api/api_frame_helper.h

@@ -29,10 +29,10 @@ static constexpr uint16_t MAX_MESSAGE_SIZE = 8192;  // 8 KiB for ESP8266
 static constexpr uint16_t MAX_MESSAGE_SIZE = 32768;  // 32 KiB for ESP32 and other platforms
 #endif
 
-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)
@@ -82,23 +82,15 @@ 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_; }
-  // 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); }
-  size_t getpeername_to(std::span<char, socket::PEERNAME_MAX_LEN> buf) { return socket_->getpeername_to(buf); }
   APIError close() {
     state_ = State::CLOSED;
     int err = this->socket_->close();
@@ -197,8 +189,9 @@ class APIFrameHelper {
   std::vector<struct iovec> reusable_iovs_;
   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]{};
+  // 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;

esphome/components/api/api_frame_helper_noise.cpp

@@ -24,34 +24,12 @@ static const char *const PROLOGUE_INIT = "NoiseAPIInit";
 #endif
 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, ...) \
-  do { \
-    char peername__[socket::PEERNAME_MAX_LEN]; \
-    this->socket_->getpeername_to(peername__); \
-    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername__, ##__VA_ARGS__); \
-  } while (0)
-#else
-#define HELPER_LOG(msg, ...) ((void) 0)
-#endif
+  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) \
-  do { \
-    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
-    ESP_LOGVV(TAG, "Received frame: %s", \
-              format_hex_pretty_to(hex_buf_, (buffer).data(), \
-                                   (buffer).size() < API_MAX_LOG_BYTES ? (buffer).size() : API_MAX_LOG_BYTES)); \
-  } while (0)
-#define LOG_PACKET_SENDING(data, len) \
-  do { \
-    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
-    ESP_LOGVV(TAG, "Sending raw: %s", \
-              format_hex_pretty_to(hex_buf_, data, (len) < API_MAX_LOG_BYTES ? (len) : API_MAX_LOG_BYTES)); \
-  } while (0)
+#define LOG_PACKET_RECEIVED(buffer) ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(buffer).c_str())
+#define LOG_PACKET_SENDING(data, len) ESP_LOGVV(TAG, "Sending raw: %s", format_hex_pretty(data, len).c_str())
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
 #define LOG_PACKET_SENDING(data, len) ((void) 0)

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"
@@ -17,34 +18,12 @@ namespace esphome::api {
 
 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, ...) \
-  do { \
-    char peername__[socket::PEERNAME_MAX_LEN]; \
-    this->socket_->getpeername_to(peername__); \
-    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername__, ##__VA_ARGS__); \
-  } while (0)
-#else
-#define HELPER_LOG(msg, ...) ((void) 0)
-#endif
+  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) \
-  do { \
-    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
-    ESP_LOGVV(TAG, "Received frame: %s", \
-              format_hex_pretty_to(hex_buf_, (buffer).data(), \
-                                   (buffer).size() < API_MAX_LOG_BYTES ? (buffer).size() : API_MAX_LOG_BYTES)); \
-  } while (0)
-#define LOG_PACKET_SENDING(data, len) \
-  do { \
-    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
-    ESP_LOGVV(TAG, "Sending raw: %s", \
-              format_hex_pretty_to(hex_buf_, data, (len) < API_MAX_LOG_BYTES ? (len) : API_MAX_LOG_BYTES)); \
-  } while (0)
+#define LOG_PACKET_RECEIVED(buffer) ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(buffer).c_str())
+#define LOG_PACKET_SENDING(data, len) ESP_LOGVV(TAG, "Sending raw: %s", format_hex_pretty(data, len).c_str())
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
 #define LOG_PACKET_SENDING(data, len) ((void) 0)

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_pb2.cpp

@@ -1710,8 +1710,8 @@ void ListEntitiesSirenResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(5, this->icon_ref_);
 #endif
   buffer.encode_bool(6, this->disabled_by_default);
-  for (const char *it : *this->tones) {
-    buffer.encode_string(7, it, strlen(it), true);
+  for (auto &it : this->tones) {
+    buffer.encode_string(7, it, true);
   }
   buffer.encode_bool(8, this->supports_duration);
   buffer.encode_bool(9, this->supports_volume);
@@ -1728,9 +1728,9 @@ void ListEntitiesSirenResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->icon_ref_.size());
 #endif
   size.add_bool(1, this->disabled_by_default);
-  if (!this->tones->empty()) {
-    for (const char *it : *this->tones) {
-      size.add_length_force(1, strlen(it));
+  if (!this->tones.empty()) {
+    for (const auto &it : this->tones) {
+      size.add_length_force(1, it.size());
     }
   }
   size.add_bool(1, this->supports_duration);
@@ -2527,22 +2527,20 @@ bool VoiceAssistantAudio::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 bool VoiceAssistantAudio::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1: {
-      this->data = value.data();
-      this->data_len = value.size();
+    case 1:
+      this->data = value.as_string();
       break;
-    }
     default:
       return false;
   }
   return true;
 }
 void VoiceAssistantAudio::encode(ProtoWriteBuffer buffer) const {
-  buffer.encode_bytes(1, this->data, this->data_len);
+  buffer.encode_bytes(1, this->data_ptr_, this->data_len_);
   buffer.encode_bool(2, this->end);
 }
 void VoiceAssistantAudio::calculate_size(ProtoSize &size) const {
-  size.add_length(1, this->data_len);
+  size.add_length(1, this->data_len_);
   size.add_bool(1, this->end);
 }
 bool VoiceAssistantTimerEventResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {

esphome/components/api/api_pb2.h

@@ -1069,7 +1069,7 @@ class SubscribeLogsResponse final : public ProtoMessage {
 class NoiseEncryptionSetKeyRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 124;
-  static constexpr uint8_t ESTIMATED_SIZE = 9;
+  static constexpr uint8_t ESTIMATED_SIZE = 19;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "noise_encryption_set_key_request"; }
 #endif
@@ -1161,7 +1161,7 @@ class HomeassistantActionRequest final : public ProtoMessage {
 class HomeassistantActionResponse final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 130;
-  static constexpr uint8_t ESTIMATED_SIZE = 24;
+  static constexpr uint8_t ESTIMATED_SIZE = 34;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "homeassistant_action_response"; }
 #endif
@@ -1708,7 +1708,7 @@ class ListEntitiesSirenResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_siren_response"; }
 #endif
-  const FixedVector<const char *> *tones{};
+  std::vector<std::string> tones{};
   bool supports_duration{false};
   bool supports_volume{false};
   void encode(ProtoWriteBuffer buffer) const override;
@@ -2146,7 +2146,7 @@ class BluetoothGATTReadResponse final : public ProtoMessage {
 class BluetoothGATTWriteRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 75;
-  static constexpr uint8_t ESTIMATED_SIZE = 19;
+  static constexpr uint8_t ESTIMATED_SIZE = 29;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "bluetooth_gatt_write_request"; }
 #endif
@@ -2182,7 +2182,7 @@ class BluetoothGATTReadDescriptorRequest final : public ProtoDecodableMessage {
 class BluetoothGATTWriteDescriptorRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 77;
-  static constexpr uint8_t ESTIMATED_SIZE = 17;
+  static constexpr uint8_t ESTIMATED_SIZE = 27;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "bluetooth_gatt_write_descriptor_request"; }
 #endif
@@ -2521,12 +2521,17 @@ class VoiceAssistantEventResponse final : public ProtoDecodableMessage {
 class VoiceAssistantAudio final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 106;
-  static constexpr uint8_t ESTIMATED_SIZE = 21;
+  static constexpr uint8_t ESTIMATED_SIZE = 11;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "voice_assistant_audio"; }
 #endif
-  const uint8_t *data{nullptr};
-  uint16_t data_len{0};
+  std::string data{};
+  const uint8_t *data_ptr_{nullptr};
+  size_t data_len_{0};
+  void set_data(const uint8_t *data, size_t len) {
+    this->data_ptr_ = data;
+    this->data_len_ = len;
+  }
   bool end{false};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;

esphome/components/api/api_pb2_dump.cpp

@@ -1579,7 +1579,7 @@ void ListEntitiesSirenResponse::dump_to(std::string &out) const {
   dump_field(out, "icon", this->icon_ref_);
 #endif
   dump_field(out, "disabled_by_default", this->disabled_by_default);
-  for (const auto &it : *this->tones) {
+  for (const auto &it : this->tones) {
     dump_field(out, "tones", it, 4);
   }
   dump_field(out, "supports_duration", this->supports_duration);
@@ -1978,7 +1978,11 @@ void VoiceAssistantEventResponse::dump_to(std::string &out) const {
 void VoiceAssistantAudio::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantAudio");
   out.append("  data: ");
-  out.append(format_hex_pretty(this->data, this->data_len));
+  if (this->data_ptr_ != nullptr) {
+    out.append(format_hex_pretty(this->data_ptr_, this->data_len_));
+  } else {
+    out.append(format_hex_pretty(reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size()));
+  }
   out.append("\n");
   dump_field(out, "end", this->end);
 }

esphome/components/api/api_server.cpp

@@ -125,18 +125,15 @@ void APIServer::loop() {
       if (!sock)
         break;
 
-      char peername[socket::PEERNAME_MAX_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
   }
@@ -187,14 +185,12 @@ void APIServer::loop() {
 
     // Rare case: handle disconnection
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    char peername_buf[socket::PEERNAME_MAX_LEN];
-    client->get_peername_to(peername_buf);
-    this->client_disconnected_trigger_->trigger(std::string(client->get_name()), std::string(peername_buf));
+    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());
+    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) {
@@ -398,7 +394,7 @@ void APIServer::register_action_response_callback(uint32_t call_id, ActionRespon
   this->action_response_callbacks_.push_back({call_id, std::move(callback)});
 }
 
-void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef error_message) {
+void APIServer::handle_action_response(uint32_t call_id, bool success, const std::string &error_message) {
   for (auto it = this->action_response_callbacks_.begin(); it != this->action_response_callbacks_.end(); ++it) {
     if (it->call_id == call_id) {
       auto callback = std::move(it->callback);
@@ -410,7 +406,7 @@ void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef
   }
 }
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef error_message,
+void APIServer::handle_action_response(uint32_t call_id, bool success, const std::string &error_message,
                                        const uint8_t *response_data, size_t response_data_len) {
   for (auto it = this->action_response_callbacks_.begin(); it != this->action_response_callbacks_.end(); ++it) {
     if (it->call_id == call_id) {
@@ -428,8 +424,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)
@@ -438,7 +434,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));
@@ -458,43 +454,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);
 }
 
@@ -702,7 +678,7 @@ void APIServer::unregister_active_action_calls_for_connection(APIConnection *con
   }
 }
 
-void APIServer::send_action_response(uint32_t action_call_id, bool success, StringRef error_message) {
+void APIServer::send_action_response(uint32_t action_call_id, bool success, const std::string &error_message) {
   for (auto &call : this->active_action_calls_) {
     if (call.action_call_id == action_call_id) {
       call.connection->send_execute_service_response(call.client_call_id, success, error_message);
@@ -712,7 +688,7 @@ void APIServer::send_action_response(uint32_t action_call_id, bool success, Stri
   ESP_LOGW(TAG, "Cannot send response: no active call found for action_call_id %u", action_call_id);
 }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-void APIServer::send_action_response(uint32_t action_call_id, bool success, StringRef error_message,
+void APIServer::send_action_response(uint32_t action_call_id, bool success, const std::string &error_message,
                                      const uint8_t *response_data, size_t response_data_len) {
   for (auto &call : this->active_action_calls_) {
     if (call.action_call_id == action_call_id) {

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
@@ -144,10 +143,10 @@ class APIServer : public Component,
   // Action response handling
   using ActionResponseCallback = std::function<void(const class ActionResponse &)>;
   void register_action_response_callback(uint32_t call_id, ActionResponseCallback callback);
-  void handle_action_response(uint32_t call_id, bool success, StringRef error_message);
+  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message);
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  void handle_action_response(uint32_t call_id, bool success, StringRef error_message, const uint8_t *response_data,
-                              size_t response_data_len);
+  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message,
+                              const uint8_t *response_data, size_t response_data_len);
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 #endif  // USE_API_HOMEASSISTANT_SERVICES
@@ -166,9 +165,9 @@ class APIServer : public Component,
   void unregister_active_action_call(uint32_t action_call_id);
   void unregister_active_action_calls_for_connection(APIConnection *conn);
   // Send response for a specific action call (uses action_call_id, sends client_call_id in response)
-  void send_action_response(uint32_t action_call_id, bool success, StringRef error_message);
+  void send_action_response(uint32_t action_call_id, bool success, const std::string &error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  void send_action_response(uint32_t action_call_id, bool success, StringRef error_message,
+  void send_action_response(uint32_t action_call_id, bool success, const std::string &error_message,
                             const uint8_t *response_data, size_t response_data_len);
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES
@@ -196,7 +195,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)
@@ -206,20 +205,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
@@ -243,13 +236,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 = "") {

esphome/components/api/homeassistant_service.h

@@ -67,10 +67,10 @@ template<typename... Ts> class TemplatableKeyValuePair {
 // the callback is invoked synchronously while the message is on the stack).
 class ActionResponse {
  public:
-  ActionResponse(bool success, StringRef error_message) : success_(success), error_message_(error_message) {}
+  ActionResponse(bool success, const std::string &error_message) : success_(success), error_message_(error_message) {}
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  ActionResponse(bool success, StringRef error_message, const uint8_t *data, size_t data_len)
+  ActionResponse(bool success, const std::string &error_message, const uint8_t *data, size_t data_len)
       : success_(success), error_message_(error_message) {
     if (data == nullptr || data_len == 0)
       return;

esphome/components/bh1750/bh1750.cpp

@@ -1,8 +1,8 @@
 #include "bh1750.h"
 #include "esphome/core/log.h"
-#include "esphome/core/application.h"
 
-namespace esphome::bh1750 {
+namespace esphome {
+namespace bh1750 {
 
 static const char *const TAG = "bh1750.sensor";
 
@@ -13,31 +13,6 @@ static const uint8_t BH1750_COMMAND_ONE_TIME_L = 0b00100011;
 static const uint8_t BH1750_COMMAND_ONE_TIME_H = 0b00100000;
 static const uint8_t BH1750_COMMAND_ONE_TIME_H2 = 0b00100001;
 
-static constexpr uint32_t MEASUREMENT_TIMEOUT_MS = 2000;
-static constexpr float HIGH_LIGHT_THRESHOLD_LX = 7000.0f;
-
-// Measurement time constants (datasheet values)
-static constexpr uint16_t MTREG_DEFAULT = 69;
-static constexpr uint16_t MTREG_MIN = 31;
-static constexpr uint16_t MTREG_MAX = 254;
-static constexpr uint16_t MEAS_TIME_L_MS = 24;   // L-resolution max measurement time @ mtreg=69
-static constexpr uint16_t MEAS_TIME_H_MS = 180;  // H/H2-resolution max measurement time @ mtreg=69
-
-// Conversion constants (datasheet formulas)
-static constexpr float RESOLUTION_DIVISOR = 1.2f;  // counts to lux conversion divisor
-static constexpr float MODE_H2_DIVISOR = 2.0f;     // H2 mode has 2x higher resolution
-
-// MTreg calculation constants
-static constexpr int COUNTS_TARGET = 50000;  // Target counts for optimal range (avoid saturation)
-static constexpr int COUNTS_NUMERATOR = 10;
-static constexpr int COUNTS_DENOMINATOR = 12;
-
-// MTreg register bit manipulation constants
-static constexpr uint8_t MTREG_HI_SHIFT = 5;       // High 3 bits start at bit 5
-static constexpr uint8_t MTREG_HI_MASK = 0b111;    // 3-bit mask for high bits
-static constexpr uint8_t MTREG_LO_SHIFT = 0;       // Low 5 bits start at bit 0
-static constexpr uint8_t MTREG_LO_MASK = 0b11111;  // 5-bit mask for low bits
-
 /*
 bh1750 properties:
 
@@ -68,7 +43,74 @@ void BH1750Sensor::setup() {
     this->mark_failed();
     return;
   }
-  this->state_ = IDLE;
+}
+
+void BH1750Sensor::read_lx_(BH1750Mode mode, uint8_t mtreg, const std::function<void(float)> &f) {
+  // turn on (after one-shot sensor automatically powers down)
+  uint8_t turn_on = BH1750_COMMAND_POWER_ON;
+  if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Power on failed");
+    f(NAN);
+    return;
+  }
+
+  if (active_mtreg_ != mtreg) {
+    // set mtreg
+    uint8_t mtreg_hi = BH1750_COMMAND_MT_REG_HI | ((mtreg >> 5) & 0b111);
+    uint8_t mtreg_lo = BH1750_COMMAND_MT_REG_LO | ((mtreg >> 0) & 0b11111);
+    if (this->write(&mtreg_hi, 1) != i2c::ERROR_OK || this->write(&mtreg_lo, 1) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Set measurement time failed");
+      active_mtreg_ = 0;
+      f(NAN);
+      return;
+    }
+    active_mtreg_ = mtreg;
+  }
+
+  uint8_t cmd;
+  uint16_t meas_time;
+  switch (mode) {
+    case BH1750_MODE_L:
+      cmd = BH1750_COMMAND_ONE_TIME_L;
+      meas_time = 24 * mtreg / 69;
+      break;
+    case BH1750_MODE_H:
+      cmd = BH1750_COMMAND_ONE_TIME_H;
+      meas_time = 180 * mtreg / 69;
+      break;
+    case BH1750_MODE_H2:
+      cmd = BH1750_COMMAND_ONE_TIME_H2;
+      meas_time = 180 * mtreg / 69;
+      break;
+    default:
+      f(NAN);
+      return;
+  }
+  if (this->write(&cmd, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Start measurement failed");
+    f(NAN);
+    return;
+  }
+
+  // probably not needed, but adjust for rounding
+  meas_time++;
+
+  this->set_timeout("read", meas_time, [this, mode, mtreg, f]() {
+    uint16_t raw_value;
+    if (this->read(reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Read data failed");
+      f(NAN);
+      return;
+    }
+    raw_value = i2c::i2ctohs(raw_value);
+
+    float lx = float(raw_value) / 1.2f;
+    lx *= 69.0f / mtreg;
+    if (mode == BH1750_MODE_H2)
+      lx /= 2.0f;
+
+    f(lx);
+  });
 }
 
 void BH1750Sensor::dump_config() {
@@ -82,189 +124,45 @@ void BH1750Sensor::dump_config() {
 }
 
 void BH1750Sensor::update() {
-  const uint32_t now = millis();
-
-  // Start coarse measurement to determine optimal mode/mtreg
-  if (this->state_ != IDLE) {
-    // Safety timeout: reset if stuck
-    if (now - this->measurement_start_time_ > MEASUREMENT_TIMEOUT_MS) {
-      ESP_LOGW(TAG, "Measurement timeout, resetting state");
-      this->state_ = IDLE;
-    } else {
-      ESP_LOGW(TAG, "Previous measurement not complete, skipping update");
+  // first do a quick measurement in L-mode with full range
+  // to find right range
+  this->read_lx_(BH1750_MODE_L, 31, [this](float val) {
+    if (std::isnan(val)) {
+      this->status_set_warning();
+      this->publish_state(NAN);
       return;
     }
-  }
 
-  if (!this->start_measurement_(BH1750_MODE_L, MTREG_MIN, now)) {
-    this->status_set_warning();
-    this->publish_state(NAN);
-    return;
-  }
-
-  this->state_ = WAITING_COARSE_MEASUREMENT;
-  this->enable_loop();  // Enable loop while measurement in progress
-}
-
-void BH1750Sensor::loop() {
-  const uint32_t now = App.get_loop_component_start_time();
-
-  switch (this->state_) {
-    case IDLE:
-      // Disable loop when idle to save cycles
-      this->disable_loop();
-      break;
-
-    case WAITING_COARSE_MEASUREMENT:
-      if (now - this->measurement_start_time_ >= this->measurement_duration_) {
-        this->state_ = READING_COARSE_RESULT;
-      }
-      break;
-
-    case READING_COARSE_RESULT: {
-      float lx;
-      if (!this->read_measurement_(lx)) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      this->process_coarse_result_(lx);
-
-      // Start fine measurement with optimal settings
-      // fetch millis() again since the read can take a bit
-      if (!this->start_measurement_(this->fine_mode_, this->fine_mtreg_, millis())) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      this->state_ = WAITING_FINE_MEASUREMENT;
-      break;
+    BH1750Mode use_mode;
+    uint8_t use_mtreg;
+    if (val <= 7000) {
+      use_mode = BH1750_MODE_H2;
+      use_mtreg = 254;
+    } else {
+      use_mode = BH1750_MODE_H;
+      // lx = counts / 1.2 * (69 / mtreg)
+      // -> mtreg = counts / 1.2 * (69 / lx)
+      // calculate for counts=50000 (allow some range to not saturate, but maximize mtreg)
+      // -> mtreg = 50000*(10/12)*(69/lx)
+      int ideal_mtreg = 50000 * 10 * 69 / (12 * (int) val);
+      use_mtreg = std::min(254, std::max(31, ideal_mtreg));
     }
+    ESP_LOGV(TAG, "L result: %f -> Calculated mode=%d, mtreg=%d", val, (int) use_mode, use_mtreg);
 
-    case WAITING_FINE_MEASUREMENT:
-      if (now - this->measurement_start_time_ >= this->measurement_duration_) {
-        this->state_ = READING_FINE_RESULT;
+    this->read_lx_(use_mode, use_mtreg, [this](float val) {
+      if (std::isnan(val)) {
+        this->status_set_warning();
+        this->publish_state(NAN);
+        return;
       }
-      break;
-
-    case READING_FINE_RESULT: {
-      float lx;
-      if (!this->read_measurement_(lx)) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), lx);
+      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), val);
       this->status_clear_warning();
-      this->publish_state(lx);
-      this->state_ = IDLE;
-      break;
-    }
-  }
-}
-
-bool BH1750Sensor::start_measurement_(BH1750Mode mode, uint8_t mtreg, uint32_t now) {
-  // Power on
-  uint8_t turn_on = BH1750_COMMAND_POWER_ON;
-  if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Power on failed");
-    return false;
-  }
-
-  // Set MTreg if changed
-  if (this->active_mtreg_ != mtreg) {
-    uint8_t mtreg_hi = BH1750_COMMAND_MT_REG_HI | ((mtreg >> MTREG_HI_SHIFT) & MTREG_HI_MASK);
-    uint8_t mtreg_lo = BH1750_COMMAND_MT_REG_LO | ((mtreg >> MTREG_LO_SHIFT) & MTREG_LO_MASK);
-    if (this->write(&mtreg_hi, 1) != i2c::ERROR_OK || this->write(&mtreg_lo, 1) != i2c::ERROR_OK) {
-      ESP_LOGW(TAG, "Set measurement time failed");
-      this->active_mtreg_ = 0;
-      return false;
-    }
-    this->active_mtreg_ = mtreg;
-  }
-
-  // Start measurement
-  uint8_t cmd;
-  uint16_t meas_time;
-  switch (mode) {
-    case BH1750_MODE_L:
-      cmd = BH1750_COMMAND_ONE_TIME_L;
-      meas_time = MEAS_TIME_L_MS * mtreg / MTREG_DEFAULT;
-      break;
-    case BH1750_MODE_H:
-      cmd = BH1750_COMMAND_ONE_TIME_H;
-      meas_time = MEAS_TIME_H_MS * mtreg / MTREG_DEFAULT;
-      break;
-    case BH1750_MODE_H2:
-      cmd = BH1750_COMMAND_ONE_TIME_H2;
-      meas_time = MEAS_TIME_H_MS * mtreg / MTREG_DEFAULT;
-      break;
-    default:
-      return false;
-  }
-
-  if (this->write(&cmd, 1) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Start measurement failed");
-    return false;
-  }
-
-  // Store current measurement parameters
-  this->current_mode_ = mode;
-  this->current_mtreg_ = mtreg;
-  this->measurement_start_time_ = now;
-  this->measurement_duration_ = meas_time + 1;  // Add 1ms for safety
-
-  return true;
-}
-
-bool BH1750Sensor::read_measurement_(float &lx_out) {
-  uint16_t raw_value;
-  if (this->read(reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Read data failed");
-    return false;
-  }
-  raw_value = i2c::i2ctohs(raw_value);
-
-  float lx = float(raw_value) / RESOLUTION_DIVISOR;
-  lx *= float(MTREG_DEFAULT) / this->current_mtreg_;
-  if (this->current_mode_ == BH1750_MODE_H2) {
-    lx /= MODE_H2_DIVISOR;
-  }
-
-  lx_out = lx;
-  return true;
-}
-
-void BH1750Sensor::process_coarse_result_(float lx) {
-  if (std::isnan(lx)) {
-    // Use defaults if coarse measurement failed
-    this->fine_mode_ = BH1750_MODE_H2;
-    this->fine_mtreg_ = MTREG_MAX;
-    return;
-  }
-
-  if (lx <= HIGH_LIGHT_THRESHOLD_LX) {
-    this->fine_mode_ = BH1750_MODE_H2;
-    this->fine_mtreg_ = MTREG_MAX;
-  } else {
-    this->fine_mode_ = BH1750_MODE_H;
-    // lx = counts / 1.2 * (69 / mtreg)
-    // -> mtreg = counts / 1.2 * (69 / lx)
-    // calculate for counts=50000 (allow some range to not saturate, but maximize mtreg)
-    // -> mtreg = 50000*(10/12)*(69/lx)
-    int ideal_mtreg = COUNTS_TARGET * COUNTS_NUMERATOR * MTREG_DEFAULT / (COUNTS_DENOMINATOR * (int) lx);
-    this->fine_mtreg_ = std::min((int) MTREG_MAX, std::max((int) MTREG_MIN, ideal_mtreg));
-  }
-
-  ESP_LOGV(TAG, "L result: %.1f -> Calculated mode=%d, mtreg=%d", lx, (int) this->fine_mode_, this->fine_mtreg_);
-}
-
-void BH1750Sensor::fail_and_reset_() {
-  this->status_set_warning();
-  this->publish_state(NAN);
-  this->state_ = IDLE;
+      this->publish_state(val);
+    });
+  });
 }
 
 float BH1750Sensor::get_setup_priority() const { return setup_priority::DATA; }
 
-}  // namespace esphome::bh1750
+}  // namespace bh1750
+}  // namespace esphome

esphome/components/bh1750/bh1750.h

@@ -4,9 +4,10 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
 
-namespace esphome::bh1750 {
+namespace esphome {
+namespace bh1750 {
 
-enum BH1750Mode : uint8_t {
+enum BH1750Mode {
   BH1750_MODE_L,
   BH1750_MODE_H,
   BH1750_MODE_H2,
@@ -20,36 +21,13 @@ class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c:
   void setup() override;
   void dump_config() override;
   void update() override;
-  void loop() override;
   float get_setup_priority() const override;
 
  protected:
-  // State machine states
-  enum State : uint8_t {
-    IDLE,
-    WAITING_COARSE_MEASUREMENT,
-    READING_COARSE_RESULT,
-    WAITING_FINE_MEASUREMENT,
-    READING_FINE_RESULT,
-  };
+  void read_lx_(BH1750Mode mode, uint8_t mtreg, const std::function<void(float)> &f);
 
-  // 4-byte aligned members
-  uint32_t measurement_start_time_{0};
-  uint32_t measurement_duration_{0};
-
-  // 1-byte members grouped together to minimize padding
-  State state_{IDLE};
-  BH1750Mode current_mode_{BH1750_MODE_L};
-  uint8_t current_mtreg_{31};
-  BH1750Mode fine_mode_{BH1750_MODE_H2};
-  uint8_t fine_mtreg_{254};
   uint8_t active_mtreg_{0};
-
-  // Helper methods
-  bool start_measurement_(BH1750Mode mode, uint8_t mtreg, uint32_t now);
-  bool read_measurement_(float &lx_out);
-  void process_coarse_result_(float lx);
-  void fail_and_reset_();
 };
 
-}  // namespace esphome::bh1750
+}  // namespace bh1750
+}  // namespace esphome

esphome/components/bthome_mithermometer/__init__.py

@@ -0,0 +1,36 @@
+import esphome.codegen as cg
+from esphome.components import esp32_ble_tracker
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_MAC_ADDRESS
+
+CODEOWNERS = ["@nagyrobi"]
+DEPENDENCIES = ["esp32_ble_tracker"]
+
+BLE_DEVICE_SCHEMA = esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA
+
+bthome_mithermometer_ns = cg.esphome_ns.namespace("bthome_mithermometer")
+BTHomeMiThermometer = bthome_mithermometer_ns.class_(
+    "BTHomeMiThermometer", esp32_ble_tracker.ESPBTDeviceListener, cg.Component
+)
+
+
+def bthome_mithermometer_base_schema(extra_schema=None):
+    if extra_schema is None:
+        extra_schema = {}
+    return (
+        cv.Schema(
+            {
+                cv.GenerateID(CONF_ID): cv.declare_id(BTHomeMiThermometer),
+                cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
+            }
+        )
+        .extend(BLE_DEVICE_SCHEMA)
+        .extend(cv.COMPONENT_SCHEMA)
+        .extend(extra_schema)
+    )
+
+
+async def setup_bthome_mithermometer(var, config):
+    await cg.register_component(var, config)
+    await esp32_ble_tracker.register_ble_device(var, config)
+    cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))

esphome/components/bthome_mithermometer/bthome_ble.cpp

@@ -0,0 +1,298 @@
+#include "bthome_ble.h"
+
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+#include <array>
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace bthome_mithermometer {
+
+static const char *const TAG = "bthome_mithermometer";
+
+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;
+  }
+
+  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) {
+  switch (obj_type) {
+    case 0x00:  // packet id
+    case 0x01:  // battery
+    case 0x09:  // count (uint8)
+    case 0x0F:  // generic boolean
+    case 0x10:  // power (bool)
+    case 0x11:  // opening
+    case 0x15:  // battery low
+    case 0x16:  // battery charging
+    case 0x17:  // carbon monoxide
+    case 0x18:  // cold
+    case 0x19:  // connectivity
+    case 0x1A:  // door
+    case 0x1B:  // garage door
+    case 0x1C:  // gas
+    case 0x1D:  // heat
+    case 0x1E:  // light
+    case 0x1F:  // lock
+    case 0x20:  // moisture
+    case 0x21:  // motion
+    case 0x22:  // moving
+    case 0x23:  // occupancy
+    case 0x24:  // plug
+    case 0x25:  // presence
+    case 0x26:  // problem
+    case 0x27:  // running
+    case 0x28:  // safety
+    case 0x29:  // smoke
+    case 0x2A:  // sound
+    case 0x2B:  // tamper
+    case 0x2C:  // vibration
+    case 0x2D:  // water leak
+    case 0x2E:  // humidity (uint8)
+    case 0x2F:  // moisture (uint8)
+    case 0x46:  // UV index
+    case 0x57:  // temperature (sint8)
+    case 0x58:  // temperature (0.35C step)
+    case 0x59:  // count (sint8)
+    case 0x60:  // channel
+      value_length = 1;
+      return true;
+    case 0x02:  // temperature (0.01C)
+    case 0x03:  // humidity
+    case 0x06:  // mass (kg)
+    case 0x07:  // mass (lb)
+    case 0x08:  // dewpoint
+    case 0x0C:  // voltage (mV)
+    case 0x0D:  // pm2.5
+    case 0x0E:  // pm10
+    case 0x12:  // CO2
+    case 0x13:  // TVOC
+    case 0x14:  // moisture
+    case 0x3D:  // count (uint16)
+    case 0x3F:  // rotation
+    case 0x40:  // distance (mm)
+    case 0x41:  // distance (m)
+    case 0x43:  // current (A)
+    case 0x44:  // speed
+    case 0x45:  // temperature (0.1C)
+    case 0x47:  // volume (L)
+    case 0x48:  // volume (mL)
+    case 0x49:  // volume flow rate
+    case 0x4A:  // voltage (0.1V)
+    case 0x51:  // acceleration
+    case 0x52:  // gyroscope
+    case 0x56:  // conductivity
+    case 0x5A:  // count (sint16)
+    case 0x5D:  // current (sint16)
+    case 0x5E:  // direction
+    case 0x5F:  // precipitation
+    case 0x61:  // rotational speed
+    case 0xF0:  // button event
+      value_length = 2;
+      return true;
+    case 0x04:  // pressure
+    case 0x05:  // illuminance
+    case 0x0A:  // energy
+    case 0x0B:  // power
+    case 0x42:  // duration
+    case 0x4B:  // gas (uint24)
+    case 0xF2:  // firmware version (uint24)
+      value_length = 3;
+      return true;
+    case 0x3E:  // count (uint32)
+    case 0x4C:  // gas (uint32)
+    case 0x4D:  // energy (uint32)
+    case 0x4E:  // volume (uint32)
+    case 0x4F:  // water (uint32)
+    case 0x50:  // timestamp
+    case 0x55:  // volume storage
+    case 0x5B:  // count (sint32)
+    case 0x5C:  // power (sint32)
+    case 0x62:  // speed (sint32)
+    case 0x63:  // acceleration (sint32)
+    case 0xF1:  // firmware version (uint32)
+      value_length = 4;
+      return true;
+    default:
+      return false;
+  }
+}
+
+void BTHomeMiThermometer::dump_config() {
+  ESP_LOGCONFIG(TAG, "BTHome MiThermometer");
+  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_);
+  LOG_SENSOR("  ", "Battery Voltage", this->battery_voltage_);
+  LOG_SENSOR("  ", "Signal Strength", this->signal_strength_);
+}
+
+bool BTHomeMiThermometer::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
+  bool matched = false;
+  for (auto &service_data : device.get_service_datas()) {
+    if (this->handle_service_data_(service_data, device)) {
+      matched = true;
+    }
+  }
+  if (matched && this->signal_strength_ != nullptr) {
+    this->signal_strength_->publish_state(device.get_rssi());
+  }
+  return matched;
+}
+
+bool BTHomeMiThermometer::handle_service_data_(const esp32_ble_tracker::ServiceData &service_data,
+                                               const esp32_ble_tracker::ESPBTDevice &device) {
+  if (!service_data.uuid.contains(0xD2, 0xFC)) {
+    return false;
+  }
+
+  const auto &data = service_data.data;
+  if (data.size() < 2) {
+    ESP_LOGVV(TAG, "BTHome data too short: %zu", data.size());
+    return false;
+  }
+
+  const uint8_t adv_info = data[0];
+  const bool is_encrypted = adv_info & 0x01;
+  const bool mac_included = adv_info & 0x02;
+  const bool is_trigger_based = adv_info & 0x04;
+  const uint8_t version = (adv_info >> 5) & 0x07;
+
+  if (version != 0x02) {
+    ESP_LOGVV(TAG, "Unsupported BTHome version %u", version);
+    return false;
+  }
+
+  if (is_encrypted) {
+    ESP_LOGV(TAG, "Ignoring encrypted BTHome frame from %s", device.address_str().c_str());
+    return false;
+  }
+
+  size_t payload_index = 1;
+  uint64_t source_address = device.address_uint64();
+
+  if (mac_included) {
+    if (data.size() < 7) {
+      ESP_LOGVV(TAG, "BTHome payload missing MAC address");
+      return false;
+    }
+    source_address = 0;
+    for (int i = 5; i >= 0; i--) {
+      source_address = (source_address << 8) | data[1 + i];
+    }
+    payload_index = 7;
+  }
+
+  if (source_address != this->address_) {
+    ESP_LOGVV(TAG, "BTHome frame from unexpected device %s", format_mac_address(source_address).c_str());
+    return false;
+  }
+
+  if (payload_index >= data.size()) {
+    ESP_LOGVV(TAG, "BTHome payload empty after header");
+    return false;
+  }
+
+  bool reported = false;
+  size_t offset = payload_index;
+  uint8_t last_type = 0;
+
+  while (offset < data.size()) {
+    const uint8_t obj_type = data[offset++];
+    size_t value_length = 0;
+    bool has_length_byte = obj_type == 0x53;  // text objects include explicit length
+
+    if (has_length_byte) {
+      if (offset >= data.size()) {
+        break;
+      }
+      value_length = data[offset++];
+    } else {
+      if (!get_bthome_value_length(obj_type, value_length)) {
+        ESP_LOGVV(TAG, "Unknown BTHome object 0x%02X", obj_type);
+        break;
+      }
+    }
+
+    if (value_length == 0) {
+      break;
+    }
+
+    if (offset + value_length > data.size()) {
+      ESP_LOGVV(TAG, "BTHome object length exceeds payload");
+      break;
+    }
+
+    const uint8_t *value = &data[offset];
+    offset += value_length;
+
+    if (obj_type < last_type) {
+      ESP_LOGVV(TAG, "BTHome objects not in ascending order");
+    }
+    last_type = obj_type;
+
+    switch (obj_type) {
+      case 0x00: {  // packet id
+        const uint8_t packet_id = value[0];
+        if (this->last_packet_id_.has_value() && *this->last_packet_id_ == packet_id) {
+          return reported;
+        }
+        this->last_packet_id_ = packet_id;
+        break;
+      }
+      case 0x01: {  // battery percentage
+        if (this->battery_level_ != nullptr) {
+          this->battery_level_->publish_state(value[0]);
+          reported = true;
+        }
+        break;
+      }
+      case 0x0C: {  // battery voltage (mV)
+        if (this->battery_voltage_ != nullptr) {
+          const uint16_t raw = encode_uint16(value[1], value[0]);
+          this->battery_voltage_->publish_state(raw * 0.001f);
+          reported = true;
+        }
+        break;
+      }
+      case 0x02: {  // temperature
+        if (this->temperature_ != nullptr) {
+          const int16_t raw = encode_uint16(value[1], value[0]);
+          this->temperature_->publish_state(raw * 0.01f);
+          reported = true;
+        }
+        break;
+      }
+      case 0x03: {  // humidity
+        if (this->humidity_ != nullptr) {
+          const uint16_t raw = encode_uint16(value[1], value[0]);
+          this->humidity_->publish_state(raw * 0.01f);
+          reported = true;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  if (reported) {
+    ESP_LOGD(TAG, "BTHome data%sfrom %s", is_trigger_based ? " (triggered) " : " ", device.address_str().c_str());
+  }
+
+  return reported;
+}
+
+}  // namespace bthome_mithermometer
+}  // namespace esphome
+
+#endif

esphome/components/bthome_mithermometer/bthome_ble.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/core/component.h"
+
+#include <cstdint>
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace bthome_mithermometer {
+
+class BTHomeMiThermometer : public esp32_ble_tracker::ESPBTDeviceListener, public Component {
+ public:
+  void set_address(uint64_t address) { this->address_ = address; }
+
+  void set_temperature(sensor::Sensor *temperature) { this->temperature_ = temperature; }
+  void set_humidity(sensor::Sensor *humidity) { this->humidity_ = humidity; }
+  void set_battery_level(sensor::Sensor *battery_level) { this->battery_level_ = battery_level; }
+  void set_battery_voltage(sensor::Sensor *battery_voltage) { this->battery_voltage_ = battery_voltage; }
+  void set_signal_strength(sensor::Sensor *signal_strength) { this->signal_strength_ = signal_strength; }
+
+  void dump_config() override;
+  bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
+
+ protected:
+  bool handle_service_data_(const esp32_ble_tracker::ServiceData &service_data,
+                            const esp32_ble_tracker::ESPBTDevice &device);
+
+  uint64_t address_{0};
+  optional<uint8_t> last_packet_id_{};
+
+  sensor::Sensor *temperature_{nullptr};
+  sensor::Sensor *humidity_{nullptr};
+  sensor::Sensor *battery_level_{nullptr};
+  sensor::Sensor *battery_voltage_{nullptr};
+  sensor::Sensor *signal_strength_{nullptr};
+};
+
+}  // namespace bthome_mithermometer
+}  // namespace esphome
+
+#endif

esphome/components/bthome_mithermometer/sensor.py

@@ -0,0 +1,88 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BATTERY_LEVEL,
+    CONF_BATTERY_VOLTAGE,
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_SIGNAL_STRENGTH,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_SIGNAL_STRENGTH,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_VOLTAGE,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_DECIBEL_MILLIWATT,
+    UNIT_PERCENT,
+    UNIT_VOLT,
+)
+
+from . import bthome_mithermometer_base_schema, setup_bthome_mithermometer
+
+CODEOWNERS = ["@nagyrobi"]
+
+DEPENDENCIES = ["esp32_ble_tracker"]
+
+CONFIG_SCHEMA = bthome_mithermometer_base_schema(
+    {
+        cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_CELSIUS,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_TEMPERATURE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+            unit_of_measurement=UNIT_PERCENT,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_HUMIDITY,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(
+            unit_of_measurement=UNIT_PERCENT,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_BATTERY,
+            state_class=STATE_CLASS_MEASUREMENT,
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        ),
+        cv.Optional(CONF_BATTERY_VOLTAGE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=3,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+            icon="mdi:battery-plus",
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        ),
+        cv.Optional(CONF_SIGNAL_STRENGTH): sensor.sensor_schema(
+            unit_of_measurement=UNIT_DECIBEL_MILLIWATT,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
+            state_class=STATE_CLASS_MEASUREMENT,
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        ),
+    }
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await setup_bthome_mithermometer(var, config)
+
+    if temp_sens := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temp_sens)
+        cg.add(var.set_temperature(sens))
+    if humi_sens := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humi_sens)
+        cg.add(var.set_humidity(sens))
+    if batl_sens := config.get(CONF_BATTERY_LEVEL):
+        sens = await sensor.new_sensor(batl_sens)
+        cg.add(var.set_battery_level(sens))
+    if batv_sens := config.get(CONF_BATTERY_VOLTAGE):
+        sens = await sensor.new_sensor(batv_sens)
+        cg.add(var.set_battery_voltage(sens))
+    if sgnl_sens := config.get(CONF_SIGNAL_STRENGTH):
+        sens = await sensor.new_sensor(sgnl_sens)
+        cg.add(var.set_signal_strength(sens))

esphome/components/captive_portal/dns_server_esp32_idf.cpp

@@ -47,10 +47,7 @@ struct DNSAnswer {
 
 void DNSServer::start(const network::IPAddress &ip) {
   this->server_ip_ = ip;
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
-  ESP_LOGV(TAG, "Starting DNS server on %s", ip.str_to(ip_buf));
-#endif
+  ESP_LOGV(TAG, "Starting DNS server on %s", ip.str().c_str());
 
   // Create loop-monitored UDP socket
   this->socket_ = socket::socket_ip_loop_monitored(SOCK_DGRAM, IPPROTO_UDP);

esphome/components/ch422g/ch422g.cpp

@@ -128,9 +128,7 @@ void CH422GGPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->
 bool CH422GGPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) ^ this->inverted_; }
 
 void CH422GGPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value ^ this->inverted_); }
-size_t CH422GGPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "EXIO%u via CH422G", this->pin_);
-}
+std::string CH422GGPIOPin::dump_summary() const { return str_sprintf("EXIO%u via CH422G", pin_); }
 void CH422GGPIOPin::set_flags(gpio::Flags flags) {
   flags_ = flags;
   this->parent_->pin_mode(this->pin_, flags);

esphome/components/ch422g/ch422g.h

@@ -50,7 +50,7 @@ class CH422GGPIOPin : public GPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
+  std::string dump_summary() const override;
 
   void set_parent(CH422GComponent *parent) { parent_ = parent; }
   void set_pin(uint8_t pin) { pin_ = pin; }

esphome/components/cse7766/cse7766.cpp

@@ -1,13 +1,11 @@
 #include "cse7766.h"
-#include "esphome/core/application.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace cse7766 {
 
 static const char *const TAG = "cse7766";
-static constexpr size_t CSE7766_RAW_DATA_SIZE = 24;
 
 void CSE7766Component::loop() {
   const uint32_t now = App.get_loop_component_start_time();
@@ -72,8 +70,8 @@ bool CSE7766Component::check_byte_() {
 void CSE7766Component::parse_data_() {
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
   {
-    char hex_buf[format_hex_pretty_size(CSE7766_RAW_DATA_SIZE)];
-    ESP_LOGVV(TAG, "Raw data: %s", format_hex_pretty_to(hex_buf, this->raw_data_, sizeof(this->raw_data_)));
+    std::string s = format_hex_pretty(this->raw_data_, sizeof(this->raw_data_));
+    ESP_LOGVV(TAG, "Raw data: %s", s.c_str());
   }
 #endif
 

esphome/components/display/__init__.py

@@ -63,13 +63,11 @@ def validate_auto_clear(value):
     return cv.boolean(value)
 
 
-def basic_display_schema(default_update_interval: str = "1s") -> cv.Schema:
-    """Create a basic display schema with configurable default update interval."""
-    return cv.Schema(
-        {
-            cv.Exclusive(CONF_LAMBDA, CONF_LAMBDA): cv.lambda_,
-        }
-    ).extend(cv.polling_component_schema(default_update_interval))
+BASIC_DISPLAY_SCHEMA = cv.Schema(
+    {
+        cv.Exclusive(CONF_LAMBDA, CONF_LAMBDA): cv.lambda_,
+    }
+).extend(cv.polling_component_schema("1s"))
 
 
 def _validate_test_card(config):
@@ -83,41 +81,34 @@ def _validate_test_card(config):
     return config
 
 
-def full_display_schema(default_update_interval: str = "1s") -> cv.Schema:
-    """Create a full display schema with configurable default update interval."""
-    schema = basic_display_schema(default_update_interval).extend(
-        {
-            cv.Optional(CONF_ROTATION): validate_rotation,
-            cv.Exclusive(CONF_PAGES, CONF_LAMBDA): cv.All(
-                cv.ensure_list(
-                    {
-                        cv.GenerateID(): cv.declare_id(DisplayPage),
-                        cv.Required(CONF_LAMBDA): cv.lambda_,
-                    }
-                ),
-                cv.Length(min=1),
-            ),
-            cv.Optional(CONF_ON_PAGE_CHANGE): automation.validate_automation(
+FULL_DISPLAY_SCHEMA = BASIC_DISPLAY_SCHEMA.extend(
+    {
+        cv.Optional(CONF_ROTATION): validate_rotation,
+        cv.Exclusive(CONF_PAGES, CONF_LAMBDA): cv.All(
+            cv.ensure_list(
                 {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        DisplayOnPageChangeTrigger
-                    ),
-                    cv.Optional(CONF_FROM): cv.use_id(DisplayPage),
-                    cv.Optional(CONF_TO): cv.use_id(DisplayPage),
+                    cv.GenerateID(): cv.declare_id(DisplayPage),
+                    cv.Required(CONF_LAMBDA): cv.lambda_,
                 }
             ),
-            cv.Optional(
-                CONF_AUTO_CLEAR_ENABLED, default=CONF_UNSPECIFIED
-            ): validate_auto_clear,
-            cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
-        }
-    )
-    schema.add_extra(_validate_test_card)
-    return schema
-
-
-BASIC_DISPLAY_SCHEMA = basic_display_schema("1s")
-FULL_DISPLAY_SCHEMA = full_display_schema("1s")
+            cv.Length(min=1),
+        ),
+        cv.Optional(CONF_ON_PAGE_CHANGE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    DisplayOnPageChangeTrigger
+                ),
+                cv.Optional(CONF_FROM): cv.use_id(DisplayPage),
+                cv.Optional(CONF_TO): cv.use_id(DisplayPage),
+            }
+        ),
+        cv.Optional(
+            CONF_AUTO_CLEAR_ENABLED, default=CONF_UNSPECIFIED
+        ): validate_auto_clear,
+        cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
+    }
+)
+FULL_DISPLAY_SCHEMA.add_extra(_validate_test_card)
 
 
 async def setup_display_core_(var, config):

esphome/components/epaper_spi/display.py

@@ -31,7 +31,6 @@ from esphome.const import (
     CONF_TRANSFORM,
     CONF_UPDATE_INTERVAL,
     CONF_WIDTH,
-    SCHEDULER_DONT_RUN,
 )
 from esphome.cpp_generator import RawExpression
 from esphome.final_validate import full_config
@@ -73,10 +72,12 @@ TRANSFORM_OPTIONS = {CONF_MIRROR_X, CONF_MIRROR_Y, CONF_SWAP_XY}
 def model_schema(config):
     model = MODELS[config[CONF_MODEL]]
     class_name = epaper_spi_ns.class_(model.class_name, EPaperBase)
+    minimum_update_interval = update_interval(
+        model.get_default(CONF_MINIMUM_UPDATE_INTERVAL, "1s")
+    )
     cv_dimensions = cv.Optional if model.get_default(CONF_WIDTH) else cv.Required
     return (
-        display.full_display_schema("60s")
-        .extend(
+        display.FULL_DISPLAY_SCHEMA.extend(
             spi.spi_device_schema(
                 cs_pin_required=False,
                 default_mode="MODE0",
@@ -93,6 +94,9 @@ def model_schema(config):
             {
                 cv.Optional(CONF_ROTATION, default=0): validate_rotation,
                 cv.Required(CONF_MODEL): cv.one_of(model.name, upper=True),
+                cv.Optional(CONF_UPDATE_INTERVAL, default=cv.UNDEFINED): cv.All(
+                    update_interval, cv.Range(min=minimum_update_interval)
+                ),
                 cv.Optional(CONF_TRANSFORM): cv.Schema(
                     {
                         cv.Required(CONF_MIRROR_X): cv.boolean,
@@ -146,22 +150,15 @@ def _final_validate(config):
     global_config = full_config.get()
     from esphome.components.lvgl import DOMAIN as LVGL_DOMAIN
 
-    # If no drawing methods are configured, and LVGL is not enabled, show a test card
-    if (
-        CONF_LAMBDA not in config
-        and CONF_PAGES not in config
-        and LVGL_DOMAIN not in global_config
-    ):
-        config[CONF_SHOW_TEST_CARD] = True
-
-    interval = config[CONF_UPDATE_INTERVAL]
-    if interval != SCHEDULER_DONT_RUN:
-        model = MODELS[config[CONF_MODEL]]
-        minimum = update_interval(model.get_default(CONF_MINIMUM_UPDATE_INTERVAL, "1s"))
-        if interval < minimum:
-            raise cv.Invalid(
-                f"update_interval must be at least {minimum} for {model.name}, got {interval}"
-            )
+    if CONF_LAMBDA not in config and CONF_PAGES not in config:
+        if LVGL_DOMAIN in global_config:
+            if CONF_UPDATE_INTERVAL not in config:
+                config[CONF_UPDATE_INTERVAL] = update_interval("never")
+        else:
+            # If no drawing methods are configured, and LVGL is not enabled, show a test card
+            config[CONF_SHOW_TEST_CARD] = True
+    elif CONF_UPDATE_INTERVAL not in config:
+        config[CONF_UPDATE_INTERVAL] = update_interval("1min")
     return config
 
 

esphome/components/epaper_spi/epaper_spi.cpp

@@ -7,7 +7,6 @@
 namespace esphome::epaper_spi {
 
 static const char *const TAG = "epaper_spi";
-static constexpr size_t EPAPER_MAX_CMD_LOG_BYTES = 128;
 
 static constexpr const char *const EPAPER_STATE_STRINGS[] = {
     "IDLE",          "UPDATE",   "RESET",          "RESET_END", "SHOULD_WAIT", "INITIALISE",
@@ -69,11 +68,8 @@ void EPaperBase::data(uint8_t value) {
 // The command is the first byte, length is the length of data only in the second byte, followed by the data.
 // [COMMAND, LENGTH, DATA...]
 void EPaperBase::cmd_data(uint8_t command, const uint8_t *ptr, size_t length) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  char hex_buf[format_hex_pretty_size(EPAPER_MAX_CMD_LOG_BYTES)];
   ESP_LOGV(TAG, "Command: 0x%02X, Length: %d, Data: %s", command, length,
-           format_hex_pretty_to(hex_buf, ptr, length, '.'));
-#endif
+           format_hex_pretty(ptr, length, '.', false).c_str());
 
   this->dc_pin_->digital_write(false);
   this->enable();

esphome/components/epaper_spi/epaper_spi.h

@@ -76,6 +76,12 @@ class EPaperBase : public Display,
     return 0;
   }
   void fill(Color color) override {
+    // If clipping is active, fall back to base implementation
+    if (this->get_clipping().is_set()) {
+      Display::fill(color);
+      return;
+    }
+
     auto pixel_color = color_to_bit(color) ? 0xFF : 0x00;
 
     // We store 8 pixels per byte

esphome/components/epaper_spi/epaper_spi_spectra_e6.cpp

@@ -97,6 +97,12 @@ void EPaperSpectraE6::deep_sleep() {
 }
 
 void EPaperSpectraE6::fill(Color color) {
+  // If clipping is active, fall back to base implementation
+  if (this->get_clipping().is_set()) {
+    EPaperBase::fill(color);
+    return;
+  }
+
   auto pixel_color = color_to_hex(color);
 
   // We store 2 pixels per byte

esphome/components/esp32/__init__.py

@@ -85,7 +85,6 @@ CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES = "enable_idf_experimental_features"
 CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
 CONF_ENABLE_OTA_ROLLBACK = "enable_ota_rollback"
 CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
-CONF_MINIMUM_CHIP_REVISION = "minimum_chip_revision"
 CONF_RELEASE = "release"
 
 LOG_LEVELS_IDF = [
@@ -110,21 +109,6 @@ COMPILER_OPTIMIZATIONS = {
     "SIZE": "CONFIG_COMPILER_OPTIMIZATION_SIZE",
 }
 
-# ESP32 (original) chip revision options
-# Setting minimum revision to 3.0 or higher:
-# - Reduces flash size by excluding workaround code for older chip bugs
-# - For PSRAM users: disables CONFIG_SPIRAM_CACHE_WORKAROUND, which saves significant
-#   IRAM by keeping C library functions in ROM instead of recompiling them
-# See: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/chip_revision.html
-ESP32_CHIP_REVISIONS = {
-    "0.0": "CONFIG_ESP32_REV_MIN_0",
-    "1.0": "CONFIG_ESP32_REV_MIN_1",
-    "1.1": "CONFIG_ESP32_REV_MIN_1_1",
-    "2.0": "CONFIG_ESP32_REV_MIN_2",
-    "3.0": "CONFIG_ESP32_REV_MIN_3",
-    "3.1": "CONFIG_ESP32_REV_MIN_3_1",
-}
-
 # Socket limit configuration for ESP-IDF
 # ESP-IDF CONFIG_LWIP_MAX_SOCKETS has range 1-253, default 10
 DEFAULT_MAX_SOCKETS = 10  # ESP-IDF default
@@ -582,16 +566,6 @@ def final_validate(config):
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_IGNORE_EFUSE_MAC_CRC],
             )
         )
-    if (
-        config[CONF_VARIANT] != VARIANT_ESP32
-        and advanced.get(CONF_MINIMUM_CHIP_REVISION) is not None
-    ):
-        errs.append(
-            cv.Invalid(
-                f"'{CONF_MINIMUM_CHIP_REVISION}' is only supported on {VARIANT_ESP32}",
-                path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_MINIMUM_CHIP_REVISION],
-            )
-        )
     if advanced[CONF_EXECUTE_FROM_PSRAM]:
         if config[CONF_VARIANT] != VARIANT_ESP32S3:
             errs.append(
@@ -651,9 +625,6 @@ CONF_LOOP_TASK_STACK_SIZE = "loop_task_stack_size"
 KEY_VFS_SELECT_REQUIRED = "vfs_select_required"
 KEY_VFS_DIR_REQUIRED = "vfs_dir_required"
 
-# Ring buffer IRAM requirement tracking
-KEY_RINGBUF_IN_IRAM = "ringbuf_in_iram"
-
 
 def require_vfs_select() -> None:
     """Mark that VFS select support is required by a component.
@@ -673,17 +644,6 @@ def require_vfs_dir() -> None:
     CORE.data[KEY_VFS_DIR_REQUIRED] = True
 
 
-def enable_ringbuf_in_iram() -> None:
-    """Keep ring buffer functions in IRAM instead of moving them to flash.
-
-    Call this from components that use esphome/core/ring_buffer.cpp and need
-    the ring buffer functions to remain in IRAM for performance reasons
-    (e.g., voice assistants, audio components).
-    This prevents CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH from being enabled.
-    """
-    CORE.data[KEY_RINGBUF_IN_IRAM] = True
-
-
 def _parse_idf_component(value: str) -> ConfigType:
     """Parse IDF component shorthand syntax like 'owner/component^version'"""
     # Match operator followed by version-like string (digit or *)
@@ -734,9 +694,6 @@ FRAMEWORK_SCHEMA = cv.Schema(
                 cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
                 cv.Optional(CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False): cv.boolean,
                 cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC, default=False): cv.boolean,
-                cv.Optional(CONF_MINIMUM_CHIP_REVISION): cv.one_of(
-                    *ESP32_CHIP_REVISIONS
-                ),
                 # DHCP server is needed for WiFi AP mode. When WiFi component is used,
                 # it will handle disabling DHCP server when AP is not configured.
                 # Default to false (disabled) when WiFi is not used.
@@ -1060,16 +1017,6 @@ async def to_code(config):
     add_idf_sdkconfig_option(
         f"CONFIG_ESPTOOLPY_FLASHSIZE_{config[CONF_FLASH_SIZE]}", True
     )
-
-    # Set minimum chip revision for ESP32 variant
-    # Setting this to 3.0 or higher reduces flash size by excluding workaround code,
-    # and for PSRAM users saves significant IRAM by keeping C library functions in ROM.
-    if variant == VARIANT_ESP32:
-        min_rev = conf[CONF_ADVANCED].get(CONF_MINIMUM_CHIP_REVISION)
-        if min_rev is not None:
-            for rev, flag in ESP32_CHIP_REVISIONS.items():
-                add_idf_sdkconfig_option(flag, rev == min_rev)
-            cg.add_define("USE_ESP32_MIN_CHIP_REVISION_SET")
     add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_SINGLE_APP", False)
     add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_CUSTOM", True)
     add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_CUSTOM_FILENAME", "partitions.csv")
@@ -1094,18 +1041,14 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH", True)
 
     # Place ring buffer functions into flash instead of IRAM by default
-    # This saves IRAM but may impact performance for audio/voice components.
-    # Components that need ring buffer in IRAM call enable_ringbuf_in_iram().
-    # Users can also set ringbuf_in_iram: true to force IRAM placement.
-    # In ESP-IDF 6.0 flash placement becomes the default.
-    if conf[CONF_ADVANCED][CONF_RINGBUF_IN_IRAM] or CORE.data.get(
-        KEY_RINGBUF_IN_IRAM, False
-    ):
-        # User config or component requires ring buffer in IRAM for performance
+    # This saves IRAM. In ESP-IDF 6.0 flash placement becomes the default.
+    # Users can set ringbuf_in_iram: true as an escape hatch if they encounter issues.
+    if conf[CONF_ADVANCED][CONF_RINGBUF_IN_IRAM]:
+        # User requests ring buffer in IRAM
         # IDF 6.0+: will need CONFIG_RINGBUF_PLACE_ISR_FUNCTIONS_INTO_FLASH=n
         add_idf_sdkconfig_option("CONFIG_RINGBUF_PLACE_ISR_FUNCTIONS_INTO_FLASH", False)
     else:
-        # No component needs it - place in flash to save IRAM
+        # Place in flash to save IRAM (default)
         add_idf_sdkconfig_option("CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH", True)
 
     # Setup watchdog

esphome/components/esp32/gpio.cpp

@@ -85,6 +85,7 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
       break;
   }
   gpio_set_intr_type(this->get_pin_num(), idf_type);
+  gpio_intr_enable(this->get_pin_num());
   if (!isr_service_installed) {
     auto res = gpio_install_isr_service(ESP_INTR_FLAG_LEVEL3);
     if (res != ESP_OK) {
@@ -94,11 +95,12 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
     isr_service_installed = true;
   }
   gpio_isr_handler_add(this->get_pin_num(), func, arg);
-  gpio_intr_enable(this->get_pin_num());
 }
 
-size_t ESP32InternalGPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "GPIO%" PRIu32, static_cast<uint32_t>(this->pin_));
+std::string ESP32InternalGPIOPin::dump_summary() const {
+  char buffer[32];
+  snprintf(buffer, sizeof(buffer), "GPIO%" PRIu32, static_cast<uint32_t>(this->pin_));
+  return buffer;
 }
 
 void ESP32InternalGPIOPin::setup() {

esphome/components/esp32/gpio.h

@@ -24,7 +24,7 @@ class ESP32InternalGPIOPin : public InternalGPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
+  std::string dump_summary() const override;
   void detach_interrupt() const override;
   ISRInternalGPIOPin to_isr() const override;
   uint8_t get_pin() const override { return this->pin_; }

esphome/components/esp32_ble/ble.cpp

@@ -98,10 +98,6 @@ void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->advertising_set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void ESP32BLE::advertising_set_manufacturer_data(std::span<const uint8_t> data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
   this->advertising_start();

esphome/components/esp32_ble/ble.h

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

esphome/components/esp32_ble/ble_advertising.cpp

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

esphome/components/esp32_ble/ble_advertising.h

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

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

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

esphome/components/esp32_ble_server/ble_server_automations.cpp

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

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -4,7 +4,6 @@
 #include "esphome/components/esp32_ble/ble.h"
 #include "esphome/components/esp32_ble_server/ble_2902.h"
 #include "esphome/core/application.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 #ifdef USE_ESP32
@@ -15,7 +14,6 @@ namespace esp32_improv {
 using namespace bytebuffer;
 
 static const char *const TAG = "esp32_improv.component";
-static constexpr size_t IMPROV_MAX_LOG_BYTES = 128;
 static const char *const ESPHOME_MY_LINK = "https://my.home-assistant.io/redirect/config_flow_start?domain=esphome";
 static constexpr uint16_t STOP_ADVERTISING_DELAY =
     10000;  // Delay (ms) before stopping service to allow BLE clients to read the final state
@@ -316,11 +314,7 @@ void ESP32ImprovComponent::dump_config() {
 void ESP32ImprovComponent::process_incoming_data_() {
   uint8_t length = this->incoming_data_[1];
 
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  char hex_buf[format_hex_pretty_size(IMPROV_MAX_LOG_BYTES)];
-  ESP_LOGV(TAG, "Processing bytes - %s",
-           format_hex_pretty_to(hex_buf, this->incoming_data_.data(), this->incoming_data_.size()));
-#endif
+  ESP_LOGV(TAG, "Processing bytes - %s", format_hex_pretty(this->incoming_data_).c_str());
   if (this->incoming_data_.size() - 3 == length) {
     this->set_error_(improv::ERROR_NONE);
     improv::ImprovCommand command = improv::parse_improv_data(this->incoming_data_);
@@ -409,12 +403,8 @@ void ESP32ImprovComponent::check_wifi_connection_() {
 #ifdef USE_WEBSERVER
     for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) {
       if (ip.is_ip4()) {
-        // "http://" (7) + IPv4 max (15) + ":" (1) + port max (5) + null = 29
-        char url_buffer[32];
-        memcpy(url_buffer, "http://", 7);  // NOLINT(bugprone-not-null-terminated-result) - str_to null-terminates
-        ip.str_to(url_buffer + 7);
-        size_t len = strlen(url_buffer);
-        snprintf(url_buffer + len, sizeof(url_buffer) - len, ":%d", USE_WEBSERVER_PORT);
+        char url_buffer[64];
+        snprintf(url_buffer, sizeof(url_buffer), "http://%s:%d", ip.str().c_str(), USE_WEBSERVER_PORT);
         url_strings[url_count++] = url_buffer;
         break;
       }

esphome/components/esp8266/__init__.py

@@ -28,7 +28,6 @@ from .const import (
     KEY_ESP8266,
     KEY_FLASH_SIZE,
     KEY_PIN_INITIAL_STATES,
-    KEY_WAVEFORM_REQUIRED,
     esp8266_ns,
 )
 from .gpio import PinInitialState, add_pin_initial_states_array
@@ -193,12 +192,7 @@ async def to_code(config):
 
     cg.add_platformio_option(
         "extra_scripts",
-        [
-            "pre:testing_mode.py",
-            "pre:exclude_updater.py",
-            "pre:exclude_waveform.py",
-            "post:post_build.py",
-        ],
+        ["pre:testing_mode.py", "pre:exclude_updater.py", "post:post_build.py"],
     )
 
     conf = config[CONF_FRAMEWORK]
@@ -270,24 +264,10 @@ async def to_code(config):
             cg.add_platformio_option("board_build.ldscript", ld_script)
 
     CORE.add_job(add_pin_initial_states_array)
-    CORE.add_job(finalize_waveform_config)
-
-
-@coroutine_with_priority(CoroPriority.WORKAROUNDS)
-async def finalize_waveform_config() -> None:
-    """Add waveform stubs define if waveform is not required.
-
-    This runs at WORKAROUNDS priority (-999) to ensure all components
-    have had a chance to call require_waveform() first.
-    """
-    if not CORE.data.get(KEY_ESP8266, {}).get(KEY_WAVEFORM_REQUIRED, False):
-        # No component needs waveform - enable stubs and exclude Arduino waveform code
-        # Use build flag (visible to both C++ code and PlatformIO script)
-        cg.add_build_flag("-DUSE_ESP8266_WAVEFORM_STUBS")
 
 
 # Called by writer.py
-def copy_files() -> None:
+def copy_files():
     dir = Path(__file__).parent
     post_build_file = dir / "post_build.py.script"
     copy_file_if_changed(
@@ -304,8 +284,3 @@ def copy_files() -> None:
         exclude_updater_file,
         CORE.relative_build_path("exclude_updater.py"),
     )
-    exclude_waveform_file = dir / "exclude_waveform.py.script"
-    copy_file_if_changed(
-        exclude_waveform_file,
-        CORE.relative_build_path("exclude_waveform.py"),
-    )

esphome/components/esp8266/const.py

@@ -1,5 +1,4 @@
 import esphome.codegen as cg
-from esphome.core import CORE
 
 KEY_ESP8266 = "esp8266"
 KEY_BOARD = "board"
@@ -7,25 +6,6 @@ KEY_PIN_INITIAL_STATES = "pin_initial_states"
 CONF_RESTORE_FROM_FLASH = "restore_from_flash"
 CONF_EARLY_PIN_INIT = "early_pin_init"
 KEY_FLASH_SIZE = "flash_size"
-KEY_WAVEFORM_REQUIRED = "waveform_required"
 
 # esp8266 namespace is already defined by arduino, manually prefix esphome
 esp8266_ns = cg.global_ns.namespace("esphome").namespace("esp8266")
-
-
-def require_waveform() -> None:
-    """Mark that Arduino waveform/PWM support is required.
-
-    Call this from components that need the Arduino waveform generator
-    (startWaveform, stopWaveform, analogWrite, Tone, Servo).
-
-    If no component calls this, the waveform code is excluded from the build
-    to save ~596 bytes of RAM and 464 bytes of flash.
-
-    Example:
-        from esphome.components.esp8266.const import require_waveform
-
-        async def to_code(config):
-            require_waveform()
-    """
-    CORE.data.setdefault(KEY_ESP8266, {})[KEY_WAVEFORM_REQUIRED] = True

esphome/components/esp8266/exclude_waveform.py.script

@@ -1,50 +0,0 @@
-# pylint: disable=E0602
-Import("env")  # noqa
-
-import os
-
-# Filter out waveform/PWM code from the Arduino core build
-# This saves ~596 bytes of RAM and 464 bytes of flash by not
-# instantiating the waveform generator state structures (wvfState + pwmState).
-#
-# The waveform code is used by: analogWrite, Tone, Servo, and direct
-# startWaveform/stopWaveform calls. ESPHome's esp8266_pwm component
-# calls require_waveform() to keep this code when needed.
-#
-# When excluded, we provide stub implementations of stopWaveform() and
-# _stopPWM() since digitalWrite() calls these unconditionally.
-
-
-def has_define_flag(env, name):
-    """Check if a define exists in the build flags."""
-    define_flag = f"-D{name}"
-    # Check BUILD_FLAGS (where ESPHome puts its defines)
-    for flag in env.get("BUILD_FLAGS", []):
-        if flag == define_flag or flag.startswith(f"{define_flag}="):
-            return True
-    # Also check CPPDEFINES list (parsed defines)
-    for define in env.get("CPPDEFINES", []):
-        if isinstance(define, tuple):
-            if define[0] == name:
-                return True
-        elif define == name:
-            return True
-    return False
-
-# USE_ESP8266_WAVEFORM_STUBS is defined when no component needs waveform
-if has_define_flag(env, "USE_ESP8266_WAVEFORM_STUBS"):
-
-    def filter_waveform_from_core(env, node):
-        """Filter callback to exclude waveform files from framework build."""
-        path = node.get_path()
-        filename = os.path.basename(path)
-        if filename in (
-            "core_esp8266_waveform_pwm.cpp",
-            "core_esp8266_waveform_phase.cpp",
-        ):
-            print(f"ESPHome: Excluding {filename} from build (waveform not required)")
-            return None
-        return node
-
-    # Apply the filter to framework sources
-    env.AddBuildMiddleware(filter_waveform_from_core, "**/cores/esp8266/*.cpp")

esphome/components/esp8266/gpio.cpp

@@ -98,8 +98,10 @@ void ESP8266GPIOPin::pin_mode(gpio::Flags flags) {
   pinMode(pin_, flags_to_mode(flags, pin_));  // NOLINT
 }
 
-size_t ESP8266GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "GPIO%u", this->pin_);
+std::string ESP8266GPIOPin::dump_summary() const {
+  char buffer[32];
+  snprintf(buffer, sizeof(buffer), "GPIO%u", pin_);
+  return buffer;
 }
 
 bool ESP8266GPIOPin::digital_read() {

esphome/components/esp8266/gpio.h

@@ -17,7 +17,7 @@ class ESP8266GPIOPin : public InternalGPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
+  std::string dump_summary() const override;
   void detach_interrupt() const override;
   ISRInternalGPIOPin to_isr() const override;
   uint8_t get_pin() const override { return pin_; }

esphome/components/esp8266/waveform_stubs.cpp

@@ -1,34 +0,0 @@
-#ifdef USE_ESP8266_WAVEFORM_STUBS
-
-// Stub implementations for Arduino waveform/PWM functions.
-//
-// When the waveform generator is not needed (no esp8266_pwm component),
-// we exclude core_esp8266_waveform_pwm.cpp from the build to save ~596 bytes
-// of RAM and 464 bytes of flash.
-//
-// These stubs satisfy calls from the Arduino GPIO code when the real
-// waveform implementation is excluded. They must be in the global namespace
-// with C linkage to match the Arduino core function declarations.
-
-#include <cstdint>
-
-// Empty namespace to satisfy linter - actual stubs must be at global scope
-namespace esphome::esp8266 {}  // namespace esphome::esp8266
-
-extern "C" {
-
-// Called by Arduino GPIO code to stop any waveform on a pin
-int stopWaveform(uint8_t pin) {
-  (void) pin;
-  return 1;  // Success (no waveform to stop)
-}
-
-// Called by Arduino GPIO code to stop any PWM on a pin
-bool _stopPWM(uint8_t pin) {
-  (void) pin;
-  return false;  // No PWM was running
-}
-
-}  // extern "C"
-
-#endif  // USE_ESP8266_WAVEFORM_STUBS

esphome/components/esp8266_pwm/output.py

@@ -1,7 +1,6 @@
 from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import output
-from esphome.components.esp8266.const import require_waveform
 import esphome.config_validation as cv
 from esphome.const import CONF_FREQUENCY, CONF_ID, CONF_NUMBER, CONF_PIN
 
@@ -35,9 +34,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-async def to_code(config) -> None:
-    require_waveform()
-
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await output.register_output(var, config)

esphome/components/esphome/ota/ota_esphome.cpp

@@ -4,7 +4,6 @@
 #include "esphome/components/sha256/sha256.h"
 #endif
 #include "esphome/components/network/util.h"
-#include "esphome/components/socket/socket.h"
 #include "esphome/components/ota/ota_backend.h"
 #include "esphome/components/ota/ota_backend_esp8266.h"
 #include "esphome/components/ota/ota_backend_arduino_libretiny.h"
@@ -444,9 +443,7 @@ void ESPHomeOTAComponent::log_socket_error_(const LogString *msg) {
 void ESPHomeOTAComponent::log_read_error_(const LogString *what) { ESP_LOGW(TAG, "Read %s failed", LOG_STR_ARG(what)); }
 
 void ESPHomeOTAComponent::log_start_(const LogString *phase) {
-  char peername[socket::PEERNAME_MAX_LEN];
-  this->client_->getpeername_to(peername);
-  ESP_LOGD(TAG, "Starting %s from %s", LOG_STR_ARG(phase), peername);
+  ESP_LOGD(TAG, "Starting %s from %s", LOG_STR_ARG(phase), this->client_->getpeername().c_str());
 }
 
 void ESPHomeOTAComponent::log_remote_closed_(const LogString *during) {

esphome/components/ethernet/ethernet_component.cpp

@@ -779,8 +779,8 @@ void EthernetComponent::ksz8081_set_clock_reference_(esp_eth_mac_t *mac) {
   ESPHL_ERROR_CHECK(err, "Read PHY Control 2 failed");
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
   char hex_buf[format_hex_pretty_size(PHY_REG_SIZE)];
-  ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s", format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
 #endif
+  ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s", format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
 
   /*
    * Bit 7 is `RMII Reference Clock Select`. Default is `0`.
@@ -797,10 +797,8 @@ void EthernetComponent::ksz8081_set_clock_reference_(esp_eth_mac_t *mac) {
     ESPHL_ERROR_CHECK(err, "Write PHY Control 2 failed");
     err = mac->read_phy_reg(mac, this->phy_addr_, KSZ80XX_PC2R_REG_ADDR, &(phy_control_2));
     ESPHL_ERROR_CHECK(err, "Read PHY Control 2 failed");
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
     ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s",
               format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
-#endif
   }
 }
 #endif  // USE_ETHERNET_KSZ8081

esphome/components/fan/fan.cpp

@@ -71,7 +71,7 @@ void FanCall::validate_() {
   auto traits = this->parent_.get_traits();
 
   if (this->speed_.has_value()) {
-    this->speed_ = clamp(*this->speed_, 1, static_cast<int>(traits.supported_speed_count()));
+    this->speed_ = clamp(*this->speed_, 1, traits.supported_speed_count());
 
     // https://developers.home-assistant.io/docs/core/entity/fan/#preset-modes
     // "Manually setting a speed must disable any set preset mode"

esphome/components/fan/fan_traits.h

@@ -11,7 +11,7 @@ namespace fan {
 class FanTraits {
  public:
   FanTraits() = default;
-  FanTraits(bool oscillation, bool speed, bool direction, uint8_t speed_count)
+  FanTraits(bool oscillation, bool speed, bool direction, int speed_count)
       : oscillation_(oscillation), speed_(speed), direction_(direction), speed_count_(speed_count) {}
 
   /// Return if this fan supports oscillation.
@@ -23,9 +23,9 @@ class FanTraits {
   /// Set whether this fan supports speed levels.
   void set_speed(bool speed) { this->speed_ = speed; }
   /// Return how many speed levels the fan has
-  uint8_t supported_speed_count() const { return this->speed_count_; }
+  int supported_speed_count() const { return this->speed_count_; }
   /// Set how many speed levels this fan has.
-  void set_supported_speed_count(uint8_t speed_count) { this->speed_count_ = speed_count; }
+  void set_supported_speed_count(int speed_count) { this->speed_count_ = speed_count; }
   /// Return if this fan supports changing direction
   bool supports_direction() const { return this->direction_; }
   /// Set whether this fan supports changing direction
@@ -64,7 +64,7 @@ class FanTraits {
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};
-  uint8_t speed_count_{};
+  int speed_count_{};
   std::vector<const char *> preset_modes_{};
 };
 

esphome/components/hbridge/fan/__init__.py

@@ -39,7 +39,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_DECAY_MODE, default="SLOW"): cv.enum(
                 DECAY_MODE_OPTIONS, upper=True
             ),
-            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
             cv.Optional(CONF_ENABLE_PIN): cv.use_id(output.FloatOutput),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }

esphome/components/hbridge/fan/hbridge_fan.h

@@ -15,7 +15,7 @@ enum DecayMode {
 
 class HBridgeFan : public Component, public fan::Fan {
  public:
-  HBridgeFan(uint8_t speed_count, DecayMode decay_mode) : speed_count_(speed_count), decay_mode_(decay_mode) {}
+  HBridgeFan(int speed_count, DecayMode decay_mode) : speed_count_(speed_count), decay_mode_(decay_mode) {}
 
   void set_pin_a(output::FloatOutput *pin_a) { pin_a_ = pin_a; }
   void set_pin_b(output::FloatOutput *pin_b) { pin_b_ = pin_b; }
@@ -33,7 +33,7 @@ class HBridgeFan : public Component, public fan::Fan {
   output::FloatOutput *pin_b_;
   output::FloatOutput *enable_{nullptr};
   output::BinaryOutput *oscillating_{nullptr};
-  uint8_t speed_count_{};
+  int speed_count_{};
   DecayMode decay_mode_{DECAY_MODE_SLOW};
   fan::FanTraits traits_;
   std::vector<const char *> preset_modes_{};

esphome/components/hlw8012/hlw8012.cpp

@@ -34,9 +34,9 @@ void HLW8012Component::setup() {
 }
 void HLW8012Component::dump_config() {
   ESP_LOGCONFIG(TAG, "HLW8012:");
-  LOG_PIN("  SEL Pin: ", this->sel_pin_);
-  LOG_PIN("  CF Pin: ", this->cf_pin_);
-  LOG_PIN("  CF1 Pin: ", this->cf1_pin_);
+  LOG_PIN("  SEL Pin: ", this->sel_pin_)
+  LOG_PIN("  CF Pin: ", this->cf_pin_)
+  LOG_PIN("  CF1 Pin: ", this->cf1_pin_)
   ESP_LOGCONFIG(TAG,
                 "  Change measurement mode every %" PRIu32 "\n"
                 "  Current resistor: %.1f mΩ\n"

esphome/components/homeassistant/binary_sensor/homeassistant_binary_sensor.cpp

@@ -1,7 +1,6 @@
 #include "homeassistant_binary_sensor.h"
-#include "esphome/components/api/api_server.h"
 #include "esphome/core/log.h"
-#include "esphome/core/string_ref.h"
+#include "esphome/components/api/api_server.h"
 
 namespace esphome {
 namespace homeassistant {
@@ -9,30 +8,31 @@ namespace homeassistant {
 static const char *const TAG = "homeassistant.binary_sensor";
 
 void HomeassistantBinarySensor::setup() {
-  api::global_api_server->subscribe_home_assistant_state(this->entity_id_, this->attribute_, [this](StringRef state) {
-    auto val = parse_on_off(state.c_str());
-    switch (val) {
-      case PARSE_NONE:
-      case PARSE_TOGGLE:
-        ESP_LOGW(TAG, "Can't convert '%s' to binary state!", state.c_str());
-        break;
-      case PARSE_ON:
-      case PARSE_OFF:
-        bool new_state = val == PARSE_ON;
-        if (this->attribute_ != nullptr) {
-          ESP_LOGD(TAG, "'%s::%s': Got attribute state %s", this->entity_id_, this->attribute_, ONOFF(new_state));
-        } else {
-          ESP_LOGD(TAG, "'%s': Got state %s", this->entity_id_, ONOFF(new_state));
+  api::global_api_server->subscribe_home_assistant_state(
+      this->entity_id_, this->attribute_, [this](const std::string &state) {
+        auto val = parse_on_off(state.c_str());
+        switch (val) {
+          case PARSE_NONE:
+          case PARSE_TOGGLE:
+            ESP_LOGW(TAG, "Can't convert '%s' to binary state!", state.c_str());
+            break;
+          case PARSE_ON:
+          case PARSE_OFF:
+            bool new_state = val == PARSE_ON;
+            if (this->attribute_ != nullptr) {
+              ESP_LOGD(TAG, "'%s::%s': Got attribute state %s", this->entity_id_, this->attribute_, ONOFF(new_state));
+            } else {
+              ESP_LOGD(TAG, "'%s': Got state %s", this->entity_id_, ONOFF(new_state));
+            }
+            if (this->initial_) {
+              this->publish_initial_state(new_state);
+            } else {
+              this->publish_state(new_state);
+            }
+            break;
         }
-        if (this->initial_) {
-          this->publish_initial_state(new_state);
-        } else {
-          this->publish_state(new_state);
-        }
-        break;
-    }
-    this->initial_ = false;
-  });
+        this->initial_ = false;
+      });
 }
 void HomeassistantBinarySensor::dump_config() {
   LOG_BINARY_SENSOR("", "Homeassistant Binary Sensor", this);

esphome/components/homeassistant/number/homeassistant_number.cpp

@@ -3,15 +3,14 @@
 #include "esphome/components/api/api_pb2.h"
 #include "esphome/components/api/api_server.h"
 #include "esphome/core/log.h"
-#include "esphome/core/string_ref.h"
 
 namespace esphome {
 namespace homeassistant {
 
 static const char *const TAG = "homeassistant.number";
 
-void HomeassistantNumber::state_changed_(StringRef state) {
-  auto number_value = parse_number<float>(state.c_str());
+void HomeassistantNumber::state_changed_(const std::string &state) {
+  auto number_value = parse_number<float>(state);
   if (!number_value.has_value()) {
     ESP_LOGW(TAG, "'%s': Can't convert '%s' to number!", this->entity_id_, state.c_str());
     this->publish_state(NAN);
@@ -24,8 +23,8 @@ void HomeassistantNumber::state_changed_(StringRef state) {
   this->publish_state(number_value.value());
 }
 
-void HomeassistantNumber::min_retrieved_(StringRef min) {
-  auto min_value = parse_number<float>(min.c_str());
+void HomeassistantNumber::min_retrieved_(const std::string &min) {
+  auto min_value = parse_number<float>(min);
   if (!min_value.has_value()) {
     ESP_LOGE(TAG, "'%s': Can't convert 'min' value '%s' to number!", this->entity_id_, min.c_str());
     return;
@@ -34,8 +33,8 @@ void HomeassistantNumber::min_retrieved_(StringRef min) {
   this->traits.set_min_value(min_value.value());
 }
 
-void HomeassistantNumber::max_retrieved_(StringRef max) {
-  auto max_value = parse_number<float>(max.c_str());
+void HomeassistantNumber::max_retrieved_(const std::string &max) {
+  auto max_value = parse_number<float>(max);
   if (!max_value.has_value()) {
     ESP_LOGE(TAG, "'%s': Can't convert 'max' value '%s' to number!", this->entity_id_, max.c_str());
     return;
@@ -44,8 +43,8 @@ void HomeassistantNumber::max_retrieved_(StringRef max) {
   this->traits.set_max_value(max_value.value());
 }
 
-void HomeassistantNumber::step_retrieved_(StringRef step) {
-  auto step_value = parse_number<float>(step.c_str());
+void HomeassistantNumber::step_retrieved_(const std::string &step) {
+  auto step_value = parse_number<float>(step);
   if (!step_value.has_value()) {
     ESP_LOGE(TAG, "'%s': Can't convert 'step' value '%s' to number!", this->entity_id_, step.c_str());
     return;

esphome/components/homeassistant/number/homeassistant_number.h

@@ -1,8 +1,10 @@
 #pragma once
 
+#include <map>
+#include <string>
+
 #include "esphome/components/number/number.h"
 #include "esphome/core/component.h"
-#include "esphome/core/string_ref.h"
 
 namespace esphome {
 namespace homeassistant {
@@ -16,10 +18,10 @@ class HomeassistantNumber : public number::Number, public Component {
   float get_setup_priority() const override;
 
  protected:
-  void state_changed_(StringRef state);
-  void min_retrieved_(StringRef min);
-  void max_retrieved_(StringRef max);
-  void step_retrieved_(StringRef step);
+  void state_changed_(const std::string &state);
+  void min_retrieved_(const std::string &min);
+  void max_retrieved_(const std::string &max);
+  void step_retrieved_(const std::string &step);
 
   void control(float value) override;
 

esphome/components/homeassistant/sensor/homeassistant_sensor.cpp

@@ -1,7 +1,6 @@
 #include "homeassistant_sensor.h"
-#include "esphome/components/api/api_server.h"
 #include "esphome/core/log.h"
-#include "esphome/core/string_ref.h"
+#include "esphome/components/api/api_server.h"
 
 namespace esphome {
 namespace homeassistant {
@@ -9,21 +8,22 @@ namespace homeassistant {
 static const char *const TAG = "homeassistant.sensor";
 
 void HomeassistantSensor::setup() {
-  api::global_api_server->subscribe_home_assistant_state(this->entity_id_, this->attribute_, [this](StringRef state) {
-    auto val = parse_number<float>(state.c_str());
-    if (!val.has_value()) {
-      ESP_LOGW(TAG, "'%s': Can't convert '%s' to number!", this->entity_id_, state.c_str());
-      this->publish_state(NAN);
-      return;
-    }
+  api::global_api_server->subscribe_home_assistant_state(
+      this->entity_id_, this->attribute_, [this](const std::string &state) {
+        auto val = parse_number<float>(state);
+        if (!val.has_value()) {
+          ESP_LOGW(TAG, "'%s': Can't convert '%s' to number!", this->entity_id_, state.c_str());
+          this->publish_state(NAN);
+          return;
+        }
 
-    if (this->attribute_ != nullptr) {
-      ESP_LOGD(TAG, "'%s::%s': Got attribute state %.2f", this->entity_id_, this->attribute_, *val);
-    } else {
-      ESP_LOGD(TAG, "'%s': Got state %.2f", this->entity_id_, *val);
-    }
-    this->publish_state(*val);
-  });
+        if (this->attribute_ != nullptr) {
+          ESP_LOGD(TAG, "'%s::%s': Got attribute state %.2f", this->entity_id_, this->attribute_, *val);
+        } else {
+          ESP_LOGD(TAG, "'%s': Got state %.2f", this->entity_id_, *val);
+        }
+        this->publish_state(*val);
+      });
 }
 void HomeassistantSensor::dump_config() {
   LOG_SENSOR("", "Homeassistant Sensor", this);

esphome/components/homeassistant/switch/homeassistant_switch.cpp

@@ -1,7 +1,6 @@
 #include "homeassistant_switch.h"
 #include "esphome/components/api/api_server.h"
 #include "esphome/core/log.h"
-#include "esphome/core/string_ref.h"
 
 namespace esphome {
 namespace homeassistant {
@@ -11,7 +10,7 @@ static const char *const TAG = "homeassistant.switch";
 using namespace esphome::switch_;
 
 void HomeassistantSwitch::setup() {
-  api::global_api_server->subscribe_home_assistant_state(this->entity_id_, nullptr, [this](StringRef state) {
+  api::global_api_server->subscribe_home_assistant_state(this->entity_id_, nullptr, [this](const std::string &state) {
     auto val = parse_on_off(state.c_str());
     switch (val) {
       case PARSE_NONE:

esphome/components/homeassistant/text_sensor/homeassistant_text_sensor.cpp

@@ -1,7 +1,6 @@
 #include "homeassistant_text_sensor.h"
-#include "esphome/components/api/api_server.h"
 #include "esphome/core/log.h"
-#include "esphome/core/string_ref.h"
+#include "esphome/components/api/api_server.h"
 
 namespace esphome {
 namespace homeassistant {
@@ -9,14 +8,15 @@ namespace homeassistant {
 static const char *const TAG = "homeassistant.text_sensor";
 
 void HomeassistantTextSensor::setup() {
-  api::global_api_server->subscribe_home_assistant_state(this->entity_id_, this->attribute_, [this](StringRef state) {
-    if (this->attribute_ != nullptr) {
-      ESP_LOGD(TAG, "'%s::%s': Got attribute state '%s'", this->entity_id_, this->attribute_, state.c_str());
-    } else {
-      ESP_LOGD(TAG, "'%s': Got state '%s'", this->entity_id_, state.c_str());
-    }
-    this->publish_state(state.str());
-  });
+  api::global_api_server->subscribe_home_assistant_state(
+      this->entity_id_, this->attribute_, [this](const std::string &state) {
+        if (this->attribute_ != nullptr) {
+          ESP_LOGD(TAG, "'%s::%s': Got attribute state '%s'", this->entity_id_, this->attribute_, state.c_str());
+        } else {
+          ESP_LOGD(TAG, "'%s': Got state '%s'", this->entity_id_, state.c_str());
+        }
+        this->publish_state(state);
+      });
 }
 void HomeassistantTextSensor::dump_config() {
   LOG_TEXT_SENSOR("", "Homeassistant Text Sensor", this);

esphome/components/host/gpio.cpp

@@ -25,7 +25,11 @@ void HostGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpio::Interr
 }
 void HostGPIOPin::pin_mode(gpio::Flags flags) { ESP_LOGD(TAG, "Setting pin %d mode to %02X", pin_, (uint32_t) flags); }
 
-size_t HostGPIOPin::dump_summary(char *buffer, size_t len) const { return snprintf(buffer, len, "GPIO%u", this->pin_); }
+std::string HostGPIOPin::dump_summary() const {
+  char buffer[32];
+  snprintf(buffer, sizeof(buffer), "GPIO%u", pin_);
+  return buffer;
+}
 
 bool HostGPIOPin::digital_read() { return inverted_; }
 void HostGPIOPin::digital_write(bool value) {

esphome/components/host/gpio.h

@@ -17,7 +17,7 @@ class HostGPIOPin : public InternalGPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
+  std::string dump_summary() const override;
   void detach_interrupt() const override;
   ISRInternalGPIOPin to_isr() const override;
   uint8_t get_pin() const override { return pin_; }

esphome/components/hte501/hte501.cpp

@@ -7,8 +7,6 @@ namespace hte501 {
 
 static const char *const TAG = "hte501";
 
-static constexpr size_t HTE501_SERIAL_NUMBER_SIZE = 7;
-
 void HTE501Component::setup() {
   uint8_t address[] = {0x70, 0x29};
   uint8_t identification[9];
@@ -18,10 +16,7 @@ void HTE501Component::setup() {
     this->mark_failed();
     return;
   }
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  char serial_hex[format_hex_size(HTE501_SERIAL_NUMBER_SIZE)];
-#endif
-  ESP_LOGV(TAG, "    Serial Number: 0x%s", format_hex_to(serial_hex, identification, HTE501_SERIAL_NUMBER_SIZE));
+  ESP_LOGV(TAG, "    Serial Number: 0x%s", format_hex(identification + 0, 7).c_str());
 }
 
 void HTE501Component::dump_config() {

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -119,7 +119,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

esphome/components/i2s_audio/__init__.py

@@ -1,11 +1,6 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components.esp32 import (
-    add_idf_sdkconfig_option,
-    enable_ringbuf_in_iram,
-    get_esp32_variant,
-)
-from esphome.components.esp32.const import (
     VARIANT_ESP32,
     VARIANT_ESP32C3,
     VARIANT_ESP32C5,
@@ -15,6 +10,8 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32P4,
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
+    add_idf_sdkconfig_option,
+    get_esp32_variant,
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_BITS_PER_SAMPLE, CONF_CHANNEL, CONF_ID, CONF_SAMPLE_RATE
@@ -281,9 +278,6 @@ async def to_code(config):
     # Helps avoid callbacks being skipped due to processor load
     add_idf_sdkconfig_option("CONFIG_I2S_ISR_IRAM_SAFE", True)
 
-    # Keep ring buffer functions in IRAM for audio performance
-    enable_ringbuf_in_iram()
-
     cg.add(var.set_lrclk_pin(config[CONF_I2S_LRCLK_PIN]))
     if CONF_I2S_BCLK_PIN in config:
         cg.add(var.set_bclk_pin(config[CONF_I2S_BCLK_PIN]))

esphome/components/ili9xxx/ili9xxx_display.cpp

@@ -131,6 +131,13 @@ float ILI9XXXDisplay::get_setup_priority() const { return setup_priority::HARDWA
 void ILI9XXXDisplay::fill(Color color) {
   if (!this->check_buffer_())
     return;
+
+  // If clipping is active, fall back to base implementation
+  if (this->get_clipping().is_set()) {
+    Display::fill(color);
+    return;
+  }
+
   uint16_t new_color = 0;
   this->x_low_ = 0;
   this->y_low_ = 0;

esphome/components/inkplate/inkplate.cpp

@@ -293,6 +293,13 @@ void Inkplate::fill(Color color) {
   ESP_LOGV(TAG, "Fill called");
   uint32_t start_time = millis();
 
+  // If clipping is active, fall back to base implementation
+  if (this->get_clipping().is_set()) {
+    Display::fill(color);
+    ESP_LOGV(TAG, "Fill finished (%ums)", millis() - start_time);
+    return;
+  }
+
   if (this->greyscale_) {
     uint8_t fill = ((color.red * 2126 / 10000) + (color.green * 7152 / 10000) + (color.blue * 722 / 10000)) >> 5;
     memset(this->buffer_, (fill << 4) | fill, this->get_buffer_length_());

esphome/components/jsn_sr04t/jsn_sr04t.cpp

@@ -39,9 +39,7 @@ void Jsnsr04tComponent::check_buffer_() {
       ESP_LOGV(TAG, "Distance from sensor: %umm, %.3fm", distance, meters);
       this->publish_state(meters);
     } else {
-      char hex_buf[format_hex_pretty_size(4)];
-      ESP_LOGW(TAG, "Invalid data read from sensor: %s",
-               format_hex_pretty_to(hex_buf, this->buffer_.data(), this->buffer_.size()));
+      ESP_LOGW(TAG, "Invalid data read from sensor: %s", format_hex_pretty(this->buffer_).c_str());
     }
   } else {
     ESP_LOGW(TAG, "checksum failed: %02x != %02x", checksum, this->buffer_[3]);

esphome/components/kuntze/kuntze.cpp

@@ -1,5 +1,4 @@
 #include "kuntze.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
 
@@ -11,17 +10,11 @@ static const char *const TAG = "kuntze";
 static const uint8_t CMD_READ_REG = 0x03;
 static const uint16_t REGISTER[] = {4136, 4160, 4680, 6000, 4688, 4728, 5832};
 
-// Maximum bytes to log for Modbus responses (2 registers = 4 bytes, plus byte count = 5 bytes)
-static constexpr size_t KUNTZE_MAX_LOG_BYTES = 8;
-
 void Kuntze::on_modbus_data(const std::vector<uint8_t> &data) {
   auto get_16bit = [&](int i) -> uint16_t { return (uint16_t(data[i * 2]) << 8) | uint16_t(data[i * 2 + 1]); };
 
   this->waiting_ = false;
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  char hex_buf[format_hex_pretty_size(KUNTZE_MAX_LOG_BYTES)];
-#endif
-  ESP_LOGV(TAG, "Data: %s", format_hex_pretty_to(hex_buf, data.data(), data.size()));
+  ESP_LOGV(TAG, "Data: %s", format_hex_pretty(data).c_str());
 
   float value = (float) get_16bit(0);
   for (int i = 0; i < data[3]; i++)

esphome/components/ld2410/ld2410.cpp

@@ -413,8 +413,7 @@ bool LD2410Component::handle_ack_data_() {
     return true;
   }
   if (!ld2410::validate_header_footer(CMD_FRAME_HEADER, this->buffer_data_)) {
-    char hex_buf[format_hex_pretty_size(HEADER_FOOTER_SIZE)];
-    ESP_LOGW(TAG, "Invalid header: %s", format_hex_pretty_to(hex_buf, this->buffer_data_, HEADER_FOOTER_SIZE));
+    ESP_LOGW(TAG, "Invalid header: %s", format_hex_pretty(this->buffer_data_, HEADER_FOOTER_SIZE).c_str());
     return true;
   }
   if (this->buffer_data_[COMMAND_STATUS] != 0x01) {
@@ -598,17 +597,11 @@ void LD2410Component::readline_(int readch) {
     return;  // Not enough data to process yet
   }
   if (ld2410::validate_header_footer(DATA_FRAME_FOOTER, &this->buffer_data_[this->buffer_pos_ - 4])) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-    char hex_buf[format_hex_pretty_size(MAX_LINE_LENGTH)];
-    ESP_LOGV(TAG, "Handling Periodic Data: %s", format_hex_pretty_to(hex_buf, this->buffer_data_, this->buffer_pos_));
-#endif
+    ESP_LOGV(TAG, "Handling Periodic Data: %s", format_hex_pretty(this->buffer_data_, this->buffer_pos_).c_str());
     this->handle_periodic_data_();
     this->buffer_pos_ = 0;  // Reset position index for next message
   } else if (ld2410::validate_header_footer(CMD_FRAME_FOOTER, &this->buffer_data_[this->buffer_pos_ - 4])) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-    char hex_buf[format_hex_pretty_size(MAX_LINE_LENGTH)];
-    ESP_LOGV(TAG, "Handling Ack Data: %s", format_hex_pretty_to(hex_buf, this->buffer_data_, this->buffer_pos_));
-#endif
+    ESP_LOGV(TAG, "Handling Ack Data: %s", format_hex_pretty(this->buffer_data_, this->buffer_pos_).c_str());
     if (this->handle_ack_data_()) {
       this->buffer_pos_ = 0;  // Reset position index for next message
     } else {

esphome/components/ld2412/ld2412.cpp

@@ -457,8 +457,7 @@ bool LD2412Component::handle_ack_data_() {
     return true;
   }
   if (!ld2412::validate_header_footer(CMD_FRAME_HEADER, this->buffer_data_)) {
-    char hex_buf[format_hex_pretty_size(HEADER_FOOTER_SIZE)];
-    ESP_LOGW(TAG, "Invalid header: %s", format_hex_pretty_to(hex_buf, this->buffer_data_, HEADER_FOOTER_SIZE));
+    ESP_LOGW(TAG, "Invalid header: %s", format_hex_pretty(this->buffer_data_, HEADER_FOOTER_SIZE).c_str());
     return true;
   }
   if (this->buffer_data_[COMMAND_STATUS] != 0x01) {
@@ -671,17 +670,11 @@ void LD2412Component::readline_(int readch) {
     return;  // Not enough data to process yet
   }
   if (ld2412::validate_header_footer(DATA_FRAME_FOOTER, &this->buffer_data_[this->buffer_pos_ - 4])) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-    char hex_buf[format_hex_pretty_size(MAX_LINE_LENGTH)];
-    ESP_LOGV(TAG, "Handling Periodic Data: %s", format_hex_pretty_to(hex_buf, this->buffer_data_, this->buffer_pos_));
-#endif
+    ESP_LOGV(TAG, "Handling Periodic Data: %s", format_hex_pretty(this->buffer_data_, this->buffer_pos_).c_str());
     this->handle_periodic_data_();
     this->buffer_pos_ = 0;  // Reset position index for next message
   } else if (ld2412::validate_header_footer(CMD_FRAME_FOOTER, &this->buffer_data_[this->buffer_pos_ - 4])) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-    char hex_buf[format_hex_pretty_size(MAX_LINE_LENGTH)];
-    ESP_LOGV(TAG, "Handling Ack Data: %s", format_hex_pretty_to(hex_buf, this->buffer_data_, this->buffer_pos_));
-#endif
+    ESP_LOGV(TAG, "Handling Ack Data: %s", format_hex_pretty(this->buffer_data_, this->buffer_pos_).c_str());
     if (this->handle_ack_data_()) {
       this->buffer_pos_ = 0;  // Reset position index for next message
     } else {

esphome/components/ld2450/ld2450.cpp

@@ -607,8 +607,7 @@ bool LD2450Component::handle_ack_data_() {
     return true;
   }
   if (!ld2450::validate_header_footer(CMD_FRAME_HEADER, this->buffer_data_)) {
-    char hex_buf[format_hex_pretty_size(HEADER_FOOTER_SIZE)];
-    ESP_LOGW(TAG, "Invalid header: %s", format_hex_pretty_to(hex_buf, this->buffer_data_, HEADER_FOOTER_SIZE));
+    ESP_LOGW(TAG, "Invalid header: %s", format_hex_pretty(this->buffer_data_, HEADER_FOOTER_SIZE).c_str());
     return true;
   }
   if (this->buffer_data_[COMMAND_STATUS] != 0x01) {
@@ -759,17 +758,11 @@ void LD2450Component::readline_(int readch) {
   }
   if (this->buffer_data_[this->buffer_pos_ - 2] == DATA_FRAME_FOOTER[0] &&
       this->buffer_data_[this->buffer_pos_ - 1] == DATA_FRAME_FOOTER[1]) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-    char hex_buf[format_hex_pretty_size(MAX_LINE_LENGTH)];
-    ESP_LOGV(TAG, "Handling Periodic Data: %s", format_hex_pretty_to(hex_buf, this->buffer_data_, this->buffer_pos_));
-#endif
+    ESP_LOGV(TAG, "Handling Periodic Data: %s", format_hex_pretty(this->buffer_data_, this->buffer_pos_).c_str());
     this->handle_periodic_data_();
     this->buffer_pos_ = 0;  // Reset position index for next frame
   } else if (ld2450::validate_header_footer(CMD_FRAME_FOOTER, &this->buffer_data_[this->buffer_pos_ - 4])) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-    char hex_buf[format_hex_pretty_size(MAX_LINE_LENGTH)];
-    ESP_LOGV(TAG, "Handling Ack Data: %s", format_hex_pretty_to(hex_buf, this->buffer_data_, this->buffer_pos_));
-#endif
+    ESP_LOGV(TAG, "Handling Ack Data: %s", format_hex_pretty(this->buffer_data_, this->buffer_pos_).c_str());
     if (this->handle_ack_data_()) {
       this->buffer_pos_ = 0;  // Reset position index for next message
     } else {

esphome/components/libretiny/gpio_arduino.cpp

@@ -63,8 +63,10 @@ void ArduinoInternalGPIOPin::pin_mode(gpio::Flags flags) {
   pinMode(pin_, flags_to_mode(flags));  // NOLINT
 }
 
-size_t ArduinoInternalGPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u", this->pin_);
+std::string ArduinoInternalGPIOPin::dump_summary() const {
+  char buffer[32];
+  snprintf(buffer, sizeof(buffer), "%u", pin_);
+  return buffer;
 }
 
 bool ArduinoInternalGPIOPin::digital_read() {

esphome/components/libretiny/gpio_arduino.h

@@ -16,7 +16,7 @@ class ArduinoInternalGPIOPin : public InternalGPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
+  std::string dump_summary() const override;
   void detach_interrupt() const override;
   ISRInternalGPIOPin to_isr() const override;
   uint8_t get_pin() const override { return pin_; }

esphome/components/logger/__init__.py

@@ -337,22 +337,6 @@ async def to_code(config):
     is_at_least_very_verbose = this_severity >= very_verbose_severity
     has_serial_logging = baud_rate != 0
 
-    # Add defines for which Serial object is needed (allows linker to exclude unused)
-    if CORE.is_esp8266:
-        hw_uart = config.get(CONF_HARDWARE_UART, UART0)
-        if has_serial_logging and hw_uart in (UART0, UART0_SWAP):
-            cg.add_define("USE_ESP8266_LOGGER_SERIAL")
-            # Exclude Serial1 from Arduino build
-            cg.add_build_flag("-DNO_GLOBAL_SERIAL1")
-        elif has_serial_logging and hw_uart == UART1:
-            cg.add_define("USE_ESP8266_LOGGER_SERIAL1")
-            # Exclude Serial from Arduino build
-            cg.add_build_flag("-DNO_GLOBAL_SERIAL")
-        else:
-            # No serial logging - exclude both
-            cg.add_build_flag("-DNO_GLOBAL_SERIAL")
-            cg.add_build_flag("-DNO_GLOBAL_SERIAL1")
-
     if (
         (CORE.is_esp8266 or CORE.is_rp2040)
         and has_serial_logging

esphome/components/logger/logger_esp8266.cpp

@@ -7,21 +7,26 @@ namespace esphome::logger {
 static const char *const TAG = "logger";
 
 void Logger::pre_setup() {
-#if defined(USE_ESP8266_LOGGER_SERIAL)
-  this->hw_serial_ = &Serial;
-  Serial.begin(this->baud_rate_);
-  if (this->uart_ == UART_SELECTION_UART0_SWAP) {
-    Serial.swap();
+  if (this->baud_rate_ > 0) {
+    switch (this->uart_) {
+      case UART_SELECTION_UART0:
+      case UART_SELECTION_UART0_SWAP:
+        this->hw_serial_ = &Serial;
+        Serial.begin(this->baud_rate_);
+        if (this->uart_ == UART_SELECTION_UART0_SWAP) {
+          Serial.swap();
+        }
+        Serial.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
+        break;
+      case UART_SELECTION_UART1:
+        this->hw_serial_ = &Serial1;
+        Serial1.begin(this->baud_rate_);
+        Serial1.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
+        break;
+    }
+  } else {
+    uart_set_debug(UART_NO);
   }
-  Serial.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
-#elif defined(USE_ESP8266_LOGGER_SERIAL1)
-  this->hw_serial_ = &Serial1;
-  Serial1.begin(this->baud_rate_);
-  Serial1.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
-#else
-  // No serial logging - disable debug output
-  uart_set_debug(UART_NO);
-#endif
 
   global_logger = this;
 
@@ -34,16 +39,15 @@ void HOT Logger::write_msg_(const char *msg, size_t len) {
 }
 
 const LogString *Logger::get_uart_selection_() {
-#if defined(USE_ESP8266_LOGGER_SERIAL)
-  if (this->uart_ == UART_SELECTION_UART0_SWAP) {
-    return LOG_STR("UART0_SWAP");
+  switch (this->uart_) {
+    case UART_SELECTION_UART0:
+      return LOG_STR("UART0");
+    case UART_SELECTION_UART1:
+      return LOG_STR("UART1");
+    case UART_SELECTION_UART0_SWAP:
+    default:
+      return LOG_STR("UART0_SWAP");
   }
-  return LOG_STR("UART0");
-#elif defined(USE_ESP8266_LOGGER_SERIAL1)
-  return LOG_STR("UART1");
-#else
-  return LOG_STR("NONE");
-#endif
 }
 
 }  // namespace esphome::logger

esphome/components/max6956/max6956.cpp

@@ -161,8 +161,10 @@ void MAX6956GPIOPin::setup() { pin_mode(flags_); }
 void MAX6956GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
 bool MAX6956GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void MAX6956GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
-size_t MAX6956GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via Max6956", this->pin_);
+std::string MAX6956GPIOPin::dump_summary() const {
+  char buffer[32];
+  snprintf(buffer, sizeof(buffer), "%u via Max6956", pin_);
+  return buffer;
 }
 
 }  // namespace max6956

esphome/components/max6956/max6956.h

@@ -76,7 +76,7 @@ class MAX6956GPIOPin : public GPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
+  std::string dump_summary() const override;
 
   void set_parent(MAX6956 *parent) { parent_ = parent; }
   void set_pin(uint8_t pin) { pin_ = pin; }

esphome/components/mcp23016/mcp23016.cpp

@@ -56,7 +56,7 @@ void MCP23016::pin_mode(uint8_t pin, gpio::Flags flags) {
     this->update_reg_(pin, false, iodir);
   }
 }
-float MCP23016::get_setup_priority() const { return setup_priority::IO; }
+float MCP23016::get_setup_priority() const { return setup_priority::HARDWARE; }
 bool MCP23016::read_reg_(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;
@@ -99,8 +99,10 @@ void MCP23016GPIOPin::setup() { pin_mode(flags_); }
 void MCP23016GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
 bool MCP23016GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void MCP23016GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
-size_t MCP23016GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via MCP23016", this->pin_);
+std::string MCP23016GPIOPin::dump_summary() const {
+  char buffer[32];
+  snprintf(buffer, sizeof(buffer), "%u via MCP23016", pin_);
+  return buffer;
 }
 
 }  // namespace mcp23016

esphome/components/mcp23016/mcp23016.h

@@ -60,7 +60,7 @@ class MCP23016GPIOPin : public GPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
+  std::string dump_summary() const override;
 
   void set_parent(MCP23016 *parent) { parent_ = parent; }
   void set_pin(uint8_t pin) { pin_ = pin; }

esphome/components/mcp23xxx_base/mcp23xxx_base.cpp

@@ -16,8 +16,8 @@ template<uint8_t N> bool MCP23XXXGPIOPin<N>::digital_read() {
 template<uint8_t N> void MCP23XXXGPIOPin<N>::digital_write(bool value) {
   this->parent_->digital_write(this->pin_, value != this->inverted_);
 }
-template<uint8_t N> size_t MCP23XXXGPIOPin<N>::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via MCP23XXX", this->pin_);
+template<uint8_t N> std::string MCP23XXXGPIOPin<N>::dump_summary() const {
+  return str_snprintf("%u via MCP23XXX", 15, pin_);
 }
 
 template class MCP23XXXGPIOPin<8>;

esphome/components/mcp23xxx_base/mcp23xxx_base.h

@@ -36,7 +36,7 @@ template<uint8_t N> class MCP23XXXGPIOPin : public GPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
+  std::string dump_summary() const override;
 
   void set_parent(MCP23XXXBase<N> *parent) { parent_ = parent; }
   void set_pin(uint8_t pin) { pin_ = pin; }

esphome/components/micro_wake_word/__init__.py

@@ -448,9 +448,6 @@ async def to_code(config):
     # The inference task queues detection events that need immediate processing
     socket.require_wake_loop_threadsafe()
 
-    # Keep ring buffer functions in IRAM for audio performance
-    esp32.enable_ringbuf_in_iram()
-
     mic_source = await microphone.microphone_source_to_code(config[CONF_MICROPHONE])
     cg.add(var.set_microphone_source(mic_source))
 

esphome/components/mipi_dsi/mipi_dsi.cpp

@@ -300,6 +300,13 @@ void MIPI_DSI::draw_pixel_at(int x, int y, Color color) {
 void MIPI_DSI::fill(Color color) {
   if (!this->check_buffer_())
     return;
+
+  // If clipping is active, fall back to base implementation
+  if (this->get_clipping().is_set()) {
+    Display::fill(color);
+    return;
+  }
+
   switch (this->color_depth_) {
     case display::COLOR_BITNESS_565: {
       auto *ptr_16 = reinterpret_cast<uint16_t *>(this->buffer_);

esphome/components/mipi_rgb/mipi_rgb.cpp

@@ -305,6 +305,13 @@ void MipiRgb::draw_pixel_at(int x, int y, Color color) {
 void MipiRgb::fill(Color color) {
   if (!this->check_buffer_())
     return;
+
+  // If clipping is active, fall back to base implementation
+  if (this->get_clipping().is_set()) {
+    Display::fill(color);
+    return;
+  }
+
   auto *ptr_16 = reinterpret_cast<uint16_t *>(this->buffer_);
   uint8_t hi_byte = static_cast<uint8_t>(color.r & 0xF8) | (color.g >> 5);
   uint8_t lo_byte = static_cast<uint8_t>((color.g & 0x1C) << 3) | (color.b >> 3);

esphome/components/mipi_spi/mipi_spi.h

@@ -247,8 +247,8 @@ class MipiSpi : public display::Display,
   void write_command_(uint8_t cmd, const uint8_t *bytes, size_t len) {
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
     char hex_buf[format_hex_pretty_size(MIPI_SPI_MAX_CMD_LOG_BYTES)];
-#endif
     esph_log_v(TAG, "Command %02X, length %d, bytes %s", cmd, len, format_hex_pretty_to(hex_buf, bytes, len));
+#endif
     if constexpr (BUS_TYPE == BUS_TYPE_QUAD) {
       this->enable();
       this->write_cmd_addr_data(8, 0x02, 24, cmd << 8, bytes, len);
@@ -569,6 +569,12 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
 
   // Fills the display with a color.
   void fill(Color color) override {
+    // If clipping is active, fall back to base implementation
+    if (this->get_clipping().is_set()) {
+      display::Display::fill(color);
+      return;
+    }
+
     this->x_low_ = 0;
     this->y_low_ = this->start_line_;
     this->x_high_ = WIDTH - 1;

esphome/components/modbus_controller/number/modbus_number.cpp

@@ -1,6 +1,5 @@
 #include <vector>
 #include "modbus_number.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -8,9 +7,6 @@ namespace modbus_controller {
 
 static const char *const TAG = "modbus.number";
 
-// Maximum uint16_t registers to log in verbose hex output
-static constexpr size_t MODBUS_NUMBER_MAX_LOG_REGISTERS = 32;
-
 void ModbusNumber::parse_and_publish(const std::vector<uint8_t> &data) {
   float result = payload_to_float(data, *this) / this->multiply_by_;
 
@@ -51,11 +47,7 @@ void ModbusNumber::control(float value) {
   }
 
   if (!data.empty()) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-    char hex_buf[format_hex_pretty_uint16_size(MODBUS_NUMBER_MAX_LOG_REGISTERS)];
-#endif
-    ESP_LOGV(TAG, "Modbus Number write raw: %s",
-             format_hex_pretty_to(hex_buf, sizeof(hex_buf), data.data(), data.size()));
+    ESP_LOGV(TAG, "Modbus Number write raw: %s", format_hex_pretty(data).c_str());
     write_cmd = ModbusCommandItem::create_custom_command(
         this->parent_, data,
         [this, write_cmd](ModbusRegisterType register_type, uint16_t start_address, const std::vector<uint8_t> &data) {

esphome/components/modbus_controller/output/modbus_output.cpp

@@ -7,9 +7,6 @@ namespace modbus_controller {
 
 static const char *const TAG = "modbus_controller.output";
 
-// Maximum bytes to log in verbose hex output
-static constexpr size_t MODBUS_OUTPUT_MAX_LOG_BYTES = 64;
-
 /** Write a value to the device
  *
  */
@@ -83,11 +80,7 @@ void ModbusBinaryOutput::write_state(bool state) {
     }
   }
   if (!data.empty()) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-    char hex_buf[format_hex_pretty_size(MODBUS_OUTPUT_MAX_LOG_BYTES)];
-#endif
-    ESP_LOGV(TAG, "Modbus binary output write raw: %s",
-             format_hex_pretty_to(hex_buf, sizeof(hex_buf), data.data(), data.size()));
+    ESP_LOGV(TAG, "Modbus binary output write raw: %s", format_hex_pretty(data).c_str());
     cmd = ModbusCommandItem::create_custom_command(
         this->parent_, data,
         [this, cmd](ModbusRegisterType register_type, uint16_t start_address, const std::vector<uint8_t> &data) {

esphome/components/modbus_controller/switch/modbus_switch.cpp

@@ -1,15 +1,11 @@
 
 #include "modbus_switch.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 namespace esphome {
 namespace modbus_controller {
 
 static const char *const TAG = "modbus_controller.switch";
 
-// Maximum bytes to log in verbose hex output
-static constexpr size_t MODBUS_SWITCH_MAX_LOG_BYTES = 64;
-
 void ModbusSwitch::setup() {
   optional<bool> initial_state = Switch::get_initial_state_with_restore_mode();
   if (initial_state.has_value()) {
@@ -75,11 +71,7 @@ void ModbusSwitch::write_state(bool state) {
     }
   }
   if (!data.empty()) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-    char hex_buf[format_hex_pretty_size(MODBUS_SWITCH_MAX_LOG_BYTES)];
-#endif
-    ESP_LOGV(TAG, "Modbus Switch write raw: %s",
-             format_hex_pretty_to(hex_buf, sizeof(hex_buf), data.data(), data.size()));
+    ESP_LOGV(TAG, "Modbus Switch write raw: %s", format_hex_pretty(data).c_str());
     cmd = ModbusCommandItem::create_custom_command(
         this->parent_, data,
         [this, cmd](ModbusRegisterType register_type, uint16_t start_address, const std::vector<uint8_t> &data) {

esphome/components/mpr121/mpr121.cpp

@@ -153,8 +153,10 @@ void MPR121GPIOPin::digital_write(bool value) {
   this->parent_->digital_write(this->pin_ - 4, value != this->inverted_);
 }
 
-size_t MPR121GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "ELE%u on MPR121", this->pin_);
+std::string MPR121GPIOPin::dump_summary() const {
+  char buffer[32];
+  snprintf(buffer, sizeof(buffer), "ELE%u on MPR121", this->pin_);
+  return buffer;
 }
 
 }  // namespace mpr121

esphome/components/mpr121/mpr121.h

@@ -109,7 +109,7 @@ class MPR121GPIOPin : public GPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
+  std::string dump_summary() const override;
 
   void set_parent(MPR121Component *parent) { this->parent_ = parent; }
   void set_pin(uint8_t pin) { this->pin_ = pin; }

esphome/components/mqtt/mqtt_client.cpp

@@ -153,14 +153,13 @@ void MQTTClientComponent::on_log(uint8_t level, const char *tag, const char *mes
 #endif
 
 void MQTTClientComponent::dump_config() {
-  char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
   ESP_LOGCONFIG(TAG,
                 "MQTT:\n"
                 "  Server Address: %s:%u (%s)\n"
                 "  Username: " LOG_SECRET("'%s'") "\n"
                                                   "  Client ID: " LOG_SECRET("'%s'") "\n"
                                                                                      "  Clean Session: %s",
-                this->credentials_.address.c_str(), this->credentials_.port, this->ip_.str_to(ip_buf),
+                this->credentials_.address.c_str(), this->credentials_.port, this->ip_.str().c_str(),
                 this->credentials_.username.c_str(), this->credentials_.client_id.c_str(),
                 YESNO(this->credentials_.clean_session));
   if (this->is_discovery_ip_enabled()) {
@@ -247,8 +246,7 @@ void MQTTClientComponent::check_dnslookup_() {
     return;
   }
 
-  char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
-  ESP_LOGD(TAG, "Resolved broker IP address to %s", this->ip_.str_to(ip_buf));
+  ESP_LOGD(TAG, "Resolved broker IP address to %s", this->ip_.str().c_str());
   this->start_connect_();
 }
 #if defined(USE_ESP8266) && LWIP_VERSION_MAJOR == 1

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -7,14 +7,12 @@
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 
 namespace esphome {
 namespace nextion {
 static const char *const TAG = "nextion.upload.arduino";
-static constexpr size_t NEXTION_MAX_RESPONSE_LOG_BYTES = 16;
 
 // Followed guide
 // https://unofficialnextion.com/t/nextion-upload-protocol-v1-2-the-fast-one/1044/2
@@ -91,10 +89,8 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
                EspClass::getFreeHeap());
       upload_first_chunk_sent_ = true;
       if (recv_string[0] == 0x08 && recv_string.size() == 5) {  // handle partial upload request
-        char hex_buf[format_hex_pretty_size(NEXTION_MAX_RESPONSE_LOG_BYTES)];
-        ESP_LOGD(
-            TAG, "Recv: [%s]",
-            format_hex_pretty_to(hex_buf, reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()));
+        ESP_LOGD(TAG, "Recv: [%s]",
+                 format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
         uint32_t result = 0;
         for (int j = 0; j < 4; ++j) {
           result += static_cast<uint8_t>(recv_string[j + 1]) << (8 * j);
@@ -111,10 +107,8 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
         buffer = nullptr;
         return range_end + 1;
       } else if (recv_string[0] != 0x05 and recv_string[0] != 0x08) {  // 0x05 == "ok"
-        char hex_buf[format_hex_pretty_size(NEXTION_MAX_RESPONSE_LOG_BYTES)];
-        ESP_LOGE(
-            TAG, "Invalid response: [%s]",
-            format_hex_pretty_to(hex_buf, reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()));
+        ESP_LOGE(TAG, "Invalid response: [%s]",
+                 format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
         // Deallocate buffer
         allocator.deallocate(buffer, 4096);
         buffer = nullptr;
@@ -280,9 +274,8 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   this->recv_ret_string_(response, 5000, true);  // This can take some time to return
 
   // The Nextion display will, if it's ready to accept data, send a 0x05 byte.
-  char hex_buf[format_hex_pretty_size(NEXTION_MAX_RESPONSE_LOG_BYTES)];
   ESP_LOGD(TAG, "Upload resp: [%s] %zu B",
-           format_hex_pretty_to(hex_buf, reinterpret_cast<const uint8_t *>(response.data()), response.size()),
+           format_hex_pretty(reinterpret_cast<const uint8_t *>(response.data()), response.size()).c_str(),
            response.length());
   ESP_LOGV(TAG, "Heap: %" PRIu32, EspClass::getFreeHeap());