tmc2130.h

Go to the documentation of this file.

#pragma once
#include "../config/config.h"
#include "../hal/gpio.h"
#include "../hal/shr16.h"
#include "../hal/spi.h"
 
namespace hal {
 
namespace tmc2130 {
 
enum MotorMode : uint8_t {
    Stealth,
    Normal
};
 
struct MotorParams {
    const hal::spi::SPI_TypeDef *const spi;
    uint8_t idx; 
    bool dirOn; 
    gpio::GPIO_pin csPin; 
    gpio::GPIO_pin stepPin; 
    gpio::GPIO_pin sgPin; 
    config::MRes mRes; 
    int8_t sg_thrs;
    uint8_t axis;
};
 
struct MotorCurrents {
    bool vSense; 
    uint8_t iRun; 
    uint8_t iHold; 
 
    constexpr MotorCurrents(uint8_t ir, uint8_t ih)
        : vSense((ir < 32) ? 1 : 0)
        , iRun((ir < 32) ? ir : (ir >> 1))
        , iHold((ir < 32) ? ih : (ih >> 1)) {}
};
 
struct __attribute__((packed)) ErrorFlags {
    uint8_t reset_flag : 1; 
    uint8_t uv_cp : 1; 
    uint8_t s2g : 1; 
    uint8_t otpw : 1; 
    uint8_t ot : 1; 
    inline constexpr ErrorFlags()
        : reset_flag(0)
        , uv_cp(0)
        , s2g(0)
        , otpw(0)
        , ot(0) {}
    inline bool Good() const { return reset_flag == 0 && uv_cp == 0 && s2g == 0 && otpw == 0 && ot == 0; }
};
 
class TMC2130 {
public:
    enum class Registers : uint8_t {
        GCONF = 0x00,
        GSTAT = 0x01,
        IOIN = 0x04,
 
        IHOLD_IRUN = 0x10,
        TPOWERDOWN = 0x11,
        TSTEP = 0x12,
        TPWMTHRS = 0x13,
        TCOOLTHRS = 0x14,
        THIGH = 0x15,
 
        MSCNT = 0x6A,
        CHOPCONF = 0x6C,
        COOLCONF = 0x6D,
        DRV_STATUS = 0x6F,
        PWMCONF = 0x70,
    };
 
    TMC2130() = default;
 
    bool Init(const MotorParams &params,
        const MotorCurrents &currents,
        MotorMode mode);
 
    void SetMode(const MotorParams &params, MotorMode mode);
 
    void SetBridgeOutput(const MotorParams &params, bool on);
 
    void SetCurrents(const MotorParams &params, const MotorCurrents &currents);
 
    void SetSGTHRS(const MotorParams &params);
 
    const bool Enabled() const {
        return enabled;
    }
 
    void SetEnabled(const MotorParams &params, bool enabled);
 
    static inline void SetDir(const MotorParams &params, bool dir) {
        hal::shr16::shr16.SetTMCDir(params.idx, dir ^ params.dirOn);
    }
 
    static inline void SetRawDir(const MotorParams &params, bool dir) {
        // Also cancels the inversion in SetTMCDir
        hal::shr16::shr16.SetTMCDir(params.idx, !dir);
    }
 
    static inline void Step(const MotorParams &params) {
        gpio::TogglePin(params.stepPin); // assumes DEDGE
    }
 
    static inline void SetStep(const MotorParams &params, bool state) {
        gpio::WritePin(params.stepPin, (state ? gpio::Level::high : gpio::Level::low));
    }
 
    static inline bool SampleDiag(const MotorParams &params) {
        return gpio::ReadPin(params.sgPin) == gpio::Level::low;
    }
 
    inline bool Stalled() const {
        return sg_filter_counter == 0;
    }
 
    inline void ClearStallguard() {
        sg_filter_counter = sg_filter_threshold;
    }
 
    bool CheckForErrors(const MotorParams &params);
 
    inline ErrorFlags GetErrorFlags() const {
        return errorFlags;
    }
 
#ifdef UNITTEST
    inline void SetErrorFlags(ErrorFlags ef) {
        errorFlags = ef;
    }
#endif
 
    uint32_t ReadRegister(const MotorParams &params, Registers reg);
 
    void WriteRegister(const MotorParams &params, Registers reg, uint32_t data);
 
    void Isr(const MotorParams &params);
 
private:
    void _spi_tx_rx(const MotorParams &params, uint8_t (&pData)[5]);
    void _handle_spi_status(const MotorParams &params, uint8_t status);
 
    ErrorFlags errorFlags;
    bool initialized = false;
    bool enabled = false;
    uint8_t sg_filter_threshold = 0;
    uint8_t sg_filter_counter = 0;
};
 
} // namespace tmc2130
} // namespace hal