My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.

planner.h 11KB

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