esphome 2025.6.2__py3-none-any.whl → 2025.7.0__py3-none-any.whl

esphome/components/remote_receiver/remote_receiver_esp32.cpp

@@ -14,7 +14,6 @@ static const uint32_t RMT_CLK_FREQ = 32000000;
 static const uint32_t RMT_CLK_FREQ = 80000000;
 #endif
 
-#if ESP_IDF_VERSION_MAJOR >= 5
 static bool IRAM_ATTR HOT rmt_callback(rmt_channel_handle_t channel, const rmt_rx_done_event_data_t *event, void *arg) {
   RemoteReceiverComponentStore *store = (RemoteReceiverComponentStore *) arg;
   rmt_rx_done_event_data_t *event_buffer = (rmt_rx_done_event_data_t *) (store->buffer + store->buffer_write);
@@ -37,11 +36,9 @@ static bool IRAM_ATTR HOT rmt_callback(rmt_channel_handle_t channel, const rmt_r
   store->buffer_write = next_write;
   return false;
 }
-#endif
 
 void RemoteReceiverComponent::setup() {
   ESP_LOGCONFIG(TAG, "Running setup");
-#if ESP_IDF_VERSION_MAJOR >= 5
   rmt_rx_channel_config_t channel;
   memset(&channel, 0, sizeof(channel));
   channel.clk_src = RMT_CLK_SRC_DEFAULT;
@@ -105,62 +102,11 @@ void RemoteReceiverComponent::setup() {
     this->mark_failed();
     return;
   }
-#else
-  this->pin_->setup();
-  rmt_config_t rmt{};
-  this->config_rmt(rmt);
-  rmt.gpio_num = gpio_num_t(this->pin_->get_pin());
-  rmt.rmt_mode = RMT_MODE_RX;
-  if (this->filter_us_ == 0) {
-    rmt.rx_config.filter_en = false;
-  } else {
-    rmt.rx_config.filter_en = true;
-    rmt.rx_config.filter_ticks_thresh = static_cast<uint8_t>(
-        std::min(this->from_microseconds_(this->filter_us_) * this->clock_divider_, (uint32_t) 255));
-  }
-  rmt.rx_config.idle_threshold =
-      static_cast<uint16_t>(std::min(this->from_microseconds_(this->idle_us_), (uint32_t) 65535));
-
-  esp_err_t error = rmt_config(&rmt);
-  if (error != ESP_OK) {
-    this->error_code_ = error;
-    this->error_string_ = "in rmt_config";
-    this->mark_failed();
-    return;
-  }
-
-  error = rmt_driver_install(this->channel_, this->buffer_size_, 0);
-  if (error != ESP_OK) {
-    this->error_code_ = error;
-    if (error == ESP_ERR_INVALID_STATE) {
-      this->error_string_ = str_sprintf("RMT channel %i is already in use by another component", this->channel_);
-    } else {
-      this->error_string_ = "in rmt_driver_install";
-    }
-    this->mark_failed();
-    return;
-  }
-  error = rmt_get_ringbuf_handle(this->channel_, &this->ringbuf_);
-  if (error != ESP_OK) {
-    this->error_code_ = error;
-    this->error_string_ = "in rmt_get_ringbuf_handle";
-    this->mark_failed();
-    return;
-  }
-  error = rmt_rx_start(this->channel_, true);
-  if (error != ESP_OK) {
-    this->error_code_ = error;
-    this->error_string_ = "in rmt_rx_start";
-    this->mark_failed();
-    return;
-  }
-#endif
 }
 
 void RemoteReceiverComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "Remote Receiver:");
   LOG_PIN("  Pin: ", this->pin_);
