/* * 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; }