STM32 SPI Library for TMC2660 Stepper Motor Controller

STM32 SPI Library for TMC2660 Stepper Motor Controller

Please read Liability Disclaimer and License Agreement CAREFULLY

For detailed setup and functionality read first the TMC2660 datasheet.

How to use example

 

TMC2660_init(0);
TMC2660_init(1);
TMC2660_start(0);
TMC2660_start(1);
printf("Steps           = %d\r\n", TMC2660_getResolution(0));
printf("PulseMode       = %d\r\n", TMC2660_getDoubleEdge(0));
printf("Interpolation   = %d\r\n", TMC2660_getInterpolation(0));
printf ("DRVCTRL --- END\n");

printf("Time off        = %d\r\n", TMC2660_getTimeOff(0));
printf("Hy Start        = %d\r\n", TMC2660_getHysteresisStart(0));
printf("Hy End          = %d\r\n", TMC2660_getHysteresisEnd(0));
printf("Hy Dec          = %d\r\n", TMC2660_getHysteresisDecrement(0));
printf("RndTim          = %d\r\n", TMC2660_getRandomTime(0));
printf("ChopMo          = %d\r\n", TMC2660_getChopperMode(0));
printf("TBL             = %d\r\n", TMC2660_getBlankingTime(0));
printf ("CHOPCONF --- END\n");

printf("ThLow           = %d\r\n", TMC2660_getCoolStepThldLow(0));
printf("CrtInc          = %d\r\n", TMC2660_getCurrentIncrement(0));
printf("ThHig           = %d\r\n", TMC2660_getCoolStepThldHigh(0));
printf("DecSp           = %d\r\n", TMC2660_getCurrentDecrementSpeed(0));
printf("CoolS           = %d\r\n", TMC2660_getMinCoolStepCurrent(0));
printf ("SMARTEN --- END\n");
  
printf("CrtSca          = %d\r\n", TMC2660_getCurrentScale(0));
printf("StallG          = %d\r\n", TMC2660_getStallGuardThld(0));
printf("StallF          = %d\r\n", TMC2660_getStallGuardFilter(0));
printf ("SGCSCONF --- END\n");
  
printf("ReadOut         = %d\r\n", TMC2660_getReadOut(0));
printf("VSENSE          = %d\r\n", TMC2660_getVSENSE(0));
printf("StepDir         = %d\r\n", TMC2660_getStepDir(0));
printf("GndTime         = %d\r\n", TMC2660_getGndDetectionTime(0));
printf("GndProt         = %d\r\n", TMC2660_getGndProtection(0));
printf("SloapL          = %d\r\n", TMC2660_getSlopeControlLowSide(0));
printf("sloapH          = %d\r\n", TMC2660_getSlopeControlHighSide(0));
printf("TstMode         = %d\r\n", TMC2660_getTestMode(0));

 

TMC2660.h

 

