Max22200Handler.h

Go to the documentation of this file.

 
#ifndef COMPONENT_HANDLER_MAX22200_HANDLER_H_
#define COMPONENT_HANDLER_MAX22200_HANDLER_H_
 
#include <cstdint>
#include <memory>
#include <type_traits>
#include <utility>
#include "core/hf-core-drivers/external/hf-max22200-driver/inc/max22200.hpp"
#include "core/hf-core-drivers/external/hf-max22200-driver/inc/max22200_spi_interface.hpp"
#include "core/hf-core-drivers/external/hf-max22200-driver/inc/max22200_types.hpp"
#include "base/BaseSpi.h"
#include "base/BaseGpio.h"
#include "RtosMutex.h"
 
 
class HalSpiMax22200Comm : public max22200::SpiInterface<HalSpiMax22200Comm> {
public:
    HalSpiMax22200Comm(BaseSpi& spi, BaseGpio& enable, BaseGpio& cmd,
                        BaseGpio* fault = nullptr) noexcept;
 
 
    bool Initialize() noexcept;
 
    bool Transfer(const uint8_t* tx_data, uint8_t* rx_data, size_t length) noexcept;
 
    bool SetChipSelect(bool state) noexcept;
 
    bool Configure(uint32_t speed_hz, uint8_t mode, bool msb_first = true) noexcept;
 
    [[nodiscard]] bool IsReady() const noexcept;
 
    void DelayUs(uint32_t us) noexcept;
 
    void GpioSet(max22200::CtrlPin pin, max22200::GpioSignal signal) noexcept;
 
    bool GpioRead(max22200::CtrlPin pin, max22200::GpioSignal& signal) noexcept;
 
 
private:
    BaseSpi&   spi_;
    BaseGpio&  enable_;
    BaseGpio&  cmd_;
    BaseGpio*  fault_;
    bool       initialized_{false};
};
 
 
 
class Max22200Handler {
public:
    using DriverType = max22200::MAX22200<HalSpiMax22200Comm>;
 
    static constexpr uint8_t kNumChannels = 8;
 
    //=========================================================================
    // Construction
    //=========================================================================
 
    Max22200Handler(BaseSpi& spi, BaseGpio& enable, BaseGpio& cmd,
                    BaseGpio* fault = nullptr) noexcept;
 
    ~Max22200Handler() noexcept;
 
    // Non-copyable
    Max22200Handler(const Max22200Handler&) = delete;
    Max22200Handler& operator=(const Max22200Handler&) = delete;
 
    // Non-movable
    Max22200Handler(Max22200Handler&&) = delete;
    Max22200Handler& operator=(Max22200Handler&&) = delete;
 
    //=========================================================================
    // Initialization
    //=========================================================================
 
    max22200::DriverStatus Initialize() noexcept;
 
    [[nodiscard]] bool EnsureInitialized() noexcept;
 
    max22200::DriverStatus Initialize(const max22200::BoardConfig& board_config) noexcept;
 
    max22200::DriverStatus Deinitialize() noexcept;
 
    [[nodiscard]] bool IsInitialized() const noexcept { return initialized_; }
 
    [[nodiscard]] uint8_t GetLastFaultByte() const noexcept;
 
    //=========================================================================
    // Channel Configuration
    //=========================================================================
 
    max22200::DriverStatus ConfigureChannel(uint8_t channel, const max22200::ChannelConfig& config) noexcept;
 
    max22200::DriverStatus SetupCdrChannel(uint8_t channel, uint16_t hit_ma,
                         uint16_t hold_ma, float hit_time_ms) noexcept;
 
    max22200::DriverStatus SetupVdrChannel(uint8_t channel, float hit_duty_pct,
                         float hold_duty_pct, float hit_time_ms) noexcept;
 
    //=========================================================================
    // Channel Control
    //=========================================================================
 
    max22200::DriverStatus EnableChannel(uint8_t channel) noexcept;
 
    max22200::DriverStatus DisableChannel(uint8_t channel) noexcept;
 
    max22200::DriverStatus EnableAllChannels() noexcept;
 
    max22200::DriverStatus DisableAllChannels() noexcept;
 
    [[nodiscard]] bool IsChannelEnabled(uint8_t channel) noexcept;
 
    max22200::DriverStatus SetChannelsMask(uint8_t mask) noexcept;
 
    //=========================================================================
    // Status & Faults
    //=========================================================================
 
    max22200::DriverStatus GetStatus(max22200::StatusConfig& status) noexcept;
 
    max22200::DriverStatus GetChannelFaults(uint8_t channel, max22200::FaultStatus& faults) noexcept;
 
    [[nodiscard]] bool HasFault() noexcept;
 
    max22200::DriverStatus ClearFaults() noexcept;
 
    //=========================================================================
    // Device Control
    //=========================================================================
 
    max22200::DriverStatus ReadFaultRegister(max22200::FaultStatus& faults) noexcept;
 
    //=========================================================================
    // Direct Driver Access
    //=========================================================================
 
    template <typename Fn>
    auto WithDriver(Fn&& fn) noexcept {
        using R = std::invoke_result_t<Fn, DriverType&>;
        if constexpr (std::is_void_v<R>) {
            MutexLockGuard lock(mutex_);
            if (!EnsureInitializedLocked() || !driver_) return false;
            fn(*driver_);
            return true;
        } else {
            return withDriver(std::forward<Fn>(fn));
        }
    }
 
    [[nodiscard]] DriverType* GetDriver() noexcept;
 
    [[nodiscard]] const DriverType* GetDriver() const noexcept;
 
    void DumpDiagnostics() noexcept;
 
private:
    max22200::DriverStatus InitializeLocked() noexcept;
    bool EnsureInitializedLocked() noexcept;
 
    bool WaitForActiveAndDrainFaults() noexcept;
 
    template <typename Fn>
    auto withDriver(Fn&& fn) noexcept {
        using R = std::invoke_result_t<Fn, DriverType&>;
        static_assert(!std::is_void_v<R>, "withDriver requires non-void return");
        MutexLockGuard lock(mutex_);
        if (!EnsureInitializedLocked() || !driver_) {
            if constexpr (std::is_same_v<R, max22200::DriverStatus>)
                return max22200::DriverStatus::INITIALIZATION_ERROR;
            else
                return R{};
        }
        return fn(*driver_);
    }
 
    bool initialized_{false};
    mutable RtosMutex mutex_;
    std::unique_ptr<HalSpiMax22200Comm> comm_;
    std::unique_ptr<DriverType> driver_;
    uint8_t last_fault_byte_{0xFF};
};
 
 
#endif // COMPONENT_HANDLER_MAX22200_HANDLER_H_