[am43][lightwaverf][rf_bridge][spi_led_strip] Replace sprintf with safe alternatives

esphome/components/am43/am43_base.cpp

@@ -1,6 +1,6 @@
 #include "am43_base.h"
+#include "esphome/core/helpers.h"
 #include <cstring>
-#include <cstdio>
 
 namespace esphome {
 namespace am43 {
@@ -8,12 +8,9 @@ namespace am43 {
 const uint8_t START_PACKET[5] = {0x00, 0xff, 0x00, 0x00, 0x9a};
 
 std::string pkt_to_hex(const uint8_t *data, uint16_t len) {
-  char buf[64];
-  memset(buf, 0, 64);
-  for (int i = 0; i < len; i++)
-    sprintf(&buf[i * 2], "%02x", data[i]);
-  std::string ret = buf;
-  return ret;
+  char buf[64];  // format_hex_size(31) = 63, fits 31 bytes of hex data
+  format_hex_to(buf, sizeof(buf), data, len);
+  return buf;
 }
 
 Am43Packet *Am43Encoder::get_battery_level_request() {

esphome/components/api/proto.cpp

@@ -48,14 +48,14 @@ uint32_t ProtoDecodableMessage::count_repeated_field(const uint8_t *buffer, size
         }
         uint32_t field_length = res->as_uint32();
         ptr += consumed;
-        if (field_length > static_cast<size_t>(end - ptr)) {
+        if (ptr + field_length > end) {
           return count;  // Out of bounds
         }
         ptr += field_length;
         break;
       }
       case WIRE_TYPE_FIXED32: {  // 32-bit - skip 4 bytes
-        if (end - ptr < 4) {
+        if (ptr + 4 > end) {
           return count;
         }
         ptr += 4;
@@ -110,7 +110,7 @@ void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
         }
         uint32_t field_length = res->as_uint32();
         ptr += consumed;
-        if (field_length > static_cast<size_t>(end - ptr)) {
+        if (ptr + field_length > end) {
           ESP_LOGV(TAG, "Out-of-bounds Length Delimited at offset %ld", (long) (ptr - buffer));
           return;
         }
@@ -121,7 +121,7 @@ void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
         break;
       }
       case WIRE_TYPE_FIXED32: {  // 32-bit
-        if (end - ptr < 4) {
+        if (ptr + 4 > end) {
           ESP_LOGV(TAG, "Out-of-bounds Fixed32-bit at offset %ld", (long) (ptr - buffer));
           return;
         }

esphome/components/atm90e32/atm90e32.cpp

@@ -158,14 +158,12 @@ void ATM90E32Component::setup() {
 
   if (this->enable_offset_calibration_) {
     // Initialize flash storage for offset calibrations
-    uint32_t o_hash = fnv1_hash("_offset_calibration_");
-    o_hash = fnv1_hash_extend(o_hash, this->cs_summary_);
+    uint32_t o_hash = fnv1_hash(std::string("_offset_calibration_") + this->cs_summary_);
     this->offset_pref_ = global_preferences->make_preference<OffsetCalibration[3]>(o_hash, true);
     this->restore_offset_calibrations_();
 
     // Initialize flash storage for power offset calibrations
-    uint32_t po_hash = fnv1_hash("_power_offset_calibration_");
-    po_hash = fnv1_hash_extend(po_hash, this->cs_summary_);
+    uint32_t po_hash = fnv1_hash(std::string("_power_offset_calibration_") + this->cs_summary_);
     this->power_offset_pref_ = global_preferences->make_preference<PowerOffsetCalibration[3]>(po_hash, true);
     this->restore_power_offset_calibrations_();
   } else {
@@ -185,8 +183,7 @@ void ATM90E32Component::setup() {
 
   if (this->enable_gain_calibration_) {
     // Initialize flash storage for gain calibration
-    uint32_t g_hash = fnv1_hash("_gain_calibration_");
-    g_hash = fnv1_hash_extend(g_hash, this->cs_summary_);
+    uint32_t g_hash = fnv1_hash(std::string("_gain_calibration_") + this->cs_summary_);
     this->gain_calibration_pref_ = global_preferences->make_preference<GainCalibration[3]>(g_hash, true);
     this->restore_gain_calibrations_();
 

esphome/components/hmac_sha256/hmac_sha256.cpp

@@ -1,3 +1,4 @@
+#include <cstdio>
 #include <cstring>
 #include "hmac_sha256.h"
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_HOST)
@@ -25,7 +26,9 @@ void HmacSHA256::calculate() { mbedtls_md_hmac_finish(&this->ctx_, this->digest_
 void HmacSHA256::get_bytes(uint8_t *output) { memcpy(output, this->digest_, SHA256_DIGEST_SIZE); }
 
 void HmacSHA256::get_hex(char *output) {
-  format_hex_to(output, SHA256_DIGEST_SIZE * 2 + 1, this->digest_, SHA256_DIGEST_SIZE);
+  for (size_t i = 0; i < SHA256_DIGEST_SIZE; i++) {
+    sprintf(output + (i * 2), "%02x", this->digest_[i]);
+  }
 }
 
 bool HmacSHA256::equals_bytes(const uint8_t *expected) {

esphome/components/http_request/http_request.h

@@ -242,7 +242,9 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
       return;
     }
 
-    size_t max_length = this->max_response_buffer_size_;
+    size_t content_length = container->content_length;
+    size_t max_length = std::min(content_length, this->max_response_buffer_size_);
+
 #ifdef USE_HTTP_REQUEST_RESPONSE
     if (this->capture_response_.value(x...)) {
       std::string response_body;

esphome/components/http_request/http_request_idf.cpp

@@ -213,12 +213,18 @@ int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
   const uint32_t start = millis();
   watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());
 
-  this->feed_wdt();
-  int read_len = esp_http_client_read(this->client_, (char *) buf, max_len);
-  this->feed_wdt();
-  if (read_len > 0) {
-    this->bytes_read_ += read_len;
+  int bufsize = std::min(max_len, this->content_length - this->bytes_read_);
+
+  if (bufsize == 0) {
+    this->duration_ms += (millis() - start);
+    return 0;
   }
+
+  this->feed_wdt();
+  int read_len = esp_http_client_read(this->client_, (char *) buf, bufsize);
+  this->feed_wdt();
+  this->bytes_read_ += read_len;
+
   this->duration_ms += (millis() - start);
 
   return read_len;

esphome/components/hub75/display.py

@@ -1,4 +1,3 @@
-import logging
 from typing import Any
 
 from esphome import automation, pins
@@ -19,16 +18,13 @@ from esphome.const import (
     CONF_ROTATION,
     CONF_UPDATE_INTERVAL,
 )
-from esphome.core import ID, EnumValue
+from esphome.core import ID
 from esphome.cpp_generator import MockObj, TemplateArgsType
 import esphome.final_validate as fv
-from esphome.helpers import add_class_to_obj
 from esphome.types import ConfigType
 
 from . import boards, hub75_ns
 
-_LOGGER = logging.getLogger(__name__)
-
 DEPENDENCIES = ["esp32"]
 CODEOWNERS = ["@stuartparmenter"]
 
@@ -124,51 +120,13 @@ PANEL_LAYOUTS = {
 }
 
 Hub75ScanWiring = cg.global_ns.enum("Hub75ScanWiring", is_class=True)
-SCAN_WIRINGS = {
+SCAN_PATTERNS = {
     "STANDARD_TWO_SCAN": Hub75ScanWiring.STANDARD_TWO_SCAN,
-    "SCAN_1_4_16PX_HIGH": Hub75ScanWiring.SCAN_1_4_16PX_HIGH,
-    "SCAN_1_8_32PX_HIGH": Hub75ScanWiring.SCAN_1_8_32PX_HIGH,
-    "SCAN_1_8_40PX_HIGH": Hub75ScanWiring.SCAN_1_8_40PX_HIGH,
-    "SCAN_1_8_64PX_HIGH": Hub75ScanWiring.SCAN_1_8_64PX_HIGH,
+    "FOUR_SCAN_16PX_HIGH": Hub75ScanWiring.FOUR_SCAN_16PX_HIGH,
+    "FOUR_SCAN_32PX_HIGH": Hub75ScanWiring.FOUR_SCAN_32PX_HIGH,
+    "FOUR_SCAN_64PX_HIGH": Hub75ScanWiring.FOUR_SCAN_64PX_HIGH,
 }
 
-# Deprecated scan wiring names - mapped to new names
-DEPRECATED_SCAN_WIRINGS = {
-    "FOUR_SCAN_16PX_HIGH": "SCAN_1_4_16PX_HIGH",
-    "FOUR_SCAN_32PX_HIGH": "SCAN_1_8_32PX_HIGH",
-    "FOUR_SCAN_64PX_HIGH": "SCAN_1_8_64PX_HIGH",
-}
-
-
-def _validate_scan_wiring(value):
-    """Validate scan_wiring with deprecation warnings for old names."""
-    value = cv.string(value).upper().replace(" ", "_")
-
-    # Check if using deprecated name
-    # Remove deprecated names in 2026.7.0
-    if value in DEPRECATED_SCAN_WIRINGS:
-        new_name = DEPRECATED_SCAN_WIRINGS[value]
-        _LOGGER.warning(
-            "Scan wiring '%s' is deprecated and will be removed in ESPHome 2026.7.0. "
-            "Please use '%s' instead.",
-            value,
-            new_name,
-        )
-        value = new_name
-
-    # Validate against allowed values
-    if value not in SCAN_WIRINGS:
-        raise cv.Invalid(
-            f"Unknown scan wiring '{value}'. "
-            f"Valid options are: {', '.join(sorted(SCAN_WIRINGS.keys()))}"
-        )
-
-    # Return as EnumValue like cv.enum does
-    result = add_class_to_obj(value, EnumValue)
-    result.enum_value = SCAN_WIRINGS[value]
-    return result
-
-
 Hub75ClockSpeed = cg.global_ns.enum("Hub75ClockSpeed", is_class=True)
 CLOCK_SPEEDS = {
     "8MHZ": Hub75ClockSpeed.HZ_8M,
@@ -424,7 +382,9 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_LAYOUT_COLS): cv.positive_int,
             cv.Optional(CONF_LAYOUT): cv.enum(PANEL_LAYOUTS, upper=True, space="_"),
             # Panel hardware configuration
-            cv.Optional(CONF_SCAN_WIRING): _validate_scan_wiring,
+            cv.Optional(CONF_SCAN_WIRING): cv.enum(
+                SCAN_PATTERNS, upper=True, space="_"
+            ),
             cv.Optional(CONF_SHIFT_DRIVER): cv.enum(SHIFT_DRIVERS, upper=True),
             # Display configuration
             cv.Optional(CONF_DOUBLE_BUFFER): cv.boolean,
@@ -587,7 +547,7 @@ def _build_config_struct(
 async def to_code(config: ConfigType) -> None:
     add_idf_component(
         name="esphome/esp-hub75",
-        ref="0.3.0",
+        ref="0.2.2",
     )
 
     # Set compile-time configuration via build flags (so external library sees them)

esphome/components/infrared/infrared.cpp

@@ -19,12 +19,12 @@ InfraredCall &InfraredCall::set_carrier_frequency(uint32_t frequency) {
 InfraredCall &InfraredCall::set_raw_timings(const std::vector<int32_t> &timings) {
   this->raw_timings_ = &timings;
   this->packed_data_ = nullptr;
-  this->base64url_ptr_ = nullptr;
+  this->base85_ptr_ = nullptr;
   return *this;
 }
 
-InfraredCall &InfraredCall::set_raw_timings_base64url(const std::string &base64url) {
-  this->base64url_ptr_ = &base64url;
+InfraredCall &InfraredCall::set_raw_timings_base85(const std::string &base85) {
+  this->base85_ptr_ = &base85;
   this->raw_timings_ = nullptr;
   this->packed_data_ = nullptr;
   return *this;
@@ -35,7 +35,7 @@ InfraredCall &InfraredCall::set_raw_timings_packed(const uint8_t *data, uint16_t
   this->packed_length_ = length;
   this->packed_count_ = count;
   this->raw_timings_ = nullptr;
-  this->base64url_ptr_ = nullptr;
+  this->base85_ptr_ = nullptr;
   return *this;
 }
 
@@ -101,22 +101,13 @@ void Infrared::control(const InfraredCall &call) {
                                                call.get_packed_count());
     ESP_LOGD(TAG, "Transmitting packed raw timings: count=%u, repeat=%u", call.get_packed_count(),
              call.get_repeat_count());
-  } else if (call.is_base64url()) {
-    // Decode base64url (URL-safe) into transmit buffer
-    if (!transmit_data->set_data_from_base64url(call.get_base64url_data())) {
-      ESP_LOGE(TAG, "Invalid base64url data");
+  } else if (call.is_base85()) {
+    // Decode base85 directly into transmit buffer (zero heap allocations)
+    if (!transmit_data->set_data_from_base85(call.get_base85_data())) {
+      ESP_LOGE(TAG, "Invalid base85 data");
       return;
     }
-    // Sanity check: validate timing values are within reasonable bounds
-    constexpr int32_t max_timing_us = 500000;  // 500ms absolute max
-    for (int32_t timing : transmit_data->get_data()) {
-      int32_t abs_timing = timing < 0 ? -timing : timing;
-      if (abs_timing > max_timing_us) {
-        ESP_LOGE(TAG, "Invalid timing value: %d µs (max %d)", timing, max_timing_us);
-        return;
-      }
-    }
-    ESP_LOGD(TAG, "Transmitting base64url raw timings: count=%zu, repeat=%u", transmit_data->get_data().size(),
+    ESP_LOGD(TAG, "Transmitting base85 raw timings: count=%zu, repeat=%u", transmit_data->get_data().size(),
              call.get_repeat_count());
   } else {
     // From vector (lambdas/automations)

esphome/components/infrared/infrared.h

@@ -40,11 +40,11 @@ class InfraredCall {
   /// @note Usage: Primarily for lambdas/automations where the vector is in scope.
   InfraredCall &set_raw_timings(const std::vector<int32_t> &timings);
 
-  /// Set the raw timings from base64url-encoded little-endian int32 data
+  /// Set the raw timings from base85-encoded int32 data
   /// @note Lifetime: Stores a pointer to the string. The string must outlive perform().
-  /// @note Usage: For web_server - base64url is fully URL-safe (uses '-' and '_').
+  /// @note Usage: For web_server where the encoded string is on the stack.
   /// @note Decoding happens at perform() time, directly into the transmit buffer.
-  InfraredCall &set_raw_timings_base64url(const std::string &base64url);
+  InfraredCall &set_raw_timings_base85(const std::string &base85);
 
   /// Set the raw timings from packed protobuf sint32 data (zigzag + varint encoded)
   /// @note Lifetime: Stores a pointer to the buffer. The buffer must outlive perform().
@@ -59,18 +59,18 @@ class InfraredCall {
 
   /// Get the carrier frequency
   const optional<uint32_t> &get_carrier_frequency() const { return this->carrier_frequency_; }
-  /// Get the raw timings (only valid if set via set_raw_timings)
+  /// Get the raw timings (only valid if set via set_raw_timings, not packed or base85)
   const std::vector<int32_t> &get_raw_timings() const { return *this->raw_timings_; }
-  /// Check if raw timings have been set (any format)
+  /// Check if raw timings have been set (vector, packed, or base85)
   bool has_raw_timings() const {
-    return this->raw_timings_ != nullptr || this->packed_data_ != nullptr || this->base64url_ptr_ != nullptr;
+    return this->raw_timings_ != nullptr || this->packed_data_ != nullptr || this->base85_ptr_ != nullptr;
   }
   /// Check if using packed data format
   bool is_packed() const { return this->packed_data_ != nullptr; }
-  /// Check if using base64url data format
-  bool is_base64url() const { return this->base64url_ptr_ != nullptr; }
-  /// Get the base64url data string
-  const std::string &get_base64url_data() const { return *this->base64url_ptr_; }
+  /// Check if using base85 data format
+  bool is_base85() const { return this->base85_ptr_ != nullptr; }
+  /// Get the base85 data string
+  const std::string &get_base85_data() const { return *this->base85_ptr_; }
   /// Get packed data (only valid if set via set_raw_timings_packed)
   const uint8_t *get_packed_data() const { return this->packed_data_; }
   uint16_t get_packed_length() const { return this->packed_length_; }
@@ -84,8 +84,8 @@ class InfraredCall {
   optional<uint32_t> carrier_frequency_;
   // Pointer to vector-based timings (caller-owned, must outlive perform())
   const std::vector<int32_t> *raw_timings_{nullptr};
-  // Pointer to base64url-encoded string (caller-owned, must outlive perform())
-  const std::string *base64url_ptr_{nullptr};
+  // Pointer to base85-encoded string (caller-owned, must outlive perform())
+  const std::string *base85_ptr_{nullptr};
   // Pointer to packed protobuf buffer (caller-owned, must outlive perform())
   const uint8_t *packed_data_{nullptr};
   uint16_t packed_length_{0};

esphome/components/light/light_json_schema.cpp

@@ -1,5 +1,4 @@
 #include "light_json_schema.h"
-#include "color_mode.h"
 #include "light_output.h"
 #include "esphome/core/progmem.h"
 
@@ -9,32 +8,29 @@ namespace esphome::light {
 
 // See https://www.home-assistant.io/integrations/light.mqtt/#json-schema for documentation on the schema
 
-// Get JSON string for color mode.
-// ColorMode enum values are sparse bitmasks (0, 1, 3, 7, 11, 19, 35, 39, 47, 51) which would
-// generate a large jump table. Converting to bit index (0-9) allows a compact switch.
-static ProgmemStr get_color_mode_json_str(ColorMode mode) {
-  switch (ColorModeBitPolicy::to_bit(mode)) {
-    case 1:
-      return ESPHOME_F("onoff");
-    case 2:
-      return ESPHOME_F("brightness");
-    case 3:
-      return ESPHOME_F("white");
-    case 4:
-      return ESPHOME_F("color_temp");
-    case 5:
-      return ESPHOME_F("cwww");
-    case 6:
-      return ESPHOME_F("rgb");
-    case 7:
-      return ESPHOME_F("rgbw");
-    case 8:
-      return ESPHOME_F("rgbct");
-    case 9:
-      return ESPHOME_F("rgbww");
-    default:
-      return nullptr;
+// Get JSON string for color mode using linear search (avoids large switch jump table)
+static const char *get_color_mode_json_str(ColorMode mode) {
+  // Parallel arrays: mode values and their corresponding strings
+  // Uses less RAM than a switch jump table on sparse enum values
+  static constexpr ColorMode MODES[] = {
+      ColorMode::ON_OFF,
+      ColorMode::BRIGHTNESS,
+      ColorMode::WHITE,
+      ColorMode::COLOR_TEMPERATURE,
+      ColorMode::COLD_WARM_WHITE,
+      ColorMode::RGB,
+      ColorMode::RGB_WHITE,
+      ColorMode::RGB_COLOR_TEMPERATURE,
+      ColorMode::RGB_COLD_WARM_WHITE,
+  };
+  static constexpr const char *STRINGS[] = {
+      "onoff", "brightness", "white", "color_temp", "cwww", "rgb", "rgbw", "rgbct", "rgbww",
+  };
+  for (size_t i = 0; i < sizeof(MODES) / sizeof(MODES[0]); i++) {
+    if (MODES[i] == mode)
+      return STRINGS[i];
   }
+  return nullptr;
 }
 
 void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
@@ -48,7 +44,7 @@ void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
   auto values = state.remote_values;
 
   const auto color_mode = values.get_color_mode();
-  const auto *mode_str = get_color_mode_json_str(color_mode);
+  const char *mode_str = get_color_mode_json_str(color_mode);
   if (mode_str != nullptr) {
     root[ESPHOME_F("color_mode")] = mode_str;
   }

esphome/components/lightwaverf/lightwaverf.cpp

@@ -1,3 +1,4 @@
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 #ifdef USE_ESP8266
@@ -44,13 +45,16 @@ void LightWaveRF::send_rx(const std::vector<uint8_t> &msg, uint8_t repeats, bool
 }
 
 void LightWaveRF::print_msg_(uint8_t *msg, uint8_t len) {
-  char buffer[65];
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
+  char buffer[65];  // max 10 entries * 6 chars + null
   ESP_LOGD(TAG, " Received code (len:%i): ", len);
 
+  size_t pos = 0;
   for (int i = 0; i < len; i++) {
-    sprintf(&buffer[i * 6], "0x%02x, ", msg[i]);
+    pos = buf_append_printf(buffer, sizeof(buffer), pos, "0x%02x, ", msg[i]);
   }
   ESP_LOGD(TAG, "[%s]", buffer);
+#endif
 }
 
 void LightWaveRF::dump_config() {

esphome/components/modbus_controller/modbus_controller.h

@@ -271,31 +271,24 @@ class ServerRegister {
 
   // Formats a raw value into a string representation based on the value type for debugging
   std::string format_value(int64_t value) const {
-    // max 44: float with %.1f can be up to 42 chars (3.4e38 → 39 integer digits + sign + decimal + 1 digit)
-    // plus null terminator = 43, rounded to 44 for 4-byte alignment
-    char buf[44];
     switch (this->value_type) {
       case SensorValueType::U_WORD:
       case SensorValueType::U_DWORD:
       case SensorValueType::U_DWORD_R:
       case SensorValueType::U_QWORD:
       case SensorValueType::U_QWORD_R:
-        buf_append_printf(buf, sizeof(buf), 0, "%" PRIu64, static_cast<uint64_t>(value));
-        return buf;
+        return std::to_string(static_cast<uint64_t>(value));
       case SensorValueType::S_WORD:
       case SensorValueType::S_DWORD:
       case SensorValueType::S_DWORD_R:
       case SensorValueType::S_QWORD:
       case SensorValueType::S_QWORD_R:
-        buf_append_printf(buf, sizeof(buf), 0, "%" PRId64, value);
-        return buf;
+        return std::to_string(value);
       case SensorValueType::FP32_R:
       case SensorValueType::FP32:
-        buf_append_printf(buf, sizeof(buf), 0, "%.1f", bit_cast<float>(static_cast<uint32_t>(value)));
-        return buf;
+        return str_sprintf("%.1f", bit_cast<float>(static_cast<uint32_t>(value)));
       default:
-        buf_append_printf(buf, sizeof(buf), 0, "%" PRId64, value);
-        return buf;
+        return std::to_string(value);
     }
   }
 

esphome/components/modbus_controller/text_sensor/modbus_textsensor.cpp

@@ -16,20 +16,12 @@ void ModbusTextSensor::parse_and_publish(const std::vector<uint8_t> &data) {
   while ((items_left > 0) && index < data.size()) {
     uint8_t b = data[index];
     switch (this->encode_) {
-      case RawEncoding::HEXBYTES: {
-        // max 3: 2 hex digits + null
-        char hex_buf[3];
-        snprintf(hex_buf, sizeof(hex_buf), "%02x", b);
-        output_str += hex_buf;
+      case RawEncoding::HEXBYTES:
+        output_str += str_snprintf("%02x", 2, b);
         break;
-      }
-      case RawEncoding::COMMA: {
-        // max 5: optional ','(1) + uint8(3) + null, for both ",%d" and "%d"
-        char dec_buf[5];
-        snprintf(dec_buf, sizeof(dec_buf), index != this->offset ? ",%d" : "%d", b);
-        output_str += dec_buf;
+      case RawEncoding::COMMA:
+        output_str += str_sprintf(index != this->offset ? ",%d" : "%d", b);
         break;
-      }
       case RawEncoding::ANSI:
         if (b < 0x20)
           break;

esphome/components/network/ip_address.h

@@ -43,14 +43,6 @@ namespace network {
 /// Buffer size for IP address string (IPv6 max: 39 chars + null)
 static constexpr size_t IP_ADDRESS_BUFFER_SIZE = 40;
 
-/// Lowercase hex digits in IP address string (A-F -> a-f for IPv6 per RFC 5952)
-inline void lowercase_ip_str(char *buf) {
-  for (char *p = buf; *p; ++p) {
-    if (*p >= 'A' && *p <= 'F')
-      *p += 32;
-  }
-}
-
 struct IPAddress {
  public:
 #ifdef USE_HOST
@@ -60,15 +52,10 @@ struct IPAddress {
   }
   IPAddress(const std::string &in_address) { inet_aton(in_address.c_str(), &ip_addr_); }
   IPAddress(const ip_addr_t *other_ip) { ip_addr_ = *other_ip; }
-  std::string str() const {
-    char buf[IP_ADDRESS_BUFFER_SIZE];
-    this->str_to(buf);
-    return buf;
-  }
+  std::string str() const { return str_lower_case(inet_ntoa(ip_addr_)); }
   /// Write IP address to buffer. Buffer must be at least IP_ADDRESS_BUFFER_SIZE bytes.
   char *str_to(char *buf) const {
-    inet_ntop(AF_INET, &ip_addr_, buf, IP_ADDRESS_BUFFER_SIZE);
-    return buf;  // IPv4 only, no hex letters to lowercase
+    return const_cast<char *>(inet_ntop(AF_INET, &ip_addr_, buf, IP_ADDRESS_BUFFER_SIZE));
   }
 #else
   IPAddress() { ip_addr_set_zero(&ip_addr_); }
@@ -147,18 +134,9 @@ struct IPAddress {
   bool is_ip4() const { return IP_IS_V4(&ip_addr_); }
   bool is_ip6() const { return IP_IS_V6(&ip_addr_); }
   bool is_multicast() const { return ip_addr_ismulticast(&ip_addr_); }
-  std::string str() const {
-    char buf[IP_ADDRESS_BUFFER_SIZE];
-    this->str_to(buf);
-    return buf;
-  }
+  std::string str() const { return str_lower_case(ipaddr_ntoa(&ip_addr_)); }
   /// Write IP address to buffer. Buffer must be at least IP_ADDRESS_BUFFER_SIZE bytes.
-  /// Output is lowercased per RFC 5952 (IPv6 hex digits a-f).
-  char *str_to(char *buf) const {
-    ipaddr_ntoa_r(&ip_addr_, buf, IP_ADDRESS_BUFFER_SIZE);
-    lowercase_ip_str(buf);
-    return buf;
-  }
+  char *str_to(char *buf) const { return ipaddr_ntoa_r(&ip_addr_, buf, IP_ADDRESS_BUFFER_SIZE); }
   bool operator==(const IPAddress &other) const { return ip_addr_cmp(&ip_addr_, &other.ip_addr_); }
   bool operator!=(const IPAddress &other) const { return !ip_addr_cmp(&ip_addr_, &other.ip_addr_); }
   IPAddress &operator+=(uint8_t increase) {

esphome/components/opentherm/opentherm.cpp

@@ -561,9 +561,8 @@ const char *OpenTherm::message_id_to_str(MessageId id) {
 }
 
 void OpenTherm::debug_data(OpenthermData &data) {
-  char type_buf[9], id_buf[9], hb_buf[9], lb_buf[9];
-  ESP_LOGD(TAG, "%s %s %s %s", format_bin_to(type_buf, data.type), format_bin_to(id_buf, data.id),
-           format_bin_to(hb_buf, data.valueHB), format_bin_to(lb_buf, data.valueLB));
+  ESP_LOGD(TAG, "%s %s %s %s", format_bin(data.type).c_str(), format_bin(data.id).c_str(),
+           format_bin(data.valueHB).c_str(), format_bin(data.valueLB).c_str());
   ESP_LOGD(TAG, "type: %s; id: %u; HB: %u; LB: %u; uint_16: %u; float: %f",
            this->message_type_to_str((MessageType) data.type), data.id, data.valueHB, data.valueLB, data.u16(),
            data.f88());

esphome/components/pipsolar/output/pipsolar_output.cpp

@@ -9,7 +9,7 @@ static const char *const TAG = "pipsolar.output";
 
 void PipsolarOutput::write_state(float state) {
   char tmp[10];
-  snprintf(tmp, sizeof(tmp), this->set_command_, state);
+  sprintf(tmp, this->set_command_.c_str(), state);
 
   if (std::find(this->possible_values_.begin(), this->possible_values_.end(), state) != this->possible_values_.end()) {
     ESP_LOGD(TAG, "Will write: %s out of value %f / %02.0f", tmp, state, state);

esphome/components/pipsolar/output/pipsolar_output.h

@@ -15,15 +15,13 @@ class PipsolarOutput : public output::FloatOutput {
  public:
   PipsolarOutput() {}
   void set_parent(Pipsolar *parent) { this->parent_ = parent; }
-  void set_set_command(const char *command) { this->set_command_ = command; }
-  /// Prevent accidental use of std::string which would dangle
-  void set_set_command(const std::string &command) = delete;
+  void set_set_command(const std::string &command) { this->set_command_ = command; };
   void set_possible_values(std::vector<float> possible_values) { this->possible_values_ = std::move(possible_values); }
-  void set_value(float value) { this->write_state(value); }
+  void set_value(float value) { this->write_state(value); };
 
  protected:
   void write_state(float state) override;
-  const char *set_command_{nullptr};
+  std::string set_command_;
   Pipsolar *parent_;
   std::vector<float> possible_values_;
 };

esphome/components/pipsolar/switch/pipsolar_switch.cpp

@@ -9,9 +9,14 @@ static const char *const TAG = "pipsolar.switch";
 
 void PipsolarSwitch::dump_config() { LOG_SWITCH("", "Pipsolar Switch", this); }
 void PipsolarSwitch::write_state(bool state) {
-  const char *command = state ? this->on_command_ : this->off_command_;
-  if (command != nullptr) {
-    this->parent_->queue_command(command);
+  if (state) {
+    if (!this->on_command_.empty()) {
+      this->parent_->queue_command(this->on_command_);
+    }
+  } else {
+    if (!this->off_command_.empty()) {
+      this->parent_->queue_command(this->off_command_);
+    }
   }
 }
 

esphome/components/pipsolar/switch/pipsolar_switch.h

@@ -9,18 +9,15 @@ namespace pipsolar {
 class Pipsolar;
 class PipsolarSwitch : public switch_::Switch, public Component {
  public:
-  void set_parent(Pipsolar *parent) { this->parent_ = parent; }
-  void set_on_command(const char *command) { this->on_command_ = command; }
-  void set_off_command(const char *command) { this->off_command_ = command; }
-  /// Prevent accidental use of std::string which would dangle
-  void set_on_command(const std::string &command) = delete;
-  void set_off_command(const std::string &command) = delete;
+  void set_parent(Pipsolar *parent) { this->parent_ = parent; };
+  void set_on_command(const std::string &command) { this->on_command_ = command; };
+  void set_off_command(const std::string &command) { this->off_command_ = command; };
   void dump_config() override;
 
  protected:
   void write_state(bool state) override;
-  const char *on_command_{nullptr};
-  const char *off_command_{nullptr};
+  std::string on_command_;
+  std::string off_command_;
   Pipsolar *parent_;
 };
 

esphome/components/remote_base/remote_base.cpp

@@ -2,6 +2,8 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
+#include <cinttypes>
+
 namespace esphome {
 namespace remote_base {
 
@@ -158,8 +160,8 @@ void RemoteTransmitData::set_data_from_packed_sint32(const uint8_t *data, size_t
   }
 }
 
-bool RemoteTransmitData::set_data_from_base64url(const std::string &base64url) {
-  return base64_decode_int32_vector(base64url, this->data_);
+bool RemoteTransmitData::set_data_from_base85(const std::string &base85) {
+  return base85_decode_int32_vector(base85, this->data_);
 }
 
 /* RemoteTransmitterBase */

esphome/components/remote_base/remote_base.h

@@ -36,11 +36,11 @@ class RemoteTransmitData {
   /// @param len Length of the buffer in bytes
   /// @param count Number of values (for reserve optimization)
   void set_data_from_packed_sint32(const uint8_t *data, size_t len, size_t count);
-  /// Set data from base64url-encoded little-endian int32 values
-  /// Base64url is URL-safe: uses '-' instead of '+', '_' instead of '/'
-  /// @param base64url Base64url-encoded string of little-endian int32 values
+  /// Set data from base85-encoded int32 values
+  /// Decodes directly into internal buffer (zero heap allocations)
+  /// @param base85 Base85-encoded string (5 chars per int32 value)
   /// @return true if successful, false if decode failed or invalid size
-  bool set_data_from_base64url(const std::string &base64url);
+  bool set_data_from_base85(const std::string &base85);
   void reset() {
     this->data_.clear();
     this->carrier_frequency_ = 0;

esphome/components/rf_bridge/rf_bridge.cpp

@@ -1,6 +1,7 @@
 #include "rf_bridge.h"
-#include "esphome/core/log.h"
 #include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include <cinttypes>
 #include <cstring>
 
@@ -72,9 +73,9 @@ bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
 
       data.length = raw[2];
       data.protocol = raw[3];
-      char next_byte[3];
+      char next_byte[3];  // 2 hex chars + null
       for (uint8_t i = 0; i < data.length - 1; i++) {
-        sprintf(next_byte, "%02X", raw[4 + i]);
+        buf_append_printf(next_byte, sizeof(next_byte), 0, "%02X", raw[4 + i]);
         data.code += next_byte;
       }
 
@@ -90,10 +91,10 @@ bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
 
       uint8_t buckets = raw[2] << 1;
       std::string str;
-      char next_byte[3];
+      char next_byte[3];  // 2 hex chars + null
 
       for (uint32_t i = 0; i <= at; i++) {
-        sprintf(next_byte, "%02X", raw[i]);
+        buf_append_printf(next_byte, sizeof(next_byte), 0, "%02X", raw[i]);
         str += next_byte;
         if ((i > 3) && buckets) {
           buckets--;

esphome/components/spi_led_strip/spi_led_strip.cpp

@@ -1,4 +1,5 @@
 #include "spi_led_strip.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace spi_led_strip {
@@ -47,15 +48,14 @@ void SpiLedStrip::dump_config() {
 void SpiLedStrip::write_state(light::LightState *state) {
   if (this->is_failed())
     return;
-  if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE) {
-    char strbuf[49];
-    size_t len = std::min(this->buffer_size_, (size_t) (sizeof(strbuf) - 1) / 3);
-    memset(strbuf, 0, sizeof(strbuf));
-    for (size_t i = 0; i != len; i++) {
-      sprintf(strbuf + i * 3, "%02X ", this->buf_[i]);
-    }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  {
+    char strbuf[49];  // format_hex_pretty_size(16) = 48, fits 16 bytes
+    size_t len = std::min(this->buffer_size_, (size_t) 16);
+    format_hex_pretty_to(strbuf, sizeof(strbuf), this->buf_, len, ' ');
     esph_log_v(TAG, "write_state: buf = %s", strbuf);
   }
+#endif
   this->enable();
   this->write_array(this->buf_, this->buffer_size_);
   this->disable();

esphome/components/sun/text_sensor/sun_text_sensor.h

@@ -14,9 +14,7 @@ class SunTextSensor : public text_sensor::TextSensor, public PollingComponent {
   void set_parent(Sun *parent) { parent_ = parent; }
   void set_elevation(double elevation) { elevation_ = elevation; }
   void set_sunrise(bool sunrise) { sunrise_ = sunrise; }
-  void set_format(const char *format) { this->format_ = format; }
-  /// Prevent accidental use of std::string which would dangle
-  void set_format(const std::string &format) = delete;
+  void set_format(const std::string &format) { format_ = format; }
 
   void update() override {
     optional<ESPTime> res;
@@ -31,14 +29,14 @@ class SunTextSensor : public text_sensor::TextSensor, public PollingComponent {
     }
 
     char buf[ESPTime::STRFTIME_BUFFER_SIZE];
-    size_t len = res->strftime_to(buf, this->format_);
+    size_t len = res->strftime_to(buf, this->format_.c_str());
     this->publish_state(buf, len);
   }
 
   void dump_config() override;
 
  protected:
-  const char *format_{nullptr};
+  std::string format_{};
   Sun *parent_;
   double elevation_;
   bool sunrise_;

esphome/components/template/alarm_control_panel/__init__.py

@@ -118,7 +118,8 @@ async def to_code(config):
     var = await alarm_control_panel.new_alarm_control_panel(config)
     await cg.register_component(var, config)
     if CONF_CODES in config:
-        cg.add(var.set_codes(config[CONF_CODES]))
+        for acode in config[CONF_CODES]:
+            cg.add(var.add_code(acode))
         if CONF_REQUIRES_CODE_TO_ARM in config:
             cg.add(var.set_requires_code_to_arm(config[CONF_REQUIRES_CODE_TO_ARM]))
 

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -206,13 +206,7 @@ bool TemplateAlarmControlPanel::is_code_valid_(optional<std::string> code) {
   if (!this->codes_.empty()) {
     if (code.has_value()) {
       ESP_LOGVV(TAG, "Checking code: %s", code.value().c_str());
-      // Use strcmp for const char* comparison
-      const char *code_cstr = code.value().c_str();
-      for (const char *stored_code : this->codes_) {
-        if (strcmp(stored_code, code_cstr) == 0)
-          return true;
-      }
-      return false;
+      return (std::count(this->codes_.begin(), this->codes_.end(), code.value()) == 1);
     }
     ESP_LOGD(TAG, "No code provided");
     return false;

esphome/components/template/alarm_control_panel/template_alarm_control_panel.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <cinttypes>
-#include <cstring>
 #include <vector>
 
 #include "esphome/core/automation.h"
@@ -87,14 +86,11 @@ class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControl
                   AlarmSensorType type = ALARM_SENSOR_TYPE_DELAYED);
 #endif
 
-  /** Set the codes (from initializer list).
+  /** add a code
    *
-   * @param codes The list of valid codes
+   * @param code The code
    */
-  void set_codes(std::initializer_list<const char *> codes) { this->codes_ = codes; }
-
-  // Deleted overload to catch incorrect std::string usage at compile time
-  void set_codes(std::initializer_list<std::string> codes) = delete;
+  void add_code(const std::string &code) { this->codes_.push_back(code); }
 
   /** set requires a code to arm
    *
@@ -159,8 +155,8 @@ class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControl
   uint32_t pending_time_;
   // the time in trigger
   uint32_t trigger_time_;
-  // a list of codes (const char* pointers to string literals in flash)
-  FixedVector<const char *> codes_;
+  // a list of codes
+  std::vector<std::string> codes_;
   // requires a code to arm
   bool requires_code_to_arm_ = false;
   bool supports_arm_home_ = false;

esphome/components/template/text/template_text.cpp

@@ -8,23 +8,16 @@ static const char *const TAG = "template.text";
 void TemplateText::setup() {
   if (this->f_.has_value())
     return;
-
-  if (this->pref_ == nullptr) {
-    // No restore - use const char* directly, no heap allocation needed
-    if (this->initial_value_ != nullptr && this->initial_value_[0] != '\0') {
-      ESP_LOGD(TAG, "State from initial: %s", this->initial_value_);
-      this->publish_state(this->initial_value_);
-    }
-    return;
+  std::string value = this->initial_value_;
+  if (!this->pref_) {
+    ESP_LOGD(TAG, "State from initial: %s", value.c_str());
+  } else {
+    uint32_t key = this->get_preference_hash();
+    key += this->traits.get_min_length() << 2;
+    key += this->traits.get_max_length() << 4;
+    key += fnv1_hash(this->traits.get_pattern_c_str()) << 6;
+    this->pref_->setup(key, value);
   }
-
-  // Need std::string for pref_->setup() to fill from flash
-  std::string value{this->initial_value_ != nullptr ? this->initial_value_ : ""};
-  uint32_t key = this->get_preference_hash();
-  key += this->traits.get_min_length() << 2;
-  key += this->traits.get_max_length() << 4;
-  key += fnv1_hash(this->traits.get_pattern_c_str()) << 6;
-  this->pref_->setup(key, value);
   if (!value.empty())
     this->publish_state(value);
 }

esphome/components/template/text/template_text.h

@@ -70,15 +70,13 @@ class TemplateText final : public text::Text, public PollingComponent {
 
   Trigger<std::string> *get_set_trigger() const { return this->set_trigger_; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
-  void set_initial_value(const char *initial_value) { this->initial_value_ = initial_value; }
-  /// Prevent accidental use of std::string which would dangle
-  void set_initial_value(const std::string &initial_value) = delete;
+  void set_initial_value(const std::string &initial_value) { this->initial_value_ = initial_value; }
   void set_value_saver(TemplateTextSaverBase *restore_value_saver) { this->pref_ = restore_value_saver; }
 
  protected:
   void control(const std::string &value) override;
   bool optimistic_ = false;
-  const char *initial_value_{nullptr};
+  std::string initial_value_;
   Trigger<std::string> *set_trigger_ = new Trigger<std::string>();
   TemplateLambda<std::string> f_{};
 

esphome/components/udp/__init__.py

@@ -108,7 +108,8 @@ async def to_code(config):
         cg.add(var.set_broadcast_port(conf_port[CONF_BROADCAST_PORT]))
     if (listen_address := str(config[CONF_LISTEN_ADDRESS])) != "255.255.255.255":
         cg.add(var.set_listen_address(listen_address))
-    cg.add(var.set_addresses([str(addr) for addr in config[CONF_ADDRESSES]]))
+    for address in config[CONF_ADDRESSES]:
+        cg.add(var.add_address(str(address)))
     if on_receive := config.get(CONF_ON_RECEIVE):
         on_receive = on_receive[0]
         trigger = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])

esphome/components/udp/udp_component.cpp

@@ -5,7 +5,8 @@
 #include "esphome/components/network/util.h"
 #include "udp_component.h"
 
-namespace esphome::udp {
+namespace esphome {
+namespace udp {
 
 static const char *const TAG = "udp";
 
@@ -94,7 +95,7 @@ void UDPComponent::setup() {
   // 8266 and RP2040 `Duino
   for (const auto &address : this->addresses_) {
     auto ipaddr = IPAddress();
-    ipaddr.fromString(address);
+    ipaddr.fromString(address.c_str());
     this->ipaddrs_.push_back(ipaddr);
   }
   if (this->should_listen_)
@@ -129,8 +130,8 @@ void UDPComponent::dump_config() {
                 "  Listen Port: %u\n"
                 "  Broadcast Port: %u",
                 this->listen_port_, this->broadcast_port_);
-  for (const char *address : this->addresses_)
-    ESP_LOGCONFIG(TAG, "  Address: %s", address);
+  for (const auto &address : this->addresses_)
+    ESP_LOGCONFIG(TAG, "  Address: %s", address.c_str());
   if (this->listen_address_.has_value()) {
     char addr_buf[network::IP_ADDRESS_BUFFER_SIZE];
     ESP_LOGCONFIG(TAG, "  Listen address: %s", this->listen_address_.value().str_to(addr_buf));
@@ -161,6 +162,7 @@ void UDPComponent::send_packet(const uint8_t *data, size_t size) {
   }
 #endif
 }
-}  // namespace esphome::udp
+}  // namespace udp
+}  // namespace esphome
 
 #endif

esphome/components/udp/udp_component.h

@@ -2,7 +2,6 @@
 
 #include "esphome/core/defines.h"
 #ifdef USE_NETWORK
-#include "esphome/core/helpers.h"
 #include "esphome/components/network/ip_address.h"
 #if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
 #include "esphome/components/socket/socket.h"
@@ -10,17 +9,15 @@
 #ifdef USE_SOCKET_IMPL_LWIP_TCP
 #include <WiFiUdp.h>
 #endif
-#include <initializer_list>
 #include <vector>
 
-namespace esphome::udp {
+namespace esphome {
+namespace udp {
 
 static const size_t MAX_PACKET_SIZE = 508;
 class UDPComponent : public Component {
  public:
-  void set_addresses(std::initializer_list<const char *> addresses) { this->addresses_ = addresses; }
-  /// Prevent accidental use of std::string which would dangle
-  void set_addresses(std::initializer_list<std::string> addresses) = delete;
+  void add_address(const char *addr) { this->addresses_.emplace_back(addr); }
   void set_listen_address(const char *listen_addr) { this->listen_address_ = network::IPAddress(listen_addr); }
   void set_listen_port(uint16_t port) { this->listen_port_ = port; }
   void set_broadcast_port(uint16_t port) { this->broadcast_port_ = port; }
@@ -52,10 +49,11 @@ class UDPComponent : public Component {
   std::vector<IPAddress> ipaddrs_{};
   WiFiUDP udp_client_{};
 #endif
-  FixedVector<const char *> addresses_{};
+  std::vector<std::string> addresses_{};
 
   optional<network::IPAddress> listen_address_{};
 };
 
-}  // namespace esphome::udp
+}  // namespace udp
+}  // namespace esphome
 #endif

esphome/components/web_server/list_entities.cpp

@@ -143,7 +143,7 @@ bool ListEntitiesIterator::on_water_heater(water_heater::WaterHeater *obj) {
 
 #ifdef USE_INFRARED
 bool ListEntitiesIterator::on_infrared(infrared::Infrared *obj) {
-  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::infrared_all_json_generator);
+  // Infrared web_server support not yet implemented - this stub acknowledges the entity
   return true;
 }
 #endif

esphome/components/web_server/web_server.cpp

@@ -33,10 +33,6 @@
 #include "esphome/components/water_heater/water_heater.h"
 #endif
 
-#ifdef USE_INFRARED
-#include "esphome/components/infrared/infrared.h"
-#endif
-
 #ifdef USE_WEBSERVER_LOCAL
 #if USE_WEBSERVER_VERSION == 2
 #include "server_index_v2.h"
@@ -662,24 +658,6 @@ std::string WebServer::text_sensor_json_(text_sensor::TextSensor *obj, const std
 #endif
 
 #ifdef USE_SWITCH
-enum SwitchAction : uint8_t { SWITCH_ACTION_NONE, SWITCH_ACTION_TOGGLE, SWITCH_ACTION_TURN_ON, SWITCH_ACTION_TURN_OFF };
-
-static void execute_switch_action(switch_::Switch *obj, SwitchAction action) {
-  switch (action) {
-    case SWITCH_ACTION_TOGGLE:
-      obj->toggle();
-      break;
-    case SWITCH_ACTION_TURN_ON:
-      obj->turn_on();
-      break;
-    case SWITCH_ACTION_TURN_OFF:
-      obj->turn_off();
-      break;
-    default:
-      break;
-  }
-}
-
 void WebServer::on_switch_update(switch_::Switch *obj) {
   if (!this->include_internal_ && obj->is_internal())
     return;
@@ -698,22 +676,34 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
       return;
     }
 
-    SwitchAction action = SWITCH_ACTION_NONE;
+    // Handle action methods with single defer and response
+    enum SwitchAction { NONE, TOGGLE, TURN_ON, TURN_OFF };
+    SwitchAction action = NONE;
 
     if (match.method_equals(ESPHOME_F("toggle"))) {
-      action = SWITCH_ACTION_TOGGLE;
+      action = TOGGLE;
     } else if (match.method_equals(ESPHOME_F("turn_on"))) {
-      action = SWITCH_ACTION_TURN_ON;
+      action = TURN_ON;
     } else if (match.method_equals(ESPHOME_F("turn_off"))) {
-      action = SWITCH_ACTION_TURN_OFF;
+      action = TURN_OFF;
     }
 
-    if (action != SWITCH_ACTION_NONE) {
-#ifdef USE_ESP8266
-      execute_switch_action(obj, action);
-#else
-      this->defer([obj, action]() { execute_switch_action(obj, action); });
-#endif
+    if (action != NONE) {
+      this->defer([obj, action]() {
+        switch (action) {
+          case TOGGLE:
+            obj->toggle();
+            break;
+          case TURN_ON:
+            obj->turn_on();
+            break;
+          case TURN_OFF:
+            obj->turn_off();
+            break;
+          default:
+            break;
+        }
+      });
       request->send(200);
     } else {
       request->send(404);
@@ -753,7 +743,7 @@ void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlM
       std::string data = this->button_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("press"))) {
-      DEFER_ACTION(obj, obj->press());
+      this->defer([obj]() { obj->press(); });
       request->send(200);
       return;
     } else {
@@ -838,7 +828,7 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
       std::string data = this->fan_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("toggle"))) {
-      DEFER_ACTION(obj, obj->toggle().perform());
+      this->defer([obj]() { obj->toggle().perform(); });
       request->send(200);
     } else {
       bool is_on = match.method_equals(ESPHOME_F("turn_on"));
@@ -869,7 +859,7 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
             return;
         }
       }
-      DEFER_ACTION(call, call.perform());
+      this->defer([call]() mutable { call.perform(); });
       request->send(200);
     }
     return;
@@ -919,7 +909,7 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
       std::string data = this->light_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("toggle"))) {
-      DEFER_ACTION(obj, obj->toggle().perform());
+      this->defer([obj]() { obj->toggle().perform(); });
       request->send(200);
     } else {
       bool is_on = match.method_equals(ESPHOME_F("turn_on"));
@@ -948,7 +938,7 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
         parse_string_param_(request, ESPHOME_F("effect"), call, &decltype(call)::set_effect);
       }
 
-      DEFER_ACTION(call, call.perform());
+      this->defer([call]() mutable { call.perform(); });
       request->send(200);
     }
     return;
@@ -1037,7 +1027,7 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
     parse_float_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
     parse_float_param_(request, ESPHOME_F("tilt"), call, &decltype(call)::set_tilt);
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1096,7 +1086,7 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
     auto call = obj->make_call();
     parse_float_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_value);
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1169,7 +1159,7 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
 
     parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_date);
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1233,7 +1223,7 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
 
     parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_time);
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1296,7 +1286,7 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
 
     parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_datetime);
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1356,7 +1346,7 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
     auto call = obj->make_call();
     parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_value);
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1414,7 +1404,7 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
     auto call = obj->make_call();
     parse_string_param_(request, ESPHOME_F("option"), call, &decltype(call)::set_option);
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1483,7 +1473,7 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
     parse_float_param_(request, ESPHOME_F("target_temperature_low"), call, &decltype(call)::set_target_temperature_low);
     parse_float_param_(request, ESPHOME_F("target_temperature"), call, &decltype(call)::set_target_temperature);
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1599,24 +1589,6 @@ std::string WebServer::climate_json_(climate::Climate *obj, JsonDetail start_con
 #endif
 
 #ifdef USE_LOCK
-enum LockAction : uint8_t { LOCK_ACTION_NONE, LOCK_ACTION_LOCK, LOCK_ACTION_UNLOCK, LOCK_ACTION_OPEN };
-
-static void execute_lock_action(lock::Lock *obj, LockAction action) {
-  switch (action) {
-    case LOCK_ACTION_LOCK:
-      obj->lock();
-      break;
-    case LOCK_ACTION_UNLOCK:
-      obj->unlock();
-      break;
-    case LOCK_ACTION_OPEN:
-      obj->open();
-      break;
-    default:
-      break;
-  }
-}
-
 void WebServer::on_lock_update(lock::Lock *obj) {
   if (!this->include_internal_ && obj->is_internal())
     return;
@@ -1635,22 +1607,34 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
       return;
     }
 
-    LockAction action = LOCK_ACTION_NONE;
+    // Handle action methods with single defer and response
+    enum LockAction { NONE, LOCK, UNLOCK, OPEN };
+    LockAction action = NONE;
 
     if (match.method_equals(ESPHOME_F("lock"))) {
-      action = LOCK_ACTION_LOCK;
+      action = LOCK;
     } else if (match.method_equals(ESPHOME_F("unlock"))) {
-      action = LOCK_ACTION_UNLOCK;
+      action = UNLOCK;
     } else if (match.method_equals(ESPHOME_F("open"))) {
-      action = LOCK_ACTION_OPEN;
+      action = OPEN;
     }
 
-    if (action != LOCK_ACTION_NONE) {
-#ifdef USE_ESP8266
-      execute_lock_action(obj, action);
-#else
-      this->defer([obj, action]() { execute_lock_action(obj, action); });
-#endif
+    if (action != NONE) {
+      this->defer([obj, action]() {
+        switch (action) {
+          case LOCK:
+            obj->lock();
+            break;
+          case UNLOCK:
+            obj->unlock();
+            break;
+          case OPEN:
+            obj->open();
+            break;
+          default:
+            break;
+        }
+      });
       request->send(200);
     } else {
       request->send(404);
@@ -1733,7 +1717,7 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
 
     parse_float_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1812,7 +1796,7 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
       return;
     }
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1888,7 +1872,7 @@ void WebServer::handle_water_heater_request(AsyncWebServerRequest *request, cons
     // Parse on/off parameter
     parse_bool_param_(request, ESPHOME_F("is_on"), base_call, &water_heater::WaterHeaterCall::set_on);
 
-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
     request->send(200);
     return;
   }
@@ -1956,110 +1940,6 @@ std::string WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDe
 }
 #endif
 
-#ifdef USE_INFRARED
-void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const UrlMatch &match) {
-  for (infrared::Infrared *obj : App.get_infrareds()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
-      continue;
-
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
-      auto detail = get_request_detail(request);
-      std::string data = this->infrared_json_(obj, detail);
-      request->send(200, ESPHOME_F("application/json"), data.c_str());
-      return;
-    }
-    if (!match.method_equals(ESPHOME_F("transmit"))) {
-      request->send(404);
-      return;
-    }
-
-    // Only allow transmit if the device supports it
-    if (!obj->has_transmitter()) {
-      request->send(400, ESPHOME_F("text/plain"), "Device does not support transmission");
-      return;
-    }
-
-    // Parse parameters
-    auto call = obj->make_call();
-
-    // Parse carrier frequency (optional)
-    if (request->hasParam(ESPHOME_F("carrier_frequency"))) {
-      auto value = parse_number<uint32_t>(request->getParam(ESPHOME_F("carrier_frequency"))->value().c_str());
-      if (value.has_value()) {
-        call.set_carrier_frequency(*value);
-      }
-    }
-
-    // Parse repeat count (optional, defaults to 1)
-    if (request->hasParam(ESPHOME_F("repeat_count"))) {
-      auto value = parse_number<uint32_t>(request->getParam(ESPHOME_F("repeat_count"))->value().c_str());
-      if (value.has_value()) {
-        call.set_repeat_count(*value);
-      }
-    }
-
-    // Parse base64url-encoded raw timings (required)
-    // Base64url is URL-safe: uses A-Za-z0-9-_ (no special characters needing escaping)
-    if (!request->hasParam(ESPHOME_F("data"))) {
-      request->send(400, ESPHOME_F("text/plain"), "Missing 'data' parameter");
-      return;
-    }
-
-    // .c_str() is required for Arduino framework where value() returns Arduino String instead of std::string
-    std::string encoded =
-        request->getParam(ESPHOME_F("data"))->value().c_str();  // NOLINT(readability-redundant-string-cstr)
-
-    // Validate base64url is not empty
-    if (encoded.empty()) {
-      request->send(400, ESPHOME_F("text/plain"), "Empty 'data' parameter");
-      return;
-    }
-
-#ifdef USE_ESP8266
-    // ESP8266 is single-threaded, call directly
-    call.set_raw_timings_base64url(encoded);
-    call.perform();
-#else
-    // Defer to main loop for thread safety. Move encoded string into lambda to ensure
-    // it outlives the call - set_raw_timings_base64url stores a pointer, so the string
-    // must remain valid until perform() completes.
-    this->defer([call, encoded = std::move(encoded)]() mutable {
-      call.set_raw_timings_base64url(encoded);
-      call.perform();
-    });
-#endif
-
-    request->send(200);
-    return;
-  }
-  request->send(404);
-}
-
-std::string WebServer::infrared_all_json_generator(WebServer *web_server, void *source) {
-  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  return web_server->infrared_json_(static_cast<infrared::Infrared *>(source), DETAIL_ALL);
-}
-
-std::string WebServer::infrared_json_(infrared::Infrared *obj, JsonDetail start_config) {
-  json::JsonBuilder builder;
-  JsonObject root = builder.root();
-
-  set_json_icon_state_value(root, obj, "infrared", "", 0, start_config);
-
-  auto traits = obj->get_traits();
-
-  root[ESPHOME_F("supports_transmitter")] = traits.get_supports_transmitter();
-  root[ESPHOME_F("supports_receiver")] = traits.get_supports_receiver();
-
-  if (start_config == DETAIL_ALL) {
-    this->add_sorting_info_(root, obj);
-  }
-
-  return builder.serialize();
-}
-#endif
-
 #ifdef USE_EVENT
 void WebServer::on_event(event::Event *obj) {
   if (!this->include_internal_ && obj->is_internal())
@@ -2152,7 +2032,7 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
       return;
     }
 
-    DEFER_ACTION(obj, obj->perform());
+    this->defer([obj]() mutable { obj->perform(); });
     request->send(200);
     return;
   }
@@ -2191,21 +2071,24 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   const auto &url = request->url();
   const auto method = request->method();
 
-  // Static URL checks - use ESPHOME_F to keep strings in flash on ESP8266
-  if (url == ESPHOME_F("/"))
-    return true;
+  // Static URL checks
+  static const char *const STATIC_URLS[] = {
+    "/",
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
-  if (url == ESPHOME_F("/events"))
-    return true;
+    "/events",
 #endif
 #ifdef USE_WEBSERVER_CSS_INCLUDE
-  if (url == ESPHOME_F("/0.css"))
-    return true;
+    "/0.css",
 #endif
 #ifdef USE_WEBSERVER_JS_INCLUDE
-  if (url == ESPHOME_F("/0.js"))
-    return true;
+    "/0.js",
 #endif
+  };
+
+  for (const auto &static_url : STATIC_URLS) {
+    if (url == static_url)
+      return true;
+  }
 
 #ifdef USE_WEBSERVER_PRIVATE_NETWORK_ACCESS
   if (method == HTTP_OPTIONS && request->hasHeader(ESPHOME_F("Access-Control-Request-Private-Network")))
@@ -2225,100 +2108,90 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   if (!is_get_or_post)
     return false;
 
-  // Check GET-only domains - use ESPHOME_F to keep strings in flash on ESP8266
-  if (is_get) {
+  // Use lookup tables for domain checks
+  static const char *const GET_ONLY_DOMAINS[] = {
 #ifdef USE_SENSOR
-    if (match.domain_equals(ESPHOME_F("sensor")))
-      return true;
+      "sensor",
 #endif
 #ifdef USE_BINARY_SENSOR
-    if (match.domain_equals(ESPHOME_F("binary_sensor")))
-      return true;
+      "binary_sensor",
 #endif
 #ifdef USE_TEXT_SENSOR
-    if (match.domain_equals(ESPHOME_F("text_sensor")))
-      return true;
+      "text_sensor",
 #endif
 #ifdef USE_EVENT
-    if (match.domain_equals(ESPHOME_F("event")))
-      return true;
+      "event",
 #endif
+  };
+
+  static const char *const GET_POST_DOMAINS[] = {
+#ifdef USE_SWITCH
+      "switch",
+#endif
+#ifdef USE_BUTTON
+      "button",
+#endif
+#ifdef USE_FAN
+      "fan",
+#endif
+#ifdef USE_LIGHT
+      "light",
+#endif
+#ifdef USE_COVER
+      "cover",
+#endif
+#ifdef USE_NUMBER
+      "number",
+#endif
+#ifdef USE_DATETIME_DATE
+      "date",
+#endif
+#ifdef USE_DATETIME_TIME
+      "time",
+#endif
+#ifdef USE_DATETIME_DATETIME
+      "datetime",
+#endif
+#ifdef USE_TEXT
+      "text",
+#endif
+#ifdef USE_SELECT
+      "select",
+#endif
+#ifdef USE_CLIMATE
+      "climate",
+#endif
+#ifdef USE_LOCK
+      "lock",
+#endif
+#ifdef USE_VALVE
+      "valve",
+#endif
+#ifdef USE_ALARM_CONTROL_PANEL
+      "alarm_control_panel",
+#endif
+#ifdef USE_UPDATE
+      "update",
+#endif
+#ifdef USE_WATER_HEATER
+      "water_heater",
+#endif
+  };
+
+  // Check GET-only domains
+  if (is_get) {
+    for (const auto &domain : GET_ONLY_DOMAINS) {
+      if (match.domain_equals(domain))
+        return true;
+    }
   }
 
   // Check GET+POST domains
   if (is_get_or_post) {
-#ifdef USE_SWITCH
-    if (match.domain_equals(ESPHOME_F("switch")))
-      return true;
-#endif
-#ifdef USE_BUTTON
-    if (match.domain_equals(ESPHOME_F("button")))
-      return true;
-#endif
-#ifdef USE_FAN
-    if (match.domain_equals(ESPHOME_F("fan")))
-      return true;
-#endif
-#ifdef USE_LIGHT
-    if (match.domain_equals(ESPHOME_F("light")))
-      return true;
-#endif
-#ifdef USE_COVER
-    if (match.domain_equals(ESPHOME_F("cover")))
-      return true;
-#endif
-#ifdef USE_NUMBER
-    if (match.domain_equals(ESPHOME_F("number")))
-      return true;
-#endif
-#ifdef USE_DATETIME_DATE
-    if (match.domain_equals(ESPHOME_F("date")))
-      return true;
-#endif
-#ifdef USE_DATETIME_TIME
-    if (match.domain_equals(ESPHOME_F("time")))
-      return true;
-#endif
-#ifdef USE_DATETIME_DATETIME
-    if (match.domain_equals(ESPHOME_F("datetime")))
-      return true;
-#endif
-#ifdef USE_TEXT
-    if (match.domain_equals(ESPHOME_F("text")))
-      return true;
-#endif
-#ifdef USE_SELECT
-    if (match.domain_equals(ESPHOME_F("select")))
-      return true;
-#endif
-#ifdef USE_CLIMATE
-    if (match.domain_equals(ESPHOME_F("climate")))
-      return true;
-#endif
-#ifdef USE_LOCK
-    if (match.domain_equals(ESPHOME_F("lock")))
-      return true;
-#endif
-#ifdef USE_VALVE
-    if (match.domain_equals(ESPHOME_F("valve")))
-      return true;
-#endif
-#ifdef USE_ALARM_CONTROL_PANEL
-    if (match.domain_equals(ESPHOME_F("alarm_control_panel")))
-      return true;
-#endif
-#ifdef USE_UPDATE
-    if (match.domain_equals(ESPHOME_F("update")))
-      return true;
-#endif
-#ifdef USE_WATER_HEATER
-    if (match.domain_equals(ESPHOME_F("water_heater")))
-      return true;
-#endif
-#ifdef USE_INFRARED
-    if (match.domain_equals(ESPHOME_F("infrared")))
-      return true;
-#endif
+    for (const auto &domain : GET_POST_DOMAINS) {
+      if (match.domain_equals(domain))
+        return true;
+    }
   }
 
   return false;
@@ -2467,11 +2340,6 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {
   else if (match.domain_equals(ESPHOME_F("water_heater"))) {
     this->handle_water_heater_request(request, match);
   }
-#endif
-#ifdef USE_INFRARED
-  else if (match.domain_equals(ESPHOME_F("infrared"))) {
-    this->handle_infrared_request(request, match);
-  }
 #endif
   else {
     // No matching handler found - send 404

esphome/components/web_server/web_server.h

@@ -42,14 +42,6 @@ using ParamNameType = const __FlashStringHelper *;
 using ParamNameType = const char *;
 #endif
 
-// ESP8266 is single-threaded, so actions can execute directly in request context.
-// Multi-core platforms need to defer to main loop thread for thread safety.
-#ifdef USE_ESP8266
-#define DEFER_ACTION(capture, action) action
-#else
-#define DEFER_ACTION(capture, action) this->defer([capture]() mutable { action; })
-#endif
-
 /// Result of matching a URL against an entity
 struct EntityMatchResult {
   bool matched;          ///< True if entity matched the URL
@@ -460,13 +452,6 @@ class WebServer : public Controller,
   static std::string water_heater_all_json_generator(WebServer *web_server, void *source);
 #endif
 
-#ifdef USE_INFRARED
-  /// Handle an infrared request under '/infrared/<id>/transmit'.
-  void handle_infrared_request(AsyncWebServerRequest *request, const UrlMatch &match);
-
-  static std::string infrared_all_json_generator(WebServer *web_server, void *source);
-#endif
-
 #ifdef USE_EVENT
   void on_event(event::Event *obj) override;
 
@@ -669,9 +654,6 @@ class WebServer : public Controller,
 #ifdef USE_WATER_HEATER
   std::string water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config);
 #endif
-#ifdef USE_INFRARED
-  std::string infrared_json_(infrared::Infrared *obj, JsonDetail start_config);
-#endif
 #ifdef USE_UPDATE
   std::string update_json_(update::UpdateEntity *obj, JsonDetail start_config);
 #endif

esphome/components/weikai/weikai.cpp

@@ -4,13 +4,19 @@
 /// @details The classes declared in this file can be used by the Weikai family
 
 #include "weikai.h"
-#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace weikai {
 
 static const char *const TAG = "weikai";
 
+/// @brief convert an int to binary representation as C++ std::string
+/// @param val integer to convert
+/// @return a std::string
+inline std::string i2s(uint8_t val) { return std::bitset<8>(val).to_string(); }
+/// Convert std::string to C string
+#define I2S2CS(val) (i2s(val).c_str())
+
 /// @brief measure the time elapsed between two calls
 /// @param last_time time of the previous call
 /// @return the elapsed time in milliseconds
@@ -164,18 +170,17 @@ void WeikaiComponent::test_gpio_input_() {
   static bool init_input{false};
   static uint8_t state{0};
   uint8_t value;
-  char bin_buf[9];  // 8 binary digits + null
   if (!init_input) {
     init_input = true;
     // set all pins in input mode
     this->reg(WKREG_GPDIR, 0) = 0x00;
     ESP_LOGI(TAG, "initializing all pins to input mode");
     state = this->reg(WKREG_GPDAT, 0);
-    ESP_LOGI(TAG, "initial input data state = %02X (%s)", state, format_bin_to(bin_buf, state));
+    ESP_LOGI(TAG, "initial input data state = %02X (%s)", state, I2S2CS(state));
   }
   value = this->reg(WKREG_GPDAT, 0);
   if (value != state) {
-    ESP_LOGI(TAG, "Input data changed from %02X to %02X (%s)", state, value, format_bin_to(bin_buf, value));
+    ESP_LOGI(TAG, "Input data changed from %02X to %02X (%s)", state, value, I2S2CS(value));
     state = value;
   }
 }
@@ -183,7 +188,6 @@ void WeikaiComponent::test_gpio_input_() {
 void WeikaiComponent::test_gpio_output_() {
   static bool init_output{false};
   static uint8_t state{0};
-  char bin_buf[9];  // 8 binary digits + null
   if (!init_output) {
     init_output = true;
     // set all pins in output mode
@@ -194,7 +198,7 @@ void WeikaiComponent::test_gpio_output_() {
   }
   state = ~state;
   this->reg(WKREG_GPDAT, 0) = state;
-  ESP_LOGI(TAG, "Flipping all outputs to %02X (%s)", state, format_bin_to(bin_buf, state));
+  ESP_LOGI(TAG, "Flipping all outputs to %02X (%s)", state, I2S2CS(state));
   delay(100);  // NOLINT
 }
 #endif
@@ -204,9 +208,7 @@ void WeikaiComponent::test_gpio_output_() {
 ///////////////////////////////////////////////////////////////////////////////
 bool WeikaiComponent::read_pin_val_(uint8_t pin) {
   this->input_state_ = this->reg(WKREG_GPDAT, 0);
-  char bin_buf[9];
-  ESP_LOGVV(TAG, "reading input pin %u = %u in_state %s", pin, this->input_state_ & (1 << pin),
-            format_bin_to(bin_buf, this->input_state_));
+  ESP_LOGVV(TAG, "reading input pin %u = %u in_state %s", pin, this->input_state_ & (1 << pin), I2S2CS(input_state_));
   return this->input_state_ & (1 << pin);
 }
 
@@ -216,9 +218,7 @@ void WeikaiComponent::write_pin_val_(uint8_t pin, bool value) {
   } else {
     this->output_state_ &= ~(1 << pin);
   }
-  char bin_buf[9];
-  ESP_LOGVV(TAG, "writing output pin %d with %d out_state %s", pin, uint8_t(value),
-            format_bin_to(bin_buf, this->output_state_));
+  ESP_LOGVV(TAG, "writing output pin %d with %d out_state %s", pin, uint8_t(value), I2S2CS(this->output_state_));
   this->reg(WKREG_GPDAT, 0) = this->output_state_;
 }
 
@@ -232,8 +232,7 @@ void WeikaiComponent::set_pin_direction_(uint8_t pin, gpio::Flags flags) {
       ESP_LOGE(TAG, "pin %d direction invalid", pin);
     }
   }
-  char bin_buf[9];
-  ESP_LOGVV(TAG, "setting pin %d direction to %d pin_config=%s", pin, flags, format_bin_to(bin_buf, this->pin_config_));
+  ESP_LOGVV(TAG, "setting pin %d direction to %d pin_config=%s", pin, flags, I2S2CS(this->pin_config_));
   this->reg(WKREG_GPDIR, 0) = this->pin_config_;  // TODO check ~
 }
 
@@ -242,6 +241,7 @@ void WeikaiGPIOPin::setup() {
                 flags_ == gpio::FLAG_INPUT          ? "Input"
                 : this->flags_ == gpio::FLAG_OUTPUT ? "Output"
                                                     : "NOT SPECIFIED");
+  // ESP_LOGCONFIG(TAG, "Setting GPIO pins mode to '%s' %02X", I2S2CS(this->flags_), this->flags_);
   this->pin_mode(this->flags_);
 }
 
@@ -297,9 +297,8 @@ void WeikaiChannel::set_line_param_() {
       break;  // no parity 000x
   }
   this->reg(WKREG_LCR) = lcr;  // write LCR
-  char bin_buf[9];
   ESP_LOGV(TAG, "    line config: %d data_bits, %d stop_bits, parity %s register [%s]", this->data_bits_,
-           this->stop_bits_, p2s(this->parity_), format_bin_to(bin_buf, lcr));
+           this->stop_bits_, p2s(this->parity_), I2S2CS(lcr));
 }
 
 void WeikaiChannel::set_baudrate_() {
@@ -335,8 +334,7 @@ size_t WeikaiChannel::tx_in_fifo_() {
   if (tfcnt == 0) {
     uint8_t const fsr = this->reg(WKREG_FSR);
     if (fsr & FSR_TFFULL) {
-      char bin_buf[9];
-      ESP_LOGVV(TAG, "tx FIFO full FSR=%s", format_bin_to(bin_buf, fsr));
+      ESP_LOGVV(TAG, "tx FIFO full FSR=%s", I2S2CS(fsr));
       tfcnt = FIFO_SIZE;
     }
   }
@@ -348,15 +346,14 @@ size_t WeikaiChannel::rx_in_fifo_() {
   size_t available = this->reg(WKREG_RFCNT);
   uint8_t const fsr = this->reg(WKREG_FSR);
   if (fsr & (FSR_RFOE | FSR_RFLB | FSR_RFFE | FSR_RFPE)) {
-    char bin_buf[9];
     if (fsr & FSR_RFOE)
-      ESP_LOGE(TAG, "Receive data overflow FSR=%s", format_bin_to(bin_buf, fsr));
+      ESP_LOGE(TAG, "Receive data overflow FSR=%s", I2S2CS(fsr));
     if (fsr & FSR_RFLB)
-      ESP_LOGE(TAG, "Receive line break FSR=%s", format_bin_to(bin_buf, fsr));
+      ESP_LOGE(TAG, "Receive line break FSR=%s", I2S2CS(fsr));
     if (fsr & FSR_RFFE)
-      ESP_LOGE(TAG, "Receive frame error FSR=%s", format_bin_to(bin_buf, fsr));
+      ESP_LOGE(TAG, "Receive frame error FSR=%s", I2S2CS(fsr));
     if (fsr & FSR_RFPE)
-      ESP_LOGE(TAG, "Receive parity error FSR=%s", format_bin_to(bin_buf, fsr));
+      ESP_LOGE(TAG, "Receive parity error FSR=%s", I2S2CS(fsr));
   }
   if ((available == 0) && (fsr & FSR_RFDAT)) {
     // here we should be very careful because we can have something like this:
@@ -365,13 +362,11 @@ size_t WeikaiChannel::rx_in_fifo_() {
     // -  so to be sure we need to do another read of RFCNT and if it is still zero -> buffer full
     available = this->reg(WKREG_RFCNT);
     if (available == 0) {  // still zero ?
-      char bin_buf[9];
-      ESP_LOGV(TAG, "rx FIFO is full FSR=%s", format_bin_to(bin_buf, fsr));
+      ESP_LOGV(TAG, "rx FIFO is full FSR=%s", I2S2CS(fsr));
       available = FIFO_SIZE;
     }
   }
-  char bin_buf2[9];
-  ESP_LOGVV(TAG, "rx FIFO contain %d bytes - FSR status=%s", available, format_bin_to(bin_buf2, fsr));
+  ESP_LOGVV(TAG, "rx FIFO contain %d bytes - FSR status=%s", available, I2S2CS(fsr));
   return available;
 }
 

esphome/components/weikai/weikai.h

@@ -8,6 +8,7 @@
 ///                 wk2132_i2c, wk2168_i2c, wk2204_i2c, wk2212_i2c
 
 #pragma once
+#include <bitset>
 #include <memory>
 #include <cinttypes>
 #include "esphome/core/component.h"

esphome/components/weikai_spi/weikai_spi.cpp

@@ -10,6 +10,13 @@ namespace weikai_spi {
 using namespace weikai;
 static const char *const TAG = "weikai_spi";
 
+/// @brief convert an int to binary representation as C++ std::string
+/// @param val integer to convert
+/// @return a std::string
+inline std::string i2s(uint8_t val) { return std::bitset<8>(val).to_string(); }
+/// Convert std::string to C string
+#define I2S2CS(val) (i2s(val).c_str())
+
 /// @brief measure the time elapsed between two calls
 /// @param last_time time of the previous call
 /// @return the elapsed time in microseconds
@@ -100,8 +107,7 @@ uint8_t WeikaiRegisterSPI::read_reg() const {
   spi_comp->write_byte(cmd);
   uint8_t val = spi_comp->read_byte();
   spi_comp->disable();
-  char bin_buf[9];
-  ESP_LOGVV(TAG, "WeikaiRegisterSPI::read_reg() cmd=%s(%02X) reg=%s ch=%d buf=%02X", format_bin_to(bin_buf, cmd), cmd,
+  ESP_LOGVV(TAG, "WeikaiRegisterSPI::read_reg() cmd=%s(%02X) reg=%s ch=%d buf=%02X", I2S2CS(cmd), cmd,
             reg_to_str(this->register_, this->comp_->page1()), this->channel_, val);
   return val;
 }
@@ -114,9 +120,8 @@ void WeikaiRegisterSPI::read_fifo(uint8_t *data, size_t length) const {
   spi_comp->read_array(data, length);
   spi_comp->disable();
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
-  char bin_buf[9];
-  ESP_LOGVV(TAG, "WeikaiRegisterSPI::read_fifo() cmd=%s(%02X) ch=%d len=%d buffer", format_bin_to(bin_buf, cmd), cmd,
-            this->channel_, length);
+  ESP_LOGVV(TAG, "WeikaiRegisterSPI::read_fifo() cmd=%s(%02X) ch=%d len=%d buffer", I2S2CS(cmd), cmd, this->channel_,
+            length);
   print_buffer(data, length);
 #endif
 }
@@ -127,9 +132,8 @@ void WeikaiRegisterSPI::write_reg(uint8_t value) {
   spi_comp->enable();
   spi_comp->write_array(buf, 2);
   spi_comp->disable();
-  char bin_buf[9];
-  ESP_LOGVV(TAG, "WeikaiRegisterSPI::write_reg() cmd=%s(%02X) reg=%s ch=%d buf=%02X", format_bin_to(bin_buf, buf[0]),
-            buf[0], reg_to_str(this->register_, this->comp_->page1()), this->channel_, buf[1]);
+  ESP_LOGVV(TAG, "WeikaiRegisterSPI::write_reg() cmd=%s(%02X) reg=%s ch=%d buf=%02X", I2S2CS(buf[0]), buf[0],
+            reg_to_str(this->register_, this->comp_->page1()), this->channel_, buf[1]);
 }
 
 void WeikaiRegisterSPI::write_fifo(uint8_t *data, size_t length) {
@@ -141,9 +145,8 @@ void WeikaiRegisterSPI::write_fifo(uint8_t *data, size_t length) {
   spi_comp->disable();
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
-  char bin_buf[9];
-  ESP_LOGVV(TAG, "WeikaiRegisterSPI::write_fifo() cmd=%s(%02X) ch=%d len=%d buffer", format_bin_to(bin_buf, cmd), cmd,
-            this->channel_, length);
+  ESP_LOGVV(TAG, "WeikaiRegisterSPI::write_fifo() cmd=%s(%02X) ch=%d len=%d buffer", I2S2CS(cmd), cmd, this->channel_,
+            length);
   print_buffer(data, length);
 #endif
 }

esphome/components/weikai_spi/weikai_spi.h

@@ -6,6 +6,7 @@
 ///          wk2124_spi, wk2132_spi, wk2168_spi, wk2204_spi, wk2212_spi,
 
 #pragma once
+#include <bitset>
 #include <memory>
 #include "esphome/core/component.h"
 #include "esphome/components/uart/uart.h"

esphome/components/wireguard/__init__.py

@@ -30,7 +30,6 @@ _WG_KEY_REGEX = re.compile(r"^[A-Za-z0-9+/]{42}[AEIMQUYcgkosw480]=$")
 
 wireguard_ns = cg.esphome_ns.namespace("wireguard")
 Wireguard = wireguard_ns.class_("Wireguard", cg.Component, cg.PollingComponent)
-AllowedIP = wireguard_ns.struct("AllowedIP")
 WireguardPeerOnlineCondition = wireguard_ns.class_(
     "WireguardPeerOnlineCondition", automation.Condition
 )
@@ -109,18 +108,8 @@ async def to_code(config):
         )
     )
 
-    cg.add(
-        var.set_allowed_ips(
-            [
-                cg.StructInitializer(
-                    AllowedIP,
-                    ("ip", str(ip.network_address)),
-                    ("netmask", str(ip.netmask)),
-                )
-                for ip in allowed_ips
-            ]
-        )
-    )
+    for ip in allowed_ips:
+        cg.add(var.add_allowed_ip(str(ip.network_address), str(ip.netmask)))
 
     cg.add(var.set_srctime(await cg.get_variable(config[CONF_TIME_ID])))
 

esphome/components/wireguard/wireguard.cpp

@@ -13,7 +13,8 @@
 #include <esp_wireguard.h>
 #include <esp_wireguard_err.h>
 
-namespace esphome::wireguard {
+namespace esphome {
+namespace wireguard {
 
 static const char *const TAG = "wireguard";
 
@@ -27,16 +28,16 @@ static const char *const LOGMSG_ONLINE = "online";
 static const char *const LOGMSG_OFFLINE = "offline";
 
 void Wireguard::setup() {
-  this->wg_config_.address = this->address_;
-  this->wg_config_.private_key = this->private_key_;
-  this->wg_config_.endpoint = this->peer_endpoint_;
-  this->wg_config_.public_key = this->peer_public_key_;
+  this->wg_config_.address = this->address_.c_str();
+  this->wg_config_.private_key = this->private_key_.c_str();
+  this->wg_config_.endpoint = this->peer_endpoint_.c_str();
+  this->wg_config_.public_key = this->peer_public_key_.c_str();
   this->wg_config_.port = this->peer_port_;
-  this->wg_config_.netmask = this->netmask_;
+  this->wg_config_.netmask = this->netmask_.c_str();
   this->wg_config_.persistent_keepalive = this->keepalive_;
 
-  if (this->preshared_key_ != nullptr)
-    this->wg_config_.preshared_key = this->preshared_key_;
+  if (!this->preshared_key_.empty())
+    this->wg_config_.preshared_key = this->preshared_key_.c_str();
 
   this->publish_enabled_state();
 
@@ -130,10 +131,6 @@ void Wireguard::update() {
 }
 
 void Wireguard::dump_config() {
-  char private_key_masked[MASK_KEY_BUFFER_SIZE];
-  char preshared_key_masked[MASK_KEY_BUFFER_SIZE];
-  mask_key_to(private_key_masked, sizeof(private_key_masked), this->private_key_);
-  mask_key_to(preshared_key_masked, sizeof(preshared_key_masked), this->preshared_key_);
   // clang-format off
   ESP_LOGCONFIG(
       TAG,
@@ -145,13 +142,13 @@ void Wireguard::dump_config() {
       "  Peer Port: " LOG_SECRET("%d") "\n"
       "  Peer Public Key: " LOG_SECRET("%s") "\n"
       "  Peer Pre-shared Key: " LOG_SECRET("%s"),
-      this->address_, this->netmask_, private_key_masked,
-      this->peer_endpoint_, this->peer_port_, this->peer_public_key_,
-      (this->preshared_key_ != nullptr ? preshared_key_masked : "NOT IN USE"));
+      this->address_.c_str(), this->netmask_.c_str(), mask_key(this->private_key_).c_str(),
+      this->peer_endpoint_.c_str(), this->peer_port_, this->peer_public_key_.c_str(),
+      (!this->preshared_key_.empty() ? mask_key(this->preshared_key_).c_str() : "NOT IN USE"));
   // clang-format on
   ESP_LOGCONFIG(TAG, "  Peer Allowed IPs:");
-  for (const AllowedIP &allowed_ip : this->allowed_ips_) {
-    ESP_LOGCONFIG(TAG, "    - %s/%s", allowed_ip.ip, allowed_ip.netmask);
+  for (auto &allowed_ip : this->allowed_ips_) {
+    ESP_LOGCONFIG(TAG, "    - %s/%s", std::get<0>(allowed_ip).c_str(), std::get<1>(allowed_ip).c_str());
   }
   ESP_LOGCONFIG(TAG, "  Peer Persistent Keepalive: %d%s", this->keepalive_,
                 (this->keepalive_ > 0 ? "s" : " (DISABLED)"));
@@ -179,6 +176,18 @@ time_t Wireguard::get_latest_handshake() const {
   return result;
 }
 
+void Wireguard::set_address(const std::string &address) { this->address_ = address; }
+void Wireguard::set_netmask(const std::string &netmask) { this->netmask_ = netmask; }
+void Wireguard::set_private_key(const std::string &key) { this->private_key_ = key; }
+void Wireguard::set_peer_endpoint(const std::string &endpoint) { this->peer_endpoint_ = endpoint; }
+void Wireguard::set_peer_public_key(const std::string &key) { this->peer_public_key_ = key; }
+void Wireguard::set_peer_port(const uint16_t port) { this->peer_port_ = port; }
+void Wireguard::set_preshared_key(const std::string &key) { this->preshared_key_ = key; }
+
+void Wireguard::add_allowed_ip(const std::string &ip, const std::string &netmask) {
+  this->allowed_ips_.emplace_back(ip, netmask);
+}
+
 void Wireguard::set_keepalive(const uint16_t seconds) { this->keepalive_ = seconds; }
 void Wireguard::set_reboot_timeout(const uint32_t seconds) { this->reboot_timeout_ = seconds; }
 void Wireguard::set_srctime(time::RealTimeClock *srctime) { this->srctime_ = srctime; }
@@ -265,8 +274,9 @@ void Wireguard::start_connection_() {
 
   ESP_LOGD(TAG, "Configuring allowed IPs list");
   bool allowed_ips_ok = true;
-  for (const AllowedIP &ip : this->allowed_ips_) {
-    allowed_ips_ok &= (esp_wireguard_add_allowed_ip(&(this->wg_ctx_), ip.ip, ip.netmask) == ESP_OK);
+  for (std::tuple<std::string, std::string> ip : this->allowed_ips_) {
+    allowed_ips_ok &=
+        (esp_wireguard_add_allowed_ip(&(this->wg_ctx_), std::get<0>(ip).c_str(), std::get<1>(ip).c_str()) == ESP_OK);
   }
 
   if (allowed_ips_ok) {
@@ -289,25 +299,8 @@ void Wireguard::stop_connection_() {
   }
 }
 
-void mask_key_to(char *buffer, size_t len, const char *key) {
-  // Format: "XXXXX[...]=\0" = MASK_KEY_BUFFER_SIZE chars minimum
-  if (len < MASK_KEY_BUFFER_SIZE || key == nullptr) {
-    if (len > 0)
-      buffer[0] = '\0';
-    return;
-  }
-  // Copy first 5 characters of the key
-  size_t i = 0;
-  for (; i < 5 && key[i] != '\0'; ++i) {
-    buffer[i] = key[i];
-  }
-  // Append "[...]="
-  const char *suffix = "[...]=";
-  for (size_t j = 0; suffix[j] != '\0' && (i + j) < len - 1; ++j) {
-    buffer[i + j] = suffix[j];
-  }
-  buffer[i + 6] = '\0';
-}
+std::string mask_key(const std::string &key) { return (key.substr(0, 5) + "[...]="); }
 
-}  // namespace esphome::wireguard
+}  // namespace wireguard
+}  // namespace esphome
 #endif

esphome/components/wireguard/wireguard.h

@@ -2,10 +2,10 @@
 #include "esphome/core/defines.h"
 #ifdef USE_WIREGUARD
 #include <ctime>
-#include <initializer_list>
+#include <vector>
+#include <tuple>
 
 #include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
 #include "esphome/components/time/real_time_clock.h"
 
 #ifdef USE_BINARY_SENSOR
@@ -22,13 +22,8 @@
 
 #include <esp_wireguard.h>
 
-namespace esphome::wireguard {
-
-/// Allowed IP entry for WireGuard peer configuration.
-struct AllowedIP {
-  const char *ip;
-  const char *netmask;
-};
+namespace esphome {
+namespace wireguard {
 
 /// Main Wireguard component class.
 class Wireguard : public PollingComponent {
@@ -42,25 +37,15 @@ class Wireguard : public PollingComponent {
 
   float get_setup_priority() const override { return esphome::setup_priority::BEFORE_CONNECTION; }
 
-  void set_address(const char *address) { this->address_ = address; }
-  void set_netmask(const char *netmask) { this->netmask_ = netmask; }
-  void set_private_key(const char *key) { this->private_key_ = key; }
-  void set_peer_endpoint(const char *endpoint) { this->peer_endpoint_ = endpoint; }
-  void set_peer_public_key(const char *key) { this->peer_public_key_ = key; }
-  void set_peer_port(uint16_t port) { this->peer_port_ = port; }
-  void set_preshared_key(const char *key) { this->preshared_key_ = key; }
+  void set_address(const std::string &address);
+  void set_netmask(const std::string &netmask);
+  void set_private_key(const std::string &key);
+  void set_peer_endpoint(const std::string &endpoint);
+  void set_peer_public_key(const std::string &key);
+  void set_peer_port(uint16_t port);
+  void set_preshared_key(const std::string &key);
 
-  /// Prevent accidental use of std::string which would dangle
-  void set_address(const std::string &address) = delete;
-  void set_netmask(const std::string &netmask) = delete;
-  void set_private_key(const std::string &key) = delete;
-  void set_peer_endpoint(const std::string &endpoint) = delete;
-  void set_peer_public_key(const std::string &key) = delete;
-  void set_preshared_key(const std::string &key) = delete;
-
-  void set_allowed_ips(std::initializer_list<AllowedIP> ips) { this->allowed_ips_ = ips; }
-  /// Prevent accidental use of std::string which would dangle
-  void set_allowed_ips(std::initializer_list<std::tuple<std::string, std::string>> ips) = delete;
+  void add_allowed_ip(const std::string &ip, const std::string &netmask);
 
   void set_keepalive(uint16_t seconds);
   void set_reboot_timeout(uint32_t seconds);
@@ -98,14 +83,14 @@ class Wireguard : public PollingComponent {
   time_t get_latest_handshake() const;
 
  protected:
-  const char *address_{nullptr};
-  const char *netmask_{nullptr};
-  const char *private_key_{nullptr};
-  const char *peer_endpoint_{nullptr};
-  const char *peer_public_key_{nullptr};
-  const char *preshared_key_{nullptr};
+  std::string address_;
+  std::string netmask_;
+  std::string private_key_;
+  std::string peer_endpoint_;
+  std::string peer_public_key_;
+  std::string preshared_key_;
 
-  FixedVector<AllowedIP> allowed_ips_;
+  std::vector<std::tuple<std::string, std::string>> allowed_ips_;
 
   uint16_t peer_port_;
   uint16_t keepalive_;
@@ -157,11 +142,8 @@ class Wireguard : public PollingComponent {
 void suspend_wdt();
 void resume_wdt();
 
-/// Size of buffer required for mask_key_to: 5 chars + "[...]=" + null = 12
-static constexpr size_t MASK_KEY_BUFFER_SIZE = 12;
-
 /// Strip most part of the key only for secure printing
-void mask_key_to(char *buffer, size_t len, const char *key);
+std::string mask_key(const std::string &key);
 
 /// Condition to check if remote peer is online.
 template<typename... Ts> class WireguardPeerOnlineCondition : public Condition<Ts...>, public Parented<Wireguard> {
@@ -187,5 +169,6 @@ template<typename... Ts> class WireguardDisableAction : public Action<Ts...>, pu
   void play(const Ts &...x) override { this->parent_->disable(); }
 };
 
-}  // namespace esphome::wireguard
+}  // namespace wireguard
+}  // namespace esphome
 #endif

esphome/core/helpers.cpp

@@ -404,31 +404,15 @@ std::string format_hex_pretty(const std::string &data, char separator, bool show
   return format_hex_pretty_uint8(reinterpret_cast<const uint8_t *>(data.data()), data.length(), separator, show_length);
 }
 
-char *format_bin_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length) {
-  if (buffer_size == 0) {
-    return buffer;
-  }
-  // Calculate max bytes we can format: each byte needs 8 chars
-  size_t max_bytes = (buffer_size - 1) / 8;
-  if (max_bytes == 0 || length == 0) {
-    buffer[0] = '\0';
-    return buffer;
-  }
-  size_t bytes_to_format = std::min(length, max_bytes);
-
-  for (size_t byte_idx = 0; byte_idx < bytes_to_format; byte_idx++) {
-    for (size_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-      buffer[byte_idx * 8 + bit_idx] = ((data[byte_idx] >> (7 - bit_idx)) & 1) + '0';
-    }
-  }
-  buffer[bytes_to_format * 8] = '\0';
-  return buffer;
-}
-
 std::string format_bin(const uint8_t *data, size_t length) {
   std::string result;
   result.resize(length * 8);
-  format_bin_to(&result[0], length * 8 + 1, data, length);
+  for (size_t byte_idx = 0; byte_idx < length; byte_idx++) {
+    for (size_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+      result[byte_idx * 8 + bit_idx] = ((data[byte_idx] >> (7 - bit_idx)) & 1) + '0';
+    }
+  }
+
   return result;
 }
 
@@ -640,44 +624,53 @@ std::vector<uint8_t> base64_decode(const std::string &encoded_string) {
   return ret;
 }
 
-/// Decode base64/base64url string directly into vector of little-endian int32 values
-/// @param base64 Base64 or base64url encoded string (both +/ and -_ accepted)
-/// @param out Output vector (cleared and filled with decoded int32 values)
-/// @return true if successful, false if decode failed or invalid size
-bool base64_decode_int32_vector(const std::string &base64, std::vector<int32_t> &out) {
-  // Decode in chunks to minimize stack usage
-  constexpr size_t chunk_bytes = 48;  // 12 int32 values
-  constexpr size_t chunk_chars = 64;  // 48 * 4/3 = 64 chars
-  uint8_t chunk[chunk_bytes];
+/// Encode int32 to 5 base85 characters + null terminator
+/// Standard ASCII85 alphabet: '!' (33) = 0 through 'u' (117) = 84
+inline void base85_encode_int32(int32_t value, std::span<char, BASE85_INT32_ENCODED_SIZE> output) {
+  uint32_t v = static_cast<uint32_t>(value);
+  // Encode least significant digit first, then reverse
+  for (int i = 4; i >= 0; i--) {
+    output[i] = static_cast<char>('!' + (v % 85));
+    v /= 85;
+  }
+  output[5] = '\0';
+}
+
+/// Decode 5 base85 characters to int32
+inline bool base85_decode_int32(const char *input, int32_t &out) {
+  uint8_t c0 = static_cast<uint8_t>(input[0] - '!');
+  uint8_t c1 = static_cast<uint8_t>(input[1] - '!');
+  uint8_t c2 = static_cast<uint8_t>(input[2] - '!');
+  uint8_t c3 = static_cast<uint8_t>(input[3] - '!');
+  uint8_t c4 = static_cast<uint8_t>(input[4] - '!');
+
+  // Each digit must be 0-84. Since uint8_t wraps, chars below '!' become > 84
+  if (c0 > 84 || c1 > 84 || c2 > 84 || c3 > 84 || c4 > 84)
+    return false;
+
+  // 85^4 = 52200625, 85^3 = 614125, 85^2 = 7225, 85^1 = 85
+  out = static_cast<int32_t>(c0 * 52200625u + c1 * 614125u + c2 * 7225u + c3 * 85u + c4);
+  return true;
+}
+
+/// Decode base85 string directly into vector (no intermediate buffer)
+bool base85_decode_int32_vector(const std::string &base85, std::vector<int32_t> &out) {
+  size_t len = base85.size();
+  if (len % 5 != 0)
+    return false;
 
   out.clear();
+  const char *ptr = base85.data();
+  const char *end = ptr + len;
 
-  const uint8_t *input = reinterpret_cast<const uint8_t *>(base64.data());
-  size_t remaining = base64.size();
-  size_t pos = 0;
-
-  while (remaining > 0) {
-    size_t chars_to_decode = std::min(remaining, chunk_chars);
-    size_t decoded_len = base64_decode(input + pos, chars_to_decode, chunk, chunk_bytes);
-
-    if (decoded_len == 0)
+  while (ptr < end) {
+    int32_t value;
+    if (!base85_decode_int32(ptr, value))
       return false;
-
-    // Parse little-endian int32 values
-    for (size_t i = 0; i + 3 < decoded_len; i += 4) {
-      int32_t timing = static_cast<int32_t>(encode_uint32(chunk[i + 3], chunk[i + 2], chunk[i + 1], chunk[i]));
-      out.push_back(timing);
-    }
-
-    // Check for incomplete int32 in last chunk
-    if (remaining <= chunk_chars && (decoded_len % 4) != 0)
-      return false;
-
-    pos += chars_to_decode;
-    remaining -= chars_to_decode;
+    out.push_back(value);
+    ptr += 5;
   }
-
-  return !out.empty();
+  return true;
 }
 
 // Colors

esphome/core/helpers.h

@@ -395,28 +395,6 @@ constexpr uint32_t FNV1_OFFSET_BASIS = 2166136261UL;
 /// FNV-1 32-bit prime
 constexpr uint32_t FNV1_PRIME = 16777619UL;
 
-/// Extend a FNV-1 hash with an integer (hashes each byte).
-template<std::integral T> constexpr uint32_t fnv1_hash_extend(uint32_t hash, T value) {
-  using UnsignedT = std::make_unsigned_t<T>;
-  UnsignedT uvalue = static_cast<UnsignedT>(value);
-  for (size_t i = 0; i < sizeof(T); i++) {
-    hash *= FNV1_PRIME;
-    hash ^= (uvalue >> (i * 8)) & 0xFF;
-  }
-  return hash;
-}
-/// Extend a FNV-1 hash with additional string data.
-constexpr uint32_t fnv1_hash_extend(uint32_t hash, const char *str) {
-  if (str) {
-    while (*str) {
-      hash *= FNV1_PRIME;
-      hash ^= *str++;
-    }
-  }
-  return hash;
-}
-inline uint32_t fnv1_hash_extend(uint32_t hash, const std::string &str) { return fnv1_hash_extend(hash, str.c_str()); }
-
 /// Extend a FNV-1a hash with additional string data.
 constexpr uint32_t fnv1a_hash_extend(uint32_t hash, const char *str) {
   if (str) {
@@ -1118,66 +1096,9 @@ std::string format_hex_pretty(T val, char separator = '.', bool show_length = tr
   return format_hex_pretty(reinterpret_cast<uint8_t *>(&val), sizeof(T), separator, show_length);
 }
 
-/// Calculate buffer size needed for format_bin_to: "01234567...\0" = bytes * 8 + 1
-constexpr size_t format_bin_size(size_t byte_count) { return byte_count * 8 + 1; }
-
-/** Format byte array as binary string to buffer.
- *
- * Each byte is formatted as 8 binary digits (MSB first).
- * Truncates output if data exceeds buffer capacity.
- *
- * @param buffer Output buffer to write to.
- * @param buffer_size Size of the output buffer.
- * @param data Pointer to the byte array to format.
- * @param length Number of bytes in the array.
- * @return Pointer to buffer.
- *
- * Buffer size needed: length * 8 + 1 (use format_bin_size()).
- *
- * Example:
- * @code
- * char buf[9];  // format_bin_size(1)
- * format_bin_to(buf, sizeof(buf), data, 1);  // "10101011"
- * @endcode
- */
-char *format_bin_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length);
-
-/// Format byte array as binary to buffer. Automatically deduces buffer size.
-template<size_t N> inline char *format_bin_to(char (&buffer)[N], const uint8_t *data, size_t length) {
-  static_assert(N >= 9, "Buffer must hold at least one binary byte (9 chars)");
-  return format_bin_to(buffer, N, data, length);
-}
-
-/** Format an unsigned integer in binary to buffer, MSB first.
- *
- * @tparam N Buffer size (must be >= sizeof(T) * 8 + 1).
- * @tparam T Unsigned integer type.
- * @param buffer Output buffer to write to.
- * @param val The unsigned integer value to format.
- * @return Pointer to buffer.
- *
- * Example:
- * @code
- * char buf[9];  // format_bin_size(sizeof(uint8_t))
- * format_bin_to(buf, uint8_t{0xAA});  // "10101010"
- * char buf16[17];  // format_bin_size(sizeof(uint16_t))
- * format_bin_to(buf16, uint16_t{0x1234});  // "0001001000110100"
- * @endcode
- */
-template<size_t N, typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
-inline char *format_bin_to(char (&buffer)[N], T val) {
-  static_assert(N >= sizeof(T) * 8 + 1, "Buffer too small for type");
-  val = convert_big_endian(val);
-  return format_bin_to(buffer, reinterpret_cast<const uint8_t *>(&val), sizeof(T));
-}
-
 /// Format the byte array \p data of length \p len in binary.
-/// @warning Allocates heap memory. Use format_bin_to() with a stack buffer instead.
-/// Causes heap fragmentation on long-running devices.
 std::string format_bin(const uint8_t *data, size_t length);
 /// Format an unsigned integer in binary, starting with the most significant byte.
-/// @warning Allocates heap memory. Use format_bin_to() with a stack buffer instead.
-/// Causes heap fragmentation on long-running devices.
 template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_bin(T val) {
   val = convert_big_endian(val);
   return format_bin(reinterpret_cast<uint8_t *>(&val), sizeof(T));
@@ -1216,11 +1137,13 @@ std::vector<uint8_t> base64_decode(const std::string &encoded_string);
 size_t base64_decode(std::string const &encoded_string, uint8_t *buf, size_t buf_len);
 size_t base64_decode(const uint8_t *encoded_data, size_t encoded_len, uint8_t *buf, size_t buf_len);
 
-/// Decode base64/base64url string directly into vector of little-endian int32 values
-/// @param base64 Base64 or base64url encoded string (both +/ and -_ accepted)
-/// @param out Output vector (cleared and filled with decoded int32 values)
-/// @return true if successful, false if decode failed or invalid size
-bool base64_decode_int32_vector(const std::string &base64, std::vector<int32_t> &out);
+/// Size of buffer needed for base85 encoded int32 (5 chars + null terminator)
+static constexpr size_t BASE85_INT32_ENCODED_SIZE = 6;
+
+void base85_encode_int32(int32_t value, std::span<char, BASE85_INT32_ENCODED_SIZE> output);
+
+bool base85_decode_int32(const char *input, int32_t &out);
+bool base85_decode_int32_vector(const std::string &base85, std::vector<int32_t> &out);
 
 ///@}
 

esphome/core/progmem.h

@@ -12,8 +12,6 @@
 #define ESPHOME_strncpy_P strncpy_P
 #define ESPHOME_strncat_P strncat_P
 #define ESPHOME_snprintf_P snprintf_P
-// Type for pointers to PROGMEM strings (for use with ESPHOME_F return values)
-using ProgmemStr = const __FlashStringHelper *;
 #else
 #define ESPHOME_F(string_literal) (string_literal)
 #define ESPHOME_PGM_P const char *
@@ -21,6 +19,4 @@ using ProgmemStr = const __FlashStringHelper *;
 #define ESPHOME_strncpy_P strncpy
 #define ESPHOME_strncat_P strncat
 #define ESPHOME_snprintf_P snprintf
-// Type for pointers to strings (no PROGMEM on non-ESP8266 platforms)
-using ProgmemStr = const char *;
 #endif

esphome/idf_component.yml

@@ -28,8 +28,8 @@ dependencies:
     rules:
       - if: "target in [esp32s2, esp32s3, esp32p4]"
   esphome/esp-hub75:
-    version: 0.3.0
+    version: 0.2.2
     rules:
-      - if: "target in [esp32, esp32s2, esp32s3, esp32c6, esp32p4]"
+      - if: "target in [esp32, esp32s2, esp32s3, esp32p4]"
   esp32async/asynctcp:
     version: 3.4.91

script/ci-custom.py

@@ -682,7 +682,6 @@ def lint_trailing_whitespace(fname, match):
 # Heap-allocating helpers that cause fragmentation on long-running embedded devices.
 # These return std::string and should be replaced with stack-based alternatives.
 HEAP_ALLOCATING_HELPERS = {
-    "format_bin": "format_bin_to() with a stack buffer",
     "format_hex": "format_hex_to() with a stack buffer",
     "format_hex_pretty": "format_hex_pretty_to() with a stack buffer",
     "format_mac_address_pretty": "format_mac_addr_upper() with a stack buffer",
@@ -700,7 +699,6 @@ HEAP_ALLOCATING_HELPERS = {
     # get_mac_address(?!_) ensures we don't match get_mac_address_into_buffer, etc.
     # CPP_RE_EOL captures rest of line so NOLINT comments are detected
     r"[^\w]("
-    r"format_bin(?!_)|"
     r"format_hex(?!_)|"
     r"format_hex_pretty(?!_)|"
     r"format_mac_address_pretty|"

tests/components/alarm_control_panel/common.yaml

@@ -9,8 +9,6 @@ alarm_control_panel:
     name: Alarm Panel
     codes:
       - "1234"
-      - "5678"
-      - "0000"
     requires_code_to_arm: true
     arming_home_time: 1s
     arming_night_time: 1s
@@ -31,7 +29,6 @@ alarm_control_panel:
     name: Alarm Panel 2
     codes:
       - "1234"
-      - "9999"
     requires_code_to_arm: true
     arming_home_time: 1s
     arming_night_time: 1s

tests/components/udp/common.yaml

@@ -5,10 +5,7 @@ wifi:
 udp:
   id: my_udp
   listen_address: 239.0.60.53
-  addresses:
-    - "239.0.60.53"
-    - "192.168.1.255"
-    - "10.0.0.255"
+  addresses: ["239.0.60.53"]
   on_receive:
     - logger.log:
         format: "Received %d bytes"

tests/integration/fixtures/udp_send_receive.yaml

@@ -1,33 +0,0 @@
-esphome:
-  name: udp-test
-
-host:
-
-api:
-  services:
-    - service: send_udp_message
-      then:
-        - udp.write:
-            id: test_udp
-            data: "HELLO_UDP_TEST"
-    - service: send_udp_bytes
-      then:
-        - udp.write:
-            id: test_udp
-            data: [0x55, 0x44, 0x50, 0x5F, 0x42, 0x59, 0x54, 0x45, 0x53]  # "UDP_BYTES"
-
-logger:
-  level: DEBUG
-
-udp:
-  - id: test_udp
-    addresses:
-      - "127.0.0.1"
-      - "127.0.0.2"
-    port:
-      listen_port: UDP_LISTEN_PORT_PLACEHOLDER
-      broadcast_port: UDP_BROADCAST_PORT_PLACEHOLDER
-    on_receive:
-      - logger.log:
-          format: "Received UDP: %d bytes"
-          args: [data.size()]

tests/integration/test_udp.py

@@ -1,171 +0,0 @@
-"""Integration test for UDP component."""
-
-from __future__ import annotations
-
-import asyncio
-from collections.abc import AsyncGenerator
-import contextlib
-from contextlib import asynccontextmanager
-from dataclasses import dataclass, field
-import socket
-
-import pytest
-
-from .types import APIClientConnectedFactory, RunCompiledFunction
-
-
-@dataclass
-class UDPReceiver:
-    """Collects UDP messages received."""
-
-    messages: list[bytes] = field(default_factory=list)
-    message_received: asyncio.Event = field(default_factory=asyncio.Event)
-
-    def on_message(self, data: bytes) -> None:
-        """Called when a message is received."""
-        self.messages.append(data)
-        self.message_received.set()
-
-    async def wait_for_message(self, timeout: float = 5.0) -> bytes:
-        """Wait for a message to be received."""
-        await asyncio.wait_for(self.message_received.wait(), timeout=timeout)
-        return self.messages[-1]
-
-    async def wait_for_content(self, content: bytes, timeout: float = 5.0) -> bytes:
-        """Wait for a specific message content."""
-        deadline = asyncio.get_event_loop().time() + timeout
-        while True:
-            for msg in self.messages:
-                if content in msg:
-                    return msg
-            remaining = deadline - asyncio.get_event_loop().time()
-            if remaining <= 0:
-                raise TimeoutError(
-                    f"Content {content!r} not found in messages: {self.messages}"
-                )
-            try:
-                await asyncio.wait_for(self.message_received.wait(), timeout=remaining)
-                self.message_received.clear()
-            except TimeoutError:
-                raise TimeoutError(
-                    f"Content {content!r} not found in messages: {self.messages}"
-                ) from None
-
-
-@asynccontextmanager
-async def udp_listener(port: int = 0) -> AsyncGenerator[tuple[int, UDPReceiver]]:
-    """Async context manager that listens for UDP messages.
-
-    Args:
-        port: Port to listen on. 0 for auto-assign.
-
-    Yields:
-        Tuple of (port, UDPReceiver) where port is the UDP port being listened on.
-    """
-    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    sock.bind(("127.0.0.1", port))
-    sock.setblocking(False)
-    actual_port = sock.getsockname()[1]
-
-    receiver = UDPReceiver()
-
-    async def receive_messages() -> None:
-        """Background task to receive UDP messages."""
-        loop = asyncio.get_running_loop()
-        while True:
-            try:
-                data = await loop.sock_recv(sock, 4096)
-                if data:
-                    receiver.on_message(data)
-            except BlockingIOError:
-                await asyncio.sleep(0.01)
-            except Exception:
-                break
-
-    task = asyncio.create_task(receive_messages())
-    try:
-        yield actual_port, receiver
-    finally:
-        task.cancel()
-        with contextlib.suppress(asyncio.CancelledError):
-            await task
-        sock.close()
-
-
-@pytest.mark.asyncio
-async def test_udp_send_receive(
-    yaml_config: str,
-    run_compiled: RunCompiledFunction,
-    api_client_connected: APIClientConnectedFactory,
-) -> None:
-    """Test UDP component can send messages with multiple addresses configured."""
-    # Track log lines to verify dump_config output
-    log_lines: list[str] = []
-
-    def on_log_line(line: str) -> None:
-        log_lines.append(line)
-
-    async with udp_listener() as (udp_port, receiver):
-        # Replace placeholders in the config
-        config = yaml_config.replace("UDP_LISTEN_PORT_PLACEHOLDER", str(udp_port + 1))
-        config = config.replace("UDP_BROADCAST_PORT_PLACEHOLDER", str(udp_port))
-
-        async with (
-            run_compiled(config, line_callback=on_log_line),
-            api_client_connected() as client,
-        ):
-            # Verify device is running
-            device_info = await client.device_info()
-            assert device_info is not None
-            assert device_info.name == "udp-test"
-
-            # Get services
-            _, services = await client.list_entities_services()
-
-            # Test sending string message
-            send_message_service = next(
-                (s for s in services if s.name == "send_udp_message"), None
-            )
-            assert send_message_service is not None, (
-                "send_udp_message service not found"
-            )
-
-            await client.execute_service(send_message_service, {})
-
-            try:
-                msg = await receiver.wait_for_content(b"HELLO_UDP_TEST", timeout=5.0)
-                assert b"HELLO_UDP_TEST" in msg
-            except TimeoutError:
-                pytest.fail(
-                    f"UDP string message not received. Got: {receiver.messages}"
-                )
-
-            # Test sending bytes
-            send_bytes_service = next(
-                (s for s in services if s.name == "send_udp_bytes"), None
-            )
-            assert send_bytes_service is not None, "send_udp_bytes service not found"
-
-            await client.execute_service(send_bytes_service, {})
-
-            try:
-                msg = await receiver.wait_for_content(b"UDP_BYTES", timeout=5.0)
-                assert b"UDP_BYTES" in msg
-            except TimeoutError:
-                pytest.fail(f"UDP bytes message not received. Got: {receiver.messages}")
-
-            # Verify we received at least 2 messages (string + bytes)
-            assert len(receiver.messages) >= 2, (
-                f"Expected at least 2 messages, got {len(receiver.messages)}"
-            )
-
-            # Verify dump_config logged all configured addresses
-            # This tests that FixedVector<const char*> stores addresses correctly
-            log_text = "\n".join(log_lines)
-            assert "Address: 127.0.0.1" in log_text, (
-                f"Address 127.0.0.1 not found in dump_config. Log: {log_text[-2000:]}"
-            )
-            assert "Address: 127.0.0.2" in log_text, (
-                f"Address 127.0.0.2 not found in dump_config. Log: {log_text[-2000:]}"
-            )