fix(touch_slider_sensor): support 2 channel slider

Author: leeebo

components/touch/touch_slider_sensor/Kconfig

@@ -8,7 +8,6 @@ menu "Touch Slider Sensor Configuration"
 
     config TOUCH_SLIDER_SENSOR_CALIBRATION_TIMES
         int "Calibration times"
-        default 50 if !IDF_TARGET_ESP32
         default 20
         range 10 1000
         help
@@ -54,19 +53,19 @@ menu "Touch Slider Sensor Configuration"
 
     config TOUCH_SLIDER_SENSOR_MAX_P_X1000
         int "Maximum positive change ratio (/1000)"
-        default 200
+        default 0
         range 0 1000
         help
             Maximum positive change ratio from baseline, multiplied by 1000.
-            For example, 200 means 0.2. 0 means no limit.
+            For example, 200 means 0.2. 0 means automatically calculated.
 
     config TOUCH_SLIDER_SENSOR_MIN_N_X1000
         int "Minimum negative change ratio (/1000)"
-        default 200
+        default 0
         range 0 1000
         help
             Minimum negative change ratio from baseline, multiplied by 1000.
-            For example, 200 means 0.2. 0 means no limit.
+            For example, 200 means 0.2. 0 means automatically calculated.
 
     config TOUCH_SLIDER_SENSOR_NEGATIVE_LOGIC
         bool "Using negative logic to detect touch"
@@ -90,7 +89,6 @@ menu "Touch Slider Sensor Configuration"
 
     config TOUCH_SLIDER_SENSOR_RESET_COVER
         int "Reset count from cover"
-        default 1000 if !IDF_TARGET_ESP32
         default 300
         range 0 5000
         help
@@ -105,7 +103,7 @@ menu "Touch Slider Sensor Configuration"
 
     config TOUCH_SLIDER_SENSOR_RAW_BUF_SIZE
         int "Raw buffer size"
-        default 40 if !IDF_TARGET_ESP32
+        default 20 if !IDF_TARGET_ESP32
         default 10
         range 10 100
         help
@@ -147,10 +145,4 @@ menu "Touch Slider Sensor Configuration"
         help
             Divisor of slider position IIR filter.
 
-    config TOUCH_SLIDER_SENSOR_CALCULATE_CHANNEL
-        int "Position calculation window"
-        default 3
-        range 1 10
-        help
-            Number of channels in position calculation
 endmenu

components/touch/touch_slider_sensor/README.md

@@ -7,14 +7,35 @@ A component providing enhanced touch slider detection functionality for ESP32 se
 ## Features
 
 - FSM-based touch detection with configurable thresholds
