alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
0edb86ddb0
esp-idf/components/touch_element/touch_slider.c

662 lines
28 KiB
C
Raw Normal View History

touch_element: add new touch library component
2020-12-29 22:57:59 -05:00
// 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.
#include <string.h>
#include <sys/queue.h>
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "esp_log.h"
#include "touch_element/touch_element_private.h"
#define TE_SLD_DEFAULT_QTF_THR(obj) ((obj)->global_config->quantify_lower_threshold)
#define TE_SLD_DEFAULT_POS_FILTER_FACTOR(obj) ((obj)->global_config->position_filter_factor)
#define TE_SLD_DEFAULT_CALCULATE_CHANNEL(obj) ((obj)->global_config->calculate_channel_count)
#define TE_SLD_DEFAULT_BCM_UPDATE_TIME(obj) ((obj)->global_config->benchmark_update_time)
#define TE_SLD_DEFAULT_FILTER_RESET_TIME(obj) ((obj)->global_config->filter_reset_time)
#define TE_SLD_DEFAULT_POS_FILTER_SIZE(obj) ((obj)->global_config->position_filter_size)
typedef struct te_slider_handle_list {
te_slider_handle_t slider_handle; //Slider handle
SLIST_ENTRY(te_slider_handle_list) next; //Slider handle list entry
} te_slider_handle_list_t;
typedef struct {
SLIST_HEAD(te_slider_handle_list_head, te_slider_handle_list) handle_list; //Slider handle (instance) list
touch_slider_global_config_t *global_config; //Slider global configuration
SemaphoreHandle_t mutex; //Slider object mutex
} te_slider_obj_t;
te_slider_obj_t *s_te_sld_obj = NULL;
/* ---------------------------------------- Slider handle(instance) methods ----------------------------------------- */
static bool slider_channel_check(te_slider_handle_t slider_handle, touch_pad_t channel_num);
static esp_err_t slider_set_threshold(te_slider_handle_t slider_handle);
static inline te_state_t slider_get_state(te_dev_t **device, int device_num);
static void slider_reset_state(te_slider_handle_t slider_handle);
static void slider_update_position(te_slider_handle_t slider_handle);
static void slider_reset_position(te_slider_handle_t slider_handle);
static void slider_update_benchmark(te_slider_handle_t slider_handle);
static void slider_update_state(te_slider_handle_t slider_handle, touch_pad_t channel_num, te_state_t channel_state);
static void slider_proc_state(te_slider_handle_t slider_handle);
static void slider_event_give(te_slider_handle_t slider_handle);
static inline void slider_dispatch(te_slider_handle_t slider_handle, touch_elem_dispatch_t dispatch_method);
/* ------------------------------------------ Slider object(class) methods ------------------------------------------ */
static esp_err_t slider_object_add_instance(te_slider_handle_t slider_handle);
static esp_err_t slider_object_remove_instance(te_slider_handle_t slider_handle);
static bool slider_object_check_channel(touch_pad_t channel_num);
static esp_err_t slider_object_set_threshold(void);
static void slider_object_process_state(void);
static void slider_object_update_state(touch_pad_t channel_num, te_state_t channel_state);
/* ------------------------------------------------------------------------------------------------------------------ */
esp_err_t touch_slider_install(const touch_slider_global_config_t *global_config)
{
TE_CHECK(te_system_check_state() == true, ESP_ERR_INVALID_STATE);
TE_CHECK(global_config != NULL, ESP_ERR_INVALID_ARG);
//Fixme: Make it thread-safe
s_te_sld_obj = (te_slider_obj_t *)calloc(1, sizeof(te_slider_obj_t));
TE_CHECK(s_te_sld_obj != NULL, ESP_ERR_NO_MEM);
s_te_sld_obj->global_config = (touch_slider_global_config_t *)calloc(1, sizeof(touch_slider_global_config_t));
s_te_sld_obj->mutex = xSemaphoreCreateMutex();
TE_CHECK_GOTO(s_te_sld_obj->global_config != NULL && s_te_sld_obj->mutex != NULL, cleanup);
xSemaphoreTake(s_te_sld_obj->mutex, portMAX_DELAY);
SLIST_INIT(&s_te_sld_obj->handle_list);
memcpy(s_te_sld_obj->global_config, global_config, sizeof(touch_slider_global_config_t));
te_object_methods_t slider_methods = {
.handle = s_te_sld_obj,
.check_channel = slider_object_check_channel,
.set_threshold = slider_object_set_threshold,
.process_state = slider_object_process_state,
.update_state = slider_object_update_state
};
te_object_method_register(&slider_methods, TE_CLS_TYPE_SLIDER);
xSemaphoreGive(s_te_sld_obj->mutex);
return ESP_OK;
cleanup:
TE_FREE_AND_NULL(s_te_sld_obj->global_config);
if (s_te_sld_obj->mutex != NULL) {
vSemaphoreDelete(s_te_sld_obj->mutex);
}
TE_FREE_AND_NULL(s_te_sld_obj);
return ESP_ERR_NO_MEM;
}
void touch_slider_uninstall(void)
{
xSemaphoreTake(s_te_sld_obj->mutex, portMAX_DELAY);
if (s_te_sld_obj == NULL) {
xSemaphoreGive(s_te_sld_obj->mutex);
return;
}
te_object_method_unregister(TE_CLS_TYPE_SLIDER);
free(s_te_sld_obj->global_config);
s_te_sld_obj->global_config = NULL;
while (!SLIST_EMPTY(&s_te_sld_obj->handle_list)) {
SLIST_FIRST(&s_te_sld_obj->handle_list);
SLIST_REMOVE_HEAD(&s_te_sld_obj->handle_list, next);
}
xSemaphoreGive(s_te_sld_obj->mutex);
vSemaphoreDelete(s_te_sld_obj->mutex);
free(s_te_sld_obj);
s_te_sld_obj = NULL;
}
esp_err_t touch_slider_create(const touch_slider_config_t *slider_config, touch_slider_handle_t *slider_handle)
{
TE_CHECK(s_te_sld_obj != NULL, ESP_ERR_INVALID_STATE);
TE_CHECK(slider_handle != NULL && slider_config != NULL, ESP_ERR_INVALID_ARG);
TE_CHECK(slider_config->channel_num > 2 &&
slider_config->channel_num < TOUCH_PAD_MAX &&
slider_config->channel_array != NULL &&
slider_config->sensitivity_array != NULL &&
slider_config->position_range > slider_config->channel_num,
ESP_ERR_INVALID_ARG);
TE_CHECK(te_object_check_channel(slider_config->channel_array, slider_config->channel_num) == false,
ESP_ERR_INVALID_ARG);
te_slider_handle_t te_slider = (te_slider_handle_t)calloc(1, sizeof(struct te_slider_s));
TE_CHECK(te_slider != NULL, ESP_ERR_NO_MEM);
esp_err_t ret = ESP_ERR_NO_MEM;
te_slider->config = (te_slider_handle_config_t *)calloc(1, sizeof(te_slider_handle_config_t));
te_slider->pos_filter_window = calloc(TE_SLD_DEFAULT_POS_FILTER_SIZE(s_te_sld_obj), sizeof(uint8_t));
te_slider->device = (te_dev_t **)calloc(slider_config->channel_num, sizeof(te_dev_t *));
te_slider->channel_bcm = (uint32_t *)calloc(slider_config->channel_num, sizeof(uint32_t));
te_slider->quantify_signal_array = (float *)calloc(slider_config->channel_num, sizeof(float));
TE_CHECK_GOTO(te_slider->config != NULL &&
te_slider->pos_filter_window != NULL &&
te_slider->device != NULL &&
te_slider->channel_bcm &&
te_slider->quantify_signal_array,
cleanup);
for (int idx = 0; idx < slider_config->channel_num; idx++) {
te_slider->device[idx] = (te_dev_t *)calloc(1, sizeof(te_dev_t));
if (te_slider->device[idx] == NULL) {
ret = ESP_ERR_NO_MEM;
goto cleanup;
}
}
ret = te_dev_init(te_slider->device, slider_config->channel_num, TOUCH_ELEM_TYPE_SLIDER,
slider_config->channel_array, slider_config->sensitivity_array,
TE_DEFAULT_THRESHOLD_DIVIDER(s_te_sld_obj));
TE_CHECK_GOTO(ret == ESP_OK, cleanup);
te_slider->config->event_mask = TOUCH_ELEM_EVENT_NONE;
te_slider->config->dispatch_method = TOUCH_ELEM_DISP_MAX;
te_slider->config->callback = NULL;
te_slider->config->arg = NULL;
te_slider->channel_bcm_update_cnt = TE_SLD_DEFAULT_BCM_UPDATE_TIME(s_te_sld_obj); //update at first time
te_slider->filter_reset_cnt = TE_SLD_DEFAULT_FILTER_RESET_TIME(s_te_sld_obj); //reset at first time
te_slider->channel_sum = slider_config->channel_num;
te_slider->position_range = slider_config->position_range;
te_slider->position_scale = (float)(slider_config->position_range) / (slider_config->channel_num - 1);
te_slider->current_state = TE_STATE_IDLE;
te_slider->last_state = TE_STATE_IDLE;
te_slider->event = TOUCH_SLIDER_EVT_MAX;
te_slider->position = 0;
te_slider->last_position = 0;
te_slider->pos_window_idx = 0;
te_slider->is_first_sample = true;
ret = slider_object_add_instance(te_slider);
TE_CHECK_GOTO(ret == ESP_OK, cleanup);
*slider_handle = (touch_elem_handle_t)te_slider;
return ESP_OK;
cleanup:
TE_FREE_AND_NULL(te_slider->config);
TE_FREE_AND_NULL(te_slider->pos_filter_window);
TE_FREE_AND_NULL(te_slider->channel_bcm);
TE_FREE_AND_NULL(te_slider->quantify_signal_array);
if (te_slider->device != NULL) {
for (int idx = 0; idx < slider_config->channel_num; idx++) {
TE_FREE_AND_NULL(te_slider->device[idx]);
}
free(te_slider->device);
te_slider->device = NULL;
}
TE_FREE_AND_NULL(te_slider);
return ret;
}
esp_err_t touch_slider_delete(touch_slider_handle_t slider_handle)
{
TE_CHECK(s_te_sld_obj != NULL, ESP_ERR_INVALID_STATE);
TE_CHECK(slider_handle != NULL, ESP_ERR_INVALID_ARG);
/*< Release touch sensor application resource */
esp_err_t ret = slider_object_remove_instance(slider_handle);
TE_CHECK(ret == ESP_OK, ret);
te_slider_handle_t te_slider = (te_slider_handle_t)slider_handle;
/*< Release touch sensor device resource */
te_dev_deinit(te_slider->device, te_slider->channel_sum);
for (int idx = 0; idx < te_slider->channel_sum; idx++) {
free(te_slider->device[idx]);
}
free(te_slider->config);
free(te_slider->quantify_signal_array);
free(te_slider->pos_filter_window);
free(te_slider->channel_bcm);
free(te_slider->device);
free(te_slider);
return ESP_OK;
}
esp_err_t touch_slider_set_dispatch_method(touch_slider_handle_t slider_handle, touch_elem_dispatch_t dispatch_method)
{
TE_CHECK(s_te_sld_obj != NULL, ESP_ERR_INVALID_STATE);
TE_CHECK(slider_handle != NULL, ESP_ERR_INVALID_ARG);
TE_CHECK(dispatch_method >= TOUCH_ELEM_DISP_EVENT && dispatch_method <= TOUCH_ELEM_DISP_MAX, ESP_ERR_INVALID_ARG);
xSemaphoreTake(s_te_sld_obj->mutex, portMAX_DELAY);
te_slider_handle_t te_slider = (te_slider_handle_t)slider_handle;
te_slider->config->dispatch_method = dispatch_method;
xSemaphoreGive(s_te_sld_obj->mutex);
return ESP_OK;
}
esp_err_t touch_slider_subscribe_event(touch_slider_handle_t slider_handle, uint32_t event_mask, void *arg)
{
TE_CHECK(s_te_sld_obj != NULL, ESP_ERR_INVALID_STATE);
TE_CHECK(slider_handle != NULL, ESP_ERR_INVALID_ARG);
if (!(event_mask & TOUCH_ELEM_EVENT_ON_PRESS) && !(event_mask & TOUCH_ELEM_EVENT_ON_RELEASE) &&
!(event_mask & TOUCH_ELEM_EVENT_NONE) && !(event_mask & TOUCH_ELEM_EVENT_ON_CALCULATION)) {
ESP_LOGE(TE_TAG, "Touch button only support TOUCH_ELEM_EVENT_ON_PRESS, "
"TOUCH_ELEM_EVENT_ON_RELEASE, TOUCH_ELEM_EVENT_ON_CALCULATION event mask");
return ESP_ERR_INVALID_ARG;
}
xSemaphoreTake(s_te_sld_obj->mutex, portMAX_DELAY);
te_slider_handle_t te_slider = (te_slider_handle_t)slider_handle;
te_slider->config->event_mask = event_mask;
te_slider->config->arg = arg;
xSemaphoreGive(s_te_sld_obj->mutex);
return ESP_OK;
}
esp_err_t touch_slider_set_callback(touch_slider_handle_t slider_handle, touch_slider_callback_t slider_callback)
{
TE_CHECK(s_te_sld_obj != NULL, ESP_ERR_INVALID_STATE);
TE_CHECK(slider_handle != NULL, ESP_ERR_INVALID_ARG);
TE_CHECK(slider_callback != NULL, ESP_ERR_INVALID_ARG);
te_slider_handle_t te_slider = (te_slider_handle_t)slider_handle;
xSemaphoreTake(s_te_sld_obj->mutex, portMAX_DELAY);
te_slider->config->callback = slider_callback;
xSemaphoreGive(s_te_sld_obj->mutex);
return ESP_OK;
}
const touch_slider_message_t* touch_slider_get_message(const touch_elem_message_t* element_message)
{
return (touch_slider_message_t*)&element_message->child_msg;
_Static_assert(sizeof(element_message->child_msg) >= sizeof(touch_slider_message_t), "Message size overflow");
}
static bool slider_object_check_channel(touch_pad_t channel_num)
{
te_slider_handle_list_t *item;
SLIST_FOREACH(item, &s_te_sld_obj->handle_list, next) {
if (slider_channel_check(item->slider_handle, channel_num)) {
return true;
}
}
return false;
}
static esp_err_t slider_object_set_threshold(void)
{
esp_err_t ret = ESP_OK;
te_slider_handle_list_t *item;
SLIST_FOREACH(item, &s_te_sld_obj->handle_list, next) {
ret = slider_set_threshold(item->slider_handle);
if (ret != ESP_OK) {
break;
}
}
return ret;
}
static void slider_object_process_state(void)
{
te_slider_handle_list_t *item;
SLIST_FOREACH(item, &s_te_sld_obj->handle_list, next) {
if (waterproof_check_mask_handle(item->slider_handle)) {
slider_reset_state(item->slider_handle);
slider_reset_position(item->slider_handle);
continue;
}
slider_proc_state(item->slider_handle);
}
}
static void slider_object_update_state(touch_pad_t channel_num, te_state_t channel_state)
{
te_slider_handle_list_t *item;
SLIST_FOREACH(item, &s_te_sld_obj->handle_list, next) {
if (waterproof_check_mask_handle(item->slider_handle)) {
continue;
}
slider_update_state(item->slider_handle, channel_num, channel_state);
}
}
static esp_err_t slider_object_add_instance(te_slider_handle_t slider_handle)
{
te_slider_handle_list_t *item = (te_slider_handle_list_t *)calloc(1, sizeof(te_slider_handle_list_t));
TE_CHECK(item != NULL, ESP_ERR_NO_MEM);
item->slider_handle = slider_handle;
xSemaphoreTake(s_te_sld_obj->mutex, portMAX_DELAY);
SLIST_INSERT_HEAD(&s_te_sld_obj->handle_list, item, next);
xSemaphoreGive(s_te_sld_obj->mutex);
return ESP_OK;
}
static esp_err_t slider_object_remove_instance(te_slider_handle_t slider_handle)
{
esp_err_t ret = ESP_ERR_NOT_FOUND;
te_slider_handle_list_t *item;
SLIST_FOREACH(item, &s_te_sld_obj->handle_list, next) {
if (slider_handle == item->slider_handle) {
xSemaphoreTake(s_te_sld_obj->mutex, portMAX_DELAY);
SLIST_REMOVE(&s_te_sld_obj->handle_list, item, te_slider_handle_list, next);
xSemaphoreGive(s_te_sld_obj->mutex);
free(item);
ret = ESP_OK;
break;
}
}
return ret;
}
static bool slider_channel_check(te_slider_handle_t slider_handle, touch_pad_t channel_num)
{
te_dev_t *device;
for (int idx = 0; idx < slider_handle->channel_sum; idx++) {
device = slider_handle->device[idx];
if (device->channel == channel_num) {
return true;
}
}
return false;
}
static esp_err_t slider_set_threshold(te_slider_handle_t slider_handle)
{
esp_err_t ret = ESP_OK;
for (int idx = 0; idx < slider_handle->channel_sum; idx++) {
ret |= te_dev_set_threshold(slider_handle->device[idx]);
}
slider_update_benchmark(slider_handle); //Update benchmark at startup
return ret;
}
static void slider_update_benchmark(te_slider_handle_t slider_handle)
{
for (int idx = 0; idx < slider_handle->channel_sum; idx++) {
uint32_t bcm_val;
te_dev_t *device = slider_handle->device[idx];
bcm_val = te_read_smooth_signal(device->channel);
slider_handle->channel_bcm[idx] = bcm_val;
}
}
static void slider_update_state(te_slider_handle_t slider_handle, touch_pad_t channel_num, te_state_t channel_state)
{
te_dev_t *device;
for (int idx = 0; idx < slider_handle->channel_sum; idx++) {
device = slider_handle->device[idx];
if (channel_num == device->channel) {
device->state = channel_state;
}
}
}
static void slider_reset_state(te_slider_handle_t slider_handle)
{
for (int idx = 0; idx < slider_handle->channel_sum; idx++) {
slider_handle->device[idx]->state = TE_STATE_IDLE;
}
slider_handle->current_state = TE_STATE_IDLE;
}
static void slider_event_give(te_slider_handle_t slider_handle)
{
touch_elem_message_t element_message;
touch_slider_message_t slider_message = {
.event = slider_handle->event,
.position = slider_handle->position
};
element_message.handle = (touch_elem_handle_t)slider_handle;
element_message.element_type = TOUCH_ELEM_TYPE_SLIDER;
element_message.arg = slider_handle->config->arg;
memcpy(element_message.child_msg, &slider_message, sizeof(slider_message));
te_event_give(element_message);
}
static inline void slider_dispatch(te_slider_handle_t slider_handle, touch_elem_dispatch_t dispatch_method)
{
if (dispatch_method == TOUCH_ELEM_DISP_EVENT) {
slider_event_give(slider_handle); //Event queue
} else if (dispatch_method == TOUCH_ELEM_DISP_CALLBACK) {
touch_slider_message_t slider_info;
slider_info.event = slider_handle->event;
slider_info.position = slider_handle->position;
void *arg = slider_handle->config->arg;
slider_handle->config->callback(slider_handle, slider_info, arg); //Event callback
}
}
/**
* @brief Slider process
*
* This function will process the slider state and maintain a slider FSM:
* IDLE ----> Press ----> Release ----> IDLE
*
* The state transition procedure is as follow:
* (channel state ----> slider state)
*
* TODO: add state transition diagram
*/
static void slider_proc_state(te_slider_handle_t slider_handle)
{
uint32_t event_mask = slider_handle->config->event_mask;
touch_elem_dispatch_t dispatch_method = slider_handle->config->dispatch_method;
BaseType_t mux_ret = xSemaphoreTake(s_te_sld_obj->mutex, 0);
if (mux_ret != pdPASS) {
return;
}
slider_handle->current_state = slider_get_state(slider_handle->device, slider_handle->channel_sum);
if (slider_handle->current_state == TE_STATE_PRESS) {
slider_handle->channel_bcm_update_cnt = 0; // Reset benchmark update counter
slider_update_position(slider_handle);
if (slider_handle->last_state == TE_STATE_IDLE) { //IDLE ---> Press = On_Press
ESP_LOGD(TE_DEBUG_TAG, "slider press");
if (event_mask & TOUCH_ELEM_EVENT_ON_PRESS) {
slider_handle->event = TOUCH_SLIDER_EVT_ON_PRESS;
slider_dispatch(slider_handle, dispatch_method);
}
} else if (slider_handle->last_state == TE_STATE_PRESS) { //Press ---> Press = On_Calculation
ESP_LOGD(TE_DEBUG_TAG, "slider calculation");
if (event_mask & TOUCH_ELEM_EVENT_ON_CALCULATION) {
slider_handle->event = TOUCH_SLIDER_EVT_ON_CALCULATION;
slider_dispatch(slider_handle, dispatch_method);
}
}
} else if (slider_handle->current_state == TE_STATE_RELEASE) {
if (slider_handle->last_state == TE_STATE_PRESS) { //Press ---> Release = On_Release
ESP_LOGD(TE_DEBUG_TAG, "slider release");
if (event_mask & TOUCH_ELEM_EVENT_ON_RELEASE) {
slider_handle->event = TOUCH_SLIDER_EVT_ON_RELEASE;
slider_dispatch(slider_handle, dispatch_method);
}
} else if (slider_handle->last_state == TE_STATE_RELEASE) { // Release ---> Release = On_IDLE (Not dispatch)
slider_reset_state(slider_handle);//Reset the slider state for the next time touch action detection
}
} else if (slider_handle->current_state == TE_STATE_IDLE) {
if (slider_handle->last_state == TE_STATE_RELEASE) { //Release ---> IDLE = On_IDLE (Not dispatch)
//Nothing
} else if (slider_handle->last_state == TE_STATE_IDLE) { //IDLE ---> IDLE = Running IDLE (Not dispatch)
if (++slider_handle->channel_bcm_update_cnt >= TE_SLD_DEFAULT_BCM_UPDATE_TIME(s_te_sld_obj)) { //Update channel benchmark
slider_handle->channel_bcm_update_cnt = 0;
slider_update_benchmark(slider_handle);
ESP_LOGD(TE_DEBUG_TAG, "slider bcm update");
}
if (++slider_handle->filter_reset_cnt >= TE_SLD_DEFAULT_FILTER_RESET_TIME(s_te_sld_obj)) {
slider_reset_position(slider_handle); //Reset slider filter so as to speed up next time position calculation
}
}
}
slider_handle->last_state = slider_handle->current_state;
xSemaphoreGive(s_te_sld_obj->mutex);
}
static inline te_state_t slider_get_state(te_dev_t **device, int device_num)
{
/*< Scan the state of all the slider channel and calculate the number of them if the state is Press*/
uint8_t press_cnt = 0;
uint8_t idle_cnt = 0;
for (int idx = 0; idx < device_num; idx++) { //Calculate how many channel is pressed
if (device[idx]->state == TE_STATE_PRESS) {
press_cnt++;
} else if (device[idx]->state == TE_STATE_IDLE) {
idle_cnt++;
}
}
if (press_cnt > 0) {
return TE_STATE_PRESS;
} else if (idle_cnt == device_num) {
return TE_STATE_IDLE;
} else {
return TE_STATE_RELEASE;
}
}
/**
* @brief Slider channel difference-rate re-quantization
*
* This function will re-quantifies the touch sensor slider channel difference-rate
* so as to make the different size of touch pad in PCB has the same difference value
*
*/
static inline void slider_quantify_signal(te_slider_handle_t slider_handle)
{
float weight_sum = 0;
for (int idx = 0; idx < slider_handle->channel_sum; idx++) {
te_dev_t *device = slider_handle->device[idx];
weight_sum += device->sens;
uint32_t current_signal = te_read_smooth_signal(device->channel);
int ans = current_signal - slider_handle->channel_bcm[idx];
float diff_rate = (float)ans / slider_handle->channel_bcm[idx];
slider_handle->quantify_signal_array[idx] = diff_rate / device->sens;
if (slider_handle->quantify_signal_array[idx] < TE_SLD_DEFAULT_QTF_THR(s_te_sld_obj)) {
slider_handle->quantify_signal_array[idx] = 0;
}
}
for (int idx = 0; idx < slider_handle->channel_sum; idx++) {
te_dev_t *device = slider_handle->device[idx];
slider_handle->quantify_signal_array[idx] = slider_handle->quantify_signal_array[idx] * weight_sum / device->sens;
}
}
/**
* @brief Calculate max sum subarray
*
* This function will figure out the max sum subarray from the
* input array, return the max sum and max sum start index
*
*/
static inline float slider_search_max_subarray(const float *array, int array_size, int *max_array_idx)
{
*max_array_idx = 0;
float max_array_sum = 0;
float current_array_sum = 0;
for (int idx = 0; idx <= (array_size - TE_SLD_DEFAULT_CALCULATE_CHANNEL(s_te_sld_obj)); idx++) {
for (int x = idx; x < idx + TE_SLD_DEFAULT_CALCULATE_CHANNEL(s_te_sld_obj); x++) {
current_array_sum += array[x];
}
if (max_array_sum < current_array_sum) {
max_array_sum = current_array_sum;
*max_array_idx = idx;
}
current_array_sum = 0;
}
return max_array_sum;
}
/**
* @brief Calculate zero number
*
* This function will figure out the number of non-zero items from
* the subarray
*/
static inline uint8_t slider_get_non_zero_num(const float *array, uint8_t array_idx)
{
uint8_t zero_cnt = 0;
for (int idx = array_idx; idx < array_idx + TE_SLD_DEFAULT_CALCULATE_CHANNEL(s_te_sld_obj); idx++) {
zero_cnt += (array[idx] > 0) ? 1 : 0;
}
return zero_cnt;
}
static inline uint32_t slider_calculate_position(te_slider_handle_t slider_handle, int subarray_index, float subarray_sum, int non_zero_num)
{
int range = slider_handle->position_range;
int array_size = slider_handle->channel_sum;
float scale = slider_handle->position_scale;
const float *array = slider_handle->quantify_signal_array;
uint32_t position = 0;
if (non_zero_num == 0) {
position = slider_handle->position;
} else if (non_zero_num == 1) {
for (int index = subarray_index; index < subarray_index + TE_SLD_DEFAULT_CALCULATE_CHANNEL(s_te_sld_obj); index++) {
if (0 != array[index]) {
if (index == array_size - 1) {
position = range;
} else {
position = (uint32_t)((float)index * scale);
}
break;
}
}
} else {
for (int idx = subarray_index; idx < subarray_index + TE_SLD_DEFAULT_CALCULATE_CHANNEL(s_te_sld_obj); idx++) {
position += ((float)idx * array[idx]);
}
position = position * scale / subarray_sum;
}
return position;
}
static uint32_t slider_filter_average(te_slider_handle_t slider_handle, uint32_t current_position)
{
uint32_t position_average = 0;
if (slider_handle->is_first_sample) {
for (int win_idx = 0; win_idx < TE_SLD_DEFAULT_POS_FILTER_SIZE(s_te_sld_obj); win_idx++) {
slider_handle->pos_filter_window[win_idx] = current_position; //Preload filter buffer
}
slider_handle->is_first_sample = false;
} else {
slider_handle->pos_filter_window[slider_handle->pos_window_idx++] = current_position; //Moving average filter
if (slider_handle->pos_window_idx >= TE_SLD_DEFAULT_POS_FILTER_SIZE(s_te_sld_obj)) {
slider_handle->pos_window_idx = 0;
}
}
for (int win_idx = 0; win_idx < TE_SLD_DEFAULT_POS_FILTER_SIZE(s_te_sld_obj); win_idx++) { //Moving average filter
position_average += slider_handle->pos_filter_window[win_idx];
}
position_average = position_average / TE_SLD_DEFAULT_POS_FILTER_SIZE(s_te_sld_obj) + 0.5;
return position_average;
}
static inline uint32_t slider_filter_iir(uint32_t in_now, uint32_t out_last, uint32_t k)
{
if (k == 0) {
return in_now;
} else {
uint32_t out_now = (in_now + (k - 1) * out_last) / k;
return out_now;
}
}
/**
* @brief touch sensor slider position update
*
* This function is the core algorithm about touch sensor slider
* position update, mainly has several steps:
* 1. Re-quantization
* 2. Figure out changed channel
* 3. Calculate position
* 4. Filter
*
*/
static void slider_update_position(te_slider_handle_t slider_handle)
{
int max_array_idx = 0;
float max_array_sum;
uint8_t non_zero_num;
uint32_t current_position;
slider_quantify_signal(slider_handle);
max_array_sum = slider_search_max_subarray(slider_handle->quantify_signal_array, slider_handle->channel_sum, &max_array_idx);
non_zero_num = slider_get_non_zero_num(slider_handle->quantify_signal_array, max_array_idx);
current_position = slider_calculate_position(slider_handle, max_array_idx, max_array_sum, non_zero_num);
uint32_t position_average = slider_filter_average(slider_handle, current_position);
slider_handle->last_position = slider_handle->last_position == 0 ? (position_average << 4) : slider_handle->last_position;
slider_handle->last_position = slider_filter_iir((position_average << 4), slider_handle->last_position, TE_SLD_DEFAULT_POS_FILTER_FACTOR(s_te_sld_obj));
slider_handle->position = ((slider_handle->last_position + 8) >> 4); //(x + 8) >> 4 ----> (x + 8) / 16 ----> x/16 + 0.5
}
static void slider_reset_position(te_slider_handle_t slider_handle)
{
slider_handle->is_first_sample = true;
slider_handle->last_position = 0;
slider_handle->pos_window_idx = 0;
}
Reference in New Issue Copy Permalink