bot nits

CODEOWNERS

@@ -134,7 +134,6 @@ esphome/components/dfplayer/* @glmnet
 esphome/components/dfrobot_sen0395/* @niklasweber
 esphome/components/dht/* @OttoWinter
 esphome/components/display_menu_base/* @numo68
-esphome/components/dlms_meter/* @SimonFischer04
 esphome/components/dps310/* @kbx81
 esphome/components/ds1307/* @badbadc0ffee
 esphome/components/ds2484/* @mrk-its

esphome/components/api/api_server.cpp

@@ -211,7 +211,7 @@ void APIServer::loop() {
 
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
     // Fire trigger after client is removed so api.connected reflects the true state
-    this->client_disconnected_trigger_.trigger(client_name, client_peername);
+    this->client_disconnected_trigger_->trigger(client_name, client_peername);
 #endif
     // Don't increment client_index since we need to process the swapped element
   }

esphome/components/api/api_server.h

@@ -227,10 +227,12 @@ class APIServer : public Component,
 #endif
 
 #ifdef USE_API_CLIENT_CONNECTED_TRIGGER
-  Trigger<std::string, std::string> *get_client_connected_trigger() { return &this->client_connected_trigger_; }
+  Trigger<std::string, std::string> *get_client_connected_trigger() const { return this->client_connected_trigger_; }
 #endif
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-  Trigger<std::string, std::string> *get_client_disconnected_trigger() { return &this->client_disconnected_trigger_; }
+  Trigger<std::string, std::string> *get_client_disconnected_trigger() const {
+    return this->client_disconnected_trigger_;
+  }
 #endif
 
  protected:
@@ -251,10 +253,10 @@ class APIServer : public Component,
   // Pointers and pointer-like types first (4 bytes each)
   std::unique_ptr<socket::Socket> socket_ = nullptr;
 #ifdef USE_API_CLIENT_CONNECTED_TRIGGER
-  Trigger<std::string, std::string> client_connected_trigger_;
+  Trigger<std::string, std::string> *client_connected_trigger_ = new Trigger<std::string, std::string>();
 #endif
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-  Trigger<std::string, std::string> client_disconnected_trigger_;
+  Trigger<std::string, std::string> *client_disconnected_trigger_ = new Trigger<std::string, std::string>();
 #endif
 
   // 4-byte aligned types

esphome/components/api/homeassistant_service.h

@@ -136,10 +136,12 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
   void set_wants_response() { this->flags_.wants_response = true; }
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  Trigger<JsonObjectConst, Ts...> *get_success_trigger_with_response() { return &this->success_trigger_with_response_; }
+  Trigger<JsonObjectConst, Ts...> *get_success_trigger_with_response() const {
+    return this->success_trigger_with_response_;
+  }
 #endif
-  Trigger<Ts...> *get_success_trigger() { return &this->success_trigger_; }
-  Trigger<std::string, Ts...> *get_error_trigger() { return &this->error_trigger_; }
+  Trigger<Ts...> *get_success_trigger() const { return this->success_trigger_; }
+  Trigger<std::string, Ts...> *get_error_trigger() const { return this->error_trigger_; }
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 
   void play(const Ts &...x) override {
@@ -185,14 +187,14 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
               if (response.is_success()) {
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
                 if (this->flags_.wants_response) {
-                  this->success_trigger_with_response_.trigger(response.get_json(), args...);
+                  this->success_trigger_with_response_->trigger(response.get_json(), args...);
                 } else
 #endif
                 {
-                  this->success_trigger_.trigger(args...);
+                  this->success_trigger_->trigger(args...);
                 }
               } else {
-                this->error_trigger_.trigger(response.get_error_message(), args...);
+                this->error_trigger_->trigger(response.get_error_message(), args...);
               }
             },
             captured_args);
@@ -249,10 +251,10 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
   TemplatableStringValue<Ts...> response_template_{""};
-  Trigger<JsonObjectConst, Ts...> success_trigger_with_response_;
+  Trigger<JsonObjectConst, Ts...> *success_trigger_with_response_ = new Trigger<JsonObjectConst, Ts...>();
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  Trigger<Ts...> success_trigger_;
-  Trigger<std::string, Ts...> error_trigger_;
+  Trigger<Ts...> *success_trigger_ = new Trigger<Ts...>();
+  Trigger<std::string, Ts...> *error_trigger_ = new Trigger<std::string, Ts...>();
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 
   struct Flags {

esphome/components/bang_bang/bang_bang_climate.cpp

@@ -6,7 +6,8 @@ namespace bang_bang {
 
 static const char *const TAG = "bang_bang.climate";
 
-BangBangClimate::BangBangClimate() = default;
+BangBangClimate::BangBangClimate()
+    : idle_trigger_(new Trigger<>()), cool_trigger_(new Trigger<>()), heat_trigger_(new Trigger<>()) {}
 
 void BangBangClimate::setup() {
   this->sensor_->add_on_state_callback([this](float state) {
@@ -159,13 +160,13 @@ void BangBangClimate::switch_to_action_(climate::ClimateAction action) {
   switch (action) {
     case climate::CLIMATE_ACTION_OFF:
     case climate::CLIMATE_ACTION_IDLE:
-      trig = &this->idle_trigger_;
+      trig = this->idle_trigger_;
       break;
     case climate::CLIMATE_ACTION_COOLING:
-      trig = &this->cool_trigger_;
+      trig = this->cool_trigger_;
       break;
     case climate::CLIMATE_ACTION_HEATING:
-      trig = &this->heat_trigger_;
+      trig = this->heat_trigger_;
       break;
     default:
       trig = nullptr;
@@ -203,9 +204,9 @@ void BangBangClimate::set_away_config(const BangBangClimateTargetTempConfig &awa
 void BangBangClimate::set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
 void BangBangClimate::set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
 
-Trigger<> *BangBangClimate::get_idle_trigger() { return &this->idle_trigger_; }
-Trigger<> *BangBangClimate::get_cool_trigger() { return &this->cool_trigger_; }
-Trigger<> *BangBangClimate::get_heat_trigger() { return &this->heat_trigger_; }
+Trigger<> *BangBangClimate::get_idle_trigger() const { return this->idle_trigger_; }
+Trigger<> *BangBangClimate::get_cool_trigger() const { return this->cool_trigger_; }
+Trigger<> *BangBangClimate::get_heat_trigger() const { return this->heat_trigger_; }
 
 void BangBangClimate::set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
 void BangBangClimate::set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }

esphome/components/bang_bang/bang_bang_climate.h

@@ -30,9 +30,9 @@ class BangBangClimate : public climate::Climate, public Component {
   void set_normal_config(const BangBangClimateTargetTempConfig &normal_config);
   void set_away_config(const BangBangClimateTargetTempConfig &away_config);
 
-  Trigger<> *get_idle_trigger();
-  Trigger<> *get_cool_trigger();
-  Trigger<> *get_heat_trigger();
+  Trigger<> *get_idle_trigger() const;
+  Trigger<> *get_cool_trigger() const;
+  Trigger<> *get_heat_trigger() const;
 
  protected:
   /// Override control to change settings of the climate device.
@@ -57,13 +57,17 @@ class BangBangClimate : public climate::Climate, public Component {
    *
    * In idle mode, the controller is assumed to have both heating and cooling disabled.
    */
-  Trigger<> idle_trigger_;
+  Trigger<> *idle_trigger_{nullptr};
   /** The trigger to call when the controller should switch to cooling mode.
    */
-  Trigger<> cool_trigger_;
+  Trigger<> *cool_trigger_{nullptr};
   /** The trigger to call when the controller should switch to heating mode.
+   *
+   * A null value for this attribute means that the controller has no heating action
+   * For example window blinds, where only cooling (blinds closed) and not-cooling
+   * (blinds open) is possible.
    */
-  Trigger<> heat_trigger_;
+  Trigger<> *heat_trigger_{nullptr};
   /** A reference to the trigger that was previously active.
    *
    * This is so that the previous trigger can be stopped before enabling a new one.

esphome/components/bme680_bsec/__init__.py

@@ -89,9 +89,8 @@ async def to_code(config):
         var.set_state_save_interval(config[CONF_STATE_SAVE_INTERVAL].total_milliseconds)
     )
 
-    # Although this component does not use SPI/Wire directly, the BSEC library requires them
+    # Although this component does not use SPI, the BSEC library requires the SPI library
     cg.add_library("SPI", None)
-    cg.add_library("Wire", None)
 
     cg.add_define("USE_BSEC")
     cg.add_library("boschsensortec/BSEC Software Library", "1.6.1480")

esphome/components/cc1101/cc1101.cpp

@@ -156,7 +156,7 @@ void CC1101Component::call_listeners_(const std::vector<uint8_t> &packet, float
   for (auto &listener : this->listeners_) {
     listener->on_packet(packet, freq_offset, rssi, lqi);
   }
-  this->packet_trigger_.trigger(packet, freq_offset, rssi, lqi);
+  this->packet_trigger_->trigger(packet, freq_offset, rssi, lqi);
 }
 
 void CC1101Component::loop() {

esphome/components/cc1101/cc1101.h

@@ -79,7 +79,7 @@ class CC1101Component : public Component,
   // Packet mode operations
   CC1101Error transmit_packet(const std::vector<uint8_t> &packet);
   void register_listener(CC1101Listener *listener) { this->listeners_.push_back(listener); }
-  Trigger<std::vector<uint8_t>, float, float, uint8_t> *get_packet_trigger() { return &this->packet_trigger_; }
+  Trigger<std::vector<uint8_t>, float, float, uint8_t> *get_packet_trigger() const { return this->packet_trigger_; }
 
  protected:
   uint16_t chip_id_{0};
@@ -96,7 +96,8 @@ class CC1101Component : public Component,
 
   // Packet handling
   void call_listeners_(const std::vector<uint8_t> &packet, float freq_offset, float rssi, uint8_t lqi);
-  Trigger<std::vector<uint8_t>, float, float, uint8_t> packet_trigger_;
+  Trigger<std::vector<uint8_t>, float, float, uint8_t> *packet_trigger_{
+      new Trigger<std::vector<uint8_t>, float, float, uint8_t>()};
   std::vector<uint8_t> packet_;
   std::vector<CC1101Listener *> listeners_;
 

esphome/components/current_based/current_based_cover.cpp

@@ -66,7 +66,7 @@ void CurrentBasedCover::loop() {
   if (this->current_operation == COVER_OPERATION_OPENING) {
     if (this->malfunction_detection_ && this->is_closing_()) {  // Malfunction
       this->direction_idle_();
-      this->malfunction_trigger_.trigger();
+      this->malfunction_trigger_->trigger();
       ESP_LOGI(TAG, "'%s' - Malfunction detected during opening. Current flow detected in close circuit",
                this->name_.c_str());
     } else if (this->is_opening_blocked_()) {  // Blocked
@@ -87,7 +87,7 @@ void CurrentBasedCover::loop() {
   } else if (this->current_operation == COVER_OPERATION_CLOSING) {
     if (this->malfunction_detection_ && this->is_opening_()) {  // Malfunction
       this->direction_idle_();
-      this->malfunction_trigger_.trigger();
+      this->malfunction_trigger_->trigger();
       ESP_LOGI(TAG, "'%s' - Malfunction detected during closing. Current flow detected in open circuit",
                this->name_.c_str());
     } else if (this->is_closing_blocked_()) {  // Blocked
@@ -221,15 +221,15 @@ void CurrentBasedCover::start_direction_(CoverOperation dir) {
   Trigger<> *trig;
   switch (dir) {
     case COVER_OPERATION_IDLE:
-      trig = &this->stop_trigger_;
+      trig = this->stop_trigger_;
       break;
     case COVER_OPERATION_OPENING:
       this->last_operation_ = dir;
-      trig = &this->open_trigger_;
+      trig = this->open_trigger_;
       break;
     case COVER_OPERATION_CLOSING:
       this->last_operation_ = dir;
-      trig = &this->close_trigger_;
+      trig = this->close_trigger_;
       break;
     default:
       return;

esphome/components/current_based/current_based_cover.h

@@ -16,9 +16,9 @@ class CurrentBasedCover : public cover::Cover, public Component {
   void dump_config() override;
   float get_setup_priority() const override;
 
-  Trigger<> *get_stop_trigger() { return &this->stop_trigger_; }
+  Trigger<> *get_stop_trigger() const { return this->stop_trigger_; }
 
-  Trigger<> *get_open_trigger() { return &this->open_trigger_; }
+  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
   void set_open_sensor(sensor::Sensor *open_sensor) { this->open_sensor_ = open_sensor; }
   void set_open_moving_current_threshold(float open_moving_current_threshold) {
     this->open_moving_current_threshold_ = open_moving_current_threshold;
@@ -28,7 +28,7 @@ class CurrentBasedCover : public cover::Cover, public Component {
   }
   void set_open_duration(uint32_t open_duration) { this->open_duration_ = open_duration; }
 
-  Trigger<> *get_close_trigger() { return &this->close_trigger_; }
+  Trigger<> *get_close_trigger() const { return this->close_trigger_; }
   void set_close_sensor(sensor::Sensor *close_sensor) { this->close_sensor_ = close_sensor; }
   void set_close_moving_current_threshold(float close_moving_current_threshold) {
     this->close_moving_current_threshold_ = close_moving_current_threshold;
@@ -44,7 +44,7 @@ class CurrentBasedCover : public cover::Cover, public Component {
   void set_malfunction_detection(bool malfunction_detection) { this->malfunction_detection_ = malfunction_detection; }
   void set_start_sensing_delay(uint32_t start_sensing_delay) { this->start_sensing_delay_ = start_sensing_delay; }
 
-  Trigger<> *get_malfunction_trigger() { return &this->malfunction_trigger_; }
+  Trigger<> *get_malfunction_trigger() const { return this->malfunction_trigger_; }
 
   cover::CoverTraits get_traits() override;
 
@@ -64,23 +64,23 @@ class CurrentBasedCover : public cover::Cover, public Component {
 
   void recompute_position_();
 
-  Trigger<> stop_trigger_;
+  Trigger<> *stop_trigger_{new Trigger<>()};
 
   sensor::Sensor *open_sensor_{nullptr};
-  Trigger<> open_trigger_;
+  Trigger<> *open_trigger_{new Trigger<>()};
   float open_moving_current_threshold_;
   float open_obstacle_current_threshold_{FLT_MAX};
   uint32_t open_duration_;
 
   sensor::Sensor *close_sensor_{nullptr};
-  Trigger<> close_trigger_;
+  Trigger<> *close_trigger_{new Trigger<>()};
   float close_moving_current_threshold_;
   float close_obstacle_current_threshold_{FLT_MAX};
   uint32_t close_duration_;
 
   uint32_t max_duration_{UINT32_MAX};
   bool malfunction_detection_{true};
-  Trigger<> malfunction_trigger_;
+  Trigger<> *malfunction_trigger_{new Trigger<>()};
   uint32_t start_sensing_delay_;
   float obstacle_rollback_;
 

esphome/components/dlms_meter/__init__.py

@@ -1,57 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import uart
-import esphome.config_validation as cv
-from esphome.const import CONF_ID, PLATFORM_ESP32, PLATFORM_ESP8266
-
-CODEOWNERS = ["@SimonFischer04"]
-DEPENDENCIES = ["uart"]
-
-CONF_DLMS_METER_ID = "dlms_meter_id"
-CONF_DECRYPTION_KEY = "decryption_key"
-CONF_PROVIDER = "provider"
-
-PROVIDERS = {"generic": 0, "netznoe": 1}
-
-dlms_meter_component_ns = cg.esphome_ns.namespace("dlms_meter")
-DlmsMeterComponent = dlms_meter_component_ns.class_(
-    "DlmsMeterComponent", cg.Component, uart.UARTDevice
-)
-
-
-def validate_key(value):
-    value = cv.string_strict(value)
-    if len(value) != 32:
-        raise cv.Invalid("Decryption key must be 32 hex characters (16 bytes)")
-    try:
-        return [int(value[i : i + 2], 16) for i in range(0, 32, 2)]
-    except ValueError as exc:
-        raise cv.Invalid("Decryption key must be hex values from 00 to FF") from exc
-
-
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(DlmsMeterComponent),
-            cv.Required(CONF_DECRYPTION_KEY): validate_key,
-            cv.Optional(CONF_PROVIDER, default="generic"): cv.enum(
-                PROVIDERS, lower=True
-            ),
-        }
-    )
-    .extend(uart.UART_DEVICE_SCHEMA)
-    .extend(cv.COMPONENT_SCHEMA),
-    cv.only_on([PLATFORM_ESP8266, PLATFORM_ESP32]),
-)
-
-FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "dlms_meter", baud_rate=2400, require_rx=True
-)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await uart.register_uart_device(var, config)
-    key = ", ".join(str(b) for b in config[CONF_DECRYPTION_KEY])
-    cg.add(var.set_decryption_key(cg.RawExpression(f"{{{key}}}")))
-    cg.add(var.set_provider(PROVIDERS[config[CONF_PROVIDER]]))

esphome/components/dlms_meter/dlms.h

@@ -1,71 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace esphome::dlms_meter {
-
-/*
-+-------------------------------+
-|       Ciphering Service       |
-+-------------------------------+
-|      System Title Length      |
-+-------------------------------+
-|                               |
-|                               |
-|                               |
-|            System             |
-|            Title              |
-|                               |
-|                               |
-|                               |
-+-------------------------------+
-|            Length             | (1 or 3 Bytes)
-+-------------------------------+
-|     Security Control Byte     |
-+-------------------------------+
-|                               |
-|             Frame             |
-|            Counter            |
-|                               |
-+-------------------------------+
-|                               |
-~                               ~
-        Encrypted Payload
-~                               ~
-|                               |
-+-------------------------------+
-
-Ciphering Service: 0xDB (General-Glo-Ciphering)
-System Title Length: 0x08
-System Title: Unique ID of meter
-Length: 1 Byte=Length <= 127, 3 Bytes=Length > 127 (0x82 & 2 Bytes length)
-Security Control Byte:
-- Bit 3…0: Security_Suite_Id
-- Bit 4: "A" subfield: indicates that authentication is applied
-- Bit 5: "E" subfield: indicates that encryption is applied
-- Bit 6: Key_Set subfield: 0 = Unicast, 1 = Broadcast
-- Bit 7: Indicates the use of compression.
- */
-
-static constexpr uint8_t DLMS_HEADER_LENGTH = 16;
-static constexpr uint8_t DLMS_HEADER_EXT_OFFSET = 2;  // Extra offset for extended length header
-static constexpr uint8_t DLMS_CIPHER_OFFSET = 0;
-static constexpr uint8_t DLMS_SYST_OFFSET = 1;
-static constexpr uint8_t DLMS_LENGTH_OFFSET = 10;
-static constexpr uint8_t TWO_BYTE_LENGTH = 0x82;
-static constexpr uint8_t DLMS_LENGTH_CORRECTION = 5;  // Header bytes included in length field
-static constexpr uint8_t DLMS_SECBYTE_OFFSET = 11;
-static constexpr uint8_t DLMS_FRAMECOUNTER_OFFSET = 12;
-static constexpr uint8_t DLMS_FRAMECOUNTER_LENGTH = 4;
-static constexpr uint8_t DLMS_PAYLOAD_OFFSET = 16;
-static constexpr uint8_t GLO_CIPHERING = 0xDB;
-static constexpr uint8_t DATA_NOTIFICATION = 0x0F;
-static constexpr uint8_t TIMESTAMP_DATETIME = 0x0C;
-static constexpr uint16_t MAX_MESSAGE_LENGTH = 512;  // Maximum size of message (when having 2 bytes length in header).
-
-// Provider specific quirks
-static constexpr uint8_t NETZ_NOE_MAGIC_BYTE = 0x81;  // Magic length byte used by Netz NOE
-static constexpr uint8_t NETZ_NOE_EXPECTED_MESSAGE_LENGTH = 0xF8;
-static constexpr uint8_t NETZ_NOE_EXPECTED_SECURITY_CONTROL_BYTE = 0x20;
-
-}  // namespace esphome::dlms_meter

esphome/components/dlms_meter/dlms_meter.cpp

