2180 lines
88 KiB
C
2180 lines
88 KiB
C
// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
/*
|
|
Tests for the touch sensor device driver
|
|
*/
|
|
#include <string.h>
|
|
#include "esp_system.h"
|
|
#include "driver/touch_pad.h"
|
|
#include "unity.h"
|
|
#include "esp_system.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/semphr.h"
|
|
#include "freertos/queue.h"
|
|
#include "esp_log.h"
|
|
#include "test_utils.h"
|
|
#include "soc/rtc_cntl_reg.h"
|
|
#include "soc/rtc_cntl_struct.h"
|
|
#include "soc/sens_reg.h"
|
|
#include "soc/sens_struct.h"
|
|
#include "soc/rtc_cntl_reg.h"
|
|
#include "soc/rtc_cntl_struct.h"
|
|
#include "soc/rtc_io_reg.h"
|
|
#include "soc/rtc_io_struct.h"
|
|
#include "soc/apb_ctrl_reg.h"
|
|
#include "driver/rtc_io.h"
|
|
|
|
#if !DISABLED_FOR_TARGETS(ESP8266, ESP32) // This testcase for ESP32S2
|
|
|
|
static const char *TAG = "test_touch";
|
|
|
|
#define PLATFORM_SELECT (1) //0: pxp; 1: chip
|
|
#if (PLATFORM_SELECT == 0) //PXP platform
|
|
#define SET_BREAK_POINT(flag) REG_WRITE(APB_CTRL_DATE_REG, flag)
|
|
//PXP clk is slower.
|
|
#define SYS_DELAY_TIME_MOM (1/40)
|
|
#define RTC_SLOW_CLK_FLAG 1 // Slow clock is 32KHz.
|
|
void test_pxp_deinit_io(void)
|
|
{
|
|
for (int i = 0; i < 22; i++) {
|
|
rtc_gpio_init(i);
|
|
}
|
|
}
|
|
#else
|
|
//PXP clk is slower.
|
|
#define SET_BREAK_POINT(flag)
|
|
#define SYS_DELAY_TIME_MOM (1)
|
|
#define RTC_SLOW_CLK_FLAG 0 // Slow clock is 32KHz.
|
|
void test_pxp_deinit_io(void)
|
|
{
|
|
;
|
|
}
|
|
#endif
|
|
|
|
#define TOUCH_READ_INVALID_VAL (SOC_TOUCH_PAD_THRESHOLD_MAX)
|
|
#define TOUCH_READ_ERROR (100)
|
|
#define TOUCH_INTR_THRESHOLD (0.1)
|
|
#define TOUCH_EXCEED_TIME_MS (1000)
|
|
|
|
#define TOUCH_REG_BASE_TEST() ({ \
|
|
TEST_ASSERT_EQUAL_UINT32(REG_GET_FIELD(RTC_CNTL_DATE_REG, RTC_CNTL_CNTL_DATE), RTCCNTL.date.date); \
|
|
TEST_ASSERT_EQUAL_UINT32(REG_GET_FIELD(SENS_SARDATE_REG, SENS_SAR_DATE), SENS.sardate.sar_date); \
|
|
TEST_ASSERT_EQUAL_UINT32(REG_GET_FIELD(RTC_IO_DATE_REG, RTC_IO_IO_DATE), RTCIO.date.date); \
|
|
})
|
|
|
|
#define TEST_TOUCH_COUNT_NUM (5)
|
|
#define TEST_TOUCH_CHANNEL (14)
|
|
static touch_pad_t touch_list[TEST_TOUCH_CHANNEL] = {
|
|
// TOUCH_PAD_NUM0, is GPIO0, for download.
|
|
TOUCH_PAD_NUM1,
|
|
TOUCH_PAD_NUM2,
|
|
TOUCH_PAD_NUM3,
|
|
TOUCH_PAD_NUM4,
|
|
TOUCH_PAD_NUM5,
|
|
TOUCH_PAD_NUM6,
|
|
TOUCH_PAD_NUM7,
|
|
TOUCH_PAD_NUM8,
|
|
TOUCH_PAD_NUM9,
|
|
TOUCH_PAD_NUM10,
|
|
TOUCH_PAD_NUM11,
|
|
TOUCH_PAD_NUM12,
|
|
TOUCH_PAD_NUM13,
|
|
TOUCH_PAD_NUM14
|
|
};
|
|
|
|
#define TOUCH_WATERPROOF_RING_PAD TOUCH_PAD_NUM1
|
|
static touch_pad_t proximity_pad[3] = {
|
|
TOUCH_PAD_NUM2,
|
|
TOUCH_PAD_NUM3,
|
|
TOUCH_PAD_NUM4,
|
|
};
|
|
|
|
static QueueHandle_t que_touch = NULL;
|
|
typedef struct touch_msg {
|
|
touch_pad_intr_mask_t intr_mask;
|
|
uint32_t pad_num;
|
|
uint32_t pad_status;
|
|
uint32_t pad_val;
|
|
uint32_t slp_proxi_cnt;
|
|
uint32_t slp_proxi_base;
|
|
} touch_event_t;
|
|
|
|
static uint32_t s_touch_timeout_mask = 0;
|
|
|
|
static void printf_touch_hw_read(const char *str)
|
|
{
|
|
uint32_t touch_value;
|
|
printf("[%s] ", str);
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
touch_pad_read_raw_data(touch_list[i], &touch_value);
|
|
printf("[%d]%d ", touch_list[i], touch_value);
|
|
}
|
|
printf("\r\n");
|
|
}
|
|
|
|
static void printf_touch_baseline_read(const char *str)
|
|
{
|
|
uint32_t touch_value;
|
|
printf("[%s] ", str);
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
printf("[%d]%d ", touch_list[i], touch_value);
|
|
}
|
|
printf("\r\n");
|
|
}
|
|
|
|
static void printf_touch_smooth_read(const char *str)
|
|
{
|
|
uint32_t touch_value;
|
|
printf("[%s] ", str);
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
touch_pad_filter_read_smooth(touch_list[i], &touch_value);
|
|
printf("[%d]%d ", touch_list[i], touch_value);
|
|
}
|
|
printf("\r\n");
|
|
}
|
|
|
|
|
|
static void test_timeout_trigger_fake(touch_pad_t pad_num)
|
|
{
|
|
touch_pad_set_cnt_mode(pad_num, TOUCH_PAD_SLOPE_0, TOUCH_PAD_TIE_OPT_DEFAULT);
|
|
}
|
|
|
|
static void test_timeout_normal(touch_pad_t pad_num)
|
|
{
|
|
touch_pad_set_cnt_mode(pad_num, TOUCH_PAD_SLOPE_7, TOUCH_PAD_TIE_OPT_DEFAULT);
|
|
}
|
|
|
|
/*
|
|
* Change the slope to get larger value from touch sensor.
|
|
*/
|
|
static void test_press_fake(touch_pad_t pad_num)
|
|
{
|
|
touch_pad_set_cnt_mode(pad_num, TOUCH_PAD_SLOPE_3, TOUCH_PAD_TIE_OPT_DEFAULT);
|
|
}
|
|
|
|
/*
|
|
* Change the slope to get larger value from touch sensor.
|
|
*/
|
|
static void test_release_fake(touch_pad_t pad_num)
|
|
{
|
|
touch_pad_set_cnt_mode(pad_num, TOUCH_PAD_SLOPE_7, TOUCH_PAD_TIE_OPT_DEFAULT);
|
|
}
|
|
|
|
static void test_touch_push_all(void)
|
|
{
|
|
ESP_LOGI(TAG, "touch push");
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
test_press_fake(touch_list[i]);
|
|
}
|
|
}
|
|
|
|
static void test_touch_release_all(void)
|
|
{
|
|
ESP_LOGI(TAG, "touch release");
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
test_release_fake(touch_list[i]);
|
|
}
|
|
}
|
|
|
|
/* Test: if the raw data exceed noise threshold, the baseline should not be updated. */
|
|
static void test_touch_baseline_not_update(void)
|
|
{
|
|
uint32_t touch_val[TEST_TOUCH_CHANNEL] = {0};
|
|
uint32_t touch_temp[TEST_TOUCH_CHANNEL] = {0};
|
|
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_val[i]) );
|
|
}
|
|
for (int i = 0; i < 10; i++) {
|
|
vTaskDelay(20 / portTICK_PERIOD_MS);
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_temp[i]) );
|
|
TEST_ASSERT_EQUAL(touch_temp[i], touch_val[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test the stable and change of touch sensor reading in SW mode.
|
|
*/
|
|
esp_err_t test_touch_sw_read(void)
|
|
{
|
|
uint32_t touch_value[TEST_TOUCH_CHANNEL] = {0};
|
|
uint32_t touch_temp[TEST_TOUCH_CHANNEL] = {0};
|
|
uint32_t touch_push[TEST_TOUCH_CHANNEL] = {0};
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_SW) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
while (test_cnt--) {
|
|
test_touch_release_all();
|
|
|
|
/* Read the touch sensor raw data in SW mode. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_sw_start() );
|
|
while (!touch_pad_meas_is_done()) ;
|
|
TEST_ESP_OK( touch_pad_read_raw_data(touch_list[i], &touch_value[i]) );
|
|
printf("T%d:[%4d] ", touch_list[i], touch_value[i]);
|
|
TEST_ASSERT_NOT_EQUAL(TOUCH_READ_INVALID_VAL, touch_value[i]);
|
|
}
|
|
printf("\n");
|
|
/* Check the stable of reading. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
if (touch_temp[i]) {
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp[i], touch_value[i]);
|
|
}
|
|
touch_temp[i] = touch_value[i];
|
|
}
|
|
|
|
test_touch_push_all();
|
|
|
|
/* Read the touch sensor raw data in SW mode. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_sw_start() );
|
|
while (!touch_pad_meas_is_done()) ;
|
|
TEST_ESP_OK( touch_pad_read_raw_data(touch_list[i], &touch_push[i]) );
|
|
printf("T%d:[%4d] ", touch_list[i], touch_push[i]);
|
|
TEST_ASSERT_NOT_EQUAL(TOUCH_READ_INVALID_VAL, touch_push[i]);
|
|
}
|
|
printf("\n");
|
|
/* Check the change of reading. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ASSERT_GREATER_THAN(touch_value[i], touch_push[i]);
|
|
}
|
|
}
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
/*
|
|
* Test the stable and change of touch sensor reading in timer mode.
|
|
* TEST POINT:
|
|
* 1. Timer mode for FSM.
|
|
* 2. Touch channel slope setting.
|
|
* 3. Touch reading stable.
|
|
*/
|
|
esp_err_t test_touch_timer_read(void)
|
|
{
|
|
uint32_t touch_value[TEST_TOUCH_CHANNEL] = {0};
|
|
uint32_t touch_temp[TEST_TOUCH_CHANNEL] = {0};
|
|
uint32_t touch_push[TEST_TOUCH_CHANNEL] = {0};
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
/* Set different slope for channels to test slope function. */
|
|
printf("Set slope for channel: ");
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
TEST_ESP_OK( touch_pad_set_cnt_mode(touch_list[i], i % 7 ? i % 7 : 1, TOUCH_PAD_TIE_OPT_DEFAULT) );
|
|
printf("[ch%d-%d] ", touch_list[i], i % 7 ? i % 7 : 1);
|
|
}
|
|
printf("\n");
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
/* Wait touch sensor stable */
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
|
|
while (test_cnt--) {
|
|
test_touch_release_all();
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
|
|
// Start task to read values sensed by pads
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_read_raw_data(touch_list[i], &touch_value[i]) );
|
|
TEST_ASSERT_NOT_EQUAL(TOUCH_READ_INVALID_VAL, touch_value[i]);
|
|
printf("T%d:[%4d] ", touch_list[i], touch_value[i]);
|
|
}
|
|
printf("\n");
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
if (touch_temp[i]) {
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp[i], touch_value[i]);
|
|
}
|
|
touch_temp[i] = touch_value[i];
|
|
}
|
|
|
|
test_touch_push_all();
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
|
|
/* Read the touch sensor raw data in FSM mode. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_read_raw_data(touch_list[i], &touch_push[i]) );
|
|
printf("T%d:[%4d] ", touch_list[i], touch_push[i]);
|
|
TEST_ASSERT_NOT_EQUAL(TOUCH_READ_INVALID_VAL, touch_push[i]);
|
|
}
|
|
printf("\n");
|
|
/* Check the change of reading. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ASSERT_GREATER_THAN(touch_value[i], touch_push[i]);
|
|
}
|
|
}
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
/*
|
|
* Test the filter mode.
|
|
* TEST POINT:
|
|
* 1. Timer mode for FSM.
|
|
* 2. Touch reading stable.
|
|
* 3. Touch reading init value.
|
|
* 4. Touch reading filtered value equal to raw data.
|
|
*/
|
|
esp_err_t test_touch_filtered_read(void)
|
|
{
|
|
uint32_t touch_value[TEST_TOUCH_CHANNEL] = {0};
|
|
uint32_t touch_temp[TEST_TOUCH_CHANNEL] = {0};
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_32, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_IIR_2,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
/* Wait touch pad init done. */
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
/* Test the stable for init value of touch reading.
|
|
* Ideal: baseline == raw data == smooth data.
|
|
*/
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value[i]) );
|
|
TEST_ASSERT_NOT_EQUAL(TOUCH_READ_INVALID_VAL, touch_value[i]);
|
|
TEST_ESP_OK( touch_pad_read_raw_data(touch_list[i], &touch_temp[i]) );
|
|
TEST_ASSERT_NOT_EQUAL(TOUCH_READ_INVALID_VAL, touch_temp[i]);
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp[i], touch_value[i]);
|
|
TEST_ESP_OK( touch_pad_filter_read_smooth(touch_list[i], &touch_temp[i]) );
|
|
TEST_ASSERT_NOT_EQUAL(TOUCH_READ_INVALID_VAL, touch_temp[i]);
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp[i], touch_value[i]);
|
|
}
|
|
printf("touch filter init value:\n");
|
|
printf_touch_hw_read("raw ");
|
|
printf_touch_baseline_read("base ");
|
|
printf_touch_smooth_read("smooth");
|
|
printf("\n");
|
|
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
while (test_cnt--) {
|
|
/* Touch reading filtered value equal to raw data. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_read_raw_data(touch_list[i], &touch_value[i]) );
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_temp[i]) );
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp[i], touch_value[i]);
|
|
TEST_ESP_OK( touch_pad_filter_read_smooth(touch_list[i], &touch_temp[i]) );
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp[i], touch_value[i]);
|
|
}
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
if (touch_temp[i]) {
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp[i], touch_value[i]);
|
|
}
|
|
touch_temp[i] = touch_value[i];
|
|
}
|
|
vTaskDelay(20 / portTICK_PERIOD_MS);
|
|
}
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
TEST_CASE("Touch Sensor reading test (SW, Timer, filter)", "[touch]")
|
|
{
|
|
TOUCH_REG_BASE_TEST();
|
|
TEST_ESP_OK( test_touch_sw_read() );
|
|
TEST_ESP_OK( test_touch_timer_read() );
|
|
TEST_ESP_OK( test_touch_filtered_read() );
|
|
}
|
|
|
|
/*
|
|
* Test the base patameter mode.
|
|
* TEST POINT:
|
|
* 1. measure time and sleep time setting.
|
|
* 2. Charge / incharge voltage threshold setting.
|
|
* 3. Touch slope setting.
|
|
* 4. Touch reading filtered value equal to raw data.
|
|
*/
|
|
int test_touch_base_parameter(touch_pad_t pad_num, int meas_time, int slp_time,
|
|
int vol_h, int vol_l, int vol_a, int slope, bool is_conn_gnd)
|
|
{
|
|
uint32_t touch_value = 0;
|
|
uint32_t touch_temp = 0, touch_filter;
|
|
uint64_t val_sum = 0;
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
/* Note: init all channel, but test one channel. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_set_cnt_mode(pad_num, slope, TOUCH_PAD_TIE_OPT_DEFAULT) );
|
|
TEST_ESP_OK( touch_pad_set_meas_time(slp_time, meas_time) );
|
|
TEST_ESP_OK( touch_pad_set_voltage(vol_h, vol_l, vol_a) );
|
|
TEST_ESP_OK( touch_pad_set_idle_channel_connect(is_conn_gnd) );
|
|
ESP_LOGI(TAG, "meas_time[%d]_slp_time[%d]_vol_h[%d]_vol_l[%d]_vol_a[%d]_slope[%d]_is_conn_gnd[%d]",
|
|
meas_time, slp_time, vol_h, vol_l, vol_a, slope, is_conn_gnd);
|
|
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_32, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_IIR_2,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
/* Some parameters will delay the init time. so wait longger time */
|
|
vTaskDelay(100 / portTICK_PERIOD_MS);
|
|
|
|
while (test_cnt--) {
|
|
/* Correctness of reading. Ideal: baseline == raw data == smooth data. */
|
|
TEST_ESP_OK( touch_pad_read_raw_data(pad_num, &touch_value) );
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(pad_num, &touch_filter) );
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_filter, touch_value);
|
|
TEST_ESP_OK( touch_pad_filter_read_smooth(pad_num, &touch_filter) );
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_filter, touch_value);
|
|
|
|
/* Stable of reading */
|
|
TEST_ESP_OK( touch_pad_read_raw_data(pad_num, &touch_value) );
|
|
TEST_ASSERT_NOT_EQUAL(TOUCH_READ_INVALID_VAL, touch_value);
|
|
if (touch_temp) {
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp, touch_value);
|
|
}
|
|
touch_temp = touch_value;
|
|
|
|
printf("T%d:[%4d] ", pad_num, touch_value);
|
|
val_sum += touch_value; // For check.
|
|
vTaskDelay(20 / portTICK_PERIOD_MS);
|
|
}
|
|
printf("\n");
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
return (uint32_t)(val_sum / TEST_TOUCH_COUNT_NUM);
|
|
}
|
|
|
|
TEST_CASE("Touch Sensor base parameters test (meas_time, voltage, slope, inv_conn)", "[touch]")
|
|
{
|
|
int touch_val[5] = {0};
|
|
|
|
ESP_LOGI(TAG, "Charge / incharge voltage level test");
|
|
touch_val[0] = test_touch_base_parameter(touch_list[2], TOUCH_PAD_MEASURE_CYCLE_DEFAULT, TOUCH_PAD_SLEEP_CYCLE_DEFAULT,
|
|
TOUCH_HVOLT_2V4, TOUCH_LVOLT_0V8, TOUCH_HVOLT_ATTEN_1V5,
|
|
TOUCH_PAD_SLOPE_DEFAULT, true);
|
|
touch_val[1] = test_touch_base_parameter(touch_list[2], TOUCH_PAD_MEASURE_CYCLE_DEFAULT, TOUCH_PAD_SLEEP_CYCLE_DEFAULT,
|
|
TOUCH_HVOLT_2V5, TOUCH_LVOLT_0V6, TOUCH_HVOLT_ATTEN_1V,
|
|
TOUCH_PAD_SLOPE_DEFAULT, true);
|
|
touch_val[2] = test_touch_base_parameter(touch_list[2], TOUCH_PAD_MEASURE_CYCLE_DEFAULT, TOUCH_PAD_SLEEP_CYCLE_DEFAULT,
|
|
TOUCH_HVOLT_2V7, TOUCH_LVOLT_0V5, TOUCH_HVOLT_ATTEN_0V,
|
|
TOUCH_PAD_SLOPE_DEFAULT, true);
|
|
|
|
TEST_ASSERT_GREATER_THAN(touch_val[0], touch_val[1]);
|
|
TEST_ASSERT_GREATER_THAN(touch_val[1], touch_val[2]);
|
|
|
|
ESP_LOGI(TAG, "Measure time / sleep time test");
|
|
touch_val[0] = test_touch_base_parameter(touch_list[1], 0xff, 0x1ff,
|
|
TOUCH_PAD_HIGH_VOLTAGE_THRESHOLD, TOUCH_PAD_LOW_VOLTAGE_THRESHOLD, TOUCH_PAD_ATTEN_VOLTAGE_THRESHOLD, TOUCH_PAD_SLOPE_DEFAULT, true);
|
|
touch_val[1] = test_touch_base_parameter(touch_list[1], 0xfff, 0xff,
|
|
TOUCH_PAD_HIGH_VOLTAGE_THRESHOLD, TOUCH_PAD_LOW_VOLTAGE_THRESHOLD, TOUCH_PAD_ATTEN_VOLTAGE_THRESHOLD, TOUCH_PAD_SLOPE_DEFAULT, true);
|
|
touch_val[2] = test_touch_base_parameter(touch_list[1], 0x1fff, 0xf,
|
|
TOUCH_PAD_HIGH_VOLTAGE_THRESHOLD, TOUCH_PAD_LOW_VOLTAGE_THRESHOLD, TOUCH_PAD_ATTEN_VOLTAGE_THRESHOLD, TOUCH_PAD_SLOPE_DEFAULT, true);
|
|
|
|
TEST_ASSERT_GREATER_THAN(touch_val[0], touch_val[1]);
|
|
TEST_ASSERT_GREATER_THAN(touch_val[1], touch_val[2]);
|
|
|
|
ESP_LOGI(TAG, "Charge / incharge slope level test");
|
|
touch_val[0] = test_touch_base_parameter(touch_list[0], TOUCH_PAD_MEASURE_CYCLE_DEFAULT, TOUCH_PAD_SLEEP_CYCLE_DEFAULT,
|
|
TOUCH_PAD_HIGH_VOLTAGE_THRESHOLD, TOUCH_PAD_LOW_VOLTAGE_THRESHOLD, TOUCH_PAD_ATTEN_VOLTAGE_THRESHOLD, 7, true);
|
|
touch_val[1] = test_touch_base_parameter(touch_list[0], TOUCH_PAD_MEASURE_CYCLE_DEFAULT, TOUCH_PAD_SLEEP_CYCLE_DEFAULT,
|
|
TOUCH_PAD_HIGH_VOLTAGE_THRESHOLD, TOUCH_PAD_LOW_VOLTAGE_THRESHOLD, TOUCH_PAD_ATTEN_VOLTAGE_THRESHOLD, 5, true);
|
|
touch_val[2] = test_touch_base_parameter(touch_list[0], TOUCH_PAD_MEASURE_CYCLE_DEFAULT, TOUCH_PAD_SLEEP_CYCLE_DEFAULT,
|
|
TOUCH_PAD_HIGH_VOLTAGE_THRESHOLD, TOUCH_PAD_LOW_VOLTAGE_THRESHOLD, TOUCH_PAD_ATTEN_VOLTAGE_THRESHOLD, 3, true);
|
|
|
|
TEST_ASSERT_GREATER_THAN(touch_val[0], touch_val[1]);
|
|
TEST_ASSERT_GREATER_THAN(touch_val[1], touch_val[2]);
|
|
|
|
/* The GND option causes larger parasitic capacitance and larger reading */
|
|
ESP_LOGI(TAG, "Inactive connect test");
|
|
touch_val[0] = test_touch_base_parameter(touch_list[3], TOUCH_PAD_MEASURE_CYCLE_DEFAULT, TOUCH_PAD_SLEEP_CYCLE_DEFAULT,
|
|
TOUCH_PAD_HIGH_VOLTAGE_THRESHOLD, TOUCH_PAD_LOW_VOLTAGE_THRESHOLD, TOUCH_PAD_ATTEN_VOLTAGE_THRESHOLD, TOUCH_PAD_SLOPE_DEFAULT,
|
|
false);
|
|
touch_val[1] = test_touch_base_parameter(touch_list[3], TOUCH_PAD_MEASURE_CYCLE_DEFAULT, TOUCH_PAD_SLEEP_CYCLE_DEFAULT,
|
|
TOUCH_PAD_HIGH_VOLTAGE_THRESHOLD, TOUCH_PAD_LOW_VOLTAGE_THRESHOLD, TOUCH_PAD_ATTEN_VOLTAGE_THRESHOLD, TOUCH_PAD_SLOPE_DEFAULT,
|
|
true);
|
|
TEST_ASSERT_GREATER_THAN(touch_val[0], touch_val[1]);
|
|
}
|
|
|
|
/*
|
|
* Check active interrupt of touch channels.
|
|
*/
|
|
static esp_err_t test_touch_check_ch_touched(uint32_t test_ch_num, uint32_t exceed_time_ms)
|
|
{
|
|
touch_event_t evt = {0};
|
|
esp_err_t ret = ESP_FAIL;
|
|
printf("Active: ");
|
|
while (1) {
|
|
if (pdTRUE == xQueueReceive(que_touch, &evt, exceed_time_ms / portTICK_PERIOD_MS)) {
|
|
if (evt.intr_mask & TOUCH_PAD_INTR_MASK_ACTIVE) {
|
|
printf("0x%x, ", evt.pad_status);
|
|
if (test_ch_num == __builtin_popcount(evt.pad_status)) {
|
|
ret = ESP_OK;
|
|
break;
|
|
}
|
|
} else if (evt.intr_mask & (TOUCH_PAD_INTR_MASK_DONE | TOUCH_PAD_INTR_MASK_SCAN_DONE)) {
|
|
continue;
|
|
} else { // If the interrupt type error, test error.
|
|
ESP_LOGI(TAG, "Touch[%d] intr error, status %d, evt_msk0x%x", evt.pad_num, evt.pad_status, evt.intr_mask);
|
|
break;
|
|
}
|
|
} else {
|
|
ESP_LOGI(TAG, "Touch intr exceed time");
|
|
break;
|
|
}
|
|
}
|
|
printf("\n");
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Check inactive interrupt of touch channels.
|
|
*/
|
|
static esp_err_t test_touch_check_ch_released(uint32_t test_ch_num, uint32_t exceed_time_ms)
|
|
{
|
|
touch_event_t evt = {0};
|
|
esp_err_t ret = ESP_FAIL;
|
|
printf("Inactive: ");
|
|
while (1) {
|
|
if (pdTRUE == xQueueReceive(que_touch, &evt, exceed_time_ms / portTICK_PERIOD_MS)) {
|
|
if (evt.intr_mask & TOUCH_PAD_INTR_MASK_INACTIVE) {
|
|
printf("0x%x, ", evt.pad_status);
|
|
if ((TEST_TOUCH_CHANNEL - test_ch_num) == __builtin_popcount(evt.pad_status)) {
|
|
ret = ESP_OK;
|
|
break;
|
|
}
|
|
} else if (evt.intr_mask & (TOUCH_PAD_INTR_MASK_DONE | TOUCH_PAD_INTR_MASK_SCAN_DONE)) {
|
|
continue;
|
|
} else { // If the interrupt type error, test error.
|
|
ESP_LOGI(TAG, "Touch[%d] intr error, status %d, evt_msk0x%x", evt.pad_num, evt.pad_status, evt.intr_mask);
|
|
break;
|
|
}
|
|
} else {
|
|
ESP_LOGI(TAG, "Touch intr exceed time");
|
|
break;
|
|
}
|
|
}
|
|
printf("\n");
|
|
return ret;
|
|
}
|
|
|
|
static esp_err_t test_touch_check_ch_touched_with_proximity(uint32_t test_ch_num, uint32_t exceed_time_ms)
|
|
{
|
|
uint32_t count = 0;
|
|
uint16_t ch_mask = 0;
|
|
touch_event_t evt = {0};
|
|
esp_err_t ret = ESP_FAIL;
|
|
|
|
TEST_ESP_OK( touch_pad_proximity_get_count(TOUCH_PAD_MAX, &count) );
|
|
printf("Active: ");
|
|
while (1) {
|
|
if (pdTRUE == xQueueReceive(que_touch, &evt, exceed_time_ms / portTICK_PERIOD_MS)) {
|
|
if (evt.intr_mask & TOUCH_PAD_INTR_MASK_ACTIVE) {
|
|
printf("0x%x, ", evt.pad_status);
|
|
if (test_ch_num == __builtin_popcount(evt.pad_status)) {
|
|
ret = ESP_OK;
|
|
break;
|
|
}
|
|
} else if (evt.intr_mask & (TOUCH_PAD_INTR_MASK_SCAN_DONE)) {
|
|
touch_pad_get_channel_mask(&ch_mask);
|
|
for (int i = TOUCH_PAD_MAX - 1; i >= 0; i--) {
|
|
if (BIT(i) & ch_mask) {
|
|
if (evt.pad_num == i) {
|
|
if (count == evt.slp_proxi_cnt) {
|
|
ets_printf("priximity base(%d) cnt(%d)\n", evt.slp_proxi_base, evt.slp_proxi_cnt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
} else { // If the interrupt type error, test error.
|
|
ESP_LOGI(TAG, "Touch[%d] intr error, status %d, evt_msk0x%x", evt.pad_num, evt.pad_status, evt.intr_mask);
|
|
continue;;
|
|
}
|
|
} else {
|
|
ESP_LOGI(TAG, "Touch intr exceed time");
|
|
break;
|
|
}
|
|
}
|
|
printf("\n");
|
|
return (esp_err_t)ret;
|
|
}
|
|
|
|
static esp_err_t test_touch_check_ch_released_with_proximity(uint32_t test_ch_num, uint32_t exceed_time_ms)
|
|
{
|
|
uint32_t count = 0;
|
|
uint16_t ch_mask = 0;
|
|
touch_event_t evt = {0};
|
|
esp_err_t ret = ESP_FAIL;
|
|
|
|
TEST_ESP_OK( touch_pad_proximity_get_count(TOUCH_PAD_MAX, &count) );
|
|
printf("Inactive: ");
|
|
while (1) {
|
|
if (pdTRUE == xQueueReceive(que_touch, &evt, exceed_time_ms / portTICK_PERIOD_MS)) {
|
|
if (evt.intr_mask & TOUCH_PAD_INTR_MASK_INACTIVE) {
|
|
printf("0x%x, ", evt.pad_status);
|
|
if ((TEST_TOUCH_CHANNEL - test_ch_num) == __builtin_popcount(evt.pad_status)) {
|
|
ret = ESP_OK;
|
|
break;
|
|
}
|
|
} else if (evt.intr_mask & (TOUCH_PAD_INTR_MASK_SCAN_DONE)) {
|
|
touch_pad_get_channel_mask(&ch_mask);
|
|
for (int i = TOUCH_PAD_MAX - 1; i >= 0; i--) {
|
|
if (BIT(i) & ch_mask) {
|
|
if (evt.pad_num == i) {
|
|
if (count == evt.slp_proxi_cnt) {
|
|
ets_printf("priximity base(%d) cnt(%d)\n", evt.slp_proxi_base, evt.slp_proxi_cnt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
} else { // If the interrupt type error, test error.
|
|
ESP_LOGI(TAG, "Touch[%d] intr error, status %d, evt_msk0x%x", evt.pad_num, evt.pad_status, evt.intr_mask);
|
|
continue;;
|
|
}
|
|
} else {
|
|
ESP_LOGI(TAG, "Touch intr exceed time");
|
|
break;
|
|
}
|
|
}
|
|
printf("\n");
|
|
return (esp_err_t)ret;
|
|
}
|
|
|
|
/*
|
|
* Check scan done interrupt of touch channels.
|
|
*/
|
|
static esp_err_t test_touch_check_ch_intr_scan_done(void)
|
|
{
|
|
touch_event_t evt = {0};
|
|
uint16_t ch_mask = 0;
|
|
esp_err_t ret = ESP_FAIL;
|
|
/* Check the scan done interrupt. */
|
|
while (1) {
|
|
if (pdTRUE == xQueueReceive(que_touch, &evt, 1000 / portTICK_PERIOD_MS)) {
|
|
/* Scan done interrupt have bug that be trigger by last two channel. */
|
|
if (evt.intr_mask & TOUCH_PAD_INTR_MASK_SCAN_DONE) {
|
|
touch_pad_get_channel_mask(&ch_mask);
|
|
for (int i = TOUCH_PAD_MAX - 1; i >= 0; i--) {
|
|
if (BIT(i) & ch_mask) {
|
|
if (evt.pad_num == i) {
|
|
ESP_LOGI(TAG, "touch _SCAN_DONE INTR be triggered");
|
|
ret = ESP_OK;
|
|
}
|
|
goto NEXT_TEST;
|
|
}
|
|
}
|
|
} else if (evt.intr_mask & (TOUCH_PAD_INTR_MASK_DONE | TOUCH_PAD_INTR_MASK_SCAN_DONE)) {
|
|
continue;
|
|
} else { // If the interrupt type error, test error.
|
|
ESP_LOGI(TAG, "Touch[%d] intr error, status %d, evt_msk0x%x", evt.pad_num, evt.pad_status, evt.intr_mask);
|
|
break;
|
|
}
|
|
} else {
|
|
ESP_LOGI(TAG, "Touch intr exceed time");
|
|
break;
|
|
}
|
|
}
|
|
NEXT_TEST:
|
|
printf("\n");
|
|
return (esp_err_t)ret;
|
|
}
|
|
|
|
/*
|
|
* Check timeout interrupt of touch channels.
|
|
*/
|
|
static esp_err_t test_touch_check_ch_intr_timeout(touch_pad_t pad_num)
|
|
{
|
|
esp_err_t ret = ESP_FAIL;
|
|
touch_event_t evt = {0};
|
|
|
|
while (1) {
|
|
if (pdTRUE == xQueueReceive(que_touch, &evt, 1000 / portTICK_PERIOD_MS)) {
|
|
/* Scan done interrupt have bug that be trigger by last two channel. */
|
|
if (evt.intr_mask & TOUCH_PAD_INTR_MASK_TIMEOUT) {
|
|
if (pad_num == evt.pad_num) {
|
|
ESP_LOGI(TAG, "touch TIMEOUT be triggered");
|
|
s_touch_timeout_mask = 0;
|
|
ret = ESP_OK;
|
|
touch_pad_timeout_resume();
|
|
break;
|
|
} else {
|
|
ets_printf("-timeout %x T[%d] status %d, evt_msk %x -\n",
|
|
s_touch_timeout_mask, evt.pad_num, evt.pad_status, evt.intr_mask);
|
|
touch_pad_timeout_resume();
|
|
}
|
|
} else {
|
|
continue;
|
|
}
|
|
} else {
|
|
ESP_LOGI(TAG, "Touch intr exceed time");
|
|
break;
|
|
}
|
|
}
|
|
printf("\n");
|
|
return (esp_err_t)ret;
|
|
}
|
|
|
|
static void test_touch_intr_cb(void *arg)
|
|
{
|
|
uint32_t cnt, touch_value;
|
|
int task_awoken = pdFALSE;
|
|
touch_event_t evt;
|
|
evt.intr_mask = touch_pad_read_intr_status_mask();
|
|
evt.pad_status = touch_pad_get_status();
|
|
evt.pad_num = touch_pad_get_current_meas_channel();
|
|
|
|
if (!evt.intr_mask) {
|
|
ets_printf(".");
|
|
return;
|
|
}
|
|
if (evt.intr_mask & TOUCH_PAD_INTR_MASK_SCAN_DONE) {
|
|
touch_pad_filter_read_baseline(evt.pad_num, &evt.pad_val);
|
|
touch_pad_sleep_channel_t slp_config;
|
|
touch_pad_sleep_channel_get_info(&slp_config);
|
|
touch_pad_sleep_channel_read_baseline(slp_config.touch_num, &touch_value);
|
|
touch_pad_sleep_channel_read_proximity_cnt(slp_config.touch_num, &cnt);
|
|
evt.slp_proxi_cnt = cnt;
|
|
evt.slp_proxi_base = touch_value;
|
|
// ets_printf("[intr] base(%d) cnt(%d)\n", touch_value, cnt);
|
|
}
|
|
if (evt.intr_mask & TOUCH_PAD_INTR_MASK_TIMEOUT) {
|
|
s_touch_timeout_mask |= (BIT(evt.pad_num));
|
|
ets_printf("-%dtout-", SENS.sar_touch_status0.touch_scan_curr);
|
|
}
|
|
|
|
xQueueSendFromISR(que_touch, &evt, &task_awoken);
|
|
if (task_awoken == pdTRUE) {
|
|
portYIELD_FROM_ISR();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test the touch active/inactive interrupt.
|
|
* TEST POINT:
|
|
* 1. Touch interrupt.
|
|
* 2. Raw data noise.
|
|
* 3. smooth data and baseline data.
|
|
*/
|
|
esp_err_t test_touch_interrupt(void)
|
|
{
|
|
uint32_t touch_value, smooth;
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL);
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_16, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_IIR_2,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
// Initialize and start a software filter to detect slight change of capacitance.
|
|
vTaskDelay(50 / portTICK_PERIOD_MS);
|
|
|
|
/* Set threshold of touch sensor */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_filter_read_smooth(touch_list[i], &smooth) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "test init: touch pad [%d] base %d, smooth %d, thresh %d",
|
|
touch_list[i], touch_value, smooth, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
|
|
while (test_cnt--) {
|
|
test_touch_push_all();
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("push");
|
|
|
|
/* Test: if the raw data exceed noise threshold, the baseline should not be updated. */
|
|
test_touch_baseline_not_update();
|
|
|
|
test_touch_release_all();
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("release");
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
/*
|
|
* Test the touch active/inactive, scan_done interrupt.
|
|
* TEST POINT:
|
|
* 1. Touch interrupt.
|
|
* 2. Raw data noise.
|
|
* 3. smooth data and baseline data.
|
|
*/
|
|
esp_err_t test_touch_scan_done_interrupt(void)
|
|
{
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
uint32_t touch_value, smooth;
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
TEST_ESP_OK( touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL) );
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_16, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_IIR_2,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_SCAN_DONE | TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
/* Check the scan done interrupt */
|
|
TEST_ESP_OK( test_touch_check_ch_intr_scan_done() );
|
|
|
|
vTaskDelay(50 / portTICK_PERIOD_MS);
|
|
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_filter_read_smooth(touch_list[i], &smooth) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "test init: touch pad [%d] base %d, smooth %d, thresh %d", \
|
|
touch_list[i], touch_value, smooth, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
|
|
while (test_cnt--) {
|
|
test_touch_push_all();
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("push");
|
|
|
|
/* Test: if the raw data exceed noise threshold, the baseline should not be updated. */
|
|
test_touch_baseline_not_update();
|
|
|
|
test_touch_release_all();
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("release");
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
/*
|
|
* Test the touch active/inactive, timeout interrupt.
|
|
* TEST POINT:
|
|
* 1. Touch interrupt.
|
|
* 2. Raw data noise.
|
|
* 3. smooth data and baseline data.
|
|
*/
|
|
esp_err_t test_touch_timeout_interrupt(void)
|
|
{
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
uint32_t touch_value, smooth;
|
|
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
TEST_ESP_OK( touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL) );
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_16, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_IIR_2,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_TIMEOUT | TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
// Initialize and start a software filter to detect slight change of capacitance.
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_filter_read_smooth(touch_list[i], &smooth) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "test init: touch pad [%d] base %d, smooth %d, thresh %d",
|
|
touch_list[i], touch_value, smooth, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
/* Set timeout parameter */
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[0], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_timeout_set(true , touch_value * 10) );
|
|
|
|
// Only fake push one touch pad.
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
test_timeout_trigger_fake(touch_list[0]);
|
|
TEST_ESP_OK( test_touch_check_ch_intr_timeout(touch_list[0]) );
|
|
test_timeout_normal(touch_list[0]);
|
|
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
printf_touch_hw_read("raw ");
|
|
printf_touch_baseline_read("base ");
|
|
printf_touch_smooth_read("smooth");
|
|
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
while (test_cnt--) {
|
|
test_touch_push_all();
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("push");
|
|
|
|
/* Test: if the raw data exceed noise threshold, the baseline should not be updated. */
|
|
test_touch_baseline_not_update();
|
|
|
|
test_touch_release_all();
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("release");
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
TEST_CASE("Touch Sensor interrupt test (active, inactive, scan_done, timeout)", "[touch]")
|
|
{
|
|
TEST_ESP_OK( test_touch_interrupt() );
|
|
TEST_ESP_OK( test_touch_scan_done_interrupt() );
|
|
TEST_ESP_OK( test_touch_timeout_interrupt() );
|
|
}
|
|
|
|
static void test_touch_measure_step(uint32_t step)
|
|
{
|
|
/* Fake the process of debounce. */
|
|
// printf("measure cnt %d: [ ", step);
|
|
for (int i = 0; i < step; i++) {
|
|
for (int j = 0; j < TEST_TOUCH_CHANNEL; j++) {
|
|
TEST_ESP_OK( touch_pad_sw_start() );
|
|
while (!touch_pad_meas_is_done()) ;
|
|
}
|
|
// printf(".");
|
|
}
|
|
// printf(" ]\n");
|
|
}
|
|
|
|
/*
|
|
* Test the touch active/inactive, scan_done interrupt.
|
|
* TEST POINT:
|
|
* 1. Touch interrupt.
|
|
* 2. Raw data noise.
|
|
* 3. smooth data and baseline data.
|
|
*/
|
|
esp_err_t test_touch_filter_parameter_debounce(int deb_cnt)
|
|
{
|
|
uint32_t touch_value;
|
|
int test_cnt = 2;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
TEST_ESP_OK( touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL) );
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_128, // Test jitter and filter 1/4.
|
|
.debounce_cnt = ((deb_cnt < 0) ? 1 : deb_cnt) , // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_OFF,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_SW) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
/* Run to wait the data become stable. */
|
|
test_touch_measure_step(20); // 2 scan loop
|
|
|
|
/* Set the threshold. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "test init: touch pad [%d] base %d, thresh %d", \
|
|
touch_list[i], touch_value, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
|
|
while (test_cnt--) {
|
|
test_touch_push_all();
|
|
/* Fake the process of push debounce. */
|
|
test_touch_measure_step(deb_cnt); // measure n times. touch state not changed.
|
|
TEST_ESP_ERR( ESP_FAIL, test_touch_check_ch_touched(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
test_touch_measure_step(1); // measure n+1 times. touch state changed.
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("push");
|
|
|
|
test_touch_release_all();
|
|
/* Fake the process of release debounce. */
|
|
test_touch_measure_step(deb_cnt); // measure n times. touch state not changed.
|
|
TEST_ESP_ERR( ESP_FAIL, test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
test_touch_measure_step(1); // measure n+1 times. touch state changed.
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("release");
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t test_touch_filter_parameter_neg_reset(int reset_cnt)
|
|
{
|
|
uint32_t touch_value, base_value;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
TEST_ESP_OK( touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL) );
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
reset_cnt = ((reset_cnt < 0) ? 10 : reset_cnt);
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_16, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = reset_cnt, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_OFF,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_SW) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
/* Run to wait the data become stable. */
|
|
test_touch_measure_step(20); // 2 scan loop
|
|
|
|
/* Set the threshold. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "test init: touch pad [%d] base %d, thresh %d", \
|
|
touch_list[i], touch_value, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
|
|
/* 1. Fake init status is touched. */
|
|
test_touch_push_all();
|
|
TEST_ESP_OK( touch_pad_filter_reset_baseline(TOUCH_PAD_MAX) );
|
|
/* Run to wait the data become stable. */
|
|
test_touch_measure_step(20); // 2 scan loop
|
|
printf_touch_hw_read("[raw ] reset:");
|
|
printf_touch_baseline_read("[base] reset:");
|
|
|
|
/* 2. Fake the touch status is released. */
|
|
test_touch_release_all();
|
|
/* 3. Fake measure `reset_cnt + 1` times to reset the baseline. */
|
|
test_touch_measure_step(reset_cnt);
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_read_raw_data(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &base_value) );
|
|
if ((base_value - touch_value) < (base_value * TOUCH_INTR_THRESHOLD)) {
|
|
ESP_LOGE(TAG, "neg reset cnt err");
|
|
TEST_FAIL();
|
|
}
|
|
}
|
|
printf_touch_hw_read("[raw ] neg_cnt:");
|
|
printf_touch_baseline_read("[base] neg_cnt:");
|
|
|
|
test_touch_measure_step(1);
|
|
/* ESP32S2 neg reset baseline to raw data */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_read_raw_data(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &base_value) );
|
|
TEST_ASSERT_EQUAL_UINT32(base_value, touch_value);
|
|
}
|
|
printf_touch_hw_read("[raw ] neg_cnt+1:");
|
|
printf_touch_baseline_read("[base] neg_cnt+1:");
|
|
|
|
int test_cnt = 2;
|
|
while (test_cnt--) {
|
|
test_touch_push_all();
|
|
/* Fake the process of push debounce. */
|
|
test_touch_measure_step(filter_info.debounce_cnt + 1);
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("push");
|
|
|
|
test_touch_release_all();
|
|
/* Fake the process of release debounce. */
|
|
test_touch_measure_step(filter_info.debounce_cnt + 1);
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("release");
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t test_touch_filter_parameter_jitter(int jitter_step)
|
|
{
|
|
uint32_t touch_value, base_value = 0;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
TEST_ESP_OK( touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL) );
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
jitter_step = ((jitter_step < 0) ? 4 : jitter_step);
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_JITTER, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = jitter_step, // use for jitter mode.
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_SW) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
/* Run to wait the data become stable. */
|
|
test_touch_measure_step(20); // 2 scan loop
|
|
|
|
/* Check the jitter step. */
|
|
printf_touch_baseline_read("[smooth] t1:");
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
test_touch_measure_step(1);
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
test_press_fake(touch_list[i]);
|
|
test_touch_measure_step(1);
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &base_value) );
|
|
TEST_ASSERT_EQUAL_UINT32(jitter_step, (base_value - touch_value));
|
|
}
|
|
printf_touch_baseline_read("[smooth] t2:");
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
test_touch_measure_step(1);
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
test_release_fake(touch_list[i]);
|
|
test_touch_measure_step(1);
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &base_value) );
|
|
TEST_ASSERT_EQUAL_UINT32(jitter_step, (touch_value - base_value));
|
|
}
|
|
printf_touch_baseline_read("[smooth] t3:");
|
|
|
|
/* Set the threshold. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
//read baseline value
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
//set interrupt threshold.
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "test init: touch pad [%d] base %d, thresh %d", \
|
|
touch_list[i], touch_value, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
|
|
int test_cnt = 2;
|
|
while (test_cnt--) {
|
|
test_touch_push_all();
|
|
/* Fake the process of push debounce. */
|
|
test_touch_measure_step(filter_info.debounce_cnt + 1);
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_smooth_read("push");
|
|
|
|
test_touch_release_all();
|
|
/* Fake the process of release debounce. */
|
|
test_touch_measure_step(filter_info.debounce_cnt + 1);
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_smooth_read("release");
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
TEST_CASE("Touch Sensor filter paramter test (debounce, neg_reset, jitter)", "[touch]")
|
|
{
|
|
ESP_LOGI(TAG, "*********** touch filter debounce test ********************");
|
|
TEST_ESP_OK( test_touch_filter_parameter_debounce(0) );
|
|
TEST_ESP_OK( test_touch_filter_parameter_debounce(3) );
|
|
TEST_ESP_OK( test_touch_filter_parameter_debounce(7) );
|
|
|
|
ESP_LOGI(TAG, "*********** touch filter neg threshold reset limit test ********************");
|
|
TEST_ESP_OK( test_touch_filter_parameter_neg_reset(1) );
|
|
TEST_ESP_OK( test_touch_filter_parameter_neg_reset(5) );
|
|
TEST_ESP_OK( test_touch_filter_parameter_neg_reset(15) );
|
|
|
|
ESP_LOGI(TAG, "*********** touch filter jitter test ********************");
|
|
TEST_ESP_OK( test_touch_filter_parameter_jitter(1) );
|
|
TEST_ESP_OK( test_touch_filter_parameter_jitter(5) );
|
|
TEST_ESP_OK( test_touch_filter_parameter_jitter(15) );
|
|
}
|
|
|
|
esp_err_t test_touch_denoise(uint32_t out_val[], uint32_t *denoise_val, touch_pad_denoise_grade_t grade, touch_pad_denoise_cap_t cap)
|
|
{
|
|
uint32_t touch_value;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
ESP_LOGI(TAG, "Denoise level (%d), cap level (%d) \n", grade, cap);
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
TEST_ESP_OK( touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL) );
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
/* Denoise setting at TouchSensor 0. */
|
|
touch_pad_denoise_t denoise = {
|
|
/* The bits to be cancelled are determined according to the noise level. */
|
|
.grade = (grade < 0) ? TOUCH_PAD_DENOISE_BIT4 : grade,
|
|
.cap_level = (cap < 0) ? TOUCH_PAD_DENOISE_CAP_L4 : cap,
|
|
};
|
|
TEST_ESP_OK( touch_pad_denoise_set_config(&denoise) );
|
|
TEST_ESP_OK( touch_pad_denoise_enable() );
|
|
ESP_LOGI(TAG, "Denoise function init");
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_16, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_SW) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
/* Run to wait the data become stable. */
|
|
test_touch_measure_step(20); // 2 scan loop
|
|
|
|
/* Set the threshold. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
if (out_val) {
|
|
/* Output value for check. */
|
|
out_val[i] = touch_value;
|
|
}
|
|
}
|
|
printf_touch_baseline_read("Denoise");
|
|
if (denoise_val) {
|
|
touch_pad_denoise_read_data(denoise_val);
|
|
}
|
|
|
|
int test_cnt = 1;
|
|
while (test_cnt--) {
|
|
test_touch_push_all();
|
|
/* Fake the process of push debounce. */
|
|
test_touch_measure_step(filter_info.debounce_cnt + 1);
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
|
|
test_touch_release_all();
|
|
/* Fake the process of release debounce. */
|
|
test_touch_measure_step(filter_info.debounce_cnt + 1);
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
TEST_CASE("Touch Sensor denoise test (cap, level)", "[touch]")
|
|
{
|
|
uint32_t val_1[TEST_TOUCH_CHANNEL];
|
|
uint32_t val_2[TEST_TOUCH_CHANNEL];
|
|
uint32_t val_3[TEST_TOUCH_CHANNEL];
|
|
uint32_t denoise_val[TOUCH_PAD_DENOISE_CAP_MAX];
|
|
|
|
ESP_LOGI(TAG, "*********** touch filter denoise level test ********************");
|
|
TEST_ESP_OK( test_touch_denoise(val_1, &denoise_val[0], TOUCH_PAD_DENOISE_BIT4, TOUCH_PAD_DENOISE_CAP_L0) );
|
|
TEST_ESP_OK( test_touch_denoise(val_2, NULL, TOUCH_PAD_DENOISE_BIT8, TOUCH_PAD_DENOISE_CAP_L0) );
|
|
TEST_ESP_OK( test_touch_denoise(val_3, NULL, TOUCH_PAD_DENOISE_BIT12, TOUCH_PAD_DENOISE_CAP_L0) );
|
|
|
|
if ((denoise_val[0] & 0xFF) < (0xFF - 10) && (denoise_val[0] & 0xFF) > 10) {
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ASSERT_GREATER_OR_EQUAL(val_3[i], val_2[i]);
|
|
TEST_ASSERT_GREATER_OR_EQUAL(val_2[i], val_1[i]);
|
|
}
|
|
} else {
|
|
/* If the value of (denoise_val[0] & 0xFF) is approximately 0,
|
|
The difference between touch reading is very small. Should skip value test. */
|
|
ESP_LOGI(TAG, "denoise value is %d", denoise_val[0]);
|
|
}
|
|
|
|
ESP_LOGI(TAG, "*********** touch filter denoise cap level test ********************");
|
|
TEST_ESP_OK( test_touch_denoise(NULL, &denoise_val[0], TOUCH_PAD_DENOISE_BIT8, TOUCH_PAD_DENOISE_CAP_L0) );
|
|
TEST_ESP_OK( test_touch_denoise(NULL, &denoise_val[1], TOUCH_PAD_DENOISE_BIT8, TOUCH_PAD_DENOISE_CAP_L1) );
|
|
TEST_ESP_OK( test_touch_denoise(NULL, &denoise_val[2], TOUCH_PAD_DENOISE_BIT8, TOUCH_PAD_DENOISE_CAP_L2) );
|
|
TEST_ESP_OK( test_touch_denoise(NULL, &denoise_val[3], TOUCH_PAD_DENOISE_BIT8, TOUCH_PAD_DENOISE_CAP_L3) );
|
|
TEST_ESP_OK( test_touch_denoise(NULL, &denoise_val[4], TOUCH_PAD_DENOISE_BIT8, TOUCH_PAD_DENOISE_CAP_L4) );
|
|
TEST_ESP_OK( test_touch_denoise(NULL, &denoise_val[5], TOUCH_PAD_DENOISE_BIT8, TOUCH_PAD_DENOISE_CAP_L5) );
|
|
TEST_ESP_OK( test_touch_denoise(NULL, &denoise_val[6], TOUCH_PAD_DENOISE_BIT8, TOUCH_PAD_DENOISE_CAP_L6) );
|
|
TEST_ESP_OK( test_touch_denoise(NULL, &denoise_val[7], TOUCH_PAD_DENOISE_BIT8, TOUCH_PAD_DENOISE_CAP_L7) );
|
|
|
|
printf("denoise read: ");
|
|
for (int i = 0; i < TOUCH_PAD_DENOISE_CAP_MAX - 1; i++) {
|
|
TEST_ASSERT_GREATER_OR_EQUAL(denoise_val[i], denoise_val[i + 1]);
|
|
printf("%d ", denoise_val[i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
esp_err_t test_touch_waterproof(void)
|
|
{
|
|
uint32_t touch_value;
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL);
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
/* Denoise setting at TouchSensor 0. */
|
|
touch_pad_denoise_t denoise = {
|
|
/* The bits to be cancelled are determined according to the noise level. */
|
|
.grade = TOUCH_PAD_DENOISE_BIT4,
|
|
.cap_level = TOUCH_PAD_DENOISE_CAP_L4,
|
|
};
|
|
TEST_ESP_OK( touch_pad_denoise_set_config(&denoise) );
|
|
TEST_ESP_OK( touch_pad_denoise_enable() );
|
|
ESP_LOGI(TAG, "Denoise function init");
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_16, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
/* Waterproof function */
|
|
touch_pad_waterproof_t waterproof = {
|
|
.guard_ring_pad = TOUCH_WATERPROOF_RING_PAD, // If no ring pad, set 0;
|
|
/* It depends on the number of the parasitic capacitance of the shield pad. */
|
|
.shield_driver = TOUCH_PAD_SHIELD_DRV_L0, //40pf
|
|
};
|
|
TEST_ESP_OK( touch_pad_waterproof_set_config(&waterproof) );
|
|
TEST_ESP_OK( touch_pad_waterproof_enable() );
|
|
ESP_LOGI(TAG, "touch pad waterproof init");
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
vTaskDelay(50 / portTICK_PERIOD_MS);
|
|
|
|
/* Set the threshold. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
}
|
|
|
|
while (test_cnt--) {
|
|
test_touch_push_all();
|
|
vTaskDelay(20 / portTICK_PERIOD_MS);
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL - 1, TOUCH_EXCEED_TIME_MS) ); // take off shield pad
|
|
printf_touch_hw_read("push");
|
|
|
|
test_touch_release_all();
|
|
vTaskDelay(20 / portTICK_PERIOD_MS);
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("release");
|
|
}
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
TEST_CASE("Touch Sensor waterproof guard test", "[touch]")
|
|
{
|
|
ESP_LOGI(TAG, "*********** touch filter waterproof guard test ********************");
|
|
TEST_ESP_OK( test_touch_waterproof() );
|
|
}
|
|
|
|
esp_err_t test_touch_proximity(int meas_num)
|
|
{
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
|
|
uint32_t touch_value;
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
TEST_ESP_OK( touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL) );
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
/* Denoise setting at TouchSensor 0. */
|
|
touch_pad_denoise_t denoise = {
|
|
/* The bits to be cancelled are determined according to the noise level. */
|
|
.grade = TOUCH_PAD_DENOISE_BIT4,
|
|
.cap_level = TOUCH_PAD_DENOISE_CAP_L4,
|
|
};
|
|
TEST_ESP_OK( touch_pad_denoise_set_config(&denoise) );
|
|
TEST_ESP_OK( touch_pad_denoise_enable() );
|
|
ESP_LOGI(TAG, "Denoise function init");
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_16, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
/* Waterproof function */
|
|
touch_pad_waterproof_t waterproof = {
|
|
.guard_ring_pad = TOUCH_WATERPROOF_RING_PAD,// If no ring pad, set 0;
|
|
/* It depends on the number of the parasitic capacitance of the shield pad. */
|
|
.shield_driver = TOUCH_PAD_SHIELD_DRV_L0, //40pf
|
|
};
|
|
TEST_ESP_OK( touch_pad_waterproof_set_config(&waterproof) );
|
|
TEST_ESP_OK( touch_pad_waterproof_enable() );
|
|
ESP_LOGI(TAG, "touch pad waterproof init");
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
vTaskDelay(50 / portTICK_PERIOD_MS);
|
|
|
|
/* Set the threshold. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
if (touch_list[i] == proximity_pad[0] ||
|
|
touch_list[i] == proximity_pad[1] ||
|
|
touch_list[i] == proximity_pad[2]) {
|
|
/* The threshold of proximity pad is the sum of touch reading `meas_num` times */
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i],
|
|
meas_num * touch_value * (1 + TOUCH_INTR_THRESHOLD)) );
|
|
ESP_LOGI(TAG, "proximity pad [%d] base %d, thresh %d", touch_list[i], touch_value,
|
|
(uint32_t)(meas_num * touch_value * (1 + TOUCH_INTR_THRESHOLD)));
|
|
} else {
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "touch pad [%d] base %d, thresh %d", \
|
|
touch_list[i], touch_value, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
}
|
|
/* Should stop the measure, then change the config. */
|
|
while (!touch_pad_meas_is_done());
|
|
TEST_ESP_OK( touch_pad_fsm_stop() );
|
|
/* Proximity function */
|
|
TEST_ESP_OK( touch_pad_proximity_enable(proximity_pad[0], true) );
|
|
TEST_ESP_OK( touch_pad_proximity_enable(proximity_pad[1], true) );
|
|
TEST_ESP_OK( touch_pad_proximity_enable(proximity_pad[2], true) );
|
|
TEST_ESP_OK( touch_pad_proximity_set_count(TOUCH_PAD_MAX, meas_num < 0 ? 16 : meas_num) );
|
|
ESP_LOGI(TAG, "touch pad proximity init");
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
vTaskDelay(20 / portTICK_PERIOD_MS);
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
while (test_cnt--) {
|
|
test_touch_push_all();
|
|
vTaskDelay(20 / portTICK_PERIOD_MS);
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL - 1, TOUCH_EXCEED_TIME_MS) ); // take off shield pad
|
|
printf_touch_hw_read("push");
|
|
|
|
test_touch_release_all();
|
|
vTaskDelay(20 / portTICK_PERIOD_MS);
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("release");
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
TEST_CASE("Touch Sensor proximity test", "[touch]")
|
|
{
|
|
ESP_LOGI(TAG, "*********** touch proximity test ********************");
|
|
|
|
TEST_ESP_OK( test_touch_proximity(5) );
|
|
TEST_ESP_OK( test_touch_proximity(1) );
|
|
}
|
|
|
|
esp_err_t test_touch_sleep_reading_stable(touch_pad_t sleep_pad)
|
|
{
|
|
uint32_t touch_temp = 0;
|
|
uint32_t touch_value, smooth, ret_val;
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
TEST_ESP_OK( touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL) );
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
// /* Denoise setting at TouchSensor 0. */
|
|
touch_pad_denoise_t denoise = {
|
|
/* The bits to be cancelled are determined according to the noise level. */
|
|
.grade = TOUCH_PAD_DENOISE_BIT4,
|
|
.cap_level = TOUCH_PAD_DENOISE_CAP_L4,
|
|
};
|
|
TEST_ESP_OK( touch_pad_denoise_set_config(&denoise) );
|
|
TEST_ESP_OK( touch_pad_denoise_enable() );
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_16, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_OFF,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_enable(sleep_pad, true) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_enable_proximity(sleep_pad, false) );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
// Initialize and start a software filter to detect slight change of capacitance.
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
|
|
/* Set threshold of touch sensor */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_filter_read_smooth(touch_list[i], &smooth) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "test init: touch pad [%d] base %d, smooth %d, thresh %d",
|
|
touch_list[i], touch_value, smooth, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
|
|
/* Sleep channel setting */
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_baseline(sleep_pad, &touch_value) );
|
|
TEST_ESP_OK( touch_pad_sleep_set_threshold(sleep_pad, touch_value * TOUCH_INTR_THRESHOLD) );
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
|
|
while (test_cnt--) {
|
|
/* Touch reading filtered value equal to raw data. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_data(sleep_pad, &touch_value) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_baseline(sleep_pad, &touch_temp) );
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp, touch_value);
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_smooth(sleep_pad, &touch_temp) );
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp, touch_value);
|
|
}
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
if (touch_temp) {
|
|
TEST_ASSERT_UINT32_WITHIN(TOUCH_READ_ERROR, touch_temp, touch_value);
|
|
}
|
|
touch_temp = touch_value;
|
|
}
|
|
vTaskDelay(20 / portTICK_PERIOD_MS);
|
|
}
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_baseline(sleep_pad, &ret_val) );
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
|
|
TEST_CASE("Touch Sensor sleep pad reading stable test", "[touch]")
|
|
{
|
|
ESP_LOGI(TAG, "*********** touch sleep pad low power (wakeup) test ********************");
|
|
test_touch_sleep_reading_stable(touch_list[0]);
|
|
}
|
|
|
|
/*
|
|
* Test the touch sleep pad interrupt in normal mode.
|
|
* TEST POINT:
|
|
* 1. Touch sleep pad interrupt.
|
|
* 2. sleep pad reading.
|
|
* 3. sleep pad enable proximity.
|
|
*/
|
|
uint32_t test_touch_sleep_pad_proximity(touch_pad_t sleep_pad, bool is_proximity, uint32_t meas_num)
|
|
{
|
|
uint32_t touch_value, smooth, ret_val;
|
|
uint32_t measure_out;
|
|
uint32_t proximity_cnt;
|
|
uint32_t touch_thres;
|
|
int test_cnt = TEST_TOUCH_COUNT_NUM;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
TEST_ESP_OK( touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL) );
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
/* Denoise setting at TouchSensor 0. */
|
|
touch_pad_denoise_t denoise = {
|
|
/* The bits to be cancelled are determined according to the noise level. */
|
|
.grade = TOUCH_PAD_DENOISE_BIT4,
|
|
.cap_level = TOUCH_PAD_DENOISE_CAP_L4,
|
|
};
|
|
TEST_ESP_OK( touch_pad_denoise_set_config(&denoise) );
|
|
TEST_ESP_OK( touch_pad_denoise_enable() );
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_16, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_OFF,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Sleep channel setting */
|
|
TEST_ESP_OK( touch_pad_sleep_channel_enable(sleep_pad, true) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_enable_proximity(sleep_pad, is_proximity) );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_SCAN_DONE | TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
// Initialize and start a software filter to detect slight change of capacitance.
|
|
vTaskDelay(100 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
|
|
if (is_proximity) {
|
|
/* Set the threshold. */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
if (touch_list[i] == sleep_pad) {
|
|
touch_pad_sleep_channel_read_smooth(sleep_pad, &touch_value);
|
|
touch_pad_sleep_set_threshold(sleep_pad, meas_num * touch_value * (1 + TOUCH_INTR_THRESHOLD));
|
|
ESP_LOGI(TAG, "Sleep pad [%d] base %d, thresh %d", touch_list[i], touch_value,
|
|
(uint32_t)(meas_num * touch_value * (1 + TOUCH_INTR_THRESHOLD)));
|
|
} else if (touch_list[i] == sleep_pad) {
|
|
// TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
touch_pad_sleep_channel_read_smooth(sleep_pad, &touch_value);
|
|
/* The threshold of proximity pad is the sum of touch reading `meas_num` times */
|
|
touch_pad_sleep_set_threshold(sleep_pad, meas_num * touch_value * (1 + TOUCH_INTR_THRESHOLD));
|
|
ESP_LOGI(TAG, "proximity pad [%d] base %d, thresh %d", touch_list[i], touch_value,
|
|
(uint32_t)(meas_num * touch_value * (1 + TOUCH_INTR_THRESHOLD)));
|
|
} else {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "touch pad [%d] base %d, thresh %d", \
|
|
touch_list[i], touch_value, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
}
|
|
/* Should stop the measure, then change the config. */
|
|
while (!touch_pad_meas_is_done());
|
|
TEST_ESP_OK( touch_pad_fsm_stop() );
|
|
/* Proximity function */
|
|
TEST_ESP_OK( touch_pad_proximity_enable(proximity_pad[0], false) );
|
|
TEST_ESP_OK( touch_pad_proximity_enable(proximity_pad[1], false) );
|
|
TEST_ESP_OK( touch_pad_proximity_enable(proximity_pad[2], false) );
|
|
TEST_ESP_OK( touch_pad_proximity_enable(sleep_pad, true) );
|
|
TEST_ESP_OK( touch_pad_proximity_set_count(TOUCH_PAD_MAX, meas_num) );
|
|
ESP_LOGI(TAG, "touch pad proximity init");
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
vTaskDelay(100 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
} else {
|
|
/* Set threshold of touch sensor */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_filter_read_smooth(touch_list[i], &smooth) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "test init: touch pad [%d] base %d, smooth %d, thresh %d",
|
|
touch_list[i], touch_value, smooth, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
/* Sleep channel setting */
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_smooth(sleep_pad, &touch_value) );
|
|
TEST_ESP_OK( touch_pad_sleep_set_threshold(sleep_pad, touch_value * TOUCH_INTR_THRESHOLD) );
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_smooth(sleep_pad, &ret_val) );
|
|
|
|
while (test_cnt--) {
|
|
test_touch_push_all();
|
|
TEST_ESP_OK( test_touch_check_ch_touched_with_proximity(TEST_TOUCH_CHANNEL, 5000) );
|
|
printf_touch_hw_read("push");
|
|
if (is_proximity) {
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_smooth(sleep_pad, &smooth) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_baseline(sleep_pad, &touch_value) );
|
|
TEST_ESP_OK( touch_pad_proximity_get_data(sleep_pad, &measure_out) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_proximity_cnt(sleep_pad, &proximity_cnt) );
|
|
TEST_ESP_OK( touch_pad_sleep_get_threshold(sleep_pad, &touch_thres) );
|
|
printf("touch slp smooth %d, base %d, proxi %d cnt %d thres%d status 0x%x\n",
|
|
smooth, touch_value, measure_out, proximity_cnt,
|
|
touch_thres, touch_pad_get_status());
|
|
}
|
|
test_touch_release_all();
|
|
TEST_ESP_OK( test_touch_check_ch_released_with_proximity(TEST_TOUCH_CHANNEL, 5000) );
|
|
printf_touch_hw_read("release");
|
|
if (is_proximity) {
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_smooth(sleep_pad, &smooth) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_baseline(sleep_pad, &touch_value) );
|
|
TEST_ESP_OK( touch_pad_proximity_get_data(sleep_pad, &measure_out) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_proximity_cnt(sleep_pad, &proximity_cnt) );
|
|
printf("touch slp smooth %d, base %d, proxi %d cnt %d status 0x%x\n",
|
|
smooth, touch_value, measure_out, proximity_cnt, touch_pad_get_status());
|
|
}
|
|
}
|
|
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
TEST_CASE("Touch Sensor sleep pad and proximity interrupt test", "[touch]")
|
|
{
|
|
ESP_LOGI(TAG, "*********** touch sleep pad interrupt test ********************");
|
|
test_touch_sleep_pad_proximity(touch_list[0], false, 0);
|
|
test_touch_sleep_pad_proximity(touch_list[0], false, 0);
|
|
test_touch_sleep_pad_proximity(touch_list[0], false, 0);
|
|
|
|
ESP_LOGI(TAG, "*********** touch sleep pad interrupt (proximity) test ********************");
|
|
test_touch_sleep_pad_proximity(touch_list[0], true, 1);
|
|
test_touch_sleep_pad_proximity(touch_list[0], true, 3);
|
|
test_touch_sleep_pad_proximity(touch_list[0], true, 5);
|
|
}
|
|
|
|
/*
|
|
* Test the touch sleep pad interrupt in normal mode.
|
|
* TEST POINT:
|
|
* 1. Touch sleep pad interrupt.
|
|
* 2. sleep pad reading.
|
|
* 3. denoise, waterproof
|
|
*/
|
|
esp_err_t test_touch_sleep_pad_interrupt_wakeup_deep_sleep(touch_pad_t sleep_pad)
|
|
{
|
|
uint32_t touch_value, smooth, raw;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
TEST_ESP_OK( touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL) );
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
// /* Denoise setting at TouchSensor 0. */
|
|
touch_pad_denoise_t denoise = {
|
|
/* The bits to be cancelled are determined according to the noise level. */
|
|
.grade = TOUCH_PAD_DENOISE_BIT4,
|
|
.cap_level = TOUCH_PAD_DENOISE_CAP_L4,
|
|
};
|
|
TEST_ESP_OK( touch_pad_denoise_set_config(&denoise) );
|
|
TEST_ESP_OK( touch_pad_denoise_disable() );
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_16, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 3, // 0%
|
|
.noise_thr = 0, // 50%
|
|
.noise_neg_thr = 0, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_OFF,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Sleep channel setting */
|
|
TEST_ESP_OK( touch_pad_sleep_channel_enable(sleep_pad, true) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_enable_proximity(sleep_pad, false) );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
|
|
// Initialize and start a software filter to detect slight change of capacitance.
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
|
|
/* Set threshold of touch sensor */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_filter_read_smooth(touch_list[i], &smooth) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_INTR_THRESHOLD) );
|
|
ESP_LOGI(TAG, "test init: touch pad [%d] base %d, smooth %d, thresh %d",
|
|
touch_list[i], touch_value, smooth, (uint32_t)(touch_value * TOUCH_INTR_THRESHOLD));
|
|
}
|
|
|
|
/* Sleep channel setting */
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_baseline(sleep_pad, &touch_value) );
|
|
TEST_ESP_OK( touch_pad_sleep_set_threshold(sleep_pad, touch_value * TOUCH_INTR_THRESHOLD) );
|
|
|
|
vTaskDelay(50 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
|
|
test_touch_push_all();
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("push");
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_smooth(sleep_pad, &smooth) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_data(sleep_pad, &raw) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_baseline(sleep_pad, &touch_value) );
|
|
printf("touch slp raw %d, smooth %d, base %d, status 0x%x\n", raw, smooth, touch_value, touch_pad_get_status());
|
|
|
|
test_touch_release_all();
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("release");
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_smooth(sleep_pad, &smooth) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_data(sleep_pad, &raw) );
|
|
TEST_ESP_OK( touch_pad_sleep_channel_read_baseline(sleep_pad, &touch_value) );
|
|
printf("touch slp raw %d, smooth %d, base %d, status 0x%x\n", raw, smooth, touch_value, touch_pad_get_status());
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
#include <sys/time.h>
|
|
#include "esp_sleep.h"
|
|
|
|
static RTC_DATA_ATTR struct timeval sleep_enter_time;
|
|
|
|
static void test_deep_sleep_init(void)
|
|
{
|
|
struct timeval now;
|
|
gettimeofday(&now, NULL);
|
|
int sleep_time_ms = (now.tv_sec - sleep_enter_time.tv_sec) * 1000 + (now.tv_usec - sleep_enter_time.tv_usec) / 1000;
|
|
printf("RTC_CNTL_SLP_WAKEUP_CAUSE_REG %x\n", REG_READ(RTC_CNTL_SLP_WAKEUP_CAUSE_REG));
|
|
switch (esp_sleep_get_wakeup_cause()) {
|
|
case ESP_SLEEP_WAKEUP_EXT1: {
|
|
uint64_t wakeup_pin_mask = esp_sleep_get_ext1_wakeup_status();
|
|
if (wakeup_pin_mask != 0) {
|
|
int pin = __builtin_ffsll(wakeup_pin_mask) - 1;
|
|
printf("Wake up from GPIO %d\n", pin);
|
|
} else {
|
|
printf("Wake up from GPIO\n");
|
|
}
|
|
break;
|
|
}
|
|
case ESP_SLEEP_WAKEUP_TIMER: {
|
|
printf("Wake up from timer. Time spent in deep sleep: %dms\n", sleep_time_ms);
|
|
break;
|
|
}
|
|
case ESP_SLEEP_WAKEUP_TOUCHPAD: {
|
|
printf("Wake up from touch on pad %d\n", esp_sleep_get_touchpad_wakeup_status());
|
|
break;
|
|
}
|
|
case ESP_SLEEP_WAKEUP_UNDEFINED:
|
|
default: {
|
|
printf("Not a deep sleep reset\n");
|
|
ESP_LOGI(TAG, "*********** touch sleep pad wakeup test ********************");
|
|
/* Sleep pad should be init once. */
|
|
test_touch_sleep_pad_interrupt_wakeup_deep_sleep(touch_list[0]);
|
|
}
|
|
}
|
|
|
|
vTaskDelay(100 * SYS_DELAY_TIME_MOM / portTICK_PERIOD_MS);
|
|
|
|
printf("Enabling touch pad wakeup\n");
|
|
esp_sleep_enable_touchpad_wakeup();
|
|
|
|
printf("Entering deep sleep\n");
|
|
gettimeofday(&sleep_enter_time, NULL);
|
|
}
|
|
|
|
TEST_CASE("Touch Sensor sleep pad wakeup deep sleep test", "[touch][ignore]")
|
|
{
|
|
test_deep_sleep_init();
|
|
|
|
/* Change the work duty of touch sensor to reduce current. */
|
|
touch_pad_set_meas_time(100, TOUCH_PAD_MEASURE_CYCLE_DEFAULT);
|
|
|
|
/* Close PD current in deep sleep. */
|
|
RTCCNTL.bias_conf.pd_cur_deep_slp = 1;
|
|
RTCCNTL.bias_conf.pd_cur_monitor = 1;
|
|
RTCCNTL.bias_conf.bias_sleep_deep_slp = 1;
|
|
RTCCNTL.bias_conf.bias_sleep_monitor = 1;
|
|
|
|
esp_deep_sleep_start();
|
|
}
|
|
|
|
#include "touch_scope.h"
|
|
/*
|
|
* 0: 10 channels raw/smooth/baseline data debug.
|
|
* 1: 5 channges smooth + baseline data debug.
|
|
* 2: 1 channels filter data.
|
|
*/
|
|
#define SCOPE_DEBUG_TYPE 2
|
|
#define TOUCH_THRESHOLD 0.5
|
|
#define TOUCH_SHELD_PAD (1)
|
|
#define SCOPE_DEBUG_CHANNEL_MAX (10)
|
|
#define SCOPE_DEBUG_ENABLE (0)
|
|
#define SCOPE_UART_BUADRATE (256000)
|
|
#define SCOPE_DEBUG_FREQ_MS (50)
|
|
|
|
void test_touch_slope_debug(int pad_num)
|
|
{
|
|
touch_event_t evt;
|
|
uint32_t touch_value, smooth;
|
|
|
|
ESP_LOGI(TAG, " >> %s << \n", __func__);
|
|
if (que_touch == NULL) {
|
|
que_touch = xQueueCreate(TEST_TOUCH_CHANNEL, sizeof(touch_event_t));
|
|
/* Should register once. */
|
|
touch_pad_isr_register(test_touch_intr_cb, NULL, TOUCH_PAD_INTR_MASK_ALL);
|
|
} else {
|
|
xQueueReset(que_touch);
|
|
}
|
|
TEST_ESP_OK( touch_pad_init() );
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_config(touch_list[i]) );
|
|
}
|
|
touch_filter_config_t filter_info = {
|
|
.mode = TOUCH_PAD_FILTER_IIR_32, // Test jitter and filter 1/4.
|
|
.debounce_cnt = 1, // 1 time count.
|
|
.hysteresis_thr = 2, // 6.25%
|
|
.noise_thr = 3, // 50%
|
|
.noise_neg_thr = 3, // 50%
|
|
.neg_noise_limit = 10, // 10 time count.
|
|
.jitter_step = 4, // use for jitter mode.
|
|
.smh_lvl = TOUCH_PAD_SMOOTH_IIR_2,
|
|
};
|
|
TEST_ESP_OK( touch_pad_filter_set_config(&filter_info) );
|
|
TEST_ESP_OK( touch_pad_filter_enable() );
|
|
/* Register touch interrupt ISR, enable intr type. */
|
|
TEST_ESP_OK( touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE) );
|
|
TEST_ESP_OK( touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER) );
|
|
TEST_ESP_OK( touch_pad_fsm_start() );
|
|
/* Waterproof function */
|
|
touch_pad_waterproof_t waterproof = {
|
|
.guard_ring_pad = 0, // If no ring pad, set 0;
|
|
/* It depends on the number of the parasitic capacitance of the shield pad. */
|
|
.shield_driver = TOUCH_PAD_SHIELD_DRV_L2, //40pf
|
|
};
|
|
TEST_ESP_OK( touch_pad_waterproof_set_config(&waterproof) );
|
|
TEST_ESP_OK( touch_pad_waterproof_enable() );
|
|
ESP_LOGI(TAG, "touch pad waterproof init");
|
|
|
|
// Initialize and start a software filter to detect slight change of capacitance.
|
|
vTaskDelay(50 / portTICK_PERIOD_MS);
|
|
|
|
/* Set threshold of touch sensor */
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
TEST_ESP_OK( touch_pad_filter_read_baseline(touch_list[i], &touch_value) );
|
|
TEST_ESP_OK( touch_pad_filter_read_smooth(touch_list[i], &smooth) );
|
|
TEST_ESP_OK( touch_pad_set_thresh(touch_list[i], touch_value * TOUCH_THRESHOLD) );
|
|
ESP_LOGI(TAG, "test init: touch pad [%d] base %d, smooth %d, thresh %d", \
|
|
touch_list[i], touch_value, smooth, (uint32_t)(touch_value * TOUCH_THRESHOLD));
|
|
}
|
|
|
|
float scope_temp[SCOPE_DEBUG_CHANNEL_MAX] = {0}; // max scope channel is 10.
|
|
uint32_t scope_data[SCOPE_DEBUG_CHANNEL_MAX] = {0}; // max scope channel is 10.
|
|
test_tp_scope_debug_init(0, -1, -1, SCOPE_UART_BUADRATE);
|
|
|
|
#if SCOPE_DEBUG_TYPE == 0
|
|
while (1) {
|
|
for (int i = 0; i < TEST_TOUCH_CHANNEL; i++) {
|
|
touch_pad_read_raw_data(touch_list[i], &scope_data[i]);
|
|
// touch_pad_filter_read_smooth(touch_list[i], &scope_data[i]);
|
|
// touch_pad_filter_read_baseline(touch_list[i], &scope_data[i]);
|
|
scope_temp[i] = scope_data[i];
|
|
}
|
|
test_tp_print_to_scope(scope_temp, TEST_TOUCH_CHANNEL);
|
|
vTaskDelay(SCOPE_DEBUG_FREQ_MS / portTICK_RATE_MS);
|
|
}
|
|
#elif SCOPE_DEBUG_TYPE == 1
|
|
while (1) {
|
|
int cnt = 0;
|
|
for (int i = 0; i < 5; i++) {
|
|
touch_pad_read_raw_data(touch_list[i], &scope_data[i]);
|
|
scope_temp[i] = scope_data[i];
|
|
}
|
|
for (int i = 0; i < 5; i++) {
|
|
touch_pad_filter_read_smooth(touch_list[i], &scope_data[i]);
|
|
scope_temp[i + SCOPE_DEBUG_CHANNEL_MAX / 2] = scope_data[i];
|
|
}
|
|
test_tp_print_to_scope(scope_temp, SCOPE_DEBUG_CHANNEL_MAX);
|
|
vTaskDelay(SCOPE_DEBUG_FREQ_MS / portTICK_RATE_MS);
|
|
}
|
|
#elif SCOPE_DEBUG_TYPE == 2
|
|
uint32_t status;
|
|
touch_pad_filter_read_baseline(pad_num, &status);
|
|
while (1) {
|
|
xQueueReceive(que_touch, &evt, SCOPE_DEBUG_FREQ_MS / portTICK_RATE_MS);
|
|
//read filtered value
|
|
touch_pad_read_raw_data(pad_num, &scope_data[0]);
|
|
touch_pad_filter_read_baseline(pad_num, &scope_data[1]);
|
|
touch_pad_get_thresh(pad_num, &scope_data[2]);
|
|
touch_pad_filter_read_smooth(pad_num, &scope_data[8]);
|
|
// raw data
|
|
scope_temp[0] = scope_data[0];
|
|
// baseline
|
|
scope_temp[1] = scope_data[1];
|
|
// smooth data
|
|
scope_temp[8] = scope_data[8];
|
|
// noise neg thr
|
|
scope_temp[2] = scope_temp[1] - scope_data[2] * 0.5;
|
|
// noise thr
|
|
scope_temp[3] = scope_temp[1] + scope_data[2] * 0.5;
|
|
// touch thr
|
|
scope_temp[4] = scope_temp[1] + scope_data[2];
|
|
// hysteresis_thr thr
|
|
scope_temp[5] = scope_temp[4] - scope_data[2] * 0.0625;
|
|
// hysteresis_thr thr
|
|
scope_temp[6] = scope_temp[4] + scope_data[2] * 0.0625;
|
|
// touch status
|
|
if (touch_pad_get_status() & BIT(pad_num)) {
|
|
scope_temp[7] = status + 100;
|
|
} else {
|
|
scope_temp[7] = status - 100; //0:release; 1:push;
|
|
}
|
|
test_tp_print_to_scope(scope_temp, 9);
|
|
}
|
|
#elif SCOPE_DEBUG_TYPE == 3
|
|
while (1) {
|
|
test_touch_push_all();
|
|
TEST_ESP_OK( test_touch_check_ch_touched(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("push");
|
|
|
|
/* Test: if the raw data exceed noise threshold, the baseline should not be updated. */
|
|
test_touch_baseline_not_update();
|
|
|
|
test_touch_release_all();
|
|
TEST_ESP_OK( test_touch_check_ch_released(TEST_TOUCH_CHANNEL, TOUCH_EXCEED_TIME_MS) );
|
|
printf_touch_hw_read("release");
|
|
}
|
|
#endif
|
|
TEST_ESP_OK( touch_pad_deinit() );
|
|
}
|
|
|
|
#endif // !DISABLED_FOR_TARGETS(ESP8266, ESP32)
|