Library for Trinamic TMC2209 stepper modules to drive bipolar stepper motors. Ported and adapted from https://github.com/teemuatlut/TMCStepper
Revision 0:f4343071c8b1, committed 2021-03-18
- Comitter:
- charly
- Date:
- Thu Mar 18 20:50:27 2021 +0000
- Child:
- 1:5ba0c258c4ed
- Commit message:
- First version of TMCStepper for Trinamic TMC2209-modules.; Software ported and adapted from https://github.com/teemuatlut/TMCStepper
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/CHOPCONF.cpp Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,110 @@ +#include "TMCStepper.h" +#include "TMC_MACROS.h" + +#define SET_REG(SETTING) CHOPCONF_register.SETTING = B; write(CHOPCONF_register.address, CHOPCONF_register.sr) + +// CHOPCONF +/* +uint32_t TMC2130Stepper::CHOPCONF() { + return read(CHOPCONF_register.address); +} +void TMC2130Stepper::CHOPCONF(uint32_t input) { + CHOPCONF_register.sr = input; + write(CHOPCONF_register.address, CHOPCONF_register.sr); +} + +void TMC2130Stepper::toff( uint8_t B ) { SET_REG(toff); } +void TMC2130Stepper::hstrt( uint8_t B ) { SET_REG(hstrt); } +void TMC2130Stepper::hend( uint8_t B ) { SET_REG(hend); } +//void TMC2130Stepper::fd( uint8_t B ) { SET_REG(fd); } +void TMC2130Stepper::disfdcc( bool B ) { SET_REG(disfdcc); } +void TMC2130Stepper::rndtf( bool B ) { SET_REG(rndtf); } +void TMC2130Stepper::chm( bool B ) { SET_REG(chm); } +void TMC2130Stepper::tbl( uint8_t B ) { SET_REG(tbl); } +void TMC2130Stepper::vsense( bool B ) { SET_REG(vsense); } +void TMC2130Stepper::vhighfs( bool B ) { SET_REG(vhighfs); } +void TMC2130Stepper::vhighchm( bool B ) { SET_REG(vhighchm);} +void TMC2130Stepper::sync( uint8_t B ) { SET_REG(sync); } +void TMC2130Stepper::mres( uint8_t B ) { SET_REG(mres); } +void TMC2130Stepper::intpol( bool B ) { SET_REG(intpol); } +void TMC2130Stepper::dedge( bool B ) { SET_REG(dedge); } +void TMC2130Stepper::diss2g( bool B ) { SET_REG(diss2g); } + +uint8_t TMC2130Stepper::toff() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.toff; } +uint8_t TMC2130Stepper::hstrt() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.hstrt; } +uint8_t TMC2130Stepper::hend() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.hend; } +//uint8_t TMC2130Stepper::fd() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.fd; } +bool TMC2130Stepper::disfdcc() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.disfdcc; } +bool TMC2130Stepper::rndtf() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.rndtf; } +bool TMC2130Stepper::chm() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.chm; } +uint8_t TMC2130Stepper::tbl() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.tbl; } +bool TMC2130Stepper::vsense() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.vsense; } +bool TMC2130Stepper::vhighfs() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.vhighfs; } +bool TMC2130Stepper::vhighchm() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.vhighchm;} +uint8_t TMC2130Stepper::sync() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.sync; } +uint8_t TMC2130Stepper::mres() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.mres; } +bool TMC2130Stepper::intpol() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.intpol; } +bool TMC2130Stepper::dedge() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.dedge; } +bool TMC2130Stepper::diss2g() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.diss2g; } + +void TMC5160Stepper::diss2vs(bool B){ SET_REG(diss2vs); } +void TMC5160Stepper::tpfd(uint8_t B){ SET_REG(tpfd); } +bool TMC5160Stepper::diss2vs() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.diss2vs; } +uint8_t TMC5160Stepper::tpfd() { CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.tpfd; } +*/ +void TMC2208Stepper::CHOPCONF(uint32_t input) { + CHOPCONF_register.sr = input; + write(CHOPCONF_register.address, CHOPCONF_register.sr); +} +uint32_t TMC2208Stepper::CHOPCONF() { + return read(CHOPCONF_register.address); +} +void TMC2208Stepper::toff ( uint8_t B ) { SET_REG(toff); } +void TMC2208Stepper::hstrt ( uint8_t B ) { SET_REG(hstrt); } +void TMC2208Stepper::hend ( uint8_t B ) { SET_REG(hend); } +void TMC2208Stepper::tbl ( uint8_t B ) { SET_REG(tbl); } +void TMC2208Stepper::vsense ( bool B ) { SET_REG(vsense); } +void TMC2208Stepper::mres ( uint8_t B ) { SET_REG(mres); } +void TMC2208Stepper::intpol ( bool B ) { SET_REG(intpol); } +void TMC2208Stepper::dedge ( bool B ) { SET_REG(dedge); } +void TMC2208Stepper::diss2g ( bool B ) { SET_REG(diss2g); } +void TMC2208Stepper::diss2vs( bool B ) { SET_REG(diss2vs); } + +uint8_t TMC2208Stepper::toff() { TMC2208_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.toff; } +uint8_t TMC2208Stepper::hstrt() { TMC2208_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.hstrt; } +uint8_t TMC2208Stepper::hend() { TMC2208_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.hend; } +uint8_t TMC2208Stepper::tbl() { TMC2208_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.tbl; } +bool TMC2208Stepper::vsense() { TMC2208_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.vsense; } +uint8_t TMC2208Stepper::mres() { TMC2208_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.mres; } +bool TMC2208Stepper::intpol() { TMC2208_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.intpol; } +bool TMC2208Stepper::dedge() { TMC2208_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.dedge; } +bool TMC2208Stepper::diss2g() { TMC2208_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.diss2g; } +bool TMC2208Stepper::diss2vs() { TMC2208_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.diss2vs; } +/* +#define GET_REG_2660(SETTING) return CHOPCONF_register.SETTING; + +uint32_t TMC2660Stepper::CHOPCONF() { return CHOPCONF_register.sr; } +void TMC2660Stepper::CHOPCONF(uint32_t data) { + CHOPCONF_register.sr = data; + write(CHOPCONF_register.address, CHOPCONF_register.sr); +} + +void TMC2660Stepper::toff(uint8_t B) { + SET_REG(toff); + if (B>0) _savedToff = B; +} +void TMC2660Stepper::hstrt(uint8_t B) { SET_REG(hstrt); } +void TMC2660Stepper::hend(uint8_t B) { SET_REG(hend); } +void TMC2660Stepper::hdec(uint8_t B) { SET_REG(hdec); } +void TMC2660Stepper::rndtf(bool B) { SET_REG(rndtf); } +void TMC2660Stepper::chm(bool B) { SET_REG(chm); } +void TMC2660Stepper::tbl(uint8_t B) { SET_REG(tbl); } + +uint8_t TMC2660Stepper::toff() { GET_REG_2660(toff); } +uint8_t TMC2660Stepper::hstrt() { GET_REG_2660(hstrt); } +uint8_t TMC2660Stepper::hend() { GET_REG_2660(hend); } +uint8_t TMC2660Stepper::hdec() { GET_REG_2660(hdec); } +bool TMC2660Stepper::rndtf() { GET_REG_2660(rndtf); } +bool TMC2660Stepper::chm() { GET_REG_2660(chm); } +uint8_t TMC2660Stepper::tbl() { GET_REG_2660(tbl); } +*/ \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/DRV_STATUS.cpp Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,38 @@ +#include "TMCStepper.h" +#include "TMC_MACROS.h" + +#define GET_REG(NS, SETTING) NS::DRV_STATUS_t r{0}; r.sr = DRV_STATUS(); return r.SETTING +/* +uint32_t TMC2130Stepper::DRV_STATUS() { return read(DRV_STATUS_t::address); } + +uint16_t TMC2130Stepper::sg_result(){ GET_REG(TMC2130_n, sg_result); } +bool TMC2130Stepper::fsactive() { GET_REG(TMC2130_n, fsactive); } +uint8_t TMC2130Stepper::cs_actual() { GET_REG(TMC2130_n, cs_actual); } +bool TMC2130Stepper::stallguard() { GET_REG(TMC2130_n, stallGuard); } +bool TMC2130Stepper::ot() { GET_REG(TMC2130_n, ot); } +bool TMC2130Stepper::otpw() { GET_REG(TMC2130_n, otpw); } +bool TMC2130Stepper::s2ga() { GET_REG(TMC2130_n, s2ga); } +bool TMC2130Stepper::s2gb() { GET_REG(TMC2130_n, s2gb); } +bool TMC2130Stepper::ola() { GET_REG(TMC2130_n, ola); } +bool TMC2130Stepper::olb() { GET_REG(TMC2130_n, olb); } +bool TMC2130Stepper::stst() { GET_REG(TMC2130_n, stst); } +*/ +uint32_t TMC2208Stepper::DRV_STATUS() { + return read(TMC2208_n::DRV_STATUS_t::address); +} + +bool TMC2208Stepper::otpw() { GET_REG(TMC2208_n, otpw); } +bool TMC2208Stepper::ot() { GET_REG(TMC2208_n, ot); } +bool TMC2208Stepper::s2ga() { GET_REG(TMC2208_n, s2ga); } +bool TMC2208Stepper::s2gb() { GET_REG(TMC2208_n, s2gb); } +bool TMC2208Stepper::s2vsa() { GET_REG(TMC2208_n, s2vsa); } +bool TMC2208Stepper::s2vsb() { GET_REG(TMC2208_n, s2vsb); } +bool TMC2208Stepper::ola() { GET_REG(TMC2208_n, ola); } +bool TMC2208Stepper::olb() { GET_REG(TMC2208_n, olb); } +bool TMC2208Stepper::t120() { GET_REG(TMC2208_n, t120); } +bool TMC2208Stepper::t143() { GET_REG(TMC2208_n, t143); } +bool TMC2208Stepper::t150() { GET_REG(TMC2208_n, t150); } +bool TMC2208Stepper::t157() { GET_REG(TMC2208_n, t157); } +uint16_t TMC2208Stepper::cs_actual() { GET_REG(TMC2208_n, cs_actual); } +bool TMC2208Stepper::stealth() { GET_REG(TMC2208_n, stealth); } +bool TMC2208Stepper::stst() { GET_REG(TMC2208_n, stst); } \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/GCONF.cpp Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,94 @@ +#include "TMCStepper.h" +#include "TMC_MACROS.h" + +#define SET_REG(SETTING) GCONF_register.SETTING = B; write(GCONF_register.address, GCONF_register.sr) + +// GCONF +/* +uint32_t TMC2130Stepper::GCONF() { + return read(GCONF_register.address); +} +void TMC2130Stepper::GCONF(uint32_t input) { + GCONF_register.sr = input; + write(GCONF_register.address, GCONF_register.sr); +} + +void TMC2130Stepper::I_scale_analog(bool B) { SET_REG(i_scale_analog); } +void TMC2130Stepper::internal_Rsense(bool B) { SET_REG(internal_rsense); } +void TMC2130Stepper::en_pwm_mode(bool B) { SET_REG(en_pwm_mode); } +void TMC2130Stepper::enc_commutation(bool B) { SET_REG(enc_commutation); } +void TMC2130Stepper::shaft(bool B) { SET_REG(shaft); } +void TMC2130Stepper::diag0_error(bool B) { SET_REG(diag0_error); } +void TMC2130Stepper::diag0_otpw(bool B) { SET_REG(diag0_otpw); } +void TMC2130Stepper::diag0_stall(bool B) { SET_REG(diag0_stall); } +void TMC2130Stepper::diag1_stall(bool B) { SET_REG(diag1_stall); } +void TMC2130Stepper::diag1_index(bool B) { SET_REG(diag1_index); } +void TMC2130Stepper::diag1_onstate(bool B) { SET_REG(diag1_onstate); } +void TMC2130Stepper::diag1_steps_skipped(bool B) { SET_REG(diag1_steps_skipped); } +void TMC2130Stepper::diag0_int_pushpull(bool B) { SET_REG(diag0_int_pushpull); } +void TMC2130Stepper::diag1_pushpull(bool B) { SET_REG(diag1_poscomp_pushpull); } +void TMC2130Stepper::small_hysteresis(bool B) { SET_REG(small_hysteresis); } +void TMC2130Stepper::stop_enable(bool B) { SET_REG(stop_enable); } +void TMC2130Stepper::direct_mode(bool B) { SET_REG(direct_mode); } + +bool TMC2130Stepper::I_scale_analog() { GCONF_t r{0}; r.sr = GCONF(); return r.i_scale_analog; } +bool TMC2130Stepper::internal_Rsense() { GCONF_t r{0}; r.sr = GCONF(); return r.internal_rsense; } +bool TMC2130Stepper::en_pwm_mode() { GCONF_t r{0}; r.sr = GCONF(); return r.en_pwm_mode; } +bool TMC2130Stepper::enc_commutation() { GCONF_t r{0}; r.sr = GCONF(); return r.enc_commutation; } +bool TMC2130Stepper::shaft() { GCONF_t r{0}; r.sr = GCONF(); return r.shaft; } +bool TMC2130Stepper::diag0_error() { GCONF_t r{0}; r.sr = GCONF(); return r.diag0_error; } +bool TMC2130Stepper::diag0_otpw() { GCONF_t r{0}; r.sr = GCONF(); return r.diag0_otpw; } +bool TMC2130Stepper::diag0_stall() { GCONF_t r{0}; r.sr = GCONF(); return r.diag0_stall; } +bool TMC2130Stepper::diag1_stall() { GCONF_t r{0}; r.sr = GCONF(); return r.diag1_stall; } +bool TMC2130Stepper::diag1_index() { GCONF_t r{0}; r.sr = GCONF(); return r.diag1_index; } +bool TMC2130Stepper::diag1_onstate() { GCONF_t r{0}; r.sr = GCONF(); return r.diag1_onstate; } +bool TMC2130Stepper::diag1_steps_skipped() { GCONF_t r{0}; r.sr = GCONF(); return r.diag1_steps_skipped; } +bool TMC2130Stepper::diag0_int_pushpull() { GCONF_t r{0}; r.sr = GCONF(); return r.diag0_int_pushpull; } +bool TMC2130Stepper::diag1_pushpull() { GCONF_t r{0}; r.sr = GCONF(); return r.diag1_poscomp_pushpull;} +bool TMC2130Stepper::small_hysteresis() { GCONF_t r{0}; r.sr = GCONF(); return r.small_hysteresis; } +bool TMC2130Stepper::stop_enable() { GCONF_t r{0}; r.sr = GCONF(); return r.stop_enable; } +bool TMC2130Stepper::direct_mode() { GCONF_t r{0}; r.sr = GCONF(); return r.direct_mode; } +*/ +/* +bit 18 not implemented: +test_mode 0: +Normal operation 1: +Enable analog test output on pin DCO. IHOLD[1..0] selects the function of DCO: +0…2: T120, DAC, VDDH Attention: +Not for user, set to 0 for normal operation! +*/ +/* +void TMC5160Stepper::recalibrate(bool B) { SET_REG(recalibrate); } +void TMC5160Stepper::faststandstill(bool B) { SET_REG(faststandstill); } +void TMC5160Stepper::multistep_filt(bool B) { SET_REG(multistep_filt); } +bool TMC5160Stepper::recalibrate() { GCONF_t r{0}; r.sr = GCONF(); return r.recalibrate; } +bool TMC5160Stepper::faststandstill() { GCONF_t r{0}; r.sr = GCONF(); return r.faststandstill; } +bool TMC5160Stepper::multistep_filt() { GCONF_t r{0}; r.sr = GCONF(); return r.multistep_filt; } +*/ +uint32_t TMC2208Stepper::GCONF() { + return read(GCONF_register.address); +} +void TMC2208Stepper::GCONF(uint32_t input) { + GCONF_register.sr = input; + write(GCONF_register.address, GCONF_register.sr); +} + +void TMC2208Stepper::I_scale_analog(bool B) { SET_REG(i_scale_analog); } +void TMC2208Stepper::internal_Rsense(bool B) { SET_REG(internal_rsense); } +void TMC2208Stepper::en_spreadCycle(bool B) { SET_REG(en_spreadcycle); } +void TMC2208Stepper::shaft(bool B) { SET_REG(shaft); } +void TMC2208Stepper::index_otpw(bool B) { SET_REG(index_otpw); } +void TMC2208Stepper::index_step(bool B) { SET_REG(index_step); } +void TMC2208Stepper::pdn_disable(bool B) { SET_REG(pdn_disable); } +void TMC2208Stepper::mstep_reg_select(bool B) { SET_REG(mstep_reg_select);} +void TMC2208Stepper::multistep_filt(bool B) { SET_REG(multistep_filt); } + +bool TMC2208Stepper::I_scale_analog() { TMC2208_n::GCONF_t r{0}; r.sr = GCONF(); return r.i_scale_analog; } +bool TMC2208Stepper::internal_Rsense() { TMC2208_n::GCONF_t r{0}; r.sr = GCONF(); return r.internal_rsense; } +bool TMC2208Stepper::en_spreadCycle() { TMC2208_n::GCONF_t r{0}; r.sr = GCONF(); return r.en_spreadcycle; } +bool TMC2208Stepper::shaft() { TMC2208_n::GCONF_t r{0}; r.sr = GCONF(); return r.shaft; } +bool TMC2208Stepper::index_otpw() { TMC2208_n::GCONF_t r{0}; r.sr = GCONF(); return r.index_otpw; } +bool TMC2208Stepper::index_step() { TMC2208_n::GCONF_t r{0}; r.sr = GCONF(); return r.index_step; } +bool TMC2208Stepper::pdn_disable() { TMC2208_n::GCONF_t r{0}; r.sr = GCONF(); return r.pdn_disable; } +bool TMC2208Stepper::mstep_reg_select() { TMC2208_n::GCONF_t r{0}; r.sr = GCONF(); return r.mstep_reg_select; } +bool TMC2208Stepper::multistep_filt() { TMC2208_n::GCONF_t r{0}; r.sr = GCONF(); return r.multistep_filt; } \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/IHOLD_IRUN.cpp Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,20 @@ +#include "TMCStepper.h" +#include "TMC_MACROS.h" + +#define SET_REG(SETTING) IHOLD_IRUN_register.SETTING = B; write(IHOLD_IRUN_register.address, IHOLD_IRUN_register.sr); +#define GET_REG(SETTING) return IHOLD_IRUN_register.SETTING; + +// IHOLD_IRUN +uint32_t TMCStepper::IHOLD_IRUN() { return IHOLD_IRUN_register.sr; } +void TMCStepper::IHOLD_IRUN(uint32_t input) { + IHOLD_IRUN_register.sr = input; + write(IHOLD_IRUN_register.address, IHOLD_IRUN_register.sr); +} + +void TMCStepper::ihold(uint8_t B) { SET_REG(ihold); } +void TMCStepper::irun(uint8_t B) { SET_REG(irun); } +void TMCStepper::iholddelay(uint8_t B) { SET_REG(iholddelay); } + +uint8_t TMCStepper::ihold() { GET_REG(ihold); } +uint8_t TMCStepper::irun() { GET_REG(irun); } +uint8_t TMCStepper::iholddelay() { GET_REG(iholddelay); } \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/PWMCONF.cpp Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,80 @@ +#include "TMCStepper.h" +#include "TMC_MACROS.h" + +#define SET_REG(SETTING) PWMCONF_register.SETTING = B; write(PWMCONF_register.address, PWMCONF_register.sr) +#define GET_REG(SETTING) return PWMCONF_register.SETTING + +// PWMCONF +/* +uint32_t TMC2130Stepper::PWMCONF() { return PWMCONF_register.sr; } +void TMC2130Stepper::PWMCONF(uint32_t input) { + PWMCONF_register.sr = input; + write(PWMCONF_register.address, PWMCONF_register.sr); +} + +void TMC2130Stepper::pwm_ampl( uint8_t B ) { SET_REG(pwm_ampl); } +void TMC2130Stepper::pwm_grad( uint8_t B ) { SET_REG(pwm_grad); } +void TMC2130Stepper::pwm_freq( uint8_t B ) { SET_REG(pwm_freq); } +void TMC2130Stepper::pwm_autoscale( bool B ) { SET_REG(pwm_autoscale); } +void TMC2130Stepper::pwm_symmetric( bool B ) { SET_REG(pwm_symmetric); } +void TMC2130Stepper::freewheel( uint8_t B ) { SET_REG(freewheel); } + +uint8_t TMC2130Stepper::pwm_ampl() { GET_REG(pwm_ampl); } +uint8_t TMC2130Stepper::pwm_grad() { GET_REG(pwm_grad); } +uint8_t TMC2130Stepper::pwm_freq() { GET_REG(pwm_freq); } +bool TMC2130Stepper::pwm_autoscale() { GET_REG(pwm_autoscale); } +bool TMC2130Stepper::pwm_symmetric() { GET_REG(pwm_symmetric); } +uint8_t TMC2130Stepper::freewheel() { GET_REG(freewheel); } + +uint32_t TMC2160Stepper::PWMCONF() { + return PWMCONF_register.sr; +} +void TMC2160Stepper::PWMCONF(uint32_t input) { + PWMCONF_register.sr = input; + write(PWMCONF_register.address, PWMCONF_register.sr); +} + +void TMC2160Stepper::pwm_ofs ( uint8_t B ) { PWMCONF_register.pwm_ofs = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2160Stepper::pwm_grad ( uint8_t B ) { PWMCONF_register.pwm_grad = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2160Stepper::pwm_freq ( uint8_t B ) { PWMCONF_register.pwm_freq = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2160Stepper::pwm_autoscale ( bool B ) { PWMCONF_register.pwm_autoscale = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2160Stepper::pwm_autograd ( bool B ) { PWMCONF_register.pwm_autograd = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2160Stepper::freewheel ( uint8_t B ) { PWMCONF_register.freewheel = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2160Stepper::pwm_reg ( uint8_t B ) { PWMCONF_register.pwm_reg = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2160Stepper::pwm_lim ( uint8_t B ) { PWMCONF_register.pwm_lim = B; write(PWMCONF_register.address, PWMCONF_register.sr); } + +uint8_t TMC2160Stepper::pwm_ofs() { return PWMCONF_register.pwm_ofs; } +uint8_t TMC2160Stepper::pwm_grad() { return PWMCONF_register.pwm_grad; } +uint8_t TMC2160Stepper::pwm_freq() { return PWMCONF_register.pwm_freq; } +bool TMC2160Stepper::pwm_autoscale() { return PWMCONF_register.pwm_autoscale;} +bool TMC2160Stepper::pwm_autograd() { return PWMCONF_register.pwm_autograd; } +uint8_t TMC2160Stepper::freewheel() { return PWMCONF_register.freewheel; } +uint8_t TMC2160Stepper::pwm_reg() { return PWMCONF_register.pwm_reg; } +uint8_t TMC2160Stepper::pwm_lim() { return PWMCONF_register.pwm_lim; } +*/ +uint32_t TMC2208Stepper::PWMCONF() { + return read(PWMCONF_register.address); +} +void TMC2208Stepper::PWMCONF(uint32_t input) { + PWMCONF_register.sr = input; + write(PWMCONF_register.address, PWMCONF_register.sr); +} + +void TMC2208Stepper::pwm_ofs ( uint8_t B ) { PWMCONF_register.pwm_ofs = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2208Stepper::pwm_grad ( uint8_t B ) { PWMCONF_register.pwm_grad = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2208Stepper::pwm_freq ( uint8_t B ) { PWMCONF_register.pwm_freq = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2208Stepper::pwm_autoscale ( bool B ) { PWMCONF_register.pwm_autoscale = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2208Stepper::pwm_autograd ( bool B ) { PWMCONF_register.pwm_autograd = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2208Stepper::freewheel ( uint8_t B ) { PWMCONF_register.freewheel = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2208Stepper::pwm_reg ( uint8_t B ) { PWMCONF_register.pwm_reg = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2208Stepper::pwm_lim ( uint8_t B ) { PWMCONF_register.pwm_lim = B; write(PWMCONF_register.address, PWMCONF_register.sr); } + +uint8_t TMC2208Stepper::pwm_ofs() { TMC2208_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_ofs; } +uint8_t TMC2208Stepper::pwm_grad() { TMC2208_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_grad; } +uint8_t TMC2208Stepper::pwm_freq() { TMC2208_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_freq; } +bool TMC2208Stepper::pwm_autoscale() { TMC2208_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_autoscale; } +bool TMC2208Stepper::pwm_autograd() { TMC2208_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_autograd; } +uint8_t TMC2208Stepper::freewheel() { TMC2208_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.freewheel; } +uint8_t TMC2208Stepper::pwm_reg() { TMC2208_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_reg; } +uint8_t TMC2208Stepper::pwm_lim() { TMC2208_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_lim; } +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TMC2208Stepper.cpp Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,459 @@ +#include "TMCStepper.h" +#include "TMC_MACROS.h" +//#include "SERIAL_SWITCH.h" + +// Protected +// addr needed for TMC2209 +TMC2208Stepper::TMC2208Stepper(Stream * SerialPort, float RS, uint8_t addr) : + TMCStepper(RS), + slave_address(addr) + { + HWSerial = SerialPort; + defaults(); + } + +TMC2208Stepper::TMC2208Stepper(Stream * SerialPort, float RS, uint8_t addr, uint16_t mul_pin1, uint16_t mul_pin2) : + TMC2208Stepper(SerialPort, RS) + { +// SSwitch *SMulObj = new SSwitch(mul_pin1, mul_pin2, addr); +// sswitch = SMulObj; + } + +#if SW_CAPABLE_PLATFORM + // Protected + // addr needed for TMC2209 + TMC2208Stepper::TMC2208Stepper(PinName SW_RX_pin, PinName SW_TX_pin, float RS, uint8_t addr) : + TMCStepper(RS), + RXTX_pin(SW_RX_pin == SW_TX_pin ? SW_RX_pin : 0), + slave_address(addr) + { + BufferedSerial *SWSerialObj = new BufferedSerial(SW_TX_pin, SW_RX_pin); + SWSerial = SWSerialObj; + defaults(); + } + + void TMC2208Stepper::beginSerial(uint32_t baudrate) { + if (SWSerial != nullptr) + { + //SWSerial->begin(baudrate); + //SWSerial->end(); + SWSerial->set_baud(baudrate); + SWSerial->set_format( + /* bits */ 8, + /* parity */ BufferedSerial::None, + /* stop bit */ 1 + ); + SWSerial->set_blocking(true); + } +// #if defined(ARDUINO_ARCH_AVR) +// if (RXTX_pin > 0) { +// digitalWrite(RXTX_pin, HIGH); +// pinMode(RXTX_pin, OUTPUT); +// } +// #endif + } +#endif + +void TMC2208Stepper::begin() { + #if SW_CAPABLE_PLATFORM + beginSerial(115200); + //beginSerial(9600); + #endif + pdn_disable(true); + mstep_reg_select(true); + //Wait to initialize + wait_us(replyDelay*1000); + +} + +void TMC2208Stepper::defaults() { + GCONF_register.i_scale_analog = 1; + GCONF_register.internal_rsense = 0; // OTP + GCONF_register.en_spreadcycle = 0; // OTP + GCONF_register.multistep_filt = 1; // OTP + IHOLD_IRUN_register.iholddelay = 1; // OTP + TPOWERDOWN_register.sr = 20; + CHOPCONF_register.sr = 0x10000053; + PWMCONF_register.sr = 0xC10D0024; + //MSLUT0_register.sr = ???; + //MSLUT1_register.sr = ???; + //MSLUT2_register.sr = ???; + //MSLUT3_register.sr = ???; + //MSLUT4_register.sr = ???; + //MSLUT5_register.sr = ???; + //MSLUT6_register.sr = ???; + //MSLUT7_register.sr = ???; + //MSLUTSTART_register.start_sin90 = 247; +} + +void TMC2208Stepper::push() { + GCONF(GCONF_register.sr); + IHOLD_IRUN(IHOLD_IRUN_register.sr); + SLAVECONF(SLAVECONF_register.sr); + TPOWERDOWN(TPOWERDOWN_register.sr); + TPWMTHRS(TPWMTHRS_register.sr); + VACTUAL(VACTUAL_register.sr); + CHOPCONF(CHOPCONF_register.sr); + PWMCONF(PWMCONF_register.sr); +} + +bool TMC2208Stepper::isEnabled() { return !enn() && toff(); } + +uint8_t TMC2208Stepper::calcCRC(uint8_t datagram[], uint8_t len) { + uint8_t crc = 0; + for (uint8_t i = 0; i < len; i++) { + uint8_t currentByte = datagram[i]; + for (uint8_t j = 0; j < 8; j++) { + if ((crc >> 7) ^ (currentByte & 0x01)) { + crc = (crc << 1) ^ 0x07; + } else { + crc = (crc << 1); + } + crc &= 0xff; + currentByte = currentByte >> 1; + } + } + return crc; +} + +__attribute__((weak)) +int TMC2208Stepper::available() { + int out = 0; + #if SW_CAPABLE_PLATFORM + if (SWSerial != nullptr) { +// out = SWSerial->available(); +out = 1; + } else + #endif + if (HWSerial != nullptr) { +// out = HWSerial->available(); +out = 1; + } + + return out; +} + +__attribute__((weak)) +void TMC2208Stepper::preWriteCommunication() { + if (HWSerial != nullptr) { +// if (sswitch != nullptr) +// sswitch->active(); + } +} + +__attribute__((weak)) +void TMC2208Stepper::preReadCommunication() { + #if SW_CAPABLE_PLATFORM + if (SWSerial != nullptr) { +// SWSerial->listen(); + } else + #endif + if (HWSerial != nullptr) { +// if (sswitch != nullptr) +// sswitch->active(); + } +} + +__attribute__((weak)) +int16_t TMC2208Stepper::serial_read() { + int16_t out = 0; + int16_t count = 0; + + #if SW_CAPABLE_PLATFORM + if (SWSerial != nullptr) { +// out = SWSerial->read(); + count = SWSerial->read(&out, 1); // read one character +// if (SWSerial->readable()) { +// SWSerial->read(&out, 1); // read one character +// } + + } else + #endif + if (HWSerial != nullptr) { +// out = HWSerial->read(); + HWSerial->read(&out, 1); // read one character + } + if (count >= 1) { +// printf("<%02X|",out); + return out; + } else { + return -1; + } +} + +__attribute__((weak)) +uint8_t TMC2208Stepper::serial_write(const uint8_t data) { + int out = 0; + #if SW_CAPABLE_PLATFORM + if (SWSerial != nullptr) { +// printf(">%02X|",data); + return SWSerial->write(&data,1); + } else + #endif + if (HWSerial != nullptr) { + return HWSerial->write(&data,1); + } + + return out; +} + +__attribute__((weak)) +void TMC2208Stepper::postWriteCommunication() {} + +__attribute__((weak)) +void TMC2208Stepper::postReadCommunication() { + #if SW_CAPABLE_PLATFORM +// if (SWSerial != nullptr) { +// SWSerial->end(); +// } + #endif +} + +void TMC2208Stepper::write(uint8_t addr, uint32_t regVal) { + uint8_t len = 7; + addr |= TMC_WRITE; + uint8_t datagram[] = {TMC2208_SYNC, slave_address, addr, (uint8_t)(regVal>>24), (uint8_t)(regVal>>16), (uint8_t)(regVal>>8), (uint8_t)(regVal>>0), 0x00}; + + datagram[len] = calcCRC(datagram, len); + + preWriteCommunication(); + + for(uint8_t i=0; i<=len; i++) { + bytesWritten += serial_write(datagram[i]); + } + postWriteCommunication(); + + //delay(replyDelay); + wait_us(replyDelay*1000); +} + +uint64_t TMC2208Stepper::_sendDatagram(uint8_t datagram[], const uint8_t len, uint16_t timeout) { + +// while (available() > 0) serial_read(); // Flush + SWSerial->sync(); +/* uint8_t dummy; + while (SWSerial->readable()) { + SWSerial->read(&dummy, 1); // read one character + } +*/ +/* uint8_t dummy; + while (SWSerial->read(&dummy, 1) >= 0) { + ; + } +*/ + + #if defined(ARDUINO_ARCH_AVR) + if (RXTX_pin > 0) { + digitalWrite(RXTX_pin, HIGH); + pinMode(RXTX_pin, OUTPUT); + } + #endif + + for(int i=0; i<=len; i++) serial_write(datagram[i]); + + #if defined(ARDUINO_ARCH_AVR) + if (RXTX_pin > 0) { + pinMode(RXTX_pin, INPUT_PULLUP); + } + #endif + + //delay(this->replyDelay); + wait_us(this->replyDelay*1000); + + // scan for the rx frame and read it + +// uint32_t ms = millis(); + uint32_t sync_target = (static_cast<uint32_t>(datagram[0])<<16) | 0xFF00 | datagram[2]; + uint32_t sync = 0; + + + do { +/* uint32_t ms2 = millis(); + if (ms2 != ms) { + // 1ms tick + ms = ms2; + timeout--; + } + if (!timeout) return 0; +*/ + int16_t res = serial_read(); + if (res < 0) continue; + + sync <<= 8; + sync |= res & 0xFF; + sync &= 0xFFFFFF; + + } while (sync != sync_target); + + uint64_t out = sync; + // ms = millis(); + // timeout = this->abort_window; + + for(uint8_t i=0; i<5;) { +/* uint32_t ms2 = millis(); + if (ms2 != ms) { + // 1ms tick + ms = ms2; + timeout--; + } + if (!timeout) return 0; +*/ + int16_t res = serial_read(); + if (res < 0) continue; + + out <<= 8; + out |= res & 0xFF; + + i++; + } + + #if defined(ARDUINO_ARCH_AVR) + if (RXTX_pin > 0) { + digitalWrite(RXTX_pin, HIGH); + pinMode(RXTX_pin, OUTPUT); + } + #endif + +// while (available() > 0) serial_read(); // Flush + SWSerial->sync(); + + return out; + + +} + +uint32_t TMC2208Stepper::read(uint8_t addr) { + constexpr uint8_t len = 3; + addr |= TMC_READ; + uint8_t datagram[] = {TMC2208_SYNC, slave_address, addr, 0x00}; + datagram[len] = calcCRC(datagram, len); + uint64_t out = 0x00000000UL; + + for (uint8_t i = 0; i < max_retries; i++) { + preReadCommunication(); + out = _sendDatagram(datagram, len, abort_window); + postReadCommunication(); + +// delay(replyDelay); +// wait_us(replyDelay*1000); + + CRCerror = false; + uint8_t out_datagram[] = { + static_cast<uint8_t>(out>>56), + static_cast<uint8_t>(out>>48), + static_cast<uint8_t>(out>>40), + static_cast<uint8_t>(out>>32), + static_cast<uint8_t>(out>>24), + static_cast<uint8_t>(out>>16), + static_cast<uint8_t>(out>> 8), + static_cast<uint8_t>(out>> 0) + }; + uint8_t crc = calcCRC(out_datagram, 7); + if ((crc != static_cast<uint8_t>(out)) || crc == 0 ) { + CRCerror = true; + out = 0; + } else { + break; + } + } + + return out>>8; +} + +uint8_t TMC2208Stepper::IFCNT() { + return read(IFCNT_t::address); +} + +void TMC2208Stepper::SLAVECONF(uint16_t input) { + SLAVECONF_register.sr = input&0xF00; + write(SLAVECONF_register.address, SLAVECONF_register.sr); +} +uint16_t TMC2208Stepper::SLAVECONF() { + return SLAVECONF_register.sr; +} +void TMC2208Stepper::senddelay(uint8_t B) { SLAVECONF_register.senddelay = B; write(SLAVECONF_register.address, SLAVECONF_register.sr); } +uint8_t TMC2208Stepper::senddelay() { return SLAVECONF_register.senddelay; } + +void TMC2208Stepper::OTP_PROG(uint16_t input) { + write(OTP_PROG_t::address, input); +} + +uint32_t TMC2208Stepper::OTP_READ() { + return read(OTP_READ_t::address); +} + +uint32_t TMC2208Stepper::IOIN() { + return read(TMC2208_n::IOIN_t::address); +} +bool TMC2208Stepper::enn() { TMC2208_n::IOIN_t r{0}; r.sr = IOIN(); return r.enn; } +bool TMC2208Stepper::ms1() { TMC2208_n::IOIN_t r{0}; r.sr = IOIN(); return r.ms1; } +bool TMC2208Stepper::ms2() { TMC2208_n::IOIN_t r{0}; r.sr = IOIN(); return r.ms2; } +bool TMC2208Stepper::diag() { TMC2208_n::IOIN_t r{0}; r.sr = IOIN(); return r.diag; } +bool TMC2208Stepper::pdn_uart() { TMC2208_n::IOIN_t r{0}; r.sr = IOIN(); return r.pdn_uart; } +bool TMC2208Stepper::step() { TMC2208_n::IOIN_t r{0}; r.sr = IOIN(); return r.step; } +bool TMC2208Stepper::sel_a() { TMC2208_n::IOIN_t r{0}; r.sr = IOIN(); return r.sel_a; } +bool TMC2208Stepper::dir() { TMC2208_n::IOIN_t r{0}; r.sr = IOIN(); return r.dir; } +uint8_t TMC2208Stepper::version() { TMC2208_n::IOIN_t r{0}; r.sr = IOIN(); return r.version; } + +/* +uint32_t TMC2224Stepper::IOIN() { + return read(TMC2224_n::IOIN_t::address); +} +bool TMC2224Stepper::enn() { TMC2224_n::IOIN_t r{0}; r.sr = IOIN(); return r.enn; } +bool TMC2224Stepper::ms1() { TMC2224_n::IOIN_t r{0}; r.sr = IOIN(); return r.ms1; } +bool TMC2224Stepper::ms2() { TMC2224_n::IOIN_t r{0}; r.sr = IOIN(); return r.ms2; } +bool TMC2224Stepper::pdn_uart() { TMC2224_n::IOIN_t r{0}; r.sr = IOIN(); return r.pdn_uart; } +bool TMC2224Stepper::spread() { TMC2224_n::IOIN_t r{0}; r.sr = IOIN(); return r.spread; } +bool TMC2224Stepper::step() { TMC2224_n::IOIN_t r{0}; r.sr = IOIN(); return r.step; } +bool TMC2224Stepper::sel_a() { TMC2224_n::IOIN_t r{0}; r.sr = IOIN(); return r.sel_a; } +bool TMC2224Stepper::dir() { TMC2224_n::IOIN_t r{0}; r.sr = IOIN(); return r.dir; } +uint8_t TMC2224Stepper::version() { TMC2224_n::IOIN_t r{0}; r.sr = IOIN(); return r.version; } +*/ +uint16_t TMC2208Stepper::FACTORY_CONF() { + return read(FACTORY_CONF_register.address); +} +void TMC2208Stepper::FACTORY_CONF(uint16_t input) { + FACTORY_CONF_register.sr = input; + write(FACTORY_CONF_register.address, FACTORY_CONF_register.sr); +} +void TMC2208Stepper::fclktrim(uint8_t B){ FACTORY_CONF_register.fclktrim = B; write(FACTORY_CONF_register.address, FACTORY_CONF_register.sr); } +void TMC2208Stepper::ottrim(uint8_t B) { FACTORY_CONF_register.ottrim = B; write(FACTORY_CONF_register.address, FACTORY_CONF_register.sr); } +uint8_t TMC2208Stepper::fclktrim() { FACTORY_CONF_t r{0}; r.sr = FACTORY_CONF(); return r.fclktrim; } +uint8_t TMC2208Stepper::ottrim() { FACTORY_CONF_t r{0}; r.sr = FACTORY_CONF(); return r.ottrim; } + +void TMC2208Stepper::VACTUAL(uint32_t input) { + VACTUAL_register.sr = input; + write(VACTUAL_register.address, VACTUAL_register.sr); +} +uint32_t TMC2208Stepper::VACTUAL() { + return VACTUAL_register.sr; +} + +uint32_t TMC2208Stepper::PWM_SCALE() { + return read(TMC2208_n::PWM_SCALE_t::address); +} +uint8_t TMC2208Stepper::pwm_scale_sum() { + TMC2208_n::PWM_SCALE_t r{0}; + r.sr = PWM_SCALE(); + return r.pwm_scale_sum; +} + +int16_t TMC2208Stepper::pwm_scale_auto() { + TMC2208_n::PWM_SCALE_t r{0}; + r.sr = PWM_SCALE(); + return r.pwm_scale_auto; + // Not two's complement? 9nth bit determines sign + /* + uint32_t d = PWM_SCALE(); + int16_t response = (d>>PWM_SCALE_AUTO_bp)&0xFF; + if (((d&PWM_SCALE_AUTO_bm) >> 24) & 0x1) return -response; + else return response; + */ +} + +// R: PWM_AUTO +uint32_t TMC2208Stepper::PWM_AUTO() { + return read(PWM_AUTO_t::address); +} +uint8_t TMC2208Stepper::pwm_ofs_auto() { PWM_AUTO_t r{0}; r.sr = PWM_AUTO(); return r.pwm_ofs_auto; } +uint8_t TMC2208Stepper::pwm_grad_auto() { PWM_AUTO_t r{0}; r.sr = PWM_AUTO(); return r.pwm_grad_auto; } \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TMC2208_bitfields.h Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,181 @@ +#pragma once +#pragma pack(push, 1) + +namespace TMC2208_n { + struct GCONF_t { + constexpr static uint8_t address = 0x00; + union { + uint16_t sr : 10; + struct { + bool i_scale_analog : 1, + internal_rsense : 1, + en_spreadcycle : 1, + shaft : 1, + index_otpw : 1, + index_step : 1, + pdn_disable : 1, + mstep_reg_select : 1, + multistep_filt : 1, + test_mode : 1; + }; + }; + }; +} + +namespace TMC2208_n { + struct IOIN_t { + constexpr static uint8_t address = 0x06; + union { + uint32_t sr; + struct { + bool enn : 1, + : 1, + ms1 : 1, + ms2 : 1, + diag : 1, + : 1, + pdn_uart : 1, + step : 1, + sel_a : 1, + dir : 1; + uint16_t : 14; + uint8_t version : 8; + }; + }; + }; +} + +namespace TMC2224_n { + struct IOIN_t { + constexpr static uint8_t address = 0x06; + union { + uint32_t sr; + struct { + bool : 1, + pdn_uart : 1, + spread : 1, + dir : 1, + enn : 1, + step : 1, + ms1 : 1, + ms2 : 1, + sel_a : 1; + uint16_t : 15; + uint8_t version : 8; + }; + }; + }; +} + +struct FACTORY_CONF_t { + constexpr static uint8_t address = 0x07; + union { + uint16_t sr; + struct { + uint8_t fclktrim : 5, + : 3, + ottrim : 2; + }; + }; +}; + +namespace TMC2208_n { + struct VACTUAL_t { + constexpr static uint8_t address = 0x22; + uint32_t sr; + }; +} + +struct MSCURACT_t { + constexpr static uint8_t address = 0x6B; + union { + uint32_t sr : 25; + struct { + int16_t cur_a : 9, + : 7, + cur_b : 9; + }; + }; +}; + +namespace TMC2208_n { + struct CHOPCONF_t { + constexpr static uint8_t address = 0x6C; + union { + uint32_t sr; + struct { + uint8_t toff : 4, + hstrt : 3, + hend : 4, + : 4, + tbl : 2; + bool vsense : 1; + uint8_t : 6, + mres : 4; + bool intpol : 1, + dedge : 1, + diss2g : 1, + diss2vs : 1; + }; + }; + }; + + struct PWMCONF_t { + constexpr static uint8_t address = 0x70; + union { + uint32_t sr; + struct { + uint8_t pwm_ofs : 8, + pwm_grad : 8, + pwm_freq : 2; + bool pwm_autoscale : 1, + pwm_autograd : 1; + uint8_t freewheel : 2, + : 2, + pwm_reg : 4, + pwm_lim : 4; + }; + }; + }; + + struct DRV_STATUS_t { + constexpr static uint8_t address = 0x6F; + union { + uint32_t sr; + struct { + bool otpw : 1, + ot : 1, + s2ga : 1, + s2gb : 1, + s2vsa : 1, + s2vsb : 1, + ola : 1, + olb : 1, + t120 : 1, + t143 : 1, + t150 : 1, + t157 : 1; + uint8_t : 4, + cs_actual : 5, + : 3, + : 6; + bool stealth : 1, + stst : 1; + }; + }; + }; + + struct PWM_SCALE_t { + constexpr static uint8_t address = 0x71; + union { + uint32_t sr; + struct { + uint8_t pwm_scale_sum : 8, + : 8; + int16_t pwm_scale_auto : 9; + }; + }; + }; +} + +#pragma pack(pop) \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TMC2209Stepper.cpp Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,45 @@ +#include "TMCStepper.h" + +uint32_t TMC2209Stepper::IOIN() { + return read(TMC2209_n::IOIN_t::address); +} +bool TMC2209Stepper::enn() { TMC2209_n::IOIN_t r{0}; r.sr = IOIN(); return r.enn; } +bool TMC2209Stepper::ms1() { TMC2209_n::IOIN_t r{0}; r.sr = IOIN(); return r.ms1; } +bool TMC2209Stepper::ms2() { TMC2209_n::IOIN_t r{0}; r.sr = IOIN(); return r.ms2; } +bool TMC2209Stepper::diag() { TMC2209_n::IOIN_t r{0}; r.sr = IOIN(); return r.diag; } +bool TMC2209Stepper::pdn_uart() { TMC2209_n::IOIN_t r{0}; r.sr = IOIN(); return r.pdn_uart; } +bool TMC2209Stepper::step() { TMC2209_n::IOIN_t r{0}; r.sr = IOIN(); return r.step; } +bool TMC2209Stepper::spread_en() { TMC2209_n::IOIN_t r{0}; r.sr = IOIN(); return r.spread_en;} +bool TMC2209Stepper::dir() { TMC2209_n::IOIN_t r{0}; r.sr = IOIN(); return r.dir; } +uint8_t TMC2209Stepper::version() { TMC2209_n::IOIN_t r{0}; r.sr = IOIN(); return r.version; } + +void TMC2209Stepper::push() { + IHOLD_IRUN(IHOLD_IRUN_register.sr); + TPOWERDOWN(TPOWERDOWN_register.sr); + TPWMTHRS(TPWMTHRS_register.sr); + GCONF(GCONF_register.sr); + SLAVECONF(SLAVECONF_register.sr); + VACTUAL(VACTUAL_register.sr); + CHOPCONF(CHOPCONF_register.sr); + PWMCONF(PWMCONF_register.sr); + TCOOLTHRS(TCOOLTHRS_register.sr); +} + +void TMC2209Stepper::SGTHRS(uint8_t input) { + SGTHRS_register.sr = input; + write(SGTHRS_register.address, SGTHRS_register.sr); +} +uint8_t TMC2209Stepper::SGTHRS() { + return SGTHRS_register.sr; +} + +// W: TCOOLTHRS +uint32_t TMC2209Stepper::TCOOLTHRS() { return TCOOLTHRS_register.sr; } +void TMC2209Stepper::TCOOLTHRS(uint32_t input) { + TCOOLTHRS_register.sr = input; + write(TCOOLTHRS_register.address, TCOOLTHRS_register.sr); +} + +uint16_t TMC2209Stepper::SG_RESULT() { + return read(TMC2209_n::SG_RESULT_t::address); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TMC2209_bitfields.h Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,247 @@ +#pragma once +#pragma pack(push, 1) + +namespace TMC2209_n { + struct IOIN_t { + constexpr static uint8_t address = 0x06; + union { + uint32_t sr; + struct { + bool enn : 1, + : 1, + ms1 : 1, + ms2 : 1, + diag : 1, + : 1, + pdn_uart : 1, + step : 1, + spread_en : 1, + dir : 1; + uint16_t : 14; + uint8_t version : 8; + }; + }; + }; + + struct SGTHRS_t { + constexpr static uint8_t address = 0x40; + uint8_t sr : 8; + }; + + struct SG_RESULT_t { + constexpr static uint8_t address = 0x41; + uint16_t sr : 10; + }; + + struct COOLCONF_t { + constexpr static uint8_t address = 0x42; + union { + uint16_t sr; + struct { + uint8_t semin : 4, + : 1, + seup : 2, + : 1, + semax : 4, + : 1, + sedn : 2; + bool seimin : 1; + }; + }; + }; + +} //namespace +////////////////////////////////////////////////////// +struct SLAVECONF_t { + constexpr static uint8_t address = 0x03; + union { + uint16_t sr : 12; + struct { + uint8_t slaveaddr : 8; + uint8_t senddelay : 4; + }; + }; +}; + +struct PWM_AUTO_t { + constexpr static uint8_t address = 0x72; + union { + uint32_t sr : 24; + struct { + uint8_t pwm_ofs_auto : 8, + : 8, + pwm_grad_auto : 8; + }; + }; +}; + +struct GCONF_t { + constexpr static uint8_t address = 0x00; + union { + uint32_t sr : 18; + struct { + bool i_scale_analog : 1, // 2130, 5130 + internal_rsense : 1, // 2130, 5130 + en_pwm_mode : 1, + enc_commutation : 1, // 2130, 5130 + shaft : 1, + diag0_error : 1, + diag0_otpw : 1, + diag0_stall : 1, + diag1_stall : 1, + diag1_index : 1, + diag1_onstate : 1, + diag1_steps_skipped : 1, + diag0_int_pushpull : 1, + diag1_pushpull : 1, + small_hysteresis : 1, + stop_enable : 1, + direct_mode : 1; + }; + struct { // TMC5160 + bool recalibrate : 1, + faststandstill : 1, + : 1, + multistep_filt : 1, + : 3, + diag0_step : 1, + diag1_dir : 1, + : 4, + diag1_poscomp_pushpull : 1; + }; + }; +}; + +struct IHOLD_IRUN_t { + constexpr static uint8_t address = 0x10; + union { + uint32_t sr : 20; + struct { + uint8_t ihold : 5, + : 3, + irun : 5, + : 3, + iholddelay : 4; + }; + }; +}; + +struct GSTAT_t { + constexpr static uint8_t address = 0x01; + union { + uint8_t sr : 3; + struct { + bool reset : 1, + drv_err : 1, + uv_cp : 1; + }; + }; +}; + +struct TPOWERDOWN_t { + constexpr static uint8_t address = 0x11; + uint8_t sr : 8; +}; + +struct TPWMTHRS_t { + constexpr static uint8_t address = 0x13; + uint32_t sr : 20; +}; + +struct TCOOLTHRS_t { + constexpr static uint8_t address = 0x14; + uint32_t sr : 20; +}; + +struct THIGH_t { + constexpr static uint8_t address = 0x15; + uint32_t sr : 20; +}; + +struct XDIRECT_t { + constexpr static uint8_t address = 0x2D; + union { + uint32_t sr : 25; + struct { + int16_t coil_A : 9; + int8_t : 7; + int16_t coil_B : 9; + }; + }; +}; + +struct VDCMIN_t { + constexpr static uint8_t address = 0x33; + uint32_t sr : 23; +}; + +struct CHOPCONF_t { + constexpr static uint8_t address = 0x6C; + union { + uint32_t sr : 32; + struct { + uint8_t toff : 4, + hstrt : 3, + hend : 4, + : 1; + bool disfdcc : 1, + rndtf : 1, + chm : 1; + uint8_t tbl : 2; + bool vsense : 1, + vhighfs : 1, + vhighchm : 1; + uint8_t sync : 4, // 2130, 5130 + mres : 4; + bool intpol : 1, + dedge : 1, + diss2g : 1; + }; + struct { // TMC5160 + uint32_t : 20; + uint8_t tpfd : 4; // 5160 + uint16_t : 7; + bool diss2vs : 1; // TMC5160 only + }; + }; +}; + +struct DCCTRL_t { + constexpr static uint8_t address = 0x6E; + union { + uint32_t sr : 24; + struct { + uint16_t dc_time : 10, + : 6; + uint8_t dc_sg : 8; + }; + }; +}; + +struct PWMCONF_t { + constexpr static uint8_t address = 0x70; + union { + uint32_t sr : 22; + struct { + uint8_t pwm_ampl : 8, + pwm_grad : 8, + pwm_freq : 2; + bool pwm_autoscale : 1, + pwm_symmetric : 1; + uint8_t freewheel : 2; + }; + }; +}; + +struct ENCM_CTRL_t { + constexpr static uint8_t address = 0x72; + union { + uint8_t sr : 2; + struct { + bool inv : 1, + maxspeed : 1; + }; + }; +}; + +#pragma pack(pop) \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TMCStepper.cpp Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,157 @@ +#include "TMCStepper.h" + + +/* + Requested current = mA = I_rms/1000 + Equation for current: + I_rms = (CS+1)/32 * V_fs/(R_sense+0.02ohm) * 1/sqrt(2) + Solve for CS -> + CS = 32*sqrt(2)*I_rms*(R_sense+0.02)/V_fs - 1 + + Example: + vsense = 0b0 -> V_fs = 0.325V + mA = 1640mA = I_rms/1000 = 1.64A + R_sense = 0.10 Ohm + -> + CS = 32*sqrt(2)*1.64*(0.10+0.02)/0.325 - 1 = 26.4 + CS = 26 +*/ + +uint16_t TMCStepper::cs2rms(uint8_t CS) { + return (float)(CS+1)/32.0 * (vsense() ? 0.180 : 0.325)/(Rsense+0.02) / 1.41421 * 1000; +} + +void TMCStepper::rms_current(uint16_t mA) { + uint8_t CS = 32.0*1.41421*mA/1000.0*(Rsense+0.02)/0.325 - 1; + // If Current Scale is too low, turn on high sensitivity R_sense and calculate again + if (CS < 16) { + vsense(true); + CS = 32.0*1.41421*mA/1000.0*(Rsense+0.02)/0.180 - 1; + } else { // If CS >= 16, turn off high_sense_r + vsense(false); + } + + if (CS > 31) + CS = 31; + + irun(CS); + ihold(CS*holdMultiplier); + //val_mA = mA; +} +void TMCStepper::rms_current(uint16_t mA, float mult) { + holdMultiplier = mult; + rms_current(mA); +} + +uint16_t TMCStepper::rms_current() { + return cs2rms(irun()); +} + +uint8_t TMCStepper::test_connection() { + uint32_t drv_status = DRV_STATUS(); + switch (drv_status) { + case 0xFFFFFFFF: return 1; + case 0: return 2; + default: return 0; + } +} + +void TMCStepper::hysteresis_end(int8_t value) { hend(value+3); } +int8_t TMCStepper::hysteresis_end() { return hend()-3; }; + +void TMCStepper::hysteresis_start(uint8_t value) { hstrt(value-1); } +uint8_t TMCStepper::hysteresis_start() { return hstrt()+1; } + +void TMCStepper::microsteps(uint16_t ms) { + switch(ms) { + case 256: mres(0); break; + case 128: mres(1); break; + case 64: mres(2); break; + case 32: mres(3); break; + case 16: mres(4); break; + case 8: mres(5); break; + case 4: mres(6); break; + case 2: mres(7); break; + case 1: mres(8); break; + default: break; + } +} + +uint16_t TMCStepper::microsteps() { + switch(mres()) { + case 0: return 256; + case 1: return 128; + case 2: return 64; + case 3: return 32; + case 4: return 16; + case 5: return 8; + case 6: return 4; + case 7: return 2; + case 8: return 1; + } + return 1; +} + +void TMCStepper::blank_time(uint8_t value) { + switch (value) { + case 16: tbl(0b00); break; + case 24: tbl(0b01); break; + case 36: tbl(0b10); break; + case 54: tbl(0b11); break; + } +} + +uint8_t TMCStepper::blank_time() { + switch (tbl()) { + case 0b00: return 16; + case 0b01: return 24; + case 0b10: return 36; + case 0b11: return 54; + } + return 0; +} + +/////////////////////////////////////////////////////////////////////////////////////// +// R+C: GSTAT +uint8_t TMCStepper::GSTAT() { return read(GSTAT_t::address); } +void TMCStepper::GSTAT(uint8_t){ write(GSTAT_t::address, 0b111); } +bool TMCStepper::reset() { GSTAT_t r; r.sr = GSTAT(); return r.reset; } +bool TMCStepper::drv_err() { GSTAT_t r; r.sr = GSTAT(); return r.drv_err; } +bool TMCStepper::uv_cp() { GSTAT_t r; r.sr = GSTAT(); return r.uv_cp; } +/////////////////////////////////////////////////////////////////////////////////////// +// W: TPOWERDOWN +uint8_t TMCStepper::TPOWERDOWN() { return TPOWERDOWN_register.sr; } +void TMCStepper::TPOWERDOWN(uint8_t input) { + TPOWERDOWN_register.sr = input; + write(TPOWERDOWN_register.address, TPOWERDOWN_register.sr); +} +/////////////////////////////////////////////////////////////////////////////////////// +// R: TSTEP +uint32_t TMCStepper::TSTEP() { return read(TSTEP_t::address); } +/////////////////////////////////////////////////////////////////////////////////////// +// W: TPWMTHRS +uint32_t TMCStepper::TPWMTHRS() { return TPWMTHRS_register.sr; } +void TMCStepper::TPWMTHRS(uint32_t input) { + TPWMTHRS_register.sr = input; + write(TPWMTHRS_register.address, TPWMTHRS_register.sr); +} + +uint16_t TMCStepper::MSCNT() { + return read(MSCNT_t::address); +} + +uint32_t TMCStepper::MSCURACT() { return read(MSCURACT_t::address); } +int16_t TMCStepper::cur_a() { + MSCURACT_t r{0}; + r.sr = MSCURACT(); + int16_t value = r.cur_a; + if (value > 255) value -= 512; + return value; +} +int16_t TMCStepper::cur_b() { + MSCURACT_t r{0}; + r.sr = MSCURACT(); + int16_t value = r.cur_b; + if (value > 255) value -= 512; + return value; +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TMCStepper.h Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,383 @@ +#pragma once + +//#define TMCDEBUG + +#include "mbed.h" + +#define SW_CAPABLE_PLATFORM true + +//#include "TMC2130_bitfields.h" +//#include "TMC2160_bitfields.h" +//#include "TMC5130_bitfields.h" +//#include "TMC5160_bitfields.h" +#include "TMC2208_bitfields.h" +#include "TMC2209_bitfields.h" +//#include "TMC2660_bitfields.h" + +#define INIT_REGISTER(REG) REG##_t REG##_register = REG##_t +//#define INIT2130_REGISTER(REG) TMC2130_n::REG##_t REG##_register = TMC2130_n::REG##_t +//#define INIT2160_REGISTER(REG) TMC2160_n::REG##_t REG##_register = TMC2160_n::REG##_t +//#define INIT5130_REGISTER(REG) TMC5130_n::REG##_t REG##_register = TMC5130_n::REG##_t +//#define INIT5160_REGISTER(REG) TMC5160_n::REG##_t REG##_register = TMC5160_n::REG##_t +//#define INIT2660_REGISTER(REG) TMC2660_n::REG##_t REG##_register = TMC2660_n::REG##_t +#define INIT2208_REGISTER(REG) TMC2208_n::REG##_t REG##_register = TMC2208_n::REG##_t +//#define INIT2224_REGISTER(REG) TMC2224_n::REG##_t REG##_register = TMC2224_n::REG##_t +#define SET_ALIAS(TYPE, DRIVER, NEW, ARG, OLD) TYPE (DRIVER::*NEW)(ARG) = &DRIVER::OLD + +#define TMCSTEPPER_VERSION 0x000701 // v0.7.1 + +#if SW_CAPABLE_PLATFORM + #include <BufferedSerial.h> + #include <Stream.h> +#endif +class TMCStepper { + public: + uint16_t cs2rms(uint8_t CS); + void rms_current(uint16_t mA); + void rms_current(uint16_t mA, float mult); + uint16_t rms_current(); + void hold_multiplier(float val) { holdMultiplier = val; } + float hold_multiplier() { return holdMultiplier; } + uint8_t test_connection(); + + // Helper functions + void microsteps(uint16_t ms); + uint16_t microsteps(); + void blank_time(uint8_t value); + uint8_t blank_time(); + void hysteresis_end(int8_t value); + int8_t hysteresis_end(); + void hysteresis_start(uint8_t value); + uint8_t hysteresis_start(); + + // R+WC: GSTAT + void GSTAT( uint8_t input); + uint8_t GSTAT(); + bool reset(); + bool drv_err(); + bool uv_cp(); + + // W: IHOLD_IRUN + void IHOLD_IRUN( uint32_t input); + uint32_t IHOLD_IRUN(); + void ihold( uint8_t B); + void irun( uint8_t B); + void iholddelay( uint8_t B); + uint8_t ihold(); + uint8_t irun(); + uint8_t iholddelay(); + + // W: TPOWERDOWN + uint8_t TPOWERDOWN(); + void TPOWERDOWN( uint8_t input); + + // R: TSTEP + uint32_t TSTEP(); + + // W: TPWMTHRS + uint32_t TPWMTHRS(); + void TPWMTHRS( uint32_t input); + + // R: MSCNT + uint16_t MSCNT(); + + // R: MSCURACT + uint32_t MSCURACT(); + int16_t cur_a(); + int16_t cur_b(); + + protected: + TMCStepper(float RS) : Rsense(RS) {}; + INIT_REGISTER(IHOLD_IRUN){{.sr=0}}; // 32b + INIT_REGISTER(TPOWERDOWN){.sr=0}; // 8b + INIT_REGISTER(TPWMTHRS){.sr=0}; // 32b + + static constexpr uint8_t TMC_READ = 0x00, + TMC_WRITE = 0x80; + + struct TSTEP_t { constexpr static uint8_t address = 0x12; }; + struct MSCNT_t { constexpr static uint8_t address = 0x6A; }; + + virtual void write(uint8_t, uint32_t) = 0; + virtual uint32_t read(uint8_t) = 0; + virtual void vsense(bool) = 0; + virtual bool vsense(void) = 0; + virtual uint32_t DRV_STATUS() = 0; + virtual void hend(uint8_t) = 0; + virtual uint8_t hend() = 0; + virtual void hstrt(uint8_t) = 0; + virtual uint8_t hstrt() = 0; + virtual void mres(uint8_t) = 0; + virtual uint8_t mres() = 0; + virtual void tbl(uint8_t) = 0; + virtual uint8_t tbl() = 0; + + const float Rsense; + float holdMultiplier = 0.5; +}; + + +class TMC2208Stepper : public TMCStepper { + public: + TMC2208Stepper(Stream * SerialPort, float RS, uint8_t addr, uint16_t mul_pin1, uint16_t mul_pin2); + TMC2208Stepper(Stream * SerialPort, float RS) : + TMC2208Stepper(SerialPort, RS, TMC2208_SLAVE_ADDR) + {} + #if SW_CAPABLE_PLATFORM + TMC2208Stepper(PinName SW_RX_pin, PinName SW_TX_pin, float RS) : + TMC2208Stepper(SW_RX_pin, SW_TX_pin, RS, TMC2208_SLAVE_ADDR) + {} + + __attribute__((deprecated("Boolean argument has been deprecated and does nothing"))) + TMC2208Stepper(PinName SW_RX_pin, PinName SW_TX_pin, float RS, bool) : + TMC2208Stepper(SW_RX_pin, SW_TX_pin, RS, TMC2208_SLAVE_ADDR) + {}; + #else + TMC2208Stepper(PinName, PinName, float) = delete; // Your platform does not currently support Software Serial + #endif + void defaults(); + void push(); + void begin(); + #if SW_CAPABLE_PLATFORM + void beginSerial(uint32_t baudrate) __attribute__((weak)); + #else + void beginSerial(uint32_t) = delete; // Your platform does not currently support Software Serial + #endif + bool isEnabled(); + + // RW: GCONF + void GCONF(uint32_t input); + void I_scale_analog(bool B); + void internal_Rsense(bool B); + void en_spreadCycle(bool B); + void shaft(bool B); + void index_otpw(bool B); + void index_step(bool B); + void pdn_disable(bool B); + void mstep_reg_select(bool B); + void multistep_filt(bool B); + uint32_t GCONF(); + bool I_scale_analog(); + bool internal_Rsense(); + bool en_spreadCycle(); + bool shaft(); + bool index_otpw(); + bool index_step(); + bool pdn_disable(); + bool mstep_reg_select(); + bool multistep_filt(); + + // R: IFCNT + uint8_t IFCNT(); + + // W: SLAVECONF + void SLAVECONF(uint16_t input); + uint16_t SLAVECONF(); + void senddelay(uint8_t B); + uint8_t senddelay(); + + // W: OTP_PROG + void OTP_PROG(uint16_t input); + + // R: OTP_READ + uint32_t OTP_READ(); + + // R: IOIN + uint32_t IOIN(); + bool enn(); + bool ms1(); + bool ms2(); + bool diag(); + bool pdn_uart(); + bool step(); + bool sel_a(); + bool dir(); + uint8_t version(); + + // RW: FACTORY_CONF + void FACTORY_CONF(uint16_t input); + uint16_t FACTORY_CONF(); + void fclktrim(uint8_t B); + void ottrim(uint8_t B); + uint8_t fclktrim(); + uint8_t ottrim(); + + // W: VACTUAL + void VACTUAL(uint32_t input); + uint32_t VACTUAL(); + + // RW: CHOPCONF + void CHOPCONF(uint32_t input); + void toff(uint8_t B); + void hstrt(uint8_t B); + void hend(uint8_t B); + void tbl(uint8_t B); + void vsense(bool B); + void mres(uint8_t B); + void intpol(bool B); + void dedge(bool B); + void diss2g(bool B); + void diss2vs(bool B); + uint32_t CHOPCONF(); + uint8_t toff(); + uint8_t hstrt(); + uint8_t hend(); + uint8_t tbl(); + bool vsense(); + uint8_t mres(); + bool intpol(); + bool dedge(); + bool diss2g(); + bool diss2vs(); + + // R: DRV_STATUS + uint32_t DRV_STATUS(); + bool otpw(); + bool ot(); + bool s2ga(); + bool s2gb(); + bool s2vsa(); + bool s2vsb(); + bool ola(); + bool olb(); + bool t120(); + bool t143(); + bool t150(); + bool t157(); + uint16_t cs_actual(); + bool stealth(); + bool stst(); + + // RW: PWMCONF + void PWMCONF(uint32_t input); + void pwm_ofs(uint8_t B); + void pwm_grad(uint8_t B); + void pwm_freq(uint8_t B); + void pwm_autoscale(bool B); + void pwm_autograd(bool B); + void freewheel(uint8_t B); + void pwm_reg(uint8_t B); + void pwm_lim(uint8_t B); + uint32_t PWMCONF(); + uint8_t pwm_ofs(); + uint8_t pwm_grad(); + uint8_t pwm_freq(); + bool pwm_autoscale(); + bool pwm_autograd(); + uint8_t freewheel(); + uint8_t pwm_reg(); + uint8_t pwm_lim(); + + // R: PWM_SCALE + uint32_t PWM_SCALE(); + uint8_t pwm_scale_sum(); + int16_t pwm_scale_auto(); + + // R: PWM_AUTO (0x72) + uint32_t PWM_AUTO(); + uint8_t pwm_ofs_auto(); + uint8_t pwm_grad_auto(); + + uint16_t bytesWritten = 0; + float Rsense = 0.11; + bool CRCerror = false; + protected: + INIT2208_REGISTER(GCONF) {{.sr=0}}; + INIT_REGISTER(SLAVECONF) {{.sr=0}}; + INIT_REGISTER(FACTORY_CONF) {{.sr=0}}; + INIT2208_REGISTER(VACTUAL) {.sr=0}; + INIT2208_REGISTER(CHOPCONF) {{.sr=0}}; + INIT2208_REGISTER(PWMCONF) {{.sr=0}}; + + struct IFCNT_t { constexpr static uint8_t address = 0x02; }; + struct OTP_PROG_t { constexpr static uint8_t address = 0x04; }; + struct OTP_READ_t { constexpr static uint8_t address = 0x05; }; + + TMC2208Stepper(Stream * SerialPort, float RS, uint8_t addr); + #if SW_CAPABLE_PLATFORM + TMC2208Stepper(PinName SW_RX_pin, PinName SW_TX_pin, float RS, uint8_t addr); + #endif + + Stream * HWSerial = nullptr; + #if SW_CAPABLE_PLATFORM + BufferedSerial * SWSerial = nullptr; + const uint16_t RXTX_pin = 0; // Half duplex + #endif + +// SSwitch *sswitch = nullptr; + + int available(); + void preWriteCommunication(); + void preReadCommunication(); + int16_t serial_read(); + uint8_t serial_write(const uint8_t data); + void postWriteCommunication(); + void postReadCommunication(); + void write(uint8_t, uint32_t); + uint32_t read(uint8_t); + const uint8_t slave_address; + uint8_t calcCRC(uint8_t datagram[], uint8_t len); + static constexpr uint8_t TMC2208_SYNC = 0x05, + TMC2208_SLAVE_ADDR = 0x00; + static constexpr uint8_t replyDelay = 2; //ms + static constexpr uint8_t abort_window = 5; + static constexpr uint8_t max_retries = 2; + + uint64_t _sendDatagram(uint8_t [], const uint8_t, uint16_t); +}; + +class TMC2209Stepper : public TMC2208Stepper { + public: + TMC2209Stepper(Stream * SerialPort, float RS, uint8_t addr) : + TMC2208Stepper(SerialPort, RS, addr) {} + + #if SW_CAPABLE_PLATFORM + TMC2209Stepper(PinName SW_RX_pin, PinName SW_TX_pin, float RS, uint8_t addr) : + TMC2208Stepper(SW_RX_pin, SW_TX_pin, RS, addr) {} + #else + TMC2209Stepper(PinName, PinName, float, uint8_t) = delete; // Your platform does not currently support Software Serial + #endif + void push(); + + // R: IOIN + uint32_t IOIN(); + bool enn(); + bool ms1(); + bool ms2(); + bool diag(); + bool pdn_uart(); + bool step(); + bool spread_en(); + bool dir(); + uint8_t version(); + + // W: TCOOLTHRS + uint32_t TCOOLTHRS(); + void TCOOLTHRS(uint32_t input); + + // W: SGTHRS + void SGTHRS(uint8_t B); + uint8_t SGTHRS(); + + // R: SG_RESULT + uint16_t SG_RESULT(); + + // W: COOLCONF + void COOLCONF(uint16_t B); + uint16_t COOLCONF(); + void semin(uint8_t B); + void seup(uint8_t B); + void semax(uint8_t B); + void sedn(uint8_t B); + void seimin(bool B); + uint8_t semin(); + uint8_t seup(); + uint8_t semax(); + uint8_t sedn(); + bool seimin(); + + protected: + INIT_REGISTER(TCOOLTHRS){.sr=0}; + TMC2209_n::SGTHRS_t SGTHRS_register{.sr=0}; + TMC2209_n::COOLCONF_t COOLCONF_register{{.sr=0}}; +};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TMC_MACROS.h Thu Mar 18 20:50:27 2021 +0000 @@ -0,0 +1,5 @@ +#pragma once + +#define DEBUG_PRINT(CFG, VAL) Serial.print(CFG); Serial.print('('); Serial.print(VAL, HEX); Serial.println(')') +//#define WRITE_REG(R) write(R##_register.address, R##_register.sr) +//#define READ_REG(R) read(R##_register.address) \ No newline at end of file