update touch with review advice

components/driver/CMakeLists.txt

@@ -61,7 +61,7 @@ if(${target} STREQUAL "esp32s3")
                      "usb_serial_jtag.c"
                      "spi_slave_hd.c"
                      "touch_sensor_common.c"
-                     "esp32s2/touch_sensor.c" # The touch sensor function is the same as the esp32s2 platform.
+                     "esp32s3/touch_sensor.c"
                     )
 endif()
 

components/driver/esp32s2/touch_sensor.c

@@ -62,7 +62,6 @@ static SemaphoreHandle_t rtc_touch_mux = NULL;
                     Touch Pad
 ---------------------------------------------------------------*/
 
-#if CONFIG_IDF_TARGET_ESP32S2
 /** Workaround for scan done interrupt issue. */
 static void touch_pad_workaround_isr_internal(void *arg)
 {
@@ -82,7 +81,6 @@ static void touch_pad_workaround_isr_internal(void *arg)
         }
     }
 }
-#endif
 
 esp_err_t touch_pad_isr_register(intr_handler_t fn, void *arg, touch_pad_intr_mask_t intr_mask)
 {
@@ -112,13 +110,12 @@ esp_err_t touch_pad_isr_register(intr_handler_t fn, void *arg, touch_pad_intr_ma
     }
 #endif
     esp_err_t ret = rtc_isr_register(fn, arg, en_msk);
-#if CONFIG_IDF_TARGET_ESP32S2
     /* Must ensure: After being registered, it is executed first. */
     if ( (ret == ESP_OK) && (reg_flag == false) && (intr_mask & (TOUCH_PAD_INTR_MASK_SCAN_DONE | TOUCH_PAD_INTR_MASK_TIMEOUT)) ) {
         rtc_isr_register(touch_pad_workaround_isr_internal, NULL, RTC_CNTL_TOUCH_SCAN_DONE_INT_ST_M | RTC_CNTL_TOUCH_TIMEOUT_INT_ST_M);
         reg_flag = true;
     }
-#endif
+
     return ret;
 }
 

components/driver/esp32s3/touch_sensor.c