-#if ESP_IDF_VERSION_MAJOR >= 5
   ESP_LOGCONFIG(TAG,
                 "  Clock resolution: %" PRIu32 " hz\n"
                 "  RMT symbols: %" PRIu32 "\n"
@@ -172,22 +118,6 @@ void RemoteReceiverComponent::dump_config() {
                 this->clock_resolution_, this->rmt_symbols_, this->filter_symbols_, this->receive_symbols_,
                 this->tolerance_, (this->tolerance_mode_ == remote_base::TOLERANCE_MODE_TIME) ? " us" : "%",
                 this->filter_us_, this->idle_us_);
-#else
-  if (this->pin_->digital_read()) {
-    ESP_LOGW(TAG, "Remote Receiver Signal starts with a HIGH value. Usually this means you have to "
-                  "invert the signal using 'inverted: True' in the pin schema!");
-  }
-  ESP_LOGCONFIG(TAG,
-                "  Channel: %d\n"
-                "  RMT memory blocks: %d\n"
-                "  Clock divider: %u\n"
-                "  Tolerance: %" PRIu32 "%s\n"
-                "  Filter out pulses shorter than: %" PRIu32 " us\n"
-                "  Signal is done after %" PRIu32 " us of no changes",
-                this->channel_, this->mem_block_num_, this->clock_divider_, this->tolerance_,
-                (this->tolerance_mode_ == remote_base::TOLERANCE_MODE_TIME) ? " us" : "%", this->filter_us_,
-                this->idle_us_);
-#endif
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Configuring RMT driver failed: %s (%s)", esp_err_to_name(this->error_code_),
              this->error_string_.c_str());
@@ -195,7 +125,6 @@ void RemoteReceiverComponent::dump_config() {
 }
 
 void RemoteReceiverComponent::loop() {
-#if ESP_IDF_VERSION_MAJOR >= 5
   if (this->store_.error != ESP_OK) {
     ESP_LOGE(TAG, "Receive error");
     this->error_code_ = this->store_.error;
@@ -221,25 +150,9 @@ void RemoteReceiverComponent::loop() {
       this->call_listeners_dumpers_();
     }
   }
-#else
-  size_t len = 0;
-  auto *item = (rmt_item32_t *) xRingbufferReceive(this->ringbuf_, &len, 0);
-  if (item != nullptr) {
-    this->decode_rmt_(item, len / sizeof(rmt_item32_t));
-    vRingbufferReturnItem(this->ringbuf_, item);
-
-    if (!this->temp_.empty()) {
-      this->call_listeners_dumpers_();
-    }
-  }
-#endif
 }
 
-#if ESP_IDF_VERSION_MAJOR >= 5
 void RemoteReceiverComponent::decode_rmt_(rmt_symbol_word_t *item, size_t item_count) {
-#else
-void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count) {
-#endif
   bool prev_level = false;
   bool idle_level = false;
   uint32_t prev_length = 0;

esphome/components/remote_receiver/remote_receiver_esp8266.cpp

@@ -27,7 +27,7 @@ void IRAM_ATTR HOT RemoteReceiverComponentStore::gpio_intr(RemoteReceiverCompone
   if (time_since_change <= arg->filter_us)
     return;
 
-  arg->buffer[arg->buffer_write_at = next] = now;
+  arg->buffer[arg->buffer_write_at = next] = now;  // NOLINT(clang-diagnostic-deprecated-volatile)
 }
 
 void RemoteReceiverComponent::setup() {

esphome/components/remote_transmitter/__init__.py

@@ -1,19 +1,19 @@
 from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import esp32, esp32_rmt, remote_base
+from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CARRIER_DUTY_PERCENT,
-    CONF_CLOCK_DIVIDER,
     CONF_CLOCK_RESOLUTION,
     CONF_ID,
     CONF_INVERTED,
     CONF_MODE,
     CONF_OPEN_DRAIN,
     CONF_PIN,
-    CONF_RMT_CHANNEL,
     CONF_RMT_SYMBOLS,
     CONF_USE_DMA,
+    PlatformFramework,
 )
 from esphome.core import CORE
 
@@ -38,34 +38,26 @@ CONFIG_SCHEMA = cv.Schema(
         ),
         cv.Optional(CONF_CLOCK_RESOLUTION): cv.All(
             cv.only_on_esp32,
-            cv.only_with_esp_idf,
             esp32_rmt.validate_clock_resolution(),
         ),
-        cv.Optional(CONF_CLOCK_DIVIDER): cv.All(
-            cv.only_on_esp32, cv.only_with_arduino, cv.int_range(min=1, max=255)
-        ),
-        cv.Optional(CONF_EOT_LEVEL): cv.All(cv.only_with_esp_idf, cv.boolean),
+        cv.Optional(CONF_EOT_LEVEL): cv.All(cv.only_on_esp32, cv.boolean),
         cv.Optional(CONF_USE_DMA): cv.All(
             esp32.only_on_variant(
                 supported=[esp32.const.VARIANT_ESP32S3, esp32.const.VARIANT_ESP32P4]
             ),
-            cv.only_with_esp_idf,
             cv.boolean,
         ),
         cv.SplitDefault(
             CONF_RMT_SYMBOLS,
-            esp32_idf=64,
-            esp32_s2_idf=64,
-            esp32_s3_idf=48,
-            esp32_p4_idf=48,
-            esp32_c3_idf=48,
-            esp32_c5_idf=48,
-            esp32_c6_idf=48,
-            esp32_h2_idf=48,
-        ): cv.All(cv.only_with_esp_idf, cv.int_range(min=2)),
-        cv.Optional(CONF_RMT_CHANNEL): cv.All(
-            cv.only_with_arduino, esp32_rmt.validate_rmt_channel(tx=True)
-        ),
+            esp32=64,
+            esp32_s2=64,
+            esp32_s3=48,
+            esp32_p4=48,
+            esp32_c3=48,
+            esp32_c5=48,
+            esp32_c6=48,
+            esp32_h2=48,
+        ): cv.All(cv.only_on_esp32, cv.int_range(min=2)),
         cv.Optional(CONF_ON_TRANSMIT): automation.validate_automation(single=True),
         cv.Optional(CONF_ON_COMPLETE): automation.validate_automation(single=True),
     }
