My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

stepper_indirection.h 14KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494
  1. /*
  2. stepper_indirection.h - stepper motor driver indirection macros
  3. to allow some stepper functions to be done via SPI/I2c instead of direct pin manipulation
  4. Part of Marlin
  5. Copyright (c) 2015 Dominik Wenger
  6. Marlin is free software: you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation, either version 3 of the License, or
  9. (at your option) any later version.
  10. Marlin is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with Marlin. If not, see <http://www.gnu.org/licenses/>.
  16. */
  17. #ifndef STEPPER_INDIRECTION_H
  18. #define STEPPER_INDIRECTION_H
  19. #include "macros.h"
  20. // X motor
  21. #define X_STEP_INIT SET_OUTPUT(X_STEP_PIN)
  22. #define X_STEP_WRITE(STATE) WRITE(X_STEP_PIN,STATE)
  23. #define X_STEP_READ READ(X_STEP_PIN)
  24. #define X_DIR_INIT SET_OUTPUT(X_DIR_PIN)
  25. #define X_DIR_WRITE(STATE) WRITE(X_DIR_PIN,STATE)
  26. #define X_DIR_READ READ(X_DIR_PIN)
  27. #define X_ENABLE_INIT SET_OUTPUT(X_ENABLE_PIN)
  28. #define X_ENABLE_WRITE(STATE) WRITE(X_ENABLE_PIN,STATE)
  29. #define X_ENABLE_READ READ(X_ENABLE_PIN)
  30. // X2 motor
  31. #define X2_STEP_INIT SET_OUTPUT(X2_STEP_PIN)
  32. #define X2_STEP_WRITE(STATE) WRITE(X2_STEP_PIN,STATE)
  33. #define X2_STEP_READ READ(X2_STEP_PIN)
  34. #define X2_DIR_INIT SET_OUTPUT(X2_DIR_PIN)
  35. #define X2_DIR_WRITE(STATE) WRITE(X2_DIR_PIN,STATE)
  36. #define X2_DIR_READ READ(X_DIR_PIN)
  37. #define X2_ENABLE_INIT SET_OUTPUT(X2_ENABLE_PIN)
  38. #define X2_ENABLE_WRITE(STATE) WRITE(X2_ENABLE_PIN,STATE)
  39. #define X2_ENABLE_READ READ(X_ENABLE_PIN)
  40. // Y motor
  41. #define Y_STEP_INIT SET_OUTPUT(Y_STEP_PIN)
  42. #define Y_STEP_WRITE(STATE) WRITE(Y_STEP_PIN,STATE)
  43. #define Y_STEP_READ READ(Y_STEP_PIN)
  44. #define Y_DIR_INIT SET_OUTPUT(Y_DIR_PIN)
  45. #define Y_DIR_WRITE(STATE) WRITE(Y_DIR_PIN,STATE)
  46. #define Y_DIR_READ READ(Y_DIR_PIN)
  47. #define Y_ENABLE_INIT SET_OUTPUT(Y_ENABLE_PIN)
  48. #define Y_ENABLE_WRITE(STATE) WRITE(Y_ENABLE_PIN,STATE)
  49. #define Y_ENABLE_READ READ(Y_ENABLE_PIN)
  50. // Y2 motor
  51. #define Y2_STEP_INIT SET_OUTPUT(Y2_STEP_PIN)
  52. #define Y2_STEP_WRITE(STATE) WRITE(Y2_STEP_PIN,STATE)
  53. #define Y2_STEP_READ READ(Y2_STEP_PIN)
  54. #define Y2_DIR_INIT SET_OUTPUT(Y2_DIR_PIN)
  55. #define Y2_DIR_WRITE(STATE) WRITE(Y2_DIR_PIN,STATE)
  56. #define Y2_DIR_READ READ(Y2_DIR_PIN)
  57. #define Y2_ENABLE_INIT SET_OUTPUT(Y2_ENABLE_PIN)
  58. #define Y2_ENABLE_WRITE(STATE) WRITE(Y2_ENABLE_PIN,STATE)
  59. #define Y2_ENABLE_READ READ(Y2_ENABLE_PIN)
  60. // Z motor
  61. #define Z_STEP_INIT SET_OUTPUT(Z_STEP_PIN)
  62. #define Z_STEP_WRITE(STATE) WRITE(Z_STEP_PIN,STATE)
  63. #define Z_STEP_READ READ(Z_STEP_PIN)
  64. #define Z_DIR_INIT SET_OUTPUT(Z_DIR_PIN)
  65. #define Z_DIR_WRITE(STATE) WRITE(Z_DIR_PIN,STATE)
  66. #define Z_DIR_READ READ(Z_DIR_PIN)
  67. #define Z_ENABLE_INIT SET_OUTPUT(Z_ENABLE_PIN)
  68. #define Z_ENABLE_WRITE(STATE) WRITE(Z_ENABLE_PIN,STATE)
  69. #define Z_ENABLE_READ READ(Z_ENABLE_PIN)
  70. // Z2 motor
  71. #define Z2_STEP_INIT SET_OUTPUT(Z2_STEP_PIN)
  72. #define Z2_STEP_WRITE(STATE) WRITE(Z2_STEP_PIN,STATE)
  73. #define Z2_STEP_READ READ(Z2_STEP_PIN)
  74. #define Z2_DIR_INIT SET_OUTPUT(Z2_DIR_PIN)
  75. #define Z2_DIR_WRITE(STATE) WRITE(Z2_DIR_PIN,STATE)
  76. #define Z2_DIR_READ READ(Z2_DIR_PIN)
  77. #define Z2_ENABLE_INIT SET_OUTPUT(Z2_ENABLE_PIN)
  78. #define Z2_ENABLE_WRITE(STATE) WRITE(Z2_ENABLE_PIN,STATE)
  79. #define Z2_ENABLE_READ READ(Z2_ENABLE_PIN)
  80. // E0 motor
  81. #define E0_STEP_INIT SET_OUTPUT(E0_STEP_PIN)
  82. #define E0_STEP_WRITE(STATE) WRITE(E0_STEP_PIN,STATE)
  83. #define E0_STEP_READ READ(E0_STEP_PIN)
  84. #define E0_DIR_INIT SET_OUTPUT(E0_DIR_PIN)
  85. #define E0_DIR_WRITE(STATE) WRITE(E0_DIR_PIN,STATE)
  86. #define E0_DIR_READ READ(E0_DIR_PIN)
  87. #define E0_ENABLE_INIT SET_OUTPUT(E0_ENABLE_PIN)
  88. #define E0_ENABLE_WRITE(STATE) WRITE(E0_ENABLE_PIN,STATE)
  89. #define E0_ENABLE_READ READ(E0_ENABLE_PIN)
  90. // E1 motor
  91. #define E1_STEP_INIT SET_OUTPUT(E1_STEP_PIN)
  92. #define E1_STEP_WRITE(STATE) WRITE(E1_STEP_PIN,STATE)
  93. #define E1_STEP_READ READ(E1_STEP_PIN)
  94. #define E1_DIR_INIT SET_OUTPUT(E1_DIR_PIN)
  95. #define E1_DIR_WRITE(STATE) WRITE(E1_DIR_PIN,STATE)
  96. #define E1_DIR_READ READ(E1_DIR_PIN)
  97. #define E1_ENABLE_INIT SET_OUTPUT(E1_ENABLE_PIN)
  98. #define E1_ENABLE_WRITE(STATE) WRITE(E1_ENABLE_PIN,STATE)
  99. #define E1_ENABLE_READ READ(E1_ENABLE_PIN)
  100. // E2 motor
  101. #define E2_STEP_INIT SET_OUTPUT(E2_STEP_PIN)
  102. #define E2_STEP_WRITE(STATE) WRITE(E2_STEP_PIN,STATE)
  103. #define E2_STEP_READ READ(E2_STEP_PIN)
  104. #define E2_DIR_INIT SET_OUTPUT(E2_DIR_PIN)
  105. #define E2_DIR_WRITE(STATE) WRITE(E2_DIR_PIN,STATE)
  106. #define E2_DIR_READ READ(E2_DIR_PIN)
  107. #define E2_ENABLE_INIT SET_OUTPUT(E2_ENABLE_PIN)
  108. #define E2_ENABLE_WRITE(STATE) WRITE(E2_ENABLE_PIN,STATE)
  109. #define E2_ENABLE_READ READ(E2_ENABLE_PIN)
  110. // E3 motor
  111. #define E3_STEP_INIT SET_OUTPUT(E3_STEP_PIN)
  112. #define E3_STEP_WRITE(STATE) WRITE(E3_STEP_PIN,STATE)
  113. #define E3_STEP_READ READ(E3_STEP_PIN)
  114. #define E3_DIR_INIT SET_OUTPUT(E3_DIR_PIN)
  115. #define E3_DIR_WRITE(STATE) WRITE(E3_DIR_PIN,STATE)
  116. #define E3_DIR_READ READ(E3_DIR_PIN)
  117. #define E3_ENABLE_INIT SET_OUTPUT(E3_ENABLE_PIN)
  118. #define E3_ENABLE_WRITE(STATE) WRITE(E3_ENABLE_PIN,STATE)
  119. #define E3_ENABLE_READ READ(E3_ENABLE_PIN)
  120. //////////////////////////////////
  121. // Pin redefines for TMC drivers.
  122. // TMC26X drivers have step and dir on normal pins, but everything else via SPI
  123. //////////////////////////////////
  124. #if ENABLED(HAVE_TMCDRIVER)
  125. #include <SPI.h>
  126. #include <TMC26XStepper.h>
  127. void tmc_init();
  128. #if ENABLED(X_IS_TMC)
  129. extern TMC26XStepper stepperX;
  130. #undef X_ENABLE_INIT
  131. #define X_ENABLE_INIT ((void)0)
  132. #undef X_ENABLE_WRITE
  133. #define X_ENABLE_WRITE(STATE) stepperX.setEnabled(STATE)
  134. #undef X_ENABLE_READ
  135. #define X_ENABLE_READ stepperX.isEnabled()
  136. #endif
  137. #if ENABLED(X2_IS_TMC)
  138. extern TMC26XStepper stepperX2;
  139. #undef X2_ENABLE_INIT
  140. #define X2_ENABLE_INIT ((void)0)
  141. #undef X2_ENABLE_WRITE
  142. #define X2_ENABLE_WRITE(STATE) stepperX2.setEnabled(STATE)
  143. #undef X2_ENABLE_READ
  144. #define X2_ENABLE_READ stepperX2.isEnabled()
  145. #endif
  146. #if ENABLED(Y_IS_TMC)
  147. extern TMC26XStepper stepperY;
  148. #undef Y_ENABLE_INIT
  149. #define Y_ENABLE_INIT ((void)0)
  150. #undef Y_ENABLE_WRITE
  151. #define Y_ENABLE_WRITE(STATE) stepperY.setEnabled(STATE)
  152. #undef Y_ENABLE_READ
  153. #define Y_ENABLE_READ stepperY.isEnabled()
  154. #endif
  155. #if ENABLED(Y2_IS_TMC)
  156. extern TMC26XStepper stepperY2;
  157. #undef Y2_ENABLE_INIT
  158. #define Y2_ENABLE_INIT ((void)0)
  159. #undef Y2_ENABLE_WRITE
  160. #define Y2_ENABLE_WRITE(STATE) stepperY2.setEnabled(STATE)
  161. #undef Y2_ENABLE_READ
  162. #define Y2_ENABLE_READ stepperY2.isEnabled()
  163. #endif
  164. #if ENABLED(Z_IS_TMC)
  165. extern TMC26XStepper stepperZ;
  166. #undef Z_ENABLE_INIT
  167. #define Z_ENABLE_INIT ((void)0)
  168. #undef Z_ENABLE_WRITE
  169. #define Z_ENABLE_WRITE(STATE) stepperZ.setEnabled(STATE)
  170. #undef Z_ENABLE_READ
  171. #define Z_ENABLE_READ stepperZ.isEnabled()
  172. #endif
  173. #if ENABLED(Z2_IS_TMC)
  174. extern TMC26XStepper stepperZ2;
  175. #undef Z2_ENABLE_INIT
  176. #define Z2_ENABLE_INIT ((void)0)
  177. #undef Z2_ENABLE_WRITE
  178. #define Z2_ENABLE_WRITE(STATE) stepperZ2.setEnabled(STATE)
  179. #undef Z2_ENABLE_READ
  180. #define Z2_ENABLE_READ stepperZ2.isEnabled()
  181. #endif
  182. #if ENABLED(E0_IS_TMC)
  183. extern TMC26XStepper stepperE0;
  184. #undef E0_ENABLE_INIT
  185. #define E0_ENABLE_INIT ((void)0)
  186. #undef E0_ENABLE_WRITE
  187. #define E0_ENABLE_WRITE(STATE) stepperE0.setEnabled(STATE)
  188. #undef E0_ENABLE_READ
  189. #define E0_ENABLE_READ stepperE0.isEnabled()
  190. #endif
  191. #if ENABLED(E1_IS_TMC)
  192. extern TMC26XStepper stepperE1;
  193. #undef E1_ENABLE_INIT
  194. #define E1_ENABLE_INIT ((void)0)
  195. #undef E1_ENABLE_WRITE
  196. #define E1_ENABLE_WRITE(STATE) stepperE1.setEnabled(STATE)
  197. #undef E1_ENABLE_READ
  198. #define E1_ENABLE_READ stepperE1.isEnabled()
  199. #endif
  200. #if ENABLED(E2_IS_TMC)
  201. extern TMC26XStepper stepperE2;
  202. #undef E2_ENABLE_INIT
  203. #define E2_ENABLE_INIT ((void)0)
  204. #undef E2_ENABLE_WRITE
  205. #define E2_ENABLE_WRITE(STATE) stepperE2.setEnabled(STATE)
  206. #undef E2_ENABLE_READ
  207. #define E2_ENABLE_READ stepperE2.isEnabled()
  208. #endif
  209. #if ENABLED(E3_IS_TMC)
  210. extern TMC26XStepper stepperE3;
  211. #undef E3_ENABLE_INIT
  212. #define E3_ENABLE_INIT ((void)0)
  213. #undef E3_ENABLE_WRITE
  214. #define E3_ENABLE_WRITE(STATE) stepperE3.setEnabled(STATE)
  215. #undef E3_ENABLE_READ
  216. #define E3_ENABLE_READ stepperE3.isEnabled()
  217. #endif
  218. #endif // HAVE_TMCDRIVER
  219. //////////////////////////////////
  220. // Pin redefines for L6470 drivers.
  221. // L640 drivers have step on normal pins, but dir and everything else via SPI
  222. //////////////////////////////////
  223. #if ENABLED(HAVE_L6470DRIVER)
  224. #include <SPI.h>
  225. #include <L6470.h>
  226. void L6470_init();
  227. #if ENABLED(X_IS_L6470)
  228. extern L6470 stepperX;
  229. #undef X_ENABLE_INIT
  230. #define X_ENABLE_INIT ((void)0)
  231. #undef X_ENABLE_WRITE
  232. #define X_ENABLE_WRITE(STATE) {if(STATE) stepperX.Step_Clock(stepperX.getStatus() & STATUS_HIZ); else stepperX.softFree();}
  233. #undef X_ENABLE_READ
  234. #define X_ENABLE_READ (stepperX.getStatus() & STATUS_HIZ)
  235. #undef X_DIR_INIT
  236. #define X_DIR_INIT ((void)0)
  237. #undef X_DIR_WRITE
  238. #define X_DIR_WRITE(STATE) stepperX.Step_Clock(STATE)
  239. #undef X_DIR_READ
  240. #define X_DIR_READ (stepperX.getStatus() & STATUS_DIR)
  241. #endif
  242. #if ENABLED(X2_IS_L6470)
  243. extern L6470 stepperX2;
  244. #undef X2_ENABLE_INIT
  245. #define X2_ENABLE_INIT ((void)0)
  246. #undef X2_ENABLE_WRITE
  247. #define X2_ENABLE_WRITE(STATE) (if(STATE) stepperX2.Step_Clock(stepperX2.getStatus() & STATUS_HIZ); else stepperX2.softFree();)
  248. #undef X2_ENABLE_READ
  249. #define X2_ENABLE_READ (stepperX2.getStatus() & STATUS_HIZ)
  250. #undef X2_DIR_INIT
  251. #define X2_DIR_INIT ((void)0)
  252. #undef X2_DIR_WRITE
  253. #define X2_DIR_WRITE(STATE) stepperX2.Step_Clock(STATE)
  254. #undef X2_DIR_READ
  255. #define X2_DIR_READ (stepperX2.getStatus() & STATUS_DIR)
  256. #endif
  257. #if ENABLED(Y_IS_L6470)
  258. extern L6470 stepperY;
  259. #undef Y_ENABLE_INIT
  260. #define Y_ENABLE_INIT ((void)0)
  261. #undef Y_ENABLE_WRITE
  262. #define Y_ENABLE_WRITE(STATE) (if(STATE) stepperY.Step_Clock(stepperY.getStatus() & STATUS_HIZ); else stepperY.softFree();)
  263. #undef Y_ENABLE_READ
  264. #define Y_ENABLE_READ (stepperY.getStatus() & STATUS_HIZ)
  265. #undef Y_DIR_INIT
  266. #define Y_DIR_INIT ((void)0)
  267. #undef Y_DIR_WRITE
  268. #define Y_DIR_WRITE(STATE) stepperY.Step_Clock(STATE)
  269. #undef Y_DIR_READ
  270. #define Y_DIR_READ (stepperY.getStatus() & STATUS_DIR)
  271. #endif
  272. #if ENABLED(Y2_IS_L6470)
  273. extern L6470 stepperY2;
  274. #undef Y2_ENABLE_INIT
  275. #define Y2_ENABLE_INIT ((void)0)
  276. #undef Y2_ENABLE_WRITE
  277. #define Y2_ENABLE_WRITE(STATE) (if(STATE) stepperY2.Step_Clock(stepperY2.getStatus() & STATUS_HIZ); else stepperY2.softFree();)
  278. #undef Y2_ENABLE_READ
  279. #define Y2_ENABLE_READ (stepperY2.getStatus() & STATUS_HIZ)
  280. #undef Y2_DIR_INIT
  281. #define Y2_DIR_INIT ((void)0)
  282. #undef Y2_DIR_WRITE
  283. #define Y2_DIR_WRITE(STATE) stepperY2.Step_Clock(STATE)
  284. #undef Y2_DIR_READ
  285. #define Y2_DIR_READ (stepperY2.getStatus() & STATUS_DIR)
  286. #endif
  287. #if ENABLED(Z_IS_L6470)
  288. extern L6470 stepperZ;
  289. #undef Z_ENABLE_INIT
  290. #define Z_ENABLE_INIT ((void)0)
  291. #undef Z_ENABLE_WRITE
  292. #define Z_ENABLE_WRITE(STATE) (if(STATE) stepperZ.Step_Clock(stepperZ.getStatus() & STATUS_HIZ); else stepperZ.softFree();)
  293. #undef Z_ENABLE_READ
  294. #define Z_ENABLE_READ (stepperZ.getStatus() & STATUS_HIZ)
  295. #undef Z_DIR_INIT
  296. #define Z_DIR_INIT ((void)0)
  297. #undef Z_DIR_WRITE
  298. #define Z_DIR_WRITE(STATE) stepperZ.Step_Clock(STATE)
  299. #undef Y_DIR_READ
  300. #define Y_DIR_READ (stepperZ.getStatus() & STATUS_DIR)
  301. #endif
  302. #if ENABLED(Z2_IS_L6470)
  303. extern L6470 stepperZ2;
  304. #undef Z2_ENABLE_INIT
  305. #define Z2_ENABLE_INIT ((void)0)
  306. #undef Z2_ENABLE_WRITE
  307. #define Z2_ENABLE_WRITE(STATE) (if(STATE) stepperZ2.Step_Clock(stepperZ2.getStatus() & STATUS_HIZ); else stepperZ2.softFree();)
  308. #undef Z2_ENABLE_READ
  309. #define Z2_ENABLE_READ (stepperZ2.getStatus() & STATUS_HIZ)
  310. #undef Z2_DIR_INIT
  311. #define Z2_DIR_INIT ((void)0)
  312. #undef Z2_DIR_WRITE
  313. #define Z2_DIR_WRITE(STATE) stepperZ2.Step_Clock(STATE)
  314. #undef Y2_DIR_READ
  315. #define Y2_DIR_READ (stepperZ2.getStatus() & STATUS_DIR)
  316. #endif
  317. #if ENABLED(E0_IS_L6470)
  318. extern L6470 stepperE0;
  319. #undef E0_ENABLE_INIT
  320. #define E0_ENABLE_INIT ((void)0)
  321. #undef E0_ENABLE_WRITE
  322. #define E0_ENABLE_WRITE(STATE) (if(STATE) stepperE0.Step_Clock(stepperE0.getStatus() & STATUS_HIZ); else stepperE0.softFree();)
  323. #undef E0_ENABLE_READ
  324. #define E0_ENABLE_READ (stepperE0.getStatus() & STATUS_HIZ)
  325. #undef E0_DIR_INIT
  326. #define E0_DIR_INIT ((void)0)
  327. #undef E0_DIR_WRITE
  328. #define E0_DIR_WRITE(STATE) stepperE0.Step_Clock(STATE)
  329. #undef E0_DIR_READ
  330. #define E0_DIR_READ (stepperE0.getStatus() & STATUS_DIR)
  331. #endif
  332. #if ENABLED(E1_IS_L6470)
  333. extern L6470 stepperE1;
  334. #undef E1_ENABLE_INIT
  335. #define E1_ENABLE_INIT ((void)0)
  336. #undef E1_ENABLE_WRITE
  337. #define E1_ENABLE_WRITE(STATE) (if(STATE) stepperE1.Step_Clock(stepperE1.getStatus() & STATUS_HIZ); else stepperE1.softFree();)
  338. #undef E1_ENABLE_READ
  339. #define E1_ENABLE_READ (stepperE1.getStatus() & STATUS_HIZ)
  340. #undef E1_DIR_INIT
  341. #define E1_DIR_INIT ((void)0)
  342. #undef E1_DIR_WRITE
  343. #define E1_DIR_WRITE(STATE) stepperE1.Step_Clock(STATE)
  344. #undef E1_DIR_READ
  345. #define E1_DIR_READ (stepperE1.getStatus() & STATUS_DIR)
  346. #endif
  347. #if ENABLED(E2_IS_L6470)
  348. extern L6470 stepperE2;
  349. #undef E2_ENABLE_INIT
  350. #define E2_ENABLE_INIT ((void)0)
  351. #undef E2_ENABLE_WRITE
  352. #define E2_ENABLE_WRITE(STATE) (if(STATE) stepperE2.Step_Clock(stepperE2.getStatus() & STATUS_HIZ); else stepperE2.softFree();)
  353. #undef E2_ENABLE_READ
  354. #define E2_ENABLE_READ (stepperE2.getStatus() & STATUS_HIZ)
  355. #undef E2_DIR_INIT
  356. #define E2_DIR_INIT ((void)0)
  357. #undef E2_DIR_WRITE
  358. #define E2_DIR_WRITE(STATE) stepperE2.Step_Clock(STATE)
  359. #undef E2_DIR_READ
  360. #define E2_DIR_READ (stepperE2.getStatus() & STATUS_DIR)
  361. #endif
  362. #if ENABLED(E3_IS_L6470)
  363. extern L6470 stepperE3;
  364. #undef E3_ENABLE_INIT
  365. #define E3_ENABLE_INIT ((void)0)
  366. #undef E3_ENABLE_WRITE
  367. #define E3_ENABLE_WRITE(STATE) (if(STATE) stepperE3.Step_Clock(stepperE3.getStatus() & STATUS_HIZ); else stepperE3.softFree();)
  368. #undef E3_ENABLE_READ
  369. #define E3_ENABLE_READ (stepperE3.getStatus() & STATUS_HIZ)
  370. #undef E3_DIR_INIT
  371. #define E3_DIR_INIT ((void)0)
  372. #undef E3_DIR_WRITE
  373. #define E3_DIR_WRITE(STATE) stepperE3.Step_Clock(STATE)
  374. #undef E3_DIR_READ
  375. #define E3_DIR_READ (stepperE3.getStatus() & STATUS_DIR)
  376. #endif
  377. #endif //HAVE_L6470DRIVER
  378. #endif // STEPPER_INDIRECTION_H