esphome 2024.12.4__py3-none-any.whl → 2025.2.0b1__py3-none-any.whl

esphome/components/qspi_dbi/qspi_dbi.cpp

@@ -33,19 +33,12 @@ void QspiDbi::update() {
   this->do_update_();
   if (this->buffer_ == nullptr || this->x_low_ > this->x_high_ || this->y_low_ > this->y_high_)
     return;
-  // Start addresses and widths/heights must be divisible by 2 (CASET/RASET restriction in datasheet)
-  if (this->x_low_ % 2 == 1) {
-    this->x_low_--;
-  }
-  if (this->x_high_ % 2 == 0) {
-    this->x_high_++;
-  }
-  if (this->y_low_ % 2 == 1) {
-    this->y_low_--;
-  }
-  if (this->y_high_ % 2 == 0) {
-    this->y_high_++;
-  }
+  // Some chips require that the drawing window be aligned on certain boundaries
+  auto dr = this->draw_rounding_;
+  this->x_low_ = this->x_low_ / dr * dr;
+  this->y_low_ = this->y_low_ / dr * dr;
+  this->x_high_ = (this->x_high_ + dr) / dr * dr - 1;
+  this->y_high_ = (this->y_high_ + dr) / dr * dr - 1;
   if (this->draw_from_origin_) {
     this->x_low_ = 0;
     this->y_low_ = 0;
@@ -175,10 +168,9 @@ void QspiDbi::write_to_display_(int x_start, int y_start, int w, int h, const ui
     this->write_cmd_addr_data(8, 0x32, 24, 0x2C00, ptr, w * h * 2, 4);
   } else {
     auto stride = x_offset + w + x_pad;
-    uint16_t cmd = 0x2C00;
+    this->write_cmd_addr_data(8, 0x32, 24, 0x2C00, nullptr, 0, 4);
     for (int y = 0; y != h; y++) {
-      this->write_cmd_addr_data(8, 0x32, 24, cmd, ptr + ((y + y_offset) * stride + x_offset) * 2, w * 2, 4);
-      cmd = 0x3C00;
+      this->write_cmd_addr_data(0, 0, 0, 0, ptr + ((y + y_offset) * stride + x_offset) * 2, w * 2, 4);
     }
   }
   this->disable();
@@ -220,6 +212,7 @@ void QspiDbi::dump_config() {
   ESP_LOGCONFIG("", "Model: %s", this->model_);
   ESP_LOGCONFIG(TAG, "  Height: %u", this->height_);
   ESP_LOGCONFIG(TAG, "  Width: %u", this->width_);
+  ESP_LOGCONFIG(TAG, "  Draw rounding: %u", this->draw_rounding_);
   LOG_PIN("  CS Pin: ", this->cs_);
   LOG_PIN("  Reset Pin: ", this->reset_pin_);
   ESP_LOGCONFIG(TAG, "  SPI Data rate: %dMHz", (unsigned) (this->data_rate_ / 1000000));

esphome/components/qspi_dbi/qspi_dbi.h

@@ -4,12 +4,10 @@
 #pragma once
 
 #ifdef USE_ESP_IDF
-#include "esphome/core/component.h"
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/display/display.h"
 #include "esphome/components/display/display_buffer.h"
 #include "esphome/components/display/display_color_utils.h"
-#include "esp_lcd_panel_ops.h"
 
 #include "esp_lcd_panel_rgb.h"
 
@@ -105,6 +103,7 @@ class QspiDbi : public display::DisplayBuffer,
   int get_height_internal() override { return this->height_; }
   bool can_proceed() override { return this->setup_complete_; }
   void add_init_sequence(const std::vector<uint8_t> &sequence) { this->init_sequences_.push_back(sequence); }
+  void set_draw_rounding(unsigned rounding) { this->draw_rounding_ = rounding; }
 
  protected:
   void check_buffer_() {
@@ -161,6 +160,7 @@ class QspiDbi : public display::DisplayBuffer,
   bool mirror_x_{};
   bool mirror_y_{};
   bool draw_from_origin_{false};
+  unsigned draw_rounding_{2};
   uint8_t brightness_{0xD0};
   const char *model_{"Unknown"};
   std::vector<std::vector<uint8_t>> init_sequences_{};

esphome/components/remote_base/__init__.py

@@ -1,41 +1,41 @@
-import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome import automation
+import esphome.codegen as cg
 from esphome.components import binary_sensor
+import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ADDRESS,
+    CONF_BUTTON,
+    CONF_CARRIER_FREQUENCY,
+    CONF_CHANNEL,
+    CONF_CHECK,
+    CONF_CODE,
+    CONF_COMMAND,
     CONF_COMMAND_REPEATS,
     CONF_DATA,
-    CONF_TRIGGER_ID,
+    CONF_DELTA,
+    CONF_DEVICE,
+    CONF_FAMILY,
+    CONF_GROUP,
+    CONF_ID,
+    CONF_INVERTED,
+    CONF_LEVEL,
+    CONF_MAGNITUDE,
     CONF_NBITS,
-    CONF_ADDRESS,
-    CONF_COMMAND,
-    CONF_CODE,
-    CONF_PULSE_LENGTH,
-    CONF_SYNC,
-    CONF_ZERO,
     CONF_ONE,
-    CONF_INVERTED,
     CONF_PROTOCOL,
-    CONF_GROUP,
-    CONF_DEVICE,
+    CONF_PULSE_LENGTH,
+    CONF_RC_CODE_1,
+    CONF_RC_CODE_2,
+    CONF_REPEAT,
     CONF_SECOND,
     CONF_STATE,
-    CONF_CHANNEL,
-    CONF_FAMILY,
-    CONF_REPEAT,
-    CONF_WAIT_TIME,
+    CONF_SYNC,
     CONF_TIMES,
+    CONF_TRIGGER_ID,
     CONF_TYPE_ID,
-    CONF_CARRIER_FREQUENCY,
-    CONF_RC_CODE_1,
-    CONF_RC_CODE_2,
-    CONF_MAGNITUDE,
+    CONF_WAIT_TIME,
     CONF_WAND_ID,
-    CONF_LEVEL,
-    CONF_DELTA,
-    CONF_ID,
-    CONF_BUTTON,
-    CONF_CHECK,
+    CONF_ZERO,
 )
 from esphome.core import coroutine
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
@@ -1963,3 +1963,55 @@ async def mirage_action(var, config, args):
     vec_ = cg.std_vector.template(cg.uint8)
     template_ = await cg.templatable(config[CONF_CODE], args, vec_, vec_)
     cg.add(var.set_code(template_))
+
+
+# Toto
+(
+    TotoData,
+    TotoBinarySensor,
+    TotoTrigger,
+    TotoAction,
+    TotoDumper,
+) = declare_protocol("Toto")
+
+TOTO_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_RC_CODE_1, default=0): cv.hex_int_range(0, 0xF),
+        cv.Optional(CONF_RC_CODE_2, default=0): cv.hex_int_range(0, 0xF),
+        cv.Required(CONF_COMMAND): cv.hex_uint8_t,
+    }
+)
+
+
+@register_binary_sensor("toto", TotoBinarySensor, TOTO_SCHEMA)
+def toto_binary_sensor(var, config):
+    cg.add(
+        var.set_data(
+            cg.StructInitializer(
+                TotoData,
+                ("rc_code_1", config[CONF_RC_CODE_1]),
+                ("rc_code_2", config[CONF_RC_CODE_2]),
+                ("command", config[CONF_COMMAND]),
+            )
+        )
+    )
+
+
+@register_trigger("toto", TotoTrigger, TotoData)
+def toto_trigger(var, config):
+    pass
+
+
+@register_dumper("toto", TotoDumper)
+def toto_dumper(var, config):
+    pass
+
+
+@register_action("toto", TotoAction, TOTO_SCHEMA)
+async def Toto_action(var, config, args):
+    template_ = await cg.templatable(config[CONF_RC_CODE_1], args, cg.uint8)
+    cg.add(var.set_rc_code_1(template_))
+    template_ = await cg.templatable(config[CONF_RC_CODE_2], args, cg.uint8)
+    cg.add(var.set_rc_code_2(template_))
+    template_ = await cg.templatable(config[CONF_COMMAND], args, cg.uint8)
+    cg.add(var.set_command(template_))