@@ -1,4 +1,608 @@
+/*
+ * SPDX-FileCopyrightText: 2016-2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <esp_types.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "esp_log.h"
+#include "sys/lock.h"
+#include "soc/soc_pins.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/xtensa_api.h"
+#include "freertos/semphr.h"
+#include "freertos/timers.h"
+#include "esp_intr_alloc.h"
+#include "driver/rtc_io.h"
+#include "driver/touch_pad.h"
+#include "driver/rtc_cntl.h"
+#include "driver/gpio.h"
+#include "sdkconfig.h"
+
+#include "hal/touch_sensor_types.h"
+#include "hal/touch_sensor_hal.h"
+
+#ifndef NDEBUG
+// Enable built-in checks in queue.h in debug builds
+#define INVARIANTS
+#endif
+#include "sys/queue.h"
+
+#define TOUCH_PAD_FILTER_FACTOR_DEFAULT   (4)   // IIR filter coefficient.
+#define TOUCH_PAD_SHIFT_DEFAULT           (4)   // Increase computing accuracy.
+#define TOUCH_PAD_SHIFT_ROUND_DEFAULT     (8)   // ROUND = 2^(n-1); rounding off for fractional.
+#define TOUCH_PAD_MEASURE_WAIT_DEFAULT  (0xFF)  // The timer frequency is 8Mhz, the max value is 0xff
+
+static const char *TOUCH_TAG = "TOUCH_SENSOR";
+#define TOUCH_CHECK(a, str, ret_val) ({                                             \
+    if (!(a)) {                                                                     \
+        ESP_LOGE(TOUCH_TAG,"%s(%d): %s", __FUNCTION__, __LINE__, str);              \
+        return (ret_val);                                                           \
+    }                                                                               \
+})
+#define TOUCH_CHANNEL_CHECK(channel) do { \
+        TOUCH_CHECK(channel < SOC_TOUCH_SENSOR_NUM && channel >= 0, "Touch channel error", ESP_ERR_INVALID_ARG); \
+        TOUCH_CHECK(channel != SOC_TOUCH_DENOISE_CHANNEL, "TOUCH0 is internal denoise channel", ESP_ERR_INVALID_ARG); \
+    } while (0);
+#define TOUCH_CH_MASK_CHECK(mask) TOUCH_CHECK((mask <= TOUCH_PAD_BIT_MASK_ALL), "touch channel bitmask error", ESP_ERR_INVALID_ARG)
+#define TOUCH_INTR_MASK_CHECK(mask) TOUCH_CHECK(mask & TOUCH_PAD_INTR_MASK_ALL, "intr mask error", ESP_ERR_INVALID_ARG)
+#define TOUCH_PARAM_CHECK_STR(s)           ""s" parameter error"
+
+extern portMUX_TYPE rtc_spinlock; //TODO: Will be placed in the appropriate position after the rtc module is finished.
+#define TOUCH_ENTER_CRITICAL_SAFE()  portENTER_CRITICAL_SAFE(&rtc_spinlock) // Can be called in isr and task.
+#define TOUCH_EXIT_CRITICAL_SAFE()  portEXIT_CRITICAL_SAFE(&rtc_spinlock)
+#define TOUCH_ENTER_CRITICAL()  portENTER_CRITICAL(&rtc_spinlock)
+#define TOUCH_EXIT_CRITICAL()  portEXIT_CRITICAL(&rtc_spinlock)
+
+static SemaphoreHandle_t rtc_touch_mux = NULL;
+
+/*---------------------------------------------------------------
+                    Touch Pad
+---------------------------------------------------------------*/
+
+esp_err_t touch_pad_isr_register(intr_handler_t fn, void *arg, touch_pad_intr_mask_t intr_mask)
+{
+    TOUCH_CHECK(fn != NULL, TOUCH_PARAM_CHECK_STR("intr_mask"), ESP_ERR_INVALID_ARG);
+    TOUCH_INTR_MASK_CHECK(intr_mask);
+
+    uint32_t en_msk = 0;
+    if (intr_mask & TOUCH_PAD_INTR_MASK_DONE) {
+        en_msk |= RTC_CNTL_TOUCH_DONE_INT_ST_M;
+    }
+    if (intr_mask & TOUCH_PAD_INTR_MASK_ACTIVE) {
+        en_msk |= RTC_CNTL_TOUCH_ACTIVE_INT_ST_M;
+    }
+    if (intr_mask & TOUCH_PAD_INTR_MASK_INACTIVE) {
+        en_msk |= RTC_CNTL_TOUCH_INACTIVE_INT_ST_M;
+    }
+    if (intr_mask & TOUCH_PAD_INTR_MASK_SCAN_DONE) {
+        en_msk |= RTC_CNTL_TOUCH_SCAN_DONE_INT_ST_M;
+    }
+    if (intr_mask & TOUCH_PAD_INTR_MASK_TIMEOUT) {
+        en_msk |= RTC_CNTL_TOUCH_TIMEOUT_INT_ST_M;
+    }
+#if SOC_TOUCH_PROXIMITY_MEAS_DONE_SUPPORTED
+    if (intr_mask & TOUCH_PAD_INTR_MASK_PROXI_MEAS_DONE) {
+        en_msk |= RTC_CNTL_TOUCH_APPROACH_LOOP_DONE_INT_ST_M;
+    }
+#endif
+    esp_err_t ret = rtc_isr_register(fn, arg, en_msk);
+
+    return ret;
+}
+
+esp_err_t touch_pad_set_meas_time(uint16_t sleep_cycle, uint16_t meas_times)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_set_meas_times(meas_times);
+    touch_hal_set_sleep_time(sleep_cycle);
+    TOUCH_EXIT_CRITICAL();
+
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_get_meas_time(uint16_t *sleep_cycle, uint16_t *meas_times)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_get_measure_times(meas_times);
+    touch_hal_get_sleep_time(sleep_cycle);
+    TOUCH_EXIT_CRITICAL();
+
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_set_idle_channel_connect(touch_pad_conn_type_t type)
+{
+    TOUCH_CHECK(type < TOUCH_PAD_CONN_MAX, TOUCH_PARAM_CHECK_STR("type"), ESP_ERR_INVALID_ARG);
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_set_idle_channel_connect(type);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_get_idle_channel_connect(touch_pad_conn_type_t *type)
+{
+    touch_hal_get_idle_channel_connect(type);
+    return ESP_OK;
+}
+
+bool touch_pad_meas_is_done(void)
+{
+    return touch_hal_meas_is_done();
+}
+
+esp_err_t touch_pad_set_channel_mask(uint16_t enable_mask)
+{
+    TOUCH_CH_MASK_CHECK(enable_mask);
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_set_channel_mask(enable_mask);
+    TOUCH_EXIT_CRITICAL();
+
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_get_channel_mask(uint16_t *enable_mask)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_get_channel_mask(enable_mask);
+    TOUCH_EXIT_CRITICAL();
+
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_clear_channel_mask(uint16_t enable_mask)
+{
+    TOUCH_CH_MASK_CHECK(enable_mask);
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_clear_channel_mask(enable_mask);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+touch_pad_t IRAM_ATTR touch_pad_get_current_meas_channel(void)
+{
+    return (touch_pad_t)touch_hal_get_current_meas_channel();
+}
+
+esp_err_t touch_pad_intr_enable(touch_pad_intr_mask_t int_mask)
+{
+    if (!(int_mask & TOUCH_PAD_INTR_MASK_ALL)) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_intr_enable(int_mask);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_intr_disable(touch_pad_intr_mask_t int_mask)
+{
+    if (!(int_mask & TOUCH_PAD_INTR_MASK_ALL)) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_intr_disable(int_mask);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_intr_clear(touch_pad_intr_mask_t int_mask)
+{
+    TOUCH_INTR_MASK_CHECK(int_mask);
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_intr_clear(int_mask);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+uint32_t touch_pad_read_intr_status_mask(void)
+{
+    return touch_hal_read_intr_status_mask();
+}
+
+esp_err_t touch_pad_timeout_set(bool enable, uint32_t threshold)
+{
+    TOUCH_ENTER_CRITICAL();
+    if (enable) {
+        touch_hal_timeout_enable();
+    } else {
+        touch_hal_timeout_disable();
+    }
+    touch_hal_timeout_set_threshold(threshold);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_timeout_get_threshold(uint32_t *threshold)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_timeout_get_threshold(threshold);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_timeout_resume(void)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_timer_force_done();
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_config(touch_pad_t touch_num)
+{
+    TOUCH_CHANNEL_CHECK(touch_num);
+
+    touch_pad_io_init(touch_num);
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_config(touch_num);
+    touch_hal_set_channel_mask(BIT(touch_num));
+    TOUCH_EXIT_CRITICAL();
+
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_init(void)
+{
+    if (rtc_touch_mux == NULL) {
+        rtc_touch_mux = xSemaphoreCreateMutex();
+    }
+    if (rtc_touch_mux == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_init();
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_deinit(void)
+{
+    TOUCH_CHECK(rtc_touch_mux != NULL, "Touch pad not initialized", ESP_FAIL);
+    xSemaphoreTake(rtc_touch_mux, portMAX_DELAY);
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_deinit();
+    TOUCH_EXIT_CRITICAL();
+    xSemaphoreGive(rtc_touch_mux);
+    vSemaphoreDelete(rtc_touch_mux);
+    rtc_touch_mux = NULL;
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_reset(void)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_reset();
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t IRAM_ATTR touch_pad_read_raw_data(touch_pad_t touch_num, uint32_t *raw_data)
+{
+    TOUCH_CHECK(touch_num < TOUCH_PAD_MAX && touch_num >= 0, "Touch channel error", ESP_ERR_INVALID_ARG);
+    TOUCH_ENTER_CRITICAL_SAFE();
+    *raw_data = touch_hal_read_raw_data(touch_num);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+esp_err_t IRAM_ATTR touch_pad_filter_read_smooth(touch_pad_t touch_num, uint32_t *smooth_data)
+{
+    TOUCH_CHANNEL_CHECK(touch_num);
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_filter_read_smooth(touch_num, smooth_data);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+esp_err_t IRAM_ATTR touch_pad_read_benchmark(touch_pad_t touch_num, uint32_t *benchmark)
+{
+    TOUCH_CHANNEL_CHECK(touch_num);
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_read_benchmark(touch_num, benchmark);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+/* Should be call after clk enable and filter enable. */
+esp_err_t touch_pad_reset_benchmark(touch_pad_t touch_num)
+{
+    TOUCH_CHECK(touch_num <= TOUCH_PAD_MAX && touch_num >= 0, "Touch channel error", ESP_ERR_INVALID_ARG);
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_reset_benchmark(touch_num);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_filter_set_config(touch_filter_config_t *filter_info)
+{
+    TOUCH_CHECK(filter_info->mode < TOUCH_PAD_FILTER_MAX, TOUCH_PARAM_CHECK_STR("mode"), ESP_ERR_INVALID_ARG);
+    TOUCH_CHECK(filter_info->debounce_cnt <= TOUCH_DEBOUNCE_CNT_MAX, TOUCH_PARAM_CHECK_STR("debounce"), ESP_ERR_INVALID_ARG);
+    TOUCH_CHECK(filter_info->noise_thr <= TOUCH_NOISE_THR_MAX, TOUCH_PARAM_CHECK_STR("noise"), ESP_ERR_INVALID_ARG);
+    TOUCH_CHECK(filter_info->jitter_step <= TOUCH_JITTER_STEP_MAX, TOUCH_PARAM_CHECK_STR("jitter_step"), ESP_ERR_INVALID_ARG);
+    TOUCH_CHECK(filter_info->smh_lvl < TOUCH_PAD_SMOOTH_MAX, TOUCH_PARAM_CHECK_STR("smooth level"), ESP_ERR_INVALID_ARG);
+
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_filter_set_config(filter_info);
+    TOUCH_EXIT_CRITICAL();
+
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_filter_get_config(touch_filter_config_t *filter_info)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_filter_get_config(filter_info);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_filter_enable(void)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_filter_enable();
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_filter_disable(void)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_filter_disable();
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_denoise_enable(void)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_clear_channel_mask(BIT(SOC_TOUCH_DENOISE_CHANNEL));
+    touch_hal_denoise_enable();
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_denoise_disable(void)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_denoise_disable();
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_denoise_set_config(touch_pad_denoise_t *denoise)
+{
+    TOUCH_CHECK(denoise->grade < TOUCH_PAD_DENOISE_MAX, TOUCH_PARAM_CHECK_STR("grade"), ESP_ERR_INVALID_ARG);
+    TOUCH_CHECK(denoise->cap_level < TOUCH_PAD_DENOISE_CAP_MAX, TOUCH_PARAM_CHECK_STR("cap_level"), ESP_ERR_INVALID_ARG);
+
+    const touch_hal_meas_mode_t meas = {
+        .slope = TOUCH_PAD_SLOPE_DEFAULT,
+        .tie_opt = TOUCH_PAD_TIE_OPT_DEFAULT,
+    };
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_set_meas_mode(SOC_TOUCH_DENOISE_CHANNEL, &meas);
+    touch_hal_denoise_set_config(denoise);
+    TOUCH_EXIT_CRITICAL();
+
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_denoise_get_config(touch_pad_denoise_t *denoise)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_denoise_get_config(denoise);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_denoise_read_data(uint32_t *data)
+{
+    touch_hal_denoise_read_data(data);
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_waterproof_set_config(touch_pad_waterproof_t *waterproof)
+{
+    TOUCH_CHECK(waterproof->guard_ring_pad < SOC_TOUCH_SENSOR_NUM, TOUCH_PARAM_CHECK_STR("pad"), ESP_ERR_INVALID_ARG);
+    TOUCH_CHECK(waterproof->shield_driver < TOUCH_PAD_SHIELD_DRV_MAX, TOUCH_PARAM_CHECK_STR("shield_driver"), ESP_ERR_INVALID_ARG);
+
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_waterproof_set_config(waterproof);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_waterproof_get_config(touch_pad_waterproof_t *waterproof)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_waterproof_get_config(waterproof);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_waterproof_enable(void)
+{
+    touch_pad_io_init(SOC_TOUCH_SHIELD_CHANNEL);
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_waterproof_enable();
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_waterproof_disable(void)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_waterproof_disable();
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_proximity_enable(touch_pad_t touch_num, bool enabled)
+{
+    esp_err_t ret = ESP_OK;
+    TOUCH_CHECK(touch_num < TOUCH_PAD_MAX, "Touch channel error", ESP_ERR_INVALID_ARG);
+
+    TOUCH_ENTER_CRITICAL();
+    if (!touch_hal_enable_proximity(touch_num, enabled)) {
+        ret = ESP_ERR_NOT_SUPPORTED;
+    }
+    TOUCH_EXIT_CRITICAL();
+    return ret;
+}
+
+esp_err_t touch_pad_proximity_set_count(touch_pad_t touch_num, uint32_t count)
+{
+    TOUCH_CHECK(count <= TOUCH_PROXIMITY_MEAS_NUM_MAX, TOUCH_PARAM_CHECK_STR("measure count"), ESP_ERR_INVALID_ARG);
+
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_proximity_set_meas_times(count);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_proximity_get_count(touch_pad_t touch_num, uint32_t *count)
+{
+    TOUCH_CHECK(count != NULL, TOUCH_PARAM_CHECK_STR("measure count"), ESP_ERR_INVALID_ARG);
+
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_proximity_get_meas_times(count);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
 /**
- * The touch sensor function is the same as the esp32s2 platform.
- * Please refer to the source files of the ESP32S2 platform.
-*/
+ * @brief Get measure count of proximity channel.
+ *        The proximity sensor measurement is the accumulation of touch channel measurements.
+ * @param touch_num touch pad index
+ * @param cnt Pointer to receive proximity channel measurement count
+ * @return
+ *     - ESP_OK Success
+ *     - ESP_ERR_INVALID_ARG parameter is NULL
+ */
+esp_err_t touch_pad_proximity_read_meas_cnt(touch_pad_t touch_num, uint32_t *cnt)
+{
+    TOUCH_CHECK(touch_hal_proximity_pad_check(touch_num), "touch num is not proximity", ESP_ERR_INVALID_ARG);
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_proximity_read_meas_cnt(touch_num, cnt);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_proximity_get_data(touch_pad_t touch_num, uint32_t *measure_out)
+{
+    TOUCH_CHECK(touch_hal_proximity_pad_check(touch_num), "touch num is not proximity", ESP_ERR_INVALID_ARG);
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_read_benchmark(touch_num, measure_out);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+/************** sleep pad setting ***********************/
+
+esp_err_t touch_pad_sleep_channel_get_info(touch_pad_sleep_channel_t *slp_config)
+{
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_sleep_channel_get_config(slp_config);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_channel_enable(touch_pad_t pad_num, bool enable)
+{
+    TOUCH_CHANNEL_CHECK(pad_num);
+
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_sleep_channel_enable(pad_num, enable);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_channel_enable_proximity(touch_pad_t pad_num, bool enable)
+{
+    TOUCH_CHANNEL_CHECK(pad_num);
+
+    TOUCH_ENTER_CRITICAL();
+    if (enable) {
+        touch_hal_sleep_enable_approach();
+    } else {
+        touch_hal_sleep_disable_approach();
+    }
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_get_channel_num(touch_pad_t *pad_num)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_sleep_get_channel_num(pad_num);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_set_threshold(touch_pad_t pad_num, uint32_t touch_thres)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_sleep_set_threshold(touch_thres);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_get_threshold(touch_pad_t pad_num, uint32_t *touch_thres)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_sleep_get_threshold(touch_thres);
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_channel_read_benchmark(touch_pad_t pad_num, uint32_t *benchmark)
+{
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_sleep_read_benchmark(benchmark);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_channel_read_smooth(touch_pad_t pad_num, uint32_t *smooth_data)
+{
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_sleep_read_smooth(smooth_data);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_channel_read_data(touch_pad_t pad_num, uint32_t *raw_data)
+{
+    TOUCH_ENTER_CRITICAL_SAFE();
+    touch_hal_sleep_read_data(raw_data);
+    TOUCH_EXIT_CRITICAL_SAFE();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_channel_reset_benchmark(void)
+{
+    TOUCH_ENTER_CRITICAL();
+    touch_hal_sleep_reset_benchmark();
+    TOUCH_EXIT_CRITICAL();
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_channel_read_debounce(touch_pad_t pad_num, uint32_t *debounce)
+{
+    touch_hal_sleep_read_debounce(debounce);
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_channel_read_proximity_cnt(touch_pad_t pad_num, uint32_t *approach_cnt)
+{
+    touch_hal_sleep_read_proximity_cnt(approach_cnt);
+    return ESP_OK;
+}
+
+esp_err_t touch_pad_sleep_channel_set_work_time(uint16_t sleep_cycle, uint16_t meas_times)
+{
+    touch_hal_sleep_channel_set_work_time(sleep_cycle, meas_times);
+    return ESP_OK;
+}

components/soc/esp32/include/soc/soc_caps.h

@@ -243,7 +243,6 @@
 
 #define SOC_TOUCH_PAD_MEASURE_WAIT_MAX      (0xFF)  /*!<The timer frequency is 8Mhz, the max value is 0xff */
 #define SOC_TOUCH_PAD_THRESHOLD_MAX         (0)     /*!<If set touch threshold max value, The touch sensor can't be in touched status */
-#define SOC_PM_SUPPORT_TOUCH_SENSOR_WAKEUP        (1)     /*!<Supports waking up from touch pad trigger */
 
 /*-------------------------- TWAI CAPS ---------------------------------------*/
 #define SOC_TWAI_BRP_MIN                        2
@@ -295,6 +294,7 @@
 
 /*-------------------------- Power Management CAPS ---------------------------*/
 #define SOC_PM_SUPPORT_EXT_WAKEUP       (1)
+#define SOC_PM_SUPPORT_TOUCH_SENSOR_WAKEUP        (1)     /*!<Supports waking up from touch pad trigger */
 
 /* ---------------------------- Compatibility ------------------------------- */
 #define SOC_CAN_SUPPORTED                   SOC_TWAI_SUPPORTED

components/soc/esp32s2/include/soc/soc_caps.h

@@ -239,7 +239,6 @@
 
 #define SOC_TOUCH_PAD_THRESHOLD_MAX         (0x1FFFFF)  /*!<If set touch threshold max value, The touch sensor can't be in touched status */
 #define SOC_TOUCH_PAD_MEASURE_WAIT_MAX      (0xFF)  /*!<The timer frequency is 8Mhz, the max value is 0xff */
-#define SOC_PM_SUPPORT_TOUCH_SENSOR_WAKEUP        (1)     /*!<Supports waking up from touch pad trigger */
 
 /*-------------------------- TWAI CAPS ---------------------------------------*/
 #define SOC_TWAI_BRP_MIN                2
@@ -330,5 +329,7 @@
 
 #define SOC_PM_SUPPORT_WIFI_PD          (1)
 
+#define SOC_PM_SUPPORT_TOUCH_SENSOR_WAKEUP        (1)     /*!<Supports waking up from touch pad trigger */
+
 /* ---------------------------- Compatibility ------------------------------- */
 // No contents

examples/peripherals/touch_sensor/touch_periph_version.txt

@@ -0,0 +1,4 @@
+| Version | Supported Targets |
+| ------- | ----------------- |
+|    V1   | ESP32             |
+|    V2   | ESP32S2, ESP32S3  |

examples/peripherals/touch_sensor/touch_sensor_v1/touch_pad_interrupt/main/tp_interrupt_main.c

@@ -16,8 +16,6 @@
 #include "soc/rtc_periph.h"
 #include "soc/sens_periph.h"
 
-#if CONFIG_IDF_TARGET_ESP32
-
 static const char *TAG = "Touch pad";
 
 #define TOUCH_THRESH_NO_USE   (0)
@@ -171,5 +169,3 @@ void app_main(void)
     // Start a task to show what pads have been touched
     xTaskCreate(&tp_example_read_task, "touch_pad_read_task", 2048, NULL, 5, NULL);
 }
-
-#endif // CONFIG_IDF_TARGET_ESP32

examples/peripherals/touch_sensor/touch_sensor_v1/touch_pad_read/main/tp_read_main.c

@@ -12,8 +12,6 @@
 #include "driver/touch_pad.h"
 #include "esp_log.h"
 
-#if CONFIG_IDF_TARGET_ESP32
-
 #define TOUCH_PAD_NO_CHANGE   (-1)
 #define TOUCH_THRESH_NO_USE   (0)
 #define TOUCH_FILTER_MODE_EN  (1)
@@ -72,5 +70,3 @@ void app_main(void)
     // Start task to read values sensed by pads
     xTaskCreate(&tp_example_read_task, "touch_pad_read_task", 2048, NULL, 5, NULL);
 }
-
-#endif // CONFIG_IDF_TARGET_ESP32

examples/peripherals/touch_sensor/touch_sensor_v2/touch_pad_read/main/tp_read_main.c

@@ -64,7 +64,7 @@ void app_main(void)
     }
 #if TOUCH_CHANGE_CONFIG
     /* If you want change the touch sensor default setting, please write here(after initialize). There are examples: */
-    touch_pad_set_meas_time(TOUCH_PAD_SLEEP_CYCLE_DEFAULT, TOUCH_PAD_SLEEP_CYCLE_DEFAULT);
+    touch_pad_set_meas_time(TOUCH_PAD_SLEEP_CYCLE_DEFAULT, TOUCH_PAD_MEASURE_CYCLE_DEFAULT);
     touch_pad_set_voltage(TOUCH_PAD_HIGH_VOLTAGE_THRESHOLD, TOUCH_PAD_LOW_VOLTAGE_THRESHOLD, TOUCH_PAD_ATTEN_VOLTAGE_THRESHOLD);
     touch_pad_set_idle_channel_connect(TOUCH_PAD_IDLE_CH_CONNECT_DEFAULT);
     for (int i = 0; i < TOUCH_BUTTON_NUM; i++) {