Tle92466edHandler.h

Go to the documentation of this file.

 
#ifndef COMPONENT_HANDLER_TLE92466ED_HANDLER_H_
#define COMPONENT_HANDLER_TLE92466ED_HANDLER_H_
 
#include <cstdint>
#include <memory>
#include <cstdarg>
#include <span>
#include <type_traits>
#include <utility>
#include "core/hf-core-drivers/external/hf-tle92466ed-driver/inc/tle92466ed.hpp"
#include "core/hf-core-drivers/external/hf-tle92466ed-driver/inc/tle92466ed_spi_interface.hpp"
#include "base/BaseSpi.h"
#include "base/BaseGpio.h"
#include "RtosMutex.h"
 
 
class HalSpiTle92466edComm : public tle92466ed::SpiInterface<HalSpiTle92466edComm> {
public:
    HalSpiTle92466edComm(BaseSpi& spi, BaseGpio& resn, BaseGpio& en,
                          BaseGpio* faultn = nullptr) noexcept;
 
 
    // Bring base class variadic Log into scope (avoids name hiding)
    using tle92466ed::SpiInterface<HalSpiTle92466edComm>::Log;
 
    tle92466ed::CommResult<void> Init() noexcept;
 
    tle92466ed::CommResult<void> Deinit() noexcept;
 
    tle92466ed::CommResult<uint32_t> Transfer32(uint32_t tx_data) noexcept;
 
    tle92466ed::CommResult<void> TransferMulti(std::span<const uint32_t> tx_data,
                                                std::span<uint32_t> rx_data) noexcept;
 
    tle92466ed::CommResult<void> TransferMulti(std::span<const uint32_t> tx_data,
                                                std::span<uint32_t> rx_data,
                                                uint32_t gap_us) noexcept;
 
    tle92466ed::CommResult<void> Delay(uint32_t microseconds) noexcept;
 
    tle92466ed::CommResult<void> Configure(const tle92466ed::SPIConfig& config) noexcept;
 
    [[nodiscard]] bool IsReady() const noexcept;
 
    [[nodiscard]] tle92466ed::CommError GetLastError() const noexcept;
 
    tle92466ed::CommResult<void> ClearErrors() noexcept;
 
    tle92466ed::CommResult<void> GpioSet(tle92466ed::CtrlPin pin,
                                          tle92466ed::GpioSignal signal) noexcept;
 
    tle92466ed::CommResult<tle92466ed::GpioSignal> GpioRead(tle92466ed::CtrlPin pin) noexcept;
 
    void Log(tle92466ed::LogLevel level, const char* tag,
             const char* format, va_list args) noexcept;
 
    [[nodiscard]] uint32_t LastRxWord() const noexcept { return last_rx_; }
 
    [[nodiscard]] uint32_t LastRxWordFirst() const noexcept { return last_rx_first_; }
 
 
private:
    BaseSpi&   spi_;
    BaseGpio&  resn_;
    BaseGpio&  en_;
    BaseGpio*  faultn_;
    bool       initialized_{false};
    tle92466ed::CommError last_error_{tle92466ed::CommError::None};
    uint32_t   last_rx_{0};
    uint32_t   last_rx_first_{0};
};
 
 
 
class Tle92466edHandler {
public:
    using DriverType = tle92466ed::Driver<HalSpiTle92466edComm>;
 
    static constexpr uint8_t kNumChannels = 6;
 
    //=========================================================================
    // Construction
    //=========================================================================
 
    Tle92466edHandler(BaseSpi& spi, BaseGpio& resn, BaseGpio& en,
                      BaseGpio* faultn = nullptr) noexcept;
 
    ~Tle92466edHandler() noexcept;
 
    // Non-copyable
    Tle92466edHandler(const Tle92466edHandler&) = delete;
    Tle92466edHandler& operator=(const Tle92466edHandler&) = delete;
 
    // Non-movable
    Tle92466edHandler(Tle92466edHandler&&) = delete;
    Tle92466edHandler& operator=(Tle92466edHandler&&) = delete;
 
    //=========================================================================
    // Initialization
    //=========================================================================
 
    tle92466ed::DriverResult<void> Initialize(bool perform_hardware_reset = true) noexcept;
 
    [[nodiscard]] bool EnsureInitialized() noexcept;
 
    tle92466ed::DriverResult<void> Initialize(const tle92466ed::GlobalConfig& config) noexcept;
 
    tle92466ed::DriverResult<void> Deinitialize() noexcept;
 
    [[nodiscard]] bool IsInitialized() const noexcept { return initialized_; }
 
