lock

.github/workflows/ci.yml

@@ -377,7 +377,15 @@ jobs:
         id: list-components
         run: |
           . venv/bin/activate
-          components=$(script/list-components.py --changed --branch ${{ steps.target-branch.outputs.branch }})
+
+          # Check if we should test all components (via label)
+          if [[ "${{ contains(github.event.pull_request.labels.*.name, 'test-all-components') }}" == "true" ]]; then
+            echo "Label 'test-all-components' found - testing ALL components"
+            components=$(script/list-components.py)
+          else
+            components=$(script/list-components.py --changed --branch ${{ steps.target-branch.outputs.branch }})
+          fi
+
           output_components=$(echo "$components" | jq -R -s -c 'split("\n")[:-1] | map(select(length > 0))')
           count=$(echo "$output_components" | jq length)
 
@@ -415,11 +423,15 @@ jobs:
       - name: test_build_components -e config -c ${{ matrix.file }}
         run: |
           . venv/bin/activate
-          ./script/test_build_components -e config -c ${{ matrix.file }}
+          # Use 4 parallel jobs for config validation
+          ./script/test_build_components -e config -c ${{ matrix.file }} -j 4 -f
       - name: test_build_components -e compile -c ${{ matrix.file }}
         run: |
           . venv/bin/activate
-          ./script/test_build_components -e compile -c ${{ matrix.file }}
+          mkdir -p build_cache
+          export PLATFORMIO_BUILD_CACHE_DIR=$PWD/build_cache
+          # Use 2 parallel jobs for compilation (resource intensive)
+          ./script/test_build_components -e compile -c ${{ matrix.file }} -j 2 -f -b $PWD/build_cache
 
   test-build-components-splitter:
     name: Split components for testing into 20 groups maximum
@@ -471,17 +483,28 @@ jobs:
       - name: Validate config
         run: |
           . venv/bin/activate
-          for component in ${{ matrix.components }}; do
-            ./script/test_build_components -e config -c $component
+          # Process all components in parallel for config validation
+          components="${{ matrix.components }}"
+          # Convert space-separated list to multiple -c flags
+          component_args=""
+          for component in $components; do
+            component_args="$component_args -c $component"
           done
+          # Use 8 parallel jobs for lightweight config validation
+          ./script/test_build_components -e config $component_args -j 8 -f
       - name: Compile config
         run: |
           . venv/bin/activate
-          mkdir build_cache
+          mkdir -p build_cache
           export PLATFORMIO_BUILD_CACHE_DIR=$PWD/build_cache
-          for component in ${{ matrix.components }}; do
-            ./script/test_build_components -e compile -c $component
+          # Process all components in parallel for compilation
+          components="${{ matrix.components }}"
+          component_args=""
+          for component in $components; do
+            component_args="$component_args -c $component"
           done
+          # Use 4 parallel jobs for resource-intensive compilation
+          ./script/test_build_components -e compile $component_args -j 4 -f -b $PWD/build_cache
 
   ci-status:
     name: CI Status

esphome/components/esp32_touch/esp32_touch.cpp

@@ -0,0 +1,355 @@
+#ifdef USE_ESP32
+
+#include "esp32_touch.h"
+#include "esphome/core/application.h"
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+
+#include <cinttypes>
+
+namespace esphome {
+namespace esp32_touch {
+
+static const char *const TAG = "esp32_touch";
+
+void ESP32TouchComponent::setup() {
+  ESP_LOGCONFIG(TAG, "Running setup");
+  touch_pad_init();
+// set up and enable/start filtering based on ESP32 variant
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+  if (this->filter_configured_()) {
+    touch_filter_config_t filter_info = {
+        .mode = this->filter_mode_,
+        .debounce_cnt = this->debounce_count_,
+        .noise_thr = this->noise_threshold_,
+        .jitter_step = this->jitter_step_,
+        .smh_lvl = this->smooth_level_,
+    };
+    touch_pad_filter_set_config(&filter_info);
+    touch_pad_filter_enable();
+  }
+
+  if (this->denoise_configured_()) {
+    touch_pad_denoise_t denoise = {
+        .grade = this->grade_,
+        .cap_level = this->cap_level_,
+    };
+    touch_pad_denoise_set_config(&denoise);
+    touch_pad_denoise_enable();
+  }
+
+  if (this->waterproof_configured_()) {
+    touch_pad_waterproof_t waterproof = {
+        .guard_ring_pad = this->waterproof_guard_ring_pad_,
+        .shield_driver = this->waterproof_shield_driver_,
+    };
+    touch_pad_waterproof_set_config(&waterproof);
+    touch_pad_waterproof_enable();
+  }
+#else
+  if (this->iir_filter_enabled_()) {
+    touch_pad_filter_start(this->iir_filter_);
+  }
+#endif
+
+#if ESP_IDF_VERSION_MAJOR >= 5 && defined(USE_ESP32_VARIANT_ESP32)
+  touch_pad_set_measurement_clock_cycles(this->meas_cycle_);
+  touch_pad_set_measurement_interval(this->sleep_cycle_);
+#else
+  touch_pad_set_meas_time(this->sleep_cycle_, this->meas_cycle_);
+#endif
+  touch_pad_set_voltage(this->high_voltage_reference_, this->low_voltage_reference_, this->voltage_attenuation_);
+
+  for (auto *child : this->children_) {
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+    touch_pad_config(child->get_touch_pad());
+#else
+    // Disable interrupt threshold
+    touch_pad_config(child->get_touch_pad(), 0);
+#endif
+  }
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+  touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
+  touch_pad_fsm_start();
+#endif
+}
+
+void ESP32TouchComponent::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "Config for ESP32 Touch Hub:\n"
+                "  Meas cycle: %.2fms\n"
+                "  Sleep cycle: %.2fms",
+                this->meas_cycle_ / (8000000.0f / 1000.0f), this->sleep_cycle_ / (150000.0f / 1000.0f));
+
+  const char *lv_s;
+  switch (this->low_voltage_reference_) {
+    case TOUCH_LVOLT_0V5:
+      lv_s = "0.5V";
+      break;
+    case TOUCH_LVOLT_0V6:
+      lv_s = "0.6V";
+      break;
+    case TOUCH_LVOLT_0V7:
+      lv_s = "0.7V";
+      break;
+    case TOUCH_LVOLT_0V8:
+      lv_s = "0.8V";
+      break;
+    default:
+      lv_s = "UNKNOWN";
+      break;
+  }
+  ESP_LOGCONFIG(TAG, "  Low Voltage Reference: %s", lv_s);
+
+  const char *hv_s;
+  switch (this->high_voltage_reference_) {
+    case TOUCH_HVOLT_2V4:
+      hv_s = "2.4V";
+      break;
+    case TOUCH_HVOLT_2V5:
+      hv_s = "2.5V";
+      break;
+    case TOUCH_HVOLT_2V6:
+      hv_s = "2.6V";
+      break;
+    case TOUCH_HVOLT_2V7:
+      hv_s = "2.7V";
+      break;
+    default:
+      hv_s = "UNKNOWN";
+      break;
+  }
+  ESP_LOGCONFIG(TAG, "  High Voltage Reference: %s", hv_s);
+
+  const char *atten_s;
+  switch (this->voltage_attenuation_) {
+    case TOUCH_HVOLT_ATTEN_1V5:
+      atten_s = "1.5V";
+      break;
+    case TOUCH_HVOLT_ATTEN_1V:
+      atten_s = "1V";
+      break;
+    case TOUCH_HVOLT_ATTEN_0V5:
+      atten_s = "0.5V";
+      break;
+    case TOUCH_HVOLT_ATTEN_0V:
+      atten_s = "0V";
+      break;
+    default:
+      atten_s = "UNKNOWN";
+      break;
+  }
+  ESP_LOGCONFIG(TAG, "  Voltage Attenuation: %s", atten_s);
+
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+  if (this->filter_configured_()) {
+    const char *filter_mode_s;
+    switch (this->filter_mode_) {
+      case TOUCH_PAD_FILTER_IIR_4:
+        filter_mode_s = "IIR_4";
+        break;
+      case TOUCH_PAD_FILTER_IIR_8:
+        filter_mode_s = "IIR_8";
+        break;
+      case TOUCH_PAD_FILTER_IIR_16:
+        filter_mode_s = "IIR_16";
+        break;
+      case TOUCH_PAD_FILTER_IIR_32:
+        filter_mode_s = "IIR_32";
+        break;
+      case TOUCH_PAD_FILTER_IIR_64:
+        filter_mode_s = "IIR_64";
+        break;
+      case TOUCH_PAD_FILTER_IIR_128:
+        filter_mode_s = "IIR_128";
+        break;
+      case TOUCH_PAD_FILTER_IIR_256:
+        filter_mode_s = "IIR_256";
+        break;
+      case TOUCH_PAD_FILTER_JITTER:
+        filter_mode_s = "JITTER";
+        break;
+      default:
+        filter_mode_s = "UNKNOWN";
+        break;
+    }
+    ESP_LOGCONFIG(TAG,
+                  "  Filter mode: %s\n"
+                  "  Debounce count: %" PRIu32 "\n"
+                  "  Noise threshold coefficient: %" PRIu32 "\n"
+                  "  Jitter filter step size: %" PRIu32,
+                  filter_mode_s, this->debounce_count_, this->noise_threshold_, this->jitter_step_);
+    const char *smooth_level_s;
+    switch (this->smooth_level_) {
+      case TOUCH_PAD_SMOOTH_OFF:
+        smooth_level_s = "OFF";
+        break;
+      case TOUCH_PAD_SMOOTH_IIR_2:
+        smooth_level_s = "IIR_2";
+        break;
+      case TOUCH_PAD_SMOOTH_IIR_4:
+        smooth_level_s = "IIR_4";
+        break;
+      case TOUCH_PAD_SMOOTH_IIR_8:
+        smooth_level_s = "IIR_8";
+        break;
+      default:
+        smooth_level_s = "UNKNOWN";
+        break;
+    }
+    ESP_LOGCONFIG(TAG, "  Smooth level: %s", smooth_level_s);
+  }
+
+  if (this->denoise_configured_()) {
+    const char *grade_s;
+    switch (this->grade_) {
+      case TOUCH_PAD_DENOISE_BIT12:
+        grade_s = "BIT12";
+        break;
+      case TOUCH_PAD_DENOISE_BIT10:
+        grade_s = "BIT10";
+        break;
+      case TOUCH_PAD_DENOISE_BIT8:
+        grade_s = "BIT8";
+        break;
+      case TOUCH_PAD_DENOISE_BIT4:
+        grade_s = "BIT4";
+        break;
+      default:
+        grade_s = "UNKNOWN";
+        break;
+    }
+    ESP_LOGCONFIG(TAG, "  Denoise grade: %s", grade_s);
+
+    const char *cap_level_s;
+    switch (this->cap_level_) {
+      case TOUCH_PAD_DENOISE_CAP_L0:
+        cap_level_s = "L0";
+        break;
+      case TOUCH_PAD_DENOISE_CAP_L1:
+        cap_level_s = "L1";
+        break;
+      case TOUCH_PAD_DENOISE_CAP_L2:
+        cap_level_s = "L2";
+        break;
+      case TOUCH_PAD_DENOISE_CAP_L3:
+        cap_level_s = "L3";
+        break;
+      case TOUCH_PAD_DENOISE_CAP_L4:
+        cap_level_s = "L4";
+        break;
+      case TOUCH_PAD_DENOISE_CAP_L5:
+        cap_level_s = "L5";
+        break;
+      case TOUCH_PAD_DENOISE_CAP_L6:
+        cap_level_s = "L6";
+        break;
+      case TOUCH_PAD_DENOISE_CAP_L7:
+        cap_level_s = "L7";
+        break;
+      default:
+        cap_level_s = "UNKNOWN";
+        break;
+    }
+    ESP_LOGCONFIG(TAG, "  Denoise capacitance level: %s", cap_level_s);
+  }
+#else
+  if (this->iir_filter_enabled_()) {
+    ESP_LOGCONFIG(TAG, "    IIR Filter: %" PRIu32 "ms", this->iir_filter_);
+  } else {
+    ESP_LOGCONFIG(TAG, "  IIR Filter DISABLED");
+  }
+#endif
+
+  if (this->setup_mode_) {
+    ESP_LOGCONFIG(TAG, "  Setup Mode ENABLED");
+  }
+
+  for (auto *child : this->children_) {
+    LOG_BINARY_SENSOR("  ", "Touch Pad", child);
+    ESP_LOGCONFIG(TAG, "    Pad: T%" PRIu32, (uint32_t) child->get_touch_pad());
+    ESP_LOGCONFIG(TAG, "    Threshold: %" PRIu32, child->get_threshold());
+  }
+}
+
+uint32_t ESP32TouchComponent::component_touch_pad_read(touch_pad_t tp) {
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+  uint32_t value = 0;
+  if (this->filter_configured_()) {
+    touch_pad_filter_read_smooth(tp, &value);
+  } else {
+    touch_pad_read_raw_data(tp, &value);
+  }
+#else
+  uint16_t value = 0;
+  if (this->iir_filter_enabled_()) {
+    touch_pad_read_filtered(tp, &value);
+  } else {
+    touch_pad_read(tp, &value);
+  }
+#endif
+  return value;
+}
+
+void ESP32TouchComponent::loop() {
+  const uint32_t now = App.get_loop_component_start_time();
+  bool should_print = this->setup_mode_ && now - this->setup_mode_last_log_print_ > 250;
+  for (auto *child : this->children_) {
+    child->value_ = this->component_touch_pad_read(child->get_touch_pad());
+#if !(defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3))
+    child->publish_state(child->value_ < child->get_threshold());
+#else
+    child->publish_state(child->value_ > child->get_threshold());
+#endif
+
+    if (should_print) {
+      ESP_LOGD(TAG, "Touch Pad '%s' (T%" PRIu32 "): %" PRIu32, child->get_name().c_str(),
+               (uint32_t) child->get_touch_pad(), child->value_);
+    }
+
+    App.feed_wdt();
+  }
+
+  if (should_print) {
+    // Avoid spamming logs
+    this->setup_mode_last_log_print_ = now;
+  }
+}
+
+void ESP32TouchComponent::on_shutdown() {
+  bool is_wakeup_source = false;
+
+#if !(defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3))
+  if (this->iir_filter_enabled_()) {
+    touch_pad_filter_stop();
+    touch_pad_filter_delete();
+  }
+#endif
+
+  for (auto *child : this->children_) {
+    if (child->get_wakeup_threshold() != 0) {
+      if (!is_wakeup_source) {
+        is_wakeup_source = true;
+        // Touch sensor FSM mode must be 'TOUCH_FSM_MODE_TIMER' to use it to wake-up.
+        touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
+      }
+
+#if !(defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3))
+      // No filter available when using as wake-up source.
+      touch_pad_config(child->get_touch_pad(), child->get_wakeup_threshold());
+#endif
+    }
+  }
+
+  if (!is_wakeup_source) {
+    touch_pad_deinit();
+  }
+}
+
+ESP32TouchBinarySensor::ESP32TouchBinarySensor(touch_pad_t touch_pad, uint32_t threshold, uint32_t wakeup_threshold)
+    : touch_pad_(touch_pad), threshold_(threshold), wakeup_threshold_(wakeup_threshold) {}
+
+}  // namespace esp32_touch
+}  // namespace esphome
+
+#endif

