Reorder Application to reduce padding

Co-authored-by: J. Nick Koston <nick@koston.org>

esphome/codegen.py

@@ -22,6 +22,7 @@ from esphome.cpp_generator import (  # noqa: F401
     TemplateArguments,
     add,
     add_build_flag,
+    add_build_unflag,
     add_define,
     add_global,
     add_library,
@@ -34,6 +35,7 @@ from esphome.cpp_generator import (  # noqa: F401
     process_lambda,
     progmem_array,
     safe_exp,
+    set_cpp_standard,
     statement,
     static_const_array,
     templatable,

esphome/components/api/api_connection.cpp

@@ -260,7 +260,7 @@ uint16_t APIConnection::encode_message_to_buffer(ProtoMessage &msg, uint16_t mes
     return 0;  // Doesn't fit
   }
 
-  // Allocate exact buffer space needed (just the payload, not the overhead)
+  // Allocate buffer space - pass payload size, allocation functions add header/footer space
   ProtoWriteBuffer buffer =
       is_single ? conn->allocate_single_message_buffer(size) : conn->allocate_batch_message_buffer(size);
 

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -58,7 +58,7 @@ static std::vector<api::BluetoothLERawAdvertisement> &get_batch_buffer() {
   return batch_buffer;
 }
 
-bool BluetoothProxy::parse_devices(const esp32_ble::BLEScanResult *scan_results, size_t count) {
+bool BluetoothProxy::parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) {
   if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr || !this->raw_advertisements_)
     return false;
 
@@ -73,7 +73,7 @@ bool BluetoothProxy::parse_devices(const esp32_ble::BLEScanResult *scan_results,
 
   // Add new advertisements to the batch buffer
   for (size_t i = 0; i < count; i++) {
-    auto &result = scan_results[i];
+    auto &result = advertisements[i];
     uint8_t length = result.adv_data_len + result.scan_rsp_len;
 
     batch_buffer.emplace_back();

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -52,7 +52,7 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
  public:
   BluetoothProxy();
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
-  bool parse_devices(const esp32_ble::BLEScanResult *scan_results, size_t count) override;
+  bool parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) override;
   void dump_config() override;
   void setup() override;
   void loop() override;

esphome/components/esp32/__init__.py

@@ -94,6 +94,13 @@ COMPILER_OPTIMIZATIONS = {
     "SIZE": "CONFIG_COMPILER_OPTIMIZATION_SIZE",
 }
 
+ARDUINO_ALLOWED_VARIANTS = [
+    VARIANT_ESP32,
+    VARIANT_ESP32C3,
+    VARIANT_ESP32S2,
+    VARIANT_ESP32S3,
+]
+
 
 def get_cpu_frequencies(*frequencies):
     return [str(x) + "MHZ" for x in frequencies]
@@ -143,12 +150,17 @@ def set_core_data(config):
         CORE.data[KEY_ESP32][KEY_COMPONENTS] = {}
     elif conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
         CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK] = "arduino"
+        if variant not in ARDUINO_ALLOWED_VARIANTS:
+            raise cv.Invalid(
+                f"ESPHome does not support using the Arduino framework for the {variant}. Please use the ESP-IDF framework instead.",
+                path=[CONF_FRAMEWORK, CONF_TYPE],
+            )
     CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = cv.Version.parse(
         config[CONF_FRAMEWORK][CONF_VERSION]
     )
 
     CORE.data[KEY_ESP32][KEY_BOARD] = config[CONF_BOARD]
-    CORE.data[KEY_ESP32][KEY_VARIANT] = config[CONF_VARIANT]
+    CORE.data[KEY_ESP32][KEY_VARIANT] = variant
     CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES] = {}
 
     return config
@@ -618,6 +630,21 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
 )
 
 
+def _set_default_framework(config):
+    if CONF_FRAMEWORK not in config:
+        config = config.copy()
+
+        variant = config[CONF_VARIANT]
+        if variant in ARDUINO_ALLOWED_VARIANTS:
+            config[CONF_FRAMEWORK] = ARDUINO_FRAMEWORK_SCHEMA({})
+            config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ARDUINO
+        else:
+            config[CONF_FRAMEWORK] = ESP_IDF_FRAMEWORK_SCHEMA({})
+            config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ESP_IDF
+
+    return config
+
+
 FRAMEWORK_ESP_IDF = "esp-idf"
 FRAMEWORK_ARDUINO = "arduino"
 FRAMEWORK_SCHEMA = cv.typed_schema(
@@ -627,7 +654,6 @@ FRAMEWORK_SCHEMA = cv.typed_schema(
     },
     lower=True,
     space="-",
-    default_type=FRAMEWORK_ARDUINO,
 )
 
 
@@ -654,10 +680,11 @@ CONFIG_SCHEMA = cv.All(
             ),
             cv.Optional(CONF_PARTITIONS): cv.file_,
             cv.Optional(CONF_VARIANT): cv.one_of(*VARIANTS, upper=True),
-            cv.Optional(CONF_FRAMEWORK, default={}): FRAMEWORK_SCHEMA,
+            cv.Optional(CONF_FRAMEWORK): FRAMEWORK_SCHEMA,
         }
     ),
     _detect_variant,
+    _set_default_framework,
     set_core_data,
 )
 
@@ -668,6 +695,7 @@ FINAL_VALIDATE_SCHEMA = cv.Schema(final_validate)
 async def to_code(config):
     cg.add_platformio_option("board", config[CONF_BOARD])
     cg.add_platformio_option("board_upload.flash_size", config[CONF_FLASH_SIZE])
+    cg.set_cpp_standard("gnu++17")
     cg.add_build_flag("-DUSE_ESP32")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
     cg.add_build_flag(f"-DUSE_ESP32_VARIANT_{config[CONF_VARIANT]}")

esphome/components/esp32_ble/ble.cpp