@@ -75,30 +67,21 @@ CONFIG_SCHEMA = cv.Schema(
 async def to_code(config):
     pin = await cg.gpio_pin_expression(config[CONF_PIN])
     if CORE.is_esp32:
-        if esp32_rmt.use_new_rmt_driver():
-            var = cg.new_Pvariable(config[CONF_ID], pin)
-            cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
-            if CONF_CLOCK_RESOLUTION in config:
-                cg.add(var.set_clock_resolution(config[CONF_CLOCK_RESOLUTION]))
-            if CONF_USE_DMA in config:
-                cg.add(var.set_with_dma(config[CONF_USE_DMA]))
-            if CONF_EOT_LEVEL in config:
-                cg.add(var.set_eot_level(config[CONF_EOT_LEVEL]))
-            else:
-                cg.add(
-                    var.set_eot_level(
-                        config[CONF_PIN][CONF_MODE][CONF_OPEN_DRAIN]
-                        or config[CONF_PIN][CONF_INVERTED]
-                    )
-                )
+        var = cg.new_Pvariable(config[CONF_ID], pin)
+        cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
+        if CONF_CLOCK_RESOLUTION in config:
+            cg.add(var.set_clock_resolution(config[CONF_CLOCK_RESOLUTION]))
+        if CONF_USE_DMA in config:
+            cg.add(var.set_with_dma(config[CONF_USE_DMA]))
+        if CONF_EOT_LEVEL in config:
+            cg.add(var.set_eot_level(config[CONF_EOT_LEVEL]))
         else:
-            if (rmt_channel := config.get(CONF_RMT_CHANNEL, None)) is not None:
-                var = cg.new_Pvariable(config[CONF_ID], pin, rmt_channel)
-            else:
-                var = cg.new_Pvariable(config[CONF_ID], pin)
-            if CONF_CLOCK_DIVIDER in config:
-                cg.add(var.set_clock_divider(config[CONF_CLOCK_DIVIDER]))
-
+            cg.add(
+                var.set_eot_level(
+                    config[CONF_PIN][CONF_MODE][CONF_OPEN_DRAIN]
+                    or config[CONF_PIN][CONF_INVERTED]
+                )
+            )
     else:
         var = cg.new_Pvariable(config[CONF_ID], pin)
     await cg.register_component(var, config)
@@ -114,3 +97,19 @@ async def to_code(config):
         await automation.build_automation(
             var.get_complete_trigger(), [], on_complete_config
         )
+
+
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "remote_transmitter_esp32.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
+        },
+        "remote_transmitter_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
+        "remote_transmitter_libretiny.cpp": {
+            PlatformFramework.BK72XX_ARDUINO,
+            PlatformFramework.RTL87XX_ARDUINO,
+            PlatformFramework.LN882X_ARDUINO,
+        },
+    }
+)

