My Marlin configs for Fabrikator Mini and CTC i3 Pro B
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

configuration_store.cpp 30KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965
  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. * configuration_store.cpp
  24. *
  25. * Configuration and EEPROM storage
  26. *
  27. * IMPORTANT: Whenever there are changes made to the variables stored in EEPROM
  28. * in the functions below, also increment the version number. This makes sure that
  29. * the default values are used whenever there is a change to the data, to prevent
  30. * wrong data being written to the variables.
  31. *
  32. * ALSO: Variables in the Store and Retrieve sections must be in the same order.
  33. * If a feature is disabled, some data must still be written that, when read,
  34. * either sets a Sane Default, or results in No Change to the existing value.
  35. *
  36. */
  37. #define EEPROM_VERSION "V24"
  38. // Change EEPROM version if these are changed:
  39. #define EEPROM_OFFSET 100
  40. #define MAX_EXTRUDERS 4
  41. /**
  42. * V24 EEPROM Layout:
  43. *
  44. * 100 Version (char x4)
  45. * 104 EEPROM Checksum (uint16_t)
  46. *
  47. * 106 M92 XYZE planner.axis_steps_per_mm (float x4)
  48. * 122 M203 XYZE planner.max_feedrate (float x4)
  49. * 138 M201 XYZE planner.max_acceleration_mm_per_s2 (uint32_t x4)
  50. * 154 M204 P planner.acceleration (float)
  51. * 158 M204 R planner.retract_acceleration (float)
  52. * 162 M204 T planner.travel_acceleration (float)
  53. * 166 M205 S planner.min_feedrate (float)
  54. * 170 M205 T planner.min_travel_feedrate (float)
  55. * 174 M205 B planner.min_segment_time (ulong)
  56. * 178 M205 X planner.max_xy_jerk (float)
  57. * 182 M205 Z planner.max_z_jerk (float)
  58. * 186 M205 E planner.max_e_jerk (float)
  59. * 190 M206 XYZ home_offset (float x3)
  60. *
  61. * Mesh bed leveling:
  62. * 202 M420 S status (uint8)
  63. * 203 z_offset (float)
  64. * 207 mesh_num_x (uint8 as set in firmware)
  65. * 208 mesh_num_y (uint8 as set in firmware)
  66. * 209 G29 S3 XYZ z_values[][] (float x9, by default)
  67. *
  68. * AUTO BED LEVELING
  69. * 245 M851 zprobe_zoffset (float)
  70. *
  71. * DELTA:
  72. * 249 M666 XYZ endstop_adj (float x3)
  73. * 261 M665 R delta_radius (float)
  74. * 265 M665 L delta_diagonal_rod (float)
  75. * 269 M665 S delta_segments_per_second (float)
  76. * 273 M665 A delta_diagonal_rod_trim_tower_1 (float)
  77. * 277 M665 B delta_diagonal_rod_trim_tower_2 (float)
  78. * 281 M665 C delta_diagonal_rod_trim_tower_3 (float)
  79. *
  80. * Z_DUAL_ENDSTOPS:
  81. * 285 M666 Z z_endstop_adj (float)
  82. *
  83. * ULTIPANEL:
  84. * 289 M145 S0 H plaPreheatHotendTemp (int)
  85. * 291 M145 S0 B plaPreheatHPBTemp (int)
  86. * 293 M145 S0 F plaPreheatFanSpeed (int)
  87. * 295 M145 S1 H absPreheatHotendTemp (int)
  88. * 297 M145 S1 B absPreheatHPBTemp (int)
  89. * 299 M145 S1 F absPreheatFanSpeed (int)
  90. *
  91. * PIDTEMP:
  92. * 301 M301 E0 PIDC Kp[0], Ki[0], Kd[0], Kc[0] (float x4)
  93. * 317 M301 E1 PIDC Kp[1], Ki[1], Kd[1], Kc[1] (float x4)
  94. * 333 M301 E2 PIDC Kp[2], Ki[2], Kd[2], Kc[2] (float x4)
  95. * 349 M301 E3 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
  96. * 365 M301 L lpq_len (int)
  97. *
  98. * PIDTEMPBED:
  99. * 367 M304 PID thermalManager.bedKp, thermalManager.bedKi, thermalManager.bedKd (float x3)
  100. *
  101. * DOGLCD:
  102. * 379 M250 C lcd_contrast (int)
  103. *
  104. * SCARA:
  105. * 381 M365 XYZ axis_scaling (float x3)
  106. *
  107. * FWRETRACT:
  108. * 393 M209 S autoretract_enabled (bool)
  109. * 394 M207 S retract_length (float)
  110. * 398 M207 W retract_length_swap (float)
  111. * 402 M207 F retract_feedrate_mm_s (float)
  112. * 406 M207 Z retract_zlift (float)
  113. * 410 M208 S retract_recover_length (float)
  114. * 414 M208 W retract_recover_length_swap (float)
  115. * 418 M208 F retract_recover_feedrate (float)
  116. *
  117. * Volumetric Extrusion:
  118. * 422 M200 D volumetric_enabled (bool)
  119. * 423 M200 T D filament_size (float x4) (T0..3)
  120. *
  121. * 439 This Slot is Available!
  122. *
  123. */
  124. #include "Marlin.h"
  125. #include "language.h"
  126. #include "planner.h"
  127. #include "temperature.h"
  128. #include "ultralcd.h"
  129. #include "configuration_store.h"
  130. #if ENABLED(MESH_BED_LEVELING)
  131. #include "mesh_bed_leveling.h"
  132. #endif
  133. uint16_t eeprom_checksum;
  134. const char version[4] = EEPROM_VERSION;
  135. void _EEPROM_writeData(int &pos, uint8_t* value, uint8_t size) {
  136. uint8_t c;
  137. while (size--) {
  138. eeprom_write_byte((unsigned char*)pos, *value);
  139. c = eeprom_read_byte((unsigned char*)pos);
  140. if (c != *value) {
  141. SERIAL_ECHO_START;
  142. SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
  143. }
  144. eeprom_checksum += c;
  145. pos++;
  146. value++;
  147. };
  148. }
  149. void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size) {
  150. do {
  151. uint8_t c = eeprom_read_byte((unsigned char*)pos);
  152. *value = c;
  153. eeprom_checksum += c;
  154. pos++;
  155. value++;
  156. } while (--size);
  157. }
  158. /**
  159. * Post-process after Retrieve or Reset
  160. */
  161. void Config_Postprocess() {
  162. // steps per s2 needs to be updated to agree with units per s2
  163. planner.reset_acceleration_rates();
  164. #if ENABLED(DELTA)
  165. recalc_delta_settings(delta_radius, delta_diagonal_rod);
  166. #endif
  167. #if ENABLED(PIDTEMP)
  168. thermalManager.updatePID();
  169. #endif
  170. calculate_volumetric_multipliers();
  171. }
  172. #if ENABLED(EEPROM_SETTINGS)
  173. #define DUMMY_PID_VALUE 3000.0f
  174. #define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value))
  175. #define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value))
  176. /**
  177. * M500 - Store Configuration
  178. */
  179. void Config_StoreSettings() {
  180. float dummy = 0.0f;
  181. char ver[4] = "000";
  182. int i = EEPROM_OFFSET;
  183. EEPROM_WRITE_VAR(i, ver); // invalidate data first
  184. i += sizeof(eeprom_checksum); // Skip the checksum slot
  185. eeprom_checksum = 0; // clear before first "real data"
  186. EEPROM_WRITE_VAR(i, planner.axis_steps_per_mm);
  187. EEPROM_WRITE_VAR(i, planner.max_feedrate);
  188. EEPROM_WRITE_VAR(i, planner.max_acceleration_mm_per_s2);
  189. EEPROM_WRITE_VAR(i, planner.acceleration);
  190. EEPROM_WRITE_VAR(i, planner.retract_acceleration);
  191. EEPROM_WRITE_VAR(i, planner.travel_acceleration);
  192. EEPROM_WRITE_VAR(i, planner.min_feedrate);
  193. EEPROM_WRITE_VAR(i, planner.min_travel_feedrate);
  194. EEPROM_WRITE_VAR(i, planner.min_segment_time);
  195. EEPROM_WRITE_VAR(i, planner.max_xy_jerk);
  196. EEPROM_WRITE_VAR(i, planner.max_z_jerk);
  197. EEPROM_WRITE_VAR(i, planner.max_e_jerk);
  198. EEPROM_WRITE_VAR(i, home_offset);
  199. #if ENABLED(MESH_BED_LEVELING)
  200. // Compile time test that sizeof(mbl.z_values) is as expected
  201. typedef char c_assert[(sizeof(mbl.z_values) == (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS) * sizeof(dummy)) ? 1 : -1];
  202. uint8_t mesh_num_x = MESH_NUM_X_POINTS,
  203. mesh_num_y = MESH_NUM_Y_POINTS,
  204. dummy_uint8 = mbl.status & _BV(MBL_STATUS_HAS_MESH_BIT);
  205. EEPROM_WRITE_VAR(i, dummy_uint8);
  206. EEPROM_WRITE_VAR(i, mbl.z_offset);
  207. EEPROM_WRITE_VAR(i, mesh_num_x);
  208. EEPROM_WRITE_VAR(i, mesh_num_y);
  209. EEPROM_WRITE_VAR(i, mbl.z_values);
  210. #else
  211. uint8_t mesh_num_x = 3,
  212. mesh_num_y = 3,
  213. dummy_uint8 = 0;
  214. dummy = 0.0f;
  215. EEPROM_WRITE_VAR(i, dummy_uint8);
  216. EEPROM_WRITE_VAR(i, dummy);
  217. EEPROM_WRITE_VAR(i, mesh_num_x);
  218. EEPROM_WRITE_VAR(i, mesh_num_y);
  219. for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_WRITE_VAR(i, dummy);
  220. #endif // MESH_BED_LEVELING
  221. #if !HAS_BED_PROBE
  222. float zprobe_zoffset = 0;
  223. #endif
  224. EEPROM_WRITE_VAR(i, zprobe_zoffset);
  225. #if ENABLED(DELTA)
  226. EEPROM_WRITE_VAR(i, endstop_adj); // 3 floats
  227. EEPROM_WRITE_VAR(i, delta_radius); // 1 float
  228. EEPROM_WRITE_VAR(i, delta_diagonal_rod); // 1 float
  229. EEPROM_WRITE_VAR(i, delta_segments_per_second); // 1 float
  230. EEPROM_WRITE_VAR(i, delta_diagonal_rod_trim_tower_1); // 1 float
  231. EEPROM_WRITE_VAR(i, delta_diagonal_rod_trim_tower_2); // 1 float
  232. EEPROM_WRITE_VAR(i, delta_diagonal_rod_trim_tower_3); // 1 float
  233. #elif ENABLED(Z_DUAL_ENDSTOPS)
  234. EEPROM_WRITE_VAR(i, z_endstop_adj); // 1 float
  235. dummy = 0.0f;
  236. for (uint8_t q = 8; q--;) EEPROM_WRITE_VAR(i, dummy);
  237. #else
  238. dummy = 0.0f;
  239. for (uint8_t q = 9; q--;) EEPROM_WRITE_VAR(i, dummy);
  240. #endif
  241. #if DISABLED(ULTIPANEL)
  242. int plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP, plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP, plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED,
  243. absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP, absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP, absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
  244. #endif // !ULTIPANEL
  245. EEPROM_WRITE_VAR(i, plaPreheatHotendTemp);
  246. EEPROM_WRITE_VAR(i, plaPreheatHPBTemp);
  247. EEPROM_WRITE_VAR(i, plaPreheatFanSpeed);
  248. EEPROM_WRITE_VAR(i, absPreheatHotendTemp);
  249. EEPROM_WRITE_VAR(i, absPreheatHPBTemp);
  250. EEPROM_WRITE_VAR(i, absPreheatFanSpeed);
  251. for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
  252. #if ENABLED(PIDTEMP)
  253. if (e < HOTENDS) {
  254. EEPROM_WRITE_VAR(i, PID_PARAM(Kp, e));
  255. EEPROM_WRITE_VAR(i, PID_PARAM(Ki, e));
  256. EEPROM_WRITE_VAR(i, PID_PARAM(Kd, e));
  257. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  258. EEPROM_WRITE_VAR(i, PID_PARAM(Kc, e));
  259. #else
  260. dummy = 1.0f; // 1.0 = default kc
  261. EEPROM_WRITE_VAR(i, dummy);
  262. #endif
  263. }
  264. else
  265. #endif // !PIDTEMP
  266. {
  267. dummy = DUMMY_PID_VALUE; // When read, will not change the existing value
  268. EEPROM_WRITE_VAR(i, dummy); // Kp
  269. dummy = 0.0f;
  270. for (uint8_t q = 3; q--;) EEPROM_WRITE_VAR(i, dummy); // Ki, Kd, Kc
  271. }
  272. } // Hotends Loop
  273. #if DISABLED(PID_ADD_EXTRUSION_RATE)
  274. int lpq_len = 20;
  275. #endif
  276. EEPROM_WRITE_VAR(i, lpq_len);
  277. #if DISABLED(PIDTEMPBED)
  278. dummy = DUMMY_PID_VALUE;
  279. for (uint8_t q = 3; q--;) EEPROM_WRITE_VAR(i, dummy);
  280. #else
  281. EEPROM_WRITE_VAR(i, thermalManager.bedKp);
  282. EEPROM_WRITE_VAR(i, thermalManager.bedKi);
  283. EEPROM_WRITE_VAR(i, thermalManager.bedKd);
  284. #endif
  285. #if !HAS_LCD_CONTRAST
  286. const int lcd_contrast = 32;
  287. #endif
  288. EEPROM_WRITE_VAR(i, lcd_contrast);
  289. #if ENABLED(SCARA)
  290. EEPROM_WRITE_VAR(i, axis_scaling); // 3 floats
  291. #else
  292. dummy = 1.0f;
  293. EEPROM_WRITE_VAR(i, dummy);
  294. #endif
  295. #if ENABLED(FWRETRACT)
  296. EEPROM_WRITE_VAR(i, autoretract_enabled);
  297. EEPROM_WRITE_VAR(i, retract_length);
  298. #if EXTRUDERS > 1
  299. EEPROM_WRITE_VAR(i, retract_length_swap);
  300. #else
  301. dummy = 0.0f;
  302. EEPROM_WRITE_VAR(i, dummy);
  303. #endif
  304. EEPROM_WRITE_VAR(i, retract_feedrate_mm_s);
  305. EEPROM_WRITE_VAR(i, retract_zlift);
  306. EEPROM_WRITE_VAR(i, retract_recover_length);
  307. #if EXTRUDERS > 1
  308. EEPROM_WRITE_VAR(i, retract_recover_length_swap);
  309. #else
  310. dummy = 0.0f;
  311. EEPROM_WRITE_VAR(i, dummy);
  312. #endif
  313. EEPROM_WRITE_VAR(i, retract_recover_feedrate);
  314. #endif // FWRETRACT
  315. EEPROM_WRITE_VAR(i, volumetric_enabled);
  316. // Save filament sizes
  317. for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
  318. if (q < EXTRUDERS) dummy = filament_size[q];
  319. EEPROM_WRITE_VAR(i, dummy);
  320. }
  321. uint16_t final_checksum = eeprom_checksum;
  322. int j = EEPROM_OFFSET;
  323. EEPROM_WRITE_VAR(j, version);
  324. EEPROM_WRITE_VAR(j, final_checksum);
  325. // Report storage size
  326. SERIAL_ECHO_START;
  327. SERIAL_ECHOPAIR("Settings Stored (", i);
  328. SERIAL_ECHOLNPGM(" bytes)");
  329. }
  330. /**
  331. * M501 - Retrieve Configuration
  332. */
  333. void Config_RetrieveSettings() {
  334. int i = EEPROM_OFFSET;
  335. char stored_ver[4];
  336. uint16_t stored_checksum;
  337. EEPROM_READ_VAR(i, stored_ver);
  338. EEPROM_READ_VAR(i, stored_checksum);
  339. // SERIAL_ECHOPAIR("Version: [", ver);
  340. // SERIAL_ECHOPAIR("] Stored version: [", stored_ver);
  341. // SERIAL_ECHOLNPGM("]");
  342. if (strncmp(version, stored_ver, 3) != 0) {
  343. Config_ResetDefault();
  344. }
  345. else {
  346. float dummy = 0;
  347. eeprom_checksum = 0; // clear before reading first "real data"
  348. // version number match
  349. EEPROM_READ_VAR(i, planner.axis_steps_per_mm);
  350. EEPROM_READ_VAR(i, planner.max_feedrate);
  351. EEPROM_READ_VAR(i, planner.max_acceleration_mm_per_s2);
  352. EEPROM_READ_VAR(i, planner.acceleration);
  353. EEPROM_READ_VAR(i, planner.retract_acceleration);
  354. EEPROM_READ_VAR(i, planner.travel_acceleration);
  355. EEPROM_READ_VAR(i, planner.min_feedrate);
  356. EEPROM_READ_VAR(i, planner.min_travel_feedrate);
  357. EEPROM_READ_VAR(i, planner.min_segment_time);
  358. EEPROM_READ_VAR(i, planner.max_xy_jerk);
  359. EEPROM_READ_VAR(i, planner.max_z_jerk);
  360. EEPROM_READ_VAR(i, planner.max_e_jerk);
  361. EEPROM_READ_VAR(i, home_offset);
  362. uint8_t dummy_uint8 = 0, mesh_num_x = 0, mesh_num_y = 0;
  363. EEPROM_READ_VAR(i, dummy_uint8);
  364. EEPROM_READ_VAR(i, dummy);
  365. EEPROM_READ_VAR(i, mesh_num_x);
  366. EEPROM_READ_VAR(i, mesh_num_y);
  367. #if ENABLED(MESH_BED_LEVELING)
  368. mbl.status = dummy_uint8;
  369. mbl.z_offset = dummy;
  370. if (mesh_num_x == MESH_NUM_X_POINTS && mesh_num_y == MESH_NUM_Y_POINTS) {
  371. EEPROM_READ_VAR(i, mbl.z_values);
  372. } else {
  373. mbl.reset();
  374. for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ_VAR(i, dummy);
  375. }
  376. #else
  377. for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ_VAR(i, dummy);
  378. #endif // MESH_BED_LEVELING
  379. #if !HAS_BED_PROBE
  380. float zprobe_zoffset = 0;
  381. #endif
  382. EEPROM_READ_VAR(i, zprobe_zoffset);
  383. #if ENABLED(DELTA)
  384. EEPROM_READ_VAR(i, endstop_adj); // 3 floats
  385. EEPROM_READ_VAR(i, delta_radius); // 1 float
  386. EEPROM_READ_VAR(i, delta_diagonal_rod); // 1 float
  387. EEPROM_READ_VAR(i, delta_segments_per_second); // 1 float
  388. EEPROM_READ_VAR(i, delta_diagonal_rod_trim_tower_1); // 1 float
  389. EEPROM_READ_VAR(i, delta_diagonal_rod_trim_tower_2); // 1 float
  390. EEPROM_READ_VAR(i, delta_diagonal_rod_trim_tower_3); // 1 float
  391. #elif ENABLED(Z_DUAL_ENDSTOPS)
  392. EEPROM_READ_VAR(i, z_endstop_adj);
  393. dummy = 0.0f;
  394. for (uint8_t q=8; q--;) EEPROM_READ_VAR(i, dummy);
  395. #else
  396. dummy = 0.0f;
  397. for (uint8_t q=9; q--;) EEPROM_READ_VAR(i, dummy);
  398. #endif
  399. #if DISABLED(ULTIPANEL)
  400. int plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed,
  401. absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed;
  402. #endif
  403. EEPROM_READ_VAR(i, plaPreheatHotendTemp);
  404. EEPROM_READ_VAR(i, plaPreheatHPBTemp);
  405. EEPROM_READ_VAR(i, plaPreheatFanSpeed);
  406. EEPROM_READ_VAR(i, absPreheatHotendTemp);
  407. EEPROM_READ_VAR(i, absPreheatHPBTemp);
  408. EEPROM_READ_VAR(i, absPreheatFanSpeed);
  409. #if ENABLED(PIDTEMP)
  410. for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
  411. EEPROM_READ_VAR(i, dummy); // Kp
  412. if (e < HOTENDS && dummy != DUMMY_PID_VALUE) {
  413. // do not need to scale PID values as the values in EEPROM are already scaled
  414. PID_PARAM(Kp, e) = dummy;
  415. EEPROM_READ_VAR(i, PID_PARAM(Ki, e));
  416. EEPROM_READ_VAR(i, PID_PARAM(Kd, e));
  417. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  418. EEPROM_READ_VAR(i, PID_PARAM(Kc, e));
  419. #else
  420. EEPROM_READ_VAR(i, dummy);
  421. #endif
  422. }
  423. else {
  424. for (uint8_t q=3; q--;) EEPROM_READ_VAR(i, dummy); // Ki, Kd, Kc
  425. }
  426. }
  427. #else // !PIDTEMP
  428. // 4 x 4 = 16 slots for PID parameters
  429. for (uint8_t q = MAX_EXTRUDERS * 4; q--;) EEPROM_READ_VAR(i, dummy); // Kp, Ki, Kd, Kc
  430. #endif // !PIDTEMP
  431. #if DISABLED(PID_ADD_EXTRUSION_RATE)
  432. int lpq_len;
  433. #endif
  434. EEPROM_READ_VAR(i, lpq_len);
  435. #if ENABLED(PIDTEMPBED)
  436. EEPROM_READ_VAR(i, dummy); // bedKp
  437. if (dummy != DUMMY_PID_VALUE) {
  438. thermalManager.bedKp = dummy;
  439. EEPROM_READ_VAR(i, thermalManager.bedKi);
  440. EEPROM_READ_VAR(i, thermalManager.bedKd);
  441. }
  442. #else
  443. for (uint8_t q=3; q--;) EEPROM_READ_VAR(i, dummy); // bedKp, bedKi, bedKd
  444. #endif
  445. #if !HAS_LCD_CONTRAST
  446. int lcd_contrast;
  447. #endif
  448. EEPROM_READ_VAR(i, lcd_contrast);
  449. #if ENABLED(SCARA)
  450. EEPROM_READ_VAR(i, axis_scaling); // 3 floats
  451. #else
  452. EEPROM_READ_VAR(i, dummy);
  453. #endif
  454. #if ENABLED(FWRETRACT)
  455. EEPROM_READ_VAR(i, autoretract_enabled);
  456. EEPROM_READ_VAR(i, retract_length);
  457. #if EXTRUDERS > 1
  458. EEPROM_READ_VAR(i, retract_length_swap);
  459. #else
  460. EEPROM_READ_VAR(i, dummy);
  461. #endif
  462. EEPROM_READ_VAR(i, retract_feedrate_mm_s);
  463. EEPROM_READ_VAR(i, retract_zlift);
  464. EEPROM_READ_VAR(i, retract_recover_length);
  465. #if EXTRUDERS > 1
  466. EEPROM_READ_VAR(i, retract_recover_length_swap);
  467. #else
  468. EEPROM_READ_VAR(i, dummy);
  469. #endif
  470. EEPROM_READ_VAR(i, retract_recover_feedrate);
  471. #endif // FWRETRACT
  472. EEPROM_READ_VAR(i, volumetric_enabled);
  473. for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
  474. EEPROM_READ_VAR(i, dummy);
  475. if (q < EXTRUDERS) filament_size[q] = dummy;
  476. }
  477. if (eeprom_checksum == stored_checksum) {
  478. Config_Postprocess();
  479. SERIAL_ECHO_START;
  480. SERIAL_ECHO(version);
  481. SERIAL_ECHOPAIR(" stored settings retrieved (", i);
  482. SERIAL_ECHOLNPGM(" bytes)");
  483. }
  484. else {
  485. SERIAL_ERROR_START;
  486. SERIAL_ERRORLNPGM("EEPROM checksum mismatch");
  487. Config_ResetDefault();
  488. }
  489. }
  490. #if ENABLED(EEPROM_CHITCHAT)
  491. Config_PrintSettings();
  492. #endif
  493. }
  494. #endif // EEPROM_SETTINGS
  495. /**
  496. * M502 - Reset Configuration
  497. */
  498. void Config_ResetDefault() {
  499. float tmp1[] = DEFAULT_AXIS_STEPS_PER_UNIT;
  500. float tmp2[] = DEFAULT_MAX_FEEDRATE;
  501. long tmp3[] = DEFAULT_MAX_ACCELERATION;
  502. for (uint8_t i = 0; i < NUM_AXIS; i++) {
  503. planner.axis_steps_per_mm[i] = tmp1[i];
  504. planner.max_feedrate[i] = tmp2[i];
  505. planner.max_acceleration_mm_per_s2[i] = tmp3[i];
  506. #if ENABLED(SCARA)
  507. if (i < COUNT(axis_scaling))
  508. axis_scaling[i] = 1;
  509. #endif
  510. }
  511. planner.acceleration = DEFAULT_ACCELERATION;
  512. planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
  513. planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
  514. planner.min_feedrate = DEFAULT_MINIMUMFEEDRATE;
  515. planner.min_segment_time = DEFAULT_MINSEGMENTTIME;
  516. planner.min_travel_feedrate = DEFAULT_MINTRAVELFEEDRATE;
  517. planner.max_xy_jerk = DEFAULT_XYJERK;
  518. planner.max_z_jerk = DEFAULT_ZJERK;
  519. planner.max_e_jerk = DEFAULT_EJERK;
  520. home_offset[X_AXIS] = home_offset[Y_AXIS] = home_offset[Z_AXIS] = 0;
  521. #if ENABLED(MESH_BED_LEVELING)
  522. mbl.reset();
  523. #endif
  524. #if HAS_BED_PROBE
  525. zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER;
  526. #endif
  527. #if ENABLED(DELTA)
  528. endstop_adj[X_AXIS] = endstop_adj[Y_AXIS] = endstop_adj[Z_AXIS] = 0;
  529. delta_radius = DELTA_RADIUS;
  530. delta_diagonal_rod = DELTA_DIAGONAL_ROD;
  531. delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;
  532. delta_diagonal_rod_trim_tower_1 = DELTA_DIAGONAL_ROD_TRIM_TOWER_1;
  533. delta_diagonal_rod_trim_tower_2 = DELTA_DIAGONAL_ROD_TRIM_TOWER_2;
  534. delta_diagonal_rod_trim_tower_3 = DELTA_DIAGONAL_ROD_TRIM_TOWER_3;
  535. #elif ENABLED(Z_DUAL_ENDSTOPS)
  536. z_endstop_adj = 0;
  537. #endif
  538. #if ENABLED(ULTIPANEL)
  539. plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP;
  540. plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP;
  541. plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED;
  542. absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP;
  543. absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP;
  544. absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
  545. #endif
  546. #if HAS_LCD_CONTRAST
  547. lcd_contrast = DEFAULT_LCD_CONTRAST;
  548. #endif
  549. #if ENABLED(PIDTEMP)
  550. #if ENABLED(PID_PARAMS_PER_HOTEND)
  551. for (uint8_t e = 0; e < HOTENDS; e++)
  552. #else
  553. int e = 0; UNUSED(e); // only need to write once
  554. #endif
  555. {
  556. PID_PARAM(Kp, e) = DEFAULT_Kp;
  557. PID_PARAM(Ki, e) = scalePID_i(DEFAULT_Ki);
  558. PID_PARAM(Kd, e) = scalePID_d(DEFAULT_Kd);
  559. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  560. PID_PARAM(Kc, e) = DEFAULT_Kc;
  561. #endif
  562. }
  563. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  564. lpq_len = 20; // default last-position-queue size
  565. #endif
  566. #endif // PIDTEMP
  567. #if ENABLED(PIDTEMPBED)
  568. thermalManager.bedKp = DEFAULT_bedKp;
  569. thermalManager.bedKi = scalePID_i(DEFAULT_bedKi);
  570. thermalManager.bedKd = scalePID_d(DEFAULT_bedKd);
  571. #endif
  572. #if ENABLED(FWRETRACT)
  573. autoretract_enabled = false;
  574. retract_length = RETRACT_LENGTH;
  575. #if EXTRUDERS > 1
  576. retract_length_swap = RETRACT_LENGTH_SWAP;
  577. #endif
  578. retract_feedrate_mm_s = RETRACT_FEEDRATE;
  579. retract_zlift = RETRACT_ZLIFT;
  580. retract_recover_length = RETRACT_RECOVER_LENGTH;
  581. #if EXTRUDERS > 1
  582. retract_recover_length_swap = RETRACT_RECOVER_LENGTH_SWAP;
  583. #endif
  584. retract_recover_feedrate = RETRACT_RECOVER_FEEDRATE;
  585. #endif
  586. volumetric_enabled = false;
  587. for (uint8_t q = 0; q < COUNT(filament_size); q++)
  588. filament_size[q] = DEFAULT_NOMINAL_FILAMENT_DIA;
  589. Config_Postprocess();
  590. SERIAL_ECHO_START;
  591. SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
  592. }
  593. #if DISABLED(DISABLE_M503)
  594. #define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START; }while(0)
  595. /**
  596. * M503 - Print Configuration
  597. */
  598. void Config_PrintSettings(bool forReplay) {
  599. // Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown
  600. CONFIG_ECHO_START;
  601. if (!forReplay) {
  602. SERIAL_ECHOLNPGM("Steps per unit:");
  603. CONFIG_ECHO_START;
  604. }
  605. SERIAL_ECHOPAIR(" M92 X", planner.axis_steps_per_mm[X_AXIS]);
  606. SERIAL_ECHOPAIR(" Y", planner.axis_steps_per_mm[Y_AXIS]);
  607. SERIAL_ECHOPAIR(" Z", planner.axis_steps_per_mm[Z_AXIS]);
  608. SERIAL_ECHOPAIR(" E", planner.axis_steps_per_mm[E_AXIS]);
  609. SERIAL_EOL;
  610. CONFIG_ECHO_START;
  611. #if ENABLED(SCARA)
  612. if (!forReplay) {
  613. SERIAL_ECHOLNPGM("Scaling factors:");
  614. CONFIG_ECHO_START;
  615. }
  616. SERIAL_ECHOPAIR(" M365 X", axis_scaling[X_AXIS]);
  617. SERIAL_ECHOPAIR(" Y", axis_scaling[Y_AXIS]);
  618. SERIAL_ECHOPAIR(" Z", axis_scaling[Z_AXIS]);
  619. SERIAL_EOL;
  620. CONFIG_ECHO_START;
  621. #endif // SCARA
  622. if (!forReplay) {
  623. SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
  624. CONFIG_ECHO_START;
  625. }
  626. SERIAL_ECHOPAIR(" M203 X", planner.max_feedrate[X_AXIS]);
  627. SERIAL_ECHOPAIR(" Y", planner.max_feedrate[Y_AXIS]);
  628. SERIAL_ECHOPAIR(" Z", planner.max_feedrate[Z_AXIS]);
  629. SERIAL_ECHOPAIR(" E", planner.max_feedrate[E_AXIS]);
  630. SERIAL_EOL;
  631. CONFIG_ECHO_START;
  632. if (!forReplay) {
  633. SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
  634. CONFIG_ECHO_START;
  635. }
  636. SERIAL_ECHOPAIR(" M201 X", planner.max_acceleration_mm_per_s2[X_AXIS]);
  637. SERIAL_ECHOPAIR(" Y", planner.max_acceleration_mm_per_s2[Y_AXIS]);
  638. SERIAL_ECHOPAIR(" Z", planner.max_acceleration_mm_per_s2[Z_AXIS]);
  639. SERIAL_ECHOPAIR(" E", planner.max_acceleration_mm_per_s2[E_AXIS]);
  640. SERIAL_EOL;
  641. CONFIG_ECHO_START;
  642. if (!forReplay) {
  643. SERIAL_ECHOLNPGM("Accelerations: P=printing, R=retract and T=travel");
  644. CONFIG_ECHO_START;
  645. }
  646. SERIAL_ECHOPAIR(" M204 P", planner.acceleration);
  647. SERIAL_ECHOPAIR(" R", planner.retract_acceleration);
  648. SERIAL_ECHOPAIR(" T", planner.travel_acceleration);
  649. SERIAL_EOL;
  650. CONFIG_ECHO_START;
  651. if (!forReplay) {
  652. SERIAL_ECHOLNPGM("Advanced variables: S=Min feedrate (mm/s), T=Min travel feedrate (mm/s), B=minimum segment time (ms), X=maximum XY jerk (mm/s), Z=maximum Z jerk (mm/s), E=maximum E jerk (mm/s)");
  653. CONFIG_ECHO_START;
  654. }
  655. SERIAL_ECHOPAIR(" M205 S", planner.min_feedrate);
  656. SERIAL_ECHOPAIR(" T", planner.min_travel_feedrate);
  657. SERIAL_ECHOPAIR(" B", planner.min_segment_time);
  658. SERIAL_ECHOPAIR(" X", planner.max_xy_jerk);
  659. SERIAL_ECHOPAIR(" Z", planner.max_z_jerk);
  660. SERIAL_ECHOPAIR(" E", planner.max_e_jerk);
  661. SERIAL_EOL;
  662. CONFIG_ECHO_START;
  663. if (!forReplay) {
  664. SERIAL_ECHOLNPGM("Home offset (mm)");
  665. CONFIG_ECHO_START;
  666. }
  667. SERIAL_ECHOPAIR(" M206 X", home_offset[X_AXIS]);
  668. SERIAL_ECHOPAIR(" Y", home_offset[Y_AXIS]);
  669. SERIAL_ECHOPAIR(" Z", home_offset[Z_AXIS]);
  670. SERIAL_EOL;
  671. #if ENABLED(MESH_BED_LEVELING)
  672. if (!forReplay) {
  673. SERIAL_ECHOLNPGM("Mesh bed leveling:");
  674. CONFIG_ECHO_START;
  675. }
  676. SERIAL_ECHOPAIR(" M420 S", mbl.has_mesh() ? 1 : 0);
  677. SERIAL_ECHOPAIR(" X", MESH_NUM_X_POINTS);
  678. SERIAL_ECHOPAIR(" Y", MESH_NUM_Y_POINTS);
  679. SERIAL_EOL;
  680. for (uint8_t py = 1; py <= MESH_NUM_Y_POINTS; py++) {
  681. for (uint8_t px = 1; px <= MESH_NUM_X_POINTS; px++) {
  682. CONFIG_ECHO_START;
  683. SERIAL_ECHOPAIR(" G29 S3 X", px);
  684. SERIAL_ECHOPAIR(" Y", py);
  685. SERIAL_ECHOPGM(" Z");
  686. SERIAL_PROTOCOL_F(mbl.z_values[py-1][px-1], 5);
  687. SERIAL_EOL;
  688. }
  689. }
  690. #endif
  691. #if ENABLED(DELTA)
  692. CONFIG_ECHO_START;
  693. if (!forReplay) {
  694. SERIAL_ECHOLNPGM("Endstop adjustment (mm):");
  695. CONFIG_ECHO_START;
  696. }
  697. SERIAL_ECHOPAIR(" M666 X", endstop_adj[X_AXIS]);
  698. SERIAL_ECHOPAIR(" Y", endstop_adj[Y_AXIS]);
  699. SERIAL_ECHOPAIR(" Z", endstop_adj[Z_AXIS]);
  700. SERIAL_EOL;
  701. CONFIG_ECHO_START;
  702. if (!forReplay) {
  703. SERIAL_ECHOLNPGM("Delta settings: L=diagonal_rod, R=radius, S=segments_per_second, ABC=diagonal_rod_trim_tower_[123]");
  704. CONFIG_ECHO_START;
  705. }
  706. SERIAL_ECHOPAIR(" M665 L", delta_diagonal_rod);
  707. SERIAL_ECHOPAIR(" R", delta_radius);
  708. SERIAL_ECHOPAIR(" S", delta_segments_per_second);
  709. SERIAL_ECHOPAIR(" A", delta_diagonal_rod_trim_tower_1);
  710. SERIAL_ECHOPAIR(" B", delta_diagonal_rod_trim_tower_2);
  711. SERIAL_ECHOPAIR(" C", delta_diagonal_rod_trim_tower_3);
  712. SERIAL_EOL;
  713. #elif ENABLED(Z_DUAL_ENDSTOPS)
  714. CONFIG_ECHO_START;
  715. if (!forReplay) {
  716. SERIAL_ECHOLNPGM("Z2 Endstop adjustment (mm):");
  717. CONFIG_ECHO_START;
  718. }
  719. SERIAL_ECHOPAIR(" M666 Z", z_endstop_adj);
  720. SERIAL_EOL;
  721. #endif // DELTA
  722. #if ENABLED(ULTIPANEL)
  723. CONFIG_ECHO_START;
  724. if (!forReplay) {
  725. SERIAL_ECHOLNPGM("Material heatup parameters:");
  726. CONFIG_ECHO_START;
  727. }
  728. SERIAL_ECHOPAIR(" M145 S0 H", plaPreheatHotendTemp);
  729. SERIAL_ECHOPAIR(" B", plaPreheatHPBTemp);
  730. SERIAL_ECHOPAIR(" F", plaPreheatFanSpeed);
  731. SERIAL_EOL;
  732. CONFIG_ECHO_START;
  733. SERIAL_ECHOPAIR(" M145 S1 H", absPreheatHotendTemp);
  734. SERIAL_ECHOPAIR(" B", absPreheatHPBTemp);
  735. SERIAL_ECHOPAIR(" F", absPreheatFanSpeed);
  736. SERIAL_EOL;
  737. #endif // ULTIPANEL
  738. #if HAS_PID_HEATING
  739. CONFIG_ECHO_START;
  740. if (!forReplay) {
  741. SERIAL_ECHOLNPGM("PID settings:");
  742. }
  743. #if ENABLED(PIDTEMP)
  744. #if HOTENDS > 1
  745. if (forReplay) {
  746. for (uint8_t i = 0; i < HOTENDS; i++) {
  747. CONFIG_ECHO_START;
  748. SERIAL_ECHOPAIR(" M301 E", i);
  749. SERIAL_ECHOPAIR(" P", PID_PARAM(Kp, i));
  750. SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, i)));
  751. SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, i)));
  752. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  753. SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, i));
  754. if (i == 0) SERIAL_ECHOPAIR(" L", lpq_len);
  755. #endif
  756. SERIAL_EOL;
  757. }
  758. }
  759. else
  760. #endif // HOTENDS > 1
  761. // !forReplay || HOTENDS == 1
  762. {
  763. CONFIG_ECHO_START;
  764. SERIAL_ECHOPAIR(" M301 P", PID_PARAM(Kp, 0)); // for compatibility with hosts, only echo values for E0
  765. SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, 0)));
  766. SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, 0)));
  767. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  768. SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, 0));
  769. SERIAL_ECHOPAIR(" L", lpq_len);
  770. #endif
  771. SERIAL_EOL;
  772. }
  773. #endif // PIDTEMP
  774. #if ENABLED(PIDTEMPBED)
  775. CONFIG_ECHO_START;
  776. SERIAL_ECHOPAIR(" M304 P", thermalManager.bedKp);
  777. SERIAL_ECHOPAIR(" I", unscalePID_i(thermalManager.bedKi));
  778. SERIAL_ECHOPAIR(" D", unscalePID_d(thermalManager.bedKd));
  779. SERIAL_EOL;
  780. #endif
  781. #endif // PIDTEMP || PIDTEMPBED
  782. #if HAS_LCD_CONTRAST
  783. CONFIG_ECHO_START;
  784. if (!forReplay) {
  785. SERIAL_ECHOLNPGM("LCD Contrast:");
  786. CONFIG_ECHO_START;
  787. }
  788. SERIAL_ECHOPAIR(" M250 C", lcd_contrast);
  789. SERIAL_EOL;
  790. #endif
  791. #if ENABLED(FWRETRACT)
  792. CONFIG_ECHO_START;
  793. if (!forReplay) {
  794. SERIAL_ECHOLNPGM("Retract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)");
  795. CONFIG_ECHO_START;
  796. }
  797. SERIAL_ECHOPAIR(" M207 S", retract_length);
  798. #if EXTRUDERS > 1
  799. SERIAL_ECHOPAIR(" W", retract_length_swap);
  800. #endif
  801. SERIAL_ECHOPAIR(" F", retract_feedrate_mm_s * 60);
  802. SERIAL_ECHOPAIR(" Z", retract_zlift);
  803. SERIAL_EOL;
  804. CONFIG_ECHO_START;
  805. if (!forReplay) {
  806. SERIAL_ECHOLNPGM("Recover: S=Extra length (mm) F:Speed (mm/m)");
  807. CONFIG_ECHO_START;
  808. }
  809. SERIAL_ECHOPAIR(" M208 S", retract_recover_length);
  810. #if EXTRUDERS > 1
  811. SERIAL_ECHOPAIR(" W", retract_recover_length_swap);
  812. #endif
  813. SERIAL_ECHOPAIR(" F", retract_recover_feedrate * 60);
  814. SERIAL_EOL;
  815. CONFIG_ECHO_START;
  816. if (!forReplay) {
  817. SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries");
  818. CONFIG_ECHO_START;
  819. }
  820. SERIAL_ECHOPAIR(" M209 S", autoretract_enabled ? 1 : 0);
  821. SERIAL_EOL;
  822. #endif // FWRETRACT
  823. /**
  824. * Volumetric extrusion M200
  825. */
  826. if (!forReplay) {
  827. CONFIG_ECHO_START;
  828. SERIAL_ECHOPGM("Filament settings:");
  829. if (volumetric_enabled)
  830. SERIAL_EOL;
  831. else
  832. SERIAL_ECHOLNPGM(" Disabled");
  833. }
  834. CONFIG_ECHO_START;
  835. SERIAL_ECHOPAIR(" M200 D", filament_size[0]);
  836. SERIAL_EOL;
  837. #if EXTRUDERS > 1
  838. CONFIG_ECHO_START;
  839. SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]);
  840. SERIAL_EOL;
  841. #if EXTRUDERS > 2
  842. CONFIG_ECHO_START;
  843. SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]);
  844. SERIAL_EOL;
  845. #if EXTRUDERS > 3
  846. CONFIG_ECHO_START;
  847. SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]);
  848. SERIAL_EOL;
  849. #endif
  850. #endif
  851. #endif
  852. if (!volumetric_enabled) {
  853. CONFIG_ECHO_START;
  854. SERIAL_ECHOLNPGM(" M200 D0");
  855. }
  856. /**
  857. * Auto Bed Leveling
  858. */
  859. #if HAS_BED_PROBE
  860. if (!forReplay) {
  861. CONFIG_ECHO_START;
  862. SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
  863. }
  864. CONFIG_ECHO_START;
  865. SERIAL_ECHOPAIR(" M851 Z", zprobe_zoffset);
  866. SERIAL_EOL;
  867. #endif
  868. }
  869. #endif // !DISABLE_M503