diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 00000000..c78ad210 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,22 @@ +# editorconfig.org +root = true + +[*] +trim_trailing_whitespace = true +insert_final_newline = true + +[{*.c,*.cpp,*.h,*.ino}] +end_of_line = lf + +[{*.c,*.cpp,*.h,*.ino}] +charset = utf-8 +indent_style = tab +indent_size = 4 + +[*.md] +# Two spaces at the end of the line means newline in Markdown +trim_trailing_whitespace = false + +[{*.conf,*.sublime-project}] +indent_style = tab +indent_size = 4 diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..e43b0f98 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.DS_Store diff --git a/README.md b/README.md index 596674da..f3d193ac 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,7 @@ Supported TMC drivers: * [TMC2208][2208] * [TMC2209][2209] * [TMC2224][2224] +* [TMC2240][2240] * [TMC2660][2660] * [TMC5130][5130] * [TMC5160][5160] @@ -16,6 +17,7 @@ Supported TMC drivers: [2208]: https://teemuatlut.github.io/TMCStepper/class_t_m_c2208_stepper.html [2209]: https://teemuatlut.github.io/TMCStepper/class_t_m_c2209_stepper.html [2224]: https://teemuatlut.github.io/TMCStepper/class_t_m_c2224_stepper.html +[2240]: https://teemuatlut.github.io/TMCStepper/class_t_m_c2240_stepper.html [2660]: https://teemuatlut.github.io/TMCStepper/class_t_m_c2660_stepper.html [5130]: https://teemuatlut.github.io/TMCStepper/class_t_m_c5130_stepper.html [5160]: https://teemuatlut.github.io/TMCStepper/class_t_m_c5160_stepper.html diff --git a/TMC2240.md b/TMC2240.md new file mode 100644 index 00000000..75c5c368 --- /dev/null +++ b/TMC2240.md @@ -0,0 +1,7 @@ +# TMC2240 Stepper Motor Driver + +## References + +- [Marlin TMC2240 (UART) for BIQU B1 SE Plus by z1996xm](//github.com/z1996xm/B1-SE-Plus-TMC2240/commits/main/) based on bugfix-2.0.x at 2022-04-24 +- [TMCStepper (UART) by z1996xm](//github.com/z1996xm/TMC2240-Lib) +- [TMC2240 (SPI) by makerbase-mks](//github.com/makerbase-mks/TMC2240-LIB) diff --git a/library.json b/library.json index b699d211..60da6ec1 100644 --- a/library.json +++ b/library.json @@ -10,4 +10,4 @@ }, "frameworks": "arduino", "platforms": "*" -} \ No newline at end of file +} diff --git a/src/TMCStepper.h b/src/TMCStepper.h index 6ea5661c..cdcc5f47 100644 --- a/src/TMCStepper.h +++ b/src/TMCStepper.h @@ -1,3 +1,21 @@ +/** + * TMCStepper library by @teemuatlut + * + * TMCStepper.h + * Classes for all stepper types. Inheritance hierarchy: + * + * TMCStepper + * TMC2130Stepper + * TMC2160Stepper + * TMC5130Stepper + * TMC5160Stepper + * TMC5161Stepper + * TMC2208Stepper + * TMC2209Stepper + * TMC2224Stepper + * TMC2660Stepper + * TMC2240Stepper + */ #pragma once //#define TMCDEBUG @@ -50,6 +68,7 @@ #include "source/TMC2208_bitfields.h" #include "source/TMC2209_bitfields.h" #include "source/TMC2660_bitfields.h" +#include "source/TMC2240_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 @@ -59,6 +78,7 @@ #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 INIT2240_REGISTER(REG) TMC2240_n::REG##_t REG##_register = TMC2240_n::REG##_t #define SET_ALIAS(TYPE, DRIVER, NEW, ARG, OLD) TYPE (DRIVER::*NEW)(ARG) = &DRIVER::OLD #define TMCSTEPPER_VERSION 0x000703 // v0.7.3 @@ -815,7 +835,7 @@ class TMC5160Stepper : public TMC5130Stepper { class TMC5161Stepper : public TMC5160Stepper { public: - TMC5161Stepper(uint16_t pinCS, float RS = default_RS, int8_t link_index = -1) : TMC5160Stepper(pinCS, RS, link_index) {} + TMC5161Stepper(uint16_t pinCS, float RS = default_RS, int8_t link_index = -1) : TMC5160Stepper(pinCS, RS, link_index) {} TMC5161Stepper(uint16_t pinCS, uint16_t pinMOSI, uint16_t pinMISO, uint16_t pinSCK, int8_t link_index = -1) : TMC5160Stepper(pinCS, pinMOSI, pinMISO, pinSCK, link_index) {} TMC5161Stepper(uint16_t pinCS, float RS, uint16_t pinMOSI, uint16_t pinMISO, uint16_t pinSCK, int8_t link_index = -1) : @@ -824,7 +844,7 @@ class TMC5161Stepper : public TMC5160Stepper { 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, uint8_t addr, uint16_t mul_pin1, uint16_t mul_pin2); TMC2208Stepper(Stream * SerialPort, float RS) : TMC2208Stepper(SerialPort, RS, TMC2208_SLAVE_ADDR) {} @@ -1101,6 +1121,302 @@ class TMC2224Stepper : public TMC2208Stepper { uint8_t version(); }; +class TMC2240Stepper { + public: + TMC2240Stepper(uint16_t pinCS, int8_t link_index = -1); + TMC2240Stepper(uint16_t pinCS, uint16_t pinMOSI, uint16_t pinMISO, uint16_t pinSCK, int8_t link_index = -1); + + /** + * ('rref', 12000, minval=12000, maxval=60000) + */ + uint32_t Rref = 12000; + void begin(); + void defaults(); + void setSPISpeed(uint32_t speed); + void switchCSpin(bool state); + bool isEnabled(); + void push(); + + // RW: GCONF + void GCONF(uint32_t input); + void fast_standstill(bool B); + void en_pwm_mode(bool B); + void multistep_filt(bool B); + void shaft(bool B); + void diag0_error(bool B); + void diag0_otpw(bool B); + void diag0_stall(bool B); + void diag1_stall(bool B); + void diag1_index(bool B); + void diag1_onstate(bool B); + void diag0_pushpull(bool B); + void diag1_pushpull(bool B); + void small_hysteresis(bool B); + void stop_enable(bool B); + void direct_mode(bool B); + uint32_t GCONF(); + bool fast_standstill(); + bool en_pwm_mode(); + bool multistep_filt(); + bool shaft(); + bool diag0_error(); + bool diag0_otpw(); + bool diag0_stall(); + bool diag1_stall(); + bool diag1_index(); + bool diag1_onstate(); + bool diag0_pushpull(); + bool diag1_pushpull(); + bool small_hysteresis(); + bool stop_enable(); + bool direct_mode(); + + // R+WC: GSTAT + void GSTAT(uint8_t input); + uint8_t GSTAT(); + bool reset(); + bool drv_err(); + bool uv_cp(); + bool register_reset(); + bool vm_uvlo(); + // R: IFCNT + + uint8_t IFCNT(); + + // W: SLAVECONF + void SLAVECONF(uint16_t input); + uint16_t SLAVECONF(); + void senddelay(uint8_t B); + uint8_t senddelay(); + + // R: IOIN + uint32_t IOIN(); + bool step(); + bool dir(); + bool encb(); + bool enca(); + bool drv_enn(); + bool encn(); + bool uart_en(); + bool comp_a(); + bool comp_b(); + bool comp_a1_a2(); + bool comp_b1_b2(); + bool output(); + bool ext_res_det(); + bool ext_clk(); + bool adc_err(); + uint8_t silicon_rv(); + uint8_t version(); + + // W: DRV_CONF + void DRV_CONF(uint32_t input); + void current_range(uint8_t); + void slope_control(uint8_t); + uint32_t DRV_CONF(); + + void GLOBAL_SCALER(uint8_t input); + uint8_t GLOBAL_SCALER(); + + // 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); + void irundelay(uint8_t B); + uint8_t ihold(); + uint8_t irun(); + uint8_t iholddelay(); + uint8_t irundelay(); + + // W: TCOOLTHRS + uint32_t TCOOLTHRS(); + void TCOOLTHRS( uint32_t input); + + // W: THIGH + uint32_t THIGH(); + void THIGH( uint32_t input); + + // RW: CHOPCONF + void CHOPCONF(uint32_t input); + void toff(uint8_t B); + void hstrt(uint8_t B); + void hend(uint8_t B); + void fd3(bool B); + void disfdcc(bool B); + void chm(bool B); + void TBL(uint8_t B); + void vhighfs(bool B); + void vhighchm(bool B); + void tpfd(uint8_t 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(); + bool fd3(); + bool disfdcc(); + bool chm(); + uint8_t TBL(); + bool vhighfs(); + bool vhighchm(); + uint8_t tpfd(); + uint8_t mres(); + bool intpol(); + bool dedge(); + bool diss2g(); + bool diss2vs(); + + // RW: COOLCONF + void COOLCONF(uint32_t B); + uint32_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); + void sgt(int8_t B); + void sfilt(bool B); + uint8_t semin(); + uint8_t seup(); + uint8_t semax(); + uint8_t sedn(); + bool seimin(); + int8_t sgt(); + bool sfilt(); + + // 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_meas_sd_enable(bool B); + void pwm_dis_reg_stst(bool 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(); + bool pwm_meas_sd_enable(); + bool pwm_dis_reg_stst(); + 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 + uint32_t PWM_AUTO(); + uint8_t pwm_ofs_auto(); + uint8_t pwm_grad_auto(); + + uint32_t DRV_STATUS(); + uint32_t SG_RESULT(); + bool s2vsa(); + bool s2vsb(); + bool stealth(); + bool fsactive(); + uint16_t CS_ACTUAL(); + bool stallguard(); + bool ot(); + bool otpw(); + bool s2ga(); + bool s2gb(); + bool ola(); + bool olb(); + bool stst(); + + uint16_t bytesWritten = 0; + bool CRCerror = false; + + void microsteps(uint16_t ms); + uint16_t microsteps(); + + uint8_t test_connection(); + uint16_t MSCNT(); + + 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 hysteresis_end(int8_t value); + int8_t hysteresis_end(); + void hysteresis_start(uint8_t value); + uint8_t hysteresis_start(); + + uint8_t TPOWERDOWN(); + void TPOWERDOWN(uint8_t input); + + // RW: TPWMTHRS + uint32_t TPWMTHRS(); + void TPWMTHRS( uint32_t input); + + uint8_t status_response; + protected: + INIT2240_REGISTER(GCONF) {{.sr=0}}; + INIT2240_REGISTER(DRV_CONF) {{.sr=0}}; + INIT2240_REGISTER(SLAVECONF) {{.sr=0}}; + INIT2240_REGISTER(IHOLD_IRUN) {{.sr=0}}; // 32b + INIT2240_REGISTER(CHOPCONF) {{.sr=0}}; + INIT2240_REGISTER(PWMCONF) {{.sr=0}}; + INIT2240_REGISTER(TPOWERDOWN) {{.sr=0}}; // 8b + INIT2240_REGISTER(GLOBAL_SCALER) {{.sr=0}}; // 8b + INIT_REGISTER(COOLCONF){{.sr=0}}; // 32b + INIT_REGISTER(TCOOLTHRS){.sr=0}; // 32b + INIT_REGISTER(TPWMTHRS){.sr=0}; // 32b + INIT_REGISTER(THIGH){.sr=0}; // 32b + + struct IFCNT_t { constexpr static uint8_t address = 0x02; }; + struct TSTEP_t { constexpr static uint8_t address = 0x12; }; + struct MSCNT_t { constexpr static uint8_t address = 0x6A; }; + + float calc_IFS_current_RMS(); + uint32_t set_globalscaler(float current, float IFS_current_RMS); + + void beginTransaction(); + void endTransaction(); + uint8_t transfer(const uint8_t data); + void transferEmptyBytes(const uint8_t n); + void write(uint8_t addressByte, uint32_t config); + uint32_t read(uint8_t addressByte); + + static constexpr uint8_t TMC_READ = 0x00, + TMC_WRITE = 0x80; + + SSwitch *sswitch = nullptr; + + static constexpr uint8_t TMC2240_SYNC = 0x05; + static constexpr uint8_t replyDelay = 2; + static constexpr uint8_t abort_window = 5; + static constexpr uint8_t max_retries = 2; + + uint64_t _sendDatagram(uint8_t [], const uint8_t, uint16_t); + float holdMultiplier = 0.5; + + static uint32_t spi_speed; // Default 2MHz + const uint16_t _pinCS; + SW_SPIClass * TMC_SW_SPI = nullptr; + static constexpr float default_RS = 0.11; + + int8_t link_index; + static int8_t chain_length; +}; + class TMC2660Stepper { public: TMC2660Stepper(uint16_t pinCS, float RS = default_RS); diff --git a/src/source/CHOPCONF.cpp b/src/source/CHOPCONF.cpp index 34fa39d5..115f0162 100644 --- a/src/source/CHOPCONF.cpp +++ b/src/source/CHOPCONF.cpp @@ -1,9 +1,17 @@ +/** + * TMCStepper library by @teemuatlut + * CHOPCONF.cpp - CHOPCONF Chopper Configuration + * TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161), TMC5160, TMC2208 (TMC2209, TMC2224), TMC2660 + */ #include "TMCStepper.h" #include "TMC_MACROS.h" #define SET_REG(SETTING) CHOPCONF_register.SETTING = B; write(CHOPCONF_register.address, CHOPCONF_register.sr) -// CHOPCONF +// +// TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161) +// + uint32_t TMC2130Stepper::CHOPCONF() { return read(CHOPCONF_register.address); } @@ -16,41 +24,49 @@ 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::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::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); } +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; } +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;} +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; } +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; } + +// +// TMC5160 (TMC5161) +// 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; } +// +// TMC2208 (TMC2209, TMC2224) +// + void TMC2208Stepper::CHOPCONF(uint32_t input) { CHOPCONF_register.sr = input; write(CHOPCONF_register.address, CHOPCONF_register.sr); @@ -58,27 +74,70 @@ void TMC2208Stepper::CHOPCONF(uint32_t input) { 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::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; } +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; } + +void TMC2240Stepper::CHOPCONF(uint32_t input) { + CHOPCONF_register.sr = input; + write(CHOPCONF_register.address, CHOPCONF_register.sr); +} +uint32_t TMC2240Stepper::CHOPCONF() { + return read(CHOPCONF_register.address); +} +void TMC2240Stepper::toff(uint8_t B) { SET_REG(toff); } +void TMC2240Stepper::hstrt(uint8_t B) { SET_REG(hstrt); } +void TMC2240Stepper::hend(uint8_t B) { SET_REG(hend); } +void TMC2240Stepper::fd3(bool B) { SET_REG(fd3); } +void TMC2240Stepper::disfdcc(bool B) { SET_REG(disfdcc); } +void TMC2240Stepper::chm(bool B) { SET_REG(chm); } +void TMC2240Stepper::TBL(uint8_t B) { SET_REG(TBL); } +void TMC2240Stepper::vhighfs(bool B) { SET_REG(vhighfs); } +void TMC2240Stepper::vhighchm(bool B) { SET_REG(vhighchm);} +void TMC2240Stepper::tpfd(uint8_t B) { SET_REG(tpfd); } +void TMC2240Stepper::mres(uint8_t B) { SET_REG(mres); } +void TMC2240Stepper::intpol(bool B) { SET_REG(intpol); } +void TMC2240Stepper::dedge(bool B) { SET_REG(dedge); } +void TMC2240Stepper::diss2g(bool B) { SET_REG(diss2g); } +void TMC2240Stepper::diss2vs(bool B) { SET_REG(diss2vs); } + +uint8_t TMC2240Stepper::toff() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.toff; } +uint8_t TMC2240Stepper::hstrt() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.hstrt; } +uint8_t TMC2240Stepper::hend() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.hend; } +bool TMC2240Stepper::fd3() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.fd3; } +bool TMC2240Stepper::disfdcc() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.disfdcc; } +bool TMC2240Stepper::chm() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.chm; } +uint8_t TMC2240Stepper::TBL() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.TBL; } +bool TMC2240Stepper::vhighfs() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.vhighfs; } +bool TMC2240Stepper::vhighchm() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.vhighchm; } +uint8_t TMC2240Stepper::tpfd() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.tpfd; } +uint8_t TMC2240Stepper::mres() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.mres; } +bool TMC2240Stepper::intpol() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.intpol; } +bool TMC2240Stepper::dedge() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.dedge; } +bool TMC2240Stepper::diss2g() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.diss2g; } +bool TMC2240Stepper::diss2vs() { TMC2240_n::CHOPCONF_t r{0}; r.sr = CHOPCONF(); return r.diss2vs; } + +// +// TMC2660 +// #define GET_REG_2660(SETTING) return CHOPCONF_register.SETTING; @@ -92,17 +151,17 @@ 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); } +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); } diff --git a/src/source/COOLCONF.cpp b/src/source/COOLCONF.cpp index 745ab15d..c47b83be 100644 --- a/src/source/COOLCONF.cpp +++ b/src/source/COOLCONF.cpp @@ -1,10 +1,18 @@ +/** + * TMCStepper library by @teemuatlut + * COOLCONF.cpp - COOLCONF CoolStep Configuration + * TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161), TMC2209 + */ #include "TMCStepper.h" #include "TMC_MACROS.h" #define SET_REG(SETTING) COOLCONF_register.SETTING = B; write(COOLCONF_register.address, COOLCONF_register.sr); #define GET_REG(SETTING) return COOLCONF_register.SETTING; -// COOLCONF +// +// TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161) +// + uint32_t TMC2130Stepper::COOLCONF() { return COOLCONF_register.sr; } void TMC2130Stepper::COOLCONF(uint32_t input) { COOLCONF_register.sr = input; @@ -33,6 +41,10 @@ int8_t TMC2130Stepper::sgt() { return val; } +// +// TMC2209 +// + uint16_t TMC2209Stepper::COOLCONF() { return COOLCONF_register.sr; } void TMC2209Stepper::COOLCONF(uint16_t input) { COOLCONF_register.sr = input; diff --git a/src/source/DRVCONF.cpp b/src/source/DRVCONF.cpp index e3adaa72..a8b28ee1 100644 --- a/src/source/DRVCONF.cpp +++ b/src/source/DRVCONF.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * DRVCONF.cpp - Driver Configuration + * TMC2660 + */ #include "TMCStepper.h" #include "TMC_MACROS.h" diff --git a/src/source/DRVCTRL.cpp b/src/source/DRVCTRL.cpp index 5c0e0a33..a46d9555 100644 --- a/src/source/DRVCTRL.cpp +++ b/src/source/DRVCTRL.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * DRVCTRL.cpp - Driver Control + * TMC2660 + */ #include "TMCStepper.h" #include "TMC_MACROS.h" diff --git a/src/source/DRVSTATUS.cpp b/src/source/DRVSTATUS.cpp index acd49f86..7e2b5c28 100644 --- a/src/source/DRVSTATUS.cpp +++ b/src/source/DRVSTATUS.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * DRVSTATUS.cpp - Driver Status + * TMC2660 + */ #include "TMCStepper.h" #include "TMC_MACROS.h" diff --git a/src/source/DRV_CONF.cpp b/src/source/DRV_CONF.cpp index ec574db4..97f5947a 100644 --- a/src/source/DRV_CONF.cpp +++ b/src/source/DRV_CONF.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * DRV_CONF.cpp - DRV_CONF Configuration + * TMC2160 (TMC5130, TMC5160, TMC5161) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" @@ -11,6 +16,13 @@ void TMC2160Stepper::DRV_CONF(uint32_t input) { write(DRV_CONF_register.address, DRV_CONF_register.sr); } +// W: DRV_CONF +uint32_t TMC2240Stepper::DRV_CONF() { return DRV_CONF_register.sr; } +void TMC2240Stepper::DRV_CONF(uint32_t input) { + DRV_CONF_register.sr = input; + write(DRV_CONF_register.address, DRV_CONF_register.sr); +} + void TMC2160Stepper::bbmtime(uint8_t B) { SET_REG(bbmtime); } void TMC2160Stepper::bbmclks(uint8_t B) { SET_REG(bbmclks); } void TMC2160Stepper::otselect(uint8_t B) { SET_REG(otselect); } diff --git a/src/source/DRV_STATUS.cpp b/src/source/DRV_STATUS.cpp index 7c72e74f..85adca5c 100644 --- a/src/source/DRV_STATUS.cpp +++ b/src/source/DRV_STATUS.cpp @@ -1,9 +1,20 @@ +/** + * TMCStepper library by @teemuatlut + * DRV_STATUS.cpp - Driver Status + * TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161), TMC2208 (TMC2209, TMC2224) + */ #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); } +// +// TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161) +// + +uint32_t TMC2130Stepper::DRV_STATUS() { + return read(TMC2130_n::DRV_STATUS_t::address); +} uint16_t TMC2130Stepper::sg_result(){ GET_REG(TMC2130_n, sg_result); } bool TMC2130Stepper::fsactive() { GET_REG(TMC2130_n, fsactive); } @@ -17,6 +28,10 @@ bool TMC2130Stepper::ola() { GET_REG(TMC2130_n, ola); } bool TMC2130Stepper::olb() { GET_REG(TMC2130_n, olb); } bool TMC2130Stepper::stst() { GET_REG(TMC2130_n, stst); } +// +// TMC2208 (TMC2209, TMC2224) +// + uint32_t TMC2208Stepper::DRV_STATUS() { return read(TMC2208_n::DRV_STATUS_t::address); } @@ -36,3 +51,23 @@ 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); } + +uint32_t TMC2240Stepper::DRV_STATUS() { + return read(TMC2240_n::DRV_STATUS_t::address); +} + +bool TMC2240Stepper::s2vsa() { GET_REG(TMC2240_n, s2vsa); } +bool TMC2240Stepper::s2vsb() { GET_REG(TMC2240_n, s2vsb); } +bool TMC2240Stepper::stealth() { GET_REG(TMC2240_n, stealth); } +bool TMC2240Stepper::fsactive() { GET_REG(TMC2240_n, fsactive); } +uint16_t TMC2240Stepper::CS_ACTUAL() { GET_REG(TMC2240_n, CS_ACTUAL); } +bool TMC2240Stepper::stallguard() { GET_REG(TMC2240_n, stallguard); } +bool TMC2240Stepper::ot() { GET_REG(TMC2240_n, ot); } +bool TMC2240Stepper::otpw() { GET_REG(TMC2240_n, otpw); } +bool TMC2240Stepper::s2ga() { GET_REG(TMC2240_n, s2ga); } +bool TMC2240Stepper::s2gb() { GET_REG(TMC2240_n, s2gb); } +bool TMC2240Stepper::ola() { GET_REG(TMC2240_n, ola); } +bool TMC2240Stepper::olb() { GET_REG(TMC2240_n, olb); } +uint32_t TMC2240Stepper::SG_RESULT() { GET_REG(TMC2240_n, SG_RESULT); } +bool TMC2240Stepper::stst() { GET_REG(TMC2240_n, stst); } + diff --git a/src/source/ENCMODE.cpp b/src/source/ENCMODE.cpp index b9446a80..430b94f5 100644 --- a/src/source/ENCMODE.cpp +++ b/src/source/ENCMODE.cpp @@ -1,10 +1,18 @@ +/** + * TMCStepper library by @teemuatlut + * ENCMODE.cpp - Driver Status + * TMC5130 (TMC5160, TMC5161) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" #define SET_REG(SETTING) ENCMODE_register.SETTING = B; write(ENCMODE_register.address, ENCMODE_register.sr); #define GET_REG(SETTING) ENCMODE_t r{0}; r.sr = ENCMODE(); return r.SETTING; -// ENCMODE +// +// TMC5130 (TMC5160, TMC5161) +// + uint32_t TMC5130Stepper::ENCMODE() { return read(ENCMODE_register.address); } diff --git a/src/source/GCONF.cpp b/src/source/GCONF.cpp index 7a787450..d1bdb86b 100644 --- a/src/source/GCONF.cpp +++ b/src/source/GCONF.cpp @@ -1,9 +1,17 @@ +/** + * TMCStepper library by @teemuatlut + * ENCMODE.cpp - Driver Status + * TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161), TMC5160 (TMC5161), TMC2208 (TMC2209, TMC2224) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" #define SET_REG(SETTING) GCONF_register.SETTING = B; write(GCONF_register.address, GCONF_register.sr) -// GCONF +// +// TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161) +// + uint32_t TMC2130Stepper::GCONF() { return read(GCONF_register.address); } @@ -48,6 +56,10 @@ bool TMC2130Stepper::small_hysteresis() { GCONF_t r{0}; r.sr = GCONF(); retur 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; } +// +// TMC5160 (TMC5161) +// + /* bit 18 not implemented: test_mode 0: @@ -57,13 +69,17 @@ Enable analog test output on pin DCO. IHOLD[1..0] selects the function of DCO: 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; } +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; } +// +// TMC2208 (TMC2209, TMC2224) +// + uint32_t TMC2208Stepper::GCONF() { return read(GCONF_register.address); } @@ -91,3 +107,45 @@ bool TMC2208Stepper::index_step() { TMC2208_n::GCONF_t r{0}; r.sr = GCONF(); re 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; } + +// +// TMC2240 +// + +uint32_t TMC2240Stepper::GCONF() { return read(GCONF_register.address); } +void TMC2240Stepper::GCONF(uint32_t input) { + GCONF_register.sr = input; + write(GCONF_register.address, GCONF_register.sr); +} + +void TMC2240Stepper::fast_standstill(bool B) { SET_REG(fast_standstill); } +void TMC2240Stepper::en_pwm_mode(bool B) { SET_REG(en_pwm_mode); } +void TMC2240Stepper::multistep_filt(bool B) { SET_REG(multistep_filt); } +void TMC2240Stepper::shaft(bool B) { SET_REG(shaft); } +void TMC2240Stepper::diag0_error(bool B) { SET_REG(diag0_error); } +void TMC2240Stepper::diag0_otpw(bool B) { SET_REG(diag0_otpw); } +void TMC2240Stepper::diag0_stall(bool B) { SET_REG(diag0_stall); } +void TMC2240Stepper::diag1_stall(bool B) { SET_REG(diag1_stall); } +void TMC2240Stepper::diag1_index(bool B) { SET_REG(diag1_index); } +void TMC2240Stepper::diag1_onstate(bool B) { SET_REG(diag1_onstate); } +void TMC2240Stepper::diag0_pushpull(bool B) { SET_REG(diag0_pushpull); } +void TMC2240Stepper::diag1_pushpull(bool B) { SET_REG(diag1_pushpull); } +void TMC2240Stepper::small_hysteresis(bool B) { SET_REG(small_hysteresis);} +void TMC2240Stepper::stop_enable(bool B) { SET_REG(stop_enable); } +void TMC2240Stepper::direct_mode(bool B) { SET_REG(direct_mode); } + +bool TMC2240Stepper::fast_standstill() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.fast_standstill; } +bool TMC2240Stepper::en_pwm_mode() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.en_pwm_mode; } +bool TMC2240Stepper::multistep_filt() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.multistep_filt; } +bool TMC2240Stepper::shaft() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.shaft; } +bool TMC2240Stepper::diag0_error() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.diag0_error; } +bool TMC2240Stepper::diag0_otpw() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.diag0_otpw; } +bool TMC2240Stepper::diag0_stall() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.diag0_stall; } +bool TMC2240Stepper::diag1_stall() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.diag1_stall; } +bool TMC2240Stepper::diag1_index() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.diag1_index; } +bool TMC2240Stepper::diag1_onstate() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.diag1_onstate; } +bool TMC2240Stepper::diag0_pushpull() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.diag0_pushpull; } +bool TMC2240Stepper::diag1_pushpull() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.diag1_pushpull; } +bool TMC2240Stepper::small_hysteresis() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.small_hysteresis; } +bool TMC2240Stepper::stop_enable() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.stop_enable; } +bool TMC2240Stepper::direct_mode() { TMC2240_n::GCONF_t r{0}; r.sr = GCONF(); return r.direct_mode; } diff --git a/src/source/GLOBAL_SCALER.cpp b/src/source/GLOBAL_SCALER.cpp new file mode 100644 index 00000000..22ddfae0 --- /dev/null +++ b/src/source/GLOBAL_SCALER.cpp @@ -0,0 +1,27 @@ +/** + * TMCStepper library by @teemuatlut + * GLOBAL_SCALER.cpp + * TMC2160, TMC2240 + */ +#include "TMCStepper.h" +#include "TMC_MACROS.h" + +// +// TMC2160 +// + +uint8_t TMC2160Stepper::GLOBAL_SCALER() { return GLOBAL_SCALER_register.sr; } +void TMC2160Stepper::GLOBAL_SCALER(uint8_t input) { + GLOBAL_SCALER_register.sr = input; + write(GLOBAL_SCALER_register.address, GLOBAL_SCALER_register.sr); +} + +// +// TMC2240 +// + +uint8_t TMC2240Stepper::GLOBAL_SCALER() { return GLOBAL_SCALER_register.sr; } +void TMC2240Stepper::GLOBAL_SCALER(uint8_t input) { + GLOBAL_SCALER_register.sr = input; + write(GLOBAL_SCALER_register.address, GLOBAL_SCALER_register.sr); +} diff --git a/src/source/IHOLD_IRUN.cpp b/src/source/IHOLD_IRUN.cpp index 9917959e..74e2c4cb 100644 --- a/src/source/IHOLD_IRUN.cpp +++ b/src/source/IHOLD_IRUN.cpp @@ -1,10 +1,18 @@ +/** + * TMCStepper library by @teemuatlut + * IHOLD_IRUN.cpp - Hold / Run + * TMCStepper - TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161), TMC2208 (TMC2209, TMC2224), TMC2240 + */ #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 +// +// TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161), TMC2208 (TMC2209, TMC2224) +// + uint32_t TMCStepper::IHOLD_IRUN() { return IHOLD_IRUN_register.sr; } void TMCStepper::IHOLD_IRUN(uint32_t input) { IHOLD_IRUN_register.sr = input; @@ -18,3 +26,23 @@ 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); } + +// +// TMC2240 +// + +uint32_t TMC2240Stepper::IHOLD_IRUN() { return IHOLD_IRUN_register.sr; } +void TMC2240Stepper::IHOLD_IRUN(uint32_t input) { + IHOLD_IRUN_register.sr = input; + write(IHOLD_IRUN_register.address, IHOLD_IRUN_register.sr); +} + +void TMC2240Stepper::ihold(uint8_t B) { SET_REG(ihold); } +void TMC2240Stepper::irun(uint8_t B) { SET_REG(irun); } +void TMC2240Stepper::iholddelay(uint8_t B) { SET_REG(iholddelay); } +void TMC2240Stepper::irundelay(uint8_t B) { SET_REG(irundelay); } + +uint8_t TMC2240Stepper::ihold() { GET_REG(ihold); } +uint8_t TMC2240Stepper::irun() { GET_REG(irun); } +uint8_t TMC2240Stepper::iholddelay() { GET_REG(iholddelay); } +uint8_t TMC2240Stepper::irundelay() { GET_REG(irundelay); } diff --git a/src/source/IOIN.cpp b/src/source/IOIN.cpp new file mode 100644 index 00000000..57ecd5ea --- /dev/null +++ b/src/source/IOIN.cpp @@ -0,0 +1,125 @@ +/** + * TMCStepper library by @teemuatlut + * IOIN.cpp - Driver Control + * TMC2130 (TMC5160, TMC5161), TMC2160, TMC5130, TMC2208, TMC2209, TMC2224, TMC2240 + */ +#include "TMCStepper.h" +#include "TMC_MACROS.h" + +#define GET_REG_NS(NS, SETTING) NS::IOIN_t r{0}; r.sr = IOIN(); return r.SETTING + +// +// TMC2130 +// +#define GET_REG(SETTING) IOIN_t r{0}; r.sr = IOIN(); return r.SETTING + +uint32_t TMC2130Stepper::IOIN() { return read(IOIN_t::address); } +bool TMC2130Stepper::step() { GET_REG(step); } +bool TMC2130Stepper::dir() { GET_REG(dir); } +bool TMC2130Stepper::dcen_cfg4() { GET_REG(dcen_cfg4); } +bool TMC2130Stepper::dcin_cfg5() { GET_REG(dcin_cfg5); } +bool TMC2130Stepper::drv_enn_cfg6() { GET_REG(drv_enn_cfg6);} +bool TMC2130Stepper::dco() { GET_REG(dco); } +uint8_t TMC2130Stepper::version() { GET_REG(version); } + +// +// TMC2160 +// +#define GET_REG_2160(SETTING) GET_REG_NS(TMC2160_n, SETTING) + +uint32_t TMC2160Stepper::IOIN() { return read(TMC2160_n::IOIN_t::address); } +bool TMC2160Stepper::refl_step() { GET_REG_2160(refl_step); } +bool TMC2160Stepper::refr_dir() { GET_REG_2160(refr_dir); } +bool TMC2160Stepper::encb_dcen_cfg4() { GET_REG_2160(encb_dcen_cfg4); } +bool TMC2160Stepper::enca_dcin_cfg5() { GET_REG_2160(enca_dcin_cfg5); } +bool TMC2160Stepper::drv_enn() { GET_REG_2160(drv_enn); } +bool TMC2160Stepper::dco_cfg6() { GET_REG_2160(dco_cfg6); } +uint8_t TMC2160Stepper::version() { GET_REG_2160(version); } + +// +// TMC2208 +// +#define GET_REG_2208(SETTING) GET_REG_NS(TMC2208_n, SETTING) + +uint32_t TMC2208Stepper::IOIN() { return read(TMC2208_n::IOIN_t::address); } +bool TMC2208Stepper::enn() { GET_REG_2208(enn); } +bool TMC2208Stepper::ms1() { GET_REG_2208(ms1); } +bool TMC2208Stepper::ms2() { GET_REG_2208(ms2); } +bool TMC2208Stepper::diag() { GET_REG_2208(diag); } +bool TMC2208Stepper::pdn_uart() { GET_REG_2208(pdn_uart); } +bool TMC2208Stepper::step() { GET_REG_2208(step); } +bool TMC2208Stepper::sel_a() { GET_REG_2208(sel_a); } +bool TMC2208Stepper::dir() { GET_REG_2208(dir); } +uint8_t TMC2208Stepper::version() { GET_REG_2208(version); } + +// +// TMC2209 +// +#define GET_REG_2209(SETTING) GET_REG_NS(TMC2209_n, SETTING) + +uint32_t TMC2209Stepper::IOIN() { return read(TMC2209_n::IOIN_t::address); } +bool TMC2209Stepper::enn() { GET_REG_2209(enn); } +bool TMC2209Stepper::ms1() { GET_REG_2209(ms1); } +bool TMC2209Stepper::ms2() { GET_REG_2209(ms2); } +bool TMC2209Stepper::diag() { GET_REG_2209(diag); } +bool TMC2209Stepper::pdn_uart() { GET_REG_2209(pdn_uart); } +bool TMC2209Stepper::step() { GET_REG_2209(step); } +bool TMC2209Stepper::spread_en() { GET_REG_2209(spread_en); } +bool TMC2209Stepper::dir() { GET_REG_2209(dir); } +uint8_t TMC2209Stepper::version() { GET_REG_2209(version); } + +// +// TMC2224 +// +#define GET_REG_2224(SETTING) GET_REG_NS(TMC2224_n, SETTING) + +uint32_t TMC2224Stepper::IOIN() { return read(TMC2224_n::IOIN_t::address); } +bool TMC2224Stepper::enn() { GET_REG_2224(enn); } +bool TMC2224Stepper::ms1() { GET_REG_2224(ms1); } +bool TMC2224Stepper::ms2() { GET_REG_2224(ms2); } +bool TMC2224Stepper::pdn_uart() { GET_REG_2224(pdn_uart); } +bool TMC2224Stepper::spread() { GET_REG_2224(spread); } +bool TMC2224Stepper::step() { GET_REG_2224(step); } +bool TMC2224Stepper::sel_a() { GET_REG_2224(sel_a); } +bool TMC2224Stepper::dir() { GET_REG_2224(dir); } +uint8_t TMC2224Stepper::version() { GET_REG_2224(version); } + +// +// TMC2240 +// +#define GET_REG_2240(SETTING) GET_REG_NS(TMC2240_n, SETTING) + +uint32_t TMC2240Stepper::IOIN() { return read(TMC2240_n::IOIN_t::address); } +bool TMC2240Stepper::step() { GET_REG_2240(step); } +bool TMC2240Stepper::dir() { GET_REG_2240(dir); } +bool TMC2240Stepper::encb() { GET_REG_2240(encb); } +bool TMC2240Stepper::enca() { GET_REG_2240(enca); } +bool TMC2240Stepper::drv_enn() { GET_REG_2240(drv_enn); } +bool TMC2240Stepper::encn() { GET_REG_2240(encn); } +bool TMC2240Stepper::uart_en() { GET_REG_2240(uart_en); } +bool TMC2240Stepper::comp_a() { GET_REG_2240(comp_a); } +bool TMC2240Stepper::comp_b() { GET_REG_2240(comp_b); } +bool TMC2240Stepper::comp_a1_a2() { GET_REG_2240(comp_a1_a2); } +bool TMC2240Stepper::comp_b1_b2() { GET_REG_2240(comp_b1_b2); } +bool TMC2240Stepper::output() { GET_REG_2240(output); } +bool TMC2240Stepper::ext_res_det() { GET_REG_2240(ext_res_det);} +bool TMC2240Stepper::ext_clk() { GET_REG_2240(ext_clk); } +bool TMC2240Stepper::adc_err() { GET_REG_2240(adc_err); } +uint8_t TMC2240Stepper::silicon_rv() { GET_REG_2240(silicon_rv); } +uint8_t TMC2240Stepper::version() { GET_REG_2240(version); } + +// +// TMC5130 +// +#define GET_REG_5130(SETTING) GET_REG_NS(TMC5130_n, SETTING) + +uint32_t TMC5130Stepper::IOIN() { return read(TMC5130_n::IOIN_t::address); } +bool TMC5130Stepper::refl_step() { GET_REG_5130(refl_step); } +bool TMC5130Stepper::refr_dir() { GET_REG_5130(refr_dir); } +bool TMC5130Stepper::encb_dcen_cfg4(){ GET_REG_5130(encb_dcen_cfg4); } +bool TMC5130Stepper::enca_dcin_cfg5(){ GET_REG_5130(enca_dcin_cfg5); } +bool TMC5130Stepper::drv_enn_cfg6() { GET_REG_5130(drv_enn_cfg6); } +bool TMC5130Stepper::enc_n_dco() { GET_REG_5130(enc_n_dco); } +bool TMC5130Stepper::sd_mode() { GET_REG_5130(sd_mode); } +bool TMC5130Stepper::swcomp_in() { GET_REG_5130(swcomp_in); } +uint8_t TMC5130Stepper::version() { GET_REG_5130(version); } diff --git a/src/source/PWMCONF.cpp b/src/source/PWMCONF.cpp index c1a47f5d..14fae01d 100644 --- a/src/source/PWMCONF.cpp +++ b/src/source/PWMCONF.cpp @@ -1,10 +1,18 @@ +/** + * TMCStepper library by @teemuatlut + * PWMCONF.cpp - PWM Configuration + * TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161), TMC2160 (TMC5130, TMC5160, TMC5161), TMC2208 (TMC2209, TMC2224) + */ #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 +// +// TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161) +// + uint32_t TMC2130Stepper::PWMCONF() { return PWMCONF_register.sr; } void TMC2130Stepper::PWMCONF(uint32_t input) { PWMCONF_register.sr = input; @@ -25,6 +33,10 @@ bool TMC2130Stepper::pwm_autoscale() { GET_REG(pwm_autoscale); } bool TMC2130Stepper::pwm_symmetric() { GET_REG(pwm_symmetric); } uint8_t TMC2130Stepper::freewheel() { GET_REG(freewheel); } +// +// TMC2160 (TMC5130, TMC5160, TMC5161) +// + uint32_t TMC2160Stepper::PWMCONF() { return PWMCONF_register.sr; } @@ -51,6 +63,10 @@ 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; } +// +// TMC2208 (TMC2209, TMC2224) +// + uint32_t TMC2208Stepper::PWMCONF() { return read(PWMCONF_register.address); } @@ -76,3 +92,32 @@ bool TMC2208Stepper::pwm_autograd() { TMC2208_n::PWMCONF_t r{0}; r.sr = PWMCONF 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; } + +// PWMCONF +uint32_t TMC2240Stepper::PWMCONF() { return PWMCONF_register.sr; } +void TMC2240Stepper::PWMCONF(uint32_t input) { + PWMCONF_register.sr = input; + write(PWMCONF_register.address, PWMCONF_register.sr); +} + +void TMC2240Stepper::pwm_ofs ( uint8_t B ) { PWMCONF_register.pwm_ofs = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2240Stepper::pwm_grad ( uint8_t B ) { PWMCONF_register.pwm_grad = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2240Stepper::pwm_freq ( uint8_t B ) { PWMCONF_register.pwm_freq = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2240Stepper::pwm_autoscale ( bool B ) { PWMCONF_register.pwm_autoscale = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2240Stepper::pwm_autograd ( bool B ) { PWMCONF_register.pwm_autograd = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2240Stepper::freewheel ( uint8_t B ) { PWMCONF_register.freewheel = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2240Stepper::pwm_meas_sd_enable ( bool B ) { PWMCONF_register.pwm_autoscale = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2240Stepper::pwm_dis_reg_stst ( bool B ) { PWMCONF_register.pwm_autograd = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2240Stepper::pwm_reg ( uint8_t B ) { PWMCONF_register.pwm_reg = B; write(PWMCONF_register.address, PWMCONF_register.sr); } +void TMC2240Stepper::pwm_lim ( uint8_t B ) { PWMCONF_register.pwm_lim = B; write(PWMCONF_register.address, PWMCONF_register.sr); } + +uint8_t TMC2240Stepper::pwm_ofs() { TMC2240_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_ofs; } +uint8_t TMC2240Stepper::pwm_grad() { TMC2240_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_grad; } +uint8_t TMC2240Stepper::pwm_freq() { TMC2240_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_freq; } +bool TMC2240Stepper::pwm_autoscale() { TMC2240_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_autoscale; } +bool TMC2240Stepper::pwm_autograd() { TMC2240_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_autograd; } +uint8_t TMC2240Stepper::freewheel() { TMC2240_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.freewheel; } +bool TMC2240Stepper::pwm_meas_sd_enable() { TMC2240_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_autoscale; } +bool TMC2240Stepper::pwm_dis_reg_stst() { TMC2240_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_autograd; } +uint8_t TMC2240Stepper::pwm_reg() { TMC2240_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_reg; } +uint8_t TMC2240Stepper::pwm_lim() { TMC2240_n::PWMCONF_t r{0}; r.sr = PWMCONF(); return r.pwm_lim; } diff --git a/src/source/RAMP_STAT.cpp b/src/source/RAMP_STAT.cpp index 64d60920..ac152894 100644 --- a/src/source/RAMP_STAT.cpp +++ b/src/source/RAMP_STAT.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * RAMP_STAT.cpp - Ramp Status + * TMC5130 (TMC5160, TMC5161) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" diff --git a/src/source/SERIAL_SWITCH.cpp b/src/source/SERIAL_SWITCH.cpp index 719ebcf2..62545bf1 100644 --- a/src/source/SERIAL_SWITCH.cpp +++ b/src/source/SERIAL_SWITCH.cpp @@ -1,3 +1,7 @@ +/** + * TMCStepper library by @teemuatlut + * SERIAL_SWITCH.cpp - Serial Switch for Arduino / Raspberry Pi + */ #include "SERIAL_SWITCH.h" SSwitch::SSwitch( const uint16_t pin1, const uint16_t pin2, const uint8_t address) : @@ -5,11 +9,11 @@ SSwitch::SSwitch( const uint16_t pin1, const uint16_t pin2, const uint8_t addres p2(pin2), addr(address) { - pinMode(pin1, OUTPUT); - pinMode(pin2, OUTPUT); + pinMode(pin1, OUTPUT); + pinMode(pin2, OUTPUT); } void SSwitch::active() { - digitalWrite(p1, addr & 0b01 ? HIGH : LOW); - digitalWrite(p2, addr & 0b10 ? HIGH : LOW); + digitalWrite(p1, addr & 0b01 ? HIGH : LOW); + digitalWrite(p2, addr & 0b10 ? HIGH : LOW); } diff --git a/src/source/SERIAL_SWITCH.h b/src/source/SERIAL_SWITCH.h index 92801756..5c7c3381 100644 --- a/src/source/SERIAL_SWITCH.h +++ b/src/source/SERIAL_SWITCH.h @@ -1,3 +1,7 @@ +/** + * TMCStepper library by @teemuatlut + * SERIAL_SWITCH.h - Serial Switch for Arduino / Raspberry Pi + */ #pragma once #if defined(ARDUINO) && ARDUINO >= 100 #include diff --git a/src/source/SGCSCONF.cpp b/src/source/SGCSCONF.cpp index 8b7241b1..b92e5f5c 100644 --- a/src/source/SGCSCONF.cpp +++ b/src/source/SGCSCONF.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * SGCSCONF.cpp - SGCS Configuration + * TMC2660 + */ #include "TMCStepper.h" #include "TMC_MACROS.h" diff --git a/src/source/SHORT_CONF.cpp b/src/source/SHORT_CONF.cpp index ed35bab8..4cc0ea6d 100644 --- a/src/source/SHORT_CONF.cpp +++ b/src/source/SHORT_CONF.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * SHORT_CONF.cpp - Short Configuration + * TMC2160 (TMC5130, TMC5160, TMC5161) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" @@ -17,4 +22,4 @@ void TMC2160Stepper::shortdelay(bool B) { SET_REG(shortdelay); } uint8_t TMC2160Stepper::s2vs_level() { GET_REG(s2vs_level); } uint8_t TMC2160Stepper::s2g_level() { GET_REG(s2g_level); } uint8_t TMC2160Stepper::shortfilter() { GET_REG(shortfilter); } -bool TMC2160Stepper::shortdelay() { GET_REG(shortdelay); } \ No newline at end of file +bool TMC2160Stepper::shortdelay() { GET_REG(shortdelay); } diff --git a/src/source/SLAVECONF.cpp b/src/source/SLAVECONF.cpp new file mode 100644 index 00000000..737b5680 --- /dev/null +++ b/src/source/SLAVECONF.cpp @@ -0,0 +1,44 @@ +/** + * TMCStepper library by @teemuatlut + * SLAVECONF.cpp + * TMC2208 (TMC2209, TMC2224), TMC2240, TMC5130 + */ +#include "TMCStepper.h" +#include "TMC_MACROS.h" + +#define SET_REG(SETTING) SLAVECONF_register.SETTING = B; write(SLAVECONF_register.address, SLAVECONF_register.sr) +#define GET_REG(SETTING) return SLAVECONF_register.SETTING + +// +// TMC2208 (TMC2209, TMC2224) +// + +uint16_t TMC2208Stepper::SLAVECONF() { return SLAVECONF_register.sr; } +void TMC2208Stepper::SLAVECONF(uint16_t input) { + SLAVECONF_register.sr = input & 0xF00; + write(SLAVECONF_register.address, SLAVECONF_register.sr); +} +uint8_t TMC2208Stepper::senddelay() { GET_REG(senddelay); } +void TMC2208Stepper::senddelay(uint8_t B) { SET_REG(senddelay); } + +// +// TMC2240 +// + +uint16_t TMC2240Stepper::SLAVECONF() { return SLAVECONF_register.sr; } +void TMC2240Stepper::SLAVECONF(uint16_t input) { + SLAVECONF_register.sr = input & 0xF00; + write(SLAVECONF_register.address, SLAVECONF_register.sr); +} +uint8_t TMC2240Stepper::senddelay() { GET_REG(senddelay); } +void TMC2240Stepper::senddelay(uint8_t B) { SET_REG(senddelay); } + +// +// TMC5130 +// + +uint16_t TMC5130Stepper::SLAVECONF() { return SLAVECONF_register.sr; } +void TMC5130Stepper::SLAVECONF(uint16_t input) { + SLAVECONF_register.sr = input; + write(SLAVECONF_register.address, SLAVECONF_register.sr); +} diff --git a/src/source/SMARTEN.cpp b/src/source/SMARTEN.cpp index 485919b4..b69e78a3 100644 --- a/src/source/SMARTEN.cpp +++ b/src/source/SMARTEN.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * SMARTEN.cpp - Smart Enable + * TMC2660 + */ #include "TMCStepper.h" #include "TMC_MACROS.h" diff --git a/src/source/SW_MODE.cpp b/src/source/SW_MODE.cpp index 0393009c..a2a64eb2 100644 --- a/src/source/SW_MODE.cpp +++ b/src/source/SW_MODE.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * SW_MODE.cpp - Software Mode + * TMC5130 (TMC5160, TMC5161) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" diff --git a/src/source/SW_SPI.cpp b/src/source/SW_SPI.cpp index 13e416e4..cce83679 100644 --- a/src/source/SW_SPI.cpp +++ b/src/source/SW_SPI.cpp @@ -1,3 +1,7 @@ +/** + * TMCStepper library by @teemuatlut + * SW_SPI.cpp - Software SPI for Arduino or Raspberry Pi + */ #include "SW_SPI.h" SW_SPIClass::SW_SPIClass(uint16_t mosi, uint16_t miso, uint16_t sck) : diff --git a/src/source/SW_SPI.h b/src/source/SW_SPI.h index 98445a05..724f10ae 100644 --- a/src/source/SW_SPI.h +++ b/src/source/SW_SPI.h @@ -1,3 +1,7 @@ +/** + * TMCStepper library by @teemuatlut + * SW_SPI.h - Software SPI for Arduino or Raspberry Pi + */ #pragma once #if defined(ARDUINO) && ARDUINO >= 100 diff --git a/src/source/TMC2130Stepper.cpp b/src/source/TMC2130Stepper.cpp index 9d01c4fc..13e36843 100644 --- a/src/source/TMC2130Stepper.cpp +++ b/src/source/TMC2130Stepper.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2130Stepper.cpp + * Implementing methods for TMC2130 (TMC2160, TMC5130, TMC5160, TMC5161) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" @@ -200,16 +205,6 @@ void TMC2130Stepper::push() { ENCM_CTRL(ENCM_CTRL_register.sr); } -/////////////////////////////////////////////////////////////////////////////////////// -// R: IOIN -uint32_t TMC2130Stepper::IOIN() { return read(IOIN_t::address); } -bool TMC2130Stepper::step() { IOIN_t r{0}; r.sr = IOIN(); return r.step; } -bool TMC2130Stepper::dir() { IOIN_t r{0}; r.sr = IOIN(); return r.dir; } -bool TMC2130Stepper::dcen_cfg4() { IOIN_t r{0}; r.sr = IOIN(); return r.dcen_cfg4; } -bool TMC2130Stepper::dcin_cfg5() { IOIN_t r{0}; r.sr = IOIN(); return r.dcin_cfg5; } -bool TMC2130Stepper::drv_enn_cfg6() { IOIN_t r{0}; r.sr = IOIN(); return r.drv_enn_cfg6; } -bool TMC2130Stepper::dco() { IOIN_t r{0}; r.sr = IOIN(); return r.dco; } -uint8_t TMC2130Stepper::version() { IOIN_t r{0}; r.sr = IOIN(); return r.version; } /////////////////////////////////////////////////////////////////////////////////////// // W: TCOOLTHRS uint32_t TMC2130Stepper::TCOOLTHRS() { return TCOOLTHRS_register.sr; } diff --git a/src/source/TMC2130_bitfields.h b/src/source/TMC2130_bitfields.h index 3bcc9708..62cdf415 100644 --- a/src/source/TMC2130_bitfields.h +++ b/src/source/TMC2130_bitfields.h @@ -1,3 +1,18 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2130_bitfields.h + * + * TMC2130 hardware register bit fields: + * GCONF, GSTAT + * IHOLD_IRUN + * IOIN + * TPOWERDOWN, TPWMTHRS, TCOOLTHRS, THIGH + * XDIRECT + * VDCMIN + * CHOPCONF, COOLCONF, PWMCONF + * DCCTRL, ENCM_CTRL + * DRV_STATUS + */ #pragma once #pragma pack(push, 1) diff --git a/src/source/TMC2160Stepper.cpp b/src/source/TMC2160Stepper.cpp index f97487a9..58db4144 100644 --- a/src/source/TMC2160Stepper.cpp +++ b/src/source/TMC2160Stepper.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2160Stepper.cpp + * Implementing methods for TMC2160 (TMC5130, TMC5160, TMC5161) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" @@ -128,26 +133,6 @@ void TMC2160Stepper::push() { GLOBAL_SCALER(GLOBAL_SCALER_register.sr); } -/////////////////////////////////////////////////////////////////////////////////////// -// R: IOIN -uint32_t TMC2160Stepper::IOIN() { - return read(TMC2160_n::IOIN_t::address); -} -bool TMC2160Stepper::refl_step() { TMC2160_n::IOIN_t r{0}; r.sr = IOIN(); return r.refl_step; } -bool TMC2160Stepper::refr_dir() { TMC2160_n::IOIN_t r{0}; r.sr = IOIN(); return r.refr_dir; } -bool TMC2160Stepper::encb_dcen_cfg4() { TMC2160_n::IOIN_t r{0}; r.sr = IOIN(); return r.encb_dcen_cfg4; } -bool TMC2160Stepper::enca_dcin_cfg5() { TMC2160_n::IOIN_t r{0}; r.sr = IOIN(); return r.enca_dcin_cfg5; } -bool TMC2160Stepper::drv_enn() { TMC2160_n::IOIN_t r{0}; r.sr = IOIN(); return r.drv_enn; } -bool TMC2160Stepper::dco_cfg6() { TMC2160_n::IOIN_t r{0}; r.sr = IOIN(); return r.dco_cfg6; } -uint8_t TMC2160Stepper::version() { TMC2160_n::IOIN_t r{0}; r.sr = IOIN(); return r.version; } - -// W: GLOBAL_SCALER -uint8_t TMC2160Stepper::GLOBAL_SCALER() { return GLOBAL_SCALER_register.sr; } -void TMC2160Stepper::GLOBAL_SCALER(uint8_t input) { - GLOBAL_SCALER_register.sr = input; - write(GLOBAL_SCALER_register.address, GLOBAL_SCALER_register.sr); -} - // R: OFFSET_READ uint16_t TMC2160Stepper::OFFSET_READ() { return read(OFFSET_READ_t::address); } diff --git a/src/source/TMC2160_bitfields.h b/src/source/TMC2160_bitfields.h index 2eaa22f4..c47ff00f 100644 --- a/src/source/TMC2160_bitfields.h +++ b/src/source/TMC2160_bitfields.h @@ -1,3 +1,13 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2160_bitfields.h + * + * TMC2160 (TMC5130, TMC5160, TMC5161) hardware register bit fields. + * + * Overriding TMC2130: + * IOIN + * PWMCONF, PWM_SCALE + */ #pragma once #pragma pack(push, 1) diff --git a/src/source/TMC2208Stepper.cpp b/src/source/TMC2208Stepper.cpp index 8e2c9ab7..c6a91242 100644 --- a/src/source/TMC2208Stepper.cpp +++ b/src/source/TMC2208Stepper.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2208Stepper.cpp + * Implementing methods for TMC2208 (TMC2209, TMC2224) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" #include "SERIAL_SWITCH.h" @@ -63,8 +68,8 @@ void TMC2208Stepper::defaults() { GCONF_register.multistep_filt = 1; // OTP IHOLD_IRUN_register.iholddelay = 1; // OTP TPOWERDOWN_register.sr = 20; - CHOPCONF_register.sr = 0x10000053; - PWMCONF_register.sr = 0xC10D0024; + CHOPCONF_register.sr = 0x10000053; // 1/16 x 256 single-edge + PWMCONF_register.sr = 0xC10D0024; // autoscale=1, freq=01, grad & amp, freewheel=00 //MSLUT0_register.sr = ???; //MSLUT1_register.sr = ???; //MSLUT2_register.sr = ???; @@ -319,16 +324,6 @@ 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); } @@ -337,32 +332,6 @@ 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); } diff --git a/src/source/TMC2208_bitfields.h b/src/source/TMC2208_bitfields.h index c1fdaf9c..b05f8e81 100644 --- a/src/source/TMC2208_bitfields.h +++ b/src/source/TMC2208_bitfields.h @@ -1,3 +1,17 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2208_bitfields.h + * + * TMC2208 (TMC2209, TMC2224) hardware register bit fields. + * + * Overriding TMC2130: + * GCONF, FACTORY_CONF, CHOPCONF + * PWMCONF, PWM_SCALE + * IOIN + * VACTUAL + * MSCURACT + * DRV_STATUS + */ #pragma once #pragma pack(push, 1) @@ -29,11 +43,11 @@ namespace TMC2208_n { uint32_t sr; struct { bool enn : 1, - : 1, + : 1, ms1 : 1, ms2 : 1, diag : 1, - : 1, + : 1, pdn_uart : 1, step : 1, sel_a : 1, diff --git a/src/source/TMC2209Stepper.cpp b/src/source/TMC2209Stepper.cpp index f5b03120..c216a647 100644 --- a/src/source/TMC2209Stepper.cpp +++ b/src/source/TMC2209Stepper.cpp @@ -1,18 +1,10 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2209Stepper.cpp + * Implementing methods for TMC2209 (TMC2224) + */ #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); @@ -27,13 +19,11 @@ void TMC2209Stepper::push() { COOLCONF(COOLCONF_register.sr); } +uint8_t TMC2209Stepper::SGTHRS() { return SGTHRS_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; } diff --git a/src/source/TMC2209_bitfields.h b/src/source/TMC2209_bitfields.h index 7655a32d..88b4e3c9 100644 --- a/src/source/TMC2209_bitfields.h +++ b/src/source/TMC2209_bitfields.h @@ -1,3 +1,14 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2209_bitfields.h + * + * TMC2209 (TMC2224) hardware register bit fields. + * + * Overriding TMC2208 < TMC2130: + * IOIN + * SGTHRS, SG_RESULT + * COOLCONF + */ #pragma once #pragma pack(push, 1) diff --git a/src/source/TMC2240Stepper.cpp b/src/source/TMC2240Stepper.cpp new file mode 100644 index 00000000..a8edd7b6 --- /dev/null +++ b/src/source/TMC2240Stepper.cpp @@ -0,0 +1,362 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2240Stepper.cpp + */ +#include "TMCStepper.h" +#include "TMC_MACROS.h" + +int8_t TMC2240Stepper::chain_length = 0; +uint32_t TMC2240Stepper::spi_speed = 16000000/8; + +TMC2240Stepper::TMC2240Stepper(uint16_t pinCS, int8_t link) : + _pinCS(pinCS), + link_index(link) + { + defaults(); + + if (link > chain_length) + chain_length = link; + } + +TMC2240Stepper::TMC2240Stepper(uint16_t pinCS, uint16_t pinMOSI, uint16_t pinMISO, uint16_t pinSCK, int8_t link) : + _pinCS(pinCS), + link_index(link) + { + SW_SPIClass *SW_SPI_Obj = new SW_SPIClass(pinMOSI, pinMISO, pinSCK); + TMC_SW_SPI = SW_SPI_Obj; + defaults(); + + if (link > chain_length) + chain_length = link; + } + +void TMC2240Stepper::defaults() { + //GCONF_register.en_spreadcycle = 0; + GCONF_register.multistep_filt = 1; + + IHOLD_IRUN_register.iholddelay = 1; + TPOWERDOWN_register.sr = 20; + + CHOPCONF_register.sr = 0x10000053; // 1/16 x 256 single-edge + PWMCONF_register.sr = 0xC10D0024; // autoscale=1, freq=01, grad & amp, freewheel=00 +} + +__attribute__((weak)) +void TMC2240Stepper::setSPISpeed(uint32_t speed) { + spi_speed = speed; +} + +__attribute__((weak)) +void TMC2240Stepper::switchCSpin(bool state) { + digitalWrite(_pinCS, state); +} + +__attribute__((weak)) +void TMC2240Stepper::beginTransaction() { + if (TMC_SW_SPI == nullptr) { + SPI.beginTransaction(SPISettings(spi_speed, MSBFIRST, SPI_MODE3)); + } +} +__attribute__((weak)) +void TMC2240Stepper::endTransaction() { + if (TMC_SW_SPI == nullptr) { + SPI.endTransaction(); + } +} + +__attribute__((weak)) +uint8_t TMC2240Stepper::transfer(const uint8_t data) { + uint8_t out = 0; + if (TMC_SW_SPI != nullptr) { + out = TMC_SW_SPI->transfer(data); + } + else { + out = SPI.transfer(data); + } + return out; +} + +void TMC2240Stepper::transferEmptyBytes(const uint8_t n) { + for (uint8_t i = 0; i < n; i++) { + transfer(0x00); + } +} + +__attribute__((weak)) +uint32_t TMC2240Stepper::read(uint8_t addressByte) { + uint32_t out = 0UL; + int8_t i = 1; + + beginTransaction(); + switchCSpin(LOW); + transfer(addressByte); + // Clear SPI + transferEmptyBytes(4); + + // Shift the written data to the correct driver in chain + // Default link_index = -1 and no shifting happens + while(i < link_index) { + transferEmptyBytes(5); + i++; + } + + switchCSpin(HIGH); + switchCSpin(LOW); + + // Shift data from target link into the last one... + while(i < chain_length) { + transferEmptyBytes(5); + i++; + } + + // ...and once more to MCU + status_response = transfer(addressByte); // Send the address byte again + out = transfer(0x00); + out <<= 8; + out |= transfer(0x00); + out <<= 8; + out |= transfer(0x00); + out <<= 8; + out |= transfer(0x00); + + endTransaction(); + switchCSpin(HIGH); + return out; +} + +__attribute__((weak)) +void TMC2240Stepper::write(uint8_t addressByte, uint32_t config) { + addressByte |= TMC_WRITE; + int8_t i = 1; + + beginTransaction(); + switchCSpin(LOW); + status_response = transfer(addressByte); + transfer(config>>24); + transfer(config>>16); + transfer(config>>8); + transfer(config); + + // Shift the written data to the correct driver in chain + // Default link_index = -1 and no shifting happens + while (i < link_index) { + transferEmptyBytes(5); + i++; + } + + endTransaction(); + switchCSpin(HIGH); +} + +void TMC2240Stepper::begin() { + // set pins + pinMode(_pinCS, OUTPUT); + switchCSpin(HIGH); + + if (TMC_SW_SPI != nullptr) TMC_SW_SPI->init(); + + //GCONF(GCONF_register.sr); + //CHOPCONF(CHOPCONF_register.sr); + //PWMCONF(PWMCONF_register.sr); + //IHOLD_IRUN(IHOLD_IRUN_register.sr); + + //toff(8); //off_time(8); + //tbl(1); //blank_time(24); +} + +void TMC2240Stepper::push() { + TPOWERDOWN(TPOWERDOWN_register.sr); + TPWMTHRS(TPWMTHRS_register.sr); + GCONF(GCONF_register.sr); + SLAVECONF(SLAVECONF_register.sr); + DRV_CONF(DRV_CONF_register.sr); + IHOLD_IRUN(IHOLD_IRUN_register.sr); + CHOPCONF(CHOPCONF_register.sr); + PWMCONF(PWMCONF_register.sr); +} + +bool TMC2240Stepper::isEnabled() { return !drv_enn() && toff(); } + +uint8_t TMC2240Stepper::IFCNT() { + return read(IFCNT_t::address); +} + +uint32_t TMC2240Stepper::PWM_SCALE() { + return read(TMC2240_n::PWM_SCALE_t::address); +} +uint8_t TMC2240Stepper::pwm_scale_sum() { + TMC2240_n::PWM_SCALE_t r{0}; + r.sr = PWM_SCALE(); + return r.pwm_scale_sum; +} + +int16_t TMC2240Stepper::pwm_scale_auto() { + TMC2240_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 TMC2240Stepper::PWM_AUTO() { + return read(PWM_AUTO_t::address); +} +uint8_t TMC2240Stepper::pwm_ofs_auto() { PWM_AUTO_t r{0}; r.sr = PWM_AUTO(); return r.pwm_ofs_auto; } +uint8_t TMC2240Stepper::pwm_grad_auto() { PWM_AUTO_t r{0}; r.sr = PWM_AUTO(); return r.pwm_grad_auto; } + +/** + * 0:1A 1:2A 2:3A 3:3A + */ +//#define TMC2240_CURRENT_RANGE 2 + +/** + * ('rref', 12000, minval=12000, maxval=60000) + */ +//#define TMC2240_Rref 12000 + +/* + 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 +*/ + +uint16_t TMC2240Stepper::cs2rms(uint8_t CS) { + float IFS_current_RMS = calc_IFS_current_RMS(); + uint32_t globalscaler = GLOBAL_SCALER(); + return (float)(CS+0.5)*(globalscaler * IFS_current_RMS)/256/32*1000; +} + + +float TMC2240Stepper::calc_IFS_current_RMS() { + uint32_t Kifs_values[] = {11750,24000,36000,36000}; + uint32_t Kifs = Kifs_values[DRV_CONF_register.current_range]; + return ((float)Kifs /Rref) /1.414; +} + +uint32_t TMC2240Stepper::set_globalscaler(float current, float IFS_current_RMS) { + uint32_t globalscaler = ((current * 256) / IFS_current_RMS) + 0.5; + + if (globalscaler < 32) globalscaler = 32; + if (globalscaler >= 256) globalscaler = 0; + GLOBAL_SCALER(globalscaler); + return globalscaler; +} + +void TMC2240Stepper::rms_current(uint16_t mA) { + float IFS_current_RMS = calc_IFS_current_RMS(); + float mA_float = (float)mA / 1000; + uint32_t globalscaler = set_globalscaler(mA_float, IFS_current_RMS); + int32_t CS = mA_float * globalscaler/256.0 * IFS_current_RMS * 32 - 1 + 0.5; + if (CS > 31) CS = 31; + if (CS < 0) CS = 0; + irun(CS); + ihold(CS*holdMultiplier); +} + +void TMC2240Stepper::rms_current(uint16_t mA, float mult) { + holdMultiplier = mult; + rms_current(mA); +} + +uint16_t TMC2240Stepper::rms_current() { + return cs2rms(irun()); +} + +void TMC2240Stepper::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 0: mres(8); break; + default: break; + } +} + +uint16_t TMC2240Stepper::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 0; + } + return 0; +} + +// R+C: GSTAT +uint8_t TMC2240Stepper::GSTAT() { return read(TMC2240_n::GSTAT_t::address); } +void TMC2240Stepper::GSTAT(uint8_t) { write(TMC2240_n::GSTAT_t::address, 0b111); } +bool TMC2240Stepper::reset() { TMC2240_n::GSTAT_t r; r.sr = GSTAT(); return r.reset; } +bool TMC2240Stepper::drv_err() { TMC2240_n::GSTAT_t r; r.sr = GSTAT(); return r.drv_err; } +bool TMC2240Stepper::uv_cp() { TMC2240_n::GSTAT_t r; r.sr = GSTAT(); return r.uv_cp; } +bool TMC2240Stepper::register_reset() { TMC2240_n::GSTAT_t r; r.sr = GSTAT(); return r.register_reset; } +bool TMC2240Stepper::vm_uvlo() { TMC2240_n::GSTAT_t r; r.sr = GSTAT(); return r.vm_uvlo; } + + +uint8_t TMC2240Stepper::test_connection() { + uint32_t drv_status = DRV_STATUS(); + switch (drv_status) { + case 0xFFFFFFFF: return 1; + case 0: return 2; + default: return 0; + } +} + +// W: TPOWERDOWN +uint8_t TMC2240Stepper::TPOWERDOWN() { return TPOWERDOWN_register.sr; } +void TMC2240Stepper::TPOWERDOWN(uint8_t input) { + TPOWERDOWN_register.sr = input; + write(TPOWERDOWN_register.address, TPOWERDOWN_register.sr); +} + +// W: TPWMTHRS +uint32_t TMC2240Stepper::TPWMTHRS() { return TPWMTHRS_register.sr; } +void TMC2240Stepper::TPWMTHRS(uint32_t input) { + TPWMTHRS_register.sr = input; + write(TPWMTHRS_register.address, TPWMTHRS_register.sr); +} + +void TMC2240Stepper::hysteresis_end(int8_t value) { hend(value+3); } +int8_t TMC2240Stepper::hysteresis_end() { return hend() - 3; }; + +void TMC2240Stepper::hysteresis_start(uint8_t value) { hstrt(value-1); } +uint8_t TMC2240Stepper::hysteresis_start() { return hstrt() + 1; } + +// W: TCOOLTHRS +uint32_t TMC2240Stepper::TCOOLTHRS() { return TCOOLTHRS_register.sr; } +void TMC2240Stepper::TCOOLTHRS(uint32_t input) { + TCOOLTHRS_register.sr = input; + write(TCOOLTHRS_register.address, TCOOLTHRS_register.sr); +} +/////////////////////////////////////////////////////////////////////////////////////// +// W: THIGH +uint32_t TMC2240Stepper::THIGH() { return THIGH_register.sr; } +void TMC2240Stepper::THIGH(uint32_t input) { + THIGH_register.sr = input; + write(THIGH_register.address, THIGH_register.sr); +} diff --git a/src/source/TMC2240_bitfields.h b/src/source/TMC2240_bitfields.h new file mode 100644 index 00000000..50ff400b --- /dev/null +++ b/src/source/TMC2240_bitfields.h @@ -0,0 +1,298 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2240_bitfields.h + * + * TMC2240 hardware register bit fields: + * CHOPCONF, DEVCONF, COOLCONF, PWMCONF + * IHOLD_IRUN + * TPOWERDOWN, TPWMTHRS, TCOOLTHRS + * SG4_THRS + * GCONF, GSTAT + */ +#pragma once +#pragma pack(push, 1) + +namespace TMC2240_n { + struct GCONF_t { + constexpr static uint8_t address = 0x00; + union { + uint16_t sr : 16; + struct { + bool : 1, + fast_standstill : 1, + en_pwm_mode : 1, + multistep_filt : 1, + shaft : 1, + diag0_error : 1, + diag0_otpw : 1, + diag0_stall : 1, + diag1_stall : 1, + diag1_index : 1, + diag1_onstate : 1, + diag0_pushpull : 1, + diag1_pushpull : 1, + small_hysteresis : 1, + stop_enable : 1, + direct_mode : 1; + }; + }; + }; + + struct GSTAT_t { + constexpr static uint8_t address = 0x01; + union { + uint8_t sr : 8; + struct { + bool reset : 1, + drv_err : 1, + uv_cp : 1, + register_reset : 1, + vm_uvlo : 1; + }; + }; + }; + + struct TPOWERDOWN_t { + constexpr static uint8_t address = 0x11; + union { + uint32_t sr; + struct { + uint16_t TPOWERDOWN : 8; + }; + }; + }; + + struct SLAVECONF_t { + constexpr static uint8_t address = 0x03; + union { + uint16_t sr : 12; + struct { + uint16_t slaveaddr : 8; + uint8_t senddelay : 4; + }; + }; + }; + + struct IOIN_t { + constexpr static uint8_t address = 0x04; + union { + uint32_t sr; + struct { + bool step : 1, + dir : 1, + encb : 1, + enca : 1, + drv_enn : 1, + encn : 1, + uart_en : 1, + : 1, + comp_a : 1, + comp_b : 1, + comp_a1_a2 : 1, + comp_b1_b2 : 1, + output : 1, + ext_res_det : 1, + ext_clk : 1, + adc_err : 1; + uint8_t silicon_rv : 3, + : 5, + version : 8; + }; + }; + }; + + struct DRV_CONF_t { + constexpr static uint8_t address = 0x0A; + union { + uint32_t sr; + struct { + uint8_t current_range : 2, + : 2, + slope_control : 2; + uint16_t : 16; + }; + }; + }; + + struct DRV_STATUS_t { + constexpr static uint8_t address = 0x6F; + union { + uint32_t sr; + struct { + uint16_t SG_RESULT : 10; + uint8_t : 2; + uint8_t s2vsa : 1, + s2vsb : 1, + stealth : 1, + fsactive : 1; + uint16_t CS_ACTUAL : 5; + uint8_t : 3; + bool stallguard : 1, + ot : 1, + otpw : 1, + s2ga : 1, + s2gb : 1, + ola : 1, + olb : 1, + stst : 1; + }; + }; + }; + + struct GLOBAL_SCALER_t { + constexpr static uint8_t address = 0xB; + union { + uint8_t sr; + struct { + uint8_t GLOBALSCALER : 8; + }; + }; + }; + + struct IHOLD_IRUN_t { + constexpr static uint8_t address = 0x10; + union { + uint32_t sr; + struct { + uint8_t ihold : 5, + : 3, + irun : 5, + : 3, + iholddelay : 4, + : 4, + irundelay : 4; + }; + }; + }; + + struct TSTEP { + constexpr static uint8_t address = 0x12; + union { + uint32_t sr; + struct { + uint32_t tstep : 20; + }; + }; + }; + + struct TPWMTHRS { + constexpr static uint8_t address = 0x13; + union { + uint32_t sr; + struct { + uint32_t tpwmthrs : 20; + }; + }; + }; + + struct TCOOLTHRS { + constexpr static uint8_t address = 0x14; + union { + uint32_t sr; + struct { + uint32_t tcoolthrs : 20; + }; + }; + }; + + struct THIGH { + constexpr static uint8_t address = 0x15; + union { + uint32_t sr; + struct { + uint32_t thigh : 20; + }; + }; + }; + + struct CHOPCONF_t { + constexpr static uint8_t address = 0x6C; + union { + uint32_t sr; + struct { + uint8_t toff : 4, + hstrt : 3, + hend : 4; + bool fd3 : 1, + disfdcc : 1, + : 1, + chm : 1; + uint8_t TBL : 2; + bool : 1, + vhighfs : 1, + vhighchm : 1; + uint8_t tpfd : 4, + mres : 4; + bool intpol : 1, + dedge : 1, + diss2g : 1, + diss2vs : 1; + }; + }; + }; + + struct COOLCONF_t { + constexpr static uint8_t address = 0x6D; + union { + uint16_t sr; + struct { + uint8_t semin : 4; + bool : 1; + uint8_t seup : 2; + bool : 1; + uint8_t semax : 4; + bool : 1; + uint8_t sedn : 2; + bool seimin : 1; + int8_t sgt : 7, + : 1; + bool sfilt : 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; + bool pwm_meas_sd_enable : 1, + pwm_dis_reg_stst : 1; + uint8_t pwm_reg : 4, + pwm_lim : 4; + }; + }; + }; + + struct PWM_SCALE_t { + constexpr static uint8_t address = 0x71; + union { + uint32_t sr; + struct { + uint16_t pwm_scale_sum : 10; + uint8_t : 6; + int16_t pwm_scale_auto : 9; + }; + }; + }; + + 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; + }; + }; + }; +} + +#pragma pack(pop) diff --git a/src/source/TMC2660Stepper.cpp b/src/source/TMC2660Stepper.cpp index 316f7fa8..f2a6bd9e 100644 --- a/src/source/TMC2660Stepper.cpp +++ b/src/source/TMC2660Stepper.cpp @@ -1,3 +1,7 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2660Stepper.cpp + */ #include "TMCStepper.h" #include "SW_SPI.h" diff --git a/src/source/TMC2660_bitfields.h b/src/source/TMC2660_bitfields.h index 18bb33da..02e86f03 100644 --- a/src/source/TMC2660_bitfields.h +++ b/src/source/TMC2660_bitfields.h @@ -1,3 +1,13 @@ +/** + * TMCStepper library by @teemuatlut + * TMC2660_bitfields.h + * + * TMC2660 hardware register bit fields: + * DRVCTRL_1, DRVCTRL_0 + * SMARTEN + * CHOPCONF, SGCSCONF, DRVCONF + * READ_RDSEL00, READ_RDSEL01, READ_RDSEL10 + */ #pragma once #pragma pack(push, 1) diff --git a/src/source/TMC5130Stepper.cpp b/src/source/TMC5130Stepper.cpp index efc95bef..3a8cb5f0 100644 --- a/src/source/TMC5130Stepper.cpp +++ b/src/source/TMC5130Stepper.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * TMC5130Stepper.cpp + * Implementing methods for TMC5130 (TMC5160, TMC5161) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" @@ -73,27 +78,6 @@ void TMC5130Stepper::push() { // R: IFCNT uint8_t TMC5130Stepper::IFCNT() { return read(IFCNT_t::address); } /////////////////////////////////////////////////////////////////////////////////////// -// W: SLAVECONF -uint16_t TMC5130Stepper::SLAVECONF() { return SLAVECONF_register.sr; } -void TMC5130Stepper::SLAVECONF(uint16_t input) { - SLAVECONF_register.sr = input; - write(SLAVECONF_register.address, SLAVECONF_register.sr); -} -/////////////////////////////////////////////////////////////////////////////////////// -// R: IOIN -uint32_t TMC5130Stepper::IOIN() { - return read(TMC5130_n::IOIN_t::address); -} -bool TMC5130Stepper::refl_step() { TMC5130_n::IOIN_t r{0}; r.sr = IOIN(); return r.refl_step; } -bool TMC5130Stepper::refr_dir() { TMC5130_n::IOIN_t r{0}; r.sr = IOIN(); return r.refr_dir; } -bool TMC5130Stepper::encb_dcen_cfg4() { TMC5130_n::IOIN_t r{0}; r.sr = IOIN(); return r.encb_dcen_cfg4; } -bool TMC5130Stepper::enca_dcin_cfg5() { TMC5130_n::IOIN_t r{0}; r.sr = IOIN(); return r.enca_dcin_cfg5; } -bool TMC5130Stepper::drv_enn_cfg6() { TMC5130_n::IOIN_t r{0}; r.sr = IOIN(); return r.drv_enn_cfg6; } -bool TMC5130Stepper::enc_n_dco() { TMC5130_n::IOIN_t r{0}; r.sr = IOIN(); return r.enc_n_dco; } -bool TMC5130Stepper::sd_mode() { TMC5130_n::IOIN_t r{0}; r.sr = IOIN(); return r.sd_mode; } -bool TMC5130Stepper::swcomp_in() { TMC5130_n::IOIN_t r{0}; r.sr = IOIN(); return r.swcomp_in; } -uint8_t TMC5130Stepper::version() { TMC5130_n::IOIN_t r{0}; r.sr = IOIN(); return r.version; } -/////////////////////////////////////////////////////////////////////////////////////// // W: OUTPUT bool TMC5130Stepper::TMC_OUTPUT() { return OUTPUT_register.sr; } void TMC5130Stepper::TMC_OUTPUT(bool input) { diff --git a/src/source/TMC5130_bitfields.h b/src/source/TMC5130_bitfields.h index a70e37fa..333859d7 100644 --- a/src/source/TMC5130_bitfields.h +++ b/src/source/TMC5130_bitfields.h @@ -1,3 +1,26 @@ +/** + * TMCStepper library by @teemuatlut + * TMC5130_bitfields.h + * + * Inherits from TMC2160 < TMC2130. + * + * Overriding TMC2130, TMC2160: + * IOIN + * + * TMC5130 (TMC5160, TMC5161) hardware registers: + * SLAVECONF + * OUTPUT + * X_COMPARE + * RAMPMODE, RAMP_STAT + * XACTUAL + * VSTART, VSTOP + * A1, V1, D1 + * AMAX, VMAX, DMAX + * TZEROWAIT + * SW_MODE + * ENCMODE, ENC_CONST + * MSLUT0 .. MSLUT7, MSLUTSEL, MSLUTSTART + */ #pragma once #pragma pack(push, 1) diff --git a/src/source/TMC5160Stepper.cpp b/src/source/TMC5160Stepper.cpp index d9b4221b..4a8525c4 100644 --- a/src/source/TMC5160Stepper.cpp +++ b/src/source/TMC5160Stepper.cpp @@ -1,3 +1,8 @@ +/** + * TMCStepper library by @teemuatlut + * TMC5160Stepper.cpp + * Implementing methods for TMC5160 (TMC5161) + */ #include "TMCStepper.h" #include "TMC_MACROS.h" diff --git a/src/source/TMC5160_bitfields.h b/src/source/TMC5160_bitfields.h index d2581cc4..2621a85a 100644 --- a/src/source/TMC5160_bitfields.h +++ b/src/source/TMC5160_bitfields.h @@ -1,3 +1,17 @@ +/** + * TMCStepper library by @teemuatlut + * TMC5130_bitfields.h + * + * Inherits from TMC5130 < TMC2160 < TMC2130. + * + * TMC5160 hardware registers: + * SHORT_CONF + * DRV_CONF + * GLOBAL_SCALER + * OFFSET_READ + * ENC_DEVIATION + * PWM_AUTO + */ #pragma once #pragma pack(push, 1) diff --git a/src/source/TMCStepper.cpp b/src/source/TMCStepper.cpp index 7e70c54c..963553a8 100644 --- a/src/source/TMCStepper.cpp +++ b/src/source/TMCStepper.cpp @@ -1,3 +1,23 @@ +/** + * TMCStepper library by @teemuatlut + * TMCStepper.cpp - TMCStepper Class + * Implementing methods for most TMCStepper + * Inherited by TMC2130, TMC2160, TMC5130, TMC5160, TMC5161, TMC2208, TMC2209, TMC2224 + * + * cs2rms + * rms_current + * test_connection + * hysteresis_end, hysteresis_start + * microsteps + * blank_time + * GSTAT + * reset + * drv_err + * uv_cp + * TPOWERDOWN, TSTEP, TPWMTHRS + * MSCNT, MSCURACT + * cur_a, cur_b + */ #include "TMCStepper.h" #include "TMC_MACROS.h" diff --git a/src/source/TMC_MACROS.h b/src/source/TMC_MACROS.h index 1b2bd6d4..e9071ecf 100644 --- a/src/source/TMC_MACROS.h +++ b/src/source/TMC_MACROS.h @@ -1,3 +1,7 @@ +/** + * TMCStepper library by @teemuatlut + * TMC_MACROS.h + */ #pragma once #define DEBUG_PRINT(CFG, VAL) Serial.print(CFG); Serial.print('('); Serial.print(VAL, HEX); Serial.println(')') diff --git a/src/source/TMC_platforms.h b/src/source/TMC_platforms.h index db633763..483e4908 100644 --- a/src/source/TMC_platforms.h +++ b/src/source/TMC_platforms.h @@ -1,4 +1,10 @@ -#if defined(ARDUINO_ARCH_AVR) // 125kHz +/** + * TMCStepper library by @teemuatlut + * TMC_platforms.h + * + * Define SPI accessors for AVR, DUE (700kHz), LPC1768, STM32, DUE (116kHz) + */ +#ifdef ARDUINO_ARCH_AVR // 125kHz typedef volatile uint8_t* fastio_reg; typedef uint8_t fastio_bm; #define getPort(P) digitalPinToPort(P) diff --git a/src/source/bcm2835_spi.cpp b/src/source/bcm2835_spi.cpp index d155f40e..24a2702e 100644 --- a/src/source/bcm2835_spi.cpp +++ b/src/source/bcm2835_spi.cpp @@ -1,4 +1,7 @@ -#if defined(bcm2835) +/** + * BCM2835 SPI for Arduino on Raspberry Pi + */ +#ifdef bcm2835 #include "bcm2835_spi.h" @@ -30,4 +33,4 @@ SPISettings::SPISettings(uint32_t s, bcm2835SPIBitOrder o, bcm2835SPIMode m) mode = m; } -#endif \ No newline at end of file +#endif // bcm2835 diff --git a/src/source/bcm2835_spi.h b/src/source/bcm2835_spi.h index a3a690c5..6945ec7d 100644 --- a/src/source/bcm2835_spi.h +++ b/src/source/bcm2835_spi.h @@ -1,7 +1,8 @@ +/** + * BCM2835 SPI for Arduino on Raspberry Pi + */ #pragma once -#if defined(bcm2835) - #include #include #include @@ -33,4 +34,3 @@ struct SPISettings }; extern SPIClass SPI; -#endif \ No newline at end of file diff --git a/src/source/bcm2835_stream.cpp b/src/source/bcm2835_stream.cpp index a8d0fcce..d12e9d10 100644 --- a/src/source/bcm2835_stream.cpp +++ b/src/source/bcm2835_stream.cpp @@ -1,4 +1,8 @@ -#if defined(bcm2835) +/** + * BCM2835 Serial Stream for Arduino on Raspberry Pi + */ +#ifdef bcm2835 + #include #include #include @@ -21,7 +25,7 @@ Stream::Stream(const char* port) void Stream::begin(unsigned long baud, int flags) { - struct termios options; + termios options{}; fd = open(port, flags); if (fd == -1) { @@ -30,6 +34,7 @@ void Stream::begin(unsigned long baud, int flags) } fcntl(fd, F_SETFL, O_RDWR); + #if 1 speed_t myBaud; switch ( baud ) @@ -51,8 +56,6 @@ void Stream::begin(unsigned long baud, int flags) return; } - termios options{}; - tcgetattr(fd, &options); cfmakeraw( &options ); @@ -86,6 +89,23 @@ void Stream::begin(unsigned long baud, int flags) options.c_cc[ VTIME ] = 10; // VTIME defined as tenths of a second so 100 is actually 10 seconds; and 10 deciseconds is 1 second. tcflush(fd, TCIOFLUSH); // flush both tx and rx + + #else + + // Use 8 data bit, no parity and 1 stop bit + tcgetattr(fd, &options); + options.c_cflag = CS8 | CLOCAL | CREAD | CBAUDEX; + options.c_cflag &= ~CBAUD; // use the extended baud + options.c_cflag &= ~PARENB; // no parity + options.c_cflag &= ~CSTOPB; // 1 stop bit + options.c_iflag = IGNPAR; + options.c_oflag = baud; + options.c_lflag = baud; + + tcflush(fd, TCIFLUSH); + + #endif + tcsetattr(fd, TCSANOW, &options); // Maybe add 10ms delay (belt and braces) to let UART setup correctly @@ -122,4 +142,4 @@ uint8_t Stream::read() Stream Serial("/dev/serial0"); Stream Serial1("/dev/serial1"); -#endif +#endif // bcm2835 diff --git a/src/source/bcm2835_stream.h b/src/source/bcm2835_stream.h index c13d9913..91e7a86b 100644 --- a/src/source/bcm2835_stream.h +++ b/src/source/bcm2835_stream.h @@ -1,5 +1,7 @@ +/** + * BCM2835 Serial Stream for Arduino on Raspberry Pi + */ #pragma once -#if defined(bcm2835) #include #include @@ -30,4 +32,3 @@ class Stream extern Stream Serial; extern Stream Serial1; -#endif diff --git a/src/source/rpi_bcm2835.h b/src/source/rpi_bcm2835.h index 508cf231..68e3dcff 100644 --- a/src/source/rpi_bcm2835.h +++ b/src/source/rpi_bcm2835.h @@ -1,3 +1,6 @@ +/** + * BCM2835 for Arduino on Raspberry Pi + */ #pragma once #include #include