esphome/components/remote_transmitter/remote_transmitter.h

@@ -5,7 +5,7 @@
 
 #include <vector>
 
-#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR >= 5
+#if defined(USE_ESP32)
 #include <driver/rmt_tx.h>
 #endif
 
@@ -20,15 +20,7 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
 #endif
 {
  public:
-#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR < 5
-  RemoteTransmitterComponent(InternalGPIOPin *pin, uint8_t mem_block_num = 1)
-      : remote_base::RemoteTransmitterBase(pin), remote_base::RemoteRMTChannel(mem_block_num) {}
-
-  RemoteTransmitterComponent(InternalGPIOPin *pin, rmt_channel_t channel, uint8_t mem_block_num = 1)
-      : remote_base::RemoteTransmitterBase(pin), remote_base::RemoteRMTChannel(channel, mem_block_num) {}
-#else
   explicit RemoteTransmitterComponent(InternalGPIOPin *pin) : remote_base::RemoteTransmitterBase(pin) {}
-#endif
   void setup() override;
 
   void dump_config() override;
@@ -38,7 +30,7 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
 
   void set_carrier_duty_percent(uint8_t carrier_duty_percent) { this->carrier_duty_percent_ = carrier_duty_percent; }
 
-#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR >= 5
+#if defined(USE_ESP32)
   void set_with_dma(bool with_dma) { this->with_dma_ = with_dma; }
   void set_eot_level(bool eot_level) { this->eot_level_ = eot_level; }
   void digital_write(bool value);
@@ -65,15 +57,11 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
 
   uint32_t current_carrier_frequency_{38000};
   bool initialized_{false};
-#if ESP_IDF_VERSION_MAJOR >= 5
   std::vector<rmt_symbol_word_t> rmt_temp_;
   bool with_dma_{false};
   bool eot_level_{false};
   rmt_channel_handle_t channel_{NULL};
   rmt_encoder_handle_t encoder_{NULL};
-#else
-  std::vector<rmt_item32_t> rmt_temp_;
-#endif
   esp_err_t error_code_{ESP_OK};
   std::string error_string_{""};
   bool inverted_{false};

esphome/components/remote_transmitter/remote_transmitter_esp32.cpp

@@ -18,18 +18,10 @@ void RemoteTransmitterComponent::setup() {
 
 void RemoteTransmitterComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "Remote Transmitter:");
-#if ESP_IDF_VERSION_MAJOR >= 5
   ESP_LOGCONFIG(TAG,
                 "  Clock resolution: %" PRIu32 " hz\n"
                 "  RMT symbols: %" PRIu32,
                 this->clock_resolution_, this->rmt_symbols_);
-#else
-  ESP_LOGCONFIG(TAG,
-                "  Channel: %d\n"
-                "  RMT memory blocks: %d\n"
-                "  Clock divider: %u",
-                this->channel_, this->mem_block_num_, this->clock_divider_);
-#endif
   LOG_PIN("  Pin: ", this->pin_);
 
   if (this->current_carrier_frequency_ != 0 && this->carrier_duty_percent_ != 100) {
@@ -42,7 +34,6 @@ void RemoteTransmitterComponent::dump_config() {
   }
 }
 
-#if ESP_IDF_VERSION_MAJOR >= 5
 void RemoteTransmitterComponent::digital_write(bool value) {
   rmt_symbol_word_t symbol = {
       .duration0 = 1,
@@ -65,10 +56,8 @@ void RemoteTransmitterComponent::digital_write(bool value) {
     this->status_set_warning();
   }
 }
-#endif
 
 void RemoteTransmitterComponent::configure_rmt_() {
-#if ESP_IDF_VERSION_MAJOR >= 5
   esp_err_t error;
 
   if (!this->initialized_) {
@@ -140,54 +129,6 @@ void RemoteTransmitterComponent::configure_rmt_() {
     this->mark_failed();
     return;
   }
-#else
-  rmt_config_t c{};
-
-  this->config_rmt(c);
-  c.rmt_mode = RMT_MODE_TX;
-  c.gpio_num = gpio_num_t(this->pin_->get_pin());
-  c.tx_config.loop_en = false;
-
-  if (this->current_carrier_frequency_ == 0 || this->carrier_duty_percent_ == 100) {
-    c.tx_config.carrier_en = false;
-  } else {
-    c.tx_config.carrier_en = true;
-    c.tx_config.carrier_freq_hz = this->current_carrier_frequency_;
-    c.tx_config.carrier_duty_percent = this->carrier_duty_percent_;
-  }
-
-  c.tx_config.idle_output_en = true;
-  if (!this->inverted_) {
-    c.tx_config.carrier_level = RMT_CARRIER_LEVEL_HIGH;
-    c.tx_config.idle_level = RMT_IDLE_LEVEL_LOW;
-  } else {
-    c.tx_config.carrier_level = RMT_CARRIER_LEVEL_LOW;
-    c.tx_config.idle_level = RMT_IDLE_LEVEL_HIGH;
-  }
-
-  esp_err_t error = rmt_config(&c);
-  if (error != ESP_OK) {
-    this->error_code_ = error;
-    this->error_string_ = "in rmt_config";
-    this->mark_failed();
-    return;
-  }
-
-  if (!this->initialized_) {
-    error = rmt_driver_install(this->channel_, 0, 0);
-    if (error != ESP_OK) {
-      this->error_code_ = error;
-      if (error == ESP_ERR_INVALID_STATE) {
-        this->error_string_ = str_sprintf("RMT channel %i is already in use by another component", this->channel_);
-      } else {
-        this->error_string_ = "in rmt_driver_install";
-      }
-      this->mark_failed();
-      return;
-    }
-    this->initialized_ = true;
-  }
-#endif
 }
 
 void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t send_wait) {
@@ -202,11 +143,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
   this->rmt_temp_.clear();
   this->rmt_temp_.reserve((this->temp_.get_data().size() + 1) / 2);
   uint32_t rmt_i = 0;
-#if ESP_IDF_VERSION_MAJOR >= 5
   rmt_symbol_word_t rmt_item;
-#else
-  rmt_item32_t rmt_item;
-#endif
 
   for (int32_t val : this->temp_.get_data()) {
     bool level = val >= 0;
@@ -241,7 +178,6 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     return;
   }
   this->transmit_trigger_->trigger();
-#if ESP_IDF_VERSION_MAJOR >= 5
   for (uint32_t i = 0; i < send_times; i++) {
     rmt_transmit_config_t config;
     memset(&config, 0, sizeof(config));
@@ -263,19 +199,6 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     if (i + 1 < send_times)
       delayMicroseconds(send_wait);
   }
-#else
-  for (uint32_t i = 0; i < send_times; i++) {
-    esp_err_t error = rmt_write_items(this->channel_, this->rmt_temp_.data(), this->rmt_temp_.size(), true);
-    if (error != ESP_OK) {
-      ESP_LOGW(TAG, "rmt_write_items failed: %s", esp_err_to_name(error));
-      this->status_set_warning();
-    } else {
-      this->status_clear_warning();
-    }
-    if (i + 1 < send_times)
-      delayMicroseconds(send_wait);
-  }
-#endif
   this->complete_trigger_->trigger();
 }
 

esphome/components/resistance/resistance_sensor.h

@@ -24,7 +24,6 @@ class ResistanceSensor : public Component, public sensor::Sensor {
       this->process_(this->sensor_->state);
   }
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
  protected:
   void process_(float value);

esphome/components/rp2040/__init__.py

@@ -165,8 +165,10 @@ async def to_code(config):
     # Allow LDF to properly discover dependency including those in preprocessor
     # conditionals
     cg.add_platformio_option("lib_ldf_mode", "chain+")
+    cg.add_platformio_option("lib_compat_mode", "strict")
     cg.add_platformio_option("board", config[CONF_BOARD])
     cg.add_build_flag("-DUSE_RP2040")
+    cg.set_cpp_standard("gnu++20")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
     cg.add_define("ESPHOME_VARIANT", "RP2040")
 

esphome/components/rp2040/helpers.cpp

@@ -0,0 +1,55 @@
+#include "esphome/core/helpers.h"
+#include "esphome/core/defines.h"
+
+#ifdef USE_RP2040
+
+#include "esphome/core/hal.h"
+
+#if defined(USE_WIFI)
+#include <WiFi.h>
+#endif
+#include <hardware/structs/rosc.h>
+#include <hardware/sync.h>
+
+namespace esphome {
+
+uint32_t random_uint32() {
+  uint32_t result = 0;
+  for (uint8_t i = 0; i < 32; i++) {
+    result <<= 1;
+    result |= rosc_hw->randombit;
+  }
+  return result;
+}
+
+bool random_bytes(uint8_t *data, size_t len) {
+  while (len-- != 0) {
+    uint8_t result = 0;
+    for (uint8_t i = 0; i < 8; i++) {
+      result <<= 1;
+      result |= rosc_hw->randombit;
+    }
+    *data++ = result;
+  }
+  return true;
+}
+
+// RP2040 doesn't have mutexes, but that shouldn't be an issue as it's single-core and non-preemptive OS.
+Mutex::Mutex() {}
+Mutex::~Mutex() {}
+void Mutex::lock() {}
+bool Mutex::try_lock() { return true; }
+void Mutex::unlock() {}
+
+IRAM_ATTR InterruptLock::InterruptLock() { state_ = save_and_disable_interrupts(); }
+IRAM_ATTR InterruptLock::~InterruptLock() { restore_interrupts(state_); }
+
+void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
+#ifdef USE_WIFI
+  WiFi.macAddress(mac);
+#endif
+}
+
+}  // namespace esphome
+
+#endif  // USE_RP2040

esphome/components/rp2040_pio_led_strip/led_strip.cpp

@@ -9,8 +9,8 @@
 #include <hardware/dma.h>
 #include <hardware/irq.h>
 #include <hardware/pio.h>
-#include <pico/stdlib.h>
 #include <pico/sem.h>
+#include <pico/stdlib.h>
 
 namespace esphome {
 namespace rp2040_pio_led_strip {
@@ -44,7 +44,7 @@ void RP2040PIOLEDStripLightOutput::setup() {
 
   size_t buffer_size = this->get_buffer_size_();
 
-  ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+  RAMAllocator<uint8_t> allocator;
   this->buf_ = allocator.allocate(buffer_size);
   if (this->buf_ == nullptr) {
     ESP_LOGE(TAG, "Failed to allocate buffer of size %u", buffer_size);

esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp

@@ -10,10 +10,8 @@ void RpiDpiRgb::setup() {
   this->reset_display_();
   esp_lcd_rgb_panel_config_t config{};
   config.flags.fb_in_psram = 1;
-#if ESP_IDF_VERSION_MAJOR >= 5
   config.bounce_buffer_size_px = this->width_ * 10;
   config.num_fbs = 1;
-#endif  // ESP_IDF_VERSION_MAJOR
   config.timings.h_res = this->width_;
   config.timings.v_res = this->height_;
   config.timings.hsync_pulse_width = this->hsync_pulse_width_;
@@ -47,10 +45,8 @@ void RpiDpiRgb::setup() {
   ESP_LOGCONFIG(TAG, "RPI_DPI_RGB setup complete");
 }
 void RpiDpiRgb::loop() {
-#if ESP_IDF_VERSION_MAJOR >= 5
   if (this->handle_ != nullptr)
     esp_lcd_rgb_panel_restart(this->handle_);
-#endif  // ESP_IDF_VERSION_MAJOR
 }
 
 void RpiDpiRgb::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,

esphome/components/rtttl/__init__.py

@@ -57,14 +57,14 @@ def validate_parent_output_config(value):
     platform = value.get(CONF_PLATFORM)
     PWM_GOOD = ["esp8266_pwm", "ledc"]
     PWM_BAD = [
-        "ac_dimmer ",
+        "ac_dimmer",
         "esp32_dac",
-        "slow_pwm",
         "mcp4725",
-        "pca9685",
-        "tlc59208f",
         "my9231",
+        "pca9685",
+        "slow_pwm",
         "sm16716",
+        "tlc59208f",
     ]
 
     if platform in PWM_BAD:

esphome/components/rtttl/rtttl.cpp

@@ -142,8 +142,10 @@ void Rtttl::stop() {
 }
 
 void Rtttl::loop() {
-  if (this->note_duration_ == 0 || this->state_ == State::STATE_STOPPED)
+  if (this->note_duration_ == 0 || this->state_ == State::STATE_STOPPED) {
+    this->disable_loop();
     return;
+  }
 
 #ifdef USE_SPEAKER
   if (this->speaker_ != nullptr) {
@@ -369,6 +371,7 @@ void Rtttl::finish_() {
   ESP_LOGD(TAG, "Playback finished");
 }
 
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
 static const LogString *state_to_string(State state) {
   switch (state) {
     case STATE_STOPPED:
@@ -385,12 +388,18 @@ static const LogString *state_to_string(State state) {
       return LOG_STR("UNKNOWN");
   }
 };
+#endif
 
 void Rtttl::set_state_(State state) {
   State old_state = this->state_;
   this->state_ = state;
   ESP_LOGV(TAG, "State changed from %s to %s", LOG_STR_ARG(state_to_string(old_state)),
            LOG_STR_ARG(state_to_string(state)));
+
+  // Clear loop_done when transitioning from STOPPED to any other state
+  if (old_state == State::STATE_STOPPED && state != State::STATE_STOPPED) {
+    this->enable_loop();
+  }
 }
 
 }  // namespace rtttl

esphome/components/ruuvitag/ruuvitag.h

@@ -48,7 +48,6 @@ class RuuviTag : public Component, public esp32_ble_tracker::ESPBTDeviceListener
   }
 
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void set_humidity(sensor::Sensor *humidity) { humidity_ = humidity; }
   void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
   void set_pressure(sensor::Sensor *pressure) { pressure_ = pressure; }

esphome/components/safe_mode/safe_mode.cpp

@@ -42,6 +42,8 @@ void SafeModeComponent::loop() {
     ESP_LOGI(TAG, "Boot seems successful; resetting boot loop counter");
     this->clean_rtc();
     this->boot_successful_ = true;
+    // Disable loop since we no longer need to check
+    this->disable_loop();
   }
 }
 

esphome/components/safe_mode/safe_mode.h

@@ -33,12 +33,15 @@ class SafeModeComponent : public Component {
   void write_rtc_(uint32_t val);
   uint32_t read_rtc_();
 
-  bool boot_successful_{false};                   ///< set to true after boot is considered successful
+  // Group all 4-byte aligned members together to avoid padding
   uint32_t safe_mode_boot_is_good_after_{60000};  ///< The amount of time after which the boot is considered successful
   uint32_t safe_mode_enable_time_{60000};         ///< The time safe mode should remain active for
   uint32_t safe_mode_rtc_value_{0};
   uint32_t safe_mode_start_time_{0};  ///< stores when safe mode was enabled
+  // Group 1-byte members together to minimize padding
+  bool boot_successful_{false};  ///< set to true after boot is considered successful
   uint8_t safe_mode_num_attempts_{0};
+  // Larger objects at the end
   ESPPreferenceObject rtc_;
   CallbackManager<void()> safe_mode_callback_{};
 

esphome/components/scd30/scd30.h

@@ -26,7 +26,6 @@ class SCD30Component : public Component, public sensirion_common::SensirionI2CDe
   void setup() override;
   void update();
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
  protected:
   bool is_data_ready_();