esphome/components/remote_base/remote_base.cpp

@@ -8,7 +8,7 @@ namespace remote_base {
 
 static const char *const TAG = "remote_base";
 
-#ifdef USE_ESP32
+#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;

esphome/components/remote_base/remote_base.h

@@ -8,7 +8,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 
-#ifdef USE_ESP32
+#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR < 5
 #include <driver/rmt.h>
 #endif
 
@@ -54,7 +54,7 @@ class RemoteReceiveData {
   uint32_t get_index() const { return index_; }
   int32_t operator[](uint32_t index) const { return this->data_[index]; }
   int32_t size() const { return this->data_.size(); }
-  bool is_valid(uint32_t offset) const { return this->index_ + offset < this->data_.size(); }
+  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_space(uint32_t length, uint32_t offset = 0) const;
@@ -112,25 +112,43 @@ 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_base/toto_protocol.cpp

@@ -0,0 +1,100 @@
+#include "toto_protocol.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace remote_base {
+
+static const char *const TAG = "remote.toto";
+
+static const uint32_t PREAMBLE_HIGH_US = 6200;
+static const uint32_t PREAMBLE_LOW_US = 2800;
+static const uint32_t BIT_HIGH_US = 550;
+static const uint32_t BIT_ONE_LOW_US = 1700;
+static const uint32_t BIT_ZERO_LOW_US = 550;
+static const uint32_t TOTO_HEADER = 0x2008;
+
+void TotoProtocol::encode(RemoteTransmitData *dst, const TotoData &data) {
+  uint32_t payload = 0;
+
+  payload = data.rc_code_1 << 20;
+  payload |= data.rc_code_2 << 16;
+  payload |= data.command << 8;
+  payload |= ((payload & 0xFF0000) >> 16) ^ ((payload & 0x00FF00) >> 8);
+
+  dst->reserve(80);
+  dst->set_carrier_frequency(38000);
+  dst->item(PREAMBLE_HIGH_US, PREAMBLE_LOW_US);
+
+  for (uint32_t mask = 1UL << 14; mask; mask >>= 1) {
+    if (TOTO_HEADER & mask) {
+      dst->item(BIT_HIGH_US, BIT_ONE_LOW_US);
+    } else {
+      dst->item(BIT_HIGH_US, BIT_ZERO_LOW_US);
+    }
+  }
+
+  for (uint32_t mask = 1UL << 23; mask; mask >>= 1) {
+    if (payload & mask) {
+      dst->item(BIT_HIGH_US, BIT_ONE_LOW_US);
+    } else {
+      dst->item(BIT_HIGH_US, BIT_ZERO_LOW_US);
+    }
+  }
+
+  dst->mark(BIT_HIGH_US);
+}
+optional<TotoData> TotoProtocol::decode(RemoteReceiveData src) {
+  uint16_t header = 0;
+  uint32_t payload = 0;
+
+  TotoData data{
+      .rc_code_1 = 0,
+      .rc_code_2 = 0,
+      .command = 0,
+  };
+
+  if (!src.expect_item(PREAMBLE_HIGH_US, PREAMBLE_LOW_US)) {
+    return {};
+  }
+
+  for (uint32_t mask = 1UL << 14; mask; mask >>= 1) {
+    if (src.expect_item(BIT_HIGH_US, BIT_ONE_LOW_US)) {
+      header |= mask;
+    } else if (src.expect_item(BIT_HIGH_US, BIT_ZERO_LOW_US)) {
+      header &= ~mask;
+    } else {
+      return {};
+    }
+  }
+
+  if (header != TOTO_HEADER) {
+    return {};
+  }
+
+  for (uint32_t mask = 1UL << 23; mask; mask >>= 1) {
+    if (src.expect_item(BIT_HIGH_US, BIT_ONE_LOW_US)) {
+      payload |= mask;
+    } else if (src.expect_item(BIT_HIGH_US, BIT_ZERO_LOW_US)) {
+      payload &= ~mask;
+    } else {
+      return {};
+    }
+  }
+
+  if ((((payload & 0xFF0000) >> 16) ^ ((payload & 0x00FF00) >> 8)) != (payload & 0x0000FF)) {
+    return {};
+  }
+
+  data.rc_code_1 = (payload & 0xF00000) >> 20;
+  data.rc_code_2 = (payload & 0x0F0000) >> 16;
+  data.command = (payload & 0x00FF00) >> 8;
+
+  return data;
+}
+void TotoProtocol::dump(const TotoData &data) {
+  ESP_LOGI(TAG, "Received Toto data: rc_code_1=0x%01X, rc_code_2=0x%01X, command=0x%02X", data.rc_code_1,
+           data.rc_code_2, data.command);
+}
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_base/toto_protocol.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "remote_base.h"
+
+namespace esphome {
+namespace remote_base {
+
+struct TotoData {
+  uint8_t rc_code_1 : 4;
+  uint8_t rc_code_2 : 4;
+  uint8_t command;
+
+  bool operator==(const TotoData &rhs) const {
+    return (rc_code_1 == rhs.rc_code_1) && (rc_code_2 == rhs.rc_code_2) && (command == rhs.command);
+  }
+};
+
+class TotoProtocol : public RemoteProtocol<TotoData> {
+ public:
+  void encode(RemoteTransmitData *dst, const TotoData &data) override;
+  optional<TotoData> decode(RemoteReceiveData src) override;
+  void dump(const TotoData &data) override;
+};
+
+DECLARE_REMOTE_PROTOCOL(Toto)
+
+template<typename... Ts> class TotoAction : public RemoteTransmitterActionBase<Ts...> {
+ public:
+  TEMPLATABLE_VALUE(uint8_t, rc_code_1)
+  TEMPLATABLE_VALUE(uint8_t, rc_code_2)
+  TEMPLATABLE_VALUE(uint8_t, command)
+
+  void encode(RemoteTransmitData *dst, Ts... x) override {
+    TotoData data{};
+    data.rc_code_1 = this->rc_code_1_.value(x...);
+    data.rc_code_2 = this->rc_code_2_.value(x...);
+    data.command = this->command_.value(x...);
+    this->set_send_times(this->send_times_.value_or(x..., 3));
+    this->set_send_wait(this->send_wait_.value_or(x..., 32000));
+    TotoProtocol().encode(dst, data);
+  }
+};
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_receiver/__init__.py

@@ -5,6 +5,7 @@ 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,
@@ -12,12 +13,17 @@ from esphome.const import (
     CONF_MEMORY_BLOCKS,
     CONF_PIN,
     CONF_RMT_CHANNEL,
+    CONF_RMT_SYMBOLS,
     CONF_TOLERANCE,
     CONF_TYPE,
+    CONF_USE_DMA,
     CONF_VALUE,
 )
 from esphome.core import CORE, TimePeriod
 
+CONF_FILTER_SYMBOLS = "filter_symbols"
+CONF_RECEIVE_SYMBOLS = "receive_symbols"
+
 AUTO_LOAD = ["remote_base"]
 remote_receiver_ns = cg.esphome_ns.namespace("remote_receiver")
 remote_base_ns = cg.esphome_ns.namespace("remote_base")
@@ -97,15 +103,43 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
                 cv.positive_time_period_microseconds,
                 cv.Range(max=TimePeriod(microseconds=4294967295)),
             ),
-            cv.SplitDefault(CONF_CLOCK_DIVIDER, esp32=80): cv.All(
-                cv.only_on_esp32, cv.Range(min=1, max=255)
+            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.Optional(CONF_MEMORY_BLOCKS, default=3): cv.Range(min=1, max=8),
-            cv.Optional(CONF_RMT_CHANNEL): esp32_rmt.validate_rmt_channel(tx=False),
+            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_c3_idf=96,
+                esp32_c6_idf=96,
+                esp32_h2_idf=96,
+            ): cv.All(cv.only_with_esp_idf, cv.int_range(min=2)),
+            cv.Optional(CONF_FILTER_SYMBOLS): cv.All(
+                cv.only_with_esp_idf, 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)),
+            cv.Optional(CONF_USE_DMA): cv.All(cv.only_with_esp_idf, cv.boolean),
         }
     ).extend(cv.COMPONENT_SCHEMA)
 )
