tmc2130.cpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644
  1. #include "Marlin.h"
  2. #ifdef TMC2130
  3. #include "tmc2130.h"
  4. #include <SPI.h>
  5. #include "LiquidCrystal.h"
  6. #include "ultralcd.h"
  7. extern LiquidCrystal lcd;
  8. #define TMC2130_GCONF_NORMAL 0x00000000 // spreadCycle
  9. #define TMC2130_GCONF_SGSENS 0x00003180 // spreadCycle with stallguard (stall activates DIAG0 and DIAG1 [pushpull])
  10. #define TMC2130_GCONF_SILENT 0x00000004 // stealthChop
  11. //externals for debuging
  12. extern float current_position[4];
  13. extern void st_get_position_xy(long &x, long &y);
  14. extern long st_get_position(uint8_t axis);
  15. extern void crashdet_stop_and_save_print();
  16. extern void crashdet_stop_and_save_print2();
  17. //chipselect pins
  18. uint8_t tmc2130_cs[4] = { X_TMC2130_CS, Y_TMC2130_CS, Z_TMC2130_CS, E0_TMC2130_CS };
  19. //mode
  20. uint8_t tmc2130_mode = TMC2130_MODE_NORMAL;
  21. //holding currents
  22. uint8_t tmc2130_current_h[4] = TMC2130_CURRENTS_H;
  23. //running currents
  24. uint8_t tmc2130_current_r[4] = TMC2130_CURRENTS_R;
  25. //running currents for homing
  26. uint8_t tmc2130_current_r_home[4] = {10, 10, 20, 10};
  27. //pwm_ampl
  28. uint8_t tmc2130_pwm_ampl[2] = {TMC2130_PWM_AMPL_X, TMC2130_PWM_AMPL_Y};
  29. //pwm_grad
  30. uint8_t tmc2130_pwm_grad[2] = {TMC2130_PWM_GRAD_X, TMC2130_PWM_GRAD_Y};
  31. //pwm_auto
  32. uint8_t tmc2130_pwm_auto[2] = {TMC2130_PWM_AUTO_X, TMC2130_PWM_AUTO_Y};
  33. //pwm_freq
  34. uint8_t tmc2130_pwm_freq[2] = {TMC2130_PWM_FREQ_X, TMC2130_PWM_FREQ_Y};
  35. uint8_t tmc2130_mres[4] = {0, 0, 0, 0}; //will be filed at begin of init
  36. uint8_t tmc2130_sg_thr[4] = {TMC2130_SG_THRS_X, TMC2130_SG_THRS_Y, TMC2130_SG_THRS_Z, TMC2130_SG_THRS_E};
  37. uint8_t tmc2130_sg_thr_home[4] = {3, 3, TMC2130_SG_THRS_Z, TMC2130_SG_THRS_E};
  38. uint8_t sg_homing_axes_mask = 0x00;
  39. uint8_t tmc2130_sg_meassure = 0xff;
  40. uint16_t tmc2130_sg_meassure_cnt = 0;
  41. uint32_t tmc2130_sg_meassure_val = 0;
  42. bool tmc2130_sg_stop_on_crash = true;
  43. uint8_t tmc2130_sg_diag_mask = 0x00;
  44. bool tmc2130_sg_crash = false;
  45. uint16_t tmc2130_sg_err[4] = {0, 0, 0, 0};
  46. uint16_t tmc2130_sg_cnt[4] = {0, 0, 0, 0};
  47. bool tmc2130_sg_change = false;
  48. bool skip_debug_msg = false;
  49. #define DBG(args...) printf_P(args)
  50. #define _n PSTR
  51. #define _i PSTR
  52. //TMC2130 registers
  53. #define TMC2130_REG_GCONF 0x00 // 17 bits
  54. #define TMC2130_REG_GSTAT 0x01 // 3 bits
  55. #define TMC2130_REG_IOIN 0x04 // 8+8 bits
  56. #define TMC2130_REG_IHOLD_IRUN 0x10 // 5+5+4 bits
  57. #define TMC2130_REG_TPOWERDOWN 0x11 // 8 bits
  58. #define TMC2130_REG_TSTEP 0x12 // 20 bits
  59. #define TMC2130_REG_TPWMTHRS 0x13 // 20 bits
  60. #define TMC2130_REG_TCOOLTHRS 0x14 // 20 bits
  61. #define TMC2130_REG_THIGH 0x15 // 20 bits
  62. #define TMC2130_REG_XDIRECT 0x2d // 32 bits
  63. #define TMC2130_REG_VDCMIN 0x33 // 23 bits
  64. #define TMC2130_REG_MSLUT0 0x60 // 32 bits
  65. #define TMC2130_REG_MSLUT1 0x61 // 32 bits
  66. #define TMC2130_REG_MSLUT2 0x62 // 32 bits
  67. #define TMC2130_REG_MSLUT3 0x63 // 32 bits
  68. #define TMC2130_REG_MSLUT4 0x64 // 32 bits
  69. #define TMC2130_REG_MSLUT5 0x65 // 32 bits
  70. #define TMC2130_REG_MSLUT6 0x66 // 32 bits
  71. #define TMC2130_REG_MSLUT7 0x67 // 32 bits
  72. #define TMC2130_REG_MSLUTSEL 0x68 // 32 bits
  73. #define TMC2130_REG_MSLUTSTART 0x69 // 8+8 bits
  74. #define TMC2130_REG_MSCNT 0x6a // 10 bits
  75. #define TMC2130_REG_MSCURACT 0x6b // 9+9 bits
  76. #define TMC2130_REG_CHOPCONF 0x6c // 32 bits
  77. #define TMC2130_REG_COOLCONF 0x6d // 25 bits
  78. #define TMC2130_REG_DCCTRL 0x6e // 24 bits
  79. #define TMC2130_REG_DRV_STATUS 0x6f // 32 bits
  80. #define TMC2130_REG_PWMCONF 0x70 // 22 bits
  81. #define TMC2130_REG_PWM_SCALE 0x71 // 8 bits
  82. #define TMC2130_REG_ENCM_CTRL 0x72 // 2 bits
  83. #define TMC2130_REG_LOST_STEPS 0x73 // 20 bits
  84. uint16_t tmc2130_rd_TSTEP(uint8_t cs);
  85. uint16_t tmc2130_rd_MSCNT(uint8_t cs);
  86. uint16_t tmc2130_rd_DRV_STATUS(uint8_t cs);
  87. void tmc2130_wr_CHOPCONF(uint8_t cs, uint8_t toff = 3, uint8_t hstrt = 4, uint8_t hend = 1, uint8_t fd3 = 0, uint8_t disfdcc = 0, uint8_t rndtf = 0, uint8_t chm = 0, uint8_t tbl = 2, uint8_t vsense = 0, uint8_t vhighfs = 0, uint8_t vhighchm = 0, uint8_t sync = 0, uint8_t mres = 0b0100, uint8_t intpol = 1, uint8_t dedge = 0, uint8_t diss2g = 0);
  88. void tmc2130_wr_PWMCONF(uint8_t cs, uint8_t pwm_ampl, uint8_t pwm_grad, uint8_t pwm_freq, uint8_t pwm_auto, uint8_t pwm_symm, uint8_t freewheel);
  89. void tmc2130_wr_TPWMTHRS(uint8_t cs, uint32_t val32);
  90. void tmc2130_wr_THIGH(uint8_t cs, uint32_t val32);
  91. uint8_t tmc2130_axis_by_cs(uint8_t cs);
  92. uint8_t tmc2130_calc_mres(uint16_t microstep_resolution);
  93. uint8_t tmc2130_wr(uint8_t cs, uint8_t addr, uint32_t wval);
  94. uint8_t tmc2130_rd(uint8_t cs, uint8_t addr, uint32_t* rval);
  95. uint8_t tmc2130_txrx(uint8_t cs, uint8_t addr, uint32_t wval, uint32_t* rval);
  96. void tmc2130_setup_chopper(uint8_t axis, uint8_t mres, uint8_t current_h, uint8_t current_r);
  97. void tmc2130_init()
  98. {
  99. DBG(_n("tmc2130_init(), mode=%S\n"), tmc2130_mode?_n("NORMAL"):_n("STEALTH"));
  100. tmc2130_mres[0] = tmc2130_calc_mres(TMC2130_USTEPS_XY);
  101. tmc2130_mres[1] = tmc2130_calc_mres(TMC2130_USTEPS_XY);
  102. tmc2130_mres[2] = tmc2130_calc_mres(TMC2130_USTEPS_Z);
  103. tmc2130_mres[3] = tmc2130_calc_mres(TMC2130_USTEPS_E);
  104. WRITE(X_TMC2130_CS, HIGH);
  105. WRITE(Y_TMC2130_CS, HIGH);
  106. WRITE(Z_TMC2130_CS, HIGH);
  107. WRITE(E0_TMC2130_CS, HIGH);
  108. SET_OUTPUT(X_TMC2130_CS);
  109. SET_OUTPUT(Y_TMC2130_CS);
  110. SET_OUTPUT(Z_TMC2130_CS);
  111. SET_OUTPUT(E0_TMC2130_CS);
  112. SET_INPUT(X_TMC2130_DIAG);
  113. SET_INPUT(Y_TMC2130_DIAG);
  114. SET_INPUT(Z_TMC2130_DIAG);
  115. SET_INPUT(E0_TMC2130_DIAG);
  116. SPI.begin();
  117. for (int axis = 0; axis < 2; axis++) // X Y axes
  118. {
  119. /* if (tmc2130_current_r[axis] <= 31)
  120. {
  121. tmc2130_wr_CHOPCONF(tmc2130_cs[axis], 3, 5, 1, 0, 0, 0, 0, 2, 1, 0, 0, 0, mres, TMC2130_INTPOL_XY, 0, 0);
  122. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_IHOLD_IRUN, 0x000f0000 | ((tmc2130_current_r[axis] & 0x1f) << 8) | (tmc2130_current_h[axis] & 0x1f));
  123. }
  124. else
  125. {
  126. tmc2130_wr_CHOPCONF(tmc2130_cs[axis], 3, 5, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, mres, TMC2130_INTPOL_XY, 0, 0);
  127. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_IHOLD_IRUN, 0x000f0000 | (((tmc2130_current_r[axis] >> 1) & 0x1f) << 8) | ((tmc2130_current_h[axis] >> 1) & 0x1f));
  128. }*/
  129. tmc2130_setup_chopper(axis, tmc2130_mres[axis], tmc2130_current_h[axis], tmc2130_current_r[axis]);
  130. // tmc2130_wr_CHOPCONF(tmc2130_cs[axis], 3, 5, 1, 0, 0, 0, 0, 2, 1, 0, 0, 0, mres, TMC2130_INTPOL_XY, 0, 0);
  131. // tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_IHOLD_IRUN, 0x000f0000 | ((tmc2130_current_r[axis] & 0x1f) << 8) | (tmc2130_current_h[axis] & 0x1f));
  132. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_TPOWERDOWN, 0x00000000);
  133. // tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_COOLCONF, (((uint32_t)tmc2130_sg_thr[axis]) << 16) | ((uint32_t)1 << 24));
  134. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_COOLCONF, (((uint32_t)tmc2130_sg_thr[axis]) << 16));
  135. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_TCOOLTHRS, (tmc2130_mode == TMC2130_MODE_SILENT)?0:((axis==X_AXIS)?TMC2130_TCOOLTHRS_X:TMC2130_TCOOLTHRS_Y));
  136. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_GCONF, (tmc2130_mode == TMC2130_MODE_SILENT)?TMC2130_GCONF_SILENT:TMC2130_GCONF_SGSENS);
  137. tmc2130_wr_PWMCONF(tmc2130_cs[axis], tmc2130_pwm_ampl[axis], tmc2130_pwm_grad[axis], tmc2130_pwm_freq[axis], tmc2130_pwm_auto[axis], 0, 0);
  138. tmc2130_wr_TPWMTHRS(tmc2130_cs[axis], TMC2130_TPWMTHRS);
  139. //tmc2130_wr_THIGH(tmc2130_cs[axis], TMC2130_THIGH);
  140. }
  141. for (int axis = 2; axis < 3; axis++) // Z axis
  142. {
  143. // uint8_t mres = tmc2130_mres(TMC2130_USTEPS_Z);
  144. /* if (tmc2130_current_r[axis] <= 31)
  145. {
  146. tmc2130_wr_CHOPCONF(tmc2130_cs[axis], 3, 5, 1, 0, 0, 0, 0, 2, 1, 0, 0, 0, mres, TMC2130_INTPOL_Z, 0, 0);
  147. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_IHOLD_IRUN, 0x000f0000 | ((tmc2130_current_r[axis] & 0x1f) << 8) | (tmc2130_current_h[axis] & 0x1f));
  148. }
  149. else
  150. {
  151. tmc2130_wr_CHOPCONF(tmc2130_cs[axis], 3, 5, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, mres, TMC2130_INTPOL_Z, 0, 0);
  152. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_IHOLD_IRUN, 0x000f0000 | (((tmc2130_current_r[axis] >> 1) & 0x1f) << 8) | ((tmc2130_current_h[axis] >> 1) & 0x1f));
  153. }*/
  154. tmc2130_setup_chopper(axis, tmc2130_mres[axis], tmc2130_current_h[axis], tmc2130_current_r[axis]);
  155. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_TPOWERDOWN, 0x00000000);
  156. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_GCONF, TMC2130_GCONF_SGSENS);
  157. }
  158. for (int axis = 3; axis < 4; axis++) // E axis
  159. {
  160. // uint8_t mres = tmc2130_mres(TMC2130_USTEPS_E);
  161. tmc2130_setup_chopper(axis, tmc2130_mres[axis], tmc2130_current_h[axis], tmc2130_current_r[axis]);
  162. // tmc2130_wr_CHOPCONF(tmc2130_cs[axis], 3, 5, 1, 0, 0, 0, 0, 2, 1, 0, 0, 0, mres, TMC2130_INTPOL_E, 0, 0);
  163. // tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_IHOLD_IRUN, 0x000f0000 | ((tmc2130_current_r[axis] & 0x1f) << 8) | (tmc2130_current_h[axis] & 0x1f));
  164. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_TPOWERDOWN, 0x00000000);
  165. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_GCONF, TMC2130_GCONF_SGSENS);
  166. }
  167. tmc2130_sg_err[0] = 0;
  168. tmc2130_sg_err[1] = 0;
  169. tmc2130_sg_err[2] = 0;
  170. tmc2130_sg_err[3] = 0;
  171. tmc2130_sg_cnt[0] = 0;
  172. tmc2130_sg_cnt[1] = 0;
  173. tmc2130_sg_cnt[2] = 0;
  174. tmc2130_sg_cnt[3] = 0;
  175. }
  176. uint8_t tmc2130_sample_diag()
  177. {
  178. uint8_t mask = 0;
  179. if (READ(X_TMC2130_DIAG)) mask |= X_AXIS_MASK;
  180. if (READ(Y_TMC2130_DIAG)) mask |= Y_AXIS_MASK;
  181. // if (READ(Z_TMC2130_DIAG)) mask |= Z_AXIS_MASK;
  182. // if (READ(E0_TMC2130_DIAG)) mask |= E_AXIS_MASK;
  183. return mask;
  184. }
  185. extern bool is_usb_printing;
  186. void tmc2130_st_isr(uint8_t last_step_mask)
  187. {
  188. if (tmc2130_mode == TMC2130_MODE_SILENT || tmc2130_sg_stop_on_crash == false) return;
  189. bool crash = false;
  190. uint8_t diag_mask = tmc2130_sample_diag();
  191. // for (uint8_t axis = X_AXIS; axis <= E_AXIS; axis++)
  192. for (uint8_t axis = X_AXIS; axis <= Z_AXIS; axis++)
  193. {
  194. uint8_t mask = (X_AXIS_MASK << axis);
  195. if (diag_mask & mask) tmc2130_sg_err[axis]++;
  196. else
  197. if (tmc2130_sg_err[axis] > 0) tmc2130_sg_err[axis]--;
  198. if (tmc2130_sg_cnt[axis] < tmc2130_sg_err[axis])
  199. {
  200. tmc2130_sg_cnt[axis] = tmc2130_sg_err[axis];
  201. tmc2130_sg_change = true;
  202. if (tmc2130_sg_err[axis] >= 64)
  203. {
  204. tmc2130_sg_err[axis] = 0;
  205. crash = true;
  206. }
  207. }
  208. }
  209. if (sg_homing_axes_mask == 0)
  210. {
  211. /* if (crash)
  212. {
  213. if (diag_mask & 0x01) tmc2130_sg_cnt[0]++;
  214. if (diag_mask & 0x02) tmc2130_sg_cnt[1]++;
  215. if (diag_mask & 0x04) tmc2130_sg_cnt[2]++;
  216. if (diag_mask & 0x08) tmc2130_sg_cnt[3]++;
  217. }*/
  218. if (/*!is_usb_printing && */tmc2130_sg_stop_on_crash && crash)
  219. {
  220. tmc2130_sg_crash = true;
  221. tmc2130_sg_stop_on_crash = false;
  222. crashdet_stop_and_save_print();
  223. }
  224. }
  225. }
  226. bool tmc2130_update_sg()
  227. {
  228. if (tmc2130_sg_meassure <= E_AXIS)
  229. {
  230. uint8_t cs = tmc2130_cs[tmc2130_sg_meassure];
  231. uint16_t sg = tmc2130_rd_DRV_STATUS(cs) & 0x3ff;
  232. tmc2130_sg_meassure_val += sg;
  233. tmc2130_sg_meassure_cnt++;
  234. // printf_P(PSTR("tmc2130_update_sg - meassure - sg=%d\n"), sg);
  235. return true;
  236. }
  237. return false;
  238. }
  239. void tmc2130_home_enter(uint8_t axes_mask)
  240. {
  241. // printf_P(PSTR("tmc2130_home_enter(axes_mask=0x%02x)\n"), axes_mask);
  242. #ifdef TMC2130_SG_HOMING
  243. for (uint8_t axis = X_AXIS; axis <= Z_AXIS; axis++) //X Y and Z axes
  244. {
  245. uint8_t mask = (X_AXIS_MASK << axis);
  246. uint8_t cs = tmc2130_cs[axis];
  247. if (axes_mask & mask)
  248. {
  249. sg_homing_axes_mask |= mask;
  250. //Configuration to spreadCycle
  251. tmc2130_wr(cs, TMC2130_REG_GCONF, TMC2130_GCONF_NORMAL);
  252. tmc2130_wr(cs, TMC2130_REG_COOLCONF, (((uint32_t)tmc2130_sg_thr_home[axis]) << 16));
  253. // tmc2130_wr(cs, TMC2130_REG_COOLCONF, (((uint32_t)tmc2130_sg_thr[axis]) << 16) | ((uint32_t)1 << 24));
  254. tmc2130_wr(cs, TMC2130_REG_TCOOLTHRS, (axis==X_AXIS)?TMC2130_TCOOLTHRS_X:TMC2130_TCOOLTHRS_Y);
  255. tmc2130_setup_chopper(axis, tmc2130_mres[axis], tmc2130_current_h[axis], tmc2130_current_r_home[axis]);
  256. if (mask & (X_AXIS_MASK | Y_AXIS_MASK | Z_AXIS_MASK))
  257. tmc2130_wr(cs, TMC2130_REG_GCONF, TMC2130_GCONF_SGSENS); //stallguard output DIAG1, DIAG1 = pushpull
  258. }
  259. }
  260. #endif //TMC2130_SG_HOMING
  261. }
  262. void tmc2130_home_exit()
  263. {
  264. // printf_P(PSTR("tmc2130_home_exit sg_homing_axes_mask=0x%02x\n"), sg_homing_axes_mask);
  265. #ifdef TMC2130_SG_HOMING
  266. if (sg_homing_axes_mask)
  267. {
  268. for (uint8_t axis = X_AXIS; axis <= Z_AXIS; axis++) //X Y and Z axes
  269. {
  270. uint8_t mask = (X_AXIS_MASK << axis);
  271. if (sg_homing_axes_mask & mask & (X_AXIS_MASK | Y_AXIS_MASK))
  272. {
  273. if (tmc2130_mode == TMC2130_MODE_SILENT)
  274. {
  275. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_GCONF, TMC2130_GCONF_SILENT); // Configuration back to stealthChop
  276. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_TCOOLTHRS, 0);
  277. // tmc2130_wr_PWMCONF(tmc2130_cs[i], tmc2130_pwm_ampl[i], tmc2130_pwm_grad[i], tmc2130_pwm_freq[i], tmc2130_pwm_auto[i], 0, 0);
  278. }
  279. else
  280. {
  281. // tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_GCONF, TMC2130_GCONF_NORMAL);
  282. tmc2130_setup_chopper(axis, tmc2130_mres[axis], tmc2130_current_h[axis], tmc2130_current_r[axis]);
  283. // tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_COOLCONF, (((uint32_t)tmc2130_sg_thr[axis]) << 16) | ((uint32_t)1 << 24));
  284. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_COOLCONF, (((uint32_t)tmc2130_sg_thr[axis]) << 16));
  285. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_TCOOLTHRS, (tmc2130_mode == TMC2130_MODE_SILENT)?0:((axis==X_AXIS)?TMC2130_TCOOLTHRS_X:TMC2130_TCOOLTHRS_Y));
  286. tmc2130_wr(tmc2130_cs[axis], TMC2130_REG_GCONF, TMC2130_GCONF_SGSENS);
  287. }
  288. }
  289. }
  290. sg_homing_axes_mask = 0x00;
  291. }
  292. tmc2130_sg_crash = false;
  293. #endif
  294. }
  295. void tmc2130_sg_meassure_start(uint8_t axis)
  296. {
  297. tmc2130_sg_meassure = axis;
  298. tmc2130_sg_meassure_cnt = 0;
  299. tmc2130_sg_meassure_val = 0;
  300. }
  301. uint16_t tmc2130_sg_meassure_stop()
  302. {
  303. tmc2130_sg_meassure = 0xff;
  304. return tmc2130_sg_meassure_val / tmc2130_sg_meassure_cnt;
  305. }
  306. bool tmc2130_wait_standstill_xy(int timeout)
  307. {
  308. // DBG(_n("tmc2130_wait_standstill_xy(timeout=%d)\n"), timeout);
  309. bool standstill = false;
  310. while (!standstill && (timeout > 0))
  311. {
  312. uint32_t drv_status_x = 0;
  313. uint32_t drv_status_y = 0;
  314. tmc2130_rd(tmc2130_cs[X_AXIS], TMC2130_REG_DRV_STATUS, &drv_status_x);
  315. tmc2130_rd(tmc2130_cs[Y_AXIS], TMC2130_REG_DRV_STATUS, &drv_status_y);
  316. // DBG(_n("\tdrv_status_x=0x%08x drv_status_x=0x%08x\n"), drv_status_x, drv_status_y);
  317. standstill = (drv_status_x & 0x80000000) && (drv_status_y & 0x80000000);
  318. tmc2130_check_overtemp();
  319. timeout--;
  320. }
  321. return standstill;
  322. }
  323. void tmc2130_check_overtemp()
  324. {
  325. const static char TMC_OVERTEMP_MSG[] PROGMEM = "TMC DRIVER OVERTEMP ";
  326. static uint32_t checktime = 0;
  327. if (millis() - checktime > 1000 )
  328. {
  329. for (int i = 0; i < 4; i++)
  330. {
  331. uint32_t drv_status = 0;
  332. skip_debug_msg = true;
  333. tmc2130_rd(tmc2130_cs[i], TMC2130_REG_DRV_STATUS, &drv_status);
  334. if (drv_status & ((uint32_t)1 << 26))
  335. { // BIT 26 - over temp prewarning ~120C (+-20C)
  336. SERIAL_ERRORRPGM(TMC_OVERTEMP_MSG);
  337. SERIAL_ECHOLN(i);
  338. for (int j = 0; j < 4; j++)
  339. tmc2130_wr(tmc2130_cs[j], TMC2130_REG_CHOPCONF, 0x00010000);
  340. kill(TMC_OVERTEMP_MSG);
  341. }
  342. }
  343. checktime = millis();
  344. tmc2130_sg_change = true;
  345. }
  346. #ifdef DEBUG_CRASHDET_COUNTERS
  347. if (tmc2130_sg_change)
  348. {
  349. for (int i = 0; i < 4; i++)
  350. {
  351. tmc2130_sg_change = false;
  352. lcd.setCursor(0 + i*4, 3);
  353. lcd.print(itostr3(tmc2130_sg_cnt[i]));
  354. lcd.print(' ');
  355. }
  356. }
  357. #endif DEBUG_CRASHDET_COUNTERS
  358. }
  359. void tmc2130_setup_chopper(uint8_t axis, uint8_t mres, uint8_t current_h, uint8_t current_r)
  360. {
  361. uint8_t cs = tmc2130_cs[axis];
  362. uint8_t intpol = 1;
  363. if (current_r <= 31)
  364. {
  365. tmc2130_wr_CHOPCONF(cs, 3, 5, 1, 0, 0, 0, 0, 2, 1, 0, 0, 0, mres, intpol, 0, 0);
  366. tmc2130_wr(cs, TMC2130_REG_IHOLD_IRUN, 0x000f0000 | ((current_r & 0x1f) << 8) | (current_h & 0x1f));
  367. }
  368. else
  369. {
  370. tmc2130_wr_CHOPCONF(cs, 3, 5, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, mres, intpol, 0, 0);
  371. tmc2130_wr(cs, TMC2130_REG_IHOLD_IRUN, 0x000f0000 | (((current_r >> 1) & 0x1f) << 8) | ((current_h >> 1) & 0x1f));
  372. }
  373. }
  374. void tmc2130_set_current_h(uint8_t axis, uint8_t current)
  375. {
  376. DBG(_n("tmc2130_set_current_h(axis=%d, current=%d\n"), axis, current);
  377. tmc2130_current_h[axis] = current;
  378. tmc2130_setup_chopper(axis, tmc2130_mres[axis], tmc2130_current_h[axis], tmc2130_current_r[axis]);
  379. }
  380. void tmc2130_set_current_r(uint8_t axis, uint8_t current)
  381. {
  382. DBG(_n("tmc2130_set_current_r(axis=%d, current=%d\n"), axis, current);
  383. tmc2130_current_r[axis] = current;
  384. tmc2130_setup_chopper(axis, tmc2130_mres[axis], tmc2130_current_h[axis], tmc2130_current_r[axis]);
  385. }
  386. void tmc2130_print_currents()
  387. {
  388. DBG(_n("tmc2130_print_currents()\n\tH\tR\nX\t%d\t%d\nY\t%d\t%d\nZ\t%d\t%d\nE\t%d\t%d\n"),
  389. tmc2130_current_h[0], tmc2130_current_r[0],
  390. tmc2130_current_h[1], tmc2130_current_r[1],
  391. tmc2130_current_h[2], tmc2130_current_r[2],
  392. tmc2130_current_h[3], tmc2130_current_r[3]
  393. );
  394. }
  395. void tmc2130_set_pwm_ampl(uint8_t axis, uint8_t pwm_ampl)
  396. {
  397. MYSERIAL.print("tmc2130_set_pwm_ampl ");
  398. MYSERIAL.print((int)axis);
  399. MYSERIAL.print(" ");
  400. MYSERIAL.println((int)pwm_ampl);
  401. tmc2130_pwm_ampl[axis] = pwm_ampl;
  402. if (((axis == 0) || (axis == 1)) && (tmc2130_mode == TMC2130_MODE_SILENT))
  403. tmc2130_wr_PWMCONF(tmc2130_cs[axis], tmc2130_pwm_ampl[axis], tmc2130_pwm_grad[axis], tmc2130_pwm_freq[axis], tmc2130_pwm_auto[axis], 0, 0);
  404. }
  405. void tmc2130_set_pwm_grad(uint8_t axis, uint8_t pwm_grad)
  406. {
  407. MYSERIAL.print("tmc2130_set_pwm_grad ");
  408. MYSERIAL.print((int)axis);
  409. MYSERIAL.print(" ");
  410. MYSERIAL.println((int)pwm_grad);
  411. tmc2130_pwm_grad[axis] = pwm_grad;
  412. if (((axis == 0) || (axis == 1)) && (tmc2130_mode == TMC2130_MODE_SILENT))
  413. tmc2130_wr_PWMCONF(tmc2130_cs[axis], tmc2130_pwm_ampl[axis], tmc2130_pwm_grad[axis], tmc2130_pwm_freq[axis], tmc2130_pwm_auto[axis], 0, 0);
  414. }
  415. uint16_t tmc2130_rd_TSTEP(uint8_t cs)
  416. {
  417. uint32_t val32 = 0;
  418. tmc2130_rd(cs, TMC2130_REG_TSTEP, &val32);
  419. if (val32 & 0x000f0000) return 0xffff;
  420. return val32 & 0xffff;
  421. }
  422. uint16_t tmc2130_rd_MSCNT(uint8_t cs)
  423. {
  424. uint32_t val32 = 0;
  425. tmc2130_rd(cs, TMC2130_REG_MSCNT, &val32);
  426. return val32 & 0x3ff;
  427. }
  428. uint16_t tmc2130_rd_DRV_STATUS(uint8_t cs)
  429. {
  430. uint32_t val32 = 0;
  431. tmc2130_rd(cs, TMC2130_REG_DRV_STATUS, &val32);
  432. return val32;
  433. }
  434. void tmc2130_wr_CHOPCONF(uint8_t cs, uint8_t toff, uint8_t hstrt, uint8_t hend, uint8_t fd3, uint8_t disfdcc, uint8_t rndtf, uint8_t chm, uint8_t tbl, uint8_t vsense, uint8_t vhighfs, uint8_t vhighchm, uint8_t sync, uint8_t mres, uint8_t intpol, uint8_t dedge, uint8_t diss2g)
  435. {
  436. uint32_t val = 0;
  437. val |= (uint32_t)(toff & 15);
  438. val |= (uint32_t)(hstrt & 7) << 4;
  439. val |= (uint32_t)(hend & 15) << 7;
  440. val |= (uint32_t)(fd3 & 1) << 11;
  441. val |= (uint32_t)(disfdcc & 1) << 12;
  442. val |= (uint32_t)(rndtf & 1) << 13;
  443. val |= (uint32_t)(chm & 1) << 14;
  444. val |= (uint32_t)(tbl & 3) << 15;
  445. val |= (uint32_t)(vsense & 1) << 17;
  446. val |= (uint32_t)(vhighfs & 1) << 18;
  447. val |= (uint32_t)(vhighchm & 1) << 19;
  448. val |= (uint32_t)(sync & 15) << 20;
  449. val |= (uint32_t)(mres & 15) << 24;
  450. val |= (uint32_t)(intpol & 1) << 28;
  451. val |= (uint32_t)(dedge & 1) << 29;
  452. val |= (uint32_t)(diss2g & 1) << 30;
  453. tmc2130_wr(cs, TMC2130_REG_CHOPCONF, val);
  454. }
  455. //void tmc2130_wr_PWMCONF(uint8_t cs, uint8_t PWMautoScale, uint8_t PWMfreq, uint8_t PWMgrad, uint8_t PWMampl)
  456. void tmc2130_wr_PWMCONF(uint8_t cs, uint8_t pwm_ampl, uint8_t pwm_grad, uint8_t pwm_freq, uint8_t pwm_auto, uint8_t pwm_symm, uint8_t freewheel)
  457. {
  458. uint32_t val = 0;
  459. val |= (uint32_t)(pwm_ampl & 255);
  460. val |= (uint32_t)(pwm_grad & 255) << 8;
  461. val |= (uint32_t)(pwm_freq & 3) << 16;
  462. val |= (uint32_t)(pwm_auto & 1) << 18;
  463. val |= (uint32_t)(pwm_symm & 1) << 19;
  464. val |= (uint32_t)(freewheel & 3) << 20;
  465. tmc2130_wr(cs, TMC2130_REG_PWMCONF, val);
  466. // tmc2130_wr(cs, TMC2130_REG_PWMCONF, ((uint32_t)(PWMautoScale+PWMfreq) << 16) | ((uint32_t)PWMgrad << 8) | PWMampl); // TMC LJ -> For better readability changed to 0x00 and added PWMautoScale and PWMfreq
  467. }
  468. void tmc2130_wr_TPWMTHRS(uint8_t cs, uint32_t val32)
  469. {
  470. tmc2130_wr(cs, TMC2130_REG_TPWMTHRS, val32);
  471. }
  472. void tmc2130_wr_THIGH(uint8_t cs, uint32_t val32)
  473. {
  474. tmc2130_wr(cs, TMC2130_REG_THIGH, val32);
  475. }
  476. #if defined(TMC2130_DEBUG_RD) || defined(TMC2130_DEBUG_WR)
  477. uint8_t tmc2130_axis_by_cs(uint8_t cs)
  478. {
  479. switch (cs)
  480. {
  481. case X_TMC2130_CS: return 0;
  482. case Y_TMC2130_CS: return 1;
  483. case Z_TMC2130_CS: return 2;
  484. case E0_TMC2130_CS: return 3;
  485. }
  486. return -1;
  487. }
  488. #endif //TMC2130_DEBUG
  489. uint8_t tmc2130_calc_mres(uint16_t microstep_resolution)
  490. {
  491. if (microstep_resolution == 256) return 0b0000;
  492. if (microstep_resolution == 128) return 0b0001;
  493. if (microstep_resolution == 64) return 0b0010;
  494. if (microstep_resolution == 32) return 0b0011;
  495. if (microstep_resolution == 16) return 0b0100;
  496. if (microstep_resolution == 8) return 0b0101;
  497. if (microstep_resolution == 4) return 0b0110;
  498. if (microstep_resolution == 2) return 0b0111;
  499. if (microstep_resolution == 1) return 0b1000;
  500. return 0;
  501. }
  502. uint8_t tmc2130_wr(uint8_t cs, uint8_t addr, uint32_t wval)
  503. {
  504. uint8_t stat = tmc2130_txrx(cs, addr | 0x80, wval, 0);
  505. #ifdef TMC2130_DEBUG_WR
  506. MYSERIAL.print("tmc2130_wr(");
  507. MYSERIAL.print((unsigned char)tmc2130_axis_by_cs(cs), DEC);
  508. MYSERIAL.print(", 0x");
  509. MYSERIAL.print((unsigned char)addr, HEX);
  510. MYSERIAL.print(", 0x");
  511. MYSERIAL.print((unsigned long)wval, HEX);
  512. MYSERIAL.print(")=0x");
  513. MYSERIAL.println((unsigned char)stat, HEX);
  514. #endif //TMC2130_DEBUG_WR
  515. return stat;
  516. }
  517. uint8_t tmc2130_rd(uint8_t cs, uint8_t addr, uint32_t* rval)
  518. {
  519. uint32_t val32 = 0;
  520. uint8_t stat = tmc2130_txrx(cs, addr, 0x00000000, &val32);
  521. if (rval != 0) *rval = val32;
  522. #ifdef TMC2130_DEBUG_RD
  523. if (!skip_debug_msg)
  524. {
  525. MYSERIAL.print("tmc2130_rd(");
  526. MYSERIAL.print((unsigned char)tmc2130_axis_by_cs(cs), DEC);
  527. MYSERIAL.print(", 0x");
  528. MYSERIAL.print((unsigned char)addr, HEX);
  529. MYSERIAL.print(", 0x");
  530. MYSERIAL.print((unsigned long)val32, HEX);
  531. MYSERIAL.print(")=0x");
  532. MYSERIAL.println((unsigned char)stat, HEX);
  533. }
  534. skip_debug_msg = false;
  535. #endif //TMC2130_DEBUG_RD
  536. return stat;
  537. }
  538. uint8_t tmc2130_txrx(uint8_t cs, uint8_t addr, uint32_t wval, uint32_t* rval)
  539. {
  540. //datagram1 - request
  541. SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE3));
  542. digitalWrite(cs, LOW);
  543. SPI.transfer(addr); // address
  544. SPI.transfer((wval >> 24) & 0xff); // MSB
  545. SPI.transfer((wval >> 16) & 0xff);
  546. SPI.transfer((wval >> 8) & 0xff);
  547. SPI.transfer(wval & 0xff); // LSB
  548. digitalWrite(cs, HIGH);
  549. SPI.endTransaction();
  550. //datagram2 - response
  551. SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE3));
  552. digitalWrite(cs, LOW);
  553. uint8_t stat = SPI.transfer(0); // status
  554. uint32_t val32 = 0;
  555. val32 = SPI.transfer(0); // MSB
  556. val32 = (val32 << 8) | SPI.transfer(0);
  557. val32 = (val32 << 8) | SPI.transfer(0);
  558. val32 = (val32 << 8) | SPI.transfer(0); // LSB
  559. digitalWrite(cs, HIGH);
  560. SPI.endTransaction();
  561. if (rval != 0) *rval = val32;
  562. return stat;
  563. }
  564. void tmc2130_eeprom_load_config()
  565. {
  566. }
  567. void tmc2130_eeprom_save_config()
  568. {
  569. }
  570. #endif //TMC2130