@@ -23,9 +23,6 @@ namespace esp32_ble {
 
 static const char *const TAG = "esp32_ble";
 
-// Maximum size of the BLE event queue
-static constexpr size_t MAX_BLE_QUEUE_SIZE = SCAN_RESULT_BUFFER_SIZE * 2;
-
 static RAMAllocator<BLEEvent> EVENT_ALLOCATOR(  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
     RAMAllocator<BLEEvent>::ALLOW_FAILURE | RAMAllocator<BLEEvent>::ALLOC_INTERNAL);
 
@@ -307,52 +304,20 @@ void ESP32BLE::loop() {
   BLEEvent *ble_event = this->ble_events_.pop();
   while (ble_event != nullptr) {
     switch (ble_event->type_) {
-      case BLEEvent::GATTS: {
-        esp_gatts_cb_event_t event = ble_event->event_.gatts.gatts_event;
-        esp_gatt_if_t gatts_if = ble_event->event_.gatts.gatts_if;
-        esp_ble_gatts_cb_param_t *param = ble_event->event_.gatts.gatts_param;
-        ESP_LOGV(TAG, "gatts_event [esp_gatt_if: %d] - %d", gatts_if, event);
-        for (auto *gatts_handler : this->gatts_event_handlers_) {
-          gatts_handler->gatts_event_handler(event, gatts_if, param);
-        }
+      case BLEEvent::GATTS:
+        this->real_gatts_event_handler_(ble_event->event_.gatts.gatts_event, ble_event->event_.gatts.gatts_if,
+                                        &ble_event->event_.gatts.gatts_param);
         break;
-      }
-      case BLEEvent::GATTC: {
-        esp_gattc_cb_event_t event = ble_event->event_.gattc.gattc_event;
-        esp_gatt_if_t gattc_if = ble_event->event_.gattc.gattc_if;
-        esp_ble_gattc_cb_param_t *param = ble_event->event_.gattc.gattc_param;
-        ESP_LOGV(TAG, "gattc_event [esp_gatt_if: %d] - %d", gattc_if, event);
-        for (auto *gattc_handler : this->gattc_event_handlers_) {
-          gattc_handler->gattc_event_handler(event, gattc_if, param);
-        }
+      case BLEEvent::GATTC:
+        this->real_gattc_event_handler_(ble_event->event_.gattc.gattc_event, ble_event->event_.gattc.gattc_if,
+                                        &ble_event->event_.gattc.gattc_param);
         break;
-      }
-      case BLEEvent::GAP: {
-        esp_gap_ble_cb_event_t gap_event = ble_event->event_.gap.gap_event;
-        if (gap_event == ESP_GAP_BLE_SCAN_RESULT_EVT) {
-          // Use the new scan event handler - no memcpy!
-          for (auto *scan_handler : this->gap_scan_event_handlers_) {
-            scan_handler->gap_scan_event_handler(ble_event->scan_result());
-          }
-        } else if (gap_event == ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT ||
-                   gap_event == ESP_GAP_BLE_SCAN_START_COMPLETE_EVT ||
-                   gap_event == ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT) {
-          // All three scan complete events have the same structure with just status
-          // The scan_complete struct matches ESP-IDF's layout exactly, so this reinterpret_cast is safe
-          // This is verified at compile-time by static_assert checks in ble_event.h
-          // The struct already contains our copy of the status (copied in BLEEvent constructor)
-          ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
-          for (auto *gap_handler : this->gap_event_handlers_) {
-            gap_handler->gap_event_handler(
-                gap_event, reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.scan_complete));
-          }
-        }
+      case BLEEvent::GAP:
+        this->real_gap_event_handler_(ble_event->event_.gap.gap_event, &ble_event->event_.gap.gap_param);
         break;
-      }
       default:
         break;
     }
-    // Destructor will clean up external allocations for GATTC/GATTS
     ble_event->~BLEEvent();
     EVENT_ALLOCATOR.deallocate(ble_event, 1);
     ble_event = this->ble_events_.pop();
@@ -362,55 +327,59 @@ void ESP32BLE::loop() {
   }
 }
 
-template<typename... Args> void enqueue_ble_event(Args... args) {
-  if (global_ble->ble_events_.size() >= MAX_BLE_QUEUE_SIZE) {
-    ESP_LOGD(TAG, "BLE event queue full (%zu), dropping event", MAX_BLE_QUEUE_SIZE);
-    return;
-  }
-
+void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
   BLEEvent *new_event = EVENT_ALLOCATOR.allocate(1);
   if (new_event == nullptr) {
     // Memory too fragmented to allocate new event. Can only drop it until memory comes back
     return;
   }
-  new (new_event) BLEEvent(args...);
+  new (new_event) BLEEvent(event, param);
   global_ble->ble_events_.push(new_event);
 }  // NOLINT(clang-analyzer-unix.Malloc)
 
-// Explicit template instantiations for the friend function
-template void enqueue_ble_event(esp_gap_ble_cb_event_t, esp_ble_gap_cb_param_t *);
-template void enqueue_ble_event(esp_gatts_cb_event_t, esp_gatt_if_t, esp_ble_gatts_cb_param_t *);
-template void enqueue_ble_event(esp_gattc_cb_event_t, esp_gatt_if_t, esp_ble_gattc_cb_param_t *);
-
-void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
-  switch (event) {
-    // Only queue the 4 GAP events we actually handle
-    case ESP_GAP_BLE_SCAN_RESULT_EVT:
-    case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
-    case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
-    case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
-      enqueue_ble_event(event, param);
-      return;
-
-    // Ignore these GAP events as they are not relevant for our use case
-    case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
-    case ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT:
-      return;
-
-    default:
-      break;
+void ESP32BLE::real_gap_event_handler_(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
+  ESP_LOGV(TAG, "(BLE) gap_event_handler - %d", event);
+  for (auto *gap_handler : this->gap_event_handlers_) {
+    gap_handler->gap_event_handler(event, param);
   }
-  ESP_LOGW(TAG, "Ignoring unexpected GAP event type: %d", event);
 }
 
 void ESP32BLE::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
                                    esp_ble_gatts_cb_param_t *param) {
-  enqueue_ble_event(event, gatts_if, param);
+  BLEEvent *new_event = EVENT_ALLOCATOR.allocate(1);
+  if (new_event == nullptr) {
+    // Memory too fragmented to allocate new event. Can only drop it until memory comes back
+    return;
+  }
+  new (new_event) BLEEvent(event, gatts_if, param);
+  global_ble->ble_events_.push(new_event);
+}  // NOLINT(clang-analyzer-unix.Malloc)
+
+void ESP32BLE::real_gatts_event_handler_(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
+                                         esp_ble_gatts_cb_param_t *param) {
+  ESP_LOGV(TAG, "(BLE) gatts_event [esp_gatt_if: %d] - %d", gatts_if, event);
+  for (auto *gatts_handler : this->gatts_event_handlers_) {
+    gatts_handler->gatts_event_handler(event, gatts_if, param);
+  }
 }
 
 void ESP32BLE::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                    esp_ble_gattc_cb_param_t *param) {
-  enqueue_ble_event(event, gattc_if, param);
+  BLEEvent *new_event = EVENT_ALLOCATOR.allocate(1);
+  if (new_event == nullptr) {
+    // Memory too fragmented to allocate new event. Can only drop it until memory comes back
+    return;
+  }
+  new (new_event) BLEEvent(event, gattc_if, param);
+  global_ble->ble_events_.push(new_event);
+}  // NOLINT(clang-analyzer-unix.Malloc)
+
+void ESP32BLE::real_gattc_event_handler_(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                                         esp_ble_gattc_cb_param_t *param) {
+  ESP_LOGV(TAG, "(BLE) gattc_event [esp_gatt_if: %d] - %d", gattc_if, event);
+  for (auto *gattc_handler : this->gattc_event_handlers_) {
+    gattc_handler->gattc_event_handler(event, gattc_if, param);
+  }
 }
 
 float ESP32BLE::get_setup_priority() const { return setup_priority::BLUETOOTH; }

esphome/components/esp32_ble/ble.h

@@ -2,7 +2,6 @@
 
 #include "ble_advertising.h"
 #include "ble_uuid.h"
-#include "ble_scan_result.h"
 
 #include <functional>
 