#ifndef __TMC2660_H
#define __TMC2660_H
#ifdef __cplusplus
extern "C" {
#endif

#include "stm32f7xx_hal.h"
#include "main.h"

    //Calculated for TMC2660-BOM with Rsense=100mOhm
    //CS = 32*R*I/V (with V = 0,31V oor 0,165V and I = 1000*current)
    //Irms=((CS+1)/32)*(Vfs/Rsense)*(1/sqrt*(2))
    #define TMC2660_SENS_LOW    0.0145983335
    #define TMC2660_SENS_HIGH    0.0274271721
    
    //some default values used in initialization
    #define ONE                                1
    #define DEFAULT_MICROSTEPPING_VALUE        8
    #define DRVCTRL_START                    0x00003ul
    #define CHOPCONF_START                    0x88004ul
    #define DRVCONF_START                    0xE0010ul
    #define SGCSCONF_START                    0xD0F1Ful
    #define SMARTEN_START                    0xA2205ul
    //DRVSTATUS
    #define SG_pos                            0
    #define OT_pos                            1
    #define OTPW_pos                        2
    #define S2GA_pos                        3
    #define S2GB_pos                        4
    #define OLA_pos                            5
    #define OLB_pos                            6
    #define STST_pos                        7
    #define MSTEP_mask                        10
    #define MSTEP_pos                        10
    #define CPOL_pos                        19
    //TMC26X register definitions
    #define DRVCTRL                            0x00000ul
    //SDOFF=0
    #define MRES_mask                        0xFFFF0 // Bit 0-3
    #define DEDGE_pos                        8
    #define DEDGE_mask                        (ONE << DEDGE_pos)
    #define INTPOL_pos                        9
    #define INTPOL_mask                        (ONE << INTPOL_pos) // Bit 9
    
    #define CHOPCONF                        0x80000ul
    #define TOFF_mask                        0xFFFF0 // Bit 0-3
    #define HSTRT_mask                        0xFFF8F // Bit 4-6
    #define HSTRT_pos                        4
    #define HEND_mask                        0xFF87F // Bit 7-10
    #define HEND_pos                        7
    #define HDEC_mask                        0xFE7FF // Bit 11-12
    #define HDEC_pos                        11
    #define COMP_mask                        ONE << 12)
    #define RNDTF_pos                        13
    #define RNDTF_mask                        (ONE << RNDTF_pos) // Bit 13
    #define CHM_pos                            14
    #define CHM_mask                        (ONE << CHM_pos) // Bit 14
    #define TBL_mask                        0xE7FFF // Bit 15-16
    #define TBL_pos                            15
    
    #define SMARTEN                            0xA0000ul
    #define SEMIN_mask                        0xFFFF0 // Bit 0-3
    #define SEUP_mask                        0xFFF9F // Bit 5-6
    #define SEUP_pos                        5    
    #define SEMAX_mask                        0xFF0FF // Bit 8-11
    #define SEMAX_pos                        8
    #define SEDN_mask                        0xF9FFF // Bit 13-14
    #define SEDN_pos                        13
    #define SEIMIN_pos                        15
  #define SEIMIN_mask                        (ONE << SEIMIN_pos) // Bit 15

    #define SGCSCONF                        0xC0000ul
    #define CS_mask                            0xFFFE0 // Bit 0-4
    #define SGT_mask                        0xF80FF // Bit 8-14
    #define SGT_pos                            8
    #define SFILT_pos                        16
    #define SFILT_mask                        (ONE << SFILT_pos) // Bit 16

    #define DRVCONF                            0xE0000ul
    #define RDSEL_mask                        0xFFFCF // Bit 4-5
    #define RDSEL_pos                        4
    #define VSENSE_pos                        6
    #define VSENSE_mask                        (ONE << VSENSE_pos) // Bit 6
    #define SDOFF_pos                        7
    #define SDOFF_mask                        (ONE << SDOFF_pos) // Bit 7
    #define TS2G_mask                        0xFFCFF // Bit 8-9
    #define TS2G_pos                        8
    #define DISS2G_pos                        10
    #define DISS2G_mask                        (ONE << DISS2G_pos) // Bit 10
    #define SLPL_mask                        0xFCFFF // Bit 12-13
    #define SLPL_pos                        12
    #define SLPH_mask                        0xF3FFF // Bit 14-15
    #define SLPH_pos                        14
    #define TST_pos                            16
    #define TST_mask                        (ONE << TST_pos) // Bit 16
    
    typedef enum {
        m_STOPPED         = 0,
        m_STARTING        = 1,
        m_FULLSPEED       = 2,
        m_BREAKING        = 3,
        m_BREAKCORRECTION = 4
    } motor_status_t;

    typedef enum {
        CCW    = 0,
        CW    = 1
    } rotation_t;
    

    typedef struct {
        motor_status_t        mStatus;
        volatile int32_t    mCrtPos; //handle by interrupt
        rotation_t            mDirection;
        uint16_t            mStep;// no need to go to 1/256 microstepping
        uint32_t            mSPS;//Steps per second. For uStep of 32 we have max. 57600SPS
        uint32_t            mStepsDec;//When To start decelerating
        uint32_t            mStepsToTarget;//Steps to target
        uint32_t            mDRVCTRL;
        uint32_t            mDRVCONF;
        uint32_t            mCHOPCONF;
        uint32_t            mSGCSCONF;
        uint32_t            mSMARTEN;
        uint32_t            mDRVSTATUS;//this holds the value we get from controller
    } motor;

    void TMC2660_setDirection(uint8_t myMotor, uint8_t direction);
    void TMC2660_setSpeed(uint8_t myMotor, uint32_t speed);
    void TMC2660_init(uint8_t myMotor);
    void TMC2660_start(uint8_t myMotor);
    
    //Functions used to get different values from status
    uint8_t TMC2660_getStallGuardStatus(uint8_t myMotor);
    uint8_t TMC2660_getTempShutDown(uint8_t myMotor);
    uint8_t TMC2660_getTempWarning(uint8_t myMotor);
    uint8_t TMC2660_getShortA(uint8_t myMotor);
    uint8_t TMC2660_getShortB(uint8_t myMotor);
    uint8_t TMC2660_getOpenLoadA(uint8_t myMotor);
    uint8_t TMC2660_getOpenLoadB(uint8_t myMotor);
    uint8_t TMC2660_getStandStill(uint8_t myMotor);
    //For RDSEl = 2
    uint8_t TMC2660_getCoolStepValue(uint8_t MotorNo);
    uint8_t TMC2660_getStallGuardValue(uint8_t MotorNo);
    //For RDSEl = 0
    uint8_t TMC2660_getStepsCounter(uint8_t MotorNo);
    //For RDSEl = 1
    uint8_t TMC2660_getFullStallGuardValue(uint8_t MotorNo);
    //The main status function
    void TMC2660_getStatus(uint8_t MotorNo);
    
    //DRVCTRL register functions
    void TMC2660_setResolution(uint8_t MotorNo, uint16_t Resolution);
    uint16_t TMC2660_getResolution(uint8_t MotorNo);
    void TMC2660_setDoubleEdge(uint8_t MotorNo, uint8_t doubleEdge);
    uint8_t TMC2660_getDoubleEdge(uint8_t MotorNo);
    void TMC2660_setInterpolation(uint8_t MotorNo, uint8_t interpolation);
    uint8_t TMC2660_getInterpolation(uint8_t MotorNo);
    
    //CHOPCONF register functions
    void TMC2660_setTimeOff(uint8_t MotorNo, uint8_t TimeOff);
    uint8_t TMC2660_getTimeOff(uint8_t MotorNo);
    void TMC2660_setHysteresisStart(uint8_t MotorNo, uint8_t HysteresisStart);
    uint8_t TMC2660_getHysteresisStart(uint8_t MotorNo);
    void TMC2660_setHysteresisStart(uint8_t MotorNo, uint8_t HysteresisStart);
    uint8_t TMC2660_getHysteresisStart(uint8_t MotorNo);
    void TMC2660_setHysteresisEnd(uint8_t MotorNo, uint8_t HysteresisEnd);
    uint8_t TMC2660_getHysteresisEnd(uint8_t MotorNo);
    void TMC2660_setHysteresisDecrement(uint8_t MotorNo, uint8_t HysteresisDecrement);
    uint8_t TMC2660_getHysteresisDecrement(uint8_t MotorNo);
    void TMC2660_setRandomTime(uint8_t MotorNo, uint8_t randomTime);
    uint8_t TMC2660_getRandomTime(uint8_t MotorNo);
    void TMC2660_setChopperMode(uint8_t MotorNo, uint8_t ChopperMode);
    uint8_t TMC2660_getChopperMode(uint8_t MotorNo);
    void TMC2660_setBlankingTime(uint8_t MotorNo, uint8_t BlankingTime);
    uint8_t TMC2660_getBlankingTime(uint8_t MotorNo);
    
    //SMARTEN register functions
    void TMC2660_setCoolStepThldLow(uint8_t MotorNo, uint8_t LowerCoolStepThreshold);
    uint8_t TMC2660_getCoolStepThldLow(uint8_t MotorNo);    
    void TMC2660_setCurrentIncrement(uint8_t MotorNo, uint8_t CurrentIncrement);
    uint8_t TMC2660_getCurrentIncrement(uint8_t MotorNo);
    void TMC2660_setCoolStepThldHigh(uint8_t MotorNo, uint8_t UpperCoolStepThreshold);
    uint8_t TMC2660_getCoolStepThldHigh(uint8_t MotorNo);
    void TMC2660_setCurrentDecrementSpeed(uint8_t MotorNo, uint8_t CurrentDecrementSpeed);
    uint8_t TMC2660_getCurrentDecrementSpeed(uint8_t MotorNo);
    void TMC2660_setMinCoolStepCurrent(uint8_t MotorNo, uint8_t coolStepCurrent);
    uint8_t TMC2660_getMinCoolStepCurrent(uint8_t MotorNo);
    
    //SGCSCONF register functions
    void TMC2660_setRMS_Current(uint8_t MotorNo, uint16_t mA);
    void TMC2660_setCurrentScale(uint8_t MotorNo, uint8_t CurrentScale);
    uint8_t TMC2660_getCurrentScale(uint8_t MotorNo);
    void TMC2660_setStallGuardThld(uint8_t MotorNo, int8_t StallGuardThld);
    int8_t TMC2660_getStallGuardThld(uint8_t MotorNo);
    void TMC2660_setStallGuardFilter(uint8_t MotorNo, uint8_t GuardFilter);
    uint8_t TMC2660_getStallGuardFilter(uint8_t MotorNo);
    
    //DRVCONF register functions
    void TMC2660_setReadOut(uint8_t MotorNo, uint8_t ReadOut);
    uint8_t TMC2660_getReadOut(uint8_t MotorNo);
    void TMC2660_setVSENSE(uint8_t MotorNo, uint8_t vSense);
    uint8_t TMC2660_getVSENSE(uint8_t MotorNo);
    void TMC2660_setStepDir(uint8_t MotorNo, uint8_t StepDirSPI);
    uint8_t TMC2660_getStepDir(uint8_t MotorNo);
    void TMC2660_setGndDetectionTime(uint8_t MotorNo, uint8_t GndTimer);
    uint8_t TMC2660_getGndDetectionTime(uint8_t MotorNo);
    void TMC2660_setGndProtection(uint8_t MotorNo, uint8_t GndProtection);
    uint8_t TMC2660_getGndProtection(uint8_t MotorNo);
    void TMC2660_set_SlopeControlLowSide(uint8_t MotorNo, uint8_t SlopeControlLowSide);
    uint8_t TMC2660_getSlopeControlLowSide(uint8_t MotorNo);
    void TMC2660_set_SlopeControlHighSide(uint8_t MotorNo, uint8_t SlopeControlHighSide);
    uint8_t TMC2660_getSlopeControlHighSide(uint8_t MotorNo);
    void TMC2660_setTestMode(uint8_t MotorNo, uint8_t TestMode);
    uint8_t TMC2660_getTestMode(uint8_t MotorNo);
    
#ifdef __cplusplus
}
#endif