esphome/components/esp32_touch/esp32_touch.h

@@ -9,19 +9,10 @@
 #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.
-
-static const uint32_t SETUP_MODE_LOG_INTERVAL_MS = 250;
-
 class ESP32TouchBinarySensor;
 
 class ESP32TouchComponent : public Component {
@@ -40,14 +31,6 @@ 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; }
@@ -64,87 +47,17 @@ class ESP32TouchComponent : public Component {
   void set_iir_filter(uint32_t iir_filter) { this->iir_filter_ = iir_filter; }
 #endif
 
- protected:
-  // Common helper methods
-  void dump_config_base_();
-  void dump_config_sensors_();
-  bool create_touch_queue_();
-  void cleanup_touch_queue_();
-  void configure_wakeup_pads_();
+  uint32_t component_touch_pad_read(touch_pad_t tp);
 
-  // Common members
-  std::vector<ESP32TouchBinarySensor *> children_;
-  bool setup_mode_{false};
-  uint32_t setup_mode_last_log_print_{0};
+  void setup() override;
+  void dump_config() override;
+  void loop() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
 
-  // 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};
-
-  // ==================== PLATFORM SPECIFIC ====================
-
-#ifdef USE_ESP32_VARIANT_ESP32
-  // ESP32 v1 specific
-  static constexpr uint32_t MINIMUM_RELEASE_TIME_MS = 100;
-
-  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;
-  };
+  void on_shutdown() override;
 
  protected:
-  // 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 (except sentinel value 1)
-  // 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_[TOUCH_PAD_MAX] = {0};
-  uint32_t release_timeout_ms_{1500};
-  uint32_t release_check_interval_ms_{50};
-  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};
-
+#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);
   }
@@ -155,78 +68,43 @@ class ESP32TouchComponent : public Component {
     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
-  void check_and_update_touch_state_(ESP32TouchBinarySensor *child);
+#else
+  bool iir_filter_enabled_() const { return this->iir_filter_ > 0; }
 #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";
-    }
-  }
+  std::vector<ESP32TouchBinarySensor *> children_;
+  bool setup_mode_{false};
+  uint32_t setup_mode_last_log_print_{0};
+  // common 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)
+  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};
+  touch_pad_denoise_grade_t grade_{TOUCH_PAD_DENOISE_MAX};
+  touch_pad_denoise_cap_t cap_level_{TOUCH_PAD_DENOISE_CAP_MAX};
+  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};
+#endif
 };
 
 /// 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)
