Tmc9660Handler.h

Go to the documentation of this file.

 
#ifndef COMPONENT_HANDLER_TMC9660_HANDLER_H_
#define COMPONENT_HANDLER_TMC9660_HANDLER_H_
 
#include <cstdint>
#include <memory>
#include <array>
#include <atomic>
#include <type_traits>
#include <variant>
#include "core/hf-core-drivers/external/hf-tmc9660-driver/inc/tmc9660.hpp"
#include "core/hf-core-drivers/external/hf-tmc9660-driver/inc/tmc9660_comm_interface.hpp"
#include "base/BaseGpio.h"
#include "base/BaseAdc.h"
#include "base/BaseTemperature.h"
#include "base/BaseSpi.h"
#include "base/BaseUart.h"
#include "RtosMutex.h"
#include <utility>  // for std::as_const
 
 
struct Tmc9660CtrlPins {
    BaseGpio& rst;      
    BaseGpio& drv_en;   
    BaseGpio& faultn;   
    BaseGpio& wake;     
 
    BaseGpio& get(tmc9660::TMC9660CtrlPin pin) noexcept {
        switch (pin) {
            case tmc9660::TMC9660CtrlPin::RST:    return rst;
            case tmc9660::TMC9660CtrlPin::DRV_EN: return drv_en;
            case tmc9660::TMC9660CtrlPin::FAULTN: return faultn;
            case tmc9660::TMC9660CtrlPin::WAKE:   return wake;
            default:                               return rst;
        }
    }
 
    const BaseGpio& get(tmc9660::TMC9660CtrlPin pin) const noexcept {
        switch (pin) {
            case tmc9660::TMC9660CtrlPin::RST:    return rst;
            case tmc9660::TMC9660CtrlPin::DRV_EN: return drv_en;
            case tmc9660::TMC9660CtrlPin::FAULTN: return faultn;
            case tmc9660::TMC9660CtrlPin::WAKE:   return wake;
            default:                               return rst;
        }
    }
};
 
class HalSpiTmc9660Comm : public tmc9660::SpiCommInterface<HalSpiTmc9660Comm> {
public:
    HalSpiTmc9660Comm(BaseSpi& spi, BaseGpio& rst, BaseGpio& drv_en,
                       BaseGpio& faultn, BaseGpio& wake,
                       bool rst_active_high = true, bool drv_en_active_high = true,
                       bool faultn_active_low = false, bool wake_active_low = false) noexcept;
 
 
    bool spiTransferTMCL(std::array<uint8_t, 8>& tx, std::array<uint8_t, 8>& rx) noexcept;
 
    bool spiTransferBootloader(std::array<uint8_t, 5>& tx, std::array<uint8_t, 5>& rx) noexcept;
 
    bool gpioSet(tmc9660::TMC9660CtrlPin pin, tmc9660::GpioSignal signal) noexcept;
 
    bool gpioRead(tmc9660::TMC9660CtrlPin pin, tmc9660::GpioSignal& signal) noexcept;
 
    void debugLog(int level, const char* tag, const char* format, va_list args) noexcept;
 
    void delayMs(uint32_t ms) noexcept;
 
    void delayUs(uint32_t us) noexcept;
 
 
private:
    BaseSpi&  spi_;             
    Tmc9660CtrlPins ctrl_pins_; 
};
 
class HalUartTmc9660Comm : public tmc9660::UartCommInterface<HalUartTmc9660Comm> {
public:
    HalUartTmc9660Comm(BaseUart& uart, BaseGpio& rst, BaseGpio& drv_en,
                        BaseGpio& faultn, BaseGpio& wake,
                        bool rst_active_high = true, bool drv_en_active_high = true,
                        bool faultn_active_low = false, bool wake_active_low = false) noexcept;
 
 
    bool uartSendTMCL(const std::array<uint8_t, 9>& data) noexcept;
 
    bool uartReceiveTMCL(std::array<uint8_t, 9>& data) noexcept;
 
    bool uartTransferBootloader(const std::array<uint8_t, 8>& tx,
                                 std::array<uint8_t, 8>& rx) noexcept;
 
