From 589646a31eea9b3dfdd92e3a3d06540dfa23f4d0 Mon Sep 17 00:00:00 2001 From: fuzhibo Date: Mon, 6 Sep 2021 21:45:08 +0800 Subject: [PATCH] update touch with review advice --- components/driver/CMakeLists.txt | 2 +- components/driver/esp32s2/touch_sensor.c | 5 +- components/driver/esp32s3/touch_sensor.c | 610 +++++++++++++++++- components/soc/esp32/include/soc/soc_caps.h | 2 +- components/soc/esp32s2/include/soc/soc_caps.h | 3 +- .../touch_sensor/touch_periph_version.txt | 4 + .../touch_pad_interrupt/CMakeLists.txt | 0 .../touch_pad_interrupt/Makefile | 0 .../touch_pad_interrupt/README.md | 0 .../touch_pad_interrupt/main/CMakeLists.txt | 0 .../touch_pad_interrupt/main/component.mk | 0 .../main/tp_interrupt_main.c | 4 - .../touch_pad_read/CMakeLists.txt | 0 .../touch_pad_read/Makefile | 0 .../touch_pad_read/README.md | 0 .../touch_pad_read/main/CMakeLists.txt | 0 .../touch_pad_read/main/component.mk | 0 .../touch_pad_read/main/tp_read_main.c | 4 - .../touch_pad_interrupt/CMakeLists.txt | 0 .../touch_pad_interrupt/Makefile | 0 .../touch_pad_interrupt/README.md | 0 .../touch_pad_interrupt/main/CMakeLists.txt | 0 .../touch_pad_interrupt/main/component.mk | 0 .../main/tp_interrupt_main.c | 0 .../touch_pad_read/CMakeLists.txt | 0 .../touch_pad_read/Makefile | 0 .../touch_pad_read/README.md | 0 .../touch_pad_read/main/CMakeLists.txt | 0 .../touch_pad_read/main/component.mk | 0 .../touch_pad_read/main/tp_read_main.c | 2 +- 30 files changed, 617 insertions(+), 19 deletions(-) create mode 100644 examples/peripherals/touch_sensor/touch_periph_version.txt rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_interrupt/CMakeLists.txt (100%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_interrupt/Makefile (100%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_interrupt/README.md (100%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_interrupt/main/CMakeLists.txt (100%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_interrupt/main/component.mk (100%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_interrupt/main/tp_interrupt_main.c (98%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_read/CMakeLists.txt (100%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_read/Makefile (100%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_read/README.md (100%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_read/main/CMakeLists.txt (100%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_read/main/component.mk (100%) rename examples/peripherals/touch_sensor/{esp32 => touch_sensor_v1}/touch_pad_read/main/tp_read_main.c (97%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_interrupt/CMakeLists.txt (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_interrupt/Makefile (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_interrupt/README.md (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_interrupt/main/CMakeLists.txt (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_interrupt/main/component.mk (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_interrupt/main/tp_interrupt_main.c (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_read/CMakeLists.txt (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_read/Makefile (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_read/README.md (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_read/main/CMakeLists.txt (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_read/main/component.mk (100%) rename examples/peripherals/touch_sensor/{ => touch_sensor_v2}/touch_pad_read/main/tp_read_main.c (99%) diff --git a/components/driver/CMakeLists.txt b/components/driver/CMakeLists.txt index c9026b268c..4671b23e7c 100644 --- a/components/driver/CMakeLists.txt +++ b/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() diff --git a/components/driver/esp32s2/touch_sensor.c b/components/driver/esp32s2/touch_sensor.c index c3c35824f8..98e390704b 100644 --- a/components/driver/esp32s2/touch_sensor.c +++ b/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; } diff --git a/components/driver/esp32s3/touch_sensor.c b/components/driver/esp32s3/touch_sensor.c index ba6323ce30..9a224d78b2 100644 --- a/components/driver/esp32s3/touch_sensor.c +++ b/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 +#include +#include +#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; +} diff --git a/components/soc/esp32/include/soc/soc_caps.h b/components/soc/esp32/include/soc/soc_caps.h index e39984ec51..02e4b1acc7 100644 --- a/components/soc/esp32/include/soc/soc_caps.h +++ b/components/soc/esp32/include/soc/soc_caps.h @@ -243,7 +243,6 @@ #define SOC_TOUCH_PAD_MEASURE_WAIT_MAX (0xFF) /*!