-      : touch_pad_(touch_pad), threshold_(threshold), wakeup_threshold_(wakeup_threshold) {}
+  ESP32TouchBinarySensor(touch_pad_t touch_pad, uint32_t threshold, uint32_t 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:
@@ -234,10 +112,7 @@ class ESP32TouchBinarySensor : public binary_sensor::BinarySensor {
 
   touch_pad_t touch_pad_{TOUCH_PAD_MAX};
   uint32_t threshold_{0};
-#ifdef USE_ESP32_VARIANT_ESP32
   uint32_t value_{0};
-#endif
-  bool last_state_{false};
   const uint32_t wakeup_threshold_{0};
 };
 

esphome/components/esp32_touch/esp32_touch_common.cpp

@@ -1,91 +0,0 @@
-#ifdef USE_ESP32
-
-#include "esp32_touch.h"
-#include "esphome/core/log.h"
-#include <cinttypes>
-
-namespace esphome {
-namespace esp32_touch {
-
-static const char *const TAG = "esp32_touch";
-
-void ESP32TouchComponent::dump_config_base_() {
-  const char *lv_s = get_low_voltage_reference_str(this->low_voltage_reference_);
-  const char *hv_s = get_high_voltage_reference_str(this->high_voltage_reference_);
-  const char *atten_s = get_voltage_attenuation_str(this->voltage_attenuation_);
-
-  ESP_LOGCONFIG(TAG,
-                "Config for ESP32 Touch Hub:\n"
-                "  Meas cycle: %.2fms\n"
-                "  Sleep cycle: %.2fms\n"
-                "  Low Voltage Reference: %s\n"
-                "  High Voltage Reference: %s\n"
-                "  Voltage Attenuation: %s",
-                this->meas_cycle_ / (8000000.0f / 1000.0f), this->sleep_cycle_ / (150000.0f / 1000.0f), lv_s, hv_s,
-                atten_s);
-}
-
-void ESP32TouchComponent::dump_config_sensors_() {
-  for (auto *child : this->children_) {
-    LOG_BINARY_SENSOR("  ", "Touch Pad", child);
-    ESP_LOGCONFIG(TAG, "    Pad: T%" PRIu32, (uint32_t) child->get_touch_pad());
-    ESP_LOGCONFIG(TAG, "    Threshold: %" PRIu32, child->get_threshold());
-  }
-}
-
-bool ESP32TouchComponent::create_touch_queue_() {
-  // Queue size calculation: children * 4 allows for burst scenarios where ISR
-  // fires multiple times before main loop processes.
-  size_t queue_size = this->children_.size() * 4;
-  if (queue_size < 8)
-    queue_size = 8;
-
-#ifdef USE_ESP32_VARIANT_ESP32
-  this->touch_queue_ = xQueueCreate(queue_size, sizeof(TouchPadEventV1));
-#else
-  this->touch_queue_ = xQueueCreate(queue_size, sizeof(TouchPadEventV2));
-#endif
-
-  if (this->touch_queue_ == nullptr) {
-    ESP_LOGE(TAG, "Failed to create touch event queue of size %" PRIu32, (uint32_t) queue_size);
-    this->mark_failed();
-    return false;
-  }
-  return true;
-}
-
-void ESP32TouchComponent::cleanup_touch_queue_() {
-  if (this->touch_queue_) {
-    vQueueDelete(this->touch_queue_);
-    this->touch_queue_ = nullptr;
-  }
-}
-
-void ESP32TouchComponent::configure_wakeup_pads_() {
-  bool is_wakeup_source = false;
-
-  // Check if any pad is configured for wakeup
-  for (auto *child : this->children_) {
-    if (child->get_wakeup_threshold() != 0) {
-      is_wakeup_source = true;
-
-#ifdef USE_ESP32_VARIANT_ESP32
-      // ESP32 v1: No filter available when using as wake-up source.
-      touch_pad_config(child->get_touch_pad(), child->get_wakeup_threshold());
-#else
-      // ESP32-S2/S3 v2: Set threshold for wakeup
-      touch_pad_set_thresh(child->get_touch_pad(), child->get_wakeup_threshold());
-#endif
-    }
-  }
-
-  if (!is_wakeup_source) {
-    // If no pad is configured for wakeup, deinitialize touch pad
-    touch_pad_deinit();
-  }
-}
-
-}  // namespace esp32_touch
-}  // namespace esphome
-
-#endif  // USE_ESP32

esphome/components/esp32_touch/esp32_touch_v1.cpp

@@ -1,248 +0,0 @@
-#ifdef USE_ESP32_VARIANT_ESP32
-
-#include "esp32_touch.h"
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-#include "esphome/core/hal.h"
-
-#include <algorithm>
-#include <cinttypes>
-
-// Include HAL for ISR-safe touch reading
-#include "hal/touch_sensor_ll.h"
-// Include for RTC clock frequency
-#include "soc/rtc.h"
-
-namespace esphome {
-namespace esp32_touch {
-
-static const char *const TAG = "esp32_touch";
-
-void ESP32TouchComponent::setup() {
-  // Create queue for touch events
-  // Queue size calculation: children * 4 allows for burst scenarios where ISR
-  // fires multiple times before main loop processes. This is important because
-  // ESP32 v1 scans all pads on each interrupt, potentially sending multiple events.
-  if (!this->create_touch_queue_()) {
-    return;
-  }
-
-  touch_pad_init();
-  touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
-
-  // Set up IIR filter if enabled
-  if (this->iir_filter_enabled_()) {
-    touch_pad_filter_start(this->iir_filter_);
-  }
-
-  // Configure measurement parameters
-#if ESP_IDF_VERSION_MAJOR >= 5
-  touch_pad_set_measurement_clock_cycles(this->meas_cycle_);
-  touch_pad_set_measurement_interval(this->sleep_cycle_);
-#else
-  touch_pad_set_meas_time(this->sleep_cycle_, this->meas_cycle_);
-#endif
-  touch_pad_set_voltage(this->high_voltage_reference_, this->low_voltage_reference_, this->voltage_attenuation_);
-
-  // Configure each touch pad
-  for (auto *child : this->children_) {
-    touch_pad_config(child->get_touch_pad(), child->get_threshold());
-  }
-
-  // Register ISR handler
-  esp_err_t err = touch_pad_isr_register(touch_isr_handler, this);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Failed to register touch ISR: %s", esp_err_to_name(err));
-    this->cleanup_touch_queue_();
-    this->mark_failed();
-    return;
-  }
-
-  // Calculate release timeout based on sleep cycle
-  // Design note: ESP32 v1 hardware limitation - interrupts only fire on touch (not release)
-  // We must use timeout-based detection for release events
-  // Formula: 3 sleep cycles converted to ms, with MINIMUM_RELEASE_TIME_MS minimum
-  // The division by 2 accounts for the fact that sleep_cycle is in half-cycles
-  uint32_t rtc_freq = rtc_clk_slow_freq_get_hz();
-  this->release_timeout_ms_ = (this->sleep_cycle_ * 1000 * 3) / (rtc_freq * 2);
-  if (this->release_timeout_ms_ < MINIMUM_RELEASE_TIME_MS) {
-    this->release_timeout_ms_ = MINIMUM_RELEASE_TIME_MS;
-  }
-  // Check for releases at 1/4 the timeout interval, capped at 50ms
-  this->release_check_interval_ms_ = std::min(this->release_timeout_ms_ / 4, (uint32_t) 50);
-
-  // Enable touch pad interrupt
-  touch_pad_intr_enable();
-}
-
-void ESP32TouchComponent::dump_config() {
-  this->dump_config_base_();
-
-  if (this->iir_filter_enabled_()) {
-    ESP_LOGCONFIG(TAG, "    IIR Filter: %" PRIu32 "ms", this->iir_filter_);
-  } else {
-    ESP_LOGCONFIG(TAG, "  IIR Filter DISABLED");
-  }
-
-  if (this->setup_mode_) {
-    ESP_LOGCONFIG(TAG, "  Setup Mode ENABLED");
-  }
-
-  this->dump_config_sensors_();
-}
-
-void ESP32TouchComponent::loop() {
-  const uint32_t now = App.get_loop_component_start_time();
-
-  // Print debug info for all pads in setup mode
-  if (this->setup_mode_ && now - this->setup_mode_last_log_print_ > SETUP_MODE_LOG_INTERVAL_MS) {
-    for (auto *child : this->children_) {
-      ESP_LOGD(TAG, "Touch Pad '%s' (T%" PRIu32 "): %" PRIu32, child->get_name().c_str(),
-               (uint32_t) child->get_touch_pad(), child->value_);
-    }
-    this->setup_mode_last_log_print_ = now;
-  }
-
-  // Process any queued touch events from interrupts
-  // Note: Events are only sent by ISR for pads that were measured in that cycle (value != 0)
-  // This is more efficient than sending all pad states every interrupt
-  TouchPadEventV1 event;
-  while (xQueueReceive(this->touch_queue_, &event, 0) == pdTRUE) {
-    // Find the corresponding sensor - O(n) search is acceptable since events are infrequent
-    for (auto *child : this->children_) {
-      if (child->get_touch_pad() != event.pad) {
-        continue;
-      }
-
-      // Found matching pad - process it
-      child->value_ = event.value;
-
-      // The interrupt gives us the touch state directly
-      bool new_state = event.is_touched;
-
-      // Track when we last saw this pad as touched
-      if (new_state) {
-        this->last_touch_time_[event.pad] = now;
-      }
-
-      // Only publish if state changed - this filters out repeated events
-      if (new_state != child->last_state_) {
-        child->last_state_ = new_state;
-        child->publish_state(new_state);
-        // Original ESP32: ISR only fires when touched, release is detected by timeout
-        // Note: ESP32 v1 uses inverted logic - touched when value < threshold
-        ESP_LOGV(TAG, "Touch Pad '%s' state: ON (value: %" PRIu32 " < threshold: %" PRIu32 ")",
-                 child->get_name().c_str(), event.value, child->get_threshold());
-      }
-      break;  // Exit inner loop after processing matching pad
-    }
-  }
-
-  // Check for released pads periodically
-  static uint32_t last_release_check = 0;
-  if (now - last_release_check < this->release_check_interval_ms_) {
-    return;
-  }
-  last_release_check = now;
-
-  for (auto *child : this->children_) {
-    touch_pad_t pad = child->get_touch_pad();
-    uint32_t last_time = this->last_touch_time_[pad];
-
-    // Design note: Sentinel value pattern explanation
-    // - 0: Never touched since boot (waiting for initial timeout)
-    // - 1: Initial OFF state has been published (prevents repeated publishes)
-    // - >1: Actual timestamp of last touch event
-    // This avoids needing a separate boolean flag for initial state tracking
-
-    // If we've never seen this pad touched (last_time == 0) and enough time has passed
-    // since startup, publish OFF state and mark as published with value 1
-    if (last_time == 0 && now > this->release_timeout_ms_) {
-      child->publish_initial_state(false);
-      this->last_touch_time_[pad] = 1;  // Mark as "initial state published"
-      ESP_LOGV(TAG, "Touch Pad '%s' state: OFF (initial)", child->get_name().c_str());
-    } else if (child->last_state_ && last_time > 1) {  // last_time > 1 means it's a real timestamp
-      uint32_t time_diff = now - last_time;
-
-      // Check if we haven't seen this pad recently
-      if (time_diff > this->release_timeout_ms_) {
-        // Haven't seen this pad recently, assume it's released
-        child->last_state_ = false;
-        child->publish_state(false);
-        this->last_touch_time_[pad] = 1;  // Reset to "initial published" state
-        ESP_LOGV(TAG, "Touch Pad '%s' state: OFF (timeout)", child->get_name().c_str());
-      }
-    }
-  }
-}
-
-void ESP32TouchComponent::on_shutdown() {
-  touch_pad_intr_disable();
-  touch_pad_isr_deregister(touch_isr_handler, this);
-  this->cleanup_touch_queue_();
-
-  if (this->iir_filter_enabled_()) {
-    touch_pad_filter_stop();
-    touch_pad_filter_delete();
-  }
-
-  // Configure wakeup pads if any are set
-  this->configure_wakeup_pads_();
-}
-
-void IRAM_ATTR ESP32TouchComponent::touch_isr_handler(void *arg) {
-  ESP32TouchComponent *component = static_cast<ESP32TouchComponent *>(arg);
-
-  touch_pad_clear_status();
-
-  // Process all configured pads to check their current state
-  // Note: ESP32 v1 doesn't tell us which specific pad triggered the interrupt,
-  // so we must scan all configured pads to find which ones were touched
-  for (auto *child : component->children_) {
-    touch_pad_t pad = child->get_touch_pad();
-
-    // Read current value using ISR-safe API
-    uint32_t value;
-    if (component->iir_filter_enabled_()) {
-      uint16_t temp_value = 0;
-      touch_pad_read_filtered(pad, &temp_value);
-      value = temp_value;
-    } else {
-      // Use low-level HAL function when filter is not enabled
-      value = touch_ll_read_raw_data(pad);
-    }
-
-    // Skip pads with 0 value - they haven't been measured in this cycle
-    // This is important: not all pads are measured every interrupt cycle,
-    // only those that the hardware has updated
-    if (value == 0) {
-      continue;
-    }
-
-    // IMPORTANT: ESP32 v1 touch detection logic - INVERTED compared to v2!
-    // ESP32 v1: Touch is detected when capacitance INCREASES, causing the measured value to DECREASE
-    // Therefore: touched = (value < threshold)
-    // This is opposite to ESP32-S2/S3 v2 where touched = (value > threshold)
-    bool is_touched = value < child->get_threshold();
-
-    // Always send the current state - the main loop will filter for changes
-    // We send both touched and untouched states because the ISR doesn't
-    // track previous state (to keep ISR fast and simple)
-    TouchPadEventV1 event;
-    event.pad = pad;
-    event.value = value;
-    event.is_touched = is_touched;
-
-    // Send to queue from ISR - non-blocking, drops if queue full
-    BaseType_t x_higher_priority_task_woken = pdFALSE;
-    xQueueSendFromISR(component->touch_queue_, &event, &x_higher_priority_task_woken);
-    if (x_higher_priority_task_woken) {
-      portYIELD_FROM_ISR();
-    }
-  }
-}
-
-}  // namespace esp32_touch
-}  // namespace esphome
-
-#endif  // USE_ESP32_VARIANT_ESP32

