kopia lustrzana https://github.com/espressif/esp-idf
1118 wiersze
44 KiB
C
1118 wiersze
44 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <inttypes.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/semphr.h"
|
|
#include "freertos/queue.h"
|
|
#include "esp_sleep.h"
|
|
#include "esp_timer.h"
|
|
#include "esp_check.h"
|
|
#include "hal/touch_sensor_hal.h" //TODO: remove hal
|
|
#include "touch_element/touch_element_private.h"
|
|
|
|
#include "esp_rom_sys.h"
|
|
|
|
|
|
#define TE_CLASS_ITEM(cls, cls_type, cls_item) ((&((cls)[cls_type]))->cls_item)
|
|
|
|
#define TE_CLASS_FOREACH(cls_var, cls_start, cls_end) \
|
|
for ((cls_var) = (cls_start); \
|
|
(cls_var) < (cls_end); \
|
|
(cls_var)++)
|
|
|
|
#define TE_CLS_METHODS_INITIALIZER(cls, cls_start, cls_end) do { \
|
|
typeof(cls_start) cls_method; \
|
|
TE_CLASS_FOREACH(cls_method, cls_start, cls_end) { \
|
|
TE_CLASS_ITEM(cls, cls_method, handle) = NULL; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define TE_CLASS_FOREACH_CHECK_CHANNEL(cls, cls_start, cls_end, channel) ({ \
|
|
bool ret = false; \
|
|
typeof(cls_start) cls_method; \
|
|
TE_CLASS_FOREACH(cls_method, cls_start, cls_end) { \
|
|
if (TE_CLASS_ITEM(cls, cls_method, handle) != NULL) { \
|
|
ret |= TE_CLASS_ITEM(cls, cls_method, check_channel(channel)); \
|
|
} \
|
|
} \
|
|
ret; \
|
|
})
|
|
|
|
#define TE_CLASS_FOREACH_SET_THRESHOLD(cls, cls_start, cls_end) do { \
|
|
typeof(cls_start) cls_method; \
|
|
TE_CLASS_FOREACH(cls_method, cls_start, cls_end) { \
|
|
if (TE_CLASS_ITEM(cls, cls_method, handle) != NULL) { \
|
|
TE_CLASS_ITEM(cls, cls_method, set_threshold()); \
|
|
} \
|
|
} \
|
|
} while (0)
|
|
|
|
#define TE_CLASS_FOREACH_PROCESS_STATE(cls, cls_start, cls_end) do { \
|
|
typeof(cls_start) cls_method; \
|
|
TE_CLASS_FOREACH(cls_method, cls_start, cls_end) { \
|
|
if (TE_CLASS_ITEM(cls, cls_method, handle) != NULL) { \
|
|
TE_CLASS_ITEM(cls, cls_method, process_state()); \
|
|
} \
|
|
} \
|
|
} while (0)
|
|
|
|
#define TE_CLASS_FOREACH_UPDATE_STATE(cls, cls_start, cls_end, channel, state) do {\
|
|
typeof(cls_start) cls_method; \
|
|
TE_CLASS_FOREACH(cls_method, cls_start, cls_end) { \
|
|
if (TE_CLASS_ITEM(cls, cls_method, handle) != NULL) { \
|
|
TE_CLASS_ITEM(cls, cls_method, update_state(channel, state)); \
|
|
} \
|
|
} \
|
|
} while (0)
|
|
|
|
#define TE_PROCESSING_PERIOD(obj) ((obj)->global_config->software.processing_period)
|
|
#define TE_WATERPROOF_DIVIDER(obj) ((obj)->global_config->software.waterproof_threshold_divider)
|
|
|
|
typedef enum {
|
|
TE_INTR_PRESS = 0, //Touch sensor press interrupt(TOUCH_PAD_INTR_MASK_ACTIVE)
|
|
TE_INTR_RELEASE, //Touch sensor release interrupt(TOUCH_PAD_INTR_MASK_INACTIVE)
|
|
TE_INTR_TIMEOUT, //Touch sensor scan timeout interrupt(TOUCH_PAD_INTR_MASK_TIMEOUT)
|
|
TE_INTR_SCAN_DONE, //Touch sensor scan done interrupt(TOUCH_PAD_INTR_MASK_SCAN_DONE), now just use for setting threshold
|
|
TE_INTR_MAX
|
|
} te_intr_t;
|
|
|
|
typedef struct {
|
|
te_intr_t intr_type; //channel interrupt type
|
|
te_state_t channel_state; //channel state
|
|
touch_pad_t channel_num; //channel index
|
|
} te_intr_msg_t;
|
|
|
|
typedef struct {
|
|
te_object_methods_t object_methods[TE_CLS_TYPE_MAX]; //Class(object) methods
|
|
touch_elem_global_config_t *global_config; //Global initialization
|
|
te_waterproof_handle_t waterproof_handle; //Waterproof configuration
|
|
te_sleep_handle_t sleep_handle;
|
|
esp_timer_handle_t proc_timer; //Processing timer handle
|
|
QueueHandle_t event_msg_queue; //Application event message queue (for user)
|
|
QueueHandle_t intr_msg_queue; //Interrupt message (for internal)
|
|
SemaphoreHandle_t mutex; //Global resource mutex
|
|
bool is_set_threshold; //Threshold configuration state bit
|
|
uint32_t denoise_channel_raw; //De-noise channel(TO) raw signal
|
|
} te_obj_t;
|
|
|
|
static te_obj_t *s_te_obj = NULL;
|
|
RTC_FAST_ATTR uint32_t threshold_shadow[TOUCH_PAD_MAX - 1] = {0};
|
|
|
|
/**
|
|
* Internal de-noise channel(Touch channel 0) equivalent capacitance table, depends on hardware design
|
|
*
|
|
* Units: pF
|
|
*/
|
|
static const float denoise_channel_equ_cap[TOUCH_PAD_DENOISE_CAP_MAX] = {5.0f, 6.4f, 7.8f, 9.2f, 10.6f, 12.0f, 13.4f, 14.8f};
|
|
|
|
/**
|
|
* Waterproof shield channel(Touch channel 14) equivalent capacitance table, depends on hardware design
|
|
*
|
|
* Units: pF
|
|
*/
|
|
static const float shield_channel_ref_cap[TOUCH_PAD_SHIELD_DRV_MAX] = {40.0f, 80.0f, 120.0f, 160.0f, 200.0f, 240.0f, 280.0f, 320.0f};
|
|
|
|
/* -------------------------------------------- Internal shared methods --------------------------------------------- */
|
|
/* ------------------------------------------------- */
|
|
/* ------------------------------------------------- System methods ------------------------------------------------- */
|
|
static esp_err_t te_hw_init(const touch_elem_hw_config_t *hardware_init);
|
|
static esp_err_t te_sw_init(const touch_elem_sw_config_t *software_init);
|
|
static inline float te_get_internal_equ_cap(touch_pad_denoise_cap_t denoise_level);
|
|
static float te_channel_get_equ_cap(touch_pad_t channel_num);
|
|
static uint32_t te_read_raw_signal(touch_pad_t channel_num);
|
|
static void te_intr_cb(void *arg);
|
|
static void te_proc_timer_cb(void *arg);
|
|
static inline esp_err_t te_object_set_threshold(void);
|
|
static inline void te_object_process_state(void);
|
|
static inline void te_object_update_state(te_intr_msg_t te_intr_msg);
|
|
/* ----------------------------------------------- Waterproof methods ----------------------------------------------- */
|
|
static inline bool waterproof_check_state(void);
|
|
static inline bool waterproof_shield_check_state(void);
|
|
static inline bool waterproof_guard_check_state(void);
|
|
static bool waterproof_channel_check(touch_pad_t channel_num);
|
|
static void waterproof_guard_set_threshold(void);
|
|
static void waterproof_guard_update_state(touch_pad_t current_channel, te_state_t current_state);
|
|
static touch_pad_shield_driver_t waterproof_get_shield_level(touch_pad_t guard_channel_num);
|
|
/* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
esp_err_t touch_element_install(const touch_elem_global_config_t *global_config)
|
|
{
|
|
TE_CHECK(s_te_obj == NULL, ESP_ERR_INVALID_STATE);
|
|
TE_CHECK(global_config != NULL, ESP_ERR_INVALID_ARG);
|
|
|
|
s_te_obj = (te_obj_t *)calloc(1, sizeof(te_obj_t));
|
|
TE_CHECK(s_te_obj != NULL, ESP_ERR_NO_MEM);
|
|
|
|
esp_err_t ret = ESP_ERR_NO_MEM;
|
|
s_te_obj->global_config = (touch_elem_global_config_t *)calloc(1, sizeof(touch_elem_global_config_t));
|
|
s_te_obj->mutex = xSemaphoreCreateMutex();
|
|
TE_CHECK_GOTO(s_te_obj->global_config != NULL && s_te_obj->mutex != NULL, cleanup);
|
|
xSemaphoreTake(s_te_obj->mutex, portMAX_DELAY);
|
|
TE_CLS_METHODS_INITIALIZER(s_te_obj->object_methods, TE_CLS_TYPE_BUTTON, TE_CLS_TYPE_MAX);
|
|
ret = te_hw_init(&global_config->hardware);
|
|
if (ret != ESP_OK) {
|
|
abort();
|
|
}
|
|
ret = te_sw_init(&global_config->software);
|
|
if (ret != ESP_OK) {
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
goto cleanup;
|
|
}
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
return ESP_OK;
|
|
|
|
cleanup:
|
|
TE_FREE_AND_NULL(s_te_obj->global_config);
|
|
if (s_te_obj->mutex != NULL) {
|
|
vSemaphoreDelete(s_te_obj->mutex);
|
|
}
|
|
TE_FREE_AND_NULL(s_te_obj);
|
|
return ret;
|
|
}
|
|
|
|
esp_err_t touch_element_start(void)
|
|
{
|
|
TE_CHECK(s_te_obj != NULL, ESP_ERR_INVALID_STATE);
|
|
esp_err_t ret;
|
|
uint16_t inited_channel_mask;
|
|
do {
|
|
xSemaphoreTake(s_te_obj->mutex, portMAX_DELAY);
|
|
ret = touch_pad_get_channel_mask(&inited_channel_mask);
|
|
if (inited_channel_mask == 0x0) {
|
|
ESP_LOGE(TE_TAG, "Can not find Touch Sensor channel that has been initialized");
|
|
ret = ESP_ERR_INVALID_STATE;
|
|
break;
|
|
}
|
|
if (ret != ESP_OK) {
|
|
break;
|
|
}
|
|
s_te_obj->is_set_threshold = false; //Threshold configuration will be set on touch sense start
|
|
ret = esp_timer_start_periodic(s_te_obj->proc_timer, TE_PROCESSING_PERIOD(s_te_obj) * 1000);
|
|
if (ret != ESP_OK) {
|
|
break;
|
|
}
|
|
ret = touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_SCAN_DONE); //Use scan done interrupt to set threshold
|
|
if (ret != ESP_OK) {
|
|
break;
|
|
}
|
|
ret = touch_pad_fsm_start();
|
|
if (ret != ESP_OK) {
|
|
break;
|
|
}
|
|
xQueueReset(s_te_obj->event_msg_queue);
|
|
xQueueReset(s_te_obj->intr_msg_queue);
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
return ESP_OK;
|
|
} while (0);
|
|
|
|
ESP_LOGE(TE_TAG, "Touch interface start failed:(%s)", __FUNCTION__ );
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
return ret;
|
|
}
|
|
|
|
esp_err_t touch_element_stop(void)
|
|
{
|
|
TE_CHECK(s_te_obj != NULL, ESP_ERR_INVALID_STATE);
|
|
esp_err_t ret;
|
|
xSemaphoreTake(s_te_obj->mutex, portMAX_DELAY);
|
|
ret = touch_pad_fsm_stop();
|
|
if (ret != ESP_OK) {
|
|
return ret;
|
|
}
|
|
ret = touch_pad_intr_disable(TOUCH_PAD_INTR_MASK_SCAN_DONE);
|
|
if (ret != ESP_OK) {
|
|
return ret;
|
|
}
|
|
ret = esp_timer_stop(s_te_obj->proc_timer);
|
|
if (ret != ESP_OK) {
|
|
return ret;
|
|
}
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
return ESP_OK;
|
|
}
|
|
|
|
//TODO: add a new api that output system's run-time state
|
|
|
|
void touch_element_uninstall(void)
|
|
{
|
|
xSemaphoreTake(s_te_obj->mutex, portMAX_DELAY);
|
|
if (s_te_obj == NULL) {
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
return;
|
|
}
|
|
esp_err_t ret;
|
|
ret = touch_pad_deinit();
|
|
if (ret != ESP_OK) {
|
|
abort();
|
|
}
|
|
ret = esp_timer_delete(s_te_obj->proc_timer);
|
|
if (ret != ESP_OK) {
|
|
abort();
|
|
}
|
|
ret = touch_pad_intr_disable(TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE | TOUCH_PAD_INTR_MASK_TIMEOUT);
|
|
if (ret != ESP_OK) {
|
|
abort();
|
|
}
|
|
ret = touch_pad_isr_deregister(te_intr_cb, NULL);
|
|
if (ret != ESP_OK) {
|
|
abort();
|
|
}
|
|
vQueueDelete(s_te_obj->event_msg_queue);
|
|
vQueueDelete(s_te_obj->intr_msg_queue);
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
vSemaphoreDelete(s_te_obj->mutex);
|
|
free(s_te_obj->global_config);
|
|
s_te_obj->global_config = NULL;
|
|
free(s_te_obj);
|
|
s_te_obj = NULL;
|
|
}
|
|
|
|
esp_err_t touch_element_message_receive(touch_elem_message_t *element_message, uint32_t ticks_to_wait)
|
|
{
|
|
//TODO: Use the generic data struct to refactor this api
|
|
TE_CHECK(s_te_obj != NULL, ESP_ERR_INVALID_STATE);
|
|
TE_CHECK(element_message != NULL, ESP_ERR_INVALID_ARG);
|
|
TE_CHECK(s_te_obj->event_msg_queue != NULL, ESP_ERR_INVALID_STATE);
|
|
int ret = xQueueReceive(s_te_obj->event_msg_queue, element_message, ticks_to_wait);
|
|
return (ret == pdTRUE) ? ESP_OK : ESP_ERR_TIMEOUT;
|
|
}
|
|
|
|
static uint32_t te_read_raw_signal(touch_pad_t channel_num)
|
|
{
|
|
uint32_t raw_signal = 0;
|
|
touch_pad_sleep_channel_t sleep_channel_info;
|
|
touch_pad_sleep_channel_get_info(&sleep_channel_info);
|
|
if (channel_num != sleep_channel_info.touch_num) {
|
|
touch_pad_read_raw_data(channel_num, &raw_signal);
|
|
} else {
|
|
touch_pad_sleep_channel_read_data(channel_num, &raw_signal);
|
|
}
|
|
return raw_signal;
|
|
}
|
|
|
|
uint32_t te_read_smooth_signal(touch_pad_t channel_num)
|
|
{
|
|
uint32_t smooth_signal = 0;
|
|
touch_pad_sleep_channel_t sleep_channel_info;
|
|
touch_pad_sleep_channel_get_info(&sleep_channel_info);
|
|
if (channel_num != sleep_channel_info.touch_num) {
|
|
touch_pad_filter_read_smooth(channel_num, &smooth_signal);
|
|
} else {
|
|
touch_pad_sleep_channel_read_smooth(channel_num, &smooth_signal);
|
|
}
|
|
return smooth_signal;
|
|
}
|
|
|
|
esp_err_t te_event_give(touch_elem_message_t te_message)
|
|
{
|
|
//TODO: add queue overwrite here when the queue is full
|
|
int ret = xQueueSend(s_te_obj->event_msg_queue, &te_message, 0);
|
|
if (ret != pdTRUE) {
|
|
ESP_LOGE(TE_TAG, "event queue send failed, event message queue is full");
|
|
return ESP_ERR_TIMEOUT;
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
uint32_t te_get_threshold(touch_pad_t channel_num)
|
|
{
|
|
uint32_t threshold = 0;
|
|
touch_pad_sleep_channel_t sleep_channel_info;
|
|
touch_pad_sleep_channel_get_info(&sleep_channel_info);
|
|
if (channel_num != sleep_channel_info.touch_num) {
|
|
touch_pad_get_thresh(channel_num, &threshold);
|
|
} else {
|
|
touch_pad_sleep_get_threshold(channel_num, &threshold);
|
|
}
|
|
return threshold;
|
|
}
|
|
|
|
bool te_is_touch_dsleep_wakeup(void)
|
|
{
|
|
soc_reset_reason_t reset_reason = esp_rom_get_reset_reason(0);
|
|
if (reset_reason != RESET_REASON_CORE_DEEP_SLEEP) {
|
|
return false;
|
|
}
|
|
esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();
|
|
return wakeup_reason == ESP_SLEEP_WAKEUP_TOUCHPAD;
|
|
}
|
|
|
|
touch_pad_t te_get_sleep_channel(void)
|
|
{
|
|
touch_pad_sleep_channel_t sleep_channel_info;
|
|
touch_pad_sleep_channel_get_info(&sleep_channel_info);
|
|
return sleep_channel_info.touch_num;
|
|
}
|
|
|
|
/**
|
|
* @brief Touch sensor interrupt service routine
|
|
*
|
|
* This function is touch sensor ISR, all the touch
|
|
* sensor channel state will be updated here.
|
|
*/
|
|
static void te_intr_cb(void *arg)
|
|
{
|
|
TE_UNUSED(arg);
|
|
static int scan_done_cnt = 0;
|
|
static uint32_t touch_pre_trig_status = 0;
|
|
int task_awoken = pdFALSE;
|
|
te_intr_msg_t te_intr_msg = {};
|
|
/*< Figure out which touch sensor channel is triggered and the trigger type */
|
|
uint32_t intr_mask = touch_pad_read_intr_status_mask();
|
|
if (intr_mask == 0x0) { //For dummy interrupt
|
|
return;
|
|
}
|
|
|
|
bool need_send_queue = true;
|
|
uint8_t pad_num = 0;
|
|
uint32_t touch_trig_status = touch_pad_get_status();
|
|
uint32_t touch_trig_diff = touch_trig_status ^ touch_pre_trig_status;
|
|
while (touch_trig_diff) {
|
|
if (touch_trig_diff & 0x1) {
|
|
if (touch_trig_status & BIT(pad_num)) {
|
|
if (s_te_obj->sleep_handle != NULL) {
|
|
#ifdef CONFIG_PM_ENABLE
|
|
esp_pm_lock_acquire(s_te_obj->sleep_handle->pm_lock);
|
|
#endif
|
|
}
|
|
te_intr_msg.channel_state = TE_STATE_PRESS;
|
|
te_intr_msg.intr_type = TE_INTR_PRESS;
|
|
} else {
|
|
te_intr_msg.channel_state = TE_STATE_RELEASE;
|
|
te_intr_msg.intr_type = TE_INTR_RELEASE;
|
|
}
|
|
touch_pre_trig_status = touch_trig_status;
|
|
te_intr_msg.channel_num = pad_num;
|
|
}
|
|
pad_num++;
|
|
touch_trig_diff >>= 1;
|
|
}
|
|
|
|
if (intr_mask & TOUCH_PAD_INTR_MASK_TIMEOUT) {
|
|
te_intr_msg.channel_state = TE_STATE_IDLE;
|
|
te_intr_msg.intr_type = TE_INTR_TIMEOUT;
|
|
} else if (intr_mask & TOUCH_PAD_INTR_MASK_SCAN_DONE) {
|
|
te_intr_msg.channel_state = TE_STATE_IDLE;
|
|
te_intr_msg.intr_type = TE_INTR_SCAN_DONE;
|
|
need_send_queue = false;
|
|
/*< Due to a hardware issue, all of the data read operation(read raw, read smooth, read benchmark) */
|
|
/*< must be after the second times of measure_done interrupt. */
|
|
if (++scan_done_cnt >= 5) {
|
|
touch_hal_intr_disable(TOUCH_PAD_INTR_MASK_SCAN_DONE); //TODO: remove hal
|
|
scan_done_cnt = 0;
|
|
need_send_queue = true;
|
|
}
|
|
/*< De-noise channel signal must be read at the time between SCAN_DONE and next measurement beginning(sleep)!!! */
|
|
touch_pad_denoise_read_data(&s_te_obj->denoise_channel_raw); //Update de-noise signal
|
|
}
|
|
if (need_send_queue) {
|
|
xQueueSendFromISR(s_te_obj->intr_msg_queue, &te_intr_msg, &task_awoken);
|
|
}
|
|
if (task_awoken == pdTRUE) {
|
|
portYIELD_FROM_ISR();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief esp-timer callback routine
|
|
*
|
|
* This function is an esp-timer daemon routine, all the touch sensor
|
|
* application(button, slider, etc...) will be processed in here.
|
|
*
|
|
*/
|
|
static void te_proc_timer_cb(void *arg)
|
|
{
|
|
TE_UNUSED(arg);
|
|
te_intr_msg_t te_intr_msg;
|
|
te_intr_msg.intr_type = TE_INTR_MAX;
|
|
BaseType_t ret = xSemaphoreTake(s_te_obj->mutex, 0);
|
|
if (ret != pdPASS) {
|
|
return;
|
|
}
|
|
ret = xQueueReceive(s_te_obj->intr_msg_queue, &te_intr_msg, 0);
|
|
if (ret == pdPASS) {
|
|
if (te_intr_msg.intr_type == TE_INTR_PRESS || te_intr_msg.intr_type == TE_INTR_RELEASE) {
|
|
te_object_update_state(te_intr_msg);
|
|
if ((s_te_obj->sleep_handle != NULL) && (te_intr_msg.intr_type == TE_INTR_RELEASE)) {
|
|
#ifdef CONFIG_PM_ENABLE
|
|
esp_pm_lock_release(s_te_obj->sleep_handle->pm_lock);
|
|
#endif
|
|
}
|
|
} else if (te_intr_msg.intr_type == TE_INTR_SCAN_DONE) {
|
|
if (s_te_obj->is_set_threshold != true) {
|
|
s_te_obj->is_set_threshold = true;
|
|
te_object_set_threshold(); //TODO: add set threshold error processing
|
|
ESP_LOGD(TE_DEBUG_TAG, "Set threshold");
|
|
if (s_te_obj->sleep_handle != NULL) {
|
|
#ifdef CONFIG_PM_ENABLE
|
|
esp_pm_lock_release(s_te_obj->sleep_handle->pm_lock);
|
|
#endif
|
|
}
|
|
}
|
|
if (waterproof_check_state()) {
|
|
te_waterproof_handle_t waterproof_handle = s_te_obj->waterproof_handle;
|
|
if (waterproof_handle->is_shield_level_set != true) {
|
|
waterproof_handle->is_shield_level_set = true;
|
|
touch_pad_waterproof_t wp_conf;
|
|
wp_conf.shield_driver = waterproof_get_shield_level(waterproof_handle->shield_channel);
|
|
wp_conf.guard_ring_pad = (waterproof_guard_check_state() ? waterproof_handle->guard_device->channel : TOUCH_WATERPROOF_GUARD_NOUSE);
|
|
touch_pad_waterproof_set_config(&wp_conf);
|
|
touch_pad_waterproof_enable();
|
|
ESP_LOGD(TE_DEBUG_TAG, "Set waterproof shield level");
|
|
}
|
|
}
|
|
ESP_LOGD(TE_DEBUG_TAG, "read denoise channel %"PRIu32, s_te_obj->denoise_channel_raw);
|
|
} else if (te_intr_msg.intr_type == TE_INTR_TIMEOUT) { //Timeout processing
|
|
touch_pad_timeout_resume();
|
|
}
|
|
}
|
|
te_object_process_state();
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
}
|
|
|
|
void te_object_method_register(te_object_methods_t *object_methods, te_class_type_t object_type)
|
|
{
|
|
xSemaphoreTake(s_te_obj->mutex, portMAX_DELAY);
|
|
TE_CLASS_ITEM(s_te_obj->object_methods, object_type, handle) = object_methods->handle;
|
|
TE_CLASS_ITEM(s_te_obj->object_methods, object_type, check_channel) = object_methods->check_channel;
|
|
TE_CLASS_ITEM(s_te_obj->object_methods, object_type, set_threshold) = object_methods->set_threshold;
|
|
TE_CLASS_ITEM(s_te_obj->object_methods, object_type, process_state) = object_methods->process_state;
|
|
TE_CLASS_ITEM(s_te_obj->object_methods, object_type, update_state) = object_methods->update_state;
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
}
|
|
|
|
void te_object_method_unregister(te_class_type_t object_type)
|
|
{
|
|
xSemaphoreTake(s_te_obj->mutex, portMAX_DELAY);
|
|
TE_CLASS_ITEM(s_te_obj->object_methods, object_type, handle) = NULL;
|
|
TE_CLASS_ITEM(s_te_obj->object_methods, object_type, check_channel) = NULL;
|
|
TE_CLASS_ITEM(s_te_obj->object_methods, object_type, set_threshold) = NULL;
|
|
TE_CLASS_ITEM(s_te_obj->object_methods, object_type, process_state) = NULL;
|
|
TE_CLASS_ITEM(s_te_obj->object_methods, object_type, update_state) = NULL;
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
}
|
|
|
|
/**
|
|
* @brief Touch Sense channel check
|
|
*
|
|
* This function will check the input channel whether is
|
|
* associated with the Touch Sense Object
|
|
*
|
|
* @return
|
|
* - true: Channel has been initialized, pls adjust the input channel
|
|
* - false: Channel has not been initialized, pass
|
|
*/
|
|
bool te_object_check_channel(const touch_pad_t *channel_array, uint8_t channel_sum)
|
|
{
|
|
touch_pad_t current_channel;
|
|
for (int idx = 0; idx < channel_sum; idx++) {
|
|
current_channel = channel_array[idx];
|
|
if (waterproof_channel_check(current_channel)) {
|
|
goto INITIALIZED;
|
|
}
|
|
if (TE_CLASS_FOREACH_CHECK_CHANNEL(s_te_obj->object_methods, TE_CLS_TYPE_BUTTON, TE_CLS_TYPE_MAX, current_channel)) {
|
|
goto INITIALIZED;
|
|
}
|
|
}
|
|
return false;
|
|
|
|
INITIALIZED:
|
|
ESP_LOGE(TE_TAG, "Current channel [%d] has been initialized:(%s)", current_channel, __FUNCTION__ );
|
|
return true;
|
|
}
|
|
|
|
|
|
static inline esp_err_t te_object_set_threshold(void)
|
|
{
|
|
if (waterproof_guard_check_state() == true) { //TODO: add to object methods
|
|
waterproof_guard_set_threshold();
|
|
}
|
|
|
|
TE_CLASS_FOREACH_SET_THRESHOLD(s_te_obj->object_methods, TE_CLS_TYPE_BUTTON, TE_CLS_TYPE_MAX);
|
|
return ESP_OK;
|
|
}
|
|
|
|
static inline void te_object_process_state(void)
|
|
{
|
|
TE_CLASS_FOREACH_PROCESS_STATE(s_te_obj->object_methods, TE_CLS_TYPE_BUTTON, TE_CLS_TYPE_MAX);
|
|
}
|
|
|
|
static inline void te_object_update_state(te_intr_msg_t te_intr_msg)
|
|
{
|
|
if (waterproof_guard_check_state()) {
|
|
waterproof_guard_update_state(te_intr_msg.channel_num, te_intr_msg.channel_state);
|
|
}
|
|
TE_CLASS_FOREACH_UPDATE_STATE(s_te_obj->object_methods, TE_CLS_TYPE_BUTTON, TE_CLS_TYPE_MAX,
|
|
te_intr_msg.channel_num, te_intr_msg.channel_state);
|
|
}
|
|
|
|
uint8_t te_get_timer_period(void)
|
|
{
|
|
return (TE_PROCESSING_PERIOD(s_te_obj));
|
|
}
|
|
|
|
esp_err_t te_dev_init(te_dev_t **device, uint8_t device_num, te_dev_type_t type, const touch_pad_t *channel, const float *sens, float divider)
|
|
{
|
|
for (int idx = 0; idx < device_num; idx++) {
|
|
device[idx]->channel = channel[idx];
|
|
device[idx]->sens = sens[idx] * divider;
|
|
device[idx]->type = type;
|
|
device[idx]->state = TE_STATE_IDLE;
|
|
device[idx]->is_use_last_threshold = false;
|
|
esp_err_t ret = touch_pad_config(device[idx]->channel);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
void te_dev_deinit(te_dev_t **device, uint8_t device_num)
|
|
{
|
|
for (int idx = 0; idx < device_num; idx++) {
|
|
touch_pad_clear_channel_mask((1UL << device[idx]->channel));
|
|
}
|
|
}
|
|
|
|
static esp_err_t te_config_thresh(touch_pad_t channel_num, uint32_t threshold)
|
|
{
|
|
esp_err_t ret;
|
|
touch_pad_sleep_channel_t sleep_channel_info;
|
|
touch_pad_sleep_channel_get_info(&sleep_channel_info);
|
|
if (channel_num != sleep_channel_info.touch_num) {
|
|
ret = touch_pad_set_thresh(channel_num, threshold);
|
|
} else {
|
|
ret = touch_pad_sleep_set_threshold(channel_num, threshold);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
esp_err_t te_dev_set_threshold(te_dev_t *device)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
uint32_t smo_val = 0;
|
|
|
|
if (s_te_obj->sleep_handle && device->is_use_last_threshold) {
|
|
if (te_is_touch_dsleep_wakeup()) { //Deep sleep wakeup reset
|
|
ret = te_config_thresh(device->channel, s_te_obj->sleep_handle->non_volatile_threshold[device->channel - 1]);
|
|
} else { //Other reset
|
|
smo_val = te_read_smooth_signal(device->channel);
|
|
ret = te_config_thresh(device->channel, device->sens * smo_val);
|
|
uint32_t threshold = te_get_threshold(device->channel);
|
|
s_te_obj->sleep_handle->non_volatile_threshold[device->channel - 1] = threshold; //Write threshold into RTC Fast Memory
|
|
}
|
|
} else {
|
|
smo_val = te_read_smooth_signal(device->channel);
|
|
ret = te_config_thresh(device->channel, device->sens * smo_val);
|
|
}
|
|
ESP_LOGD(TE_DEBUG_TAG, "channel: %"PRIu8", smo_val: %"PRIu32, (uint8_t)device->channel, smo_val);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* This function returns the s_te_obj whether is initialized
|
|
*
|
|
* @return
|
|
* - true: initialized
|
|
* - false: not initialized
|
|
*/
|
|
bool te_system_check_state(void)
|
|
{
|
|
return (s_te_obj != NULL);
|
|
}
|
|
|
|
static inline float te_get_internal_equ_cap(touch_pad_denoise_cap_t denoise_level)
|
|
{
|
|
return denoise_channel_equ_cap[denoise_level];
|
|
}
|
|
|
|
/**
|
|
* @brief Get channel equivalent capacitance
|
|
*
|
|
* This function calculates the equivalent capacitance of input channel by
|
|
* using the Touch channel 0 equivalent capacitance. The formula is:
|
|
*
|
|
* Raw_N / Raw_0 = Cap_N / Cap_0
|
|
*
|
|
* Note that Raw_N and Raw_0 are the raw data of touch channel N and touch channel 0 respectively,
|
|
* Cap_N and Cap_0 are the equivalent capacitance of touch channel N and touch channel 0.
|
|
*
|
|
* @param[in] channel_num Input touch sensor channel
|
|
*
|
|
* @note The unit is pF
|
|
*
|
|
* @return Specified channel equivalent capacitance.
|
|
*/
|
|
static float te_channel_get_equ_cap(touch_pad_t channel_num)
|
|
{
|
|
//Fixme: add a mutex in here and prevent the system call this function
|
|
TE_CHECK(channel_num > TOUCH_PAD_NUM0 && channel_num < TOUCH_PAD_MAX, 0);
|
|
uint32_t tn_raw, t0_raw;
|
|
float tn_ref_cap, t0_ref_cap;
|
|
touch_pad_denoise_t denoise_channel_conf;
|
|
touch_pad_denoise_get_config(&denoise_channel_conf);
|
|
tn_raw = te_read_raw_signal(channel_num);
|
|
t0_raw = s_te_obj->denoise_channel_raw;
|
|
t0_ref_cap = te_get_internal_equ_cap(denoise_channel_conf.cap_level);
|
|
if (t0_raw == 0) {
|
|
return 0;
|
|
}
|
|
tn_ref_cap = (float)tn_raw / t0_raw * t0_ref_cap;
|
|
return tn_ref_cap;
|
|
}
|
|
|
|
/**
|
|
* @brief Touch sensor driver default init [ESP32S2 only]
|
|
*
|
|
* 1. Channel measure time: Raw_value / RTC_FAST_CLK ==> Raw_value / 8000 000
|
|
* 2. Channel sleep time: TOUCH_PAD_SLEEP_CYCLE_DEFAULT / RTC_SLOW_CLK ==> 0xf / 90 000(default) = 0.16ms
|
|
* 3. Channel charge voltage threshold(upper/lower): 2.7V upper voltage, 0.5V lower voltage, 0.5V attenuation voltage
|
|
* 4. IDLE channel processing: Connecting to GND
|
|
* 5. Interrupt type: ACTIVE, INACTIVE, TIMEOUT
|
|
*
|
|
* @note A touch sensor channel will spend the time = measure time + sleep time, RTC_FAST_CLK is 8M
|
|
*
|
|
*/
|
|
static esp_err_t te_hw_init(const touch_elem_hw_config_t *hardware_init)
|
|
{
|
|
esp_err_t ret;
|
|
ret = touch_pad_init();
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
ret = touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
ret = touch_pad_set_measurement_interval(hardware_init->sleep_cycle);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
ret = touch_pad_set_charge_discharge_times(hardware_init->sample_count);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
ret = touch_pad_set_voltage(hardware_init->upper_voltage, hardware_init->lower_voltage,
|
|
hardware_init->voltage_attenuation);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
ret = touch_pad_set_idle_channel_connect(hardware_init->suspend_channel_polarity);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
ret = touch_pad_isr_register(te_intr_cb, NULL,
|
|
TOUCH_PAD_INTR_MASK_ACTIVE | TOUCH_PAD_INTR_MASK_INACTIVE |
|
|
TOUCH_PAD_INTR_MASK_TIMEOUT | TOUCH_PAD_INTR_MASK_SCAN_DONE);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
ret = touch_pad_intr_enable(TOUCH_PAD_INTR_MASK_ACTIVE |
|
|
TOUCH_PAD_INTR_MASK_INACTIVE | TOUCH_PAD_INTR_MASK_TIMEOUT);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
|
|
/*< Internal de-noise configuration */
|
|
touch_pad_denoise_t denoise_config;
|
|
denoise_config.grade = hardware_init->denoise_level;
|
|
denoise_config.cap_level = hardware_init->denoise_equivalent_cap;
|
|
ret = touch_pad_denoise_set_config(&denoise_config);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
ret = touch_pad_denoise_enable();
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
|
|
/*< benchmark filter configuration */
|
|
touch_filter_config_t filter_config;
|
|
filter_config.smh_lvl = hardware_init->smooth_filter_mode;
|
|
filter_config.mode = hardware_init->benchmark_filter_mode;
|
|
filter_config.debounce_cnt = hardware_init->benchmark_debounce_count;
|
|
filter_config.noise_thr = hardware_init->benchmark_calibration_threshold;
|
|
filter_config.jitter_step = hardware_init->benchmark_jitter_step;
|
|
ret = touch_pad_filter_set_config(&filter_config);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
ret = touch_pad_filter_enable();
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
memcpy(&s_te_obj->global_config->hardware, hardware_init, sizeof(touch_elem_hw_config_t));
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t te_sw_init(const touch_elem_sw_config_t *software_init)
|
|
{
|
|
TE_CHECK(software_init->processing_period > 1, ESP_ERR_INVALID_ARG);
|
|
TE_CHECK(software_init->waterproof_threshold_divider > 0, ESP_ERR_INVALID_ARG);
|
|
TE_CHECK(software_init->intr_message_size >= (TOUCH_PAD_MAX - 1), ESP_ERR_INVALID_ARG);
|
|
TE_CHECK(software_init->event_message_size > 0, ESP_ERR_INVALID_ARG);
|
|
|
|
esp_err_t ret = ESP_ERR_NO_MEM;
|
|
s_te_obj->intr_msg_queue = xQueueCreate(software_init->intr_message_size, sizeof(te_intr_msg_t));
|
|
s_te_obj->event_msg_queue = xQueueCreate(software_init->event_message_size, sizeof(touch_elem_message_t));
|
|
TE_CHECK_GOTO(s_te_obj->event_msg_queue != NULL && s_te_obj->intr_msg_queue != NULL, cleanup);
|
|
|
|
const esp_timer_create_args_t te_proc_timer_args = {
|
|
.name = "te_proc_timer_cb",
|
|
.arg = NULL,
|
|
.callback = &te_proc_timer_cb,
|
|
.skip_unhandled_events = true,
|
|
};
|
|
ret = esp_timer_create(&te_proc_timer_args, &s_te_obj->proc_timer);
|
|
TE_CHECK_GOTO(ret == ESP_OK, cleanup);
|
|
memcpy(&s_te_obj->global_config->software, software_init, sizeof(touch_elem_sw_config_t));
|
|
return ret;
|
|
|
|
cleanup:
|
|
if (s_te_obj->event_msg_queue != NULL) {
|
|
vQueueDelete(s_te_obj->event_msg_queue);
|
|
}
|
|
if (s_te_obj->intr_msg_queue != NULL) {
|
|
vQueueDelete(s_te_obj->intr_msg_queue);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//TODO: add waterproof guard-lock hysteresis
|
|
esp_err_t touch_element_waterproof_install(const touch_elem_waterproof_config_t *waterproof_config)
|
|
{
|
|
TE_CHECK(s_te_obj != NULL, ESP_ERR_INVALID_STATE);
|
|
TE_CHECK(waterproof_config != NULL, ESP_ERR_INVALID_ARG);
|
|
TE_CHECK(waterproof_config->guard_channel >= TOUCH_PAD_NUM0 &&
|
|
waterproof_config->guard_channel < TOUCH_PAD_MAX,
|
|
ESP_ERR_INVALID_ARG);
|
|
te_waterproof_handle_t waterproof_handle = (te_waterproof_handle_t)calloc(1, sizeof(struct te_waterproof_s));
|
|
TE_CHECK(waterproof_handle != NULL, ESP_ERR_NO_MEM);
|
|
waterproof_handle->shield_channel = TOUCH_PAD_NUM14;
|
|
|
|
esp_err_t ret;
|
|
if (waterproof_config->guard_channel != TOUCH_WATERPROOF_GUARD_NOUSE) { //Use guard sensor
|
|
if (te_object_check_channel(&waterproof_config->guard_channel, 1)) {
|
|
ret = ESP_ERR_INVALID_ARG;
|
|
goto cleanup;
|
|
}
|
|
ret = ESP_ERR_NO_MEM;
|
|
waterproof_handle->mask_handle = (touch_elem_handle_t *) calloc(TOUCH_PAD_MAX, sizeof(touch_elem_handle_t));
|
|
waterproof_handle->guard_device = (te_dev_t *)calloc(1, sizeof(te_dev_t));
|
|
TE_CHECK_GOTO(waterproof_handle->mask_handle != NULL && waterproof_handle->guard_device, cleanup);
|
|
|
|
ret = te_dev_init(&waterproof_handle->guard_device, 1, TOUCH_ELEM_TYPE_BUTTON,
|
|
&waterproof_config->guard_channel, &waterproof_config->guard_sensitivity,
|
|
TE_WATERPROOF_DIVIDER(s_te_obj));
|
|
TE_CHECK_GOTO(ret == ESP_OK, cleanup);
|
|
waterproof_handle->guard_device->state = TE_STATE_RELEASE;
|
|
for (int idx = 0; idx < TOUCH_PAD_MAX; idx++) {
|
|
waterproof_handle->mask_handle[idx] = NULL;
|
|
}
|
|
} else { //No use waterproof guard sensor
|
|
waterproof_handle->guard_device = NULL;
|
|
waterproof_handle->mask_handle = NULL;
|
|
}
|
|
waterproof_handle->is_shield_level_set = 0; //Set a state bit so as to configure the shield level at the run-time
|
|
touch_pad_waterproof_t wp_conf;
|
|
wp_conf.shield_driver = TOUCH_PAD_SHIELD_DRV_L0; //Set a default shield level
|
|
wp_conf.guard_ring_pad = waterproof_config->guard_channel;
|
|
ret = touch_pad_waterproof_set_config(&wp_conf);
|
|
TE_CHECK_GOTO(ret == ESP_OK, cleanup);
|
|
ret = touch_pad_waterproof_enable();
|
|
TE_CHECK_GOTO(ret == ESP_OK, cleanup);
|
|
s_te_obj->waterproof_handle = waterproof_handle; //Fixme: add mutex
|
|
return ESP_OK;
|
|
|
|
cleanup:
|
|
TE_FREE_AND_NULL(waterproof_handle->mask_handle);
|
|
TE_FREE_AND_NULL(waterproof_handle->guard_device);
|
|
TE_FREE_AND_NULL(waterproof_handle);
|
|
return ret;
|
|
}
|
|
|
|
esp_err_t touch_element_waterproof_add(touch_elem_handle_t element_handle)
|
|
{
|
|
TE_CHECK(s_te_obj->waterproof_handle != NULL, ESP_ERR_INVALID_STATE);
|
|
TE_CHECK(s_te_obj->waterproof_handle->guard_device != NULL, ESP_ERR_INVALID_STATE);
|
|
TE_CHECK(element_handle != NULL, ESP_ERR_INVALID_ARG);
|
|
te_waterproof_handle_t waterproof_handle = s_te_obj->waterproof_handle;
|
|
xSemaphoreTake(s_te_obj->mutex, portMAX_DELAY);
|
|
for (int idx = 0; idx < TOUCH_PAD_MAX; idx++) {
|
|
if (waterproof_handle->mask_handle[idx] == NULL) {
|
|
waterproof_handle->mask_handle[idx] = element_handle;
|
|
break;
|
|
}
|
|
}
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t touch_element_waterproof_remove(touch_elem_handle_t element_handle)
|
|
{
|
|
TE_CHECK(s_te_obj->waterproof_handle != NULL, ESP_ERR_INVALID_STATE);
|
|
TE_CHECK(element_handle != NULL, ESP_ERR_INVALID_ARG);
|
|
esp_err_t ret = ESP_ERR_NOT_FOUND;
|
|
te_waterproof_handle_t waterproof_handle = s_te_obj->waterproof_handle;
|
|
xSemaphoreTake(s_te_obj->mutex, portMAX_DELAY);
|
|
for (int idx = 0; idx < TOUCH_PAD_MAX; idx++) {
|
|
if (waterproof_handle->mask_handle[idx] == element_handle) {
|
|
waterproof_handle->mask_handle[idx] = NULL;
|
|
ret = ESP_OK;
|
|
break;
|
|
}
|
|
}
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
return ret;
|
|
}
|
|
|
|
void touch_element_waterproof_uninstall(void)
|
|
{
|
|
xSemaphoreTake(s_te_obj->mutex, portMAX_DELAY);
|
|
touch_pad_waterproof_disable();
|
|
free(s_te_obj->waterproof_handle->guard_device);
|
|
free(s_te_obj->waterproof_handle->mask_handle);
|
|
free(s_te_obj->waterproof_handle);
|
|
s_te_obj->waterproof_handle = NULL;
|
|
xSemaphoreGive(s_te_obj->mutex);
|
|
}
|
|
|
|
static touch_pad_shield_driver_t waterproof_get_shield_level(touch_pad_t guard_channel_num)
|
|
{
|
|
touch_pad_shield_driver_t shield_level = TOUCH_PAD_SHIELD_DRV_L7;
|
|
float guard_ref_cap = te_channel_get_equ_cap(guard_channel_num);
|
|
for (int level = 0; level < TOUCH_PAD_SHIELD_DRV_MAX; level++) {
|
|
if (guard_ref_cap <= shield_channel_ref_cap[level]) {
|
|
shield_level = (touch_pad_shield_driver_t)level;
|
|
break;
|
|
}
|
|
}
|
|
return shield_level;
|
|
}
|
|
|
|
/**
|
|
* This function returns the waterproof_handle whether is initialized
|
|
*
|
|
* @return
|
|
* - true: initialized
|
|
* - false: not initialized
|
|
*/
|
|
static inline bool waterproof_check_state(void)
|
|
{
|
|
return (s_te_obj->waterproof_handle != NULL);
|
|
}
|
|
|
|
static inline bool waterproof_shield_check_state(void)
|
|
{
|
|
return waterproof_check_state(); //Driver does not allow to disable shield sensor after waterproof enabling
|
|
}
|
|
|
|
static inline bool waterproof_guard_check_state(void)
|
|
{
|
|
if (waterproof_check_state() == false) {
|
|
return false;
|
|
}
|
|
if (s_te_obj->waterproof_handle->guard_device == NULL || s_te_obj->waterproof_handle->mask_handle == NULL) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool waterproof_channel_check(touch_pad_t channel_num)
|
|
{
|
|
if (waterproof_check_state() == false) {
|
|
return false;
|
|
}
|
|
te_waterproof_handle_t waterproof_handle = s_te_obj->waterproof_handle;
|
|
if (waterproof_shield_check_state()) {
|
|
if (channel_num == waterproof_handle->shield_channel) {
|
|
ESP_LOGE(TE_TAG, "TOUCH_PAD_NUM%"PRIu8" has been used for waterproof shield channel,"
|
|
" please change the touch sensor channel or disable waterproof", (uint8_t)channel_num);
|
|
return true;
|
|
}
|
|
}
|
|
if (waterproof_guard_check_state()) {
|
|
if (channel_num == waterproof_handle->guard_device->channel) {
|
|
ESP_LOGE(TE_TAG, "TOUCH_PAD_NUM%"PRIu8" has been used for waterproof guard channel,"
|
|
" please change the touch sensor channel or disable waterproof", (uint8_t)channel_num);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void waterproof_guard_set_threshold(void)
|
|
{
|
|
if (waterproof_check_state() == false) {
|
|
return;
|
|
}
|
|
if (waterproof_guard_check_state() == false) {
|
|
return;
|
|
}
|
|
te_dev_set_threshold(s_te_obj->waterproof_handle->guard_device);
|
|
}
|
|
|
|
/**
|
|
* This function will figure out current handle whether is a masked channel
|
|
* while guard channel is triggered.
|
|
*
|
|
* @param[in] te_handle Touch sensor application handle
|
|
* @return
|
|
* - true current handle is a masked channel
|
|
* - false current handle is not a masked channel
|
|
*/
|
|
bool waterproof_check_mask_handle(touch_elem_handle_t te_handle)
|
|
{
|
|
if (waterproof_check_state() == false) {
|
|
return false;
|
|
}
|
|
if (waterproof_guard_check_state() == false) {
|
|
return false;
|
|
}
|
|
te_waterproof_handle_t waterproof_handle = s_te_obj->waterproof_handle;
|
|
bool ret = false;
|
|
if (waterproof_handle->guard_device->state == TE_STATE_PRESS) {
|
|
for (int idx = 0; idx < TOUCH_PAD_MAX; idx++) {
|
|
if (waterproof_handle->mask_handle[idx] == NULL) {
|
|
break;
|
|
}
|
|
if (waterproof_handle->mask_handle[idx] == te_handle) {
|
|
ret = true;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void waterproof_guard_update_state(touch_pad_t current_channel, te_state_t current_state)
|
|
{
|
|
te_dev_t *guard_device = s_te_obj->waterproof_handle->guard_device;
|
|
if (current_channel == guard_device->channel) {
|
|
guard_device->state = current_state;
|
|
}
|
|
ESP_LOGD(TE_DEBUG_TAG, "waterproof guard state update %d", guard_device->state);
|
|
}
|
|
|
|
esp_err_t touch_element_enable_light_sleep(const touch_elem_sleep_config_t *sleep_config)
|
|
{
|
|
TE_CHECK(s_te_obj != NULL, ESP_ERR_INVALID_STATE);
|
|
TE_CHECK(s_te_obj->sleep_handle == NULL, ESP_ERR_INVALID_STATE);
|
|
uint16_t sample_count = 500;
|
|
uint16_t sleep_cycle = 0x0f;
|
|
if (sleep_config) {
|
|
sample_count = sleep_config->sample_count;
|
|
sleep_cycle = sleep_config->sleep_cycle;
|
|
}
|
|
|
|
s_te_obj->sleep_handle = calloc(1, sizeof(struct te_sleep_s));
|
|
TE_CHECK(s_te_obj->sleep_handle, ESP_ERR_NO_MEM);
|
|
|
|
esp_err_t ret = ESP_OK;
|
|
touch_pad_sleep_channel_set_work_time(sleep_cycle, sample_count);
|
|
TE_CHECK_GOTO(esp_sleep_enable_touchpad_wakeup() == ESP_OK, cleanup);
|
|
|
|
TE_CHECK_GOTO(esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON) == ESP_OK, cleanup);
|
|
s_te_obj->sleep_handle->non_volatile_threshold = threshold_shadow;
|
|
|
|
#ifdef CONFIG_PM_ENABLE
|
|
TE_CHECK_GOTO(esp_pm_lock_create(ESP_PM_NO_LIGHT_SLEEP, 0, "touch_element", &s_te_obj->sleep_handle->pm_lock) == ESP_OK, cleanup);
|
|
TE_CHECK_GOTO(esp_pm_lock_acquire(s_te_obj->sleep_handle->pm_lock) == ESP_OK, cleanup);
|
|
#endif
|
|
|
|
return ESP_OK;
|
|
|
|
cleanup:
|
|
#ifdef CONFIG_PM_ENABLE
|
|
if (s_te_obj->sleep_handle->pm_lock != NULL) {
|
|
if (esp_pm_lock_delete(s_te_obj->sleep_handle->pm_lock) != ESP_OK) {
|
|
abort();
|
|
}
|
|
}
|
|
#endif
|
|
TE_FREE_AND_NULL(s_te_obj->sleep_handle);
|
|
return ret;
|
|
}
|
|
|
|
esp_err_t touch_element_disable_light_sleep(void)
|
|
{
|
|
TE_CHECK(s_te_obj->sleep_handle, ESP_ERR_INVALID_STATE);
|
|
#ifdef CONFIG_PM_ENABLE
|
|
if (s_te_obj->sleep_handle->pm_lock != NULL) {
|
|
/* Sleep channel is going to uninstall, pm lock is not needed anymore,
|
|
but we need to make sure that pm lock has been released before delete it. */
|
|
while(esp_pm_lock_release(s_te_obj->sleep_handle->pm_lock) == ESP_OK);
|
|
esp_err_t ret = esp_pm_lock_delete(s_te_obj->sleep_handle->pm_lock);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
s_te_obj->sleep_handle->pm_lock = NULL;
|
|
}
|
|
#endif
|
|
esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TOUCHPAD);
|
|
TE_FREE_AND_NULL(s_te_obj->sleep_handle);
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t touch_element_enable_deep_sleep(touch_elem_handle_t wakeup_elem_handle, const touch_elem_sleep_config_t *sleep_config)
|
|
{
|
|
TE_CHECK(s_te_obj != NULL, ESP_ERR_INVALID_STATE);
|
|
TE_CHECK(s_te_obj->sleep_handle == NULL, ESP_ERR_INVALID_STATE);
|
|
TE_CHECK(wakeup_elem_handle != NULL, ESP_ERR_INVALID_ARG);
|
|
TE_CHECK(sleep_config != NULL, ESP_ERR_INVALID_ARG);
|
|
uint16_t sample_count = 500;
|
|
uint16_t sleep_cycle = 0x0f;
|
|
if (sleep_config) {
|
|
sample_count = sleep_config->sample_count;
|
|
sleep_cycle = sleep_config->sleep_cycle;
|
|
}
|
|
|
|
s_te_obj->sleep_handle = calloc(1, sizeof(struct te_sleep_s));
|
|
TE_CHECK(s_te_obj->sleep_handle, ESP_ERR_NO_MEM);
|
|
|
|
esp_err_t ret = ESP_OK;
|
|
touch_pad_sleep_channel_set_work_time(sleep_cycle, sample_count);
|
|
TE_CHECK_GOTO(esp_sleep_enable_touchpad_wakeup() == ESP_OK, cleanup);
|
|
|
|
TE_CHECK_GOTO(esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON) == ESP_OK, cleanup);
|
|
s_te_obj->sleep_handle->non_volatile_threshold = threshold_shadow;
|
|
|
|
#ifdef CONFIG_PM_ENABLE
|
|
TE_CHECK_GOTO(esp_pm_lock_create(ESP_PM_NO_LIGHT_SLEEP, 0, "touch_element", &s_te_obj->sleep_handle->pm_lock) == ESP_OK, cleanup);
|
|
TE_CHECK_GOTO(esp_pm_lock_acquire(s_te_obj->sleep_handle->pm_lock) == ESP_OK, cleanup);
|
|
#endif
|
|
//Only support one channel/element as the deep sleep wakeup channel/element
|
|
TE_CHECK(is_button_object_handle(wakeup_elem_handle), ESP_ERR_NOT_SUPPORTED);
|
|
s_te_obj->sleep_handle->wakeup_handle = wakeup_elem_handle;
|
|
te_button_handle_t button_handle = wakeup_elem_handle;
|
|
ret = touch_pad_sleep_channel_enable(button_handle->device->channel, true);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
|
|
return ESP_OK;
|
|
|
|
cleanup:
|
|
#ifdef CONFIG_PM_ENABLE
|
|
if (s_te_obj->sleep_handle->pm_lock != NULL) {
|
|
if (esp_pm_lock_delete(s_te_obj->sleep_handle->pm_lock) != ESP_OK) {
|
|
abort();
|
|
}
|
|
}
|
|
#endif
|
|
TE_FREE_AND_NULL(s_te_obj->sleep_handle);
|
|
return ret;
|
|
}
|
|
|
|
esp_err_t touch_element_disable_deep_sleep(void)
|
|
{
|
|
TE_CHECK(s_te_obj->sleep_handle, ESP_ERR_INVALID_STATE);
|
|
esp_err_t ret;
|
|
#ifdef CONFIG_PM_ENABLE
|
|
if (s_te_obj->sleep_handle->pm_lock != NULL) {
|
|
/* Sleep channel is going to uninstall, pm lock is not needed anymore,
|
|
but we need to make sure that pm lock has been released before delete it. */
|
|
while(esp_pm_lock_release(s_te_obj->sleep_handle->pm_lock) == ESP_OK);
|
|
ret = esp_pm_lock_delete(s_te_obj->sleep_handle->pm_lock);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
s_te_obj->sleep_handle->pm_lock = NULL;
|
|
}
|
|
#endif
|
|
te_button_handle_t button_handle = s_te_obj->sleep_handle->wakeup_handle;
|
|
ret = touch_pad_sleep_channel_enable(button_handle->device->channel, false);
|
|
TE_CHECK(ret == ESP_OK, ret);
|
|
esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TOUCHPAD);
|
|
s_te_obj->sleep_handle->wakeup_handle = NULL;
|
|
TE_FREE_AND_NULL(s_te_obj->sleep_handle);
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t touch_element_sleep_enable_wakeup_calibration(touch_elem_handle_t element_handle, bool en)
|
|
{
|
|
TE_CHECK(element_handle != NULL, ESP_ERR_INVALID_ARG);
|
|
if (is_button_object_handle(element_handle)) {
|
|
button_enable_wakeup_calibration(element_handle, en);
|
|
} else if (is_slider_object_handle(element_handle)) {
|
|
slider_enable_wakeup_calibration(element_handle, en);
|
|
} else if (is_matrix_object_handle(element_handle)) {
|
|
matrix_enable_wakeup_calibration(element_handle, en);
|
|
} else {
|
|
return ESP_ERR_NOT_FOUND;
|
|
}
|
|
return ESP_OK;
|
|
}
|