esphome 2025.9.2__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

esphome/components/captive_portal/dns_server_esp32_idf.cpp

@@ -0,0 +1,205 @@
+#include "dns_server_esp32_idf.h"
+#ifdef USE_ESP_IDF
+
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+#include "esphome/components/socket/socket.h"
+#include <lwip/sockets.h>
+#include <lwip/inet.h>
+
+namespace esphome::captive_portal {
+
+static const char *const TAG = "captive_portal.dns";
+
+// DNS constants
+static constexpr uint16_t DNS_PORT = 53;
+static constexpr uint16_t DNS_QR_FLAG = 1 << 15;
+static constexpr uint16_t DNS_OPCODE_MASK = 0x7800;
+static constexpr uint16_t DNS_QTYPE_A = 0x0001;
+static constexpr uint16_t DNS_QCLASS_IN = 0x0001;
+static constexpr uint16_t DNS_ANSWER_TTL = 300;
+
+// DNS Header structure
+struct DNSHeader {
+  uint16_t id;
+  uint16_t flags;
+  uint16_t qd_count;
+  uint16_t an_count;
+  uint16_t ns_count;
+  uint16_t ar_count;
+} __attribute__((packed));
+
+// DNS Question structure
+struct DNSQuestion {
+  uint16_t type;
+  uint16_t dns_class;
+} __attribute__((packed));
+
+// DNS Answer structure
+struct DNSAnswer {
+  uint16_t ptr_offset;
+  uint16_t type;
+  uint16_t dns_class;
+  uint32_t ttl;
+  uint16_t addr_len;
+  uint32_t ip_addr;
+} __attribute__((packed));
+
+void DNSServer::start(const network::IPAddress &ip) {
+  this->server_ip_ = ip;
+  ESP_LOGV(TAG, "Starting DNS server on %s", ip.str().c_str());
+
+  // Create loop-monitored UDP socket
+  this->socket_ = socket::socket_ip_loop_monitored(SOCK_DGRAM, IPPROTO_UDP);
+  if (this->socket_ == nullptr) {
+    ESP_LOGE(TAG, "Socket create failed");
+    return;
+  }
+
+  // Set socket options
+  int enable = 1;
+  this->socket_->setsockopt(SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
+
+  // Bind to port 53
+  struct sockaddr_storage server_addr = {};
+  socklen_t addr_len = socket::set_sockaddr_any((struct sockaddr *) &server_addr, sizeof(server_addr), DNS_PORT);
+
+  int err = this->socket_->bind((struct sockaddr *) &server_addr, addr_len);
+  if (err != 0) {
+    ESP_LOGE(TAG, "Bind failed: %d", errno);
+    this->socket_ = nullptr;
+    return;
+  }
+  ESP_LOGV(TAG, "Bound to port %d", DNS_PORT);
+}
+
+void DNSServer::stop() {
+  if (this->socket_ != nullptr) {
+    this->socket_->close();
+    this->socket_ = nullptr;
+  }
+  ESP_LOGV(TAG, "Stopped");
+}
+
+void DNSServer::process_next_request() {
+  // Process one request if socket is valid and data is available
+  if (this->socket_ == nullptr || !this->socket_->ready()) {
+    return;
+  }
+  struct sockaddr_in client_addr;
+  socklen_t client_addr_len = sizeof(client_addr);
+
+  // Receive DNS request using raw fd for recvfrom
+  int fd = this->socket_->get_fd();
+  if (fd < 0) {
+    return;
+  }
+
+  ssize_t len = recvfrom(fd, this->buffer_, sizeof(this->buffer_), MSG_DONTWAIT, (struct sockaddr *) &client_addr,
+                         &client_addr_len);
+
+  if (len < 0) {
+    if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR) {
+      ESP_LOGE(TAG, "recvfrom failed: %d", errno);
+    }
+    return;
+  }
+
+  ESP_LOGVV(TAG, "Received %d bytes from %s:%d", len, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
+
+  if (len < static_cast<ssize_t>(sizeof(DNSHeader) + 1)) {
+    ESP_LOGV(TAG, "Request too short: %d", len);
+    return;
+  }
+
+  // Parse DNS header
+  DNSHeader *header = (DNSHeader *) this->buffer_;
+  uint16_t flags = ntohs(header->flags);
+  uint16_t qd_count = ntohs(header->qd_count);
+
+  // Check if it's a standard query
+  if ((flags & DNS_QR_FLAG) || (flags & DNS_OPCODE_MASK) || qd_count != 1) {
+    ESP_LOGV(TAG, "Not a standard query: flags=0x%04X, qd_count=%d", flags, qd_count);
+    return;  // Not a standard query
+  }
+
+  // Parse domain name (we don't actually care about it - redirect everything)
+  uint8_t *ptr = this->buffer_ + sizeof(DNSHeader);
+  uint8_t *end = this->buffer_ + len;
+
+  while (ptr < end && *ptr != 0) {
+    uint8_t label_len = *ptr;
+    if (label_len > 63) {  // Check for invalid label length
+      return;
+    }
+    // Check if we have room for this label plus the length byte
+    if (ptr + label_len + 1 > end) {
+      return;  // Would overflow
+    }
+    ptr += label_len + 1;
+  }
+
+  // Check if we reached a proper null terminator
+  if (ptr >= end || *ptr != 0) {
+    return;  // Name not terminated or truncated
+  }
+  ptr++;  // Skip the null terminator
+
+  // Check we have room for the question
+  if (ptr + sizeof(DNSQuestion) > end) {
+    return;  // Request truncated
+  }
+
+  // Parse DNS question
+  DNSQuestion *question = (DNSQuestion *) ptr;
+  uint16_t qtype = ntohs(question->type);
+  uint16_t qclass = ntohs(question->dns_class);
+
+  // We only handle A queries
+  if (qtype != DNS_QTYPE_A || qclass != DNS_QCLASS_IN) {
+    ESP_LOGV(TAG, "Not an A query: type=0x%04X, class=0x%04X", qtype, qclass);
+    return;  // Not an A query
+  }
+
+  // Build DNS response by modifying the request in-place
+  header->flags = htons(DNS_QR_FLAG | 0x8000);  // Response + Authoritative
+  header->an_count = htons(1);                  // One answer
+
+  // Add answer section after the question
+  size_t question_len = (ptr + sizeof(DNSQuestion)) - this->buffer_ - sizeof(DNSHeader);
+  size_t answer_offset = sizeof(DNSHeader) + question_len;
+
+  // Check if we have room for the answer
+  if (answer_offset + sizeof(DNSAnswer) > sizeof(this->buffer_)) {
+    ESP_LOGW(TAG, "Response too large");
+    return;
+  }
+
+  DNSAnswer *answer = (DNSAnswer *) (this->buffer_ + answer_offset);
+
+  // Pointer to name in question (offset from start of packet)
+  answer->ptr_offset = htons(0xC000 | sizeof(DNSHeader));
+  answer->type = htons(DNS_QTYPE_A);
+  answer->dns_class = htons(DNS_QCLASS_IN);
+  answer->ttl = htonl(DNS_ANSWER_TTL);
+  answer->addr_len = htons(4);
+
+  // Get the raw IP address
+  ip4_addr_t addr = this->server_ip_;
+  answer->ip_addr = addr.addr;
+
+  size_t response_len = answer_offset + sizeof(DNSAnswer);
+
+  // Send response
+  ssize_t sent =
+      this->socket_->sendto(this->buffer_, response_len, 0, (struct sockaddr *) &client_addr, client_addr_len);
+  if (sent < 0) {
+    ESP_LOGV(TAG, "Send failed: %d", errno);
+  } else {
+    ESP_LOGV(TAG, "Sent %d bytes", sent);
+  }
+}
+
+}  // namespace esphome::captive_portal
+
+#endif  // USE_ESP_IDF

esphome/components/captive_portal/dns_server_esp32_idf.h

@@ -0,0 +1,27 @@
+#pragma once
+#ifdef USE_ESP_IDF
+
+#include <memory>
+#include "esphome/core/helpers.h"
+#include "esphome/components/network/ip_address.h"
+#include "esphome/components/socket/socket.h"
+
+namespace esphome::captive_portal {
+
+class DNSServer {
+ public:
+  void start(const network::IPAddress &ip);
+  void stop();
+  void process_next_request();
+
+ protected:
+  static constexpr size_t DNS_BUFFER_SIZE = 192;
+
+  std::unique_ptr<socket::Socket> socket_{nullptr};
+  network::IPAddress server_ip_;
+  uint8_t buffer_[DNS_BUFFER_SIZE];
+};
+
+}  // namespace esphome::captive_portal
+
+#endif  // USE_ESP_IDF

esphome/components/ccs811/ccs811.cpp

@@ -155,7 +155,7 @@ void CCS811Component::dump_config() {
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "CO2 Sensor", this->co2_);
   LOG_SENSOR("  ", "TVOC Sensor", this->tvoc_);
-  LOG_TEXT_SENSOR("  ", "Firmware Version Sensor", this->version_)
+  LOG_TEXT_SENSOR("  ", "Firmware Version Sensor", this->version_);
   if (this->baseline_) {
     ESP_LOGCONFIG(TAG, "  Baseline: %04X", *this->baseline_);
   } else {

esphome/components/climate/climate.cpp

@@ -367,9 +367,11 @@ void Climate::save_state_() {
     state.uses_custom_fan_mode = true;
     const auto &supported = traits.get_supported_custom_fan_modes();
     std::vector<std::string> vec{supported.begin(), supported.end()};
-    auto it = std::find(vec.begin(), vec.end(), custom_fan_mode);
-    if (it != vec.end()) {
-      state.custom_fan_mode = std::distance(vec.begin(), it);
+    for (size_t i = 0; i < vec.size(); i++) {
+      if (vec[i] == custom_fan_mode) {
+        state.custom_fan_mode = i;
+        break;
+      }
     }
   }
   if (traits.get_supports_presets() && preset.has_value()) {
@@ -380,10 +382,11 @@ void Climate::save_state_() {
     state.uses_custom_preset = true;
     const auto &supported = traits.get_supported_custom_presets();
     std::vector<std::string> vec{supported.begin(), supported.end()};
-    auto it = std::find(vec.begin(), vec.end(), custom_preset);
-    // only set custom preset if value exists, otherwise leave it as is
-    if (it != vec.cend()) {
-      state.custom_preset = std::distance(vec.begin(), it);
+    for (size_t i = 0; i < vec.size(); i++) {
+      if (vec[i] == custom_preset) {
+        state.custom_preset = i;
+        break;
+      }
     }
   }
   if (traits.get_supports_swing_modes()) {

esphome/components/cm1106/cm1106.cpp

@@ -13,7 +13,7 @@ static const uint8_t C_M1106_CMD_SET_CO2_CALIB_RESPONSE[4] = {0x16, 0x01, 0x03,
 
 uint8_t cm1106_checksum(const uint8_t *response, size_t len) {
   uint8_t crc = 0;
-  for (int i = 0; i < len - 1; i++) {
+  for (size_t i = 0; i < len - 1; i++) {
     crc -= response[i];
   }
   return crc;

esphome/components/copy/lock/copy_lock.cpp

@@ -11,7 +11,7 @@ void CopyLock::setup() {
 
   traits.set_assumed_state(source_->traits.get_assumed_state());
   traits.set_requires_code(source_->traits.get_requires_code());
-  traits.set_supported_states(source_->traits.get_supported_states());
+  traits.set_supported_states_mask(source_->traits.get_supported_states_mask());
   traits.set_supports_open(source_->traits.get_supports_open());
 
   this->publish_state(source_->state);

esphome/components/cover/cover.cpp

@@ -1,5 +1,6 @@
 #include "cover.h"
 #include "esphome/core/log.h"
+#include <strings.h>
 
 namespace esphome {
 namespace cover {

esphome/components/daikin_arc/daikin_arc.cpp

@@ -26,7 +26,7 @@ void DaikinArcClimate::transmit_query_() {
   uint8_t remote_header[8] = {0x11, 0xDA, 0x27, 0x00, 0x84, 0x87, 0x20, 0x00};
 
   // Calculate checksum
-  for (int i = 0; i < sizeof(remote_header) - 1; i++) {
+  for (size_t i = 0; i < sizeof(remote_header) - 1; i++) {
     remote_header[sizeof(remote_header) - 1] += remote_header[i];
   }
 
@@ -102,7 +102,7 @@ void DaikinArcClimate::transmit_state() {
   remote_state[9] = fan_speed & 0xff;
 
   // Calculate checksum
-  for (int i = 0; i < sizeof(remote_header) - 1; i++) {
+  for (size_t i = 0; i < sizeof(remote_header) - 1; i++) {
     remote_header[sizeof(remote_header) - 1] += remote_header[i];
   }
 
@@ -350,7 +350,7 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
   bool valid_daikin_frame = false;
   if (data.expect_item(DAIKIN_HEADER_MARK, DAIKIN_HEADER_SPACE)) {
     valid_daikin_frame = true;
-    int bytes_count = data.size() / 2 / 8;
+    size_t bytes_count = data.size() / 2 / 8;
     std::unique_ptr<char[]> buf(new char[bytes_count * 3 + 1]);
     buf[0] = '\0';
     for (size_t i = 0; i < bytes_count; i++) {
@@ -370,7 +370,7 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
   if (!valid_daikin_frame) {
     char sbuf[16 * 10 + 1];
     sbuf[0] = '\0';
-    for (size_t j = 0; j < data.size(); j++) {
+    for (size_t j = 0; j < static_cast<size_t>(data.size()); j++) {
       if ((j - 2) % 16 == 0) {
         if (j > 0) {
           ESP_LOGD(TAG, "DATA %04x: %s", (j - 16 > 0xffff ? 0 : j - 16), sbuf);
@@ -380,19 +380,26 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
       char type_ch = ' ';
       // debug_tolerance = 25%
 
-      if (DAIKIN_DBG_LOWER(DAIKIN_ARC_PRE_MARK) <= data[j] && data[j] <= DAIKIN_DBG_UPPER(DAIKIN_ARC_PRE_MARK))
+      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_ARC_PRE_MARK)) <= data[j] &&
+          data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_ARC_PRE_MARK)))
         type_ch = 'P';
-      if (DAIKIN_DBG_LOWER(DAIKIN_ARC_PRE_SPACE) <= -data[j] && -data[j] <= DAIKIN_DBG_UPPER(DAIKIN_ARC_PRE_SPACE))
+      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_ARC_PRE_SPACE)) <= -data[j] &&
+          -data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_ARC_PRE_SPACE)))
         type_ch = 'a';
-      if (DAIKIN_DBG_LOWER(DAIKIN_HEADER_MARK) <= data[j] && data[j] <= DAIKIN_DBG_UPPER(DAIKIN_HEADER_MARK))
+      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_HEADER_MARK)) <= data[j] &&
+          data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_HEADER_MARK)))
         type_ch = 'H';
-      if (DAIKIN_DBG_LOWER(DAIKIN_HEADER_SPACE) <= -data[j] && -data[j] <= DAIKIN_DBG_UPPER(DAIKIN_HEADER_SPACE))
+      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_HEADER_SPACE)) <= -data[j] &&
+          -data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_HEADER_SPACE)))
         type_ch = 'h';
-      if (DAIKIN_DBG_LOWER(DAIKIN_BIT_MARK) <= data[j] && data[j] <= DAIKIN_DBG_UPPER(DAIKIN_BIT_MARK))
+      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_BIT_MARK)) <= data[j] &&
+          data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_BIT_MARK)))
         type_ch = 'B';
