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

configuration_store.cpp 61KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977
  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 "V44"
  38. // Change EEPROM version if these are changed:
  39. #define EEPROM_OFFSET 100
  40. /**
  41. * V44 EEPROM Layout:
  42. *
  43. * 100 Version (char x4)
  44. * 104 EEPROM CRC16 (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_us (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 planner.leveling_active (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 x81) +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 z_values[][] (float x9, up to float x256) +988
  85. *
  86. * AUTO_BED_LEVELING_UBL: 2 bytes
  87. * 324 G29 A planner.leveling_active (bool)
  88. * 325 G29 S ubl.storage_slot (int8_t)
  89. *
  90. * DELTA: 40 bytes
  91. * 352 M666 XYZ delta_endstop_adj (float x3)
  92. * 364 M665 R delta_radius (float)
  93. * 368 M665 L delta_diagonal_rod (float)
  94. * 372 M665 S delta_segments_per_second (float)
  95. * 376 M665 B delta_calibration_radius (float)
  96. * 380 M665 X delta_tower_angle_trim[A] (float)
  97. * 384 M665 Y delta_tower_angle_trim[B] (float)
  98. * 388 M665 Z delta_tower_angle_trim[C] (float)
  99. *
  100. * [XYZ]_DUAL_ENDSTOPS: 12 bytes
  101. * 352 M666 X endstops.x_endstop_adj (float)
  102. * 356 M666 Y endstops.y_endstop_adj (float)
  103. * 360 M666 Z endstops.z_endstop_adj (float)
  104. *
  105. * ULTIPANEL: 6 bytes
  106. * 392 M145 S0 H lcd_preheat_hotend_temp (int x2)
  107. * 396 M145 S0 B lcd_preheat_bed_temp (int x2)
  108. * 400 M145 S0 F lcd_preheat_fan_speed (int x2)
  109. *
  110. * PIDTEMP: 82 bytes
  111. * 404 M301 E0 PIDC Kp[0], Ki[0], Kd[0], Kc[0] (float x4)
  112. * 420 M301 E1 PIDC Kp[1], Ki[1], Kd[1], Kc[1] (float x4)
  113. * 436 M301 E2 PIDC Kp[2], Ki[2], Kd[2], Kc[2] (float x4)
  114. * 452 M301 E3 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
  115. * 468 M301 E4 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
  116. * 484 M301 L lpq_len (int)
  117. *
  118. * PIDTEMPBED: 12 bytes
  119. * 486 M304 PID thermalManager.bedKp, .bedKi, .bedKd (float x3)
  120. *
  121. * DOGLCD: 2 bytes
  122. * 498 M250 C lcd_contrast (uint16_t)
  123. *
  124. * FWRETRACT: 33 bytes
  125. * 500 M209 S autoretract_enabled (bool)
  126. * 501 M207 S retract_length (float)
  127. * 505 M207 F retract_feedrate_mm_s (float)
  128. * 509 M207 Z retract_zlift (float)
  129. * 513 M208 S retract_recover_length (float)
  130. * 517 M208 F retract_recover_feedrate_mm_s (float)
  131. * 521 M207 W swap_retract_length (float)
  132. * 525 M208 W swap_retract_recover_length (float)
  133. * 529 M208 R swap_retract_recover_feedrate_mm_s (float)
  134. *
  135. * Volumetric Extrusion: 21 bytes
  136. * 533 M200 D volumetric_enabled (bool)
  137. * 534 M200 T D filament_size (float x5) (T0..3)
  138. *
  139. * HAVE_TMC2130: 22 bytes
  140. * 554 M906 X Stepper X current (uint16_t)
  141. * 556 M906 Y Stepper Y current (uint16_t)
  142. * 558 M906 Z Stepper Z current (uint16_t)
  143. * 560 M906 X2 Stepper X2 current (uint16_t)
  144. * 562 M906 Y2 Stepper Y2 current (uint16_t)
  145. * 564 M906 Z2 Stepper Z2 current (uint16_t)
  146. * 566 M906 E0 Stepper E0 current (uint16_t)
  147. * 568 M906 E1 Stepper E1 current (uint16_t)
  148. * 570 M906 E2 Stepper E2 current (uint16_t)
  149. * 572 M906 E3 Stepper E3 current (uint16_t)
  150. * 574 M906 E4 Stepper E4 current (uint16_t)
  151. *
  152. * LIN_ADVANCE: 8 bytes
  153. * 576 M900 K extruder_advance_k (float)
  154. * 580 M900 WHD advance_ed_ratio (float)
  155. *
  156. * HAS_MOTOR_CURRENT_PWM:
  157. * 584 M907 X Stepper XY current (uint32_t)
  158. * 588 M907 Z Stepper Z current (uint32_t)
  159. * 592 M907 E Stepper E current (uint32_t)
  160. *
  161. * CNC_COORDINATE_SYSTEMS 108 bytes
  162. * 596 G54-G59.3 coordinate_system (float x 27)
  163. *
  164. * 704 Minimum end-point
  165. * 2025 (704 + 36 + 9 + 288 + 988) Maximum end-point
  166. *
  167. * ========================================================================
  168. * meshes_begin (between max and min end-point, directly above)
  169. * -- MESHES --
  170. * meshes_end
  171. * -- MAT (Mesh Allocation Table) -- 128 bytes (placeholder size)
  172. * mat_end = E2END (0xFFF)
  173. *
  174. */
  175. #include "configuration_store.h"
  176. MarlinSettings settings;
  177. #include "endstops.h"
  178. #include "planner.h"
  179. #include "stepper.h"
  180. #include "temperature.h"
  181. #include "../lcd/ultralcd.h"
  182. #include "../core/language.h"
  183. #include "../Marlin.h"
  184. #include "../gcode/parser.h"
  185. #if HAS_LEVELING
  186. #include "../feature/bedlevel/bedlevel.h"
  187. #endif
  188. #if HAS_BED_PROBE
  189. #include "../module/probe.h"
  190. #endif
  191. #if ENABLED(HAVE_TMC2130)
  192. #include "stepper_indirection.h"
  193. #endif
  194. #if ENABLED(FWRETRACT)
  195. #include "../feature/fwretract.h"
  196. #endif
  197. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  198. float new_z_fade_height;
  199. #endif
  200. #if ENABLED(CNC_COORDINATE_SYSTEMS)
  201. bool position_changed;
  202. #endif
  203. /**
  204. * Post-process after Retrieve or Reset
  205. */
  206. void MarlinSettings::postprocess() {
  207. // steps per s2 needs to be updated to agree with units per s2
  208. planner.reset_acceleration_rates();
  209. // Make sure delta kinematics are updated before refreshing the
  210. // planner position so the stepper counts will be set correctly.
  211. #if ENABLED(DELTA)
  212. recalc_delta_settings(delta_radius, delta_diagonal_rod, delta_tower_angle_trim);
  213. #endif
  214. // Refresh steps_to_mm with the reciprocal of axis_steps_per_mm
  215. // and init stepper.count[], planner.position[] with current_position
  216. planner.refresh_positioning();
  217. #if ENABLED(PIDTEMP)
  218. thermalManager.updatePID();
  219. #endif
  220. planner.calculate_volumetric_multipliers();
  221. #if HAS_HOME_OFFSET || ENABLED(DUAL_X_CARRIAGE)
  222. // Software endstops depend on home_offset
  223. LOOP_XYZ(i) update_software_endstops((AxisEnum)i);
  224. #endif
  225. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  226. set_z_fade_height(new_z_fade_height);
  227. #endif
  228. #if HAS_BED_PROBE
  229. refresh_zprobe_zoffset();
  230. #endif
  231. #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
  232. refresh_bed_level();
  233. //set_bed_leveling_enabled(leveling_is_on);
  234. #endif
  235. #if HAS_MOTOR_CURRENT_PWM
  236. stepper.refresh_motor_power();
  237. #endif
  238. #if ENABLED(FWRETRACT)
  239. fwretract.refresh_autoretract();
  240. #endif
  241. #if ENABLED(CNC_COORDINATE_SYSTEMS)
  242. if (position_changed) {
  243. report_current_position();
  244. position_changed = false;
  245. }
  246. #endif
  247. }
  248. #if ENABLED(EEPROM_SETTINGS)
  249. #include "../HAL/persistent_store_api.h"
  250. #define DUMMY_PID_VALUE 3000.0f
  251. #define EEPROM_START() int eeprom_index = EEPROM_OFFSET; HAL::PersistentStore::access_start()
  252. #define EEPROM_FINISH() HAL::PersistentStore::access_finish()
  253. #define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR)
  254. #define EEPROM_WRITE(VAR) HAL::PersistentStore::write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
  255. #define EEPROM_READ(VAR) HAL::PersistentStore::read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
  256. #define EEPROM_ASSERT(TST,ERR) if (!(TST)) do{ SERIAL_ERROR_START(); SERIAL_ERRORLNPGM(ERR); eeprom_read_error = true; }while(0)
  257. const char version[4] = EEPROM_VERSION;
  258. bool MarlinSettings::eeprom_error;
  259. #if ENABLED(AUTO_BED_LEVELING_UBL)
  260. int MarlinSettings::meshes_begin;
  261. #endif
  262. /**
  263. * M500 - Store Configuration
  264. */
  265. bool MarlinSettings::save() {
  266. float dummy = 0.0f;
  267. char ver[4] = "000";
  268. uint16_t working_crc = 0;
  269. EEPROM_START();
  270. eeprom_error = false;
  271. EEPROM_WRITE(ver); // invalidate data first
  272. EEPROM_SKIP(working_crc); // Skip the checksum slot
  273. working_crc = 0; // Init to 0. Accumulated by EEPROM_READ
  274. const uint8_t esteppers = COUNT(planner.axis_steps_per_mm) - XYZ;
  275. EEPROM_WRITE(esteppers);
  276. EEPROM_WRITE(planner.axis_steps_per_mm);
  277. EEPROM_WRITE(planner.max_feedrate_mm_s);
  278. EEPROM_WRITE(planner.max_acceleration_mm_per_s2);
  279. EEPROM_WRITE(planner.acceleration);
  280. EEPROM_WRITE(planner.retract_acceleration);
  281. EEPROM_WRITE(planner.travel_acceleration);
  282. EEPROM_WRITE(planner.min_feedrate_mm_s);
  283. EEPROM_WRITE(planner.min_travel_feedrate_mm_s);
  284. EEPROM_WRITE(planner.min_segment_time_us);
  285. EEPROM_WRITE(planner.max_jerk);
  286. #if !HAS_HOME_OFFSET
  287. const float home_offset[XYZ] = { 0 };
  288. #endif
  289. #if ENABLED(DELTA)
  290. dummy = 0.0;
  291. EEPROM_WRITE(dummy);
  292. EEPROM_WRITE(dummy);
  293. dummy = DELTA_HEIGHT + home_offset[Z_AXIS];
  294. EEPROM_WRITE(dummy);
  295. #else
  296. EEPROM_WRITE(home_offset);
  297. #endif
  298. #if HOTENDS > 1
  299. // Skip hotend 0 which must be 0
  300. for (uint8_t e = 1; e < HOTENDS; e++)
  301. LOOP_XYZ(i) EEPROM_WRITE(hotend_offset[i][e]);
  302. #endif
  303. //
  304. // Global Leveling
  305. //
  306. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  307. const float zfh = planner.z_fade_height;
  308. #else
  309. const float zfh = 0.0;
  310. #endif
  311. EEPROM_WRITE(zfh);
  312. //
  313. // Mesh Bed Leveling
  314. //
  315. #if ENABLED(MESH_BED_LEVELING)
  316. // Compile time test that sizeof(mbl.z_values) is as expected
  317. static_assert(
  318. sizeof(mbl.z_values) == GRID_MAX_POINTS * sizeof(mbl.z_values[0][0]),
  319. "MBL Z array is the wrong size."
  320. );
  321. const bool leveling_is_on = mbl.has_mesh;
  322. const uint8_t mesh_num_x = GRID_MAX_POINTS_X, mesh_num_y = GRID_MAX_POINTS_Y;
  323. EEPROM_WRITE(leveling_is_on);
  324. EEPROM_WRITE(mbl.z_offset);
  325. EEPROM_WRITE(mesh_num_x);
  326. EEPROM_WRITE(mesh_num_y);
  327. EEPROM_WRITE(mbl.z_values);
  328. #else // For disabled MBL write a default mesh
  329. const bool leveling_is_on = false;
  330. dummy = 0.0f;
  331. const uint8_t mesh_num_x = 3, mesh_num_y = 3;
  332. EEPROM_WRITE(leveling_is_on);
  333. EEPROM_WRITE(dummy); // z_offset
  334. EEPROM_WRITE(mesh_num_x);
  335. EEPROM_WRITE(mesh_num_y);
  336. for (uint8_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_WRITE(dummy);
  337. #endif // MESH_BED_LEVELING
  338. #if !HAS_BED_PROBE
  339. const float zprobe_zoffset = 0;
  340. #endif
  341. EEPROM_WRITE(zprobe_zoffset);
  342. //
  343. // Planar Bed Leveling matrix
  344. //
  345. #if ABL_PLANAR
  346. EEPROM_WRITE(planner.bed_level_matrix);
  347. #else
  348. dummy = 0.0;
  349. for (uint8_t q = 9; q--;) EEPROM_WRITE(dummy);
  350. #endif
  351. //
  352. // Bilinear Auto Bed Leveling
  353. //
  354. #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
  355. // Compile time test that sizeof(z_values) is as expected
  356. static_assert(
  357. sizeof(z_values) == GRID_MAX_POINTS * sizeof(z_values[0][0]),
  358. "Bilinear Z array is the wrong size."
  359. );
  360. const uint8_t grid_max_x = GRID_MAX_POINTS_X, grid_max_y = GRID_MAX_POINTS_Y;
  361. EEPROM_WRITE(grid_max_x); // 1 byte
  362. EEPROM_WRITE(grid_max_y); // 1 byte
  363. EEPROM_WRITE(bilinear_grid_spacing); // 2 ints
  364. EEPROM_WRITE(bilinear_start); // 2 ints
  365. EEPROM_WRITE(z_values); // 9-256 floats
  366. #else
  367. // For disabled Bilinear Grid write an empty 3x3 grid
  368. const uint8_t grid_max_x = 3, grid_max_y = 3;
  369. const int bilinear_start[2] = { 0 }, bilinear_grid_spacing[2] = { 0 };
  370. dummy = 0.0f;
  371. EEPROM_WRITE(grid_max_x);
  372. EEPROM_WRITE(grid_max_y);
  373. EEPROM_WRITE(bilinear_grid_spacing);
  374. EEPROM_WRITE(bilinear_start);
  375. for (uint16_t q = grid_max_x * grid_max_y; q--;) EEPROM_WRITE(dummy);
  376. #endif // AUTO_BED_LEVELING_BILINEAR
  377. #if ENABLED(AUTO_BED_LEVELING_UBL)
  378. EEPROM_WRITE(planner.leveling_active);
  379. EEPROM_WRITE(ubl.storage_slot);
  380. #else
  381. const bool ubl_active = false;
  382. const int8_t storage_slot = -1;
  383. EEPROM_WRITE(ubl_active);
  384. EEPROM_WRITE(storage_slot);
  385. #endif // AUTO_BED_LEVELING_UBL
  386. // 10 floats for DELTA / [XYZ]_DUAL_ENDSTOPS
  387. #if ENABLED(DELTA)
  388. EEPROM_WRITE(delta_endstop_adj); // 3 floats
  389. EEPROM_WRITE(delta_radius); // 1 float
  390. EEPROM_WRITE(delta_diagonal_rod); // 1 float
  391. EEPROM_WRITE(delta_segments_per_second); // 1 float
  392. EEPROM_WRITE(delta_calibration_radius); // 1 float
  393. EEPROM_WRITE(delta_tower_angle_trim); // 3 floats
  394. #elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS)
  395. // Write dual endstops in X, Y, Z order. Unused = 0.0
  396. dummy = 0.0f;
  397. #if ENABLED(X_DUAL_ENDSTOPS)
  398. EEPROM_WRITE(endstops.x_endstop_adj); // 1 float
  399. #else
  400. EEPROM_WRITE(dummy);
  401. #endif
  402. #if ENABLED(Y_DUAL_ENDSTOPS)
  403. EEPROM_WRITE(endstops.y_endstop_adj); // 1 float
  404. #else
  405. EEPROM_WRITE(dummy);
  406. #endif
  407. #if ENABLED(Z_DUAL_ENDSTOPS)
  408. EEPROM_WRITE(endstops.z_endstop_adj); // 1 float
  409. #else
  410. EEPROM_WRITE(dummy);
  411. #endif
  412. for (uint8_t q = 7; q--;) EEPROM_WRITE(dummy);
  413. #else
  414. dummy = 0.0f;
  415. for (uint8_t q = 10; q--;) EEPROM_WRITE(dummy);
  416. #endif
  417. #if DISABLED(ULTIPANEL)
  418. constexpr int lcd_preheat_hotend_temp[2] = { PREHEAT_1_TEMP_HOTEND, PREHEAT_2_TEMP_HOTEND },
  419. lcd_preheat_bed_temp[2] = { PREHEAT_1_TEMP_BED, PREHEAT_2_TEMP_BED },
  420. lcd_preheat_fan_speed[2] = { PREHEAT_1_FAN_SPEED, PREHEAT_2_FAN_SPEED };
  421. #endif
  422. EEPROM_WRITE(lcd_preheat_hotend_temp);
  423. EEPROM_WRITE(lcd_preheat_bed_temp);
  424. EEPROM_WRITE(lcd_preheat_fan_speed);
  425. for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
  426. #if ENABLED(PIDTEMP)
  427. if (e < HOTENDS) {
  428. EEPROM_WRITE(PID_PARAM(Kp, e));
  429. EEPROM_WRITE(PID_PARAM(Ki, e));
  430. EEPROM_WRITE(PID_PARAM(Kd, e));
  431. #if ENABLED(PID_EXTRUSION_SCALING)
  432. EEPROM_WRITE(PID_PARAM(Kc, e));
  433. #else
  434. dummy = 1.0f; // 1.0 = default kc
  435. EEPROM_WRITE(dummy);
  436. #endif
  437. }
  438. else
  439. #endif // !PIDTEMP
  440. {
  441. dummy = DUMMY_PID_VALUE; // When read, will not change the existing value
  442. EEPROM_WRITE(dummy); // Kp
  443. dummy = 0.0f;
  444. for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy); // Ki, Kd, Kc
  445. }
  446. } // Hotends Loop
  447. #if DISABLED(PID_EXTRUSION_SCALING)
  448. int lpq_len = 20;
  449. #endif
  450. EEPROM_WRITE(lpq_len);
  451. #if DISABLED(PIDTEMPBED)
  452. dummy = DUMMY_PID_VALUE;
  453. for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy);
  454. #else
  455. EEPROM_WRITE(thermalManager.bedKp);
  456. EEPROM_WRITE(thermalManager.bedKi);
  457. EEPROM_WRITE(thermalManager.bedKd);
  458. #endif
  459. #if !HAS_LCD_CONTRAST
  460. const uint16_t lcd_contrast = 32;
  461. #endif
  462. EEPROM_WRITE(lcd_contrast);
  463. #if DISABLED(FWRETRACT)
  464. const bool autoretract_enabled = false;
  465. const float autoretract_defaults[] = { 3, 45, 0, 0, 0, 13, 0, 8 };
  466. EEPROM_WRITE(autoretract_enabled);
  467. EEPROM_WRITE(autoretract_defaults);
  468. #else
  469. EEPROM_WRITE(fwretract.autoretract_enabled);
  470. EEPROM_WRITE(fwretract.retract_length);
  471. EEPROM_WRITE(fwretract.retract_feedrate_mm_s);
  472. EEPROM_WRITE(fwretract.retract_zlift);
  473. EEPROM_WRITE(fwretract.retract_recover_length);
  474. EEPROM_WRITE(fwretract.retract_recover_feedrate_mm_s);
  475. EEPROM_WRITE(fwretract.swap_retract_length);
  476. EEPROM_WRITE(fwretract.swap_retract_recover_length);
  477. EEPROM_WRITE(fwretract.swap_retract_recover_feedrate_mm_s);
  478. #endif
  479. EEPROM_WRITE(parser.volumetric_enabled);
  480. // Save filament sizes
  481. for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
  482. if (q < COUNT(planner.filament_size)) dummy = planner.filament_size[q];
  483. EEPROM_WRITE(dummy);
  484. }
  485. // Save TMC2130 Configuration, and placeholder values
  486. uint16_t val;
  487. #if ENABLED(HAVE_TMC2130)
  488. #if ENABLED(X_IS_TMC2130)
  489. val = stepperX.getCurrent();
  490. #else
  491. val = 0;
  492. #endif
  493. EEPROM_WRITE(val);
  494. #if ENABLED(Y_IS_TMC2130)
  495. val = stepperY.getCurrent();
  496. #else
  497. val = 0;
  498. #endif
  499. EEPROM_WRITE(val);
  500. #if ENABLED(Z_IS_TMC2130)
  501. val = stepperZ.getCurrent();
  502. #else
  503. val = 0;
  504. #endif
  505. EEPROM_WRITE(val);
  506. #if ENABLED(X2_IS_TMC2130)
  507. val = stepperX2.getCurrent();
  508. #else
  509. val = 0;
  510. #endif
  511. EEPROM_WRITE(val);
  512. #if ENABLED(Y2_IS_TMC2130)
  513. val = stepperY2.getCurrent();
  514. #else
  515. val = 0;
  516. #endif
  517. EEPROM_WRITE(val);
  518. #if ENABLED(Z2_IS_TMC2130)
  519. val = stepperZ2.getCurrent();
  520. #else
  521. val = 0;
  522. #endif
  523. EEPROM_WRITE(val);
  524. #if ENABLED(E0_IS_TMC2130)
  525. val = stepperE0.getCurrent();
  526. #else
  527. val = 0;
  528. #endif
  529. EEPROM_WRITE(val);
  530. #if ENABLED(E1_IS_TMC2130)
  531. val = stepperE1.getCurrent();
  532. #else
  533. val = 0;
  534. #endif
  535. EEPROM_WRITE(val);
  536. #if ENABLED(E2_IS_TMC2130)
  537. val = stepperE2.getCurrent();
  538. #else
  539. val = 0;
  540. #endif
  541. EEPROM_WRITE(val);
  542. #if ENABLED(E3_IS_TMC2130)
  543. val = stepperE3.getCurrent();
  544. #else
  545. val = 0;
  546. #endif
  547. EEPROM_WRITE(val);
  548. #if ENABLED(E4_IS_TMC2130)
  549. val = stepperE4.getCurrent();
  550. #else
  551. val = 0;
  552. #endif
  553. EEPROM_WRITE(val);
  554. #else
  555. val = 0;
  556. for (uint8_t q = 11; q--;) EEPROM_WRITE(val);
  557. #endif
  558. //
  559. // Linear Advance
  560. //
  561. #if ENABLED(LIN_ADVANCE)
  562. EEPROM_WRITE(planner.extruder_advance_k);
  563. EEPROM_WRITE(planner.advance_ed_ratio);
  564. #else
  565. dummy = 0.0f;
  566. EEPROM_WRITE(dummy);
  567. EEPROM_WRITE(dummy);
  568. #endif
  569. #if HAS_MOTOR_CURRENT_PWM
  570. for (uint8_t q = 3; q--;) EEPROM_WRITE(stepper.motor_current_setting[q]);
  571. #else
  572. const uint32_t dummyui32 = 0;
  573. for (uint8_t q = 3; q--;) EEPROM_WRITE(dummyui32);
  574. #endif
  575. #if ENABLED(CNC_COORDINATE_SYSTEMS)
  576. EEPROM_WRITE(coordinate_system); // 27 floats
  577. #else
  578. dummy = 0.0f;
  579. for (uint8_t q = 27; q--;) EEPROM_WRITE(dummy);
  580. #endif
  581. if (!eeprom_error) {
  582. #if ENABLED(EEPROM_CHITCHAT)
  583. const int eeprom_size = eeprom_index;
  584. #endif
  585. const uint16_t final_crc = working_crc;
  586. // Write the EEPROM header
  587. eeprom_index = EEPROM_OFFSET;
  588. EEPROM_WRITE(version);
  589. EEPROM_WRITE(final_crc);
  590. // Report storage size
  591. #if ENABLED(EEPROM_CHITCHAT)
  592. SERIAL_ECHO_START();
  593. SERIAL_ECHOPAIR("Settings Stored (", eeprom_size - (EEPROM_OFFSET));
  594. SERIAL_ECHOPAIR(" bytes; crc ", (uint32_t)final_crc);
  595. SERIAL_ECHOLNPGM(")");
  596. #endif
  597. }
  598. EEPROM_FINISH();
  599. #if ENABLED(UBL_SAVE_ACTIVE_ON_M500)
  600. if (ubl.storage_slot >= 0)
  601. store_mesh(ubl.storage_slot);
  602. #endif
  603. return !eeprom_error;
  604. }
  605. /**
  606. * M501 - Retrieve Configuration
  607. */
  608. bool MarlinSettings::load() {
  609. uint16_t working_crc = 0;
  610. EEPROM_START();
  611. char stored_ver[4];
  612. EEPROM_READ(stored_ver);
  613. uint16_t stored_crc;
  614. EEPROM_READ(stored_crc);
  615. // Version has to match or defaults are used
  616. if (strncmp(version, stored_ver, 3) != 0) {
  617. if (stored_ver[0] != 'V') {
  618. stored_ver[0] = '?';
  619. stored_ver[1] = '\0';
  620. }
  621. #if ENABLED(EEPROM_CHITCHAT)
  622. SERIAL_ECHO_START();
  623. SERIAL_ECHOPGM("EEPROM version mismatch ");
  624. SERIAL_ECHOPAIR("(EEPROM=", stored_ver);
  625. SERIAL_ECHOLNPGM(" Marlin=" EEPROM_VERSION ")");
  626. #endif
  627. reset();
  628. }
  629. else {
  630. float dummy = 0;
  631. bool dummyb;
  632. working_crc = 0; //clear before reading first "real data"
  633. // Number of esteppers may change
  634. uint8_t esteppers;
  635. EEPROM_READ(esteppers);
  636. //
  637. // Planner Motion
  638. //
  639. // Get only the number of E stepper parameters previously stored
  640. // Any steppers added later are set to their defaults
  641. const float def1[] = DEFAULT_AXIS_STEPS_PER_UNIT, def2[] = DEFAULT_MAX_FEEDRATE;
  642. const uint32_t def3[] = DEFAULT_MAX_ACCELERATION;
  643. float tmp1[XYZ + esteppers], tmp2[XYZ + esteppers];
  644. uint32_t tmp3[XYZ + esteppers];
  645. EEPROM_READ(tmp1);
  646. EEPROM_READ(tmp2);
  647. EEPROM_READ(tmp3);
  648. LOOP_XYZE_N(i) {
  649. planner.axis_steps_per_mm[i] = i < XYZ + esteppers ? tmp1[i] : def1[i < COUNT(def1) ? i : COUNT(def1) - 1];
  650. planner.max_feedrate_mm_s[i] = i < XYZ + esteppers ? tmp2[i] : def2[i < COUNT(def2) ? i : COUNT(def2) - 1];
  651. planner.max_acceleration_mm_per_s2[i] = i < XYZ + esteppers ? tmp3[i] : def3[i < COUNT(def3) ? i : COUNT(def3) - 1];
  652. }
  653. EEPROM_READ(planner.acceleration);
  654. EEPROM_READ(planner.retract_acceleration);
  655. EEPROM_READ(planner.travel_acceleration);
  656. EEPROM_READ(planner.min_feedrate_mm_s);
  657. EEPROM_READ(planner.min_travel_feedrate_mm_s);
  658. EEPROM_READ(planner.min_segment_time_us);
  659. EEPROM_READ(planner.max_jerk);
  660. //
  661. // Home Offset (M206)
  662. //
  663. #if !HAS_HOME_OFFSET
  664. float home_offset[XYZ];
  665. #endif
  666. EEPROM_READ(home_offset);
  667. #if ENABLED(DELTA)
  668. home_offset[X_AXIS] = 0.0;
  669. home_offset[Y_AXIS] = 0.0;
  670. home_offset[Z_AXIS] -= DELTA_HEIGHT;
  671. #endif
  672. //
  673. // Hotend Offsets, if any
  674. //
  675. #if HOTENDS > 1
  676. // Skip hotend 0 which must be 0
  677. for (uint8_t e = 1; e < HOTENDS; e++)
  678. LOOP_XYZ(i) EEPROM_READ(hotend_offset[i][e]);
  679. #endif
  680. //
  681. // Global Leveling
  682. //
  683. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  684. EEPROM_READ(new_z_fade_height);
  685. #else
  686. EEPROM_READ(dummy);
  687. #endif
  688. //
  689. // Mesh (Manual) Bed Leveling
  690. //
  691. bool leveling_is_on;
  692. uint8_t mesh_num_x, mesh_num_y;
  693. EEPROM_READ(leveling_is_on);
  694. EEPROM_READ(dummy);
  695. EEPROM_READ(mesh_num_x);
  696. EEPROM_READ(mesh_num_y);
  697. #if ENABLED(MESH_BED_LEVELING)
  698. mbl.has_mesh = leveling_is_on;
  699. mbl.z_offset = dummy;
  700. if (mesh_num_x == GRID_MAX_POINTS_X && mesh_num_y == GRID_MAX_POINTS_Y) {
  701. // EEPROM data fits the current mesh
  702. EEPROM_READ(mbl.z_values);
  703. }
  704. else {
  705. // EEPROM data is stale
  706. mbl.reset();
  707. for (uint16_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_READ(dummy);
  708. }
  709. #else
  710. // MBL is disabled - skip the stored data
  711. for (uint16_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_READ(dummy);
  712. #endif // MESH_BED_LEVELING
  713. #if !HAS_BED_PROBE
  714. float zprobe_zoffset;
  715. #endif
  716. EEPROM_READ(zprobe_zoffset);
  717. //
  718. // Planar Bed Leveling matrix
  719. //
  720. #if ABL_PLANAR
  721. EEPROM_READ(planner.bed_level_matrix);
  722. #else
  723. for (uint8_t q = 9; q--;) EEPROM_READ(dummy);
  724. #endif
  725. //
  726. // Bilinear Auto Bed Leveling
  727. //
  728. uint8_t grid_max_x, grid_max_y;
  729. EEPROM_READ(grid_max_x); // 1 byte
  730. EEPROM_READ(grid_max_y); // 1 byte
  731. #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
  732. if (grid_max_x == GRID_MAX_POINTS_X && grid_max_y == GRID_MAX_POINTS_Y) {
  733. set_bed_leveling_enabled(false);
  734. EEPROM_READ(bilinear_grid_spacing); // 2 ints
  735. EEPROM_READ(bilinear_start); // 2 ints
  736. EEPROM_READ(z_values); // 9 to 256 floats
  737. }
  738. else // EEPROM data is stale
  739. #endif // AUTO_BED_LEVELING_BILINEAR
  740. {
  741. // Skip past disabled (or stale) Bilinear Grid data
  742. int bgs[2], bs[2];
  743. EEPROM_READ(bgs);
  744. EEPROM_READ(bs);
  745. for (uint16_t q = grid_max_x * grid_max_y; q--;) EEPROM_READ(dummy);
  746. }
  747. //
  748. // Unified Bed Leveling active state
  749. //
  750. #if ENABLED(AUTO_BED_LEVELING_UBL)
  751. EEPROM_READ(planner.leveling_active);
  752. EEPROM_READ(ubl.storage_slot);
  753. #else
  754. uint8_t dummyui8;
  755. EEPROM_READ(dummyb);
  756. EEPROM_READ(dummyui8);
  757. #endif // AUTO_BED_LEVELING_UBL
  758. //
  759. // DELTA Geometry or Dual Endstops offsets
  760. //
  761. #if ENABLED(DELTA)
  762. EEPROM_READ(delta_endstop_adj); // 3 floats
  763. EEPROM_READ(delta_radius); // 1 float
  764. EEPROM_READ(delta_diagonal_rod); // 1 float
  765. EEPROM_READ(delta_segments_per_second); // 1 float
  766. EEPROM_READ(delta_calibration_radius); // 1 float
  767. EEPROM_READ(delta_tower_angle_trim); // 3 floats
  768. dummy = 0.0f;
  769. for (uint8_t q=2; q--;) EEPROM_READ(dummy);
  770. #elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS)
  771. #if ENABLED(X_DUAL_ENDSTOPS)
  772. EEPROM_READ(endstops.x_endstop_adj); // 1 float
  773. #else
  774. EEPROM_READ(dummy);
  775. #endif
  776. #if ENABLED(Y_DUAL_ENDSTOPS)
  777. EEPROM_READ(endstops.y_endstop_adj); // 1 float
  778. #else
  779. EEPROM_READ(dummy);
  780. #endif
  781. #if ENABLED(Z_DUAL_ENDSTOPS)
  782. EEPROM_READ(endstops.z_endstop_adj); // 1 float
  783. #else
  784. EEPROM_READ(dummy);
  785. #endif
  786. for (uint8_t q=7; q--;) EEPROM_READ(dummy);
  787. #else
  788. for (uint8_t q=10; q--;) EEPROM_READ(dummy);
  789. #endif
  790. //
  791. // LCD Preheat settings
  792. //
  793. #if DISABLED(ULTIPANEL)
  794. int lcd_preheat_hotend_temp[2], lcd_preheat_bed_temp[2], lcd_preheat_fan_speed[2];
  795. #endif
  796. EEPROM_READ(lcd_preheat_hotend_temp); // 2 floats
  797. EEPROM_READ(lcd_preheat_bed_temp); // 2 floats
  798. EEPROM_READ(lcd_preheat_fan_speed); // 2 floats
  799. //EEPROM_ASSERT(
  800. // WITHIN(lcd_preheat_fan_speed, 0, 255),
  801. // "lcd_preheat_fan_speed out of range"
  802. //);
  803. //
  804. // Hotend PID
  805. //
  806. #if ENABLED(PIDTEMP)
  807. for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
  808. EEPROM_READ(dummy); // Kp
  809. if (e < HOTENDS && dummy != DUMMY_PID_VALUE) {
  810. // do not need to scale PID values as the values in EEPROM are already scaled
  811. PID_PARAM(Kp, e) = dummy;
  812. EEPROM_READ(PID_PARAM(Ki, e));
  813. EEPROM_READ(PID_PARAM(Kd, e));
  814. #if ENABLED(PID_EXTRUSION_SCALING)
  815. EEPROM_READ(PID_PARAM(Kc, e));
  816. #else
  817. EEPROM_READ(dummy);
  818. #endif
  819. }
  820. else {
  821. for (uint8_t q=3; q--;) EEPROM_READ(dummy); // Ki, Kd, Kc
  822. }
  823. }
  824. #else // !PIDTEMP
  825. // 4 x 4 = 16 slots for PID parameters
  826. for (uint8_t q = MAX_EXTRUDERS * 4; q--;) EEPROM_READ(dummy); // Kp, Ki, Kd, Kc
  827. #endif // !PIDTEMP
  828. //
  829. // PID Extrusion Scaling
  830. //
  831. #if DISABLED(PID_EXTRUSION_SCALING)
  832. int lpq_len;
  833. #endif
  834. EEPROM_READ(lpq_len);
  835. //
  836. // Heated Bed PID
  837. //
  838. #if ENABLED(PIDTEMPBED)
  839. EEPROM_READ(dummy); // bedKp
  840. if (dummy != DUMMY_PID_VALUE) {
  841. thermalManager.bedKp = dummy;
  842. EEPROM_READ(thermalManager.bedKi);
  843. EEPROM_READ(thermalManager.bedKd);
  844. }
  845. #else
  846. for (uint8_t q=3; q--;) EEPROM_READ(dummy); // bedKp, bedKi, bedKd
  847. #endif
  848. //
  849. // LCD Contrast
  850. //
  851. #if !HAS_LCD_CONTRAST
  852. uint16_t lcd_contrast;
  853. #endif
  854. EEPROM_READ(lcd_contrast);
  855. //
  856. // Firmware Retraction
  857. //
  858. #if ENABLED(FWRETRACT)
  859. EEPROM_READ(fwretract.autoretract_enabled);
  860. EEPROM_READ(fwretract.retract_length);
  861. EEPROM_READ(fwretract.retract_feedrate_mm_s);
  862. EEPROM_READ(fwretract.retract_zlift);
  863. EEPROM_READ(fwretract.retract_recover_length);
  864. EEPROM_READ(fwretract.retract_recover_feedrate_mm_s);
  865. EEPROM_READ(fwretract.swap_retract_length);
  866. EEPROM_READ(fwretract.swap_retract_recover_length);
  867. EEPROM_READ(fwretract.swap_retract_recover_feedrate_mm_s);
  868. #else
  869. EEPROM_READ(dummyb);
  870. for (uint8_t q=8; q--;) EEPROM_READ(dummy);
  871. #endif
  872. //
  873. // Volumetric & Filament Size
  874. //
  875. EEPROM_READ(parser.volumetric_enabled);
  876. for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
  877. EEPROM_READ(dummy);
  878. if (q < COUNT(planner.filament_size)) planner.filament_size[q] = dummy;
  879. }
  880. //
  881. // TMC2130 Stepper Current
  882. //
  883. uint16_t val;
  884. #if ENABLED(HAVE_TMC2130)
  885. EEPROM_READ(val);
  886. #if ENABLED(X_IS_TMC2130)
  887. stepperX.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  888. #endif
  889. EEPROM_READ(val);
  890. #if ENABLED(Y_IS_TMC2130)
  891. stepperY.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  892. #endif
  893. EEPROM_READ(val);
  894. #if ENABLED(Z_IS_TMC2130)
  895. stepperZ.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  896. #endif
  897. EEPROM_READ(val);
  898. #if ENABLED(X2_IS_TMC2130)
  899. stepperX2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  900. #endif
  901. EEPROM_READ(val);
  902. #if ENABLED(Y2_IS_TMC2130)
  903. stepperY2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  904. #endif
  905. EEPROM_READ(val);
  906. #if ENABLED(Z2_IS_TMC2130)
  907. stepperZ2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  908. #endif
  909. EEPROM_READ(val);
  910. #if ENABLED(E0_IS_TMC2130)
  911. stepperE0.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  912. #endif
  913. EEPROM_READ(val);
  914. #if ENABLED(E1_IS_TMC2130)
  915. stepperE1.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  916. #endif
  917. EEPROM_READ(val);
  918. #if ENABLED(E2_IS_TMC2130)
  919. stepperE2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  920. #endif
  921. EEPROM_READ(val);
  922. #if ENABLED(E3_IS_TMC2130)
  923. stepperE3.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  924. #endif
  925. EEPROM_READ(val);
  926. #if ENABLED(E4_IS_TMC2130)
  927. stepperE4.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
  928. #endif
  929. #else
  930. for (uint8_t q = 0; q < 11; q++) EEPROM_READ(val);
  931. #endif
  932. //
  933. // Linear Advance
  934. //
  935. #if ENABLED(LIN_ADVANCE)
  936. EEPROM_READ(planner.extruder_advance_k);
  937. EEPROM_READ(planner.advance_ed_ratio);
  938. #else
  939. EEPROM_READ(dummy);
  940. EEPROM_READ(dummy);
  941. #endif
  942. //
  943. // Motor Current PWM
  944. //
  945. #if HAS_MOTOR_CURRENT_PWM
  946. for (uint8_t q = 3; q--;) EEPROM_READ(stepper.motor_current_setting[q]);
  947. #else
  948. uint32_t dummyui32;
  949. for (uint8_t q = 3; q--;) EEPROM_READ(dummyui32);
  950. #endif
  951. //
  952. // CNC Coordinate System
  953. //
  954. #if ENABLED(CNC_COORDINATE_SYSTEMS)
  955. position_changed = gcode.select_coordinate_system(-1); // Go back to machine space
  956. EEPROM_READ(gcode.coordinate_system); // 27 floats
  957. #else
  958. for (uint8_t q = 27; q--;) EEPROM_READ(dummy);
  959. #endif
  960. if (working_crc == stored_crc) {
  961. postprocess();
  962. #if ENABLED(EEPROM_CHITCHAT)
  963. SERIAL_ECHO_START();
  964. SERIAL_ECHO(version);
  965. SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index - (EEPROM_OFFSET));
  966. SERIAL_ECHOPAIR(" bytes; crc ", (uint32_t)working_crc);
  967. SERIAL_ECHOLNPGM(")");
  968. #endif
  969. }
  970. else {
  971. #if ENABLED(EEPROM_CHITCHAT)
  972. SERIAL_ERROR_START();
  973. SERIAL_ERRORPGM("EEPROM CRC mismatch - (stored) ");
  974. SERIAL_ERROR(stored_crc);
  975. SERIAL_ERRORPGM(" != ");
  976. SERIAL_ERROR(working_crc);
  977. SERIAL_ERRORLNPGM(" (calculated)!");
  978. #endif
  979. reset();
  980. }
  981. #if ENABLED(AUTO_BED_LEVELING_UBL)
  982. meshes_begin = (eeprom_index + 32) & 0xFFF8; // Pad the end of configuration data so it
  983. // can float up or down a little bit without
  984. // disrupting the mesh data
  985. ubl.report_state();
  986. if (!ubl.sanity_check()) {
  987. SERIAL_EOL();
  988. #if ENABLED(EEPROM_CHITCHAT)
  989. ubl.echo_name();
  990. SERIAL_ECHOLNPGM(" initialized.\n");
  991. #endif
  992. }
  993. else {
  994. #if ENABLED(EEPROM_CHITCHAT)
  995. SERIAL_PROTOCOLPGM("?Can't enable ");
  996. ubl.echo_name();
  997. SERIAL_PROTOCOLLNPGM(".");
  998. #endif
  999. ubl.reset();
  1000. }
  1001. if (ubl.storage_slot >= 0) {
  1002. load_mesh(ubl.storage_slot);
  1003. #if ENABLED(EEPROM_CHITCHAT)
  1004. SERIAL_ECHOPAIR("Mesh ", ubl.storage_slot);
  1005. SERIAL_ECHOLNPGM(" loaded from storage.");
  1006. #endif
  1007. }
  1008. else {
  1009. ubl.reset();
  1010. #if ENABLED(EEPROM_CHITCHAT)
  1011. SERIAL_ECHOLNPGM("UBL System reset()");
  1012. #endif
  1013. }
  1014. #endif
  1015. }
  1016. #if ENABLED(EEPROM_CHITCHAT) && DISABLED(DISABLE_M503)
  1017. report();
  1018. #endif
  1019. EEPROM_FINISH();
  1020. return !eeprom_error;
  1021. }
  1022. #if ENABLED(AUTO_BED_LEVELING_UBL)
  1023. #if ENABLED(EEPROM_CHITCHAT)
  1024. void ubl_invalid_slot(const int s) {
  1025. SERIAL_PROTOCOLLNPGM("?Invalid slot.");
  1026. SERIAL_PROTOCOL(s);
  1027. SERIAL_PROTOCOLLNPGM(" mesh slots available.");
  1028. }
  1029. #endif
  1030. int MarlinSettings::calc_num_meshes() {
  1031. //obviously this will get more sophisticated once we've added an actual MAT
  1032. if (meshes_begin <= 0) return 0;
  1033. return (meshes_end - meshes_begin) / sizeof(ubl.z_values);
  1034. }
  1035. void MarlinSettings::store_mesh(int8_t slot) {
  1036. #if ENABLED(AUTO_BED_LEVELING_UBL)
  1037. const int a = calc_num_meshes();
  1038. if (!WITHIN(slot, 0, a - 1)) {
  1039. #if ENABLED(EEPROM_CHITCHAT)
  1040. ubl_invalid_slot(a);
  1041. SERIAL_PROTOCOLPAIR("E2END=", E2END);
  1042. SERIAL_PROTOCOLPAIR(" meshes_end=", meshes_end);
  1043. SERIAL_PROTOCOLLNPAIR(" slot=", slot);
  1044. SERIAL_EOL();
  1045. #endif
  1046. return;
  1047. }
  1048. uint16_t crc = 0;
  1049. bool status;
  1050. int pos = meshes_end - (slot + 1) * sizeof(ubl.z_values);
  1051. HAL::PersistentStore::access_start();
  1052. status = HAL::PersistentStore::write_data(pos, (uint8_t *)&ubl.z_values, sizeof(ubl.z_values), &crc);
  1053. HAL::PersistentStore::access_finish();
  1054. if (status)
  1055. SERIAL_PROTOCOL("?Unable to save mesh data.\n");
  1056. // Write crc to MAT along with other data, or just tack on to the beginning or end
  1057. #if ENABLED(EEPROM_CHITCHAT)
  1058. if (!status)
  1059. SERIAL_PROTOCOLLNPAIR("Mesh saved in slot ", slot);
  1060. #endif
  1061. #else
  1062. // Other mesh types
  1063. #endif
  1064. }
  1065. void MarlinSettings::load_mesh(int8_t slot, void *into /* = 0 */) {
  1066. #if ENABLED(AUTO_BED_LEVELING_UBL)
  1067. const int16_t a = settings.calc_num_meshes();
  1068. if (!WITHIN(slot, 0, a - 1)) {
  1069. #if ENABLED(EEPROM_CHITCHAT)
  1070. ubl_invalid_slot(a);
  1071. #endif
  1072. return;
  1073. }
  1074. uint16_t crc = 0;
  1075. int pos = meshes_end - (slot + 1) * sizeof(ubl.z_values);
  1076. uint8_t * const dest = into ? (uint8_t*)into : (uint8_t*)&ubl.z_values;
  1077. uint16_t status;
  1078. HAL::PersistentStore::access_start();
  1079. status = HAL::PersistentStore::read_data(pos, dest, sizeof(ubl.z_values), &crc);
  1080. HAL::PersistentStore::access_finish();
  1081. if (status)
  1082. SERIAL_PROTOCOL("?Unable to load mesh data.\n");
  1083. #if ENABLED(EEPROM_CHITCHAT)
  1084. else
  1085. SERIAL_PROTOCOLLNPAIR("Mesh loaded from slot ", slot);
  1086. #endif
  1087. EEPROM_FINISH();
  1088. #else
  1089. // Other mesh types
  1090. #endif
  1091. }
  1092. //void MarlinSettings::delete_mesh() { return; }
  1093. //void MarlinSettings::defrag_meshes() { return; }
  1094. #endif // AUTO_BED_LEVELING_UBL
  1095. #else // !EEPROM_SETTINGS
  1096. bool MarlinSettings::save() {
  1097. SERIAL_ERROR_START();
  1098. SERIAL_ERRORLNPGM("EEPROM disabled");
  1099. return false;
  1100. }
  1101. #endif // !EEPROM_SETTINGS
  1102. /**
  1103. * M502 - Reset Configuration
  1104. */
  1105. void MarlinSettings::reset() {
  1106. static const float tmp1[] PROGMEM = DEFAULT_AXIS_STEPS_PER_UNIT, tmp2[] PROGMEM = DEFAULT_MAX_FEEDRATE;
  1107. static const uint32_t tmp3[] PROGMEM = DEFAULT_MAX_ACCELERATION;
  1108. LOOP_XYZE_N(i) {
  1109. planner.axis_steps_per_mm[i] = pgm_read_float(&tmp1[i < COUNT(tmp1) ? i : COUNT(tmp1) - 1]);
  1110. planner.max_feedrate_mm_s[i] = pgm_read_float(&tmp2[i < COUNT(tmp2) ? i : COUNT(tmp2) - 1]);
  1111. planner.max_acceleration_mm_per_s2[i] = pgm_read_dword_near(&tmp3[i < COUNT(tmp3) ? i : COUNT(tmp3) - 1]);
  1112. }
  1113. planner.acceleration = DEFAULT_ACCELERATION;
  1114. planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
  1115. planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
  1116. planner.min_feedrate_mm_s = DEFAULT_MINIMUMFEEDRATE;
  1117. planner.min_segment_time_us = DEFAULT_MINSEGMENTTIME;
  1118. planner.min_travel_feedrate_mm_s = DEFAULT_MINTRAVELFEEDRATE;
  1119. planner.max_jerk[X_AXIS] = DEFAULT_XJERK;
  1120. planner.max_jerk[Y_AXIS] = DEFAULT_YJERK;
  1121. planner.max_jerk[Z_AXIS] = DEFAULT_ZJERK;
  1122. planner.max_jerk[E_AXIS] = DEFAULT_EJERK;
  1123. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  1124. new_z_fade_height = 0.0;
  1125. #endif
  1126. #if HAS_HOME_OFFSET
  1127. ZERO(home_offset);
  1128. #endif
  1129. #if HOTENDS > 1
  1130. constexpr float tmp4[XYZ][HOTENDS] = {
  1131. HOTEND_OFFSET_X,
  1132. HOTEND_OFFSET_Y
  1133. #ifdef HOTEND_OFFSET_Z
  1134. , HOTEND_OFFSET_Z
  1135. #else
  1136. , { 0 }
  1137. #endif
  1138. };
  1139. static_assert(
  1140. tmp4[X_AXIS][0] == 0 && tmp4[Y_AXIS][0] == 0 && tmp4[Z_AXIS][0] == 0,
  1141. "Offsets for the first hotend must be 0.0."
  1142. );
  1143. LOOP_XYZ(i) HOTEND_LOOP() hotend_offset[i][e] = tmp4[i][e];
  1144. #endif
  1145. // Applies to all MBL and ABL
  1146. #if HAS_LEVELING
  1147. reset_bed_level();
  1148. #endif
  1149. #if HAS_BED_PROBE
  1150. zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER;
  1151. #endif
  1152. #if ENABLED(DELTA)
  1153. const float adj[ABC] = DELTA_ENDSTOP_ADJ,
  1154. dta[ABC] = DELTA_TOWER_ANGLE_TRIM;
  1155. COPY(delta_endstop_adj, adj);
  1156. delta_radius = DELTA_RADIUS;
  1157. delta_diagonal_rod = DELTA_DIAGONAL_ROD;
  1158. delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;
  1159. delta_calibration_radius = DELTA_CALIBRATION_RADIUS;
  1160. COPY(delta_tower_angle_trim, dta);
  1161. home_offset[Z_AXIS] = 0;
  1162. #elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS)
  1163. #if ENABLED(X_DUAL_ENDSTOPS)
  1164. endstops.x_endstop_adj = (
  1165. #ifdef X_DUAL_ENDSTOPS_ADJUSTMENT
  1166. X_DUAL_ENDSTOPS_ADJUSTMENT
  1167. #else
  1168. 0
  1169. #endif
  1170. );
  1171. #endif
  1172. #if ENABLED(Y_DUAL_ENDSTOPS)
  1173. endstops.y_endstop_adj = (
  1174. #ifdef Y_DUAL_ENDSTOPS_ADJUSTMENT
  1175. Y_DUAL_ENDSTOPS_ADJUSTMENT
  1176. #else
  1177. 0
  1178. #endif
  1179. );
  1180. #endif
  1181. #if ENABLED(Z_DUAL_ENDSTOPS)
  1182. endstops.z_endstop_adj = (
  1183. #ifdef Z_DUAL_ENDSTOPS_ADJUSTMENT
  1184. Z_DUAL_ENDSTOPS_ADJUSTMENT
  1185. #else
  1186. 0
  1187. #endif
  1188. );
  1189. #endif
  1190. #endif
  1191. #if ENABLED(ULTIPANEL)
  1192. lcd_preheat_hotend_temp[0] = PREHEAT_1_TEMP_HOTEND;
  1193. lcd_preheat_hotend_temp[1] = PREHEAT_2_TEMP_HOTEND;
  1194. lcd_preheat_bed_temp[0] = PREHEAT_1_TEMP_BED;
  1195. lcd_preheat_bed_temp[1] = PREHEAT_2_TEMP_BED;
  1196. lcd_preheat_fan_speed[0] = PREHEAT_1_FAN_SPEED;
  1197. lcd_preheat_fan_speed[1] = PREHEAT_2_FAN_SPEED;
  1198. #endif
  1199. #if HAS_LCD_CONTRAST
  1200. lcd_contrast = DEFAULT_LCD_CONTRAST;
  1201. #endif
  1202. #if ENABLED(PIDTEMP)
  1203. #if ENABLED(PID_PARAMS_PER_HOTEND) && HOTENDS > 1
  1204. HOTEND_LOOP()
  1205. #endif
  1206. {
  1207. PID_PARAM(Kp, e) = DEFAULT_Kp;
  1208. PID_PARAM(Ki, e) = scalePID_i(DEFAULT_Ki);
  1209. PID_PARAM(Kd, e) = scalePID_d(DEFAULT_Kd);
  1210. #if ENABLED(PID_EXTRUSION_SCALING)
  1211. PID_PARAM(Kc, e) = DEFAULT_Kc;
  1212. #endif
  1213. }
  1214. #if ENABLED(PID_EXTRUSION_SCALING)
  1215. lpq_len = 20; // default last-position-queue size
  1216. #endif
  1217. #endif // PIDTEMP
  1218. #if ENABLED(PIDTEMPBED)
  1219. thermalManager.bedKp = DEFAULT_bedKp;
  1220. thermalManager.bedKi = scalePID_i(DEFAULT_bedKi);
  1221. thermalManager.bedKd = scalePID_d(DEFAULT_bedKd);
  1222. #endif
  1223. #if ENABLED(FWRETRACT)
  1224. fwretract.reset();
  1225. #endif
  1226. parser.volumetric_enabled =
  1227. #if ENABLED(VOLUMETRIC_DEFAULT_ON)
  1228. true
  1229. #else
  1230. false
  1231. #endif
  1232. ;
  1233. for (uint8_t q = 0; q < COUNT(planner.filament_size); q++)
  1234. planner.filament_size[q] = DEFAULT_NOMINAL_FILAMENT_DIA;
  1235. endstops.enable_globally(
  1236. #if ENABLED(ENDSTOPS_ALWAYS_ON_DEFAULT)
  1237. true
  1238. #else
  1239. false
  1240. #endif
  1241. );
  1242. #if ENABLED(HAVE_TMC2130)
  1243. #if ENABLED(X_IS_TMC2130)
  1244. stepperX.setCurrent(X_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1245. #endif
  1246. #if ENABLED(Y_IS_TMC2130)
  1247. stepperY.setCurrent(Y_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1248. #endif
  1249. #if ENABLED(Z_IS_TMC2130)
  1250. stepperZ.setCurrent(Z_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1251. #endif
  1252. #if ENABLED(X2_IS_TMC2130)
  1253. stepperX2.setCurrent(X2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1254. #endif
  1255. #if ENABLED(Y2_IS_TMC2130)
  1256. stepperY2.setCurrent(Y2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1257. #endif
  1258. #if ENABLED(Z2_IS_TMC2130)
  1259. stepperZ2.setCurrent(Z2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1260. #endif
  1261. #if ENABLED(E0_IS_TMC2130)
  1262. stepperE0.setCurrent(E0_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1263. #endif
  1264. #if ENABLED(E1_IS_TMC2130)
  1265. stepperE1.setCurrent(E1_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1266. #endif
  1267. #if ENABLED(E2_IS_TMC2130)
  1268. stepperE2.setCurrent(E2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1269. #endif
  1270. #if ENABLED(E3_IS_TMC2130)
  1271. stepperE3.setCurrent(E3_CURRENT, R_SENSE, HOLD_MULTIPLIER);
  1272. #endif
  1273. #endif
  1274. #if ENABLED(LIN_ADVANCE)
  1275. planner.extruder_advance_k = LIN_ADVANCE_K;
  1276. planner.advance_ed_ratio = LIN_ADVANCE_E_D_RATIO;
  1277. #endif
  1278. #if HAS_MOTOR_CURRENT_PWM
  1279. uint32_t tmp_motor_current_setting[3] = PWM_MOTOR_CURRENT;
  1280. for (uint8_t q = 3; q--;)
  1281. stepper.digipot_current(q, (stepper.motor_current_setting[q] = tmp_motor_current_setting[q]));
  1282. #endif
  1283. #if ENABLED(AUTO_BED_LEVELING_UBL)
  1284. ubl.reset();
  1285. #endif
  1286. postprocess();
  1287. #if ENABLED(EEPROM_CHITCHAT)
  1288. SERIAL_ECHO_START();
  1289. SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
  1290. #endif
  1291. }
  1292. #if DISABLED(DISABLE_M503)
  1293. #define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START(); }while(0)
  1294. /**
  1295. * M503 - Report current settings in RAM
  1296. *
  1297. * Unless specifically disabled, M503 is available even without EEPROM
  1298. */
  1299. void MarlinSettings::report(bool forReplay) {
  1300. /**
  1301. * Announce current units, in case inches are being displayed
  1302. */
  1303. CONFIG_ECHO_START;
  1304. #if ENABLED(INCH_MODE_SUPPORT)
  1305. #define LINEAR_UNIT(N) ((N) / parser.linear_unit_factor)
  1306. #define VOLUMETRIC_UNIT(N) ((N) / (parser.volumetric_enabled ? parser.volumetric_unit_factor : parser.linear_unit_factor))
  1307. SERIAL_ECHOPGM(" G2");
  1308. SERIAL_CHAR(parser.linear_unit_factor == 1.0 ? '1' : '0');
  1309. SERIAL_ECHOPGM(" ; Units in ");
  1310. serialprintPGM(parser.linear_unit_factor == 1.0 ? PSTR("mm\n") : PSTR("inches\n"));
  1311. #else
  1312. #define LINEAR_UNIT(N) N
  1313. #define VOLUMETRIC_UNIT(N) N
  1314. SERIAL_ECHOLNPGM(" G21 ; Units in mm");
  1315. #endif
  1316. #if ENABLED(ULTIPANEL)
  1317. // Temperature units - for Ultipanel temperature options
  1318. CONFIG_ECHO_START;
  1319. #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
  1320. #define TEMP_UNIT(N) parser.to_temp_units(N)
  1321. SERIAL_ECHOPGM(" M149 ");
  1322. SERIAL_CHAR(parser.temp_units_code());
  1323. SERIAL_ECHOPGM(" ; Units in ");
  1324. serialprintPGM(parser.temp_units_name());
  1325. #else
  1326. #define TEMP_UNIT(N) N
  1327. SERIAL_ECHOLNPGM(" M149 C ; Units in Celsius");
  1328. #endif
  1329. #endif
  1330. SERIAL_EOL();
  1331. /**
  1332. * Volumetric extrusion M200
  1333. */
  1334. if (!forReplay) {
  1335. CONFIG_ECHO_START;
  1336. SERIAL_ECHOPGM("Filament settings:");
  1337. if (parser.volumetric_enabled)
  1338. SERIAL_EOL();
  1339. else
  1340. SERIAL_ECHOLNPGM(" Disabled");
  1341. }
  1342. CONFIG_ECHO_START;
  1343. SERIAL_ECHOPAIR(" M200 D", planner.filament_size[0]);
  1344. SERIAL_EOL();
  1345. #if EXTRUDERS > 1
  1346. CONFIG_ECHO_START;
  1347. SERIAL_ECHOPAIR(" M200 T1 D", planner.filament_size[1]);
  1348. SERIAL_EOL();
  1349. #if EXTRUDERS > 2
  1350. CONFIG_ECHO_START;
  1351. SERIAL_ECHOPAIR(" M200 T2 D", planner.filament_size[2]);
  1352. SERIAL_EOL();
  1353. #if EXTRUDERS > 3
  1354. CONFIG_ECHO_START;
  1355. SERIAL_ECHOPAIR(" M200 T3 D", planner.filament_size[3]);
  1356. SERIAL_EOL();
  1357. #if EXTRUDERS > 4
  1358. CONFIG_ECHO_START;
  1359. SERIAL_ECHOPAIR(" M200 T4 D", planner.filament_size[4]);
  1360. SERIAL_EOL();
  1361. #endif // EXTRUDERS > 4
  1362. #endif // EXTRUDERS > 3
  1363. #endif // EXTRUDERS > 2
  1364. #endif // EXTRUDERS > 1
  1365. if (!parser.volumetric_enabled) {
  1366. CONFIG_ECHO_START;
  1367. SERIAL_ECHOLNPGM(" M200 D0");
  1368. }
  1369. if (!forReplay) {
  1370. CONFIG_ECHO_START;
  1371. SERIAL_ECHOLNPGM("Steps per unit:");
  1372. }
  1373. CONFIG_ECHO_START;
  1374. SERIAL_ECHOPAIR(" M92 X", LINEAR_UNIT(planner.axis_steps_per_mm[X_AXIS]));
  1375. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.axis_steps_per_mm[Y_AXIS]));
  1376. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.axis_steps_per_mm[Z_AXIS]));
  1377. #if DISABLED(DISTINCT_E_FACTORS)
  1378. SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS]));
  1379. #endif
  1380. SERIAL_EOL();
  1381. #if ENABLED(DISTINCT_E_FACTORS)
  1382. CONFIG_ECHO_START;
  1383. for (uint8_t i = 0; i < E_STEPPERS; i++) {
  1384. SERIAL_ECHOPAIR(" M92 T", (int)i);
  1385. SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS + i]));
  1386. }
  1387. #endif
  1388. if (!forReplay) {
  1389. CONFIG_ECHO_START;
  1390. SERIAL_ECHOLNPGM("Maximum feedrates (units/s):");
  1391. }
  1392. CONFIG_ECHO_START;
  1393. SERIAL_ECHOPAIR(" M203 X", LINEAR_UNIT(planner.max_feedrate_mm_s[X_AXIS]));
  1394. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_feedrate_mm_s[Y_AXIS]));
  1395. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_feedrate_mm_s[Z_AXIS]));
  1396. #if DISABLED(DISTINCT_E_FACTORS)
  1397. SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS]));
  1398. #endif
  1399. SERIAL_EOL();
  1400. #if ENABLED(DISTINCT_E_FACTORS)
  1401. CONFIG_ECHO_START;
  1402. for (uint8_t i = 0; i < E_STEPPERS; i++) {
  1403. SERIAL_ECHOPAIR(" M203 T", (int)i);
  1404. SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS + i]));
  1405. }
  1406. #endif
  1407. if (!forReplay) {
  1408. CONFIG_ECHO_START;
  1409. SERIAL_ECHOLNPGM("Maximum Acceleration (units/s2):");
  1410. }
  1411. CONFIG_ECHO_START;
  1412. SERIAL_ECHOPAIR(" M201 X", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[X_AXIS]));
  1413. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[Y_AXIS]));
  1414. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[Z_AXIS]));
  1415. #if DISABLED(DISTINCT_E_FACTORS)
  1416. SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS]));
  1417. #endif
  1418. SERIAL_EOL();
  1419. #if ENABLED(DISTINCT_E_FACTORS)
  1420. CONFIG_ECHO_START;
  1421. for (uint8_t i = 0; i < E_STEPPERS; i++) {
  1422. SERIAL_ECHOPAIR(" M201 T", (int)i);
  1423. SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS + i]));
  1424. }
  1425. #endif
  1426. if (!forReplay) {
  1427. CONFIG_ECHO_START;
  1428. SERIAL_ECHOLNPGM("Acceleration (units/s2): P<print_accel> R<retract_accel> T<travel_accel>");
  1429. }
  1430. CONFIG_ECHO_START;
  1431. SERIAL_ECHOPAIR(" M204 P", LINEAR_UNIT(planner.acceleration));
  1432. SERIAL_ECHOPAIR(" R", LINEAR_UNIT(planner.retract_acceleration));
  1433. SERIAL_ECHOLNPAIR(" T", LINEAR_UNIT(planner.travel_acceleration));
  1434. if (!forReplay) {
  1435. CONFIG_ECHO_START;
  1436. SERIAL_ECHOLNPGM("Advanced: S<min_feedrate> T<min_travel_feedrate> B<min_segment_time_us> X<max_xy_jerk> Z<max_z_jerk> E<max_e_jerk>");
  1437. }
  1438. CONFIG_ECHO_START;
  1439. SERIAL_ECHOPAIR(" M205 S", LINEAR_UNIT(planner.min_feedrate_mm_s));
  1440. SERIAL_ECHOPAIR(" T", LINEAR_UNIT(planner.min_travel_feedrate_mm_s));
  1441. SERIAL_ECHOPAIR(" B", planner.min_segment_time_us);
  1442. SERIAL_ECHOPAIR(" X", LINEAR_UNIT(planner.max_jerk[X_AXIS]));
  1443. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_jerk[Y_AXIS]));
  1444. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_jerk[Z_AXIS]));
  1445. SERIAL_ECHOLNPAIR(" E", LINEAR_UNIT(planner.max_jerk[E_AXIS]));
  1446. #if HAS_M206_COMMAND
  1447. if (!forReplay) {
  1448. CONFIG_ECHO_START;
  1449. SERIAL_ECHOLNPGM("Home offset:");
  1450. }
  1451. CONFIG_ECHO_START;
  1452. SERIAL_ECHOPAIR(" M206 X", LINEAR_UNIT(home_offset[X_AXIS]));
  1453. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(home_offset[Y_AXIS]));
  1454. SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(home_offset[Z_AXIS]));
  1455. #endif
  1456. #if HOTENDS > 1
  1457. if (!forReplay) {
  1458. CONFIG_ECHO_START;
  1459. SERIAL_ECHOLNPGM("Hotend offsets:");
  1460. }
  1461. CONFIG_ECHO_START;
  1462. for (uint8_t e = 1; e < HOTENDS; e++) {
  1463. SERIAL_ECHOPAIR(" M218 T", (int)e);
  1464. SERIAL_ECHOPAIR(" X", LINEAR_UNIT(hotend_offset[X_AXIS][e]));
  1465. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(hotend_offset[Y_AXIS][e]));
  1466. #if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_NOZZLE) ||ENABLED(PARKING_EXTRUDER)
  1467. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(hotend_offset[Z_AXIS][e]));
  1468. #endif
  1469. SERIAL_EOL();
  1470. }
  1471. #endif
  1472. #if ENABLED(MESH_BED_LEVELING)
  1473. if (!forReplay) {
  1474. CONFIG_ECHO_START;
  1475. SERIAL_ECHOLNPGM("Mesh Bed Leveling:");
  1476. }
  1477. CONFIG_ECHO_START;
  1478. SERIAL_ECHOPAIR(" M420 S", leveling_is_valid() ? 1 : 0);
  1479. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  1480. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
  1481. #endif
  1482. SERIAL_EOL();
  1483. for (uint8_t py = 0; py < GRID_MAX_POINTS_Y; py++) {
  1484. for (uint8_t px = 0; px < GRID_MAX_POINTS_X; px++) {
  1485. CONFIG_ECHO_START;
  1486. SERIAL_ECHOPAIR(" G29 S3 X", (int)px + 1);
  1487. SERIAL_ECHOPAIR(" Y", (int)py + 1);
  1488. SERIAL_ECHOPGM(" Z");
  1489. SERIAL_PROTOCOL_F(LINEAR_UNIT(mbl.z_values[px][py]), 5);
  1490. SERIAL_EOL();
  1491. }
  1492. }
  1493. #elif ENABLED(AUTO_BED_LEVELING_UBL)
  1494. if (!forReplay) {
  1495. CONFIG_ECHO_START;
  1496. ubl.echo_name();
  1497. SERIAL_ECHOLNPGM(":");
  1498. }
  1499. CONFIG_ECHO_START;
  1500. SERIAL_ECHOPAIR(" M420 S", planner.leveling_active ? 1 : 0);
  1501. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  1502. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
  1503. #endif
  1504. SERIAL_EOL();
  1505. if (!forReplay) {
  1506. SERIAL_EOL();
  1507. ubl.report_state();
  1508. SERIAL_ECHOLNPAIR("\nActive Mesh Slot: ", ubl.storage_slot);
  1509. SERIAL_ECHOPAIR("EEPROM can hold ", calc_num_meshes());
  1510. SERIAL_ECHOLNPGM(" meshes.\n");
  1511. }
  1512. #elif HAS_ABL
  1513. if (!forReplay) {
  1514. CONFIG_ECHO_START;
  1515. SERIAL_ECHOLNPGM("Auto Bed Leveling:");
  1516. }
  1517. CONFIG_ECHO_START;
  1518. SERIAL_ECHOPAIR(" M420 S", planner.leveling_active ? 1 : 0);
  1519. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  1520. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
  1521. #endif
  1522. SERIAL_EOL();
  1523. #endif
  1524. #if ENABLED(DELTA)
  1525. if (!forReplay) {
  1526. CONFIG_ECHO_START;
  1527. SERIAL_ECHOLNPGM("Endstop adjustment:");
  1528. }
  1529. CONFIG_ECHO_START;
  1530. SERIAL_ECHOPAIR(" M666 X", LINEAR_UNIT(delta_endstop_adj[X_AXIS]));
  1531. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(delta_endstop_adj[Y_AXIS]));
  1532. SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(delta_endstop_adj[Z_AXIS]));
  1533. if (!forReplay) {
  1534. CONFIG_ECHO_START;
  1535. SERIAL_ECHOLNPGM("Delta settings: L<diagonal_rod> R<radius> H<height> S<segments_per_s> B<calibration radius> XYZ<tower angle corrections>");
  1536. }
  1537. CONFIG_ECHO_START;
  1538. SERIAL_ECHOPAIR(" M665 L", LINEAR_UNIT(delta_diagonal_rod));
  1539. SERIAL_ECHOPAIR(" R", LINEAR_UNIT(delta_radius));
  1540. SERIAL_ECHOPAIR(" H", LINEAR_UNIT(DELTA_HEIGHT + home_offset[Z_AXIS]));
  1541. SERIAL_ECHOPAIR(" S", delta_segments_per_second);
  1542. SERIAL_ECHOPAIR(" B", LINEAR_UNIT(delta_calibration_radius));
  1543. SERIAL_ECHOPAIR(" X", LINEAR_UNIT(delta_tower_angle_trim[A_AXIS]));
  1544. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(delta_tower_angle_trim[B_AXIS]));
  1545. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(delta_tower_angle_trim[C_AXIS]));
  1546. SERIAL_EOL();
  1547. #elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS)
  1548. if (!forReplay) {
  1549. CONFIG_ECHO_START;
  1550. SERIAL_ECHOLNPGM("Endstop adjustment:");
  1551. }
  1552. CONFIG_ECHO_START;
  1553. SERIAL_ECHOPGM(" M666");
  1554. #if ENABLED(X_DUAL_ENDSTOPS)
  1555. SERIAL_ECHOPAIR(" X", LINEAR_UNIT(endstops.x_endstop_adj));
  1556. #endif
  1557. #if ENABLED(Y_DUAL_ENDSTOPS)
  1558. SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(endstops.y_endstop_adj));
  1559. #endif
  1560. #if ENABLED(Z_DUAL_ENDSTOPS)
  1561. SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(endstops.z_endstop_adj));
  1562. #endif
  1563. SERIAL_EOL();
  1564. #endif // DELTA
  1565. #if ENABLED(ULTIPANEL)
  1566. if (!forReplay) {
  1567. CONFIG_ECHO_START;
  1568. SERIAL_ECHOLNPGM("Material heatup parameters:");
  1569. }
  1570. CONFIG_ECHO_START;
  1571. for (uint8_t i = 0; i < COUNT(lcd_preheat_hotend_temp); i++) {
  1572. SERIAL_ECHOPAIR(" M145 S", (int)i);
  1573. SERIAL_ECHOPAIR(" H", TEMP_UNIT(lcd_preheat_hotend_temp[i]));
  1574. SERIAL_ECHOPAIR(" B", TEMP_UNIT(lcd_preheat_bed_temp[i]));
  1575. SERIAL_ECHOLNPAIR(" F", lcd_preheat_fan_speed[i]);
  1576. }
  1577. #endif // ULTIPANEL
  1578. #if HAS_PID_HEATING
  1579. if (!forReplay) {
  1580. CONFIG_ECHO_START;
  1581. SERIAL_ECHOLNPGM("PID settings:");
  1582. }
  1583. #if ENABLED(PIDTEMP)
  1584. #if HOTENDS > 1
  1585. if (forReplay) {
  1586. HOTEND_LOOP() {
  1587. CONFIG_ECHO_START;
  1588. SERIAL_ECHOPAIR(" M301 E", e);
  1589. SERIAL_ECHOPAIR(" P", PID_PARAM(Kp, e));
  1590. SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, e)));
  1591. SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, e)));
  1592. #if ENABLED(PID_EXTRUSION_SCALING)
  1593. SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, e));
  1594. if (e == 0) SERIAL_ECHOPAIR(" L", lpq_len);
  1595. #endif
  1596. SERIAL_EOL();
  1597. }
  1598. }
  1599. else
  1600. #endif // HOTENDS > 1
  1601. // !forReplay || HOTENDS == 1
  1602. {
  1603. CONFIG_ECHO_START;
  1604. SERIAL_ECHOPAIR(" M301 P", PID_PARAM(Kp, 0)); // for compatibility with hosts, only echo values for E0
  1605. SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, 0)));
  1606. SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, 0)));
  1607. #if ENABLED(PID_EXTRUSION_SCALING)
  1608. SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, 0));
  1609. SERIAL_ECHOPAIR(" L", lpq_len);
  1610. #endif
  1611. SERIAL_EOL();
  1612. }
  1613. #endif // PIDTEMP
  1614. #if ENABLED(PIDTEMPBED)
  1615. CONFIG_ECHO_START;
  1616. SERIAL_ECHOPAIR(" M304 P", thermalManager.bedKp);
  1617. SERIAL_ECHOPAIR(" I", unscalePID_i(thermalManager.bedKi));
  1618. SERIAL_ECHOPAIR(" D", unscalePID_d(thermalManager.bedKd));
  1619. SERIAL_EOL();
  1620. #endif
  1621. #endif // PIDTEMP || PIDTEMPBED
  1622. #if HAS_LCD_CONTRAST
  1623. if (!forReplay) {
  1624. CONFIG_ECHO_START;
  1625. SERIAL_ECHOLNPGM("LCD Contrast:");
  1626. }
  1627. CONFIG_ECHO_START;
  1628. SERIAL_ECHOLNPAIR(" M250 C", lcd_contrast);
  1629. #endif
  1630. #if ENABLED(FWRETRACT)
  1631. if (!forReplay) {
  1632. CONFIG_ECHO_START;
  1633. SERIAL_ECHOLNPGM("Retract: S<length> F<units/m> Z<lift>");
  1634. }
  1635. CONFIG_ECHO_START;
  1636. SERIAL_ECHOPAIR(" M207 S", LINEAR_UNIT(fwretract.retract_length));
  1637. SERIAL_ECHOPAIR(" W", LINEAR_UNIT(fwretract.swap_retract_length));
  1638. SERIAL_ECHOPAIR(" F", MMS_TO_MMM(LINEAR_UNIT(fwretract.retract_feedrate_mm_s)));
  1639. SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(fwretract.retract_zlift));
  1640. if (!forReplay) {
  1641. CONFIG_ECHO_START;
  1642. SERIAL_ECHOLNPGM("Recover: S<length> F<units/m>");
  1643. }
  1644. CONFIG_ECHO_START;
  1645. SERIAL_ECHOPAIR(" M208 S", LINEAR_UNIT(fwretract.retract_recover_length));
  1646. SERIAL_ECHOPAIR(" W", LINEAR_UNIT(fwretract.swap_retract_recover_length));
  1647. SERIAL_ECHOLNPAIR(" F", MMS_TO_MMM(LINEAR_UNIT(fwretract.retract_recover_feedrate_mm_s)));
  1648. if (!forReplay) {
  1649. CONFIG_ECHO_START;
  1650. SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret E-only moves as retract/recover");
  1651. }
  1652. CONFIG_ECHO_START;
  1653. SERIAL_ECHOLNPAIR(" M209 S", fwretract.autoretract_enabled ? 1 : 0);
  1654. #endif // FWRETRACT
  1655. /**
  1656. * Probe Offset
  1657. */
  1658. #if HAS_BED_PROBE
  1659. if (!forReplay) {
  1660. CONFIG_ECHO_START;
  1661. SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
  1662. }
  1663. CONFIG_ECHO_START;
  1664. SERIAL_ECHOLNPAIR(" M851 Z", LINEAR_UNIT(zprobe_zoffset));
  1665. #endif
  1666. /**
  1667. * TMC2130 stepper driver current
  1668. */
  1669. #if ENABLED(HAVE_TMC2130)
  1670. if (!forReplay) {
  1671. CONFIG_ECHO_START;
  1672. SERIAL_ECHOLNPGM("Stepper driver current:");
  1673. }
  1674. CONFIG_ECHO_START;
  1675. SERIAL_ECHO(" M906");
  1676. #if ENABLED(X_IS_TMC2130)
  1677. SERIAL_ECHOPAIR(" X", stepperX.getCurrent());
  1678. #endif
  1679. #if ENABLED(Y_IS_TMC2130)
  1680. SERIAL_ECHOPAIR(" Y", stepperY.getCurrent());
  1681. #endif
  1682. #if ENABLED(Z_IS_TMC2130)
  1683. SERIAL_ECHOPAIR(" Z", stepperZ.getCurrent());
  1684. #endif
  1685. #if ENABLED(X2_IS_TMC2130)
  1686. SERIAL_ECHOPAIR(" X2", stepperX2.getCurrent());
  1687. #endif
  1688. #if ENABLED(Y2_IS_TMC2130)
  1689. SERIAL_ECHOPAIR(" Y2", stepperY2.getCurrent());
  1690. #endif
  1691. #if ENABLED(Z2_IS_TMC2130)
  1692. SERIAL_ECHOPAIR(" Z2", stepperZ2.getCurrent());
  1693. #endif
  1694. #if ENABLED(E0_IS_TMC2130)
  1695. SERIAL_ECHOPAIR(" E0", stepperE0.getCurrent());
  1696. #endif
  1697. #if ENABLED(E1_IS_TMC2130)
  1698. SERIAL_ECHOPAIR(" E1", stepperE1.getCurrent());
  1699. #endif
  1700. #if ENABLED(E2_IS_TMC2130)
  1701. SERIAL_ECHOPAIR(" E2", stepperE2.getCurrent());
  1702. #endif
  1703. #if ENABLED(E3_IS_TMC2130)
  1704. SERIAL_ECHOPAIR(" E3", stepperE3.getCurrent());
  1705. #endif
  1706. SERIAL_EOL();
  1707. #endif
  1708. /**
  1709. * Linear Advance
  1710. */
  1711. #if ENABLED(LIN_ADVANCE)
  1712. if (!forReplay) {
  1713. CONFIG_ECHO_START;
  1714. SERIAL_ECHOLNPGM("Linear Advance:");
  1715. }
  1716. CONFIG_ECHO_START;
  1717. SERIAL_ECHOPAIR(" M900 K", planner.extruder_advance_k);
  1718. SERIAL_ECHOLNPAIR(" R", planner.advance_ed_ratio);
  1719. #endif
  1720. #if HAS_MOTOR_CURRENT_PWM
  1721. CONFIG_ECHO_START;
  1722. if (!forReplay) {
  1723. SERIAL_ECHOLNPGM("Stepper motor currents:");
  1724. CONFIG_ECHO_START;
  1725. }
  1726. SERIAL_ECHOPAIR(" M907 X", stepper.motor_current_setting[0]);
  1727. SERIAL_ECHOPAIR(" Z", stepper.motor_current_setting[1]);
  1728. SERIAL_ECHOPAIR(" E", stepper.motor_current_setting[2]);
  1729. SERIAL_EOL();
  1730. #endif
  1731. }
  1732. #endif // !DISABLE_M503