-- Support for slider gesture detection
+- Support for slider gesture detection with configurable position calculation window
+- Automatic default value selection for optimal performance
 - Callback-based event notification
 
 ## Dependencies
 
 - [touch_sensor_fsm](https://components.espressif.com/components/espressif/touch_sensor_fsm)
 - [touch_sensor_lowlevel](https://components.espressif.com/components/espressif/touch_sensor_lowlevel)
 
+## Configuration Options
+
+### Calculate Window (`calculate_window`)
+
+The `calculate_window` parameter determines how many adjacent touch channels are used for position calculation. This affects the precision and noise immunity of the slider.
+
+**Default Values (when set to 0):**
+- **2 channels**: `calculate_window = 2` (uses all available channels)
+- **3+ channels**: `calculate_window = 3` (optimal balance between precision and noise immunity)
+
+**Manual Configuration:**
+- You can explicitly set any value from 1 to `channel_num`
+- Smaller values (1-2): Higher sensitivity but more susceptible to noise
+- Larger values (3+): Better noise immunity but potentially lower resolution
+- For high-precision applications: Recommended value is `min(3, channel_num)`
+
+**Backward Compatibility:**
+- Setting `calculate_window = 0` enables automatic default selection
+- Existing code that doesn't initialize this field will use optimal defaults
+- Explicitly set values continue to work as before
 
 ## Example
 
@@ -70,6 +91,7 @@ void app_main(void)
         .swipe_hysterisis = 40,
         .channel_gold_value = NULL,
         .debounce_times = 0,
+        .calculate_window = 0,  // Use default value (auto-selected based on channel count)
         .skip_lowlevel_init = false
     };
 

components/touch/touch_slider_sensor/idf_component.yml

@@ -1,4 +1,4 @@
-version: "0.1.0"
+version: "0.2.0"
 targets:
   - esp32
   - esp32s2
@@ -14,9 +14,9 @@ dependencies:
   idf: ">=4.4"
   cmake_utilities: "0.*"
   touch_sensor_fsm:
-    version: ">=0.7.0"
+    version: ">=0.8.1~1,<0.9.0"
   touch_sensor_lowlevel:
-    version: ">=0.8.1"
+    version: ">=0.9.1~1,<0.10.0"
     public: true
 files:
   exclude:

components/touch/touch_slider_sensor/include/touch_slider_sensor.h

@@ -29,7 +29,8 @@ typedef struct {
     uint32_t *channel_gold_value; /*!< (Optional) Reference values for touch channels */
     uint32_t debounce_times;      /*!< Number of consecutive readings needed to confirm state change */
     uint32_t filter_reset_times;  /*!< Number of consecutive readings to reset position filter */
-    uint32_t position_range;       /*!< The right region of touch slider position range, [0, position_range (less than or equal to 255)] */
+    uint32_t position_range;      /*!< Maximum position value of touch slider, range [0, position_range]. Higher values provide better position resolution */
+    uint8_t calculate_window;     /*!< Window size for position calculation (should be <= channel_num). Set to 0 for auto-default: 2 for 2-channel, 3 for 3+ channels */
     float swipe_threshold;        /*!< The speed threshold for identifying swiping */
     float swipe_hysterisis;       /*!< The speed hysterisis for identifying swiping */
     float swipe_alpha;            /*!< Filter parameter for estimating speed */
@@ -54,14 +55,22 @@ typedef void (*touch_slider_event_cb_t)(touch_slider_handle_t handle, touch_slid
  * This function initializes the touch sensor hardware (unless skip_lowlevel_init is true),
  * sets up FSM instances for touch detection, and registers callbacks for touch events.
  *
+ * @note The calculate_window parameter determines how many adjacent channels are used
+ *       for position calculation. For backward compatibility, if set to 0, default
+ *       values will be used:
+ *       - 2 channels: window_size = 2 (use all channels)
+ *       - 3+ channels: window_size = 3 (optimal balance between precision and noise immunity)
+ *       - For high-precision applications: window_size = min(3, channel_num)
+ *
  * @param config   Touch slider sensor configuration
  * @param handle   Pointer to receive the created touch slider sensor handle
  * @param cb       Callback function for touch slider events
  * @param cb_arg   User data to pass to callback function
  *
  * @return
  *     - ESP_OK on success
- *     - ESP_ERR_INVALID_ARG if config, handle, or required config fields are NULL
+ *     - ESP_ERR_INVALID_ARG if config, handle, or required config fields are NULL,
+ *       or if calculate_window is less than 2 or greater than channel_num (0 is acceptable for auto-default)
  *     - ESP_ERR_NO_MEM if memory allocation fails
  *     - ESP_FAIL if touch sensor or FSM initialization fails
  */

components/touch/touch_slider_sensor/test_apps/main/test_touch_slider_sensor.c

@@ -57,10 +57,11 @@ TEST_CASE("touch slider sensor create/delete test", "[touch_slider][create]")
         .position_range = 10000,
         .channel_gold_value = NULL,
         .debounce_times = 3,
+        .calculate_window = 0,  // Test default value (should auto-select based on channel_num)
         .skip_lowlevel_init = false
     };
 
-    // Test successful creation
+    // Test successful creation with default calculate_window
     TEST_ASSERT_EQUAL(ESP_OK, touch_slider_sensor_create(&config, &s_touch_slider, touch_slider_event_callback, NULL));
     TEST_ASSERT_NOT_NULL(s_touch_slider);
 
@@ -79,6 +80,7 @@ TEST_CASE("touch slider sensor position test", "[touch_slider][events]")
         .position_range = 10000,
         .channel_gold_value = NULL,
         .debounce_times = 0,
+        .calculate_window = 0,  // Test default value
         .skip_lowlevel_init = false
     };
 
@@ -114,6 +116,7 @@ TEST_CASE("touch slider sensor event handling test", "[touch_slider][events]")
         .swipe_hysterisis = 40,
         .channel_gold_value = NULL,
         .debounce_times = 0,
+        .calculate_window = 3,  // Explicitly set to 3 for testing
         .skip_lowlevel_init = false
     };
 