esphome/components/esp32_touch/esp32_touch_v2.cpp

@@ -1,354 +0,0 @@
-#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
-
-#include "esp32_touch.h"
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-#include "esphome/core/hal.h"
-
-namespace esphome {
-namespace esp32_touch {
-
-static const char *const TAG = "esp32_touch";
-
-// Helper to update touch state with a known state
-void ESP32TouchComponent::update_touch_state_(ESP32TouchBinarySensor *child, bool is_touched) {
-  if (child->last_state_ != is_touched) {
-    // Read value for logging
-    uint32_t value = this->read_touch_value(child->get_touch_pad());
-
-    child->last_state_ = is_touched;
-    child->publish_state(is_touched);
-    ESP_LOGD(TAG, "Touch Pad '%s' %s (value: %" PRIu32 " %s threshold: %" PRIu32 ")", child->get_name().c_str(),
-             is_touched ? "touched" : "released", value, is_touched ? ">" : "<=", child->get_threshold());
-  }
-}
-
-// Helper to read touch value and update state for a given child (used for timeout events)
-void ESP32TouchComponent::check_and_update_touch_state_(ESP32TouchBinarySensor *child) {
-  // Read current touch value
-  uint32_t value = this->read_touch_value(child->get_touch_pad());
-
-  // ESP32-S2/S3 v2: Touch is detected when value > threshold
-  bool is_touched = value > child->get_threshold();
-
-  this->update_touch_state_(child, is_touched);
-}
-
-void ESP32TouchComponent::setup() {
-  // Create queue for touch events first
-  if (!this->create_touch_queue_()) {
-    return;
-  }
-
-  // Initialize touch pad peripheral
-  esp_err_t init_err = touch_pad_init();
-  if (init_err != ESP_OK) {
-    ESP_LOGE(TAG, "Failed to initialize touch pad: %s", esp_err_to_name(init_err));
-    this->mark_failed();
-    return;
-  }
-
-  // Configure each touch pad first
-  for (auto *child : this->children_) {
-    esp_err_t config_err = touch_pad_config(child->get_touch_pad());
-    if (config_err != ESP_OK) {
-      ESP_LOGE(TAG, "Failed to configure touch pad %d: %s", child->get_touch_pad(), esp_err_to_name(config_err));
-    }
-  }
-
-  // Set up filtering if configured
-  if (this->filter_configured_()) {
-    touch_filter_config_t filter_info = {
-        .mode = this->filter_mode_,
-        .debounce_cnt = this->debounce_count_,
-        .noise_thr = this->noise_threshold_,
-        .jitter_step = this->jitter_step_,
-        .smh_lvl = this->smooth_level_,
-    };
-    touch_pad_filter_set_config(&filter_info);
-    touch_pad_filter_enable();
-  }
-
-  if (this->denoise_configured_()) {
-    touch_pad_denoise_t denoise = {
-        .grade = this->grade_,
-        .cap_level = this->cap_level_,
-    };
-    touch_pad_denoise_set_config(&denoise);
-    touch_pad_denoise_enable();
-  }
-
-  if (this->waterproof_configured_()) {
-    touch_pad_waterproof_t waterproof = {
-        .guard_ring_pad = this->waterproof_guard_ring_pad_,
-        .shield_driver = this->waterproof_shield_driver_,
-    };
-    touch_pad_waterproof_set_config(&waterproof);
-    touch_pad_waterproof_enable();
-  }
-
-  // Configure measurement parameters
-  touch_pad_set_voltage(this->high_voltage_reference_, this->low_voltage_reference_, this->voltage_attenuation_);
-  // ESP32-S2/S3 always use the older API
-  touch_pad_set_meas_time(this->sleep_cycle_, this->meas_cycle_);
-
-  // Configure timeout if needed
-  touch_pad_timeout_set(true, TOUCH_PAD_THRESHOLD_MAX);
-
-  // Register ISR handler with interrupt mask
-  esp_err_t err =
-      touch_pad_isr_register(touch_isr_handler, this, static_cast<touch_pad_intr_mask_t>(TOUCH_PAD_INTR_MASK_ALL));
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Failed to register touch ISR: %s", esp_err_to_name(err));
-    this->cleanup_touch_queue_();
-    this->mark_failed();
-    return;
-  }
-
-  // Set thresholds for each pad BEFORE starting FSM
-  for (auto *child : this->children_) {
-    if (child->get_threshold() != 0) {
-      touch_pad_set_thresh(child->get_touch_pad(), child->get_threshold());
-    }
-  }
-
-  // Enable interrupts
-  touch_pad_intr_enable(static_cast<touch_pad_intr_mask_t>(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE |
-                                                           TOUCH_PAD_INTR_MASK_TIMEOUT));
-
-  // Set FSM mode before starting
-  touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
-
-  // Start FSM
-  touch_pad_fsm_start();
-
-  // Read initial states after all hardware is initialized
-  for (auto *child : this->children_) {
-    // Read current value
-    uint32_t value = this->read_touch_value(child->get_touch_pad());
-
-    // Set initial state and publish
-    bool is_touched = value > child->get_threshold();
-    child->last_state_ = is_touched;
-    child->publish_initial_state(is_touched);
-
-    ESP_LOGD(TAG, "Touch Pad '%s' initial state: %s (value: %d %s threshold: %d)", child->get_name().c_str(),
-             is_touched ? "touched" : "released", value, is_touched ? ">" : "<=", child->get_threshold());
-  }
-}
-
-void ESP32TouchComponent::dump_config() {
-  this->dump_config_base_();
-
-  if (this->filter_configured_()) {
-    const char *filter_mode_s;
-    switch (this->filter_mode_) {
-      case TOUCH_PAD_FILTER_IIR_4:
-        filter_mode_s = "IIR_4";
-        break;
-      case TOUCH_PAD_FILTER_IIR_8:
-        filter_mode_s = "IIR_8";
-        break;
-      case TOUCH_PAD_FILTER_IIR_16:
-        filter_mode_s = "IIR_16";
-        break;
-      case TOUCH_PAD_FILTER_IIR_32:
-        filter_mode_s = "IIR_32";
-        break;
-      case TOUCH_PAD_FILTER_IIR_64:
-        filter_mode_s = "IIR_64";
-        break;
-      case TOUCH_PAD_FILTER_IIR_128:
-        filter_mode_s = "IIR_128";
-        break;
-      case TOUCH_PAD_FILTER_IIR_256:
-        filter_mode_s = "IIR_256";
-        break;
-      case TOUCH_PAD_FILTER_JITTER:
-        filter_mode_s = "JITTER";
-        break;
-      default:
-        filter_mode_s = "UNKNOWN";
-        break;
-    }
-    ESP_LOGCONFIG(TAG,
-                  "  Filter mode: %s\n"
-                  "  Debounce count: %" PRIu32 "\n"
-                  "  Noise threshold coefficient: %" PRIu32 "\n"
-                  "  Jitter filter step size: %" PRIu32,
-                  filter_mode_s, this->debounce_count_, this->noise_threshold_, this->jitter_step_);
-    const char *smooth_level_s;
-    switch (this->smooth_level_) {
-      case TOUCH_PAD_SMOOTH_OFF:
-        smooth_level_s = "OFF";
-        break;
-      case TOUCH_PAD_SMOOTH_IIR_2:
-        smooth_level_s = "IIR_2";
-        break;
-      case TOUCH_PAD_SMOOTH_IIR_4:
-        smooth_level_s = "IIR_4";
-        break;
-      case TOUCH_PAD_SMOOTH_IIR_8:
-        smooth_level_s = "IIR_8";
-        break;
-      default:
-        smooth_level_s = "UNKNOWN";
-        break;
-    }
-    ESP_LOGCONFIG(TAG, "  Smooth level: %s", smooth_level_s);
-  }
-
-  if (this->denoise_configured_()) {
-    const char *grade_s;
-    switch (this->grade_) {
-      case TOUCH_PAD_DENOISE_BIT12:
-        grade_s = "BIT12";
-        break;
-      case TOUCH_PAD_DENOISE_BIT10:
-        grade_s = "BIT10";
-        break;
-      case TOUCH_PAD_DENOISE_BIT8:
-        grade_s = "BIT8";
-        break;
-      case TOUCH_PAD_DENOISE_BIT4:
-        grade_s = "BIT4";
-        break;
-      default:
-        grade_s = "UNKNOWN";
-        break;
-    }
-    ESP_LOGCONFIG(TAG, "  Denoise grade: %s", grade_s);
-
-    const char *cap_level_s;
-    switch (this->cap_level_) {
-      case TOUCH_PAD_DENOISE_CAP_L0:
-        cap_level_s = "L0";
-        break;
-      case TOUCH_PAD_DENOISE_CAP_L1:
-        cap_level_s = "L1";
-        break;
-      case TOUCH_PAD_DENOISE_CAP_L2:
-        cap_level_s = "L2";
-        break;
-      case TOUCH_PAD_DENOISE_CAP_L3:
-        cap_level_s = "L3";
-        break;
-      case TOUCH_PAD_DENOISE_CAP_L4:
-        cap_level_s = "L4";
-        break;
-      case TOUCH_PAD_DENOISE_CAP_L5:
-        cap_level_s = "L5";
-        break;
-      case TOUCH_PAD_DENOISE_CAP_L6:
-        cap_level_s = "L6";
-        break;
-      case TOUCH_PAD_DENOISE_CAP_L7:
-        cap_level_s = "L7";
-        break;
-      default:
-        cap_level_s = "UNKNOWN";
-        break;
-    }
-    ESP_LOGCONFIG(TAG, "  Denoise capacitance level: %s", cap_level_s);
-  }
-
-  if (this->setup_mode_) {
-    ESP_LOGCONFIG(TAG, "  Setup Mode ENABLED");
-  }
-
-  this->dump_config_sensors_();
-}
-
-void ESP32TouchComponent::loop() {
-  const uint32_t now = App.get_loop_component_start_time();
-
-  // In setup mode, periodically log all pad values
-  if (this->setup_mode_ && now - this->setup_mode_last_log_print_ > SETUP_MODE_LOG_INTERVAL_MS) {
-    for (auto *child : this->children_) {
-      // Read the value being used for touch detection
-      uint32_t value = this->read_touch_value(child->get_touch_pad());
-
-      ESP_LOGD(TAG, "Touch Pad '%s' (T%d): %d", child->get_name().c_str(), child->get_touch_pad(), value);
-    }
-    this->setup_mode_last_log_print_ = now;
-  }
-
-  // Process any queued touch events from interrupts
-  TouchPadEventV2 event;
-  while (xQueueReceive(this->touch_queue_, &event, 0) == pdTRUE) {
-    // Handle timeout events
-    if (event.intr_mask & TOUCH_PAD_INTR_MASK_TIMEOUT) {
-      // Resume measurement after timeout
-      touch_pad_timeout_resume();
-      // For timeout events, always check the current state
-    } else if (!(event.intr_mask & (TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE))) {
-      // Skip if not an active/inactive/timeout event
-      continue;
-    }
-
-    // Find the child for the pad that triggered the interrupt
-    for (auto *child : this->children_) {
-      if (child->get_touch_pad() != event.pad) {
-        continue;
-      }
-
-      if (event.intr_mask & TOUCH_PAD_INTR_MASK_TIMEOUT) {
-        // For timeout events, we need to read the value to determine state
-        this->check_and_update_touch_state_(child);
-      } else {
-        // For ACTIVE/INACTIVE events, the interrupt tells us the state
-        bool is_touched = (event.intr_mask & TOUCH_PAD_INTR_MASK_ACTIVE) != 0;
-        this->update_touch_state_(child, is_touched);
-      }
-      break;
-    }
-  }
-}
-
-void ESP32TouchComponent::on_shutdown() {
-  // Disable interrupts
-  touch_pad_intr_disable(static_cast<touch_pad_intr_mask_t>(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE |
-                                                            TOUCH_PAD_INTR_MASK_TIMEOUT));
-  touch_pad_isr_deregister(touch_isr_handler, this);
-  this->cleanup_touch_queue_();
-
-  // Configure wakeup pads if any are set
-  this->configure_wakeup_pads_();
-}
-
-void IRAM_ATTR ESP32TouchComponent::touch_isr_handler(void *arg) {
-  ESP32TouchComponent *component = static_cast<ESP32TouchComponent *>(arg);
-  BaseType_t x_higher_priority_task_woken = pdFALSE;
-
-  // Read interrupt status
-  TouchPadEventV2 event;
-  event.intr_mask = touch_pad_read_intr_status_mask();
-  event.pad = touch_pad_get_current_meas_channel();
-
-  // Send event to queue for processing in main loop
-  xQueueSendFromISR(component->touch_queue_, &event, &x_higher_priority_task_woken);
-
-  if (x_higher_priority_task_woken) {
-    portYIELD_FROM_ISR();
-  }
-}
-
-uint32_t ESP32TouchComponent::read_touch_value(touch_pad_t pad) const {
-  // Unlike ESP32 v1, touch reads on ESP32-S2/S3 v2 are non-blocking operations.
-  // The hardware continuously samples in the background and we can read the
-  // latest value at any time without waiting.
-  uint32_t value = 0;
-  if (this->filter_configured_()) {
-    // Read filtered/smoothed value when filter is enabled
-    touch_pad_filter_read_smooth(pad, &value);
-  } else {
-    // Read raw value when filter is not configured
-    touch_pad_read_raw_data(pad, &value);
-  }
-  return value;
-}
-
-}  // namespace esp32_touch
-}  // namespace esphome
-
-#endif  // USE_ESP32_VARIANT_ESP32S2 || USE_ESP32_VARIANT_ESP32S3

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -337,23 +337,26 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
 bool Nextion::upload_end_(bool successful) {
   ESP_LOGD(TAG, "TFT upload done: %s", YESNO(successful));
-  this->is_updating_ = false;
-  this->ignore_is_setup_ = false;
-
-  uint32_t baud_rate = this->parent_->get_baud_rate();
-  if (baud_rate != this->original_baud_rate_) {
-    ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
-    this->parent_->set_baud_rate(this->original_baud_rate_);
-    this->parent_->load_settings();
-  }
 
   if (successful) {
     ESP_LOGD(TAG, "Restart");
     delay(1500);  // NOLINT
     App.safe_reboot();
+    delay(1500);  // NOLINT
   } else {
     ESP_LOGE(TAG, "TFT upload failed");
+
+    this->is_updating_ = false;
+    this->ignore_is_setup_ = false;
+
+    uint32_t baud_rate = this->parent_->get_baud_rate();
+    if (baud_rate != this->original_baud_rate_) {
+      ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
+      this->parent_->set_baud_rate(this->original_baud_rate_);
+      this->parent_->load_settings();
+    }
   }
+
   return successful;
 }
 

