clickable.hpp

Go to the documentation of this file.

 
#ifndef LSHCORE_PERIPHERALS_INPUT_CLICKABLE_HPP
#define LSHCORE_PERIPHERALS_INPUT_CLICKABLE_HPP
 
#include <etl/vector.h>
#include <stdint.h>
 
#include "internal/user_config_bridge.hpp"
#include "util/constants/clickresults.hpp"
#include "util/constants/clicktypes.hpp"
#include "util/constants/timing.hpp"
 
class Clickable
{
private:
    enum class State : uint8_t
    {
        IDLE,       
        DEBOUNCING, 
        PRESSED,    
        RELEASED    
    };
 
    enum class ActionFired : uint8_t
    {
        NONE,
        LONG,
        SUPER_LONG
    };
 
    // Bitfield for configuration flags to save RAM. These are "cold" data, mostly read after setup.
    // Data structures definitions
    struct ClickableConfigFlags
    {
        uint8_t isShortClickable : 1 = true;             
        uint8_t isLongClickable : 1 = false;             
        uint8_t isSuperLongClickable : 1 = false;        
        uint8_t isNetworkLongClickable : 1 = false;      
        uint8_t isNetworkSuperLongClickable : 1 = false; 
        uint8_t isQuickClickable : 1 = false;            
        uint8_t isValid : 1 = false;                     
        uint8_t isChecked : 1 = false;                   
    };
 
    // Bitfield for configuration flags to save RAM. "Hot" data, read every detection.
    ClickableConfigFlags configFlags;
 
#ifndef CONFIG_USE_FAST_CLICKABLES
    const uint8_t pinNumber; 
#else
    const uint8_t pinMask;                 
    const volatile uint8_t *const pinPort; 
#endif
    uint8_t index = 0U; 
    const uint8_t id;   
 
    // State variables for the FSM ("hot" data, move to top for <64 byte offset optimization).
    State currentState = State::IDLE;                
    uint32_t stateChangeTime = 0U;                   
    ActionFired lastActionFired = ActionFired::NONE; 
 
    // Timings ("hot" configuration, move to top)
    uint16_t longClick_ms = constants::timings::CLICKABLE_LONG_CLICK_TIME_MS;            
    uint16_t superLongClick_ms = constants::timings::CLICKABLE_SUPER_LONG_CLICK_TIME_MS; 
protected:
    uint8_t debounce_ms = constants::timings::CLICKABLE_DEBOUNCE_TIME_MS; 
private:
 
    // Non-boolean configuration properties (Cold data, rarely accessed in tight loops)
    constants::LongClickType longClickType = constants::LongClickType::NONE;                    
    constants::NoNetworkClickType longClickFallback = constants::NoNetworkClickType::NONE;      
    constants::SuperLongClickType superLongClickType = constants::SuperLongClickType::NONE;     
    constants::NoNetworkClickType superLongClickFallback = constants::NoNetworkClickType::NONE; 
 
    // Attached actuators (HUGE size due to static storage)
    // Keep at the bottom to avoid pushing hot variables out of the 64-byte displacement range.
    etl::vector<uint8_t, CONFIG_MAX_ACTUATORS> actuatorsShort{};     
    etl::vector<uint8_t, CONFIG_MAX_ACTUATORS> actuatorsLong{};      
    etl::vector<uint8_t, CONFIG_MAX_ACTUATORS> actuatorsSuperLong{}; 
 
public:
#ifndef CONFIG_USE_FAST_CLICKABLES
    explicit constexpr Clickable(uint8_t pin, uint8_t uniqueId) noexcept : pinNumber(pin), id(uniqueId) {}
#else
    explicit Clickable(uint8_t pin, uint8_t uniqueId) noexcept : pinMask(digitalPinToBitMask(pin)), pinPort(portInputRegister(digitalPinToPort(pin))), id(uniqueId) {}
#endif
 
// Delete copy constructor, copy assignment operator, move constructor and move assignment operator
#if (__cplusplus >= 201703L) && (__GNUC__ >= 7)
    Clickable(const Clickable &) = delete;
    Clickable(Clickable &&) = delete;
    auto operator=(const Clickable &) -> Clickable & = delete;
    auto operator=(Clickable &&) -> Clickable & = delete;
#endif // (__cplusplus >= 201703L) && (__GNUC__ >= 7)
 