@@ -23,13 +22,6 @@
 namespace esphome {
 namespace esp32_ble {
 
-// Maximum number of BLE scan results to buffer
-#ifdef USE_PSRAM
-static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 32;
-#else
-static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 20;
-#endif
-
 uint64_t ble_addr_to_uint64(const esp_bd_addr_t address);
 
 // NOLINTNEXTLINE(modernize-use-using)
@@ -65,11 +57,6 @@ class GAPEventHandler {
   virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) = 0;
 };
 
-class GAPScanEventHandler {
- public:
-  virtual void gap_scan_event_handler(const BLEScanResult &scan_result) = 0;
-};
-
 class GATTcEventHandler {
  public:
   virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
@@ -114,9 +101,6 @@ class ESP32BLE : public Component {
   void advertising_register_raw_advertisement_callback(std::function<void(bool)> &&callback);
 
   void register_gap_event_handler(GAPEventHandler *handler) { this->gap_event_handlers_.push_back(handler); }
-  void register_gap_scan_event_handler(GAPScanEventHandler *handler) {
-    this->gap_scan_event_handlers_.push_back(handler);
-  }
   void register_gattc_event_handler(GATTcEventHandler *handler) { this->gattc_event_handlers_.push_back(handler); }
   void register_gatts_event_handler(GATTsEventHandler *handler) { this->gatts_event_handlers_.push_back(handler); }
   void register_ble_status_event_handler(BLEStatusEventHandler *handler) {
@@ -129,16 +113,16 @@ class ESP32BLE : public Component {
   static void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);
   static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param);
 
+  void real_gatts_event_handler_(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param);
+  void real_gattc_event_handler_(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);
+  void real_gap_event_handler_(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param);
+
   bool ble_setup_();
   bool ble_dismantle_();
   bool ble_pre_setup_();
   void advertising_init_();
 
- private:
-  template<typename... Args> friend void enqueue_ble_event(Args... args);
-
   std::vector<GAPEventHandler *> gap_event_handlers_;
-  std::vector<GAPScanEventHandler *> gap_scan_event_handlers_;
   std::vector<GATTcEventHandler *> gattc_event_handlers_;
   std::vector<GATTsEventHandler *> gatts_event_handlers_;
   std::vector<BLEStatusEventHandler *> ble_status_event_handlers_;

esphome/components/esp32_ble/ble_event.h

@@ -2,232 +2,92 @@
 
 #ifdef USE_ESP32
 
-#include <cstddef>  // for offsetof
 #include <vector>
 
 #include <esp_gap_ble_api.h>
 #include <esp_gattc_api.h>
 #include <esp_gatts_api.h>
 
-#include "ble_scan_result.h"
-
 namespace esphome {
 namespace esp32_ble {
-
-// Compile-time verification that ESP-IDF scan complete events only contain a status field
-// This ensures our reinterpret_cast in ble.cpp is safe
-static_assert(sizeof(esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param) == sizeof(esp_bt_status_t),
-              "ESP-IDF scan_param_cmpl structure has unexpected size");
-static_assert(sizeof(esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param) == sizeof(esp_bt_status_t),
-              "ESP-IDF scan_start_cmpl structure has unexpected size");
-static_assert(sizeof(esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param) == sizeof(esp_bt_status_t),
-              "ESP-IDF scan_stop_cmpl structure has unexpected size");
-
-// Verify the status field is at offset 0 (first member)
-static_assert(offsetof(esp_ble_gap_cb_param_t, scan_param_cmpl.status) ==
-                  offsetof(esp_ble_gap_cb_param_t, scan_param_cmpl),
-              "status must be first member of scan_param_cmpl");
-static_assert(offsetof(esp_ble_gap_cb_param_t, scan_start_cmpl.status) ==
-                  offsetof(esp_ble_gap_cb_param_t, scan_start_cmpl),
-              "status must be first member of scan_start_cmpl");
-static_assert(offsetof(esp_ble_gap_cb_param_t, scan_stop_cmpl.status) ==
-                  offsetof(esp_ble_gap_cb_param_t, scan_stop_cmpl),
-              "status must be first member of scan_stop_cmpl");
-
 // Received GAP, GATTC and GATTS events are only queued, and get processed in the main loop().
-// This class stores each event with minimal memory usage.
-// GAP events (99% of traffic) don't have the vector overhead.
-// GATTC/GATTS events use heap allocation for their param and data.
-//
-// Event flow:
-// 1. ESP-IDF BLE stack calls our static handlers in the BLE task context
-// 2. The handlers create a BLEEvent instance, copying only the data we need
-// 3. The event is pushed to a thread-safe queue
-// 4. In the main loop(), events are popped from the queue and processed
-// 5. The event destructor cleans up any external allocations
-//
-// Thread safety:
-// - GAP events: We copy only the fields we need directly into the union
-// - GATTC/GATTS events: We heap-allocate and copy the entire param struct, ensuring
-//   the data remains valid even after the BLE callback returns. The original
-//   param pointer from ESP-IDF is only valid during the callback.
+// This class stores each event in a single type.
 class BLEEvent {
  public:
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  enum ble_event_t : uint8_t {
-    GAP,
-    GATTC,
-    GATTS,
+  BLEEvent(esp_gap_ble_cb_event_t e, esp_ble_gap_cb_param_t *p) {
+    this->event_.gap.gap_event = e;
+    memcpy(&this->event_.gap.gap_param, p, sizeof(esp_ble_gap_cb_param_t));
+    this->type_ = GAP;
   };
 
-  // Constructor for GAP events - no external allocations needed
-  BLEEvent(esp_gap_ble_cb_event_t e, esp_ble_gap_cb_param_t *p) {
-    this->type_ = GAP;
-    this->event_.gap.gap_event = e;
-
-    if (p == nullptr) {
-      return;  // Invalid event, but we can't log in header file
-    }
-
-    // Only copy the data we actually use for each GAP event type
-    switch (e) {
-      case ESP_GAP_BLE_SCAN_RESULT_EVT:
-        // Copy only the fields we use from scan results
-        memcpy(this->event_.gap.scan_result.bda, p->scan_rst.bda, sizeof(esp_bd_addr_t));
-        this->event_.gap.scan_result.ble_addr_type = p->scan_rst.ble_addr_type;
-        this->event_.gap.scan_result.rssi = p->scan_rst.rssi;
-        this->event_.gap.scan_result.adv_data_len = p->scan_rst.adv_data_len;
-        this->event_.gap.scan_result.scan_rsp_len = p->scan_rst.scan_rsp_len;
-        this->event_.gap.scan_result.search_evt = p->scan_rst.search_evt;
-        memcpy(this->event_.gap.scan_result.ble_adv, p->scan_rst.ble_adv,
-               ESP_BLE_ADV_DATA_LEN_MAX + ESP_BLE_SCAN_RSP_DATA_LEN_MAX);
-        break;
-
-      case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
-        this->event_.gap.scan_complete.status = p->scan_param_cmpl.status;
-        break;
-
-      case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
-        this->event_.gap.scan_complete.status = p->scan_start_cmpl.status;
-        break;
-
-      case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
-        this->event_.gap.scan_complete.status = p->scan_stop_cmpl.status;
-        break;
-
-      default:
-        // We only handle 4 GAP event types, others are dropped
-        break;
-    }
-  }
-
-  // Constructor for GATTC events - uses heap allocation
-  // Creates a copy of the param struct since the original is only valid during the callback
   BLEEvent(esp_gattc_cb_event_t e, esp_gatt_if_t i, esp_ble_gattc_cb_param_t *p) {
-    this->type_ = GATTC;
     this->event_.gattc.gattc_event = e;
     this->event_.gattc.gattc_if = i;
-
-    if (p == nullptr) {
-      this->event_.gattc.gattc_param = nullptr;
-      this->event_.gattc.data = nullptr;
-      return;  // Invalid event, but we can't log in header file
-    }
-
-    // Heap-allocate param and data
-    // Heap allocation is used because GATTC/GATTS events are rare (<1% of events)
-    // while GAP events (99%) are stored inline to minimize memory usage
-    this->event_.gattc.gattc_param = new esp_ble_gattc_cb_param_t(*p);
-
-    // Copy data for events that need it
+    memcpy(&this->event_.gattc.gattc_param, p, sizeof(esp_ble_gattc_cb_param_t));
+    // Need to also make a copy of relevant event data.
     switch (e) {
       case ESP_GATTC_NOTIFY_EVT:
-        this->event_.gattc.data = new std::vector<uint8_t>(p->notify.value, p->notify.value + p->notify.value_len);
-        this->event_.gattc.gattc_param->notify.value = this->event_.gattc.data->data();
+        this->data.assign(p->notify.value, p->notify.value + p->notify.value_len);
+        this->event_.gattc.gattc_param.notify.value = this->data.data();
         break;
       case ESP_GATTC_READ_CHAR_EVT:
       case ESP_GATTC_READ_DESCR_EVT:
-        this->event_.gattc.data = new std::vector<uint8_t>(p->read.value, p->read.value + p->read.value_len);
-        this->event_.gattc.gattc_param->read.value = this->event_.gattc.data->data();
+        this->data.assign(p->read.value, p->read.value + p->read.value_len);
+        this->event_.gattc.gattc_param.read.value = this->data.data();
         break;
       default:
-        this->event_.gattc.data = nullptr;
         break;
     }
-  }
+    this->type_ = GATTC;
+  };
 
-  // Constructor for GATTS events - uses heap allocation
-  // Creates a copy of the param struct since the original is only valid during the callback
   BLEEvent(esp_gatts_cb_event_t e, esp_gatt_if_t i, esp_ble_gatts_cb_param_t *p) {
-    this->type_ = GATTS;
     this->event_.gatts.gatts_event = e;
     this->event_.gatts.gatts_if = i;
-
-    if (p == nullptr) {
-      this->event_.gatts.gatts_param = nullptr;
-      this->event_.gatts.data = nullptr;
-      return;  // Invalid event, but we can't log in header file
-    }
-
-    // Heap-allocate param and data
-    // Heap allocation is used because GATTC/GATTS events are rare (<1% of events)
-    // while GAP events (99%) are stored inline to minimize memory usage
-    this->event_.gatts.gatts_param = new esp_ble_gatts_cb_param_t(*p);
-
-    // Copy data for events that need it
+    memcpy(&this->event_.gatts.gatts_param, p, sizeof(esp_ble_gatts_cb_param_t));
+    // Need to also make a copy of relevant event data.
     switch (e) {
       case ESP_GATTS_WRITE_EVT:
-        this->event_.gatts.data = new std::vector<uint8_t>(p->write.value, p->write.value + p->write.len);
-        this->event_.gatts.gatts_param->write.value = this->event_.gatts.data->data();
-        break;
-      default:
-        this->event_.gatts.data = nullptr;
-        break;
-    }
-  }
-
-  // Destructor to clean up heap allocations
-  ~BLEEvent() {
-    switch (this->type_) {
-      case GATTC:
-        delete this->event_.gattc.gattc_param;
-        delete this->event_.gattc.data;
-        break;
-      case GATTS:
-        delete this->event_.gatts.gatts_param;
-        delete this->event_.gatts.data;
+        this->data.assign(p->write.value, p->write.value + p->write.len);
+        this->event_.gatts.gatts_param.write.value = this->data.data();
         break;
       default:
         break;
     }
-  }
-
-  // Disable copy to prevent double-delete
-  BLEEvent(const BLEEvent &) = delete;
-  BLEEvent &operator=(const BLEEvent &) = delete;
+    this->type_ = GATTS;
+  };
 
   union {
     // NOLINTNEXTLINE(readability-identifier-naming)
     struct gap_event {
       esp_gap_ble_cb_event_t gap_event;
-      union {
-        BLEScanResult scan_result;  // 73 bytes
-        // This matches ESP-IDF's scan complete event structures
-        // All three (scan_param_cmpl, scan_start_cmpl, scan_stop_cmpl) have identical layout
-        struct {
-          esp_bt_status_t status;
-        } scan_complete;  // 1 byte
-      };
-    } gap;  // 80 bytes total
+      esp_ble_gap_cb_param_t gap_param;
+    } gap;
 
     // NOLINTNEXTLINE(readability-identifier-naming)
     struct gattc_event {
       esp_gattc_cb_event_t gattc_event;
       esp_gatt_if_t gattc_if;
-      esp_ble_gattc_cb_param_t *gattc_param;  // Heap-allocated
-      std::vector<uint8_t> *data;             // Heap-allocated
-    } gattc;                                  // 16 bytes (pointers only)
+      esp_ble_gattc_cb_param_t gattc_param;
+    } gattc;
 
     // NOLINTNEXTLINE(readability-identifier-naming)
     struct gatts_event {
       esp_gatts_cb_event_t gatts_event;
       esp_gatt_if_t gatts_if;
-      esp_ble_gatts_cb_param_t *gatts_param;  // Heap-allocated
-      std::vector<uint8_t> *data;             // Heap-allocated
-    } gatts;                                  // 16 bytes (pointers only)
-  } event_;                                   // 80 bytes
+      esp_ble_gatts_cb_param_t gatts_param;
+    } gatts;
+  } event_;
 
-  ble_event_t type_;
-
-  // Helper methods to access event data
-  ble_event_t type() const { return type_; }
-  esp_gap_ble_cb_event_t gap_event_type() const { return event_.gap.gap_event; }
-  const BLEScanResult &scan_result() const { return event_.gap.scan_result; }
-  esp_bt_status_t scan_complete_status() const { return event_.gap.scan_complete.status; }
+  std::vector<uint8_t> data{};
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  enum ble_event_t : uint8_t {
+    GAP,
+    GATTC,
+    GATTS,
+  } type_;
 };
 
-// BLEEvent total size: 84 bytes (80 byte union + 1 byte type + 3 bytes padding)
-
 }  // namespace esp32_ble
 }  // namespace esphome
 

esphome/components/esp32_ble/ble_scan_result.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP32
-
-#include <esp_gap_ble_api.h>
-
-namespace esphome {
-namespace esp32_ble {
-
-// Structure for BLE scan results - only fields we actually use
-struct __attribute__((packed)) BLEScanResult {
-  esp_bd_addr_t bda;
-  uint8_t ble_addr_type;
-  int8_t rssi;
-  uint8_t ble_adv[ESP_BLE_ADV_DATA_LEN_MAX + ESP_BLE_SCAN_RSP_DATA_LEN_MAX];
-  uint8_t adv_data_len;
-  uint8_t scan_rsp_len;
-  uint8_t search_evt;
-};  // ~73 bytes vs ~400 bytes for full esp_ble_gap_cb_param_t
-
-}  // namespace esp32_ble
-}  // namespace esphome
-
-#endif

esphome/components/esp32_ble/queue.h

@@ -45,17 +45,6 @@ template<class T> class Queue {
     return element;
   }
 