esphome/components/nextion/nextion_upload_idf.cpp

@@ -337,15 +337,6 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
 bool Nextion::upload_end_(bool successful) {
   ESP_LOGD(TAG, "TFT upload done: %s", YESNO(successful));
-  this->is_updating_ = false;
-  this->ignore_is_setup_ = false;
-
-  uint32_t baud_rate = this->parent_->get_baud_rate();
-  if (baud_rate != this->original_baud_rate_) {
-    ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
-    this->parent_->set_baud_rate(this->original_baud_rate_);
-    this->parent_->load_settings();
-  }
 
   if (successful) {
     ESP_LOGD(TAG, "Restart");
@@ -353,7 +344,18 @@ bool Nextion::upload_end_(bool successful) {
     App.safe_reboot();
   } else {
     ESP_LOGE(TAG, "TFT upload failed");
+
+    this->is_updating_ = false;
+    this->ignore_is_setup_ = false;
+
+    uint32_t baud_rate = this->parent_->get_baud_rate();
+    if (baud_rate != this->original_baud_rate_) {
+      ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
+      this->parent_->set_baud_rate(this->original_baud_rate_);
+      this->parent_->load_settings();
+    }
   }
+
   return successful;
 }
 

esphome/components/runtime_stats/__init__.py

@@ -1,26 +0,0 @@
-"""
-Runtime statistics component for ESPHome.
-"""
-
-import esphome.codegen as cg
-import esphome.config_validation as cv
-
-DEPENDENCIES = []
-
-CONF_ENABLED = "enabled"
-CONF_LOG_INTERVAL = "log_interval"
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.Optional(CONF_ENABLED, default=True): cv.boolean,
-        cv.Optional(
-            CONF_LOG_INTERVAL, default=60000
-        ): cv.positive_time_period_milliseconds,
-    }
-)
-
-
-async def to_code(config):
-    """Generate code for the runtime statistics component."""
-    cg.add(cg.App.set_runtime_stats_enabled(config[CONF_ENABLED]))
-    cg.add(cg.App.set_runtime_stats_log_interval(config[CONF_LOG_INTERVAL]))

esphome/core/application.h

