diff --git a/cores/esp32/esp32-hal-touch-ng.c b/cores/esp32/esp32-hal-touch-ng.c
index 888a299ec0c..483a444b4a0 100644
--- a/cores/esp32/esp32-hal-touch-ng.c
+++ b/cores/esp32/esp32-hal-touch-ng.c
@@ -12,11 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 #include "soc/soc_caps.h"
+#include "esp_idf_version.h"
 
 #if SOC_TOUCH_SENSOR_SUPPORTED
-#if SOC_TOUCH_SENSOR_VERSION == 3  // ESP32P4 for now
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0) || SOC_TOUCH_SENSOR_VERSION == 3
 
-#include "driver/touch_sens.h"
 #include "esp32-hal-touch-ng.h"
 #include "esp32-hal-periman.h"
 
@@ -37,11 +37,24 @@ typedef struct {
 static TouchInterruptHandle_t __touchInterruptHandlers[SOC_TOUCH_SENSOR_NUM] = {
   0,
 };
-
-static uint8_t _sample_num = 1;
+#if SOC_TOUCH_SENSOR_VERSION == 1 // ESP32
+static uint8_t _sample_num = 1; // only one sample configuration supported
+static float _duration_ms = 5.0f;
+static touch_volt_lim_l_t _volt_low = TOUCH_VOLT_LIM_L_0V5;
+static touch_volt_lim_h_t _volt_high = TOUCH_VOLT_LIM_H_1V7;
+static touch_intr_trig_mode_t _intr_trig_mode = TOUCH_INTR_TRIG_ON_BELOW_THRESH;
+#elif SOC_TOUCH_SENSOR_VERSION == 2 // ESP32S2, ESP32S3
+static uint8_t _sample_num = 1; // only one sample configuration supported
+static uint32_t _chg_times = 500;
+static touch_volt_lim_l_t _volt_low = TOUCH_VOLT_LIM_L_0V5;
+static touch_volt_lim_h_t _volt_high = TOUCH_VOLT_LIM_H_2V2;
+#elif SOC_TOUCH_SENSOR_VERSION == 3 // ESP32P4
+static uint8_t _sample_num = 1; // TODO: can be extended to multiple samples
 static uint32_t _div_num = 1;
 static uint8_t _coarse_freq_tune = 1;
 static uint8_t _fine_freq_tune = 1;
+#endif
+
 static uint8_t used_pads = 0;
 
 static uint32_t __touchSleepTime = 256;
@@ -156,15 +169,28 @@ bool touchBenchmarkThreshold(uint8_t pad) {
 
   // Reconfigure passed pad with new threshold
   uint32_t benchmark[_sample_num] = {};
+  #if SOC_TOUCH_SUPPORT_BENCHMARK // ESP32S2, ESP32S3,ESP32P4
   if (touch_channel_read_data(touch_channel_handle[pad], TOUCH_CHAN_DATA_TYPE_BENCHMARK, benchmark) != ESP_OK) {
     log_e("Touch channel read data failed!");
     return false;
   }
+  #else
+  if (touch_channel_read_data(touch_channel_handle[pad], TOUCH_CHAN_DATA_TYPE_SMOOTH, benchmark) != ESP_OK) {
+    log_e("Touch channel read data failed!");
+    return false;
+  }
+  #endif
+
   /* Calculate the proper active thresholds regarding the initial benchmark */
-  touch_channel_config_t chan_cfg = {};
+  touch_channel_config_t chan_cfg = TOUCH_CHANNEL_DEFAULT_CONFIG();
   for (int i = 0; i < _sample_num; i++) {
+#if SOC_TOUCH_SENSOR_VERSION == 1 // ESP32
+    chan_cfg.abs_active_thresh[i] = (uint32_t)(benchmark[i] * (1 - s_thresh2bm_ratio));
+    log_v("Configured [CH %d] sample %d: benchmark = %"PRIu32", threshold = %"PRIu32"\t", pad, i, benchmark[i], chan_cfg.abs_active_thresh[i]);
+#else
     chan_cfg.active_thresh[i] = (uint32_t)(benchmark[i] * s_thresh2bm_ratio);
-    log_v("Configured [CH %d] sample %d: benchmark = %" PRIu32 ", threshold = %" PRIu32 "\t", pad, i, benchmark[i], chan_cfg.active_thresh[i]);
+    log_v("Configured [CH %d] sample %d: benchmark = %"PRIu32", threshold = %"PRIu32"\t", pad, i, benchmark[i], chan_cfg.active_thresh[i]);
+#endif
   }
   /* Update the channel configuration */
   if (touch_sensor_reconfig_channel(touch_channel_handle[pad], &chan_cfg) != ESP_OK) {
@@ -198,21 +224,40 @@ static void __touchInit() {
     return;
   }
   // Support only one sample configuration for now
+#if SOC_TOUCH_SENSOR_VERSION == 1 // ESP32
+  touch_sensor_sample_config_t single_sample_cfg = TOUCH_SENSOR_V1_DEFAULT_SAMPLE_CONFIG(_duration_ms, _volt_low, _volt_high);
+#elif SOC_TOUCH_SENSOR_VERSION == 2 // ESP32S2, ESP32S3
+  touch_sensor_sample_config_t single_sample_cfg = TOUCH_SENSOR_V2_DEFAULT_SAMPLE_CONFIG(_chg_times, _volt_low, _volt_high);
+#elif SOC_TOUCH_SENSOR_VERSION == 3 // ESP32P4
   touch_sensor_sample_config_t single_sample_cfg = TOUCH_SENSOR_V3_DEFAULT_SAMPLE_CONFIG(_div_num, _coarse_freq_tune, _fine_freq_tune);
+#endif
   touch_sensor_sample_config_t sample_cfg[_sample_num] = {};
   sample_cfg[0] = single_sample_cfg;
 
-  /* Allocate new touch controller handle */
   touch_sensor_config_t sens_cfg = {
+#if SOC_TOUCH_SENSOR_VERSION == 1 // ESP32
+    .power_on_wait_us = __touchSleepTime,
+    .meas_interval_us = __touchMeasureTime,
+    .intr_trig_mode = _intr_trig_mode,
+    .intr_trig_group = TOUCH_INTR_TRIG_GROUP_BOTH,
+    .sample_cfg_num = _sample_num,
+    .sample_cfg = sample_cfg,
+#elif SOC_TOUCH_SENSOR_VERSION == 2 // ESP32S2, ESP32S3
+    .power_on_wait_us = __touchSleepTime,
+    .meas_interval_us = __touchMeasureTime,
+    .max_meas_time_us = 0,
+    .sample_cfg_num = _sample_num,
+    .sample_cfg = sample_cfg,
+#elif SOC_TOUCH_SENSOR_VERSION == 3 // ESP32P4
     .power_on_wait_us = __touchSleepTime,
     .meas_interval_us = __touchMeasureTime,
     .max_meas_time_us = 0,
     .output_mode = TOUCH_PAD_OUT_AS_CLOCK,
     .sample_cfg_num = _sample_num,
     .sample_cfg = sample_cfg,
+#endif
   };
 
-  // touch_sensor_config_t sens_cfg = TOUCH_SENSOR_DEFAULT_BASIC_CONFIG(_sample_num, sample_cfg);
   if (touch_sensor_new_controller(&sens_cfg, &touch_sensor_handle) != ESP_OK) {
     goto err;
   }
@@ -225,14 +270,10 @@ static void __touchInit() {
   }
 
   /* Register the touch sensor on_active and on_inactive callbacks */
-  touch_event_callbacks_t callbacks = {
-    .on_active = __touchOnActiveISR,
-    .on_inactive = __touchOnInactiveISR,
-    .on_measure_done = NULL,
-    .on_scan_done = NULL,
-    .on_timeout = NULL,
-    .on_proximity_meas_done = NULL,
-  };
+  touch_event_callbacks_t callbacks = {0};
+  callbacks.on_active = __touchOnActiveISR;
+  callbacks.on_inactive = __touchOnInactiveISR;
+
   if (touch_sensor_register_callbacks(touch_sensor_handle, &callbacks, NULL) != ESP_OK) {
     goto err;
   }
@@ -253,10 +294,8 @@ static void __touchChannelInit(int pad) {
   // Initial setup with default Threshold
   __touchInterruptHandlers[pad].fn = NULL;
 
-  touch_channel_config_t chan_cfg = {
-    .active_thresh = {1000}  // default threshold, will be updated after benchmark
-  };
-
+  touch_channel_config_t chan_cfg = TOUCH_CHANNEL_DEFAULT_CONFIG();
+  
   if (!touchStop() || !touchDisable()) {
     log_e("Touch sensor stop and disable failed!");
     return;
@@ -323,8 +362,21 @@ static void __touchConfigInterrupt(uint8_t pin, void (*userFunc)(void), void *Ar
     __touchInterruptHandlers[pad].arg = NULL;
   } else {
     // attach ISR User Call
-    __touchInit();
-    __touchChannelInit(pad);
+    if (perimanGetPinBus(pin, ESP32_BUS_TYPE_TOUCH) == NULL) {
+      perimanSetBusDeinit(ESP32_BUS_TYPE_TOUCH, touchDetachBus);
+      if (!perimanClearPinBus(pin)) {
+        log_e("Failed to clear pin bus");
+        return;
+      }
+      __touchInit();
+      __touchChannelInit(pad);
+
+      if (!perimanSetPinBus(pin, ESP32_BUS_TYPE_TOUCH, (void *)(pin + 1), -1, pad)) {
+        touchDetachBus((void *)(pin + 1));
+        log_e("Failed to set bus to Peripheral manager");
+        return;
+      }
+    }
     __touchInterruptHandlers[pad].fn = userFunc;
     __touchInterruptHandlers[pad].callWithArgs = callWithArgs;
     __touchInterruptHandlers[pad].arg = Args;
@@ -338,7 +390,11 @@ static void __touchConfigInterrupt(uint8_t pin, void (*userFunc)(void), void *Ar
 
     touch_channel_config_t chan_cfg = {};
     for (int i = 0; i < _sample_num; i++) {
+#if SOC_TOUCH_SENSOR_VERSION == 1 // ESP32
+      chan_cfg.abs_active_thresh[i] = threshold;
+#else
       chan_cfg.active_thresh[i] = threshold;
+#endif
     }
 
     if (touch_sensor_reconfig_channel(touch_channel_handle[pad], &chan_cfg) != ESP_OK) {
@@ -375,7 +431,6 @@ bool touchInterruptGetLastStatus(uint8_t pin) {
   if (pad < 0) {
     return false;
   }
-
   return __touchInterruptHandlers[pad].lastStatusIsPressed;
 }
 
@@ -405,9 +460,13 @@ void touchSleepWakeUpEnable(uint8_t pin, touch_value_t threshold) {
 
   touch_sleep_config_t deep_slp_cfg = {
     .slp_wakeup_lvl = TOUCH_DEEP_SLEEP_WAKEUP,
+#if SOC_TOUCH_SENSOR_VERSION == 1 // ESP32
+    .deep_slp_sens_cfg = NULL,  // Use the original touch sensor configuration
+#else // SOC_TOUCH_SENSOR_VERSION 2 and 3// ESP32S2, ESP32S3, ESP32P4
     .deep_slp_chan = touch_channel_handle[pad],
     .deep_slp_thresh = {threshold},
     .deep_slp_sens_cfg = NULL,  // Use the original touch sensor configuration
+#endif
   };
 
   // Register the deep sleep wake-up
@@ -434,6 +493,29 @@ void touchSetTiming(float measure, uint32_t sleep) {
   __touchMeasureTime = measure;
 }
 
+#if SOC_TOUCH_SENSOR_VERSION == 1 // ESP32
+void touchSetConfig(float duration_ms, touch_volt_lim_l_t volt_low, touch_volt_lim_h_t volt_high) {
+  if (initialized) {
+    log_e("Touch sensor already initialized. Cannot set configuration.");
+    return;
+  }
+  _duration_ms = duration_ms;
+  _volt_low = volt_low;
+  _volt_high = volt_high;
+}
+
+#elif SOC_TOUCH_SENSOR_VERSION == 2 // ESP32S2, ESP32S3
+void touchSetConfig(uint32_t chg_times, touch_volt_lim_l_t volt_low, touch_volt_lim_h_t volt_high) {
+  if (initialized) {
+    log_e("Touch sensor already initialized. Cannot set configuration.");
+    return;
+  }
+  _chg_times = chg_times;
+  _volt_low = volt_low;
+  _volt_high = volt_high;
+}
+
+#elif SOC_TOUCH_SENSOR_VERSION == 3 // ESP32P4
 void touchSetConfig(uint32_t div_num, uint8_t coarse_freq_tune, uint8_t fine_freq_tune) {
   if (initialized) {
     log_e("Touch sensor already initialized. Cannot set configuration.");
@@ -443,11 +525,22 @@ void touchSetConfig(uint32_t div_num, uint8_t coarse_freq_tune, uint8_t fine_fre
   _coarse_freq_tune = coarse_freq_tune;
   _fine_freq_tune = fine_freq_tune;
 }
+#endif
+
+#if SOC_TOUCH_SENSOR_VERSION == 1 // ESP32
+void touchInterruptSetThresholdDirection(bool mustbeLower) {
+  if (mustbeLower) {
+    _intr_trig_mode = TOUCH_INTR_TRIG_ON_BELOW_THRESH;
+  } else {
+    _intr_trig_mode = TOUCH_INTR_TRIG_ON_ABOVE_THRESH;
+  }
+}
+#endif
 
 extern touch_value_t touchRead(uint8_t) __attribute__((weak, alias("__touchRead")));
 extern void touchAttachInterrupt(uint8_t, voidFuncPtr, touch_value_t) __attribute__((weak, alias("__touchAttachInterrupt")));
 extern void touchAttachInterruptArg(uint8_t, voidArgFuncPtr, void *, touch_value_t) __attribute__((weak, alias("__touchAttachArgsInterrupt")));
 extern void touchDetachInterrupt(uint8_t) __attribute__((weak, alias("__touchDettachInterrupt")));
 
-#endif /* SOC_TOUCH_SENSOR_VERSION == 3 */
+#endif /* ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0) || SOC_TOUCH_SENSOR_VERSION == 3 */
 #endif /* SOC_TOUCH_SENSOR_SUPPORTED */
diff --git a/cores/esp32/esp32-hal-touch-ng.h b/cores/esp32/esp32-hal-touch-ng.h
index 0d4eb79ac58..988fdccda00 100644
--- a/cores/esp32/esp32-hal-touch-ng.h
+++ b/cores/esp32/esp32-hal-touch-ng.h
@@ -21,14 +21,36 @@
 #define MAIN_ESP32_HAL_TOUCH_NEW_H_
 
 #include "soc/soc_caps.h"
+#include "esp_idf_version.h"
+
 #if SOC_TOUCH_SENSOR_SUPPORTED
-#if SOC_TOUCH_SENSOR_VERSION == 3  // ESP32P4
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0) || SOC_TOUCH_SENSOR_VERSION == 3
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #include "esp32-hal.h"
+#include "driver/touch_sens.h"
+
+#if SOC_TOUCH_SENSOR_VERSION == 1 // ESP32
+#define TOUCH_CHANNEL_DEFAULT_CONFIG()        {  \
+    .abs_active_thresh = {1000},  \
+    .charge_speed = TOUCH_CHARGE_SPEED_7,  \
+    .init_charge_volt = TOUCH_INIT_CHARGE_VOLT_DEFAULT,  \
+    .group = TOUCH_CHAN_TRIG_GROUP_BOTH,  \
+}
+#elif SOC_TOUCH_SENSOR_VERSION == 2     // ESP32-S2 & ESP32-S3
+#define TOUCH_CHANNEL_DEFAULT_CONFIG()        {  \
+    .active_thresh = {2000},  \
+    .charge_speed = TOUCH_CHARGE_SPEED_7,  \
+    .init_charge_volt = TOUCH_INIT_CHARGE_VOLT_DEFAULT,  \
+}
+#elif SOC_TOUCH_SENSOR_VERSION == 3     // ESP32-P4
+#define TOUCH_CHANNEL_DEFAULT_CONFIG()        {  \
+    .active_thresh = {1000},  \
+}
+#endif
 
 typedef uint32_t touch_value_t;
 
@@ -40,11 +62,39 @@ typedef uint32_t touch_value_t;
  **/
 void touchSetTiming(float measure, uint32_t sleep);
 
+#if SOC_TOUCH_SENSOR_VERSION == 1 // ESP32
+/*
+ * @param[in] duration_ms   The measurement duration of the touch channel
+ * @param[in] volt_low      The low voltage limit of the touch channel
+ * @param[in] volt_high     The high voltage limit of the touch channel
+ */
+void touchSetConfig(float duration_ms, touch_volt_lim_l_t volt_low, touch_volt_lim_h_t volt_high);
+
+#elif SOC_TOUCH_SENSOR_VERSION == 2 // ESP32S2, ESP32S3
+/*
+ * @param[in] chg_times     The charge times of the touch channel
+ * @param[in] volt_low      The low voltage limit of the touch channel
+ * @param[in] volt_high     The high voltage limit of the touch channel
+ */
+void touchSetConfig(uint32_t chg_times, touch_volt_lim_l_t volt_low, touch_volt_lim_h_t volt_high);
+
+#elif SOC_TOUCH_SENSOR_VERSION == 3 // ESP32P4
 /*
  * Tune the touch pad frequency.
  * Note: Must be called before setting up touch pads
 */
 void touchSetConfig(uint32_t _div_num, uint8_t coarse_freq_tune, uint8_t fine_freq_tune);
+#endif
+
+#if SOC_TOUCH_SENSOR_VERSION == 1
+/*
+ * Specific functions to ESP32
+ * Tells the driver if it shall activate the ISR if the sensor is Lower or Higher than the Threshold
+ * Default if Lower.
+ * Note: Must be called before setting up touch pads
+ **/
+void touchInterruptSetThresholdDirection(bool mustbeLower);
+#endif
 
 /*
  * Read touch pad value.
@@ -86,6 +136,6 @@ void touchSleepWakeUpEnable(uint8_t pin, touch_value_t threshold);
 }
 #endif
 
-#endif /* SOC_TOUCH_SENSOR_VERSION == 3 */
+#endif /* ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0) || SOC_TOUCH_SENSOR_VERSION == 3 */
 #endif /* SOC_TOUCH_SENSOR_SUPPORTED */
 #endif /* MAIN_ESP32_HAL_TOUCH_H_ */
diff --git a/cores/esp32/esp32-hal-touch.c b/cores/esp32/esp32-hal-touch.c
index 701bf6d16c9..e611fa557f1 100644
--- a/cores/esp32/esp32-hal-touch.c
+++ b/cores/esp32/esp32-hal-touch.c
@@ -12,9 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 #include "soc/soc_caps.h"
+#include "esp_idf_version.h"
 
 #if SOC_TOUCH_SENSOR_SUPPORTED
-#if SOC_TOUCH_SENSOR_VERSION <= 2  // ESP32, ESP32S2, ESP32S3
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 5, 0) && SOC_TOUCH_SENSOR_VERSION <= 2  // ESP32, ESP32S2, ESP32S3
 
 #include "driver/touch_sensor.h"
 #include "esp32-hal-touch.h"
@@ -325,5 +326,5 @@ extern void touchAttachInterruptArg(uint8_t, voidArgFuncPtr, void *, touch_value
 extern void touchDetachInterrupt(uint8_t) __attribute__((weak, alias("__touchDettachInterrupt")));
 extern void touchSetCycles(uint16_t, uint16_t) __attribute__((weak, alias("__touchSetCycles")));
 
-#endif /* SOC_TOUCH_SENSOR_VERSION <= 2 */
-#endif /* SOC_TOUCH_SENSOR_SUPPORTED */
+#endif /* ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 5, 0) && SOC_TOUCH_SENSOR_VERSION <= 2 */
+#endif /* SOC_TOUCH_SENSOR_SUPPORTED */
\ No newline at end of file
diff --git a/cores/esp32/esp32-hal-touch.h b/cores/esp32/esp32-hal-touch.h
index 4b06c7db766..44c99dce206 100644
--- a/cores/esp32/esp32-hal-touch.h
+++ b/cores/esp32/esp32-hal-touch.h
@@ -21,8 +21,10 @@
 #define MAIN_ESP32_HAL_TOUCH_H_
 
 #include "soc/soc_caps.h"
+#include "esp_idf_version.h"
+
 #if SOC_TOUCH_SENSOR_SUPPORTED
-#if SOC_TOUCH_SENSOR_VERSION <= 2  // ESP32 ESP32S2 ESP32S3
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 5, 0) && SOC_TOUCH_SENSOR_VERSION <= 2  // ESP32, ESP32S2, ESP32S3
 
 #ifdef __cplusplus
 extern "C" {
@@ -98,6 +100,6 @@ void touchSleepWakeUpEnable(uint8_t pin, touch_value_t threshold);
 }
 #endif
 
-#endif /* SOC_TOUCH_SENSOR_VERSION <= 2 */
+#endif /* ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 5, 0) && SOC_TOUCH_SENSOR_VERSION <= 2 */
 #endif /* SOC_TOUCH_SENSOR_SUPPORTED */
 #endif /* MAIN_ESP32_HAL_TOUCH_H_ */
diff --git a/libraries/ESP32/examples/Touch/TouchButton/TouchButton.ino b/libraries/ESP32/examples/Touch/TouchButton/TouchButton.ino
index 43f3bc36592..ac2b641be40 100644
--- a/libraries/ESP32/examples/Touch/TouchButton/TouchButton.ino
+++ b/libraries/ESP32/examples/Touch/TouchButton/TouchButton.ino
@@ -3,44 +3,53 @@
 This is an example how to use Touch Intrrerupts
 The sketch will tell when it is touched and then released as like a push-button
 
-This method based on touchInterruptSetThresholdDirection() is only available for ESP32
+This method based on touchInterruptGetLastStatus()
 */
 
 #include "Arduino.h"
 
-int threshold = 40;
-bool touchActive = false;
-bool lastTouchActive = false;
-bool testingLower = true;
-
-void gotTouchEvent() {
-  if (lastTouchActive != testingLower) {
-    touchActive = !touchActive;
-    testingLower = !testingLower;
-    // Touch ISR will be inverted: Lower <--> Higher than the Threshold after ISR event is noticed
-    touchInterruptSetThresholdDirection(testingLower);
-  }
+int threshold = 0;  // if 0 is used, benchmark value is used. Its by default 1,5% change, can be changed by touchSetDefaultThreshold(float percentage)
+bool touch1detected = false;
+bool touch2detected = false;
+
+void gotTouch1() {
+  touch1detected = true;
+}
+
+void gotTouch2() {
+  touch2detected = true;
 }
 
 void setup() {
   Serial.begin(115200);
   delay(1000);  // give me time to bring up serial monitor
-  Serial.println("ESP32 Touch Interrupt Test");
-  touchAttachInterrupt(T2, gotTouchEvent, threshold);
 
-  // Touch ISR will be activated when touchRead is lower than the Threshold
-  touchInterruptSetThresholdDirection(testingLower);
+  //Optional: Set the threshold to 5% of the benchmark value. Only effective if threshold = 0.
+  touchSetDefaultThreshold(5);
+
+  //Set the touch pads
+  Serial.println("\n ESP32 Touch Interrupt Test\n");
+  touchAttachInterrupt(T1, gotTouch1, threshold);
+  touchAttachInterrupt(T2, gotTouch2, threshold);
 }
 
 void loop() {
-  if (lastTouchActive != touchActive) {
-    lastTouchActive = touchActive;
-    if (touchActive) {
-      Serial.println("  ---- Touch was Pressed");
+  if (touch1detected) {
+    touch1detected = false;
+    if (touchInterruptGetLastStatus(T1)) {
+      Serial.println(" --- T1 Touched");
     } else {
-      Serial.println("  ---- Touch was Released");
+      Serial.println(" --- T1 Released");
     }
   }
-  Serial.printf("T2 pin2 = %d \n", touchRead(T2));
-  delay(125);
+  if (touch2detected) {
+    touch2detected = false;
+    if (touchInterruptGetLastStatus(T2)) {
+      Serial.println(" --- T2 Touched");
+    } else {
+      Serial.println(" --- T2 Released");
+    }
+  }
+
+  delay(80);
 }
diff --git a/libraries/ESP32/examples/Touch/TouchButton/ci.json b/libraries/ESP32/examples/Touch/TouchButton/ci.json
index cec76a84f9d..c0ecf9fc0a5 100644
--- a/libraries/ESP32/examples/Touch/TouchButton/ci.json
+++ b/libraries/ESP32/examples/Touch/TouchButton/ci.json
@@ -1,5 +1,5 @@
 {
   "requires": [
-    "CONFIG_SOC_TOUCH_VERSION_1=y"
+    "CONFIG_SOC_TOUCH_SENSOR_SUPPORTED=y"
   ]
 }
diff --git a/libraries/ESP32/examples/Touch/TouchButtonV2/TouchButtonV2.ino b/libraries/ESP32/examples/Touch/TouchButtonV2/TouchButtonV2.ino
deleted file mode 100644
index df9b3f41149..00000000000
--- a/libraries/ESP32/examples/Touch/TouchButtonV2/TouchButtonV2.ino
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-
-This is an example how to use Touch Intrrerupts
-The sketch will tell when it is touched and then released as like a push-button
-
-This method based on touchInterruptGetLastStatus() is only available for ESP32 S2 and S3
-*/
-
-#include "Arduino.h"
-
-int threshold = 1500;  // ESP32S2
-bool touch1detected = false;
-bool touch2detected = false;
-
-void gotTouch1() {
-  touch1detected = true;
-}
-
-void gotTouch2() {
-  touch2detected = true;
-}
-
-void setup() {
-  Serial.begin(115200);
-  delay(1000);  // give me time to bring up serial monitor
-
-  Serial.println("\n ESP32 Touch Interrupt Test\n");
-  touchAttachInterrupt(T1, gotTouch1, threshold);
-  touchAttachInterrupt(T2, gotTouch2, threshold);
-}
-
-void loop() {
-  if (touch1detected) {
-    touch1detected = false;
-    if (touchInterruptGetLastStatus(T1)) {
-      Serial.println(" --- T1 Touched");
-    } else {
-      Serial.println(" --- T1 Released");
-    }
-  }
-  if (touch2detected) {
-    touch2detected = false;
-    if (touchInterruptGetLastStatus(T2)) {
-      Serial.println(" --- T2 Touched");
-    } else {
-      Serial.println(" --- T2 Released");
-    }
-  }
-
-  delay(80);
-}
diff --git a/libraries/ESP32/examples/Touch/TouchButtonV2/ci.json b/libraries/ESP32/examples/Touch/TouchButtonV2/ci.json
deleted file mode 100644
index 2710fa7940e..00000000000
--- a/libraries/ESP32/examples/Touch/TouchButtonV2/ci.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "requires": [
-    "CONFIG_SOC_TOUCH_VERSION_2=y"
-  ]
-}
diff --git a/libraries/ESP32/examples/Touch/TouchInterrupt/TouchInterrupt.ino b/libraries/ESP32/examples/Touch/TouchInterrupt/TouchInterrupt.ino
index 3b4e5f0b9e9..08e10dc0fac 100644
--- a/libraries/ESP32/examples/Touch/TouchInterrupt/TouchInterrupt.ino
+++ b/libraries/ESP32/examples/Touch/TouchInterrupt/TouchInterrupt.ino
@@ -3,11 +3,7 @@ This is an example how to use Touch Intrrerupts
 The bigger the threshold, the more sensible is the touch
 */
 
-#if CONFIG_IDF_TARGET_ESP32P4
-int threshold = 0;  // when 0 is used, the benchmarked value will be used
-#else
-int threshold = 40;
-#endif
+int threshold = 0;  // if 0 is used, benchmark value is used. Its by default 1,5% change, can be changed by touchSetDefaultThreshold(float percentage)
 
 bool touch1detected = false;
 bool touch2detected = false;
@@ -23,6 +19,10 @@ void gotTouch2() {
 void setup() {
   Serial.begin(115200);
   delay(1000);  // give me time to bring up serial monitor
+
+  //Optional: Set the threshold to 5% of the benchmark value. Only effective if threshold = 0.
+  touchSetDefaultThreshold(5);
+  
   Serial.println("ESP32 Touch Interrupt Test");
   touchAttachInterrupt(T2, gotTouch1, threshold);
   touchAttachInterrupt(T3, gotTouch2, threshold);
diff --git a/libraries/ESP32/examples/Touch/TouchRead/TouchRead.ino b/libraries/ESP32/examples/Touch/TouchRead/TouchRead.ino
index 8e93ba44691..ba221f3048f 100644
--- a/libraries/ESP32/examples/Touch/TouchRead/TouchRead.ino
+++ b/libraries/ESP32/examples/Touch/TouchRead/TouchRead.ino
@@ -1,5 +1,5 @@
 // ESP32 Touch Test
-// Just test touch pin - Touch0 is T0 which is on GPIO 4.
+// Just test touch pin - Touch2 is T2 which is on GPIO 2.
 
 void setup() {
   Serial.begin(115200);
@@ -8,6 +8,6 @@ void setup() {
 }
 
 void loop() {
-  Serial.println(touchRead(T1));  // get value using T0
+  Serial.println(touchRead(T2));  // get value using T2
   delay(1000);
 }
diff --git a/tests/validation/touch/touch.ino b/tests/validation/touch/touch.ino
index 97aac8a65e6..abe450a27ab 100644
--- a/tests/validation/touch/touch.ino
+++ b/tests/validation/touch/touch.ino
@@ -1,35 +1,33 @@
 #include <unity.h>
 #include "soc/soc_caps.h"
-#include "driver/touch_pad.h"
-
-#if SOC_TOUCH_SENSOR_VERSION == 3
 #include "hal/touch_sensor_ll.h"
-#endif
 
 #if CONFIG_IDF_TARGET_ESP32
 
-#define TEST_TOUCH_CHANNEL (9)
+#define TEST_TOUCH_CHANNEL (7)
 static touch_pad_t touch_list[TEST_TOUCH_CHANNEL] = {
   TOUCH_PAD_NUM0,
   //TOUCH_PAD_NUM1 is GPIO0, for download.
-  TOUCH_PAD_NUM2, TOUCH_PAD_NUM3, TOUCH_PAD_NUM4, TOUCH_PAD_NUM5, TOUCH_PAD_NUM6, TOUCH_PAD_NUM7, TOUCH_PAD_NUM8, TOUCH_PAD_NUM9
+  TOUCH_PAD_NUM2, TOUCH_PAD_NUM3, TOUCH_PAD_NUM4, TOUCH_PAD_NUM5, TOUCH_PAD_NUM6, TOUCH_PAD_NUM7 /*,TOUCH_PAD_NUM8, TOUCH_PAD_NUM9*/
 };
 
-uint8_t TOUCH_GPIOS[] = {4, 2, 15, 13, 12, 14, 27, 33, 32};
+uint8_t TOUCH_GPIOS[] = {4,/* 0,*/ 2, 15, 13, 12, 14, 27/*, 33, 32*/};
 
 #define NO_TOUCH_GPIO 25
 
 #elif (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
 
-#define TEST_TOUCH_CHANNEL (12)  //14
+#define TEST_TOUCH_CHANNEL (9)  //14
 static touch_pad_t touch_list[TEST_TOUCH_CHANNEL] = {
   TOUCH_PAD_NUM1, TOUCH_PAD_NUM2, TOUCH_PAD_NUM3,  TOUCH_PAD_NUM4,  TOUCH_PAD_NUM5, TOUCH_PAD_NUM6, TOUCH_PAD_NUM7,
-  TOUCH_PAD_NUM8, TOUCH_PAD_NUM9, TOUCH_PAD_NUM10, TOUCH_PAD_NUM11, TOUCH_PAD_NUM12
+  TOUCH_PAD_NUM8, /*TOUCH_PAD_NUM9,*/ TOUCH_PAD_NUM10
+  //TOUCH_PAD_NUM11, //Wrong reading
+  //TOUCH_PAD_NUM12, //Wrong reading
   //TOUCH_PAD_NUM13, //Wrong reading
   //TOUCH_PAD_NUM14
 };
 
-uint8_t TOUCH_GPIOS[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 /*,13,14*/};
+uint8_t TOUCH_GPIOS[] = {1, 2, 3, 4, 5, 6, 7, 8,/*9,*/ 10/*, 11, 12, 13, 14*/};
 
 #define NO_TOUCH_GPIO 17
 
@@ -47,21 +45,14 @@ uint8_t TOUCH_GPIOS[] = {2, 3, 4, 5, 6 /*, 7, 8, 9, 10, 11, 12 ,13, 14, 15*/};
 #define NO_TOUCH_GPIO 17
 #endif
 
+#define INTERRUPT_THRESHOLD      0    // Use benchmarked threshold
+
 #if CONFIG_IDF_TARGET_ESP32
-#define RELEASED_VALUE      75  //75+ read value to pass test
-#define PRESSED_VALUE       20  //20- read value to pass test
-#define INTERRUPT_THRESHOLD 40
-#elif CONFIG_IDF_TARGET_ESP32S2
-#define RELEASED_VALUE      10000  //10000- read value to pass test
-#define PRESSED_VALUE       42000  //40000+ read value to pass test
-#define INTERRUPT_THRESHOLD 30000
-#elif CONFIG_IDF_TARGET_ESP32S3
-#define RELEASED_VALUE      25000  //25000- read value to pass test
-#define PRESSED_VALUE       90000  //90000+ read value to pass test
-#define INTERRUPT_THRESHOLD 80000
-#elif CONFIG_IDF_TARGET_ESP32P4
+#define PRESSED_VALUE_DIFFERENCE 200  //-200 read value difference against the unpressed value
+#elif CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32S2
+#define PRESSED_VALUE_DIFFERENCE 2000  //2000+ read value difference against the unpressed value
+#elif CONFIG_IDF_TARGET_ESP32P4 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
 #define PRESSED_VALUE_DIFFERENCE 200  //200+ read value difference against the unpressed value
-#define INTERRUPT_THRESHOLD      0    // Use benchmarked threshold
 #else
 #error Test not currently supported on this chip. Please adjust and try again!
 #endif
@@ -82,7 +73,7 @@ void gotTouch2() {
  */
 static void test_press_fake(touch_pad_t pad_num) {
 #if SOC_TOUCH_SENSOR_VERSION <= 2
-  touch_pad_set_cnt_mode(pad_num, TOUCH_PAD_SLOPE_1, TOUCH_PAD_TIE_OPT_DEFAULT);
+  touch_ll_set_charge_speed(pad_num,TOUCH_CHARGE_SPEED_4);
 #else
   touch_ll_set_internal_capacitor(0x7f);
 #endif
@@ -93,7 +84,7 @@ static void test_press_fake(touch_pad_t pad_num) {
  */
 static void test_release_fake(touch_pad_t pad_num) {
 #if SOC_TOUCH_SENSOR_VERSION <= 2
-  touch_pad_set_cnt_mode(pad_num, TOUCH_PAD_SLOPE_7, TOUCH_PAD_TIE_OPT_DEFAULT);
+  touch_ll_set_charge_speed(pad_num, TOUCH_CHARGE_SPEED_7); 
 #else
   touch_ll_set_internal_capacitor(0);
 #endif
@@ -113,31 +104,6 @@ void tearDown(void) {
  * Test Touch read on all available channels - compare values if reading is right
  */
 void test_touch_read(void) {
-
-#if SOC_TOUCH_SENSOR_VERSION <= 2
-  //TEST RELEASE STATE
-  for (int i = 0; i < sizeof(TOUCH_GPIOS); i++) {
-#ifdef CONFIG_IDF_TARGET_ESP32
-    TEST_ASSERT_GREATER_THAN(RELEASED_VALUE, touchRead(TOUCH_GPIOS[i]));
-#else
-    TEST_ASSERT_LESS_THAN(RELEASED_VALUE, touchRead(TOUCH_GPIOS[i]));
-#endif
-  }
-
-  // TEST PRESS STATE
-  for (int j = 0; j < TEST_TOUCH_CHANNEL; j++) {
-    test_press_fake(touch_list[j]);
-  }
-  delay(100);
-
-  for (int k = 0; k < sizeof(TOUCH_GPIOS); k++) {
-#ifdef CONFIG_IDF_TARGET_ESP32
-    TEST_ASSERT_LESS_THAN(PRESSED_VALUE, touchRead(TOUCH_GPIOS[k]));
-#else
-    TEST_ASSERT_GREATER_THAN(PRESSED_VALUE, touchRead(TOUCH_GPIOS[k]));
-#endif
-  }
-#else  //TOUCH V3
   //TEST RELEASE STATE
   touch_value_t touch_unpressed[sizeof(TOUCH_GPIOS)];
   for (int i = 0; i < sizeof(TOUCH_GPIOS); i++) {
@@ -155,11 +121,17 @@ void test_touch_read(void) {
     touch_pressed[k] = touchRead(TOUCH_GPIOS[k]);
   }
 
-  // COMPARE PRESSED > UNPRESSED
+  // COMPARE PRESSED <-> UNPRESSED
   for (int l = 0; l < sizeof(TOUCH_GPIOS); l++) {
-    TEST_ASSERT_GREATER_THAN((touch_unpressed[l] + PRESSED_VALUE_DIFFERENCE), touch_pressed[l]);
+    log_v("Touch %d: %d -> %d", TOUCH_GPIOS[l], touch_unpressed[l], touch_pressed[l]);
   }
+  for (int l = 0; l < sizeof(TOUCH_GPIOS); l++) {
+#if CONFIG_IDF_TARGET_ESP32
+    TEST_ASSERT_LESS_THAN((touch_unpressed[l] - PRESSED_VALUE_DIFFERENCE), touch_pressed[l]);
+#else
+    TEST_ASSERT_GREATER_THAN((touch_unpressed[l] + PRESSED_VALUE_DIFFERENCE), touch_pressed[l]);
 #endif
+  }
 }
 
 void test_touch_interrtupt(void) {
@@ -170,7 +142,6 @@ void test_touch_interrtupt(void) {
   test_press_fake(touch_list[0]);
   test_press_fake(touch_list[1]);
 
-  delay(300);
 
   touchDetachInterrupt(TOUCH_GPIOS[0]);
   touchDetachInterrupt(TOUCH_GPIOS[1]);
@@ -192,6 +163,11 @@ void setup() {
 
   UNITY_BEGIN();
   RUN_TEST(test_touch_read);
+
+#if SOC_TOUCH_SENSOR_VERSION == 3
+  touch_ll_enable_internal_capacitor(true);
+#endif
+
   RUN_TEST(test_touch_interrtupt);
   RUN_TEST(test_touch_errors);
   UNITY_END();