My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Du kannst nicht mehr als 25 Themen auswählen Themen müssen mit entweder einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.

planner.h 11KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315
  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. * planner.h
  24. *
  25. * Buffer movement commands and manage the acceleration profile plan
  26. *
  27. * Derived from Grbl
  28. * Copyright (c) 2009-2011 Simen Svale Skogsrud
  29. */
  30. #ifndef PLANNER_H
  31. #define PLANNER_H
  32. #include "Marlin.h"
  33. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  34. #include "vector_3.h"
  35. #endif
  36. class Planner;
  37. extern Planner planner;
  38. /**
  39. * struct block_t
  40. *
  41. * A single entry in the planner buffer.
  42. * Tracks linear movement over multiple axes.
  43. *
  44. * The "nominal" values are as-specified by gcode, and
  45. * may never actually be reached due to acceleration limits.
  46. */
  47. typedef struct {
  48. unsigned char active_extruder; // The extruder to move (if E move)
  49. // Fields used by the bresenham algorithm for tracing the line
  50. long steps[NUM_AXIS]; // Step count along each axis
  51. unsigned long step_event_count; // The number of step events required to complete this block
  52. long accelerate_until; // The index of the step event on which to stop acceleration
  53. long decelerate_after; // The index of the step event on which to start decelerating
  54. long acceleration_rate; // The acceleration rate used for acceleration calculation
  55. unsigned char direction_bits; // The direction bit set for this block (refers to *_DIRECTION_BIT in config.h)
  56. #if ENABLED(ADVANCE)
  57. long advance_rate;
  58. volatile long initial_advance;
  59. volatile long final_advance;
  60. float advance;
  61. #endif
  62. // Fields used by the motion planner to manage acceleration
  63. float nominal_speed; // The nominal speed for this block in mm/sec
  64. float entry_speed; // Entry speed at previous-current junction in mm/sec
  65. float max_entry_speed; // Maximum allowable junction entry speed in mm/sec
  66. float millimeters; // The total travel of this block in mm
  67. float acceleration; // acceleration mm/sec^2
  68. unsigned char recalculate_flag; // Planner flag to recalculate trapezoids on entry junction
  69. unsigned char nominal_length_flag; // Planner flag for nominal speed always reached
  70. // Settings for the trapezoid generator
  71. unsigned long nominal_rate; // The nominal step rate for this block in step_events/sec
  72. unsigned long initial_rate; // The jerk-adjusted step rate at start of block
  73. unsigned long final_rate; // The minimal rate at exit
  74. unsigned long acceleration_st; // acceleration steps/sec^2
  75. #if FAN_COUNT > 0
  76. unsigned long fan_speed[FAN_COUNT];
  77. #endif
  78. #if ENABLED(BARICUDA)
  79. unsigned long valve_pressure;
  80. unsigned long e_to_p_pressure;
  81. #endif
  82. volatile char busy;
  83. } block_t;
  84. #define BLOCK_MOD(n) ((n)&(BLOCK_BUFFER_SIZE-1))
  85. class Planner {
  86. public:
  87. /**
  88. * A ring buffer of moves described in steps
  89. */
  90. block_t block_buffer[BLOCK_BUFFER_SIZE];
  91. volatile uint8_t block_buffer_head = 0; // Index of the next block to be pushed
  92. volatile uint8_t block_buffer_tail = 0;
  93. float max_feedrate[NUM_AXIS]; // Max speeds in mm per minute
  94. float axis_steps_per_unit[NUM_AXIS];
  95. unsigned long axis_steps_per_sqr_second[NUM_AXIS];
  96. unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software
  97. millis_t min_segment_time;
  98. float min_feedrate;
  99. float acceleration; // Normal acceleration mm/s^2 DEFAULT ACCELERATION for all printing moves. M204 SXXXX
  100. float retract_acceleration; // Retract acceleration mm/s^2 filament pull-back and push-forward while standing still in the other axes M204 TXXXX
  101. float travel_acceleration; // Travel acceleration mm/s^2 DEFAULT ACCELERATION for all NON printing moves. M204 MXXXX
  102. float max_xy_jerk; // The largest speed change requiring no acceleration
  103. float max_z_jerk;
  104. float max_e_jerk;
  105. float min_travel_feedrate;
  106. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  107. matrix_3x3 bed_level_matrix; // Transform to compensate for bed level
  108. #endif
  109. private:
  110. /**
  111. * The current position of the tool in absolute steps
  112. * Reclculated if any axis_steps_per_unit are changed by gcode
  113. */
  114. long position[NUM_AXIS] = { 0 };
  115. /**
  116. * Speed of previous path line segment
  117. */
  118. float previous_speed[NUM_AXIS];
  119. /**
  120. * Nominal speed of previous path line segment
  121. */
  122. float previous_nominal_speed;
  123. #if ENABLED(DISABLE_INACTIVE_EXTRUDER)
  124. /**
  125. * Counters to manage disabling inactive extruders
  126. */
  127. uint8_t g_uc_extruder_last_move[EXTRUDERS] = { 0 };
  128. #endif // DISABLE_INACTIVE_EXTRUDER
  129. #ifdef XY_FREQUENCY_LIMIT
  130. // Used for the frequency limit
  131. #define MAX_FREQ_TIME (1000000.0/XY_FREQUENCY_LIMIT)
  132. // Old direction bits. Used for speed calculations
  133. static unsigned char old_direction_bits = 0;
  134. // Segment times (in µs). Used for speed calculations
  135. static long axis_segment_time[2][3] = { {MAX_FREQ_TIME + 1, 0, 0}, {MAX_FREQ_TIME + 1, 0, 0} };
  136. #endif
  137. public:
  138. Planner();
  139. void init();
  140. void reset_acceleration_rates();
  141. // Manage fans, paste pressure, etc.
  142. void check_axes_activity();
  143. /**
  144. * Number of moves currently in the planner
  145. */
  146. FORCE_INLINE uint8_t movesplanned() { return BLOCK_MOD(block_buffer_head - block_buffer_tail + BLOCK_BUFFER_SIZE); }
  147. #if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING)
  148. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  149. /**
  150. * The corrected position, applying the bed level matrix
  151. */
  152. vector_3 adjusted_position();
  153. #endif
  154. /**
  155. * Add a new linear movement to the buffer.
  156. *
  157. * x,y,z,e - target position in mm
  158. * feed_rate - (target) speed of the move
  159. * extruder - target extruder
  160. */
  161. void buffer_line(float x, float y, float z, const float& e, float feed_rate, const uint8_t extruder);
  162. /**
  163. * Set the planner.position and individual stepper positions.
  164. * Used by G92, G28, G29, and other procedures.
  165. *
  166. * Multiplies by axis_steps_per_unit[] and does necessary conversion
  167. * for COREXY / COREXZ / COREYZ to set the corresponding stepper positions.
  168. *
  169. * Clears previous speed values.
  170. */
  171. void set_position(float x, float y, float z, const float& e);
  172. #else
  173. void buffer_line(const float& x, const float& y, const float& z, const float& e, float feed_rate, const uint8_t extruder);
  174. void set_position(const float& x, const float& y, const float& z, const float& e);
  175. #endif // AUTO_BED_LEVELING_FEATURE || MESH_BED_LEVELING
  176. /**
  177. * Set the E position (mm) of the planner (and the E stepper)
  178. */
  179. void set_e_position(const float& e);
  180. /**
  181. * Does the buffer have any blocks queued?
  182. */
  183. FORCE_INLINE bool blocks_queued() { return (block_buffer_head != block_buffer_tail); }
  184. /**
  185. * "Discards" the block and "releases" the memory.
  186. * Called when the current block is no longer needed.
  187. */
  188. FORCE_INLINE void discard_current_block() {
  189. if (blocks_queued())
  190. block_buffer_tail = BLOCK_MOD(block_buffer_tail + 1);
  191. }
  192. /**
  193. * The current block. NULL if the buffer is empty.
  194. * This also marks the block as busy.
  195. */
  196. FORCE_INLINE block_t* get_current_block() {
  197. if (blocks_queued()) {
  198. block_t* block = &block_buffer[block_buffer_tail];
  199. block->busy = true;
  200. return block;
  201. }
  202. else
  203. return NULL;
  204. }
  205. #if ENABLED(AUTOTEMP)
  206. float autotemp_max = 250;
  207. float autotemp_min = 210;
  208. float autotemp_factor = 0.1;
  209. bool autotemp_enabled = false;
  210. void getHighESpeed();
  211. void autotemp_M109();
  212. #endif
  213. private:
  214. /**
  215. * Get the index of the next / previous block in the ring buffer
  216. */
  217. FORCE_INLINE int8_t next_block_index(int8_t block_index) { return BLOCK_MOD(block_index + 1); }
  218. FORCE_INLINE int8_t prev_block_index(int8_t block_index) { return BLOCK_MOD(block_index - 1); }
  219. /**
  220. * Calculate the distance (not time) it takes to accelerate
  221. * from initial_rate to target_rate using the given acceleration:
  222. */
  223. FORCE_INLINE float estimate_acceleration_distance(float initial_rate, float target_rate, float acceleration) {
  224. if (acceleration == 0) return 0; // acceleration was 0, set acceleration distance to 0
  225. return (target_rate * target_rate - initial_rate * initial_rate) / (acceleration * 2);
  226. }
  227. /**
  228. * Return the point at which you must start braking (at the rate of -'acceleration') if
  229. * you start at 'initial_rate', accelerate (until reaching the point), and want to end at
  230. * 'final_rate' after traveling 'distance'.
  231. *
  232. * This is used to compute the intersection point between acceleration and deceleration
  233. * in cases where the "trapezoid" has no plateau (i.e., never reaches maximum speed)
  234. */
  235. FORCE_INLINE float intersection_distance(float initial_rate, float final_rate, float acceleration, float distance) {
  236. if (acceleration == 0) return 0; // acceleration was 0, set intersection distance to 0
  237. return (acceleration * 2 * distance - initial_rate * initial_rate + final_rate * final_rate) / (acceleration * 4);
  238. }
  239. /**
  240. * Calculate the maximum allowable speed at this point, in order
  241. * to reach 'target_velocity' using 'acceleration' within a given
  242. * 'distance'.
  243. */
  244. FORCE_INLINE float max_allowable_speed(float acceleration, float target_velocity, float distance) {
  245. return sqrt(target_velocity * target_velocity - 2 * acceleration * distance);
  246. }
  247. void calculate_trapezoid_for_block(block_t* block, float entry_factor, float exit_factor);
  248. void reverse_pass_kernel(block_t* previous, block_t* current, block_t* next);
  249. void forward_pass_kernel(block_t* previous, block_t* current, block_t* next);
  250. void reverse_pass();
  251. void forward_pass();
  252. void recalculate_trapezoids();
  253. void recalculate();
  254. };
  255. #endif // PLANNER_H