| /* |
| * 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 defines 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. |
| */ |
| #pragma once |
| |
| #include "platform_button.h" |
| #include "wiced.h" |
| #include "wiced_rtos.h" |
| #include "wiced_timer.h" |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /****************************************************** |
| * Macros |
| ******************************************************/ |
| |
| /****************************************************** |
| * Constants |
| ******************************************************/ |
| |
| /****************************************************** |
| * Enumerations |
| ******************************************************/ |
| |
| /** |
| * @brief Button Manager events. |
| * |
| */ |
| typedef enum |
| { |
| BUTTON_CLICK_EVENT = (1 << 0), /**< A click is a combination of press and release button events. Typically ~ < 200 ms. */ |
| BUTTON_SHORT_DURATION_EVENT = (1 << 1), /**< Short duration click event */ |
| BUTTON_MEDIUM_DURATION_EVENT = (1 << 2), /**< Medium duration click event */ |
| BUTTON_LONG_DURATION_EVENT = (1 << 3), /**< Long duration click event */ |
| BUTTON_VERY_LONG_DURATION_EVENT = (1 << 4), /**< Very long duration click event */ |
| BUTTON_DOUBLE_CLICK_EVENT = |
| (1 << 5), /**< A double click is a combination of two single clicks with some delay between them */ |
| BUTTON_HOLDING_EVENT = (1 << 6), /**< Button is holding over at least two long duration. */ |
| } button_manager_event_t; |
| |
| /** |
| * @brief Button states. |
| * |
| */ |
| typedef enum |
| { |
| BUTTON_STATE_HELD = (0), /**< Button state held */ |
| BUTTON_STATE_RELEASED = (1), /**< Button state released */ |
| } button_manager_button_state_t; |
| |
| /****************************************************** |
| * Type Definitions |
| ******************************************************/ |
| |
| /** |
| * @brief Worker thread structure. |
| * |
| */ |
| typedef struct |
| { |
| wiced_thread_t * thread; /**< Button event thread */ |
| wiced_queue_t * event_queue; /**< Button event queue */ |
| } button_worker_thread_t; |
| |
| /** |
| * @brief Button Event Message. |
| * |
| */ |
| typedef struct |
| { |
| event_handler_t function; /**< Button event handler function */ |
| void * arg; /**< Button event message arguments to be passed */ |
| } button_event_message_t; |
| /****************************************************** |
| * Structures |
| ******************************************************/ |
| |
| /** |
| * @brief Button configuration. |
| * |
| */ |
| typedef struct |
| { |
| platform_button_t button; /**< Logical Button-ids which map to physical buttons on the board */ |
| uint16_t button_event_mask; /**< Button event mask */ |
| uint32_t application_event; /**< Application event */ |
| } wiced_button_configuration_t; |
| |
| /** |
| * @brief Button Information. |
| * |
| */ |
| typedef struct |
| { |
| const wiced_button_configuration_t * configuration; /**< Button configuration */ |
| button_manager_button_state_t current_state; /**< Button current state */ |
| button_manager_event_t last_sent_event; /**< Button last sent event */ |
| uint64_t pressed_timestamp; /**< Button pressed time stamp (us) */ |
| uint64_t released_timestamp; /**< Button released time stamp (us) */ |
| uint32_t last_released_timestamp; /**< Button last released time stamp */ |
| wiced_bool_t check_for_double_click; /**< Button double click event or not */ |
| uint32_t repeat; /**< Button holding counter */ |
| int32_t debounce_counter; /**< Button debounce counter */ |
| wiced_timer_t debounce_timer; /**< Button debounce timer */ |
| wiced_bool_t debouncing; /**< Button debounce state indication */ |
| wiced_timer_t long_press_timer; /**< Button long press detection timer */ |
| uint64_t timer_timestamp; /**< Button event time stamp (us) */ |
| } button_manager_button_t; |
| |
| /** |
| * Button event handler |
| * |
| * @param button Which button in the list has been pressed/released/held |
| * @param event What exact event the button is generating. |
| * @param state What exact state the button is in. |
| * |
| * @return void Library should not care whether app handled the button-events correctly or not. |
| * |
| */ |
| typedef void (*wiced_button_event_handler_t)(const button_manager_button_t * button, button_manager_event_t event, |
| button_manager_button_state_t state); |
| |
| /** |
| * @brief Button manager Configuration. |
| * |
| */ |
| typedef struct |
| { |
| uint16_t short_hold_duration; /**< held for short duration (ms) */ |
| uint16_t medium_hold_duration; /**< held for medium duration (ms) */ |
| uint16_t long_hold_duration; /**< held for long duration (ms) */ |
| uint16_t very_long_hold_duration; /**< held for very long duration (ms) */ |
| uint16_t debounce_duration; /**< duration taken to de-bounce (ms) */ |
| uint16_t double_click_interval; /**< Time interval between two RELEASE events */ |
| wiced_bool_t continuous_hold_detect; /**< Flag to enable button holding detection.\n |
| If this is set to true, the BUTTON_VERY_LONG_DURATION_EVENT is disabled |
| and a BUTTON_HOLDING_EVENT will be triggered if a button is pressed over |
| twice the long_hold_duration.\n |
| The BUTTON_HOLDING_EVENT will continuous be sent every long_hold_duration |
| after the first BUTTON_HOLDING_EVENT event been sent. */ |
| wiced_button_event_handler_t event_handler; |
| } wiced_button_manager_configuration_t; |
| |
| /** |
| * @brief Button Manager structure. |
| * |
| */ |
| typedef struct |
| { |
| const wiced_button_manager_configuration_t * configuration; /**< Button manager configuration */ |
| button_manager_button_t * buttons; /**< Button information */ |
| uint32_t number_of_buttons; /**< Number of buttons */ |
| wiced_button_event_handler_t button_callback; /**< Button event handler */ |
| } button_manager_t; |
| |
| /** |
| * Button's state change call back |
| * |
| * @param id Id of the button |
| * @param new_state What exact new state the button is going to. |
| * |
| * @return void Library should not care whether app handled the button-events correctly or not. |
| */ |
| |
| typedef void (*wiced_button_state_change_callback_t)(platform_button_t id, wiced_bool_t new_state); |
| |
| /****************************************************** |
| * Global Variables |
| ******************************************************/ |
| |
| /****************************************************** |
| * Function Declarations |
| ******************************************************/ |
| |
| /** |
| * The application should call this function to Initialize the Button Manager |
| * |
| * @param manager : pointer to button manager. |
| * @param configuration : Configuration for the button. |
| * @param buttons : Button information. |
| * @param number_of_buttons : Number of buttons. |
| * @return : result. |
| */ |
| extern wiced_result_t 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); |
| |
| /** |
| * The application should call this function to de-Initialize the Button Manager |
| * |
| * @param manager : Pointer to button manager to de-initialize. |
| * @return : result. |
| */ |
| extern wiced_result_t wiced_button_manager_deinit(button_manager_t * manager); |
| |
| #ifdef __cplusplus |
| } /* extern "C" */ |
| #endif |
