Tmc5160Handler.h

Go to the documentation of this file.

 
#ifndef COMPONENT_HANDLER_TMC5160_HANDLER_H_
#define COMPONENT_HANDLER_TMC5160_HANDLER_H_
 
#include <cstdint>
#include <memory>
#include <type_traits>
#include <cstdarg>
#include <variant>
#include "core/hf-core-drivers/external/hf-tmc5160-driver/inc/tmc51x0.hpp"
#include "core/hf-core-drivers/external/hf-tmc5160-driver/inc/tmc51x0_comm_interface.hpp"
#include "core/hf-core-drivers/external/hf-tmc5160-driver/inc/tmc51x0_types.hpp"
#include "core/hf-core-drivers/external/hf-tmc5160-driver/inc/tmc51x0_result.hpp"
#include "base/BaseSpi.h"
#include "base/BaseUart.h"
#include "base/BaseGpio.h"
#include "RtosMutex.h"
 
 
struct Tmc5160CtrlPins {
    BaseGpio& enable;                
    BaseGpio* diag0{nullptr};        
    BaseGpio* diag1{nullptr};        
 
    BaseGpio* get(tmc51x0::TMC51x0CtrlPin pin) noexcept {
        switch (pin) {
            case tmc51x0::TMC51x0CtrlPin::EN:    return &enable;
            case tmc51x0::TMC51x0CtrlPin::DIAG0: return diag0;
            case tmc51x0::TMC51x0CtrlPin::DIAG1: return diag1;
            default:                               return nullptr;
        }
    }
};
 
class HalSpiTmc5160Comm : public tmc51x0::SpiCommInterface<HalSpiTmc5160Comm> {
public:
    HalSpiTmc5160Comm(BaseSpi& spi, BaseGpio& enable,
                       BaseGpio* diag0 = nullptr, BaseGpio* diag1 = nullptr,
                       const tmc51x0::PinActiveLevels& active_levels = {}) noexcept;
 
 
    tmc51x0::Result<void> SpiTransfer(const uint8_t* tx, uint8_t* rx, size_t length) noexcept;
 
    tmc51x0::Result<void> GpioSet(tmc51x0::TMC51x0CtrlPin pin, tmc51x0::GpioSignal signal) noexcept;
 
    tmc51x0::Result<tmc51x0::GpioSignal> GpioRead(tmc51x0::TMC51x0CtrlPin pin) 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;
 
    [[nodiscard]] tmc51x0::CommMode GetMode() const noexcept { return tmc51x0::CommMode::SPI; }
 
 
private:
    BaseSpi&         spi_;
    Tmc5160CtrlPins  ctrl_pins_;
    tmc51x0::PinActiveLevels active_levels_;
};
 
class HalUartTmc5160Comm : public tmc51x0::UartCommInterface<HalUartTmc5160Comm> {
public:
    HalUartTmc5160Comm(BaseUart& uart, BaseGpio& enable,
                        BaseGpio* diag0 = nullptr, BaseGpio* diag1 = nullptr,
                        const tmc51x0::PinActiveLevels& active_levels = {}) noexcept;
 
 
    tmc51x0::Result<void> UartSend(const uint8_t* data, size_t length) noexcept;
 
    tmc51x0::Result<void> UartReceive(uint8_t* data, size_t length) noexcept;
 
    tmc51x0::Result<void> GpioSet(tmc51x0::TMC51x0CtrlPin pin, tmc51x0::GpioSignal signal) noexcept;
 
    tmc51x0::Result<tmc51x0::GpioSignal> GpioRead(tmc51x0::TMC51x0CtrlPin pin) 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;
 
    [[nodiscard]] tmc51x0::CommMode GetMode() const noexcept { return tmc51x0::CommMode::UART; }
 
 
private:
    BaseUart&        uart_;
    Tmc5160CtrlPins  ctrl_pins_;
    tmc51x0::PinActiveLevels active_levels_;
};
 
 
 
class Tmc5160Handler {
public:
    using SpiDriver  = tmc51x0::TMC51x0<HalSpiTmc5160Comm>;
    using UartDriver = tmc51x0::TMC51x0<HalUartTmc5160Comm>;
 
    using DriverVariant = std::variant<std::monostate, SpiDriver*, UartDriver*>;
    using ConstDriverVariant = std::variant<std::monostate, const SpiDriver*, const UartDriver*>;
 
    //=========================================================================
    // Construction
    //=========================================================================
 
