refactor(touch): refactor the filter configuration

Author: L-KAYA

components/esp_driver_touch_sens/hw_ver3/include/driver/touch_version_types.h

@@ -55,11 +55,7 @@ extern "C" {
     .benchmark = { \
         .filter_mode = TOUCH_BM_IIR_FILTER_4, \
         .jitter_step = 4, \
-        .update = { \
-                .pos_thresh = TOUCH_UPDATE_BM_POS_THRESH_1_4, \
-                .neg_thresh = TOUCH_UPDATE_BM_NEG_THRESH_1_4, \
-                .neg_limit = 5, \
-        }, \
+        .denoise_lvl = 1, \
     }, \
     .data = { \
         .smooth_filter = TOUCH_SMOOTH_IIR_FILTER_2, \
@@ -115,35 +111,6 @@ typedef enum {
     TOUCH_BM_JITTER_FILTER,                 /*!< Jitter Filter for benchmark, raw value +/- jitter_step */
 } touch_benchmark_filter_mode_t;
 
-/**
- * @brief Positive noise limitation of benchmark
- *        benchmark will only update gradually when
- *        the smooth data within the positive noise limitation
- *
- */
-typedef enum {
-    TOUCH_UPDATE_BM_POS_ALWAYS = -1,        /*!< Always update benchmark when (smooth_data - benchmark) > 0 */
-    TOUCH_UPDATE_BM_POS_THRESH_1_2 = 0,     /*!< Only update benchmark when the (smooth_data - benchmark) < 1/2 * activate_threshold  */
-    TOUCH_UPDATE_BM_POS_THRESH_3_8,         /*!< Only update benchmark when the (smooth_data - benchmark) < 3/8 * activate_threshold  */
-    TOUCH_UPDATE_BM_POS_THRESH_1_4,         /*!< Only update benchmark when the (smooth_data - benchmark) < 1/4 * activate_threshold  */
-    TOUCH_UPDATE_BM_POS_THRESH_1,           /*!< Only update benchmark when the (smooth_data - benchmark) <   1 * activate_threshold  */
-} touch_benchmark_pos_thresh_t;
-
-/**
- * @brief Negative noise limitation of benchmark
- *        benchmark will only update gradually when
- *        the smooth data within the negative noise limitation
- *
- */
-typedef enum {
-    TOUCH_UPDATE_BM_NEG_NEVER = -2,         /*!< Never update benchmark when (benchmark - smooth_data) > 0 */
-    TOUCH_UPDATE_BM_NEG_ALWAYS = -1,        /*!< Always update benchmark when (benchmark - smooth_data) > 0 */
-    TOUCH_UPDATE_BM_NEG_THRESH_1_2 = 0,     /*!< Only update benchmark when the (benchmark - smooth_data) < 1/2 * activate_threshold  */
-    TOUCH_UPDATE_BM_NEG_THRESH_3_8,         /*!< Only update benchmark when the (benchmark - smooth_data) < 3/8 * activate_threshold  */
-    TOUCH_UPDATE_BM_NEG_THRESH_1_4,         /*!< Only update benchmark when the (benchmark - smooth_data) < 1/4 * activate_threshold  */
-    TOUCH_UPDATE_BM_NEG_THRESH_1,           /*!< Only update benchmark when the (benchmark - smooth_data) <   1 * activate_threshold  */
-} touch_benchmark_neg_thresh_t;
-
 /**
  * @brief Touch channel Infinite Impulse Response (IIR) filter for smooth data
  *
@@ -222,31 +189,11 @@ typedef struct {
         touch_benchmark_filter_mode_t   filter_mode;        /*!< Benchmark filter mode. IIR filter and Jitter filter can be selected,
                                                              *   TOUCH_BM_IIR_FILTER_16 is recommended
                                                              */
-        uint32_t                        jitter_step;        /*!< Jitter filter step size, only takes effect when the `filter_mode` is TOUCH_BM_JITTER_FILTER. Range: 0 ~ 15 */
-        /**
-         * @brief Benchmark update strategy
-         */
-        struct {
-            touch_benchmark_pos_thresh_t pos_thresh;        /*!< Select the positive noise threshold. Higher = More noise resistance.
-                                                             *   Range: [-1 ~ 3]. The coefficient of the positive threshold are -1: always; 0: 4/8;  1: 3/8;   2: 2/8;   3: 1;
-                                                             *   Once the data of the channel exceeded the positive threshold (i.e., benchmark + coefficient * touch threshold),
-                                                             *   the benchmark will stop updated to that value.
-                                                             *   -1: ignore the positive threshold and always update the benchmark for positive noise
-                                                             */
-            touch_benchmark_neg_thresh_t neg_thresh;        /*!< Select the negative noise threshold. Higher = More noise resistance.
-                                                             *   Range: [-2 ~ 3]. The coefficient of the negative threshold are -2: never; -1: always; 0: 4/8;  1: 3/8;   2: 2/8;   3: 1;
-                                                             *   Once the data of the channel below the negative threshold (i.e., benchmark - coefficient * touch threshold),
-                                                             *   the benchmark will stop updated to that value,
-                                                             *   unless the data keep below the negative threshold for more than the limitation of `neg_limit`
-                                                             *   -1: ignore the negative threshold and always update the benchmark for negative noise
-                                                             *   -2: never update the benchmark for negative noise
-                                                             */
-            uint32_t                    neg_limit;          /*!< Set the time limitation of the negative threshold.
-                                                             *   The benchmark will be updated to the value that below to the negative threshold after the limited time.
-                                                             *   Normally the negative update is used at the beginning, as the initial benchmark is a very large value.
-                                                             *   (the unit of `neg_limit` is the tick of the slow clock source)
+        uint32_t                        jitter_step;        /*!< Jitter filter step size, only takes effect when the `filter_mode` is TOUCH_BM_JITTER_FILTER. Range: [0 ~ 15] */
+        int                             denoise_lvl;        /*!< The denoise level, which determines the noise bouncing range that won't trigger benchmark update.
+                                                             *   Range: [0 ~ 4]. The greater the denoise_lvl is, more noise resistance will be. Specially, `0` stands for no denoise
+                                                             *   Typically, recommend to set this field to 1.
                                                              */
-        } update;                                           /*!< The benchmark update strategy */
     } benchmark;                                            /*!< Benchmark filter */
     /**
      * @brief Data configuration

components/esp_driver_touch_sens/hw_ver3/touch_version_specific.c

@@ -282,8 +282,8 @@ esp_err_t touch_sensor_config_filter(touch_sensor_handle_t sens_handle, const to
 {
     TOUCH_NULL_POINTER_CHECK(sens_handle);
     if (filter_cfg) {
-        ESP_RETURN_ON_FALSE(filter_cfg->benchmark.update.neg_limit >= filter_cfg->data.debounce_cnt,
-                            ESP_ERR_INVALID_ARG, TAG, "The neg_limit should be greater than debounce_cnt");
+        ESP_RETURN_ON_FALSE(filter_cfg->benchmark.denoise_lvl >= 0 && filter_cfg->benchmark.denoise_lvl <= 4,
+                            ESP_ERR_INVALID_ARG, TAG, "denoise_lvl is out of range");
     }
 
     esp_err_t ret = ESP_OK;
@@ -297,8 +297,7 @@ esp_err_t touch_sensor_config_filter(touch_sensor_handle_t sens_handle, const to
         if (filter_cfg->benchmark.filter_mode == TOUCH_BM_JITTER_FILTER) {
             touch_ll_filter_set_jitter_step(filter_cfg->benchmark.jitter_step);
         }
-        touch_ll_filter_set_pos_noise_thresh(filter_cfg->benchmark.update.pos_thresh);
-        touch_ll_filter_set_neg_noise_thresh(filter_cfg->benchmark.update.neg_thresh, filter_cfg->benchmark.update.neg_limit);
+        touch_ll_filter_set_denoise_level(filter_cfg->benchmark.denoise_lvl);
         /* Configure the touch data filter */
         touch_ll_filter_set_smooth_mode(filter_cfg->data.smooth_filter);
         touch_ll_filter_set_active_hysteresis(filter_cfg->data.active_hysteresis);

components/hal/esp32p4/include/hal/touch_sensor_ll.h

@@ -695,39 +695,23 @@ static inline void touch_ll_filter_set_debounce(uint32_t 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)
+ * Set the denoise coefficient regarding the denoise level.
  *
- *
- * @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
+ * @param denoise_lvl   Range [0 ~ 4]. 0 = no noise resistance, otherwise higher denoise_lvl means more noise resistance.
  */
-static inline void touch_ll_filter_set_pos_noise_thresh(int pos_noise_thresh)
+static inline void touch_ll_filter_set_denoise_level(int denoise_lvl)
 {
-    bool always_update = pos_noise_thresh < 0;
+    HAL_ASSERT(denoise_lvl >= 0 && denoise_lvl <= 4);
+    bool always_update = denoise_lvl == 0;
+    // Map denoise level to actual noise threshold coefficients
+    uint32_t noise_thresh = denoise_lvl == 4 ? 3 : 3 - denoise_lvl;
+
     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;
-}
+    LP_ANA_PERI.touch_filter1.touch_noise_thres = always_update ? 0 : 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_nn_thres = always_update;
-    LP_ANA_PERI.touch_filter1.touch_nn_disupdate_baseline_en = stop_update;
-    LP_ANA_PERI.touch_filter1.touch_nn_thres = always_update || stop_update ? 0 : neg_noise_thresh;
-    LP_ANA_PERI.touch_filter1.touch_nn_limit = always_update || stop_update ? 5 : neg_noise_limit; // 5 is the default value
+    LP_ANA_PERI.touch_filter1.touch_nn_thres = always_update ? 0 : noise_thresh;
+    LP_ANA_PERI.touch_filter1.touch_nn_limit = 5; // 5 is the default value
 }
 
 /**