My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.

planner.h 11KB

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