| /* |
| * Copyright 2016-2021, Cypress Semiconductor Corporation (an Infineon company) or |
| * an affiliate of Cypress Semiconductor Corporation. All rights reserved. |
| * |
| * This software, including source code, documentation and related |
| * materials ("Software") is owned by Cypress Semiconductor Corporation |
| * or one of its affiliates ("Cypress") and is protected by and subject to |
| * worldwide patent protection (United States and foreign), |
| * United States copyright laws and international treaty provisions. |
| * Therefore, you may use this Software only as provided in the license |
| * agreement accompanying the software package from which you |
| * obtained this Software ("EULA"). |
| * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, |
| * non-transferable license to copy, modify, and compile the Software |
| * source code solely for use in connection with Cypress's |
| * integrated circuit products. Any reproduction, modification, translation, |
| * compilation, or representation of this Software except as specified |
| * above is prohibited without the express written permission of Cypress. |
| * |
| * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress |
| * reserves the right to make changes to the Software without notice. Cypress |
| * does not assume any liability arising out of the application or use of the |
| * Software or any product or circuit described in the Software. Cypress does |
| * not authorize its products for use in any products where a malfunction or |
| * failure of the Cypress product may reasonably be expected to result in |
| * significant property damage, injury or death ("High Risk Product"). By |
| * including Cypress's product in a High Risk Product, the manufacturer |
| * of such system or application assumes all risk of such use and in doing |
| * so agrees to indemnify Cypress against all liability. |
| */ |
| /** @file |
| * |
| * Button manager implements generic interface for button events and button type configurations. |
| * It exposes interface to configure platform button events (like click,long press) with user configurable timing. |
| */ |
| #include "wiced_button_manager.h" |
| #include "clock_timer.h" |
| #include "platform_button.h" |
| #include "string.h" |
| #include "wiced_bt_trace.h" |
| #ifdef CYW55572 |
| #include "wiced_memory.h" |
| #include "wiced_misc_rtos_utils.h" |
| #endif |
| |
| /****************************************************** |
| * Macros |
| ******************************************************/ |
| |
| #define BUTTON_TIMER_TIMEOUT (100) /*msec*/ |
| |
| /****************************************************** |
| * Constants |
| ******************************************************/ |
| |
| /****************************************************** |
| * Enumerations |
| ******************************************************/ |
| |
| /****************************************************** |
| * Type Definitions |
| ******************************************************/ |
| #if BTSTACK_VER >= 0x03000001 |
| #define TIMER_PARAM_TYPE WICED_TIMER_PARAM_TYPE |
| #endif |
| |
| #ifdef CYW55572 |
| #define BUTTON_EVENT_QUEUE_DEPTH 16 |
| #endif |
| |
| /****************************************************** |
| * Structures |
| ******************************************************/ |
| #ifdef CYW55572 |
| typedef struct |
| { |
| button_manager_button_t * p_button; |
| button_manager_event_t event; |
| } button_event_defer_to_mpaf_t; |
| #endif |
| |
| /****************************************************** |
| * Function Declarations |
| ******************************************************/ |
| static void button_state_change_callback(platform_button_t id, wiced_bool_t new_state); |
| static wiced_result_t button_pressed_event_handler(void * arg); |
| static wiced_result_t button_released_event_handler(void * arg); |
| static wiced_result_t deferred_button_timer_handler(void * arg); |
| |
| static wiced_bool_t button_check_event_mask(button_manager_button_t * button, uint16_t new_event); |
| static void button_check_for_double_click(button_manager_button_t * button, button_manager_event_t * new_event); |
| static button_manager_event_t button_deduce_duration_event(button_manager_button_t * button, uint32_t current_interval); |
| static button_manager_button_t * get_button(platform_button_t id); |
| #ifdef CYW55572 |
| static void button_event_defer_to_mpaf(void * arg); |
| #endif |
| |
| /****************************************************** |
| * Variables Definitions |
| ******************************************************/ |
| static button_manager_t * button_manager; |
| #ifdef CYW55572 |
| static wiced_mutex_t * p_mutex_button_event; |
| static wiced_bt_buffer_q_t button_event_queue; |
| static wiced_bt_pool_t * p_button_event_pool = NULL; |
| #endif |
| |
| /****************************************************** |
| * Function Definitions |
| ******************************************************/ |
| |
| /* |
| * button_long_press_detect_timeout_handler |
| * |
| * Timeout handler for button long press detect timer. |
| * |
| * The execution duration of this utility is defined in BUTTON_TIMER_TIMEOUT. |
| */ |
| static void button_long_press_detect_timeout_handler(TIMER_PARAM_TYPE arg) |
| { |
| button_manager_button_t * p_button = (button_manager_button_t *) arg; |
| |
| /* Check if button is under debouncing state. */ |
| if (p_button->debouncing) |
| { |
| return; |
| } |
| |
| /* Get current button state. */ |
| p_button->current_state = (button_manager_button_state_t) platform_button_get_value(p_button->configuration->button); |
| |
| if (p_button->current_state != BUTTON_STATE_HELD) |
| { |
| WICED_BT_TRACE("Err: Button %d is already released\n", p_button->configuration->button); |
| |
| if (wiced_is_timer_in_use(&p_button->long_press_timer)) |
| { |
| wiced_stop_timer(&p_button->long_press_timer); |
| } |
| |
| return; |
| } |
| /* Get current timestatmp. */ |
| p_button->timer_timestamp = clock_SystemTimeMicroseconds64(); |
| |
| deferred_button_timer_handler((void *) p_button); |
| } |
| |
| /* |
| * button_debounce_timeout_handler |
| * |
| * Timeout handler for button debounce timer. |
| */ |
| static void button_debounce_timeout_handler(TIMER_PARAM_TYPE arg) |
| { |
| button_manager_button_t * p_button = (button_manager_button_t *) arg; |
| wiced_result_t result; |
| |
| // WICED_BT_TRACE("button_debounce_timeout_handler (%d, %d)\n", p_button->configuration->button, p_button->debounce_counter); |
| |
| if (p_button->debounce_counter > 0) |
| { |
| /* Reset the button debounce counter. */ |
| p_button->debounce_counter = 0; |
| |
| button_pressed_event_handler((void *) p_button); |
| } |
| else |
| { |
| if (wiced_is_timer_in_use(&p_button->long_press_timer)) |
| { |
| wiced_stop_timer(&p_button->long_press_timer); |
| } |
| } |
| |
| /* Reset the button debounce state. */ |
| p_button->debouncing = WICED_FALSE; |
| } |
| |
| /** |
| * The application should call this function to Initialize the Button Manager |
| */ |
| wiced_result_t __attribute__((weak)) |
| wiced_button_manager_init(button_manager_t * manager, const wiced_button_manager_configuration_t * configuration, |
| button_manager_button_t * buttons, uint32_t number_of_buttons) |
| { |
| uint32_t a; |
| |
| memset(manager, 0, sizeof(*manager)); |
| |
| manager->configuration = configuration; |
| manager->buttons = buttons; |
| manager->number_of_buttons = number_of_buttons; |
| |
| button_manager = manager; |
| |
| for (a = 0; a < number_of_buttons; a++) |
| { |
| platform_button_init(buttons[a].configuration->button); |
| platform_button_enable(buttons[a].configuration->button); |
| buttons[a].current_state = BUTTON_STATE_RELEASED; |
| buttons[a].repeat = 0; |
| buttons[a].debounce_counter = 0; |
| buttons[a].debouncing = WICED_FALSE; |
| } |
| |
| platform_button_register_state_change_callback(button_state_change_callback); |
| |
| /* Initialize the timers used for detecting the long press event. */ |
| for (a = 0; a < number_of_buttons; a++) |
| { |
| wiced_init_timer(&buttons[a].long_press_timer, button_long_press_detect_timeout_handler, (TIMER_PARAM_TYPE) &buttons[a], |
| WICED_MILLI_SECONDS_PERIODIC_TIMER); |
| } |
| |
| /* Initialize the timers used for de-bounce. */ |
| for (a = 0; a < number_of_buttons; a++) |
| { |
| wiced_init_timer(&buttons[a].debounce_timer, button_debounce_timeout_handler, (TIMER_PARAM_TYPE) &buttons[a], |
| WICED_MILLI_SECONDS_TIMER); |
| } |
| |
| #ifdef CYW55572 |
| p_button_event_pool = |
| wiced_bt_create_pool("Button Event", sizeof(button_event_defer_to_mpaf_t), BUTTON_EVENT_QUEUE_DEPTH, NULL); |
| |
| if (!p_button_event_pool) |
| { |
| WICED_BT_TRACE("%s: Fail to create pool.\n", __FUNCTION__); |
| return WICED_ERROR; |
| } |
| |
| wiced_bt_init_q(&button_event_queue, NULL); |
| p_mutex_button_event = wiced_rtos_create_mutex(); |
| if (p_mutex_button_event == NULL) |
| { |
| WICED_BT_TRACE("%s: Fail to create mutex.\n", __FUNCTION__); |
| return WICED_ERROR; |
| } |
| |
| if (wiced_rtos_init_mutex(p_mutex_button_event) != WICED_SUCCESS) |
| { |
| WICED_BT_TRACE("%s: Fail to init. mutex.\n", __FUNCTION__); |
| return WICED_ERROR; |
| } |
| #endif |
| |
| return WICED_SUCCESS; |
| } |
| |
| /** |
| * The application should call this function to de-Initialize the Button Manager |
| * |
| * @param manager : Pointer to button manager to de-initialize. |
| * @return : result. |
| */ |
| wiced_result_t wiced_button_manager_deinit(button_manager_t * manager) |
| { |
| uint32_t a; |
| for (a = 0; a < manager->number_of_buttons; a++) |
| { |
| platform_button_disable(manager->buttons[a].configuration->button); |
| platform_button_deinit(manager->buttons[a].configuration->button); |
| } |
| |
| for (a = 0; a < manager->number_of_buttons; a++) |
| { |
| if (WICED_TRUE == wiced_is_timer_in_use(&manager->buttons[a].debounce_timer)) |
| { |
| wiced_stop_timer(&manager->buttons[a].debounce_timer); |
| } |
| |
| wiced_deinit_timer(&manager->buttons[a].debounce_timer); |
| |
| if (WICED_TRUE == wiced_is_timer_in_use(&manager->buttons[a].long_press_timer)) |
| { |
| wiced_stop_timer(&manager->buttons[a].long_press_timer); |
| } |
| |
| wiced_deinit_timer(&manager->buttons[a].long_press_timer); |
| } |
| |
| button_manager = NULL; |
| return WICED_SUCCESS; |
| } |
| |
| /** |
| * Deferred Handler initiated from timer handler |
| * |
| * @param arg : Arguments passed by the timer framework to timer handler |
| * @return : result |
| */ |
| static wiced_result_t deferred_button_timer_handler(void * arg) |
| { |
| button_manager_button_t * p_button = (button_manager_button_t *) arg; |
| uint64_t duration; // us |
| button_manager_event_t new_held_event = 0; |
| |
| /* Check current button state. */ |
| if (p_button->current_state == BUTTON_STATE_RELEASED) |
| { |
| return WICED_SUCCESS; |
| } |
| |
| /* Calculate the time difference. */ |
| duration = p_button->timer_timestamp - p_button->pressed_timestamp; // us |
| duration = duration / 1000; // ms |
| |
| /* deduce the event depending on the duration */ |
| new_held_event = button_deduce_duration_event(p_button, (uint32_t) duration); |
| |
| /* |
| * timers should be mainly interested in duration-specific events; |
| * let release_handler only report Click events to the application |
| */ |
| if (new_held_event == BUTTON_CLICK_EVENT) |
| { |
| return WICED_SUCCESS; |
| } |
| |
| if (button_check_event_mask(p_button, new_held_event)) |
| { |
| if (p_button->last_sent_event != BUTTON_HOLDING_EVENT) |
| { |
| if (p_button->last_sent_event != new_held_event) |
| { |
| button_manager->configuration->event_handler(p_button, new_held_event, p_button->current_state); |
| p_button->last_sent_event = new_held_event; |
| } |
| } |
| else |
| { |
| button_manager->configuration->event_handler(p_button, new_held_event, p_button->current_state); |
| p_button->last_sent_event = new_held_event; |
| } |
| } |
| |
| return WICED_SUCCESS; |
| } |
| |
| static void button_state_change_callback_pressed(button_manager_button_t * p_button) |
| { |
| /* Check if the button is under de-bounce state. */ |
| if (p_button->debouncing) |
| { // under de-bounce state |
| p_button->debounce_counter++; |
| } |
| else |
| { |
| /* ignore pressed event for already pressed button*/ |
| if (p_button->current_state == BUTTON_STATE_HELD) |
| { |
| return; |
| } |
| |
| /* Get current timestamp for pressed event. */ |
| p_button->pressed_timestamp = clock_SystemTimeMicroseconds64(); |
| |
| /* Start the button debounce timer. */ |
| wiced_start_timer(&p_button->debounce_timer, (uint32_t) button_manager->configuration->debounce_duration); |
| |
| /* Start the long pressed event detect timer. */ |
| wiced_start_timer(&p_button->long_press_timer, BUTTON_TIMER_TIMEOUT); |
| |
| /* Update information. */ |
| p_button->debouncing = WICED_TRUE; |
| p_button->debounce_counter = 1; |
| } |
| } |
| |
| static void button_state_change_callback_released(button_manager_button_t * p_button) |
| { |
| wiced_result_t result; |
| |
| /* Check if the button is under de-bounce state. */ |
| if (p_button->debouncing) |
| { // under de-bounce state |
| p_button->debounce_counter--; |
| } |
| else |
| { |
| /* ignore released event for already released button */ |
| if (p_button->current_state == BUTTON_STATE_RELEASED) |
| { |
| return; |
| } |
| |
| /* Get current timestamp for release event. */ |
| p_button->released_timestamp = clock_SystemTimeMicroseconds64(); |
| |
| /* Stop the long pressed event detect timer. */ |
| if (wiced_is_timer_in_use(&p_button->long_press_timer)) |
| { |
| wiced_stop_timer(&p_button->long_press_timer); |
| } |
| |
| button_released_event_handler((void *) p_button); |
| } |
| } |
| |
| /** |
| * Call back received when button state is changed. |
| * |
| * @param id : id of the button. |
| * @param new_state : new state of the button. |
| * @return void : no return value is expected. |
| */ |
| static void button_state_change_callback(platform_button_t id, wiced_bool_t new_state) |
| { |
| button_manager_button_t * button = get_button(id); |
| |
| #if 0 |
| WICED_BT_TRACE("button_state_change_callback (button %d %s, %s, %d, %d)\n", |
| id, |
| button->current_state == BUTTON_STATE_HELD ? "H" : "R", |
| button->debouncing ? "D" : "-", |
| new_state, |
| button->debounce_counter); |
| #endif |
| |
| /* Check module state.*/ |
| if (button == NULL || button_manager == NULL) |
| { |
| WICED_BT_TRACE("button manager not initialized\n"); |
| return; |
| } |
| |
| if (new_state == WICED_TRUE) |
| { |
| button_state_change_callback_pressed(button); |
| } |
| else |
| { |
| button_state_change_callback_released(button); |
| } |
| } |
| |
| /** |
| * Event handler for button press event. |
| * |
| * @param arg : Arguments passed by the event manager |
| * @return void : No return value expected. |
| */ |
| static wiced_result_t button_pressed_event_handler(void * arg) |
| { |
| button_manager_button_t * button = (button_manager_button_t *) arg; |
| |
| if (button->current_state == BUTTON_STATE_HELD) |
| { |
| return WICED_SUCCESS; |
| } |
| |
| /** Button is pressed; update the state so that timer-handlers know it */ |
| button->current_state = BUTTON_STATE_HELD; |
| |
| return WICED_SUCCESS; |
| } |
| |
| /** |
| * Event handler for button release event. |
| * |
| * @param arg : Arguments passed by the event manager |
| * @return void : No return value expected. |
| */ |
| |
| static wiced_result_t button_released_event_handler(void * arg) |
| { |
| button_manager_button_t * button = (button_manager_button_t *) arg; |
| button_manager_event_t new_release_event = 0; |
| uint64_t duration; // us |
| |
| if (button->current_state == BUTTON_STATE_RELEASED) |
| { |
| return WICED_SUCCESS; |
| } |
| |
| button->current_state = BUTTON_STATE_RELEASED; |
| |
| /* Calculate the time difference. */ |
| duration = button->released_timestamp - button->pressed_timestamp; // us |
| duration = duration / 1000; // ms |
| |
| /** If release event comes before debounce duration, ignore it */ |
| if (duration <= button_manager->configuration->debounce_duration) |
| { |
| return WICED_SUCCESS; |
| } |
| |
| /** deduce the event depending on the duration */ |
| new_release_event = button_deduce_duration_event(button, (uint32_t) duration); |
| |
| /** Check if this Release is from 2nd click of a double-click event */ |
| button_check_for_double_click(button, &new_release_event); |
| |
| /** |
| * As the new state is Release and application has asked for this kind of event, |
| * send it irrespective of whether timer-handler |
| * had sent it previously |
| */ |
| if (button_check_event_mask(button, new_release_event)) |
| { |
| #ifndef CYW55572 |
| button_manager->configuration->event_handler(button, new_release_event, button->current_state); |
| #else |
| /* |
| * Button released event is handled by another thread, it needs defer to mpaf thread. |
| * Deferred_button_timer_handler(long press) is handled by timer which is in mpaf thread, |
| * it does not need defer. |
| */ |
| wiced_result_t result; |
| |
| wiced_rtos_lock_mutex(p_mutex_button_event); |
| button_event_defer_to_mpaf_t * p_data = (button_event_defer_to_mpaf_t *) wiced_bt_get_buffer_from_pool(p_button_event_pool); |
| |
| if (!p_data) |
| { |
| wiced_rtos_unlock_mutex(p_mutex_button_event); |
| WICED_BT_TRACE("Err: release event_handler no memory \n"); |
| goto DEFER_MPAF_ERROR; |
| } |
| |
| p_data->p_button = button; |
| p_data->event = new_release_event; |
| wiced_bt_enqueue(&button_event_queue, (wiced_bt_buffer_t *) p_data); |
| wiced_rtos_unlock_mutex(p_mutex_button_event); |
| result = wiced_rtos_defer_execution(WICED_RTOS_DEFER_TO_MPAF_THREAD, &button_event_defer_to_mpaf, NULL); |
| |
| if (result != WICED_SUCCESS) |
| { |
| wiced_rtos_lock_mutex(p_mutex_button_event); |
| button_event_defer_to_mpaf_t * p_buf = (button_event_defer_to_mpaf_t *) wiced_bt_dequeue(&button_event_queue); |
| wiced_bt_free_buffer(p_buf); |
| wiced_rtos_unlock_mutex(p_mutex_button_event); |
| WICED_BT_TRACE("Err: release event_handler wiced_rtos_defer_execution (%d)\n", result); |
| goto DEFER_MPAF_ERROR; |
| } |
| #endif |
| } |
| |
| #ifdef CYW55572 |
| DEFER_MPAF_ERROR: |
| #endif |
| |
| /** reset the button's last-sent so that a new press/held after this release is handled properly */ |
| button->last_sent_event = 0; |
| |
| return WICED_SUCCESS; |
| } |
| |
| /** |
| * Checks if the event is a double click event. |
| * |
| * @param button : button information. |
| * @param new_event : new event generated for the button. |
| * @return void : no return value is expected. |
| */ |
| static void button_check_for_double_click(button_manager_button_t * button, button_manager_event_t * new_event) |
| { |
| if (!button_check_event_mask(button, BUTTON_DOUBLE_CLICK_EVENT) || *new_event != BUTTON_CLICK_EVENT) |
| { |
| return; |
| } |
| /** figure out the time-difference in two-releases */ |
| if ((button->released_timestamp - button->last_released_timestamp) <= button_manager->configuration->double_click_interval) |
| { |
| /** morph it as DOUBLE_CLICK */ |
| *new_event = BUTTON_DOUBLE_CLICK_EVENT; |
| } |
| |
| button->last_released_timestamp = button->released_timestamp; |
| |
| return; |
| } |
| |
| /** |
| * Checks the event mask for the button |
| * |
| * @param button : button information. |
| * @param new_event : new event generated for the button. |
| * @return wiced_bool_t : returns true/false based on the new event. |
| */ |
| static wiced_bool_t button_check_event_mask(button_manager_button_t * button, uint16_t new_event) |
| { |
| if (!button) |
| { |
| return WICED_FALSE; |
| } |
| |
| return ((new_event & button->configuration->button_event_mask) ? WICED_TRUE : WICED_FALSE); |
| } |
| |
| /** |
| * Checks duration of the event |
| * |
| * @param button : the button that been triggered |
| * @param current_interval : current time interval |
| * @return button_manager_event_t : returns button manager event. |
| */ |
| |
| static button_manager_event_t button_deduce_duration_event(button_manager_button_t * button, uint32_t current_interval) |
| { |
| button_manager_event_t new_event = 0; |
| uint32_t target_hold_interval; |
| |
| if (current_interval <= button_manager->configuration->debounce_duration) |
| { |
| return (button_manager_event_t) 0; |
| } |
| else if (current_interval > button_manager->configuration->debounce_duration && |
| current_interval <= button_manager->configuration->short_hold_duration) |
| { |
| return BUTTON_CLICK_EVENT; |
| } |
| else if (current_interval > button_manager->configuration->short_hold_duration && |
| current_interval <= button_manager->configuration->medium_hold_duration) |
| { |
| return BUTTON_SHORT_DURATION_EVENT; |
| } |
| else if (current_interval > button_manager->configuration->medium_hold_duration && |
| current_interval <= button_manager->configuration->long_hold_duration) |
| { |
| return BUTTON_MEDIUM_DURATION_EVENT; |
| } |
| else if (current_interval > button_manager->configuration->long_hold_duration && |
| current_interval <= button_manager->configuration->very_long_hold_duration) |
| { |
| button->repeat = 0; |
| return BUTTON_LONG_DURATION_EVENT; |
| } |
| else |
| { // current_interval > button_manager->configuration->very_long_hold_duration |
| if (button_manager->configuration->continuous_hold_detect == WICED_FALSE) |
| { |
| return BUTTON_VERY_LONG_DURATION_EVENT; |
| } |
| else |
| { |
| target_hold_interval = (button->repeat + 2) * button_manager->configuration->long_hold_duration; |
| |
| if (current_interval > target_hold_interval) |
| { |
| button->repeat++; |
| |
| return BUTTON_HOLDING_EVENT; |
| } |
| else |
| { |
| return (button_manager_event_t) 0; |
| } |
| } |
| } |
| } |
| |
| /** |
| * returns button based on the button id |
| * |
| * @param id : id of the buttonl |
| * @return button_manager_button_t : returns button. |
| */ |
| |
| static button_manager_button_t * get_button(platform_button_t id) |
| { |
| uint8_t a; |
| |
| for (a = 0; a < button_manager->number_of_buttons; a++) |
| { |
| if (button_manager->buttons[a].configuration->button == id) |
| { |
| return &button_manager->buttons[a]; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| #ifdef CYW55572 |
| static void button_event_defer_to_mpaf(void * arg) |
| { |
| button_event_defer_to_mpaf_t button_event_buf; |
| |
| wiced_rtos_lock_mutex(p_mutex_button_event); |
| button_event_defer_to_mpaf_t * p_buf = (button_event_defer_to_mpaf_t *) wiced_bt_dequeue(&button_event_queue); |
| memcpy(&button_event_buf, p_buf, sizeof(button_event_defer_to_mpaf_t)); |
| wiced_bt_free_buffer(p_buf); |
| wiced_rtos_unlock_mutex(p_mutex_button_event); |
| button_manager->configuration->event_handler(button_event_buf.p_button, button_event_buf.event, |
| button_event_buf.p_button->current_state); |
| } |
| #endif |