    bool gpioSet(tmc9660::TMC9660CtrlPin pin, tmc9660::GpioSignal signal) noexcept;
 
    bool gpioRead(tmc9660::TMC9660CtrlPin pin, tmc9660::GpioSignal& signal) noexcept;
 
    void debugLog(int level, const char* tag, const char* format, va_list args) noexcept;
 
    void delayMs(uint32_t ms) noexcept;
 
    void delayUs(uint32_t us) noexcept;
 
 
private:
    BaseUart& uart_;            
    Tmc9660CtrlPins ctrl_pins_; 
};
 
 
 
class Tmc9660Handler {
public:
    //==========================================================================
    //==========================================================================
 
    using SpiDriver  = tmc9660::TMC9660<HalSpiTmc9660Comm>;
 
    using UartDriver = tmc9660::TMC9660<HalUartTmc9660Comm>;
 
    using DriverVariant = std::variant<std::monostate, SpiDriver*, UartDriver*>;
 
    using ConstDriverVariant = std::variant<std::monostate, const SpiDriver*, const UartDriver*>;
 
 
    //==========================================================================
    //==========================================================================
 
    static const tmc9660::BootloaderConfig kDefaultBootConfig;
 
 
    //==========================================================================
    //==========================================================================
 
    Tmc9660Handler(BaseSpi& spi, BaseGpio& rst, BaseGpio& drv_en,
                   BaseGpio& faultn, BaseGpio& wake,
                   uint8_t address = 0,
                   const tmc9660::BootloaderConfig* bootCfg = &kDefaultBootConfig);
 
    Tmc9660Handler(BaseUart& uart, BaseGpio& rst, BaseGpio& drv_en,
                   BaseGpio& faultn, BaseGpio& wake,
                   uint8_t address = 0,
                   const tmc9660::BootloaderConfig* bootCfg = &kDefaultBootConfig);
 
    ~Tmc9660Handler() noexcept;
 
    Tmc9660Handler(const Tmc9660Handler&) = delete;
    Tmc9660Handler& operator=(const Tmc9660Handler&) = delete;
 
    Tmc9660Handler(Tmc9660Handler&&) = delete;
    Tmc9660Handler& operator=(Tmc9660Handler&&) = delete;
 
 
    //==========================================================================
    //==========================================================================
 
    bool Initialize(bool performReset = true, bool retrieveBootloaderInfo = true,
                    bool failOnVerifyError = false);
 
    bool EnsureInitialized() noexcept;
 
    bool IsDriverReady() const noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    class Gpio : public BaseGpio {
    public:
        Gpio(Tmc9660Handler& parent, uint8_t gpioNumber);
 
        ~Gpio() noexcept override = default;
 
 
        bool Initialize() noexcept override;
 
        bool Deinitialize() noexcept override;
 
        bool IsPinAvailable() const noexcept override;
 
        hf_u8_t GetMaxPins() const noexcept override;
 
        const char* GetDescription() const noexcept override;
 
 
    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_err_t SetPinLevelImpl(hf_gpio_level_t level) noexcept override;
 
        hf_gpio_err_t GetPinLevelImpl(hf_gpio_level_t& level) noexcept override;
 
        hf_gpio_pull_mode_t GetPullModeImpl() const 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;
 
 
    private:
        Tmc9660Handler& parent_;        
        uint8_t gpioNumber_;            
        char description_[32];          
        hf_gpio_direction_t direction_ = hf_gpio_direction_t::HF_GPIO_DIRECTION_OUTPUT; 
    };
 
    class Adc : public BaseAdc {
    public:
        Adc(Tmc9660Handler& parent);
 
        ~Adc() noexcept override = default;
 
 
        bool Initialize() noexcept override;
 
        bool Deinitialize() noexcept override;
 
        hf_u8_t GetMaxChannels() const noexcept override;
 
        bool IsChannelAvailable(hf_channel_id_t channel_id) const noexcept override;
 
        hf_adc_err_t ReadChannelV(hf_channel_id_t channel_id, float& channel_reading_v,
                                 hf_u8_t numOfSamplesToAvg = 1,
                                 hf_time_t timeBetweenSamples = 0) noexcept override;
 
