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.cpp 37KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250
  1. /**
  2. * Marlin 3D Printer Firmware
  3. * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  4. *
  5. * Based on Sprinter and grbl.
  6. * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  7. *
  8. * This program is free software: you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation, either version 3 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  20. *
  21. */
  22. /**
  23. * stepper.cpp - A singleton object to execute motion plans using stepper motors
  24. * Marlin Firmware
  25. *
  26. * Derived from Grbl
  27. * Copyright (c) 2009-2011 Simen Svale Skogsrud
  28. *
  29. * Grbl is free software: you can redistribute it and/or modify
  30. * it under the terms of the GNU General Public License as published by
  31. * the Free Software Foundation, either version 3 of the License, or
  32. * (at your option) any later version.
  33. *
  34. * Grbl is distributed in the hope that it will be useful,
  35. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  36. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  37. * GNU General Public License for more details.
  38. *
  39. * You should have received a copy of the GNU General Public License
  40. * along with Grbl. If not, see <http://www.gnu.org/licenses/>.
  41. */
  42. /* The timer calculations of this module informed by the 'RepRap cartesian firmware' by Zack Smith
  43. and Philipp Tiefenbacher. */
  44. #include "Marlin.h"
  45. #include "stepper.h"
  46. #include "endstops.h"
  47. #include "planner.h"
  48. #include "temperature.h"
  49. #include "ultralcd.h"
  50. #include "language.h"
  51. #include "cardreader.h"
  52. #include "speed_lookuptable.h"
  53. #if HAS_DIGIPOTSS
  54. #include <SPI.h>
  55. #endif
  56. Stepper stepper; // Singleton
  57. // public:
  58. block_t* Stepper::current_block = NULL; // A pointer to the block currently being traced
  59. #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
  60. bool Stepper::abort_on_endstop_hit = false;
  61. #endif
  62. #if ENABLED(Z_DUAL_ENDSTOPS)
  63. bool Stepper::performing_homing = false;
  64. #endif
  65. // private:
  66. unsigned char Stepper::last_direction_bits = 0; // The next stepping-bits to be output
  67. unsigned int Stepper::cleaning_buffer_counter = 0;
  68. #if ENABLED(Z_DUAL_ENDSTOPS)
  69. bool Stepper::locked_z_motor = false;
  70. bool Stepper::locked_z2_motor = false;
  71. #endif
  72. long Stepper::counter_X = 0,
  73. Stepper::counter_Y = 0,
  74. Stepper::counter_Z = 0,
  75. Stepper::counter_E = 0;
  76. volatile unsigned long Stepper::step_events_completed = 0; // The number of step events executed in the current block
  77. #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
  78. unsigned char Stepper::old_OCR0A;
  79. volatile unsigned char Stepper::eISR_Rate = 200; // Keep the ISR at a low rate until needed
  80. #if ENABLED(LIN_ADVANCE)
  81. volatile int Stepper::e_steps[E_STEPPERS];
  82. int Stepper::extruder_advance_k = LIN_ADVANCE_K,
  83. Stepper::final_estep_rate,
  84. Stepper::current_estep_rate[E_STEPPERS],
  85. Stepper::current_adv_steps[E_STEPPERS];
  86. #else
  87. long Stepper::e_steps[E_STEPPERS],
  88. Stepper::final_advance = 0,
  89. Stepper::old_advance = 0,
  90. Stepper::advance_rate,
  91. Stepper::advance;
  92. #endif
  93. #endif
  94. long Stepper::acceleration_time, Stepper::deceleration_time;
  95. volatile long Stepper::count_position[NUM_AXIS] = { 0 };
  96. volatile signed char Stepper::count_direction[NUM_AXIS] = { 1, 1, 1, 1 };
  97. #if ENABLED(MIXING_EXTRUDER)
  98. long Stepper::counter_M[MIXING_STEPPERS];
  99. #endif
  100. unsigned short Stepper::acc_step_rate; // needed for deceleration start point
  101. uint8_t Stepper::step_loops, Stepper::step_loops_nominal;
  102. unsigned short Stepper::OCR1A_nominal;
  103. volatile long Stepper::endstops_trigsteps[3];
  104. #if ENABLED(X_DUAL_STEPPER_DRIVERS)
  105. #define X_APPLY_DIR(v,Q) do{ X_DIR_WRITE(v); X2_DIR_WRITE((v) != INVERT_X2_VS_X_DIR); }while(0)
  106. #define X_APPLY_STEP(v,Q) do{ X_STEP_WRITE(v); X2_STEP_WRITE(v); }while(0)
  107. #elif ENABLED(DUAL_X_CARRIAGE)
  108. #define X_APPLY_DIR(v,ALWAYS) \
  109. if (extruder_duplication_enabled || ALWAYS) { \
  110. X_DIR_WRITE(v); \
  111. X2_DIR_WRITE(v); \
  112. } \
  113. else { \
  114. if (current_block->active_extruder) X2_DIR_WRITE(v); else X_DIR_WRITE(v); \
  115. }
  116. #define X_APPLY_STEP(v,ALWAYS) \
  117. if (extruder_duplication_enabled || ALWAYS) { \
  118. X_STEP_WRITE(v); \
  119. X2_STEP_WRITE(v); \
  120. } \
  121. else { \
  122. if (current_block->active_extruder != 0) X2_STEP_WRITE(v); else X_STEP_WRITE(v); \
  123. }
  124. #else
  125. #define X_APPLY_DIR(v,Q) X_DIR_WRITE(v)
  126. #define X_APPLY_STEP(v,Q) X_STEP_WRITE(v)
  127. #endif
  128. #if ENABLED(Y_DUAL_STEPPER_DRIVERS)
  129. #define Y_APPLY_DIR(v,Q) do{ Y_DIR_WRITE(v); Y2_DIR_WRITE((v) != INVERT_Y2_VS_Y_DIR); }while(0)
  130. #define Y_APPLY_STEP(v,Q) do{ Y_STEP_WRITE(v); Y2_STEP_WRITE(v); }while(0)
  131. #else
  132. #define Y_APPLY_DIR(v,Q) Y_DIR_WRITE(v)
  133. #define Y_APPLY_STEP(v,Q) Y_STEP_WRITE(v)
  134. #endif
  135. #if ENABLED(Z_DUAL_STEPPER_DRIVERS)
  136. #define Z_APPLY_DIR(v,Q) do{ Z_DIR_WRITE(v); Z2_DIR_WRITE(v); }while(0)
  137. #if ENABLED(Z_DUAL_ENDSTOPS)
  138. #define Z_APPLY_STEP(v,Q) \
  139. if (performing_homing) { \
  140. if (Z_HOME_DIR > 0) {\
  141. if (!(TEST(endstops.old_endstop_bits, Z_MAX) && (count_direction[Z_AXIS] > 0)) && !locked_z_motor) Z_STEP_WRITE(v); \
  142. if (!(TEST(endstops.old_endstop_bits, Z2_MAX) && (count_direction[Z_AXIS] > 0)) && !locked_z2_motor) Z2_STEP_WRITE(v); \
  143. } \
  144. else { \
  145. if (!(TEST(endstops.old_endstop_bits, Z_MIN) && (count_direction[Z_AXIS] < 0)) && !locked_z_motor) Z_STEP_WRITE(v); \
  146. if (!(TEST(endstops.old_endstop_bits, Z2_MIN) && (count_direction[Z_AXIS] < 0)) && !locked_z2_motor) Z2_STEP_WRITE(v); \
  147. } \
  148. } \
  149. else { \
  150. Z_STEP_WRITE(v); \
  151. Z2_STEP_WRITE(v); \
  152. }
  153. #else
  154. #define Z_APPLY_STEP(v,Q) do{ Z_STEP_WRITE(v); Z2_STEP_WRITE(v); }while(0)
  155. #endif
  156. #else
  157. #define Z_APPLY_DIR(v,Q) Z_DIR_WRITE(v)
  158. #define Z_APPLY_STEP(v,Q) Z_STEP_WRITE(v)
  159. #endif
  160. #if DISABLED(MIXING_EXTRUDER)
  161. #define E_APPLY_STEP(v,Q) E_STEP_WRITE(v)
  162. #endif
  163. // intRes = longIn1 * longIn2 >> 24
  164. // uses:
  165. // r26 to store 0
  166. // r27 to store bits 16-23 of the 48bit result. The top bit is used to round the two byte result.
  167. // note that the lower two bytes and the upper byte of the 48bit result are not calculated.
  168. // this can cause the result to be out by one as the lower bytes may cause carries into the upper ones.
  169. // B0 A0 are bits 24-39 and are the returned value
  170. // C1 B1 A1 is longIn1
  171. // D2 C2 B2 A2 is longIn2
  172. //
  173. #define MultiU24X32toH16(intRes, longIn1, longIn2) \
  174. asm volatile ( \
  175. "clr r26 \n\t" \
  176. "mul %A1, %B2 \n\t" \
  177. "mov r27, r1 \n\t" \
  178. "mul %B1, %C2 \n\t" \
  179. "movw %A0, r0 \n\t" \
  180. "mul %C1, %C2 \n\t" \
  181. "add %B0, r0 \n\t" \
  182. "mul %C1, %B2 \n\t" \
  183. "add %A0, r0 \n\t" \
  184. "adc %B0, r1 \n\t" \
  185. "mul %A1, %C2 \n\t" \
  186. "add r27, r0 \n\t" \
  187. "adc %A0, r1 \n\t" \
  188. "adc %B0, r26 \n\t" \
  189. "mul %B1, %B2 \n\t" \
  190. "add r27, r0 \n\t" \
  191. "adc %A0, r1 \n\t" \
  192. "adc %B0, r26 \n\t" \
  193. "mul %C1, %A2 \n\t" \
  194. "add r27, r0 \n\t" \
  195. "adc %A0, r1 \n\t" \
  196. "adc %B0, r26 \n\t" \
  197. "mul %B1, %A2 \n\t" \
  198. "add r27, r1 \n\t" \
  199. "adc %A0, r26 \n\t" \
  200. "adc %B0, r26 \n\t" \
  201. "lsr r27 \n\t" \
  202. "adc %A0, r26 \n\t" \
  203. "adc %B0, r26 \n\t" \
  204. "mul %D2, %A1 \n\t" \
  205. "add %A0, r0 \n\t" \
  206. "adc %B0, r1 \n\t" \
  207. "mul %D2, %B1 \n\t" \
  208. "add %B0, r0 \n\t" \
  209. "clr r1 \n\t" \
  210. : \
  211. "=&r" (intRes) \
  212. : \
  213. "d" (longIn1), \
  214. "d" (longIn2) \
  215. : \
  216. "r26" , "r27" \
  217. )
  218. // Some useful constants
  219. #define ENABLE_STEPPER_DRIVER_INTERRUPT() SBI(TIMSK1, OCIE1A)
  220. #define DISABLE_STEPPER_DRIVER_INTERRUPT() CBI(TIMSK1, OCIE1A)
  221. /**
  222. * __________________________
  223. * /| |\ _________________ ^
  224. * / | | \ /| |\ |
  225. * / | | \ / | | \ s
  226. * / | | | | | \ p
  227. * / | | | | | \ e
  228. * +-----+------------------------+---+--+---------------+----+ e
  229. * | BLOCK 1 | BLOCK 2 | d
  230. *
  231. * time ----->
  232. *
  233. * The trapezoid is the shape the speed curve over time. It starts at block->initial_rate, accelerates
  234. * first block->accelerate_until step_events_completed, then keeps going at constant speed until
  235. * step_events_completed reaches block->decelerate_after after which it decelerates until the trapezoid generator is reset.
  236. * The slope of acceleration is calculated using v = u + at where t is the accumulated timer values of the steps so far.
  237. */
  238. void Stepper::wake_up() {
  239. // TCNT1 = 0;
  240. ENABLE_STEPPER_DRIVER_INTERRUPT();
  241. }
  242. /**
  243. * Set the stepper direction of each axis
  244. *
  245. * COREXY: X_AXIS=A_AXIS and Y_AXIS=B_AXIS
  246. * COREXZ: X_AXIS=A_AXIS and Z_AXIS=C_AXIS
  247. * COREYZ: Y_AXIS=B_AXIS and Z_AXIS=C_AXIS
  248. */
  249. void Stepper::set_directions() {
  250. #define SET_STEP_DIR(AXIS) \
  251. if (motor_direction(AXIS ##_AXIS)) { \
  252. AXIS ##_APPLY_DIR(INVERT_## AXIS ##_DIR, false); \
  253. count_direction[AXIS ##_AXIS] = -1; \
  254. } \
  255. else { \
  256. AXIS ##_APPLY_DIR(!INVERT_## AXIS ##_DIR, false); \
  257. count_direction[AXIS ##_AXIS] = 1; \
  258. }
  259. SET_STEP_DIR(X); // A
  260. SET_STEP_DIR(Y); // B
  261. SET_STEP_DIR(Z); // C
  262. #if DISABLED(ADVANCE)
  263. if (motor_direction(E_AXIS)) {
  264. REV_E_DIR();
  265. count_direction[E_AXIS] = -1;
  266. }
  267. else {
  268. NORM_E_DIR();
  269. count_direction[E_AXIS] = 1;
  270. }
  271. #endif //!ADVANCE
  272. }
  273. // "The Stepper Driver Interrupt" - This timer interrupt is the workhorse.
  274. // It pops blocks from the block_buffer and executes them by pulsing the stepper pins appropriately.
  275. ISR(TIMER1_COMPA_vect) { Stepper::isr(); }
  276. void Stepper::isr() {
  277. if (cleaning_buffer_counter) {
  278. current_block = NULL;
  279. planner.discard_current_block();
  280. #ifdef SD_FINISHED_RELEASECOMMAND
  281. if ((cleaning_buffer_counter == 1) && (SD_FINISHED_STEPPERRELEASE)) enqueue_and_echo_commands_P(PSTR(SD_FINISHED_RELEASECOMMAND));
  282. #endif
  283. cleaning_buffer_counter--;
  284. OCR1A = 200;
  285. return;
  286. }
  287. // If there is no current block, attempt to pop one from the buffer
  288. if (!current_block) {
  289. // Anything in the buffer?
  290. current_block = planner.get_current_block();
  291. if (current_block) {
  292. current_block->busy = true;
  293. trapezoid_generator_reset();
  294. // Initialize Bresenham counters to 1/2 the ceiling
  295. counter_X = counter_Y = counter_Z = counter_E = -(current_block->step_event_count >> 1);
  296. #if ENABLED(MIXING_EXTRUDER)
  297. MIXING_STEPPERS_LOOP(i)
  298. counter_M[i] = -(current_block->mix_event_count[i] >> 1);
  299. #endif
  300. step_events_completed = 0;
  301. #if ENABLED(Z_LATE_ENABLE)
  302. if (current_block->steps[Z_AXIS] > 0) {
  303. enable_z();
  304. OCR1A = 2000; //1ms wait
  305. return;
  306. }
  307. #endif
  308. // #if ENABLED(ADVANCE)
  309. // e_steps[TOOL_E_INDEX] = 0;
  310. // #endif
  311. }
  312. else {
  313. OCR1A = 2000; // 1kHz.
  314. }
  315. }
  316. if (current_block) {
  317. // Update endstops state, if enabled
  318. if (endstops.enabled
  319. #if HAS_BED_PROBE
  320. || endstops.z_probe_enabled
  321. #endif
  322. ) endstops.update();
  323. // Take multiple steps per interrupt (For high speed moves)
  324. for (int8_t i = 0; i < step_loops; i++) {
  325. #ifndef USBCON
  326. customizedSerial.checkRx(); // Check for serial chars.
  327. #endif
  328. #if ENABLED(LIN_ADVANCE)
  329. counter_E += current_block->steps[E_AXIS];
  330. if (counter_E > 0) {
  331. counter_E -= current_block->step_event_count;
  332. #if DISABLED(MIXING_EXTRUDER)
  333. // Don't step E here for mixing extruder
  334. count_position[E_AXIS] += count_direction[E_AXIS];
  335. e_steps[TOOL_E_INDEX] += motor_direction(E_AXIS) ? -1 : 1;
  336. #endif
  337. }
  338. #if ENABLED(MIXING_EXTRUDER)
  339. // Step mixing steppers proportionally
  340. long dir = motor_direction(E_AXIS) ? -1 : 1;
  341. MIXING_STEPPERS_LOOP(j) {
  342. counter_m[j] += current_block->steps[E_AXIS];
  343. if (counter_m[j] > 0) {
  344. counter_m[j] -= current_block->mix_event_count[j];
  345. e_steps[j] += dir;
  346. }
  347. }
  348. #endif
  349. if (current_block->use_advance_lead) {
  350. int delta_adv_steps = (((long)extruder_advance_k * current_estep_rate[TOOL_E_INDEX]) >> 9) - current_adv_steps[TOOL_E_INDEX];
  351. #if ENABLED(MIXING_EXTRUDER)
  352. // Mixing extruders apply advance lead proportionally
  353. MIXING_STEPPERS_LOOP(j) {
  354. int steps = delta_adv_steps * current_block->step_event_count / current_block->mix_event_count[j];
  355. e_steps[j] += steps;
  356. current_adv_steps[j] += steps;
  357. }
  358. #else
  359. // For most extruders, advance the single E stepper
  360. e_steps[TOOL_E_INDEX] += delta_adv_steps;
  361. current_adv_steps[TOOL_E_INDEX] += delta_adv_steps;
  362. #endif
  363. }
  364. #elif ENABLED(ADVANCE)
  365. // Always count the unified E axis
  366. counter_E += current_block->steps[E_AXIS];
  367. if (counter_E > 0) {
  368. counter_E -= current_block->step_event_count;
  369. #if DISABLED(MIXING_EXTRUDER)
  370. // Don't step E here for mixing extruder
  371. e_steps[TOOL_E_INDEX] += motor_direction(E_AXIS) ? -1 : 1;
  372. #endif
  373. }
  374. #if ENABLED(MIXING_EXTRUDER)
  375. // Step mixing steppers proportionally
  376. long dir = motor_direction(E_AXIS) ? -1 : 1;
  377. MIXING_STEPPERS_LOOP(j) {
  378. counter_m[j] += current_block->steps[E_AXIS];
  379. if (counter_m[j] > 0) {
  380. counter_m[j] -= current_block->mix_event_count[j];
  381. e_steps[j] += dir;
  382. }
  383. }
  384. #endif // MIXING_EXTRUDER
  385. #endif // ADVANCE or LIN_ADVANCE
  386. #define _COUNTER(AXIS) counter_## AXIS
  387. #define _APPLY_STEP(AXIS) AXIS ##_APPLY_STEP
  388. #define _INVERT_STEP_PIN(AXIS) INVERT_## AXIS ##_STEP_PIN
  389. #define STEP_ADD(AXIS) \
  390. _COUNTER(AXIS) += current_block->steps[_AXIS(AXIS)]; \
  391. if (_COUNTER(AXIS) > 0) { _APPLY_STEP(AXIS)(!_INVERT_STEP_PIN(AXIS),0); }
  392. STEP_ADD(X);
  393. STEP_ADD(Y);
  394. STEP_ADD(Z);
  395. #if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE)
  396. #if ENABLED(MIXING_EXTRUDER)
  397. // Keep updating the single E axis
  398. counter_E += current_block->steps[E_AXIS];
  399. // Tick the counters used for this mix
  400. MIXING_STEPPERS_LOOP(j) {
  401. // Step mixing steppers (proportionally)
  402. counter_M[j] += current_block->steps[E_AXIS];
  403. // Step when the counter goes over zero
  404. if (counter_M[j] > 0) En_STEP_WRITE(j, !INVERT_E_STEP_PIN);
  405. }
  406. #else // !MIXING_EXTRUDER
  407. STEP_ADD(E);
  408. #endif
  409. #endif // !ADVANCE && !LIN_ADVANCE
  410. #define STEP_IF_COUNTER(AXIS) \
  411. if (_COUNTER(AXIS) > 0) { \
  412. _COUNTER(AXIS) -= current_block->step_event_count; \
  413. count_position[_AXIS(AXIS)] += count_direction[_AXIS(AXIS)]; \
  414. _APPLY_STEP(AXIS)(_INVERT_STEP_PIN(AXIS),0); \
  415. }
  416. STEP_IF_COUNTER(X);
  417. STEP_IF_COUNTER(Y);
  418. STEP_IF_COUNTER(Z);
  419. #if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE)
  420. #if ENABLED(MIXING_EXTRUDER)
  421. // Always step the single E axis
  422. if (counter_E > 0) {
  423. counter_E -= current_block->step_event_count;
  424. count_position[E_AXIS] += count_direction[E_AXIS];
  425. }
  426. MIXING_STEPPERS_LOOP(j) {
  427. if (counter_M[j] > 0) {
  428. counter_M[j] -= current_block->mix_event_count[j];
  429. En_STEP_WRITE(j, INVERT_E_STEP_PIN);
  430. }
  431. }
  432. #else // !MIXING_EXTRUDER
  433. STEP_IF_COUNTER(E);
  434. #endif
  435. #endif // !ADVANCE && !LIN_ADVANCE
  436. step_events_completed++;
  437. if (step_events_completed >= current_block->step_event_count) break;
  438. }
  439. #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
  440. // If we have esteps to execute, fire the next ISR "now"
  441. if (e_steps[TOOL_E_INDEX]) OCR0A = TCNT0 + 2;
  442. #endif
  443. // Calculate new timer value
  444. unsigned short timer, step_rate;
  445. if (step_events_completed <= (unsigned long)current_block->accelerate_until) {
  446. MultiU24X32toH16(acc_step_rate, acceleration_time, current_block->acceleration_rate);
  447. acc_step_rate += current_block->initial_rate;
  448. // upper limit
  449. NOMORE(acc_step_rate, current_block->nominal_rate);
  450. // step_rate to timer interval
  451. timer = calc_timer(acc_step_rate);
  452. OCR1A = timer;
  453. acceleration_time += timer;
  454. #if ENABLED(LIN_ADVANCE)
  455. if (current_block->use_advance_lead)
  456. current_estep_rate[TOOL_E_INDEX] = ((unsigned long)acc_step_rate * current_block->e_speed_multiplier8) >> 8;
  457. if (current_block->use_advance_lead) {
  458. #if ENABLED(MIXING_EXTRUDER)
  459. MIXING_STEPPERS_LOOP(j)
  460. current_estep_rate[j] = ((unsigned long)acc_step_rate * current_block->e_speed_multiplier8 * current_block->step_event_count / current_block->mix_event_count[j]) >> 8;
  461. #else
  462. current_estep_rate[TOOL_E_INDEX] = ((unsigned long)acc_step_rate * current_block->e_speed_multiplier8) >> 8;
  463. #endif
  464. }
  465. #elif ENABLED(ADVANCE)
  466. advance += advance_rate * step_loops;
  467. //NOLESS(advance, current_block->advance);
  468. long advance_whole = advance >> 8,
  469. advance_factor = advance_whole - old_advance;
  470. // Do E steps + advance steps
  471. #if ENABLED(MIXING_EXTRUDER)
  472. // ...for mixing steppers proportionally
  473. MIXING_STEPPERS_LOOP(j)
  474. e_steps[j] += advance_factor * current_block->step_event_count / current_block->mix_event_count[j];
  475. #else
  476. // ...for the active extruder
  477. e_steps[TOOL_E_INDEX] += advance_factor;
  478. #endif
  479. old_advance = advance_whole;
  480. #endif // ADVANCE or LIN_ADVANCE
  481. #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
  482. eISR_Rate = (timer >> 2) * step_loops / abs(e_steps[TOOL_E_INDEX]);
  483. #endif
  484. }
  485. else if (step_events_completed > (unsigned long)current_block->decelerate_after) {
  486. MultiU24X32toH16(step_rate, deceleration_time, current_block->acceleration_rate);
  487. if (step_rate <= acc_step_rate) { // Still decelerating?
  488. step_rate = acc_step_rate - step_rate;
  489. NOLESS(step_rate, current_block->final_rate);
  490. }
  491. else
  492. step_rate = current_block->final_rate;
  493. // step_rate to timer interval
  494. timer = calc_timer(step_rate);
  495. OCR1A = timer;
  496. deceleration_time += timer;
  497. #if ENABLED(LIN_ADVANCE)
  498. if (current_block->use_advance_lead) {
  499. #if ENABLED(MIXING_EXTRUDER)
  500. MIXING_STEPPERS_LOOP(j)
  501. current_estep_rate[j] = ((unsigned long)step_rate * current_block->e_speed_multiplier8 * current_block->step_event_count / current_block->mix_event_count[j]) >> 8;
  502. #else
  503. current_estep_rate[TOOL_E_INDEX] = ((unsigned long)step_rate * current_block->e_speed_multiplier8) >> 8;
  504. #endif
  505. }
  506. #elif ENABLED(ADVANCE)
  507. advance -= advance_rate * step_loops;
  508. NOLESS(advance, final_advance);
  509. // Do E steps + advance steps
  510. long advance_whole = advance >> 8,
  511. advance_factor = advance_whole - old_advance;
  512. #if ENABLED(MIXING_EXTRUDER)
  513. MIXING_STEPPERS_LOOP(j)
  514. e_steps[j] += advance_factor * current_block->step_event_count / current_block->mix_event_count[j];
  515. #else
  516. e_steps[TOOL_E_INDEX] += advance_factor;
  517. #endif
  518. old_advance = advance_whole;
  519. #endif // ADVANCE or LIN_ADVANCE
  520. #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
  521. eISR_Rate = (timer >> 2) * step_loops / abs(e_steps[TOOL_E_INDEX]);
  522. #endif
  523. }
  524. else {
  525. #if ENABLED(LIN_ADVANCE)
  526. if (current_block->use_advance_lead)
  527. current_estep_rate[TOOL_E_INDEX] = final_estep_rate;
  528. eISR_Rate = (OCR1A_nominal >> 2) * step_loops_nominal / abs(e_steps[TOOL_E_INDEX]);
  529. #endif
  530. OCR1A = OCR1A_nominal;
  531. // ensure we're running at the correct step rate, even if we just came off an acceleration
  532. step_loops = step_loops_nominal;
  533. }
  534. OCR1A = (OCR1A < (TCNT1 + 16)) ? (TCNT1 + 16) : OCR1A;
  535. // If current block is finished, reset pointer
  536. if (step_events_completed >= current_block->step_event_count) {
  537. current_block = NULL;
  538. planner.discard_current_block();
  539. }
  540. }
  541. }
  542. #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
  543. // Timer interrupt for E. e_steps is set in the main routine;
  544. // Timer 0 is shared with millies
  545. ISR(TIMER0_COMPA_vect) { Stepper::advance_isr(); }
  546. void Stepper::advance_isr() {
  547. old_OCR0A += eISR_Rate;
  548. OCR0A = old_OCR0A;
  549. #define STEP_E_ONCE(INDEX) \
  550. if (e_steps[INDEX] != 0) { \
  551. E## INDEX ##_STEP_WRITE(INVERT_E_STEP_PIN); \
  552. if (e_steps[INDEX] < 0) { \
  553. E## INDEX ##_DIR_WRITE(INVERT_E## INDEX ##_DIR); \
  554. e_steps[INDEX]++; \
  555. } \
  556. else { \
  557. E## INDEX ##_DIR_WRITE(!INVERT_E## INDEX ##_DIR); \
  558. e_steps[INDEX]--; \
  559. } \
  560. E## INDEX ##_STEP_WRITE(!INVERT_E_STEP_PIN); \
  561. }
  562. // Step all E steppers that have steps
  563. for (uint8_t i = 0; i < step_loops; i++) {
  564. STEP_E_ONCE(0);
  565. #if E_STEPPERS > 1
  566. STEP_E_ONCE(1);
  567. #if E_STEPPERS > 2
  568. STEP_E_ONCE(2);
  569. #if E_STEPPERS > 3
  570. STEP_E_ONCE(3);
  571. #endif
  572. #endif
  573. #endif
  574. }
  575. }
  576. #endif // ADVANCE or LIN_ADVANCE
  577. void Stepper::init() {
  578. digipot_init(); //Initialize Digipot Motor Current
  579. microstep_init(); //Initialize Microstepping Pins
  580. // initialise TMC Steppers
  581. #if ENABLED(HAVE_TMCDRIVER)
  582. tmc_init();
  583. #endif
  584. // initialise L6470 Steppers
  585. #if ENABLED(HAVE_L6470DRIVER)
  586. L6470_init();
  587. #endif
  588. // Initialize Dir Pins
  589. #if HAS_X_DIR
  590. X_DIR_INIT;
  591. #endif
  592. #if HAS_X2_DIR
  593. X2_DIR_INIT;
  594. #endif
  595. #if HAS_Y_DIR
  596. Y_DIR_INIT;
  597. #if ENABLED(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_DIR
  598. Y2_DIR_INIT;
  599. #endif
  600. #endif
  601. #if HAS_Z_DIR
  602. Z_DIR_INIT;
  603. #if ENABLED(Z_DUAL_STEPPER_DRIVERS) && HAS_Z2_DIR
  604. Z2_DIR_INIT;
  605. #endif
  606. #endif
  607. #if HAS_E0_DIR
  608. E0_DIR_INIT;
  609. #endif
  610. #if HAS_E1_DIR
  611. E1_DIR_INIT;
  612. #endif
  613. #if HAS_E2_DIR
  614. E2_DIR_INIT;
  615. #endif
  616. #if HAS_E3_DIR
  617. E3_DIR_INIT;
  618. #endif
  619. //Initialize Enable Pins - steppers default to disabled.
  620. #if HAS_X_ENABLE
  621. X_ENABLE_INIT;
  622. if (!X_ENABLE_ON) X_ENABLE_WRITE(HIGH);
  623. #if ENABLED(DUAL_X_CARRIAGE) && HAS_X2_ENABLE
  624. X2_ENABLE_INIT;
  625. if (!X_ENABLE_ON) X2_ENABLE_WRITE(HIGH);
  626. #endif
  627. #endif
  628. #if HAS_Y_ENABLE
  629. Y_ENABLE_INIT;
  630. if (!Y_ENABLE_ON) Y_ENABLE_WRITE(HIGH);
  631. #if ENABLED(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_ENABLE
  632. Y2_ENABLE_INIT;
  633. if (!Y_ENABLE_ON) Y2_ENABLE_WRITE(HIGH);
  634. #endif
  635. #endif
  636. #if HAS_Z_ENABLE
  637. Z_ENABLE_INIT;
  638. if (!Z_ENABLE_ON) Z_ENABLE_WRITE(HIGH);
  639. #if ENABLED(Z_DUAL_STEPPER_DRIVERS) && HAS_Z2_ENABLE
  640. Z2_ENABLE_INIT;
  641. if (!Z_ENABLE_ON) Z2_ENABLE_WRITE(HIGH);
  642. #endif
  643. #endif
  644. #if HAS_E0_ENABLE
  645. E0_ENABLE_INIT;
  646. if (!E_ENABLE_ON) E0_ENABLE_WRITE(HIGH);
  647. #endif
  648. #if HAS_E1_ENABLE
  649. E1_ENABLE_INIT;
  650. if (!E_ENABLE_ON) E1_ENABLE_WRITE(HIGH);
  651. #endif
  652. #if HAS_E2_ENABLE
  653. E2_ENABLE_INIT;
  654. if (!E_ENABLE_ON) E2_ENABLE_WRITE(HIGH);
  655. #endif
  656. #if HAS_E3_ENABLE
  657. E3_ENABLE_INIT;
  658. if (!E_ENABLE_ON) E3_ENABLE_WRITE(HIGH);
  659. #endif
  660. //
  661. // Init endstops and pullups here
  662. //
  663. endstops.init();
  664. #define _STEP_INIT(AXIS) AXIS ##_STEP_INIT
  665. #define _WRITE_STEP(AXIS, HIGHLOW) AXIS ##_STEP_WRITE(HIGHLOW)
  666. #define _DISABLE(axis) disable_## axis()
  667. #define AXIS_INIT(axis, AXIS, PIN) \
  668. _STEP_INIT(AXIS); \
  669. _WRITE_STEP(AXIS, _INVERT_STEP_PIN(PIN)); \
  670. _DISABLE(axis)
  671. #define E_AXIS_INIT(NUM) AXIS_INIT(e## NUM, E## NUM, E)
  672. // Initialize Step Pins
  673. #if HAS_X_STEP
  674. #if ENABLED(X_DUAL_STEPPER_DRIVERS) || ENABLED(DUAL_X_CARRIAGE)
  675. X2_STEP_INIT;
  676. X2_STEP_WRITE(INVERT_X_STEP_PIN);
  677. #endif
  678. AXIS_INIT(x, X, X);
  679. #endif
  680. #if HAS_Y_STEP
  681. #if ENABLED(Y_DUAL_STEPPER_DRIVERS)
  682. Y2_STEP_INIT;
  683. Y2_STEP_WRITE(INVERT_Y_STEP_PIN);
  684. #endif
  685. AXIS_INIT(y, Y, Y);
  686. #endif
  687. #if HAS_Z_STEP
  688. #if ENABLED(Z_DUAL_STEPPER_DRIVERS)
  689. Z2_STEP_INIT;
  690. Z2_STEP_WRITE(INVERT_Z_STEP_PIN);
  691. #endif
  692. AXIS_INIT(z, Z, Z);
  693. #endif
  694. #if HAS_E0_STEP
  695. E_AXIS_INIT(0);
  696. #endif
  697. #if HAS_E1_STEP
  698. E_AXIS_INIT(1);
  699. #endif
  700. #if HAS_E2_STEP
  701. E_AXIS_INIT(2);
  702. #endif
  703. #if HAS_E3_STEP
  704. E_AXIS_INIT(3);
  705. #endif
  706. // waveform generation = 0100 = CTC
  707. CBI(TCCR1B, WGM13);
  708. SBI(TCCR1B, WGM12);
  709. CBI(TCCR1A, WGM11);
  710. CBI(TCCR1A, WGM10);
  711. // output mode = 00 (disconnected)
  712. TCCR1A &= ~(3 << COM1A0);
  713. TCCR1A &= ~(3 << COM1B0);
  714. // Set the timer pre-scaler
  715. // Generally we use a divider of 8, resulting in a 2MHz timer
  716. // frequency on a 16MHz MCU. If you are going to change this, be
  717. // sure to regenerate speed_lookuptable.h with
  718. // create_speed_lookuptable.py
  719. TCCR1B = (TCCR1B & ~(0x07 << CS10)) | (2 << CS10);
  720. OCR1A = 0x4000;
  721. TCNT1 = 0;
  722. ENABLE_STEPPER_DRIVER_INTERRUPT();
  723. #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
  724. for (int i = 0; i < E_STEPPERS; i++) {
  725. e_steps[i] = 0;
  726. #if ENABLED(LIN_ADVANCE)
  727. current_adv_steps[i] = 0;
  728. #endif
  729. }
  730. #if defined(TCCR0A) && defined(WGM01)
  731. CBI(TCCR0A, WGM01);
  732. CBI(TCCR0A, WGM00);
  733. #endif
  734. SBI(TIMSK0, OCIE0A);
  735. #endif // ADVANCE or LIN_ADVANCE
  736. endstops.enable(true); // Start with endstops active. After homing they can be disabled
  737. sei();
  738. set_directions(); // Init directions to last_direction_bits = 0
  739. }
  740. /**
  741. * Block until all buffered steps are executed
  742. */
  743. void Stepper::synchronize() { while (planner.blocks_queued()) idle(); }
  744. /**
  745. * Set the stepper positions directly in steps
  746. *
  747. * The input is based on the typical per-axis XYZ steps.
  748. * For CORE machines XYZ needs to be translated to ABC.
  749. *
  750. * This allows get_axis_position_mm to correctly
  751. * derive the current XYZ position later on.
  752. */
  753. void Stepper::set_position(const long& x, const long& y, const long& z, const long& e) {
  754. CRITICAL_SECTION_START;
  755. #if ENABLED(COREXY)
  756. // corexy positioning
  757. // these equations follow the form of the dA and dB equations on http://www.corexy.com/theory.html
  758. count_position[A_AXIS] = x + y;
  759. count_position[B_AXIS] = x - y;
  760. count_position[Z_AXIS] = z;
  761. #elif ENABLED(COREXZ)
  762. // corexz planning
  763. count_position[A_AXIS] = x + z;
  764. count_position[Y_AXIS] = y;
  765. count_position[C_AXIS] = x - z;
  766. #elif ENABLED(COREYZ)
  767. // coreyz planning
  768. count_position[X_AXIS] = x;
  769. count_position[B_AXIS] = y + z;
  770. count_position[C_AXIS] = y - z;
  771. #else
  772. // default non-h-bot planning
  773. count_position[X_AXIS] = x;
  774. count_position[Y_AXIS] = y;
  775. count_position[Z_AXIS] = z;
  776. #endif
  777. count_position[E_AXIS] = e;
  778. CRITICAL_SECTION_END;
  779. }
  780. void Stepper::set_e_position(const long& e) {
  781. CRITICAL_SECTION_START;
  782. count_position[E_AXIS] = e;
  783. CRITICAL_SECTION_END;
  784. }
  785. /**
  786. * Get a stepper's position in steps.
  787. */
  788. long Stepper::position(AxisEnum axis) {
  789. CRITICAL_SECTION_START;
  790. long count_pos = count_position[axis];
  791. CRITICAL_SECTION_END;
  792. return count_pos;
  793. }
  794. /**
  795. * Get an axis position according to stepper position(s)
  796. * For CORE machines apply translation from ABC to XYZ.
  797. */
  798. float Stepper::get_axis_position_mm(AxisEnum axis) {
  799. float axis_steps;
  800. #if ENABLED(COREXY) || ENABLED(COREXZ) || ENABLED(COREYZ)
  801. // Requesting one of the "core" axes?
  802. if (axis == CORE_AXIS_1 || axis == CORE_AXIS_2) {
  803. CRITICAL_SECTION_START;
  804. long pos1 = count_position[CORE_AXIS_1],
  805. pos2 = count_position[CORE_AXIS_2];
  806. CRITICAL_SECTION_END;
  807. // ((a1+a2)+(a1-a2))/2 -> (a1+a2+a1-a2)/2 -> (a1+a1)/2 -> a1
  808. // ((a1+a2)-(a1-a2))/2 -> (a1+a2-a1+a2)/2 -> (a2+a2)/2 -> a2
  809. axis_steps = (pos1 + ((axis == CORE_AXIS_1) ? pos2 : -pos2)) * 0.5f;
  810. }
  811. else
  812. axis_steps = position(axis);
  813. #else
  814. axis_steps = position(axis);
  815. #endif
  816. return axis_steps * planner.steps_to_mm[axis];
  817. }
  818. void Stepper::finish_and_disable() {
  819. synchronize();
  820. disable_all_steppers();
  821. }
  822. void Stepper::quick_stop() {
  823. cleaning_buffer_counter = 5000;
  824. DISABLE_STEPPER_DRIVER_INTERRUPT();
  825. while (planner.blocks_queued()) planner.discard_current_block();
  826. current_block = NULL;
  827. ENABLE_STEPPER_DRIVER_INTERRUPT();
  828. }
  829. void Stepper::endstop_triggered(AxisEnum axis) {
  830. #if ENABLED(COREXY) || ENABLED(COREXZ) || ENABLED(COREYZ)
  831. float axis_pos = count_position[axis];
  832. if (axis == CORE_AXIS_1)
  833. axis_pos = (axis_pos + count_position[CORE_AXIS_2]) * 0.5;
  834. else if (axis == CORE_AXIS_2)
  835. axis_pos = (count_position[CORE_AXIS_1] - axis_pos) * 0.5;
  836. endstops_trigsteps[axis] = axis_pos;
  837. #else // !COREXY && !COREXZ && !COREYZ
  838. endstops_trigsteps[axis] = count_position[axis];
  839. #endif // !COREXY && !COREXZ && !COREYZ
  840. kill_current_block();
  841. }
  842. void Stepper::report_positions() {
  843. CRITICAL_SECTION_START;
  844. long xpos = count_position[X_AXIS],
  845. ypos = count_position[Y_AXIS],
  846. zpos = count_position[Z_AXIS];
  847. CRITICAL_SECTION_END;
  848. #if ENABLED(COREXY) || ENABLED(COREXZ)
  849. SERIAL_PROTOCOLPGM(MSG_COUNT_A);
  850. #else
  851. SERIAL_PROTOCOLPGM(MSG_COUNT_X);
  852. #endif
  853. SERIAL_PROTOCOL(xpos);
  854. #if ENABLED(COREXY) || ENABLED(COREYZ)
  855. SERIAL_PROTOCOLPGM(" B:");
  856. #else
  857. SERIAL_PROTOCOLPGM(" Y:");
  858. #endif
  859. SERIAL_PROTOCOL(ypos);
  860. #if ENABLED(COREXZ) || ENABLED(COREYZ)
  861. SERIAL_PROTOCOLPGM(" C:");
  862. #else
  863. SERIAL_PROTOCOLPGM(" Z:");
  864. #endif
  865. SERIAL_PROTOCOL(zpos);
  866. SERIAL_EOL;
  867. }
  868. #if ENABLED(BABYSTEPPING)
  869. // MUST ONLY BE CALLED BY AN ISR,
  870. // No other ISR should ever interrupt this!
  871. void Stepper::babystep(const uint8_t axis, const bool direction) {
  872. #define _ENABLE(axis) enable_## axis()
  873. #define _READ_DIR(AXIS) AXIS ##_DIR_READ
  874. #define _INVERT_DIR(AXIS) INVERT_## AXIS ##_DIR
  875. #define _APPLY_DIR(AXIS, INVERT) AXIS ##_APPLY_DIR(INVERT, true)
  876. #define BABYSTEP_AXIS(axis, AXIS, INVERT) { \
  877. _ENABLE(axis); \
  878. uint8_t old_pin = _READ_DIR(AXIS); \
  879. _APPLY_DIR(AXIS, _INVERT_DIR(AXIS)^direction^INVERT); \
  880. _APPLY_STEP(AXIS)(!_INVERT_STEP_PIN(AXIS), true); \
  881. delayMicroseconds(2); \
  882. _APPLY_STEP(AXIS)(_INVERT_STEP_PIN(AXIS), true); \
  883. _APPLY_DIR(AXIS, old_pin); \
  884. }
  885. switch (axis) {
  886. case X_AXIS:
  887. BABYSTEP_AXIS(x, X, false);
  888. break;
  889. case Y_AXIS:
  890. BABYSTEP_AXIS(y, Y, false);
  891. break;
  892. case Z_AXIS: {
  893. #if DISABLED(DELTA)
  894. BABYSTEP_AXIS(z, Z, BABYSTEP_INVERT_Z);
  895. #else // DELTA
  896. bool z_direction = direction ^ BABYSTEP_INVERT_Z;
  897. enable_x();
  898. enable_y();
  899. enable_z();
  900. uint8_t old_x_dir_pin = X_DIR_READ,
  901. old_y_dir_pin = Y_DIR_READ,
  902. old_z_dir_pin = Z_DIR_READ;
  903. //setup new step
  904. X_DIR_WRITE(INVERT_X_DIR ^ z_direction);
  905. Y_DIR_WRITE(INVERT_Y_DIR ^ z_direction);
  906. Z_DIR_WRITE(INVERT_Z_DIR ^ z_direction);
  907. //perform step
  908. X_STEP_WRITE(!INVERT_X_STEP_PIN);
  909. Y_STEP_WRITE(!INVERT_Y_STEP_PIN);
  910. Z_STEP_WRITE(!INVERT_Z_STEP_PIN);
  911. delayMicroseconds(2);
  912. X_STEP_WRITE(INVERT_X_STEP_PIN);
  913. Y_STEP_WRITE(INVERT_Y_STEP_PIN);
  914. Z_STEP_WRITE(INVERT_Z_STEP_PIN);
  915. //get old pin state back.
  916. X_DIR_WRITE(old_x_dir_pin);
  917. Y_DIR_WRITE(old_y_dir_pin);
  918. Z_DIR_WRITE(old_z_dir_pin);
  919. #endif
  920. } break;
  921. default: break;
  922. }
  923. }
  924. #endif //BABYSTEPPING
  925. /**
  926. * Software-controlled Stepper Motor Current
  927. */
  928. #if HAS_DIGIPOTSS
  929. // From Arduino DigitalPotControl example
  930. void Stepper::digitalPotWrite(int address, int value) {
  931. digitalWrite(DIGIPOTSS_PIN, LOW); // take the SS pin low to select the chip
  932. SPI.transfer(address); // send in the address and value via SPI:
  933. SPI.transfer(value);
  934. digitalWrite(DIGIPOTSS_PIN, HIGH); // take the SS pin high to de-select the chip:
  935. //delay(10);
  936. }
  937. #endif //HAS_DIGIPOTSS
  938. void Stepper::digipot_init() {
  939. #if HAS_DIGIPOTSS
  940. const uint8_t digipot_motor_current[] = DIGIPOT_MOTOR_CURRENT;
  941. SPI.begin();
  942. pinMode(DIGIPOTSS_PIN, OUTPUT);
  943. for (uint8_t i = 0; i < COUNT(digipot_motor_current); i++) {
  944. //digitalPotWrite(digipot_ch[i], digipot_motor_current[i]);
  945. digipot_current(i, digipot_motor_current[i]);
  946. }
  947. #endif
  948. #if HAS_MOTOR_CURRENT_PWM
  949. #if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
  950. pinMode(MOTOR_CURRENT_PWM_XY_PIN, OUTPUT);
  951. digipot_current(0, motor_current_setting[0]);
  952. #endif
  953. #if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
  954. pinMode(MOTOR_CURRENT_PWM_Z_PIN, OUTPUT);
  955. digipot_current(1, motor_current_setting[1]);
  956. #endif
  957. #if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
  958. pinMode(MOTOR_CURRENT_PWM_E_PIN, OUTPUT);
  959. digipot_current(2, motor_current_setting[2]);
  960. #endif
  961. //Set timer5 to 31khz so the PWM of the motor power is as constant as possible. (removes a buzzing noise)
  962. TCCR5B = (TCCR5B & ~(_BV(CS50) | _BV(CS51) | _BV(CS52))) | _BV(CS50);
  963. #endif
  964. }
  965. void Stepper::digipot_current(uint8_t driver, int current) {
  966. #if HAS_DIGIPOTSS
  967. const uint8_t digipot_ch[] = DIGIPOT_CHANNELS;
  968. digitalPotWrite(digipot_ch[driver], current);
  969. #elif HAS_MOTOR_CURRENT_PWM
  970. #define _WRITE_CURRENT_PWM(P) analogWrite(P, 255L * current / (MOTOR_CURRENT_PWM_RANGE))
  971. switch (driver) {
  972. #if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
  973. case 0: _WRITE_CURRENT_PWM(MOTOR_CURRENT_PWM_XY_PIN); break;
  974. #endif
  975. #if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
  976. case 1: _WRITE_CURRENT_PWM(MOTOR_CURRENT_PWM_Z_PIN); break;
  977. #endif
  978. #if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
  979. case 2: _WRITE_CURRENT_PWM(MOTOR_CURRENT_PWM_E_PIN); break;
  980. #endif
  981. }
  982. #else
  983. UNUSED(driver);
  984. UNUSED(current);
  985. #endif
  986. }
  987. void Stepper::microstep_init() {
  988. #if HAS_MICROSTEPS_E1
  989. pinMode(E1_MS1_PIN, OUTPUT);
  990. pinMode(E1_MS2_PIN, OUTPUT);
  991. #endif
  992. #if HAS_MICROSTEPS
  993. pinMode(X_MS1_PIN, OUTPUT);
  994. pinMode(X_MS2_PIN, OUTPUT);
  995. pinMode(Y_MS1_PIN, OUTPUT);
  996. pinMode(Y_MS2_PIN, OUTPUT);
  997. pinMode(Z_MS1_PIN, OUTPUT);
  998. pinMode(Z_MS2_PIN, OUTPUT);
  999. pinMode(E0_MS1_PIN, OUTPUT);
  1000. pinMode(E0_MS2_PIN, OUTPUT);
  1001. const uint8_t microstep_modes[] = MICROSTEP_MODES;
  1002. for (uint16_t i = 0; i < COUNT(microstep_modes); i++)
  1003. microstep_mode(i, microstep_modes[i]);
  1004. #endif
  1005. }
  1006. /**
  1007. * Software-controlled Microstepping
  1008. */
  1009. void Stepper::microstep_ms(uint8_t driver, int8_t ms1, int8_t ms2) {
  1010. if (ms1 >= 0) switch (driver) {
  1011. case 0: digitalWrite(X_MS1_PIN, ms1); break;
  1012. case 1: digitalWrite(Y_MS1_PIN, ms1); break;
  1013. case 2: digitalWrite(Z_MS1_PIN, ms1); break;
  1014. case 3: digitalWrite(E0_MS1_PIN, ms1); break;
  1015. #if HAS_MICROSTEPS_E1
  1016. case 4: digitalWrite(E1_MS1_PIN, ms1); break;
  1017. #endif
  1018. }
  1019. if (ms2 >= 0) switch (driver) {
  1020. case 0: digitalWrite(X_MS2_PIN, ms2); break;
  1021. case 1: digitalWrite(Y_MS2_PIN, ms2); break;
  1022. case 2: digitalWrite(Z_MS2_PIN, ms2); break;
  1023. case 3: digitalWrite(E0_MS2_PIN, ms2); break;
  1024. #if PIN_EXISTS(E1_MS2)
  1025. case 4: digitalWrite(E1_MS2_PIN, ms2); break;
  1026. #endif
  1027. }
  1028. }
  1029. void Stepper::microstep_mode(uint8_t driver, uint8_t stepping_mode) {
  1030. switch (stepping_mode) {
  1031. case 1: microstep_ms(driver, MICROSTEP1); break;
  1032. case 2: microstep_ms(driver, MICROSTEP2); break;
  1033. case 4: microstep_ms(driver, MICROSTEP4); break;
  1034. case 8: microstep_ms(driver, MICROSTEP8); break;
  1035. case 16: microstep_ms(driver, MICROSTEP16); break;
  1036. }
  1037. }
  1038. void Stepper::microstep_readings() {
  1039. SERIAL_PROTOCOLLNPGM("MS1,MS2 Pins");
  1040. SERIAL_PROTOCOLPGM("X: ");
  1041. SERIAL_PROTOCOL(digitalRead(X_MS1_PIN));
  1042. SERIAL_PROTOCOLLN(digitalRead(X_MS2_PIN));
  1043. SERIAL_PROTOCOLPGM("Y: ");
  1044. SERIAL_PROTOCOL(digitalRead(Y_MS1_PIN));
  1045. SERIAL_PROTOCOLLN(digitalRead(Y_MS2_PIN));
  1046. SERIAL_PROTOCOLPGM("Z: ");
  1047. SERIAL_PROTOCOL(digitalRead(Z_MS1_PIN));
  1048. SERIAL_PROTOCOLLN(digitalRead(Z_MS2_PIN));
  1049. SERIAL_PROTOCOLPGM("E0: ");
  1050. SERIAL_PROTOCOL(digitalRead(E0_MS1_PIN));
  1051. SERIAL_PROTOCOLLN(digitalRead(E0_MS2_PIN));
  1052. #if HAS_MICROSTEPS_E1
  1053. SERIAL_PROTOCOLPGM("E1: ");
  1054. SERIAL_PROTOCOL(digitalRead(E1_MS1_PIN));
  1055. SERIAL_PROTOCOLLN(digitalRead(E1_MS2_PIN));
  1056. #endif
  1057. }
  1058. #if ENABLED(LIN_ADVANCE)
  1059. void Stepper::advance_M905(const float &k) {
  1060. if (k >= 0) extruder_advance_k = k;
  1061. SERIAL_ECHO_START;
  1062. SERIAL_ECHOPAIR("Advance factor: ", extruder_advance_k);
  1063. SERIAL_EOL;
  1064. }
  1065. #endif // LIN_ADVANCE