diff --git a/components/driver/test_apps/.build-test-rules.yml b/components/driver/test_apps/.build-test-rules.yml index f2e92614c7..300b2b44b2 100644 --- a/components/driver/test_apps/.build-test-rules.yml +++ b/components/driver/test_apps/.build-test-rules.yml @@ -149,11 +149,11 @@ components/driver/test_apps/temperature_sensor: components/driver/test_apps/touch_sensor_v1: disable: - - if: SOC_TOUCH_VERSION_1 != 1 + - if: SOC_TOUCH_SENSOR_VERSION != 1 components/driver/test_apps/touch_sensor_v2: disable: - - if: SOC_TOUCH_VERSION_2 != 1 + - if: SOC_TOUCH_SENSOR_VERSION != 2 components/driver/test_apps/twai: disable: diff --git a/components/driver/test_apps/touch_sensor_v2/main/test_touch_v2.c b/components/driver/test_apps/touch_sensor_v2/main/test_touch_v2.c index 44643ffd68..1ef0f9f656 100644 --- a/components/driver/test_apps/touch_sensor_v2/main/test_touch_v2.c +++ b/components/driver/test_apps/touch_sensor_v2/main/test_touch_v2.c @@ -57,7 +57,7 @@ void test_pxp_deinit_io(void) } #endif -#define TOUCH_READ_INVALID_VAL (SOC_TOUCH_PAD_THRESHOLD_MAX) +#define TOUCH_READ_INVALID_VAL (TOUCH_PAD_THRESHOLD_MAX) #define TOUCH_READ_ERROR_THRESH (0.1) // 10% error #define TOUCH_INTR_THRESHOLD (0.1) #define TOUCH_EXCEED_TIME_MS (1000) diff --git a/components/hal/esp32/include/hal/touch_sensor_ll.h b/components/hal/esp32/include/hal/touch_sensor_ll.h index 21850c9b97..c12200fc52 100644 --- a/components/hal/esp32/include/hal/touch_sensor_ll.h +++ b/components/hal/esp32/include/hal/touch_sensor_ll.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -32,6 +32,8 @@ extern "C" { #define TOUCH_LL_BIT_SWAP(data, n, m) (((data >> n) & 0x1) == ((data >> m) & 0x1) ? (data) : ((data) ^ ((0x1 < +#include +#include "hal/misc.h" +#include "hal/assert.h" +#include "soc/touch_sensor_periph.h" +#include "soc/lp_analog_peri_struct.h" +#include "soc/touch_struct.h" +#include "soc/pmu_struct.h" +#include "soc/soc_caps.h" +#include "hal/touch_sensor_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define TOUCH_LL_READ_RAW 0x0 +#define TOUCH_LL_READ_BENCHMARK 0x2 +#define TOUCH_LL_READ_SMOOTH 0x3 + +#define TOUCH_LL_TIMER_FORCE_DONE_BY_SW 0x1 +#define TOUCH_LL_TIMER_DONE_BY_FSM 0x0 + +// Interrupt mask +#define TOUCH_LL_INTR_MASK_SCAN_DONE BIT(1) +#define TOUCH_LL_INTR_MASK_DONE BIT(2) +#define TOUCH_LL_INTR_MASK_ACTIVE BIT(3) +#define TOUCH_LL_INTR_MASK_INACTIVE BIT(4) +#define TOUCH_LL_INTR_MASK_TIMEOUT BIT(5) +#define TOUCH_LL_INTR_MASK_APPROACH_DONE BIT(6) +#define TOUCH_LL_INTR_MASK_ALL (0x3F) + +#define TOUCH_LL_FULL_CHANNEL_MASK ((uint16_t)((1U << SOC_TOUCH_SENSOR_NUM) - 1)) +#define TOUCH_LL_NULL_CHANNEL (15) // Null Channel id. Used for disabling some functions like sleep/approach/waterproof + +#define TOUCH_LL_PAD_MEASURE_WAIT_MAX (0x7FFF) // The timer frequency is 8Mhz, the max value is 0xff + +/** + * Enable/disable clock gate of touch sensor. + * + * @param enable true/false. + */ +static inline void touch_ll_enable_clock(bool enable) +{ + LP_ANA_PERI.date.clk_en = enable; +} + +/** + * Set the power on wait cycle + * + * @param wait_cycles + */ +static inline void touch_ll_set_power_on_wait_cycle(uint32_t wait_cycles) +{ + LP_ANA_PERI.touch_scan_ctrl1.touch_xpd_wait = wait_cycles; +} + +/** + * Set touch sensor touch sensor charge and discharge times of every measurement on a pad. + * + * @param sampler_id The sampler index + * @param charge_times The times of charge and discharge in each measure process of touch channels. + * The timer frequency is 8Mhz. Range: 0 ~ 0xffff. + */ +static inline void touch_ll_set_charge_times(uint8_t sampler_id, uint16_t charge_times) +{ + //The times of charge and discharge in each measure process of touch channels. + switch (sampler_id) { + case 0: + LP_ANA_PERI.touch_work_meas_num.touch_meas_num0 = charge_times; + break; + case 1: + LP_ANA_PERI.touch_work_meas_num.touch_meas_num1 = charge_times; + break; + case 2: + LP_ANA_PERI.touch_work_meas_num.touch_meas_num2 = charge_times; + break; + default: + abort(); + } +} + +/** + * Get touch sensor times of charge and discharge. + * + * @param meas_times Pointer to accept times count of charge and discharge. + */ +static inline void touch_ll_get_charge_times(uint8_t sampler_id, uint16_t *charge_times) +{ + switch (sampler_id) { + case 0: + *charge_times = LP_ANA_PERI.touch_work_meas_num.touch_meas_num0; + break; + case 1: + *charge_times = LP_ANA_PERI.touch_work_meas_num.touch_meas_num1; + break; + case 2: + *charge_times = LP_ANA_PERI.touch_work_meas_num.touch_meas_num2; + break; + default: + abort(); + } +} + +/** + * Set touch sensor sleep time. + * + * @param interval_ticks The touch sensor will sleep for some cycles after each measurement. + * interval_ticks decide the interval between each measurement. + * t_sleep = interval_ticks / (RTC_SLOW_CLK frequency). + * The approximate frequency value of RTC_SLOW_CLK can be obtained using rtc_clk_slow_freq_get_hz function. + */ +static inline void touch_ll_set_measure_interval_ticks(uint16_t interval_ticks) +{ + // touch sensor sleep cycle Time = interval_ticks / RTC_SLOW_CLK + HAL_FORCE_MODIFY_U32_REG_FIELD(PMU.touch_pwr_cntl, touch_sleep_cycles, interval_ticks); +} + +/** + * Get touch sensor sleep time. + * + * @param interval_ticks Pointer to accept measurement interval (sleep) cycle number. + */ +static inline void touch_ll_get_measure_interval_ticks(uint16_t *interval_ticks) +{ + *interval_ticks = HAL_FORCE_READ_U32_REG_FIELD(PMU.touch_pwr_cntl, touch_sleep_cycles); +} + +/** + * Set touch sensor FSM mode. + * The measurement action can be triggered by the hardware timer, as well as by the software instruction. + * + * @param mode FSM mode. + * TOUCH_FSM_MODE_TIMER: the FSM will trigger scanning repeatedly under the control of the hardware timer + * TOUCH_FSM_MODE_SW: the FSM will trigger scanning once under the control of the software + */ +static inline void touch_ll_set_fsm_mode(touch_fsm_mode_t mode) +{ + // FSM controlled by timer or software + LP_ANA_PERI.touch_mux0.touch_fsm_en = mode; + // Start by timer or software + LP_ANA_PERI.touch_mux0.touch_start_force = mode; + // Stop by timer or software + LP_ANA_PERI.touch_mux0.touch_done_force = mode; +} + +/** + * Get touch sensor FSM mode. + * The measurement action can be triggered by the hardware timer, as well as by the software instruction. + * + * @param mode FSM mode. + */ +static inline void touch_ll_get_fsm_mode(touch_fsm_mode_t *mode) +{ + *mode = (touch_fsm_mode_t)LP_ANA_PERI.touch_mux0.touch_fsm_en; +} + +/** + * Is touch sensor FSM using hardware timer to trigger scanning. + * The measurement action can be triggered by the hardware timer, as well as by the software instruction. + * + * @return Whether FSM timer enabled. + */ +static inline bool touch_ll_is_fsm_using_timer(void) +{ + return !LP_ANA_PERI.touch_mux0.touch_start_force; +} + +/** + * Touch timer trigger measurement and always wait measurement done. + * Force done for touch timer ensures that the timer always can get the measurement done signal. + */ +static inline void touch_ll_force_done_curr_measurement(void) +{ + if (touch_ll_is_fsm_using_timer()) { + LP_ANA_PERI.touch_mux0.touch_done_force = TOUCH_LL_TIMER_FORCE_DONE_BY_SW; + LP_ANA_PERI.touch_mux0.touch_done_en = 1; + LP_ANA_PERI.touch_mux0.touch_done_en = 0; + LP_ANA_PERI.touch_mux0.touch_done_force = TOUCH_LL_TIMER_DONE_BY_FSM; + } else { + LP_ANA_PERI.touch_mux0.touch_done_en = 1; + LP_ANA_PERI.touch_mux0.touch_done_en = 0; + } +} + +/** + * Start touch sensor FSM timer to run FSM repeatedly + * The measurement action can be triggered by the hardware timer, as well as by the software instruction. + * @note + * The timer should be triggered + * @param is_sleep Whether in sleep state + */ +static inline void touch_ll_start_fsm_repeated_timer(bool is_sleep) +{ + /** + * Touch timer trigger measurement and always wait measurement done. + * Force done for touch timer ensures that the timer always can get the measurement done signal. + */ + touch_ll_force_done_curr_measurement(); + if (is_sleep) { + PMU.touch_pwr_cntl.touch_sleep_timer_en = 1; + } else { + LP_ANA_PERI.touch_mux0.touch_start_en = 1; + } +} + +/** + * Stop touch sensor FSM timer. + * The measurement action can be triggered by the hardware timer, as well as by the software instruction. + * @param is_sleep Whether in sleep state + */ +static inline void touch_ll_stop_fsm_repeated_timer(bool is_sleep) +{ + if (is_sleep) { + PMU.touch_pwr_cntl.touch_sleep_timer_en = 0; + } else { + LP_ANA_PERI.touch_mux0.touch_start_en = 0; + } + touch_ll_force_done_curr_measurement(); +} + +/** + * Start touch sensor FSM once by software + * @note Every trigger means measuring one channel, not scanning all enabled channels + */ +static inline void touch_ll_start_fsm_once(void) +{ + /* Trigger once measurement */ + LP_ANA_PERI.touch_mux0.touch_start_en = 1; + LP_ANA_PERI.touch_mux0.touch_start_en = 0; +} + +static inline void touch_ll_measure_channel_once(uint16_t chan_mask) +{ + LP_ANA_PERI.touch_mux1.touch_start = chan_mask; +} + +/** + * Set touch sensor threshold of charge cycles that triggers pad active state. + * The threshold determines the sensitivity of the touch sensor. + * The threshold is the original value of the trigger state minus the benchmark value. + * + * @note If set "TOUCH_PAD_THRESHOLD_MAX", the touch is never be triggered. + * @param touch_num The touch pad id + * @param sampler_id The sampler index + * @param thresh The threshold of charge cycles + */ +static inline void touch_ll_set_chan_active_threshold(uint32_t touch_num, uint8_t sampler_id, uint32_t thresh) +{ + HAL_ASSERT(sampler_id < SOC_TOUCH_SAMPLER_NUM); + HAL_FORCE_MODIFY_U32_REG_FIELD(LP_ANA_PERI.touch_padx_thn[touch_num].thn[sampler_id], threshold, thresh); +} + +/** + * Enable touch sensor channel. Register touch channel into touch sensor measurement group. + * The working mode of the touch sensor is simultaneous measurement. + * This function will set the measure bits according to the given bitmask. + * + * @note If set this mask, the FSM timer should be stop firstly. + * @note The touch sensor that in scan map, should be deinit GPIO function firstly. + * @param enable_mask bitmask of touch sensor scan group. + * e.g. TOUCH_PAD_NUM1 -> BIT(1) + * @return + * - ESP_OK on success + */ +static inline void touch_ll_set_channel_mask(uint16_t enable_mask) +{ + uint16_t mask = enable_mask & TOUCH_PAD_BIT_MASK_ALL; + LP_ANA_PERI.touch_scan_ctrl1.touch_scan_pad_map = mask; + LP_ANA_PERI.touch_filter2.touch_outen = mask; +} + +/** + * @brief Power on the channel by mask + * + * @param chan_mask The channel mask that needs to power on + */ +static inline void touch_ll_channel_power_on(uint16_t chan_mask) +{ + uint32_t curr_mask = LP_ANA_PERI.touch_mux1.touch_xpd; + LP_ANA_PERI.touch_mux1.touch_xpd = chan_mask | curr_mask; +} + +/** + * @brief Power off the channel by mask + * + * @param chan_mask The channel mask that needs to power off + */ +static inline void touch_ll_channel_power_off(uint16_t chan_mask) +{ + uint32_t curr_mask = LP_ANA_PERI.touch_mux1.touch_xpd; + LP_ANA_PERI.touch_mux1.touch_xpd = (~chan_mask) & curr_mask; +} + +/** + * @brief Start channel by mask + * @note Only start the specified channels + * + * @param chan_mask The channel mask that needs to start + */ +static inline void touch_ll_channel_start(uint16_t chan_mask) +{ + uint32_t curr_mask = LP_ANA_PERI.touch_mux1.touch_start; + LP_ANA_PERI.touch_mux1.touch_start = chan_mask | curr_mask; + LP_ANA_PERI.touch_mux1.touch_start = (~chan_mask) & curr_mask; +} + +/** + * Get the touch sensor active channel mask, usually used in ISR to decide which channels are 'touched'. + * + * @param active_mask The touch channel status. e.g. Touch1 trigger status is `status_mask & (BIT1)`. + */ +static inline void touch_ll_get_active_channel_mask(uint32_t *active_mask) +{ + *active_mask = LP_TOUCH.chn_status.pad_active; +} + +/** + * Clear all touch sensor channels active status. + * + * @note Generally no manual removal is required. + */ +static inline void touch_ll_clear_active_channel_status(void) +{ + LP_ANA_PERI.touch_clr.touch_status_clr = 1; +} + +/** + * Get the data of the touch channel according to the types + * + * @param touch_num touch pad index + * @param sampler_id The sampler index + * @param type data type + * 0/1: TOUCH_LL_READ_RAW, the raw data of the touch channel + * 2: TOUCH_LL_READ_BENCHMARK, benchmark value of touch channel, + * the benchmark value is the maximum during the first measurement period + * 3: TOUCH_LL_READ_SMOOTH, the smoothed data that obtained by filtering the raw data. + * @param data pointer to the data + */ +__attribute__((always_inline)) +static inline void touch_ll_read_chan_data(uint32_t touch_num, uint8_t sampler_id, uint8_t type, uint32_t *data) +{ + HAL_ASSERT(sampler_id < SOC_TOUCH_SAMPLER_NUM); + HAL_ASSERT(type <= TOUCH_LL_READ_SMOOTH); + LP_ANA_PERI.touch_mux0.touch_freq_sel = sampler_id + 1; + LP_ANA_PERI.touch_mux0.touch_data_sel = type; + *data = LP_TOUCH.chn_data[touch_num - 1].pad_data; +} + +/** + * Get touch sensor measure status. No block. + * + * @return + * - If touch sensors measure done. + */ +static inline bool touch_ll_is_measure_done(uint32_t *touch_num) +{ + *touch_num = (uint32_t)(LP_TOUCH.chn_status.scan_curr); + return (bool)LP_TOUCH.chn_status.meas_done; +} + +/** + * Select the counting mode of the binarized touch out wave + * + * @param mode 0: as data, the value will be smaller than actual value but more sensitive when the frequency of touch_out is close to the source clock + * 1: as clock, the value is accurate but less sensitive when the frequency of touch_out is close to the source clock + * No big difference when the frequency of touch_out is far more lower than the source clock + */ +static inline void touch_ll_set_out_mode(touch_out_mode_t mode) +{ + LP_ANA_PERI.touch_work.touch_out_sel = mode; +} + +/** + * @brief Set the clock division of the sampling frequency + * + * @param sampler_id The sampler index + * @param div_num Division number + */ +static inline void touch_ll_set_clock_div(uint8_t sampler_id, uint32_t div_num) +{ + switch (sampler_id) { + case 0: + LP_ANA_PERI.touch_work.div_num0 = div_num; + break; + case 1: + LP_ANA_PERI.touch_work.div_num1 = div_num; + break; + case 2: + LP_ANA_PERI.touch_work.div_num2 = div_num; + break; + default: + // invalid sampler_id + abort(); + } +} + +/** + * Set connection type of touch channel in idle status. + * When a channel is in measurement mode, other initialized channels are in idle mode. + * The touch channel is generally adjacent to the trace, so the connection state of the idle channel + * affects the stability and sensitivity of the test channel. + * The `CONN_HIGHZ`(high resistance) setting increases the sensitivity of touch channels. + * The `CONN_GND`(grounding) setting increases the stability of touch channels. + * @note This option does not take effect, it is default to HIGH Z + * Only remained here to be compatible to other version + * + * @param type Select idle channel connect to high resistance state or ground. (No effect) + */ +static inline void touch_ll_set_idle_channel_connect(touch_pad_conn_type_t type) +{ + (void)type; +} + +/** + * Get the current channel that under measuring. + * + * @return + * - touch channel number + */ +__attribute__((always_inline)) +static inline uint32_t touch_ll_get_current_meas_channel(void) +{ + return (uint32_t)(LP_TOUCH.chn_status.scan_curr); +} + +/** + * Enable touch sensor interrupt by bitmask. + * + * @param int_mask interrupt mask + */ +static inline void touch_ll_intr_enable(uint32_t int_mask) +{ + uint32_t mask = LP_TOUCH.int_ena.val; + mask |= (int_mask & TOUCH_LL_INTR_MASK_ALL); + LP_TOUCH.int_ena.val = mask; +} + +/** + * Disable touch sensor interrupt by bitmask. + * + * @param int_mask interrupt mask + */ +static inline void touch_ll_intr_disable(uint32_t int_mask) +{ + uint32_t mask = LP_TOUCH.int_ena.val; + mask &= ~(int_mask & TOUCH_LL_INTR_MASK_ALL); + LP_TOUCH.int_ena.val = mask; +} + +/** + * Clear touch sensor interrupt by bitmask. + * + * @param int_mask Pad mask to clear interrupts + */ +static inline void touch_ll_intr_clear_all(void) +{ + LP_TOUCH.int_clr.val = TOUCH_LL_INTR_MASK_ALL; +} + +/** + * Get the bitmask of touch sensor interrupt status. + * + * @return type interrupt type + */ +static inline uint32_t touch_ll_get_intr_status_mask(void) +{ + uint32_t intr_st = LP_TOUCH.int_st.val; + return (intr_st & TOUCH_LL_INTR_MASK_ALL); +} + +/** + * Enable the timeout check for all touch sensor channels measurements. + * When the touch reading of a touch channel exceeds the measurement threshold, + * If enable: a timeout interrupt will be generated and it will go to the next channel measurement. + * If disable: the FSM is always on the channel, until the measurement of this channel is over. + * + * @param timeout_cycles The maximum time cycles of the measurement on one channel. + */ +static inline void touch_ll_timeout_enable(uint32_t timeout_cycles) +{ + LP_ANA_PERI.touch_scan_ctrl2.touch_timeout_num = timeout_cycles; + LP_ANA_PERI.touch_scan_ctrl2.touch_timeout_en = 1; +} + +/** + * Disable the timeout check for all touch sensor channels measurements. + * When the touch reading of a touch channel exceeds the measurement threshold, + * If enable: a timeout interrupt will be generated and it will go to the next channel measurement. + * If disable: the FSM is always on the channel, until the measurement of this channel is over. + */ +static inline void touch_ll_timeout_disable(void) +{ + LP_ANA_PERI.touch_scan_ctrl2.touch_timeout_en = 0; +} + +/** + * Set the engaged sampler number + * + * @param sampler_num The enabled sampler number, range 0~3. + * 0/1 means only one sampler enabled, which can not support frequency hopping + */ +static inline void touch_ll_sampler_set_engaged_num(uint8_t sampler_num) +{ + HAL_ASSERT(sampler_num < SOC_TOUCH_SAMPLER_NUM); + LP_ANA_PERI.touch_scan_ctrl2.freq_scan_en = !!sampler_num; + LP_ANA_PERI.touch_scan_ctrl2.freq_scan_cnt_limit = sampler_num ? sampler_num : 1; +} + +/** + * Set capacitance and resistance of the RC filter of the sampling frequency. + * + * @param sampler_id The sampler index + * @param cap Capacitance of the RC filter. + * @param res Resistance of the RC filter. + */ +static inline void touch_ll_sampler_set_rc_filter(uint8_t sampler_id, uint32_t cap, uint32_t res) +{ + HAL_ASSERT(sampler_id < SOC_TOUCH_SAMPLER_NUM); + LP_ANA_PERI.touch_freq_scan_para[sampler_id].touch_freq_dcap_lpf = cap; + LP_ANA_PERI.touch_freq_scan_para[sampler_id].touch_freq_dres_lpf = res; +} + +/** + * @brief Set the driver of the sampling frequency + * + * @param sampler_id The sampler index + * @param ls_drv Low speed touch driver + * @param hs_drv High speed touch driver + */ +static inline void touch_ll_sampler_set_driver(uint8_t sampler_id, uint32_t ls_drv, uint32_t hs_drv) +{ + HAL_ASSERT(sampler_id < SOC_TOUCH_SAMPLER_NUM); + LP_ANA_PERI.touch_freq_scan_para[sampler_id].touch_freq_drv_ls = ls_drv; + LP_ANA_PERI.touch_freq_scan_para[sampler_id].touch_freq_drv_hs = hs_drv; +} + +/** + * Set the touch internal LDO bias voltage of the sampling frequency + * + * @param sampler_id The sampler index + * @param bias_volt LDO bias voltage + */ +static inline void touch_ll_sampler_set_bias_voltage(uint8_t sampler_id, uint32_t bias_volt) +{ + HAL_ASSERT(sampler_id < SOC_TOUCH_SAMPLER_NUM); + LP_ANA_PERI.touch_freq_scan_para[sampler_id].touch_freq_dbias = bias_volt; +} + +/** + * @brief Set the internal loop capacitance + * Can simulate the touch signal via the internal capacitance + * Need to turn off touch pad + * @param cap The internal capacitance + */ +static inline void touch_ll_set_internal_loop_capacitance(int cap) +{ + bool enable = cap > 0; + LP_ANA_PERI.touch_ana_para.touch_touch_en_cal = enable; + LP_ANA_PERI.touch_ana_para.touch_touch_dcap_cal = enable ? cap : 0; +} + +/************************ Filter register setting ************************/ + +/** + * Force reset benchmark to raw data of touch sensor. + * + * @note If call this API, make sure enable clock gate(`touch_ll_clkgate`) first. + * @param chan_mask touch channel mask + */ +static inline void touch_ll_reset_chan_benchmark(uint32_t chan_mask) +{ + LP_ANA_PERI.touch_clr.touch_channel_clr = chan_mask; +} + +/** + * Set filter mode. The input of the filter is the raw value of touch reading, + * and the output of the filter is involved in the judgment of the touch state. + * + * @param mode Filter mode type. Refer to ``touch_filter_mode_t``. + */ +static inline void touch_ll_filter_set_filter_mode(touch_filter_mode_t mode) +{ + LP_ANA_PERI.touch_filter1.touch_filter_mode = mode; +} + +/** + * Set filter mode. The input to the filter is raw data and the output is the smooth data. + * The smooth data is used to determine the touch status. + * + * @param mode Filter mode type. Refer to ``touch_smooth_mode_t``. + */ +static inline void touch_ll_filter_set_smooth_mode(touch_smooth_mode_t mode) +{ + LP_ANA_PERI.touch_filter1.touch_smooth_lvl = mode; +} + +/** + * Set debounce count, such as `n`. If the measured values continue to exceed + * the threshold for `n+1` times, it is determined that the touch sensor state changes. + * + * @param dbc_cnt Debounce count value. + */ +static inline void touch_ll_filter_set_debounce(uint32_t dbc_cnt) +{ + LP_ANA_PERI.touch_filter1.touch_debounce_limit = dbc_cnt; +} + +/** + * Set the positive noise threshold coefficient. Higher = More noise resistance. + * The benchmark will update to the new value if the touch data is within (benchmark + active_threshold * pos_coeff) + * + * + * @param pos_noise_thresh Range [-1 ~ 3]. The coefficient is -1: always; 0: 4/8; 1: 3/8; 2: 2/8; 3: 1; + * -1: the benchmark will always update to the new touch data without considering the positive noise threshold + */ +static inline void touch_ll_filter_set_pos_noise_thresh(int pos_noise_thresh) +{ + bool always_update = pos_noise_thresh < 0; + LP_ANA_PERI.touch_filter2.touch_bypass_noise_thres = always_update; + LP_ANA_PERI.touch_filter1.touch_noise_thres = always_update ? 0 : pos_noise_thresh; +} + +/** + * Set the negative noise threshold coefficient. Higher = More noise resistance. + * The benchmark will update to the new value if the touch data is greater than (benchmark - active_threshold * neg_coeff) + * + * @param neg_noise_thresh Range [-2 ~ 3]. The coefficient is -2: never; -1: always; 0: 4/8; 1: 3/8; 2: 2/8; 3: 1; + * -1: the benchmark will always update to the new touch data without considering the negative noise threshold + * -2: the benchmark will never update to the new touch data with negative growth + * @param neg_noise_limit Only when neg_noise_thresh >= 0, if the touch data keep blow the negative threshold for mare than neg_noise_limit ticks, + * the benchmark will still update to the new value. + * It is normally used for updating the benchmark at the first scanning + */ +static inline void touch_ll_filter_set_neg_noise_thresh(int neg_noise_thresh, uint8_t neg_noise_limit) +{ + bool always_update = neg_noise_thresh == -1; + bool stop_update = neg_noise_thresh == -2; + LP_ANA_PERI.touch_filter2.touch_bypass_neg_noise_thres = always_update; + LP_ANA_PERI.touch_filter1.touch_neg_noise_disupdate_baseline_en = stop_update; + LP_ANA_PERI.touch_filter1.touch_neg_noise_thres = always_update || stop_update ? 0 : neg_noise_thresh; + LP_ANA_PERI.touch_filter1.touch_neg_noise_limit = always_update || stop_update ? 5 : neg_noise_limit; // 5 is the default value +} + +/** + * Set the hysteresis value of the active threshold + * While the touch data is greater than active_threshold + hysteresis and last for several ticks, the channel is activated, + * and while the touch data is smaller than active_threshold - hysteresis and last for several ticks, the channel is inactivated + * + * @param hysteresis The hysteresis value of active threshold + */ +static inline void touch_ll_filter_set_active_hysteresis(uint32_t hysteresis) +{ + LP_ANA_PERI.touch_filter1.touch_hysteresis = hysteresis; +} + +/** + * Set jitter filter step size. + * If filter mode is jitter, should set filter step for jitter. + * Range: 0 ~ 15 + * + * @param step The step size of the data change. + */ +static inline void touch_ll_filter_set_jitter_step(uint32_t step) +{ + LP_ANA_PERI.touch_filter1.touch_jitter_step = step; +} + +/** + * Enable or disable touch sensor filter and detection algorithm. + * For more details on the detection algorithm, please refer to the application documentation. + */ +static inline void touch_ll_filter_enable(bool enable) +{ + LP_ANA_PERI.touch_filter1.touch_filter_en = enable; +} + +/** + * Force the update the benchmark by software + * @note This benchmark will be applied to all enabled channel and all sampling frequency + * + * @param benchmark The benchmark specified by software + */ +static inline void touch_ll_force_update_benchmark(uint32_t benchmark) +{ + HAL_FORCE_MODIFY_U32_REG_FIELD(LP_ANA_PERI.touch_filter3, touch_baseline_sw, benchmark); + LP_ANA_PERI.touch_filter3.touch_update_baseline_sw = 1; + // waiting for update + while (LP_ANA_PERI.touch_filter3.touch_update_baseline_sw); +} + +/************************ Waterproof register setting ************************/ + +/** + * Set touch channel use for guard pad. + * + * @param pad_num Touch sensor channel number. + */ +static inline void touch_ll_waterproof_set_guard_chan(uint32_t pad_num) +{ + LP_ANA_PERI.touch_scan_ctrl2.touch_out_ring = pad_num; +} + +/** + * Enable or disable parameter of waterproof function. + * + * The waterproof function includes a shielded channel (TOUCH_PAD_NUM14) and a guard channel. + * Guard pad is used to detect the large area of water covering the touch panel. + * Shield pad is used to shield the influence of water droplets covering the touch panel. + * It is generally designed as a grid and is placed around the touch buttons. + */ +static inline void touch_ll_waterproof_enable(bool enable) +{ + LP_ANA_PERI.touch_scan_ctrl1.touch_shield_pad_en = enable; +} + +/** + * Set the shield channel mask + * + * @param mask The channels that set in the mask will be used as shield channel + */ +static inline void touch_ll_waterproof_set_shield_chan_mask(uint32_t mask) +{ + LP_ANA_PERI.touch_mux0.touch_bufsel = (mask & TOUCH_LL_FULL_CHANNEL_MASK); +} + +/** + * Set the touch buff driver for the shield channel. + * + * @param driver_level The driver level of the touch buff + */ +static inline void touch_ll_waterproof_set_shield_driver(touch_pad_shield_driver_t driver_level) +{ + LP_ANA_PERI.touch_ana_para.touch_touch_buf_drv = driver_level; +} + +/************************ Approach register setting ************************/ + +/** + * Set the approach channel to the specific touch channel + * To disable the approach channel, point this pad to `TOUCH_LL_NULL_CHANNEL` + * + * @param aprch_chan approach channel. + * @param touch_num The touch channel that supposed to be used as approach channel + */ +static inline void touch_ll_set_approach_channel(uint8_t aprch_chan, uint32_t touch_num) +{ + switch (aprch_chan) { + case 0: + LP_ANA_PERI.touch_approach.touch_approach_pad0 = touch_num; + break; + case 1: + LP_ANA_PERI.touch_approach.touch_approach_pad1 = touch_num; + break; + case 2: + LP_ANA_PERI.touch_approach.touch_approach_pad2 = touch_num; + break; + default: + // invalid approach channel + abort(); + } +} + +/** + * Set cumulative measurement times for approach channel. + * + * @param sampler_id The sampler index + * @param times The cumulative number of measurement cycles. + */ +static inline void touch_ll_approach_set_measure_times(uint8_t sampler_id, uint32_t times) +{ + switch (sampler_id) { + case 0: + LP_ANA_PERI.touch_approach_work_meas_num.touch_approach_meas_num0 = times; + break; + case 1: + LP_ANA_PERI.touch_approach_work_meas_num.touch_approach_meas_num1 = times; + break; + case 2: + LP_ANA_PERI.touch_approach_work_meas_num.touch_approach_meas_num2 = times; + break; + default: + // invalid sampler_id + abort(); + } +} + +/** + * Read current cumulative measurement times for approach channel. + * + * @param aprch_chan approach channel. + * @param cnt The cumulative number of measurement cycles. + */ +static inline void touch_ll_approach_read_measure_cnt(uint8_t aprch_chan, uint32_t *cnt) +{ + switch (aprch_chan) { + case 0: + *cnt = HAL_FORCE_READ_U32_REG_FIELD(LP_TOUCH.aprch_ch_data, approach_pad0_cnt); + break; + case 1: + *cnt = HAL_FORCE_READ_U32_REG_FIELD(LP_TOUCH.aprch_ch_data, approach_pad1_cnt); + break; + case 2: + *cnt = HAL_FORCE_READ_U32_REG_FIELD(LP_TOUCH.aprch_ch_data, approach_pad2_cnt); + break; + default: // sleep channel + *cnt = HAL_FORCE_READ_U32_REG_FIELD(LP_TOUCH.aprch_ch_data, slp_approach_cnt); + break; + } +} + +/** + * Check if the touch sensor channel is the approach channel. + * + * @param touch_num The touch sensor channel number. + */ +static inline bool touch_ll_is_approach_channel(uint32_t touch_num) +{ + if ((LP_ANA_PERI.touch_approach.touch_approach_pad0 != touch_num) + && (LP_ANA_PERI.touch_approach.touch_approach_pad1 != touch_num) + && (LP_ANA_PERI.touch_approach.touch_approach_pad2 != touch_num)) { + return false; + } else { + return true; + } +} + +/************** sleep channel setting ***********************/ + +/** + * Set touch channel number for sleep channel. + * + * @note Only one touch sensor channel is supported in deep sleep mode. + * @param touch_num Touch sensor channel number. + */ +static inline void touch_ll_sleep_set_channel_num(uint32_t touch_num) +{ + LP_ANA_PERI.touch_slp0.touch_slp_pad = touch_num; +} + +/** + * Get touch channel number for sleep pad. + * + * @note Only one touch sensor channel is supported in deep sleep mode. + * @param touch_num Touch sensor channel number. + */ +static inline void touch_ll_sleep_get_channel_num(uint32_t *touch_num) +{ + *touch_num = (uint32_t)(LP_ANA_PERI.touch_slp0.touch_slp_pad); +} + +/** + * Set the trigger threshold of touch sensor in deep sleep. + * The threshold determines the sensitivity of the touch sensor. + * The threshold is the original value of the trigger state minus the benchmark value. + * + * @note In general, the touch threshold during sleep can use the threshold parameter parameters before sleep. + */ +static inline void touch_ll_sleep_set_threshold(uint8_t sampler_id, uint32_t touch_thresh) +{ + switch (sampler_id) { + case 0: + HAL_FORCE_MODIFY_U32_REG_FIELD(LP_ANA_PERI.touch_slp0, touch_slp_th0, touch_thresh); + break; + case 1: + HAL_FORCE_MODIFY_U32_REG_FIELD(LP_ANA_PERI.touch_slp1, touch_slp_th1, touch_thresh); + break; + case 2: + HAL_FORCE_MODIFY_U32_REG_FIELD(LP_ANA_PERI.touch_slp1, touch_slp_th2, touch_thresh); + break; + default: + // invalid sampler_id + abort(); + } +} + +/** + * Enable approach function for sleep channel. + */ +static inline void touch_ll_sleep_enable_approach(bool enable) +{ + LP_ANA_PERI.touch_approach.touch_slp_approach_en = enable; +} + +/** + * Get the data of the touch channel according to the types + * + * @param sampler_id The sampler index + * @param type data type + * 0/1: TOUCH_LL_READ_RAW, the raw data of the touch channel + * 2: TOUCH_LL_READ_BENCHMARK, benchmark value of touch channel, + * the benchmark value is the maximum during the first measurement period + * 3: TOUCH_LL_READ_SMOOTH, the smoothed data that obtained by filtering the raw data. + * @param smooth_data pointer to smoothed data + */ +__attribute__((always_inline)) +static inline void touch_ll_sleep_read_chan_data(uint8_t type, uint8_t sampler_id, uint32_t *data) +{ + HAL_ASSERT(type <= TOUCH_LL_READ_SMOOTH); + LP_ANA_PERI.touch_mux0.touch_freq_sel = sampler_id + 1; + LP_ANA_PERI.touch_mux0.touch_data_sel = type; + *data = HAL_FORCE_READ_U32_REG_FIELD(LP_TOUCH.slp_ch_data, slp_data); +} + +/** + * @brief Reset the benchmark of the sleep channel + * + */ +static inline void touch_ll_sleep_reset_benchmark(void) +{ + LP_ANA_PERI.touch_slp0.touch_slp_channel_clr = 1; +} + +/** + * Read debounce of touch sensor for sleep channel. + * + * @param debounce Pointer to accept touch sensor debounce value. + */ +static inline void touch_ll_sleep_read_debounce(uint32_t *debounce) +{ + *debounce = LP_TOUCH.slp_ch_data.slp_debounce_cnt; +} + +/** + * Read approach count of touch sensor for sleep channel. + * @param approach_cnt Pointer to accept touch sensor approach count value. + */ +static inline void touch_ll_sleep_read_approach_cnt(uint32_t *approach_cnt) +{ + *approach_cnt = HAL_FORCE_READ_U32_REG_FIELD(LP_TOUCH.aprch_ch_data, slp_approach_cnt); +} + +#ifdef __cplusplus +} +#endif diff --git a/components/hal/esp32s2/include/hal/touch_sensor_ll.h b/components/hal/esp32s2/include/hal/touch_sensor_ll.h index 62072a5856..656b79099f 100644 --- a/components/hal/esp32s2/include/hal/touch_sensor_ll.h +++ b/components/hal/esp32s2/include/hal/touch_sensor_ll.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -34,6 +34,8 @@ extern "C" { #define TOUCH_LL_TIMER_FORCE_DONE 0x3 #define TOUCH_LL_TIMER_DONE 0x0 +#define TOUCH_LL_PAD_MEASURE_WAIT_MAX (0xFF) /*!`_. -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 For more information about testing touch sensors in various configurations, please check the `Guide for ESP32-Sense-Kit `_. @@ -118,14 +118,14 @@ Configuration * - T13 - GPIO13 * - T14 - - GPIO14 + - GPIO14 Use the function :cpp:func:`touch_pad_set_fsm_mode` to select if touch pad measurement (operated by FSM) should be started automatically by a hardware timer, or by software. If software mode is selected, use :cpp:func:`touch_pad_sw_start` to start the FSM. Touch State Measurements ^^^^^^^^^^^^^^^^^^^^^^^^ -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 The following two functions come in handy to read raw or filtered measurements from the sensor: @@ -138,7 +138,7 @@ Touch State Measurements Before using :cpp:func:`touch_pad_read_filtered`, you need to initialize and configure the filter by calling specific filter functions described in Section `Filtering of Measurements`_. -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 The following function come in handy to read raw measurements from the sensor: @@ -151,7 +151,7 @@ For the demonstration of how to read the touch pad data, check the application e Method of Measurements ^^^^^^^^^^^^^^^^^^^^^^ -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 The touch sensor counts the number of charge/discharge cycles over a fixed period of time (specified by :cpp:func:`touch_pad_set_measurement_clock_cycles`). The count result is the raw data that read from :cpp:func:`touch_pad_read_raw_data`. After finishing one measurement, the touch sensor sleeps until the next measurement start, this interval between two measurements can be set by :cpp:func:`touch_pad_set_measurement_interval`. @@ -159,7 +159,7 @@ Method of Measurements If the specified clock cycles for measurement is too samll, the result may be inaccurate, but increasing clock cycles will increase the power consumption as well. Additionally, the response of the touch sensor will slow down if the total time of the inverval and measurement is too long. -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 The touch sensor records the period of time (i.e., the number of clock cycles) over a fixed charge/discharge cycles (specified by :cpp:func:`touch_pad_set_charge_discharge_times`). The count result is the raw data that read from :cpp:func:`touch_pad_read_raw_data`. After finishing one measurement, the touch sensor sleeps until the next measurement start, this interval between two measurements can be set by :cpp:func:`touch_pad_set_measurement_interval`. @@ -172,11 +172,11 @@ Optimization of Measurements A touch sensor has several configurable parameters to match the characteristics of a particular touch pad design. For instance, to sense smaller capacity changes, it is possible to narrow down the reference voltage range within which the touch pads are charged/discharged. The high and low reference voltages are set using the function :cpp:func:`touch_pad_set_voltage`. -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 Besides the ability to discern smaller capacity changes, a positive side effect is reduction of power consumption for low power applications. A likely negative effect is an increase in measurement noise. If the dynamic range of obtained readings is still satisfactory, then further reduction of power consumption might be done by reducing the measurement time with :cpp:func:`touch_pad_set_measurement_clock_cycles`. -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 Besides the ability to discern smaller capacity changes, a positive side effect is reduction of power consumption for low power applications. A likely negative effect is an increase in measurement noise. If the dynamic range of obtained readings is still satisfactory, then further reduction of power consumption might be done by reducing the measurement time with :cpp:func:`touch_pad_set_charge_discharge_times`. @@ -187,17 +187,17 @@ The following list summarizes available measurement parameters and corresponding * voltage range: :cpp:func:`touch_pad_set_voltage` * speed (slope): :cpp:func:`touch_pad_set_cnt_mode` -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 * Clock cycles of one measurement: :cpp:func:`touch_pad_set_measurement_clock_cycles` -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 * Charge and discharge times of one measurement: :cpp:func:`touch_pad_set_charge_discharge_times` Relationship between the voltage range (high/low reference voltages), speed (slope), and measurement time is shown in the figure below. -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 .. figure:: ../../../_static/touch_pad-measurement-parameters.jpg :align: center @@ -208,7 +208,7 @@ Relationship between the voltage range (high/low reference voltages), speed (slo The last chart **Output** represents the touch sensor reading, i.e., the count of pulses collected within the measurement time. -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 .. figure:: ../../../_static/touch_pad-measurement-parameters-version2.png :align: center @@ -225,7 +225,7 @@ All functions are provided in pairs to **set** a specific parameter and to **get Filtering of Measurements ^^^^^^^^^^^^^^^^^^^^^^^^^ -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 If measurements are noisy, you can filter them with provided API functions. Before using the filter, please start it by calling :cpp:func:`touch_pad_filter_start`. @@ -233,7 +233,7 @@ Filtering of Measurements You can stop the filter with :cpp:func:`touch_pad_filter_stop`. If not required anymore, the filter can be deleted by invoking :cpp:func:`touch_pad_filter_delete`. -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 If measurements are noisy, you can filter them with provided API functions. The {IDF_TARGET_NAME}'s touch functionality provide two sets of APIs for doing this. @@ -259,7 +259,7 @@ Before enabling an interrupt on a touch detection, you should establish a touch Once a detection threshold is established, it can be set during initialization with :cpp:func:`touch_pad_config` or at the runtime with :cpp:func:`touch_pad_set_thresh`. -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 In the next step, configure how interrupts are triggered. They can be triggered below or above the threshold, which is set with the function :cpp:func:`touch_pad_set_trigger_mode`. @@ -270,13 +270,13 @@ Finally, configure and manage interrupt calls using the following functions: When interrupts are operational, you can obtain the information from which particular pad an interrupt came by invoking :cpp:func:`touch_pad_get_status` and clear the pad status with :cpp:func:`touch_pad_clear_status`. -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 .. note:: Interrupts on touch detection operate on raw/unfiltered measurements checked against user established threshold and are implemented in hardware. Enabling the software filtering API (see :ref:`touch_pad-api-filtering-of-measurements`) does not affect this process. -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 Wakeup from Sleep Mode ^^^^^^^^^^^^^^^^^^^^^^ diff --git a/docs/zh_CN/api-reference/peripherals/touch_pad.rst b/docs/zh_CN/api-reference/peripherals/touch_pad.rst index 66abf2f6bd..832928ac6d 100644 --- a/docs/zh_CN/api-reference/peripherals/touch_pad.rst +++ b/docs/zh_CN/api-reference/peripherals/touch_pad.rst @@ -16,7 +16,7 @@ 请参考 `触摸传感器应用方案简介 `_，查看触摸传感器设计详情和固件开发指南。 -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 如果想评估触摸传感器的多种应用场景，请查看 `ESP32 触摸功能开发套件 `_。 @@ -125,7 +125,7 @@ 触摸状态测量 ^^^^^^^^^^^^^^^^^^^^^^^^ -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 借助以下两个函数从传感器读取原始数据和滤波后的数据： @@ -138,7 +138,7 @@ 使用 :cpp:func:`touch_pad_read_filtered` 之前，需要先调用 `滤波采样`_ 中特定的滤波器函数来初始化并配置该滤波器。 -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 借助以下函数从传感器读取原始数据： @@ -151,7 +151,7 @@ 测量方式 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 触摸传感器会统计固定时间内的充放电次数，其计数结果即为原始数据，可由 :cpp:func:`touch_pad_read_raw_data` 读出。上述固定时间可通过 :cpp:func:`touch_pad_set_measurement_clock_cycles` 设置。完成一次测量后，触摸传感器会在下次测量开始前保持睡眠状态。两次测量之前的间隔时间可由 :cpp:func:`touch_pad_set_measurement_interval` 进行设置。 @@ -159,7 +159,7 @@ 若设置的计数时间太短（即测量持续的时钟周期数太小），则可能导致结果不准确，但是过大的计数时间也会造成功耗上升。另外，若睡眠时间加测量时间的总时间过长，则会造成触摸传感器响应变慢。 -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 触摸传感器会统计固定充放电次数所需的时间（即所需时钟周期数），其结果即为原始数据，可由 :cpp:func:`touch_pad_read_raw_data` 读出。上述固定的充放电次数可通过 :cpp:func:`touch_pad_set_charge_discharge_times` 设置。完成一次测量后，触摸传感器会在下次测量开始前保持睡眠状态。两次测量之前的间隔时间可由 :cpp:func:`touch_pad_set_measurement_interval` 进行设置。 @@ -172,11 +172,11 @@ 触摸传感器设有数个可配置参数，以适应触摸传感器设计特点。例如，如果需要感知较细微的电容变化，则可以缩小触摸传感器充放电的参考电压范围。使用 :cpp:func:`touch_pad_set_voltage` 函数，可以设置电压参考低值和参考高值。 -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 优化测量除了可以识别细微的电容变化之外，还可以降低应用程序功耗，但可能会增加测量噪声干扰。如果得到的动态读数范围结果比较理想，则可以调用 :cpp:func:`touch_pad_set_measurement_clock_cycles` 函数来减少测量时间，从而进一步降低功耗。 -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 优化测量除了可以识别细微的电容变化之外，还可以降低应用程序功耗，但可能会增加测量噪声干扰。如果得到的动态读数范围结果比较理想，则可以调用 :cpp:func:`touch_pad_set_charge_discharge_times` 函数来减少测量时间，从而进一步降低功耗。 @@ -187,17 +187,17 @@ * 电压门限：:cpp:func:`touch_pad_set_voltage` * 速率（斜率）：:cpp:func:`touch_pad_set_cnt_mode` -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 * 单次测量所用的时钟周期：:cpp:func:`touch_pad_set_measurement_clock_cycles` -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 * 单次测量所需充放电次数：:cpp:func:`touch_pad_set_charge_discharge_times` 电压门限（参考低值/参考高值）、速率（斜率）与测量时间的关系如下图所示： -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 .. figure:: ../../../_static/touch_pad-measurement-parameters.jpg :align: center @@ -208,7 +208,7 @@ 上图中的 **Output** 代表触摸传感器读值，即一个测量周期内测得的脉冲计数值。 -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 .. figure:: ../../../_static/touch_pad-measurement-parameters-version2.png :align: center @@ -225,7 +225,7 @@ 滤波采样 ^^^^^^^^^^^^^^^^^^^^^^^^^ -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 如果测量中存在噪声，可以使用提供的 API 函数对采样进行滤波。使用滤波器之前，请先调用 :cpp:func:`touch_pad_filter_start` 启动该滤波器。 @@ -233,7 +233,7 @@ 如需停止滤波器，请调用 :cpp:func:`touch_pad_filter_stop` 函数。如果不再使用该滤波器，请调用 :cpp:func:`touch_pad_filter_delete` 删除此滤波器。 -.. only:: SOC_TOUCH_VERSION_2 +.. only:: esp32s2 or esp32s3 如果测量中存在噪声，可以使用提供的 API 函数对采样进行滤波。{IDF_TARGET_NAME} 的触摸功能提供了两套 API 可实现此功能。 @@ -259,7 +259,7 @@ 确定监测阈值后就可以在初始化时调用 :cpp:func:`touch_pad_config` 设置此阈值，或在运行时调用 :cpp:func:`touch_pad_set_thresh` 设置此阈值。 -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 下一步就是设置如何触发中断。可以设置在阈值以下或以上触发中断，具体触发模式由函数 :cpp:func:`touch_pad_set_trigger_mode` 设置。 @@ -270,13 +270,13 @@ 中断配置完成后，可以调用 :cpp:func:`touch_pad_get_status` 查看中断信号来自哪个触摸传感器，也可以调用 :cpp:func:`touch_pad_clear_status` 清除触摸传感器状态信息。 -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 .. note:: 触摸监测中的中断信号基于原始/未经滤波的采样（对比设置的阈值），并在硬件中实现。启用软件滤波 API（请参考 :ref:`touch_pad-api-filtering-of-measurements`）并不会影响这一过程。 -.. only:: SOC_TOUCH_VERSION_1 +.. only:: esp32 从睡眠模式唤醒 ^^^^^^^^^^^^^^^^^^^^^^ diff --git a/examples/peripherals/.build-test-rules.yml b/examples/peripherals/.build-test-rules.yml index cdd760633d..a26e19b143 100644 --- a/examples/peripherals/.build-test-rules.yml +++ b/examples/peripherals/.build-test-rules.yml @@ -324,11 +324,11 @@ examples/peripherals/touch_sensor/touch_element: examples/peripherals/touch_sensor/touch_sensor_v1: disable: - - if: SOC_TOUCH_VERSION_1 != 1 + - if: SOC_TOUCH_SENSOR_VERSION != 1 examples/peripherals/touch_sensor/touch_sensor_v2: disable: - - if: SOC_TOUCH_VERSION_2 != 1 + - if: SOC_TOUCH_SENSOR_VERSION != 2 examples/peripherals/twai/twai_alert_and_recovery: disable: diff --git a/examples/peripherals/touch_sensor/touch_sensor_v2/touch_pad_interrupt/main/tp_interrupt_main.c b/examples/peripherals/touch_sensor/touch_sensor_v2/touch_pad_interrupt/main/tp_interrupt_main.c index 10837efb7c..e8a671ecfc 100644 --- a/examples/peripherals/touch_sensor/touch_sensor_v2/touch_pad_interrupt/main/tp_interrupt_main.c +++ b/examples/peripherals/touch_sensor/touch_sensor_v2/touch_pad_interrupt/main/tp_interrupt_main.c @@ -196,7 +196,7 @@ void app_main(void) /* Filter setting */ touchsensor_filter_set(TOUCH_PAD_FILTER_IIR_16); - touch_pad_timeout_set(true, SOC_TOUCH_PAD_THRESHOLD_MAX); + touch_pad_timeout_set(true, TOUCH_PAD_THRESHOLD_MAX); /* Register touch interrupt ISR, enable intr type. */ touch_pad_isr_register(touchsensor_interrupt_cb, NULL, TOUCH_PAD_INTR_MASK_ALL); /* If you have other touch algorithm, you can get the measured value after the `TOUCH_PAD_INTR_MASK_SCAN_DONE` interrupt is generated. */