Pcal95555Handler.h

Go to the documentation of this file.

 
#ifndef COMPONENT_HANDLER_PCAL95555_HANDLER_H_
#define COMPONENT_HANDLER_PCAL95555_HANDLER_H_
 
#include <atomic>
#include <cstdint>
#include <memory>
#include <array>
#include <functional>
#include "base/BaseGpio.h"
#include "base/BaseI2c.h"
#include "core/hf-core-drivers/external/hf-pcal95555-driver/inc/pcal95555.hpp"
#include "RtosMutex.h"
 
// Forward declarations
class Pcal95555Handler;
 
 
class HalI2cPcal95555Comm : public pcal95555::I2cInterface<HalI2cPcal95555Comm> {
public:
    explicit HalI2cPcal95555Comm(BaseI2c& i2c_device) noexcept;
 
 
    bool Write(uint8_t addr, uint8_t reg, const uint8_t* data, size_t len) noexcept;
 
    bool Read(uint8_t addr, uint8_t reg, uint8_t* data, size_t len) noexcept;
 
    bool EnsureInitialized() noexcept;
 
    bool RegisterInterruptHandler(std::function<void()> handler) noexcept;
 
 
    const std::function<void()>& GetInterruptHandler() const noexcept { return interrupt_handler_; }
 
private:
    BaseI2c& i2c_device_;                  
    mutable RtosMutex i2c_mutex_;          
    std::function<void()> interrupt_handler_; 
    uint8_t cmd_scratch_{0};               
    uint8_t tx_scratch_[4]{};
    uint8_t rx_scratch_[2]{};
};
 
 
 
class Pcal95555GpioPin : public BaseGpio {
public:
    Pcal95555GpioPin(hf_pin_num_t pin,
                     Pcal95555Handler* parent_handler,
                     hf_gpio_direction_t direction = hf_gpio_direction_t::HF_GPIO_DIRECTION_INPUT,
                     hf_gpio_active_state_t active_state = hf_gpio_active_state_t::HF_GPIO_ACTIVE_HIGH,
                     hf_gpio_output_mode_t output_mode = hf_gpio_output_mode_t::HF_GPIO_OUTPUT_MODE_PUSH_PULL,
                     hf_gpio_pull_mode_t pull_mode = hf_gpio_pull_mode_t::HF_GPIO_PULL_MODE_FLOATING,
                     bool configure_hardware = true) noexcept;
 
    ~Pcal95555GpioPin() noexcept override = default;
 
 
    bool Initialize() noexcept override;
 
    bool Deinitialize() noexcept override;
 
    bool IsPinAvailable() const noexcept override;
 
    hf_u8_t GetMaxPins() const noexcept override { return 16; }
 
    const char* GetDescription() const noexcept override;
 
    hf_gpio_err_t SupportsInterrupts() const noexcept override;
 
    hf_gpio_err_t ConfigureInterrupt(hf_gpio_interrupt_trigger_t trigger,
                                     InterruptCallback callback = nullptr,
                                     void* user_data = nullptr) noexcept override;
 
 
 
    hf_gpio_err_t SetPolarityInversion(bool invert) noexcept;
 
    hf_gpio_err_t SetInterruptMask(bool mask) noexcept;
 
    using BaseGpio::GetInterruptStatus;
 
    hf_gpio_err_t GetInterruptStatus(bool& status) noexcept;
 
 
protected:
 
    hf_gpio_err_t SetDirectionImpl(hf_gpio_direction_t direction) noexcept override;
 
    hf_gpio_err_t SetOutputModeImpl(hf_gpio_output_mode_t mode) noexcept override;
 
    hf_gpio_err_t SetPullModeImpl(hf_gpio_pull_mode_t mode) noexcept override;
 
    hf_gpio_pull_mode_t GetPullModeImpl() const noexcept override;
 
    hf_gpio_err_t SetPinLevelImpl(hf_gpio_level_t level) noexcept override;
 
    hf_gpio_err_t GetPinLevelImpl(hf_gpio_level_t& level) noexcept override;
 
    hf_gpio_err_t GetDirectionImpl(hf_gpio_direction_t& direction) const noexcept override;
 
    hf_gpio_err_t GetOutputModeImpl(hf_gpio_output_mode_t& mode) const noexcept override;
 
 
    friend class Pcal95555Handler;
 
private:
    hf_pin_num_t pin_;                     
    Pcal95555Handler* parent_handler_;     
    char description_[32] = {};            
    bool configure_hardware_{true};        
 