    //=========================================================================
    // Channel Control
    //=========================================================================
 
    tle92466ed::DriverResult<void> ConfigureChannel(uint8_t channel, const tle92466ed::ChannelConfig& config) noexcept;
 
    tle92466ed::DriverResult<void> EnableChannel(uint8_t channel) noexcept;
 
    tle92466ed::DriverResult<void> DisableChannel(uint8_t channel) noexcept;
 
    tle92466ed::DriverResult<void> EnableAllChannels() noexcept;
 
    tle92466ed::DriverResult<void> DisableAllChannels() noexcept;
 
    tle92466ed::DriverResult<void> SetChannelCurrent(uint8_t channel, uint16_t current_ma) noexcept;
 
    tle92466ed::DriverResult<void> SetChannelCurrentUa(uint8_t channel, uint32_t current_ua) noexcept;
 
    tle92466ed::DriverResult<uint16_t> GetChannelCurrentSetpoint(
        uint8_t channel, bool parallel_mode = false) noexcept;
 
    tle92466ed::DriverResult<void> ConfigurePwmRaw(uint8_t channel, uint8_t mantissa,
                         uint8_t exponent, bool low_freq_range = false) noexcept;
 
    //=========================================================================
    // Device Mode
    //=========================================================================
 
    tle92466ed::DriverResult<void> EnterMissionMode() noexcept;
 
    tle92466ed::DriverResult<void> EnterConfigMode() noexcept;
 
    [[nodiscard]] bool IsMissionMode() noexcept;
 
    //=========================================================================
    // Hardware Output Stage (EN pin)
    //=========================================================================
 
    tle92466ed::DriverResult<void> EnableOutputStage() noexcept;
 
    tle92466ed::DriverResult<void> DisableOutputStage() noexcept;
 
    tle92466ed::DriverResult<void> EnableFeedbackUpdates() noexcept;
 
    //=========================================================================
    // Status & Diagnostics
    //=========================================================================
 
    tle92466ed::DriverResult<void> GetStatus(tle92466ed::DeviceStatus& status) noexcept;
 
    tle92466ed::DriverResult<void> GetChannelDiagnostics(uint8_t channel, tle92466ed::ChannelDiagnostics& diag) noexcept;
 
    tle92466ed::DriverResult<void> GetFaultReport(tle92466ed::FaultReport& report) noexcept;
 
    tle92466ed::DriverResult<void> ClearFaults() noexcept;
 
    [[nodiscard]] bool HasFault() noexcept;
 
    //=========================================================================
    // Watchdog
    //=========================================================================
 
    tle92466ed::DriverResult<void> KickWatchdog(uint16_t reload_value = 1000) noexcept;
 
    //=========================================================================
    // Device Info
    //=========================================================================
 
    uint32_t GetChipId() noexcept;
 
    uint32_t GetIcVersion() noexcept;
 
    [[nodiscard]] uint32_t LastSpiRxWord() const noexcept {
        return comm_ ? comm_->LastRxWord() : 0U;
    }
 
    [[nodiscard]] uint32_t LastSpiRxWordFirst() const noexcept {
        return comm_ ? comm_->LastRxWordFirst() : 0U;
    }
 
    [[nodiscard]] bool RawSpiChain(std::span<const uint32_t> tx,
                                   std::span<uint32_t> rx,
                                   uint32_t gap_us = 0U) noexcept {
        MutexLockGuard lock(mutex_);
        if (!EnsureInitializedLocked() || !comm_) {
            return false;
        }
        return comm_->TransferMulti(tx, rx, gap_us).has_value();
    }
 
    template <typename Fn>
    auto WithLock(Fn&& fn) noexcept {
        MutexLockGuard lock(mutex_);
        return std::forward<Fn>(fn)();
    }
 
    //=========================================================================
    // 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:
    tle92466ed::DriverResult<void> InitializeLocked(bool perform_hardware_reset) noexcept;
    bool EnsureInitializedLocked() noexcept;
 
    template <typename T>
    struct is_driver_result : std::false_type {};
    template <typename T>
    struct is_driver_result<tle92466ed::DriverResult<T>> : std::true_type {};
 
    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 (is_driver_result<R>::value)
                return R{tle::unexpected(tle92466ed::DriverError::NotInitialized)};
            else
                return R{};
        }
        return fn(*driver_);
    }
 
    bool initialized_{false};
    mutable RtosMutex mutex_;
    std::unique_ptr<HalSpiTle92466edComm> comm_;
    std::unique_ptr<DriverType> driver_;
};
 
 
#endif // COMPONENT_HANDLER_TLE92466ED_HANDLER_H_