-  size_t size() const {
-    // Lock-free size check. While std::queue::size() is not thread-safe, we intentionally
-    // avoid locking here to prevent blocking the BLE callback thread. The size is only
-    // used to decide whether to drop incoming events when the queue is near capacity.
-    // With a queue limit of 40-64 events and normal processing, dropping events should
-    // be extremely rare. When it does approach capacity, being off by 1-2 events is
-    // acceptable to avoid blocking the BLE stack's time-sensitive callbacks.
-    // Trade-off: We prefer occasional dropped events over potential BLE stack delays.
-    return q_.size();
-  }
-
  protected:
   std::queue<T *> q_;
   SemaphoreHandle_t m_;

esphome/components/esp32_ble_tracker/__init__.py

@@ -268,7 +268,6 @@ async def to_code(config):
 
     parent = await cg.get_variable(config[esp32_ble.CONF_BLE_ID])
     cg.add(parent.register_gap_event_handler(var))
-    cg.add(parent.register_gap_scan_event_handler(var))
     cg.add(parent.register_gattc_event_handler(var))
     cg.add(parent.register_ble_status_event_handler(var))
     cg.add(var.set_parent(parent))

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -50,8 +50,9 @@ void ESP32BLETracker::setup() {
     ESP_LOGE(TAG, "BLE Tracker was marked failed by ESP32BLE");
     return;
   }