    Tmc5160Handler(BaseSpi& spi, BaseGpio& enable,
                   BaseGpio* diag0 = nullptr, BaseGpio* diag1 = nullptr,
                   uint8_t daisy_chain_position = 0,
                   const tmc51x0::PinActiveLevels& active_levels = {}) noexcept;
 
    Tmc5160Handler(BaseUart& uart, BaseGpio& enable,
                   BaseGpio* diag0 = nullptr, BaseGpio* diag1 = nullptr,
                   uint8_t uart_node_address = 0,
                   const tmc51x0::PinActiveLevels& active_levels = {}) noexcept;
 
    ~Tmc5160Handler() noexcept;
 
    // Non-copyable, non-movable
    Tmc5160Handler(const Tmc5160Handler&) = delete;
    Tmc5160Handler& operator=(const Tmc5160Handler&) = delete;
    Tmc5160Handler(Tmc5160Handler&&) = delete;
    Tmc5160Handler& operator=(Tmc5160Handler&&) = delete;
 
    //=========================================================================
    // Initialization
    //=========================================================================
 
    tmc51x0::ErrorCode Initialize(const tmc51x0::DriverConfig& config, bool verbose = true) noexcept;
 
    bool EnsureInitialized() noexcept;
 
    bool Deinitialize() noexcept;
 
    [[nodiscard]] bool IsInitialized() const noexcept { return initialized_; }
 
    [[nodiscard]] bool IsSpi() const noexcept { return is_spi_; }
 
    //=========================================================================
    // Direct Driver Access (typed pointers + visitDriver pattern)
    //=========================================================================
 
    template <typename Fn>
    auto visitDriver(Fn&& fn) noexcept -> decltype(fn(std::declval<SpiDriver&>())) {
        using ReturnType = decltype(fn(std::declval<SpiDriver&>()));
        MutexLockGuard lock(mutex_);
        if (!EnsureInitialized()) {
            if constexpr (std::is_void_v<ReturnType>) {
                return;
            } else {
                return ReturnType{};
            }
        }
        if (is_spi_ && spi_driver_) {
            return fn(*spi_driver_);
        } else if (!is_spi_ && uart_driver_) {
            return fn(*uart_driver_);
        }
        if constexpr (std::is_void_v<ReturnType>) {
            return;
        } else {
            return ReturnType{};
        }
    }
 
    [[nodiscard]] SpiDriver* driverViaSpi() noexcept;
    [[nodiscard]] const SpiDriver* driverViaSpi() const noexcept;
 
    [[nodiscard]] UartDriver* driverViaUart() noexcept;
    [[nodiscard]] 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{};
    }
 
    //=========================================================================
    // Diagnostics
    //=========================================================================
 
    void DumpDiagnostics() noexcept;
 
    //=========================================================================
    // Utility
    //=========================================================================
 
    const char* GetDescription() const noexcept;
 
    static tmc51x0::DriverConfig GetDefaultConfig() noexcept { return tmc51x0::DriverConfig{}; }
 
    //=========================================================================
    // Configuration Snapshot
    //=========================================================================
 
    [[nodiscard]] const tmc51x0::DriverConfig& GetDriverConfig() const noexcept { return config_; }
 
private:
    bool EnsureInitializedLocked() noexcept;
 
    bool is_spi_{true};
 
    bool initialized_{false};
 
    mutable RtosMutex mutex_;
 
    std::unique_ptr<HalSpiTmc5160Comm> spi_comm_;
 
    std::unique_ptr<HalUartTmc5160Comm> uart_comm_;
 
    std::unique_ptr<SpiDriver> spi_driver_;
 
    std::unique_ptr<UartDriver> uart_driver_;
 
    uint8_t address_{0};
 
    tmc51x0::DriverConfig config_{};
 
    char description_[64]{};
 
    template <typename Fn>
    auto visitDriverInternal(Fn&& fn) noexcept -> decltype(fn(std::declval<SpiDriver&>())) {
        using ReturnType = decltype(fn(std::declval<SpiDriver&>()));
        if (is_spi_ && spi_driver_) {
            return fn(*spi_driver_);
        } else if (!is_spi_ && uart_driver_) {
            return fn(*uart_driver_);
        }
        if constexpr (std::is_void_v<ReturnType>) {
            return;
        } else {
            return ReturnType{};
        }
    }
};
 
 
#endif // COMPONENT_HANDLER_TMC5160_HANDLER_H_