@@ -1,468 +0,0 @@
-#include "dlms_meter.h"
-
-#include <cmath>
-
-#if defined(USE_ESP8266_FRAMEWORK_ARDUINO)
-#include <bearssl/bearssl.h>
-#elif defined(USE_ESP32)
-#include "mbedtls/esp_config.h"
-#include "mbedtls/gcm.h"
-#endif
-
-namespace esphome::dlms_meter {
-
-static constexpr const char *TAG = "dlms_meter";
-
-void DlmsMeterComponent::dump_config() {
-  const char *provider_name = this->provider_ == PROVIDER_NETZNOE ? "Netz NOE" : "Generic";
-  ESP_LOGCONFIG(TAG,
-                "DLMS Meter:\n"
-                "  Provider: %s\n"
-                "  Read Timeout: %u ms",
-                provider_name, this->read_timeout_);
-#define DLMS_METER_LOG_SENSOR(s) LOG_SENSOR("  ", #s, this->s##_sensor_);
-  DLMS_METER_SENSOR_LIST(DLMS_METER_LOG_SENSOR, )
-#define DLMS_METER_LOG_TEXT_SENSOR(s) LOG_TEXT_SENSOR("  ", #s, this->s##_text_sensor_);
-  DLMS_METER_TEXT_SENSOR_LIST(DLMS_METER_LOG_TEXT_SENSOR, )
-}
-
-void DlmsMeterComponent::loop() {
-  // Read while data is available, netznoe uses two frames so allow 2x max frame length
-  while (this->available()) {
-    if (this->receive_buffer_.size() >= MBUS_MAX_FRAME_LENGTH * 2) {
-      ESP_LOGW(TAG, "Receive buffer full, dropping remaining bytes");
-      break;
-    }
-    uint8_t c;
-    this->read_byte(&c);
-    this->receive_buffer_.push_back(c);
-    this->last_read_ = millis();
-  }
-
-  if (!this->receive_buffer_.empty() && millis() - this->last_read_ > this->read_timeout_) {
-    this->mbus_payload_.clear();
-    if (!this->parse_mbus_(this->mbus_payload_))
-      return;
-
-    uint16_t message_length;
-    uint8_t systitle_length;
-    uint16_t header_offset;
-    if (!this->parse_dlms_(this->mbus_payload_, message_length, systitle_length, header_offset))
-      return;
-
-    if (message_length < DECODER_START_OFFSET || message_length > MAX_MESSAGE_LENGTH) {
-      ESP_LOGE(TAG, "DLMS: Message length invalid: %u", message_length);
-      this->receive_buffer_.clear();
-      return;
-    }
-
-    // Decrypt in place and then decode the OBIS codes
-    if (!this->decrypt_(this->mbus_payload_, message_length, systitle_length, header_offset))
-      return;
-    this->decode_obis_(&this->mbus_payload_[header_offset + DLMS_PAYLOAD_OFFSET], message_length);
-  }
-}
-
-bool DlmsMeterComponent::parse_mbus_(std::vector<uint8_t> &mbus_payload) {
-  ESP_LOGV(TAG, "Parsing M-Bus frames");
-  uint16_t frame_offset = 0;  // Offset is used if the M-Bus message is split into multiple frames
-
-  while (frame_offset < this->receive_buffer_.size()) {
-    // Ensure enough bytes remain for the minimal intro header before accessing indices
-    if (this->receive_buffer_.size() - frame_offset < MBUS_HEADER_INTRO_LENGTH) {
-      ESP_LOGE(TAG, "MBUS: Not enough data for frame header (need %d, have %d)", MBUS_HEADER_INTRO_LENGTH,
-               (this->receive_buffer_.size() - frame_offset));
-      this->receive_buffer_.clear();
-      return false;
-    }
-
-    // Check start bytes
-    if (this->receive_buffer_[frame_offset + MBUS_START1_OFFSET] != START_BYTE_LONG_FRAME ||
-        this->receive_buffer_[frame_offset + MBUS_START2_OFFSET] != START_BYTE_LONG_FRAME) {
-      ESP_LOGE(TAG, "MBUS: Start bytes do not match");
-      this->receive_buffer_.clear();
-      return false;
-    }
-
-    // Both length bytes must be identical
-    if (this->receive_buffer_[frame_offset + MBUS_LENGTH1_OFFSET] !=
-        this->receive_buffer_[frame_offset + MBUS_LENGTH2_OFFSET]) {
-      ESP_LOGE(TAG, "MBUS: Length bytes do not match");
-      this->receive_buffer_.clear();
-      return false;
-    }
-
-    uint8_t frame_length = this->receive_buffer_[frame_offset + MBUS_LENGTH1_OFFSET];  // Get length of this frame
-
-    // Check if received data is enough for the given frame length
-    if (this->receive_buffer_.size() - frame_offset <
-        frame_length + 3) {  // length field inside packet does not account for second start- + checksum- + stop- byte
-      ESP_LOGE(TAG, "MBUS: Frame too big for received data");
-      this->receive_buffer_.clear();
-      return false;
-    }
-
-    // Ensure we have full frame (header + payload + checksum + stop byte) before accessing stop byte
-    size_t required_total =
-        frame_length + MBUS_HEADER_INTRO_LENGTH + MBUS_FOOTER_LENGTH;  // payload + header + 2 footer bytes
-    if (this->receive_buffer_.size() - frame_offset < required_total) {
-      ESP_LOGE(TAG, "MBUS: Incomplete frame (need %d, have %d)", (unsigned int) required_total,
-               this->receive_buffer_.size() - frame_offset);
-      this->receive_buffer_.clear();
-      return false;
-    }
-
-    if (this->receive_buffer_[frame_offset + frame_length + MBUS_HEADER_INTRO_LENGTH + MBUS_FOOTER_LENGTH - 1] !=
-        STOP_BYTE) {
-      ESP_LOGE(TAG, "MBUS: Invalid stop byte");
-      this->receive_buffer_.clear();
-      return false;
-    }
-
-    // Verify checksum: sum of all bytes starting at MBUS_HEADER_INTRO_LENGTH, take last byte
-    uint8_t checksum = 0;  // use uint8_t so only the 8 least significant bits are stored
-    for (uint16_t i = 0; i < frame_length; i++) {
-      checksum += this->receive_buffer_[frame_offset + MBUS_HEADER_INTRO_LENGTH + i];
-    }
-    if (checksum != this->receive_buffer_[frame_offset + frame_length + MBUS_HEADER_INTRO_LENGTH]) {
-      ESP_LOGE(TAG, "MBUS: Invalid checksum: %x != %x", checksum,
-               this->receive_buffer_[frame_offset + frame_length + MBUS_HEADER_INTRO_LENGTH]);
-      this->receive_buffer_.clear();
-      return false;
-    }
-
-    mbus_payload.insert(mbus_payload.end(), &this->receive_buffer_[frame_offset + MBUS_FULL_HEADER_LENGTH],
-                        &this->receive_buffer_[frame_offset + MBUS_HEADER_INTRO_LENGTH + frame_length]);
-
-    frame_offset += MBUS_HEADER_INTRO_LENGTH + frame_length + MBUS_FOOTER_LENGTH;
-  }
-  return true;
-}
-
-bool DlmsMeterComponent::parse_dlms_(const std::vector<uint8_t> &mbus_payload, uint16_t &message_length,
-                                     uint8_t &systitle_length, uint16_t &header_offset) {
-  ESP_LOGV(TAG, "Parsing DLMS header");
-  if (mbus_payload.size() < DLMS_HEADER_LENGTH + DLMS_HEADER_EXT_OFFSET) {
-    ESP_LOGE(TAG, "DLMS: Payload too short");
-    this->receive_buffer_.clear();
-    return false;
-  }
-
-  if (mbus_payload[DLMS_CIPHER_OFFSET] != GLO_CIPHERING) {  // Only general-glo-ciphering is supported (0xDB)
-    ESP_LOGE(TAG, "DLMS: Unsupported cipher");
-    this->receive_buffer_.clear();
-    return false;
-  }
-
-  systitle_length = mbus_payload[DLMS_SYST_OFFSET];
-
-  if (systitle_length != 0x08) {  // Only system titles with length of 8 are supported
-    ESP_LOGE(TAG, "DLMS: Unsupported system title length");
-    this->receive_buffer_.clear();
-    return false;
-  }
-
-  message_length = mbus_payload[DLMS_LENGTH_OFFSET];
-  header_offset = 0;
-
-  if (this->provider_ == PROVIDER_NETZNOE) {
-    // for some reason EVN seems to set the standard "length" field to 0x81 and then the actual length is in the next
-    // byte. Check some bytes to see if received data still matches expectation
-    if (message_length == NETZ_NOE_MAGIC_BYTE &&
-        mbus_payload[DLMS_LENGTH_OFFSET + 1] == NETZ_NOE_EXPECTED_MESSAGE_LENGTH &&
-        mbus_payload[DLMS_LENGTH_OFFSET + 2] == NETZ_NOE_EXPECTED_SECURITY_CONTROL_BYTE) {
-      message_length = mbus_payload[DLMS_LENGTH_OFFSET + 1];
-      header_offset = 1;
-    } else {
-      ESP_LOGE(TAG, "Wrong Length - Security Control Byte sequence detected for provider EVN");
-    }
-  } else {
-    if (message_length == TWO_BYTE_LENGTH) {
-      message_length = encode_uint16(mbus_payload[DLMS_LENGTH_OFFSET + 1], mbus_payload[DLMS_LENGTH_OFFSET + 2]);
-      header_offset = DLMS_HEADER_EXT_OFFSET;
-    }
-  }
-  if (message_length < DLMS_LENGTH_CORRECTION) {
-    ESP_LOGE(TAG, "DLMS: Message length too short: %u", message_length);
-    this->receive_buffer_.clear();
-    return false;
-  }
-  message_length -= DLMS_LENGTH_CORRECTION;  // Correct message length due to part of header being included in length
-
-  if (mbus_payload.size() - DLMS_HEADER_LENGTH - header_offset != message_length) {
-    ESP_LOGV(TAG, "DLMS: Length mismatch - payload=%d, header=%d, offset=%d, message=%d", mbus_payload.size(),
-             DLMS_HEADER_LENGTH, header_offset, message_length);
-    ESP_LOGE(TAG, "DLMS: Message has invalid length");
-    this->receive_buffer_.clear();
-    return false;
-  }
-
-  if (mbus_payload[header_offset + DLMS_SECBYTE_OFFSET] != 0x21 &&
-      mbus_payload[header_offset + DLMS_SECBYTE_OFFSET] !=
-          0x20) {  // Only certain security suite is supported (0x21 || 0x20)
-    ESP_LOGE(TAG, "DLMS: Unsupported security control byte");
-    this->receive_buffer_.clear();
-    return false;
-  }
-
-  return true;
-}
-
-bool DlmsMeterComponent::decrypt_(std::vector<uint8_t> &mbus_payload, uint16_t message_length, uint8_t systitle_length,
-                                  uint16_t header_offset) {
-  ESP_LOGV(TAG, "Decrypting payload");
-  uint8_t iv[12];  // Reserve space for the IV, always 12 bytes
-  // Copy system title to IV (System title is before length; no header offset needed!)
-  // Add 1 to the offset in order to skip the system title length byte
-  memcpy(&iv[0], &mbus_payload[DLMS_SYST_OFFSET + 1], systitle_length);
-  memcpy(&iv[8], &mbus_payload[header_offset + DLMS_FRAMECOUNTER_OFFSET],
-         DLMS_FRAMECOUNTER_LENGTH);  // Copy frame counter to IV
-
-  uint8_t *payload_ptr = &mbus_payload[header_offset + DLMS_PAYLOAD_OFFSET];
-
-#if defined(USE_ESP8266_FRAMEWORK_ARDUINO)
-  br_gcm_context gcm_ctx;
-  br_aes_ct_ctr_keys bc;
-  br_aes_ct_ctr_init(&bc, this->decryption_key_.data(), this->decryption_key_.size());
-  br_gcm_init(&gcm_ctx, &bc.vtable, br_ghash_ctmul32);
-  br_gcm_reset(&gcm_ctx, iv, sizeof(iv));
-  br_gcm_flip(&gcm_ctx);
-  br_gcm_run(&gcm_ctx, 0, payload_ptr, message_length);
-#elif defined(USE_ESP32)
-  size_t outlen = 0;
-  mbedtls_gcm_context gcm_ctx;
-  mbedtls_gcm_init(&gcm_ctx);
-  mbedtls_gcm_setkey(&gcm_ctx, MBEDTLS_CIPHER_ID_AES, this->decryption_key_.data(), this->decryption_key_.size() * 8);
-  mbedtls_gcm_starts(&gcm_ctx, MBEDTLS_GCM_DECRYPT, iv, sizeof(iv));
-  auto ret = mbedtls_gcm_update(&gcm_ctx, payload_ptr, message_length, payload_ptr, message_length, &outlen);
-  mbedtls_gcm_free(&gcm_ctx);
-  if (ret != 0) {
-    ESP_LOGE(TAG, "Decryption failed with error: %d", ret);
-    this->receive_buffer_.clear();
-    return false;
-  }
-#else
-#error "Invalid Platform"
-#endif
-
-  if (payload_ptr[0] != DATA_NOTIFICATION || payload_ptr[5] != TIMESTAMP_DATETIME) {
-    ESP_LOGE(TAG, "OBIS: Packet was decrypted but data is invalid");
-    this->receive_buffer_.clear();
-    return false;
-  }
-  ESP_LOGV(TAG, "Decrypted payload: %d bytes", message_length);
-  return true;
-}
-
-void DlmsMeterComponent::decode_obis_(uint8_t *plaintext, uint16_t message_length) {
-  ESP_LOGV(TAG, "Decoding payload");
-  MeterData data{};
-  uint16_t current_position = DECODER_START_OFFSET;
-  bool power_factor_found = false;
-
-  while (current_position + OBIS_CODE_OFFSET <= message_length) {
-    if (plaintext[current_position + OBIS_TYPE_OFFSET] != DataType::OCTET_STRING) {
-      ESP_LOGE(TAG, "OBIS: Unsupported OBIS header type: %x", plaintext[current_position + OBIS_TYPE_OFFSET]);
-      this->receive_buffer_.clear();
-      return;
-    }
-
-    uint8_t obis_code_length = plaintext[current_position + OBIS_LENGTH_OFFSET];
-    if (obis_code_length != OBIS_CODE_LENGTH_STANDARD && obis_code_length != OBIS_CODE_LENGTH_EXTENDED) {
-      ESP_LOGE(TAG, "OBIS: Unsupported OBIS header length: %x", obis_code_length);
-      this->receive_buffer_.clear();
-      return;
-    }
-    if (current_position + OBIS_CODE_OFFSET + obis_code_length > message_length) {
-      ESP_LOGE(TAG, "OBIS: Buffer too short for OBIS code");
-      this->receive_buffer_.clear();
-      return;
-    }
-
-    uint8_t *obis_code = &plaintext[current_position + OBIS_CODE_OFFSET];
-    uint8_t obis_medium = obis_code[OBIS_A];
-    uint16_t obis_cd = encode_uint16(obis_code[OBIS_C], obis_code[OBIS_D]);
-
-    bool timestamp_found = false;
-    bool meter_number_found = false;
-    if (this->provider_ == PROVIDER_NETZNOE) {
-      // Do not advance Position when reading the Timestamp at DECODER_START_OFFSET
-      if ((obis_code_length == OBIS_CODE_LENGTH_EXTENDED) && (current_position == DECODER_START_OFFSET)) {
-        timestamp_found = true;
-      } else if (power_factor_found) {
-        meter_number_found = true;
-        power_factor_found = false;
-      } else {
-        current_position += obis_code_length + OBIS_CODE_OFFSET;  // Advance past code and position
-      }
-    } else {
-      current_position += obis_code_length + OBIS_CODE_OFFSET;  // Advance past code, position and type
-    }
-    if (!timestamp_found && !meter_number_found && obis_medium != Medium::ELECTRICITY &&
-        obis_medium != Medium::ABSTRACT) {
-      ESP_LOGE(TAG, "OBIS: Unsupported OBIS medium: %x", obis_medium);
-      this->receive_buffer_.clear();
-      return;
-    }
-
-    if (current_position >= message_length) {
-      ESP_LOGE(TAG, "OBIS: Buffer too short for data type");
-      this->receive_buffer_.clear();
-      return;
-    }
-
-    float value = 0.0f;
-    uint8_t value_size = 0;
-    uint8_t data_type = plaintext[current_position];
-    current_position++;
-
-    switch (data_type) {
-      case DataType::DOUBLE_LONG_UNSIGNED: {
-        value_size = 4;
-        if (current_position + value_size > message_length) {
-          ESP_LOGE(TAG, "OBIS: Buffer too short for DOUBLE_LONG_UNSIGNED");
-          this->receive_buffer_.clear();
-          return;
-        }
-        value = encode_uint32(plaintext[current_position + 0], plaintext[current_position + 1],
-                              plaintext[current_position + 2], plaintext[current_position + 3]);
-        current_position += value_size;
-        break;
-      }
-      case DataType::LONG_UNSIGNED: {
-        value_size = 2;
-        if (current_position + value_size > message_length) {
-          ESP_LOGE(TAG, "OBIS: Buffer too short for LONG_UNSIGNED");
-          this->receive_buffer_.clear();
-          return;
-        }
-        value = encode_uint16(plaintext[current_position + 0], plaintext[current_position + 1]);
-        current_position += value_size;
-        break;
-      }
-      case DataType::OCTET_STRING: {
-        uint8_t data_length = plaintext[current_position];
-        current_position++;  // Advance past string length
-        if (current_position + data_length > message_length) {
-          ESP_LOGE(TAG, "OBIS: Buffer too short for OCTET_STRING");
-          this->receive_buffer_.clear();
-          return;
-        }
-        // Handle timestamp (normal OBIS code or NETZNOE special case)
-        if (obis_cd == OBIS_TIMESTAMP || timestamp_found) {
-          if (data_length < 8) {
-            ESP_LOGE(TAG, "OBIS: Timestamp data too short: %u", data_length);
-            this->receive_buffer_.clear();
-            return;
-          }
-          uint16_t year = encode_uint16(plaintext[current_position + 0], plaintext[current_position + 1]);
-          uint8_t month = plaintext[current_position + 2];
-          uint8_t day = plaintext[current_position + 3];
-          uint8_t hour = plaintext[current_position + 5];
-          uint8_t minute = plaintext[current_position + 6];
-          uint8_t second = plaintext[current_position + 7];
-          if (year > 9999 || month > 12 || day > 31 || hour > 23 || minute > 59 || second > 59) {
-            ESP_LOGE(TAG, "Invalid timestamp values: %04u-%02u-%02uT%02u:%02u:%02uZ", year, month, day, hour, minute,
-                     second);
-            this->receive_buffer_.clear();
-            return;
-          }
-          snprintf(data.timestamp, sizeof(data.timestamp), "%04u-%02u-%02uT%02u:%02u:%02uZ", year, month, day, hour,
-                   minute, second);
-        } else if (meter_number_found) {
-          snprintf(data.meternumber, sizeof(data.meternumber), "%.*s", data_length, &plaintext[current_position]);
-        }
-        current_position += data_length;
-        break;
-      }
-      default:
-        ESP_LOGE(TAG, "OBIS: Unsupported OBIS data type: %x", data_type);
-        this->receive_buffer_.clear();
-        return;
-    }
-
-    // Skip break after data
-    if (this->provider_ == PROVIDER_NETZNOE) {
-      // Don't skip the break on the first timestamp, as there's none
-      if (!timestamp_found) {
-        current_position += 2;
-      }
-    } else {
-      current_position += 2;
-    }
-
-    // Check for additional data (scaler-unit structure)
-    if (current_position < message_length && plaintext[current_position] == DataType::INTEGER) {
-      // Apply scaler: real_value = raw_value × 10^scaler
-      if (current_position + 1 < message_length) {
-        int8_t scaler = static_cast<int8_t>(plaintext[current_position + 1]);
-        if (scaler != 0) {
-          value *= powf(10.0f, scaler);
-        }
-      }
-
-      // on EVN Meters there is no additional break
-      if (this->provider_ == PROVIDER_NETZNOE) {
-        current_position += 4;
-      } else {
-        current_position += 6;
-      }
-    }
-
-    // Handle numeric values (LONG_UNSIGNED and DOUBLE_LONG_UNSIGNED)
-    if (value_size > 0) {
-      switch (obis_cd) {
-        case OBIS_VOLTAGE_L1:
-          data.voltage_l1 = value;
-          break;
-        case OBIS_VOLTAGE_L2:
-          data.voltage_l2 = value;
-          break;
-        case OBIS_VOLTAGE_L3:
-          data.voltage_l3 = value;
-          break;
-        case OBIS_CURRENT_L1:
-          data.current_l1 = value;
-          break;
-        case OBIS_CURRENT_L2:
-          data.current_l2 = value;
-          break;
-        case OBIS_CURRENT_L3:
-          data.current_l3 = value;
-          break;
-        case OBIS_ACTIVE_POWER_PLUS:
-          data.active_power_plus = value;
-          break;
-        case OBIS_ACTIVE_POWER_MINUS:
-          data.active_power_minus = value;
-          break;
-        case OBIS_ACTIVE_ENERGY_PLUS:
-          data.active_energy_plus = value;
-          break;
-        case OBIS_ACTIVE_ENERGY_MINUS:
-          data.active_energy_minus = value;
-          break;
-        case OBIS_REACTIVE_ENERGY_PLUS:
-          data.reactive_energy_plus = value;
-          break;
-        case OBIS_REACTIVE_ENERGY_MINUS:
-          data.reactive_energy_minus = value;
-          break;
-        case OBIS_POWER_FACTOR:
-          data.power_factor = value;
-          power_factor_found = true;
-          break;
-        default:
-          ESP_LOGW(TAG, "Unsupported OBIS code 0x%04X", obis_cd);
-      }
-    }
-  }
-
-  this->receive_buffer_.clear();
-
-  ESP_LOGI(TAG, "Received valid data");
-  this->publish_sensors(data);
-  this->status_clear_warning();
-}
-
-}  // namespace esphome::dlms_meter

esphome/components/dlms_meter/dlms_meter.h

