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.

ubl.h 16KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371
  1. /**
  2. * Marlin 3D Printer Firmware
  3. * Copyright (C) 2016, 2017 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. #ifndef UNIFIED_BED_LEVELING_H
  23. #define UNIFIED_BED_LEVELING_H
  24. #include "MarlinConfig.h"
  25. #if ENABLED(AUTO_BED_LEVELING_UBL)
  26. #include "Marlin.h"
  27. #include "planner.h"
  28. #include "math.h"
  29. #include "vector_3.h"
  30. #define UBL_VERSION "1.00"
  31. #define UBL_OK false
  32. #define UBL_ERR true
  33. typedef struct {
  34. int8_t x_index, y_index;
  35. float distance; // When populated, the distance from the search location
  36. } mesh_index_pair;
  37. enum MeshPointType { INVALID, REAL, SET_IN_BITMAP };
  38. void dump(char * const str, const float &f);
  39. bool ubl_lcd_clicked();
  40. void probe_entire_mesh(const float&, const float&, const bool, const bool, const bool);
  41. void debug_current_and_destination(const char * const title);
  42. void ubl_line_to_destination(const float&, uint8_t);
  43. void manually_probe_remaining_mesh(const float&, const float&, const float&, const float&, const bool);
  44. float measure_business_card_thickness(const float&);
  45. mesh_index_pair find_closest_mesh_point_of_type(const MeshPointType, const float&, const float&, const bool, unsigned int[16], bool);
  46. void shift_mesh_height();
  47. bool g29_parameter_parsing();
  48. void g29_what_command();
  49. void g29_eeprom_dump();
  50. void g29_compare_current_mesh_to_stored_mesh();
  51. void fine_tune_mesh(const float&, const float&, const bool);
  52. void bit_clear(uint16_t bits[16], uint8_t x, uint8_t y);
  53. void bit_set(uint16_t bits[16], uint8_t x, uint8_t y);
  54. bool is_bit_set(uint16_t bits[16], uint8_t x, uint8_t y);
  55. char *ftostr43sign(const float&, char);
  56. void gcode_G26();
  57. void gcode_G28();
  58. void gcode_G29();
  59. extern int ubl_cnt;
  60. ///////////////////////////////////////////////////////////////////////////////////////////////////////
  61. #if ENABLED(ULTRA_LCD)
  62. extern char lcd_status_message[];
  63. void lcd_quick_feedback();
  64. #endif
  65. #define MESH_X_DIST (float(UBL_MESH_MAX_X - (UBL_MESH_MIN_X)) / float(GRID_MAX_POINTS_X - 1))
  66. #define MESH_Y_DIST (float(UBL_MESH_MAX_Y - (UBL_MESH_MIN_Y)) / float(GRID_MAX_POINTS_Y - 1))
  67. typedef struct {
  68. bool active = false;
  69. float z_offset = 0.0;
  70. int8_t eeprom_storage_slot = -1;
  71. } ubl_state;
  72. class unified_bed_leveling {
  73. private:
  74. static float last_specified_z;
  75. public:
  76. //
  77. // Please do not put STATIC qualifiers in front of ANYTHING in this file. You WILL cause problems by doing that.
  78. // The GCC optimizer inlines static functions and this DRAMATICALLY increases the size of the stack frame of
  79. // functions that call STATIC functions.
  80. //
  81. void find_mean_mesh_height();
  82. void shift_mesh_height();
  83. void probe_entire_mesh(const float &lx, const float &ly, const bool do_ubl_mesh_map, const bool stow_probe, bool do_furthest);
  84. void tilt_mesh_based_on_3pts(const float &z1, const float &z2, const float &z3);
  85. void tilt_mesh_based_on_probed_grid(const bool do_ubl_mesh_map);
  86. void manually_probe_remaining_mesh(const float &lx, const float &ly, const float &z_clearance, const float &card_thickness, const bool do_ubl_mesh_map);
  87. void save_ubl_active_state_and_disable();
  88. void restore_ubl_active_state_and_leave();
  89. void g29_what_command();
  90. //
  91. // Please do not put STATIC qualifiers in front of ANYTHING in this file. You WILL cause problems by doing that.
  92. // The GCC optimizer inlines static functions and this DRAMATICALLY increases the size of the stack frame of
  93. // functions that call STATIC functions.
  94. //
  95. void g29_eeprom_dump() ;
  96. void g29_compare_current_mesh_to_stored_mesh();
  97. void fine_tune_mesh(const float &lx, const float &ly, const bool do_ubl_mesh_map);
  98. void smart_fill_mesh();
  99. void display_map(const int);
  100. void reset();
  101. //
  102. // Please do not put STATIC qualifiers in front of ANYTHING in this file. You WILL cause problems by doing that.
  103. // The GCC optimizer inlines static functions and this DRAMATICALLY increases the size of the stack frame of
  104. // functions that call STATIC functions.
  105. //
  106. void invalidate();
  107. void store_state();
  108. void load_state();
  109. void store_mesh(const int16_t);
  110. void load_mesh(const int16_t);
  111. bool sanity_check();
  112. static ubl_state state;
  113. static float z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
  114. // 15 is the maximum nubmer of grid points supported + 1 safety margin for now,
  115. // until determinism prevails
  116. constexpr static float mesh_index_to_xpos[16] PROGMEM = { UBL_MESH_MIN_X+0*(MESH_X_DIST),
  117. UBL_MESH_MIN_X+1*(MESH_X_DIST), UBL_MESH_MIN_X+2*(MESH_X_DIST),
  118. UBL_MESH_MIN_X+3*(MESH_X_DIST), UBL_MESH_MIN_X+4*(MESH_X_DIST),
  119. UBL_MESH_MIN_X+5*(MESH_X_DIST), UBL_MESH_MIN_X+6*(MESH_X_DIST),
  120. UBL_MESH_MIN_X+7*(MESH_X_DIST), UBL_MESH_MIN_X+8*(MESH_X_DIST),
  121. UBL_MESH_MIN_X+9*(MESH_X_DIST), UBL_MESH_MIN_X+10*(MESH_X_DIST),
  122. UBL_MESH_MIN_X+11*(MESH_X_DIST), UBL_MESH_MIN_X+12*(MESH_X_DIST),
  123. UBL_MESH_MIN_X+13*(MESH_X_DIST), UBL_MESH_MIN_X+14*(MESH_X_DIST),
  124. UBL_MESH_MIN_X+15*(MESH_X_DIST) };
  125. constexpr static float mesh_index_to_ypos[16] PROGMEM = { UBL_MESH_MIN_Y+0*(MESH_Y_DIST),
  126. UBL_MESH_MIN_Y+1*(MESH_Y_DIST), UBL_MESH_MIN_Y+2*(MESH_Y_DIST),
  127. UBL_MESH_MIN_Y+3*(MESH_Y_DIST), UBL_MESH_MIN_Y+4*(MESH_Y_DIST),
  128. UBL_MESH_MIN_Y+5*(MESH_Y_DIST), UBL_MESH_MIN_Y+6*(MESH_Y_DIST),
  129. UBL_MESH_MIN_Y+7*(MESH_Y_DIST), UBL_MESH_MIN_Y+8*(MESH_Y_DIST),
  130. UBL_MESH_MIN_Y+9*(MESH_Y_DIST), UBL_MESH_MIN_Y+10*(MESH_Y_DIST),
  131. UBL_MESH_MIN_Y+11*(MESH_Y_DIST), UBL_MESH_MIN_Y+12*(MESH_Y_DIST),
  132. UBL_MESH_MIN_Y+13*(MESH_Y_DIST), UBL_MESH_MIN_Y+14*(MESH_Y_DIST),
  133. UBL_MESH_MIN_Y+15*(MESH_Y_DIST) };
  134. static bool g26_debug_flag, has_control_of_lcd_panel;
  135. static int16_t eeprom_start; // Please do no change this to 8 bits in size
  136. // It needs to hold values bigger than this.
  137. static volatile int encoder_diff; // Volatile because it's changed at interrupt time.
  138. unified_bed_leveling();
  139. //
  140. // Please do not put STATIC qualifiers in front of ANYTHING in this file. You WILL cause problems by doing that.
  141. // The GCC optimizer inlines static functions and this DRAMATICALLY increases the size of the stack frame of
  142. // functions that call STATIC functions.
  143. //
  144. FORCE_INLINE void set_z(const int8_t px, const int8_t py, const float &z) { z_values[px][py] = z; }
  145. int8_t get_cell_index_x(const float &x) {
  146. const int8_t cx = (x - (UBL_MESH_MIN_X)) * (1.0 / (MESH_X_DIST));
  147. return constrain(cx, 0, (GRID_MAX_POINTS_X) - 1); // -1 is appropriate if we want all movement to the X_MAX
  148. } // position. But with this defined this way, it is possible
  149. // to extrapolate off of this point even further out. Probably
  150. // that is OK because something else should be keeping that from
  151. // happening and should not be worried about at this level.
  152. int8_t get_cell_index_y(const float &y) {
  153. const int8_t cy = (y - (UBL_MESH_MIN_Y)) * (1.0 / (MESH_Y_DIST));
  154. return constrain(cy, 0, (GRID_MAX_POINTS_Y) - 1); // -1 is appropriate if we want all movement to the Y_MAX
  155. } // position. But with this defined this way, it is possible
  156. // to extrapolate off of this point even further out. Probably
  157. // that is OK because something else should be keeping that from
  158. // happening and should not be worried about at this level.
  159. //
  160. // Please do not put STATIC qualifiers in front of ANYTHING in this file. You WILL cause problems by doing that.
  161. // The GCC optimizer inlines static functions and this DRAMATICALLY increases the size of the stack frame of
  162. // functions that call STATIC functions.
  163. //
  164. int8_t find_closest_x_index(const float &x) {
  165. const int8_t px = (x - (UBL_MESH_MIN_X) + (MESH_X_DIST) * 0.5) * (1.0 / (MESH_X_DIST));
  166. return WITHIN(px, 0, GRID_MAX_POINTS_X - 1) ? px : -1;
  167. }
  168. int8_t find_closest_y_index(const float &y) {
  169. const int8_t py = (y - (UBL_MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * (1.0 / (MESH_Y_DIST));
  170. return WITHIN(py, 0, GRID_MAX_POINTS_Y - 1) ? py : -1;
  171. }
  172. /**
  173. * z2 --|
  174. * z0 | |
  175. * | | + (z2-z1)
  176. * z1 | | |
  177. * ---+-------------+--------+-- --|
  178. * a1 a0 a2
  179. * |<---delta_a---------->|
  180. *
  181. * calc_z0 is the basis for all the Mesh Based correction. It is used to
  182. * find the expected Z Height at a position between two known Z-Height locations.
  183. *
  184. * It is fairly expensive with its 4 floating point additions and 2 floating point
  185. * multiplications.
  186. */
  187. FORCE_INLINE float calc_z0(const float &a0, const float &a1, const float &z1, const float &a2, const float &z2) {
  188. return z1 + (z2 - z1) * (a0 - a1) / (a2 - a1);
  189. }
  190. //
  191. // Please do not put STATIC qualifiers in front of ANYTHING in this file. You WILL cause problems by doing that.
  192. // The GCC optimizer inlines static functions and this DRAMATICALLY increases the size of the stack frame of
  193. // functions that call STATIC functions.
  194. //
  195. /**
  196. * z_correction_for_x_on_horizontal_mesh_line is an optimization for
  197. * the rare occasion when a point lies exactly on a Mesh line (denoted by index yi).
  198. */
  199. inline float z_correction_for_x_on_horizontal_mesh_line(const float &lx0, const int x1_i, const int yi) {
  200. if (!WITHIN(x1_i, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(yi, 0, GRID_MAX_POINTS_Y - 1)) {
  201. SERIAL_ECHOPAIR("? in z_correction_for_x_on_horizontal_mesh_line(lx0=", lx0);
  202. SERIAL_ECHOPAIR(",x1_i=", x1_i);
  203. SERIAL_ECHOPAIR(",yi=", yi);
  204. SERIAL_CHAR(')');
  205. SERIAL_EOL;
  206. return NAN;
  207. }
  208. const float xratio = (RAW_X_POSITION(lx0) - pgm_read_float(&mesh_index_to_xpos[x1_i])) * (1.0 / (MESH_X_DIST)),
  209. z1 = z_values[x1_i][yi];
  210. return z1 + xratio * (z_values[x1_i + 1][yi] - z1);
  211. }
  212. //
  213. // See comments above for z_correction_for_x_on_horizontal_mesh_line
  214. //
  215. inline float z_correction_for_y_on_vertical_mesh_line(const float &ly0, const int xi, const int y1_i) {
  216. if (!WITHIN(xi, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(y1_i, 0, GRID_MAX_POINTS_Y - 1)) {
  217. SERIAL_ECHOPAIR("? in get_z_correction_along_vertical_mesh_line_at_specific_x(ly0=", ly0);
  218. SERIAL_ECHOPAIR(", x1_i=", xi);
  219. SERIAL_ECHOPAIR(", yi=", y1_i);
  220. SERIAL_CHAR(')');
  221. SERIAL_EOL;
  222. return NAN;
  223. }
  224. const float yratio = (RAW_Y_POSITION(ly0) - pgm_read_float(&mesh_index_to_ypos[y1_i])) * (1.0 / (MESH_Y_DIST)),
  225. z1 = z_values[xi][y1_i];
  226. return z1 + yratio * (z_values[xi][y1_i + 1] - z1);
  227. }
  228. /**
  229. * This is the generic Z-Correction. It works anywhere within a Mesh Cell. It first
  230. * does a linear interpolation along both of the bounding X-Mesh-Lines to find the
  231. * Z-Height at both ends. Then it does a linear interpolation of these heights based
  232. * on the Y position within the cell.
  233. */
  234. float get_z_correction(const float &lx0, const float &ly0) {
  235. const int8_t cx = get_cell_index_x(RAW_X_POSITION(lx0)),
  236. cy = get_cell_index_y(RAW_Y_POSITION(ly0));
  237. if (!WITHIN(cx, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(cy, 0, GRID_MAX_POINTS_Y - 1)) {
  238. SERIAL_ECHOPAIR("? in get_z_correction(lx0=", lx0);
  239. SERIAL_ECHOPAIR(", ly0=", ly0);
  240. SERIAL_CHAR(')');
  241. SERIAL_EOL;
  242. #if ENABLED(ULTRA_LCD)
  243. strcpy(lcd_status_message, "get_z_correction() indexes out of range.");
  244. lcd_quick_feedback();
  245. #endif
  246. return 0.0; // this used to return state.z_offset
  247. }
  248. const float z1 = calc_z0(RAW_X_POSITION(lx0),
  249. pgm_read_float(&mesh_index_to_xpos[cx]), z_values[cx][cy],
  250. pgm_read_float(&mesh_index_to_xpos[cx + 1]), z_values[cx + 1][cy]);
  251. const float z2 = calc_z0(RAW_X_POSITION(lx0),
  252. pgm_read_float(&mesh_index_to_xpos[cx]), z_values[cx][cy + 1],
  253. pgm_read_float(&mesh_index_to_xpos[cx + 1]), z_values[cx + 1][cy + 1]);
  254. float z0 = calc_z0(RAW_Y_POSITION(ly0),
  255. pgm_read_float(&mesh_index_to_ypos[cy]), z1,
  256. pgm_read_float(&mesh_index_to_ypos[cy + 1]), z2);
  257. #if ENABLED(DEBUG_LEVELING_FEATURE)
  258. if (DEBUGGING(MESH_ADJUST)) {
  259. SERIAL_ECHOPAIR(" raw get_z_correction(", lx0);
  260. SERIAL_CHAR(',');
  261. SERIAL_ECHO(ly0);
  262. SERIAL_ECHOPGM(") = ");
  263. SERIAL_ECHO_F(z0, 6);
  264. }
  265. #endif
  266. #if ENABLED(DEBUG_LEVELING_FEATURE)
  267. if (DEBUGGING(MESH_ADJUST)) {
  268. SERIAL_ECHOPGM(" >>>---> ");
  269. SERIAL_ECHO_F(z0, 6);
  270. SERIAL_EOL;
  271. }
  272. #endif
  273. if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN
  274. z0 = 0.0; // in ubl.z_values[][] and propagate through the
  275. // calculations. If our correction is NAN, we throw it out
  276. // because part of the Mesh is undefined and we don't have the
  277. // information we need to complete the height correction.
  278. #if ENABLED(DEBUG_LEVELING_FEATURE)
  279. if (DEBUGGING(MESH_ADJUST)) {
  280. SERIAL_ECHOPAIR("??? Yikes! NAN in get_z_correction(", lx0);
  281. SERIAL_CHAR(',');
  282. SERIAL_ECHO(ly0);
  283. SERIAL_CHAR(')');
  284. SERIAL_EOL;
  285. }
  286. #endif
  287. }
  288. return z0; // there used to be a +state.z_offset on this line
  289. }
  290. /**
  291. * This function sets the Z leveling fade factor based on the given Z height,
  292. * only re-calculating when necessary.
  293. *
  294. * Returns 1.0 if planner.z_fade_height is 0.0.
  295. * Returns 0.0 if Z is past the specified 'Fade Height'.
  296. */
  297. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  298. FORCE_INLINE float fade_scaling_factor_for_z(const float &lz) {
  299. if (planner.z_fade_height == 0.0) return 1.0;
  300. static float fade_scaling_factor = 1.0;
  301. const float rz = RAW_Z_POSITION(lz);
  302. if (last_specified_z != rz) {
  303. last_specified_z = rz;
  304. fade_scaling_factor =
  305. rz < planner.z_fade_height
  306. ? 1.0 - (rz * planner.inverse_z_fade_height)
  307. : 0.0;
  308. }
  309. return fade_scaling_factor;
  310. }
  311. #endif
  312. }; // class unified_bed_leveling
  313. extern unified_bed_leveling ubl;
  314. #define UBL_LAST_EEPROM_INDEX E2END
  315. #endif // AUTO_BED_LEVELING_UBL
  316. #endif // UNIFIED_BED_LEVELING_H