components/touch/touch_slider_sensor/touch_slider_sensor.c

@@ -59,6 +59,7 @@ typedef struct touch_slider_sensor_t {
     uint32_t filter_reset_times;
     float quantify_signal_array[SOC_TOUCH_SENSOR_NUM];                    // Slider re-quantization array
     uint32_t position_range;
+    uint8_t calculate_window;                                             // Window size for position calculation
     float swipe_threshold;
     float swipe_hysterisis;
     float swipe_alpha;
@@ -155,6 +156,21 @@ esp_err_t touch_slider_sensor_create(touch_slider_config_t *config, touch_slider
     ESP_RETURN_ON_FALSE(config && handle, ESP_ERR_INVALID_ARG, TAG, "Invalid arguments");
     ESP_RETURN_ON_FALSE(config->channel_num > 1 && config->channel_list, ESP_ERR_INVALID_ARG, TAG, "Invalid channel config");
 
+    // Set default calculate_window if not specified or invalid (for backward compatibility)
+    if (config->calculate_window == 0) {
+        // Recommended default values based on channel count
+        if (config->channel_num == 2) {
+            config->calculate_window = 2;  // Use all channels for 2-channel setup
+        } else {
+            config->calculate_window = 3;  // Optimal balance for 3+ channels
+        }
+        ESP_LOGI(TAG, "Using default calculate_window: %"PRIu8, config->calculate_window);
+    }
+
+    // Validate calculation window size
+    ESP_RETURN_ON_FALSE(config->calculate_window >= 2 && config->calculate_window <= config->channel_num,
+                        ESP_ERR_INVALID_ARG, TAG, "Invalid calculate_window: must be >= 2 and <= channel_num (%"PRIu32")", config->channel_num);
+
     touch_slider_sensor_t *sensor = calloc(1, sizeof(touch_slider_sensor_t));
     ESP_RETURN_ON_FALSE(sensor, ESP_ERR_NO_MEM, TAG, "Failed to allocate memory");
 
@@ -174,6 +190,7 @@ esp_err_t touch_slider_sensor_create(touch_slider_config_t *config, touch_slider
     sensor->channel_bcm_update_cnt = CONFIG_TOUCH_SLIDER_SENSOR_BENCHMARK_UPDATE_TIME; // update at first time
     sensor->filter_reset_cnt = config->filter_reset_times;
     sensor->position_range = config->position_range;
+    sensor->calculate_window = config->calculate_window;                               // Store calculate window size
     sensor->swipe_threshold = config->swipe_threshold;
     sensor->swipe_hysterisis = config->swipe_hysterisis;
     sensor->swipe_alpha = config->swipe_alpha;
@@ -385,22 +402,23 @@ static inline void slider_quantify_signal(touch_slider_handle_t slider_handle)
  *
  * This function will figure out the max sum subarray from the
  * input array, return the max sum and max sum start index
- *
  */
-static inline float slider_search_max_subarray(const float *array, int array_size, int *max_array_idx)
+static inline float slider_search_max_subarray(const float *array, uint8_t array_size, uint8_t window_size, uint8_t *max_array_idx)
 {
     *max_array_idx = 0;
     float max_array_sum = 0;
     float current_array_sum = 0;
-    for (int idx = 0; idx <= (array_size - CONFIG_TOUCH_SLIDER_SENSOR_CALCULATE_CHANNEL); idx++) {
-        for (int x = idx; x < idx + CONFIG_TOUCH_SLIDER_SENSOR_CALCULATE_CHANNEL; x++) {
+    uint8_t max_start_idx = array_size - window_size;
+
+    for (uint8_t idx = 0; idx <= max_start_idx; idx++) {
+        current_array_sum = 0;
+        for (uint8_t x = idx; x < idx + window_size; x++) {
             current_array_sum += array[x];
         }
         if (max_array_sum < current_array_sum) {
             max_array_sum = current_array_sum;
             *max_array_idx = idx;
         }
-        current_array_sum = 0;
     }
     return max_array_sum;
 }
@@ -411,26 +429,34 @@ static inline float slider_search_max_subarray(const float *array, int array_siz
  * This function will figure out the number of non-zero items from
  * the subarray
  */
-static inline uint8_t slider_get_non_zero_num(const float *array, uint8_t array_idx)
+static inline uint8_t slider_get_non_zero_num(const float *array, uint8_t array_idx, uint8_t window_size, uint8_t array_size)
 {
     uint8_t zero_cnt = 0;
-    for (int idx = array_idx; idx < array_idx + CONFIG_TOUCH_SLIDER_SENSOR_CALCULATE_CHANNEL; idx++) {
+    // Prevent uint8_t overflow and ensure we don't exceed array bounds
+    uint8_t end_idx = (array_idx + window_size > array_size) ? array_size : array_idx + window_size;
+
+    for (uint8_t idx = array_idx; idx < end_idx; idx++) {
         zero_cnt += (array[idx] > 0) ? 1 : 0;
     }
     return zero_cnt;
 }
 
-static inline uint32_t slider_calculate_position(touch_slider_handle_t slider_handle, int subarray_index, float subarray_sum, int non_zero_num)
+static inline uint32_t slider_calculate_position(touch_slider_handle_t slider_handle, uint8_t subarray_index, float subarray_sum, uint8_t non_zero_num)
 {
-    int range = slider_handle->position_range;
-    int array_size = slider_handle->channel_num;
+    uint32_t range = slider_handle->position_range;
+    uint8_t array_size = slider_handle->channel_num;
+    uint8_t window_size = slider_handle->calculate_window;  // Use user-configured window size
     float scale = (float)range / (slider_handle->channel_num - 1);
     const float *array = slider_handle->quantify_signal_array;
     uint32_t position = 0;
+
     if (non_zero_num == 0) {
         position = slider_handle->position;
     } else if (non_zero_num == 1) {
-        for (int index = subarray_index; index < subarray_index + CONFIG_TOUCH_SLIDER_SENSOR_CALCULATE_CHANNEL; index++) {
+        // Search for non-zero elements within actual window range
+        uint8_t end_idx = (subarray_index + window_size > array_size) ? array_size : subarray_index + window_size;
+
+        for (uint8_t index = subarray_index; index < end_idx; index++) {
             if (0 != array[index]) {
                 if (index == array_size - 1) {
                     position = range;
@@ -441,7 +467,9 @@ static inline uint32_t slider_calculate_position(touch_slider_handle_t slider_ha
             }
         }
     } else {
-        for (int idx = subarray_index; idx < subarray_index + CONFIG_TOUCH_SLIDER_SENSOR_CALCULATE_CHANNEL; idx++) {
+        // Multiple channels have signals, use weighted average
+        uint8_t end_idx = (subarray_index + window_size > array_size) ? array_size : subarray_index + window_size;  // Prevent uint8_t overflow and ensure we don't exceed array bounds
+        for (uint8_t idx = subarray_index; idx < end_idx; idx++) {
             position += ((float)idx * array[idx]);
         }
         position = position * scale / subarray_sum;
@@ -495,14 +523,14 @@ static inline uint32_t slider_filter_iir(uint32_t in_now, uint32_t out_last, uin
  */
 static void slider_update_position(touch_slider_handle_t slider_handle)
 {
-    int max_array_idx = 0;
+    uint8_t max_array_idx = 0;
     float max_array_sum;
     uint8_t non_zero_num;
     uint32_t current_position;
 
     slider_quantify_signal(slider_handle);
-    max_array_sum = slider_search_max_subarray(slider_handle->quantify_signal_array, slider_handle->channel_num, &max_array_idx);
-    non_zero_num = slider_get_non_zero_num(slider_handle->quantify_signal_array, max_array_idx);
+    max_array_sum = slider_search_max_subarray(slider_handle->quantify_signal_array, slider_handle->channel_num, slider_handle->calculate_window, &max_array_idx);
+    non_zero_num = slider_get_non_zero_num(slider_handle->quantify_signal_array, max_array_idx, slider_handle->calculate_window, slider_handle->channel_num);
     current_position = slider_calculate_position(slider_handle, max_array_idx, max_array_sum, non_zero_num);
     uint32_t position_average = slider_filter_average(slider_handle, current_position);
     slider_handle->last_position = slider_handle->position == 0 ? position_average : slider_handle->position;