esphome 2025.8.4__py3-none-any.whl → 2025.9.0b2__py3-none-any.whl

esphome/components/captive_portal/captive_portal.cpp

@@ -11,17 +11,35 @@ namespace captive_portal {
 static const char *const TAG = "captive_portal";
 
 void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
-  AsyncResponseStream *stream = request->beginResponseStream("application/json");
-  stream->addHeader("cache-control", "public, max-age=0, must-revalidate");
+  AsyncResponseStream *stream = request->beginResponseStream(F("application/json"));
+  stream->addHeader(F("cache-control"), F("public, max-age=0, must-revalidate"));
+#ifdef USE_ESP8266
+  stream->print(F("{\"mac\":\""));
+  stream->print(get_mac_address_pretty().c_str());
+  stream->print(F("\",\"name\":\""));
+  stream->print(App.get_name().c_str());
+  stream->print(F("\",\"aps\":[{}"));
+#else
   stream->printf(R"({"mac":"%s","name":"%s","aps":[{})", get_mac_address_pretty().c_str(), App.get_name().c_str());
+#endif
 
   for (auto &scan : wifi::global_wifi_component->get_scan_result()) {
     if (scan.get_is_hidden())
       continue;
 
-    // Assumes no " in ssid, possible unicode isses?
+      // Assumes no " in ssid, possible unicode isses?
+#ifdef USE_ESP8266
+    stream->print(F(",{\"ssid\":\""));
+    stream->print(scan.get_ssid().c_str());
+    stream->print(F("\",\"rssi\":"));
+    stream->print(scan.get_rssi());
+    stream->print(F(",\"lock\":"));
+    stream->print(scan.get_with_auth());
+    stream->print(F("}"));
+#else
     stream->printf(R"(,{"ssid":"%s","rssi":%d,"lock":%d})", scan.get_ssid().c_str(), scan.get_rssi(),
                    scan.get_with_auth());
+#endif
   }
   stream->print(F("]}"));
   request->send(stream);
@@ -34,7 +52,7 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
   ESP_LOGI(TAG, "  Password=" LOG_SECRET("'%s'"), psk.c_str());
   wifi::global_wifi_component->save_wifi_sta(ssid, psk);
   wifi::global_wifi_component->start_scanning();
-  request->redirect("/?save");
+  request->redirect(F("/?save"));
 }
 
 void CaptivePortal::setup() {
@@ -53,18 +71,23 @@ void CaptivePortal::start() {
   this->dns_server_ = make_unique<DNSServer>();
   this->dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
   network::IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();
-  this->dns_server_->start(53, "*", ip);
+  this->dns_server_->start(53, F("*"), ip);
   // Re-enable loop() when DNS server is started
   this->enable_loop();
 #endif
 
   this->base_->get_server()->onNotFound([this](AsyncWebServerRequest *req) {
     if (!this->active_ || req->host().c_str() == wifi::global_wifi_component->wifi_soft_ap_ip().str()) {
-      req->send(404, "text/html", "File not found");
+      req->send(404, F("text/html"), F("File not found"));
       return;
     }
 
+#ifdef USE_ESP8266
+    String url = F("http://");
+    url += wifi::global_wifi_component->wifi_soft_ap_ip().str().c_str();
+#else
     auto url = "http://" + wifi::global_wifi_component->wifi_soft_ap_ip().str();
+#endif
     req->redirect(url.c_str());
   });
 
@@ -73,19 +96,19 @@ void CaptivePortal::start() {
 }
 
 void CaptivePortal::handleRequest(AsyncWebServerRequest *req) {
-  if (req->url() == "/") {
+  if (req->url() == F("/")) {
 #ifndef USE_ESP8266
-    auto *response = req->beginResponse(200, "text/html", INDEX_GZ, sizeof(INDEX_GZ));
+    auto *response = req->beginResponse(200, F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
 #else
-    auto *response = req->beginResponse_P(200, "text/html", INDEX_GZ, sizeof(INDEX_GZ));
+    auto *response = req->beginResponse_P(200, F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
 #endif
-    response->addHeader("Content-Encoding", "gzip");
+    response->addHeader(F("Content-Encoding"), F("gzip"));
     req->send(response);
     return;
-  } else if (req->url() == "/config.json") {
+  } else if (req->url() == F("/config.json")) {
     this->handle_config(req);
     return;
-  } else if (req->url() == "/wifisave") {
+  } else if (req->url() == F("/wifisave")) {
     this->handle_wifisave(req);
     return;
   }

esphome/components/captive_portal/captive_portal.h

@@ -45,11 +45,11 @@ class CaptivePortal : public AsyncWebHandler, public Component {
       return false;
 
     if (request->method() == HTTP_GET) {
-      if (request->url() == "/")
+      if (request->url() == F("/"))
         return true;
-      if (request->url() == "/config.json")
+      if (request->url() == F("/config.json"))
         return true;
-      if (request->url() == "/wifisave")
+      if (request->url() == F("/wifisave"))
         return true;
     }
 

esphome/components/ccs811/ccs811.cpp

@@ -152,9 +152,9 @@ void CCS811Component::send_env_data_() {
 void CCS811Component::dump_config() {
   ESP_LOGCONFIG(TAG, "CCS811");
   LOG_I2C_DEVICE(this)
-  LOG_UPDATE_INTERVAL(this)
-  LOG_SENSOR("  ", "CO2 Sensor", this->co2_)
-  LOG_SENSOR("  ", "TVOC Sensor", this->tvoc_)
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "CO2 Sensor", this->co2_);
+  LOG_SENSOR("  ", "TVOC Sensor", this->tvoc_);
   LOG_TEXT_SENSOR("  ", "Firmware Version Sensor", this->version_)
   if (this->baseline_) {
     ESP_LOGCONFIG(TAG, "  Baseline: %04X", *this->baseline_);

esphome/components/climate/__init__.py

@@ -47,7 +47,7 @@ from esphome.const import (
     CONF_VISUAL,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -517,6 +517,6 @@ async def climate_control_to_code(config, action_id, template_arg, args):
     return var
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(climate_ns.using)

esphome/components/climate/climate.cpp

@@ -327,7 +327,7 @@ void Climate::add_on_control_callback(std::function<void(ClimateCall &)> &&callb
 static const uint32_t RESTORE_STATE_VERSION = 0x848EA6ADUL;
 
 optional<ClimateDeviceRestoreState> Climate::restore_state_() {
-  this->rtc_ = global_preferences->make_preference<ClimateDeviceRestoreState>(this->get_object_id_hash() ^
+  this->rtc_ = global_preferences->make_preference<ClimateDeviceRestoreState>(this->get_preference_hash() ^
                                                                               RESTORE_STATE_VERSION);
   ClimateDeviceRestoreState recovered{};
   if (!this->rtc_.load(&recovered))

esphome/components/cover/__init__.py

@@ -32,7 +32,7 @@ from esphome.const import (
     DEVICE_CLASS_SHUTTER,
     DEVICE_CLASS_WINDOW,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -228,9 +228,9 @@ async def cover_stop_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action("cover.toggle", ToggleAction, COVER_ACTION_SCHEMA)
-def cover_toggle_to_code(config, action_id, template_arg, args):
-    paren = yield cg.get_variable(config[CONF_ID])
-    yield cg.new_Pvariable(action_id, template_arg, paren)
+async def cover_toggle_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 COVER_CONTROL_ACTION_SCHEMA = cv.Schema(
@@ -263,6 +263,6 @@ async def cover_control_to_code(config, action_id, template_arg, args):
     return var
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(cover_ns.using)

esphome/components/cover/cover.cpp

@@ -194,7 +194,7 @@ void Cover::publish_state(bool save) {
   }
 }
 optional<CoverRestoreState> Cover::restore_state_() {
-  this->rtc_ = global_preferences->make_preference<CoverRestoreState>(this->get_object_id_hash());
+  this->rtc_ = global_preferences->make_preference<CoverRestoreState>(this->get_preference_hash());
   CoverRestoreState recovered{};
   if (!this->rtc_.load(&recovered))
     return {};

esphome/components/cover/cover.h

@@ -19,8 +19,8 @@ const extern float COVER_CLOSED;
     if (traits_.get_is_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \
     } \
-    if (!(obj)->get_device_class().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class().c_str()); \
+    if (!(obj)->get_device_class_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class_ref().c_str()); \
     } \
   }
 

esphome/components/dallas_temp/dallas_temp.cpp

@@ -64,7 +64,7 @@ bool DallasTemperatureSensor::read_scratch_pad_() {
     }
   } else {
     ESP_LOGW(TAG, "'%s' - reading scratch pad failed bus reset", this->get_name().c_str());
-    this->status_set_warning("bus reset failed");
+    this->status_set_warning(LOG_STR("bus reset failed"));
   }
   return success;
 }
@@ -124,7 +124,7 @@ bool DallasTemperatureSensor::check_scratch_pad_() {
             crc8(this->scratch_pad_, 8));
 #endif
   if (!chksum_validity) {
-    this->status_set_warning("scratch pad checksum invalid");
+    this->status_set_warning(LOG_STR("scratch pad checksum invalid"));
     ESP_LOGD(TAG, "Scratch pad: %02X.%02X.%02X.%02X.%02X.%02X.%02X.%02X.%02X (%02X)", this->scratch_pad_[0],
              this->scratch_pad_[1], this->scratch_pad_[2], this->scratch_pad_[3], this->scratch_pad_[4],
              this->scratch_pad_[5], this->scratch_pad_[6], this->scratch_pad_[7], this->scratch_pad_[8],

esphome/components/datetime/__init__.py

@@ -21,7 +21,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
     CONF_YEAR,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -172,7 +172,7 @@ async def new_datetime(config, *args):
     return var
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(datetime_ns.using)
 

esphome/components/datetime/date_entity.h

@@ -16,8 +16,8 @@ namespace datetime {
 #define LOG_DATETIME_DATE(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
     } \
   }
 

esphome/components/datetime/datetime_entity.h

@@ -16,8 +16,8 @@ namespace datetime {
 #define LOG_DATETIME_DATETIME(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
     } \
   }
 

esphome/components/datetime/time_entity.h

@@ -16,8 +16,8 @@ namespace datetime {
 #define LOG_DATETIME_TIME(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
     } \
   }
 

esphome/components/debug/debug_esp32.cpp

@@ -52,7 +52,7 @@ void DebugComponent::on_shutdown() {
   char buffer[REBOOT_MAX_LEN]{};
   auto pref = global_preferences->make_preference(REBOOT_MAX_LEN, fnv1_hash(REBOOT_KEY + App.get_name()));
   if (component != nullptr) {
-    strncpy(buffer, component->get_component_source(), REBOOT_MAX_LEN - 1);
+    strncpy(buffer, LOG_STR_ARG(component->get_component_log_str()), REBOOT_MAX_LEN - 1);
     buffer[REBOOT_MAX_LEN - 1] = '\0';
   }
   ESP_LOGD(TAG, "Storing reboot source: %s", buffer);

esphome/components/display/__init__.py

@@ -15,7 +15,7 @@ from esphome.const import (
     CONF_UPDATE_INTERVAL,
     SCHEDULER_DONT_RUN,
 )
-from esphome.core import coroutine_with_priority
+from esphome.core import CoroPriority, coroutine_with_priority
 
 IS_PLATFORM_COMPONENT = True
 
@@ -176,7 +176,7 @@ async def display_page_show_to_code(config, action_id, template_arg, args):
     DisplayPageShowNextAction,
     maybe_simple_id(
         {
-            cv.Required(CONF_ID): cv.templatable(cv.use_id(Display)),
+            cv.GenerateID(CONF_ID): cv.templatable(cv.use_id(Display)),
         }
     ),
 )
@@ -190,7 +190,7 @@ async def display_page_show_next_to_code(config, action_id, template_arg, args):
     DisplayPageShowPrevAction,
     maybe_simple_id(
         {
-            cv.Required(CONF_ID): cv.templatable(cv.use_id(Display)),
+            cv.GenerateID(CONF_ID): cv.templatable(cv.use_id(Display)),
         }
     ),
 )
@@ -218,7 +218,7 @@ async def display_is_displaying_page_to_code(config, condition_id, template_arg,
     return var
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(display_ns.using)
     cg.add_define("USE_DISPLAY")

esphome/components/duty_time/duty_time_sensor.cpp

@@ -41,7 +41,7 @@ void DutyTimeSensor::setup() {
   uint32_t seconds = 0;
 
   if (this->restore_) {
-    this->pref_ = global_preferences->make_preference<uint32_t>(this->get_object_id_hash());
+    this->pref_ = global_preferences->make_preference<uint32_t>(this->get_preference_hash());
     this->pref_.load(&seconds);
   }
 

esphome/components/esp32/__init__.py

@@ -859,11 +859,6 @@ async def to_code(config):
 
         cg.add_platformio_option("platform_packages", [conf[CONF_SOURCE]])
 
-        # platformio/toolchain-esp32ulp does not support linux_aarch64 yet and has not been updated for over 2 years
-        # This is espressif's own published version which is more up to date.
-        cg.add_platformio_option(
-            "platform_packages", ["espressif/toolchain-esp32ulp@2.35.0-20220830"]
-        )
         add_idf_sdkconfig_option(f"CONFIG_IDF_TARGET_{variant}", True)
         add_idf_sdkconfig_option(
             f"CONFIG_ESPTOOLPY_FLASHSIZE_{config[CONF_FLASH_SIZE]}", True

esphome/components/esp32/gpio.cpp

@@ -54,13 +54,13 @@ struct ISRPinArg {
 
 ISRInternalGPIOPin ESP32InternalGPIOPin::to_isr() const {
   auto *arg = new ISRPinArg{};  // NOLINT(cppcoreguidelines-owning-memory)
-  arg->pin = this->pin_;
+  arg->pin = this->get_pin_num();
   arg->flags = gpio::FLAG_NONE;
-  arg->inverted = inverted_;
+  arg->inverted = this->pin_flags_.inverted;
 #if defined(USE_ESP32_VARIANT_ESP32)
-  arg->use_rtc = rtc_gpio_is_valid_gpio(this->pin_);
+  arg->use_rtc = rtc_gpio_is_valid_gpio(this->get_pin_num());
   if (arg->use_rtc)
-    arg->rtc_pin = rtc_io_number_get(this->pin_);
+    arg->rtc_pin = rtc_io_number_get(this->get_pin_num());
 #endif
   return ISRInternalGPIOPin((void *) arg);
 }
@@ -69,23 +69,23 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
   gpio_int_type_t idf_type = GPIO_INTR_ANYEDGE;
   switch (type) {
     case gpio::INTERRUPT_RISING_EDGE:
-      idf_type = inverted_ ? GPIO_INTR_NEGEDGE : GPIO_INTR_POSEDGE;
+      idf_type = this->pin_flags_.inverted ? GPIO_INTR_NEGEDGE : GPIO_INTR_POSEDGE;
       break;
     case gpio::INTERRUPT_FALLING_EDGE:
-      idf_type = inverted_ ? GPIO_INTR_POSEDGE : GPIO_INTR_NEGEDGE;
+      idf_type = this->pin_flags_.inverted ? GPIO_INTR_POSEDGE : GPIO_INTR_NEGEDGE;
       break;
     case gpio::INTERRUPT_ANY_EDGE:
       idf_type = GPIO_INTR_ANYEDGE;
       break;
     case gpio::INTERRUPT_LOW_LEVEL:
-      idf_type = inverted_ ? GPIO_INTR_HIGH_LEVEL : GPIO_INTR_LOW_LEVEL;
+      idf_type = this->pin_flags_.inverted ? GPIO_INTR_HIGH_LEVEL : GPIO_INTR_LOW_LEVEL;
       break;
     case gpio::INTERRUPT_HIGH_LEVEL:
-      idf_type = inverted_ ? GPIO_INTR_LOW_LEVEL : GPIO_INTR_HIGH_LEVEL;
+      idf_type = this->pin_flags_.inverted ? GPIO_INTR_LOW_LEVEL : GPIO_INTR_HIGH_LEVEL;
       break;
   }
-  gpio_set_intr_type(pin_, idf_type);
-  gpio_intr_enable(pin_);
+  gpio_set_intr_type(this->get_pin_num(), idf_type);
+  gpio_intr_enable(this->get_pin_num());
   if (!isr_service_installed) {
     auto res = gpio_install_isr_service(ESP_INTR_FLAG_LEVEL3);
     if (res != ESP_OK) {
@@ -94,31 +94,31 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
     }
     isr_service_installed = true;
   }
-  gpio_isr_handler_add(pin_, func, arg);
+  gpio_isr_handler_add(this->get_pin_num(), func, arg);
 }
 
 std::string ESP32InternalGPIOPin::dump_summary() const {
   char buffer[32];
-  snprintf(buffer, sizeof(buffer), "GPIO%" PRIu32, static_cast<uint32_t>(pin_));
+  snprintf(buffer, sizeof(buffer), "GPIO%" PRIu32, static_cast<uint32_t>(this->pin_));
   return buffer;
 }
 
 void ESP32InternalGPIOPin::setup() {
   gpio_config_t conf{};
-  conf.pin_bit_mask = 1ULL << static_cast<uint32_t>(pin_);
-  conf.mode = flags_to_mode(flags_);
-  conf.pull_up_en = flags_ & gpio::FLAG_PULLUP ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
-  conf.pull_down_en = flags_ & gpio::FLAG_PULLDOWN ? GPIO_PULLDOWN_ENABLE : GPIO_PULLDOWN_DISABLE;
+  conf.pin_bit_mask = 1ULL << static_cast<uint32_t>(this->pin_);
+  conf.mode = flags_to_mode(this->flags_);
+  conf.pull_up_en = this->flags_ & gpio::FLAG_PULLUP ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
+  conf.pull_down_en = this->flags_ & gpio::FLAG_PULLDOWN ? GPIO_PULLDOWN_ENABLE : GPIO_PULLDOWN_DISABLE;
   conf.intr_type = GPIO_INTR_DISABLE;
   gpio_config(&conf);
-  if (flags_ & gpio::FLAG_OUTPUT) {
-    gpio_set_drive_capability(pin_, drive_strength_);
+  if (this->flags_ & gpio::FLAG_OUTPUT) {
+    gpio_set_drive_capability(this->get_pin_num(), this->get_drive_strength());
   }
 }
 
 void ESP32InternalGPIOPin::pin_mode(gpio::Flags flags) {
   // can't call gpio_config here because that logs in esp-idf which may cause issues
-  gpio_set_direction(pin_, flags_to_mode(flags));
+  gpio_set_direction(this->get_pin_num(), flags_to_mode(flags));
   gpio_pull_mode_t pull_mode = GPIO_FLOATING;
   if ((flags & gpio::FLAG_PULLUP) && (flags & gpio::FLAG_PULLDOWN)) {
     pull_mode = GPIO_PULLUP_PULLDOWN;
@@ -127,12 +127,16 @@ void ESP32InternalGPIOPin::pin_mode(gpio::Flags flags) {
   } else if (flags & gpio::FLAG_PULLDOWN) {
     pull_mode = GPIO_PULLDOWN_ONLY;
   }
-  gpio_set_pull_mode(pin_, pull_mode);
+  gpio_set_pull_mode(this->get_pin_num(), pull_mode);
 }
 
-bool ESP32InternalGPIOPin::digital_read() { return bool(gpio_get_level(pin_)) != inverted_; }
-void ESP32InternalGPIOPin::digital_write(bool value) { gpio_set_level(pin_, value != inverted_ ? 1 : 0); }
-void ESP32InternalGPIOPin::detach_interrupt() const { gpio_intr_disable(pin_); }
+bool ESP32InternalGPIOPin::digital_read() {
+  return bool(gpio_get_level(this->get_pin_num())) != this->pin_flags_.inverted;
+}
+void ESP32InternalGPIOPin::digital_write(bool value) {
+  gpio_set_level(this->get_pin_num(), value != this->pin_flags_.inverted ? 1 : 0);
+}
+void ESP32InternalGPIOPin::detach_interrupt() const { gpio_intr_disable(this->get_pin_num()); }
 
 }  // namespace esp32
 

esphome/components/esp32/gpio.h

@@ -7,12 +7,18 @@
 namespace esphome {
 namespace esp32 {
 
+// Static assertions to ensure our bit-packed fields can hold the enum values
+static_assert(GPIO_NUM_MAX <= 256, "gpio_num_t has too many values for uint8_t");
+static_assert(GPIO_DRIVE_CAP_MAX <= 4, "gpio_drive_cap_t has too many values for 2-bit field");
+
 class ESP32InternalGPIOPin : public InternalGPIOPin {
  public:
-  void set_pin(gpio_num_t pin) { pin_ = pin; }
-  void set_inverted(bool inverted) { inverted_ = inverted; }
-  void set_drive_strength(gpio_drive_cap_t drive_strength) { drive_strength_ = drive_strength; }
-  void set_flags(gpio::Flags flags) { flags_ = flags; }
+  void set_pin(gpio_num_t pin) { this->pin_ = static_cast<uint8_t>(pin); }
+  void set_inverted(bool inverted) { this->pin_flags_.inverted = inverted; }
+  void set_drive_strength(gpio_drive_cap_t drive_strength) {
+    this->pin_flags_.drive_strength = static_cast<uint8_t>(drive_strength);
+  }
+  void set_flags(gpio::Flags flags) { this->flags_ = flags; }
 
   void setup() override;
   void pin_mode(gpio::Flags flags) override;
@@ -21,17 +27,26 @@ class ESP32InternalGPIOPin : public InternalGPIOPin {
   std::string dump_summary() const override;
   void detach_interrupt() const override;
   ISRInternalGPIOPin to_isr() const override;
-  uint8_t get_pin() const override { return (uint8_t) pin_; }
-  gpio::Flags get_flags() const override { return flags_; }
-  bool is_inverted() const override { return inverted_; }
+  uint8_t get_pin() const override { return this->pin_; }
+  gpio::Flags get_flags() const override { return this->flags_; }
+  bool is_inverted() const override { return this->pin_flags_.inverted; }
+  gpio_num_t get_pin_num() const { return static_cast<gpio_num_t>(this->pin_); }
+  gpio_drive_cap_t get_drive_strength() const { return static_cast<gpio_drive_cap_t>(this->pin_flags_.drive_strength); }
 
  protected:
   void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override;
 
-  gpio_num_t pin_;
-  gpio_drive_cap_t drive_strength_;
-  gpio::Flags flags_;
-  bool inverted_;
+  // Memory layout: 8 bytes total on 32-bit systems
+  // - 3 bytes for members below
+  // - 1 byte padding for alignment
+  // - 4 bytes for vtable pointer
+  uint8_t pin_;        // GPIO pin number (0-255, actual max ~54 on ESP32)
+  gpio::Flags flags_;  // GPIO flags (1 byte)
+  struct PinFlags {
+    uint8_t inverted : 1;        // Invert pin logic (1 bit)
+    uint8_t drive_strength : 2;  // Drive strength 0-3 (2 bits)
+    uint8_t reserved : 5;        // Reserved for future use (5 bits)
+  } pin_flags_;                  // Total: 1 byte
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
   static bool isr_service_installed;
 };

esphome/components/esp32/preferences.cpp

@@ -8,6 +8,7 @@
 #include <cinttypes>
 #include <vector>
 #include <string>
+#include <memory>
 
 namespace esphome {
 namespace esp32 {
@@ -156,20 +157,23 @@ class ESP32Preferences : public ESPPreferences {
     return failed == 0;
   }
   bool is_changed(const uint32_t nvs_handle, const NVSData &to_save) {
-    NVSData stored_data{};
     size_t actual_len;
     esp_err_t err = nvs_get_blob(nvs_handle, to_save.key.c_str(), nullptr, &actual_len);
     if (err != 0) {
       ESP_LOGV(TAG, "nvs_get_blob('%s'): %s - the key might not be set yet", to_save.key.c_str(), esp_err_to_name(err));
       return true;
     }
-    stored_data.data.resize(actual_len);
-    err = nvs_get_blob(nvs_handle, to_save.key.c_str(), stored_data.data.data(), &actual_len);
+    // Check size first before allocating memory
+    if (actual_len != to_save.data.size()) {
+      return true;
+    }
+    auto stored_data = std::make_unique<uint8_t[]>(actual_len);
+    err = nvs_get_blob(nvs_handle, to_save.key.c_str(), stored_data.get(), &actual_len);
     if (err != 0) {
       ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", to_save.key.c_str(), esp_err_to_name(err));
       return true;
     }
-    return to_save.data != stored_data.data;
+    return memcmp(to_save.data.data(), stored_data.get(), to_save.data.size()) != 0;
   }
 
   bool reset() override {

esphome/components/esp32_ble/__init__.py

@@ -5,9 +5,14 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_sdkconfig_option, const, get_esp32_variant
 import esphome.config_validation as cv
-from esphome.const import CONF_ENABLE_ON_BOOT, CONF_ESPHOME, CONF_ID, CONF_NAME
+from esphome.const import (
+    CONF_ENABLE_ON_BOOT,
+    CONF_ESPHOME,
+    CONF_ID,
+    CONF_NAME,
+    CONF_NAME_ADD_MAC_SUFFIX,
+)
 from esphome.core import CORE, TimePeriod
-from esphome.core.config import CONF_NAME_ADD_MAC_SUFFIX
 import esphome.final_validate as fv
 
 DEPENDENCIES = ["esp32"]

esphome/components/esp32_ble/ble_uuid.cpp

@@ -7,6 +7,7 @@
 #include <cstdio>
 #include <cinttypes>
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome::esp32_ble {
 
@@ -169,22 +170,42 @@ bool ESPBTUUID::operator==(const ESPBTUUID &uuid) const {
 }
 esp_bt_uuid_t ESPBTUUID::get_uuid() const { return this->uuid_; }
 std::string ESPBTUUID::to_string() const {
+  char buf[40];  // Enough for 128-bit UUID with dashes
+  char *pos = buf;
+
   switch (this->uuid_.len) {
     case ESP_UUID_LEN_16:
-      return str_snprintf("0x%02X%02X", 6, this->uuid_.uuid.uuid16 >> 8, this->uuid_.uuid.uuid16 & 0xff);
+      *pos++ = '0';
+      *pos++ = 'x';
+      *pos++ = format_hex_pretty_char(this->uuid_.uuid.uuid16 >> 12);
+      *pos++ = format_hex_pretty_char((this->uuid_.uuid.uuid16 >> 8) & 0x0F);
+      *pos++ = format_hex_pretty_char((this->uuid_.uuid.uuid16 >> 4) & 0x0F);
+      *pos++ = format_hex_pretty_char(this->uuid_.uuid.uuid16 & 0x0F);
+      *pos = '\0';
+      return std::string(buf);
+
     case ESP_UUID_LEN_32:
-      return str_snprintf("0x%02" PRIX32 "%02" PRIX32 "%02" PRIX32 "%02" PRIX32, 10, (this->uuid_.uuid.uuid32 >> 24),
-                          (this->uuid_.uuid.uuid32 >> 16 & 0xff), (this->uuid_.uuid.uuid32 >> 8 & 0xff),
-                          this->uuid_.uuid.uuid32 & 0xff);
+      *pos++ = '0';
+      *pos++ = 'x';
+      for (int shift = 28; shift >= 0; shift -= 4) {
+        *pos++ = format_hex_pretty_char((this->uuid_.uuid.uuid32 >> shift) & 0x0F);
+      }
+      *pos = '\0';
+      return std::string(buf);
+
     default:
     case ESP_UUID_LEN_128:
-      std::string buf;
+      // Format: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
       for (int8_t i = 15; i >= 0; i--) {
-        buf += str_snprintf("%02X", 2, this->uuid_.uuid.uuid128[i]);
-        if (i == 6 || i == 8 || i == 10 || i == 12)
-          buf += "-";
+        uint8_t byte = this->uuid_.uuid.uuid128[i];
+        *pos++ = format_hex_pretty_char(byte >> 4);
+        *pos++ = format_hex_pretty_char(byte & 0x0F);
+        if (i == 12 || i == 10 || i == 8 || i == 6) {
+          *pos++ = '-';
+        }
       }
-      return buf;
+      *pos = '\0';
+      return std::string(buf);
   }
   return "";
 }