My Marlin configs for Fabrikator Mini and CTC i3 Pro B
您最多选择25个主题 主题必须以字母或数字开头,可以包含连字符 (-),并且长度不得超过35个字符

configuration_store.cpp 54KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666
  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. * Settings 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 "V35"
  38. // Change EEPROM version if these are changed:
  39. #define EEPROM_OFFSET 100
  40. /**
  41. * V33 EEPROM Layout:
  42. *
  43. * 100 Version (char x4)
  44. * 104 EEPROM Checksum (uint16_t)
  45. *
  46. * 106 E_STEPPERS (uint8_t)
  47. * 107 M92 XYZE planner.axis_steps_per_mm (float x4 ... x8)
  48. * 123 M203 XYZE planner.max_feedrate_mm_s (float x4 ... x8)
  49. * 139 M201 XYZE planner.max_acceleration_mm_per_s2 (uint32_t x4 ... x8)
  50. * 155 M204 P planner.acceleration (float)
  51. * 159 M204 R planner.retract_acceleration (float)
  52. * 163 M204 T planner.travel_acceleration (float)
  53. * 167 M205 S planner.min_feedrate_mm_s (float)
  54. * 171 M205 T planner.min_travel_feedrate_mm_s (float)
  55. * 175 M205 B planner.min_segment_time (ulong)
  56. * 179 M205 X planner.max_jerk[X_AXIS] (float)
  57. * 183 M205 Y planner.max_jerk[Y_AXIS] (float)
  58. * 187 M205 Z planner.max_jerk[Z_AXIS] (float)
  59. * 191 M205 E planner.max_jerk[E_AXIS] (float)
  60. * 195 M206 XYZ home_offset (float x3)
  61. * 207 M218 XYZ hotend_offset (float x3 per additional hotend)
  62. *
  63. * Global Leveling:
  64. * 219 z_fade_height (float)
  65. *
  66. * MESH_BED_LEVELING: 43 bytes
  67. * 223 M420 S from mbl.status (bool)
  68. * 224 mbl.z_offset (float)
  69. * 228 GRID_MAX_POINTS_X (uint8_t)
  70. * 229 GRID_MAX_POINTS_Y (uint8_t)
  71. * 230 G29 S3 XYZ z_values[][] (float x9, up to float x 81) +288
  72. *
  73. * HAS_BED_PROBE: 4 bytes
  74. * 266 M851 zprobe_zoffset (float)
  75. *
  76. * ABL_PLANAR: 36 bytes
  77. * 270 planner.bed_level_matrix (matrix_3x3 = float x9)
  78. *
  79. * AUTO_BED_LEVELING_BILINEAR: 47 bytes
  80. * 306 GRID_MAX_POINTS_X (uint8_t)
  81. * 307 GRID_MAX_POINTS_Y (uint8_t)
  82. * 308 bilinear_grid_spacing (int x2)
  83. * 312 G29 L F bilinear_start (int x2)
  84. * 316 bed_level_grid[][] (float x9, up to float x256) +988
  85. *
  86. * DELTA: 48 bytes
  87. * 348 M666 XYZ endstop_adj (float x3)
  88. * 360 M665 R delta_radius (float)
  89. * 364 M665 L delta_diagonal_rod (float)
  90. * 368 M665 S delta_segments_per_second (float)
  91. * 372 M665 A delta_diagonal_rod_trim[A] (float)
  92. * 376 M665 B delta_diagonal_rod_trim[B] (float)
  93. * 380 M665 C delta_diagonal_rod_trim[C] (float)
  94. * 384 M665 I delta_tower_angle_trim[A] (float)
  95. * 388 M665 J delta_tower_angle_trim[B] (float)
  96. * 392 M665 K delta_tower_angle_trim[C] (float)
  97. *
  98. * Z_DUAL_ENDSTOPS: 48 bytes
  99. * 348 M666 Z z_endstop_adj (float)
  100. * --- dummy data (float x11)
  101. *
  102. * ULTIPANEL: 6 bytes
  103. * 396 M145 S0 H lcd_preheat_hotend_temp (int x2)
  104. * 400 M145 S0 B lcd_preheat_bed_temp (int x2)
  105. * 404 M145 S0 F lcd_preheat_fan_speed (int x2)
  106. *
  107. * PIDTEMP: 66 bytes
  108. * 408 M301 E0 PIDC Kp[0], Ki[0], Kd[0], Kc[0] (float x4)
  109. * 424 M301 E1 PIDC Kp[1], Ki[1], Kd[1], Kc[1] (float x4)
  110. * 440 M301 E2 PIDC Kp[2], Ki[2], Kd[2], Kc[2] (float x4)
  111. * 456 M301 E3 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
  112. * 472 M301 E4 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
  113. * 488 M301 L lpq_len (int)
  114. *
  115. * PIDTEMPBED: 12 bytes
  116. * 490 M304 PID thermalManager.bedKp, .bedKi, .bedKd (float x3)
  117. *
  118. * DOGLCD: 2 bytes
  119. * 502 M250 C lcd_contrast (int)
  120. *
  121. * FWRETRACT: 29 bytes
  122. * 504 M209 S autoretract_enabled (bool)
  123. * 505 M207 S retract_length (float)
  124. * 509 M207 W retract_length_swap (float)
  125. * 513 M207 F retract_feedrate_mm_s (float)
  126. * 517 M207 Z retract_zlift (float)
  127. * 521 M208 S retract_recover_length (float)
  128. * 525 M208 W retract_recover_length_swap (float)
  129. * 529 M208 F retract_recover_feedrate_mm_s (float)
  130. *
  131. * Volumetric Extrusion: 21 bytes
  132. * 533 M200 D volumetric_enabled (bool)
  133. * 534 M200 T D filament_size (float x5) (T0..3)
  134. *
  135. * HAVE_TMC2130: 20 bytes
  136. * 554 M906 X stepperX current (uint16_t)
  137. * 556 M906 Y stepperY current (uint16_t)
  138. * 558 M906 Z stepperZ current (uint16_t)
  139. * 560 M906 X2 stepperX2 current (uint16_t)
  140. * 562 M906 Y2 stepperY2 current (uint16_t)
  141. * 564 M906 Z2 stepperZ2 current (uint16_t)
  142. * 566 M906 E0 stepperE0 current (uint16_t)
  143. * 568 M906 E1 stepperE1 current (uint16_t)
  144. * 570 M906 E2 stepperE2 current (uint16_t)
  145. * 572 M906 E3 stepperE3 current (uint16_t)
  146. * 576 M906 E4 stepperE4 current (uint16_t)
  147. *
  148. * LIN_ADVANCE: 8 bytes
  149. * 580 M900 K extruder_advance_k (float)
  150. * 584 M900 WHD advance_ed_ratio (float)
  151. *
  152. * 588 Minimum end-point
  153. * 1909 (588 + 36 + 9 + 288 + 988) Maximum end-point
  154. */
  155. #include "configuration_store.h"
  156. MarlinSettings settings;
  157. #include "Marlin.h"
  158. #include "language.h"
  159. #include "endstops.h"
  160. #include "planner.h"
  161. #include "temperature.h"
  162. #include "ultralcd.h"
  163. #if ENABLED(MESH_BED_LEVELING)
  164. #include "mesh_bed_leveling.h"
  165. #endif
  166. #if ENABLED(HAVE_TMC2130)
  167. #include "stepper_indirection.h"
  168. #endif
  169. #if ENABLED(AUTO_BED_LEVELING_UBL)
  170. #include "ubl.h"
  171. #endif
  172. #if ENABLED(ABL_BILINEAR_SUBDIVISION)
  173. extern void bed_level_virt_interpolate();
  174. #endif
  175. /**
  176. * Post-process after Retrieve or Reset
  177. */
  178. void MarlinSettings::postprocess() {
  179. // steps per s2 needs to be updated to agree with units per s2
  180. planner.reset_acceleration_rates();
  181. // Make sure delta kinematics are updated before refreshing the
  182. // planner position so the stepper counts will be set correctly.
  183. #if ENABLED(DELTA)
  184. recalc_delta_settings(delta_radius, delta_diagonal_rod);
  185. #endif
  186. // Refresh steps_to_mm with the reciprocal of axis_steps_per_mm
  187. // and init stepper.count[], planner.position[] with current_position
  188. planner.refresh_positioning();
  189. #if ENABLED(PIDTEMP)
  190. thermalManager.updatePID();
  191. #endif
  192. calculate_volumetric_multipliers();
  193. #if HAS_HOME_OFFSET || ENABLED(DUAL_X_CARRIAGE)
  194. // Software endstops depend on home_offset
  195. LOOP_XYZ(i) update_software_endstops((AxisEnum)i);
  196. #endif
  197. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  198. set_z_fade_height(
  199. //#if ENABLED(AUTO_BED_LEVELING_UBL)
  200. // ubl.state.g29_correction_fade_height
  201. //#else
  202. planner.z_fade_height
  203. //#endif
  204. );
  205. #endif
  206. #if HAS_BED_PROBE
  207. refresh_zprobe_zoffset();
  208. #endif
  209. }
  210. #if ENABLED(EEPROM_SETTINGS)
  211. const char version[4] = EEPROM_VERSION;
  212. uint16_t MarlinSettings::eeprom_checksum;
  213. bool MarlinSettings::eeprom_write_error,
  214. MarlinSettings::eeprom_read_error;
  215. void MarlinSettings::write_data(int &pos, const uint8_t* value, uint16_t size) {
  216. if (eeprom_write_error) return;
  217. while (size--) {
  218. uint8_t * const p = (uint8_t * const)pos;
  219. const uint8_t v = *value;
  220. // EEPROM has only ~100,000 write cycles,
  221. // so only write bytes that have changed!
  222. if (v != eeprom_read_byte(p)) {
  223. eeprom_write_byte(p, v);
  224. if (eeprom_read_byte(p) != v) {
  225. SERIAL_ECHO_START;
  226. SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
  227. eeprom_write_error = true;
  228. return;
  229. }
  230. }
  231. eeprom_checksum += v;
  232. pos++;
  233. value++;
  234. };
  235. }
  236. void MarlinSettings::read_data(int &pos, uint8_t* value, uint16_t size) {
  237. do {
  238. uint8_t c = eeprom_read_byte((unsigned char*)pos);
  239. if (!eeprom_read_error) *value = c;
  240. eeprom_checksum += c;
  241. pos++;
  242. value++;
  243. } while (--size);
  244. }
  245. #define DUMMY_PID_VALUE 3000.0f
  246. #define EEPROM_START() int eeprom_index = EEPROM_OFFSET
  247. #define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR)
  248. #define EEPROM_WRITE(VAR) write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
  249. #define EEPROM_READ(VAR) read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
  250. #define EEPROM_ASSERT(TST,ERR) if (!(TST)) do{ SERIAL_ERROR_START; SERIAL_ERRORLNPGM(ERR); eeprom_read_error = true; }while(0)
  251. /**
  252. * M500 - Store Configuration
  253. */
  254. bool MarlinSettings::save() {
  255. float dummy = 0.0f;
  256. char ver[4] = "000";
  257. EEPROM_START();
  258. eeprom_write_error = false;
  259. EEPROM_WRITE(ver); // invalidate data first
  260. EEPROM_SKIP(eeprom_checksum); // Skip the checksum slot
  261. eeprom_checksum = 0; // clear before first "real data"
  262. const uint8_t esteppers = COUNT(planner.axis_steps_per_mm) - XYZ;
  263. EEPROM_WRITE(esteppers);
  264. EEPROM_WRITE(planner.axis_steps_per_mm);
  265. EEPROM_WRITE(planner.max_feedrate_mm_s);
  266. EEPROM_WRITE(planner.max_acceleration_mm_per_s2);
  267. EEPROM_WRITE(planner.acceleration);
  268. EEPROM_WRITE(planner.retract_acceleration);
  269. EEPROM_WRITE(planner.travel_acceleration);
  270. EEPROM_WRITE(planner.min_feedrate_mm_s);
  271. EEPROM_WRITE(planner.min_travel_feedrate_mm_s);
  272. EEPROM_WRITE(planner.min_segment_time);
  273. EEPROM_WRITE(planner.max_jerk);
  274. #if !HAS_HOME_OFFSET
  275. const float home_offset[XYZ] = { 0 };
  276. #endif
  277. #if ENABLED(DELTA)
  278. dummy = 0.0;
  279. EEPROM_WRITE(dummy);
  280. EEPROM_WRITE(dummy);
  281. dummy = DELTA_HEIGHT + home_offset[Z_AXIS];
  282. EEPROM_WRITE(dummy);
  283. #else
  284. EEPROM_WRITE(home_offset);
  285. #endif
  286. #if HOTENDS > 1
  287. // Skip hotend 0 which must be 0
  288. for (uint8_t e = 1; e < HOTENDS; e++)
  289. LOOP_XYZ(i) EEPROM_WRITE(hotend_offset[i][e]);
  290. #endif
  291. //
  292. // General Leveling
  293. //
  294. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  295. EEPROM_WRITE(planner.z_fade_height);
  296. #else
  297. dummy = 10.0;
  298. EEPROM_WRITE(dummy);
  299. #endif
  300. //
  301. // Mesh Bed Leveling
  302. //
  303. #if ENABLED(MESH_BED_LEVELING)
  304. // Compile time test that sizeof(mbl.z_values) is as expected
  305. typedef char c_assert[(sizeof(mbl.z_values) == (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) * sizeof(dummy)) ? 1 : -1];
  306. const bool leveling_is_on = TEST(mbl.status, MBL_STATUS_HAS_MESH_BIT);
  307. const uint8_t mesh_num_x = GRID_MAX_POINTS_X, mesh_num_y = GRID_MAX_POINTS_Y;
  308. EEPROM_WRITE(leveling_is_on);
  309. EEPROM_WRITE(mbl.z_offset);
  310. EEPROM_WRITE(mesh_num_x);
  311. EEPROM_WRITE(mesh_num_y);
  312. EEPROM_WRITE(mbl.z_values);
  313. #else
  314. // For disabled MBL write a default mesh
  315. const bool leveling_is_on = false;
  316. dummy = 0.0f;
  317. const uint8_t mesh_num_x = 3, mesh_num_y = 3;
  318. EEPROM_WRITE(leveling_is_on);
  319. EEPROM_WRITE(dummy); // z_offset
  320. EEPROM_WRITE(mesh_num_x);
  321. EEPROM_WRITE(mesh_num_y);
  322. for (uint8_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_WRITE(dummy);
  323. #endif // MESH_BED_LEVELING
  324. #if !HAS_BED_PROBE
  325. const float zprobe_zoffset = 0;
  326. #endif
  327. EEPROM_WRITE(zprobe_zoffset);
  328. //
  329. // Planar Bed Leveling matrix
  330. //
  331. #if ABL_PLANAR
  332. EEPROM_WRITE(planner.bed_level_matrix);
  333. #else
  334. dummy = 0.0;
  335. for (uint8_t q = 9; q--;) EEPROM_WRITE(dummy);
  336. #endif
  337. //
  338. // Bilinear Auto Bed Leveling
  339. //
  340. #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
  341. // Compile time test that sizeof(bed_level_grid) is as expected
  342. typedef char c_assert[(sizeof(bed_level_grid) == (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) * sizeof(dummy)) ? 1 : -1];
  343. const uint8_t grid_max_x = GRID_MAX_POINTS_X, grid_max_y = GRID_MAX_POINTS_Y;
  344. EEPROM_WRITE(grid_max_x); // 1 byte
  345. EEPROM_WRITE(grid_max_y); // 1 byte
  346. EEPROM_WRITE(bilinear_grid_spacing); // 2 ints
  347. EEPROM_WRITE(bilinear_start); // 2 ints
  348. EEPROM_WRITE(bed_level_grid); // 9-256 floats
  349. #else
  350. // For disabled Bilinear Grid write an empty 3x3 grid
  351. const uint8_t grid_max_x = 3, grid_max_y = 3;
  352. const int bilinear_start[2] = { 0 }, bilinear_grid_spacing[2] = { 0 };
  353. dummy = 0.0f;
  354. EEPROM_WRITE(grid_max_x);
  355. EEPROM_WRITE(grid_max_y);
  356. EEPROM_WRITE(bilinear_grid_spacing);
  357. EEPROM_WRITE(bilinear_start);
  358. for (uint16_t q = grid_max_x * grid_max_y; q--;) EEPROM_WRITE(dummy);
  359. #endif // AUTO_BED_LEVELING_BILINEAR
  360. // 9 floats for DELTA / Z_DUAL_ENDSTOPS
  361. #if ENABLED(DELTA)
  362. EEPROM_WRITE(endstop_adj); // 3 floats
  363. EEPROM_WRITE(delta_radius); // 1 float
  364. EEPROM_WRITE(delta_diagonal_rod); // 1 float
  365. EEPROM_WRITE(delta_segments_per_second); // 1 float
  366. EEPROM_WRITE(delta_diagonal_rod_trim); // 3 floats
  367. EEPROM_WRITE(delta_tower_angle_trim); // 3 floats
  368. #elif ENABLED(Z_DUAL_ENDSTOPS)
  369. EEPROM_WRITE(z_endstop_adj); // 1 float
  370. dummy = 0.0f;
  371. for (uint8_t q = 11; q--;) EEPROM_WRITE(dummy);
  372. #else
  373. dummy = 0.0f;
  374. for (uint8_t q = 12; q--;) EEPROM_WRITE(dummy);
  375. #endif
  376. #if DISABLED(ULTIPANEL)
  377. const int lcd_preheat_hotend_temp[2] = { PREHEAT_1_TEMP_HOTEND, PREHEAT_2_TEMP_HOTEND },
  378. lcd_preheat_bed_temp[2] = { PREHEAT_1_TEMP_BED, PREHEAT_2_TEMP_BED },
  379. lcd_preheat_fan_speed[2] = { PREHEAT_1_FAN_SPEED, PREHEAT_2_FAN_SPEED };
  380. #endif // !ULTIPANEL
  381. EEPROM_WRITE(lcd_preheat_hotend_temp);
  382. EEPROM_WRITE(lcd_preheat_bed_temp);
  383. EEPROM_WRITE(lcd_preheat_fan_speed);
  384. for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
  385. #if ENABLED(PIDTEMP)
  386. if (e < HOTENDS) {
  387. EEPROM_WRITE(PID_PARAM(Kp, e));
  388. EEPROM_WRITE(PID_PARAM(Ki, e));
  389. EEPROM_WRITE(PID_PARAM(Kd, e));
  390. #if ENABLED(PID_EXTRUSION_SCALING)
  391. EEPROM_WRITE(PID_PARAM(Kc, e));
  392. #else
  393. dummy = 1.0f; // 1.0 = default kc
  394. EEPROM_WRITE(dummy);
  395. #endif
  396. }
  397. else
  398. #endif // !PIDTEMP
  399. {
  400. dummy = DUMMY_PID_VALUE; // When read, will not change the existing value
  401. EEPROM_WRITE(dummy); // Kp
  402. dummy = 0.0f;
  403. for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy); // Ki, Kd, Kc
  404. }
  405. } // Hotends Loop
  406. #if DISABLED(PID_EXTRUSION_SCALING)
  407. int lpq_len = 20;
  408. #endif
  409. EEPROM_WRITE(lpq_len);
  410. #if DISABLED(PIDTEMPBED)
  411. dummy = DUMMY_PID_VALUE;
  412. for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy);
  413. #else
  414. EEPROM_WRITE(thermalManager.bedKp);
  415. EEPROM_WRITE(thermalManager.bedKi);
  416. EEPROM_WRITE(thermalManager.bedKd);
  417. #endif
  418. #if !HAS_LCD_CONTRAST
  419. const int lcd_contrast = 32;
  420. #endif
  421. EEPROM_WRITE(lcd_contrast);
  422. #if ENABLED(FWRETRACT)
  423. EEPROM_WRITE(autoretract_enabled);
  424. EEPROM_WRITE(retract_length);
  425. #if EXTRUDERS > 1
  426. EEPROM_WRITE(retract_length_swap);
  427. #else
  428. dummy = 0.0f;
  429. EEPROM_WRITE(dummy);
  430. #endif
  431. EEPROM_WRITE(retract_feedrate_mm_s);
  432. EEPROM_WRITE(retract_zlift);
  433. EEPROM_WRITE(retract_recover_length);
  434. #if EXTRUDERS > 1
  435. EEPROM_WRITE(retract_recover_length_swap);
  436. #else
  437. dummy = 0.0f;
  438. EEPROM_WRITE(dummy);
  439. #endif
  440. EEPROM_WRITE(retract_recover_feedrate_mm_s);
  441. #endif // FWRETRACT
  442. EEPROM_WRITE(volumetric_enabled);
  443. // Save filament sizes
  444. for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
  445. if (q < COUNT(filament_size)) dummy = filament_size[q];
  446. EEPROM_WRITE(dummy);
  447. }
  448. // Save TMC2130 Configuration, and placeholder values
  449. uint16_t val;
  450. #if ENABLED(HAVE_TMC2130)
  451. #if ENABLED(X_IS_TMC2130)
  452. val = stepperX.getCurrent();
  453. #else
  454. val = 0;
  455. #endif
  456. EEPROM_WRITE(val);
  457. #if ENABLED(Y_IS_TMC2130)
  458. val = stepperY.getCurrent();
  459. #else
  460. val = 0;
  461. #endif
  462. EEPROM_WRITE(val);
  463. #if ENABLED(Z_IS_TMC2130)
  464. val = stepperZ.getCurrent();
  465. #else
  466. val = 0;
  467. #endif
  468. EEPROM_WRITE(val);
  469. #if ENABLED(X2_IS_TMC2130)
  470. val = stepperX2.getCurrent();
  471. #else
  472. val = 0;
  473. #endif
  474. EEPROM_WRITE(val);
  475. #if ENABLED(Y2_IS_TMC2130)
  476. val = stepperY2.getCurrent();
  477. #else
  478. val = 0;
  479. #endif
  480. EEPROM_WRITE(val);
  481. #if ENABLED(Z2_IS_TMC2130)
  482. val = stepperZ2.getCurrent();
  483. #else
  484. val = 0;
  485. #endif
  486. EEPROM_WRITE(val);
  487. #if ENABLED(E0_IS_TMC2130)
  488. val = stepperE0.getCurrent();
  489. #else
  490. val = 0;
  491. #endif
  492. EEPROM_WRITE(val);
  493. #if ENABLED(E1_IS_TMC2130)
  494. val = stepperE1.getCurrent();
  495. #else
  496. val = 0;
  497. #endif
  498. EEPROM_WRITE(val);
  499. #if ENABLED(E2_IS_TMC2130)
  500. val = stepperE2.getCurrent();
  501. #else
  502. val = 0;
  503. #endif
  504. EEPROM_WRITE(val);
  505. #if ENABLED(E3_IS_TMC2130)
  506. val = stepperE3.getCurrent();
  507. #else
  508. val = 0;
  509. #endif
  510. EEPROM_WRITE(val);
  511. #if ENABLED(E4_IS_TMC2130)
  512. val = stepperE4.getCurrent();
  513. #else
  514. val = 0;
  515. #endif
  516. EEPROM_WRITE(val);
  517. #else
  518. val = 0;
  519. for (uint8_t q = 0; q < 11; ++q) EEPROM_WRITE(val);
  520. #endif
  521. //
  522. // Linear Advance
  523. //
  524. float extruder_advance_k = 0.0f, advance_ed_ratio = 0.0f;
  525. #if ENABLED(LIN_ADVANCE)
  526. extruder_advance_k = planner.get_extruder_advance_k();
  527. advance_ed_ratio = planner.get_advance_ed_ratio();
  528. #endif
  529. EEPROM_WRITE(extruder_advance_k);
  530. EEPROM_WRITE(advance_ed_ratio);
  531. if (!eeprom_write_error) {
  532. const uint16_t final_checksum = eeprom_checksum,
  533. eeprom_size = eeprom_index;
  534. // Write the EEPROM header
  535. eeprom_index = EEPROM_OFFSET;
  536. EEPROM_WRITE(version);
  537. EEPROM_WRITE(final_checksum);
  538. // Report storage size
  539. SERIAL_ECHO_START;
  540. SERIAL_ECHOPAIR("Settings Stored (", eeprom_size - (EEPROM_OFFSET));
  541. SERIAL_ECHOLNPGM(" bytes)");
  542. }
  543. #if ENABLED(AUTO_BED_LEVELING_UBL)
  544. ubl.store_state();
  545. if (ubl.state.eeprom_storage_slot >= 0)
  546. ubl.store_mesh(ubl.state.eeprom_storage_slot);
  547. #endif
  548. return !eeprom_write_error;
  549. }
  550. /**
  551. * M501 - Retrieve Configuration
  552. */
  553. bool MarlinSettings::load() {
  554. EEPROM_START();
  555. eeprom_read_error = false; // If set EEPROM_READ won't write into RAM
  556. char stored_ver[4];
  557. EEPROM_READ(stored_ver);
  558. uint16_t stored_checksum;
  559. EEPROM_READ(stored_checksum);
  560. // Version has to match or defaults are used
  561. if (strncmp(version, stored_ver, 3) != 0) {
  562. if (stored_ver[0] != 'V') {
  563. stored_ver[0] = '?';
  564. stored_ver[1] = '\0';
  565. }
  566. SERIAL_ECHO_START;
  567. SERIAL_ECHOPGM("EEPROM version mismatch ");
  568. SERIAL_ECHOPAIR("(EEPROM=", stored_ver);
  569. SERIAL_ECHOLNPGM(" Marlin=" EEPROM_VERSION ")");
  570. reset();
  571. }
  572. else {
  573. float dummy = 0;
  574. eeprom_checksum = 0; // clear before reading first "real data"
  575. // Number of esteppers may change
  576. uint8_t esteppers;
  577. EEPROM_READ(esteppers);
  578. // Get only the number of E stepper parameters previously stored
  579. // Any steppers added later are set to their defaults
  580. const float def1[] = DEFAULT_AXIS_STEPS_PER_UNIT, def2[] = DEFAULT_MAX_FEEDRATE;
  581. const uint32_t def3[] = DEFAULT_MAX_ACCELERATION;
  582. float tmp1[XYZ + esteppers], tmp2[XYZ + esteppers];
  583. uint32_t tmp3[XYZ + esteppers];
  584. EEPROM_READ(tmp1);
  585. EEPROM_READ(tmp2);
  586. EEPROM_READ(tmp3);
  587. LOOP_XYZE_N(i) {
  588. planner.axis_steps_per_mm[i] = i < XYZ + esteppers ? tmp1[i] : def1[i < COUNT(def1) ? i : COUNT(def1) - 1];
  589. planner.max_feedrate_mm_s[i] = i < XYZ + esteppers ? tmp2[i] : def2[i < COUNT(def2) ? i : COUNT(def2) - 1];
  590. planner.max_acceleration_mm_per_s2[i] = i < XYZ + esteppers ? tmp3[i] : def3[i < COUNT(def3) ? i : COUNT(def3) - 1];
  591. }
  592. EEPROM_READ(planner.acceleration);
  593. EEPROM_READ(planner.retract_acceleration);
  594. EEPROM_READ(planner.travel_acceleration);
  595. EEPROM_READ(planner.min_feedrate_mm_s);
  596. EEPROM_READ(planner.min_travel_feedrate_mm_s);
  597. EEPROM_READ(planner.min_segment_time);
  598. EEPROM_READ(planner.max_jerk);
  599. #if !HAS_HOME_OFFSET
  600. float home_offset[XYZ];
  601. #endif
  602. EEPROM_READ(home_offset);
  603. #if ENABLED(DELTA)
  604. home_offset[X_AXIS] = 0.0;
  605. home_offset[Y_AXIS] = 0.0;
  606. home_offset[Z_AXIS] -= DELTA_HEIGHT;
  607. #endif
  608. #if HOTENDS > 1
  609. // Skip hotend 0 which must be 0
  610. for (uint8_t e = 1; e < HOTENDS; e++)
  611. LOOP_XYZ(i) EEPROM_READ(hotend_offset[i][e]);
  612. #endif
  613. //
  614. // General Leveling
  615. //
  616. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  617. EEPROM_READ(planner.z_fade_height);
  618. #else
  619. EEPROM_READ(dummy);
  620. #endif
  621. //
  622. // Mesh (Manual) Bed Leveling
  623. //
  624. bool leveling_is_on;
  625. uint8_t mesh_num_x, mesh_num_y;
  626. EEPROM_READ(leveling_is_on);
  627. EEPROM_READ(dummy);
  628. EEPROM_READ(mesh_num_x);
  629. EEPROM_READ(mesh_num_y);
  630. #if ENABLED(MESH_BED_LEVELING)
  631. mbl.status = leveling_is_on ? _BV(MBL_STATUS_HAS_MESH_BIT) : 0;
  632. mbl.z_offset = dummy;
  633. if (mesh_num_x == GRID_MAX_POINTS_X && mesh_num_y == GRID_MAX_POINTS_Y) {
  634. // EEPROM data fits the current mesh
  635. EEPROM_READ(mbl.z_values);
  636. }
  637. else {
  638. // EEPROM data is stale
  639. mbl.reset();
  640. for (uint16_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_READ(dummy);
  641. }
  642. #else
  643. // MBL is disabled - skip the stored data
  644. for (uint16_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_READ(dummy);
  645. #endif // MESH_BED_LEVELING
  646. #if !HAS_BED_PROBE
  647. float zprobe_zoffset;
  648. #endif
  649. EEPROM_READ(zprobe_zoffset);
  650. //
  651. // Planar Bed Leveling matrix
  652. //
  653. #if ABL_PLANAR
  654. EEPROM_READ(planner.bed_level_matrix);
  655. #else
  656. for (uint8_t q = 9; q--;) EEPROM_READ(dummy);
  657. #endif
  658. //
  659. // Bilinear Auto Bed Leveling
  660. //
  661. uint8_t grid_max_x, grid_max_y;
  662. EEPROM_READ(grid_max_x); // 1 byte
  663. EEPROM_READ(grid_max_y); // 1 byte
  664. #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
  665. if (grid_max_x == GRID_MAX_POINTS_X && grid_max_y == GRID_MAX_POINTS_Y) {
  666. set_bed_leveling_enabled(false);
  667. EEPROM_READ(bilinear_grid_spacing); // 2 ints
  668. EEPROM_READ(bilinear_start); // 2 ints
  669. EEPROM_READ(bed_level_grid); // 9 to 256 floats
  670. #if ENABLED(ABL_BILINEAR_SUBDIVISION)
  671. bed_level_virt_interpolate();
  672. #endif
  673. //set_bed_leveling_enabled(leveling_is_on);
  674. }
  675. else // EEPROM data is stale
  676. #endif // AUTO_BED_LEVELING_BILINEAR
  677. {
  678. // Skip past disabled (or stale) Bilinear Grid data
  679. int bgs[2], bs[2];
  680. EEPROM_READ(bgs);
  681. EEPROM_READ(bs);
  682. for (uint16_t q = grid_max_x * grid_max_y; q--;) EEPROM_READ(dummy);
  683. }
  684. #if ENABLED(DELTA)
  685. EEPROM_READ(endstop_adj); // 3 floats
  686. EEPROM_READ(delta_radius); // 1 float
  687. EEPROM_READ(delta_diagonal_rod); // 1 float
  688. EEPROM_READ(delta_segments_per_second); // 1 float
  689. EEPROM_READ(delta_diagonal_rod_trim); // 3 floats
  690. EEPROM_READ(delta_tower_angle_trim); // 3 floats
  691. #elif ENABLED(Z_DUAL_ENDSTOPS)
  692. EEPROM_READ(z_endstop_adj);
  693. dummy = 0.0f;
  694. for (uint8_t q=11; q--;) EEPROM_READ(dummy);
  695. #else
  696. dummy = 0.0f;
  697. for (uint8_t q=12; q--;) EEPROM_READ(dummy);
  698. #endif
  699. #if DISABLED(ULTIPANEL)
  700. int lcd_preheat_hotend_temp[2], lcd_preheat_bed_temp[2], lcd_preheat_fan_speed[2];
  701. #endif
  702. EEPROM_READ(lcd_preheat_hotend_temp);
  703. EEPROM_READ(lcd_preheat_bed_temp);
  704. EEPROM_READ(lcd_preheat_fan_speed);
  705. //EEPROM_ASSERT(
  706. // WITHIN(lcd_preheat_fan_speed, 0, 255),
  707. // "lcd_preheat_fan_speed out of range"
  708. //);
  709. #if ENABLED(PIDTEMP)
  710. for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
  711. EEPROM_READ(dummy); // Kp
  712. if (e < HOTENDS && dummy != DUMMY_PID_VALUE) {
  713. // do not need to scale PID values as the values in EEPROM are already scaled
  714. PID_PARAM(Kp, e) = dummy;
  715. EEPROM_READ(PID_PARAM(Ki, e));
  716. EEPROM_READ(PID_PARAM(Kd, e));
  717. #if ENABLED(PID_EXTRUSION_SCALING)
  718. EEPROM_READ(PID_PARAM(Kc, e));
  719. #else
  720. EEPROM_READ(dummy);
  721. #endif
  722. }
  723. else {
  724. for (uint8_t q=3; q--;) EEPROM_READ(dummy); // Ki, Kd, Kc
  725. }
  726. }
  727. #else // !PIDTEMP
  728. // 4 x 4 = 16 slots for PID parameters
  729. for (uint8_t q = MAX_EXTRUDERS * 4; q--;) EEPROM_READ(dummy); // Kp, Ki, Kd, Kc
  730. #endif // !PIDTEMP
  731. #if DISABLED(PID_EXTRUSION_SCALING)
  732. int lpq_len;
  733. #endif
  734. EEPROM_READ(lpq_len);
  735. #if ENABLED(PIDTEMPBED)
  736. EEPROM_READ(dummy); // bedKp
  737. if (dummy != DUMMY_PID_VALUE) {
  738. thermalManager.bedKp = dummy;
  739. EEPROM_READ(thermalManager.bedKi);
  740. EEPROM_READ(thermalManager.bedKd);
  741. }
  742. #else
  743. for (uint8_t q=3; q--;) EEPROM_READ(dummy); // bedKp, bedKi, bedKd
  744. #endif
  745. #if !HAS_LCD_CONTRAST
  746. int lcd_contrast;
  747. #endif
  748. EEPROM_READ(lcd_contrast);
  749. #if ENABLED(FWRETRACT)
  750. EEPROM_READ(autoretract_enabled);
  751. EEPROM_READ(retract_length);
  752. #if EXTRUDERS > 1
  753. EEPROM_READ(retract_length_swap);
  754. #else
  755. EEPROM_READ(dummy);
  756. #endif
  757. EEPROM_READ(retract_feedrate_mm_s);
  758. EEPROM_READ(retract_zlift);
  759. EEPROM_READ(retract_recover_length);
  760. #if EXTRUDERS > 1
  761. EEPROM_READ(retract_recover_length_swap);
  762. #else
  763. EEPROM_READ(dummy);
  764. #endif
  765. EEPROM_READ(retract_recover_feedrate_mm_s);
  766. #endif // FWRETRACT
  767. EEPROM_READ(volumetric_enabled);
  768. for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
  769. EEPROM_READ(dummy);
  770. if (q < COUNT(filament_size)) filament_size[q] = dummy;
  771. }
  772. uint16_t val;
  773. #if ENABLED(HAVE_TMC2130)
  774. EEPROM_READ(val);
  775. #if ENABLED(X_IS_TMC2130)
  776. stepperX.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  777. #endif
  778. EEPROM_READ(val);
  779. #if ENABLED(Y_IS_TMC2130)
  780. stepperY.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  781. #endif
  782. EEPROM_READ(val);
  783. #if ENABLED(Z_IS_TMC2130)
  784. stepperZ.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  785. #endif
  786. EEPROM_READ(val);
  787. #if ENABLED(X2_IS_TMC2130)
  788. stepperX2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  789. #endif
  790. EEPROM_READ(val);
  791. #if ENABLED(Y2_IS_TMC2130)
  792. stepperY2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  793. #endif
  794. EEPROM_READ(val);
  795. #if ENABLED(Z2_IS_TMC2130)
  796. stepperZ2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  797. #endif
  798. EEPROM_READ(val);
  799. #if ENABLED(E0_IS_TMC2130)
  800. stepperE0.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  801. #endif
  802. EEPROM_READ(val);
  803. #if ENABLED(E1_IS_TMC2130)
  804. stepperE1.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  805. #endif
  806. EEPROM_READ(val);
  807. #if ENABLED(E2_IS_TMC2130)
  808. stepperE2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  809. #endif
  810. EEPROM_READ(val);
  811. #if ENABLED(E3_IS_TMC2130)
  812. stepperE3.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  813. #endif
  814. EEPROM_READ(val);
  815. #if ENABLED(E4_IS_TMC2130)
  816. stepperE4.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  817. #endif
  818. #else
  819. for (uint8_t q = 0; q < 11; q++) EEPROM_READ(val);
  820. #endif
  821. //
  822. // Linear Advance
  823. //
  824. float extruder_advance_k, advance_ed_ratio;
  825. EEPROM_READ(extruder_advance_k);
  826. EEPROM_READ(advance_ed_ratio);
  827. #if ENABLED(LIN_ADVANCE)
  828. planner.set_extruder_advance_k(extruder_advance_k);
  829. planner.set_advance_ed_ratio(advance_ed_ratio);
  830. #endif
  831. if (eeprom_checksum == stored_checksum) {
  832. if (eeprom_read_error)
  833. reset();
  834. else {
  835. postprocess();
  836. SERIAL_ECHO_START;
  837. SERIAL_ECHO(version);
  838. SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index - (EEPROM_OFFSET));
  839. SERIAL_ECHOLNPGM(" bytes)");
  840. }
  841. }
  842. else {
  843. SERIAL_ERROR_START;
  844. SERIAL_ERRORLNPGM("EEPROM checksum mismatch");
  845. reset();
  846. }
  847. #if ENABLED(AUTO_BED_LEVELING_UBL)
  848. ubl.eeprom_start = (eeprom_index + 32) & 0xFFF8; // Pad the end of configuration data so it
  849. // can float up or down a little bit without
  850. // disrupting the Unified Bed Leveling data
  851. ubl.load_state();
  852. SERIAL_ECHOPGM(" UBL ");
  853. if (!ubl.state.active) SERIAL_ECHO("not ");
  854. SERIAL_ECHOLNPGM("active!");
  855. if (!ubl.sanity_check()) {
  856. int tmp_mesh; // We want to preserve whether the UBL System is Active
  857. bool tmp_active; // If it is, we want to preserve the Mesh that is being used.
  858. tmp_mesh = ubl.state.eeprom_storage_slot;
  859. tmp_active = ubl.state.active;
  860. SERIAL_ECHOLNPGM("\nInitializing Bed Leveling State to current firmware settings.\n");
  861. ubl.state = ubl.pre_initialized; // Initialize with the pre_initialized data structure
  862. ubl.state.eeprom_storage_slot = tmp_mesh; // But then restore some data we don't want mangled
  863. ubl.state.active = tmp_active;
  864. }
  865. else {
  866. SERIAL_PROTOCOLPGM("?Unable to enable Unified Bed Leveling.\n");
  867. ubl.state = ubl.pre_initialized;
  868. ubl.reset();
  869. ubl.store_state();
  870. }
  871. if (ubl.state.eeprom_storage_slot >= 0) {
  872. ubl.load_mesh(ubl.state.eeprom_storage_slot);
  873. SERIAL_ECHOPAIR("Mesh ", ubl.state.eeprom_storage_slot);
  874. SERIAL_ECHOLNPGM(" loaded from storage.");
  875. }
  876. else {
  877. ubl.reset();
  878. SERIAL_ECHOLNPGM("UBL System reset()");
  879. }
  880. #endif
  881. }
  882. #if ENABLED(EEPROM_CHITCHAT)
  883. report();
  884. #endif
  885. return !eeprom_read_error;
  886. }
  887. #else // !EEPROM_SETTINGS
  888. bool MarlinSettings::save() {
  889. SERIAL_ERROR_START;
  890. SERIAL_ERRORLNPGM("EEPROM disabled");
  891. return false;
  892. }
  893. #endif // !EEPROM_SETTINGS
  894. /**
  895. * M502 - Reset Configuration
  896. */
  897. void MarlinSettings::reset() {
  898. const float tmp1[] = DEFAULT_AXIS_STEPS_PER_UNIT, tmp2[] = DEFAULT_MAX_FEEDRATE;
  899. const uint32_t tmp3[] = DEFAULT_MAX_ACCELERATION;
  900. LOOP_XYZE_N(i) {
  901. planner.axis_steps_per_mm[i] = tmp1[i < COUNT(tmp1) ? i : COUNT(tmp1) - 1];
  902. planner.max_feedrate_mm_s[i] = tmp2[i < COUNT(tmp2) ? i : COUNT(tmp2) - 1];
  903. planner.max_acceleration_mm_per_s2[i] = tmp3[i < COUNT(tmp3) ? i : COUNT(tmp3) - 1];
  904. }
  905. planner.acceleration = DEFAULT_ACCELERATION;
  906. planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
  907. planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
  908. planner.min_feedrate_mm_s = DEFAULT_MINIMUMFEEDRATE;
  909. planner.min_segment_time = DEFAULT_MINSEGMENTTIME;
  910. planner.min_travel_feedrate_mm_s = DEFAULT_MINTRAVELFEEDRATE;
  911. planner.max_jerk[X_AXIS] = DEFAULT_XJERK;
  912. planner.max_jerk[Y_AXIS] = DEFAULT_YJERK;
  913. planner.max_jerk[Z_AXIS] = DEFAULT_ZJERK;
  914. planner.max_jerk[E_AXIS] = DEFAULT_EJERK;
  915. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  916. planner.z_fade_height = 0.0;
  917. #endif
  918. #if HAS_HOME_OFFSET
  919. ZERO(home_offset);
  920. #endif
  921. #if HOTENDS > 1
  922. constexpr float tmp4[XYZ][HOTENDS] = {
  923. HOTEND_OFFSET_X,
  924. HOTEND_OFFSET_Y
  925. #ifdef HOTEND_OFFSET_Z
  926. , HOTEND_OFFSET_Z
  927. #else
  928. , { 0 }
  929. #endif
  930. };
  931. static_assert(
  932. tmp4[X_AXIS][0] == 0 && tmp4[Y_AXIS][0] == 0 && tmp4[Z_AXIS][0] == 0,
  933. "Offsets for the first hotend must be 0.0."
  934. );
  935. LOOP_XYZ(i) HOTEND_LOOP() hotend_offset[i][e] = tmp4[i][e];
  936. #endif
  937. // Applies to all MBL and ABL
  938. #if PLANNER_LEVELING
  939. reset_bed_level();
  940. #endif
  941. #if HAS_BED_PROBE
  942. zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER;
  943. #endif
  944. #if ENABLED(DELTA)
  945. const float adj[ABC] = DELTA_ENDSTOP_ADJ,
  946. drt[ABC] = { DELTA_DIAGONAL_ROD_TRIM_TOWER_1, DELTA_DIAGONAL_ROD_TRIM_TOWER_2, DELTA_DIAGONAL_ROD_TRIM_TOWER_3 },
  947. dta[ABC] = { DELTA_TOWER_ANGLE_TRIM_1, DELTA_TOWER_ANGLE_TRIM_2, DELTA_TOWER_ANGLE_TRIM_3 };
  948. COPY(endstop_adj, adj);
  949. delta_radius = DELTA_RADIUS;
  950. delta_diagonal_rod = DELTA_DIAGONAL_ROD;
  951. delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;
  952. COPY(delta_diagonal_rod_trim, drt);
  953. COPY(delta_tower_angle_trim, dta);
  954. home_offset[Z_AXIS] = 0;
  955. #elif ENABLED(Z_DUAL_ENDSTOPS)
  956. float z_endstop_adj =
  957. #ifdef Z_DUAL_ENDSTOPS_ADJUSTMENT
  958. Z_DUAL_ENDSTOPS_ADJUSTMENT
  959. #else
  960. 0
  961. #endif
  962. ;
  963. #endif
  964. #if ENABLED(ULTIPANEL)
  965. lcd_preheat_hotend_temp[0] = PREHEAT_1_TEMP_HOTEND;
  966. lcd_preheat_hotend_temp[1] = PREHEAT_2_TEMP_HOTEND;
  967. lcd_preheat_bed_temp[0] = PREHEAT_1_TEMP_BED;
  968. lcd_preheat_bed_temp[1] = PREHEAT_2_TEMP_BED;
  969. lcd_preheat_fan_speed[0] = PREHEAT_1_FAN_SPEED;
  970. lcd_preheat_fan_speed[1] = PREHEAT_2_FAN_SPEED;
  971. #endif
  972. #if HAS_LCD_CONTRAST
  973. lcd_contrast = DEFAULT_LCD_CONTRAST;
  974. #endif
  975. #if ENABLED(PIDTEMP)
  976. #if ENABLED(PID_PARAMS_PER_HOTEND) && HOTENDS > 1
  977. HOTEND_LOOP()
  978. #endif
  979. {
  980. PID_PARAM(Kp, e) = DEFAULT_Kp;
  981. PID_PARAM(Ki, e) = scalePID_i(DEFAULT_Ki);
  982. PID_PARAM(Kd, e) = scalePID_d(DEFAULT_Kd);
  983. #if ENABLED(PID_EXTRUSION_SCALING)
  984. PID_PARAM(Kc, e) = DEFAULT_Kc;
  985. #endif
  986. }
  987. #if ENABLED(PID_EXTRUSION_SCALING)
  988. lpq_len = 20; // default last-position-queue size
  989. #endif
  990. #endif // PIDTEMP
  991. #if ENABLED(PIDTEMPBED)
  992. thermalManager.bedKp = DEFAULT_bedKp;
  993. thermalManager.bedKi = scalePID_i(DEFAULT_bedKi);
  994. thermalManager.bedKd = scalePID_d(DEFAULT_bedKd);
  995. #endif
  996. #if ENABLED(FWRETRACT)
  997. autoretract_enabled = false;
  998. retract_length = RETRACT_LENGTH;
  999. #if EXTRUDERS > 1
  1000. retract_length_swap = RETRACT_LENGTH_SWAP;
  1001. #endif
  1002. retract_feedrate_mm_s = RETRACT_FEEDRATE;
  1003. retract_zlift = RETRACT_ZLIFT;
  1004. retract_recover_length = RETRACT_RECOVER_LENGTH;
  1005. #if EXTRUDERS > 1
  1006. retract_recover_length_swap = RETRACT_RECOVER_LENGTH_SWAP;
  1007. #endif
  1008. retract_recover_feedrate_mm_s = RETRACT_RECOVER_FEEDRATE;
  1009. #endif
  1010. volumetric_enabled =
  1011. #if ENABLED(VOLUMETRIC_DEFAULT_ON)
  1012. true
  1013. #else
  1014. false
  1015. #endif
  1016. ;
  1017. for (uint8_t q = 0; q < COUNT(filament_size); q++)
  1018. filament_size[q] = DEFAULT_NOMINAL_FILAMENT_DIA;
  1019. endstops.enable_globally(
  1020. #if ENABLED(ENDSTOPS_ALWAYS_ON_DEFAULT)
  1021. (true)
  1022. #else
  1023. (false)
  1024. #endif
  1025. );
  1026. #if ENABLED(HAVE_TMC2130)
  1027. #if ENABLED(X_IS_TMC2130)
  1028. stepperX.setCurrent(X_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1029. #endif
  1030. #if ENABLED(Y_IS_TMC2130)
  1031. stepperY.setCurrent(Y_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1032. #endif
  1033. #if ENABLED(Z_IS_TMC2130)
  1034. stepperZ.setCurrent(Z_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1035. #endif
  1036. #if ENABLED(X2_IS_TMC2130)
  1037. stepperX2.setCurrent(X2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1038. #endif
  1039. #if ENABLED(Y2_IS_TMC2130)
  1040. stepperY2.setCurrent(Y2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1041. #endif
  1042. #if ENABLED(Z2_IS_TMC2130)
  1043. stepperZ2.setCurrent(Z2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1044. #endif
  1045. #if ENABLED(E0_IS_TMC2130)
  1046. stepperE0.setCurrent(E0_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1047. #endif
  1048. #if ENABLED(E1_IS_TMC2130)
  1049. stepperE1.setCurrent(E1_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1050. #endif
  1051. #if ENABLED(E2_IS_TMC2130)
  1052. stepperE2.setCurrent(E2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1053. #endif
  1054. #if ENABLED(E3_IS_TMC2130)
  1055. stepperE3.setCurrent(E3_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1056. #endif
  1057. #endif
  1058. #if ENABLED(LIN_ADVANCE)
  1059. planner.set_extruder_advance_k(LIN_ADVANCE_K);
  1060. planner.set_advance_ed_ratio(LIN_ADVANCE_E_D_RATIO);
  1061. #endif
  1062. postprocess();
  1063. SERIAL_ECHO_START;
  1064. SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
  1065. }
  1066. #if DISABLED(DISABLE_M503)
  1067. #define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START; }while(0)
  1068. /**
  1069. * M503 - Report current settings in RAM
  1070. *
  1071. * Unless specifically disabled, M503 is available even without EEPROM
  1072. */
  1073. void MarlinSettings::report(bool forReplay) {
  1074. /**
  1075. * Announce current units, in case inches are being displayed
  1076. */
  1077. CONFIG_ECHO_START;
  1078. #if ENABLED(INCH_MODE_SUPPORT)
  1079. extern float linear_unit_factor, volumetric_unit_factor;
  1080. #define LINEAR_UNIT(N) ((N) / linear_unit_factor)
  1081. #define VOLUMETRIC_UNIT(N) ((N) / (volumetric_enabled ? volumetric_unit_factor : linear_unit_factor))
  1082. serialprintPGM(linear_unit_factor == 1.0 ? PSTR(" G21 ; Units in mm\n") : PSTR(" G20 ; Units in inches\n"));
  1083. #else
  1084. #define LINEAR_UNIT(N) N
  1085. #define VOLUMETRIC_UNIT(N) N
  1086. SERIAL_ECHOLNPGM(" G21 ; Units in mm\n");
  1087. #endif
  1088. SERIAL_EOL;
  1089. /**
  1090. * Volumetric extrusion M200
  1091. */
  1092. if (!forReplay) {
  1093. CONFIG_ECHO_START;
  1094. SERIAL_ECHOPGM("Filament settings:");
  1095. if (volumetric_enabled)
  1096. SERIAL_EOL;
  1097. else
  1098. SERIAL_ECHOLNPGM(" Disabled");
  1099. }
  1100. CONFIG_ECHO_START;
  1101. SERIAL_ECHOPAIR(" M200 D", filament_size[0]);
  1102. SERIAL_EOL;
  1103. #if EXTRUDERS > 1
  1104. CONFIG_ECHO_START;
  1105. SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]);
  1106. SERIAL_EOL;
  1107. #if EXTRUDERS > 2
  1108. CONFIG_ECHO_START;
  1109. SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]);
  1110. SERIAL_EOL;
  1111. #if EXTRUDERS > 3
  1112. CONFIG_ECHO_START;
  1113. SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]);
  1114. SERIAL_EOL;
  1115. #if EXTRUDERS > 4
  1116. CONFIG_ECHO_START;
  1117. SERIAL_ECHOPAIR(" M200 T4 D", filament_size[4]);
  1118. SERIAL_EOL;
  1119. #endif // EXTRUDERS > 4
  1120. #endif // EXTRUDERS > 3
  1121. #endif // EXTRUDERS > 2
  1122. #endif // EXTRUDERS > 1
  1123. if (!volumetric_enabled) {
  1124. CONFIG_ECHO_START;
  1125. SERIAL_ECHOLNPGM(" M200 D0");
  1126. }
  1127. if (!forReplay) {
  1128. CONFIG_ECHO_START;
  1129. SERIAL_ECHOLNPGM("Steps per unit:");
  1130. }
  1131. CONFIG_ECHO_START;
  1132. SERIAL_ECHOPAIR(" M92 X", LINEAR_UNIT(planner.axis_steps_per_mm[X_AXIS]));
  1133. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.axis_steps_per_mm[Y_AXIS]));
  1134. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.axis_steps_per_mm[Z_AXIS]));
  1135. #if DISABLED(DISTINCT_E_FACTORS)
  1136. SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS]));
  1137. #endif
  1138. SERIAL_EOL;
  1139. #if ENABLED(DISTINCT_E_FACTORS)
  1140. CONFIG_ECHO_START;
  1141. for (uint8_t i = 0; i < E_STEPPERS; i++) {
  1142. SERIAL_ECHOPAIR(" M92 T", (int)i);
  1143. SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS + i]));
  1144. }
  1145. #endif
  1146. if (!forReplay) {
  1147. CONFIG_ECHO_START;
  1148. SERIAL_ECHOLNPGM("Maximum feedrates (units/s):");
  1149. }
  1150. CONFIG_ECHO_START;
  1151. SERIAL_ECHOPAIR(" M203 X", LINEAR_UNIT(planner.max_feedrate_mm_s[X_AXIS]));
  1152. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_feedrate_mm_s[Y_AXIS]));
  1153. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_feedrate_mm_s[Z_AXIS]));
  1154. #if DISABLED(DISTINCT_E_FACTORS)
  1155. SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS]));
  1156. #endif
  1157. SERIAL_EOL;
  1158. #if ENABLED(DISTINCT_E_FACTORS)
  1159. CONFIG_ECHO_START;
  1160. for (uint8_t i = 0; i < E_STEPPERS; i++) {
  1161. SERIAL_ECHOPAIR(" M203 T", (int)i);
  1162. SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS + i]));
  1163. }
  1164. #endif
  1165. if (!forReplay) {
  1166. CONFIG_ECHO_START;
  1167. SERIAL_ECHOLNPGM("Maximum Acceleration (units/s2):");
  1168. }
  1169. CONFIG_ECHO_START;
  1170. SERIAL_ECHOPAIR(" M201 X", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[X_AXIS]));
  1171. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[Y_AXIS]));
  1172. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[Z_AXIS]));
  1173. #if DISABLED(DISTINCT_E_FACTORS)
  1174. SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS]));
  1175. #endif
  1176. SERIAL_EOL;
  1177. #if ENABLED(DISTINCT_E_FACTORS)
  1178. SERIAL_ECHO_START;
  1179. for (uint8_t i = 0; i < E_STEPPERS; i++) {
  1180. SERIAL_ECHOPAIR(" M201 T", (int)i);
  1181. SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS + i]));
  1182. }
  1183. #endif
  1184. if (!forReplay) {
  1185. CONFIG_ECHO_START;
  1186. SERIAL_ECHOLNPGM("Acceleration (units/s2): P<print_accel> R<retract_accel> T<travel_accel>");
  1187. }
  1188. CONFIG_ECHO_START;
  1189. SERIAL_ECHOPAIR(" M204 P", LINEAR_UNIT(planner.acceleration));
  1190. SERIAL_ECHOPAIR(" R", LINEAR_UNIT(planner.retract_acceleration));
  1191. SERIAL_ECHOLNPAIR(" T", LINEAR_UNIT(planner.travel_acceleration));
  1192. if (!forReplay) {
  1193. CONFIG_ECHO_START;
  1194. SERIAL_ECHOLNPGM("Advanced: S<min_feedrate> T<min_travel_feedrate> B<min_segment_time_ms> X<max_xy_jerk> Z<max_z_jerk> E<max_e_jerk>");
  1195. }
  1196. CONFIG_ECHO_START;
  1197. SERIAL_ECHOPAIR(" M205 S", LINEAR_UNIT(planner.min_feedrate_mm_s));
  1198. SERIAL_ECHOPAIR(" T", LINEAR_UNIT(planner.min_travel_feedrate_mm_s));
  1199. SERIAL_ECHOPAIR(" B", planner.min_segment_time);
  1200. SERIAL_ECHOPAIR(" X", LINEAR_UNIT(planner.max_jerk[X_AXIS]));
  1201. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_jerk[Y_AXIS]));
  1202. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_jerk[Z_AXIS]));
  1203. SERIAL_ECHOLNPAIR(" E", LINEAR_UNIT(planner.max_jerk[E_AXIS]));
  1204. #if HAS_M206_COMMAND
  1205. if (!forReplay) {
  1206. CONFIG_ECHO_START;
  1207. SERIAL_ECHOLNPGM("Home offset:");
  1208. }
  1209. CONFIG_ECHO_START;
  1210. SERIAL_ECHOPAIR(" M206 X", LINEAR_UNIT(home_offset[X_AXIS]));
  1211. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(home_offset[Y_AXIS]));
  1212. SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(home_offset[Z_AXIS]));
  1213. #endif
  1214. #if HOTENDS > 1
  1215. if (!forReplay) {
  1216. CONFIG_ECHO_START;
  1217. SERIAL_ECHOLNPGM("Hotend offsets:");
  1218. }
  1219. CONFIG_ECHO_START;
  1220. for (uint8_t e = 1; e < HOTENDS; e++) {
  1221. SERIAL_ECHOPAIR(" M218 T", (int)e);
  1222. SERIAL_ECHOPAIR(" X", LINEAR_UNIT(hotend_offset[X_AXIS][e]));
  1223. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(hotend_offset[Y_AXIS][e]));
  1224. #if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_EXTRUDER)
  1225. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(hotend_offset[Z_AXIS][e]));
  1226. #endif
  1227. SERIAL_EOL;
  1228. }
  1229. #endif
  1230. #if ENABLED(MESH_BED_LEVELING)
  1231. if (!forReplay) {
  1232. CONFIG_ECHO_START;
  1233. SERIAL_ECHOLNPGM("Mesh Bed Leveling:");
  1234. }
  1235. CONFIG_ECHO_START;
  1236. SERIAL_ECHOPAIR(" M420 S", mbl.has_mesh() ? 1 : 0);
  1237. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  1238. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
  1239. #endif
  1240. SERIAL_EOL;
  1241. for (uint8_t py = 0; py < GRID_MAX_POINTS_Y; py++) {
  1242. for (uint8_t px = 0; px < GRID_MAX_POINTS_X; px++) {
  1243. CONFIG_ECHO_START;
  1244. SERIAL_ECHOPAIR(" G29 S3 X", (int)px + 1);
  1245. SERIAL_ECHOPAIR(" Y", (int)py + 1);
  1246. SERIAL_ECHOPGM(" Z");
  1247. SERIAL_PROTOCOL_F(LINEAR_UNIT(mbl.z_values[px][py]), 5);
  1248. SERIAL_EOL;
  1249. }
  1250. }
  1251. #elif ENABLED(AUTO_BED_LEVELING_UBL)
  1252. if (!forReplay) {
  1253. CONFIG_ECHO_START;
  1254. SERIAL_ECHOLNPGM("Unified Bed Leveling:");
  1255. }
  1256. CONFIG_ECHO_START;
  1257. SERIAL_ECHOPAIR(" M420 S", ubl.state.active ? 1 : 0);
  1258. //#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  1259. // SERIAL_ECHOPAIR(" Z", ubl.state.g29_correction_fade_height);
  1260. //#endif
  1261. SERIAL_EOL;
  1262. if (!forReplay) {
  1263. SERIAL_ECHOPGM("\nUBL is ");
  1264. ubl.state.active ? SERIAL_CHAR('A') : SERIAL_ECHOPGM("Ina");
  1265. SERIAL_ECHOLNPAIR("ctive\n\nActive Mesh Slot: ", ubl.state.eeprom_storage_slot);
  1266. SERIAL_ECHOPGM("z_offset: ");
  1267. SERIAL_ECHO_F(ubl.state.z_offset, 6);
  1268. SERIAL_EOL;
  1269. SERIAL_ECHOPAIR("EEPROM can hold ", (int)((UBL_LAST_EEPROM_INDEX - ubl.eeprom_start) / sizeof(ubl.z_values)));
  1270. SERIAL_ECHOLNPGM(" meshes.\n");
  1271. SERIAL_ECHOLNPAIR("GRID_MAX_POINTS_X ", GRID_MAX_POINTS_X);
  1272. SERIAL_ECHOLNPAIR("GRID_MAX_POINTS_Y ", GRID_MAX_POINTS_Y);
  1273. SERIAL_ECHOPGM("UBL_MESH_MIN_X " STRINGIFY(UBL_MESH_MIN_X));
  1274. SERIAL_ECHOLNPAIR("=", UBL_MESH_MIN_X );
  1275. SERIAL_ECHOPGM("UBL_MESH_MIN_Y " STRINGIFY(UBL_MESH_MIN_Y));
  1276. SERIAL_ECHOLNPAIR("=", UBL_MESH_MIN_Y );
  1277. SERIAL_ECHOPGM("UBL_MESH_MAX_X " STRINGIFY(UBL_MESH_MAX_X));
  1278. SERIAL_ECHOLNPAIR("=", UBL_MESH_MAX_X);
  1279. SERIAL_ECHOPGM("UBL_MESH_MAX_Y " STRINGIFY(UBL_MESH_MAX_Y));
  1280. SERIAL_ECHOLNPAIR("=", UBL_MESH_MAX_Y);
  1281. SERIAL_ECHOLNPAIR("MESH_X_DIST ", MESH_X_DIST);
  1282. SERIAL_ECHOLNPAIR("MESH_Y_DIST ", MESH_Y_DIST);
  1283. SERIAL_EOL;
  1284. }
  1285. #elif HAS_ABL
  1286. if (!forReplay) {
  1287. CONFIG_ECHO_START;
  1288. SERIAL_ECHOLNPGM("Auto Bed Leveling:");
  1289. }
  1290. CONFIG_ECHO_START;
  1291. SERIAL_ECHOPAIR(" M420 S", planner.abl_enabled ? 1 : 0);
  1292. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  1293. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
  1294. #endif
  1295. SERIAL_EOL;
  1296. #endif
  1297. #if ENABLED(DELTA)
  1298. if (!forReplay) {
  1299. CONFIG_ECHO_START;
  1300. SERIAL_ECHOLNPGM("Endstop adjustment:");
  1301. }
  1302. CONFIG_ECHO_START;
  1303. SERIAL_ECHOPAIR(" M666 X", LINEAR_UNIT(endstop_adj[X_AXIS]));
  1304. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(endstop_adj[Y_AXIS]));
  1305. SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(endstop_adj[Z_AXIS]));
  1306. if (!forReplay) {
  1307. CONFIG_ECHO_START;
  1308. SERIAL_ECHOLNPGM("Delta settings: L<diagonal_rod> R<radius> H<height> S<segments_per_s> ABC<diagonal_rod_[123]_trim>");
  1309. }
  1310. CONFIG_ECHO_START;
  1311. SERIAL_ECHOPAIR(" M665 L", LINEAR_UNIT(delta_diagonal_rod));
  1312. SERIAL_ECHOPAIR(" R", LINEAR_UNIT(delta_radius));
  1313. SERIAL_ECHOPAIR(" H", LINEAR_UNIT(DELTA_HEIGHT + home_offset[Z_AXIS]));
  1314. SERIAL_ECHOPAIR(" S", delta_segments_per_second);
  1315. SERIAL_ECHOPAIR(" A", LINEAR_UNIT(delta_diagonal_rod_trim[A_AXIS]));
  1316. SERIAL_ECHOPAIR(" B", LINEAR_UNIT(delta_diagonal_rod_trim[B_AXIS]));
  1317. SERIAL_ECHOPAIR(" C", LINEAR_UNIT(delta_diagonal_rod_trim[C_AXIS]));
  1318. SERIAL_ECHOPAIR(" I", LINEAR_UNIT(delta_tower_angle_trim[A_AXIS]));
  1319. SERIAL_ECHOPAIR(" J", LINEAR_UNIT(delta_tower_angle_trim[B_AXIS]));
  1320. SERIAL_ECHOLNPAIR(" K", LINEAR_UNIT(delta_tower_angle_trim[C_AXIS]));
  1321. #elif ENABLED(Z_DUAL_ENDSTOPS)
  1322. if (!forReplay) {
  1323. CONFIG_ECHO_START;
  1324. SERIAL_ECHOLNPGM("Z2 Endstop adjustment:");
  1325. }
  1326. CONFIG_ECHO_START;
  1327. SERIAL_ECHOLNPAIR(" M666 Z", LINEAR_UNIT(z_endstop_adj));
  1328. #endif // DELTA
  1329. #if ENABLED(ULTIPANEL)
  1330. if (!forReplay) {
  1331. CONFIG_ECHO_START;
  1332. SERIAL_ECHOLNPGM("Material heatup parameters:");
  1333. }
  1334. CONFIG_ECHO_START;
  1335. for (uint8_t i = 0; i < COUNT(lcd_preheat_hotend_temp); i++) {
  1336. SERIAL_ECHOPAIR(" M145 S", (int)i);
  1337. SERIAL_ECHOPAIR(" H", lcd_preheat_hotend_temp[i]);
  1338. SERIAL_ECHOPAIR(" B", lcd_preheat_bed_temp[i]);
  1339. SERIAL_ECHOLNPAIR(" F", lcd_preheat_fan_speed[i]);
  1340. }
  1341. #endif // ULTIPANEL
  1342. #if HAS_PID_HEATING
  1343. if (!forReplay) {
  1344. CONFIG_ECHO_START;
  1345. SERIAL_ECHOLNPGM("PID settings:");
  1346. }
  1347. #if ENABLED(PIDTEMP)
  1348. #if HOTENDS > 1
  1349. if (forReplay) {
  1350. HOTEND_LOOP() {
  1351. CONFIG_ECHO_START;
  1352. SERIAL_ECHOPAIR(" M301 E", e);
  1353. SERIAL_ECHOPAIR(" P", PID_PARAM(Kp, e));
  1354. SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, e)));
  1355. SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, e)));
  1356. #if ENABLED(PID_EXTRUSION_SCALING)
  1357. SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, e));
  1358. if (e == 0) SERIAL_ECHOPAIR(" L", lpq_len);
  1359. #endif
  1360. SERIAL_EOL;
  1361. }
  1362. }
  1363. else
  1364. #endif // HOTENDS > 1
  1365. // !forReplay || HOTENDS == 1
  1366. {
  1367. CONFIG_ECHO_START;
  1368. SERIAL_ECHOPAIR(" M301 P", PID_PARAM(Kp, 0)); // for compatibility with hosts, only echo values for E0
  1369. SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, 0)));
  1370. SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, 0)));
  1371. #if ENABLED(PID_EXTRUSION_SCALING)
  1372. SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, 0));
  1373. SERIAL_ECHOPAIR(" L", lpq_len);
  1374. #endif
  1375. SERIAL_EOL;
  1376. }
  1377. #endif // PIDTEMP
  1378. #if ENABLED(PIDTEMPBED)
  1379. CONFIG_ECHO_START;
  1380. SERIAL_ECHOPAIR(" M304 P", thermalManager.bedKp);
  1381. SERIAL_ECHOPAIR(" I", unscalePID_i(thermalManager.bedKi));
  1382. SERIAL_ECHOPAIR(" D", unscalePID_d(thermalManager.bedKd));
  1383. SERIAL_EOL;
  1384. #endif
  1385. #endif // PIDTEMP || PIDTEMPBED
  1386. #if HAS_LCD_CONTRAST
  1387. if (!forReplay) {
  1388. CONFIG_ECHO_START;
  1389. SERIAL_ECHOLNPGM("LCD Contrast:");
  1390. }
  1391. CONFIG_ECHO_START;
  1392. SERIAL_ECHOLNPAIR(" M250 C", lcd_contrast);
  1393. #endif
  1394. #if ENABLED(FWRETRACT)
  1395. if (!forReplay) {
  1396. CONFIG_ECHO_START;
  1397. SERIAL_ECHOLNPGM("Retract: S<length> F<units/m> Z<lift>");
  1398. }
  1399. CONFIG_ECHO_START;
  1400. SERIAL_ECHOPAIR(" M207 S", LINEAR_UNIT(retract_length));
  1401. #if EXTRUDERS > 1
  1402. SERIAL_ECHOPAIR(" W", LINEAR_UNIT(retract_length_swap));
  1403. #endif
  1404. SERIAL_ECHOPAIR(" F", MMS_TO_MMM(LINEAR_UNIT(retract_feedrate_mm_s)));
  1405. SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(retract_zlift));
  1406. if (!forReplay) {
  1407. CONFIG_ECHO_START;
  1408. SERIAL_ECHOLNPGM("Recover: S<length> F<units/m>");
  1409. }
  1410. CONFIG_ECHO_START;
  1411. SERIAL_ECHOPAIR(" M208 S", LINEAR_UNIT(retract_recover_length));
  1412. #if EXTRUDERS > 1
  1413. SERIAL_ECHOPAIR(" W", LINEAR_UNIT(retract_recover_length_swap));
  1414. #endif
  1415. SERIAL_ECHOLNPAIR(" F", MMS_TO_MMM(LINEAR_UNIT(retract_recover_feedrate_mm_s)));
  1416. if (!forReplay) {
  1417. CONFIG_ECHO_START;
  1418. SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries");
  1419. }
  1420. CONFIG_ECHO_START;
  1421. SERIAL_ECHOLNPAIR(" M209 S", autoretract_enabled ? 1 : 0);
  1422. #endif // FWRETRACT
  1423. /**
  1424. * Auto Bed Leveling
  1425. */
  1426. #if HAS_BED_PROBE
  1427. if (!forReplay) {
  1428. CONFIG_ECHO_START;
  1429. SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
  1430. }
  1431. CONFIG_ECHO_START;
  1432. SERIAL_ECHOLNPAIR(" M851 Z", LINEAR_UNIT(zprobe_zoffset));
  1433. #endif
  1434. /**
  1435. * TMC2130 stepper driver current
  1436. */
  1437. #if ENABLED(HAVE_TMC2130)
  1438. if (!forReplay) {
  1439. CONFIG_ECHO_START;
  1440. SERIAL_ECHOLNPGM("Stepper driver current:");
  1441. }
  1442. CONFIG_ECHO_START;
  1443. SERIAL_ECHO(" M906");
  1444. #if ENABLED(X_IS_TMC2130)
  1445. SERIAL_ECHOPAIR(" X", stepperX.getCurrent());
  1446. #endif
  1447. #if ENABLED(Y_IS_TMC2130)
  1448. SERIAL_ECHOPAIR(" Y", stepperY.getCurrent());
  1449. #endif
  1450. #if ENABLED(Z_IS_TMC2130)
  1451. SERIAL_ECHOPAIR(" Z", stepperZ.getCurrent());
  1452. #endif
  1453. #if ENABLED(X2_IS_TMC2130)
  1454. SERIAL_ECHOPAIR(" X2", stepperX2.getCurrent());
  1455. #endif
  1456. #if ENABLED(Y2_IS_TMC2130)
  1457. SERIAL_ECHOPAIR(" Y2", stepperY2.getCurrent());
  1458. #endif
  1459. #if ENABLED(Z2_IS_TMC2130)
  1460. SERIAL_ECHOPAIR(" Z2", stepperZ2.getCurrent());
  1461. #endif
  1462. #if ENABLED(E0_IS_TMC2130)
  1463. SERIAL_ECHOPAIR(" E0", stepperE0.getCurrent());
  1464. #endif
  1465. #if ENABLED(E1_IS_TMC2130)
  1466. SERIAL_ECHOPAIR(" E1", stepperE1.getCurrent());
  1467. #endif
  1468. #if ENABLED(E2_IS_TMC2130)
  1469. SERIAL_ECHOPAIR(" E2", stepperE2.getCurrent());
  1470. #endif
  1471. #if ENABLED(E3_IS_TMC2130)
  1472. SERIAL_ECHOPAIR(" E3", stepperE3.getCurrent());
  1473. #endif
  1474. SERIAL_EOL;
  1475. #endif
  1476. /**
  1477. * Linear Advance
  1478. */
  1479. #if ENABLED(LIN_ADVANCE)
  1480. if (!forReplay) {
  1481. CONFIG_ECHO_START;
  1482. SERIAL_ECHOLNPGM("Linear Advance:");
  1483. }
  1484. CONFIG_ECHO_START;
  1485. SERIAL_ECHOPAIR(" M900 K", planner.get_extruder_advance_k());
  1486. SERIAL_ECHOLNPAIR(" R", planner.get_advance_ed_ratio());
  1487. #endif
  1488. }
  1489. #endif // !DISABLE_M503