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

esphome/components/esp32_rmt_led_strip/led_strip.cpp

@@ -21,6 +21,43 @@ static const uint32_t RMT_CLK_FREQ = 80000000;
 static const uint8_t RMT_CLK_DIV = 2;
 #endif
 
+static const size_t RMT_SYMBOLS_PER_BYTE = 8;
+
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
+static size_t IRAM_ATTR HOT encoder_callback(const void *data, size_t size, size_t symbols_written, size_t symbols_free,
+                                             rmt_symbol_word_t *symbols, bool *done, void *arg) {
+  auto *params = static_cast<LedParams *>(arg);
+  const auto *bytes = static_cast<const uint8_t *>(data);
+  size_t index = symbols_written / RMT_SYMBOLS_PER_BYTE;
+
+  // convert byte to symbols
+  if (index < size) {
+    if (symbols_free < RMT_SYMBOLS_PER_BYTE) {
+      return 0;
+    }
+    for (int32_t i = 0; i < RMT_SYMBOLS_PER_BYTE; i++) {
+      if (bytes[index] & (1 << (7 - i))) {
+        symbols[i] = params->bit1;
+      } else {
+        symbols[i] = params->bit0;
+      }
+    }
+    if ((index + 1) >= size && params->reset.duration0 == 0 && params->reset.duration1 == 0) {
+      *done = true;
+    }
+    return RMT_SYMBOLS_PER_BYTE;
+  }
+
+  // send reset
+  if (symbols_free < 1) {
+    return 0;
+  }
+  symbols[0] = params->reset;
+  *done = true;
+  return 1;
+}
+#endif
+
 void ESP32RMTLEDStripLightOutput::setup() {
   ESP_LOGCONFIG(TAG, "Running setup");
 
@@ -42,11 +79,15 @@ void ESP32RMTLEDStripLightOutput::setup() {
     return;
   }
 
-#if ESP_IDF_VERSION_MAJOR >= 5
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
+  // copy of the led buffer
+  this->rmt_buf_ = allocator.allocate(buffer_size);
+#else
   RAMAllocator<rmt_symbol_word_t> rmt_allocator(this->use_psram_ ? 0 : RAMAllocator<rmt_symbol_word_t>::ALLOC_INTERNAL);
 
   // 8 bits per byte, 1 rmt_symbol_word_t per bit + 1 rmt_symbol_word_t for reset
   this->rmt_buf_ = rmt_allocator.allocate(buffer_size * 8 + 1);
+#endif
 
   rmt_tx_channel_config_t channel;
   memset(&channel, 0, sizeof(channel));
@@ -66,6 +107,18 @@ void ESP32RMTLEDStripLightOutput::setup() {
     return;
   }
 
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
+  rmt_simple_encoder_config_t encoder;
+  memset(&encoder, 0, sizeof(encoder));
+  encoder.callback = encoder_callback;
+  encoder.arg = &this->params_;
+  encoder.min_chunk_size = 8;
+  if (rmt_new_simple_encoder(&encoder, &this->encoder_) != ESP_OK) {
+    ESP_LOGE(TAG, "Encoder creation failed");
+    this->mark_failed();
+    return;
+  }
+#else
   rmt_copy_encoder_config_t encoder;
   memset(&encoder, 0, sizeof(encoder));
   if (rmt_new_copy_encoder(&encoder, &this->encoder_) != ESP_OK) {
@@ -73,42 +126,13 @@ void ESP32RMTLEDStripLightOutput::setup() {
     this->mark_failed();
     return;
   }
+#endif
 
   if (rmt_enable(this->channel_) != ESP_OK) {
     ESP_LOGE(TAG, "Enabling channel failed");
     this->mark_failed();
     return;
   }
-#else
-  RAMAllocator<rmt_item32_t> rmt_allocator(this->use_psram_ ? 0 : RAMAllocator<rmt_item32_t>::ALLOC_INTERNAL);
-
-  // 8 bits per byte, 1 rmt_item32_t per bit + 1 rmt_item32_t for reset
-  this->rmt_buf_ = rmt_allocator.allocate(buffer_size * 8 + 1);
-
-  rmt_config_t config;
-  memset(&config, 0, sizeof(config));
-  config.channel = this->channel_;
-  config.rmt_mode = RMT_MODE_TX;
-  config.gpio_num = gpio_num_t(this->pin_);
-  config.mem_block_num = 1;
-  config.clk_div = RMT_CLK_DIV;
-  config.tx_config.loop_en = false;
-  config.tx_config.carrier_level = RMT_CARRIER_LEVEL_LOW;
-  config.tx_config.carrier_en = false;
-  config.tx_config.idle_level = RMT_IDLE_LEVEL_LOW;
-  config.tx_config.idle_output_en = true;
-
-  if (rmt_config(&config) != ESP_OK) {
-    ESP_LOGE(TAG, "Cannot initialize RMT!");
-    this->mark_failed();
-    return;
-  }
-  if (rmt_driver_install(config.channel, 0, 0) != ESP_OK) {
-    ESP_LOGE(TAG, "Cannot install RMT driver!");
-    this->mark_failed();
-    return;
-  }
-#endif
 }
 
 void ESP32RMTLEDStripLightOutput::set_led_params(uint32_t bit0_high, uint32_t bit0_low, uint32_t bit1_high,
@@ -116,20 +140,20 @@ void ESP32RMTLEDStripLightOutput::set_led_params(uint32_t bit0_high, uint32_t bi
   float ratio = (float) RMT_CLK_FREQ / RMT_CLK_DIV / 1e09f;
 
   // 0-bit
-  this->bit0_.duration0 = (uint32_t) (ratio * bit0_high);
-  this->bit0_.level0 = 1;
-  this->bit0_.duration1 = (uint32_t) (ratio * bit0_low);
-  this->bit0_.level1 = 0;
+  this->params_.bit0.duration0 = (uint32_t) (ratio * bit0_high);
+  this->params_.bit0.level0 = 1;
+  this->params_.bit0.duration1 = (uint32_t) (ratio * bit0_low);
+  this->params_.bit0.level1 = 0;
   // 1-bit
-  this->bit1_.duration0 = (uint32_t) (ratio * bit1_high);
-  this->bit1_.level0 = 1;
-  this->bit1_.duration1 = (uint32_t) (ratio * bit1_low);
-  this->bit1_.level1 = 0;
+  this->params_.bit1.duration0 = (uint32_t) (ratio * bit1_high);
+  this->params_.bit1.level0 = 1;
+  this->params_.bit1.duration1 = (uint32_t) (ratio * bit1_low);
+  this->params_.bit1.level1 = 0;
   // reset
-  this->reset_.duration0 = (uint32_t) (ratio * reset_time_high);
-  this->reset_.level0 = 1;
-  this->reset_.duration1 = (uint32_t) (ratio * reset_time_low);
-  this->reset_.level1 = 0;
+  this->params_.reset.duration0 = (uint32_t) (ratio * reset_time_high);
+  this->params_.reset.level0 = 1;
+  this->params_.reset.duration1 = (uint32_t) (ratio * reset_time_low);
+  this->params_.reset.level1 = 0;
 }
 
 void ESP32RMTLEDStripLightOutput::write_state(light::LightState *state) {
@@ -145,11 +169,7 @@ void ESP32RMTLEDStripLightOutput::write_state(light::LightState *state) {
 
   ESP_LOGVV(TAG, "Writing RGB values to bus");
 
-#if ESP_IDF_VERSION_MAJOR >= 5
   esp_err_t error = rmt_tx_wait_all_done(this->channel_, 1000);
-#else
-  esp_err_t error = rmt_wait_tx_done(this->channel_, pdMS_TO_TICKS(1000));
-#endif
   if (error != ESP_OK) {
     ESP_LOGE(TAG, "RMT TX timeout");
     this->status_set_warning();
@@ -157,20 +177,19 @@ void ESP32RMTLEDStripLightOutput::write_state(light::LightState *state) {
   }
   delayMicroseconds(50);
 
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
+  memcpy(this->rmt_buf_, this->buf_, this->get_buffer_size_());
+#else
   size_t buffer_size = this->get_buffer_size_();
 
   size_t size = 0;
   size_t len = 0;
   uint8_t *psrc = this->buf_;
-#if ESP_IDF_VERSION_MAJOR >= 5
   rmt_symbol_word_t *pdest = this->rmt_buf_;
-#else
-  rmt_item32_t *pdest = this->rmt_buf_;
-#endif
   while (size < buffer_size) {
     uint8_t b = *psrc;
     for (int i = 0; i < 8; i++) {
-      pdest->val = b & (1 << (7 - i)) ? this->bit1_.val : this->bit0_.val;
+      pdest->val = b & (1 << (7 - i)) ? this->params_.bit1.val : this->params_.bit0.val;
       pdest++;
       len++;
     }
@@ -178,20 +197,19 @@ void ESP32RMTLEDStripLightOutput::write_state(light::LightState *state) {
     psrc++;
   }
 
-  if (this->reset_.duration0 > 0 || this->reset_.duration1 > 0) {
-    pdest->val = this->reset_.val;
+  if (this->params_.reset.duration0 > 0 || this->params_.reset.duration1 > 0) {
+    pdest->val = this->params_.reset.val;
     pdest++;
     len++;
   }
+#endif
 
-#if ESP_IDF_VERSION_MAJOR >= 5
   rmt_transmit_config_t config;
   memset(&config, 0, sizeof(config));
-  config.loop_count = 0;
-  config.flags.eot_level = 0;
-  error = rmt_transmit(this->channel_, this->encoder_, this->rmt_buf_, len * sizeof(rmt_symbol_word_t), &config);
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
+  error = rmt_transmit(this->channel_, this->encoder_, this->rmt_buf_, this->get_buffer_size_(), &config);
 #else
-  error = rmt_write_items(this->channel_, this->rmt_buf_, len, false);
+  error = rmt_transmit(this->channel_, this->encoder_, this->rmt_buf_, len * sizeof(rmt_symbol_word_t), &config);
 #endif
   if (error != ESP_OK) {
     ESP_LOGE(TAG, "RMT TX error");
@@ -251,11 +269,7 @@ void ESP32RMTLEDStripLightOutput::dump_config() {
                 "ESP32 RMT LED Strip:\n"
                 "  Pin: %u",
                 this->pin_);
-#if ESP_IDF_VERSION_MAJOR >= 5
   ESP_LOGCONFIG(TAG, "  RMT Symbols: %" PRIu32, this->rmt_symbols_);
-#else
-  ESP_LOGCONFIG(TAG, "  Channel: %u", this->channel_);
-#endif
   const char *rgb_order;
   switch (this->rgb_order_) {
     case ORDER_RGB:

esphome/components/esp32_rmt_led_strip/led_strip.h

@@ -11,12 +11,7 @@
 #include <driver/gpio.h>
 #include <esp_err.h>
 #include <esp_idf_version.h>
-
-#if ESP_IDF_VERSION_MAJOR >= 5
 #include <driver/rmt_tx.h>
-#else
-#include <driver/rmt.h>
-#endif
 
 namespace esphome {
 namespace esp32_rmt_led_strip {
@@ -30,6 +25,12 @@ enum RGBOrder : uint8_t {
   ORDER_BRG,
 };
 
+struct LedParams {
+  rmt_symbol_word_t bit0;
+  rmt_symbol_word_t bit1;
+  rmt_symbol_word_t reset;
+};
+
 class ESP32RMTLEDStripLightOutput : public light::AddressableLight {
  public:
   void setup() override;
@@ -61,11 +62,7 @@ class ESP32RMTLEDStripLightOutput : public light::AddressableLight {
                       uint32_t reset_time_high, uint32_t reset_time_low);
 
   void set_rgb_order(RGBOrder rgb_order) { this->rgb_order_ = rgb_order; }
-#if ESP_IDF_VERSION_MAJOR >= 5
   void set_rmt_symbols(uint32_t rmt_symbols) { this->rmt_symbols_ = rmt_symbols; }
-#else
-  void set_rmt_channel(rmt_channel_t channel) { this->channel_ = channel; }
-#endif
 
   void clear_effect_data() override {
     for (int i = 0; i < this->size(); i++)
@@ -81,18 +78,15 @@ class ESP32RMTLEDStripLightOutput : public light::AddressableLight {
 
   uint8_t *buf_{nullptr};
   uint8_t *effect_data_{nullptr};
-#if ESP_IDF_VERSION_MAJOR >= 5
+  LedParams params_;
   rmt_channel_handle_t channel_{nullptr};
   rmt_encoder_handle_t encoder_{nullptr};
-  rmt_symbol_word_t *rmt_buf_{nullptr};
-  rmt_symbol_word_t bit0_, bit1_, reset_;
-  uint32_t rmt_symbols_{48};
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
+  uint8_t *rmt_buf_{nullptr};
 #else
-  rmt_item32_t *rmt_buf_{nullptr};
-  rmt_item32_t bit0_, bit1_, reset_;
-  rmt_channel_t channel_{RMT_CHANNEL_0};
+  rmt_symbol_word_t *rmt_buf_{nullptr};
 #endif
-
+  uint32_t rmt_symbols_{48};
   uint8_t pin_;
   uint16_t num_leds_;
   bool is_rgbw_{false};

esphome/components/esp32_rmt_led_strip/light.py

@@ -3,7 +3,7 @@ import logging
 
 from esphome import pins
 import esphome.codegen as cg
-from esphome.components import esp32, esp32_rmt, light
+from esphome.components import esp32, light
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHIPSET,
@@ -13,11 +13,9 @@ from esphome.const import (
     CONF_OUTPUT_ID,
     CONF_PIN,
     CONF_RGB_ORDER,
-    CONF_RMT_CHANNEL,
     CONF_RMT_SYMBOLS,
     CONF_USE_DMA,
 )
-from esphome.core import CORE
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -69,53 +67,6 @@ CONF_RESET_HIGH = "reset_high"
 CONF_RESET_LOW = "reset_low"
 
 
-class OptionalForIDF5(cv.SplitDefault):
-    @property
-    def default(self):
-        if not esp32_rmt.use_new_rmt_driver():
-            return cv.UNDEFINED
-        return super().default
-
-    @default.setter
-    def default(self, value):
-        # Ignore default set from vol.Optional
-        pass
-
-
-def only_with_new_rmt_driver(obj):
-    if not esp32_rmt.use_new_rmt_driver():
-        raise cv.Invalid(
-            "This feature is only available for the IDF framework version 5."
-        )
-    return obj
-
-
-def not_with_new_rmt_driver(obj):
-    if esp32_rmt.use_new_rmt_driver():
-        raise cv.Invalid(
-            "This feature is not available for the IDF framework version 5."
-        )
-    return obj
-
-
-def final_validation(config):
-    if not esp32_rmt.use_new_rmt_driver():
-        if CONF_RMT_CHANNEL not in config:
-            if CORE.using_esp_idf:
-                raise cv.Invalid(
-                    "rmt_channel is a required option for IDF version < 5."
-                )
-            raise cv.Invalid(
-                "rmt_channel is a required option for the Arduino framework."
-            )
-        _LOGGER.warning(
-            "RMT_LED_STRIP support for IDF version < 5 is deprecated and will be removed soon."
-        )
-
-
-FINAL_VALIDATE_SCHEMA = final_validation
-
-
 CONFIG_SCHEMA = cv.All(
     light.ADDRESSABLE_LIGHT_SCHEMA.extend(
         {
@@ -123,20 +74,17 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_PIN): pins.internal_gpio_output_pin_number,
             cv.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
             cv.Required(CONF_RGB_ORDER): cv.enum(RGB_ORDERS, upper=True),
-            cv.Optional(CONF_RMT_CHANNEL): cv.All(
-                not_with_new_rmt_driver, esp32_rmt.validate_rmt_channel(tx=True)
-            ),
-            OptionalForIDF5(
+            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(only_with_new_rmt_driver, 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.int_range(min=2),
             cv.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
             cv.Optional(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
             cv.Optional(CONF_IS_RGBW, default=False): cv.boolean,
@@ -145,7 +93,6 @@ CONFIG_SCHEMA = cv.All(
                 esp32.only_on_variant(
                     supported=[esp32.const.VARIANT_ESP32S3, esp32.const.VARIANT_ESP32P4]
                 ),
-                cv.only_with_esp_idf,
                 cv.boolean,
             ),
             cv.Optional(CONF_USE_PSRAM, default=True): cv.boolean,
@@ -218,15 +165,6 @@ async def to_code(config):
     cg.add(var.set_is_rgbw(config[CONF_IS_RGBW]))
     cg.add(var.set_is_wrgb(config[CONF_IS_WRGB]))
     cg.add(var.set_use_psram(config[CONF_USE_PSRAM]))
-
-    if esp32_rmt.use_new_rmt_driver():
-        cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
-        if CONF_USE_DMA in config:
-            cg.add(var.set_use_dma(config[CONF_USE_DMA]))
-    else:
-        rmt_channel_t = cg.global_ns.enum("rmt_channel_t")
-        cg.add(
-            var.set_rmt_channel(
-                getattr(rmt_channel_t, f"RMT_CHANNEL_{config[CONF_RMT_CHANNEL]}")
-            )
-        )
+    cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
+    if CONF_USE_DMA in config:
+        cg.add(var.set_use_dma(config[CONF_USE_DMA]))

esphome/components/esp32_touch/esp32_touch.h

@@ -9,10 +9,26 @@
 #include <vector>
 
 #include <driver/touch_sensor.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
 
 namespace esphome {
 namespace esp32_touch {
 
+// IMPORTANT: Touch detection logic differs between ESP32 variants:
+// - ESP32 v1 (original): Touch detected when value < threshold (capacitance increase causes value decrease)
+// - ESP32-S2/S3 v2: Touch detected when value > threshold (capacitance increase causes value increase)
+// This inversion is due to different hardware implementations between chip generations.
+//
+// INTERRUPT BEHAVIOR:
+// - ESP32 v1: Interrupts fire when ANY pad is touched and continue while touched.
+//   Releases are detected by timeout since hardware doesn't generate release interrupts.
+// - ESP32-S2/S3 v2: Hardware supports both touch and release interrupts, but release
+//   interrupts are unreliable and sometimes don't fire. We now only use touch interrupts
+//   and detect releases via timeout, similar to v1.
+
+static const uint32_t SETUP_MODE_LOG_INTERVAL_MS = 250;
+
 class ESP32TouchBinarySensor;
 
 class ESP32TouchComponent : public Component {
@@ -31,6 +47,14 @@ class ESP32TouchComponent : public Component {
   void set_voltage_attenuation(touch_volt_atten_t voltage_attenuation) {
     this->voltage_attenuation_ = voltage_attenuation;
   }
+
+  void setup() override;
+  void dump_config() override;
+  void loop() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+  void on_shutdown() override;
+
 #if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
   void set_filter_mode(touch_filter_mode_t filter_mode) { this->filter_mode_ = filter_mode; }
   void set_debounce_count(uint32_t debounce_count) { this->debounce_count_ = debounce_count; }
@@ -47,64 +71,172 @@ class ESP32TouchComponent : public Component {
   void set_iir_filter(uint32_t iir_filter) { this->iir_filter_ = iir_filter; }
 #endif
 
-  uint32_t component_touch_pad_read(touch_pad_t tp);
-
-  void setup() override;
-  void dump_config() override;
-  void loop() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
-  void on_shutdown() override;
-
  protected:
-#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
-  bool filter_configured_() const {
-    return (this->filter_mode_ != TOUCH_PAD_FILTER_MAX) && (this->smooth_level_ != TOUCH_PAD_SMOOTH_MAX);
-  }
-  bool denoise_configured_() const {
-    return (this->grade_ != TOUCH_PAD_DENOISE_MAX) && (this->cap_level_ != TOUCH_PAD_DENOISE_CAP_MAX);
-  }
-  bool waterproof_configured_() const {
-    return (this->waterproof_guard_ring_pad_ != TOUCH_PAD_MAX) &&
-           (this->waterproof_shield_driver_ != TOUCH_PAD_SHIELD_DRV_MAX);
-  }
-#else
-  bool iir_filter_enabled_() const { return this->iir_filter_ > 0; }
-#endif
+  // Common helper methods
+  void dump_config_base_();
+  void dump_config_sensors_();
+  bool create_touch_queue_();
+  void cleanup_touch_queue_();
+  void configure_wakeup_pads_();
 
+  // Helper methods for loop() logic
+  void process_setup_mode_logging_(uint32_t now);
+  bool should_check_for_releases_(uint32_t now);
+  void publish_initial_state_if_needed_(ESP32TouchBinarySensor *child, uint32_t now);
+  void check_and_disable_loop_if_all_released_(size_t pads_off);
+  void calculate_release_timeout_();
+
+  // Common members
   std::vector<ESP32TouchBinarySensor *> children_;
   bool setup_mode_{false};
   uint32_t setup_mode_last_log_print_{0};
-  // common parameters
+  uint32_t last_release_check_{0};
+  uint32_t release_timeout_ms_{1500};
+  uint32_t release_check_interval_ms_{50};
+
+  // Common configuration parameters
   uint16_t sleep_cycle_{4095};
   uint16_t meas_cycle_{65535};
   touch_low_volt_t low_voltage_reference_{TOUCH_LVOLT_0V5};
   touch_high_volt_t high_voltage_reference_{TOUCH_HVOLT_2V7};
   touch_volt_atten_t voltage_attenuation_{TOUCH_HVOLT_ATTEN_0V};
-#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+
+  // Common constants
+  static constexpr uint32_t MINIMUM_RELEASE_TIME_MS = 100;
+
+  // ==================== PLATFORM SPECIFIC ====================
+
+#ifdef USE_ESP32_VARIANT_ESP32
+  // ESP32 v1 specific
+
+  static void touch_isr_handler(void *arg);
+  QueueHandle_t touch_queue_{nullptr};
+
+ private:
+  // Touch event structure for ESP32 v1
+  // Contains touch pad info, value, and touch state for queue communication
+  struct TouchPadEventV1 {
+    touch_pad_t pad;
+    uint32_t value;
+    bool is_touched;
+  };
+
+ protected:
+  uint32_t iir_filter_{0};
+
+  bool iir_filter_enabled_() const { return this->iir_filter_ > 0; }
+
+#elif defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+  // ESP32-S2/S3 v2 specific
+  static void touch_isr_handler(void *arg);
+  QueueHandle_t touch_queue_{nullptr};
+
+ private:
+  // Touch event structure for ESP32 v2 (S2/S3)
+  // Contains touch pad and interrupt mask for queue communication
+  struct TouchPadEventV2 {
+    touch_pad_t pad;
+    uint32_t intr_mask;
+  };
+
+ protected:
+  // Filter configuration
   touch_filter_mode_t filter_mode_{TOUCH_PAD_FILTER_MAX};
   uint32_t debounce_count_{0};
   uint32_t noise_threshold_{0};
   uint32_t jitter_step_{0};
   touch_smooth_mode_t smooth_level_{TOUCH_PAD_SMOOTH_MAX};
+
+  // Denoise configuration
   touch_pad_denoise_grade_t grade_{TOUCH_PAD_DENOISE_MAX};
   touch_pad_denoise_cap_t cap_level_{TOUCH_PAD_DENOISE_CAP_MAX};
+
+  // Waterproof configuration
   touch_pad_t waterproof_guard_ring_pad_{TOUCH_PAD_MAX};
   touch_pad_shield_driver_t waterproof_shield_driver_{TOUCH_PAD_SHIELD_DRV_MAX};
-#else
-  uint32_t iir_filter_{0};
+
+  bool filter_configured_() const {
+    return (this->filter_mode_ != TOUCH_PAD_FILTER_MAX) && (this->smooth_level_ != TOUCH_PAD_SMOOTH_MAX);
+  }
+  bool denoise_configured_() const {
+    return (this->grade_ != TOUCH_PAD_DENOISE_MAX) && (this->cap_level_ != TOUCH_PAD_DENOISE_CAP_MAX);
+  }
+  bool waterproof_configured_() const {
+    return (this->waterproof_guard_ring_pad_ != TOUCH_PAD_MAX) &&
+           (this->waterproof_shield_driver_ != TOUCH_PAD_SHIELD_DRV_MAX);
+  }
+
+  // Helper method to read touch values - non-blocking operation
+  // Returns the current touch pad value using either filtered or raw reading
+  // based on the filter configuration
+  uint32_t read_touch_value(touch_pad_t pad) const;
+
+  // Helper to update touch state with a known state
+  void update_touch_state_(ESP32TouchBinarySensor *child, bool is_touched);
+
+  // Helper to read touch value and update state for a given child
+  bool check_and_update_touch_state_(ESP32TouchBinarySensor *child);
 #endif
+
+  // Helper functions for dump_config - common to both implementations
+  static const char *get_low_voltage_reference_str(touch_low_volt_t ref) {
+    switch (ref) {
+      case TOUCH_LVOLT_0V5:
+        return "0.5V";
+      case TOUCH_LVOLT_0V6:
+        return "0.6V";
+      case TOUCH_LVOLT_0V7:
+        return "0.7V";
+      case TOUCH_LVOLT_0V8:
+        return "0.8V";
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  static const char *get_high_voltage_reference_str(touch_high_volt_t ref) {
+    switch (ref) {
+      case TOUCH_HVOLT_2V4:
+        return "2.4V";
+      case TOUCH_HVOLT_2V5:
+        return "2.5V";
+      case TOUCH_HVOLT_2V6:
+        return "2.6V";
+      case TOUCH_HVOLT_2V7:
+        return "2.7V";
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  static const char *get_voltage_attenuation_str(touch_volt_atten_t atten) {
+    switch (atten) {
+      case TOUCH_HVOLT_ATTEN_1V5:
+        return "1.5V";
+      case TOUCH_HVOLT_ATTEN_1V:
+        return "1V";
+      case TOUCH_HVOLT_ATTEN_0V5:
+        return "0.5V";
+      case TOUCH_HVOLT_ATTEN_0V:
+        return "0V";
+      default:
+        return "UNKNOWN";
+    }
+  }
 };
 
 /// Simple helper class to expose a touch pad value as a binary sensor.
 class ESP32TouchBinarySensor : public binary_sensor::BinarySensor {
  public:
-  ESP32TouchBinarySensor(touch_pad_t touch_pad, uint32_t threshold, uint32_t wakeup_threshold);
+  ESP32TouchBinarySensor(touch_pad_t touch_pad, uint32_t threshold, uint32_t wakeup_threshold)
+      : touch_pad_(touch_pad), threshold_(threshold), wakeup_threshold_(wakeup_threshold) {}
 
   touch_pad_t get_touch_pad() const { return this->touch_pad_; }
   uint32_t get_threshold() const { return this->threshold_; }
   void set_threshold(uint32_t threshold) { this->threshold_ = threshold; }
+#ifdef USE_ESP32_VARIANT_ESP32
   uint32_t get_value() const { return this->value_; }
+#endif
   uint32_t get_wakeup_threshold() const { return this->wakeup_threshold_; }
 
  protected:
@@ -112,8 +244,22 @@ class ESP32TouchBinarySensor : public binary_sensor::BinarySensor {
 
   touch_pad_t touch_pad_{TOUCH_PAD_MAX};
   uint32_t threshold_{0};
+  uint32_t benchmark_{};
+#ifdef USE_ESP32_VARIANT_ESP32
   uint32_t value_{0};
+#endif
+  bool last_state_{false};
   const uint32_t wakeup_threshold_{0};
+
+  // Track last touch time for timeout-based release detection
+  // Design note: last_touch_time_ does not require synchronization primitives because:
+  // 1. ESP32 guarantees atomic 32-bit aligned reads/writes
+  // 2. ISR only writes timestamps, main loop only reads
+  // 3. Timing tolerance allows for occasional stale reads (50ms check interval)
+  // 4. Queue operations provide implicit memory barriers
+  // Using atomic/critical sections would add overhead without meaningful benefit
+  uint32_t last_touch_time_{};
+  bool initial_state_published_{};
 };
 
 }  // namespace esp32_touch