@@ -7,7 +7,6 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
-#include "esphome/core/runtime_stats.h"
 #include "esphome/core/scheduler.h"
 
 #ifdef USE_SOCKET_SELECT_SUPPORT
@@ -315,18 +314,6 @@ class Application {
 
   uint32_t get_loop_interval() const { return this->loop_interval_; }
 
-  /** Enable or disable runtime statistics collection.
-   *
-   * @param enable Whether to enable runtime statistics collection.
-   */
-  void set_runtime_stats_enabled(bool enable) { runtime_stats.set_enabled(enable); }
-
-  /** Set the interval at which runtime statistics are logged.
-   *
-   * @param interval The interval in milliseconds between logging of runtime statistics.
-   */
-  void set_runtime_stats_log_interval(uint32_t interval) { runtime_stats.set_log_interval(interval); }
-
   void schedule_dump_config() { this->dump_config_at_ = 0; }
 
   void feed_wdt(uint32_t time = 0);

esphome/core/component.cpp

@@ -246,9 +246,6 @@ uint32_t WarnIfComponentBlockingGuard::finish() {
   uint32_t curr_time = millis();
 
   uint32_t blocking_time = curr_time - this->started_;
-
-  // Record component runtime stats
-  runtime_stats.record_component_time(this->component_, blocking_time, curr_time);
   bool should_warn;
   if (this->component_ != nullptr) {
     should_warn = this->component_->should_warn_of_blocking(blocking_time);

esphome/core/component.h

@@ -6,7 +6,6 @@
 #include <string>
 
 #include "esphome/core/optional.h"
-#include "esphome/core/runtime_stats.h"
 
 namespace esphome {
 

esphome/core/runtime_stats.cpp

@@ -1,28 +0,0 @@
-#include "esphome/core/runtime_stats.h"
-#include "esphome/core/component.h"
-
-namespace esphome {
-
-RuntimeStatsCollector runtime_stats;
-
-void RuntimeStatsCollector::record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time) {
-  if (!this->enabled_ || component == nullptr)
-    return;
-
-  const char *component_source = component->get_component_source();
-  this->component_stats_[component_source].record_time(duration_ms);
-
-  // If next_log_time_ is 0, initialize it
-  if (this->next_log_time_ == 0) {
-    this->next_log_time_ = current_time + this->log_interval_;
-    return;
-  }
-
-  if (current_time >= this->next_log_time_) {
-    this->log_stats_();
-    this->reset_stats_();
-    this->next_log_time_ = current_time + this->log_interval_;
-  }
-}
-
-}  // namespace esphome

esphome/core/runtime_stats.h

@@ -1,161 +0,0 @@
-#pragma once
-
-#include <map>
-#include <string>
-#include <vector>
-#include <cstdint>
-#include <algorithm>
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-
-static const char *const RUNTIME_TAG = "runtime";
-
-class Component;  // Forward declaration
-
-class ComponentRuntimeStats {
- public:
-  ComponentRuntimeStats()
-      : period_count_(0),
-        total_count_(0),
-        period_time_ms_(0),
-        total_time_ms_(0),
-        period_max_time_ms_(0),
-        total_max_time_ms_(0) {}
-
-  void record_time(uint32_t duration_ms) {
-    // Update period counters
-    this->period_count_++;
-    this->period_time_ms_ += duration_ms;
-    if (duration_ms > this->period_max_time_ms_)
-      this->period_max_time_ms_ = duration_ms;
-
-    // Update total counters
-    this->total_count_++;
-    this->total_time_ms_ += duration_ms;
-    if (duration_ms > this->total_max_time_ms_)
-      this->total_max_time_ms_ = duration_ms;
-  }
-
-  void reset_period_stats() {
-    this->period_count_ = 0;
-    this->period_time_ms_ = 0;
-    this->period_max_time_ms_ = 0;
-  }
-
-  // Period stats (reset each logging interval)
-  uint32_t get_period_count() const { return this->period_count_; }
-  uint32_t get_period_time_ms() const { return this->period_time_ms_; }
-  uint32_t get_period_max_time_ms() const { return this->period_max_time_ms_; }
-  float get_period_avg_time_ms() const {
-    return this->period_count_ > 0 ? this->period_time_ms_ / static_cast<float>(this->period_count_) : 0.0f;
-  }
-
-  // Total stats (persistent until reboot)
-  uint32_t get_total_count() const { return this->total_count_; }
-  uint32_t get_total_time_ms() const { return this->total_time_ms_; }
-  uint32_t get_total_max_time_ms() const { return this->total_max_time_ms_; }
-  float get_total_avg_time_ms() const {
-    return this->total_count_ > 0 ? this->total_time_ms_ / static_cast<float>(this->total_count_) : 0.0f;
-  }
-
- protected:
-  // Period stats (reset each logging interval)
-  uint32_t period_count_;
-  uint32_t period_time_ms_;
-  uint32_t period_max_time_ms_;
-
-  // Total stats (persistent until reboot)
-  uint32_t total_count_;
-  uint32_t total_time_ms_;
-  uint32_t total_max_time_ms_;
-};
-
-// For sorting components by run time
-struct ComponentStatPair {
-  std::string name;
-  const ComponentRuntimeStats *stats;
-
-  bool operator>(const ComponentStatPair &other) const {
-    // Sort by period time as that's what we're displaying in the logs
-    return stats->get_period_time_ms() > other.stats->get_period_time_ms();
-  }
-};
-
-class RuntimeStatsCollector {
- public:
-  RuntimeStatsCollector() : log_interval_(60000), next_log_time_(0), enabled_(true) {}
-
-  void set_log_interval(uint32_t log_interval) { this->log_interval_ = log_interval; }
-  uint32_t get_log_interval() const { return this->log_interval_; }
-
-  void set_enabled(bool enabled) { this->enabled_ = enabled; }
-  bool is_enabled() const { return this->enabled_; }
-
-  void record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time);
-
- protected:
-  void log_stats_() {
-    ESP_LOGI(RUNTIME_TAG, "Component Runtime Statistics");
-    ESP_LOGI(RUNTIME_TAG, "Period stats (last %" PRIu32 "ms):", this->log_interval_);
-
-    // First collect stats we want to display
-    std::vector<ComponentStatPair> stats_to_display;
-
-    for (const auto &it : this->component_stats_) {
-      const ComponentRuntimeStats &stats = it.second;
-      if (stats.get_period_count() > 0) {
-        ComponentStatPair pair = {it.first, &stats};
-        stats_to_display.push_back(pair);
-      }
-    }
-
-    // Sort by period runtime (descending)
-    std::sort(stats_to_display.begin(), stats_to_display.end(), std::greater<ComponentStatPair>());
-
-    // Log top components by period runtime
-    for (const auto &it : stats_to_display) {
-      const std::string &source = it.name;
-      const ComponentRuntimeStats *stats = it.stats;
-
-      ESP_LOGI(RUNTIME_TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms",
-               source.c_str(), stats->get_period_count(), stats->get_period_avg_time_ms(),
-               stats->get_period_max_time_ms(), stats->get_period_time_ms());
-    }
-
-    // Log total stats since boot
-    ESP_LOGI(RUNTIME_TAG, "Total stats (since boot):");
-
-    // Re-sort by total runtime for all-time stats
-    std::sort(stats_to_display.begin(), stats_to_display.end(),
-              [](const ComponentStatPair &a, const ComponentStatPair &b) {
-                return a.stats->get_total_time_ms() > b.stats->get_total_time_ms();
-              });
-
-    for (const auto &it : stats_to_display) {
-      const std::string &source = it.name;
-      const ComponentRuntimeStats *stats = it.stats;
-
-      ESP_LOGI(RUNTIME_TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms",
-               source.c_str(), stats->get_total_count(), stats->get_total_avg_time_ms(), stats->get_total_max_time_ms(),
-               stats->get_total_time_ms());
-    }
-  }
-
-  void reset_stats_() {
-    for (auto &it : this->component_stats_) {
-      it.second.reset_period_stats();
-    }
-  }
-
-  std::map<std::string, ComponentRuntimeStats> component_stats_;
-  uint32_t log_interval_;
-  uint32_t next_log_time_;
-  bool enabled_;
-};
-
-// Global instance for runtime stats collection
-extern RuntimeStatsCollector runtime_stats;
-
-}  // namespace esphome

esphome/git.py

@@ -10,6 +10,7 @@ import urllib.parse
 
 import esphome.config_validation as cv
 from esphome.core import CORE, TimePeriodSeconds
+from esphome.git_lock import git_operation_lock
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -59,66 +60,72 @@ def clone_or_update(
         )
 
     repo_dir = _compute_destination_path(key, domain)
-    if not repo_dir.is_dir():
-        _LOGGER.info("Cloning %s", key)
-        _LOGGER.debug("Location: %s", repo_dir)
-        cmd = ["git", "clone", "--depth=1"]
-        cmd += ["--", url, str(repo_dir)]
-        run_git_command(cmd)
 
-        if ref is not None:
-            # We need to fetch the PR branch first, otherwise git will complain
-            # about missing objects
-            _LOGGER.info("Fetching %s", ref)
-            run_git_command(["git", "fetch", "--", "origin", ref], str(repo_dir))
-            run_git_command(["git", "reset", "--hard", "FETCH_HEAD"], str(repo_dir))
-
-        if submodules is not None:
-            _LOGGER.info(
-                "Initialising submodules (%s) for %s", ", ".join(submodules), key
-            )
-            run_git_command(
-                ["git", "submodule", "update", "--init"] + submodules, str(repo_dir)
-            )
-
-    else:
-        # Check refresh needed
-        file_timestamp = Path(repo_dir / ".git" / "FETCH_HEAD")
-        # On first clone, FETCH_HEAD does not exists
-        if not file_timestamp.exists():
-            file_timestamp = Path(repo_dir / ".git" / "HEAD")
-        age = datetime.now() - datetime.fromtimestamp(file_timestamp.stat().st_mtime)
-        if refresh is None or age.total_seconds() > refresh.total_seconds:
-            old_sha = run_git_command(["git", "rev-parse", "HEAD"], str(repo_dir))
-            _LOGGER.info("Updating %s", key)
+    # Use lock to prevent concurrent access to the same repository
+    with git_operation_lock(key):
+        if not repo_dir.is_dir():
+            _LOGGER.info("Cloning %s", key)
             _LOGGER.debug("Location: %s", repo_dir)
-            # Stash local changes (if any)
-            run_git_command(
-                ["git", "stash", "push", "--include-untracked"], str(repo_dir)
-            )
-            # Fetch remote ref
-            cmd = ["git", "fetch", "--", "origin"]
+            cmd = ["git", "clone", "--depth=1"]
+            cmd += ["--", url, str(repo_dir)]
+            run_git_command(cmd)
+
             if ref is not None:
-                cmd.append(ref)
-            run_git_command(cmd, str(repo_dir))
-            # Hard reset to FETCH_HEAD (short-lived git ref corresponding to most recent fetch)
-            run_git_command(["git", "reset", "--hard", "FETCH_HEAD"], str(repo_dir))
+                # We need to fetch the PR branch first, otherwise git will complain
+                # about missing objects
+                _LOGGER.info("Fetching %s", ref)
+                run_git_command(["git", "fetch", "--", "origin", ref], str(repo_dir))
+                run_git_command(["git", "reset", "--hard", "FETCH_HEAD"], str(repo_dir))
 
             if submodules is not None:
                 _LOGGER.info(
-                    "Updating submodules (%s) for %s", ", ".join(submodules), key
+                    "Initialising submodules (%s) for %s", ", ".join(submodules), key
                 )
                 run_git_command(
                     ["git", "submodule", "update", "--init"] + submodules, str(repo_dir)
                 )
 
-            def revert():
-                _LOGGER.info("Reverting changes to %s -> %s", key, old_sha)
-                run_git_command(["git", "reset", "--hard", old_sha], str(repo_dir))
+        else:
+            # Check refresh needed
+            file_timestamp = Path(repo_dir / ".git" / "FETCH_HEAD")
+            # On first clone, FETCH_HEAD does not exists
+            if not file_timestamp.exists():
+                file_timestamp = Path(repo_dir / ".git" / "HEAD")
+            age = datetime.now() - datetime.fromtimestamp(
+                file_timestamp.stat().st_mtime
+            )
+            if refresh is None or age.total_seconds() > refresh.total_seconds:
+                old_sha = run_git_command(["git", "rev-parse", "HEAD"], str(repo_dir))
+                _LOGGER.info("Updating %s", key)
+                _LOGGER.debug("Location: %s", repo_dir)
+                # Stash local changes (if any)
+                run_git_command(
+                    ["git", "stash", "push", "--include-untracked"], str(repo_dir)
+                )
+                # Fetch remote ref
+                cmd = ["git", "fetch", "--", "origin"]
+                if ref is not None:
+                    cmd.append(ref)
+                run_git_command(cmd, str(repo_dir))
+                # Hard reset to FETCH_HEAD (short-lived git ref corresponding to most recent fetch)
+                run_git_command(["git", "reset", "--hard", "FETCH_HEAD"], str(repo_dir))
 
-            return repo_dir, revert
+                if submodules is not None:
+                    _LOGGER.info(
+                        "Updating submodules (%s) for %s", ", ".join(submodules), key
+                    )
+                    run_git_command(
+                        ["git", "submodule", "update", "--init"] + submodules,
+                        str(repo_dir),
+                    )
 
-    return repo_dir, None
+                def revert():
+                    _LOGGER.info("Reverting changes to %s -> %s", key, old_sha)
+                    run_git_command(["git", "reset", "--hard", old_sha], str(repo_dir))
+
+                return repo_dir, revert
+
+        return repo_dir, None
 
 
 GIT_DOMAINS = {

esphome/git_lock.py

@@ -0,0 +1,141 @@
+"""File locking for git operations to prevent race conditions."""
+
+from contextlib import contextmanager
+import hashlib
+import logging
+from pathlib import Path
+import sys
+import tempfile
+import time
+
+# Platform-specific imports
+if sys.platform == "win32":
+    import msvcrt
+else:
+    import fcntl
+
+_LOGGER = logging.getLogger(__name__)
+
+# Global lock directory
+LOCK_DIR = Path(tempfile.gettempdir()) / "esphome_git_locks"
+LOCK_DIR.mkdir(exist_ok=True)
+
+
+def _acquire_lock_unix(lock_file, timeout, identifier):
+    """Acquire lock on Unix systems using fcntl."""
+    start_time = time.time()
+    last_log_time = start_time
+    while True:
+        try:
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+            return True
+        except OSError:
+            elapsed = time.time() - start_time
+            if elapsed > timeout:
+                raise TimeoutError(
+                    f"Could not acquire lock for {identifier} within {timeout}s"
+                )
+
+            # Log progress every 10 seconds
+            if time.time() - last_log_time > 10:
+                _LOGGER.info(
+                    f"Still waiting for lock {identifier} ({elapsed:.1f}s elapsed)..."
+                )
+                last_log_time = time.time()
+
+            time.sleep(0.1)
+
+
+def _release_lock_unix(lock_file):
+    """Release lock on Unix systems."""
+    try:
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+    except Exception:
+        pass
+
+
+def _acquire_lock_windows(lock_file, timeout, identifier):
+    """Acquire lock on Windows systems using msvcrt."""
+    start_time = time.time()
+    while True:
+        try:
+            msvcrt.locking(lock_file.fileno(), msvcrt.LK_NBLCK, 1)
+            return True
+        except OSError:
+            if time.time() - start_time > timeout:
+                raise TimeoutError(
+                    f"Could not acquire lock for {identifier} within {timeout}s"
+                )
+            time.sleep(0.1)
+
+
+def _release_lock_windows(lock_file):
+    """Release lock on Windows systems."""
+    try:
+        msvcrt.locking(lock_file.fileno(), msvcrt.LK_UNLCK, 1)
+    except Exception:
+        pass
+
+
+@contextmanager
+def git_operation_lock(identifier: str, timeout: float = 30.0):
+    """
+    Acquire a file lock for a git operation.
+
+    :param identifier: Unique identifier for the operation (e.g., repo URL or path)
+    :param timeout: Maximum time to wait for the lock in seconds
+    """
+    # Create a safe filename from the identifier
+    lock_name = hashlib.sha256(identifier.encode()).hexdigest()[:16]
+    lock_path = LOCK_DIR / f"{lock_name}.lock"
+
+    # Ensure lock file exists
+    lock_path.touch(exist_ok=True)
+
+    lock_file = None
+    acquired = False
+
+    try:
+        # Open in binary mode for Windows compatibility
+        lock_file = open(lock_path, "r+b")
+
+        # Platform-specific lock acquisition
+        if sys.platform == "win32":
+            acquired = _acquire_lock_windows(lock_file, timeout, identifier)
+        else:
+            acquired = _acquire_lock_unix(lock_file, timeout, identifier)
+
+        if acquired:
+            _LOGGER.debug(f"Acquired lock for {identifier}")
+
+        yield
+
+    finally:
+        if lock_file:
+            if acquired:
+                # Platform-specific lock release
+                if sys.platform == "win32":
+                    _release_lock_windows(lock_file)
+                else:
+                    _release_lock_unix(lock_file)
+                _LOGGER.debug(f"Released lock for {identifier}")
+            lock_file.close()
+
+
+@contextmanager
+def platformio_init_lock(timeout: float = 30.0):
+    """Lock for PlatformIO initialization to prevent race conditions."""
+    with git_operation_lock("platformio_init", timeout=timeout):
+        yield
+
+
+@contextmanager
+def platformio_install_lock(package_name: str, timeout: float = 300.0):
+    """Lock for PlatformIO package installation to prevent race conditions."""
+    _LOGGER.info(
+        f"Waiting for PlatformIO package installation lock ({package_name})..."
+    )
+    with git_operation_lock(f"platformio_install_{package_name}", timeout=timeout):
+        _LOGGER.info(f"Acquired PlatformIO package installation lock ({package_name})")
+        yield
+        _LOGGER.info(f"Released PlatformIO package installation lock ({package_name})")

esphome/platformio_api.py

@@ -86,9 +86,28 @@ def run_platformio_cli(*args, **kwargs) -> str | int:
     if os.environ.get("ESPHOME_USE_SUBPROCESS") is not None:
         return run_external_process(*cmd, **kwargs)
 
-    import platformio.__main__
+    # Import with minimal locking to prevent initialization race conditions
+    from esphome.git_lock import platformio_init_lock
+
+    with platformio_init_lock():
+        import platformio.__main__
 
     patch_structhash()
+
+    # For first-time PlatformIO runs, use a lock to prevent directory creation conflicts
+    home_pio = Path.home() / ".platformio"
+    if not home_pio.exists() and len(args) > 0 and args[0] == "run":
+        from esphome.git_lock import platformio_install_lock
+
+        _LOGGER.info("First PlatformIO run detected, using initialization lock...")
+        with platformio_install_lock("first_run", timeout=120.0):
+            # Create the directory if it still doesn't exist
+            home_pio.mkdir(exist_ok=True)
+            result = run_external_command(platformio.__main__.main, *cmd, **kwargs)
+            _LOGGER.info("First PlatformIO run completed")
+            return result
+
+    # Normal execution without locking
     return run_external_command(platformio.__main__.main, *cmd, **kwargs)
 
 

script/test_build_components

@@ -3,25 +3,37 @@
 set -e
 
 help() {
-  echo "Usage: $0 [-e <config|compile|clean>] [-c <string>] [-t <string>]" 1>&2
+  echo "Usage: $0 [-e <config|compile|clean>] [-c <string>] [-t <string>] [-j <number>] [-p <string>] [-f]" 1>&2
   echo 1>&2
   echo "  - e - Parameter for esphome command. Default compile. Common alternative is config." 1>&2
   echo "  - c - Component folder name to test. Default *. E.g. '-c logger'." 1>&2
   echo "  - t - Target name to test. Put '-t list' to display all possibilities. E.g. '-t esp32-s2-idf-51'." 1>&2
+  echo "  - j - Number of parallel jobs. Default is number of CPU cores." 1>&2
+  echo "  - p - Platform filter. E.g. '-p esp32' to test only ESP32 platforms." 1>&2
+  echo "  - f - Fail fast. Exit on first failure." 1>&2
+  echo "  - b - Build cache directory. E.g. '-b /tmp/esphome_cache'." 1>&2
   exit 1
 }
 
 # Parse parameter:
-# - `e` - Parameter for `esphome` command. Default `compile`. Common alternative is `config`.
-# - `c` - Component folder name to test. Default `*`.
 esphome_command="compile"
 target_component="*"
-while getopts e:c:t: flag
+num_jobs=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4)
+platform_filter=""
+fail_fast=false
+build_cache_dir=""
+
+while getopts e:c:t:j:p:b:fh flag
 do
     case $flag in
         e) esphome_command=${OPTARG};;
         c) target_component=${OPTARG};;
         t) requested_target_platform=${OPTARG};;