#endif /* __TMC2660_H */

 

 

TMC2660.c

 

#include <stdio.h>
#include <spi.h>
#include "TMC2660.h"
#include "gpio.h"
#include "spi.h"
#include "tim.h"

    //SPI_AS5048;//Set SPI2->CR1-->CPOL Low
    //SPI_Default;//Set SPI2->CR1-->CPHA High
    motor myMotors[2];
    // SPI Modes
    //   Mode      CPOL      CPHA
    //    0        0        0
    //    1        0        1
    //    2        1        0
    //    3        1        1
    //    if(SPI_Mode == TM_SPI_Mode_0) {
    //        SPIHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
    //        SPIHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
    //    } else if(SPI_Mode == TM_SPI_Mode_1) {
    //        SPIHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
    //        SPIHandle.Init.CLKPhase = SPI_PHASE_2EDGE;
    //    } else if(SPI_Mode == TM_SPI_Mode_2) {
    //        SPIHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
    //        SPIHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
    //    } else if(SPI_Mode == TM_SPI_Mode_3) {
    //        SPIHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
    //        SPIHandle.Init.CLKPhase = SPI_PHASE_2EDGE;
    //    }

    static void print_Bits(uint32_t data) {
        int b = 19;//31
    //  for(; b>=24; b--){
    //    printf("%d",(data>>b)&1);
    //  }
    //  Serial.print(".");
        for(; b>=16; b--){
            printf("%d", (data>>b)&1);
        }
        printf(".");
        for(; b>=8; b--){
            printf("%d",(data>>b)&1);
        }
        printf(".");
        for(; b>=0; b--){
            printf("%d",(data>>b)&1);
        }
        printf("\n");
    }

    static void send(uint8_t MotorNo, uint32_t regVal) {
        // Change SPI mode 1 for AS5048 and 3 for TMC2660
        printf("%d -->\n", MotorNo);
        print_Bits(regVal);
        uint8_t toSend[3] = {((regVal >> 16) & 0xff), ((regVal >>  8) & 0xff), (regVal & 0xff)};
        printf("*****\n");
        uint8_t toGet[3] = {0, 0, 0};
        //select the TMC driver
        if(MotorNo){
            V_CS_Select;
        } else {
            H_CS_Select;
        }
        //write/read the values
        if(HAL_SPI_TransmitReceive(&hspi2, toSend, toGet, 6, PORT_TIMEOUT) != HAL_OK)
            printf ("HAL_SPI_TransmitReceive \n");
        //deselect the TMC chip
        if(MotorNo){
            V_CS_Release;
        } else {
            H_CS_Release;
        }
        //store the status result
        myMotors[MotorNo].mDRVSTATUS = ((toGet[0] << 16) | (toGet[1] << 8) | (toGet[2] >> 4));
        //printf("->>mDRVSTATUS Motor %d = ", MotorNo);
        //print_Bits(Motors[MotorNo].mDRVSTATUS);
    }

    void TMC2660_setSpeed(uint8_t MotorNo, uint32_t speed){
        myMotors[MotorNo].mSPS = speed;
        uint32_t NewTimPeriod = ((TimTickFreq/myMotors[MotorNo].mSPS) - 1);
        uint32_t PulseLen = ((NewTimPeriod + 1)/2) - 1;
        switch(MotorNo){
            case 0:
                htim2.Instance->ARR = NewTimPeriod;
                htim2.Instance->CNT = 0;
                __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_3, PulseLen);
            case 1:
                htim5.Instance->ARR = NewTimPeriod;
                htim5.Instance->CNT = 0;
                __HAL_TIM_SET_COMPARE(&htim5, TIM_CHANNEL_4, PulseLen);
            break;
        }    
    }

    void TMC2660_setDirection(uint8_t MotorNo, uint8_t direction){
        switch(MotorNo) {
            case 0:
                if(direction){
                    H_DIR_A;
                } else {
                    H_DIR_B;
                }        
            break;
            case 1:
                if(direction){
                    V_DIR_A;
                } else {
                    V_DIR_B;
                }        
            break;        
        }    
    }

    void TMC2660_init(uint8_t MotorNo) {
        //init the structures
        myMotors[MotorNo].mStatus                    = m_STOPPED;
        myMotors[MotorNo].mCrtPos                    = 0;//handle by interrupt
        myMotors[MotorNo].mDirection            = CW;
        myMotors[MotorNo].mStep                        = 8;//0=256uS 8=full step
        myMotors[MotorNo].mSPS                         = 100;//Steps per second (actual frequency of the timer) this is why 32 bit timer is nice
        myMotors[MotorNo].mStepsDec             = 2;//When To start decelerating
        myMotors[MotorNo].mStepsToTarget     = 0;//Steps to target
        
        //setting the default register values
        myMotors[MotorNo].mDRVCTRL  = DRVCTRL;
        myMotors[MotorNo].mCHOPCONF = CHOPCONF;
        myMotors[MotorNo].mSMARTEN  = SMARTEN;
        myMotors[MotorNo].mSGCSCONF = SGCSCONF;
        myMotors[MotorNo].mDRVCONF  = DRVCONF;
//        //All setting below can be done in a single pass
//        //This long way of setting up registers is to show the functions
//        
        //DRVCTRL settings
        TMC2660_setResolution(MotorNo, myMotors[MotorNo].mStep);
        TMC2660_setDoubleEdge(MotorNo, 0);//use single edge for stepping
        TMC2660_setInterpolation(MotorNo, 0);//do not interpolate steps
        //CHOPCONF settings
        TMC2660_setTimeOff(MotorNo, 4);//if 0 then the driver is disabled
        TMC2660_setHysteresisStart(MotorNo, 4);// !!! Valuse are moved to 0...7 not 1..8 HEND+HSTRT must be <= 17 (15 in datasheet)
        TMC2660_setHysteresisEnd(MotorNo, 3);// !!! remember, add +3 Valuse are moved to 0...15 not -3..12 HEND+HSTRT must be <= 17(15 in datasheet)
        TMC2660_setHysteresisDecrement(MotorNo, 0);
        TMC2660_setRandomTime(MotorNo, 0);
        TMC2660_setChopperMode(MotorNo, 0);//Standard mode (spreadCycle)
        //Blanking time interval, in system clock periods: %00: 16 %01: 24 %10: 36 %11: 54
        TMC2660_setBlankingTime(MotorNo, 2);
        //DRVCONF settings
        TMC2660_setReadOut(MotorNo, 1);//get stall guard value
        TMC2660_setVSENSE(MotorNo, 1);//sense resistor voltage is 310mV - will be changed by TMC2660_setRMS_Current if needed
        TMC2660_setStepDir(MotorNo, 0);//Select the Step/Dir interface
        TMC2660_setGndDetectionTime(MotorNo, 0);//3.2us
        TMC2660_setGndProtection(MotorNo, 0);//enable short to ground protection
        TMC2660_set_SlopeControlLowSide(MotorNo, 3);// medium
        TMC2660_set_SlopeControlHighSide(MotorNo, 3);// medium
        //SMARTEN settings
        TMC2660_setCoolStepThldLow(MotorNo, 2);//if not 0 then coolStep is enabled
        TMC2660_setCurrentIncrement(MotorNo, 1);
        TMC2660_setCoolStepThldHigh(MotorNo, 2);
        TMC2660_setCurrentDecrementSpeed(MotorNo, 32);
        TMC2660_setMinCoolStepCurrent(MotorNo, 1);//½ CS current setting
        //SGCSCONF settings
        TMC2660_setCurrentScale(MotorNo, 31);//or use TMC2660_setRMS_Current scale
        //TMC2660_setRMS_Current(MotorNo, 1697);//current in mA 2.4A max/
        TMC2660_setStallGuardThld(MotorNo, 63);//increase/decrese depending on the torque needed -64 to 63
        TMC2660_setStallGuardFilter(MotorNo, 1);//enable filter for better accuracy
        TMC2660_setSpeed(MotorNo, myMotors[MotorNo].mSPS);//set steps per second
        printf("------------------------------------------\n");
        print_Bits(myMotors[MotorNo].mDRVCTRL);
        print_Bits(myMotors[MotorNo].mCHOPCONF);
        print_Bits(myMotors[MotorNo].mSMARTEN);
        print_Bits(myMotors[MotorNo].mSGCSCONF);
        print_Bits(myMotors[MotorNo].mDRVCONF);
        printf("------------------------------------------\n");
    }

    void TMC2660_start(uint8_t MotorNo){
        printf("------------------------------------------\n");
        printf("Motor = %d\n", MotorNo);
        printf("DRVCTRL  ");
        send(MotorNo, myMotors[MotorNo].mDRVCTRL);

        printf("CHOPCONF ");
        send(MotorNo, myMotors[MotorNo].mCHOPCONF);

        printf("SMARTEN  ");
        send(MotorNo, myMotors[MotorNo].mSMARTEN);

        printf("SGCSCONF ");
        send(MotorNo, myMotors[MotorNo].mSGCSCONF);

        printf("DRVCONF  ");
        send(MotorNo, myMotors[MotorNo].mDRVCONF);
        printf("------------------------------------------\n");        
        
        TMC2660_setDirection(MotorNo, myMotors[MotorNo].mDirection);
        //save that we are in running mode
        myMotors[MotorNo].mStatus = m_STARTING;
        //Enable pin set to low
        if(MotorNo){
            __HAL_TIM_ENABLE_IT(&htim5, TIM_IT_UPDATE);
            //Motor 1 PWM
            //HAL_TIM_Base_Start(&htim5);
            HAL_TIM_PWM_Start(&htim5, TIM_CHANNEL_4);
            V_EN_On;
        } else {
            __HAL_TIM_ENABLE_IT(&htim2, TIM_IT_UPDATE);
            //Motor 0 PWM
            //HAL_TIM_Base_Start(&htim2);
            HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3);
            H_EN_On;
        }
    }


    //0: No motor stall detected.
    //1: stallGuard2 threshold has been reached, and the SG_TST output is driven high.
    uint8_t TMC2660_getStallGuardStatus(uint8_t MotorNo){
        return myMotors[MotorNo].mDRVSTATUS & ONE;
    }

    //0: No overtemperature shutdown condition.
    //1: Overtemperature shutdown has occurred.
    uint8_t TMC2660_getTempShutDown(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVSTATUS >> OT_pos) & ONE);
    }

    //0: No overtemperature warning condition.
    //1: Warning threshold is active.
    uint8_t TMC2660_getTempWarning(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVSTATUS >> OTPW_pos) & ONE);
    }

    //0: No short to ground shutdown condition.
    //1: Short to ground shutdown condition. The short counter is incremented by each short
    //circuit and the chopper cycle is suspended. The counter is decremented for each phase
    //polarity change. The MOSFETs are shut off when the counter reaches 3 and remain shut off
    //until the shutdown condition is cleared by disabling and re-enabling the driver.
    //The shutdown conditions reset by deasserting the ENN input or clearing the TOFF parameter.
    uint8_t TMC2660_getShortA(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVSTATUS >> S2GA_pos) & ONE);
    }

    uint8_t TMC2660_getShortB(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVSTATUS >> S2GB_pos) & ONE);
    }

    //0: No open load condition detected.
    //1: No chopper event has happened during the last period with constant coil polarity.
    //Only a current above 1/16 of the maximum setting can clear this bit!
    //Hint: This bit is only a status indicator. The chip takes no other action when this bit is set.
    //False indications may occur during fast motion and at standstill. Check this bit only during slow motion.
    uint8_t TMC2660_getOpenLoadA(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVSTATUS >> OLA_pos) & ONE);
    }

    uint8_t TMC2660_getOpenLoadB(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVSTATUS >> OLB_pos) & ONE);
    }

    //0: No standstill condition detected.
    //1: No active edge occurred on the STEP input during the last 220 system clock cycles.
    uint8_t TMC2660_getStandStill(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVSTATUS >> STST_pos) & ONE);
    }

    void TMC2660_getStatus(uint8_t MotorNo){
        
        printf("->getStat DRVCONF %d = \n", MotorNo);
        print_Bits(myMotors[MotorNo].mDRVCONF);
        send(MotorNo, myMotors[MotorNo].mDRVCONF);
        printf("Result \n");
        print_Bits(myMotors[MotorNo].mDRVCONF);
        uint32_t response = myMotors[MotorNo].mDRVSTATUS & 0xFFCFF;
        printf("& 0xFFCFF \n");
        print_Bits(response);
        myMotors[MotorNo].mDRVSTATUS = (response & 0xFF);
        printf("& 0xFF \n");
        print_Bits(myMotors[MotorNo].mDRVCONF);
        myMotors[MotorNo].mDRVSTATUS |= (response & 0xFFC00);
        printf("& 0xFFC00 \n");
        print_Bits(myMotors[MotorNo].mDRVCONF);
        printf("getStatus response %d = ", MotorNo);
        print_Bits(myMotors[MotorNo].mDRVSTATUS);
        if(TMC2660_getStallGuardStatus(MotorNo))
            printf("Motor %d StallGuard detected \n", MotorNo);
        if(TMC2660_getTempShutDown(MotorNo))
            printf("Motor %d TempShutDown detected \n", MotorNo);
        if(TMC2660_getTempWarning(MotorNo))
            printf("Motor %d TempWarning detected \n", MotorNo);        
        if(TMC2660_getShortA(MotorNo))
            printf("Motor %d A Short to GND detected \n", MotorNo);
        if(TMC2660_getShortB(MotorNo))
            printf("Motor %d B Short to GND detected \n", MotorNo);
        if(TMC2660_getOpenLoadA(MotorNo))
            printf("Motor %d A OpenLoad detected \n", MotorNo);
        if(TMC2660_getOpenLoadB(MotorNo))
            printf("Motor %d B OpenLoad detected \n", MotorNo);    
        if(TMC2660_getStandStill(MotorNo))
            printf("Motor %d StandStill detected \n", MotorNo);
        //printf("Motor %d StallGuardValue %d \n", MotorNo, TMC2660_getFullStallGuardValue(MotorNo));            
    }
    