    inline auto getState() const -> bool
    {
#ifdef CONFIG_USE_FAST_CLICKABLES
        return (*this->pinPort & this->pinMask) != 0U;
#else
        return (static_cast<bool>(digitalRead(this->pinNumber)));
#endif
    }
 
    void setIndex(uint8_t indexToSet); // Set the Clickable index on Clickables namespace Array
 
    // Clickability setters
    auto setClickableShort(bool shortClickable) -> Clickable &; // Set the short clickability of the clickable
    auto setClickableLong(bool longClickable,
                          constants::LongClickType clickType = constants::LongClickType::NORMAL,
                          bool networkClickable = false,
                          constants::NoNetworkClickType fallback = constants::NoNetworkClickType::LOCAL_FALLBACK) -> Clickable &; // Set long click network clickability
    auto setClickableSuperLong(bool superLongClickable,
                               constants::SuperLongClickType clickType = constants::SuperLongClickType::NORMAL,
                               bool networkClickable = false,
                               constants::NoNetworkClickType fallback = constants::NoNetworkClickType::LOCAL_FALLBACK) -> Clickable &; // Set super long click network clickability
 
    // Actuators setter
    auto addActuator(uint8_t actuatorIndex, constants::ClickType actuatorType) -> Clickable &; // Add an actuator
    auto addActuatorShort(uint8_t actuatorIndex) -> Clickable &;                               // Add a short click actuator
    auto addActuatorLong(uint8_t actuatorIndex) -> Clickable &;                                // Add a long click actuator
    auto addActuatorSuperLong(uint8_t actuatorIndex) -> Clickable &;                           // Add a super long click actuator
 
    // Timing setters
    auto setDebounceTime(uint8_t timeToSet_ms) -> Clickable &;        // Set debounce time in ms (0-255)
    auto setLongClickTime(uint16_t timeToSet_ms) -> Clickable &;      // Set long click time in ms (0-65535)
    auto setSuperLongClickTime(uint16_t timeToSet_ms) -> Clickable &; // Set super long click time in ms (0-65535)
 
    // Getters
    [[nodiscard]] auto getIndex() const -> uint8_t;                                                               // Get the Clickable index on Clickables namespace Array
    [[nodiscard]] auto getId() const -> uint8_t;                                                                  // Return unique ID of the clickable
    [[nodiscard]] auto getActuators(constants::ClickType actuatorType) const -> const etl::ivector<uint8_t> *;    // Returns attached actuators of one kind
    [[nodiscard]] auto getTotalActuators(constants::ClickType actuatorType) const -> uint8_t;                     // Returns the total number of a kind of actuators
    [[nodiscard]] auto getLongClickType() const -> constants::LongClickType;                                      // Returns the type of long click
    [[nodiscard]] auto isNetworkClickable(constants::ClickType clickType) const -> bool;                          // Returns if the clickable is network clickable for long or super long click actions
    [[nodiscard]] auto getNetworkFallback(constants::ClickType clickType) const -> constants::NoNetworkClickType; // Returns the fallback type for a give network click type
    [[nodiscard]] auto getSuperLongClickType() const -> constants::SuperLongClickType;                            // Returns the type of super long click
 
    // Utilities
    auto check() -> bool;                                          // Check for clickable coherence, it has to be clickable, it has to be connected to something
    [[nodiscard]] auto shortClick() const -> bool;                 // Perform a short click action
    [[nodiscard]] auto longClick() const -> bool;                  // Perform a long click action
    [[nodiscard]] auto superLongClickSelective() const -> bool;    // Perform a selective super long click;
    [[nodiscard]] auto clickDetection() -> constants::ClickResult; // Processes input state and determines the click type using an internal Finite State Machine (FSM).
 
};
 
#endif // LSHCORE_PERIPHERALS_INPUT_CLICKABLE_HPP