My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341
  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 "math.h"
  28. #include "vector_3.h"
  29. #define UBL_VERSION "1.00"
  30. #define UBL_OK false
  31. #define UBL_ERR true
  32. typedef struct {
  33. int8_t x_index, y_index;
  34. float distance; // When populated, the distance from the search location
  35. } mesh_index_pair;
  36. enum MeshPointType { INVALID, REAL, SET_IN_BITMAP };
  37. void dump(char * const str, const float &f);
  38. bool ubl_lcd_clicked();
  39. void probe_entire_mesh(const float&, const float&, const bool, const bool, const bool);
  40. void debug_current_and_destination(const char * const title);
  41. void ubl_line_to_destination(const float&, uint8_t);
  42. void manually_probe_remaining_mesh(const float&, const float&, const float&, const float&, const bool);
  43. vector_3 tilt_mesh_based_on_3pts(const float&, const float&, const float&);
  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 find_mean_mesh_height();
  47. void shift_mesh_height();
  48. bool g29_parameter_parsing();
  49. void g29_what_command();
  50. void g29_eeprom_dump();
  51. void g29_compare_current_mesh_to_stored_mesh();
  52. void fine_tune_mesh(const float&, const float&, const bool);
  53. void bit_clear(uint16_t bits[16], uint8_t x, uint8_t y);
  54. void bit_set(uint16_t bits[16], uint8_t x, uint8_t y);
  55. bool is_bit_set(uint16_t bits[16], uint8_t x, uint8_t y);
  56. char *ftostr43sign(const float&, char);
  57. void gcode_G26();
  58. void gcode_G28();
  59. void gcode_G29();
  60. extern char conv[9];
  61. void save_ubl_active_state_and_disable();
  62. void restore_ubl_active_state_and_leave();
  63. ///////////////////////////////////////////////////////////////////////////////////////////////////////
  64. #if ENABLED(ULTRA_LCD)
  65. extern char lcd_status_message[];
  66. void lcd_quick_feedback();
  67. #endif
  68. enum MBLStatus { MBL_STATUS_NONE = 0, MBL_STATUS_HAS_MESH_BIT = 0, MBL_STATUS_ACTIVE_BIT = 1 };
  69. #define MESH_X_DIST (float(UBL_MESH_MAX_X - (UBL_MESH_MIN_X)) / float(GRID_MAX_POINTS_X - 1))
  70. #define MESH_Y_DIST (float(UBL_MESH_MAX_Y - (UBL_MESH_MIN_Y)) / float(GRID_MAX_POINTS_Y - 1))
  71. typedef struct {
  72. bool active = false;
  73. float z_offset = 0.0;
  74. int8_t eeprom_storage_slot = -1,
  75. n_x = GRID_MAX_POINTS_X,
  76. n_y = GRID_MAX_POINTS_Y;
  77. float mesh_x_min = UBL_MESH_MIN_X,
  78. mesh_y_min = UBL_MESH_MIN_Y,
  79. mesh_x_max = UBL_MESH_MAX_X,
  80. mesh_y_max = UBL_MESH_MAX_Y,
  81. mesh_x_dist = MESH_X_DIST,
  82. mesh_y_dist = MESH_Y_DIST;
  83. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  84. float g29_correction_fade_height = 10.0,
  85. g29_fade_height_multiplier = 1.0 / 10.0; // It's cheaper to do a floating point multiply than divide,
  86. // so keep this value and its reciprocal.
  87. #endif
  88. // If you change this struct, adjust TOTAL_STRUCT_SIZE
  89. #define TOTAL_STRUCT_SIZE 40 // Total size of the above fields
  90. // padding provides space to add state variables without
  91. // changing the location of data structures in the EEPROM.
  92. // This is for compatibility with future versions to keep
  93. // users from having to regenerate their mesh data.
  94. unsigned char padding[64 - TOTAL_STRUCT_SIZE];
  95. } ubl_state;
  96. class unified_bed_leveling {
  97. private:
  98. static float last_specified_z;
  99. public:
  100. static ubl_state state, pre_initialized;
  101. static float z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y],
  102. mesh_index_to_xpos[GRID_MAX_POINTS_X + 1], // +1 safety margin for now, until determinism prevails
  103. mesh_index_to_ypos[GRID_MAX_POINTS_Y + 1];
  104. static bool g26_debug_flag,
  105. has_control_of_lcd_panel;
  106. static int8_t eeprom_start;
  107. static volatile int encoder_diff; // Volatile because it's changed at interrupt time.
  108. unified_bed_leveling();
  109. static void display_map(const int);
  110. static void reset();
  111. static void invalidate();
  112. static void store_state();
  113. static void load_state();
  114. static void store_mesh(const int16_t);
  115. static void load_mesh(const int16_t);
  116. static bool sanity_check();
  117. static FORCE_INLINE void set_z(const int8_t px, const int8_t py, const float &z) { z_values[px][py] = z; }
  118. static int8_t get_cell_index_x(const float &x) {
  119. const int8_t cx = (x - (UBL_MESH_MIN_X)) * (1.0 / (MESH_X_DIST));
  120. return constrain(cx, 0, (GRID_MAX_POINTS_X) - 1); // -1 is appropriate if we want all movement to the X_MAX
  121. } // position. But with this defined this way, it is possible
  122. // to extrapolate off of this point even further out. Probably
  123. // that is OK because something else should be keeping that from
  124. // happening and should not be worried about at this level.
  125. static int8_t get_cell_index_y(const float &y) {
  126. const int8_t cy = (y - (UBL_MESH_MIN_Y)) * (1.0 / (MESH_Y_DIST));
  127. return constrain(cy, 0, (GRID_MAX_POINTS_Y) - 1); // -1 is appropriate if we want all movement to the Y_MAX
  128. } // position. But with this defined this way, it is possible
  129. // to extrapolate off of this point even further out. Probably
  130. // that is OK because something else should be keeping that from
  131. // happening and should not be worried about at this level.
  132. static int8_t find_closest_x_index(const float &x) {
  133. const int8_t px = (x - (UBL_MESH_MIN_X) + (MESH_X_DIST) * 0.5) * (1.0 / (MESH_X_DIST));
  134. return WITHIN(px, 0, GRID_MAX_POINTS_X - 1) ? px : -1;
  135. }
  136. static int8_t find_closest_y_index(const float &y) {
  137. const int8_t py = (y - (UBL_MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * (1.0 / (MESH_Y_DIST));
  138. return WITHIN(py, 0, GRID_MAX_POINTS_Y - 1) ? py : -1;
  139. }
  140. /**
  141. * z2 --|
  142. * z0 | |
  143. * | | + (z2-z1)
  144. * z1 | | |
  145. * ---+-------------+--------+-- --|
  146. * a1 a0 a2
  147. * |<---delta_a---------->|
  148. *
  149. * calc_z0 is the basis for all the Mesh Based correction. It is used to
  150. * find the expected Z Height at a position between two known Z-Height locations.
  151. *
  152. * It is fairly expensive with its 4 floating point additions and 2 floating point
  153. * multiplications.
  154. */
  155. static FORCE_INLINE float calc_z0(const float &a0, const float &a1, const float &z1, const float &a2, const float &z2) {
  156. return z1 + (z2 - z1) * (a0 - a1) / (a2 - a1);
  157. }
  158. /**
  159. * z_correction_for_x_on_horizontal_mesh_line is an optimization for
  160. * the rare occasion when a point lies exactly on a Mesh line (denoted by index yi).
  161. */
  162. static inline float z_correction_for_x_on_horizontal_mesh_line(const float &lx0, const int x1_i, const int yi) {
  163. if (!WITHIN(x1_i, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(yi, 0, GRID_MAX_POINTS_Y - 1)) {
  164. SERIAL_ECHOPAIR("? in z_correction_for_x_on_horizontal_mesh_line(lx0=", lx0);
  165. SERIAL_ECHOPAIR(",x1_i=", x1_i);
  166. SERIAL_ECHOPAIR(",yi=", yi);
  167. SERIAL_CHAR(')');
  168. SERIAL_EOL;
  169. return NAN;
  170. }
  171. const float xratio = (RAW_X_POSITION(lx0) - mesh_index_to_xpos[x1_i]) * (1.0 / (MESH_X_DIST)),
  172. z1 = z_values[x1_i][yi];
  173. return z1 + xratio * (z_values[x1_i + 1][yi] - z1);
  174. }
  175. //
  176. // See comments above for z_correction_for_x_on_horizontal_mesh_line
  177. //
  178. static inline float z_correction_for_y_on_vertical_mesh_line(const float &ly0, const int xi, const int y1_i) {
  179. if (!WITHIN(xi, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(y1_i, 0, GRID_MAX_POINTS_Y - 1)) {
  180. SERIAL_ECHOPAIR("? in get_z_correction_along_vertical_mesh_line_at_specific_x(ly0=", ly0);
  181. SERIAL_ECHOPAIR(", x1_i=", xi);
  182. SERIAL_ECHOPAIR(", yi=", y1_i);
  183. SERIAL_CHAR(')');
  184. SERIAL_EOL;
  185. return NAN;
  186. }
  187. const float yratio = (RAW_Y_POSITION(ly0) - mesh_index_to_ypos[y1_i]) * (1.0 / (MESH_Y_DIST)),
  188. z1 = z_values[xi][y1_i];
  189. return z1 + yratio * (z_values[xi][y1_i + 1] - z1);
  190. }
  191. /**
  192. * This is the generic Z-Correction. It works anywhere within a Mesh Cell. It first
  193. * does a linear interpolation along both of the bounding X-Mesh-Lines to find the
  194. * Z-Height at both ends. Then it does a linear interpolation of these heights based
  195. * on the Y position within the cell.
  196. */
  197. static float get_z_correction(const float &lx0, const float &ly0) {
  198. const int8_t cx = get_cell_index_x(RAW_X_POSITION(lx0)),
  199. cy = get_cell_index_y(RAW_Y_POSITION(ly0));
  200. if (!WITHIN(cx, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(cy, 0, GRID_MAX_POINTS_Y - 1)) {
  201. SERIAL_ECHOPAIR("? in get_z_correction(lx0=", lx0);
  202. SERIAL_ECHOPAIR(", ly0=", ly0);
  203. SERIAL_CHAR(')');
  204. SERIAL_EOL;
  205. #if ENABLED(ULTRA_LCD)
  206. strcpy(lcd_status_message, "get_z_correction() indexes out of range.");
  207. lcd_quick_feedback();
  208. #endif
  209. return 0.0; // this used to return state.z_offset
  210. }
  211. const float z1 = calc_z0(RAW_X_POSITION(lx0),
  212. mesh_index_to_xpos[cx], z_values[cx][cy],
  213. mesh_index_to_xpos[cx + 1], z_values[cx + 1][cy]),
  214. z2 = calc_z0(RAW_X_POSITION(lx0),
  215. mesh_index_to_xpos[cx], z_values[cx][cy + 1],
  216. mesh_index_to_xpos[cx + 1], z_values[cx + 1][cy + 1]);
  217. float z0 = calc_z0(RAW_Y_POSITION(ly0),
  218. mesh_index_to_ypos[cy], z1,
  219. mesh_index_to_ypos[cy + 1], z2);
  220. #if ENABLED(DEBUG_LEVELING_FEATURE)
  221. if (DEBUGGING(MESH_ADJUST)) {
  222. SERIAL_ECHOPAIR(" raw get_z_correction(", lx0);
  223. SERIAL_CHAR(',');
  224. SERIAL_ECHO(ly0);
  225. SERIAL_ECHOPGM(") = ");
  226. SERIAL_ECHO_F(z0, 6);
  227. }
  228. #endif
  229. #if ENABLED(DEBUG_LEVELING_FEATURE)
  230. if (DEBUGGING(MESH_ADJUST)) {
  231. SERIAL_ECHOPGM(" >>>---> ");
  232. SERIAL_ECHO_F(z0, 6);
  233. SERIAL_EOL;
  234. }
  235. #endif
  236. if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN
  237. z0 = 0.0; // in ubl.z_values[][] and propagate through the
  238. // calculations. If our correction is NAN, we throw it out
  239. // because part of the Mesh is undefined and we don't have the
  240. // information we need to complete the height correction.
  241. #if ENABLED(DEBUG_LEVELING_FEATURE)
  242. if (DEBUGGING(MESH_ADJUST)) {
  243. SERIAL_ECHOPAIR("??? Yikes! NAN in get_z_correction(", lx0);
  244. SERIAL_CHAR(',');
  245. SERIAL_ECHO(ly0);
  246. SERIAL_CHAR(')');
  247. SERIAL_EOL;
  248. }
  249. #endif
  250. }
  251. return z0; // there used to be a +state.z_offset on this line
  252. }
  253. /**
  254. * This function sets the Z leveling fade factor based on the given Z height,
  255. * only re-calculating when necessary.
  256. *
  257. * Returns 1.0 if g29_correction_fade_height is 0.0.
  258. * Returns 0.0 if Z is past the specified 'Fade Height'.
  259. */
  260. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  261. static FORCE_INLINE float fade_scaling_factor_for_z(const float &lz) {
  262. if (state.g29_correction_fade_height == 0.0) return 1.0;
  263. static float fade_scaling_factor = 1.0;
  264. const float rz = RAW_Z_POSITION(lz);
  265. if (last_specified_z != rz) {
  266. last_specified_z = rz;
  267. fade_scaling_factor =
  268. rz < state.g29_correction_fade_height
  269. ? 1.0 - (rz * state.g29_fade_height_multiplier)
  270. : 0.0;
  271. }
  272. return fade_scaling_factor;
  273. }
  274. #endif
  275. }; // class unified_bed_leveling
  276. extern unified_bed_leveling ubl;
  277. #define UBL_LAST_EEPROM_INDEX (E2END - sizeof(unified_bed_leveling::state))
  278. #endif // AUTO_BED_LEVELING_UBL
  279. #endif // UNIFIED_BED_LEVELING_H