esphome 2025.7.4__py3-none-any.whl → 2025.8.0b1__py3-none-any.whl

esphome/components/sensor/__init__.py

@@ -41,6 +41,7 @@ from esphome.const import (
     CONF_VALUE,
     CONF_WEB_SERVER,
     CONF_WINDOW_SIZE,
+    DEVICE_CLASS_ABSOLUTE_HUMIDITY,
     DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_AQI,
     DEVICE_CLASS_AREA,
@@ -107,6 +108,7 @@ from esphome.util import Registry
 
 CODEOWNERS = ["@esphome/core"]
 DEVICE_CLASSES = [
+    DEVICE_CLASS_ABSOLUTE_HUMIDITY,
     DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_AQI,
     DEVICE_CLASS_AREA,
@@ -254,6 +256,7 @@ OffsetFilter = sensor_ns.class_("OffsetFilter", Filter)
 MultiplyFilter = sensor_ns.class_("MultiplyFilter", Filter)
 FilterOutValueFilter = sensor_ns.class_("FilterOutValueFilter", Filter)
 ThrottleFilter = sensor_ns.class_("ThrottleFilter", Filter)
+ThrottleWithPriorityFilter = sensor_ns.class_("ThrottleWithPriorityFilter", Filter)
 TimeoutFilter = sensor_ns.class_("TimeoutFilter", Filter, cg.Component)
 DebounceFilter = sensor_ns.class_("DebounceFilter", Filter, cg.Component)
 HeartbeatFilter = sensor_ns.class_("HeartbeatFilter", Filter, cg.Component)
@@ -330,6 +333,7 @@ def sensor_schema(
     device_class: str = cv.UNDEFINED,
     state_class: str = cv.UNDEFINED,
     entity_category: str = cv.UNDEFINED,
+    filters: list = cv.UNDEFINED,
 ) -> cv.Schema:
     schema = {}
 
@@ -344,6 +348,7 @@ def sensor_schema(
         (CONF_DEVICE_CLASS, device_class, validate_device_class),
         (CONF_STATE_CLASS, state_class, validate_state_class),
         (CONF_ENTITY_CATEGORY, entity_category, sensor_entity_category),
+        (CONF_FILTERS, filters, validate_filters),
     ]:
         if default is not cv.UNDEFINED:
             schema[cv.Optional(key, default=default)] = validator
@@ -591,6 +596,29 @@ async def throttle_filter_to_code(config, filter_id):
     return cg.new_Pvariable(filter_id, config)
 
 
+THROTTLE_WITH_PRIORITY_SCHEMA = cv.maybe_simple_value(
+    {
+        cv.Required(CONF_TIMEOUT): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_VALUE, default="nan"): cv.Any(
+            cv.templatable(cv.float_), [cv.templatable(cv.float_)]
+        ),
+    },
+    key=CONF_TIMEOUT,
+)
+
+
+@FILTER_REGISTRY.register(
+    "throttle_with_priority",
+    ThrottleWithPriorityFilter,
+    THROTTLE_WITH_PRIORITY_SCHEMA,
+)
+async def throttle_with_priority_filter_to_code(config, filter_id):
+    if not isinstance(config[CONF_VALUE], list):
+        config[CONF_VALUE] = [config[CONF_VALUE]]
+    template_ = [await cg.templatable(x, [], float) for x in config[CONF_VALUE]]
+    return cg.new_Pvariable(filter_id, config[CONF_TIMEOUT], template_)
+
+
 @FILTER_REGISTRY.register(
     "heartbeat", HeartbeatFilter, cv.positive_time_period_milliseconds
 )
@@ -603,7 +631,9 @@ async def heartbeat_filter_to_code(config, filter_id):
 TIMEOUT_SCHEMA = cv.maybe_simple_value(
     {
         cv.Required(CONF_TIMEOUT): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_VALUE, default="nan"): cv.templatable(cv.float_),
+        cv.Optional(CONF_VALUE, default="nan"): cv.Any(
+            "last", cv.templatable(cv.float_)
+        ),
     },
     key=CONF_TIMEOUT,
 )