+        j) num_jobs=${OPTARG};;
+        p) platform_filter=${OPTARG};;
+        f) fail_fast=true;;
+        b) build_cache_dir=${OPTARG};;
+        h) help;;
         \?) help;;
     esac
 done
@@ -29,16 +41,66 @@ done
 cd "$(dirname "$0")/.."
 
 if ! [ -d "./tests/test_build_components/build" ]; then
-  mkdir ./tests/test_build_components/build
+  mkdir -p ./tests/test_build_components/build
 fi
 
+# Export build cache directory if specified
+if [ -n "$build_cache_dir" ]; then
+  export PLATFORMIO_BUILD_CACHE_DIR="$build_cache_dir"
+  mkdir -p "$build_cache_dir"
+  echo "Using build cache directory: $build_cache_dir"
+fi
+
+# Track PIDs for parallel execution
+pids=()
+failed_builds=()
+build_count=0
+total_builds=0
+
+# Function to wait for jobs and handle failures
+wait_for_jobs() {
+  local max_jobs=$1
+  while [ ${#pids[@]} -ge $max_jobs ]; do
+    for i in "${!pids[@]}"; do
+      if ! kill -0 "${pids[$i]}" 2>/dev/null; then
+        wait "${pids[$i]}"
+        exit_code=$?
+        if [ $exit_code -ne 0 ]; then
+          failed_builds+=("${build_info[$i]}")
+          if [ "$fail_fast" = true ]; then
+            echo "Build failed, exiting due to fail-fast mode"
+            # Kill remaining jobs
+            for pid in "${pids[@]}"; do
+              kill -TERM "$pid" 2>/dev/null || true
+            done
+            exit 1
+          fi
+        fi
+        unset pids[$i]
+        unset build_info[$i]
+        # Reindex arrays
+        pids=("${pids[@]}")
+        build_info=("${build_info[@]}")
+        break
+      fi
+    done
+    sleep 0.1
+  done
+}
+
 start_esphome() {
   if [ -n "$requested_target_platform" ] && [ "$requested_target_platform" != "$target_platform_with_version" ]; then
     echo "Skipping $target_platform_with_version"
     return
   fi
+
+  # Apply platform filter if specified
+  if [ -n "$platform_filter" ] && [[ ! "$target_platform_with_version" =~ ^$platform_filter ]]; then
+    echo "Skipping $target_platform_with_version (filtered)"
+    return
+  fi
+
   # create dynamic yaml file in `build` folder.
-  # `./tests/test_build_components/build/[target_component].[test_name].[target_platform_with_version].yaml`
   component_test_file="./tests/test_build_components/build/$target_component.$test_name.$target_platform_with_version.yaml"
 
   cp $target_platform_file $component_test_file
@@ -49,17 +111,79 @@ start_esphome() {
     sed -i "s!\$component_test_file!../../.$f!g" $component_test_file
   fi
 
-  # Start esphome process
-  echo "> [$target_component] [$test_name] [$target_platform_with_version]"
-  set -x
-  # TODO: Validate escape of Command line substitution value
-  python3 -m esphome -s component_name $target_component -s component_dir ../../components/$target_component -s test_name $test_name -s target_platform $target_platform $esphome_command $component_test_file
-  { set +x; } 2>/dev/null
+  # Start esphome process in background
+  build_count=$((build_count + 1))
+  echo "> [$build_count/$total_builds] [$target_component] [$test_name] [$target_platform_with_version]"
+
+  (
+    # Add compile process limit for ESPHome internal parallelization
+    export ESPHOME_COMPILE_PROCESS_LIMIT=2
+    
+    # For compilation, add a small random delay to reduce thundering herd effect
+    # This helps stagger the package installation requests
+    if [ "$esphome_command" = "compile" ]; then
+      sleep $((RANDOM % 5))
+    fi
+    
+    python3 -m esphome -s component_name $target_component -s component_dir ../../components/$target_component -s test_name $test_name -s target_platform $target_platform $esphome_command $component_test_file
+  ) &
+
+  local pid=$!
+  pids+=($pid)
+  build_info+=("$target_component/$test_name/$target_platform_with_version")
+
+  # Wait if we've reached the job limit
+  wait_for_jobs $num_jobs
 }
 
-# Find all test yaml files.
-# - `./tests/components/[target_component]/[test_name].[target_platform].yaml`
-# - `./tests/components/[target_component]/[test_name].all.yaml`
+# First pass: count total builds
+echo "Calculating total number of builds..."
+for f in ./tests/components/$target_component/*.*.yaml; do
+  [ -f "$f" ] || continue
+  IFS='/' read -r -a folder_name <<< "$f"
+  IFS='.' read -r -a file_name <<< "${folder_name[4]}"
+  target_platform="${file_name[1]}"
+  file_name_parts=${#file_name[@]}
+
+  if [ "$target_platform" = "all" ] || [ $file_name_parts = 2 ]; then
+    for target_platform_file in ./tests/test_build_components/build_components_base.*.yaml; do
+      IFS='/' read -r -a folder_name <<< "$target_platform_file"
+      IFS='.' read -r -a file_name <<< "${folder_name[3]}"
+      target_platform="${file_name[1]}"
+      target_platform_with_version=${target_platform_file:52}
+      target_platform_with_version=${target_platform_with_version%.*}
+
+      if [ -n "$platform_filter" ] && [[ ! "$target_platform_with_version" =~ ^$platform_filter ]]; then
+        continue
+      fi
+      if [ -n "$requested_target_platform" ] && [ "$requested_target_platform" != "$target_platform_with_version" ]; then
+        continue
+      fi
+      total_builds=$((total_builds + 1))
+    done
+  else
+    target_platform_file="./tests/test_build_components/build_components_base.$target_platform.yaml"
+    if [ -f "$target_platform_file" ]; then
+      for target_platform_file in ./tests/test_build_components/build_components_base.$target_platform*.yaml; do
+        target_platform_with_version=${target_platform_file:52}
+        target_platform_with_version=${target_platform_with_version%.*}
+
+        if [ -n "$platform_filter" ] && [[ ! "$target_platform_with_version" =~ ^$platform_filter ]]; then
+          continue
+        fi
+        if [ -n "$requested_target_platform" ] && [ "$requested_target_platform" != "$target_platform_with_version" ]; then
+          continue
+        fi
+        total_builds=$((total_builds + 1))
+      done
+    fi
+  fi
+done
+
+echo "Total builds to execute: $total_builds with $num_jobs parallel jobs"
+echo
+
+# Second pass: execute builds
 for f in ./tests/components/$target_component/*.*.yaml; do
   [ -f "$f" ] || continue
   IFS='/' read -r -a folder_name <<< "$f"
@@ -72,22 +196,21 @@ for f in ./tests/components/$target_component/*.*.yaml; do
 
   if [ "$target_platform" = "all" ] || [ $file_name_parts = 2 ]; then
     # Test has *not* defined a specific target platform. Need to run tests for all possible target platforms.
-    
+
     for target_platform_file in ./tests/test_build_components/build_components_base.*.yaml; do
       IFS='/' read -r -a folder_name <<< "$target_platform_file"
       IFS='.' read -r -a file_name <<< "${folder_name[3]}"
       target_platform="${file_name[1]}"
+      target_platform_with_version=${target_platform_file:52}
+      target_platform_with_version=${target_platform_with_version%.*}
 
       start_esphome
     done
 
   else
     # Test has defined a specific target platform.
-  
+
     # Validate we have a base test yaml for selected platform.
-    # The target_platform is sourced from the following location.
-    # 1. `./tests/test_build_components/build_components_base.[target_platform].yaml`
-    # 2. `./tests/test_build_components/build_components_base.[target_platform]-ard.yaml`
     target_platform_file="./tests/test_build_components/build_components_base.$target_platform.yaml"
     if ! [ -f "$target_platform_file" ]; then
       echo "No base test file [./tests/test_build_components/build_components_base.$target_platform.yaml] for component test [$f] found."
@@ -104,3 +227,23 @@ for f in ./tests/components/$target_component/*.*.yaml; do
     done
   fi
 done
+
+# Wait for all remaining jobs
+wait_for_jobs 1
+
+echo
+echo "============================================"
+echo "Build Summary:"
+echo "Total builds: $total_builds"
+echo "Failed builds: ${#failed_builds[@]}"
+
+if [ ${#failed_builds[@]} -gt 0 ]; then
+  echo
+  echo "Failed builds:"
+  for build in "${failed_builds[@]}"; do
+    echo "  - $build"
+  done
+  exit 1
+else
+  echo "All builds completed successfully!"
+fi