-  ExternalRAMAllocator<BLEScanResult> allocator(ExternalRAMAllocator<BLEScanResult>::ALLOW_FAILURE);
-  this->scan_result_buffer_ = allocator.allocate(SCAN_RESULT_BUFFER_SIZE);
+  ExternalRAMAllocator<esp_ble_gap_cb_param_t::ble_scan_result_evt_param> allocator(
+      ExternalRAMAllocator<esp_ble_gap_cb_param_t::ble_scan_result_evt_param>::ALLOW_FAILURE);
+  this->scan_result_buffer_ = allocator.allocate(ESP32BLETracker::SCAN_RESULT_BUFFER_SIZE);
 
   if (this->scan_result_buffer_ == nullptr) {
     ESP_LOGE(TAG, "Could not allocate buffer for BLE Tracker!");
@@ -123,7 +124,7 @@ void ESP32BLETracker::loop() {
       this->scan_result_index_ &&  // if it looks like we have a scan result we will take the lock
       xSemaphoreTake(this->scan_result_lock_, 0)) {
     uint32_t index = this->scan_result_index_;
-    if (index >= SCAN_RESULT_BUFFER_SIZE) {
+    if (index >= ESP32BLETracker::SCAN_RESULT_BUFFER_SIZE) {
       ESP_LOGW(TAG, "Too many BLE events to process. Some devices may not show up.");
     }
 
@@ -369,6 +370,9 @@ void ESP32BLETracker::recalculate_advertisement_parser_types() {
 
 void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
   switch (event) {
+    case ESP_GAP_BLE_SCAN_RESULT_EVT:
+      this->gap_scan_result_(param->scan_rst);
+      break;
     case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
       this->gap_scan_set_param_complete_(param->scan_param_cmpl);
       break;
@@ -381,42 +385,11 @@ void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_ga
     default:
       break;
   }
-  // Forward all events to clients (scan results are handled separately via gap_scan_event_handler)
   for (auto *client : this->clients_) {
     client->gap_event_handler(event, param);
   }
 }
 
-void ESP32BLETracker::gap_scan_event_handler(const BLEScanResult &scan_result) {
-  ESP_LOGV(TAG, "gap_scan_result - event %d", scan_result.search_evt);
-
-  if (scan_result.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
-    if (xSemaphoreTake(this->scan_result_lock_, 0)) {
-      if (this->scan_result_index_ < SCAN_RESULT_BUFFER_SIZE) {
-        // Store BLEScanResult directly in our buffer
-        this->scan_result_buffer_[this->scan_result_index_++] = scan_result;
-      }
-      xSemaphoreGive(this->scan_result_lock_);
-    }
-  } else if (scan_result.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
-    // Scan finished on its own
-    if (this->scanner_state_ != ScannerState::RUNNING) {
-      if (this->scanner_state_ == ScannerState::STOPPING) {
-        ESP_LOGE(TAG, "Scan was not running when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::STARTING) {
-        ESP_LOGE(TAG, "Scan was not started when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::FAILED) {
-        ESP_LOGE(TAG, "Scan was in failed state when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::IDLE) {
-        ESP_LOGE(TAG, "Scan was idle when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::STOPPED) {
-        ESP_LOGE(TAG, "Scan was stopped when scan completed.");
-      }
-    }
-    this->set_scanner_state_(ScannerState::STOPPED);
-  }
-}
-
 void ESP32BLETracker::gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param &param) {
   ESP_LOGV(TAG, "gap_scan_set_param_complete - status %d", param.status);
   if (param.status == ESP_BT_STATUS_DONE) {
@@ -471,6 +444,34 @@ void ESP32BLETracker::gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_
   this->set_scanner_state_(ScannerState::STOPPED);
 }
 
+void ESP32BLETracker::gap_scan_result_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
+  ESP_LOGV(TAG, "gap_scan_result - event %d", param.search_evt);
+  if (param.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
+    if (xSemaphoreTake(this->scan_result_lock_, 0)) {
+      if (this->scan_result_index_ < ESP32BLETracker::SCAN_RESULT_BUFFER_SIZE) {
+        this->scan_result_buffer_[this->scan_result_index_++] = param;
+      }
+      xSemaphoreGive(this->scan_result_lock_);
+    }
+  } else if (param.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
+    // Scan finished on its own
+    if (this->scanner_state_ != ScannerState::RUNNING) {
+      if (this->scanner_state_ == ScannerState::STOPPING) {
+        ESP_LOGE(TAG, "Scan was not running when scan completed.");
+      } else if (this->scanner_state_ == ScannerState::STARTING) {
+        ESP_LOGE(TAG, "Scan was not started when scan completed.");
+      } else if (this->scanner_state_ == ScannerState::FAILED) {
+        ESP_LOGE(TAG, "Scan was in failed state when scan completed.");
+      } else if (this->scanner_state_ == ScannerState::IDLE) {
+        ESP_LOGE(TAG, "Scan was idle when scan completed.");
+      } else if (this->scanner_state_ == ScannerState::STOPPED) {
+        ESP_LOGE(TAG, "Scan was stopped when scan completed.");
+      }
+    }
+    this->set_scanner_state_(ScannerState::STOPPED);
+  }
+}
+
 void ESP32BLETracker::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                           esp_ble_gattc_cb_param_t *param) {
   for (auto *client : this->clients_) {
@@ -493,15 +494,13 @@ optional<ESPBLEiBeacon> ESPBLEiBeacon::from_manufacturer_data(const ServiceData
   return ESPBLEiBeacon(data.data.data());
 }
 
-void ESPBTDevice::parse_scan_rst(const BLEScanResult &scan_result) {
+void ESPBTDevice::parse_scan_rst(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
+  this->scan_result_ = param;
   for (uint8_t i = 0; i < ESP_BD_ADDR_LEN; i++)
-    this->address_[i] = scan_result.bda[i];
-  this->address_type_ = static_cast<esp_ble_addr_type_t>(scan_result.ble_addr_type);
-  this->rssi_ = scan_result.rssi;
-
-  // Parse advertisement data directly
-  uint8_t total_len = scan_result.adv_data_len + scan_result.scan_rsp_len;
-  this->parse_adv_(scan_result.ble_adv, total_len);
+    this->address_[i] = param.bda[i];
+  this->address_type_ = param.ble_addr_type;
+  this->rssi_ = param.rssi;
+  this->parse_adv_(param);
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
   ESP_LOGVV(TAG, "Parse Result:");
@@ -559,13 +558,13 @@ void ESPBTDevice::parse_scan_rst(const BLEScanResult &scan_result) {
     ESP_LOGVV(TAG, "    Data: %s", format_hex_pretty(data.data).c_str());
   }
 
-  ESP_LOGVV(TAG, "  Adv data: %s",
-            format_hex_pretty(scan_result.ble_adv, scan_result.adv_data_len + scan_result.scan_rsp_len).c_str());
+  ESP_LOGVV(TAG, "  Adv data: %s", format_hex_pretty(param.ble_adv, param.adv_data_len + param.scan_rsp_len).c_str());
 #endif
 }
-
-void ESPBTDevice::parse_adv_(const uint8_t *payload, uint8_t len) {
+void ESPBTDevice::parse_adv_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
   size_t offset = 0;
+  const uint8_t *payload = param.ble_adv;
+  uint8_t len = param.adv_data_len + param.scan_rsp_len;
 
   while (offset + 2 < len) {
     const uint8_t field_length = payload[offset++];  // First byte is length of adv record

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -62,7 +62,7 @@ class ESPBLEiBeacon {
 
 class ESPBTDevice {
  public:
-  void parse_scan_rst(const BLEScanResult &scan_result);
+  void parse_scan_rst(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param);
 
   std::string address_str() const;
 
@@ -84,6 +84,8 @@ class ESPBTDevice {
 
   const std::vector<ServiceData> &get_service_datas() const { return service_datas_; }
 
+  const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &get_scan_result() const { return scan_result_; }
+
   bool resolve_irk(const uint8_t *irk) const;
 
   optional<ESPBLEiBeacon> get_ibeacon() const {
@@ -96,7 +98,7 @@ class ESPBTDevice {
   }
 
  protected:
-  void parse_adv_(const uint8_t *payload, uint8_t len);
+  void parse_adv_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param);
 
   esp_bd_addr_t address_{
       0,
@@ -110,6 +112,7 @@ class ESPBTDevice {
   std::vector<ESPBTUUID> service_uuids_{};
   std::vector<ServiceData> manufacturer_datas_{};
   std::vector<ServiceData> service_datas_{};
+  esp_ble_gap_cb_param_t::ble_scan_result_evt_param scan_result_{};
 };
 
 class ESP32BLETracker;
@@ -118,7 +121,9 @@ class ESPBTDeviceListener {
  public:
   virtual void on_scan_end() {}
   virtual bool parse_device(const ESPBTDevice &device) = 0;
-  virtual bool parse_devices(const BLEScanResult *scan_results, size_t count) { return false; };
+  virtual bool parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) {
+    return false;
+  };
   virtual AdvertisementParserType get_advertisement_parser_type() {
     return AdvertisementParserType::PARSED_ADVERTISEMENTS;
   };
@@ -205,7 +210,6 @@ class ESPBTClient : public ESPBTDeviceListener {
 
 class ESP32BLETracker : public Component,
                         public GAPEventHandler,
-                        public GAPScanEventHandler,
                         public GATTcEventHandler,
                         public BLEStatusEventHandler,
                         public Parented<ESP32BLE> {
@@ -236,7 +240,6 @@ class ESP32BLETracker : public Component,
   void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                            esp_ble_gattc_cb_param_t *param) override;
   void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) override;
-  void gap_scan_event_handler(const BLEScanResult &scan_result) override;
   void ble_before_disabled_event_handler() override;
 
   void add_scanner_state_callback(std::function<void(ScannerState)> &&callback) {
@@ -284,7 +287,12 @@ class ESP32BLETracker : public Component,
   bool parse_advertisements_{false};
   SemaphoreHandle_t scan_result_lock_;
   size_t scan_result_index_{0};
-  BLEScanResult *scan_result_buffer_;
+#ifdef USE_PSRAM
+  const static u_int8_t SCAN_RESULT_BUFFER_SIZE = 32;
+#else
+  const static u_int8_t SCAN_RESULT_BUFFER_SIZE = 20;
+#endif  // USE_PSRAM
+  esp_ble_gap_cb_param_t::ble_scan_result_evt_param *scan_result_buffer_;
   esp_bt_status_t scan_start_failed_{ESP_BT_STATUS_SUCCESS};
   esp_bt_status_t scan_set_param_failed_{ESP_BT_STATUS_SUCCESS};
   int connecting_{0};

esphome/components/esp8266/__init__.py

@@ -183,6 +183,7 @@ async def to_code(config):
 
     cg.add_platformio_option("board", config[CONF_BOARD])
     cg.add_build_flag("-DUSE_ESP8266")
+    cg.set_cpp_standard("gnu++17")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
     cg.add_define("ESPHOME_VARIANT", "ESP8266")
 

esphome/components/ina219/ina219.cpp

@@ -129,6 +129,13 @@ void INA219Component::setup() {
   }
 }
 
+void INA219Component::on_powerdown() {
+  // Mode = 0 -> power down
+  if (!this->write_byte_16(INA219_REGISTER_CONFIG, 0)) {
+    ESP_LOGE(TAG, "powerdown error");
+  }
+}
+
 void INA219Component::dump_config() {
   ESP_LOGCONFIG(TAG, "INA219:");
   LOG_I2C_DEVICE(this);

esphome/components/ina219/ina219.h

@@ -15,6 +15,7 @@ class INA219Component : public PollingComponent, public i2c::I2CDevice {
   void dump_config() override;
   float get_setup_priority() const override;
   void update() override;
+  void on_powerdown() override;
 
   void set_shunt_resistance_ohm(float shunt_resistance_ohm) { shunt_resistance_ohm_ = shunt_resistance_ohm; }
   void set_max_current_a(float max_current_a) { max_current_a_ = max_current_a; }

esphome/components/libretiny/__init__.py

@@ -264,6 +264,7 @@ async def component_to_code(config):
     # force using arduino framework
     cg.add_platformio_option("framework", "arduino")
     cg.add_build_flag("-DUSE_ARDUINO")
+    cg.set_cpp_standard("gnu++17")
 
     # disable library compatibility checks
     cg.add_platformio_option("lib_ldf_mode", "off")

esphome/components/logger/logger.cpp

@@ -116,7 +116,7 @@ void Logger::log_vprintf_(int level, const char *tag, int line, const __FlashStr
   if (this->baud_rate_ > 0) {
     this->write_msg_(this->tx_buffer_ + msg_start);
   }
-  this->log_callback_.call(level, tag, this->tx_buffer_ + msg_start);
+  this->call_log_callbacks_(level, tag, this->tx_buffer_ + msg_start);
 
   global_recursion_guard_ = false;
 }
@@ -129,6 +129,19 @@ inline int Logger::level_for(const char *tag) {
   return this->current_level_;
 }
 
+void HOT Logger::call_log_callbacks_(int level, const char *tag, const char *msg) {
+#ifdef USE_ESP32
+  // Suppress network-logging if memory constrained
+  // In some configurations (eg BLE enabled) there may be some transient
+  // memory exhaustion, and trying to log when OOM can lead to a crash. Skipping
+  // here usually allows the stack to recover instead.
+  // See issue #1234 for analysis.
+  if (xPortGetFreeHeapSize() < 2048)
+    return;
+#endif
+  this->log_callback_.call(level, tag, msg);
+}
+
 Logger::Logger(uint32_t baud_rate, size_t tx_buffer_size) : baud_rate_(baud_rate), tx_buffer_size_(tx_buffer_size) {
   // add 1 to buffer size for null terminator
   this->tx_buffer_ = new char[this->tx_buffer_size_ + 1];  // NOLINT
@@ -176,7 +189,7 @@ void Logger::loop() {
                                   this->tx_buffer_size_);
       this->write_footer_to_buffer_(this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
       this->tx_buffer_[this->tx_buffer_at_] = '\0';
-      this->log_callback_.call(message->level, message->tag, this->tx_buffer_);
+      this->call_log_callbacks_(message->level, message->tag, this->tx_buffer_);
       // At this point all the data we need from message has been transferred to the tx_buffer
       // so we can release the message to allow other tasks to use it as soon as possible.
       this->log_buffer_->release_message_main_loop(received_token);

esphome/components/logger/logger.h

@@ -156,6 +156,7 @@ class Logger : public Component {
 #endif
 
  protected:
+  void call_log_callbacks_(int level, const char *tag, const char *msg);
   void write_msg_(const char *msg);
 
   // Format a log message with printf-style arguments and write it to a buffer with header, footer, and null terminator
@@ -190,7 +191,7 @@ class Logger : public Component {
     if (this->baud_rate_ > 0) {
       this->write_msg_(this->tx_buffer_);  // If logging is enabled, write to console
     }
-    this->log_callback_.call(level, tag, this->tx_buffer_);
+    this->call_log_callbacks_(level, tag, this->tx_buffer_);
   }
 
   // Write the body of the log message to the buffer

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -337,23 +337,26 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
 bool Nextion::upload_end_(bool successful) {
   ESP_LOGD(TAG, "TFT upload done: %s", YESNO(successful));
-  this->is_updating_ = false;
-  this->ignore_is_setup_ = false;
-
-  uint32_t baud_rate = this->parent_->get_baud_rate();
-  if (baud_rate != this->original_baud_rate_) {
-    ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
-    this->parent_->set_baud_rate(this->original_baud_rate_);
-    this->parent_->load_settings();
-  }
 
   if (successful) {
     ESP_LOGD(TAG, "Restart");
     delay(1500);  // NOLINT
     App.safe_reboot();
+    delay(1500);  // NOLINT
   } else {
     ESP_LOGE(TAG, "TFT upload failed");
+
+    this->is_updating_ = false;
+    this->ignore_is_setup_ = false;
+
+    uint32_t baud_rate = this->parent_->get_baud_rate();
+    if (baud_rate != this->original_baud_rate_) {
+      ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
+      this->parent_->set_baud_rate(this->original_baud_rate_);
+      this->parent_->load_settings();
+    }
   }
+
   return successful;
 }
 

esphome/components/nextion/nextion_upload_idf.cpp

@@ -337,15 +337,6 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
 bool Nextion::upload_end_(bool successful) {
   ESP_LOGD(TAG, "TFT upload done: %s", YESNO(successful));
-  this->is_updating_ = false;
-  this->ignore_is_setup_ = false;
-
-  uint32_t baud_rate = this->parent_->get_baud_rate();
-  if (baud_rate != this->original_baud_rate_) {
-    ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
-    this->parent_->set_baud_rate(this->original_baud_rate_);
-    this->parent_->load_settings();
-  }
 
   if (successful) {
     ESP_LOGD(TAG, "Restart");
@@ -353,7 +344,18 @@ bool Nextion::upload_end_(bool successful) {
     App.safe_reboot();
   } else {
     ESP_LOGE(TAG, "TFT upload failed");
+
+    this->is_updating_ = false;
+    this->ignore_is_setup_ = false;
+
+    uint32_t baud_rate = this->parent_->get_baud_rate();
+    if (baud_rate != this->original_baud_rate_) {
+      ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
+      this->parent_->set_baud_rate(this->original_baud_rate_);
+      this->parent_->load_settings();
+    }
   }
+
   return successful;
 }
 

esphome/components/prometheus/__init__.py

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

esphome/components/rp2040/__init__.py

@@ -167,6 +167,7 @@ async def to_code(config):
     cg.add_platformio_option("lib_ldf_mode", "chain+")
     cg.add_platformio_option("board", config[CONF_BOARD])
     cg.add_build_flag("-DUSE_RP2040")
+    cg.set_cpp_standard("gnu++17")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
     cg.add_define("ESPHOME_VARIANT", "RP2040")
 

esphome/components/runtime_stats/__init__.py

@@ -1,26 +0,0 @@
-"""
-Runtime statistics component for ESPHome.
-"""
-
-import esphome.codegen as cg
-import esphome.config_validation as cv
-
-DEPENDENCIES = []
-
-CONF_ENABLED = "enabled"
-CONF_LOG_INTERVAL = "log_interval"
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.Optional(CONF_ENABLED, default=True): cv.boolean,
-        cv.Optional(
-            CONF_LOG_INTERVAL, default=60000
-        ): cv.positive_time_period_milliseconds,
-    }
-)
-
-
-async def to_code(config):
-    """Generate code for the runtime statistics component."""
-    cg.add(cg.App.set_runtime_stats_enabled(config[CONF_ENABLED]))
-    cg.add(cg.App.set_runtime_stats_log_interval(config[CONF_LOG_INTERVAL]))

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -110,15 +110,7 @@ void TemplateAlarmControlPanel::loop() {
       delay = this->arming_night_time_;
     }
     if ((millis() - this->last_update_) > delay) {
-#ifdef USE_BINARY_SENSOR
-      for (auto sensor_info : this->sensor_map_) {
-        // Check for sensors left on and set to bypass automatically and remove them from monitoring
-        if ((sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (sensor_info.first->state)) {
-          ESP_LOGW(TAG, "%s is left on and will be automatically bypassed", sensor_info.first->get_name().c_str());
-          this->bypassed_sensor_indicies_.push_back(sensor_info.second.store_index);
-        }
-      }
-#endif
+      this->bypass_before_arming();
       this->publish_state(this->desired_state_);
     }
     return;
@@ -259,10 +251,23 @@ void TemplateAlarmControlPanel::arm_(optional<std::string> code, alarm_control_p
   if (delay > 0) {
     this->publish_state(ACP_STATE_ARMING);
   } else {
+    this->bypass_before_arming();
     this->publish_state(state);
   }
 }
 
+void TemplateAlarmControlPanel::bypass_before_arming() {
+#ifdef USE_BINARY_SENSOR
+  for (auto sensor_info : this->sensor_map_) {
+    // Check for sensors left on and set to bypass automatically and remove them from monitoring
+    if ((sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (sensor_info.first->state)) {
+      ESP_LOGW(TAG, "'%s' is left on and will be automatically bypassed", sensor_info.first->get_name().c_str());
+      this->bypassed_sensor_indicies_.push_back(sensor_info.second.store_index);
+    }
+  }
+#endif
+}
+
 void TemplateAlarmControlPanel::control(const AlarmControlPanelCall &call) {
   if (call.get_state()) {
     if (call.get_state() == ACP_STATE_ARMED_AWAY) {

esphome/components/template/alarm_control_panel/template_alarm_control_panel.h

@@ -60,6 +60,7 @@ class TemplateAlarmControlPanel : public alarm_control_panel::AlarmControlPanel,
   bool get_requires_code_to_arm() const override { return this->requires_code_to_arm_; }
   bool get_all_sensors_ready() { return this->sensors_ready_; };
   void set_restore_mode(TemplateAlarmControlPanelRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
+  void bypass_before_arming();
 
 #ifdef USE_BINARY_SENSOR
   /** Add a binary_sensor to the alarm_panel.

esphome/components/web_server_idf/__init__.py

@@ -8,8 +8,6 @@ CONFIG_SCHEMA = cv.All(
     cv.only_with_esp_idf,
 )
 
-AUTO_LOAD = ["web_server"]
-
 
 async def to_code(config):
     # Increase the maximum supported size of headers section in HTTP request packet to be processed by the server

esphome/components/web_server_idf/web_server_idf.cpp

@@ -9,10 +9,12 @@
 
 #include "utils.h"
 
+#include "web_server_idf.h"
+
+#ifdef USE_WEBSERVER
 #include "esphome/components/web_server/web_server.h"
 #include "esphome/components/web_server/list_entities.h"
-
-#include "web_server_idf.h"
+#endif  // USE_WEBSERVER
 
 namespace esphome {
 namespace web_server_idf {
@@ -273,6 +275,7 @@ void AsyncResponseStream::printf(const char *fmt, ...) {
   this->print(str);
 }
 
+#ifdef USE_WEBSERVER
 AsyncEventSource::~AsyncEventSource() {
   for (auto *ses : this->sessions_) {
     delete ses;  // NOLINT(cppcoreguidelines-owning-memory)
@@ -511,6 +514,7 @@ void AsyncEventSourceResponse::deferrable_send_state(void *source, const char *e
     }
   }
 }
+#endif
 
 }  // namespace web_server_idf
 }  // namespace esphome

esphome/components/web_server_idf/web_server_idf.h

@@ -1,6 +1,7 @@
 #pragma once
 #ifdef USE_ESP_IDF
 
+#include "esphome/core/defines.h"
 #include <esp_http_server.h>
 
 #include <functional>
@@ -12,10 +13,12 @@
 #include <vector>
 
 namespace esphome {
+#ifdef USE_WEBSERVER
 namespace web_server {
 class WebServer;
 class ListEntitiesIterator;
 };  // namespace web_server
+#endif
 namespace web_server_idf {
 
 #define F(string_literal) (string_literal)
@@ -220,6 +223,7 @@ class AsyncWebHandler {
   virtual bool isRequestHandlerTrivial() { return true; }
 };
 
+#ifdef USE_WEBSERVER
 class AsyncEventSource;
 class AsyncEventSourceResponse;
 
@@ -307,10 +311,13 @@ class AsyncEventSource : public AsyncWebHandler {
   connect_handler_t on_connect_{};
   esphome::web_server::WebServer *web_server_;
 };
+#endif  // USE_WEBSERVER
 
 class DefaultHeaders {
   friend class AsyncWebServerRequest;
+#ifdef USE_WEBSERVER
   friend class AsyncEventSourceResponse;
+#endif
 
  public:
   // NOLINTNEXTLINE(readability-identifier-naming)

esphome/core/__init__.py

@@ -507,6 +507,8 @@ class EsphomeCore:
         self.libraries: list[Library] = []
         # A set of build flags to set in the platformio project
         self.build_flags: set[str] = set()
+        # A set of build unflags to set in the platformio project
+        self.build_unflags: set[str] = set()
         # A set of defines to set for the compile process in esphome/core/defines.h
         self.defines: set[Define] = set()
         # A map of all platformio options to apply
@@ -545,6 +547,7 @@ class EsphomeCore:
         self.global_statements = []
         self.libraries = []
         self.build_flags = set()
+        self.build_unflags = set()
         self.defines = set()
         self.platformio_options = {}
         self.loaded_integrations = set()
@@ -766,11 +769,15 @@ class EsphomeCore:
             self.libraries.append(library)
         return library
 
-    def add_build_flag(self, build_flag):
+    def add_build_flag(self, build_flag: str) -> str:
         self.build_flags.add(build_flag)
         _LOGGER.debug("Adding build flag: %s", build_flag)
         return build_flag
 
+    def add_build_unflag(self, build_unflag: str) -> None:
+        self.build_unflags.add(build_unflag)
+        _LOGGER.debug("Adding build unflag: %s", build_unflag)
+
     def add_define(self, define):
         if isinstance(define, str):
             define = Define(define)

esphome/core/application.h

@@ -7,7 +7,6 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
-#include "esphome/core/runtime_stats.h"
 #include "esphome/core/scheduler.h"
 
 #ifdef USE_SOCKET_SELECT_SUPPORT
@@ -315,18 +314,6 @@ class Application {
 
   uint32_t get_loop_interval() const { return this->loop_interval_; }
 
-  /** Enable or disable runtime statistics collection.
-   *
-   * @param enable Whether to enable runtime statistics collection.
-   */
-  void set_runtime_stats_enabled(bool enable) { runtime_stats.set_enabled(enable); }
-
-  /** Set the interval at which runtime statistics are logged.
-   *
-   * @param interval The interval in milliseconds between logging of runtime statistics.
-   */
-  void set_runtime_stats_log_interval(uint32_t interval) { runtime_stats.set_log_interval(interval); }
-
   void schedule_dump_config() { this->dump_config_at_ = 0; }
 
   void feed_wdt(uint32_t time = 0);
@@ -662,21 +649,27 @@ class Application {
   std::string area_;
   const char *comment_{nullptr};
   const char *compilation_time_{nullptr};
-  bool name_add_mac_suffix_;
+  Component *current_component_{nullptr};
   uint32_t last_loop_{0};
   uint32_t loop_interval_{16};
+<<<<<<< Updated upstream
   size_t dump_config_at_{SIZE_MAX};
   uint32_t app_state_{0};
   Component *current_component_{nullptr};
+=======
+>>>>>>> Stashed changes
   uint32_t loop_component_start_time_{0};
+  size_t dump_config_at_{SIZE_MAX};
+  bool name_add_mac_suffix_;
+  uint8_t app_state_{0};
 
 #ifdef USE_SOCKET_SELECT_SUPPORT
   // Socket select management
   std::vector<int> socket_fds_;     // Vector of all monitored socket file descriptors
-  bool socket_fds_changed_{false};  // Flag to rebuild base_read_fds_ when socket_fds_ changes
-  int max_fd_{-1};                  // Highest file descriptor number for select()
   fd_set base_read_fds_{};          // Cached fd_set rebuilt only when socket_fds_ changes
   fd_set read_fds_{};               // Working fd_set for select(), copied from base_read_fds_
+  int max_fd_{-1};                  // Highest file descriptor number for select()
+  bool socket_fds_changed_{false};  // Flag to rebuild base_read_fds_ when socket_fds_ changes
 #endif
 };
 

esphome/core/component.cpp

@@ -246,9 +246,6 @@ uint32_t WarnIfComponentBlockingGuard::finish() {
   uint32_t curr_time = millis();
 
   uint32_t blocking_time = curr_time - this->started_;
-
-  // Record component runtime stats
-  runtime_stats.record_component_time(this->component_, blocking_time, curr_time);
   bool should_warn;
   if (this->component_ != nullptr) {
     should_warn = this->component_->should_warn_of_blocking(blocking_time);

esphome/core/component.h

@@ -6,7 +6,6 @@
 #include <string>
 
 #include "esphome/core/optional.h"
-#include "esphome/core/runtime_stats.h"
 
 namespace esphome {
 
@@ -64,7 +63,7 @@ extern const uint32_t STATUS_LED_OK;
 extern const uint32_t STATUS_LED_WARNING;
 extern const uint32_t STATUS_LED_ERROR;
 
-enum class RetryResult { DONE, RETRY };
+enum class RetryResult : uint8_t { DONE, RETRY };
 
 extern const uint32_t WARN_IF_BLOCKING_OVER_MS;
 

esphome/core/runtime_stats.cpp

@@ -1,28 +0,0 @@
-#include "esphome/core/runtime_stats.h"
-#include "esphome/core/component.h"
-
-namespace esphome {
-
-RuntimeStatsCollector runtime_stats;
-
-void RuntimeStatsCollector::record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time) {
-  if (!this->enabled_ || component == nullptr)
-    return;
-
-  const char *component_source = component->get_component_source();
-  this->component_stats_[component_source].record_time(duration_ms);
-
-  // If next_log_time_ is 0, initialize it
-  if (this->next_log_time_ == 0) {
-    this->next_log_time_ = current_time + this->log_interval_;
-    return;
-  }
-
-  if (current_time >= this->next_log_time_) {
-    this->log_stats_();
-    this->reset_stats_();
-    this->next_log_time_ = current_time + this->log_interval_;
-  }
-}
-
-}  // namespace esphome

esphome/core/runtime_stats.h

@@ -1,161 +0,0 @@
-#pragma once
-
-#include <map>
-#include <string>
-#include <vector>
-#include <cstdint>
-#include <algorithm>
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-
-static const char *const RUNTIME_TAG = "runtime";
-
-class Component;  // Forward declaration
-
-class ComponentRuntimeStats {
- public:
-  ComponentRuntimeStats()
-      : period_count_(0),
-        total_count_(0),
-        period_time_ms_(0),
-        total_time_ms_(0),
-        period_max_time_ms_(0),
-        total_max_time_ms_(0) {}
-
-  void record_time(uint32_t duration_ms) {
-    // Update period counters
-    this->period_count_++;
-    this->period_time_ms_ += duration_ms;
-    if (duration_ms > this->period_max_time_ms_)
-      this->period_max_time_ms_ = duration_ms;
-
-    // Update total counters
-    this->total_count_++;
-    this->total_time_ms_ += duration_ms;
-    if (duration_ms > this->total_max_time_ms_)
-      this->total_max_time_ms_ = duration_ms;
-  }
-
-  void reset_period_stats() {
-    this->period_count_ = 0;
-    this->period_time_ms_ = 0;
-    this->period_max_time_ms_ = 0;
-  }
-
-  // Period stats (reset each logging interval)
-  uint32_t get_period_count() const { return this->period_count_; }
-  uint32_t get_period_time_ms() const { return this->period_time_ms_; }
-  uint32_t get_period_max_time_ms() const { return this->period_max_time_ms_; }
-  float get_period_avg_time_ms() const {
-    return this->period_count_ > 0 ? this->period_time_ms_ / static_cast<float>(this->period_count_) : 0.0f;
-  }
-
-  // Total stats (persistent until reboot)
-  uint32_t get_total_count() const { return this->total_count_; }
-  uint32_t get_total_time_ms() const { return this->total_time_ms_; }
-  uint32_t get_total_max_time_ms() const { return this->total_max_time_ms_; }
-  float get_total_avg_time_ms() const {
-    return this->total_count_ > 0 ? this->total_time_ms_ / static_cast<float>(this->total_count_) : 0.0f;
-  }
-
- protected:
-  // Period stats (reset each logging interval)
-  uint32_t period_count_;
-  uint32_t period_time_ms_;
-  uint32_t period_max_time_ms_;
-
-  // Total stats (persistent until reboot)
-  uint32_t total_count_;
-  uint32_t total_time_ms_;
-  uint32_t total_max_time_ms_;
-};
-
-// For sorting components by run time
-struct ComponentStatPair {
-  std::string name;
-  const ComponentRuntimeStats *stats;
-
-  bool operator>(const ComponentStatPair &other) const {
-    // Sort by period time as that's what we're displaying in the logs
-    return stats->get_period_time_ms() > other.stats->get_period_time_ms();
-  }
-};
-
-class RuntimeStatsCollector {
- public:
-  RuntimeStatsCollector() : log_interval_(60000), next_log_time_(0), enabled_(true) {}
-
-  void set_log_interval(uint32_t log_interval) { this->log_interval_ = log_interval; }
-  uint32_t get_log_interval() const { return this->log_interval_; }
-
-  void set_enabled(bool enabled) { this->enabled_ = enabled; }
-  bool is_enabled() const { return this->enabled_; }
-
-  void record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time);
-
- protected:
-  void log_stats_() {
-    ESP_LOGI(RUNTIME_TAG, "Component Runtime Statistics");
-    ESP_LOGI(RUNTIME_TAG, "Period stats (last %" PRIu32 "ms):", this->log_interval_);
-
-    // First collect stats we want to display
-    std::vector<ComponentStatPair> stats_to_display;
-
-    for (const auto &it : this->component_stats_) {
-      const ComponentRuntimeStats &stats = it.second;
-      if (stats.get_period_count() > 0) {
-        ComponentStatPair pair = {it.first, &stats};
-        stats_to_display.push_back(pair);
-      }
-    }
-
-    // Sort by period runtime (descending)
-    std::sort(stats_to_display.begin(), stats_to_display.end(), std::greater<ComponentStatPair>());
-
-    // Log top components by period runtime
-    for (const auto &it : stats_to_display) {
-      const std::string &source = it.name;
-      const ComponentRuntimeStats *stats = it.stats;
-
-      ESP_LOGI(RUNTIME_TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms",
-               source.c_str(), stats->get_period_count(), stats->get_period_avg_time_ms(),
-               stats->get_period_max_time_ms(), stats->get_period_time_ms());
-    }
-
-    // Log total stats since boot
-    ESP_LOGI(RUNTIME_TAG, "Total stats (since boot):");
-
-    // Re-sort by total runtime for all-time stats
-    std::sort(stats_to_display.begin(), stats_to_display.end(),
-              [](const ComponentStatPair &a, const ComponentStatPair &b) {
-                return a.stats->get_total_time_ms() > b.stats->get_total_time_ms();
-              });
-
-    for (const auto &it : stats_to_display) {
-      const std::string &source = it.name;
-      const ComponentRuntimeStats *stats = it.stats;
-
-      ESP_LOGI(RUNTIME_TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms",
-               source.c_str(), stats->get_total_count(), stats->get_total_avg_time_ms(), stats->get_total_max_time_ms(),
-               stats->get_total_time_ms());
-    }
-  }
-
-  void reset_stats_() {
-    for (auto &it : this->component_stats_) {
-      it.second.reset_period_stats();
-    }
-  }
-
-  std::map<std::string, ComponentRuntimeStats> component_stats_;
-  uint32_t log_interval_;
-  uint32_t next_log_time_;
-  bool enabled_;
-};
-
-// Global instance for runtime stats collection
-extern RuntimeStatsCollector runtime_stats;
-
-}  // namespace esphome

esphome/cpp_generator.py

@@ -608,6 +608,17 @@ def add_build_flag(build_flag: str):
     CORE.add_build_flag(build_flag)
 
 
+def add_build_unflag(build_unflag: str) -> None:
+    """Add a global build unflag to the compiler flags."""
+    CORE.add_build_unflag(build_unflag)
+
+
+def set_cpp_standard(standard: str) -> None:
+    """Set C++ standard with compiler flag `-std={standard}`."""
+    CORE.add_build_unflag("-std=gnu++11")
+    CORE.add_build_flag(f"-std={standard}")
+
+
 def add_define(name: str, value: SafeExpType = None):
     """Add a global define to the auto-generated defines.h file.
 

esphome/wizard.py

@@ -67,20 +67,6 @@ esp8266:
 """
 
 ESP32_CONFIG = """
-esp32:
-  board: {board}
-  framework:
-    type: arduino
-"""
-
-ESP32S2_CONFIG = """
-esp32:
-  board: {board}
-  framework:
-    type: esp-idf
-"""
-
-ESP32C3_CONFIG = """
 esp32:
   board: {board}
   framework:
@@ -105,8 +91,6 @@ rtl87xx:
 HARDWARE_BASE_CONFIGS = {
     "ESP8266": ESP8266_CONFIG,
     "ESP32": ESP32_CONFIG,
-    "ESP32S2": ESP32S2_CONFIG,
-    "ESP32C3": ESP32C3_CONFIG,
     "RP2040": RP2040_CONFIG,
     "BK72XX": BK72XX_CONFIG,
     "RTL87XX": RTL87XX_CONFIG,

esphome/writer.py

@@ -153,6 +153,9 @@ def get_ini_content():
     # Sort to avoid changing build flags order
     CORE.add_platformio_option("build_flags", sorted(CORE.build_flags))
 
+    # Sort to avoid changing build unflags order
+    CORE.add_platformio_option("build_unflags", sorted(CORE.build_unflags))
+
     content = "[platformio]\n"
     content += f"description = ESPHome {__version__}\n"
 

platformio.ini

@@ -48,6 +48,9 @@ lib_deps =
     lvgl/lvgl@8.4.0                                       ; lvgl
 build_flags =
     -DESPHOME_LOG_LEVEL=ESPHOME_LOG_LEVEL_VERY_VERBOSE
+    -std=gnu++17
+build_unflags =
+    -std=gnu++11
 src_filter =
     +<./>
     +<../tests/dummy_main.cpp>
@@ -73,6 +76,8 @@ lib_deps =
 build_flags =
     ${common.build_flags}
     -DUSE_ARDUINO
+build_unflags =
+    ${common.build_unflags}
 
 ; This are common settings for all IDF-framework based environments.
 [common:idf]
@@ -80,6 +85,8 @@ extends = common
 build_flags =
     ${common.build_flags}
     -DUSE_ESP_IDF
+build_unflags =
+    ${common.build_unflags}
 
 ; This are common settings for the ESP8266 using Arduino.
 [common:esp8266-arduino]
@@ -104,6 +111,8 @@ build_flags =
     -Wno-nonnull-compare
     -DUSE_ESP8266
     -DUSE_ESP8266_FRAMEWORK_ARDUINO
+build_unflags =
+    ${common.build_unflags}
 extra_scripts = post:esphome/components/esp8266/post_build.py.script
 
 ; This are common settings for the ESP32 (all variants) using Arduino.
@@ -135,6 +144,8 @@ build_flags =
     -DUSE_ESP32
     -DUSE_ESP32_FRAMEWORK_ARDUINO
     -DAUDIO_NO_SD_FS                ; i2s_audio
+build_unflags =
+    ${common.build_unflags}
 extra_scripts = post:esphome/components/esp32/post_build.py.script
 
 ; This are common settings for the ESP32 (all variants) using IDF.
@@ -155,6 +166,8 @@ build_flags =
     -Wno-nonnull-compare
     -DUSE_ESP32
     -DUSE_ESP32_FRAMEWORK_ESP_IDF
+build_unflags =
+    ${common.build_unflags}
 extra_scripts = post:esphome/components/esp32/post_build.py.script
 
 ; This are common settings for the ESP32 using the latest ESP-IDF version.
@@ -181,6 +194,8 @@ build_flags =
     ${common:arduino.build_flags}
     -DUSE_RP2040
     -DUSE_RP2040_FRAMEWORK_ARDUINO
+build_unflags =
+    ${common.build_unflags}
 
 ; This are common settings for the LibreTiny (all variants) using Arduino.
 [common:libretiny-arduino]
@@ -192,6 +207,8 @@ lib_deps =
 build_flags =
     ${common:arduino.build_flags}
     -DUSE_LIBRETINY
+build_unflags =
+    ${common.build_unflags}
 build_src_flags = -include Arduino.h
 
 ; This is the common settings for the nRF52 using Zephyr.
@@ -224,6 +241,8 @@ board = nodemcuv2
 build_flags =
     ${common:esp8266-arduino.build_flags}
     ${flags:runtime.build_flags}
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp8266-arduino-tidy]
 extends = common:esp8266-arduino
@@ -231,6 +250,8 @@ board = nodemcuv2
 build_flags =
     ${common:esp8266-arduino.build_flags}
     ${flags:clangtidy.build_flags}
+build_unflags =
+    ${common.build_unflags}
 
 ;;;;;;;; ESP32 ;;;;;;;;
 
@@ -242,6 +263,8 @@ build_flags =
     ${common:esp32-arduino.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32-arduino-tidy]
 extends = common:esp32-arduino
@@ -250,6 +273,8 @@ build_flags =
     ${common:esp32-arduino.build_flags}
     ${flags:clangtidy.build_flags}
     -DUSE_ESP32_VARIANT_ESP32
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32-idf]
 extends = common:esp32-idf
@@ -259,6 +284,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32-idf-5_3]
 extends = common:esp32-idf-5_3
@@ -268,6 +295,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32-idf-tidy]
 extends = common:esp32-idf
@@ -277,6 +306,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:clangtidy.build_flags}
     -DUSE_ESP32_VARIANT_ESP32
+build_unflags =
+    ${common.build_unflags}
 
 ;;;;;;;; ESP32-C3 ;;;;;;;;
 
@@ -287,6 +318,8 @@ build_flags =
     ${common:esp32-arduino.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32C3
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32c3-arduino-tidy]
 extends = common:esp32-arduino
@@ -295,6 +328,8 @@ build_flags =
     ${common:esp32-arduino.build_flags}
     ${flags:clangtidy.build_flags}
     -DUSE_ESP32_VARIANT_ESP32C3
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32c3-idf]
 extends = common:esp32-idf
@@ -304,6 +339,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32C3
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32c3-idf-5_3]
 extends = common:esp32-idf-5_3
@@ -313,6 +350,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32C3
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32c3-idf-tidy]
 extends = common:esp32-idf
@@ -322,6 +361,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:clangtidy.build_flags}
     -DUSE_ESP32_VARIANT_ESP32C3
+build_unflags =
+    ${common.build_unflags}
 
 ;;;;;;;; ESP32-C6 ;;;;;;;;
 
@@ -343,6 +384,8 @@ build_flags =
     ${common:esp32-arduino.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32S2
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32s2-arduino-tidy]
 extends = common:esp32-arduino
@@ -351,6 +394,8 @@ build_flags =
     ${common:esp32-arduino.build_flags}
     ${flags:clangtidy.build_flags}
     -DUSE_ESP32_VARIANT_ESP32S2
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32s2-idf]
 extends = common:esp32-idf
@@ -360,6 +405,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32S2
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32s2-idf-5_3]
 extends = common:esp32-idf-5_3
@@ -369,6 +416,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32S2
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32s2-idf-tidy]
 extends = common:esp32-idf
@@ -378,6 +427,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:clangtidy.build_flags}
     -DUSE_ESP32_VARIANT_ESP32S2
+build_unflags =
+    ${common.build_unflags}
 
 ;;;;;;;; ESP32-S3 ;;;;;;;;
 
@@ -388,6 +439,8 @@ build_flags =
     ${common:esp32-arduino.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32S3
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32s3-arduino-tidy]
 extends = common:esp32-arduino
@@ -396,6 +449,8 @@ build_flags =
     ${common:esp32-arduino.build_flags}
     ${flags:clangtidy.build_flags}
     -DUSE_ESP32_VARIANT_ESP32S3
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32s3-idf]
 extends = common:esp32-idf
@@ -405,6 +460,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32S3
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32s3-idf-5_3]
 extends = common:esp32-idf-5_3
@@ -414,6 +471,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:runtime.build_flags}
     -DUSE_ESP32_VARIANT_ESP32S3
+build_unflags =
+    ${common.build_unflags}
 
 [env:esp32s3-idf-tidy]
 extends = common:esp32-idf
@@ -423,6 +482,8 @@ build_flags =
     ${common:esp32-idf.build_flags}
     ${flags:clangtidy.build_flags}
     -DUSE_ESP32_VARIANT_ESP32S3
+build_unflags =
+    ${common.build_unflags}
 
 ;;;;;;;; ESP32-P4 ;;;;;;;;
 
@@ -444,6 +505,8 @@ board = rpipico
 build_flags =
     ${common:rp2040-arduino.build_flags}
     ${flags:runtime.build_flags}
+build_unflags =
+    ${common.build_unflags}
 
 ;;;;;;;; LibreTiny ;;;;;;;;
 
@@ -455,6 +518,8 @@ build_flags =
     ${flags:runtime.build_flags}
     -DUSE_BK72XX
     -DUSE_LIBRETINY_VARIANT_BK7231N
+build_unflags =
+    ${common.build_unflags}
 
 [env:rtl87xxb-arduino]
 extends = common:libretiny-arduino
@@ -464,6 +529,8 @@ build_flags =
     ${flags:runtime.build_flags}
     -DUSE_RTL87XX
     -DUSE_LIBRETINY_VARIANT_RTL8710B
+build_unflags =
+    ${common.build_unflags}
 
 [env:rtl87xxc-arduino]
 extends = common:libretiny-arduino
@@ -473,6 +540,8 @@ build_flags =
     ${flags:runtime.build_flags}
     -DUSE_RTL87XX
     -DUSE_LIBRETINY_VARIANT_RTL8720C
+build_unflags =
+    ${common.build_unflags}
 
 [env:host]
 extends = common
@@ -483,6 +552,8 @@ build_flags =
     ${common.build_flags}
     -DUSE_HOST
     -std=c++17
+build_unflags =
+    ${common.build_unflags}
 
 ;;;;;;;; nRF52 ;;;;;;;;
 
@@ -492,6 +563,8 @@ board = adafruit_feather_nrf52840
 build_flags =
     ${common:nrf52-zephyr.build_flags}
     ${flags:runtime.build_flags}
+build_unflags =
+    ${common.build_unflags}
 
 [env:nrf52-tidy]
 extends = common:nrf52-zephyr
@@ -499,3 +572,5 @@ board = adafruit_feather_nrf52840
 build_flags =
     ${common:nrf52-zephyr.build_flags}
     ${flags:clangtidy.build_flags}
+build_unflags =
+    ${common.build_unflags}

requirements_test.txt

@@ -6,9 +6,9 @@ pre-commit
 
 # Unit tests
 pytest==8.4.0
-pytest-cov==6.1.1
+pytest-cov==6.2.1
 pytest-mock==3.14.1
-pytest-asyncio==0.26.0
+pytest-asyncio==1.0.0
 pytest-xdist==3.7.0
 asyncmock==0.4.2
 hypothesis==6.92.1