@@ -611,8 +641,11 @@ TIMEOUT_SCHEMA = cv.maybe_simple_value(
 
 @FILTER_REGISTRY.register("timeout", TimeoutFilter, TIMEOUT_SCHEMA)
 async def timeout_filter_to_code(config, filter_id):
-    template_ = await cg.templatable(config[CONF_VALUE], [], float)
-    var = cg.new_Pvariable(filter_id, config[CONF_TIMEOUT], template_)
+    if config[CONF_VALUE] == "last":
+        var = cg.new_Pvariable(filter_id, config[CONF_TIMEOUT])
+    else:
+        template_ = await cg.templatable(config[CONF_VALUE], [], float)
+        var = cg.new_Pvariable(filter_id, config[CONF_TIMEOUT], template_)
     await cg.register_component(var, {})
     return var
 
@@ -1111,5 +1144,4 @@ def _lstsq(a, b):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
-    cg.add_define("USE_SENSOR")
     cg.add_global(sensor_ns.using)

esphome/components/sensor/filter.cpp

@@ -1,5 +1,6 @@
 #include "filter.h"
 #include <cmath>
+#include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 #include "sensor.h"
@@ -50,6 +51,7 @@ optional<float> MedianFilter::new_value(float value) {
     if (!this->queue_.empty()) {
       // Copy queue without NaN values
       std::vector<float> median_queue;
+      median_queue.reserve(this->queue_.size());
       for (auto v : this->queue_) {
         if (!std::isnan(v)) {
           median_queue.push_back(v);
@@ -223,7 +225,7 @@ optional<float> SlidingWindowMovingAverageFilter::new_value(float value) {
 
 // ExponentialMovingAverageFilter
 ExponentialMovingAverageFilter::ExponentialMovingAverageFilter(float alpha, size_t send_every, size_t send_first_at)
-    : send_every_(send_every), send_at_(send_every - send_first_at), alpha_(alpha) {}
+    : alpha_(alpha), send_every_(send_every), send_at_(send_every - send_first_at) {}
 optional<float> ExponentialMovingAverageFilter::new_value(float value) {
   if (!std::isnan(value)) {
     if (this->first_value_) {
@@ -323,7 +325,7 @@ optional<float> FilterOutValueFilter::new_value(float value) {
 // ThrottleFilter
 ThrottleFilter::ThrottleFilter(uint32_t min_time_between_inputs) : min_time_between_inputs_(min_time_between_inputs) {}
 optional<float> ThrottleFilter::new_value(float value) {
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
   if (this->last_input_ == 0 || now - this->last_input_ >= min_time_between_inputs_) {
     this->last_input_ = now;
     return value;
@@ -331,21 +333,53 @@ optional<float> ThrottleFilter::new_value(float value) {
   return {};
 }
 
+// ThrottleWithPriorityFilter
+ThrottleWithPriorityFilter::ThrottleWithPriorityFilter(uint32_t min_time_between_inputs,
+                                                       std::vector<TemplatableValue<float>> prioritized_values)
+    : min_time_between_inputs_(min_time_between_inputs), prioritized_values_(std::move(prioritized_values)) {}
+
+optional<float> ThrottleWithPriorityFilter::new_value(float value) {
+  bool is_prioritized_value = false;
+  int8_t accuracy = this->parent_->get_accuracy_decimals();
+  float accuracy_mult = powf(10.0f, accuracy);
+  const uint32_t now = App.get_loop_component_start_time();
+  // First, determine if the new value is one of the prioritized values
+  for (auto prioritized_value : this->prioritized_values_) {
+    if (std::isnan(prioritized_value.value())) {
+      if (std::isnan(value)) {
+        is_prioritized_value = true;
+        break;
+      }
+      continue;
+    }
+    float rounded_prioritized_value = roundf(accuracy_mult * prioritized_value.value());
+    float rounded_value = roundf(accuracy_mult * value);
+    if (rounded_prioritized_value == rounded_value) {
+      is_prioritized_value = true;
+      break;
+    }
+  }
+  // Finally, determine if the new value should be throttled and pass it through if not
+  if (this->last_input_ == 0 || now - this->last_input_ >= min_time_between_inputs_ || is_prioritized_value) {
+    this->last_input_ = now;
+    return value;
+  }
+  return {};
+}
+
 // DeltaFilter
 DeltaFilter::DeltaFilter(float delta, bool percentage_mode)
-    : delta_(delta), current_delta_(delta), percentage_mode_(percentage_mode), last_value_(NAN) {}
+    : delta_(delta), current_delta_(delta), last_value_(NAN), percentage_mode_(percentage_mode) {}
 optional<float> DeltaFilter::new_value(float value) {
   if (std::isnan(value)) {
     if (std::isnan(this->last_value_)) {
       return {};
     } else {
-      if (this->percentage_mode_) {
-        this->current_delta_ = fabsf(value * this->delta_);
-      }
       return this->last_value_ = value;
     }
   }
-  if (std::isnan(this->last_value_) || fabsf(value - this->last_value_) >= this->current_delta_) {
+  float diff = fabsf(value - this->last_value_);
+  if (std::isnan(this->last_value_) || (diff > 0.0f && diff >= this->current_delta_)) {
     if (this->percentage_mode_) {
       this->current_delta_ = fabsf(value * this->delta_);
     }
@@ -383,12 +417,17 @@ void OrFilter::initialize(Sensor *parent, Filter *next) {
 
 // TimeoutFilter
 optional<float> TimeoutFilter::new_value(float value) {
-  this->set_timeout("timeout", this->time_period_, [this]() { this->output(this->value_.value()); });
+  if (this->value_.has_value()) {
+    this->set_timeout("timeout", this->time_period_, [this]() { this->output(this->value_.value().value()); });
+  } else {
+    this->set_timeout("timeout", this->time_period_, [this, value]() { this->output(value); });
+  }
   return value;
 }
 
-TimeoutFilter::TimeoutFilter(uint32_t time_period, TemplatableValue<float> new_value)
-    : time_period_(time_period), value_(std::move(new_value)) {}
+TimeoutFilter::TimeoutFilter(uint32_t time_period) : time_period_(time_period) {}
+TimeoutFilter::TimeoutFilter(uint32_t time_period, const TemplatableValue<float> &new_value)
+    : time_period_(time_period), value_(new_value) {}
 float TimeoutFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
 // DebounceFilter

esphome/components/sensor/filter.h

@@ -221,11 +221,11 @@ class ExponentialMovingAverageFilter : public Filter {
   void set_alpha(float alpha);
 
  protected:
-  bool first_value_{true};
   float accumulator_{NAN};
+  float alpha_;
   size_t send_every_;
   size_t send_at_;
-  float alpha_;
+  bool first_value_{true};
 };
 
 /** Simple throttle average filter.
@@ -243,9 +243,9 @@ class ThrottleAverageFilter : public Filter, public Component {
   float get_setup_priority() const override;
 
  protected:
-  uint32_t time_period_;
   float sum_{0.0f};
   unsigned int n_{0};
+  uint32_t time_period_;
   bool have_nan_{false};
 };
 
@@ -314,9 +314,24 @@ class ThrottleFilter : public Filter {
   uint32_t min_time_between_inputs_;
 };
 
+/// Same as 'throttle' but will immediately publish values contained in `value_to_prioritize`.
+class ThrottleWithPriorityFilter : public Filter {
+ public:
+  explicit ThrottleWithPriorityFilter(uint32_t min_time_between_inputs,
+                                      std::vector<TemplatableValue<float>> prioritized_values);
+
+  optional<float> new_value(float value) override;
+
+ protected:
+  uint32_t last_input_{0};
+  uint32_t min_time_between_inputs_;
+  std::vector<TemplatableValue<float>> prioritized_values_;
+};
+
 class TimeoutFilter : public Filter, public Component {
  public:
-  explicit TimeoutFilter(uint32_t time_period, TemplatableValue<float> new_value);
+  explicit TimeoutFilter(uint32_t time_period);
+  explicit TimeoutFilter(uint32_t time_period, const TemplatableValue<float> &new_value);
 
   optional<float> new_value(float value) override;
 
@@ -324,7 +339,7 @@ class TimeoutFilter : public Filter, public Component {
 
  protected:
   uint32_t time_period_;
-  TemplatableValue<float> value_;
+  optional<TemplatableValue<float>> value_;
 };
 
 class DebounceFilter : public Filter, public Component {
@@ -364,8 +379,8 @@ class DeltaFilter : public Filter {
  protected:
   float delta_;
   float current_delta_;
-  bool percentage_mode_;
   float last_value_{NAN};
+  bool percentage_mode_;
 };
 
 class OrFilter : public Filter {
@@ -387,8 +402,8 @@ class OrFilter : public Filter {
   };
 
   std::vector<Filter *> filters_;
-  bool has_value_{false};
   PhiNode phi_;
+  bool has_value_{false};
 };
 
 class CalibrateLinearFilter : public Filter {

esphome/components/sensor/sensor.cpp

@@ -96,7 +96,6 @@ void Sensor::clear_filters() {
 }
 float Sensor::get_state() const { return this->state; }
 float Sensor::get_raw_state() const { return this->raw_state; }
-std::string Sensor::unique_id() { return ""; }
 
 void Sensor::internal_send_state_to_frontend(float state) {
   this->set_has_state(true);

esphome/components/sensor/sensor.h

@@ -28,9 +28,6 @@ namespace sensor {
     if (!(obj)->get_icon().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \
-    if (!(obj)->unique_id().empty()) { \
-      ESP_LOGV(TAG, "%s  Unique ID: '%s'", prefix, (obj)->unique_id().c_str()); \
-    } \
     if ((obj)->get_force_update()) { \
       ESP_LOGV(TAG, "%s  Force Update: YES", prefix); \
     } \
@@ -141,12 +138,6 @@ class Sensor : public EntityBase, public EntityBase_DeviceClass, public EntityBa
    */
   float raw_state;
 
-  /** Override this method to set the unique ID of this sensor.
-   *
-   * @deprecated Do not use for new sensors, a suitable unique ID is automatically generated (2023.4).
-   */
-  virtual std::string unique_id();
-
   void internal_send_state_to_frontend(float state);
 
  protected:

esphome/components/sfa30/sfa30.cpp

@@ -11,8 +11,6 @@ static const uint16_t SFA30_CMD_START_CONTINUOUS_MEASUREMENTS = 0x0006;
 static const uint16_t SFA30_CMD_READ_MEASUREMENT = 0x0327;
 
 void SFA30Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // Serial Number identification
   uint16_t raw_device_marking[16];
   if (!this->get_register(SFA30_CMD_GET_DEVICE_MARKING, raw_device_marking, 16, 5)) {
@@ -34,8 +32,6 @@ void SFA30Component::setup() {
     this->mark_failed();
     return;
   }
-
-  ESP_LOGD(TAG, "Sensor initialized");
 }
 
 void SFA30Component::dump_config() {

esphome/components/sgp30/sgp30.cpp

@@ -33,8 +33,6 @@ const uint32_t SHORTEST_BASELINE_STORE_INTERVAL = 3600;
 const uint32_t MAXIMUM_STORAGE_DIFF = 50;
 
 void SGP30Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // Serial Number identification
   uint16_t raw_serial_number[3];
   if (!this->get_register(SGP30_CMD_GET_SERIAL_ID, raw_serial_number, 3)) {

esphome/components/sgp4x/sensor.py

@@ -139,7 +139,7 @@ async def to_code(config):
                 )
             )
     cg.add_library(
-        None,
+        "Sensirion Gas Index Algorithm",
         None,
         "https://github.com/Sensirion/arduino-gas-index-algorithm.git#3.2.1",
     )

esphome/components/sgp4x/sgp4x.cpp

@@ -9,8 +9,6 @@ namespace sgp4x {
 static const char *const TAG = "sgp4x";
 
 void SGP4xComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // Serial Number identification
   uint16_t raw_serial_number[3];
   if (!this->get_register(SGP4X_CMD_GET_SERIAL_ID, raw_serial_number, 3, 1)) {

esphome/components/shelly_dimmer/shelly_dimmer.cpp

@@ -101,8 +101,6 @@ void ShellyDimmer::setup() {
   this->pin_nrst_->setup();
   this->pin_boot0_->setup();
 
-  ESP_LOGI(TAG, "Initializing");
-
   this->handle_firmware();
 
   this->send_settings_();

esphome/components/sht3xd/sht3xd.cpp

@@ -25,7 +25,6 @@ static const uint16_t SHT3XD_COMMAND_POLLING_H = 0x2400;
 static const uint16_t SHT3XD_COMMAND_FETCH_DATA = 0xE000;
 
 void SHT3XDComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   uint16_t raw_serial_number[2];
   if (!this->get_register(SHT3XD_COMMAND_READ_SERIAL_NUMBER_CLOCK_STRETCHING, raw_serial_number, 2)) {
     this->error_code_ = READ_SERIAL_STRETCHED_FAILED;
@@ -61,7 +60,6 @@ void SHT3XDComponent::dump_config() {
     ESP_LOGE(TAG, "  Communication with SHT3xD failed!");
     return;
   }
-  ESP_LOGD(TAG, "  Setup successful");
   ESP_LOGD(TAG, "  Serial Number: 0x%08" PRIX32, this->serial_number_);
   ESP_LOGD(TAG, "  Heater Enabled: %s", this->heater_enabled_ ? "true" : "false");
 

esphome/components/sht4x/sht4x.cpp

@@ -18,8 +18,6 @@ void SHT4XComponent::start_heater_() {
 }
 
 void SHT4XComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   auto err = this->write(nullptr, 0);
   if (err != i2c::ERROR_OK) {
     this->mark_failed();

esphome/components/shtcx/shtcx.cpp

@@ -25,7 +25,6 @@ inline const char *to_string(SHTCXType type) {
 }
 
 void SHTCXComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->wake_up();
   this->soft_reset();
 

esphome/components/sim800l/__init__.py

@@ -171,8 +171,7 @@ async def sim800l_dial_to_code(config, action_id, template_arg, args):
 )
 async def sim800l_connect_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 SIM800L_SEND_USSD_SCHEMA = cv.Schema(
@@ -201,5 +200,4 @@ async def sim800l_send_ussd_to_code(config, action_id, template_arg, args):
 )
 async def sim800l_disconnect_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_arg, paren)

esphome/components/sm16716/sm16716.cpp

@@ -7,7 +7,6 @@ namespace sm16716 {
 static const char *const TAG = "sm16716";
 
 void SM16716::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(false);
   this->clock_pin_->setup();

esphome/components/sm2135/sm2135.cpp

@@ -20,7 +20,6 @@ static const uint8_t SM2135_RGB = 0x00;  // RGB channel
 static const uint8_t SM2135_CW = 0x80;   // CW channel (Chip default)
 
 void SM2135::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(false);
   this->data_pin_->pin_mode(gpio::FLAG_OUTPUT);

esphome/components/sm2235/sm2235.cpp

@@ -7,7 +7,6 @@ namespace sm2235 {
 static const char *const TAG = "sm2235";
 
 void SM2235::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(true);
   this->clock_pin_->setup();

esphome/components/sm2335/sm2335.cpp

@@ -7,7 +7,6 @@ namespace sm2335 {
 static const char *const TAG = "sm2335";
 
 void SM2335::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(true);
   this->clock_pin_->setup();

esphome/components/sn74hc165/sn74hc165.cpp

@@ -7,7 +7,6 @@ namespace sn74hc165 {
 static const char *const TAG = "sn74hc165";
 
 void SN74HC165Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   // initialize pins
   this->clock_pin_->setup();
   this->data_pin_->setup();

esphome/components/sn74hc595/sn74hc595.cpp

@@ -8,7 +8,6 @@ namespace sn74hc595 {
 static const char *const TAG = "sn74hc595";
 
 void SN74HC595Component::pre_setup_() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->have_oe_pin_) {  // disable output
     this->oe_pin_->setup();
     this->oe_pin_->digital_write(true);

esphome/components/sntp/sntp_component.cpp

@@ -15,7 +15,6 @@ namespace sntp {
 static const char *const TAG = "sntp";
 
 void SNTPComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
 #if defined(USE_ESP32)
   if (esp_sntp_enabled()) {
     esp_sntp_stop();

esphome/components/sound_level/sensor.py

@@ -12,7 +12,7 @@ from esphome.const import (
     UNIT_DECIBEL,
 )
 
-AUTOLOAD = ["audio"]
+AUTO_LOAD = ["audio"]
 CODEOWNERS = ["@kahrendt"]
 DEPENDENCIES = ["microphone"]
 

esphome/components/speaker/media_player/__init__.py

@@ -155,8 +155,7 @@ def _read_audio_file_and_type(file_config):
     import puremagic
 
     file_type: str = puremagic.from_string(data)
-    if file_type.startswith("."):
-        file_type = file_type[1:]
+    file_type = file_type.removeprefix(".")
 
     media_file_type = audio.AUDIO_FILE_TYPE_ENUM["NONE"]
     if file_type in ("wav"):
@@ -204,13 +203,14 @@ def _validate_pipeline(config):
 
 
 def _validate_repeated_speaker(config):
-    if (announcement_config := config.get(CONF_ANNOUNCEMENT_PIPELINE)) and (
-        media_config := config.get(CONF_MEDIA_PIPELINE)
+    if (
+        (announcement_config := config.get(CONF_ANNOUNCEMENT_PIPELINE))
+        and (media_config := config.get(CONF_MEDIA_PIPELINE))
+        and announcement_config[CONF_SPEAKER] == media_config[CONF_SPEAKER]
     ):
-        if announcement_config[CONF_SPEAKER] == media_config[CONF_SPEAKER]:
-            raise cv.Invalid(
-                "The announcement and media pipelines cannot use the same speaker. Use the `mixer` speaker component to create two source speakers."
-            )
+        raise cv.Invalid(
+            "The announcement and media pipelines cannot use the same speaker. Use the `mixer` speaker component to create two source speakers."
+        )
 
     return config
 
@@ -315,31 +315,19 @@ async def to_code(config):
         cg.add_define("USE_AUDIO_FLAC_SUPPORT", True)
         cg.add_define("USE_AUDIO_MP3_SUPPORT", True)
 
-        # Wifi settings based on https://github.com/espressif/esp-adf/issues/297#issuecomment-783811702
-        esp32.add_idf_sdkconfig_option("CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM", 16)
-        esp32.add_idf_sdkconfig_option("CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM", 512)
-        esp32.add_idf_sdkconfig_option("CONFIG_ESP32_WIFI_STATIC_TX_BUFFER", True)
-        esp32.add_idf_sdkconfig_option("CONFIG_ESP32_WIFI_TX_BUFFER_TYPE", 0)
-        esp32.add_idf_sdkconfig_option("CONFIG_ESP32_WIFI_STATIC_TX_BUFFER_NUM", 8)
-        esp32.add_idf_sdkconfig_option("CONFIG_ESP32_WIFI_CACHE_TX_BUFFER_NUM", 32)
-        esp32.add_idf_sdkconfig_option("CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED", True)
-        esp32.add_idf_sdkconfig_option("CONFIG_ESP32_WIFI_TX_BA_WIN", 16)
-        esp32.add_idf_sdkconfig_option("CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED", True)
-        esp32.add_idf_sdkconfig_option("CONFIG_ESP32_WIFI_RX_BA_WIN", 32)
-        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_MAX_ACTIVE_TCP", 16)
-        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_MAX_LISTENING_TCP", 16)
-        esp32.add_idf_sdkconfig_option("CONFIG_TCP_MAXRTX", 12)
-        esp32.add_idf_sdkconfig_option("CONFIG_TCP_SYNMAXRTX", 6)
-        esp32.add_idf_sdkconfig_option("CONFIG_TCP_MSS", 1436)
-        esp32.add_idf_sdkconfig_option("CONFIG_TCP_MSL", 60000)
-        esp32.add_idf_sdkconfig_option("CONFIG_TCP_SND_BUF_DEFAULT", 65535)
-        esp32.add_idf_sdkconfig_option("CONFIG_TCP_WND_DEFAULT", 512000)
-        esp32.add_idf_sdkconfig_option("CONFIG_TCP_RECVMBOX_SIZE", 512)
-        esp32.add_idf_sdkconfig_option("CONFIG_TCP_QUEUE_OOSEQ", True)
-        esp32.add_idf_sdkconfig_option("CONFIG_TCP_OVERSIZE_MSS", True)
-        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_WND_SCALE", True)
-        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCP_RCV_SCALE", 3)
-        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_RECVMBOX_SIZE", 512)
+        # Based on https://github.com/espressif/esp-idf/blob/release/v5.4/examples/wifi/iperf/sdkconfig.defaults.esp32
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM", 16)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM", 64)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER_NUM", 64)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_AMPDU_TX_ENABLED", True)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_TX_BA_WIN", 32)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_AMPDU_RX_ENABLED", True)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_RX_BA_WIN", 32)
+
+        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCP_SND_BUF_DEFAULT", 65534)
+        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCP_WND_DEFAULT", 65534)
+        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCP_RECVMBOX_SIZE", 64)
+        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_RECVMBOX_SIZE", 64)
 
         # Allocate wifi buffers in PSRAM
         esp32.add_idf_sdkconfig_option("CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP", True)

esphome/components/speaker/media_player/audio_pipeline.cpp

@@ -259,13 +259,10 @@ esp_err_t AudioPipeline::allocate_communications_() {
 esp_err_t AudioPipeline::start_tasks_() {
   if (this->read_task_handle_ == nullptr) {
     if (this->read_task_stack_buffer_ == nullptr) {
-      if (this->task_stack_in_psram_) {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
-        this->read_task_stack_buffer_ = stack_allocator.allocate(READ_TASK_STACK_SIZE);
-      } else {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-        this->read_task_stack_buffer_ = stack_allocator.allocate(READ_TASK_STACK_SIZE);
-      }
+      // Reader task uses the AudioReader class which uses esp_http_client. This crashes on IDF 5.4 if the task stack is
+      // in PSRAM. As a workaround, always allocate the read task in internal memory.
+      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
+      this->read_task_stack_buffer_ = stack_allocator.allocate(READ_TASK_STACK_SIZE);
     }
 
     if (this->read_task_stack_buffer_ == nullptr) {