Pca9685Handler.h

Go to the documentation of this file.

 
#ifndef COMPONENT_HANDLER_PCA9685_HANDLER_H_
#define COMPONENT_HANDLER_PCA9685_HANDLER_H_
 
#include <cstdint>
#include <memory>
#include <array>
#include <cmath>
#include "base/BaseGpio.h"
#include "base/BasePwm.h"
#include "base/BaseI2c.h"
#include "core/hf-core-drivers/external/hf-pca9685-driver/inc/pca9685.hpp"
#include "RtosMutex.h"
#include "handlers/common/HandlerCommon.h"
 
// Forward declarations
class Pca9685Handler;
 
 
class HalI2cPca9685Comm : public pca9685::I2cInterface<HalI2cPca9685Comm> {
public:
    explicit HalI2cPca9685Comm(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;
 
    void DelayUs(uint32_t us) noexcept;
 
 
private:
    BaseI2c& i2c_device_;              
    mutable RtosMutex i2c_mutex_;      
};
 
 
 
class Pca9685PwmAdapter : public BasePwm {
public:
    static constexpr uint8_t kMaxChannels = 16;
 
    static constexpr uint8_t kResolutionBits = 12;
 
    static constexpr uint16_t kMaxRawValue = 4095;
 
    static constexpr uint32_t kMinFrequencyHz = 24;
 
    static constexpr uint32_t kMaxFrequencyHz = 1526;
 
    explicit Pca9685PwmAdapter(Pca9685Handler* parent_handler) noexcept;
 
    ~Pca9685PwmAdapter() noexcept override = default;
 
 
    hf_pwm_err_t Initialize() noexcept override;
 
    hf_pwm_err_t Deinitialize() noexcept override;
 
    hf_pwm_err_t EnableChannel(hf_channel_id_t channel_id) noexcept override;
 
    hf_pwm_err_t DisableChannel(hf_channel_id_t channel_id) noexcept override;
 
    bool IsChannelEnabled(hf_channel_id_t channel_id) const noexcept override;
 
    hf_pwm_err_t SetDutyCycle(hf_channel_id_t channel_id,
                              float duty_cycle) noexcept override;
 
    hf_pwm_err_t SetDutyCycleRaw(hf_channel_id_t channel_id,
                                 hf_u32_t raw_value) noexcept override;
 
    hf_pwm_err_t SetFrequency(hf_channel_id_t channel_id,
                              hf_frequency_hz_t frequency_hz) noexcept override;
 
    hf_pwm_err_t SetPhaseShift(hf_channel_id_t channel_id,
                               float phase_shift_degrees) noexcept override;
 
    hf_pwm_err_t StartAll() noexcept override;
 
    hf_pwm_err_t StopAll() noexcept override;
 
    hf_pwm_err_t UpdateAll() noexcept override;
 
    hf_pwm_err_t SetComplementaryOutput(hf_channel_id_t primary_channel,
                                        hf_channel_id_t complementary_channel,
                                        hf_u32_t deadtime_ns) noexcept override;
 
    float GetDutyCycle(hf_channel_id_t channel_id) const noexcept override;
 
    hf_frequency_hz_t GetFrequency(hf_channel_id_t channel_id) const noexcept override;
 
 
    friend class Pca9685Handler;
 
private:
    Pca9685Handler* parent_handler_;                    
 
    std::array<float, kMaxChannels> duty_cache_;        
    std::array<uint16_t, kMaxChannels> on_time_cache_;  
    std::array<bool, kMaxChannels> channel_enabled_;    
 
    hf_frequency_hz_t current_frequency_hz_ = 200;     
 
    bool validateChannel(hf_channel_id_t channel_id) const noexcept {
        return channel_id < kMaxChannels;
    }
};
 
 
 
class Pca9685GpioPin : public BaseGpio {
public:
    Pca9685GpioPin(hf_pin_num_t pin,
                   Pca9685Handler* parent_handler,
                   hf_gpio_active_state_t active_state =
                       hf_gpio_active_state_t::HF_GPIO_ACTIVE_HIGH) noexcept;
 
    ~Pca9685GpioPin() 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;
 
 
protected:
 
    hf_gpio_err_t SetDirectionImpl(hf_gpio_direction_t direction) noexcept override;
 
    hf_gpio_err_t GetDirectionImpl(hf_gpio_direction_t& direction) const noexcept override;
 