@@ -114,13 +148,24 @@ 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 (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]
-            )
+        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:
-            var = cg.new_Pvariable(config[CONF_ID], pin, config[CONF_MEMORY_BLOCKS])
-        cg.add(var.set_clock_divider(config[CONF_CLOCK_DIVIDER]))
+            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]))
     else:
         var = cg.new_Pvariable(config[CONF_ID], pin)
 

esphome/components/remote_receiver/remote_receiver.h

@@ -5,6 +5,10 @@
 
 #include <cinttypes>
 
+#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR >= 5
+#include <driver/rmt_rx.h>
+#endif
+
 namespace esphome {
 namespace remote_receiver {
 
@@ -25,6 +29,21 @@ struct RemoteReceiverComponentStore {
   uint32_t filter_us{10};
   ISRInternalGPIOPin pin;
 };
+#elif defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR >= 5
+struct RemoteReceiverComponentStore {
+  /// Stores RMT symbols and rx done event data
+  volatile uint8_t *buffer{nullptr};
+  /// The position last written to
+  volatile uint32_t buffer_write{0};
+  /// The position last read from
+  volatile uint32_t buffer_read{0};
+  bool overflow{false};
+  uint32_t buffer_size{1000};
+  uint32_t receive_size{0};
+  uint32_t filter_symbols{0};
+  esp_err_t error{ESP_OK};
+  rmt_receive_config_t config;
+};
 #endif
 
 class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
@@ -33,9 +52,10 @@ class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
     ,
                                 public remote_base::RemoteRMTChannel
 #endif
+
 {
  public:
-#ifdef USE_ESP32
+#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) {}
 
@@ -49,19 +69,32 @@ class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
   void loop() override;
   float get_setup_priority() const override { return setup_priority::DATA; }
 
+#if defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR >= 5
+  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; }
+#endif
   void set_buffer_size(uint32_t buffer_size) { this->buffer_size_ = buffer_size; }
   void set_filter_us(uint32_t filter_us) { this->filter_us_ = filter_us; }
   void set_idle_us(uint32_t idle_us) { this->idle_us_ = idle_us; }
 
  protected:
 #ifdef USE_ESP32
-  void decode_rmt_(rmt_item32_t *item, size_t len);
+#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)
+#if defined(USE_ESP8266) || defined(USE_LIBRETINY) || (defined(USE_ESP32) && ESP_IDF_VERSION_MAJOR >= 5)
   RemoteReceiverComponentStore store_;
   HighFrequencyLoopRequester high_freq_;
 #endif