-      if (DAIKIN_DBG_LOWER(DAIKIN_ONE_SPACE) <= -data[j] && -data[j] <= DAIKIN_DBG_UPPER(DAIKIN_ONE_SPACE))
+      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_ONE_SPACE)) <= -data[j] &&
+          -data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_ONE_SPACE)))
         type_ch = '1';
-      if (DAIKIN_DBG_LOWER(DAIKIN_ZERO_SPACE) <= -data[j] && -data[j] <= DAIKIN_DBG_UPPER(DAIKIN_ZERO_SPACE))
+      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_ZERO_SPACE)) <= -data[j] &&
+          -data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_ZERO_SPACE)))
         type_ch = '0';
 
       if (abs(data[j]) > 100000) {
@@ -400,7 +407,7 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
       } else {
         sprintf(sbuf, "%s%-5d[%c] ", sbuf, (int) (round(data[j] / 10.) * 10), type_ch);
       }
-      if (j == data.size() - 1) {
+      if (j + 1 == static_cast<size_t>(data.size())) {
         ESP_LOGD(TAG, "DATA %04x: %s", (j - 8 > 0xffff ? 0 : j - 8), sbuf);
       }
     }

esphome/components/deep_sleep/__init__.py

@@ -197,7 +197,8 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_ESP32_EXT1_WAKEUP): cv.All(
                 cv.only_on_esp32,
                 esp32.only_on_variant(
-                    unsupported=[VARIANT_ESP32C3], msg_prefix="Wakeup from ext1"
+                    unsupported=[VARIANT_ESP32C2, VARIANT_ESP32C3],
+                    msg_prefix="Wakeup from ext1",
                 ),
                 cv.Schema(
                     {
@@ -214,7 +215,13 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_TOUCH_WAKEUP): cv.All(
                 cv.only_on_esp32,
                 esp32.only_on_variant(
-                    unsupported=[VARIANT_ESP32C3], msg_prefix="Wakeup from touch"
+                    unsupported=[
+                        VARIANT_ESP32C2,
+                        VARIANT_ESP32C3,
+                        VARIANT_ESP32C6,
+                        VARIANT_ESP32H2,
+                    ],
+                    msg_prefix="Wakeup from touch",
                 ),
                 cv.boolean,
             ),

esphome/components/deep_sleep/deep_sleep_component.h

@@ -34,7 +34,7 @@ enum WakeupPinMode {
   WAKEUP_PIN_MODE_INVERT_WAKEUP,
 };
 
-#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3)
+#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3)
 struct Ext1Wakeup {
   uint64_t mask;
   esp_sleep_ext1_wakeup_mode_t wakeup_mode;
@@ -50,7 +50,7 @@ struct WakeupCauseToRunDuration {
   uint32_t gpio_cause;
 };
 
-#endif
+#endif  // USE_ESP32
 
 template<typename... Ts> class EnterDeepSleepAction;
 
@@ -73,20 +73,22 @@ class DeepSleepComponent : public Component {
   void set_wakeup_pin(InternalGPIOPin *pin) { this->wakeup_pin_ = pin; }
 
   void set_wakeup_pin_mode(WakeupPinMode wakeup_pin_mode);
-#endif
+#endif  // USE_ESP32
 
 #if defined(USE_ESP32)
-#if !defined(USE_ESP32_VARIANT_ESP32C3)
-
+#if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3)
   void set_ext1_wakeup(Ext1Wakeup ext1_wakeup);
+#endif
 
+#if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3) && \
+    !defined(USE_ESP32_VARIANT_ESP32C6) && !defined(USE_ESP32_VARIANT_ESP32H2)
   void set_touch_wakeup(bool touch_wakeup);
-
 #endif
+
   // Set the duration in ms for how long the code should run before entering
   // deep sleep mode, according to the cause the ESP32 has woken.
   void set_run_duration(WakeupCauseToRunDuration wakeup_cause_to_run_duration);
-#endif
+#endif  // USE_ESP32
 
   /// Set a duration in ms for how long the code should run before entering deep sleep mode.
   void set_run_duration(uint32_t time_ms);
@@ -117,13 +119,13 @@ class DeepSleepComponent : public Component {
   InternalGPIOPin *wakeup_pin_;
   WakeupPinMode wakeup_pin_mode_{WAKEUP_PIN_MODE_IGNORE};
 
-#if !defined(USE_ESP32_VARIANT_ESP32C3)
+#if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3)
   optional<Ext1Wakeup> ext1_wakeup_;
 #endif
 
   optional<bool> touch_wakeup_;
   optional<WakeupCauseToRunDuration> wakeup_cause_to_run_duration_;
-#endif
+#endif  // USE_ESP32
   optional<uint32_t> run_duration_;
   bool next_enter_deep_sleep_{false};
   bool prevent_{false};

esphome/components/deep_sleep/deep_sleep_esp32.cpp

@@ -7,6 +7,26 @@
 namespace esphome {
 namespace deep_sleep {
 
+// Deep Sleep feature support matrix for ESP32 variants:
+//
+// | Variant   | ext0 | ext1 | Touch | GPIO wakeup |
+// |-----------|------|------|-------|-------------|
+// | ESP32     | ✓    | ✓    | ✓     |             |
+// | ESP32-S2  | ✓    | ✓    | ✓     |             |
+// | ESP32-S3  | ✓    | ✓    | ✓     |             |
+// | ESP32-C2  |      |      |       | ✓           |
+// | ESP32-C3  |      |      |       | ✓           |
+// | ESP32-C5  |      | (✓)  |       | (✓)         |
+// | ESP32-C6  |      | ✓    |       | ✓           |
+// | ESP32-H2  |      | ✓    |       |             |
+//
+// Notes:
+// - (✓) = Supported by hardware but not yet implemented in ESPHome
+// - ext0: Single pin wakeup using RTC GPIO (esp_sleep_enable_ext0_wakeup)
+// - ext1: Multiple pin wakeup (esp_sleep_enable_ext1_wakeup)
+// - Touch: Touch pad wakeup (esp_sleep_enable_touchpad_wakeup)
+// - GPIO wakeup: GPIO wakeup for non-RTC pins (esp_deep_sleep_enable_gpio_wakeup)
+
 static const char *const TAG = "deep_sleep";
 
 optional<uint32_t> DeepSleepComponent::get_run_duration_() const {
@@ -30,13 +50,13 @@ void DeepSleepComponent::set_wakeup_pin_mode(WakeupPinMode wakeup_pin_mode) {
   this->wakeup_pin_mode_ = wakeup_pin_mode;
 }
 
-#if !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32C6)
+#if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3)
 void DeepSleepComponent::set_ext1_wakeup(Ext1Wakeup ext1_wakeup) { this->ext1_wakeup_ = ext1_wakeup; }
-
-#if !defined(USE_ESP32_VARIANT_ESP32H2)
-void DeepSleepComponent::set_touch_wakeup(bool touch_wakeup) { this->touch_wakeup_ = touch_wakeup; }
 #endif
 
+#if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3) && \
+    !defined(USE_ESP32_VARIANT_ESP32C6) && !defined(USE_ESP32_VARIANT_ESP32H2)
+void DeepSleepComponent::set_touch_wakeup(bool touch_wakeup) { this->touch_wakeup_ = touch_wakeup; }
 #endif
 
 void DeepSleepComponent::set_run_duration(WakeupCauseToRunDuration wakeup_cause_to_run_duration) {
@@ -72,9 +92,13 @@ bool DeepSleepComponent::prepare_to_sleep_() {
 }
 
 void DeepSleepComponent::deep_sleep_() {
-#if !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32C6) && !defined(USE_ESP32_VARIANT_ESP32H2)
+  // Timer wakeup - all variants support this
   if (this->sleep_duration_.has_value())
     esp_sleep_enable_timer_wakeup(*this->sleep_duration_);
+
+    // Single pin wakeup (ext0) - ESP32, S2, S3 only
+#if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3) && \
+    !defined(USE_ESP32_VARIANT_ESP32C6) && !defined(USE_ESP32_VARIANT_ESP32H2)
   if (this->wakeup_pin_ != nullptr) {
     const auto gpio_pin = gpio_num_t(this->wakeup_pin_->get_pin());
     if (this->wakeup_pin_->get_flags() & gpio::FLAG_PULLUP) {
@@ -95,32 +119,15 @@ void DeepSleepComponent::deep_sleep_() {
     }
     esp_sleep_enable_ext0_wakeup(gpio_pin, level);
   }
-  if (this->ext1_wakeup_.has_value()) {
-    esp_sleep_enable_ext1_wakeup(this->ext1_wakeup_->mask, this->ext1_wakeup_->wakeup_mode);
-  }
-
-  if (this->touch_wakeup_.has_value() && *(this->touch_wakeup_)) {
-    esp_sleep_enable_touchpad_wakeup();
-    esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
-  }
 #endif
 
-#if defined(USE_ESP32_VARIANT_ESP32H2)
-  if (this->sleep_duration_.has_value())
-    esp_sleep_enable_timer_wakeup(*this->sleep_duration_);
-  if (this->ext1_wakeup_.has_value()) {
-    esp_sleep_enable_ext1_wakeup(this->ext1_wakeup_->mask, this->ext1_wakeup_->wakeup_mode);
-  }
-#endif
-
-#if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6)
-  if (this->sleep_duration_.has_value())
-    esp_sleep_enable_timer_wakeup(*this->sleep_duration_);
+  // GPIO wakeup - C2, C3, C6 only
+#if defined(USE_ESP32_VARIANT_ESP32C2) || defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6)
   if (this->wakeup_pin_ != nullptr) {
     const auto gpio_pin = gpio_num_t(this->wakeup_pin_->get_pin());
-    if (this->wakeup_pin_->get_flags() && gpio::FLAG_PULLUP) {
+    if (this->wakeup_pin_->get_flags() & gpio::FLAG_PULLUP) {
       gpio_sleep_set_pull_mode(gpio_pin, GPIO_PULLUP_ONLY);
-    } else if (this->wakeup_pin_->get_flags() && gpio::FLAG_PULLDOWN) {
+    } else if (this->wakeup_pin_->get_flags() & gpio::FLAG_PULLDOWN) {
       gpio_sleep_set_pull_mode(gpio_pin, GPIO_PULLDOWN_ONLY);
     }
     gpio_sleep_set_direction(gpio_pin, GPIO_MODE_INPUT);
@@ -138,9 +145,26 @@ void DeepSleepComponent::deep_sleep_() {
                                       static_cast<esp_deepsleep_gpio_wake_up_mode_t>(level));
   }
 #endif
+
+  // Multiple pin wakeup (ext1) - All except C2, C3
+#if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3)
+  if (this->ext1_wakeup_.has_value()) {
+    esp_sleep_enable_ext1_wakeup(this->ext1_wakeup_->mask, this->ext1_wakeup_->wakeup_mode);
+  }
+#endif
+
+  // Touch wakeup - ESP32, S2, S3 only
+#if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3) && \
+    !defined(USE_ESP32_VARIANT_ESP32C6) && !defined(USE_ESP32_VARIANT_ESP32H2)
+  if (this->touch_wakeup_.has_value() && *(this->touch_wakeup_)) {
+    esp_sleep_enable_touchpad_wakeup();
+    esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
+  }
+#endif
+
   esp_deep_sleep_start();
 }
 
 }  // namespace deep_sleep
 }  // namespace esphome
-#endif
+#endif  // USE_ESP32

esphome/components/ektf2232/touchscreen/__init__.py

@@ -2,7 +2,7 @@ from esphome import pins
 import esphome.codegen as cg
 from esphome.components import i2c, touchscreen
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_INTERRUPT_PIN
+from esphome.const import CONF_ID, CONF_INTERRUPT_PIN, CONF_RESET_PIN
 
 CODEOWNERS = ["@jesserockz"]
 DEPENDENCIES = ["i2c"]
@@ -15,7 +15,7 @@ EKTF2232Touchscreen = ektf2232_ns.class_(
 )
 
 CONF_EKTF2232_ID = "ektf2232_id"
-CONF_RTS_PIN = "rts_pin"
+CONF_RTS_PIN = "rts_pin"  # To be removed before 2026.4.0
 
 CONFIG_SCHEMA = touchscreen.TOUCHSCREEN_SCHEMA.extend(
     cv.Schema(
@@ -24,7 +24,10 @@ CONFIG_SCHEMA = touchscreen.TOUCHSCREEN_SCHEMA.extend(
             cv.Required(CONF_INTERRUPT_PIN): cv.All(
                 pins.internal_gpio_input_pin_schema
             ),
-            cv.Required(CONF_RTS_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_RESET_PIN): pins.gpio_output_pin_schema,
+            cv.Optional(CONF_RTS_PIN): cv.invalid(
+                f"{CONF_RTS_PIN} has been renamed to {CONF_RESET_PIN}"
+            ),
         }
     ).extend(i2c.i2c_device_schema(0x15))
 )
@@ -37,5 +40,5 @@ async def to_code(config):
 
     interrupt_pin = await cg.gpio_pin_expression(config[CONF_INTERRUPT_PIN])
     cg.add(var.set_interrupt_pin(interrupt_pin))
-    rts_pin = await cg.gpio_pin_expression(config[CONF_RTS_PIN])
-    cg.add(var.set_rts_pin(rts_pin))
+    reset_pin = await cg.gpio_pin_expression(config[CONF_RESET_PIN])
+    cg.add(var.set_reset_pin(reset_pin))

esphome/components/ektf2232/touchscreen/ektf2232.cpp

@@ -21,7 +21,7 @@ void EKTF2232Touchscreen::setup() {
 
   this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
 
-  this->rts_pin_->setup();
+  this->reset_pin_->setup();
 
   this->hard_reset_();
   if (!this->soft_reset_()) {
@@ -98,9 +98,9 @@ bool EKTF2232Touchscreen::get_power_state() {
 }
 
 void EKTF2232Touchscreen::hard_reset_() {
-  this->rts_pin_->digital_write(false);
+  this->reset_pin_->digital_write(false);
   delay(15);
-  this->rts_pin_->digital_write(true);
+  this->reset_pin_->digital_write(true);
   delay(15);
 }
 
@@ -127,7 +127,7 @@ void EKTF2232Touchscreen::dump_config() {
   ESP_LOGCONFIG(TAG, "EKT2232 Touchscreen:");
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
-  LOG_PIN("  RTS Pin: ", this->rts_pin_);
+  LOG_PIN("  Reset Pin: ", this->reset_pin_);
 }
 
 }  // namespace ektf2232