    hf_gpio_err_t SetOutputModeImpl(hf_gpio_output_mode_t mode) noexcept override;
 
    hf_gpio_err_t GetOutputModeImpl(hf_gpio_output_mode_t& mode) const 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;
 
 
    friend class Pca9685Handler;
 
private:
    hf_pin_num_t pin_;                     
    Pca9685Handler* parent_handler_;       
    char description_[32] = {};            
    hf_gpio_level_t cached_level_ =
        hf_gpio_level_t::HF_GPIO_LEVEL_LOW; 
};
 
 
 
class Pca9685Handler {
public:
    //==========================================================================
    //==========================================================================
 
    using Pca9685Driver = pca9685::PCA9685<HalI2cPca9685Comm>;
 
 
    //==========================================================================
    //==========================================================================
 
    explicit Pca9685Handler(BaseI2c& i2c_device) noexcept;
 
    ~Pca9685Handler() noexcept = default;
 
    Pca9685Handler(const Pca9685Handler&) = delete;
    Pca9685Handler& operator=(const Pca9685Handler&) = delete;
 
    Pca9685Handler(Pca9685Handler&&) = delete;
    Pca9685Handler& operator=(Pca9685Handler&&) = delete;
 
 
    //==========================================================================
    //==========================================================================
 
    bool EnsureInitialized() noexcept;
 
    bool EnsureDeinitialized() noexcept;
 
    bool IsInitialized() const noexcept { return initialized_; }
 
 
    //==========================================================================
    //==========================================================================
 
    static constexpr uint8_t ChannelCount() noexcept { return 16; }
 
    uint8_t GetI2cAddress() const noexcept;
 
    std::shared_ptr<BasePwm> GetPwmAdapter() noexcept;
 
    std::shared_ptr<BaseGpio> CreateGpioPin(
        hf_pin_num_t channel,
        hf_gpio_active_state_t active_state =
            hf_gpio_active_state_t::HF_GPIO_ACTIVE_HIGH,
        bool allow_existing = true) noexcept;
 
    std::shared_ptr<BaseGpio> GetGpioPin(hf_pin_num_t channel) noexcept;
 
    bool IsPinCreated(hf_pin_num_t channel) const noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    uint16_t GetErrorFlags() const noexcept;
 
    void ClearErrorFlags(uint16_t mask = 0xFFFF) noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    void DumpDiagnostics() const noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    [[nodiscard]] Pca9685Driver* GetDriver() noexcept;
    [[nodiscard]] const Pca9685Driver* GetDriver() const noexcept;
 
 
    friend class Pca9685PwmAdapter;
    friend class Pca9685GpioPin;
 
private:
    //==========================================================================
    // Private Methods
    //==========================================================================
 
    bool ensureInitializedLocked() noexcept;
 
    hf_pwm_err_t initializeInternal() noexcept;
 
    hf_pwm_err_t deinitializeInternal() noexcept;
 
    bool validateChannel(uint8_t channel) const noexcept { return channel < 16; }
 
    // ---- PWM/power/output ops (used internally by Pca9685PwmAdapter & Pca9685GpioPin) ----
    bool SetFrequency(float freq_hz) noexcept;
    bool SetDuty(uint8_t channel, float duty) noexcept;
    bool SetPwm(uint8_t channel, uint16_t on_time, uint16_t off_time) noexcept;
    bool SetAllPwm(uint16_t on_time, uint16_t off_time) noexcept;
    bool SetChannelFullOn(uint8_t channel) noexcept;
    bool SetChannelFullOff(uint8_t channel) noexcept;
    bool Sleep() noexcept;
    bool Wake() noexcept;
    bool SetOutputInvert(bool invert) noexcept;
    bool SetOutputDriverMode(bool totem_pole) noexcept;
 
    //==========================================================================
    // Private Members
    //==========================================================================
 
    BaseI2c& i2c_device_;                              
    std::unique_ptr<HalI2cPca9685Comm> i2c_adapter_;   
    std::unique_ptr<Pca9685Driver> pca9685_driver_;    
    bool initialized_ = false;                          
    mutable RtosMutex handler_mutex_;                   
 
    std::shared_ptr<Pca9685PwmAdapter> pwm_adapter_;                 
    std::array<std::shared_ptr<Pca9685GpioPin>, 16> gpio_registry_;  
};
 
 
#endif // COMPONENT_HANDLER_PCA9685_HANDLER_H_