    InterruptCallback interrupt_callback_ = nullptr;
    void* interrupt_user_data_ = nullptr;
    hf_gpio_interrupt_trigger_t interrupt_trigger_ =
        hf_gpio_interrupt_trigger_t::HF_GPIO_INTERRUPT_TRIGGER_NONE;
    bool interrupt_enabled_ = false;
};
 
 
 
class Pcal95555Handler {
public:
    //==========================================================================
    //==========================================================================
 
    using Pcal95555Driver = pcal95555::PCAL95555<HalI2cPcal95555Comm>;
 
 
    //==========================================================================
    //==========================================================================
 
    explicit Pcal95555Handler(BaseI2c& i2c_device, BaseGpio* interrupt_pin = nullptr) noexcept;
 
    ~Pcal95555Handler() noexcept = default;
 
    Pcal95555Handler(const Pcal95555Handler&) = delete;
    Pcal95555Handler& operator=(const Pcal95555Handler&) = delete;
 
    Pcal95555Handler(Pcal95555Handler&&) = delete;
    Pcal95555Handler& operator=(Pcal95555Handler&&) = delete;
 
 
    //==========================================================================
    //==========================================================================
 
    bool EnsureInitialized() noexcept;
 
    bool EnsureDeinitialized() noexcept;
 
    bool IsInitialized() const noexcept { return initialized_; }
 
 
    //==========================================================================
    //==========================================================================
 
    hf_gpio_err_t SetDirection(uint8_t pin, hf_gpio_direction_t direction) noexcept;
 
    hf_gpio_err_t SetOutput(uint8_t pin, bool active) noexcept;
 
    hf_gpio_err_t ReadInput(uint8_t pin, bool& active) noexcept;
 
    hf_gpio_err_t Toggle(uint8_t pin) noexcept;
 
    hf_gpio_err_t SetPullMode(uint8_t pin, hf_gpio_pull_mode_t pull_mode) noexcept;
 
    hf_gpio_err_t GetPullMode(uint8_t pin, hf_gpio_pull_mode_t& pull_mode) noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    hf_gpio_err_t SetDirections(uint16_t pin_mask, hf_gpio_direction_t direction) noexcept;
 
    hf_gpio_err_t SetOutputs(uint16_t pin_mask, bool active) noexcept;
 
    hf_gpio_err_t SetOutputsVerified(uint16_t pin_mask, bool active) noexcept;
 
    hf_gpio_err_t SetPullModes(uint16_t pin_mask, hf_gpio_pull_mode_t pull_mode) noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    bool HasInterruptSupport() const noexcept { return interrupt_pin_ != nullptr; }
 
    bool IsInterruptConfigured() const noexcept { return interrupt_configured_; }
 
    bool DrainPendingInterrupts() noexcept;
 
    hf_gpio_err_t GetAllInterruptMasks(uint16_t& mask) noexcept;
 
    hf_gpio_err_t GetAllInterruptStatus(uint16_t& status) noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    static constexpr uint8_t PinCount() noexcept { return 16; }
 
    uint8_t GetI2cAddress() const noexcept;
 
    bool AttachStaticPin(Pcal95555GpioPin& pin) noexcept;
 
    std::shared_ptr<BaseGpio> CreateGpioPin(
        hf_pin_num_t pin,
        hf_gpio_direction_t direction = hf_gpio_direction_t::HF_GPIO_DIRECTION_INPUT,
        hf_gpio_active_state_t active_state = hf_gpio_active_state_t::HF_GPIO_ACTIVE_HIGH,
        hf_gpio_output_mode_t output_mode = hf_gpio_output_mode_t::HF_GPIO_OUTPUT_MODE_PUSH_PULL,
        hf_gpio_pull_mode_t pull_mode = hf_gpio_pull_mode_t::HF_GPIO_PULL_MODE_FLOATING,
        bool allow_existing = true,
        bool configure_hardware = true) noexcept;
 
    std::shared_ptr<BaseGpio> GetGpioPin(hf_pin_num_t pin) noexcept;
 
    Pcal95555GpioPin* GetGpioPinRaw(hf_pin_num_t pin) noexcept;
 
    hf_gpio_err_t ReadAllInputLevels(uint16_t& levels) noexcept;
 
    hf_gpio_err_t ProgramPortsAbsolute(uint16_t config, uint16_t output,
                                       uint16_t out_check_mask) noexcept;
 
