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

esphome/components/pulse_meter/pulse_meter_sensor.cpp

@@ -31,6 +31,10 @@ void PulseMeterSensor::setup() {
     this->pulse_state_.latched_ = this->last_pin_val_;
     this->pin_->attach_interrupt(PulseMeterSensor::pulse_intr, this, gpio::INTERRUPT_ANY_EDGE);
   }
+
+  if (this->total_sensor_ != nullptr) {
+    this->total_sensor_->publish_state(this->total_pulses_);
+  }
 }
 
 void PulseMeterSensor::loop() {
@@ -63,7 +67,7 @@ void PulseMeterSensor::loop() {
   // If an edge was peeked, repay the debt
   if (this->peeked_edge_ && this->get_->count_ > 0) {
     this->peeked_edge_ = false;
-    this->get_->count_--;
+    this->get_->count_--;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // If there is an unprocessed edge, and filter_us_ has passed since, count this edge early
@@ -71,7 +75,7 @@ void PulseMeterSensor::loop() {
       now - this->get_->last_rising_edge_us_ >= this->filter_us_) {
     this->peeked_edge_ = true;
     this->get_->last_detected_edge_us_ = this->get_->last_rising_edge_us_;
-    this->get_->count_++;
+    this->get_->count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // Check if we detected a pulse this loop
@@ -146,7 +150,7 @@ void IRAM_ATTR PulseMeterSensor::edge_intr(PulseMeterSensor *sensor) {
     state.last_sent_edge_us_ = now;
     set.last_detected_edge_us_ = now;
     set.last_rising_edge_us_ = now;
-    set.count_++;
+    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // This ISR is bound to rising edges, so the pin is high
@@ -169,7 +173,7 @@ void IRAM_ATTR PulseMeterSensor::pulse_intr(PulseMeterSensor *sensor) {
   } else if (length && !state.latched_ && sensor->last_pin_val_) {  // Long enough high edge
     state.latched_ = true;
     set.last_detected_edge_us_ = state.last_intr_;
-    set.count_++;
+    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // Due to order of operations this includes

esphome/components/pulse_width/pulse_width.h

@@ -32,7 +32,6 @@ class PulseWidthSensor : public sensor::Sensor, public PollingComponent {
   void set_pin(InternalGPIOPin *pin) { pin_ = pin; }
   void setup() override { this->store_.setup(this->pin_); }
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void update() override;
 
  protected:

esphome/components/pvvx_mithermometer/display/pvvx_display.cpp

@@ -146,11 +146,7 @@ void PVVXDisplay::sync_time_() {
   }
   time.recalc_timestamp_utc(true);  // calculate timestamp of local time
   uint8_t blk[5] = {};
-#if ESP_IDF_VERSION_MAJOR >= 5
   ESP_LOGD(TAG, "[%s] Sync time with timestamp %" PRIu64 ".", this->parent_->address_str().c_str(), time.timestamp);
-#else
-  ESP_LOGD(TAG, "[%s] Sync time with timestamp %lu.", this->parent_->address_str().c_str(), time.timestamp);
-#endif
   blk[0] = 0x23;
   blk[1] = time.timestamp & 0xff;
   blk[2] = (time.timestamp >> 8) & 0xff;

esphome/components/pvvx_mithermometer/display/pvvx_display.h

@@ -39,8 +39,6 @@ class PVVXDisplay : public ble_client::BLEClientNode, public PollingComponent {
 
   void dump_config() override;
 
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
   void update() override;
 
   void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,

esphome/components/pvvx_mithermometer/pvvx_mithermometer.h

@@ -25,7 +25,6 @@ class PVVXMiThermometer : public Component, public esp32_ble_tracker::ESPBTDevic
 
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
   void set_humidity(sensor::Sensor *humidity) { humidity_ = humidity; }
   void set_battery_level(sensor::Sensor *battery_level) { battery_level_ = battery_level; }

esphome/components/qr_code/__init__.py

@@ -21,21 +21,24 @@ ECC = {
     "HIGH": qrcodegen_Ecc.qrcodegen_Ecc_HIGH,
 }
 
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_ID): cv.declare_id(QRCode),
-        cv.Required(CONF_VALUE): cv.string,
-        cv.Optional(CONF_ECC, default="LOW"): cv.enum(ECC, upper=True),
-    }
+CONFIG_SCHEMA = cv.ensure_list(
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.declare_id(QRCode),
+            cv.Required(CONF_VALUE): cv.string,
+            cv.Optional(CONF_ECC, default="LOW"): cv.enum(ECC, upper=True),
+        }
+    )
 )
 
 
 async def to_code(config):
     cg.add_library("wjtje/qr-code-generator-library", "^1.7.0")
 
-    var = cg.new_Pvariable(config[CONF_ID])
-    cg.add(var.set_value(config[CONF_VALUE]))
-    cg.add(var.set_ecc(ECC[config[CONF_ECC]]))
-    await cg.register_component(var, config)
+    for entry in config:
+        var = cg.new_Pvariable(entry[CONF_ID])
+        cg.add(var.set_value(entry[CONF_VALUE]))
+        cg.add(var.set_ecc(ECC[entry[CONF_ECC]]))
+        await cg.register_component(var, entry)
 
     cg.add_define("USE_QR_CODE")

esphome/components/qwiic_pir/qwiic_pir.h

@@ -36,7 +36,6 @@ class QwiicPIRComponent : public Component, public i2c::I2CDevice, public binary
   void loop() override;
 
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   void set_debounce_time(uint16_t debounce_time) { this->debounce_time_ = debounce_time; }
   void set_debounce_mode(DebounceMode mode) { this->debounce_mode_ = mode; }

esphome/components/radon_eye_ble/radon_eye_listener.cpp

@@ -17,7 +17,7 @@ bool RadonEyeListener::parse_device(const esp32_ble_tracker::ESPBTDevice &device
 
     // Check if the device name starts with any of the prefixes
     if (std::any_of(prefixes.begin(), prefixes.end(),
-                    [&](const std::string &prefix) { return device.get_name().rfind(prefix, 0) == 0; })) {
+                    [&](const std::string &prefix) { return device.get_name().starts_with(prefix); })) {
       // Device found
       ESP_LOGD(TAG, "Found Radon Eye device Name: %s (MAC: %s)", device.get_name().c_str(),
                device.address_str().c_str());

esphome/components/rc522/rc522.h

@@ -19,7 +19,6 @@ class RC522 : public PollingComponent {
   void dump_config() override;
 
   void update() override;
-  float get_setup_priority() const override { return setup_priority::DATA; };
 
   void loop() override;
 

esphome/components/rdm6300/rdm6300.h

@@ -21,8 +21,6 @@ class RDM6300Component : public Component, public uart::UARTDevice {
   void register_card(RDM6300BinarySensor *obj) { this->cards_.push_back(obj); }
   void register_trigger(RDM6300Trigger *trig) { this->triggers_.push_back(trig); }
 
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
  protected:
   int8_t read_state_{-1};
   uint8_t buffer_[6]{};

esphome/components/remote_base/__init__.py

@@ -57,7 +57,7 @@ RemoteReceiverBinarySensorBase = ns.class_(
 RemoteReceiverTrigger = ns.class_(
     "RemoteReceiverTrigger", automation.Trigger, RemoteReceiverListener
 )
-RemoteTransmitterDumper = ns.class_("RemoteTransmitterDumper")
+RemoteReceiverDumperBase = ns.class_("RemoteReceiverDumperBase")
 RemoteTransmittable = ns.class_("RemoteTransmittable")
 RemoteTransmitterActionBase = ns.class_(
     "RemoteTransmitterActionBase", RemoteTransmittable, automation.Action
@@ -126,8 +126,10 @@ def register_trigger(name, type, data_type):
     return decorator
 
 
-def register_dumper(name, type):
-    registerer = DUMPER_REGISTRY.register(name, type, {})
+def register_dumper(name, type, schema=None):
+    if schema is None:
+        schema = {}
+    registerer = DUMPER_REGISTRY.register(name, type, schema)
 
     def decorator(func):
         async def new_func(config, dumper_id):
@@ -189,7 +191,7 @@ def declare_protocol(name):
     binary_sensor_ = ns.class_(f"{name}BinarySensor", RemoteReceiverBinarySensorBase)
     trigger = ns.class_(f"{name}Trigger", RemoteReceiverTrigger)
     action = ns.class_(f"{name}Action", RemoteTransmitterActionBase)
-    dumper = ns.class_(f"{name}Dumper", RemoteTransmitterDumper)
+    dumper = ns.class_(f"{name}Dumper", RemoteReceiverDumperBase)
     return data, binary_sensor_, trigger, action, dumper
 
 
@@ -1405,7 +1407,7 @@ rc_switch_protocols = ns.RC_SWITCH_PROTOCOLS
 RCSwitchData = ns.struct("RCSwitchData")
 RCSwitchBase = ns.class_("RCSwitchBase")
 RCSwitchTrigger = ns.class_("RCSwitchTrigger", RemoteReceiverTrigger)
-RCSwitchDumper = ns.class_("RCSwitchDumper", RemoteTransmitterDumper)
+RCSwitchDumper = ns.class_("RCSwitchDumper", RemoteReceiverDumperBase)
 RCSwitchRawAction = ns.class_("RCSwitchRawAction", RemoteTransmitterActionBase)
 RCSwitchTypeAAction = ns.class_("RCSwitchTypeAAction", RemoteTransmitterActionBase)
 RCSwitchTypeBAction = ns.class_("RCSwitchTypeBAction", RemoteTransmitterActionBase)

esphome/components/remote_base/remote_base.cpp

@@ -8,27 +8,6 @@ namespace remote_base {
 
 static const char *const TAG = "remote_base";
 
-#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR < 5
-RemoteRMTChannel::RemoteRMTChannel(uint8_t mem_block_num) : mem_block_num_(mem_block_num) {
-  static rmt_channel_t next_rmt_channel = RMT_CHANNEL_0;
-  this->channel_ = next_rmt_channel;
-  next_rmt_channel = rmt_channel_t(int(next_rmt_channel) + mem_block_num);
-}
-
-RemoteRMTChannel::RemoteRMTChannel(rmt_channel_t channel, uint8_t mem_block_num)
-    : channel_(channel), mem_block_num_(mem_block_num) {}
-
-void RemoteRMTChannel::config_rmt(rmt_config_t &rmt) {
-  if (rmt_channel_t(int(this->channel_) + this->mem_block_num_) > RMT_CHANNEL_MAX) {
-    this->mem_block_num_ = int(RMT_CHANNEL_MAX) - int(this->channel_);
-    ESP_LOGW(TAG, "Not enough RMT memory blocks available, reduced to %i blocks.", this->mem_block_num_);
-  }
-  rmt.channel = this->channel_;
-  rmt.clk_div = this->clock_divider_;
-  rmt.mem_block_num = this->mem_block_num_;
-}
-#endif
-
 /* RemoteReceiveData */
 
 bool RemoteReceiveData::peek_mark(uint32_t length, uint32_t offset) const {
@@ -40,6 +19,22 @@ bool RemoteReceiveData::peek_mark(uint32_t length, uint32_t offset) const {
   return value >= 0 && lo <= value && value <= hi;
 }
 
+bool RemoteReceiveData::peek_mark_at_least(uint32_t length, uint32_t offset) const {
+  if (!this->is_valid(offset))
+    return false;
+  const int32_t value = this->peek(offset);
+  const int32_t lo = this->lower_bound_(length);
+  return value >= 0 && lo <= value;
+}
+
+bool RemoteReceiveData::peek_mark_at_most(uint32_t length, uint32_t offset) const {
+  if (!this->is_valid(offset))
+    return false;
+  const int32_t value = this->peek(offset);
+  const int32_t hi = this->upper_bound_(length);
+  return value >= 0 && value <= hi;
+}
+
 bool RemoteReceiveData::peek_space(uint32_t length, uint32_t offset) const {
   if (!this->is_valid(offset))
     return false;
@@ -57,6 +52,14 @@ bool RemoteReceiveData::peek_space_at_least(uint32_t length, uint32_t offset) co
   return value <= 0 && lo <= -value;
 }
 
+bool RemoteReceiveData::peek_space_at_most(uint32_t length, uint32_t offset) const {
+  if (!this->is_valid(offset))
+    return false;
+  const int32_t value = this->peek(offset);
+  const int32_t hi = this->upper_bound_(length);
+  return value <= 0 && -value <= hi;
+}
+
 bool RemoteReceiveData::expect_mark(uint32_t length) {
   if (!this->peek_mark(length))
     return false;

esphome/components/remote_base/remote_base.h

@@ -8,10 +8,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 
-#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR < 5
-#include <driver/rmt.h>
-#endif
-
 namespace esphome {
 namespace remote_base {
 
@@ -57,8 +53,11 @@ class RemoteReceiveData {
   bool is_valid(uint32_t offset = 0) const { return this->index_ + offset < this->data_.size(); }
   int32_t peek(uint32_t offset = 0) const { return this->data_[this->index_ + offset]; }
   bool peek_mark(uint32_t length, uint32_t offset = 0) const;
+  bool peek_mark_at_least(uint32_t length, uint32_t offset = 0) const;
+  bool peek_mark_at_most(uint32_t length, uint32_t offset = 0) const;
   bool peek_space(uint32_t length, uint32_t offset = 0) const;
   bool peek_space_at_least(uint32_t length, uint32_t offset = 0) const;
+  bool peek_space_at_most(uint32_t length, uint32_t offset = 0) const;
   bool peek_item(uint32_t mark, uint32_t space, uint32_t offset = 0) const {
     return this->peek_space(space, offset + 1) && this->peek_mark(mark, offset);
   }
@@ -112,43 +111,21 @@ class RemoteComponentBase {
 #ifdef USE_ESP32
 class RemoteRMTChannel {
  public:
-#if ESP_IDF_VERSION_MAJOR >= 5
   void set_clock_resolution(uint32_t clock_resolution) { this->clock_resolution_ = clock_resolution; }
   void set_rmt_symbols(uint32_t rmt_symbols) { this->rmt_symbols_ = rmt_symbols; }
-#else
-  explicit RemoteRMTChannel(uint8_t mem_block_num = 1);
-  explicit RemoteRMTChannel(rmt_channel_t channel, uint8_t mem_block_num = 1);
-
-  void config_rmt(rmt_config_t &rmt);
-  void set_clock_divider(uint8_t clock_divider) { this->clock_divider_ = clock_divider; }
-#endif
 
  protected:
   uint32_t from_microseconds_(uint32_t us) {
-#if ESP_IDF_VERSION_MAJOR >= 5
     const uint32_t ticks_per_ten_us = this->clock_resolution_ / 100000u;
-#else
-    const uint32_t ticks_per_ten_us = 80000000u / this->clock_divider_ / 100000u;
-#endif
     return us * ticks_per_ten_us / 10;
   }
   uint32_t to_microseconds_(uint32_t ticks) {
-#if ESP_IDF_VERSION_MAJOR >= 5
     const uint32_t ticks_per_ten_us = this->clock_resolution_ / 100000u;
-#else
-    const uint32_t ticks_per_ten_us = 80000000u / this->clock_divider_ / 100000u;
-#endif
     return (ticks * 10) / ticks_per_ten_us;
   }
   RemoteComponentBase *remote_base_;
-#if ESP_IDF_VERSION_MAJOR >= 5
   uint32_t clock_resolution_{1000000};
   uint32_t rmt_symbols_;
-#else
-  rmt_channel_t channel_{RMT_CHANNEL_0};
-  uint8_t mem_block_num_;
-  uint8_t clock_divider_{80};
-#endif
 };
 #endif
 

esphome/components/remote_receiver/__init__.py

@@ -1,23 +1,22 @@
 from esphome import 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_BUFFER_SIZE,
-    CONF_CLOCK_DIVIDER,
     CONF_CLOCK_RESOLUTION,
     CONF_DUMP,
     CONF_FILTER,
     CONF_ID,
     CONF_IDLE,
-    CONF_MEMORY_BLOCKS,
     CONF_PIN,
-    CONF_RMT_CHANNEL,
     CONF_RMT_SYMBOLS,
     CONF_TOLERANCE,
     CONF_TYPE,
     CONF_USE_DMA,
     CONF_VALUE,
+    PlatformFramework,
 )
 from esphome.core import CORE, TimePeriod
 
@@ -97,55 +96,43 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
                 esp32="10000b",
                 esp8266="1000b",
                 bk72xx="1000b",
+                ln882x="1000b",
                 rtl87xx="1000b",
             ): cv.validate_bytes,
             cv.Optional(CONF_FILTER, default="50us"): cv.All(
                 cv.positive_time_period_microseconds,
                 cv.Range(max=TimePeriod(microseconds=4294967295)),
             ),
-            cv.SplitDefault(CONF_CLOCK_DIVIDER, esp32_arduino=80): cv.All(
-                cv.only_on_esp32,
-                cv.only_with_arduino,
-                cv.int_range(min=1, max=255),
-            ),
             cv.Optional(CONF_CLOCK_RESOLUTION): cv.All(
                 cv.only_on_esp32,
-                cv.only_with_esp_idf,
                 esp32_rmt.validate_clock_resolution(),
             ),
             cv.Optional(CONF_IDLE, default="10ms"): cv.All(
                 cv.positive_time_period_microseconds,
                 cv.Range(max=TimePeriod(microseconds=4294967295)),
             ),
-            cv.SplitDefault(CONF_MEMORY_BLOCKS, esp32_arduino=3): cv.All(
-                cv.only_with_arduino, cv.int_range(min=1, max=8)
-            ),
-            cv.Optional(CONF_RMT_CHANNEL): cv.All(
-                cv.only_with_arduino, esp32_rmt.validate_rmt_channel(tx=False)
-            ),
             cv.SplitDefault(
                 CONF_RMT_SYMBOLS,
-                esp32_idf=192,
-                esp32_s2_idf=192,
-                esp32_s3_idf=192,
-                esp32_p4_idf=192,
-                esp32_c3_idf=96,
-                esp32_c5_idf=96,
-                esp32_c6_idf=96,
-                esp32_h2_idf=96,
-            ): cv.All(cv.only_with_esp_idf, cv.int_range(min=2)),
+                esp32=192,
+                esp32_s2=192,
+                esp32_s3=192,
+                esp32_p4=192,
+                esp32_c3=96,
+                esp32_c5=96,
+                esp32_c6=96,
+                esp32_h2=96,
+            ): cv.All(cv.only_on_esp32, cv.int_range(min=2)),
             cv.Optional(CONF_FILTER_SYMBOLS): cv.All(
-                cv.only_with_esp_idf, cv.int_range(min=0)
+                cv.only_on_esp32, cv.int_range(min=0)
             ),
             cv.SplitDefault(
                 CONF_RECEIVE_SYMBOLS,
-                esp32_idf=192,
-            ): cv.All(cv.only_with_esp_idf, cv.int_range(min=2)),
+                esp32=192,
+            ): cv.All(cv.only_on_esp32, cv.int_range(min=2)),
             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,
             ),
         }
@@ -156,24 +143,15 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
 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]))
-            cg.add(var.set_receive_symbols(config[CONF_RECEIVE_SYMBOLS]))
-            if CONF_USE_DMA in config:
-                cg.add(var.set_with_dma(config[CONF_USE_DMA]))
-            if CONF_CLOCK_RESOLUTION in config:
-                cg.add(var.set_clock_resolution(config[CONF_CLOCK_RESOLUTION]))
-            if CONF_FILTER_SYMBOLS in config:
-                cg.add(var.set_filter_symbols(config[CONF_FILTER_SYMBOLS]))
-        else:
-            if (rmt_channel := config.get(CONF_RMT_CHANNEL, None)) is not None:
-                var = cg.new_Pvariable(
-                    config[CONF_ID], pin, rmt_channel, config[CONF_MEMORY_BLOCKS]
-                )
-            else:
-                var = cg.new_Pvariable(config[CONF_ID], pin, config[CONF_MEMORY_BLOCKS])
-            cg.add(var.set_clock_divider(config[CONF_CLOCK_DIVIDER]))
+        var = cg.new_Pvariable(config[CONF_ID], pin)
+        cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
+        cg.add(var.set_receive_symbols(config[CONF_RECEIVE_SYMBOLS]))
+        if CONF_USE_DMA in config:
+            cg.add(var.set_with_dma(config[CONF_USE_DMA]))
+        if CONF_CLOCK_RESOLUTION in config:
+            cg.add(var.set_clock_resolution(config[CONF_CLOCK_RESOLUTION]))
+        if CONF_FILTER_SYMBOLS in config:
+            cg.add(var.set_filter_symbols(config[CONF_FILTER_SYMBOLS]))
     else:
         var = cg.new_Pvariable(config[CONF_ID], pin)
 
@@ -194,3 +172,19 @@ async def to_code(config):
     cg.add(var.set_buffer_size(config[CONF_BUFFER_SIZE]))
     cg.add(var.set_filter_us(config[CONF_FILTER]))
     cg.add(var.set_idle_us(config[CONF_IDLE]))
+
+
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "remote_receiver_esp32.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
+        },
+        "remote_receiver_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
+        "remote_receiver_libretiny.cpp": {
+            PlatformFramework.BK72XX_ARDUINO,
+            PlatformFramework.RTL87XX_ARDUINO,
+            PlatformFramework.LN882X_ARDUINO,
+        },
+    }
+)

esphome/components/remote_receiver/remote_receiver.h

@@ -5,7 +5,7 @@
 
 #include <cinttypes>
 
-#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR >= 5
+#if defined(USE_ESP32)
 #include <driver/rmt_rx.h>
 #endif
 
@@ -29,7 +29,7 @@ struct RemoteReceiverComponentStore {
   uint32_t filter_us{10};
   ISRInternalGPIOPin pin;
 };
-#elif defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR >= 5
+#elif defined(USE_ESP32)
 struct RemoteReceiverComponentStore {
   /// Stores RMT symbols and rx done event data
   volatile uint8_t *buffer{nullptr};
@@ -55,21 +55,12 @@ class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
 
 {
  public:
-#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR < 5
-  RemoteReceiverComponent(InternalGPIOPin *pin, uint8_t mem_block_num = 1)
-      : RemoteReceiverBase(pin), remote_base::RemoteRMTChannel(mem_block_num) {}
-
-  RemoteReceiverComponent(InternalGPIOPin *pin, rmt_channel_t channel, uint8_t mem_block_num = 1)
-      : RemoteReceiverBase(pin), remote_base::RemoteRMTChannel(channel, mem_block_num) {}
-#else
   RemoteReceiverComponent(InternalGPIOPin *pin) : RemoteReceiverBase(pin) {}
-#endif
   void setup() override;
   void dump_config() override;
   void loop() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
-#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR >= 5
+#ifdef USE_ESP32
   void set_filter_symbols(uint32_t filter_symbols) { this->filter_symbols_ = filter_symbols; }
   void set_receive_symbols(uint32_t receive_symbols) { this->receive_symbols_ = receive_symbols; }
   void set_with_dma(bool with_dma) { this->with_dma_ = with_dma; }
@@ -80,21 +71,16 @@ class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
 
  protected:
 #ifdef USE_ESP32
-#if ESP_IDF_VERSION_MAJOR >= 5
   void decode_rmt_(rmt_symbol_word_t *item, size_t item_count);
   rmt_channel_handle_t channel_{NULL};
   uint32_t filter_symbols_{0};
   uint32_t receive_symbols_{0};
   bool with_dma_{false};
-#else
-  void decode_rmt_(rmt_item32_t *item, size_t item_count);
-  RingbufHandle_t ringbuf_;
-#endif
   esp_err_t error_code_{ESP_OK};
   std::string error_string_{""};
 #endif
 
-#if defined(USE_ESP8266) || defined(USE_LIBRETINY) || (defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR >= 5)
+#if defined(USE_ESP8266) || defined(USE_LIBRETINY) || defined(USE_ESP32)
   RemoteReceiverComponentStore store_;
   HighFrequencyLoopRequester high_freq_;
 #endif