//we start with DRVCTRL register
//0            1            2            3            4    5    6    7    8            9        
//MRES0    MRES1    MRES2    MRES3    0    0    0    0    DEDGE    INTPOL    
//10    11    12    13    14    15    16    17    18    19                                                                            
//0    0    0    0    0    0    0    0    0    0

//Microstep resolution for STEP/DIR mode
//Microsteps per 90°:
//%0000:0 256
//%0001:1 128
//%0010:2 64
//%0011:3 32
//%0100:4 16
//%0101:5 8
//%0110:6 4
//%0111:7 2 (halfstep)
//%1000:8 1 (fullstep)
void TMC2660_setResolution(uint8_t MotorNo, uint16_t Resolution){
    myMotors[MotorNo].mDRVCTRL = (myMotors[MotorNo].mDRVCTRL & MRES_mask) | Resolution;
    if(myMotors[MotorNo].mStatus)
        send(MotorNo, myMotors[MotorNo].mDRVCTRL);
}

uint16_t TMC2660_getResolution(uint8_t MotorNo){
    return (myMotors[MotorNo].mDRVCTRL & (~MRES_mask));
}

    //Enable double edge STEP pulses
    //0: Rising STEP pulse edge is active, falling edge is inactive.
    //1: Both rising and falling STEP pulse edges are active.
    void TMC2660_setDoubleEdge(uint8_t MotorNo, uint8_t doubleEdge){
    if(doubleEdge){
        myMotors[MotorNo].mDRVCTRL |= DEDGE_mask;
    } else {
        myMotors[MotorNo].mDRVCTRL &= ~DEDGE_mask;
    }
    if(myMotors[MotorNo].mStatus)
        send(MotorNo, myMotors[MotorNo].mDRVCTRL);
    }

    uint8_t TMC2660_getDoubleEdge(uint8_t MotorNo){
        return (myMotors[MotorNo].mDRVCTRL >> DEDGE_pos) & ONE;
    }

    //Enable STEP interpolation
    //0: Disable STEP pulse interpolation.
    //1: Enable STEP pulse multiplication by 16.
    void TMC2660_setInterpolation(uint8_t MotorNo, uint8_t interpolation){
    if(interpolation){
        myMotors[MotorNo].mDRVCTRL |= INTPOL_mask;
    } else {
        myMotors[MotorNo].mDRVCTRL &= ~INTPOL_mask;
    }
    if(myMotors[MotorNo].mStatus)
        send(MotorNo, myMotors[MotorNo].mDRVCTRL);
    }

    uint8_t TMC2660_getInterpolation(uint8_t MotorNo){
        return (myMotors[MotorNo].mDRVCTRL >> INTPOL_pos) & ONE;
    }

    //CHOPCONF register
    //0            1            2            3            4                5                6                7            8            9            
    //TOFF0    TOFF1    TOFF2    TOFF3    HSTRT0    HSTRT1    HSTRT2    HEND0    HEND1    HEND2    
    //10        11        12        13        14    15        16        17    18    19
    //HEND3    HDEC0    HDEC1    RNDTF    CHM    TBL0    TBL1    0        0        1

    //Duration of slow decay phase. If TOFF is 0, the MOSFETs are shut off.
    //If TOFF is nonzero, slow decay time is a multiple of system clock
    //periods: NCLK= 12 + (32 x TOFF) (Minimum time is 64clocks.)
    //%0000: Driver disable, all bridges off
    //%0001: 1 (use with TBL of minimum 24 clocks)
    //%0010 … %1111: 2 … 15
    void TMC2660_setTimeOff(uint8_t MotorNo, uint8_t TimeOff){
    if(TimeOff > 15)
        TimeOff = 15;
    myMotors[MotorNo].mCHOPCONF = (myMotors[MotorNo].mCHOPCONF & TOFF_mask) | TimeOff;
    if(myMotors[MotorNo].mStatus)
        send(MotorNo, myMotors[MotorNo].mCHOPCONF);
    }

    uint8_t TMC2660_getTimeOff(uint8_t MotorNo){
        return (myMotors[MotorNo].mCHOPCONF & (~TOFF_mask));
    }

    //CHM=0 Hysteresis start offset from HEND:
    //%000: 1 %001: 2 %010: 3 %011: 4 %100: 5 %101: 6 %110: 7 %111: 8
    //Effective: HEND+HSTRT must be = 15
    //CHM=1 Three least-significant bits of the duration of the fast decay phase. The MSB is HDEC0.
    //Fast decay time is a multiple of system clock periods: NCLK= 32 x (HDEC0+HSTRT)
    // !!! Valuse are moved to 0...7 not 1..8
    void TMC2660_setHysteresisStart(uint8_t MotorNo, uint8_t HysteresisStart){
        if(HysteresisStart > 7)
            HysteresisStart = 7;
        int8_t hEND = TMC2660_getHysteresisEnd(MotorNo);
        if((hEND + HysteresisStart) > 17)
            HysteresisStart = 17 - hEND;
        myMotors[MotorNo].mCHOPCONF = (myMotors[MotorNo].mCHOPCONF & HSTRT_mask) | ((uint32_t)HysteresisStart << HSTRT_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mCHOPCONF);
    }

    uint8_t TMC2660_getHysteresisStart(uint8_t MotorNo){
        return ((myMotors[MotorNo].mCHOPCONF & (~HSTRT_mask)) >> HSTRT_pos); 
    }

    //CHM=0 %0000 … %1111:
    //Hysteresis is -3, -2, -1, 0, 1, …, 12 (1/512 of this setting adds to current setting)
    //This is the hysteresis value which becomes used for the hysteresis chopper
    //CHM=1 %0000 … %1111: Offset is -3, -2, -1, 0, 1, …, 12
    //This is the sine wave offset and 1/512 of the value becomes added to the absolute value
    //of each sine wave entry.
    // !!! Valuse are moved to 0...15 not -3..12
    void TMC2660_setHysteresisEnd(uint8_t MotorNo, uint8_t HysteresisEnd){
        if(HysteresisEnd > 15)
            HysteresisEnd = 15;
        uint8_t hSTA = TMC2660_getHysteresisStart(MotorNo);
        if((hSTA + HysteresisEnd) > 17)
            HysteresisEnd = 17 - hSTA;
        myMotors[MotorNo].mCHOPCONF = (myMotors[MotorNo].mCHOPCONF & HEND_mask) | ((uint32_t)HysteresisEnd << HEND_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mCHOPCONF);
    }

    uint8_t TMC2660_getHysteresisEnd(uint8_t MotorNo){
        return ((myMotors[MotorNo].mCHOPCONF & (~HEND_mask)) >> HEND_pos);
    }

    //Hysteresis decrement interval or Fast decay mode
    //CHM=0 Hysteresis decrement period setting, in system clock periods: %00: 16 %01: 32 %10: 48 %11: 64
    //CHM=1 HDEC1=0: current comparator can terminate the fast decay phase before timer expires.
    //HDEC1=1: only the timer terminates the fast decay phase.
    //HDEC0: MSB of fast decay time setting
    void TMC2660_setHysteresisDecrement(uint8_t MotorNo, uint8_t hysteresisDecrement){
        if(hysteresisDecrement > 3)
            hysteresisDecrement = 3;
        myMotors[MotorNo].mCHOPCONF = (myMotors[MotorNo].mCHOPCONF & HDEC_mask) | ((uint32_t)hysteresisDecrement << HDEC_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mCHOPCONF);
    }

    uint8_t TMC2660_getHysteresisDecrement(uint8_t MotorNo){
        return ((myMotors[MotorNo].mCHOPCONF & (~HDEC_mask)) >> HDEC_pos);
    }

    //Enable randomizing the slow decay phase duration:
    //0: Chopper off time is fixed as set by bits tOFF
    //1: Random mode, tOFF is random modulated by dNCLK= -12 … +3 clocks.
    void TMC2660_setRandomTime(uint8_t MotorNo, uint8_t randomTime){
        if(randomTime){
            myMotors[MotorNo].mCHOPCONF |= RNDTF_mask;
        } else {
            myMotors[MotorNo].mCHOPCONF &= ~RNDTF_mask;
        }
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mCHOPCONF);
    }

    uint8_t TMC2660_getRandomTime(uint8_t MotorNo){
        return ((myMotors[MotorNo].mCHOPCONF >> RNDTF_pos) & ONE);
    }

    // This mode bit affects the interpretation of the HDEC, HEND, and HSTRT parameters shown below
    //0 - Standard mode (spreadCycle)
    //1 - Constant tOFF with fast decay time. Fast decay time is also terminated when the
    //negative nominal current is reached. Fast decay is after on time.

    void TMC2660_setChopperMode(uint8_t MotorNo, uint8_t ChopperMode){
        if(ChopperMode){
            myMotors[MotorNo].mCHOPCONF |= CHM_mask;
        } else {
            myMotors[MotorNo].mCHOPCONF &= ~CHM_mask;
        }
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mCHOPCONF);
    }

    uint8_t TMC2660_getChopperMode(uint8_t MotorNo){
        return ((myMotors[MotorNo].mCHOPCONF >> CHM_pos) & ONE);
    }

    //Blanking time interval, in system clock periods: %00: 16 %01: 24 %10: 36 %11: 54
    void TMC2660_setBlankingTime(uint8_t MotorNo, uint8_t BlankingTime){
        if(BlankingTime > 3)
            BlankingTime = 3;
        myMotors[MotorNo].mCHOPCONF = (myMotors[MotorNo].mCHOPCONF & TBL_mask) | ((uint32_t)BlankingTime << TBL_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mCHOPCONF);
    }

    uint8_t TMC2660_getBlankingTime(uint8_t MotorNo){
        return ((myMotors[MotorNo].mCHOPCONF & (~TBL_mask)) >> TBL_pos);
    }

    //Next on the list is SMARTEN register
    //0        1        2        3        4    5        6        7    8        9        
    //SEMIN0    SEMIN1    SEMIN2    SEMIN3    0    SEUP0    SEUP1    0    SEMAX0    SEMAX1    
    //10        11        12    13        14        15        16    17    18    19                                                                            
    //SEMAX2    SEMAX3    0    SEDN0    SEDN1    SEIMIN    0    1    0    1

    //Lower coolStep threshold/coolStep disable
    //If SEMIN is 0, coolStep is disabled. If SEMIN is nonzero and the stallGuard2 value SG falls below SEMIN x 32,
    //the coolStep current scaling factor is increased.

    void TMC2660_setCoolStepThldLow(uint8_t MotorNo, uint8_t LowerCoolStepThreshold){
        if(LowerCoolStepThreshold > 15)
            LowerCoolStepThreshold = 15;
        myMotors[MotorNo].mSMARTEN = (myMotors[MotorNo].mSMARTEN & SEMIN_mask) | LowerCoolStepThreshold;
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mSMARTEN);
    }

    uint8_t TMC2660_getCoolStepThldLow(uint8_t MotorNo){
        return (myMotors[MotorNo].mSMARTEN & (~SEMIN_mask));
    }

    //Current increment size
    //Number of current increment steps for each time that the stallGuard2 value SG is sampled below the lower
    //threshold: %00: 1 %01: 2 %10: 4 %11: 8
    void TMC2660_setCurrentIncrement(uint8_t MotorNo, uint8_t CurrentIncrement){
        if(CurrentIncrement > 3)
            CurrentIncrement = 3;
        myMotors[MotorNo].mSMARTEN = (myMotors[MotorNo].mSMARTEN & SEUP_mask) | ((uint32_t)CurrentIncrement << SEUP_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mSMARTEN);
    }

    uint8_t TMC2660_getCurrentIncrement(uint8_t MotorNo){
        return ((myMotors[MotorNo].mSMARTEN & (~SEUP_mask)) >> SEUP_pos);
    }

    //Upper coolStep threshold as an offset from the lower threshold
    //If the stallGuard2 measurement value SG is sampled equal to or above (SEMIN+SEMAX+1) x 32
    //enough times, then the coil current scaling factor is decremented.
    void TMC2660_setCoolStepThldHigh(uint8_t MotorNo, uint8_t UpperCoolStepThreshold){
        if(UpperCoolStepThreshold > 15)
            UpperCoolStepThreshold = 15;
        myMotors[MotorNo].mSMARTEN = (myMotors[MotorNo].mSMARTEN & SEMAX_mask) | ((uint32_t)UpperCoolStepThreshold << SEMAX_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mSMARTEN);
    }

    uint8_t TMC2660_getCoolStepThldHigh(uint8_t MotorNo){
        return ((myMotors[MotorNo].mSMARTEN & (~SEMAX_mask)) >> SEMAX_pos);
    }

    //Current decrement speed
    //Number of times that the stallGuard2 value must be sampled equal to or above the
    //upper threshold for each decrement of the coil current: %00: 32 %01: 8 %10: 2 %11: 1
    void TMC2660_setCurrentDecrementSpeed(uint8_t MotorNo, uint8_t CurrentDecrementSpeed){
        if(CurrentDecrementSpeed > 3)
            CurrentDecrementSpeed = 3;
        myMotors[MotorNo].mSMARTEN = (myMotors[MotorNo].mSMARTEN & SEDN_mask) | ((uint32_t)CurrentDecrementSpeed<<SEDN_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mSMARTEN);
    }

    uint8_t TMC2660_getCurrentDecrementSpeed(uint8_t MotorNo){
        return (myMotors[MotorNo].mSMARTEN & (~SEDN_mask)) >> SEDN_pos;
    }

    //Minimum coolStep current
    //0: ½ CS current setting
    //1: ¼ CS current setting
    void TMC2660_setMinCoolStepCurrent(uint8_t MotorNo, uint8_t coolStepCurrent){
        if(coolStepCurrent){
            myMotors[MotorNo].mSMARTEN |= SEIMIN_mask;
        } else {
            myMotors[MotorNo].mSMARTEN &= ~SEIMIN_mask;
        }
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mSMARTEN);
    }

    uint8_t TMC2660_getMinCoolStepCurrent(uint8_t MotorNo){
        return ((myMotors[MotorNo].mSMARTEN >> SEIMIN_pos) & ONE);
    }

    //Next on the list is SGCSCONF register
    //0        1    2    3    4    5    6    7    8        9        
    //CS0    CS1    CS2    CS3    CS4    0    0    0    SGT0    SGT1    
    //10    11        12        13        14        15    16        17    18    19                                                                            
    //SGT2    SGT3    SGT4    SGT5    SGT6    0    SFILT    0        1        1

    //Requested current = mA = I_rms/1000
    //Equation for current:
    //I_rms = (CS+1)/32 * (V_fs/R_sense) * (1/sqrt(2))
    //Solve for CS ->
    //CS = 32*sqrt(2)*I_rms*R_sense/V_fs - 1
    //  Example:
    //  vsense = 0b0 -> V_fs = 0.310V //Typical
    //  mA = 1650mA = I_rms/1000 = 1.65A
    //  R_sense = 0.100 Ohm
    //  CS = 32*sqrt(2)*1.65*0.100/0.310 - 1 = 24,09
    //  CS = 24
    void TMC2660_setRMS_Current(uint8_t MotorNo, uint16_t mA) {
        uint8_t CS = TMC2660_SENS_LOW*(double)mA - 1.0;
        // If Current Scale is too low, turn on high sensitivity R_sense and calculate again
        if (CS < 16) {
            TMC2660_setVSENSE(MotorNo, 1);
            CS = TMC2660_SENS_HIGH*(double)mA - 1.0;
        } else { // If CS >= 16, turn off high_sense_r
            TMC2660_setVSENSE(MotorNo, 0);
        }
        if(CS > 31)
            CS = 31;
        TMC2660_setCurrentScale(MotorNo, CS);
    }
    
    
    //Current scale (scales digital currents A and B)
    //Current scaling for SPI and step/direction operation. %00000 … %11111: 1/32, 2/32, 3/32, … 32/32
    //This value is biased by 1 and divided by 32, so the range is 1/32 to 32/32. Example: CS=0 is 1/32 current
    void TMC2660_setCurrentScale(uint8_t MotorNo, uint8_t CurrentScale){
        if(CurrentScale > 31)
            CurrentScale = 31;
        myMotors[MotorNo].mSGCSCONF = (myMotors[MotorNo].mSGCSCONF & CS_mask) | CurrentScale;
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mSGCSCONF);
    }

    uint8_t TMC2660_getCurrentScale(uint8_t MotorNo){
        return (myMotors[MotorNo].mSGCSCONF & (~CS_mask));
    }

    //stallGuard2 threshold value
    //The stallGuard2 threshold value controls the optimum measurement range for readout.
    //A lower value results in a higher sensitivity and requires less torque to indicate a stall.
    //The value is a two’s complement signed integer. Values below -10 are not recommended.
    //Range: -64 to +63
    void TMC2660_setStallGuardThld(uint8_t MotorNo, int8_t StallGuardThld){
        if(StallGuardThld > 63) StallGuardThld = 63;
        if(StallGuardThld < -64) StallGuardThld = -64;
        StallGuardThld &= 0x7f;
        myMotors[MotorNo].mSGCSCONF = (myMotors[MotorNo].mSGCSCONF & SGT_mask) | ((uint32_t)StallGuardThld << SGT_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mSGCSCONF);
    }

    int8_t TMC2660_getStallGuardThld(uint8_t MotorNo){
    uint8_t tmp = ((myMotors[MotorNo].mSGCSCONF & (~SGT_mask)) >> SGT_pos);
    if(tmp > 63){
        return tmp - 128;
    } else {
            return tmp;
    }
    }

    //stallGuard2 filter enable
    //0: Standard mode, fastest response time.
    //1: Filtered mode, updated once for each four fullsteps to compensate for variation in motor construction, highest accuracy.
    void TMC2660_setStallGuardFilter(uint8_t MotorNo, uint8_t GuardFilter){
        if(GuardFilter){
            myMotors[MotorNo].mSGCSCONF |= SFILT_mask;
        } else {
            myMotors[MotorNo].mSGCSCONF &= ~SFILT_mask;
        }
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mSGCSCONF);
    }

    uint8_t TMC2660_getStallGuardFilter(uint8_t MotorNo){
        return ((myMotors[MotorNo].mSGCSCONF >> SFILT_pos) & ONE);
    }    

    //Next on the list is DRVCONF register
    //0    1    2    3    4        5        6        7        8        9        
    //0    0    0    0    RDSEL0    RDSEL1    VSENSE    SDOFF    TS2G0    TS2G1    
    //10        11    12        13        14        15        16    17    18    19                                                                            
    //DISS2G    0    SLPL0    SLPL1    SLPH0    SLPH1    TST    1    1    1

    //Select value for read out (RD bits)
    //%00 Microstep position read back
    //%01 stallGuard2 level read back
    //%10 stallGuard2 and coolStep current level read back
    //%11 Reserved, do not use
    void TMC2660_setReadOut(uint8_t MotorNo, uint8_t ReadOut){
        if(ReadOut > 2)
            ReadOut = 2;
        myMotors[MotorNo].mDRVCONF = (myMotors[MotorNo].mDRVCONF & RDSEL_mask) | ((uint32_t)ReadOut << RDSEL_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mDRVCONF);
    }

    uint8_t TMC2660_getReadOut(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVCONF & (~RDSEL_mask)) >> RDSEL_pos);
    }

    //Sense resistor voltage-based current scaling
    //0: Full-scale sense resistor voltage is 305mV.
    //1: Full-scale sense resistor voltage is 165mV.
    //(Full-scale refers to a current setting of 31 and a DAC value of 255.)
    void TMC2660_setVSENSE(uint8_t MotorNo, uint8_t vSense){
        if(vSense){
            myMotors[MotorNo].mDRVCONF |= VSENSE_mask;
        } else {
            myMotors[MotorNo].mDRVCONF &= ~VSENSE_mask;
        }
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mDRVCONF);
    }

    uint8_t TMC2660_getVSENSE(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVCONF >> VSENSE_pos) & ONE);
    }
    
    //STEP/DIR interface disable
    //0: Enable STEP and DIR interface.
    //1: Disable STEP and DIR interface. SPI interface is used to move motor.
    void TMC2660_setStepDir(uint8_t MotorNo, uint8_t StepDirSPI){
        if(StepDirSPI){
            myMotors[MotorNo].mDRVCONF |= SDOFF_mask;
        } else {
            myMotors[MotorNo].mDRVCONF &= ~SDOFF_mask;
        }
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mDRVCONF);
    }

    uint8_t TMC2660_getStepDir(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVCONF >> SDOFF_pos) & ONE);
    }
    
    //Short to GND detection timer
    //%00: 3.2µs. %01: 1.6µs. %10: 1.2µs. %11: 0.8µs.
    void TMC2660_setGndDetectionTime(uint8_t MotorNo, uint8_t GndTimer){
        if(GndTimer > 3)
            GndTimer = 3;
        myMotors[MotorNo].mDRVCONF = (myMotors[MotorNo].mDRVCONF & TS2G_mask) | ((uint32_t)GndTimer << TS2G_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mDRVCONF);
    }

    uint8_t TMC2660_getGndDetectionTime(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVCONF & (~TS2G_mask)) >> TS2G_pos);
    }
    
    //Short to GND protection disable
    //0: Short to GND protection is enabled.
    //1: Short to GND protection is disabled.
    void TMC2660_setGndProtection(uint8_t MotorNo, uint8_t GndProtection){
        if(GndProtection){
            myMotors[MotorNo].mDRVCONF |= DISS2G_mask;
        } else {
            myMotors[MotorNo].mDRVCONF &= ~DISS2G_mask;
        }
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mDRVCONF);
    }

    uint8_t TMC2660_getGndProtection(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVCONF >> DISS2G_pos) & ONE);
    }

    //Slope control, low side
    //%00: Minimum.    %01: Minimum.    %10: Medium.    %11: Maximum.
    void TMC2660_set_SlopeControlLowSide(uint8_t MotorNo, uint8_t SlopeControlLowSide){
        if(SlopeControlLowSide > 3)
            SlopeControlLowSide = 3;
        myMotors[MotorNo].mDRVCONF = (myMotors[MotorNo].mDRVCONF & SLPL_mask) | ((uint32_t)SlopeControlLowSide << SLPL_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mDRVCONF);
    }

    uint8_t TMC2660_getSlopeControlLowSide(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVCONF & (~SLPL_mask)) >> SLPL_pos);
    }
    
    //Slope control, high side
    //%00: Minimum    %01: Minimum temperature compensation mode.    %10: Medium temperature compensation mode.
    //%11: Maximum    In temperature compensated mode (tc), the MOSFET gate driver strength is increased if the overtemperature
    //warning temperature is reached. This compensates for temperature dependency of high-side slope control.
    void TMC2660_set_SlopeControlHighSide(uint8_t MotorNo, uint8_t SlopeControlHighSide){
        if(SlopeControlHighSide > 3)
            SlopeControlHighSide = 3;
        myMotors[MotorNo].mDRVCONF = (myMotors[MotorNo].mDRVCONF & SLPH_mask) | ((uint32_t)SlopeControlHighSide << SLPH_pos);
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mDRVCONF);
    }

    uint8_t TMC2660_getSlopeControlHighSide(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVCONF & (~SLPH_mask)) >> SLPH_pos);
    }
    
    //Reserved TEST mode
    //Must be cleared for normal operation. When set, the SG_TST output exposes digital test values,
    //and the TEST_ANA output exposes analog test values. Test value selection is controlled by SGT1 and SGT0:
    //TEST_ANA: %00: anatest_2vth, %01: anatest_dac_out, %10: anatest_vdd_half.
    //SG_TST: %00: comp_A, %01: comp_B, %10: CLK, %11: on_state_xy
    void TMC2660_setTestMode(uint8_t MotorNo, uint8_t TestMode){
        if(TestMode){
            myMotors[MotorNo].mDRVCONF |= TST_mask;
        } else {
            myMotors[MotorNo].mDRVCONF &= ~TST_mask;
        }
        if(myMotors[MotorNo].mStatus)
            send(MotorNo, myMotors[MotorNo].mDRVCONF);
    }

    uint8_t TMC2660_getTestMode(uint8_t MotorNo){
        return ((myMotors[MotorNo].mDRVCONF >> TST_pos) & ONE);
    }

 

    

Comments powered by CComment

Who’s online

We have 62 guests and no members online