        hf_adc_err_t ReadChannelCount(hf_channel_id_t channel_id, hf_u32_t& channel_reading_count,
                                     hf_u8_t numOfSamplesToAvg = 1,
                                     hf_time_t timeBetweenSamples = 0) noexcept override;
 
        hf_adc_err_t ReadChannel(hf_channel_id_t channel_id, hf_u32_t& channel_reading_count,
                               float& channel_reading_v, hf_u8_t numOfSamplesToAvg = 1,
                               hf_time_t timeBetweenSamples = 0) noexcept override;
 
        hf_adc_err_t ReadMultipleChannels(const hf_channel_id_t* channel_ids, hf_u8_t num_channels,
                                         hf_u32_t* readings, float* voltages) noexcept override;
 
        hf_adc_err_t GetStatistics(hf_adc_statistics_t& statistics) noexcept override;
 
        hf_adc_err_t GetDiagnostics(hf_adc_diagnostics_t& diagnostics) noexcept override;
 
        hf_adc_err_t ResetStatistics() noexcept override;
 
        hf_adc_err_t ResetDiagnostics() noexcept override;
 
 
 
        hf_adc_err_t ReadAinChannel(uint8_t ain_channel, hf_u32_t& raw_value, float& voltage) noexcept;
 
        hf_adc_err_t ReadCurrentSenseChannel(uint8_t current_channel, hf_u32_t& raw_value, float& voltage) noexcept;
 
        hf_adc_err_t ReadVoltageChannel(uint8_t voltage_channel, hf_u32_t& raw_value, float& voltage) noexcept;
 
        hf_adc_err_t ReadTemperatureChannel(uint8_t temp_channel, hf_u32_t& raw_value, float& voltage) noexcept;
 
        hf_adc_err_t ReadMotorDataChannel(uint8_t motor_channel, hf_u32_t& raw_value, float& voltage) noexcept;
 
 
    private:
        Tmc9660Handler& parent_;                   
        mutable RtosMutex mutex_;                  
        mutable hf_adc_statistics_t statistics_;    
        mutable hf_adc_diagnostics_t diagnostics_; 
        std::atomic<hf_adc_err_t> last_error_;     
 
        hf_adc_err_t ValidateChannelId(hf_channel_id_t channel_id) const noexcept;
 
        hf_adc_err_t ReadChannelLocked(hf_channel_id_t channel_id,
                                       hf_u32_t& raw, float& voltage) noexcept;
 
        hf_adc_err_t UpdateStatistics(hf_adc_err_t result, uint64_t start_time_us) noexcept;
 
        uint64_t GetCurrentTimeUs() const noexcept;
 
        void UpdateDiagnostics(hf_adc_err_t error) noexcept;
 
        const char* GetChannelTypeString(hf_channel_id_t channel_id) const noexcept;
    };
 
    class Temperature : public BaseTemperature {
    public:
        Temperature(Tmc9660Handler& parent);
 
        ~Temperature() noexcept override = default;
 
 
        bool Initialize() noexcept override;
 
        bool Deinitialize() noexcept override;
 
        hf_temp_err_t ReadTemperatureCelsiusImpl(float* temperature_celsius) noexcept override;
 
        hf_temp_err_t GetSensorInfo(hf_temp_sensor_info_t* info) const noexcept override;
 
        hf_u32_t GetCapabilities() const noexcept override;
 
 
    private:
        Tmc9660Handler& parent_;                    
        mutable RtosMutex mutex_;                   
        mutable hf_temp_statistics_t statistics_;    
        mutable hf_temp_diagnostics_t diagnostics_; 
        std::atomic<hf_temp_err_t> last_error_;     
 
        hf_temp_err_t UpdateStatistics(hf_temp_err_t result, uint64_t start_time_us) noexcept;
 
        uint64_t GetCurrentTimeUs() const noexcept;
 
        void UpdateDiagnostics(hf_temp_err_t error) noexcept;
    };
 
 
    //==========================================================================
    //==========================================================================
 
    Gpio& gpio(uint8_t gpioNumber);
 
    Adc& adc();
 