    hf_gpio_err_t ReadConfigAndOutputPorts(uint16_t& config,
                                           uint16_t& output) noexcept;
 
    hf_gpio_err_t ReadOutputLatchFromWire(uint16_t& output) noexcept;
 
    hf_gpio_err_t ReadStandardRegisterBank(uint16_t& input, uint16_t& output,
                                           uint16_t& polarity,
                                           uint16_t& config) noexcept;
 
    hf_gpio_err_t VerifyOutputPinEffect(uint8_t pin, uint16_t& latch_high,
                                        uint16_t& input_high, uint16_t& latch_low,
                                        uint16_t& input_low) noexcept;
 
    bool IsPinCreated(hf_pin_num_t pin) const noexcept;
 
    uint16_t GetCreatedPinMask() const noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    bool HasAgileIO() const noexcept;
 
    pcal95555::ChipVariant GetChipVariant() const noexcept;
 
    hf_gpio_err_t SetPolarityInversion(hf_pin_num_t pin, bool invert) noexcept;
 
    hf_gpio_err_t SetMultiplePolarityInversion(uint16_t pin_mask, bool invert) noexcept;
 
    hf_gpio_err_t SetInterruptMask(hf_pin_num_t pin, bool mask) noexcept;
 
    hf_gpio_err_t GetInterruptStatus(hf_pin_num_t pin, bool& status) noexcept;
 
    hf_gpio_err_t SetDriveStrength(hf_pin_num_t pin, pcal95555::DriveStrength level) noexcept;
 
    hf_gpio_err_t EnableInputLatch(hf_pin_num_t pin, bool enable) noexcept;
 
    hf_gpio_err_t SetOutputMode(bool port0_open_drain, bool port1_open_drain) noexcept;
 
    hf_gpio_err_t ResetToDefault() noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    uint16_t GetErrorFlags() const noexcept;
 
    void ClearErrorFlags(uint16_t mask = 0xFFFF) noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    void DumpDiagnostics() const noexcept;
 
 
    friend class Pcal95555GpioPin;
 
private:
    //==========================================================================
    // Private Methods
    //==========================================================================
 
    bool EnsureInitializedLocked() noexcept;
 
    hf_gpio_err_t Initialize() noexcept;
 
    hf_gpio_err_t Deinitialize() noexcept;
 
    bool ValidatePin(uint8_t pin) const noexcept { return pin < 16; }
 
    hf_gpio_err_t RegisterPinInterrupt(hf_pin_num_t pin,
                                       hf_gpio_interrupt_trigger_t trigger,
                                       InterruptCallback callback,
                                       void* user_data) noexcept;
 
    hf_gpio_err_t UnregisterPinInterrupt(hf_pin_num_t pin) noexcept;
 
    hf_gpio_err_t ConfigureHardwareInterrupt() noexcept;
 
    static void HardwareInterruptCallback(BaseGpio* gpio,
                                          hf_gpio_interrupt_trigger_t trigger,
                                          void* user_data) noexcept;
 
    void ProcessInterrupts() noexcept;
 
    //==========================================================================
    //==========================================================================
 
    [[nodiscard]] Pcal95555Driver* GetDriver() noexcept;
    [[nodiscard]] const Pcal95555Driver* GetDriver() const noexcept;
 
 
    //==========================================================================
    // Private Members
    //==========================================================================
 
    BaseI2c& i2c_device_;                              
    std::unique_ptr<HalI2cPcal95555Comm> i2c_adapter_; 
    std::unique_ptr<Pcal95555Driver> pcal95555_driver_; 
    bool initialized_ = false;                          
    mutable RtosMutex handler_mutex_;                   
 
    std::array<Pcal95555GpioPin*, 16> pin_registry_{}; 
    std::array<std::unique_ptr<Pcal95555GpioPin>, 16> owned_pins_{}; 
 
    BaseGpio* interrupt_pin_;       
    bool interrupt_configured_;     
    std::atomic<bool> interrupt_pending_{false}; 
 
    std::array<hf_gpio_pull_mode_t, 16> pull_mode_cache_;
 
    uint16_t prev_input_state_ = 0; 
 
    uint16_t output_shadow_{0xFFFFU};   
    uint16_t config_shadow_{0xFFFFU};   
    uint16_t polarity_shadow_{0};       
    bool port_shadow_valid_{false};
};
 
 
#endif // COMPONENT_HANDLER_PCAL95555_HANDLER_H_