@@ -1,96 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/log.h"
-#ifdef USE_SENSOR
-#include "esphome/components/sensor/sensor.h"
-#endif
-#ifdef USE_TEXT_SENSOR
-#include "esphome/components/text_sensor/text_sensor.h"
-#endif
-#include "esphome/components/uart/uart.h"
-
-#include "mbus.h"
-#include "dlms.h"
-#include "obis.h"
-
-#include <array>
-#include <vector>
-
-namespace esphome::dlms_meter {
-
-#ifndef DLMS_METER_SENSOR_LIST
-#define DLMS_METER_SENSOR_LIST(F, SEP)
-#endif
-
-#ifndef DLMS_METER_TEXT_SENSOR_LIST
-#define DLMS_METER_TEXT_SENSOR_LIST(F, SEP)
-#endif
-
-struct MeterData {
-  float voltage_l1 = 0.0f;             // Voltage L1
-  float voltage_l2 = 0.0f;             // Voltage L2
-  float voltage_l3 = 0.0f;             // Voltage L3
-  float current_l1 = 0.0f;             // Current L1
-  float current_l2 = 0.0f;             // Current L2
-  float current_l3 = 0.0f;             // Current L3
-  float active_power_plus = 0.0f;      // Active power taken from grid
-  float active_power_minus = 0.0f;     // Active power put into grid
-  float active_energy_plus = 0.0f;     // Active energy taken from grid
-  float active_energy_minus = 0.0f;    // Active energy put into grid
-  float reactive_energy_plus = 0.0f;   // Reactive energy taken from grid
-  float reactive_energy_minus = 0.0f;  // Reactive energy put into grid
-  char timestamp[27]{};                // Text sensor for the timestamp value
-
-  // Netz NOE
-  float power_factor = 0.0f;  // Power Factor
-  char meternumber[13]{};     // Text sensor for the meterNumber value
-};
-
-// Provider constants
-enum Providers : uint32_t { PROVIDER_GENERIC = 0x00, PROVIDER_NETZNOE = 0x01 };
-
-class DlmsMeterComponent : public Component, public uart::UARTDevice {
- public:
-  DlmsMeterComponent() = default;
-
-  void dump_config() override;
-  void loop() override;
-
-  void set_decryption_key(const std::array<uint8_t, 16> &key) { this->decryption_key_ = key; }
-  void set_provider(uint32_t provider) { this->provider_ = provider; }
-
-  void publish_sensors(MeterData &data) {
-#define DLMS_METER_PUBLISH_SENSOR(s) \
-  if (this->s##_sensor_ != nullptr) \
-    s##_sensor_->publish_state(data.s);
-    DLMS_METER_SENSOR_LIST(DLMS_METER_PUBLISH_SENSOR, )
-
-#define DLMS_METER_PUBLISH_TEXT_SENSOR(s) \
-  if (this->s##_text_sensor_ != nullptr) \
-    s##_text_sensor_->publish_state(data.s);
-    DLMS_METER_TEXT_SENSOR_LIST(DLMS_METER_PUBLISH_TEXT_SENSOR, )
-  }
-
-  DLMS_METER_SENSOR_LIST(SUB_SENSOR, )
-  DLMS_METER_TEXT_SENSOR_LIST(SUB_TEXT_SENSOR, )
-
- protected:
-  bool parse_mbus_(std::vector<uint8_t> &mbus_payload);
-  bool parse_dlms_(const std::vector<uint8_t> &mbus_payload, uint16_t &message_length, uint8_t &systitle_length,
-                   uint16_t &header_offset);
-  bool decrypt_(std::vector<uint8_t> &mbus_payload, uint16_t message_length, uint8_t systitle_length,
-                uint16_t header_offset);
-  void decode_obis_(uint8_t *plaintext, uint16_t message_length);
-
-  std::vector<uint8_t> receive_buffer_;  // Stores the packet currently being received
-  std::vector<uint8_t> mbus_payload_;    // Parsed M-Bus payload, reused to avoid heap churn
-  uint32_t last_read_ = 0;               // Timestamp when data was last read
-  uint32_t read_timeout_ = 1000;         // Time to wait after last byte before considering data complete
-
-  uint32_t provider_ = PROVIDER_GENERIC;  // Provider of the meter / your grid operator
-  std::array<uint8_t, 16> decryption_key_;
-};
-
-}  // namespace esphome::dlms_meter

esphome/components/dlms_meter/mbus.h

@@ -1,69 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace esphome::dlms_meter {
-
-/*
-+----------------------------------------------------+ -
-|               Start Character [0x68]               |  \
-+----------------------------------------------------+   |
-|                   Data Length (L)                  |   |
-+----------------------------------------------------+   |
-|               Data Length Repeat (L)               |   |
-+----------------------------------------------------+    > M-Bus Data link layer
-|            Start Character Repeat [0x68]           |   |
-+----------------------------------------------------+   |
-|             Control/Function Field (C)             |   |
-+----------------------------------------------------+   |
-|                  Address Field (A)                 |  /
-+----------------------------------------------------+ -
-|           Control Information Field (CI)           |  \
-+----------------------------------------------------+   |
-|    Source Transport Service Access Point (STSAP)   |    > DLMS/COSEM M-Bus transport layer
-+----------------------------------------------------+   |
-| Destination Transport Service Access Point (DTSAP) |  /
-+----------------------------------------------------+ -
-|                                                    |  \
-~                                                    ~   |
-                         Data                             > DLMS/COSEM Application Layer
-~                                                    ~   |
-|                                                    |  /
-+----------------------------------------------------+ -
-|                      Checksum                      |  \
-+----------------------------------------------------+    > M-Bus Data link layer
-|                Stop Character [0x16]               |  /
-+----------------------------------------------------+ -
-
-Data_Length = L - C - A - CI
-Each line (except Data) is one Byte
-
-Possible Values found in publicly available docs:
-- C: 0x53/0x73 (SND_UD)
-- A: FF (Broadcast)
-- CI: 0x00-0x1F/0x60/0x61/0x7C/0x7D
-- STSAP: 0x01 (Management Logical Device ID 1 of the meter)
-- DTSAP: 0x67 (Consumer Information Push Client ID 103)
- */
-
-// MBUS start bytes for different telegram formats:
-// - Single Character: 0xE5 (length=1)
-// - Short Frame: 0x10 (length=5)
-// - Control Frame: 0x68 (length=9)
-// - Long Frame: 0x68 (length=9+data_length)
-// This component currently only uses Long Frame.
-static constexpr uint8_t START_BYTE_SINGLE_CHARACTER = 0xE5;
-static constexpr uint8_t START_BYTE_SHORT_FRAME = 0x10;
-static constexpr uint8_t START_BYTE_CONTROL_FRAME = 0x68;
-static constexpr uint8_t START_BYTE_LONG_FRAME = 0x68;
-static constexpr uint8_t MBUS_HEADER_INTRO_LENGTH = 4;  // Header length for the intro (0x68, length, length, 0x68)
-static constexpr uint8_t MBUS_FULL_HEADER_LENGTH = 9;   // Total header length
-static constexpr uint8_t MBUS_FOOTER_LENGTH = 2;        // Footer after frame
-static constexpr uint8_t MBUS_MAX_FRAME_LENGTH = 250;   // Maximum size of frame
-static constexpr uint8_t MBUS_START1_OFFSET = 0;        // Offset of first start byte
-static constexpr uint8_t MBUS_LENGTH1_OFFSET = 1;       // Offset of first length byte
-static constexpr uint8_t MBUS_LENGTH2_OFFSET = 2;       // Offset of (duplicated) second length byte
-static constexpr uint8_t MBUS_START2_OFFSET = 3;        // Offset of (duplicated) second start byte
-static constexpr uint8_t STOP_BYTE = 0x16;
-
-}  // namespace esphome::dlms_meter

esphome/components/dlms_meter/obis.h

@@ -1,94 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace esphome::dlms_meter {
-
-// Data types as per specification
-enum DataType {
-  NULL_DATA = 0x00,
-  BOOLEAN = 0x03,
-  BIT_STRING = 0x04,
-  DOUBLE_LONG = 0x05,
-  DOUBLE_LONG_UNSIGNED = 0x06,
-  OCTET_STRING = 0x09,
-  VISIBLE_STRING = 0x0A,
-  UTF8_STRING = 0x0C,
-  BINARY_CODED_DECIMAL = 0x0D,
-  INTEGER = 0x0F,
-  LONG = 0x10,
-  UNSIGNED = 0x11,
-  LONG_UNSIGNED = 0x12,
-  LONG64 = 0x14,
-  LONG64_UNSIGNED = 0x15,
-  ENUM = 0x16,
-  FLOAT32 = 0x17,
-  FLOAT64 = 0x18,
-  DATE_TIME = 0x19,
-  DATE = 0x1A,
-  TIME = 0x1B,
-
-  ARRAY = 0x01,
-  STRUCTURE = 0x02,
-  COMPACT_ARRAY = 0x13
-};
-
-enum Medium {
-  ABSTRACT = 0x00,
-  ELECTRICITY = 0x01,
-  HEAT_COST_ALLOCATOR = 0x04,
-  COOLING = 0x05,
-  HEAT = 0x06,
-  GAS = 0x07,
-  COLD_WATER = 0x08,
-  HOT_WATER = 0x09,
-  OIL = 0x10,
-  COMPRESSED_AIR = 0x11,
-  NITROGEN = 0x12
-};
-
-// Data structure
-static constexpr uint8_t DECODER_START_OFFSET = 20;  // Skip header, timestamp and break block
-static constexpr uint8_t OBIS_TYPE_OFFSET = 0;
-static constexpr uint8_t OBIS_LENGTH_OFFSET = 1;
-static constexpr uint8_t OBIS_CODE_OFFSET = 2;
-static constexpr uint8_t OBIS_CODE_LENGTH_STANDARD = 0x06;  // 6-byte OBIS code (A.B.C.D.E.F)
-static constexpr uint8_t OBIS_CODE_LENGTH_EXTENDED = 0x0C;  // 12-byte extended OBIS code
-static constexpr uint8_t OBIS_A = 0;
-static constexpr uint8_t OBIS_B = 1;
-static constexpr uint8_t OBIS_C = 2;
-static constexpr uint8_t OBIS_D = 3;
-static constexpr uint8_t OBIS_E = 4;
-static constexpr uint8_t OBIS_F = 5;
-
-// Metadata
-static constexpr uint16_t OBIS_TIMESTAMP = 0x0100;
-static constexpr uint16_t OBIS_SERIAL_NUMBER = 0x6001;
-static constexpr uint16_t OBIS_DEVICE_NAME = 0x2A00;
-
-// Voltage
-static constexpr uint16_t OBIS_VOLTAGE_L1 = 0x2007;
-static constexpr uint16_t OBIS_VOLTAGE_L2 = 0x3407;
-static constexpr uint16_t OBIS_VOLTAGE_L3 = 0x4807;
-
-// Current
-static constexpr uint16_t OBIS_CURRENT_L1 = 0x1F07;
-static constexpr uint16_t OBIS_CURRENT_L2 = 0x3307;
-static constexpr uint16_t OBIS_CURRENT_L3 = 0x4707;
-
-// Power
-static constexpr uint16_t OBIS_ACTIVE_POWER_PLUS = 0x0107;
-static constexpr uint16_t OBIS_ACTIVE_POWER_MINUS = 0x0207;
-
-// Active energy
-static constexpr uint16_t OBIS_ACTIVE_ENERGY_PLUS = 0x0108;
-static constexpr uint16_t OBIS_ACTIVE_ENERGY_MINUS = 0x0208;
-
-// Reactive energy
-static constexpr uint16_t OBIS_REACTIVE_ENERGY_PLUS = 0x0308;
-static constexpr uint16_t OBIS_REACTIVE_ENERGY_MINUS = 0x0408;
-
-// Netz NOE specific
-static constexpr uint16_t OBIS_POWER_FACTOR = 0x0D07;
-
-}  // namespace esphome::dlms_meter

esphome/components/dlms_meter/sensor/__init__.py

@@ -1,124 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ID,
-    DEVICE_CLASS_CURRENT,
-    DEVICE_CLASS_ENERGY,
-    DEVICE_CLASS_POWER,
-    DEVICE_CLASS_POWER_FACTOR,
-    DEVICE_CLASS_VOLTAGE,
-    STATE_CLASS_MEASUREMENT,
-    STATE_CLASS_TOTAL_INCREASING,
-    UNIT_AMPERE,
-    UNIT_VOLT,
-    UNIT_WATT,
-    UNIT_WATT_HOURS,
-)
-
-from .. import CONF_DLMS_METER_ID, DlmsMeterComponent
-
-AUTO_LOAD = ["dlms_meter"]
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_DLMS_METER_ID): cv.use_id(DlmsMeterComponent),
-        cv.Optional("voltage_l1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=1,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_l2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=1,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("voltage_l3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_VOLT,
-            accuracy_decimals=1,
-            device_class=DEVICE_CLASS_VOLTAGE,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("current_l1"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=2,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("current_l2"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=2,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("current_l3"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=2,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("active_power_plus"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_WATT,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("active_power_minus"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_WATT,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("active_energy_plus"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_WATT_HOURS,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("active_energy_minus"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_WATT_HOURS,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("reactive_energy_plus"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_WATT_HOURS,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("reactive_energy_minus"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_WATT_HOURS,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        # Netz NOE
-        cv.Optional("power_factor"): sensor.sensor_schema(
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER_FACTOR,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-    }
-).extend(cv.COMPONENT_SCHEMA)
-
-
-async def to_code(config):
-    hub = await cg.get_variable(config[CONF_DLMS_METER_ID])
-
-    sensors = []
-    for key, conf in config.items():
-        if not isinstance(conf, dict):
-            continue
-        id = conf[CONF_ID]
-        if id and id.type == sensor.Sensor:
-            sens = await sensor.new_sensor(conf)
-            cg.add(getattr(hub, f"set_{key}_sensor")(sens))
-            sensors.append(f"F({key})")
-
-    if sensors:
-        cg.add_define(
-            "DLMS_METER_SENSOR_LIST(F, sep)", cg.RawExpression(" sep ".join(sensors))
-        )

esphome/components/dlms_meter/text_sensor/__init__.py

@@ -1,37 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import text_sensor
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
-
-from .. import CONF_DLMS_METER_ID, DlmsMeterComponent
-
-AUTO_LOAD = ["dlms_meter"]
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_DLMS_METER_ID): cv.use_id(DlmsMeterComponent),
-        cv.Optional("timestamp"): text_sensor.text_sensor_schema(),
-        # Netz NOE
-        cv.Optional("meternumber"): text_sensor.text_sensor_schema(),
-    }
-).extend(cv.COMPONENT_SCHEMA)
-
-
-async def to_code(config):
-    hub = await cg.get_variable(config[CONF_DLMS_METER_ID])
-
-    text_sensors = []
-    for key, conf in config.items():
-        if not isinstance(conf, dict):
-            continue
-        id = conf[CONF_ID]
-        if id and id.type == text_sensor.TextSensor:
-            sens = await text_sensor.new_text_sensor(conf)
-            cg.add(getattr(hub, f"set_{key}_text_sensor")(sens))
-            text_sensors.append(f"F({key})")
-
-    if text_sensors:
-        cg.add_define(
-            "DLMS_METER_TEXT_SENSOR_LIST(F, sep)",
-            cg.RawExpression(" sep ".join(text_sensors)),
-        )

esphome/components/endstop/endstop_cover.cpp

@@ -141,15 +141,15 @@ void EndstopCover::start_direction_(CoverOperation dir) {
   Trigger<> *trig;
   switch (dir) {
     case COVER_OPERATION_IDLE:
-      trig = &this->stop_trigger_;
+      trig = this->stop_trigger_;
       break;
     case COVER_OPERATION_OPENING:
       this->last_operation_ = dir;
-      trig = &this->open_trigger_;
+      trig = this->open_trigger_;
       break;
     case COVER_OPERATION_CLOSING:
       this->last_operation_ = dir;
-      trig = &this->close_trigger_;
+      trig = this->close_trigger_;
       break;
     default:
       return;

esphome/components/endstop/endstop_cover.h

@@ -15,9 +15,9 @@ class EndstopCover : public cover::Cover, public Component {
   void dump_config() override;
   float get_setup_priority() const override;
 
-  Trigger<> *get_open_trigger() { return &this->open_trigger_; }
-  Trigger<> *get_close_trigger() { return &this->close_trigger_; }
-  Trigger<> *get_stop_trigger() { return &this->stop_trigger_; }
+  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
+  Trigger<> *get_close_trigger() const { return this->close_trigger_; }
+  Trigger<> *get_stop_trigger() const { return this->stop_trigger_; }
   void set_open_endstop(binary_sensor::BinarySensor *open_endstop) { this->open_endstop_ = open_endstop; }
   void set_close_endstop(binary_sensor::BinarySensor *close_endstop) { this->close_endstop_ = close_endstop; }
   void set_open_duration(uint32_t open_duration) { this->open_duration_ = open_duration; }
@@ -39,11 +39,11 @@ class EndstopCover : public cover::Cover, public Component {
 
   binary_sensor::BinarySensor *open_endstop_;
   binary_sensor::BinarySensor *close_endstop_;
-  Trigger<> open_trigger_;
+  Trigger<> *open_trigger_{new Trigger<>()};
   uint32_t open_duration_;
-  Trigger<> close_trigger_;
+  Trigger<> *close_trigger_{new Trigger<>()};
   uint32_t close_duration_;
-  Trigger<> stop_trigger_;
+  Trigger<> *stop_trigger_{new Trigger<>()};
   uint32_t max_duration_{UINT32_MAX};
 
   Trigger<> *prev_command_trigger_{nullptr};

esphome/components/esp32/__init__.py

@@ -5,7 +5,6 @@ import logging
 import os
 from pathlib import Path
 import re
-import shutil
 
 from esphome import yaml_util
 import esphome.codegen as cg
@@ -51,7 +50,6 @@ from esphome.writer import clean_cmake_cache
 
 from .boards import BOARDS, STANDARD_BOARDS
 from .const import (  # noqa
-    KEY_ARDUINO_LIBRARIES,
     KEY_BOARD,
     KEY_COMPONENTS,
     KEY_ESP32,
@@ -148,168 +146,6 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "wifi_provisioning",  # WiFi provisioning - ESPHome uses its own improv implementation
 )
 
-# Additional IDF managed components to exclude for Arduino framework builds
-# These are pulled in by the Arduino framework's idf_component.yml but not used by ESPHome
-# Note: Component names include the namespace prefix (e.g., "espressif__cbor") because
-# that's how managed components are registered in the IDF build system
-# List includes direct dependencies from arduino-esp32/idf_component.yml
-# plus transitive dependencies from RainMaker/Insights (except espressif/mdns which we need)
-ARDUINO_EXCLUDED_IDF_COMPONENTS = (
-    "chmorgan__esp-libhelix-mp3",  # MP3 decoder - not used
-    "espressif__cbor",  # CBOR library - only used by RainMaker/Insights
-    "espressif__esp-dsp",  # DSP library - not used
-    "espressif__esp-modbus",  # Modbus - ESPHome has its own
-    "espressif__esp-sr",  # Speech recognition - not used
-    "espressif__esp-zboss-lib",  # Zigbee ZBOSS library - not used
-    "espressif__esp-zigbee-lib",  # Zigbee library - not used
-    "espressif__esp_diag_data_store",  # Diagnostics - not used
-    "espressif__esp_diagnostics",  # Diagnostics - not used
-    "espressif__esp_hosted",  # ESP hosted - only for ESP32-P4
-    "espressif__esp_insights",  # ESP Insights - not used
-    "espressif__esp_modem",  # Modem library - not used
-    "espressif__esp_rainmaker",  # RainMaker - not used
-    "espressif__esp_rcp_update",  # RCP update - RainMaker transitive dep
-    "espressif__esp_schedule",  # Schedule - RainMaker transitive dep
-    "espressif__esp_secure_cert_mgr",  # Secure cert - RainMaker transitive dep
-    "espressif__esp_wifi_remote",  # WiFi remote - only for ESP32-P4
-    "espressif__json_generator",  # JSON generator - RainMaker transitive dep
-    "espressif__json_parser",  # JSON parser - RainMaker transitive dep
-    "espressif__lan867x",  # Ethernet PHY - ESPHome uses ESP-IDF ethernet directly
-    "espressif__libsodium",  # Crypto - ESPHome uses its own noise-c library
-    "espressif__network_provisioning",  # Network provisioning - not used
-    "espressif__qrcode",  # QR code - not used
-    "espressif__rmaker_common",  # RainMaker common - not used
-    "joltwallet__littlefs",  # LittleFS - ESPHome doesn't use filesystem
-)
-
-# Mapping of Arduino libraries to IDF managed components they require
-# When an Arduino library is enabled via cg.add_library(), these components
-# are automatically un-stubbed from ARDUINO_EXCLUDED_IDF_COMPONENTS.
-#
-# Note: Some libraries (Matter, LittleFS, ESP_SR, WiFiProv, ArduinoOTA) already have
-# conditional maybe_add_component() calls in arduino-esp32/CMakeLists.txt that handle
-# their managed component dependencies. Our mapping is primarily needed for libraries
-# that don't have such conditionals (Ethernet, PPP, Zigbee, RainMaker, Insights, etc.)
-# and to ensure the stubs are removed from our idf_component.yml overrides.
-ARDUINO_LIBRARY_IDF_COMPONENTS: dict[str, tuple[str, ...]] = {
-    "BLE": ("esp_driver_gptimer",),
-    "BluetoothSerial": ("esp_driver_gptimer",),
-    "ESP_HostedOTA": ("espressif__esp_hosted", "espressif__esp_wifi_remote"),
-    "ESP_SR": ("espressif__esp-sr",),
-    "Ethernet": ("espressif__lan867x",),
-    "FFat": ("fatfs",),
-    "Insights": (
-        "espressif__cbor",
-        "espressif__esp_insights",
-        "espressif__esp_diagnostics",
-        "espressif__esp_diag_data_store",
-        "espressif__rmaker_common",  # Transitive dep from esp_insights
-    ),
-    "LittleFS": ("joltwallet__littlefs",),
-    "Matter": ("espressif__esp_matter",),
-    "PPP": ("espressif__esp_modem",),
-    "RainMaker": (
-        # Direct deps from idf_component.yml
-        "espressif__cbor",
-        "espressif__esp_rainmaker",
-        "espressif__esp_insights",
-        "espressif__esp_diagnostics",
-        "espressif__esp_diag_data_store",
-        "espressif__rmaker_common",
-        "espressif__qrcode",
-        # Transitive deps from esp_rainmaker
-        "espressif__esp_rcp_update",
-        "espressif__esp_schedule",
-        "espressif__esp_secure_cert_mgr",
-        "espressif__json_generator",
-        "espressif__json_parser",
-        "espressif__network_provisioning",
-    ),
-    "SD": ("fatfs",),
-    "SD_MMC": ("fatfs",),
-    "SPIFFS": ("spiffs",),
-    "WiFiProv": ("espressif__network_provisioning", "espressif__qrcode"),
-    "Zigbee": ("espressif__esp-zigbee-lib", "espressif__esp-zboss-lib"),
-}
-
-# Arduino library to Arduino library dependencies
-# When enabling one library, also enable its dependencies
-# Kconfig "select" statements don't work with CONFIG_ARDUINO_SELECTIVE_COMPILATION
-ARDUINO_LIBRARY_DEPENDENCIES: dict[str, tuple[str, ...]] = {
-    "Ethernet": ("Network",),
-    "WiFi": ("Network",),
-}
-
-
-def _idf_component_stub_name(component: str) -> str:
-    """Get stub directory name from IDF component name.
-
-    Component names are typically namespace__name (e.g., espressif__cbor).
-    Returns just the name part (e.g., cbor). If no namespace is present,
-    returns the original component name.
-    """
-    _prefix, sep, suffix = component.partition("__")
-    return suffix if sep else component
-
-
-def _idf_component_dep_name(component: str) -> str:
-    """Convert IDF component name to dependency format.
-
-    Converts espressif__cbor to espressif/cbor.
-    """
-    return component.replace("__", "/")
-
-
-# Arduino libraries to disable by default when using Arduino framework
-# ESPHome uses ESP-IDF APIs directly; we only need the Arduino core
-# (HardwareSerial, Print, Stream, GPIO functions which are always compiled)
-# Components use cg.add_library() which auto-enables any they need
-# This list must match ARDUINO_ALL_LIBRARIES from arduino-esp32/CMakeLists.txt
-ARDUINO_DISABLED_LIBRARIES: frozenset[str] = frozenset(
-    {
-        "ArduinoOTA",
-        "AsyncUDP",
-        "BLE",
-        "BluetoothSerial",
-        "DNSServer",
-        "EEPROM",
-        "ESP_HostedOTA",
-        "ESP_I2S",
-        "ESP_NOW",
-        "ESP_SR",
-        "ESPmDNS",
-        "Ethernet",
-        "FFat",
-        "FS",
-        "Hash",
-        "HTTPClient",
-        "HTTPUpdate",
-        "Insights",
-        "LittleFS",
-        "Matter",
-        "NetBIOS",
-        "Network",
-        "NetworkClientSecure",
-        "OpenThread",
-        "PPP",
-        "Preferences",
-        "RainMaker",
-        "SD",
-        "SD_MMC",
-        "SimpleBLE",
-        "SPI",
-        "SPIFFS",
-        "Ticker",
-        "Update",
-        "USB",
-        "WebServer",
-        "WiFi",
-        "WiFiProv",
-        "Wire",
-        "Zigbee",
-    }
-)
-
 # ESP32 (original) chip revision options
 # Setting minimum revision to 3.0 or higher:
 # - Reduces flash size by excluding workaround code for older chip bugs
@@ -401,13 +237,7 @@ def set_core_data(config):
     CORE.data[KEY_ESP32][KEY_COMPONENTS] = {}
     # Initialize with default exclusions - components can call include_builtin_idf_component()
     # to re-enable any they need
-    excluded = set(DEFAULT_EXCLUDED_IDF_COMPONENTS)
-    # Add Arduino-specific managed component exclusions when using Arduino framework
-    if conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
-        excluded.update(ARDUINO_EXCLUDED_IDF_COMPONENTS)
-    CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS] = excluded
-    # Initialize Arduino library tracking - cg.add_library() auto-enables libraries
-    CORE.data[KEY_ESP32][KEY_ARDUINO_LIBRARIES] = set()
+    CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS] = set(DEFAULT_EXCLUDED_IDF_COMPONENTS)
     CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = cv.Version.parse(
         config[CONF_FRAMEWORK][CONF_VERSION]
     )
@@ -555,26 +385,6 @@ def include_builtin_idf_component(name: str) -> None:
     CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS].discard(name)
 
 
-def _enable_arduino_library(name: str) -> None:
-    """Enable an Arduino library that is disabled by default.
-
-    This is called automatically by CORE.add_library() when a component adds
-    an Arduino library via cg.add_library(). Components should not call this
-    directly - just use cg.add_library("LibName", None).
-
-    Args:
-        name: The library name (e.g., "Wire", "SPI", "WiFi")
-    """
-    enabled_libs: set[str] = CORE.data[KEY_ESP32][KEY_ARDUINO_LIBRARIES]
-    enabled_libs.add(name)
-    # Also enable any required Arduino library dependencies
-    for dep_lib in ARDUINO_LIBRARY_DEPENDENCIES.get(name, ()):
-        enabled_libs.add(dep_lib)
-    # Also enable any required IDF components
-    for idf_component in ARDUINO_LIBRARY_IDF_COMPONENTS.get(name, ()):
-        include_builtin_idf_component(idf_component)
-
-
 def add_extra_script(stage: str, filename: str, path: Path):
     """Add an extra script to the project."""
     key = f"{stage}:{filename}"
@@ -1316,27 +1126,6 @@ async def _write_exclude_components() -> None:
         )
 
 
-@coroutine_with_priority(CoroPriority.FINAL)
-async def _write_arduino_libraries_sdkconfig() -> None:
-    """Write Arduino selective compilation sdkconfig after all components have added libraries.
-
-    This must run at FINAL priority so that all components have had a chance to call
-    cg.add_library() which auto-enables Arduino libraries via _enable_arduino_library().
-    """
-    if KEY_ESP32 not in CORE.data:
-        return
-    # Enable Arduino selective compilation to disable unused Arduino libraries
-    # ESPHome uses ESP-IDF APIs directly; we only need the Arduino core
-    # (HardwareSerial, Print, Stream, GPIO functions which are always compiled)
-    # cg.add_library() auto-enables needed libraries; users can also add
-    # libraries via esphome: libraries: config which calls cg.add_library()
-    add_idf_sdkconfig_option("CONFIG_ARDUINO_SELECTIVE_COMPILATION", True)
-    enabled_libs = CORE.data[KEY_ESP32].get(KEY_ARDUINO_LIBRARIES, set())
-    for lib in ARDUINO_DISABLED_LIBRARIES:
-        # Enable if explicitly requested, disable otherwise
-        add_idf_sdkconfig_option(f"CONFIG_ARDUINO_SELECTIVE_{lib}", lib in enabled_libs)
-
-
 @coroutine_with_priority(CoroPriority.FINAL)
 async def _add_yaml_idf_components(components: list[ConfigType]):
     """Add IDF components from YAML config with final priority to override code-added components."""
@@ -1540,10 +1329,6 @@ async def to_code(config):
     # Disable dynamic log level control to save memory
     add_idf_sdkconfig_option("CONFIG_LOG_DYNAMIC_LEVEL_CONTROL", False)
 
-    # Disable per-tag log level filtering since dynamic level control is disabled above
-    # This saves ~250 bytes of RAM (tag cache) and associated code
-    add_idf_sdkconfig_option("CONFIG_LOG_TAG_LEVEL_IMPL_NONE", True)
-
     # Reduce PHY TX power in the event of a brownout
     add_idf_sdkconfig_option("CONFIG_ESP_PHY_REDUCE_TX_POWER", True)
 
@@ -1755,11 +1540,6 @@ async def to_code(config):
     # Default exclusions are added in set_core_data() during config validation.
     CORE.add_job(_write_exclude_components)
 
-    # Write Arduino selective compilation sdkconfig at FINAL priority after all
-    # components have had a chance to call cg.add_library() to enable libraries they need.
-    if conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
-        CORE.add_job(_write_arduino_libraries_sdkconfig)
-
 
 APP_PARTITION_SIZES = {
     "2MB": 0x0C0000,  # 768 KB
@@ -1840,49 +1620,11 @@ def _write_sdkconfig():
 
 def _write_idf_component_yml():
     yml_path = CORE.relative_build_path("src/idf_component.yml")
-    dependencies: dict[str, dict] = {}
-
-    # For Arduino builds, override unused managed components from the Arduino framework
-    # by pointing them to empty stub directories using override_path
-    # This prevents the IDF component manager from downloading the real components
-    if CORE.using_arduino:
-        # Determine which IDF components are needed by enabled Arduino libraries
-        enabled_libs = CORE.data[KEY_ESP32].get(KEY_ARDUINO_LIBRARIES, set())
-        required_idf_components = {
-            comp
-            for lib in enabled_libs
-            for comp in ARDUINO_LIBRARY_IDF_COMPONENTS.get(lib, ())
-        }
-
-        # Only stub components that are not required by any enabled Arduino library
-        components_to_stub = (
-            set(ARDUINO_EXCLUDED_IDF_COMPONENTS) - required_idf_components
-        )
-
-        stubs_dir = CORE.relative_build_path("component_stubs")
-        stubs_dir.mkdir(exist_ok=True)
-        for component_name in components_to_stub:
-            # Create stub directory with minimal CMakeLists.txt
-            stub_path = stubs_dir / _idf_component_stub_name(component_name)
-            stub_path.mkdir(exist_ok=True)
-            stub_cmake = stub_path / "CMakeLists.txt"
-            if not stub_cmake.exists():
-                stub_cmake.write_text("idf_component_register()\n")
-            dependencies[_idf_component_dep_name(component_name)] = {
-                "version": "*",
-                "override_path": str(stub_path),
-            }
-
-        # Remove stubs for components that are now required by enabled libraries
-        for component_name in required_idf_components:
-            stub_path = stubs_dir / _idf_component_stub_name(component_name)
-            if stub_path.exists():
-                shutil.rmtree(stub_path)
-
     if CORE.data[KEY_ESP32][KEY_COMPONENTS]:
         components: dict = CORE.data[KEY_ESP32][KEY_COMPONENTS]
+        dependencies = {}
         for name, component in components.items():
-            dependency: dict[str, str] = {}
+            dependency = {}
             if component[KEY_REF]:
                 dependency["version"] = component[KEY_REF]
             if component[KEY_REPO]:
@@ -1890,8 +1632,9 @@ def _write_idf_component_yml():
             if component[KEY_PATH]:
                 dependency["path"] = component[KEY_PATH]
             dependencies[name] = dependency
-
-    contents = yaml_util.dump({"dependencies": dependencies}) if dependencies else ""
+        contents = yaml_util.dump({"dependencies": dependencies})
+    else:
+        contents = ""
     if write_file_if_changed(yml_path, contents):
         dependencies_lock = CORE.relative_build_path("dependencies.lock")
         if dependencies_lock.is_file():

esphome/components/esp32/const.py

@@ -7,7 +7,6 @@ KEY_VARIANT = "variant"
 KEY_SDKCONFIG_OPTIONS = "sdkconfig_options"
 KEY_COMPONENTS = "components"
 KEY_EXCLUDE_COMPONENTS = "exclude_components"
-KEY_ARDUINO_LIBRARIES = "arduino_libraries"
 KEY_REPO = "repo"
 KEY_REF = "ref"
 KEY_REFRESH = "refresh"

esphome/components/esp32_hosted/update/esp32_hosted_update.cpp

@@ -196,11 +196,14 @@ bool Esp32HostedUpdate::fetch_manifest_() {
     int read_or_error = container->read(buf, sizeof(buf));
     App.feed_wdt();
     yield();
-    auto result = http_request::http_read_loop_result(read_or_error, last_data_time, read_timeout);
+    auto result =
+        http_request::http_read_loop_result(read_or_error, last_data_time, read_timeout, container->is_read_complete());
     if (result == http_request::HttpReadLoopResult::RETRY)
       continue;
+    // Note: COMPLETE is currently unreachable since the loop condition checks bytes_read < content_length,
+    // but this is defensive code in case chunked transfer encoding support is added in the future.
     if (result != http_request::HttpReadLoopResult::DATA)
-      break;  // ERROR or TIMEOUT
+      break;  // COMPLETE, ERROR, or TIMEOUT
     json_str.append(reinterpret_cast<char *>(buf), read_or_error);
   }
   container->end();
@@ -321,9 +324,14 @@ bool Esp32HostedUpdate::stream_firmware_to_coprocessor_() {
     App.feed_wdt();
     yield();
 
-    auto result = http_request::http_read_loop_result(read_or_error, last_data_time, read_timeout);
+    auto result =
+        http_request::http_read_loop_result(read_or_error, last_data_time, read_timeout, container->is_read_complete());
     if (result == http_request::HttpReadLoopResult::RETRY)
       continue;
+    // Note: COMPLETE is currently unreachable since the loop condition checks bytes_read < content_length,
+    // but this is defensive code in case chunked transfer encoding support is added in the future.
+    if (result == http_request::HttpReadLoopResult::COMPLETE)
+      break;
     if (result != http_request::HttpReadLoopResult::DATA) {
       if (result == http_request::HttpReadLoopResult::TIMEOUT) {
         ESP_LOGE(TAG, "Timeout reading firmware data");

esphome/components/espnow/__init__.py

@@ -13,7 +13,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_WIFI,
 )
-from esphome.core import HexInt
+from esphome.core import CORE, HexInt
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@jesserockz"]
@@ -124,6 +124,9 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
+    if CORE.using_arduino:
+        cg.add_library("WiFi", None)
+
     # ESP-NOW uses wake_loop_threadsafe() to wake the main loop from ESP-NOW callbacks
     # This enables low-latency event processing instead of waiting for select() timeout
     socket.require_wake_loop_threadsafe()

esphome/components/ethernet/__init__.py

@@ -1,6 +1,6 @@
 import logging
 
-from esphome import automation, pins
+from esphome import pins
 import esphome.codegen as cg
 from esphome.components.esp32 import (
     VARIANT_ESP32,
@@ -35,8 +35,6 @@ from esphome.const import (
     CONF_MODE,
     CONF_MOSI_PIN,
     CONF_NUMBER,
-    CONF_ON_CONNECT,
-    CONF_ON_DISCONNECT,
     CONF_PAGE_ID,
     CONF_PIN,
     CONF_POLLING_INTERVAL,
@@ -239,8 +237,6 @@ BASE_SCHEMA = cv.Schema(
         cv.Optional(CONF_DOMAIN, default=".local"): cv.domain_name,
         cv.Optional(CONF_USE_ADDRESS): cv.string_strict,
         cv.Optional(CONF_MAC_ADDRESS): cv.mac_address,
-        cv.Optional(CONF_ON_CONNECT): automation.validate_automation(single=True),
-        cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(single=True),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -431,17 +427,8 @@ async def to_code(config):
         # Add LAN867x 10BASE-T1S PHY support component
         add_idf_component(name="espressif/lan867x", ref="2.0.0")
 
-    if on_connect_config := config.get(CONF_ON_CONNECT):
-        cg.add_define("USE_ETHERNET_CONNECT_TRIGGER")
-        await automation.build_automation(
-            var.get_connect_trigger(), [], on_connect_config
-        )
-
-    if on_disconnect_config := config.get(CONF_ON_DISCONNECT):
-        cg.add_define("USE_ETHERNET_DISCONNECT_TRIGGER")
-        await automation.build_automation(
-            var.get_disconnect_trigger(), [], on_disconnect_config
-        )
+    if CORE.using_arduino:
+        cg.add_library("WiFi", None)
 
     CORE.add_job(final_step)
 

esphome/components/ethernet/ethernet_component.cpp

@@ -309,9 +309,6 @@ void EthernetComponent::loop() {
 
         this->dump_connect_params_();
         this->status_clear_warning();
-#ifdef USE_ETHERNET_CONNECT_TRIGGER
-        this->connect_trigger_.trigger();
-#endif
       } else if (now - this->connect_begin_ > 15000) {
         ESP_LOGW(TAG, "Connecting failed; reconnecting");
         this->start_connect_();
@@ -321,16 +318,10 @@ void EthernetComponent::loop() {
       if (!this->started_) {
         ESP_LOGI(TAG, "Stopped connection");
         this->state_ = EthernetComponentState::STOPPED;
-#ifdef USE_ETHERNET_DISCONNECT_TRIGGER
-        this->disconnect_trigger_.trigger();
-#endif
       } else if (!this->connected_) {
         ESP_LOGW(TAG, "Connection lost; reconnecting");
         this->state_ = EthernetComponentState::CONNECTING;
         this->start_connect_();
-#ifdef USE_ETHERNET_DISCONNECT_TRIGGER
-        this->disconnect_trigger_.trigger();
-#endif
       } else {
         this->finish_connect_();
         // When connected and stable, disable the loop to save CPU cycles

esphome/components/ethernet/ethernet_component.h

@@ -4,7 +4,6 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/automation.h"
 #include "esphome/components/network/ip_address.h"
 
 #ifdef USE_ESP32
@@ -120,12 +119,6 @@ class EthernetComponent : public Component {
   void add_ip_state_listener(EthernetIPStateListener *listener) { this->ip_state_listeners_.push_back(listener); }
 #endif
 
-#ifdef USE_ETHERNET_CONNECT_TRIGGER
-  Trigger<> *get_connect_trigger() { return &this->connect_trigger_; }
-#endif
-#ifdef USE_ETHERNET_DISCONNECT_TRIGGER
-  Trigger<> *get_disconnect_trigger() { return &this->disconnect_trigger_; }
-#endif
  protected:
   static void eth_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data);
   static void got_ip_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data);
@@ -197,12 +190,6 @@ class EthernetComponent : public Component {
   StaticVector<EthernetIPStateListener *, ESPHOME_ETHERNET_IP_STATE_LISTENERS> ip_state_listeners_;
 #endif
 
-#ifdef USE_ETHERNET_CONNECT_TRIGGER
-  Trigger<> connect_trigger_;
-#endif
-#ifdef USE_ETHERNET_DISCONNECT_TRIGGER
-  Trigger<> disconnect_trigger_;
-#endif
  private:
   // Stores a pointer to a string literal (static storage duration).
   // ONLY set from Python-generated code with string literals - never dynamic strings.

esphome/components/feedback/feedback_cover.cpp

@@ -335,18 +335,18 @@ void FeedbackCover::start_direction_(CoverOperation dir) {
 
   switch (dir) {
     case COVER_OPERATION_IDLE:
-      trig = &this->stop_trigger_;
+      trig = this->stop_trigger_;
       break;
     case COVER_OPERATION_OPENING:
       this->last_operation_ = dir;
-      trig = &this->open_trigger_;
+      trig = this->open_trigger_;
 #ifdef USE_BINARY_SENSOR
       obstacle = this->open_obstacle_;
 #endif
       break;
     case COVER_OPERATION_CLOSING:
       this->last_operation_ = dir;
-      trig = &this->close_trigger_;
+      trig = this->close_trigger_;
 #ifdef USE_BINARY_SENSOR
       obstacle = this->close_obstacle_;
 #endif

esphome/components/feedback/feedback_cover.h

@@ -17,9 +17,9 @@ class FeedbackCover : public cover::Cover, public Component {
   void loop() override;
   void dump_config() override;
 
-  Trigger<> *get_open_trigger() { return &this->open_trigger_; }
-  Trigger<> *get_close_trigger() { return &this->close_trigger_; }
-  Trigger<> *get_stop_trigger() { return &this->stop_trigger_; }
+  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
+  Trigger<> *get_close_trigger() const { return this->close_trigger_; }
+  Trigger<> *get_stop_trigger() const { return this->stop_trigger_; }
 
 #ifdef USE_BINARY_SENSOR
   void set_open_endstop(binary_sensor::BinarySensor *open_endstop);
@@ -61,9 +61,9 @@ class FeedbackCover : public cover::Cover, public Component {
   binary_sensor::BinarySensor *close_obstacle_{nullptr};
 
 #endif
-  Trigger<> open_trigger_;
-  Trigger<> close_trigger_;
-  Trigger<> stop_trigger_;
+  Trigger<> *open_trigger_{new Trigger<>()};
+  Trigger<> *close_trigger_{new Trigger<>()};
+  Trigger<> *stop_trigger_{new Trigger<>()};
 
   uint32_t open_duration_{0};
   uint32_t close_duration_{0};

esphome/components/http_request/http_request.h

@@ -26,6 +26,7 @@ struct Header {
 enum HttpStatus {
   HTTP_STATUS_OK = 200,
   HTTP_STATUS_NO_CONTENT = 204,
+  HTTP_STATUS_RESET_CONTENT = 205,
   HTTP_STATUS_PARTIAL_CONTENT = 206,
 
   /* 3xx - Redirection */
@@ -126,19 +127,21 @@ struct HttpReadResult {
 
 /// Result of processing a non-blocking read with timeout (for manual loops)
 enum class HttpReadLoopResult : uint8_t {
-  DATA,     ///< Data was read, process it
-  RETRY,    ///< No data yet, already delayed, caller should continue loop
-  ERROR,    ///< Read error, caller should exit loop
-  TIMEOUT,  ///< Timeout waiting for data, caller should exit loop
+  DATA,      ///< Data was read, process it
+  COMPLETE,  ///< All content has been read, caller should exit loop
+  RETRY,     ///< No data yet, already delayed, caller should continue loop
+  ERROR,     ///< Read error, caller should exit loop
+  TIMEOUT,   ///< Timeout waiting for data, caller should exit loop
 };
 
 /// Process a read result with timeout tracking and delay handling
 /// @param bytes_read_or_error Return value from read() - positive for bytes read, negative for error
 /// @param last_data_time Time of last successful read, updated when data received
 /// @param timeout_ms Maximum time to wait for data
-/// @return DATA if data received, RETRY if should continue loop, ERROR/TIMEOUT if should exit
-inline HttpReadLoopResult http_read_loop_result(int bytes_read_or_error, uint32_t &last_data_time,
-                                                uint32_t timeout_ms) {
+/// @param is_read_complete Whether all expected content has been read (from HttpContainer::is_read_complete())
+/// @return How the caller should proceed - see HttpReadLoopResult enum
+inline HttpReadLoopResult http_read_loop_result(int bytes_read_or_error, uint32_t &last_data_time, uint32_t timeout_ms,
+                                                bool is_read_complete) {
   if (bytes_read_or_error > 0) {
     last_data_time = millis();
     return HttpReadLoopResult::DATA;
@@ -146,7 +149,10 @@ inline HttpReadLoopResult http_read_loop_result(int bytes_read_or_error, uint32_
   if (bytes_read_or_error < 0) {
     return HttpReadLoopResult::ERROR;
   }
-  // bytes_read_or_error == 0: no data available yet
+  // bytes_read_or_error == 0: either "no data yet" or "all content read"
+  if (is_read_complete) {
+    return HttpReadLoopResult::COMPLETE;
+  }
   if (millis() - last_data_time >= timeout_ms) {
     return HttpReadLoopResult::TIMEOUT;
   }
@@ -159,9 +165,9 @@ class HttpRequestComponent;
 class HttpContainer : public Parented<HttpRequestComponent> {
  public:
   virtual ~HttpContainer() = default;
-  size_t content_length;
-  int status_code;
-  uint32_t duration_ms;
+  size_t content_length{0};
+  int status_code{-1};  ///< -1 indicates no response received yet
+  uint32_t duration_ms{0};
 
   /**
    * @brief Read data from the HTTP response body.
@@ -194,9 +200,24 @@ class HttpContainer : public Parented<HttpRequestComponent> {
   virtual void end() = 0;
 
   void set_secure(bool secure) { this->secure_ = secure; }
+  void set_chunked(bool chunked) { this->is_chunked_ = chunked; }
 
   size_t get_bytes_read() const { return this->bytes_read_; }
 
+  /// Check if all expected content has been read
+  /// For chunked responses, returns false (completion detected via read() returning error/EOF)
+  bool is_read_complete() const {
+    // Per RFC 9112, these responses have no body:
+    // - 1xx (Informational), 204 No Content, 205 Reset Content, 304 Not Modified
+    if ((this->status_code >= 100 && this->status_code < 200) || this->status_code == HTTP_STATUS_NO_CONTENT ||
+        this->status_code == HTTP_STATUS_RESET_CONTENT || this->status_code == HTTP_STATUS_NOT_MODIFIED) {
+      return true;
+    }
+    // For non-chunked responses, complete when bytes_read >= content_length
+    // This handles both Content-Length: 0 and Content-Length: N cases
+    return !this->is_chunked_ && this->bytes_read_ >= this->content_length;
+  }
+
   /**
    * @brief Get response headers.
    *
@@ -209,6 +230,7 @@ class HttpContainer : public Parented<HttpRequestComponent> {
  protected:
   size_t bytes_read_{0};
   bool secure_{false};
+  bool is_chunked_{false};  ///< True if response uses chunked transfer encoding
   std::map<std::string, std::list<std::string>> response_headers_{};
 };
 
@@ -219,7 +241,7 @@ class HttpContainer : public Parented<HttpRequestComponent> {
 /// @param total_size Total bytes to read
 /// @param chunk_size Maximum bytes per read call
 /// @param timeout_ms Read timeout in milliseconds
-/// @return HttpReadResult with status and error_code on failure
+/// @return HttpReadResult with status and error_code on failure; use container->get_bytes_read() for total bytes read
 inline HttpReadResult http_read_fully(HttpContainer *container, uint8_t *buffer, size_t total_size, size_t chunk_size,
                                       uint32_t timeout_ms) {
   size_t read_index = 0;
@@ -231,9 +253,11 @@ inline HttpReadResult http_read_fully(HttpContainer *container, uint8_t *buffer,
     App.feed_wdt();
     yield();
 
-    auto result = http_read_loop_result(read_bytes_or_error, last_data_time, timeout_ms);
+    auto result = http_read_loop_result(read_bytes_or_error, last_data_time, timeout_ms, container->is_read_complete());
     if (result == HttpReadLoopResult::RETRY)
       continue;
+    if (result == HttpReadLoopResult::COMPLETE)
+      break;  // Server sent less data than requested, but transfer is complete
     if (result == HttpReadLoopResult::ERROR)
       return {HttpReadStatus::ERROR, read_bytes_or_error};
     if (result == HttpReadLoopResult::TIMEOUT)
@@ -332,13 +356,13 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
   void set_json(std::function<void(Ts..., JsonObject)> json_func) { this->json_func_ = json_func; }
 
 #ifdef USE_HTTP_REQUEST_RESPONSE
-  Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...> *get_success_trigger_with_response() {
-    return &this->success_trigger_with_response_;
+  Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...> *get_success_trigger_with_response() const {
+    return this->success_trigger_with_response_;
   }
 #endif
-  Trigger<std::shared_ptr<HttpContainer>, Ts...> *get_success_trigger() { return &this->success_trigger_; }
+  Trigger<std::shared_ptr<HttpContainer>, Ts...> *get_success_trigger() const { return this->success_trigger_; }
 
-  Trigger<Ts...> *get_error_trigger() { return &this->error_trigger_; }
+  Trigger<Ts...> *get_error_trigger() const { return this->error_trigger_; }
 
   void set_max_response_buffer_size(size_t max_response_buffer_size) {
     this->max_response_buffer_size_ = max_response_buffer_size;
@@ -372,7 +396,7 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
     auto captured_args = std::make_tuple(x...);
 
     if (container == nullptr) {
-      std::apply([this](Ts... captured_args_inner) { this->error_trigger_.trigger(captured_args_inner...); },
+      std::apply([this](Ts... captured_args_inner) { this->error_trigger_->trigger(captured_args_inner...); },
                  captured_args);
       return;
     }
@@ -393,11 +417,12 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
           int read_or_error = container->read(buf + read_index, std::min<size_t>(max_length - read_index, 512));
           App.feed_wdt();
           yield();
-          auto result = http_read_loop_result(read_or_error, last_data_time, read_timeout);
+          auto result =
+              http_read_loop_result(read_or_error, last_data_time, read_timeout, container->is_read_complete());
           if (result == HttpReadLoopResult::RETRY)
             continue;
           if (result != HttpReadLoopResult::DATA)
-            break;  // ERROR or TIMEOUT
+            break;  // COMPLETE, ERROR, or TIMEOUT
           read_index += read_or_error;
         }
         response_body.reserve(read_index);
@@ -406,14 +431,14 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
       }
       std::apply(
           [this, &container, &response_body](Ts... captured_args_inner) {
-            this->success_trigger_with_response_.trigger(container, response_body, captured_args_inner...);
+            this->success_trigger_with_response_->trigger(container, response_body, captured_args_inner...);
           },
           captured_args);
     } else
 #endif
     {
       std::apply([this, &container](
-                     Ts... captured_args_inner) { this->success_trigger_.trigger(container, captured_args_inner...); },
+                     Ts... captured_args_inner) { this->success_trigger_->trigger(container, captured_args_inner...); },
                  captured_args);
     }
     container->end();
@@ -433,10 +458,12 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
   std::map<const char *, TemplatableValue<std::string, Ts...>> json_{};
   std::function<void(Ts..., JsonObject)> json_func_{nullptr};
 #ifdef USE_HTTP_REQUEST_RESPONSE
-  Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...> success_trigger_with_response_;
+  Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...> *success_trigger_with_response_ =
+      new Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...>();
 #endif
-  Trigger<std::shared_ptr<HttpContainer>, Ts...> success_trigger_;
-  Trigger<Ts...> error_trigger_;
+  Trigger<std::shared_ptr<HttpContainer>, Ts...> *success_trigger_ =
+      new Trigger<std::shared_ptr<HttpContainer>, Ts...>();
+  Trigger<Ts...> *error_trigger_ = new Trigger<Ts...>();
 
   size_t max_response_buffer_size_{SIZE_MAX};
 };

esphome/components/http_request/http_request_arduino.cpp

@@ -135,9 +135,23 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &ur
   // When cast to size_t, -1 becomes SIZE_MAX (4294967295 on 32-bit).
   // The read() method handles this: bytes_read_ can never reach SIZE_MAX, so the
   // early return check (bytes_read_ >= content_length) will never trigger.
+  //
+  // TODO: Chunked transfer encoding is NOT properly supported on Arduino.
+  // The implementation in #7884 was incomplete - it only works correctly on ESP-IDF where
+  // esp_http_client_read() decodes chunks internally. On Arduino, using getStreamPtr()
+  // returns raw TCP data with chunk framing (e.g., "12a\r\n{json}\r\n0\r\n\r\n") instead
+  // of decoded content. This wasn't noticed because requests would complete and payloads
+  // were only examined on IDF. The long transfer times were also masked by the misleading
+  // "HTTP on Arduino version >= 3.1 is **very** slow" warning above. This causes two issues:
+  // 1. Response body is corrupted - contains chunk size headers mixed with data
+  // 2. Cannot detect end of transfer - connection stays open (keep-alive), causing timeout
+  // The proper fix would be to use getString() for chunked responses, which decodes chunks
+  // internally, but this buffers the entire response in memory.
   int content_length = container->client_.getSize();
   ESP_LOGD(TAG, "Content-Length: %d", content_length);
   container->content_length = (size_t) content_length;
+  // -1 (SIZE_MAX when cast to size_t) means chunked transfer encoding
+  container->set_chunked(content_length == -1);
   container->duration_ms = millis() - start;
 
   return container;
@@ -178,9 +192,9 @@ int HttpContainerArduino::read(uint8_t *buf, size_t max_len) {
 
   if (bufsize == 0) {
     this->duration_ms += (millis() - start);
-    // Check if we've read all expected content (only valid when content_length is known and not SIZE_MAX)
-    // For chunked encoding (content_length == SIZE_MAX), we can't use this check
-    if (this->content_length > 0 && this->bytes_read_ >= this->content_length) {
+    // Check if we've read all expected content (non-chunked only)
+    // For chunked encoding (content_length == SIZE_MAX), is_read_complete() returns false
+    if (this->is_read_complete()) {
       return 0;  // All content read successfully
     }
     // No data available - check if connection is still open

esphome/components/http_request/http_request_idf.cpp

@@ -160,6 +160,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
   // esp_http_client_fetch_headers() returns 0 for chunked transfer encoding (no Content-Length header).
   // The read() method handles content_length == 0 specially to support chunked responses.
   container->content_length = esp_http_client_fetch_headers(client);
+  container->set_chunked(esp_http_client_is_chunked_response(client));
   container->feed_wdt();
   container->status_code = esp_http_client_get_status_code(client);
   container->feed_wdt();
@@ -195,6 +196,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
 
       container->feed_wdt();
       container->content_length = esp_http_client_fetch_headers(client);
+      container->set_chunked(esp_http_client_is_chunked_response(client));
       container->feed_wdt();
       container->status_code = esp_http_client_get_status_code(client);
       container->feed_wdt();
@@ -239,10 +241,9 @@ int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
   const uint32_t start = millis();
   watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());
 
-  // Check if we've already read all expected content
-  // Skip this check when content_length is 0 (chunked transfer encoding or unknown length)
-  // For chunked responses, esp_http_client_read() will return 0 when all data is received
-  if (this->content_length > 0 && this->bytes_read_ >= this->content_length) {
+  // Check if we've already read all expected content (non-chunked only)
+  // For chunked responses (content_length == 0), esp_http_client_read() handles EOF
+  if (this->is_read_complete()) {
     return 0;  // All content read successfully
   }
 

esphome/components/http_request/ota/ota_http_request.cpp

@@ -130,9 +130,13 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
     App.feed_wdt();
     yield();
 
-    auto result = http_read_loop_result(bufsize_or_error, last_data_time, read_timeout);
+    auto result = http_read_loop_result(bufsize_or_error, last_data_time, read_timeout, container->is_read_complete());
     if (result == HttpReadLoopResult::RETRY)
       continue;
+    // Note: COMPLETE is currently unreachable since the loop condition checks bytes_read < content_length,
+    // but this is defensive code in case chunked transfer encoding support is added for OTA in the future.
+    if (result == HttpReadLoopResult::COMPLETE)
+      break;
     if (result != HttpReadLoopResult::DATA) {
       if (result == HttpReadLoopResult::TIMEOUT) {
         ESP_LOGE(TAG, "Timeout reading data");

esphome/components/i2c/i2c.cpp

@@ -11,6 +11,12 @@ namespace i2c {
 static const char *const TAG = "i2c";
 
 void I2CBus::i2c_scan_() {
+  // suppress logs from the IDF I2C library during the scan
+#if defined(USE_ESP32) && defined(USE_LOGGER)
+  auto previous = esp_log_level_get("*");
+  esp_log_level_set("*", ESP_LOG_NONE);
+#endif
+
   for (uint8_t address = 8; address != 120; address++) {
     auto err = write_readv(address, nullptr, 0, nullptr, 0);
     if (err == ERROR_OK) {
@@ -21,6 +27,9 @@ void I2CBus::i2c_scan_() {
     // it takes 16sec to scan on nrf52. It prevents board reset.
     arch_feed_wdt();
   }
+#if defined(USE_ESP32) && defined(USE_LOGGER)
+  esp_log_level_set("*", previous);
+#endif
 }
 
 ErrorCode I2CDevice::read_register(uint8_t a_register, uint8_t *data, size_t len) {

esphome/components/i2s_audio/media_player/__init__.py

@@ -114,7 +114,6 @@ async def to_code(config):
         cg.add(var.set_external_dac_channels(2 if config[CONF_MODE] == "stereo" else 1))
         cg.add(var.set_i2s_comm_fmt_lsb(config[CONF_I2S_COMM_FMT] == "lsb"))
 
-    cg.add_library("WiFi", None)
     cg.add_library("NetworkClientSecure", None)
     cg.add_library("HTTPClient", None)
     cg.add_library("esphome/ESP32-audioI2S", "2.3.0")

esphome/components/light/base_light_effects.h

@@ -138,20 +138,20 @@ class LambdaLightEffect : public LightEffect {
 class AutomationLightEffect : public LightEffect {
  public:
   AutomationLightEffect(const char *name) : LightEffect(name) {}
-  void stop() override { this->trig_.stop_action(); }
+  void stop() override { this->trig_->stop_action(); }
   void apply() override {
-    if (!this->trig_.is_action_running()) {
-      this->trig_.trigger();
+    if (!this->trig_->is_action_running()) {
+      this->trig_->trigger();
     }
   }
-  Trigger<> *get_trig() { return &this->trig_; }
+  Trigger<> *get_trig() const { return trig_; }
 
   /// Get the current effect index for use in automations.
   /// Useful for automations that need to know which effect is running.
   uint32_t get_current_index() const { return this->get_index(); }
 
  protected:
-  Trigger<> trig_;
+  Trigger<> *trig_{new Trigger<>};
 };
 
 struct StrobeLightEffectColor {

esphome/components/logger/logger_esp32.cpp

@@ -114,6 +114,9 @@ void Logger::pre_setup() {
 
   global_logger = this;
   esp_log_set_vprintf(esp_idf_log_vprintf_);
+  if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE) {
+    esp_log_level_set("*", ESP_LOG_VERBOSE);
+  }
 
   ESP_LOGI(TAG, "Log initialized");
 }

esphome/components/max7219/display.py

@@ -28,10 +28,11 @@ CONFIG_SCHEMA = (
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID], config[CONF_NUM_CHIPS])
+    var = cg.new_Pvariable(config[CONF_ID])
     await spi.register_spi_device(var, config, write_only=True)
     await display.register_display(var, config)
 
+    cg.add(var.set_num_chips(config[CONF_NUM_CHIPS]))
     cg.add(var.set_intensity(config[CONF_INTENSITY]))
     cg.add(var.set_reverse(config[CONF_REVERSE_ENABLE]))
 

esphome/components/max7219/max7219.cpp

@@ -3,7 +3,8 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-namespace esphome::max7219 {
+namespace esphome {
+namespace max7219 {
 
 static const char *const TAG = "max7219";
 
@@ -114,14 +115,12 @@ const uint8_t MAX7219_ASCII_TO_RAW[95] PROGMEM = {
 };
 
 float MAX7219Component::get_setup_priority() const { return setup_priority::PROCESSOR; }
-
-MAX7219Component::MAX7219Component(uint8_t num_chips) : num_chips_(num_chips) {
-  this->buffer_ = new uint8_t[this->num_chips_ * 8];  // NOLINT
-  memset(this->buffer_, 0, this->num_chips_ * 8);
-}
-
 void MAX7219Component::setup() {
   this->spi_setup();
+  this->buffer_ = new uint8_t[this->num_chips_ * 8];  // NOLINT
+  for (uint8_t i = 0; i < this->num_chips_ * 8; i++)
+    this->buffer_[i] = 0;
+
   // let's assume the user has all 8 digits connected, only important in daisy chained setups anyway
   this->send_to_all_(MAX7219_REGISTER_SCAN_LIMIT, 7);
   // let's use our own ASCII -> led pattern encoding
@@ -230,6 +229,7 @@ void MAX7219Component::set_intensity(uint8_t intensity) {
     this->intensity_ = intensity;
   }
 }
+void MAX7219Component::set_num_chips(uint8_t num_chips) { this->num_chips_ = num_chips; }
 
 uint8_t MAX7219Component::strftime(uint8_t pos, const char *format, ESPTime time) {
   char buffer[64];
@@ -240,4 +240,5 @@ uint8_t MAX7219Component::strftime(uint8_t pos, const char *format, ESPTime time
 }
 uint8_t MAX7219Component::strftime(const char *format, ESPTime time) { return this->strftime(0, format, time); }
 
-}  // namespace esphome::max7219
+}  // namespace max7219
+}  // namespace esphome

esphome/components/max7219/max7219.h

@@ -6,7 +6,8 @@
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/display/display.h"
 
-namespace esphome::max7219 {
+namespace esphome {
+namespace max7219 {
 
 class MAX7219Component;
 
@@ -16,8 +17,6 @@ class MAX7219Component : public PollingComponent,
                          public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
                                                spi::CLOCK_PHASE_LEADING, spi::DATA_RATE_1MHZ> {
  public:
-  explicit MAX7219Component(uint8_t num_chips);
-
   void set_writer(max7219_writer_t &&writer);
 
   void setup() override;
@@ -31,6 +30,7 @@ class MAX7219Component : public PollingComponent,
   void display();
 
   void set_intensity(uint8_t intensity);
+  void set_num_chips(uint8_t num_chips);
   void set_reverse(bool reverse) { this->reverse_ = reverse; };
 
   /// Evaluate the printf-format and print the result at the given position.
@@ -56,9 +56,10 @@ class MAX7219Component : public PollingComponent,
   uint8_t intensity_{15};     // Intensity of the display from 0 to 15 (most)
   bool intensity_changed_{};  // True if we need to re-send the intensity
   uint8_t num_chips_{1};
-  uint8_t *buffer_{nullptr};
+  uint8_t *buffer_;
   bool reverse_{false};
   max7219_writer_t writer_{};
 };
 
-}  // namespace esphome::max7219
+}  // namespace max7219
+}  // namespace esphome

esphome/components/micro_wake_word/micro_wake_word.cpp

@@ -325,7 +325,7 @@ void MicroWakeWord::loop() {
           ESP_LOGD(TAG, "Detected '%s' with sliding average probability is %.2f and max probability is %.2f",
                    detection_event.wake_word->c_str(), (detection_event.average_probability / uint8_to_float_divisor),
                    (detection_event.max_probability / uint8_to_float_divisor));
-          this->wake_word_detected_trigger_.trigger(*detection_event.wake_word);
+          this->wake_word_detected_trigger_->trigger(*detection_event.wake_word);
           if (this->stop_after_detection_) {
             this->stop();
           }

esphome/components/micro_wake_word/micro_wake_word.h

@@ -60,7 +60,7 @@ class MicroWakeWord : public Component
 
   void set_stop_after_detection(bool stop_after_detection) { this->stop_after_detection_ = stop_after_detection; }
 
-  Trigger<std::string> *get_wake_word_detected_trigger() { return &this->wake_word_detected_trigger_; }
+  Trigger<std::string> *get_wake_word_detected_trigger() const { return this->wake_word_detected_trigger_; }
 
   void add_wake_word_model(WakeWordModel *model);
 
@@ -78,7 +78,7 @@ class MicroWakeWord : public Component
 
  protected:
   microphone::MicrophoneSource *microphone_source_{nullptr};
-  Trigger<std::string> wake_word_detected_trigger_;
+  Trigger<std::string> *wake_word_detected_trigger_ = new Trigger<std::string>();
   State state_{State::STOPPED};
 
   std::weak_ptr<RingBuffer> ring_buffer_;

esphome/components/midea/climate.py

@@ -30,7 +30,7 @@ from esphome.const import (
     UNIT_PERCENT,
     UNIT_WATT,
 )
-from esphome.core import CORE, coroutine
+from esphome.core import coroutine
 
 CODEOWNERS = ["@dudanov"]
 DEPENDENCIES = ["climate", "uart"]
@@ -290,7 +290,4 @@ async def to_code(config):
     if CONF_HUMIDITY_SETPOINT in config:
         sens = await sensor.new_sensor(config[CONF_HUMIDITY_SETPOINT])
         cg.add(var.set_humidity_setpoint_sensor(sens))
-    # MideaUART library requires WiFi (WiFi auto-enables Network via dependency mapping)
-    if CORE.is_esp32:
-        cg.add_library("WiFi", None)
     cg.add_library("dudanov/MideaUART", "1.1.9")

esphome/components/mipi_spi/mipi_spi.cpp

@@ -1,39 +1,6 @@
 #include "mipi_spi.h"
 #include "esphome/core/log.h"
 
-namespace esphome::mipi_spi {
-
-void internal_dump_config(const char *model, int width, int height, int offset_width, int offset_height, uint8_t madctl,
-                          bool invert_colors, int display_bits, bool is_big_endian, const optional<uint8_t> &brightness,
-                          GPIOPin *cs, GPIOPin *reset, GPIOPin *dc, int spi_mode, uint32_t data_rate, int bus_width) {
-  ESP_LOGCONFIG(TAG,
-                "MIPI_SPI Display\n"
-                "  Model: %s\n"
-                "  Width: %d\n"
-                "  Height: %d\n"
-                "  Swap X/Y: %s\n"
-                "  Mirror X: %s\n"
-                "  Mirror Y: %s\n"
-                "  Invert colors: %s\n"
-                "  Color order: %s\n"
-                "  Display pixels: %d bits\n"
-                "  Endianness: %s\n"
-                "  SPI Mode: %d\n"
-                "  SPI Data rate: %uMHz\n"
-                "  SPI Bus width: %d",
-                model, width, height, YESNO(madctl & MADCTL_MV), YESNO(madctl & (MADCTL_MX | MADCTL_XFLIP)),
-                YESNO(madctl & (MADCTL_MY | MADCTL_YFLIP)), YESNO(invert_colors), (madctl & MADCTL_BGR) ? "BGR" : "RGB",
-                display_bits, is_big_endian ? "Big" : "Little", spi_mode, static_cast<unsigned>(data_rate / 1000000),
-                bus_width);
-  LOG_PIN("  CS Pin: ", cs);
-  LOG_PIN("  Reset Pin: ", reset);
-  LOG_PIN("  DC Pin: ", dc);
-  if (offset_width != 0)
-    ESP_LOGCONFIG(TAG, "  Offset width: %d", offset_width);
-  if (offset_height != 0)
-    ESP_LOGCONFIG(TAG, "  Offset height: %d", offset_height);
-  if (brightness.has_value())
-    ESP_LOGCONFIG(TAG, "  Brightness: %u", brightness.value());
-}
-
-}  // namespace esphome::mipi_spi
+namespace esphome {
+namespace mipi_spi {}  // namespace mipi_spi
+}  // namespace esphome

esphome/components/mipi_spi/mipi_spi.h

@@ -63,11 +63,6 @@ enum BusType {
   BUS_TYPE_SINGLE_16 = 16,  // Single bit bus, but 16 bits per transfer
 };
 
-// Helper function for dump_config - defined in mipi_spi.cpp to allow use of LOG_PIN macro
-void internal_dump_config(const char *model, int width, int height, int offset_width, int offset_height, uint8_t madctl,
-                          bool invert_colors, int display_bits, bool is_big_endian, const optional<uint8_t> &brightness,
-                          GPIOPin *cs, GPIOPin *reset, GPIOPin *dc, int spi_mode, uint32_t data_rate, int bus_width);
-
 /**
  * Base class for MIPI SPI displays.
  * All the methods are defined here in the header file, as it is not possible to define templated methods in a cpp file.
@@ -206,9 +201,37 @@ class MipiSpi : public display::Display,
   }
 
   void dump_config() override {
-    internal_dump_config(this->model_, WIDTH, HEIGHT, OFFSET_WIDTH, OFFSET_HEIGHT, this->madctl_, this->invert_colors_,
-                         DISPLAYPIXEL * 8, IS_BIG_ENDIAN, this->brightness_, this->cs_, this->reset_pin_, this->dc_pin_,
-                         this->mode_, this->data_rate_, BUS_TYPE);
+    esph_log_config(TAG,
+                    "MIPI_SPI Display\n"
+                    "  Model: %s\n"
+                    "  Width: %u\n"
+                    "  Height: %u",
+                    this->model_, WIDTH, HEIGHT);
+    if constexpr (OFFSET_WIDTH != 0)
+      esph_log_config(TAG, "  Offset width: %u", OFFSET_WIDTH);
+    if constexpr (OFFSET_HEIGHT != 0)
+      esph_log_config(TAG, "  Offset height: %u", OFFSET_HEIGHT);
+    esph_log_config(TAG,
+                    "  Swap X/Y: %s\n"
+                    "  Mirror X: %s\n"
+                    "  Mirror Y: %s\n"
+                    "  Invert colors: %s\n"
+                    "  Color order: %s\n"
+                    "  Display pixels: %d bits\n"
+                    "  Endianness: %s\n",
+                    YESNO(this->madctl_ & MADCTL_MV), YESNO(this->madctl_ & (MADCTL_MX | MADCTL_XFLIP)),
+                    YESNO(this->madctl_ & (MADCTL_MY | MADCTL_YFLIP)), YESNO(this->invert_colors_),
+                    this->madctl_ & MADCTL_BGR ? "BGR" : "RGB", DISPLAYPIXEL * 8, IS_BIG_ENDIAN ? "Big" : "Little");
+    if (this->brightness_.has_value())
+      esph_log_config(TAG, "  Brightness: %u", this->brightness_.value());
+    log_pin(TAG, "  CS Pin: ", this->cs_);
+    log_pin(TAG, "  Reset Pin: ", this->reset_pin_);
+    log_pin(TAG, "  DC Pin: ", this->dc_pin_);
+    esph_log_config(TAG,
+                    "  SPI Mode: %d\n"
+                    "  SPI Data rate: %dMHz\n"
+                    "  SPI Bus width: %d",
+                    this->mode_, static_cast<unsigned>(this->data_rate_ / 1000000), BUS_TYPE);
   }
 
  protected:

esphome/components/mixer/speaker/automation.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "esphome/core/automation.h"
 #include "mixer_speaker.h"
 
 #ifdef USE_ESP32

esphome/components/mqtt/mqtt_backend_esp32.h

@@ -139,8 +139,7 @@ class MQTTBackendESP32 final : public MQTTBackend {
     this->lwt_retain_ = retain;
   }
   void set_server(network::IPAddress ip, uint16_t port) final {
-    char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
-    this->host_ = ip.str_to(ip_buf);
+    this->host_ = ip.str();
     this->port_ = port;
   }
   void set_server(const char *host, uint16_t port) final {

esphome/components/network/__init__.py

@@ -137,7 +137,8 @@ CONFIG_SCHEMA = cv.Schema(
 @coroutine_with_priority(CoroPriority.NETWORK)
 async def to_code(config):
     cg.add_define("USE_NETWORK")
-    # ESP32 with Arduino uses ESP-IDF network APIs directly, no Arduino Network library needed
+    if CORE.using_arduino and CORE.is_esp32:
+        cg.add_library("Networking", None)
 
     # Apply high performance networking settings
     # Config can explicitly enable/disable, or default to component-driven behavior

esphome/components/pmsx003/pmsx003.cpp

@@ -181,20 +181,17 @@ optional<bool> PMSX003Component::check_byte_() {
 bool PMSX003Component::check_payload_length_(uint16_t payload_length) {
   // https://avaldebe.github.io/PyPMS/sensors/Plantower/
   switch (this->type_) {
-    case Type::PMS1003:
-      return payload_length == 28;  // 2*13+2
-    case Type::PMS3003:             // Data 7/8/9 not set/reserved
-      return payload_length == 20;  // 2*9+2
-    case Type::PMSX003:             // Data 13 not set/reserved
-      // Deprecated: Length 20 is for PMS3003 backwards compatibility
+    case Type::PMSX003:
+      // The expected payload length is typically 28 bytes.
+      // However, a 20-byte payload check was already present in the code.
+      // No official documentation was found confirming this.
+      // Retaining this check to avoid breaking existing behavior.
       return payload_length == 28 || payload_length == 20;  // 2*13+2
     case Type::PMS5003S:
-    case Type::PMS5003T:            // Data 13 not set/reserved
-      return payload_length == 28;  // 2*13+2
-    case Type::PMS5003ST:           // Data 16 not set/reserved
-      return payload_length == 36;  // 2*17+2
-    case Type::PMS9003M:
-      return payload_length == 28;  // 2*13+2
+    case Type::PMS5003T:
+      return payload_length == 28;  // 2*13+2 (Data 13 not set/reserved)
+    case Type::PMS5003ST:
+      return payload_length == 36;  // 2*17+2 (Data 16 not set/reserved)
   }
   return false;
 }
@@ -317,10 +314,9 @@ void PMSX003Component::parse_data_() {
   }
 
   // Firmware Version and Error Code
-  if (this->type_ == Type::PMS1003 || this->type_ == Type::PMS5003ST || this->type_ == Type::PMS9003M) {
-    const uint8_t firmware_error_code_offset = (this->type_ == Type::PMS5003ST) ? 36 : 28;
-    const uint8_t firmware_version = this->data_[firmware_error_code_offset];
-    const uint8_t error_code = this->data_[firmware_error_code_offset + 1];
+  if (this->type_ == Type::PMS5003ST) {
+    const uint8_t firmware_version = this->data_[36];
+    const uint8_t error_code = this->data_[37];
 
     ESP_LOGD(TAG, "Got Firmware Version: 0x%02X, Error Code: 0x%02X", firmware_version, error_code);
   }

esphome/components/pmsx003/pmsx003.h

@@ -8,13 +8,10 @@
 namespace esphome::pmsx003 {
 
 enum class Type : uint8_t {
-  PMS1003 = 0,
-  PMS3003,
-  PMSX003,  // PMS5003, PMS6003, PMS7003, PMSA003 (NOT PMSA003I - see `pmsa003i` component)
+  PMSX003 = 0,
   PMS5003S,
   PMS5003T,
   PMS5003ST,
-  PMS9003M,
 };
 
 enum class Command : uint8_t {

esphome/components/pmsx003/sensor.py

@@ -40,127 +40,33 @@ pmsx003_ns = cg.esphome_ns.namespace("pmsx003")
 PMSX003Component = pmsx003_ns.class_("PMSX003Component", uart.UARTDevice, cg.Component)
 PMSX003Sensor = pmsx003_ns.class_("PMSX003Sensor", sensor.Sensor)
 
-TYPE_PMS1003 = "PMS1003"
-TYPE_PMS3003 = "PMS3003"
-TYPE_PMSX003 = "PMSX003"  # PMS5003, PMS6003, PMS7003, PMSA003 (NOT PMSA003I - see `pmsa003i` component)
+TYPE_PMSX003 = "PMSX003"
 TYPE_PMS5003S = "PMS5003S"
 TYPE_PMS5003T = "PMS5003T"
 TYPE_PMS5003ST = "PMS5003ST"
-TYPE_PMS9003M = "PMS9003M"
 
 Type = pmsx003_ns.enum("Type", is_class=True)
 
 PMSX003_TYPES = {
-    TYPE_PMS1003: Type.PMS1003,
-    TYPE_PMS3003: Type.PMS3003,
     TYPE_PMSX003: Type.PMSX003,
     TYPE_PMS5003S: Type.PMS5003S,
     TYPE_PMS5003T: Type.PMS5003T,
     TYPE_PMS5003ST: Type.PMS5003ST,
-    TYPE_PMS9003M: Type.PMS9003M,
 }
 
 SENSORS_TO_TYPE = {
-    CONF_PM_1_0_STD: [
-        TYPE_PMS1003,
-        TYPE_PMS3003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003T,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_2_5_STD: [
-        TYPE_PMS1003,
-        TYPE_PMS3003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003T,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_10_0_STD: [
-        TYPE_PMS1003,
-        TYPE_PMS3003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003T,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_1_0: [
-        TYPE_PMS1003,
-        TYPE_PMS3003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003T,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_2_5: [
-        TYPE_PMS1003,
-        TYPE_PMS3003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003T,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_10_0: [
-        TYPE_PMS1003,
-        TYPE_PMS3003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003T,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_0_3UM: [
-        TYPE_PMS1003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003T,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_0_5UM: [
-        TYPE_PMS1003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003T,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_1_0UM: [
-        TYPE_PMS1003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003T,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_2_5UM: [
-        TYPE_PMS1003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003T,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_5_0UM: [
-        TYPE_PMS1003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
-    CONF_PM_10_0UM: [
-        TYPE_PMS1003,
-        TYPE_PMSX003,
-        TYPE_PMS5003S,
-        TYPE_PMS5003ST,
-        TYPE_PMS9003M,
-    ],
+    CONF_PM_1_0_STD: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
+    CONF_PM_2_5_STD: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
+    CONF_PM_10_0_STD: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
+    CONF_PM_1_0: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
+    CONF_PM_2_5: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
+    CONF_PM_10_0: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
+    CONF_PM_0_3UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
+    CONF_PM_0_5UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
+    CONF_PM_1_0UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
+    CONF_PM_2_5UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
+    CONF_PM_5_0UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003ST],
+    CONF_PM_10_0UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003ST],
     CONF_FORMALDEHYDE: [TYPE_PMS5003S, TYPE_PMS5003ST],
     CONF_TEMPERATURE: [TYPE_PMS5003T, TYPE_PMS5003ST],
     CONF_HUMIDITY: [TYPE_PMS5003T, TYPE_PMS5003ST],

esphome/components/remote_transmitter/remote_transmitter.cpp

@@ -83,7 +83,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
   uint32_t on_time, off_time;
   this->calculate_on_off_time_(this->temp_.get_carrier_frequency(), &on_time, &off_time);
   this->target_time_ = 0;
-  this->transmit_trigger_.trigger();
+  this->transmit_trigger_->trigger();
   for (uint32_t i = 0; i < send_times; i++) {
     InterruptLock lock;
     for (int32_t item : this->temp_.get_data()) {
@@ -102,7 +102,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     if (i + 1 < send_times)
       this->target_time_ += send_wait;
   }
-  this->complete_trigger_.trigger();
+  this->complete_trigger_->trigger();
 }
 
 }  // namespace remote_transmitter

esphome/components/remote_transmitter/remote_transmitter.h

@@ -57,8 +57,8 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
   void set_non_blocking(bool non_blocking) { this->non_blocking_ = non_blocking; }
 #endif
 
-  Trigger<> *get_transmit_trigger() { return &this->transmit_trigger_; }
-  Trigger<> *get_complete_trigger() { return &this->complete_trigger_; }
+  Trigger<> *get_transmit_trigger() const { return this->transmit_trigger_; };
+  Trigger<> *get_complete_trigger() const { return this->complete_trigger_; };
 
  protected:
   void send_internal(uint32_t send_times, uint32_t send_wait) override;
@@ -96,8 +96,8 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
 #endif
   uint8_t carrier_duty_percent_;
 
-  Trigger<> transmit_trigger_;
-  Trigger<> complete_trigger_;
+  Trigger<> *transmit_trigger_{new Trigger<>()};
+  Trigger<> *complete_trigger_{new Trigger<>()};
 };
 
 }  // namespace remote_transmitter

esphome/components/remote_transmitter/remote_transmitter_esp32.cpp

@@ -203,7 +203,7 @@ void RemoteTransmitterComponent::wait_for_rmt_() {
     this->status_set_warning();
   }
 
-  this->complete_trigger_.trigger();
+  this->complete_trigger_->trigger();
 }
 
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
@@ -264,7 +264,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     return;
   }
 
-  this->transmit_trigger_.trigger();
+  this->transmit_trigger_->trigger();
 
   rmt_transmit_config_t config;
   memset(&config, 0, sizeof(config));
@@ -333,7 +333,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     ESP_LOGE(TAG, "Empty data");
     return;
   }
-  this->transmit_trigger_.trigger();
+  this->transmit_trigger_->trigger();
   for (uint32_t i = 0; i < send_times; i++) {
     rmt_transmit_config_t config;
     memset(&config, 0, sizeof(config));
@@ -354,7 +354,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     if (i + 1 < send_times)
       delayMicroseconds(send_wait);
   }
-  this->complete_trigger_.trigger();
+  this->complete_trigger_->trigger();
 }
 #endif
 

esphome/components/speaker/media_player/speaker_media_player.cpp

@@ -519,9 +519,9 @@ void SpeakerMediaPlayer::set_mute_state_(bool mute_state) {
 
   if (old_mute_state != mute_state) {
     if (mute_state) {
-      this->defer([this]() { this->mute_trigger_.trigger(); });
+      this->defer([this]() { this->mute_trigger_->trigger(); });
     } else {
-      this->defer([this]() { this->unmute_trigger_.trigger(); });
+      this->defer([this]() { this->unmute_trigger_->trigger(); });
     }
   }
 }
@@ -550,7 +550,7 @@ void SpeakerMediaPlayer::set_volume_(float volume, bool publish) {
     this->set_mute_state_(false);
   }
 
-  this->defer([this, volume]() { this->volume_trigger_.trigger(volume); });
+  this->defer([this, volume]() { this->volume_trigger_->trigger(volume); });
 }
 
 }  // namespace speaker

esphome/components/speaker/media_player/speaker_media_player.h

@@ -84,9 +84,9 @@ class SpeakerMediaPlayer : public Component,
     this->media_format_ = media_format;
   }
 
-  Trigger<> *get_mute_trigger() { return &this->mute_trigger_; }
-  Trigger<> *get_unmute_trigger() { return &this->unmute_trigger_; }
-  Trigger<float> *get_volume_trigger() { return &this->volume_trigger_; }
+  Trigger<> *get_mute_trigger() const { return this->mute_trigger_; }
+  Trigger<> *get_unmute_trigger() const { return this->unmute_trigger_; }
+  Trigger<float> *get_volume_trigger() const { return this->volume_trigger_; }
 
   void play_file(audio::AudioFile *media_file, bool announcement, bool enqueue);
 
@@ -154,9 +154,9 @@ class SpeakerMediaPlayer : public Component,
   // Used to save volume/mute state for restoration on reboot
   ESPPreferenceObject pref_;
 
-  Trigger<> mute_trigger_;
-  Trigger<> unmute_trigger_;
-  Trigger<float> volume_trigger_;
+  Trigger<> *mute_trigger_ = new Trigger<>();
+  Trigger<> *unmute_trigger_ = new Trigger<>();
+  Trigger<float> *volume_trigger_ = new Trigger<float>();
 };
 
 }  // namespace speaker

esphome/components/sprinkler/sprinkler.cpp

@@ -29,7 +29,7 @@ void SprinklerControllerNumber::setup() {
 }
 
 void SprinklerControllerNumber::control(float value) {
-  this->set_trigger_.trigger(value);
+  this->set_trigger_->trigger(value);
 
   this->publish_state(value);
 
@@ -39,7 +39,8 @@ void SprinklerControllerNumber::control(float value) {
 
 void SprinklerControllerNumber::dump_config() { LOG_NUMBER("", "Sprinkler Controller Number", this); }
 
-SprinklerControllerSwitch::SprinklerControllerSwitch() = default;
+SprinklerControllerSwitch::SprinklerControllerSwitch()
+    : turn_on_trigger_(new Trigger<>()), turn_off_trigger_(new Trigger<>()) {}
 
 void SprinklerControllerSwitch::loop() {
   // Loop is only enabled when f_ has a value (see setup())
@@ -55,11 +56,11 @@ void SprinklerControllerSwitch::write_state(bool state) {
   }
 
   if (state) {
-    this->prev_trigger_ = &this->turn_on_trigger_;
-    this->turn_on_trigger_.trigger();
+    this->prev_trigger_ = this->turn_on_trigger_;
+    this->turn_on_trigger_->trigger();
   } else {
-    this->prev_trigger_ = &this->turn_off_trigger_;
-    this->turn_off_trigger_.trigger();
+    this->prev_trigger_ = this->turn_off_trigger_;
+    this->turn_off_trigger_->trigger();
   }
 
   this->publish_state(state);
@@ -68,6 +69,9 @@ void SprinklerControllerSwitch::write_state(bool state) {
 void SprinklerControllerSwitch::set_state_lambda(std::function<optional<bool>()> &&f) { this->f_ = f; }
 float SprinklerControllerSwitch::get_setup_priority() const { return setup_priority::HARDWARE; }
 
+Trigger<> *SprinklerControllerSwitch::get_turn_on_trigger() const { return this->turn_on_trigger_; }
+Trigger<> *SprinklerControllerSwitch::get_turn_off_trigger() const { return this->turn_off_trigger_; }
+
 void SprinklerControllerSwitch::setup() {
   this->state = this->get_initial_state_with_restore_mode().value_or(false);
   // Disable loop if no state lambda is set - nothing to poll

esphome/components/sprinkler/sprinkler.h

@@ -76,7 +76,7 @@ class SprinklerControllerNumber : public number::Number, public Component {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::PROCESSOR; }
 
-  Trigger<float> *get_set_trigger() { return &this->set_trigger_; }
+  Trigger<float> *get_set_trigger() const { return set_trigger_; }
   void set_initial_value(float initial_value) { initial_value_ = initial_value; }
   void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
 
@@ -84,7 +84,7 @@ class SprinklerControllerNumber : public number::Number, public Component {
   void control(float value) override;
   float initial_value_{NAN};
   bool restore_value_{true};
-  Trigger<float> set_trigger_;
+  Trigger<float> *set_trigger_ = new Trigger<float>();
 
   ESPPreferenceObject pref_;
 };
@@ -97,8 +97,8 @@ class SprinklerControllerSwitch : public switch_::Switch, public Component {
   void dump_config() override;
 
   void set_state_lambda(std::function<optional<bool>()> &&f);
-  Trigger<> *get_turn_on_trigger() { return &this->turn_on_trigger_; }
-  Trigger<> *get_turn_off_trigger() { return &this->turn_off_trigger_; }
+  Trigger<> *get_turn_on_trigger() const;
+  Trigger<> *get_turn_off_trigger() const;
   void loop() override;
 
   float get_setup_priority() const override;
@@ -107,8 +107,8 @@ class SprinklerControllerSwitch : public switch_::Switch, public Component {
   void write_state(bool state) override;
 
   optional<std::function<optional<bool>()>> f_;
-  Trigger<> turn_on_trigger_;
-  Trigger<> turn_off_trigger_;
+  Trigger<> *turn_on_trigger_;
+  Trigger<> *turn_off_trigger_;
   Trigger<> *prev_trigger_{nullptr};
 };
 

esphome/components/sx126x/sx126x.cpp

@@ -343,7 +343,7 @@ void SX126x::call_listeners_(const std::vector<uint8_t> &packet, float rssi, flo
   for (auto &listener : this->listeners_) {
     listener->on_packet(packet, rssi, snr);
   }
-  this->packet_trigger_.trigger(packet, rssi, snr);
+  this->packet_trigger_->trigger(packet, rssi, snr);
 }
 
 void SX126x::loop() {

esphome/components/sx126x/sx126x.h

@@ -97,7 +97,7 @@ class SX126x : public Component,
   void configure();
   SX126xError transmit_packet(const std::vector<uint8_t> &packet);
   void register_listener(SX126xListener *listener) { this->listeners_.push_back(listener); }
-  Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
+  Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() const { return this->packet_trigger_; };
 
  protected:
   void configure_fsk_ook_();
@@ -111,7 +111,7 @@ class SX126x : public Component,
   void read_register_(uint16_t reg, uint8_t *data, uint8_t size);
   void call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr);
   void wait_busy_();
-  Trigger<std::vector<uint8_t>, float, float> packet_trigger_;
+  Trigger<std::vector<uint8_t>, float, float> *packet_trigger_{new Trigger<std::vector<uint8_t>, float, float>()};
   std::vector<SX126xListener *> listeners_;
   std::vector<uint8_t> packet_;
   std::vector<uint8_t> sync_value_;

esphome/components/sx127x/sx127x.cpp

@@ -300,7 +300,7 @@ void SX127x::call_listeners_(const std::vector<uint8_t> &packet, float rssi, flo
   for (auto &listener : this->listeners_) {
     listener->on_packet(packet, rssi, snr);
   }
-  this->packet_trigger_.trigger(packet, rssi, snr);
+  this->packet_trigger_->trigger(packet, rssi, snr);
 }
 
 void SX127x::loop() {

esphome/components/sx127x/sx127x.h

@@ -83,7 +83,7 @@ class SX127x : public Component,
   void configure();
   SX127xError transmit_packet(const std::vector<uint8_t> &packet);
   void register_listener(SX127xListener *listener) { this->listeners_.push_back(listener); }
-  Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
+  Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() const { return this->packet_trigger_; };
 
  protected:
   void configure_fsk_ook_();
@@ -94,7 +94,7 @@ class SX127x : public Component,
   void write_register_(uint8_t reg, uint8_t value);
   void call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr);
   uint8_t read_register_(uint8_t reg);
-  Trigger<std::vector<uint8_t>, float, float> packet_trigger_;
+  Trigger<std::vector<uint8_t>, float, float> *packet_trigger_{new Trigger<std::vector<uint8_t>, float, float>()};
   std::vector<SX127xListener *> listeners_;
   std::vector<uint8_t> packet_;
   std::vector<uint8_t> sync_value_;

esphome/components/template/cover/template_cover.cpp

@@ -7,7 +7,13 @@ using namespace esphome::cover;
 
 static const char *const TAG = "template.cover";
 
-TemplateCover::TemplateCover() = default;
+TemplateCover::TemplateCover()
+    : open_trigger_(new Trigger<>()),
+      close_trigger_(new Trigger<>),
+      stop_trigger_(new Trigger<>()),
+      toggle_trigger_(new Trigger<>()),
+      position_trigger_(new Trigger<float>()),
+      tilt_trigger_(new Trigger<float>()) {}
 void TemplateCover::setup() {
   switch (this->restore_mode_) {
     case COVER_NO_RESTORE:
@@ -56,22 +62,22 @@ void TemplateCover::loop() {
 void TemplateCover::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 void TemplateCover::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 float TemplateCover::get_setup_priority() const { return setup_priority::HARDWARE; }
-Trigger<> *TemplateCover::get_open_trigger() { return &this->open_trigger_; }
-Trigger<> *TemplateCover::get_close_trigger() { return &this->close_trigger_; }
-Trigger<> *TemplateCover::get_stop_trigger() { return &this->stop_trigger_; }
-Trigger<> *TemplateCover::get_toggle_trigger() { return &this->toggle_trigger_; }
+Trigger<> *TemplateCover::get_open_trigger() const { return this->open_trigger_; }
+Trigger<> *TemplateCover::get_close_trigger() const { return this->close_trigger_; }
+Trigger<> *TemplateCover::get_stop_trigger() const { return this->stop_trigger_; }
+Trigger<> *TemplateCover::get_toggle_trigger() const { return this->toggle_trigger_; }
 void TemplateCover::dump_config() { LOG_COVER("", "Template Cover", this); }
 void TemplateCover::control(const CoverCall &call) {
   if (call.get_stop()) {
     this->stop_prev_trigger_();
-    this->stop_trigger_.trigger();
-    this->prev_command_trigger_ = &this->stop_trigger_;
+    this->stop_trigger_->trigger();
+    this->prev_command_trigger_ = this->stop_trigger_;
     this->publish_state();
   }
   if (call.get_toggle().has_value()) {
     this->stop_prev_trigger_();
-    this->toggle_trigger_.trigger();
-    this->prev_command_trigger_ = &this->toggle_trigger_;
+    this->toggle_trigger_->trigger();
+    this->prev_command_trigger_ = this->toggle_trigger_;
     this->publish_state();
   }
   if (call.get_position().has_value()) {
@@ -79,13 +85,13 @@ void TemplateCover::control(const CoverCall &call) {
     this->stop_prev_trigger_();
 
     if (pos == COVER_OPEN) {
-      this->open_trigger_.trigger();
-      this->prev_command_trigger_ = &this->open_trigger_;
+      this->open_trigger_->trigger();
+      this->prev_command_trigger_ = this->open_trigger_;
     } else if (pos == COVER_CLOSED) {
-      this->close_trigger_.trigger();
-      this->prev_command_trigger_ = &this->close_trigger_;
+      this->close_trigger_->trigger();
+      this->prev_command_trigger_ = this->close_trigger_;
     } else {
-      this->position_trigger_.trigger(pos);
+      this->position_trigger_->trigger(pos);
     }
 
     if (this->optimistic_) {
@@ -95,7 +101,7 @@ void TemplateCover::control(const CoverCall &call) {
 
   if (call.get_tilt().has_value()) {
     auto tilt = *call.get_tilt();
-    this->tilt_trigger_.trigger(tilt);
+    this->tilt_trigger_->trigger(tilt);
 
     if (this->optimistic_) {
       this->tilt = tilt;
@@ -113,8 +119,8 @@ CoverTraits TemplateCover::get_traits() {
   traits.set_supports_tilt(this->has_tilt_);
   return traits;
 }
-Trigger<float> *TemplateCover::get_position_trigger() { return &this->position_trigger_; }
-Trigger<float> *TemplateCover::get_tilt_trigger() { return &this->tilt_trigger_; }
+Trigger<float> *TemplateCover::get_position_trigger() const { return this->position_trigger_; }
+Trigger<float> *TemplateCover::get_tilt_trigger() const { return this->tilt_trigger_; }
 void TemplateCover::set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
 void TemplateCover::set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
 void TemplateCover::set_has_position(bool has_position) { this->has_position_ = has_position; }

esphome/components/template/cover/template_cover.h

@@ -19,12 +19,12 @@ class TemplateCover final : public cover::Cover, public Component {
 
   template<typename F> void set_state_lambda(F &&f) { this->state_f_.set(std::forward<F>(f)); }
   template<typename F> void set_tilt_lambda(F &&f) { this->tilt_f_.set(std::forward<F>(f)); }
-  Trigger<> *get_open_trigger();
-  Trigger<> *get_close_trigger();
-  Trigger<> *get_stop_trigger();
-  Trigger<> *get_toggle_trigger();
-  Trigger<float> *get_position_trigger();
-  Trigger<float> *get_tilt_trigger();
+  Trigger<> *get_open_trigger() const;
+  Trigger<> *get_close_trigger() const;
+  Trigger<> *get_stop_trigger() const;
+  Trigger<> *get_toggle_trigger() const;
+  Trigger<float> *get_position_trigger() const;
+  Trigger<float> *get_tilt_trigger() const;
   void set_optimistic(bool optimistic);
   void set_assumed_state(bool assumed_state);
   void set_has_stop(bool has_stop);
@@ -49,16 +49,16 @@ class TemplateCover final : public cover::Cover, public Component {
   TemplateLambda<float> tilt_f_;
   bool assumed_state_{false};
   bool optimistic_{false};
-  Trigger<> open_trigger_;
-  Trigger<> close_trigger_;
+  Trigger<> *open_trigger_;
+  Trigger<> *close_trigger_;
   bool has_stop_{false};
   bool has_toggle_{false};
-  Trigger<> stop_trigger_;
-  Trigger<> toggle_trigger_;
+  Trigger<> *stop_trigger_;
+  Trigger<> *toggle_trigger_;
   Trigger<> *prev_command_trigger_{nullptr};
-  Trigger<float> position_trigger_;
+  Trigger<float> *position_trigger_;
   bool has_position_{false};
-  Trigger<float> tilt_trigger_;
+  Trigger<float> *tilt_trigger_;
   bool has_tilt_{false};
 };
 

esphome/components/template/datetime/template_date.cpp

@@ -62,7 +62,7 @@ void TemplateDate::control(const datetime::DateCall &call) {
   if (has_day)
     value.day_of_month = *call.get_day();
 
-  this->set_trigger_.trigger(value);
+  this->set_trigger_->trigger(value);
 
   if (this->optimistic_) {
     if (has_year)

esphome/components/template/datetime/template_date.h

@@ -22,7 +22,7 @@ class TemplateDate final : public datetime::DateEntity, public PollingComponent
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<ESPTime> *get_set_trigger() { return &this->set_trigger_; }
+  Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 
   void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
@@ -34,7 +34,7 @@ class TemplateDate final : public datetime::DateEntity, public PollingComponent
   bool optimistic_{false};
   ESPTime initial_value_{};
   bool restore_value_{false};
-  Trigger<ESPTime> set_trigger_;
+  Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
   TemplateLambda<ESPTime> f_;
 
   ESPPreferenceObject pref_;

esphome/components/template/datetime/template_datetime.cpp

@@ -80,7 +80,7 @@ void TemplateDateTime::control(const datetime::DateTimeCall &call) {
   if (has_second)
     value.second = *call.get_second();
 
-  this->set_trigger_.trigger(value);
+  this->set_trigger_->trigger(value);
 
   if (this->optimistic_) {
     if (has_year)

esphome/components/template/datetime/template_datetime.h

@@ -22,7 +22,7 @@ class TemplateDateTime final : public datetime::DateTimeEntity, public PollingCo
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<ESPTime> *get_set_trigger() { return &this->set_trigger_; }
+  Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 
   void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
@@ -34,7 +34,7 @@ class TemplateDateTime final : public datetime::DateTimeEntity, public PollingCo
   bool optimistic_{false};
   ESPTime initial_value_{};
   bool restore_value_{false};
-  Trigger<ESPTime> set_trigger_;
+  Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
   TemplateLambda<ESPTime> f_;
 
   ESPPreferenceObject pref_;

esphome/components/template/datetime/template_time.cpp

@@ -62,7 +62,7 @@ void TemplateTime::control(const datetime::TimeCall &call) {
   if (has_second)
     value.second = *call.get_second();
 
-  this->set_trigger_.trigger(value);
+  this->set_trigger_->trigger(value);
 
   if (this->optimistic_) {
     if (has_hour)

esphome/components/template/datetime/template_time.h

@@ -22,7 +22,7 @@ class TemplateTime final : public datetime::TimeEntity, public PollingComponent
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<ESPTime> *get_set_trigger() { return &this->set_trigger_; }
+  Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 
   void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
@@ -34,7 +34,7 @@ class TemplateTime final : public datetime::TimeEntity, public PollingComponent
   bool optimistic_{false};
   ESPTime initial_value_{};
   bool restore_value_{false};
-  Trigger<ESPTime> set_trigger_;
+  Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
   TemplateLambda<ESPTime> f_;
 
   ESPPreferenceObject pref_;

esphome/components/template/lock/template_lock.cpp

@@ -7,7 +7,8 @@ using namespace esphome::lock;
 
 static const char *const TAG = "template.lock";
 
-TemplateLock::TemplateLock() = default;
+TemplateLock::TemplateLock()
+    : lock_trigger_(new Trigger<>()), unlock_trigger_(new Trigger<>()), open_trigger_(new Trigger<>()) {}
 
 void TemplateLock::setup() {
   if (!this->f_.has_value())
@@ -27,11 +28,11 @@ void TemplateLock::control(const lock::LockCall &call) {
 
   auto state = *call.get_state();
   if (state == LOCK_STATE_LOCKED) {
-    this->prev_trigger_ = &this->lock_trigger_;
-    this->lock_trigger_.trigger();
+    this->prev_trigger_ = this->lock_trigger_;
+    this->lock_trigger_->trigger();
   } else if (state == LOCK_STATE_UNLOCKED) {
-    this->prev_trigger_ = &this->unlock_trigger_;
-    this->unlock_trigger_.trigger();
+    this->prev_trigger_ = this->unlock_trigger_;
+    this->unlock_trigger_->trigger();
   }
 
   if (this->optimistic_)
@@ -41,11 +42,14 @@ void TemplateLock::open_latch() {
   if (this->prev_trigger_ != nullptr) {
     this->prev_trigger_->stop_action();
   }
-  this->prev_trigger_ = &this->open_trigger_;
-  this->open_trigger_.trigger();
+  this->prev_trigger_ = this->open_trigger_;
+  this->open_trigger_->trigger();
 }
 void TemplateLock::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 float TemplateLock::get_setup_priority() const { return setup_priority::HARDWARE; }
+Trigger<> *TemplateLock::get_lock_trigger() const { return this->lock_trigger_; }
+Trigger<> *TemplateLock::get_unlock_trigger() const { return this->unlock_trigger_; }
+Trigger<> *TemplateLock::get_open_trigger() const { return this->open_trigger_; }
 void TemplateLock::dump_config() {
   LOG_LOCK("", "Template Lock", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));

esphome/components/template/lock/template_lock.h

@@ -15,9 +15,9 @@ class TemplateLock final : public lock::Lock, public Component {
   void dump_config() override;
 
   template<typename F> void set_state_lambda(F &&f) { this->f_.set(std::forward<F>(f)); }
-  Trigger<> *get_lock_trigger() { return &this->lock_trigger_; }
-  Trigger<> *get_unlock_trigger() { return &this->unlock_trigger_; }
-  Trigger<> *get_open_trigger() { return &this->open_trigger_; }
+  Trigger<> *get_lock_trigger() const;
+  Trigger<> *get_unlock_trigger() const;
+  Trigger<> *get_open_trigger() const;
   void set_optimistic(bool optimistic);
   void loop() override;
 
@@ -29,9 +29,9 @@ class TemplateLock final : public lock::Lock, public Component {
 
   TemplateLambda<lock::LockState> f_;
   bool optimistic_{false};
-  Trigger<> lock_trigger_;
-  Trigger<> unlock_trigger_;
-  Trigger<> open_trigger_;
+  Trigger<> *lock_trigger_;
+  Trigger<> *unlock_trigger_;
+  Trigger<> *open_trigger_;
   Trigger<> *prev_trigger_{nullptr};
 };
 

esphome/components/template/number/template_number.cpp

@@ -36,7 +36,7 @@ void TemplateNumber::update() {
 }
 
 void TemplateNumber::control(float value) {
-  this->set_trigger_.trigger(value);
+  this->set_trigger_->trigger(value);
 
   if (this->optimistic_)
     this->publish_state(value);

esphome/components/template/number/template_number.h

@@ -17,7 +17,7 @@ class TemplateNumber final : public number::Number, public PollingComponent {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<float> *get_set_trigger() { return &this->set_trigger_; }
+  Trigger<float> *get_set_trigger() const { return set_trigger_; }
   void set_optimistic(bool optimistic) { optimistic_ = optimistic; }
   void set_initial_value(float initial_value) { initial_value_ = initial_value; }
   void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
@@ -27,7 +27,7 @@ class TemplateNumber final : public number::Number, public PollingComponent {
   bool optimistic_{false};
   float initial_value_{NAN};
   bool restore_value_{false};
-  Trigger<float> set_trigger_;
+  Trigger<float> *set_trigger_ = new Trigger<float>();
   TemplateLambda<float> f_;
 
   ESPPreferenceObject pref_;

esphome/components/template/output/template_output.h

@@ -8,22 +8,22 @@ namespace esphome::template_ {
 
 class TemplateBinaryOutput final : public output::BinaryOutput {
  public:
-  Trigger<bool> *get_trigger() { return &this->trigger_; }
+  Trigger<bool> *get_trigger() const { return trigger_; }
 
  protected:
-  void write_state(bool state) override { this->trigger_.trigger(state); }
+  void write_state(bool state) override { this->trigger_->trigger(state); }
 
-  Trigger<bool> trigger_;
+  Trigger<bool> *trigger_ = new Trigger<bool>();
 };
 
 class TemplateFloatOutput final : public output::FloatOutput {
  public:
-  Trigger<float> *get_trigger() { return &this->trigger_; }
+  Trigger<float> *get_trigger() const { return trigger_; }
 
  protected:
-  void write_state(float state) override { this->trigger_.trigger(state); }
+  void write_state(float state) override { this->trigger_->trigger(state); }
 
-  Trigger<float> trigger_;
+  Trigger<float> *trigger_ = new Trigger<float>();
 };
 
 }  // namespace esphome::template_

esphome/components/template/switch/template_switch.cpp

@@ -5,7 +5,7 @@ namespace esphome::template_ {
 
 static const char *const TAG = "template.switch";
 
-TemplateSwitch::TemplateSwitch() = default;
+TemplateSwitch::TemplateSwitch() : turn_on_trigger_(new Trigger<>()), turn_off_trigger_(new Trigger<>()) {}
 
 void TemplateSwitch::loop() {
   auto s = this->f_();
@@ -19,11 +19,11 @@ void TemplateSwitch::write_state(bool state) {
   }
 
   if (state) {
-    this->prev_trigger_ = &this->turn_on_trigger_;
-    this->turn_on_trigger_.trigger();
+    this->prev_trigger_ = this->turn_on_trigger_;
+    this->turn_on_trigger_->trigger();
   } else {
-    this->prev_trigger_ = &this->turn_off_trigger_;
-    this->turn_off_trigger_.trigger();
+    this->prev_trigger_ = this->turn_off_trigger_;
+    this->turn_off_trigger_->trigger();
   }
 
   if (this->optimistic_)
@@ -32,8 +32,8 @@ void TemplateSwitch::write_state(bool state) {
 void TemplateSwitch::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 bool TemplateSwitch::assumed_state() { return this->assumed_state_; }
 float TemplateSwitch::get_setup_priority() const { return setup_priority::HARDWARE - 2.0f; }
-Trigger<> *TemplateSwitch::get_turn_on_trigger() { return &this->turn_on_trigger_; }
-Trigger<> *TemplateSwitch::get_turn_off_trigger() { return &this->turn_off_trigger_; }
+Trigger<> *TemplateSwitch::get_turn_on_trigger() const { return this->turn_on_trigger_; }
+Trigger<> *TemplateSwitch::get_turn_off_trigger() const { return this->turn_off_trigger_; }
 void TemplateSwitch::setup() {
   if (!this->f_.has_value())
     this->disable_loop();

esphome/components/template/switch/template_switch.h

@@ -15,8 +15,8 @@ class TemplateSwitch final : public switch_::Switch, public Component {
   void dump_config() override;
 
   template<typename F> void set_state_lambda(F &&f) { this->f_.set(std::forward<F>(f)); }
-  Trigger<> *get_turn_on_trigger();
-  Trigger<> *get_turn_off_trigger();
+  Trigger<> *get_turn_on_trigger() const;
+  Trigger<> *get_turn_off_trigger() const;
   void set_optimistic(bool optimistic);
   void set_assumed_state(bool assumed_state);
   void loop() override;
@@ -31,9 +31,9 @@ class TemplateSwitch final : public switch_::Switch, public Component {
   TemplateLambda<bool> f_;
   bool optimistic_{false};
   bool assumed_state_{false};
-  Trigger<> turn_on_trigger_;
-  Trigger<> turn_off_trigger_;
-  Trigger<> *prev_trigger_{nullptr};  // Points to one of the above
+  Trigger<> *turn_on_trigger_;
+  Trigger<> *turn_off_trigger_;
+  Trigger<> *prev_trigger_{nullptr};
 };
 
 }  // namespace esphome::template_

esphome/components/template/text/template_text.cpp

@@ -47,7 +47,7 @@ void TemplateText::update() {
 }
 
 void TemplateText::control(const std::string &value) {
-  this->set_trigger_.trigger(value);
+  this->set_trigger_->trigger(value);
 
   if (this->optimistic_)
     this->publish_state(value);

esphome/components/template/text/template_text.h

@@ -68,7 +68,7 @@ class TemplateText final : public text::Text, public PollingComponent {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<std::string> *get_set_trigger() { return &this->set_trigger_; }
+  Trigger<std::string> *get_set_trigger() const { return this->set_trigger_; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
   void set_initial_value(const char *initial_value) { this->initial_value_ = initial_value; }
   /// Prevent accidental use of std::string which would dangle
@@ -79,7 +79,7 @@ class TemplateText final : public text::Text, public PollingComponent {
   void control(const std::string &value) override;
   bool optimistic_ = false;
   const char *initial_value_{nullptr};
-  Trigger<std::string> set_trigger_;
+  Trigger<std::string> *set_trigger_ = new Trigger<std::string>();
   TemplateLambda<std::string> f_{};
 
   TemplateTextSaverBase *pref_ = nullptr;

esphome/components/template/valve/template_valve.cpp

@@ -7,7 +7,12 @@ using namespace esphome::valve;
 
 static const char *const TAG = "template.valve";
 
-TemplateValve::TemplateValve() = default;
+TemplateValve::TemplateValve()
+    : open_trigger_(new Trigger<>()),
+      close_trigger_(new Trigger<>),
+      stop_trigger_(new Trigger<>()),
+      toggle_trigger_(new Trigger<>()),
+      position_trigger_(new Trigger<float>()) {}
 
 void TemplateValve::setup() {
   switch (this->restore_mode_) {
@@ -51,10 +56,10 @@ void TemplateValve::set_optimistic(bool optimistic) { this->optimistic_ = optimi
 void TemplateValve::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 float TemplateValve::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-Trigger<> *TemplateValve::get_open_trigger() { return &this->open_trigger_; }
-Trigger<> *TemplateValve::get_close_trigger() { return &this->close_trigger_; }
-Trigger<> *TemplateValve::get_stop_trigger() { return &this->stop_trigger_; }
-Trigger<> *TemplateValve::get_toggle_trigger() { return &this->toggle_trigger_; }
+Trigger<> *TemplateValve::get_open_trigger() const { return this->open_trigger_; }
+Trigger<> *TemplateValve::get_close_trigger() const { return this->close_trigger_; }
+Trigger<> *TemplateValve::get_stop_trigger() const { return this->stop_trigger_; }
+Trigger<> *TemplateValve::get_toggle_trigger() const { return this->toggle_trigger_; }
 
 void TemplateValve::dump_config() {
   LOG_VALVE("", "Template Valve", this);
@@ -67,14 +72,14 @@ void TemplateValve::dump_config() {
 void TemplateValve::control(const ValveCall &call) {
   if (call.get_stop()) {
     this->stop_prev_trigger_();
-    this->stop_trigger_.trigger();
-    this->prev_command_trigger_ = &this->stop_trigger_;
+    this->stop_trigger_->trigger();
+    this->prev_command_trigger_ = this->stop_trigger_;
     this->publish_state();
   }
   if (call.get_toggle().has_value()) {
     this->stop_prev_trigger_();
-    this->toggle_trigger_.trigger();
-    this->prev_command_trigger_ = &this->toggle_trigger_;
+    this->toggle_trigger_->trigger();
+    this->prev_command_trigger_ = this->toggle_trigger_;
     this->publish_state();
   }
   if (call.get_position().has_value()) {
@@ -82,13 +87,13 @@ void TemplateValve::control(const ValveCall &call) {
     this->stop_prev_trigger_();
 
     if (pos == VALVE_OPEN) {
-      this->open_trigger_.trigger();
-      this->prev_command_trigger_ = &this->open_trigger_;
+      this->open_trigger_->trigger();
+      this->prev_command_trigger_ = this->open_trigger_;
     } else if (pos == VALVE_CLOSED) {
-      this->close_trigger_.trigger();
-      this->prev_command_trigger_ = &this->close_trigger_;
+      this->close_trigger_->trigger();
+      this->prev_command_trigger_ = this->close_trigger_;
     } else {
-      this->position_trigger_.trigger(pos);
+      this->position_trigger_->trigger(pos);
     }
 
     if (this->optimistic_) {
@@ -108,7 +113,7 @@ ValveTraits TemplateValve::get_traits() {
   return traits;
 }
 
-Trigger<float> *TemplateValve::get_position_trigger() { return &this->position_trigger_; }
+Trigger<float> *TemplateValve::get_position_trigger() const { return this->position_trigger_; }
 
 void TemplateValve::set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
 void TemplateValve::set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }

esphome/components/template/valve/template_valve.h

@@ -18,11 +18,11 @@ class TemplateValve final : public valve::Valve, public Component {
   TemplateValve();
 
   template<typename F> void set_state_lambda(F &&f) { this->state_f_.set(std::forward<F>(f)); }
-  Trigger<> *get_open_trigger();
-  Trigger<> *get_close_trigger();
-  Trigger<> *get_stop_trigger();
-  Trigger<> *get_toggle_trigger();
-  Trigger<float> *get_position_trigger();
+  Trigger<> *get_open_trigger() const;
+  Trigger<> *get_close_trigger() const;
+  Trigger<> *get_stop_trigger() const;
+  Trigger<> *get_toggle_trigger() const;
+  Trigger<float> *get_position_trigger() const;
   void set_optimistic(bool optimistic);
   void set_assumed_state(bool assumed_state);
   void set_has_stop(bool has_stop);
@@ -45,14 +45,14 @@ class TemplateValve final : public valve::Valve, public Component {
   TemplateLambda<float> state_f_;
   bool assumed_state_{false};
   bool optimistic_{false};
-  Trigger<> open_trigger_;
-  Trigger<> close_trigger_;
+  Trigger<> *open_trigger_;
+  Trigger<> *close_trigger_;
   bool has_stop_{false};
   bool has_toggle_{false};
-  Trigger<> stop_trigger_;
-  Trigger<> toggle_trigger_;
+  Trigger<> *stop_trigger_;
+  Trigger<> *toggle_trigger_;
   Trigger<> *prev_command_trigger_{nullptr};
-  Trigger<float> position_trigger_;
+  Trigger<float> *position_trigger_;
   bool has_position_{false};
 };
 

esphome/components/template/water_heater/template_water_heater.cpp

@@ -5,7 +5,7 @@ namespace esphome::template_ {
 
 static const char *const TAG = "template.water_heater";
 
-TemplateWaterHeater::TemplateWaterHeater() = default;
+TemplateWaterHeater::TemplateWaterHeater() : set_trigger_(new Trigger<>()) {}
 
 void TemplateWaterHeater::setup() {
   if (this->restore_mode_ == TemplateWaterHeaterRestoreMode::WATER_HEATER_RESTORE ||
@@ -78,7 +78,7 @@ void TemplateWaterHeater::control(const water_heater::WaterHeaterCall &call) {
     }
   }
 
-  this->set_trigger_.trigger();
+  this->set_trigger_->trigger();
 
   if (this->optimistic_) {
     this->publish_state();

esphome/components/template/water_heater/template_water_heater.h

@@ -28,7 +28,7 @@ class TemplateWaterHeater : public Component, public water_heater::WaterHeater {
     this->supported_modes_ = modes;
   }
 
-  Trigger<> *get_set_trigger() { return &this->set_trigger_; }
+  Trigger<> *get_set_trigger() const { return this->set_trigger_; }
 
   void setup() override;
   void loop() override;
@@ -42,7 +42,7 @@ class TemplateWaterHeater : public Component, public water_heater::WaterHeater {
   water_heater::WaterHeaterTraits traits() override;
 
   // Ordered to minimize padding on 32-bit: 4-byte members first, then smaller
-  Trigger<> set_trigger_;
+  Trigger<> *set_trigger_;
   TemplateLambda<float> current_temperature_f_;
   TemplateLambda<water_heater::WaterHeaterMode> mode_f_;
   TemplateWaterHeaterRestoreMode restore_mode_{WATER_HEATER_NO_RESTORE};

esphome/components/thermostat/thermostat_climate.cpp

@@ -499,7 +499,7 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
   }
 
   bool action_ready = false;
-  Trigger<> *trig = &this->idle_action_trigger_, *trig_fan = nullptr;
+  Trigger<> *trig = this->idle_action_trigger_, *trig_fan = nullptr;
   switch (action) {
     case climate::CLIMATE_ACTION_OFF:
     case climate::CLIMATE_ACTION_IDLE:
@@ -529,10 +529,10 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
         this->start_timer_(thermostat::THERMOSTAT_TIMER_COOLING_MAX_RUN_TIME);
         if (this->supports_fan_with_cooling_) {
           this->start_timer_(thermostat::THERMOSTAT_TIMER_FANNING_ON);
-          trig_fan = &this->fan_only_action_trigger_;
+          trig_fan = this->fan_only_action_trigger_;
         }
         this->cooling_max_runtime_exceeded_ = false;
-        trig = &this->cool_action_trigger_;
+        trig = this->cool_action_trigger_;
         ESP_LOGVV(TAG, "Switching to COOLING action");
         action_ready = true;
       }
@@ -543,10 +543,10 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
         this->start_timer_(thermostat::THERMOSTAT_TIMER_HEATING_MAX_RUN_TIME);
         if (this->supports_fan_with_heating_) {
           this->start_timer_(thermostat::THERMOSTAT_TIMER_FANNING_ON);
-          trig_fan = &this->fan_only_action_trigger_;
+          trig_fan = this->fan_only_action_trigger_;
         }
         this->heating_max_runtime_exceeded_ = false;
-        trig = &this->heat_action_trigger_;
+        trig = this->heat_action_trigger_;
         ESP_LOGVV(TAG, "Switching to HEATING action");
         action_ready = true;
       }
@@ -558,7 +558,7 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
         } else {
           this->start_timer_(thermostat::THERMOSTAT_TIMER_FANNING_ON);
         }
-        trig = &this->fan_only_action_trigger_;
+        trig = this->fan_only_action_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_ONLY action");
         action_ready = true;
       }
@@ -567,7 +567,7 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
       if (this->drying_action_ready_()) {
         this->start_timer_(thermostat::THERMOSTAT_TIMER_COOLING_ON);
         this->start_timer_(thermostat::THERMOSTAT_TIMER_FANNING_ON);
-        trig = &this->dry_action_trigger_;
+        trig = this->dry_action_trigger_;
         ESP_LOGVV(TAG, "Switching to DRYING action");
         action_ready = true;
       }
@@ -586,7 +586,9 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
     }
     this->action = action;
     this->prev_action_trigger_ = trig;
-    trig->trigger();
+    if (trig != nullptr) {
+      trig->trigger();
+    }
     // if enabled, call the fan_only action with cooling/heating actions
     if (trig_fan != nullptr) {
       ESP_LOGVV(TAG, "Calling FAN_ONLY action with HEATING/COOLING action");
@@ -632,14 +634,14 @@ void ThermostatClimate::trigger_supplemental_action_() {
       if (!this->timer_active_(thermostat::THERMOSTAT_TIMER_COOLING_MAX_RUN_TIME)) {
         this->start_timer_(thermostat::THERMOSTAT_TIMER_COOLING_MAX_RUN_TIME);
       }
-      trig = &this->supplemental_cool_action_trigger_;
+      trig = this->supplemental_cool_action_trigger_;
       ESP_LOGVV(TAG, "Calling supplemental COOLING action");
       break;
     case climate::CLIMATE_ACTION_HEATING:
       if (!this->timer_active_(thermostat::THERMOSTAT_TIMER_HEATING_MAX_RUN_TIME)) {
         this->start_timer_(thermostat::THERMOSTAT_TIMER_HEATING_MAX_RUN_TIME);
       }
-      trig = &this->supplemental_heat_action_trigger_;
+      trig = this->supplemental_heat_action_trigger_;
       ESP_LOGVV(TAG, "Calling supplemental HEATING action");
       break;
     default:
@@ -658,24 +660,24 @@ void ThermostatClimate::switch_to_humidity_control_action_(HumidificationAction
     return;
   }
 
-  Trigger<> *trig = &this->humidity_control_off_action_trigger_;
+  Trigger<> *trig = this->humidity_control_off_action_trigger_;
   switch (action) {
     case THERMOSTAT_HUMIDITY_CONTROL_ACTION_OFF:
-      // trig = &this->humidity_control_off_action_trigger_;
+      // trig = this->humidity_control_off_action_trigger_;
       ESP_LOGVV(TAG, "Switching to HUMIDIFICATION_OFF action");
       break;
     case THERMOSTAT_HUMIDITY_CONTROL_ACTION_DEHUMIDIFY:
-      trig = &this->humidity_control_dehumidify_action_trigger_;
+      trig = this->humidity_control_dehumidify_action_trigger_;
       ESP_LOGVV(TAG, "Switching to DEHUMIDIFY action");
       break;
     case THERMOSTAT_HUMIDITY_CONTROL_ACTION_HUMIDIFY:
-      trig = &this->humidity_control_humidify_action_trigger_;
+      trig = this->humidity_control_humidify_action_trigger_;
       ESP_LOGVV(TAG, "Switching to HUMIDIFY action");
       break;
     case THERMOSTAT_HUMIDITY_CONTROL_ACTION_NONE:
     default:
       action = THERMOSTAT_HUMIDITY_CONTROL_ACTION_OFF;
-      // trig = &this->humidity_control_off_action_trigger_;
+      // trig = this->humidity_control_off_action_trigger_;
   }
 
   if (this->prev_humidity_control_trigger_ != nullptr) {
@@ -684,7 +686,9 @@ void ThermostatClimate::switch_to_humidity_control_action_(HumidificationAction
   }
   this->humidification_action = action;
   this->prev_humidity_control_trigger_ = trig;
-  trig->trigger();
+  if (trig != nullptr) {
+    trig->trigger();
+  }
 }
 
 void ThermostatClimate::switch_to_fan_mode_(climate::ClimateFanMode fan_mode, bool publish_state) {
@@ -699,60 +703,62 @@ void ThermostatClimate::switch_to_fan_mode_(climate::ClimateFanMode fan_mode, bo
     this->publish_state();
 
   if (this->fan_mode_ready_()) {
-    Trigger<> *trig = &this->fan_mode_auto_trigger_;
+    Trigger<> *trig = this->fan_mode_auto_trigger_;
     switch (fan_mode) {
       case climate::CLIMATE_FAN_ON:
-        trig = &this->fan_mode_on_trigger_;
+        trig = this->fan_mode_on_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_ON mode");
         break;
       case climate::CLIMATE_FAN_OFF:
-        trig = &this->fan_mode_off_trigger_;
+        trig = this->fan_mode_off_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_OFF mode");
         break;
       case climate::CLIMATE_FAN_AUTO:
-        // trig = &this->fan_mode_auto_trigger_;
+        // trig = this->fan_mode_auto_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_AUTO mode");
         break;
       case climate::CLIMATE_FAN_LOW:
-        trig = &this->fan_mode_low_trigger_;
+        trig = this->fan_mode_low_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_LOW mode");
         break;
       case climate::CLIMATE_FAN_MEDIUM:
-        trig = &this->fan_mode_medium_trigger_;
+        trig = this->fan_mode_medium_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_MEDIUM mode");
         break;
       case climate::CLIMATE_FAN_HIGH:
-        trig = &this->fan_mode_high_trigger_;
+        trig = this->fan_mode_high_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_HIGH mode");
         break;
       case climate::CLIMATE_FAN_MIDDLE:
-        trig = &this->fan_mode_middle_trigger_;
+        trig = this->fan_mode_middle_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_MIDDLE mode");
         break;
       case climate::CLIMATE_FAN_FOCUS:
-        trig = &this->fan_mode_focus_trigger_;
+        trig = this->fan_mode_focus_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_FOCUS mode");
         break;
       case climate::CLIMATE_FAN_DIFFUSE:
-        trig = &this->fan_mode_diffuse_trigger_;
+        trig = this->fan_mode_diffuse_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_DIFFUSE mode");
         break;
       case climate::CLIMATE_FAN_QUIET:
-        trig = &this->fan_mode_quiet_trigger_;
+        trig = this->fan_mode_quiet_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_QUIET mode");
         break;
       default:
         // we cannot report an invalid mode back to HA (even if it asked for one)
         //  and must assume some valid value
         fan_mode = climate::CLIMATE_FAN_AUTO;
-        // trig = &this->fan_mode_auto_trigger_;
+        // trig = this->fan_mode_auto_trigger_;
     }
     if (this->prev_fan_mode_trigger_ != nullptr) {
       this->prev_fan_mode_trigger_->stop_action();
       this->prev_fan_mode_trigger_ = nullptr;
     }
     this->start_timer_(thermostat::THERMOSTAT_TIMER_FAN_MODE);
-    trig->trigger();
+    if (trig != nullptr) {
+      trig->trigger();
+    }
     this->prev_fan_mode_ = fan_mode;
     this->prev_fan_mode_trigger_ = trig;
   }
@@ -769,25 +775,25 @@ void ThermostatClimate::switch_to_mode_(climate::ClimateMode mode, bool publish_
     this->prev_mode_trigger_->stop_action();
     this->prev_mode_trigger_ = nullptr;
   }
-  Trigger<> *trig = &this->off_mode_trigger_;
+  Trigger<> *trig = this->off_mode_trigger_;
   switch (mode) {
     case climate::CLIMATE_MODE_AUTO:
-      trig = &this->auto_mode_trigger_;
+      trig = this->auto_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_HEAT_COOL:
-      trig = &this->heat_cool_mode_trigger_;
+      trig = this->heat_cool_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_COOL:
-      trig = &this->cool_mode_trigger_;
+      trig = this->cool_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_HEAT:
-      trig = &this->heat_mode_trigger_;
+      trig = this->heat_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_FAN_ONLY:
-      trig = &this->fan_only_mode_trigger_;
+      trig = this->fan_only_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_DRY:
-      trig = &this->dry_mode_trigger_;
+      trig = this->dry_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_OFF:
     default:
@@ -796,7 +802,9 @@ void ThermostatClimate::switch_to_mode_(climate::ClimateMode mode, bool publish_
       mode = climate::CLIMATE_MODE_OFF;
       // trig = this->off_mode_trigger_;
   }
-  trig->trigger();
+  if (trig != nullptr) {
+    trig->trigger();
+  }
   this->mode = mode;
   this->prev_mode_ = mode;
   this->prev_mode_trigger_ = trig;
@@ -816,27 +824,29 @@ void ThermostatClimate::switch_to_swing_mode_(climate::ClimateSwingMode swing_mo
     this->prev_swing_mode_trigger_->stop_action();
     this->prev_swing_mode_trigger_ = nullptr;
   }
-  Trigger<> *trig = &this->swing_mode_off_trigger_;
+  Trigger<> *trig = this->swing_mode_off_trigger_;
   switch (swing_mode) {
     case climate::CLIMATE_SWING_BOTH:
-      trig = &this->swing_mode_both_trigger_;
+      trig = this->swing_mode_both_trigger_;
       break;
     case climate::CLIMATE_SWING_HORIZONTAL:
-      trig = &this->swing_mode_horizontal_trigger_;
+      trig = this->swing_mode_horizontal_trigger_;
       break;
     case climate::CLIMATE_SWING_OFF:
-      // trig = &this->swing_mode_off_trigger_;
+      // trig = this->swing_mode_off_trigger_;
       break;
     case climate::CLIMATE_SWING_VERTICAL:
-      trig = &this->swing_mode_vertical_trigger_;
+      trig = this->swing_mode_vertical_trigger_;
       break;
     default:
       // we cannot report an invalid mode back to HA (even if it asked for one)
       //  and must assume some valid value
       swing_mode = climate::CLIMATE_SWING_OFF;
-      // trig = &this->swing_mode_off_trigger_;
+      // trig = this->swing_mode_off_trigger_;
+  }
+  if (trig != nullptr) {
+    trig->trigger();
   }
-  trig->trigger();
   this->swing_mode = swing_mode;
   this->prev_swing_mode_ = swing_mode;
   this->prev_swing_mode_trigger_ = trig;
@@ -1014,8 +1024,10 @@ void ThermostatClimate::check_humidity_change_trigger_() {
     this->prev_target_humidity_ = this->target_humidity;
   }
   // trigger the action
-  Trigger<> *trig = &this->humidity_change_trigger_;
-  trig->trigger();
+  Trigger<> *trig = this->humidity_change_trigger_;
+  if (trig != nullptr) {
+    trig->trigger();
+  }
 }
 
 void ThermostatClimate::check_temperature_change_trigger_() {
@@ -1038,8 +1050,10 @@ void ThermostatClimate::check_temperature_change_trigger_() {
     }
   }
   // trigger the action
-  Trigger<> *trig = &this->temperature_change_trigger_;
-  trig->trigger();
+  Trigger<> *trig = this->temperature_change_trigger_;
+  if (trig != nullptr) {
+    trig->trigger();
+  }
 }
 
 bool ThermostatClimate::cooling_required_() {
@@ -1188,10 +1202,12 @@ void ThermostatClimate::change_preset_(climate::ClimatePreset preset) {
   if (config != nullptr) {
     ESP_LOGV(TAG, "Preset %s requested", LOG_STR_ARG(climate::climate_preset_to_string(preset)));
     if (this->change_preset_internal_(*config) || (!this->preset.has_value()) || this->preset.value() != preset) {
-      // Fire preset changed trigger
-      Trigger<> *trig = &this->preset_change_trigger_;
+      // Fire any preset changed trigger if defined
+      Trigger<> *trig = this->preset_change_trigger_;
       this->set_preset_(preset);
-      trig->trigger();
+      if (trig != nullptr) {
+        trig->trigger();
+      }
 
       this->refresh();
       ESP_LOGI(TAG, "Preset %s applied", LOG_STR_ARG(climate::climate_preset_to_string(preset)));
@@ -1218,11 +1234,13 @@ void ThermostatClimate::change_custom_preset_(const char *custom_preset, size_t
     ESP_LOGV(TAG, "Custom preset %s requested", custom_preset);
     if (this->change_preset_internal_(*config) || !this->has_custom_preset() ||
         this->get_custom_preset() != custom_preset) {
-      // Fire preset changed trigger
-      Trigger<> *trig = &this->preset_change_trigger_;
+      // Fire any preset changed trigger if defined
+      Trigger<> *trig = this->preset_change_trigger_;
       // Use the base class method which handles pointer lookup and preset reset internally
       this->set_custom_preset_(custom_preset);
-      trig->trigger();
+      if (trig != nullptr) {
+        trig->trigger();
+      }
 
       this->refresh();
       ESP_LOGI(TAG, "Custom preset %s applied", custom_preset);
@@ -1287,7 +1305,41 @@ void ThermostatClimate::set_custom_preset_config(std::initializer_list<CustomPre
   this->custom_preset_config_ = presets;
 }
 
-ThermostatClimate::ThermostatClimate() = default;
+ThermostatClimate::ThermostatClimate()
+    : cool_action_trigger_(new Trigger<>()),
+      supplemental_cool_action_trigger_(new Trigger<>()),
+      cool_mode_trigger_(new Trigger<>()),
+      dry_action_trigger_(new Trigger<>()),
+      dry_mode_trigger_(new Trigger<>()),
+      heat_action_trigger_(new Trigger<>()),
+      supplemental_heat_action_trigger_(new Trigger<>()),
+      heat_mode_trigger_(new Trigger<>()),
+      heat_cool_mode_trigger_(new Trigger<>()),
+      auto_mode_trigger_(new Trigger<>()),
+      idle_action_trigger_(new Trigger<>()),
+      off_mode_trigger_(new Trigger<>()),
+      fan_only_action_trigger_(new Trigger<>()),
+      fan_only_mode_trigger_(new Trigger<>()),
+      fan_mode_on_trigger_(new Trigger<>()),
+      fan_mode_off_trigger_(new Trigger<>()),
+      fan_mode_auto_trigger_(new Trigger<>()),
+      fan_mode_low_trigger_(new Trigger<>()),
+      fan_mode_medium_trigger_(new Trigger<>()),
+      fan_mode_high_trigger_(new Trigger<>()),
+      fan_mode_middle_trigger_(new Trigger<>()),
+      fan_mode_focus_trigger_(new Trigger<>()),
+      fan_mode_diffuse_trigger_(new Trigger<>()),
+      fan_mode_quiet_trigger_(new Trigger<>()),
+      swing_mode_both_trigger_(new Trigger<>()),
+      swing_mode_off_trigger_(new Trigger<>()),
+      swing_mode_horizontal_trigger_(new Trigger<>()),
+      swing_mode_vertical_trigger_(new Trigger<>()),
+      humidity_change_trigger_(new Trigger<>()),
+      temperature_change_trigger_(new Trigger<>()),
+      preset_change_trigger_(new Trigger<>()),
+      humidity_control_dehumidify_action_trigger_(new Trigger<>()),
+      humidity_control_humidify_action_trigger_(new Trigger<>()),
+      humidity_control_off_action_trigger_(new Trigger<>()) {}
 
 void ThermostatClimate::set_default_preset(const char *custom_preset) {
   // Find the preset in custom_preset_config_ and store pointer from there
@@ -1461,49 +1513,49 @@ void ThermostatClimate::set_supports_humidification(bool supports_humidification
   }
 }
 
-Trigger<> *ThermostatClimate::get_cool_action_trigger() { return &this->cool_action_trigger_; }
-Trigger<> *ThermostatClimate::get_supplemental_cool_action_trigger() {
-  return &this->supplemental_cool_action_trigger_;
+Trigger<> *ThermostatClimate::get_cool_action_trigger() const { return this->cool_action_trigger_; }
+Trigger<> *ThermostatClimate::get_supplemental_cool_action_trigger() const {
+  return this->supplemental_cool_action_trigger_;
 }
-Trigger<> *ThermostatClimate::get_dry_action_trigger() { return &this->dry_action_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_only_action_trigger() { return &this->fan_only_action_trigger_; }
-Trigger<> *ThermostatClimate::get_heat_action_trigger() { return &this->heat_action_trigger_; }
-Trigger<> *ThermostatClimate::get_supplemental_heat_action_trigger() {
-  return &this->supplemental_heat_action_trigger_;
+Trigger<> *ThermostatClimate::get_dry_action_trigger() const { return this->dry_action_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_only_action_trigger() const { return this->fan_only_action_trigger_; }
+Trigger<> *ThermostatClimate::get_heat_action_trigger() const { return this->heat_action_trigger_; }
+Trigger<> *ThermostatClimate::get_supplemental_heat_action_trigger() const {
+  return this->supplemental_heat_action_trigger_;
 }
-Trigger<> *ThermostatClimate::get_idle_action_trigger() { return &this->idle_action_trigger_; }
-Trigger<> *ThermostatClimate::get_auto_mode_trigger() { return &this->auto_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_cool_mode_trigger() { return &this->cool_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_dry_mode_trigger() { return &this->dry_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_only_mode_trigger() { return &this->fan_only_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_heat_mode_trigger() { return &this->heat_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_heat_cool_mode_trigger() { return &this->heat_cool_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_off_mode_trigger() { return &this->off_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_on_trigger() { return &this->fan_mode_on_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_off_trigger() { return &this->fan_mode_off_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_auto_trigger() { return &this->fan_mode_auto_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_low_trigger() { return &this->fan_mode_low_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_medium_trigger() { return &this->fan_mode_medium_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_high_trigger() { return &this->fan_mode_high_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_middle_trigger() { return &this->fan_mode_middle_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_focus_trigger() { return &this->fan_mode_focus_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_diffuse_trigger() { return &this->fan_mode_diffuse_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_quiet_trigger() { return &this->fan_mode_quiet_trigger_; }
-Trigger<> *ThermostatClimate::get_swing_mode_both_trigger() { return &this->swing_mode_both_trigger_; }
-Trigger<> *ThermostatClimate::get_swing_mode_off_trigger() { return &this->swing_mode_off_trigger_; }
-Trigger<> *ThermostatClimate::get_swing_mode_horizontal_trigger() { return &this->swing_mode_horizontal_trigger_; }
-Trigger<> *ThermostatClimate::get_swing_mode_vertical_trigger() { return &this->swing_mode_vertical_trigger_; }
-Trigger<> *ThermostatClimate::get_humidity_change_trigger() { return &this->humidity_change_trigger_; }
-Trigger<> *ThermostatClimate::get_temperature_change_trigger() { return &this->temperature_change_trigger_; }
-Trigger<> *ThermostatClimate::get_preset_change_trigger() { return &this->preset_change_trigger_; }
-Trigger<> *ThermostatClimate::get_humidity_control_dehumidify_action_trigger() {
-  return &this->humidity_control_dehumidify_action_trigger_;
+Trigger<> *ThermostatClimate::get_idle_action_trigger() const { return this->idle_action_trigger_; }
+Trigger<> *ThermostatClimate::get_auto_mode_trigger() const { return this->auto_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_cool_mode_trigger() const { return this->cool_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_dry_mode_trigger() const { return this->dry_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_only_mode_trigger() const { return this->fan_only_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_heat_mode_trigger() const { return this->heat_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_heat_cool_mode_trigger() const { return this->heat_cool_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_off_mode_trigger() const { return this->off_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_on_trigger() const { return this->fan_mode_on_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_off_trigger() const { return this->fan_mode_off_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_auto_trigger() const { return this->fan_mode_auto_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_low_trigger() const { return this->fan_mode_low_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_medium_trigger() const { return this->fan_mode_medium_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_high_trigger() const { return this->fan_mode_high_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_middle_trigger() const { return this->fan_mode_middle_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_focus_trigger() const { return this->fan_mode_focus_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_diffuse_trigger() const { return this->fan_mode_diffuse_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_quiet_trigger() const { return this->fan_mode_quiet_trigger_; }
+Trigger<> *ThermostatClimate::get_swing_mode_both_trigger() const { return this->swing_mode_both_trigger_; }
+Trigger<> *ThermostatClimate::get_swing_mode_off_trigger() const { return this->swing_mode_off_trigger_; }
+Trigger<> *ThermostatClimate::get_swing_mode_horizontal_trigger() const { return this->swing_mode_horizontal_trigger_; }
+Trigger<> *ThermostatClimate::get_swing_mode_vertical_trigger() const { return this->swing_mode_vertical_trigger_; }
+Trigger<> *ThermostatClimate::get_humidity_change_trigger() const { return this->humidity_change_trigger_; }
+Trigger<> *ThermostatClimate::get_temperature_change_trigger() const { return this->temperature_change_trigger_; }
+Trigger<> *ThermostatClimate::get_preset_change_trigger() const { return this->preset_change_trigger_; }
+Trigger<> *ThermostatClimate::get_humidity_control_dehumidify_action_trigger() const {
+  return this->humidity_control_dehumidify_action_trigger_;
 }
-Trigger<> *ThermostatClimate::get_humidity_control_humidify_action_trigger() {
-  return &this->humidity_control_humidify_action_trigger_;
+Trigger<> *ThermostatClimate::get_humidity_control_humidify_action_trigger() const {
+  return this->humidity_control_humidify_action_trigger_;
 }
-Trigger<> *ThermostatClimate::get_humidity_control_off_action_trigger() {
-  return &this->humidity_control_off_action_trigger_;
+Trigger<> *ThermostatClimate::get_humidity_control_off_action_trigger() const {
+  return this->humidity_control_off_action_trigger_;
 }
 
 void ThermostatClimate::dump_config() {

esphome/components/thermostat/thermostat_climate.h

@@ -146,40 +146,40 @@ class ThermostatClimate : public climate::Climate, public Component {
   void set_preset_config(std::initializer_list<PresetEntry> presets);
   void set_custom_preset_config(std::initializer_list<CustomPresetEntry> presets);
 
-  Trigger<> *get_cool_action_trigger();
-  Trigger<> *get_supplemental_cool_action_trigger();
-  Trigger<> *get_dry_action_trigger();
-  Trigger<> *get_fan_only_action_trigger();
-  Trigger<> *get_heat_action_trigger();
-  Trigger<> *get_supplemental_heat_action_trigger();
-  Trigger<> *get_idle_action_trigger();
-  Trigger<> *get_auto_mode_trigger();
-  Trigger<> *get_cool_mode_trigger();
-  Trigger<> *get_dry_mode_trigger();
-  Trigger<> *get_fan_only_mode_trigger();
-  Trigger<> *get_heat_mode_trigger();
-  Trigger<> *get_heat_cool_mode_trigger();
-  Trigger<> *get_off_mode_trigger();
-  Trigger<> *get_fan_mode_on_trigger();
-  Trigger<> *get_fan_mode_off_trigger();
-  Trigger<> *get_fan_mode_auto_trigger();
-  Trigger<> *get_fan_mode_low_trigger();
-  Trigger<> *get_fan_mode_medium_trigger();
-  Trigger<> *get_fan_mode_high_trigger();
-  Trigger<> *get_fan_mode_middle_trigger();
-  Trigger<> *get_fan_mode_focus_trigger();
-  Trigger<> *get_fan_mode_diffuse_trigger();
-  Trigger<> *get_fan_mode_quiet_trigger();
-  Trigger<> *get_swing_mode_both_trigger();
-  Trigger<> *get_swing_mode_horizontal_trigger();
-  Trigger<> *get_swing_mode_off_trigger();
-  Trigger<> *get_swing_mode_vertical_trigger();
-  Trigger<> *get_humidity_change_trigger();
-  Trigger<> *get_temperature_change_trigger();
-  Trigger<> *get_preset_change_trigger();
-  Trigger<> *get_humidity_control_dehumidify_action_trigger();
-  Trigger<> *get_humidity_control_humidify_action_trigger();
-  Trigger<> *get_humidity_control_off_action_trigger();
+  Trigger<> *get_cool_action_trigger() const;
+  Trigger<> *get_supplemental_cool_action_trigger() const;
+  Trigger<> *get_dry_action_trigger() const;
+  Trigger<> *get_fan_only_action_trigger() const;
+  Trigger<> *get_heat_action_trigger() const;
+  Trigger<> *get_supplemental_heat_action_trigger() const;
+  Trigger<> *get_idle_action_trigger() const;
+  Trigger<> *get_auto_mode_trigger() const;
+  Trigger<> *get_cool_mode_trigger() const;
+  Trigger<> *get_dry_mode_trigger() const;
+  Trigger<> *get_fan_only_mode_trigger() const;
+  Trigger<> *get_heat_mode_trigger() const;
+  Trigger<> *get_heat_cool_mode_trigger() const;
+  Trigger<> *get_off_mode_trigger() const;
+  Trigger<> *get_fan_mode_on_trigger() const;
+  Trigger<> *get_fan_mode_off_trigger() const;
+  Trigger<> *get_fan_mode_auto_trigger() const;
+  Trigger<> *get_fan_mode_low_trigger() const;
+  Trigger<> *get_fan_mode_medium_trigger() const;
+  Trigger<> *get_fan_mode_high_trigger() const;
+  Trigger<> *get_fan_mode_middle_trigger() const;
+  Trigger<> *get_fan_mode_focus_trigger() const;
+  Trigger<> *get_fan_mode_diffuse_trigger() const;
+  Trigger<> *get_fan_mode_quiet_trigger() const;
+  Trigger<> *get_swing_mode_both_trigger() const;
+  Trigger<> *get_swing_mode_horizontal_trigger() const;
+  Trigger<> *get_swing_mode_off_trigger() const;
+  Trigger<> *get_swing_mode_vertical_trigger() const;
+  Trigger<> *get_humidity_change_trigger() const;
+  Trigger<> *get_temperature_change_trigger() const;
+  Trigger<> *get_preset_change_trigger() const;
+  Trigger<> *get_humidity_control_dehumidify_action_trigger() const;
+  Trigger<> *get_humidity_control_humidify_action_trigger() const;
+  Trigger<> *get_humidity_control_off_action_trigger() const;
   /// Get current hysteresis values
   float cool_deadband();
   float cool_overrun();
@@ -417,65 +417,115 @@ class ThermostatClimate : public climate::Climate, public Component {
   /// The sensor used for getting the current humidity
   sensor::Sensor *humidity_sensor_{nullptr};
 
-  /// Trigger for cooling action/mode
-  Trigger<> cool_action_trigger_;
-  Trigger<> supplemental_cool_action_trigger_;
-  Trigger<> cool_mode_trigger_;
+  /// The trigger to call when the controller should switch to cooling action/mode.
+  ///
+  /// A null value for this attribute means that the controller has no cooling action
+  /// For example electric heat, where only heating (power on) and not-heating
+  /// (power off) is possible.
+  Trigger<> *cool_action_trigger_{nullptr};
+  Trigger<> *supplemental_cool_action_trigger_{nullptr};
+  Trigger<> *cool_mode_trigger_{nullptr};
 
-  /// Trigger for dry (dehumidification) mode
-  Trigger<> dry_action_trigger_;
-  Trigger<> dry_mode_trigger_;
+  /// The trigger to call when the controller should switch to dry (dehumidification) mode.
+  ///
+  /// In dry mode, the controller is assumed to have both heating and cooling disabled,
+  /// although the system may use its cooling mechanism to achieve drying.
+  Trigger<> *dry_action_trigger_{nullptr};
+  Trigger<> *dry_mode_trigger_{nullptr};
 
-  /// Trigger for heating action/mode
-  Trigger<> heat_action_trigger_;
-  Trigger<> supplemental_heat_action_trigger_;
-  Trigger<> heat_mode_trigger_;
+  /// The trigger to call when the controller should switch to heating action/mode.
+  ///
+  /// A null value for this attribute means that the controller has no heating action
+  /// For example window blinds, where only cooling (blinds closed) and not-cooling
+  /// (blinds open) is possible.
+  Trigger<> *heat_action_trigger_{nullptr};
+  Trigger<> *supplemental_heat_action_trigger_{nullptr};
+  Trigger<> *heat_mode_trigger_{nullptr};
 
-  /// Trigger for heat/cool mode
-  Trigger<> heat_cool_mode_trigger_;
+  /// The trigger to call when the controller should switch to heat/cool mode.
+  ///
+  /// In heat/cool mode, the controller will enable heating/cooling as necessary and switch
+  /// to idle when the temperature is within the thresholds/set points.
+  Trigger<> *heat_cool_mode_trigger_{nullptr};
 
-  /// Trigger for auto mode
-  Trigger<> auto_mode_trigger_;
+  /// The trigger to call when the controller should switch to auto mode.
+  ///
+  /// In auto mode, the controller will enable heating/cooling as supported/necessary and switch
+  /// to idle when the temperature is within the thresholds/set points.
+  Trigger<> *auto_mode_trigger_{nullptr};
 
-  /// Trigger for idle action/off mode
-  Trigger<> idle_action_trigger_;
-  Trigger<> off_mode_trigger_;
+  /// The trigger to call when the controller should switch to idle action/off mode.
+  ///
+  /// In these actions/modes, the controller is assumed to have both heating and cooling disabled.
+  Trigger<> *idle_action_trigger_{nullptr};
+  Trigger<> *off_mode_trigger_{nullptr};
 
-  /// Trigger for fan-only action/mode
-  Trigger<> fan_only_action_trigger_;
-  Trigger<> fan_only_mode_trigger_;
+  /// The trigger to call when the controller should switch to fan-only action/mode.
+  ///
+  /// In fan-only mode, the controller is assumed to have both heating and cooling disabled.
+  /// The system should activate the fan only.
+  Trigger<> *fan_only_action_trigger_{nullptr};
+  Trigger<> *fan_only_mode_trigger_{nullptr};
 
-  /// Fan mode triggers
-  Trigger<> fan_mode_on_trigger_;
-  Trigger<> fan_mode_off_trigger_;
-  Trigger<> fan_mode_auto_trigger_;
-  Trigger<> fan_mode_low_trigger_;
-  Trigger<> fan_mode_medium_trigger_;
-  Trigger<> fan_mode_high_trigger_;
-  Trigger<> fan_mode_middle_trigger_;
-  Trigger<> fan_mode_focus_trigger_;
-  Trigger<> fan_mode_diffuse_trigger_;
-  Trigger<> fan_mode_quiet_trigger_;
+  /// The trigger to call when the controller should switch on the fan.
+  Trigger<> *fan_mode_on_trigger_{nullptr};
 
-  /// Swing mode triggers
-  Trigger<> swing_mode_both_trigger_;
-  Trigger<> swing_mode_off_trigger_;
-  Trigger<> swing_mode_horizontal_trigger_;
-  Trigger<> swing_mode_vertical_trigger_;
+  /// The trigger to call when the controller should switch off the fan.
+  Trigger<> *fan_mode_off_trigger_{nullptr};
 
-  /// Trigger for target humidity changes
-  Trigger<> humidity_change_trigger_;
+  /// The trigger to call when the controller should switch the fan to "auto" mode.
+  Trigger<> *fan_mode_auto_trigger_{nullptr};
 
-  /// Trigger for target temperature changes
-  Trigger<> temperature_change_trigger_;
+  /// The trigger to call when the controller should switch the fan to "low" speed.
+  Trigger<> *fan_mode_low_trigger_{nullptr};
 
-  /// Trigger for preset mode changes
-  Trigger<> preset_change_trigger_;
+  /// The trigger to call when the controller should switch the fan to "medium" speed.
+  Trigger<> *fan_mode_medium_trigger_{nullptr};
 
-  /// Humidity control triggers
-  Trigger<> humidity_control_dehumidify_action_trigger_;
-  Trigger<> humidity_control_humidify_action_trigger_;
-  Trigger<> humidity_control_off_action_trigger_;
+  /// The trigger to call when the controller should switch the fan to "high" speed.
+  Trigger<> *fan_mode_high_trigger_{nullptr};
+
+  /// The trigger to call when the controller should switch the fan to "middle" position.
+  Trigger<> *fan_mode_middle_trigger_{nullptr};
+
+  /// The trigger to call when the controller should switch the fan to "focus" position.
+  Trigger<> *fan_mode_focus_trigger_{nullptr};
+
+  /// The trigger to call when the controller should switch the fan to "diffuse" position.
+  Trigger<> *fan_mode_diffuse_trigger_{nullptr};
+
+  /// The trigger to call when the controller should switch the fan to "quiet" position.
+  Trigger<> *fan_mode_quiet_trigger_{nullptr};
+
+  /// The trigger to call when the controller should switch the swing mode to "both".
+  Trigger<> *swing_mode_both_trigger_{nullptr};
+
+  /// The trigger to call when the controller should switch the swing mode to "off".
+  Trigger<> *swing_mode_off_trigger_{nullptr};
+
+  /// The trigger to call when the controller should switch the swing mode to "horizontal".
+  Trigger<> *swing_mode_horizontal_trigger_{nullptr};
+
+  /// The trigger to call when the controller should switch the swing mode to "vertical".
+  Trigger<> *swing_mode_vertical_trigger_{nullptr};
+
+  /// The trigger to call when the target humidity changes.
+  Trigger<> *humidity_change_trigger_{nullptr};
+
+  /// The trigger to call when the target temperature(s) change(es).
+  Trigger<> *temperature_change_trigger_{nullptr};
+
+  /// The trigger to call when the preset mode changes
+  Trigger<> *preset_change_trigger_{nullptr};
+
+  /// The trigger to call when dehumidification is required
+  Trigger<> *humidity_control_dehumidify_action_trigger_{nullptr};
+
+  /// The trigger to call when humidification is required
+  Trigger<> *humidity_control_humidify_action_trigger_{nullptr};
+
+  /// The trigger to call when (de)humidification should stop
+  Trigger<> *humidity_control_off_action_trigger_{nullptr};
 
   /// A reference to the trigger that was previously active.
   ///

esphome/components/time_based/time_based_cover.cpp

@@ -132,15 +132,15 @@ void TimeBasedCover::start_direction_(CoverOperation dir) {
   Trigger<> *trig;
   switch (dir) {
     case COVER_OPERATION_IDLE:
-      trig = &this->stop_trigger_;
+      trig = this->stop_trigger_;
       break;
     case COVER_OPERATION_OPENING:
       this->last_operation_ = dir;
-      trig = &this->open_trigger_;
+      trig = this->open_trigger_;
       break;
     case COVER_OPERATION_CLOSING:
       this->last_operation_ = dir;
-      trig = &this->close_trigger_;
+      trig = this->close_trigger_;
       break;
     default:
       return;

esphome/components/time_based/time_based_cover.h

@@ -14,9 +14,9 @@ class TimeBasedCover : public cover::Cover, public Component {
   void dump_config() override;
   float get_setup_priority() const override;
 
-  Trigger<> *get_open_trigger() { return &this->open_trigger_; }
-  Trigger<> *get_close_trigger() { return &this->close_trigger_; }
-  Trigger<> *get_stop_trigger() { return &this->stop_trigger_; }
+  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
+  Trigger<> *get_close_trigger() const { return this->close_trigger_; }
+  Trigger<> *get_stop_trigger() const { return this->stop_trigger_; }
   void set_open_duration(uint32_t open_duration) { this->open_duration_ = open_duration; }
   void set_close_duration(uint32_t close_duration) { this->close_duration_ = close_duration; }
   cover::CoverTraits get_traits() override;
@@ -34,11 +34,11 @@ class TimeBasedCover : public cover::Cover, public Component {
 
   void recompute_position_();
 
-  Trigger<> open_trigger_;
+  Trigger<> *open_trigger_{new Trigger<>()};
   uint32_t open_duration_;
-  Trigger<> close_trigger_;
+  Trigger<> *close_trigger_{new Trigger<>()};
   uint32_t close_duration_;
-  Trigger<> stop_trigger_;
+  Trigger<> *stop_trigger_{new Trigger<>()};
 
   Trigger<> *prev_command_trigger_{nullptr};
   uint32_t last_recompute_time_{0};

esphome/components/udp/__init__.py

@@ -12,8 +12,8 @@ from esphome.components.packet_transport import (
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_PORT, CONF_TRIGGER_ID
-from esphome.core import ID
-from esphome.cpp_generator import literal
+from esphome.core import ID, Lambda
+from esphome.cpp_generator import ExpressionStatement, MockObj
 
 CODEOWNERS = ["@clydebarrow"]
 DEPENDENCIES = ["network"]
@@ -24,8 +24,6 @@ udp_ns = cg.esphome_ns.namespace("udp")
 UDPComponent = udp_ns.class_("UDPComponent", cg.Component)
 UDPWriteAction = udp_ns.class_("UDPWriteAction", automation.Action)
 trigger_args = cg.std_vector.template(cg.uint8)
-trigger_argname = "data"
-trigger_argtype = [(trigger_args, trigger_argname)]
 
 CONF_ADDRESSES = "addresses"
 CONF_LISTEN_ADDRESS = "listen_address"
@@ -113,14 +111,13 @@ async def to_code(config):
     cg.add(var.set_addresses([str(addr) for addr in config[CONF_ADDRESSES]]))
     if on_receive := config.get(CONF_ON_RECEIVE):
         on_receive = on_receive[0]
-        trigger_id = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
+        trigger = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
         trigger = await automation.build_automation(
-            trigger_id, trigger_argtype, on_receive
+            trigger, [(trigger_args, "data")], on_receive
         )
-        trigger_lambda = await cg.process_lambda(
-            trigger.trigger(literal(trigger_argname)), trigger_argtype
-        )
-        cg.add(var.add_listener(trigger_lambda))
+        trigger = Lambda(str(ExpressionStatement(trigger.trigger(MockObj("data")))))
+        trigger = await cg.process_lambda(trigger, [(trigger_args, "data")])
+        cg.add(var.add_listener(trigger))
         cg.add(var.set_should_listen())
 
 

esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp

@@ -155,9 +155,8 @@ void USBCDCACMInstance::setup() {
     return;
   }
 
-  // Use a larger stack size for very verbose logging
-  constexpr size_t stack_size =
-      ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE ? USB_TX_TASK_STACK_SIZE_VV : USB_TX_TASK_STACK_SIZE;
+  // Use a larger stack size for (very) verbose logging
+  const size_t stack_size = esp_log_level_get(TAG) > ESP_LOG_DEBUG ? USB_TX_TASK_STACK_SIZE_VV : USB_TX_TASK_STACK_SIZE;
 
   // Create a simple, unique task name per interface
   char task_name[] = "usb_tx_0";

esphome/components/voice_assistant/voice_assistant.cpp

@@ -197,7 +197,7 @@ void VoiceAssistant::loop() {
   switch (this->state_) {
     case State::IDLE: {
       if (this->continuous_ && this->desired_state_ == State::IDLE) {
-        this->idle_trigger_.trigger();
+        this->idle_trigger_->trigger();
         this->set_state_(State::START_MICROPHONE, State::START_PIPELINE);
       } else {
         this->deallocate_buffers_();
@@ -254,7 +254,7 @@ void VoiceAssistant::loop() {
       if (this->api_client_ == nullptr ||
           !this->api_client_->send_message(msg, api::VoiceAssistantRequest::MESSAGE_TYPE)) {
         ESP_LOGW(TAG, "Could not request start");
-        this->error_trigger_.trigger("not-connected", "Could not request start");
+        this->error_trigger_->trigger("not-connected", "Could not request start");
         this->continuous_ = false;
         this->set_state_(State::IDLE, State::IDLE);
         break;
@@ -384,7 +384,7 @@ void VoiceAssistant::loop() {
         this->wait_for_stream_end_ = false;
         this->stream_ended_ = false;
 
-        this->tts_stream_end_trigger_.trigger();
+        this->tts_stream_end_trigger_->trigger();
       }
 #endif
       if (this->continue_conversation_) {
@@ -425,7 +425,7 @@ void VoiceAssistant::client_subscription(api::APIConnection *client, bool subscr
       return;
     }
     this->api_client_ = nullptr;
-    this->client_disconnected_trigger_.trigger();
+    this->client_disconnected_trigger_->trigger();
     return;
   }
 
@@ -440,7 +440,7 @@ void VoiceAssistant::client_subscription(api::APIConnection *client, bool subscr
   }
 
   this->api_client_ = client;
-  this->client_connected_trigger_.trigger();
+  this->client_connected_trigger_->trigger();
 }
 
 static const LogString *voice_assistant_state_to_string(State state) {
@@ -491,7 +491,7 @@ void VoiceAssistant::set_state_(State state, State desired_state) {
 
 void VoiceAssistant::failed_to_start() {
   ESP_LOGE(TAG, "Failed to start server. See Home Assistant logs for more details.");
-  this->error_trigger_.trigger("failed-to-start", "Failed to start server. See Home Assistant logs for more details.");
+  this->error_trigger_->trigger("failed-to-start", "Failed to start server. See Home Assistant logs for more details.");
   this->set_state_(State::STOP_MICROPHONE, State::IDLE);
 }
 
@@ -637,18 +637,18 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         }
       }
 #endif
-      this->defer([this]() { this->start_trigger_.trigger(); });
+      this->defer([this]() { this->start_trigger_->trigger(); });
       break;
     case api::enums::VOICE_ASSISTANT_WAKE_WORD_START:
       break;
     case api::enums::VOICE_ASSISTANT_WAKE_WORD_END: {
       ESP_LOGD(TAG, "Wake word detected");
-      this->defer([this]() { this->wake_word_detected_trigger_.trigger(); });
+      this->defer([this]() { this->wake_word_detected_trigger_->trigger(); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_STT_START:
       ESP_LOGD(TAG, "STT started");
-      this->defer([this]() { this->listening_trigger_.trigger(); });
+      this->defer([this]() { this->listening_trigger_->trigger(); });
       break;
     case api::enums::VOICE_ASSISTANT_STT_END: {
       std::string text;
@@ -665,12 +665,12 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         text += "...";
       }
       ESP_LOGD(TAG, "Speech recognised as: \"%s\"", text.c_str());
-      this->defer([this, text]() { this->stt_end_trigger_.trigger(text); });
+      this->defer([this, text]() { this->stt_end_trigger_->trigger(text); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_INTENT_START:
       ESP_LOGD(TAG, "Intent started");
-      this->defer([this]() { this->intent_start_trigger_.trigger(); });
+      this->defer([this]() { this->intent_start_trigger_->trigger(); });
       break;
     case api::enums::VOICE_ASSISTANT_INTENT_PROGRESS: {
       ESP_LOGD(TAG, "Intent progress");
@@ -693,7 +693,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         }
       }
 #endif
-      this->defer([this, tts_url_for_trigger]() { this->intent_progress_trigger_.trigger(tts_url_for_trigger); });
+      this->defer([this, tts_url_for_trigger]() { this->intent_progress_trigger_->trigger(tts_url_for_trigger); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_INTENT_END: {
@@ -704,7 +704,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
           this->continue_conversation_ = (arg.value == "1");
         }
       }
-      this->defer([this]() { this->intent_end_trigger_.trigger(); });
+      this->defer([this]() { this->intent_end_trigger_->trigger(); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_TTS_START: {
@@ -724,7 +724,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
       }
       ESP_LOGD(TAG, "Response: \"%s\"", text.c_str());
       this->defer([this, text]() {
-        this->tts_start_trigger_.trigger(text);
+        this->tts_start_trigger_->trigger(text);
 #ifdef USE_SPEAKER
         if (this->speaker_ != nullptr) {
           this->speaker_->start();
@@ -756,7 +756,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         }
         this->started_streaming_tts_ = false;  // Helps indicate reaching the TTS_END stage
 #endif
-        this->tts_end_trigger_.trigger(url);
+        this->tts_end_trigger_->trigger(url);
       });
       State new_state = this->local_output_ ? State::STREAMING_RESPONSE : State::IDLE;
       if (new_state != this->state_) {
@@ -776,7 +776,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         // No TTS start event ("nevermind")
         this->set_state_(State::IDLE, State::IDLE);
       }
-      this->defer([this]() { this->end_trigger_.trigger(); });
+      this->defer([this]() { this->end_trigger_->trigger(); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_ERROR: {
@@ -796,7 +796,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         // Wake word is not set up or not ready on Home Assistant so stop and do not retry until user starts again.
         this->defer([this, code, message]() {
           this->request_stop();
-          this->error_trigger_.trigger(code, message);
+          this->error_trigger_->trigger(code, message);
         });
         return;
       }
@@ -805,7 +805,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         this->signal_stop_();
         this->set_state_(State::STOP_MICROPHONE, State::IDLE);
       }
-      this->defer([this, code, message]() { this->error_trigger_.trigger(code, message); });
+      this->defer([this, code, message]() { this->error_trigger_->trigger(code, message); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_TTS_STREAM_START: {
@@ -813,7 +813,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
       if (this->speaker_ != nullptr) {
         this->wait_for_stream_end_ = true;
         ESP_LOGD(TAG, "TTS stream start");
-        this->defer([this] { this->tts_stream_start_trigger_.trigger(); });
+        this->defer([this] { this->tts_stream_start_trigger_->trigger(); });
       }
 #endif
       break;
@@ -829,12 +829,12 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
     }
     case api::enums::VOICE_ASSISTANT_STT_VAD_START:
       ESP_LOGD(TAG, "Starting STT by VAD");
-      this->defer([this]() { this->stt_vad_start_trigger_.trigger(); });
+      this->defer([this]() { this->stt_vad_start_trigger_->trigger(); });
       break;
     case api::enums::VOICE_ASSISTANT_STT_VAD_END:
       ESP_LOGD(TAG, "STT by VAD end");
       this->set_state_(State::STOP_MICROPHONE, State::AWAITING_RESPONSE);
-      this->defer([this]() { this->stt_vad_end_trigger_.trigger(); });
+      this->defer([this]() { this->stt_vad_end_trigger_->trigger(); });
       break;
     default:
       ESP_LOGD(TAG, "Unhandled event type: %" PRId32, msg.event_type);
@@ -876,17 +876,17 @@ void VoiceAssistant::on_timer_event(const api::VoiceAssistantTimerEventResponse
 
   switch (msg.event_type) {
     case api::enums::VOICE_ASSISTANT_TIMER_STARTED:
-      this->timer_started_trigger_.trigger(timer);
+      this->timer_started_trigger_->trigger(timer);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_UPDATED:
-      this->timer_updated_trigger_.trigger(timer);
+      this->timer_updated_trigger_->trigger(timer);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_CANCELLED:
-      this->timer_cancelled_trigger_.trigger(timer);
+      this->timer_cancelled_trigger_->trigger(timer);
       this->timers_.erase(timer.id);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_FINISHED:
-      this->timer_finished_trigger_.trigger(timer);
+      this->timer_finished_trigger_->trigger(timer);
       this->timers_.erase(timer.id);
       break;
   }
@@ -910,13 +910,13 @@ void VoiceAssistant::timer_tick_() {
     }
     res.push_back(timer);
   }
-  this->timer_tick_trigger_.trigger(res);
+  this->timer_tick_trigger_->trigger(res);
 }
 
 void VoiceAssistant::on_announce(const api::VoiceAssistantAnnounceRequest &msg) {
 #ifdef USE_MEDIA_PLAYER
   if (this->media_player_ != nullptr) {
-    this->tts_start_trigger_.trigger(msg.text);
+    this->tts_start_trigger_->trigger(msg.text);
 
     this->media_player_response_state_ = MediaPlayerResponseState::URL_SENT;
 
@@ -939,8 +939,8 @@ void VoiceAssistant::on_announce(const api::VoiceAssistantAnnounceRequest &msg)
       this->set_state_(State::STREAMING_RESPONSE, State::STREAMING_RESPONSE);
     }
 
-    this->tts_end_trigger_.trigger(msg.media_id);
-    this->end_trigger_.trigger();
+    this->tts_end_trigger_->trigger(msg.media_id);
+    this->end_trigger_->trigger();
   }
 #endif
 }

esphome/components/voice_assistant/voice_assistant.h

@@ -195,38 +195,38 @@ class VoiceAssistant : public Component {
   void set_conversation_timeout(uint32_t conversation_timeout) { this->conversation_timeout_ = conversation_timeout; }
   void reset_conversation_id();
 
-  Trigger<> *get_intent_end_trigger() { return &this->intent_end_trigger_; }
-  Trigger<> *get_intent_start_trigger() { return &this->intent_start_trigger_; }
-  Trigger<std::string> *get_intent_progress_trigger() { return &this->intent_progress_trigger_; }
-  Trigger<> *get_listening_trigger() { return &this->listening_trigger_; }
-  Trigger<> *get_end_trigger() { return &this->end_trigger_; }
-  Trigger<> *get_start_trigger() { return &this->start_trigger_; }
-  Trigger<> *get_stt_vad_end_trigger() { return &this->stt_vad_end_trigger_; }
-  Trigger<> *get_stt_vad_start_trigger() { return &this->stt_vad_start_trigger_; }
+  Trigger<> *get_intent_end_trigger() const { return this->intent_end_trigger_; }
+  Trigger<> *get_intent_start_trigger() const { return this->intent_start_trigger_; }
+  Trigger<std::string> *get_intent_progress_trigger() const { return this->intent_progress_trigger_; }
+  Trigger<> *get_listening_trigger() const { return this->listening_trigger_; }
+  Trigger<> *get_end_trigger() const { return this->end_trigger_; }
+  Trigger<> *get_start_trigger() const { return this->start_trigger_; }
+  Trigger<> *get_stt_vad_end_trigger() const { return this->stt_vad_end_trigger_; }
+  Trigger<> *get_stt_vad_start_trigger() const { return this->stt_vad_start_trigger_; }
 #ifdef USE_SPEAKER
-  Trigger<> *get_tts_stream_start_trigger() { return &this->tts_stream_start_trigger_; }
-  Trigger<> *get_tts_stream_end_trigger() { return &this->tts_stream_end_trigger_; }
+  Trigger<> *get_tts_stream_start_trigger() const { return this->tts_stream_start_trigger_; }
+  Trigger<> *get_tts_stream_end_trigger() const { return this->tts_stream_end_trigger_; }
 #endif
-  Trigger<> *get_wake_word_detected_trigger() { return &this->wake_word_detected_trigger_; }
-  Trigger<std::string> *get_stt_end_trigger() { return &this->stt_end_trigger_; }
-  Trigger<std::string> *get_tts_end_trigger() { return &this->tts_end_trigger_; }
-  Trigger<std::string> *get_tts_start_trigger() { return &this->tts_start_trigger_; }
-  Trigger<std::string, std::string> *get_error_trigger() { return &this->error_trigger_; }
-  Trigger<> *get_idle_trigger() { return &this->idle_trigger_; }
+  Trigger<> *get_wake_word_detected_trigger() const { return this->wake_word_detected_trigger_; }
+  Trigger<std::string> *get_stt_end_trigger() const { return this->stt_end_trigger_; }
+  Trigger<std::string> *get_tts_end_trigger() const { return this->tts_end_trigger_; }
+  Trigger<std::string> *get_tts_start_trigger() const { return this->tts_start_trigger_; }
+  Trigger<std::string, std::string> *get_error_trigger() const { return this->error_trigger_; }
+  Trigger<> *get_idle_trigger() const { return this->idle_trigger_; }
 
-  Trigger<> *get_client_connected_trigger() { return &this->client_connected_trigger_; }
-  Trigger<> *get_client_disconnected_trigger() { return &this->client_disconnected_trigger_; }
+  Trigger<> *get_client_connected_trigger() const { return this->client_connected_trigger_; }
+  Trigger<> *get_client_disconnected_trigger() const { return this->client_disconnected_trigger_; }
 
   void client_subscription(api::APIConnection *client, bool subscribe);
   api::APIConnection *get_api_connection() const { return this->api_client_; }
 
   void set_wake_word(const std::string &wake_word) { this->wake_word_ = wake_word; }
 
-  Trigger<Timer> *get_timer_started_trigger() { return &this->timer_started_trigger_; }
-  Trigger<Timer> *get_timer_updated_trigger() { return &this->timer_updated_trigger_; }
-  Trigger<Timer> *get_timer_cancelled_trigger() { return &this->timer_cancelled_trigger_; }
-  Trigger<Timer> *get_timer_finished_trigger() { return &this->timer_finished_trigger_; }
-  Trigger<std::vector<Timer>> *get_timer_tick_trigger() { return &this->timer_tick_trigger_; }
+  Trigger<Timer> *get_timer_started_trigger() const { return this->timer_started_trigger_; }
+  Trigger<Timer> *get_timer_updated_trigger() const { return this->timer_updated_trigger_; }
+  Trigger<Timer> *get_timer_cancelled_trigger() const { return this->timer_cancelled_trigger_; }
+  Trigger<Timer> *get_timer_finished_trigger() const { return this->timer_finished_trigger_; }
+  Trigger<std::vector<Timer>> *get_timer_tick_trigger() const { return this->timer_tick_trigger_; }
   void set_has_timers(bool has_timers) { this->has_timers_ = has_timers; }
   const std::unordered_map<std::string, Timer> &get_timers() const { return this->timers_; }
 
@@ -243,37 +243,37 @@ class VoiceAssistant : public Component {
   std::unique_ptr<socket::Socket> socket_ = nullptr;
   struct sockaddr_storage dest_addr_;
 
-  Trigger<> intent_end_trigger_;
-  Trigger<> intent_start_trigger_;
-  Trigger<> listening_trigger_;
-  Trigger<> end_trigger_;
-  Trigger<> start_trigger_;
-  Trigger<> stt_vad_start_trigger_;
-  Trigger<> stt_vad_end_trigger_;
+  Trigger<> *intent_end_trigger_ = new Trigger<>();
+  Trigger<> *intent_start_trigger_ = new Trigger<>();
+  Trigger<> *listening_trigger_ = new Trigger<>();
+  Trigger<> *end_trigger_ = new Trigger<>();
+  Trigger<> *start_trigger_ = new Trigger<>();
+  Trigger<> *stt_vad_start_trigger_ = new Trigger<>();
+  Trigger<> *stt_vad_end_trigger_ = new Trigger<>();
 #ifdef USE_SPEAKER
-  Trigger<> tts_stream_start_trigger_;
-  Trigger<> tts_stream_end_trigger_;
+  Trigger<> *tts_stream_start_trigger_ = new Trigger<>();
+  Trigger<> *tts_stream_end_trigger_ = new Trigger<>();
 #endif
-  Trigger<std::string> intent_progress_trigger_;
-  Trigger<> wake_word_detected_trigger_;
-  Trigger<std::string> stt_end_trigger_;
-  Trigger<std::string> tts_end_trigger_;
-  Trigger<std::string> tts_start_trigger_;
-  Trigger<std::string, std::string> error_trigger_;
-  Trigger<> idle_trigger_;
+  Trigger<std::string> *intent_progress_trigger_ = new Trigger<std::string>();
+  Trigger<> *wake_word_detected_trigger_ = new Trigger<>();
+  Trigger<std::string> *stt_end_trigger_ = new Trigger<std::string>();
+  Trigger<std::string> *tts_end_trigger_ = new Trigger<std::string>();
+  Trigger<std::string> *tts_start_trigger_ = new Trigger<std::string>();
+  Trigger<std::string, std::string> *error_trigger_ = new Trigger<std::string, std::string>();
+  Trigger<> *idle_trigger_ = new Trigger<>();
 
-  Trigger<> client_connected_trigger_;
-  Trigger<> client_disconnected_trigger_;
+  Trigger<> *client_connected_trigger_ = new Trigger<>();
+  Trigger<> *client_disconnected_trigger_ = new Trigger<>();
 
   api::APIConnection *api_client_{nullptr};
 
   std::unordered_map<std::string, Timer> timers_;
   void timer_tick_();
-  Trigger<Timer> timer_started_trigger_;
-  Trigger<Timer> timer_finished_trigger_;
-  Trigger<Timer> timer_updated_trigger_;
-  Trigger<Timer> timer_cancelled_trigger_;
-  Trigger<std::vector<Timer>> timer_tick_trigger_;
+  Trigger<Timer> *timer_started_trigger_ = new Trigger<Timer>();
+  Trigger<Timer> *timer_finished_trigger_ = new Trigger<Timer>();
+  Trigger<Timer> *timer_updated_trigger_ = new Trigger<Timer>();
+  Trigger<Timer> *timer_cancelled_trigger_ = new Trigger<Timer>();
+  Trigger<std::vector<Timer>> *timer_tick_trigger_ = new Trigger<std::vector<Timer>>();
   bool has_timers_{false};
   bool timer_tick_running_{false};
 

esphome/components/web_server_base/__init__.py

@@ -38,8 +38,11 @@ async def to_code(config):
         cg.add_define("WEB_SERVER_DEFAULT_HEADERS_COUNT", 1)
         return
 
-    # ESP32 uses IDF web server (early return above), so this is for other Arduino platforms
     if CORE.using_arduino:
+        if CORE.is_esp32:
+            cg.add_library("WiFi", None)
+            cg.add_library("FS", None)
+            cg.add_library("Update", None)
         if CORE.is_esp8266:
             cg.add_library("ESP8266WiFi", None)
         if CORE.is_libretiny:

esphome/components/wled/__init__.py

@@ -3,7 +3,6 @@ from esphome.components.light.effects import register_addressable_effect
 from esphome.components.light.types import AddressableLightEffect
 import esphome.config_validation as cv
 from esphome.const import CONF_NAME, CONF_PORT
-from esphome.core import CORE
 
 wled_ns = cg.esphome_ns.namespace("wled")
 WLEDLightEffect = wled_ns.class_("WLEDLightEffect", AddressableLightEffect)
@@ -28,6 +27,4 @@ async def wled_light_effect_to_code(config, effect_id):
     cg.add(effect.set_port(config[CONF_PORT]))
     cg.add(effect.set_sync_group_mask(config[CONF_SYNC_GROUP_MASK]))
     cg.add(effect.set_blank_on_start(config[CONF_BLANK_ON_START]))
-    if CORE.is_esp32:
-        cg.add_library("WiFi", None)
     return effect

esphome/core/__init__.py

@@ -278,13 +278,9 @@ LAMBDA_PROG = re.compile(r"\bid\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)(\.?)")
 
 class Lambda:
     def __init__(self, value):
-        from esphome.cpp_generator import Expression, statement
-
         # pylint: disable=protected-access
         if isinstance(value, Lambda):
             self._value = value._value
-        elif isinstance(value, Expression):
-            self._value = str(statement(value))
         else:
             self._value = value
         self._parts = None
@@ -892,16 +888,6 @@ class EsphomeCore:
             library.name if "/" not in library.name else library.name.split("/")[-1]
         )
 
-        # Auto-enable Arduino libraries on ESP32 Arduino builds
-        if self.is_esp32 and self.using_arduino:
-            from esphome.components.esp32 import (
-                ARDUINO_DISABLED_LIBRARIES,
-                _enable_arduino_library,
-            )
-
-            if short_name in ARDUINO_DISABLED_LIBRARIES:
-                _enable_arduino_library(short_name)
-
         if short_name not in self.platformio_libraries:
             _LOGGER.debug("Adding library: %s", library)
             self.platformio_libraries[short_name] = library

esphome/core/defines.h

@@ -240,8 +240,6 @@
 #define USE_ETHERNET_KSZ8081
 #define USE_ETHERNET_MANUAL_IP
 #define USE_ETHERNET_IP_STATE_LISTENERS
-#define USE_ETHERNET_CONNECT_TRIGGER
-#define USE_ETHERNET_DISCONNECT_TRIGGER
 #define ESPHOME_ETHERNET_IP_STATE_LISTENERS 2
 #endif
 

esphome/cpp_generator.py

@@ -462,16 +462,6 @@ def statement(expression: Expression | Statement) -> Statement:
     return ExpressionStatement(expression)
 
 
-def literal(name: str) -> "MockObj":
-    """Create a literal name that will appear in the generated code
-    not surrounded by quotes.
-
-    :param name: The name of the literal.
-    :return: The literal as a MockObj.
-    """
-    return MockObj(name, "")
-
-
 def variable(
     id_: ID, rhs: SafeExpType, type_: "MockObj" = None, register=True
 ) -> "MockObj":
@@ -675,7 +665,7 @@ async def get_variable_with_full_id(id_: ID) -> tuple[ID, "MockObj"]:
 
 
 async def process_lambda(
-    value: Lambda | Expression,
+    value: Lambda,
     parameters: TemplateArgsType,
     capture: str = "",
     return_type: SafeExpType = None,
@@ -699,14 +689,6 @@ async def process_lambda(
 
     if value is None:
         return None
-    # Inadvertently passing a malformed parameters value will lead to the build process mysteriously hanging at the
-    # "Generating C++ source..." stage, so check here to save the developer's hair.
-    assert isinstance(parameters, list) and all(
-        isinstance(p, tuple) and len(p) == 2 for p in parameters
-    )
-    if isinstance(value, Expression):
-        value = Lambda(value)
-
     parts = value.parts[:]
     for i, id in enumerate(value.requires_ids):
         full_id, var = await get_variable_with_full_id(id)

tests/components/dlms_meter/common-generic.yaml

@@ -1,11 +0,0 @@
-dlms_meter:
-  decryption_key: "36C66639E48A8CA4D6BC8B282A793BBB"   # change this to your decryption key!
-
-sensor:
-  - platform: dlms_meter
-    reactive_energy_plus:
-      name: "Reactive energy taken from grid"
-    reactive_energy_minus:
-      name: "Reactive energy put into grid"
-
-<<: !include common.yaml

tests/components/dlms_meter/common-netznoe.yaml

@@ -1,17 +0,0 @@
-dlms_meter:
-  decryption_key: "36C66639E48A8CA4D6BC8B282A793BBB"  # change this to your decryption key!
-  provider: netznoe                                   # (optional) key - only set if using evn
-
-sensor:
-  - platform: dlms_meter
-    # EVN
-    power_factor:
-      name: "Power Factor"
-
-text_sensor:
-  - platform: dlms_meter
-    # EVN
-    meternumber:
-      name: "meterNumber"
-
-<<: !include common.yaml

tests/components/dlms_meter/common.yaml

@@ -1,27 +0,0 @@
-sensor:
-  - platform: dlms_meter
-    voltage_l1:
-      name: "Voltage L1"
-    voltage_l2:
-      name: "Voltage L2"
-    voltage_l3:
-      name: "Voltage L3"
-    current_l1:
-      name: "Current L1"
-    current_l2:
-      name: "Current L2"
-    current_l3:
-      name: "Current L3"
-    active_power_plus:
-      name: "Active power taken from grid"
-    active_power_minus:
-      name: "Active power put into grid"
-    active_energy_plus:
-      name: "Active energy taken from grid"
-    active_energy_minus:
-      name: "Active energy put into grid"
-
-text_sensor:
-  - platform: dlms_meter
-    timestamp:
-      name: "timestamp"