    Temperature& temperature();
 
 
    //==========================================================================
    //==========================================================================
 
    tmc9660::CommMode GetCommMode() const noexcept;
 
    const tmc9660::BootloaderConfig& bootConfig() const noexcept { return *bootCfg_; }
 
 
    //==========================================================================
    //==========================================================================
 
    void DumpDiagnostics() noexcept;
 
    const char* GetDescription() const noexcept;
 
 
    //==========================================================================
    //==========================================================================
 
    SpiDriver* driverViaSpi() noexcept;
 
    const SpiDriver* driverViaSpi() const noexcept;
 
    UartDriver* driverViaUart() noexcept;
 
    const UartDriver* driverViaUart() const noexcept;
 
    [[nodiscard]] DriverVariant GetDriver() noexcept {
        if (auto* spi = driverViaSpi()) {
            return spi;
        }
        if (auto* uart = driverViaUart()) {
            return uart;
        }
        return std::monostate{};
    }
 
    [[nodiscard]] ConstDriverVariant GetDriver() const noexcept {
        if (auto* spi = driverViaSpi()) {
            return spi;
        }
        if (auto* uart = driverViaUart()) {
            return uart;
        }
        return std::monostate{};
    }
 
 
    //==========================================================================
    //==========================================================================
 
    template <typename Func>
    auto visitDriver(Func&& func) noexcept {
        using ReturnType = decltype(func(*spi_driver_));
        MutexLockGuard lock(handler_mutex_);
        if (!EnsureInitializedLocked()) {
            if constexpr (std::is_void_v<ReturnType>) {
                return;
            } else {
                return ReturnType{};
            }
        }
        if (use_spi_) {
            if (spi_driver_) return func(*spi_driver_);
        } else {
            if (uart_driver_) return func(*uart_driver_);
        }
        if constexpr (std::is_void_v<ReturnType>) {
            return;
        } else {
            return ReturnType{};
        }
    }
 
    template <typename Func>
    auto visitDriver(Func&& func) const noexcept {
        using ReturnType = decltype(func(std::as_const(*spi_driver_)));
        MutexLockGuard lock(handler_mutex_);
        auto* self = const_cast<Tmc9660Handler*>(this);
        if (!self->EnsureInitializedLocked()) {
            if constexpr (std::is_void_v<ReturnType>) {
                return;
            } else {
                return ReturnType{};
            }
        }
        if (use_spi_) {
            if (spi_driver_) return func(std::as_const(*spi_driver_));
        } else {
            if (uart_driver_) return func(std::as_const(*uart_driver_));
        }
        if constexpr (std::is_void_v<ReturnType>) {
            return;
        } else {
            return ReturnType{};
        }
    }
 
 
private:
    //==========================================================================
    // Private Helpers
    //==========================================================================
 
    bool EnsureInitializedLocked() noexcept;
 
    template <typename Func>
    auto visitDriverInternal(Func&& func) noexcept {
        using ReturnType = decltype(func(*spi_driver_));
        if (use_spi_) {
            if (spi_driver_) return func(*spi_driver_);
        } else {
            if (uart_driver_) return func(*uart_driver_);
        }
        if constexpr (std::is_void_v<ReturnType>) {
            return;
        } else {
            return ReturnType{};
        }
    }
 
    //==========================================================================
    // Private Members
    //==========================================================================
 
    bool use_spi_;  
 
    std::unique_ptr<HalSpiTmc9660Comm>  spi_comm_;   
    std::unique_ptr<HalUartTmc9660Comm> uart_comm_;   
 
    std::unique_ptr<SpiDriver>  spi_driver_;   
    std::unique_ptr<UartDriver> uart_driver_;   
 
    std::array<std::unique_ptr<Gpio>, 2> gpioWrappers_;   
    std::unique_ptr<Adc>         adcWrapper_;              
    std::unique_ptr<Temperature> temperatureWrapper_;      
 
    const tmc9660::BootloaderConfig* bootCfg_;   
    uint8_t device_address_;                      
 
    mutable RtosMutex handler_mutex_;   
 
    char description_[64]{};   
};
 
 
#endif // COMPONENT_HANDLER_TMC9660_HANDLER_H_