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

settings.cpp 111KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756
  1. /**
  2. * Marlin 3D Printer Firmware
  3. * Copyright (c) 2020 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 <https://www.gnu.org/licenses/>.
  20. *
  21. */
  22. /**
  23. * settings.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. // Change EEPROM version if the structure changes
  37. #define EEPROM_VERSION "V81"
  38. #define EEPROM_OFFSET 100
  39. // Check the integrity of data offsets.
  40. // Can be disabled for production build.
  41. //#define DEBUG_EEPROM_READWRITE
  42. #include "settings.h"
  43. #include "endstops.h"
  44. #include "planner.h"
  45. #include "stepper.h"
  46. #include "temperature.h"
  47. #if ENABLED(DWIN_CREALITY_LCD)
  48. #include "../lcd/dwin/e3v2/dwin.h"
  49. #endif
  50. #include "../lcd/ultralcd.h"
  51. #include "../libs/vector_3.h" // for matrix_3x3
  52. #include "../gcode/gcode.h"
  53. #include "../MarlinCore.h"
  54. #if EITHER(EEPROM_SETTINGS, SD_FIRMWARE_UPDATE)
  55. #include "../HAL/shared/eeprom_api.h"
  56. #endif
  57. #include "probe.h"
  58. #if HAS_LEVELING
  59. #include "../feature/bedlevel/bedlevel.h"
  60. #endif
  61. #if ENABLED(Z_STEPPER_AUTO_ALIGN)
  62. #include "../feature/z_stepper_align.h"
  63. #endif
  64. #if ENABLED(EXTENSIBLE_UI)
  65. #include "../lcd/extui/ui_api.h"
  66. #endif
  67. #if HAS_SERVOS
  68. #include "servo.h"
  69. #endif
  70. #if HAS_SERVOS && HAS_SERVO_ANGLES
  71. #define EEPROM_NUM_SERVOS NUM_SERVOS
  72. #else
  73. #define EEPROM_NUM_SERVOS NUM_SERVO_PLUGS
  74. #endif
  75. #include "../feature/fwretract.h"
  76. #if ENABLED(POWER_LOSS_RECOVERY)
  77. #include "../feature/powerloss.h"
  78. #endif
  79. #if HAS_POWER_MONITOR
  80. #include "../feature/power_monitor.h"
  81. #endif
  82. #include "../feature/pause.h"
  83. #if ENABLED(BACKLASH_COMPENSATION)
  84. #include "../feature/backlash.h"
  85. #endif
  86. #if HAS_FILAMENT_SENSOR
  87. #include "../feature/runout.h"
  88. #ifndef FIL_RUNOUT_ENABLED_DEFAULT
  89. #define FIL_RUNOUT_ENABLED_DEFAULT true
  90. #endif
  91. #endif
  92. #if ENABLED(EXTRA_LIN_ADVANCE_K)
  93. extern float other_extruder_advance_K[EXTRUDERS];
  94. #endif
  95. #if HAS_MULTI_EXTRUDER
  96. #include "tool_change.h"
  97. void M217_report(const bool eeprom);
  98. #endif
  99. #if ENABLED(BLTOUCH)
  100. #include "../feature/bltouch.h"
  101. #endif
  102. #if HAS_TRINAMIC_CONFIG
  103. #include "stepper/indirection.h"
  104. #include "../feature/tmc_util.h"
  105. #endif
  106. #if ENABLED(PROBE_TEMP_COMPENSATION)
  107. #include "../feature/probe_temp_comp.h"
  108. #endif
  109. #include "../feature/controllerfan.h"
  110. #if ENABLED(CONTROLLER_FAN_EDITABLE)
  111. void M710_report(const bool forReplay);
  112. #endif
  113. #if ENABLED(CASE_LIGHT_ENABLE) && DISABLED(CASE_LIGHT_NO_BRIGHTNESS)
  114. #include "../feature/caselight.h"
  115. #define HAS_CASE_LIGHT_BRIGHTNESS 1
  116. #endif
  117. #if ENABLED(PASSWORD_FEATURE)
  118. #include "../feature/password/password.h"
  119. #endif
  120. #if ENABLED(TOUCH_SCREEN_CALIBRATION)
  121. #include "../lcd/tft/touch.h"
  122. #endif
  123. #pragma pack(push, 1) // No padding between variables
  124. typedef struct { uint16_t X, Y, Z, X2, Y2, Z2, Z3, Z4, E0, E1, E2, E3, E4, E5, E6, E7; } tmc_stepper_current_t;
  125. typedef struct { uint32_t X, Y, Z, X2, Y2, Z2, Z3, Z4, E0, E1, E2, E3, E4, E5, E6, E7; } tmc_hybrid_threshold_t;
  126. typedef struct { int16_t X, Y, Z, X2, Y2, Z2, Z3, Z4; } tmc_sgt_t;
  127. typedef struct { bool X, Y, Z, X2, Y2, Z2, Z3, Z4, E0, E1, E2, E3, E4, E5, E6, E7; } tmc_stealth_enabled_t;
  128. // Limit an index to an array size
  129. #define ALIM(I,ARR) _MIN(I, (signed)COUNT(ARR) - 1)
  130. // Defaults for reset / fill in on load
  131. static const uint32_t _DMA[] PROGMEM = DEFAULT_MAX_ACCELERATION;
  132. static const float _DASU[] PROGMEM = DEFAULT_AXIS_STEPS_PER_UNIT;
  133. static const feedRate_t _DMF[] PROGMEM = DEFAULT_MAX_FEEDRATE;
  134. extern const char SP_X_STR[], SP_Y_STR[], SP_Z_STR[], SP_E_STR[];
  135. /**
  136. * Current EEPROM Layout
  137. *
  138. * Keep this data structure up to date so
  139. * EEPROM size is known at compile time!
  140. */
  141. typedef struct SettingsDataStruct {
  142. char version[4]; // Vnn\0
  143. uint16_t crc; // Data Checksum
  144. //
  145. // DISTINCT_E_FACTORS
  146. //
  147. uint8_t esteppers; // XYZE_N - XYZ
  148. planner_settings_t planner_settings;
  149. xyze_float_t planner_max_jerk; // M205 XYZE planner.max_jerk
  150. float planner_junction_deviation_mm; // M205 J planner.junction_deviation_mm
  151. xyz_pos_t home_offset; // M206 XYZ / M665 TPZ
  152. #if HAS_HOTEND_OFFSET
  153. xyz_pos_t hotend_offset[HOTENDS - 1]; // M218 XYZ
  154. #endif
  155. //
  156. // FILAMENT_RUNOUT_SENSOR
  157. //
  158. bool runout_sensor_enabled; // M412 S
  159. float runout_distance_mm; // M412 D
  160. //
  161. // ENABLE_LEVELING_FADE_HEIGHT
  162. //
  163. float planner_z_fade_height; // M420 Zn planner.z_fade_height
  164. //
  165. // MESH_BED_LEVELING
  166. //
  167. float mbl_z_offset; // mbl.z_offset
  168. uint8_t mesh_num_x, mesh_num_y; // GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y
  169. float mbl_z_values[TERN(MESH_BED_LEVELING, GRID_MAX_POINTS_X, 3)] // mbl.z_values
  170. [TERN(MESH_BED_LEVELING, GRID_MAX_POINTS_Y, 3)];
  171. //
  172. // HAS_BED_PROBE
  173. //
  174. xyz_pos_t probe_offset;
  175. //
  176. // ABL_PLANAR
  177. //
  178. matrix_3x3 planner_bed_level_matrix; // planner.bed_level_matrix
  179. //
  180. // AUTO_BED_LEVELING_BILINEAR
  181. //
  182. uint8_t grid_max_x, grid_max_y; // GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y
  183. xy_pos_t bilinear_grid_spacing, bilinear_start; // G29 L F
  184. #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
  185. bed_mesh_t z_values; // G29
  186. #else
  187. float z_values[3][3];
  188. #endif
  189. //
  190. // AUTO_BED_LEVELING_UBL
  191. //
  192. bool planner_leveling_active; // M420 S planner.leveling_active
  193. int8_t ubl_storage_slot; // ubl.storage_slot
  194. //
  195. // SERVO_ANGLES
  196. //
  197. uint16_t servo_angles[EEPROM_NUM_SERVOS][2]; // M281 P L U
  198. //
  199. // Temperature first layer compensation values
  200. //
  201. #if ENABLED(PROBE_TEMP_COMPENSATION)
  202. int16_t z_offsets_probe[COUNT(temp_comp.z_offsets_probe)], // M871 P I V
  203. z_offsets_bed[COUNT(temp_comp.z_offsets_bed)] // M871 B I V
  204. #if ENABLED(USE_TEMP_EXT_COMPENSATION)
  205. , z_offsets_ext[COUNT(temp_comp.z_offsets_ext)] // M871 E I V
  206. #endif
  207. ;
  208. #endif
  209. //
  210. // BLTOUCH
  211. //
  212. bool bltouch_last_written_mode;
  213. //
  214. // DELTA / [XYZ]_DUAL_ENDSTOPS
  215. //
  216. #if ENABLED(DELTA)
  217. float delta_height; // M666 H
  218. abc_float_t delta_endstop_adj; // M666 X Y Z
  219. float delta_radius, // M665 R
  220. delta_diagonal_rod, // M665 L
  221. delta_segments_per_second; // M665 S
  222. abc_float_t delta_tower_angle_trim, // M665 X Y Z
  223. delta_diagonal_rod_trim; // M665 A B C
  224. #elif HAS_EXTRA_ENDSTOPS
  225. float x2_endstop_adj, // M666 X
  226. y2_endstop_adj, // M666 Y
  227. z2_endstop_adj, // M666 (S2) Z
  228. z3_endstop_adj, // M666 (S3) Z
  229. z4_endstop_adj; // M666 (S4) Z
  230. #endif
  231. //
  232. // Z_STEPPER_AUTO_ALIGN, Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS
  233. //
  234. #if ENABLED(Z_STEPPER_AUTO_ALIGN)
  235. xy_pos_t z_stepper_align_xy[NUM_Z_STEPPER_DRIVERS]; // M422 S X Y
  236. #if ENABLED(Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS)
  237. xy_pos_t z_stepper_align_stepper_xy[NUM_Z_STEPPER_DRIVERS]; // M422 W X Y
  238. #endif
  239. #endif
  240. //
  241. // Material Presets
  242. //
  243. #if PREHEAT_COUNT
  244. preheat_t ui_material_preset[PREHEAT_COUNT]; // M145 S0 H B F
  245. #endif
  246. //
  247. // PIDTEMP
  248. //
  249. PIDCF_t hotendPID[HOTENDS]; // M301 En PIDCF / M303 En U
  250. int16_t lpq_len; // M301 L
  251. //
  252. // PIDTEMPBED
  253. //
  254. PID_t bedPID; // M304 PID / M303 E-1 U
  255. //
  256. // User-defined Thermistors
  257. //
  258. #if HAS_USER_THERMISTORS
  259. user_thermistor_t user_thermistor[USER_THERMISTORS]; // M305 P0 R4700 T100000 B3950
  260. #endif
  261. //
  262. // Power monitor
  263. //
  264. uint8_t power_monitor_flags; // M430 I V W
  265. //
  266. // HAS_LCD_CONTRAST
  267. //
  268. int16_t lcd_contrast; // M250 C
  269. //
  270. // Controller fan settings
  271. //
  272. controllerFan_settings_t controllerFan_settings; // M710
  273. //
  274. // POWER_LOSS_RECOVERY
  275. //
  276. bool recovery_enabled; // M413 S
  277. //
  278. // FWRETRACT
  279. //
  280. fwretract_settings_t fwretract_settings; // M207 S F Z W, M208 S F W R
  281. bool autoretract_enabled; // M209 S
  282. //
  283. // !NO_VOLUMETRIC
  284. //
  285. bool parser_volumetric_enabled; // M200 S parser.volumetric_enabled
  286. float planner_filament_size[EXTRUDERS]; // M200 T D planner.filament_size[]
  287. float planner_volumetric_extruder_limit[EXTRUDERS]; // M200 T L planner.volumetric_extruder_limit[]
  288. //
  289. // HAS_TRINAMIC_CONFIG
  290. //
  291. tmc_stepper_current_t tmc_stepper_current; // M906 X Y Z X2 Y2 Z2 Z3 Z4 E0 E1 E2 E3 E4 E5
  292. tmc_hybrid_threshold_t tmc_hybrid_threshold; // M913 X Y Z X2 Y2 Z2 Z3 Z4 E0 E1 E2 E3 E4 E5
  293. tmc_sgt_t tmc_sgt; // M914 X Y Z X2 Y2 Z2 Z3 Z4
  294. tmc_stealth_enabled_t tmc_stealth_enabled; // M569 X Y Z X2 Y2 Z2 Z3 Z4 E0 E1 E2 E3 E4 E5
  295. //
  296. // LIN_ADVANCE
  297. //
  298. float planner_extruder_advance_K[_MAX(EXTRUDERS, 1)]; // M900 K planner.extruder_advance_K
  299. //
  300. // HAS_MOTOR_CURRENT_PWM
  301. //
  302. uint32_t motor_current_setting[3]; // M907 X Z E
  303. //
  304. // CNC_COORDINATE_SYSTEMS
  305. //
  306. xyz_pos_t coordinate_system[MAX_COORDINATE_SYSTEMS]; // G54-G59.3
  307. //
  308. // SKEW_CORRECTION
  309. //
  310. skew_factor_t planner_skew_factor; // M852 I J K planner.skew_factor
  311. //
  312. // ADVANCED_PAUSE_FEATURE
  313. //
  314. #if EXTRUDERS
  315. fil_change_settings_t fc_settings[EXTRUDERS]; // M603 T U L
  316. #endif
  317. //
  318. // Tool-change settings
  319. //
  320. #if HAS_MULTI_EXTRUDER
  321. toolchange_settings_t toolchange_settings; // M217 S P R
  322. #endif
  323. //
  324. // BACKLASH_COMPENSATION
  325. //
  326. xyz_float_t backlash_distance_mm; // M425 X Y Z
  327. uint8_t backlash_correction; // M425 F
  328. float backlash_smoothing_mm; // M425 S
  329. //
  330. // EXTENSIBLE_UI
  331. //
  332. #if ENABLED(EXTENSIBLE_UI)
  333. // This is a significant hardware change; don't reserve space when not present
  334. uint8_t extui_data[ExtUI::eeprom_data_size];
  335. #endif
  336. //
  337. // HAS_CASE_LIGHT_BRIGHTNESS
  338. //
  339. #if HAS_CASE_LIGHT_BRIGHTNESS
  340. uint8_t caselight_brightness; // M355 P
  341. #endif
  342. //
  343. // PASSWORD_FEATURE
  344. //
  345. #if ENABLED(PASSWORD_FEATURE)
  346. bool password_is_set;
  347. uint32_t password_value;
  348. #endif
  349. //
  350. // TOUCH_SCREEN_CALIBRATION
  351. //
  352. #if ENABLED(TOUCH_SCREEN_CALIBRATION)
  353. touch_calibration_t touch_calibration;
  354. #endif
  355. } SettingsData;
  356. //static_assert(sizeof(SettingsData) <= MARLIN_EEPROM_SIZE, "EEPROM too small to contain SettingsData!");
  357. MarlinSettings settings;
  358. uint16_t MarlinSettings::datasize() { return sizeof(SettingsData); }
  359. /**
  360. * Post-process after Retrieve or Reset
  361. */
  362. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  363. float new_z_fade_height;
  364. #endif
  365. void MarlinSettings::postprocess() {
  366. xyze_pos_t oldpos = current_position;
  367. // steps per s2 needs to be updated to agree with units per s2
  368. planner.reset_acceleration_rates();
  369. // Make sure delta kinematics are updated before refreshing the
  370. // planner position so the stepper counts will be set correctly.
  371. TERN_(DELTA, recalc_delta_settings());
  372. TERN_(PIDTEMP, thermalManager.updatePID());
  373. #if DISABLED(NO_VOLUMETRICS)
  374. planner.calculate_volumetric_multipliers();
  375. #elif EXTRUDERS
  376. for (uint8_t i = COUNT(planner.e_factor); i--;)
  377. planner.refresh_e_factor(i);
  378. #endif
  379. // Software endstops depend on home_offset
  380. LOOP_XYZ(i) {
  381. update_workspace_offset((AxisEnum)i);
  382. update_software_endstops((AxisEnum)i);
  383. }
  384. TERN_(ENABLE_LEVELING_FADE_HEIGHT, set_z_fade_height(new_z_fade_height, false)); // false = no report
  385. TERN_(AUTO_BED_LEVELING_BILINEAR, refresh_bed_level());
  386. TERN_(HAS_MOTOR_CURRENT_PWM, stepper.refresh_motor_power());
  387. TERN_(FWRETRACT, fwretract.refresh_autoretract());
  388. TERN_(HAS_LINEAR_E_JERK, planner.recalculate_max_e_jerk());
  389. TERN_(HAS_CASE_LIGHT_BRIGHTNESS, caselight.update_brightness());
  390. // Refresh steps_to_mm with the reciprocal of axis_steps_per_mm
  391. // and init stepper.count[], planner.position[] with current_position
  392. planner.refresh_positioning();
  393. // Various factors can change the current position
  394. if (oldpos != current_position)
  395. report_current_position();
  396. }
  397. #if BOTH(PRINTCOUNTER, EEPROM_SETTINGS)
  398. #include "printcounter.h"
  399. static_assert(
  400. !WITHIN(STATS_EEPROM_ADDRESS, EEPROM_OFFSET, EEPROM_OFFSET + sizeof(SettingsData)) &&
  401. !WITHIN(STATS_EEPROM_ADDRESS + sizeof(printStatistics), EEPROM_OFFSET, EEPROM_OFFSET + sizeof(SettingsData)),
  402. "STATS_EEPROM_ADDRESS collides with EEPROM settings storage."
  403. );
  404. #endif
  405. #if ENABLED(SD_FIRMWARE_UPDATE)
  406. #if ENABLED(EEPROM_SETTINGS)
  407. static_assert(
  408. !WITHIN(SD_FIRMWARE_UPDATE_EEPROM_ADDR, EEPROM_OFFSET, EEPROM_OFFSET + sizeof(SettingsData)),
  409. "SD_FIRMWARE_UPDATE_EEPROM_ADDR collides with EEPROM settings storage."
  410. );
  411. #endif
  412. bool MarlinSettings::sd_update_status() {
  413. uint8_t val;
  414. persistentStore.read_data(SD_FIRMWARE_UPDATE_EEPROM_ADDR, &val);
  415. return (val == SD_FIRMWARE_UPDATE_ACTIVE_VALUE);
  416. }
  417. bool MarlinSettings::set_sd_update_status(const bool enable) {
  418. if (enable != sd_update_status())
  419. persistentStore.write_data(
  420. SD_FIRMWARE_UPDATE_EEPROM_ADDR,
  421. enable ? SD_FIRMWARE_UPDATE_ACTIVE_VALUE : SD_FIRMWARE_UPDATE_INACTIVE_VALUE
  422. );
  423. return true;
  424. }
  425. #endif // SD_FIRMWARE_UPDATE
  426. #ifdef ARCHIM2_SPI_FLASH_EEPROM_BACKUP_SIZE
  427. static_assert(
  428. EEPROM_OFFSET + sizeof(SettingsData) < ARCHIM2_SPI_FLASH_EEPROM_BACKUP_SIZE,
  429. "ARCHIM2_SPI_FLASH_EEPROM_BACKUP_SIZE is insufficient to capture all EEPROM data."
  430. );
  431. #endif
  432. #define DEBUG_OUT ENABLED(EEPROM_CHITCHAT)
  433. #include "../core/debug_out.h"
  434. #if ENABLED(EEPROM_SETTINGS)
  435. #define EEPROM_START() if (!persistentStore.access_start()) { SERIAL_ECHO_MSG("No EEPROM."); return false; } \
  436. int eeprom_index = EEPROM_OFFSET
  437. #define EEPROM_FINISH() persistentStore.access_finish()
  438. #define EEPROM_SKIP(VAR) (eeprom_index += sizeof(VAR))
  439. #define EEPROM_WRITE(VAR) do{ persistentStore.write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc); }while(0)
  440. #define EEPROM_READ(VAR) do{ persistentStore.read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc, !validating); }while(0)
  441. #define EEPROM_READ_ALWAYS(VAR) do{ persistentStore.read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc); }while(0)
  442. #define EEPROM_ASSERT(TST,ERR) do{ if (!(TST)) { SERIAL_ERROR_MSG(ERR); eeprom_error = true; } }while(0)
  443. #if ENABLED(DEBUG_EEPROM_READWRITE)
  444. #define _FIELD_TEST(FIELD) \
  445. EEPROM_ASSERT( \
  446. eeprom_error || eeprom_index == offsetof(SettingsData, FIELD) + EEPROM_OFFSET, \
  447. "Field " STRINGIFY(FIELD) " mismatch." \
  448. )
  449. #else
  450. #define _FIELD_TEST(FIELD) NOOP
  451. #endif
  452. const char version[4] = EEPROM_VERSION;
  453. bool MarlinSettings::eeprom_error, MarlinSettings::validating;
  454. bool MarlinSettings::size_error(const uint16_t size) {
  455. if (size != datasize()) {
  456. DEBUG_ERROR_MSG("EEPROM datasize error.");
  457. return true;
  458. }
  459. return false;
  460. }
  461. /**
  462. * M500 - Store Configuration
  463. */
  464. bool MarlinSettings::save() {
  465. float dummyf = 0;
  466. char ver[4] = "ERR";
  467. uint16_t working_crc = 0;
  468. EEPROM_START();
  469. eeprom_error = false;
  470. // Write or Skip version. (Flash doesn't allow rewrite without erase.)
  471. TERN(FLASH_EEPROM_EMULATION, EEPROM_SKIP, EEPROM_WRITE)(ver);
  472. EEPROM_SKIP(working_crc); // Skip the checksum slot
  473. working_crc = 0; // clear before first "real data"
  474. _FIELD_TEST(esteppers);
  475. const uint8_t esteppers = COUNT(planner.settings.axis_steps_per_mm) - XYZ;
  476. EEPROM_WRITE(esteppers);
  477. //
  478. // Planner Motion
  479. //
  480. {
  481. EEPROM_WRITE(planner.settings);
  482. #if HAS_CLASSIC_JERK
  483. EEPROM_WRITE(planner.max_jerk);
  484. #if HAS_LINEAR_E_JERK
  485. dummyf = float(DEFAULT_EJERK);
  486. EEPROM_WRITE(dummyf);
  487. #endif
  488. #else
  489. const xyze_pos_t planner_max_jerk = { 10, 10, 0.4, float(DEFAULT_EJERK) };
  490. EEPROM_WRITE(planner_max_jerk);
  491. #endif
  492. TERN_(CLASSIC_JERK, dummyf = 0.02f);
  493. EEPROM_WRITE(TERN(CLASSIC_JERK, dummyf, planner.junction_deviation_mm));
  494. }
  495. //
  496. // Home Offset
  497. //
  498. {
  499. _FIELD_TEST(home_offset);
  500. #if HAS_SCARA_OFFSET
  501. EEPROM_WRITE(scara_home_offset);
  502. #else
  503. #if !HAS_HOME_OFFSET
  504. const xyz_pos_t home_offset{0};
  505. #endif
  506. EEPROM_WRITE(home_offset);
  507. #endif
  508. }
  509. //
  510. // Hotend Offsets, if any
  511. //
  512. {
  513. #if HAS_HOTEND_OFFSET
  514. // Skip hotend 0 which must be 0
  515. LOOP_S_L_N(e, 1, HOTENDS)
  516. EEPROM_WRITE(hotend_offset[e]);
  517. #endif
  518. }
  519. //
  520. // Filament Runout Sensor
  521. //
  522. {
  523. #if HAS_FILAMENT_SENSOR
  524. const bool &runout_sensor_enabled = runout.enabled;
  525. #else
  526. constexpr int8_t runout_sensor_enabled = -1;
  527. #endif
  528. _FIELD_TEST(runout_sensor_enabled);
  529. EEPROM_WRITE(runout_sensor_enabled);
  530. #if HAS_FILAMENT_RUNOUT_DISTANCE
  531. const float &runout_distance_mm = runout.runout_distance();
  532. #else
  533. constexpr float runout_distance_mm = 0;
  534. #endif
  535. EEPROM_WRITE(runout_distance_mm);
  536. }
  537. //
  538. // Global Leveling
  539. //
  540. {
  541. const float zfh = TERN(ENABLE_LEVELING_FADE_HEIGHT, planner.z_fade_height, 10.0f);
  542. EEPROM_WRITE(zfh);
  543. }
  544. //
  545. // Mesh Bed Leveling
  546. //
  547. {
  548. #if ENABLED(MESH_BED_LEVELING)
  549. static_assert(
  550. sizeof(mbl.z_values) == (GRID_MAX_POINTS) * sizeof(mbl.z_values[0][0]),
  551. "MBL Z array is the wrong size."
  552. );
  553. #else
  554. dummyf = 0;
  555. #endif
  556. const uint8_t mesh_num_x = TERN(MESH_BED_LEVELING, GRID_MAX_POINTS_X, 3),
  557. mesh_num_y = TERN(MESH_BED_LEVELING, GRID_MAX_POINTS_Y, 3);
  558. EEPROM_WRITE(TERN(MESH_BED_LEVELING, mbl.z_offset, dummyf));
  559. EEPROM_WRITE(mesh_num_x);
  560. EEPROM_WRITE(mesh_num_y);
  561. #if ENABLED(MESH_BED_LEVELING)
  562. EEPROM_WRITE(mbl.z_values);
  563. #else
  564. for (uint8_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_WRITE(dummyf);
  565. #endif
  566. }
  567. //
  568. // Probe XYZ Offsets
  569. //
  570. {
  571. _FIELD_TEST(probe_offset);
  572. #if HAS_BED_PROBE
  573. const xyz_pos_t &zpo = probe.offset;
  574. #else
  575. constexpr xyz_pos_t zpo{0};
  576. #endif
  577. EEPROM_WRITE(zpo);
  578. }
  579. //
  580. // Planar Bed Leveling matrix
  581. //
  582. {
  583. #if ABL_PLANAR
  584. EEPROM_WRITE(planner.bed_level_matrix);
  585. #else
  586. dummyf = 0;
  587. for (uint8_t q = 9; q--;) EEPROM_WRITE(dummyf);
  588. #endif
  589. }
  590. //
  591. // Bilinear Auto Bed Leveling
  592. //
  593. {
  594. #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
  595. static_assert(
  596. sizeof(z_values) == (GRID_MAX_POINTS) * sizeof(z_values[0][0]),
  597. "Bilinear Z array is the wrong size."
  598. );
  599. #else
  600. const xy_pos_t bilinear_start{0}, bilinear_grid_spacing{0};
  601. #endif
  602. const uint8_t grid_max_x = TERN(AUTO_BED_LEVELING_BILINEAR, GRID_MAX_POINTS_X, 3),
  603. grid_max_y = TERN(AUTO_BED_LEVELING_BILINEAR, GRID_MAX_POINTS_Y, 3);
  604. EEPROM_WRITE(grid_max_x);
  605. EEPROM_WRITE(grid_max_y);
  606. EEPROM_WRITE(bilinear_grid_spacing);
  607. EEPROM_WRITE(bilinear_start);
  608. #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
  609. EEPROM_WRITE(z_values); // 9-256 floats
  610. #else
  611. dummyf = 0;
  612. for (uint16_t q = grid_max_x * grid_max_y; q--;) EEPROM_WRITE(dummyf);
  613. #endif
  614. }
  615. //
  616. // Unified Bed Leveling
  617. //
  618. {
  619. _FIELD_TEST(planner_leveling_active);
  620. const bool ubl_active = TERN(AUTO_BED_LEVELING_UBL, planner.leveling_active, false);
  621. const int8_t storage_slot = TERN(AUTO_BED_LEVELING_UBL, ubl.storage_slot, -1);
  622. EEPROM_WRITE(ubl_active);
  623. EEPROM_WRITE(storage_slot);
  624. }
  625. //
  626. // Servo Angles
  627. //
  628. {
  629. _FIELD_TEST(servo_angles);
  630. #if !HAS_SERVO_ANGLES
  631. uint16_t servo_angles[EEPROM_NUM_SERVOS][2] = { { 0, 0 } };
  632. #endif
  633. EEPROM_WRITE(servo_angles);
  634. }
  635. //
  636. // Thermal first layer compensation values
  637. //
  638. #if ENABLED(PROBE_TEMP_COMPENSATION)
  639. EEPROM_WRITE(temp_comp.z_offsets_probe);
  640. EEPROM_WRITE(temp_comp.z_offsets_bed);
  641. #if ENABLED(USE_TEMP_EXT_COMPENSATION)
  642. EEPROM_WRITE(temp_comp.z_offsets_ext);
  643. #endif
  644. #else
  645. // No placeholder data for this feature
  646. #endif
  647. //
  648. // BLTOUCH
  649. //
  650. {
  651. _FIELD_TEST(bltouch_last_written_mode);
  652. const bool bltouch_last_written_mode = TERN(BLTOUCH, bltouch.last_written_mode, false);
  653. EEPROM_WRITE(bltouch_last_written_mode);
  654. }
  655. //
  656. // DELTA Geometry or Dual Endstops offsets
  657. //
  658. {
  659. #if ENABLED(DELTA)
  660. _FIELD_TEST(delta_height);
  661. EEPROM_WRITE(delta_height); // 1 float
  662. EEPROM_WRITE(delta_endstop_adj); // 3 floats
  663. EEPROM_WRITE(delta_radius); // 1 float
  664. EEPROM_WRITE(delta_diagonal_rod); // 1 float
  665. EEPROM_WRITE(delta_segments_per_second); // 1 float
  666. EEPROM_WRITE(delta_tower_angle_trim); // 3 floats
  667. EEPROM_WRITE(delta_diagonal_rod_trim); // 3 floats
  668. #elif HAS_EXTRA_ENDSTOPS
  669. _FIELD_TEST(x2_endstop_adj);
  670. // Write dual endstops in X, Y, Z order. Unused = 0.0
  671. dummyf = 0;
  672. EEPROM_WRITE(TERN(X_DUAL_ENDSTOPS, endstops.x2_endstop_adj, dummyf)); // 1 float
  673. EEPROM_WRITE(TERN(Y_DUAL_ENDSTOPS, endstops.y2_endstop_adj, dummyf)); // 1 float
  674. EEPROM_WRITE(TERN(Z_MULTI_ENDSTOPS, endstops.z2_endstop_adj, dummyf)); // 1 float
  675. #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 3
  676. EEPROM_WRITE(endstops.z3_endstop_adj); // 1 float
  677. #else
  678. EEPROM_WRITE(dummyf);
  679. #endif
  680. #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 4
  681. EEPROM_WRITE(endstops.z4_endstop_adj); // 1 float
  682. #else
  683. EEPROM_WRITE(dummyf);
  684. #endif
  685. #endif
  686. }
  687. #if ENABLED(Z_STEPPER_AUTO_ALIGN)
  688. EEPROM_WRITE(z_stepper_align.xy);
  689. #if ENABLED(Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS)
  690. EEPROM_WRITE(z_stepper_align.stepper_xy);
  691. #endif
  692. #endif
  693. //
  694. // LCD Preheat settings
  695. //
  696. #if PREHEAT_COUNT
  697. _FIELD_TEST(ui_material_preset);
  698. EEPROM_WRITE(ui.material_preset);
  699. #endif
  700. //
  701. // PIDTEMP
  702. //
  703. {
  704. _FIELD_TEST(hotendPID);
  705. HOTEND_LOOP() {
  706. PIDCF_t pidcf = {
  707. #if DISABLED(PIDTEMP)
  708. NAN, NAN, NAN,
  709. NAN, NAN
  710. #else
  711. PID_PARAM(Kp, e),
  712. unscalePID_i(PID_PARAM(Ki, e)),
  713. unscalePID_d(PID_PARAM(Kd, e)),
  714. PID_PARAM(Kc, e),
  715. PID_PARAM(Kf, e)
  716. #endif
  717. };
  718. EEPROM_WRITE(pidcf);
  719. }
  720. _FIELD_TEST(lpq_len);
  721. #if DISABLED(PID_EXTRUSION_SCALING)
  722. const int16_t lpq_len = 20;
  723. #endif
  724. EEPROM_WRITE(TERN(PID_EXTRUSION_SCALING, thermalManager.lpq_len, lpq_len));
  725. }
  726. //
  727. // PIDTEMPBED
  728. //
  729. {
  730. _FIELD_TEST(bedPID);
  731. const PID_t bed_pid = {
  732. #if DISABLED(PIDTEMPBED)
  733. NAN, NAN, NAN
  734. #else
  735. // Store the unscaled PID values
  736. thermalManager.temp_bed.pid.Kp,
  737. unscalePID_i(thermalManager.temp_bed.pid.Ki),
  738. unscalePID_d(thermalManager.temp_bed.pid.Kd)
  739. #endif
  740. };
  741. EEPROM_WRITE(bed_pid);
  742. }
  743. //
  744. // User-defined Thermistors
  745. //
  746. #if HAS_USER_THERMISTORS
  747. {
  748. _FIELD_TEST(user_thermistor);
  749. EEPROM_WRITE(thermalManager.user_thermistor);
  750. }
  751. #endif
  752. //
  753. // Power monitor
  754. //
  755. {
  756. #if HAS_POWER_MONITOR
  757. const uint8_t &power_monitor_flags = power_monitor.flags;
  758. #else
  759. constexpr uint8_t power_monitor_flags = 0x00;
  760. #endif
  761. _FIELD_TEST(power_monitor_flags);
  762. EEPROM_WRITE(power_monitor_flags);
  763. }
  764. //
  765. // LCD Contrast
  766. //
  767. {
  768. _FIELD_TEST(lcd_contrast);
  769. const int16_t lcd_contrast =
  770. #if HAS_LCD_CONTRAST
  771. ui.contrast
  772. #else
  773. 127
  774. #endif
  775. ;
  776. EEPROM_WRITE(lcd_contrast);
  777. }
  778. //
  779. // Controller Fan
  780. //
  781. {
  782. _FIELD_TEST(controllerFan_settings);
  783. #if ENABLED(USE_CONTROLLER_FAN)
  784. const controllerFan_settings_t &cfs = controllerFan.settings;
  785. #else
  786. controllerFan_settings_t cfs = controllerFan_defaults;
  787. #endif
  788. EEPROM_WRITE(cfs);
  789. }
  790. //
  791. // Power-Loss Recovery
  792. //
  793. {
  794. _FIELD_TEST(recovery_enabled);
  795. const bool recovery_enabled = TERN(POWER_LOSS_RECOVERY, recovery.enabled, ENABLED(PLR_ENABLED_DEFAULT));
  796. EEPROM_WRITE(recovery_enabled);
  797. }
  798. //
  799. // Firmware Retraction
  800. //
  801. {
  802. _FIELD_TEST(fwretract_settings);
  803. #if DISABLED(FWRETRACT)
  804. const fwretract_settings_t autoretract_defaults = { 3, 45, 0, 0, 0, 13, 0, 8 };
  805. #endif
  806. EEPROM_WRITE(TERN(FWRETRACT, fwretract.settings, autoretract_defaults));
  807. #if DISABLED(FWRETRACT_AUTORETRACT)
  808. const bool autoretract_enabled = false;
  809. #endif
  810. EEPROM_WRITE(TERN(FWRETRACT_AUTORETRACT, fwretract.autoretract_enabled, autoretract_enabled));
  811. }
  812. //
  813. // Volumetric & Filament Size
  814. //
  815. {
  816. _FIELD_TEST(parser_volumetric_enabled);
  817. #if DISABLED(NO_VOLUMETRICS)
  818. EEPROM_WRITE(parser.volumetric_enabled);
  819. EEPROM_WRITE(planner.filament_size);
  820. #if ENABLED(VOLUMETRIC_EXTRUDER_LIMIT)
  821. EEPROM_WRITE(planner.volumetric_extruder_limit);
  822. #else
  823. dummyf = DEFAULT_VOLUMETRIC_EXTRUDER_LIMIT;
  824. for (uint8_t q = EXTRUDERS; q--;) EEPROM_WRITE(dummyf);
  825. #endif
  826. #else
  827. const bool volumetric_enabled = false;
  828. EEPROM_WRITE(volumetric_enabled);
  829. dummyf = DEFAULT_NOMINAL_FILAMENT_DIA;
  830. for (uint8_t q = EXTRUDERS; q--;) EEPROM_WRITE(dummyf);
  831. dummyf = DEFAULT_VOLUMETRIC_EXTRUDER_LIMIT;
  832. for (uint8_t q = EXTRUDERS; q--;) EEPROM_WRITE(dummyf);
  833. #endif
  834. }
  835. //
  836. // TMC Configuration
  837. //
  838. {
  839. _FIELD_TEST(tmc_stepper_current);
  840. tmc_stepper_current_t tmc_stepper_current = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  841. #if HAS_TRINAMIC_CONFIG
  842. #if AXIS_IS_TMC(X)
  843. tmc_stepper_current.X = stepperX.getMilliamps();
  844. #endif
  845. #if AXIS_IS_TMC(Y)
  846. tmc_stepper_current.Y = stepperY.getMilliamps();
  847. #endif
  848. #if AXIS_IS_TMC(Z)
  849. tmc_stepper_current.Z = stepperZ.getMilliamps();
  850. #endif
  851. #if AXIS_IS_TMC(X2)
  852. tmc_stepper_current.X2 = stepperX2.getMilliamps();
  853. #endif
  854. #if AXIS_IS_TMC(Y2)
  855. tmc_stepper_current.Y2 = stepperY2.getMilliamps();
  856. #endif
  857. #if AXIS_IS_TMC(Z2)
  858. tmc_stepper_current.Z2 = stepperZ2.getMilliamps();
  859. #endif
  860. #if AXIS_IS_TMC(Z3)
  861. tmc_stepper_current.Z3 = stepperZ3.getMilliamps();
  862. #endif
  863. #if AXIS_IS_TMC(Z4)
  864. tmc_stepper_current.Z4 = stepperZ4.getMilliamps();
  865. #endif
  866. #if MAX_EXTRUDERS
  867. #if AXIS_IS_TMC(E0)
  868. tmc_stepper_current.E0 = stepperE0.getMilliamps();
  869. #endif
  870. #if MAX_EXTRUDERS > 1
  871. #if AXIS_IS_TMC(E1)
  872. tmc_stepper_current.E1 = stepperE1.getMilliamps();
  873. #endif
  874. #if MAX_EXTRUDERS > 2
  875. #if AXIS_IS_TMC(E2)
  876. tmc_stepper_current.E2 = stepperE2.getMilliamps();
  877. #endif
  878. #if MAX_EXTRUDERS > 3
  879. #if AXIS_IS_TMC(E3)
  880. tmc_stepper_current.E3 = stepperE3.getMilliamps();
  881. #endif
  882. #if MAX_EXTRUDERS > 4
  883. #if AXIS_IS_TMC(E4)
  884. tmc_stepper_current.E4 = stepperE4.getMilliamps();
  885. #endif
  886. #if MAX_EXTRUDERS > 5
  887. #if AXIS_IS_TMC(E5)
  888. tmc_stepper_current.E5 = stepperE5.getMilliamps();
  889. #endif
  890. #if MAX_EXTRUDERS > 6
  891. #if AXIS_IS_TMC(E6)
  892. tmc_stepper_current.E6 = stepperE6.getMilliamps();
  893. #endif
  894. #if MAX_EXTRUDERS > 7
  895. #if AXIS_IS_TMC(E7)
  896. tmc_stepper_current.E7 = stepperE7.getMilliamps();
  897. #endif
  898. #endif // MAX_EXTRUDERS > 7
  899. #endif // MAX_EXTRUDERS > 6
  900. #endif // MAX_EXTRUDERS > 5
  901. #endif // MAX_EXTRUDERS > 4
  902. #endif // MAX_EXTRUDERS > 3
  903. #endif // MAX_EXTRUDERS > 2
  904. #endif // MAX_EXTRUDERS > 1
  905. #endif // MAX_EXTRUDERS
  906. #endif
  907. EEPROM_WRITE(tmc_stepper_current);
  908. }
  909. //
  910. // TMC Hybrid Threshold, and placeholder values
  911. //
  912. {
  913. _FIELD_TEST(tmc_hybrid_threshold);
  914. #if ENABLED(HYBRID_THRESHOLD)
  915. tmc_hybrid_threshold_t tmc_hybrid_threshold = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  916. #if AXIS_HAS_STEALTHCHOP(X)
  917. tmc_hybrid_threshold.X = stepperX.get_pwm_thrs();
  918. #endif
  919. #if AXIS_HAS_STEALTHCHOP(Y)
  920. tmc_hybrid_threshold.Y = stepperY.get_pwm_thrs();
  921. #endif
  922. #if AXIS_HAS_STEALTHCHOP(Z)
  923. tmc_hybrid_threshold.Z = stepperZ.get_pwm_thrs();
  924. #endif
  925. #if AXIS_HAS_STEALTHCHOP(X2)
  926. tmc_hybrid_threshold.X2 = stepperX2.get_pwm_thrs();
  927. #endif
  928. #if AXIS_HAS_STEALTHCHOP(Y2)
  929. tmc_hybrid_threshold.Y2 = stepperY2.get_pwm_thrs();
  930. #endif
  931. #if AXIS_HAS_STEALTHCHOP(Z2)
  932. tmc_hybrid_threshold.Z2 = stepperZ2.get_pwm_thrs();
  933. #endif
  934. #if AXIS_HAS_STEALTHCHOP(Z3)
  935. tmc_hybrid_threshold.Z3 = stepperZ3.get_pwm_thrs();
  936. #endif
  937. #if AXIS_HAS_STEALTHCHOP(Z4)
  938. tmc_hybrid_threshold.Z4 = stepperZ4.get_pwm_thrs();
  939. #endif
  940. #if MAX_EXTRUDERS
  941. #if AXIS_HAS_STEALTHCHOP(E0)
  942. tmc_hybrid_threshold.E0 = stepperE0.get_pwm_thrs();
  943. #endif
  944. #if MAX_EXTRUDERS > 1
  945. #if AXIS_HAS_STEALTHCHOP(E1)
  946. tmc_hybrid_threshold.E1 = stepperE1.get_pwm_thrs();
  947. #endif
  948. #if MAX_EXTRUDERS > 2
  949. #if AXIS_HAS_STEALTHCHOP(E2)
  950. tmc_hybrid_threshold.E2 = stepperE2.get_pwm_thrs();
  951. #endif
  952. #if MAX_EXTRUDERS > 3
  953. #if AXIS_HAS_STEALTHCHOP(E3)
  954. tmc_hybrid_threshold.E3 = stepperE3.get_pwm_thrs();
  955. #endif
  956. #if MAX_EXTRUDERS > 4
  957. #if AXIS_HAS_STEALTHCHOP(E4)
  958. tmc_hybrid_threshold.E4 = stepperE4.get_pwm_thrs();
  959. #endif
  960. #if MAX_EXTRUDERS > 5
  961. #if AXIS_HAS_STEALTHCHOP(E5)
  962. tmc_hybrid_threshold.E5 = stepperE5.get_pwm_thrs();
  963. #endif
  964. #if MAX_EXTRUDERS > 6
  965. #if AXIS_HAS_STEALTHCHOP(E6)
  966. tmc_hybrid_threshold.E6 = stepperE6.get_pwm_thrs();
  967. #endif
  968. #if MAX_EXTRUDERS > 7
  969. #if AXIS_HAS_STEALTHCHOP(E7)
  970. tmc_hybrid_threshold.E7 = stepperE7.get_pwm_thrs();
  971. #endif
  972. #endif // MAX_EXTRUDERS > 7
  973. #endif // MAX_EXTRUDERS > 6
  974. #endif // MAX_EXTRUDERS > 5
  975. #endif // MAX_EXTRUDERS > 4
  976. #endif // MAX_EXTRUDERS > 3
  977. #endif // MAX_EXTRUDERS > 2
  978. #endif // MAX_EXTRUDERS > 1
  979. #endif // MAX_EXTRUDERS
  980. #else
  981. const tmc_hybrid_threshold_t tmc_hybrid_threshold = {
  982. .X = 100, .Y = 100, .Z = 3,
  983. .X2 = 100, .Y2 = 100, .Z2 = 3, .Z3 = 3, .Z4 = 3,
  984. .E0 = 30, .E1 = 30, .E2 = 30,
  985. .E3 = 30, .E4 = 30, .E5 = 30
  986. };
  987. #endif
  988. EEPROM_WRITE(tmc_hybrid_threshold);
  989. }
  990. //
  991. // TMC StallGuard threshold
  992. //
  993. {
  994. tmc_sgt_t tmc_sgt{0};
  995. #if USE_SENSORLESS
  996. TERN_(X_SENSORLESS, tmc_sgt.X = stepperX.homing_threshold());
  997. TERN_(X2_SENSORLESS, tmc_sgt.X2 = stepperX2.homing_threshold());
  998. TERN_(Y_SENSORLESS, tmc_sgt.Y = stepperY.homing_threshold());
  999. TERN_(Y2_SENSORLESS, tmc_sgt.Y2 = stepperY2.homing_threshold());
  1000. TERN_(Z_SENSORLESS, tmc_sgt.Z = stepperZ.homing_threshold());
  1001. TERN_(Z2_SENSORLESS, tmc_sgt.Z2 = stepperZ2.homing_threshold());
  1002. TERN_(Z3_SENSORLESS, tmc_sgt.Z3 = stepperZ3.homing_threshold());
  1003. TERN_(Z4_SENSORLESS, tmc_sgt.Z4 = stepperZ4.homing_threshold());
  1004. #endif
  1005. EEPROM_WRITE(tmc_sgt);
  1006. }
  1007. //
  1008. // TMC stepping mode
  1009. //
  1010. {
  1011. _FIELD_TEST(tmc_stealth_enabled);
  1012. tmc_stealth_enabled_t tmc_stealth_enabled = { false, false, false, false, false, false, false, false, false, false, false, false, false };
  1013. #if HAS_STEALTHCHOP
  1014. #if AXIS_HAS_STEALTHCHOP(X)
  1015. tmc_stealth_enabled.X = stepperX.get_stored_stealthChop_status();
  1016. #endif
  1017. #if AXIS_HAS_STEALTHCHOP(Y)
  1018. tmc_stealth_enabled.Y = stepperY.get_stored_stealthChop_status();
  1019. #endif
  1020. #if AXIS_HAS_STEALTHCHOP(Z)
  1021. tmc_stealth_enabled.Z = stepperZ.get_stored_stealthChop_status();
  1022. #endif
  1023. #if AXIS_HAS_STEALTHCHOP(X2)
  1024. tmc_stealth_enabled.X2 = stepperX2.get_stored_stealthChop_status();
  1025. #endif
  1026. #if AXIS_HAS_STEALTHCHOP(Y2)
  1027. tmc_stealth_enabled.Y2 = stepperY2.get_stored_stealthChop_status();
  1028. #endif
  1029. #if AXIS_HAS_STEALTHCHOP(Z2)
  1030. tmc_stealth_enabled.Z2 = stepperZ2.get_stored_stealthChop_status();
  1031. #endif
  1032. #if AXIS_HAS_STEALTHCHOP(Z3)
  1033. tmc_stealth_enabled.Z3 = stepperZ3.get_stored_stealthChop_status();
  1034. #endif
  1035. #if AXIS_HAS_STEALTHCHOP(Z4)
  1036. tmc_stealth_enabled.Z4 = stepperZ4.get_stored_stealthChop_status();
  1037. #endif
  1038. #if MAX_EXTRUDERS
  1039. #if AXIS_HAS_STEALTHCHOP(E0)
  1040. tmc_stealth_enabled.E0 = stepperE0.get_stored_stealthChop_status();
  1041. #endif
  1042. #if MAX_EXTRUDERS > 1
  1043. #if AXIS_HAS_STEALTHCHOP(E1)
  1044. tmc_stealth_enabled.E1 = stepperE1.get_stored_stealthChop_status();
  1045. #endif
  1046. #if MAX_EXTRUDERS > 2
  1047. #if AXIS_HAS_STEALTHCHOP(E2)
  1048. tmc_stealth_enabled.E2 = stepperE2.get_stored_stealthChop_status();
  1049. #endif
  1050. #if MAX_EXTRUDERS > 3
  1051. #if AXIS_HAS_STEALTHCHOP(E3)
  1052. tmc_stealth_enabled.E3 = stepperE3.get_stored_stealthChop_status();
  1053. #endif
  1054. #if MAX_EXTRUDERS > 4
  1055. #if AXIS_HAS_STEALTHCHOP(E4)
  1056. tmc_stealth_enabled.E4 = stepperE4.get_stored_stealthChop_status();
  1057. #endif
  1058. #if MAX_EXTRUDERS > 5
  1059. #if AXIS_HAS_STEALTHCHOP(E5)
  1060. tmc_stealth_enabled.E5 = stepperE5.get_stored_stealthChop_status();
  1061. #endif
  1062. #if MAX_EXTRUDERS > 6
  1063. #if AXIS_HAS_STEALTHCHOP(E6)
  1064. tmc_stealth_enabled.E6 = stepperE6.get_stored_stealthChop_status();
  1065. #endif
  1066. #if MAX_EXTRUDERS > 7
  1067. #if AXIS_HAS_STEALTHCHOP(E7)
  1068. tmc_stealth_enabled.E7 = stepperE7.get_stored_stealthChop_status();
  1069. #endif
  1070. #endif // MAX_EXTRUDERS > 7
  1071. #endif // MAX_EXTRUDERS > 6
  1072. #endif // MAX_EXTRUDERS > 5
  1073. #endif // MAX_EXTRUDERS > 4
  1074. #endif // MAX_EXTRUDERS > 3
  1075. #endif // MAX_EXTRUDERS > 2
  1076. #endif // MAX_EXTRUDERS > 1
  1077. #endif // MAX_EXTRUDERS
  1078. #endif
  1079. EEPROM_WRITE(tmc_stealth_enabled);
  1080. }
  1081. //
  1082. // Linear Advance
  1083. //
  1084. {
  1085. _FIELD_TEST(planner_extruder_advance_K);
  1086. #if ENABLED(LIN_ADVANCE)
  1087. EEPROM_WRITE(planner.extruder_advance_K);
  1088. #else
  1089. dummyf = 0;
  1090. for (uint8_t q = _MAX(EXTRUDERS, 1); q--;) EEPROM_WRITE(dummyf);
  1091. #endif
  1092. }
  1093. //
  1094. // Motor Current PWM
  1095. //
  1096. {
  1097. _FIELD_TEST(motor_current_setting);
  1098. #if HAS_MOTOR_CURRENT_PWM
  1099. EEPROM_WRITE(stepper.motor_current_setting);
  1100. #else
  1101. const uint32_t no_current[3] = { 0 };
  1102. EEPROM_WRITE(no_current);
  1103. #endif
  1104. }
  1105. //
  1106. // CNC Coordinate Systems
  1107. //
  1108. _FIELD_TEST(coordinate_system);
  1109. #if DISABLED(CNC_COORDINATE_SYSTEMS)
  1110. const xyz_pos_t coordinate_system[MAX_COORDINATE_SYSTEMS] = { { 0 } };
  1111. #endif
  1112. EEPROM_WRITE(TERN(CNC_COORDINATE_SYSTEMS, gcode.coordinate_system, coordinate_system));
  1113. //
  1114. // Skew correction factors
  1115. //
  1116. _FIELD_TEST(planner_skew_factor);
  1117. EEPROM_WRITE(planner.skew_factor);
  1118. //
  1119. // Advanced Pause filament load & unload lengths
  1120. //
  1121. #if EXTRUDERS
  1122. {
  1123. #if DISABLED(ADVANCED_PAUSE_FEATURE)
  1124. const fil_change_settings_t fc_settings[EXTRUDERS] = { 0, 0 };
  1125. #endif
  1126. _FIELD_TEST(fc_settings);
  1127. EEPROM_WRITE(fc_settings);
  1128. }
  1129. #endif
  1130. //
  1131. // Multiple Extruders
  1132. //
  1133. #if HAS_MULTI_EXTRUDER
  1134. _FIELD_TEST(toolchange_settings);
  1135. EEPROM_WRITE(toolchange_settings);
  1136. #endif
  1137. //
  1138. // Backlash Compensation
  1139. //
  1140. {
  1141. #if ENABLED(BACKLASH_GCODE)
  1142. const xyz_float_t &backlash_distance_mm = backlash.distance_mm;
  1143. const uint8_t &backlash_correction = backlash.correction;
  1144. #else
  1145. const xyz_float_t backlash_distance_mm{0};
  1146. const uint8_t backlash_correction = 0;
  1147. #endif
  1148. #if ENABLED(BACKLASH_GCODE) && defined(BACKLASH_SMOOTHING_MM)
  1149. const float &backlash_smoothing_mm = backlash.smoothing_mm;
  1150. #else
  1151. const float backlash_smoothing_mm = 3;
  1152. #endif
  1153. _FIELD_TEST(backlash_distance_mm);
  1154. EEPROM_WRITE(backlash_distance_mm);
  1155. EEPROM_WRITE(backlash_correction);
  1156. EEPROM_WRITE(backlash_smoothing_mm);
  1157. }
  1158. //
  1159. // Extensible UI User Data
  1160. //
  1161. #if ENABLED(EXTENSIBLE_UI)
  1162. {
  1163. char extui_data[ExtUI::eeprom_data_size] = { 0 };
  1164. ExtUI::onStoreSettings(extui_data);
  1165. _FIELD_TEST(extui_data);
  1166. EEPROM_WRITE(extui_data);
  1167. }
  1168. #endif
  1169. //
  1170. // Case Light Brightness
  1171. //
  1172. #if HAS_CASE_LIGHT_BRIGHTNESS
  1173. EEPROM_WRITE(caselight.brightness);
  1174. #endif
  1175. //
  1176. // Password feature
  1177. //
  1178. #if ENABLED(PASSWORD_FEATURE)
  1179. EEPROM_WRITE(password.is_set);
  1180. EEPROM_WRITE(password.value);
  1181. #endif
  1182. //
  1183. // TOUCH_SCREEN_CALIBRATION
  1184. //
  1185. #if ENABLED(TOUCH_SCREEN_CALIBRATION)
  1186. EEPROM_WRITE(touch.calibration);
  1187. #endif
  1188. //
  1189. // Validate CRC and Data Size
  1190. //
  1191. if (!eeprom_error) {
  1192. const uint16_t eeprom_size = eeprom_index - (EEPROM_OFFSET),
  1193. final_crc = working_crc;
  1194. // Write the EEPROM header
  1195. eeprom_index = EEPROM_OFFSET;
  1196. EEPROM_WRITE(version);
  1197. EEPROM_WRITE(final_crc);
  1198. // Report storage size
  1199. DEBUG_ECHO_START();
  1200. DEBUG_ECHOLNPAIR("Settings Stored (", eeprom_size, " bytes; crc ", (uint32_t)final_crc, ")");
  1201. eeprom_error |= size_error(eeprom_size);
  1202. }
  1203. EEPROM_FINISH();
  1204. //
  1205. // UBL Mesh
  1206. //
  1207. #if ENABLED(UBL_SAVE_ACTIVE_ON_M500)
  1208. if (ubl.storage_slot >= 0)
  1209. store_mesh(ubl.storage_slot);
  1210. #endif
  1211. if (!eeprom_error) LCD_MESSAGEPGM(MSG_SETTINGS_STORED);
  1212. TERN_(EXTENSIBLE_UI, ExtUI::onConfigurationStoreWritten(!eeprom_error));
  1213. return !eeprom_error;
  1214. }
  1215. /**
  1216. * M501 - Retrieve Configuration
  1217. */
  1218. bool MarlinSettings::_load() {
  1219. uint16_t working_crc = 0;
  1220. EEPROM_START();
  1221. char stored_ver[4];
  1222. EEPROM_READ_ALWAYS(stored_ver);
  1223. uint16_t stored_crc;
  1224. EEPROM_READ_ALWAYS(stored_crc);
  1225. // Version has to match or defaults are used
  1226. if (strncmp(version, stored_ver, 3) != 0) {
  1227. if (stored_ver[3] != '\0') {
  1228. stored_ver[0] = '?';
  1229. stored_ver[1] = '\0';
  1230. }
  1231. DEBUG_ECHO_START();
  1232. DEBUG_ECHOLNPAIR("EEPROM version mismatch (EEPROM=", stored_ver, " Marlin=" EEPROM_VERSION ")");
  1233. TERN(EEPROM_AUTO_INIT,,ui.eeprom_alert_version());
  1234. eeprom_error = true;
  1235. }
  1236. else {
  1237. float dummyf = 0;
  1238. working_crc = 0; // Init to 0. Accumulated by EEPROM_READ
  1239. _FIELD_TEST(esteppers);
  1240. // Number of esteppers may change
  1241. uint8_t esteppers;
  1242. EEPROM_READ_ALWAYS(esteppers);
  1243. //
  1244. // Planner Motion
  1245. //
  1246. {
  1247. // Get only the number of E stepper parameters previously stored
  1248. // Any steppers added later are set to their defaults
  1249. uint32_t tmp1[XYZ + esteppers];
  1250. float tmp2[XYZ + esteppers];
  1251. feedRate_t tmp3[XYZ + esteppers];
  1252. EEPROM_READ(tmp1); // max_acceleration_mm_per_s2
  1253. EEPROM_READ(planner.settings.min_segment_time_us);
  1254. EEPROM_READ(tmp2); // axis_steps_per_mm
  1255. EEPROM_READ(tmp3); // max_feedrate_mm_s
  1256. if (!validating) LOOP_XYZE_N(i) {
  1257. const bool in = (i < esteppers + XYZ);
  1258. planner.settings.max_acceleration_mm_per_s2[i] = in ? tmp1[i] : pgm_read_dword(&_DMA[ALIM(i, _DMA)]);
  1259. planner.settings.axis_steps_per_mm[i] = in ? tmp2[i] : pgm_read_float(&_DASU[ALIM(i, _DASU)]);
  1260. planner.settings.max_feedrate_mm_s[i] = in ? tmp3[i] : pgm_read_float(&_DMF[ALIM(i, _DMF)]);
  1261. }
  1262. EEPROM_READ(planner.settings.acceleration);
  1263. EEPROM_READ(planner.settings.retract_acceleration);
  1264. EEPROM_READ(planner.settings.travel_acceleration);
  1265. EEPROM_READ(planner.settings.min_feedrate_mm_s);
  1266. EEPROM_READ(planner.settings.min_travel_feedrate_mm_s);
  1267. #if HAS_CLASSIC_JERK
  1268. EEPROM_READ(planner.max_jerk);
  1269. #if HAS_LINEAR_E_JERK
  1270. EEPROM_READ(dummyf);
  1271. #endif
  1272. #else
  1273. for (uint8_t q = 4; q--;) EEPROM_READ(dummyf);
  1274. #endif
  1275. EEPROM_READ(TERN(CLASSIC_JERK, dummyf, planner.junction_deviation_mm));
  1276. }
  1277. //
  1278. // Home Offset (M206 / M665)
  1279. //
  1280. {
  1281. _FIELD_TEST(home_offset);
  1282. #if HAS_SCARA_OFFSET
  1283. EEPROM_READ(scara_home_offset);
  1284. #else
  1285. #if !HAS_HOME_OFFSET
  1286. xyz_pos_t home_offset;
  1287. #endif
  1288. EEPROM_READ(home_offset);
  1289. #endif
  1290. }
  1291. //
  1292. // Hotend Offsets, if any
  1293. //
  1294. {
  1295. #if HAS_HOTEND_OFFSET
  1296. // Skip hotend 0 which must be 0
  1297. LOOP_S_L_N(e, 1, HOTENDS)
  1298. EEPROM_READ(hotend_offset[e]);
  1299. #endif
  1300. }
  1301. //
  1302. // Filament Runout Sensor
  1303. //
  1304. {
  1305. int8_t runout_sensor_enabled;
  1306. _FIELD_TEST(runout_sensor_enabled);
  1307. EEPROM_READ(runout_sensor_enabled);
  1308. #if HAS_FILAMENT_SENSOR
  1309. runout.enabled = runout_sensor_enabled < 0 ? FIL_RUNOUT_ENABLED_DEFAULT : runout_sensor_enabled;
  1310. #endif
  1311. TERN_(HAS_FILAMENT_SENSOR, if (runout.enabled) runout.reset());
  1312. float runout_distance_mm;
  1313. EEPROM_READ(runout_distance_mm);
  1314. #if HAS_FILAMENT_RUNOUT_DISTANCE
  1315. if (!validating) runout.set_runout_distance(runout_distance_mm);
  1316. #endif
  1317. }
  1318. //
  1319. // Global Leveling
  1320. //
  1321. EEPROM_READ(TERN(ENABLE_LEVELING_FADE_HEIGHT, new_z_fade_height, dummyf));
  1322. //
  1323. // Mesh (Manual) Bed Leveling
  1324. //
  1325. {
  1326. uint8_t mesh_num_x, mesh_num_y;
  1327. EEPROM_READ(dummyf);
  1328. EEPROM_READ_ALWAYS(mesh_num_x);
  1329. EEPROM_READ_ALWAYS(mesh_num_y);
  1330. #if ENABLED(MESH_BED_LEVELING)
  1331. if (!validating) mbl.z_offset = dummyf;
  1332. if (mesh_num_x == GRID_MAX_POINTS_X && mesh_num_y == GRID_MAX_POINTS_Y) {
  1333. // EEPROM data fits the current mesh
  1334. EEPROM_READ(mbl.z_values);
  1335. }
  1336. else {
  1337. // EEPROM data is stale
  1338. if (!validating) mbl.reset();
  1339. for (uint16_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_READ(dummyf);
  1340. }
  1341. #else
  1342. // MBL is disabled - skip the stored data
  1343. for (uint16_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_READ(dummyf);
  1344. #endif // MESH_BED_LEVELING
  1345. }
  1346. //
  1347. // Probe Z Offset
  1348. //
  1349. {
  1350. _FIELD_TEST(probe_offset);
  1351. #if HAS_BED_PROBE
  1352. const xyz_pos_t &zpo = probe.offset;
  1353. #else
  1354. xyz_pos_t zpo;
  1355. #endif
  1356. EEPROM_READ(zpo);
  1357. }
  1358. //
  1359. // Planar Bed Leveling matrix
  1360. //
  1361. {
  1362. #if ABL_PLANAR
  1363. EEPROM_READ(planner.bed_level_matrix);
  1364. #else
  1365. for (uint8_t q = 9; q--;) EEPROM_READ(dummyf);
  1366. #endif
  1367. }
  1368. //
  1369. // Bilinear Auto Bed Leveling
  1370. //
  1371. {
  1372. uint8_t grid_max_x, grid_max_y;
  1373. EEPROM_READ_ALWAYS(grid_max_x); // 1 byte
  1374. EEPROM_READ_ALWAYS(grid_max_y); // 1 byte
  1375. #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
  1376. if (grid_max_x == GRID_MAX_POINTS_X && grid_max_y == GRID_MAX_POINTS_Y) {
  1377. if (!validating) set_bed_leveling_enabled(false);
  1378. EEPROM_READ(bilinear_grid_spacing); // 2 ints
  1379. EEPROM_READ(bilinear_start); // 2 ints
  1380. EEPROM_READ(z_values); // 9 to 256 floats
  1381. }
  1382. else // EEPROM data is stale
  1383. #endif // AUTO_BED_LEVELING_BILINEAR
  1384. {
  1385. // Skip past disabled (or stale) Bilinear Grid data
  1386. xy_pos_t bgs, bs;
  1387. EEPROM_READ(bgs);
  1388. EEPROM_READ(bs);
  1389. for (uint16_t q = grid_max_x * grid_max_y; q--;) EEPROM_READ(dummyf);
  1390. }
  1391. }
  1392. //
  1393. // Unified Bed Leveling active state
  1394. //
  1395. {
  1396. _FIELD_TEST(planner_leveling_active);
  1397. #if ENABLED(AUTO_BED_LEVELING_UBL)
  1398. const bool &planner_leveling_active = planner.leveling_active;
  1399. const int8_t &ubl_storage_slot = ubl.storage_slot;
  1400. #else
  1401. bool planner_leveling_active;
  1402. int8_t ubl_storage_slot;
  1403. #endif
  1404. EEPROM_READ(planner_leveling_active);
  1405. EEPROM_READ(ubl_storage_slot);
  1406. }
  1407. //
  1408. // SERVO_ANGLES
  1409. //
  1410. {
  1411. _FIELD_TEST(servo_angles);
  1412. #if ENABLED(EDITABLE_SERVO_ANGLES)
  1413. uint16_t (&servo_angles_arr)[EEPROM_NUM_SERVOS][2] = servo_angles;
  1414. #else
  1415. uint16_t servo_angles_arr[EEPROM_NUM_SERVOS][2];
  1416. #endif
  1417. EEPROM_READ(servo_angles_arr);
  1418. }
  1419. //
  1420. // Thermal first layer compensation values
  1421. //
  1422. #if ENABLED(PROBE_TEMP_COMPENSATION)
  1423. EEPROM_READ(temp_comp.z_offsets_probe);
  1424. EEPROM_READ(temp_comp.z_offsets_bed);
  1425. #if ENABLED(USE_TEMP_EXT_COMPENSATION)
  1426. EEPROM_READ(temp_comp.z_offsets_ext);
  1427. #endif
  1428. temp_comp.reset_index();
  1429. #else
  1430. // No placeholder data for this feature
  1431. #endif
  1432. //
  1433. // BLTOUCH
  1434. //
  1435. {
  1436. _FIELD_TEST(bltouch_last_written_mode);
  1437. #if ENABLED(BLTOUCH)
  1438. const bool &bltouch_last_written_mode = bltouch.last_written_mode;
  1439. #else
  1440. bool bltouch_last_written_mode;
  1441. #endif
  1442. EEPROM_READ(bltouch_last_written_mode);
  1443. }
  1444. //
  1445. // DELTA Geometry or Dual Endstops offsets
  1446. //
  1447. {
  1448. #if ENABLED(DELTA)
  1449. _FIELD_TEST(delta_height);
  1450. EEPROM_READ(delta_height); // 1 float
  1451. EEPROM_READ(delta_endstop_adj); // 3 floats
  1452. EEPROM_READ(delta_radius); // 1 float
  1453. EEPROM_READ(delta_diagonal_rod); // 1 float
  1454. EEPROM_READ(delta_segments_per_second); // 1 float
  1455. EEPROM_READ(delta_tower_angle_trim); // 3 floats
  1456. EEPROM_READ(delta_diagonal_rod_trim); // 3 floats
  1457. #elif HAS_EXTRA_ENDSTOPS
  1458. _FIELD_TEST(x2_endstop_adj);
  1459. EEPROM_READ(TERN(X_DUAL_ENDSTOPS, endstops.x2_endstop_adj, dummyf)); // 1 float
  1460. EEPROM_READ(TERN(Y_DUAL_ENDSTOPS, endstops.y2_endstop_adj, dummyf)); // 1 float
  1461. EEPROM_READ(TERN(Z_MULTI_ENDSTOPS, endstops.z2_endstop_adj, dummyf)); // 1 float
  1462. #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 3
  1463. EEPROM_READ(endstops.z3_endstop_adj); // 1 float
  1464. #else
  1465. EEPROM_READ(dummyf);
  1466. #endif
  1467. #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 4
  1468. EEPROM_READ(endstops.z4_endstop_adj); // 1 float
  1469. #else
  1470. EEPROM_READ(dummyf);
  1471. #endif
  1472. #endif
  1473. }
  1474. #if ENABLED(Z_STEPPER_AUTO_ALIGN)
  1475. EEPROM_READ(z_stepper_align.xy);
  1476. #if ENABLED(Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS)
  1477. EEPROM_READ(z_stepper_align.stepper_xy);
  1478. #endif
  1479. #endif
  1480. //
  1481. // LCD Preheat settings
  1482. //
  1483. #if PREHEAT_COUNT
  1484. _FIELD_TEST(ui_material_preset);
  1485. EEPROM_READ(ui.material_preset);
  1486. #endif
  1487. //
  1488. // Hotend PID
  1489. //
  1490. {
  1491. HOTEND_LOOP() {
  1492. PIDCF_t pidcf;
  1493. EEPROM_READ(pidcf);
  1494. #if ENABLED(PIDTEMP)
  1495. if (!validating && !isnan(pidcf.Kp)) {
  1496. // Scale PID values since EEPROM values are unscaled
  1497. PID_PARAM(Kp, e) = pidcf.Kp;
  1498. PID_PARAM(Ki, e) = scalePID_i(pidcf.Ki);
  1499. PID_PARAM(Kd, e) = scalePID_d(pidcf.Kd);
  1500. TERN_(PID_EXTRUSION_SCALING, PID_PARAM(Kc, e) = pidcf.Kc);
  1501. TERN_(PID_FAN_SCALING, PID_PARAM(Kf, e) = pidcf.Kf);
  1502. }
  1503. #endif
  1504. }
  1505. }
  1506. //
  1507. // PID Extrusion Scaling
  1508. //
  1509. {
  1510. _FIELD_TEST(lpq_len);
  1511. #if ENABLED(PID_EXTRUSION_SCALING)
  1512. const int16_t &lpq_len = thermalManager.lpq_len;
  1513. #else
  1514. int16_t lpq_len;
  1515. #endif
  1516. EEPROM_READ(lpq_len);
  1517. }
  1518. //
  1519. // Heated Bed PID
  1520. //
  1521. {
  1522. PID_t pid;
  1523. EEPROM_READ(pid);
  1524. #if ENABLED(PIDTEMPBED)
  1525. if (!validating && !isnan(pid.Kp)) {
  1526. // Scale PID values since EEPROM values are unscaled
  1527. thermalManager.temp_bed.pid.Kp = pid.Kp;
  1528. thermalManager.temp_bed.pid.Ki = scalePID_i(pid.Ki);
  1529. thermalManager.temp_bed.pid.Kd = scalePID_d(pid.Kd);
  1530. }
  1531. #endif
  1532. }
  1533. //
  1534. // User-defined Thermistors
  1535. //
  1536. #if HAS_USER_THERMISTORS
  1537. {
  1538. _FIELD_TEST(user_thermistor);
  1539. EEPROM_READ(thermalManager.user_thermistor);
  1540. }
  1541. #endif
  1542. //
  1543. // Power monitor
  1544. //
  1545. {
  1546. #if HAS_POWER_MONITOR
  1547. uint8_t &power_monitor_flags = power_monitor.flags;
  1548. #else
  1549. uint8_t power_monitor_flags;
  1550. #endif
  1551. _FIELD_TEST(power_monitor_flags);
  1552. EEPROM_READ(power_monitor_flags);
  1553. }
  1554. //
  1555. // LCD Contrast
  1556. //
  1557. {
  1558. _FIELD_TEST(lcd_contrast);
  1559. int16_t lcd_contrast;
  1560. EEPROM_READ(lcd_contrast);
  1561. if (!validating) {
  1562. TERN_(HAS_LCD_CONTRAST, ui.set_contrast(lcd_contrast));
  1563. }
  1564. }
  1565. //
  1566. // Controller Fan
  1567. //
  1568. {
  1569. _FIELD_TEST(controllerFan_settings);
  1570. #if ENABLED(CONTROLLER_FAN_EDITABLE)
  1571. const controllerFan_settings_t &cfs = controllerFan.settings;
  1572. #else
  1573. controllerFan_settings_t cfs = { 0 };
  1574. #endif
  1575. EEPROM_READ(cfs);
  1576. }
  1577. //
  1578. // Power-Loss Recovery
  1579. //
  1580. {
  1581. _FIELD_TEST(recovery_enabled);
  1582. #if ENABLED(POWER_LOSS_RECOVERY)
  1583. const bool &recovery_enabled = recovery.enabled;
  1584. #else
  1585. bool recovery_enabled;
  1586. #endif
  1587. EEPROM_READ(recovery_enabled);
  1588. }
  1589. //
  1590. // Firmware Retraction
  1591. //
  1592. {
  1593. _FIELD_TEST(fwretract_settings);
  1594. #if ENABLED(FWRETRACT)
  1595. EEPROM_READ(fwretract.settings);
  1596. #else
  1597. fwretract_settings_t fwretract_settings;
  1598. EEPROM_READ(fwretract_settings);
  1599. #endif
  1600. #if BOTH(FWRETRACT, FWRETRACT_AUTORETRACT)
  1601. EEPROM_READ(fwretract.autoretract_enabled);
  1602. #else
  1603. bool autoretract_enabled;
  1604. EEPROM_READ(autoretract_enabled);
  1605. #endif
  1606. }
  1607. //
  1608. // Volumetric & Filament Size
  1609. //
  1610. {
  1611. struct {
  1612. bool volumetric_enabled;
  1613. float filament_size[EXTRUDERS];
  1614. float volumetric_extruder_limit[EXTRUDERS];
  1615. } storage;
  1616. _FIELD_TEST(parser_volumetric_enabled);
  1617. EEPROM_READ(storage);
  1618. #if DISABLED(NO_VOLUMETRICS)
  1619. if (!validating) {
  1620. parser.volumetric_enabled = storage.volumetric_enabled;
  1621. COPY(planner.filament_size, storage.filament_size);
  1622. #if ENABLED(VOLUMETRIC_EXTRUDER_LIMIT)
  1623. COPY(planner.volumetric_extruder_limit, storage.volumetric_extruder_limit);
  1624. #endif
  1625. }
  1626. #endif
  1627. }
  1628. //
  1629. // TMC Stepper Settings
  1630. //
  1631. if (!validating) reset_stepper_drivers();
  1632. // TMC Stepper Current
  1633. {
  1634. _FIELD_TEST(tmc_stepper_current);
  1635. tmc_stepper_current_t currents;
  1636. EEPROM_READ(currents);
  1637. #if HAS_TRINAMIC_CONFIG
  1638. #define SET_CURR(Q) stepper##Q.rms_current(currents.Q ? currents.Q : Q##_CURRENT)
  1639. if (!validating) {
  1640. #if AXIS_IS_TMC(X)
  1641. SET_CURR(X);
  1642. #endif
  1643. #if AXIS_IS_TMC(Y)
  1644. SET_CURR(Y);
  1645. #endif
  1646. #if AXIS_IS_TMC(Z)
  1647. SET_CURR(Z);
  1648. #endif
  1649. #if AXIS_IS_TMC(X2)
  1650. SET_CURR(X2);
  1651. #endif
  1652. #if AXIS_IS_TMC(Y2)
  1653. SET_CURR(Y2);
  1654. #endif
  1655. #if AXIS_IS_TMC(Z2)
  1656. SET_CURR(Z2);
  1657. #endif
  1658. #if AXIS_IS_TMC(Z3)
  1659. SET_CURR(Z3);
  1660. #endif
  1661. #if AXIS_IS_TMC(Z4)
  1662. SET_CURR(Z4);
  1663. #endif
  1664. #if AXIS_IS_TMC(E0)
  1665. SET_CURR(E0);
  1666. #endif
  1667. #if AXIS_IS_TMC(E1)
  1668. SET_CURR(E1);
  1669. #endif
  1670. #if AXIS_IS_TMC(E2)
  1671. SET_CURR(E2);
  1672. #endif
  1673. #if AXIS_IS_TMC(E3)
  1674. SET_CURR(E3);
  1675. #endif
  1676. #if AXIS_IS_TMC(E4)
  1677. SET_CURR(E4);
  1678. #endif
  1679. #if AXIS_IS_TMC(E5)
  1680. SET_CURR(E5);
  1681. #endif
  1682. #if AXIS_IS_TMC(E6)
  1683. SET_CURR(E6);
  1684. #endif
  1685. #if AXIS_IS_TMC(E7)
  1686. SET_CURR(E7);
  1687. #endif
  1688. }
  1689. #endif
  1690. }
  1691. // TMC Hybrid Threshold
  1692. {
  1693. tmc_hybrid_threshold_t tmc_hybrid_threshold;
  1694. _FIELD_TEST(tmc_hybrid_threshold);
  1695. EEPROM_READ(tmc_hybrid_threshold);
  1696. #if ENABLED(HYBRID_THRESHOLD)
  1697. if (!validating) {
  1698. #if AXIS_HAS_STEALTHCHOP(X)
  1699. stepperX.set_pwm_thrs(tmc_hybrid_threshold.X);
  1700. #endif
  1701. #if AXIS_HAS_STEALTHCHOP(Y)
  1702. stepperY.set_pwm_thrs(tmc_hybrid_threshold.Y);
  1703. #endif
  1704. #if AXIS_HAS_STEALTHCHOP(Z)
  1705. stepperZ.set_pwm_thrs(tmc_hybrid_threshold.Z);
  1706. #endif
  1707. #if AXIS_HAS_STEALTHCHOP(X2)
  1708. stepperX2.set_pwm_thrs(tmc_hybrid_threshold.X2);
  1709. #endif
  1710. #if AXIS_HAS_STEALTHCHOP(Y2)
  1711. stepperY2.set_pwm_thrs(tmc_hybrid_threshold.Y2);
  1712. #endif
  1713. #if AXIS_HAS_STEALTHCHOP(Z2)
  1714. stepperZ2.set_pwm_thrs(tmc_hybrid_threshold.Z2);
  1715. #endif
  1716. #if AXIS_HAS_STEALTHCHOP(Z3)
  1717. stepperZ3.set_pwm_thrs(tmc_hybrid_threshold.Z3);
  1718. #endif
  1719. #if AXIS_HAS_STEALTHCHOP(Z4)
  1720. stepperZ4.set_pwm_thrs(tmc_hybrid_threshold.Z4);
  1721. #endif
  1722. #if AXIS_HAS_STEALTHCHOP(E0)
  1723. stepperE0.set_pwm_thrs(tmc_hybrid_threshold.E0);
  1724. #endif
  1725. #if AXIS_HAS_STEALTHCHOP(E1)
  1726. stepperE1.set_pwm_thrs(tmc_hybrid_threshold.E1);
  1727. #endif
  1728. #if AXIS_HAS_STEALTHCHOP(E2)
  1729. stepperE2.set_pwm_thrs(tmc_hybrid_threshold.E2);
  1730. #endif
  1731. #if AXIS_HAS_STEALTHCHOP(E3)
  1732. stepperE3.set_pwm_thrs(tmc_hybrid_threshold.E3);
  1733. #endif
  1734. #if AXIS_HAS_STEALTHCHOP(E4)
  1735. stepperE4.set_pwm_thrs(tmc_hybrid_threshold.E4);
  1736. #endif
  1737. #if AXIS_HAS_STEALTHCHOP(E5)
  1738. stepperE5.set_pwm_thrs(tmc_hybrid_threshold.E5);
  1739. #endif
  1740. #if AXIS_HAS_STEALTHCHOP(E6)
  1741. stepperE6.set_pwm_thrs(tmc_hybrid_threshold.E6);
  1742. #endif
  1743. #if AXIS_HAS_STEALTHCHOP(E7)
  1744. stepperE7.set_pwm_thrs(tmc_hybrid_threshold.E7);
  1745. #endif
  1746. }
  1747. #endif
  1748. }
  1749. //
  1750. // TMC StallGuard threshold.
  1751. //
  1752. {
  1753. tmc_sgt_t tmc_sgt;
  1754. _FIELD_TEST(tmc_sgt);
  1755. EEPROM_READ(tmc_sgt);
  1756. #if USE_SENSORLESS
  1757. if (!validating) {
  1758. TERN_(X_SENSORLESS, stepperX.homing_threshold(tmc_sgt.X));
  1759. TERN_(X2_SENSORLESS, stepperX2.homing_threshold(tmc_sgt.X2));
  1760. TERN_(Y_SENSORLESS, stepperY.homing_threshold(tmc_sgt.Y));
  1761. TERN_(Y2_SENSORLESS, stepperY2.homing_threshold(tmc_sgt.Y2));
  1762. TERN_(Z_SENSORLESS, stepperZ.homing_threshold(tmc_sgt.Z));
  1763. TERN_(Z2_SENSORLESS, stepperZ2.homing_threshold(tmc_sgt.Z2));
  1764. TERN_(Z3_SENSORLESS, stepperZ3.homing_threshold(tmc_sgt.Z3));
  1765. TERN_(Z4_SENSORLESS, stepperZ4.homing_threshold(tmc_sgt.Z4));
  1766. }
  1767. #endif
  1768. }
  1769. // TMC stepping mode
  1770. {
  1771. _FIELD_TEST(tmc_stealth_enabled);
  1772. tmc_stealth_enabled_t tmc_stealth_enabled;
  1773. EEPROM_READ(tmc_stealth_enabled);
  1774. #if HAS_TRINAMIC_CONFIG
  1775. #define SET_STEPPING_MODE(ST) stepper##ST.stored.stealthChop_enabled = tmc_stealth_enabled.ST; stepper##ST.refresh_stepping_mode();
  1776. if (!validating) {
  1777. #if AXIS_HAS_STEALTHCHOP(X)
  1778. SET_STEPPING_MODE(X);
  1779. #endif
  1780. #if AXIS_HAS_STEALTHCHOP(Y)
  1781. SET_STEPPING_MODE(Y);
  1782. #endif
  1783. #if AXIS_HAS_STEALTHCHOP(Z)
  1784. SET_STEPPING_MODE(Z);
  1785. #endif
  1786. #if AXIS_HAS_STEALTHCHOP(X2)
  1787. SET_STEPPING_MODE(X2);
  1788. #endif
  1789. #if AXIS_HAS_STEALTHCHOP(Y2)
  1790. SET_STEPPING_MODE(Y2);
  1791. #endif
  1792. #if AXIS_HAS_STEALTHCHOP(Z2)
  1793. SET_STEPPING_MODE(Z2);
  1794. #endif
  1795. #if AXIS_HAS_STEALTHCHOP(Z3)
  1796. SET_STEPPING_MODE(Z3);
  1797. #endif
  1798. #if AXIS_HAS_STEALTHCHOP(Z4)
  1799. SET_STEPPING_MODE(Z4);
  1800. #endif
  1801. #if AXIS_HAS_STEALTHCHOP(E0)
  1802. SET_STEPPING_MODE(E0);
  1803. #endif
  1804. #if AXIS_HAS_STEALTHCHOP(E1)
  1805. SET_STEPPING_MODE(E1);
  1806. #endif
  1807. #if AXIS_HAS_STEALTHCHOP(E2)
  1808. SET_STEPPING_MODE(E2);
  1809. #endif
  1810. #if AXIS_HAS_STEALTHCHOP(E3)
  1811. SET_STEPPING_MODE(E3);
  1812. #endif
  1813. #if AXIS_HAS_STEALTHCHOP(E4)
  1814. SET_STEPPING_MODE(E4);
  1815. #endif
  1816. #if AXIS_HAS_STEALTHCHOP(E5)
  1817. SET_STEPPING_MODE(E5);
  1818. #endif
  1819. #if AXIS_HAS_STEALTHCHOP(E6)
  1820. SET_STEPPING_MODE(E6);
  1821. #endif
  1822. #if AXIS_HAS_STEALTHCHOP(E7)
  1823. SET_STEPPING_MODE(E7);
  1824. #endif
  1825. }
  1826. #endif
  1827. }
  1828. //
  1829. // Linear Advance
  1830. //
  1831. {
  1832. float extruder_advance_K[_MAX(EXTRUDERS, 1)];
  1833. _FIELD_TEST(planner_extruder_advance_K);
  1834. EEPROM_READ(extruder_advance_K);
  1835. #if ENABLED(LIN_ADVANCE)
  1836. if (!validating)
  1837. COPY(planner.extruder_advance_K, extruder_advance_K);
  1838. #endif
  1839. }
  1840. //
  1841. // Motor Current PWM
  1842. //
  1843. {
  1844. uint32_t motor_current_setting[3];
  1845. _FIELD_TEST(motor_current_setting);
  1846. EEPROM_READ(motor_current_setting);
  1847. #if HAS_MOTOR_CURRENT_PWM
  1848. if (!validating)
  1849. COPY(stepper.motor_current_setting, motor_current_setting);
  1850. #endif
  1851. }
  1852. //
  1853. // CNC Coordinate System
  1854. //
  1855. {
  1856. _FIELD_TEST(coordinate_system);
  1857. #if ENABLED(CNC_COORDINATE_SYSTEMS)
  1858. if (!validating) (void)gcode.select_coordinate_system(-1); // Go back to machine space
  1859. EEPROM_READ(gcode.coordinate_system);
  1860. #else
  1861. xyz_pos_t coordinate_system[MAX_COORDINATE_SYSTEMS];
  1862. EEPROM_READ(coordinate_system);
  1863. #endif
  1864. }
  1865. //
  1866. // Skew correction factors
  1867. //
  1868. {
  1869. skew_factor_t skew_factor;
  1870. _FIELD_TEST(planner_skew_factor);
  1871. EEPROM_READ(skew_factor);
  1872. #if ENABLED(SKEW_CORRECTION_GCODE)
  1873. if (!validating) {
  1874. planner.skew_factor.xy = skew_factor.xy;
  1875. #if ENABLED(SKEW_CORRECTION_FOR_Z)
  1876. planner.skew_factor.xz = skew_factor.xz;
  1877. planner.skew_factor.yz = skew_factor.yz;
  1878. #endif
  1879. }
  1880. #endif
  1881. }
  1882. //
  1883. // Advanced Pause filament load & unload lengths
  1884. //
  1885. #if EXTRUDERS
  1886. {
  1887. #if DISABLED(ADVANCED_PAUSE_FEATURE)
  1888. fil_change_settings_t fc_settings[EXTRUDERS];
  1889. #endif
  1890. _FIELD_TEST(fc_settings);
  1891. EEPROM_READ(fc_settings);
  1892. }
  1893. #endif
  1894. //
  1895. // Tool-change settings
  1896. //
  1897. #if HAS_MULTI_EXTRUDER
  1898. _FIELD_TEST(toolchange_settings);
  1899. EEPROM_READ(toolchange_settings);
  1900. #endif
  1901. //
  1902. // Backlash Compensation
  1903. //
  1904. {
  1905. #if ENABLED(BACKLASH_GCODE)
  1906. const xyz_float_t &backlash_distance_mm = backlash.distance_mm;
  1907. const uint8_t &backlash_correction = backlash.correction;
  1908. #else
  1909. float backlash_distance_mm[XYZ];
  1910. uint8_t backlash_correction;
  1911. #endif
  1912. #if ENABLED(BACKLASH_GCODE) && defined(BACKLASH_SMOOTHING_MM)
  1913. const float &backlash_smoothing_mm = backlash.smoothing_mm;
  1914. #else
  1915. float backlash_smoothing_mm;
  1916. #endif
  1917. _FIELD_TEST(backlash_distance_mm);
  1918. EEPROM_READ(backlash_distance_mm);
  1919. EEPROM_READ(backlash_correction);
  1920. EEPROM_READ(backlash_smoothing_mm);
  1921. }
  1922. //
  1923. // Extensible UI User Data
  1924. //
  1925. #if ENABLED(EXTENSIBLE_UI)
  1926. // This is a significant hardware change; don't reserve EEPROM space when not present
  1927. {
  1928. const char extui_data[ExtUI::eeprom_data_size] = { 0 };
  1929. _FIELD_TEST(extui_data);
  1930. EEPROM_READ(extui_data);
  1931. if (!validating) ExtUI::onLoadSettings(extui_data);
  1932. }
  1933. #endif
  1934. //
  1935. // Case Light Brightness
  1936. //
  1937. #if HAS_CASE_LIGHT_BRIGHTNESS
  1938. _FIELD_TEST(caselight_brightness);
  1939. EEPROM_READ(caselight.brightness);
  1940. #endif
  1941. //
  1942. // Password feature
  1943. //
  1944. #if ENABLED(PASSWORD_FEATURE)
  1945. _FIELD_TEST(password_is_set);
  1946. EEPROM_READ(password.is_set);
  1947. EEPROM_READ(password.value);
  1948. #endif
  1949. //
  1950. // TOUCH_SCREEN_CALIBRATION
  1951. //
  1952. #if ENABLED(TOUCH_SCREEN_CALIBRATION)
  1953. _FIELD_TEST(touch.calibration);
  1954. EEPROM_READ(touch.calibration);
  1955. #endif
  1956. eeprom_error = size_error(eeprom_index - (EEPROM_OFFSET));
  1957. if (eeprom_error) {
  1958. DEBUG_ECHO_START();
  1959. DEBUG_ECHOLNPAIR("Index: ", int(eeprom_index - (EEPROM_OFFSET)), " Size: ", datasize());
  1960. TERN(EEPROM_AUTO_INIT,,ui.eeprom_alert_index());
  1961. }
  1962. else if (working_crc != stored_crc) {
  1963. eeprom_error = true;
  1964. DEBUG_ERROR_START();
  1965. DEBUG_ECHOLNPAIR("EEPROM CRC mismatch - (stored) ", stored_crc, " != ", working_crc, " (calculated)!");
  1966. TERN(EEPROM_AUTO_INIT,,ui.eeprom_alert_crc());
  1967. }
  1968. else if (!validating) {
  1969. DEBUG_ECHO_START();
  1970. DEBUG_ECHO(version);
  1971. DEBUG_ECHOLNPAIR(" stored settings retrieved (", eeprom_index - (EEPROM_OFFSET), " bytes; crc ", (uint32_t)working_crc, ")");
  1972. }
  1973. if (!validating && !eeprom_error) postprocess();
  1974. #if ENABLED(AUTO_BED_LEVELING_UBL)
  1975. if (!validating) {
  1976. ubl.report_state();
  1977. if (!ubl.sanity_check()) {
  1978. SERIAL_EOL();
  1979. #if ENABLED(EEPROM_CHITCHAT)
  1980. ubl.echo_name();
  1981. DEBUG_ECHOLNPGM(" initialized.\n");
  1982. #endif
  1983. }
  1984. else {
  1985. eeprom_error = true;
  1986. #if ENABLED(EEPROM_CHITCHAT)
  1987. DEBUG_ECHOPGM("?Can't enable ");
  1988. ubl.echo_name();
  1989. DEBUG_ECHOLNPGM(".");
  1990. #endif
  1991. ubl.reset();
  1992. }
  1993. if (ubl.storage_slot >= 0) {
  1994. load_mesh(ubl.storage_slot);
  1995. DEBUG_ECHOLNPAIR("Mesh ", ubl.storage_slot, " loaded from storage.");
  1996. }
  1997. else {
  1998. ubl.reset();
  1999. DEBUG_ECHOLNPGM("UBL reset");
  2000. }
  2001. }
  2002. #endif
  2003. }
  2004. #if ENABLED(EEPROM_CHITCHAT) && DISABLED(DISABLE_M503)
  2005. // Report the EEPROM settings
  2006. if (!validating && (DISABLED(EEPROM_BOOT_SILENT) || IsRunning())) report();
  2007. #endif
  2008. EEPROM_FINISH();
  2009. return !eeprom_error;
  2010. }
  2011. #ifdef ARCHIM2_SPI_FLASH_EEPROM_BACKUP_SIZE
  2012. extern bool restoreEEPROM();
  2013. #endif
  2014. bool MarlinSettings::validate() {
  2015. validating = true;
  2016. #ifdef ARCHIM2_SPI_FLASH_EEPROM_BACKUP_SIZE
  2017. bool success = _load();
  2018. if (!success && restoreEEPROM()) {
  2019. SERIAL_ECHOLNPGM("Recovered backup EEPROM settings from SPI Flash");
  2020. success = _load();
  2021. }
  2022. #else
  2023. const bool success = _load();
  2024. #endif
  2025. validating = false;
  2026. return success;
  2027. }
  2028. bool MarlinSettings::load() {
  2029. if (validate()) {
  2030. const bool success = _load();
  2031. TERN_(EXTENSIBLE_UI, ExtUI::onConfigurationStoreRead(success));
  2032. return success;
  2033. }
  2034. reset();
  2035. #if ENABLED(EEPROM_AUTO_INIT)
  2036. (void)save();
  2037. SERIAL_ECHO_MSG("EEPROM Initialized");
  2038. #endif
  2039. return false;
  2040. }
  2041. #if ENABLED(AUTO_BED_LEVELING_UBL)
  2042. inline void ubl_invalid_slot(const int s) {
  2043. #if ENABLED(EEPROM_CHITCHAT)
  2044. DEBUG_ECHOLNPGM("?Invalid slot.");
  2045. DEBUG_ECHO(s);
  2046. DEBUG_ECHOLNPGM(" mesh slots available.");
  2047. #else
  2048. UNUSED(s);
  2049. #endif
  2050. }
  2051. const uint16_t MarlinSettings::meshes_end = persistentStore.capacity() - 129; // 128 (+1 because of the change to capacity rather than last valid address)
  2052. // is a placeholder for the size of the MAT; the MAT will always
  2053. // live at the very end of the eeprom
  2054. uint16_t MarlinSettings::meshes_start_index() {
  2055. return (datasize() + EEPROM_OFFSET + 32) & 0xFFF8; // Pad the end of configuration data so it can float up
  2056. // or down a little bit without disrupting the mesh data
  2057. }
  2058. uint16_t MarlinSettings::calc_num_meshes() {
  2059. return (meshes_end - meshes_start_index()) / sizeof(ubl.z_values);
  2060. }
  2061. int MarlinSettings::mesh_slot_offset(const int8_t slot) {
  2062. return meshes_end - (slot + 1) * sizeof(ubl.z_values);
  2063. }
  2064. void MarlinSettings::store_mesh(const int8_t slot) {
  2065. #if ENABLED(AUTO_BED_LEVELING_UBL)
  2066. const int16_t a = calc_num_meshes();
  2067. if (!WITHIN(slot, 0, a - 1)) {
  2068. ubl_invalid_slot(a);
  2069. DEBUG_ECHOLNPAIR("E2END=", persistentStore.capacity() - 1, " meshes_end=", meshes_end, " slot=", slot);
  2070. DEBUG_EOL();
  2071. return;
  2072. }
  2073. int pos = mesh_slot_offset(slot);
  2074. uint16_t crc = 0;
  2075. // Write crc to MAT along with other data, or just tack on to the beginning or end
  2076. persistentStore.access_start();
  2077. const bool status = persistentStore.write_data(pos, (uint8_t *)&ubl.z_values, sizeof(ubl.z_values), &crc);
  2078. persistentStore.access_finish();
  2079. if (status) SERIAL_ECHOLNPGM("?Unable to save mesh data.");
  2080. else DEBUG_ECHOLNPAIR("Mesh saved in slot ", slot);
  2081. #else
  2082. // Other mesh types
  2083. #endif
  2084. }
  2085. void MarlinSettings::load_mesh(const int8_t slot, void * const into/*=nullptr*/) {
  2086. #if ENABLED(AUTO_BED_LEVELING_UBL)
  2087. const int16_t a = settings.calc_num_meshes();
  2088. if (!WITHIN(slot, 0, a - 1)) {
  2089. ubl_invalid_slot(a);
  2090. return;
  2091. }
  2092. int pos = mesh_slot_offset(slot);
  2093. uint16_t crc = 0;
  2094. uint8_t * const dest = into ? (uint8_t*)into : (uint8_t*)&ubl.z_values;
  2095. persistentStore.access_start();
  2096. const uint16_t status = persistentStore.read_data(pos, dest, sizeof(ubl.z_values), &crc);
  2097. persistentStore.access_finish();
  2098. if (status) SERIAL_ECHOLNPGM("?Unable to load mesh data.");
  2099. else DEBUG_ECHOLNPAIR("Mesh loaded from slot ", slot);
  2100. EEPROM_FINISH();
  2101. #else
  2102. // Other mesh types
  2103. #endif
  2104. }
  2105. //void MarlinSettings::delete_mesh() { return; }
  2106. //void MarlinSettings::defrag_meshes() { return; }
  2107. #endif // AUTO_BED_LEVELING_UBL
  2108. #else // !EEPROM_SETTINGS
  2109. bool MarlinSettings::save() {
  2110. DEBUG_ERROR_MSG("EEPROM disabled");
  2111. return false;
  2112. }
  2113. #endif // !EEPROM_SETTINGS
  2114. /**
  2115. * M502 - Reset Configuration
  2116. */
  2117. void MarlinSettings::reset() {
  2118. LOOP_XYZE_N(i) {
  2119. planner.settings.max_acceleration_mm_per_s2[i] = pgm_read_dword(&_DMA[ALIM(i, _DMA)]);
  2120. planner.settings.axis_steps_per_mm[i] = pgm_read_float(&_DASU[ALIM(i, _DASU)]);
  2121. planner.settings.max_feedrate_mm_s[i] = pgm_read_float(&_DMF[ALIM(i, _DMF)]);
  2122. }
  2123. planner.settings.min_segment_time_us = DEFAULT_MINSEGMENTTIME;
  2124. planner.settings.acceleration = DEFAULT_ACCELERATION;
  2125. planner.settings.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
  2126. planner.settings.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
  2127. planner.settings.min_feedrate_mm_s = feedRate_t(DEFAULT_MINIMUMFEEDRATE);
  2128. planner.settings.min_travel_feedrate_mm_s = feedRate_t(DEFAULT_MINTRAVELFEEDRATE);
  2129. #if HAS_CLASSIC_JERK
  2130. #ifndef DEFAULT_XJERK
  2131. #define DEFAULT_XJERK 0
  2132. #endif
  2133. #ifndef DEFAULT_YJERK
  2134. #define DEFAULT_YJERK 0
  2135. #endif
  2136. #ifndef DEFAULT_ZJERK
  2137. #define DEFAULT_ZJERK 0
  2138. #endif
  2139. planner.max_jerk.set(DEFAULT_XJERK, DEFAULT_YJERK, DEFAULT_ZJERK);
  2140. TERN_(HAS_CLASSIC_E_JERK, planner.max_jerk.e = DEFAULT_EJERK;);
  2141. #endif
  2142. #if HAS_JUNCTION_DEVIATION
  2143. planner.junction_deviation_mm = float(JUNCTION_DEVIATION_MM);
  2144. #endif
  2145. #if HAS_SCARA_OFFSET
  2146. scara_home_offset.reset();
  2147. #elif HAS_HOME_OFFSET
  2148. home_offset.reset();
  2149. #endif
  2150. TERN_(HAS_HOTEND_OFFSET, reset_hotend_offsets());
  2151. //
  2152. // Filament Runout Sensor
  2153. //
  2154. #if HAS_FILAMENT_SENSOR
  2155. runout.enabled = FIL_RUNOUT_ENABLED_DEFAULT;
  2156. runout.reset();
  2157. TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, runout.set_runout_distance(FILAMENT_RUNOUT_DISTANCE_MM));
  2158. #endif
  2159. //
  2160. // Tool-change Settings
  2161. //
  2162. #if HAS_MULTI_EXTRUDER
  2163. #if ENABLED(TOOLCHANGE_FILAMENT_SWAP)
  2164. toolchange_settings.swap_length = TOOLCHANGE_FS_LENGTH;
  2165. toolchange_settings.extra_resume = TOOLCHANGE_FS_EXTRA_RESUME_LENGTH;
  2166. toolchange_settings.retract_speed = TOOLCHANGE_FS_RETRACT_SPEED;
  2167. toolchange_settings.unretract_speed = TOOLCHANGE_FS_UNRETRACT_SPEED;
  2168. toolchange_settings.extra_prime = TOOLCHANGE_FS_EXTRA_PRIME;
  2169. toolchange_settings.prime_speed = TOOLCHANGE_FS_PRIME_SPEED;
  2170. toolchange_settings.fan_speed = TOOLCHANGE_FS_FAN_SPEED;
  2171. toolchange_settings.fan_time = TOOLCHANGE_FS_FAN_TIME;
  2172. #endif
  2173. #if ENABLED(TOOLCHANGE_FS_PRIME_FIRST_USED)
  2174. enable_first_prime = false;
  2175. #endif
  2176. #if ENABLED(TOOLCHANGE_PARK)
  2177. constexpr xyz_pos_t tpxy = TOOLCHANGE_PARK_XY;
  2178. toolchange_settings.enable_park = true;
  2179. toolchange_settings.change_point = tpxy;
  2180. #endif
  2181. toolchange_settings.z_raise = TOOLCHANGE_ZRAISE;
  2182. #if ENABLED(TOOLCHANGE_MIGRATION_FEATURE)
  2183. migration = migration_defaults;
  2184. #endif
  2185. #endif
  2186. #if ENABLED(BACKLASH_GCODE)
  2187. backlash.correction = (BACKLASH_CORRECTION) * 255;
  2188. constexpr xyz_float_t tmp = BACKLASH_DISTANCE_MM;
  2189. backlash.distance_mm = tmp;
  2190. #ifdef BACKLASH_SMOOTHING_MM
  2191. backlash.smoothing_mm = BACKLASH_SMOOTHING_MM;
  2192. #endif
  2193. #endif
  2194. TERN_(EXTENSIBLE_UI, ExtUI::onFactoryReset());
  2195. //
  2196. // Case Light Brightness
  2197. //
  2198. TERN_(HAS_CASE_LIGHT_BRIGHTNESS, caselight.brightness = CASE_LIGHT_DEFAULT_BRIGHTNESS);
  2199. //
  2200. // TOUCH_SCREEN_CALIBRATION
  2201. //
  2202. TERN_(TOUCH_SCREEN_CALIBRATION, touch.calibration_reset());
  2203. //
  2204. // Magnetic Parking Extruder
  2205. //
  2206. TERN_(MAGNETIC_PARKING_EXTRUDER, mpe_settings_init());
  2207. //
  2208. // Global Leveling
  2209. //
  2210. TERN_(ENABLE_LEVELING_FADE_HEIGHT, new_z_fade_height = 0.0);
  2211. TERN_(HAS_LEVELING, reset_bed_level());
  2212. #if HAS_BED_PROBE
  2213. constexpr float dpo[] = NOZZLE_TO_PROBE_OFFSET;
  2214. static_assert(COUNT(dpo) == 3, "NOZZLE_TO_PROBE_OFFSET must contain offsets for X, Y, and Z.");
  2215. #if HAS_PROBE_XY_OFFSET
  2216. LOOP_XYZ(a) probe.offset[a] = dpo[a];
  2217. #else
  2218. probe.offset.set(0, 0, dpo[Z_AXIS]);
  2219. #endif
  2220. #endif
  2221. //
  2222. // Z Stepper Auto-alignment points
  2223. //
  2224. TERN_(Z_STEPPER_AUTO_ALIGN, z_stepper_align.reset_to_default());
  2225. //
  2226. // Servo Angles
  2227. //
  2228. TERN_(EDITABLE_SERVO_ANGLES, COPY(servo_angles, base_servo_angles)); // When not editable only one copy of servo angles exists
  2229. //
  2230. // BLTOUCH
  2231. //
  2232. //#if ENABLED(BLTOUCH)
  2233. // bltouch.last_written_mode;
  2234. //#endif
  2235. //
  2236. // Endstop Adjustments
  2237. //
  2238. #if ENABLED(DELTA)
  2239. const abc_float_t adj = DELTA_ENDSTOP_ADJ, dta = DELTA_TOWER_ANGLE_TRIM, ddr = DELTA_DIAGONAL_ROD_TRIM_TOWER;
  2240. delta_height = DELTA_HEIGHT;
  2241. delta_endstop_adj = adj;
  2242. delta_radius = DELTA_RADIUS;
  2243. delta_diagonal_rod = DELTA_DIAGONAL_ROD;
  2244. delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;
  2245. delta_tower_angle_trim = dta;
  2246. delta_diagonal_rod_trim = ddr;
  2247. #endif
  2248. #if ENABLED(X_DUAL_ENDSTOPS)
  2249. #ifndef X2_ENDSTOP_ADJUSTMENT
  2250. #define X2_ENDSTOP_ADJUSTMENT 0
  2251. #endif
  2252. endstops.x2_endstop_adj = X2_ENDSTOP_ADJUSTMENT;
  2253. #endif
  2254. #if ENABLED(Y_DUAL_ENDSTOPS)
  2255. #ifndef Y2_ENDSTOP_ADJUSTMENT
  2256. #define Y2_ENDSTOP_ADJUSTMENT 0
  2257. #endif
  2258. endstops.y2_endstop_adj = Y2_ENDSTOP_ADJUSTMENT;
  2259. #endif
  2260. #if ENABLED(Z_MULTI_ENDSTOPS)
  2261. #ifndef Z2_ENDSTOP_ADJUSTMENT
  2262. #define Z2_ENDSTOP_ADJUSTMENT 0
  2263. #endif
  2264. endstops.z2_endstop_adj = Z2_ENDSTOP_ADJUSTMENT;
  2265. #if NUM_Z_STEPPER_DRIVERS >= 3
  2266. #ifndef Z3_ENDSTOP_ADJUSTMENT
  2267. #define Z3_ENDSTOP_ADJUSTMENT 0
  2268. #endif
  2269. endstops.z3_endstop_adj = Z3_ENDSTOP_ADJUSTMENT;
  2270. #endif
  2271. #if NUM_Z_STEPPER_DRIVERS >= 4
  2272. #ifndef Z4_ENDSTOP_ADJUSTMENT
  2273. #define Z4_ENDSTOP_ADJUSTMENT 0
  2274. #endif
  2275. endstops.z4_endstop_adj = Z4_ENDSTOP_ADJUSTMENT;
  2276. #endif
  2277. #endif
  2278. //
  2279. // Preheat parameters
  2280. //
  2281. #if PREHEAT_COUNT
  2282. #if HAS_HOTEND
  2283. constexpr uint16_t hpre[] = ARRAY_N(PREHEAT_COUNT, PREHEAT_1_TEMP_HOTEND, PREHEAT_2_TEMP_HOTEND, PREHEAT_3_TEMP_HOTEND, PREHEAT_4_TEMP_HOTEND, PREHEAT_5_TEMP_HOTEND);
  2284. #endif
  2285. #if HAS_HEATED_BED
  2286. constexpr uint16_t bpre[] = ARRAY_N(PREHEAT_COUNT, PREHEAT_1_TEMP_BED, PREHEAT_2_TEMP_BED, PREHEAT_3_TEMP_BED, PREHEAT_4_TEMP_BED, PREHEAT_5_TEMP_BED);
  2287. #endif
  2288. #if HAS_FAN
  2289. constexpr uint8_t fpre[] = ARRAY_N(PREHEAT_COUNT, PREHEAT_1_FAN_SPEED, PREHEAT_2_FAN_SPEED, PREHEAT_3_FAN_SPEED, PREHEAT_4_FAN_SPEED, PREHEAT_5_FAN_SPEED);
  2290. #endif
  2291. LOOP_L_N(i, PREHEAT_COUNT) {
  2292. #if HAS_HOTEND
  2293. ui.material_preset[i].hotend_temp = hpre[i];
  2294. #endif
  2295. #if HAS_HEATED_BED
  2296. ui.material_preset[i].bed_temp = bpre[i];
  2297. #endif
  2298. #if HAS_FAN
  2299. ui.material_preset[i].fan_speed = fpre[i];
  2300. #endif
  2301. }
  2302. #endif
  2303. //
  2304. // Hotend PID
  2305. //
  2306. #if ENABLED(PIDTEMP)
  2307. #if ENABLED(PID_PARAMS_PER_HOTEND)
  2308. constexpr float defKp[] =
  2309. #ifdef DEFAULT_Kp_LIST
  2310. DEFAULT_Kp_LIST
  2311. #else
  2312. ARRAY_BY_HOTENDS1(DEFAULT_Kp)
  2313. #endif
  2314. , defKi[] =
  2315. #ifdef DEFAULT_Ki_LIST
  2316. DEFAULT_Ki_LIST
  2317. #else
  2318. ARRAY_BY_HOTENDS1(DEFAULT_Ki)
  2319. #endif
  2320. , defKd[] =
  2321. #ifdef DEFAULT_Kd_LIST
  2322. DEFAULT_Kd_LIST
  2323. #else
  2324. ARRAY_BY_HOTENDS1(DEFAULT_Kd)
  2325. #endif
  2326. ;
  2327. static_assert(WITHIN(COUNT(defKp), 1, HOTENDS), "DEFAULT_Kp_LIST must have between 1 and HOTENDS items.");
  2328. static_assert(WITHIN(COUNT(defKi), 1, HOTENDS), "DEFAULT_Ki_LIST must have between 1 and HOTENDS items.");
  2329. static_assert(WITHIN(COUNT(defKd), 1, HOTENDS), "DEFAULT_Kd_LIST must have between 1 and HOTENDS items.");
  2330. #if ENABLED(PID_EXTRUSION_SCALING)
  2331. constexpr float defKc[] =
  2332. #ifdef DEFAULT_Kc_LIST
  2333. DEFAULT_Kc_LIST
  2334. #else
  2335. ARRAY_BY_HOTENDS1(DEFAULT_Kc)
  2336. #endif
  2337. ;
  2338. static_assert(WITHIN(COUNT(defKc), 1, HOTENDS), "DEFAULT_Kc_LIST must have between 1 and HOTENDS items.");
  2339. #endif
  2340. #if ENABLED(PID_FAN_SCALING)
  2341. constexpr float defKf[] =
  2342. #ifdef DEFAULT_Kf_LIST
  2343. DEFAULT_Kf_LIST
  2344. #else
  2345. ARRAY_BY_HOTENDS1(DEFAULT_Kf)
  2346. #endif
  2347. ;
  2348. static_assert(WITHIN(COUNT(defKf), 1, HOTENDS), "DEFAULT_Kf_LIST must have between 1 and HOTENDS items.");
  2349. #endif
  2350. #define PID_DEFAULT(N,E) def##N[E]
  2351. #else
  2352. #define PID_DEFAULT(N,E) DEFAULT_##N
  2353. #endif
  2354. HOTEND_LOOP() {
  2355. PID_PARAM(Kp, e) = float(PID_DEFAULT(Kp, ALIM(e, defKp)));
  2356. PID_PARAM(Ki, e) = scalePID_i(PID_DEFAULT(Ki, ALIM(e, defKi)));
  2357. PID_PARAM(Kd, e) = scalePID_d(PID_DEFAULT(Kd, ALIM(e, defKd)));
  2358. TERN_(PID_EXTRUSION_SCALING, PID_PARAM(Kc, e) = float(PID_DEFAULT(Kc, ALIM(e, defKc))));
  2359. TERN_(PID_FAN_SCALING, PID_PARAM(Kf, e) = float(PID_DEFAULT(Kf, ALIM(e, defKf))));
  2360. }
  2361. #endif
  2362. //
  2363. // PID Extrusion Scaling
  2364. //
  2365. TERN_(PID_EXTRUSION_SCALING, thermalManager.lpq_len = 20); // Default last-position-queue size
  2366. //
  2367. // Heated Bed PID
  2368. //
  2369. #if ENABLED(PIDTEMPBED)
  2370. thermalManager.temp_bed.pid.Kp = DEFAULT_bedKp;
  2371. thermalManager.temp_bed.pid.Ki = scalePID_i(DEFAULT_bedKi);
  2372. thermalManager.temp_bed.pid.Kd = scalePID_d(DEFAULT_bedKd);
  2373. #endif
  2374. //
  2375. // User-Defined Thermistors
  2376. //
  2377. TERN_(HAS_USER_THERMISTORS, thermalManager.reset_user_thermistors());
  2378. //
  2379. // Power Monitor
  2380. //
  2381. TERN_(POWER_MONITOR, power_monitor.reset());
  2382. //
  2383. // LCD Contrast
  2384. //
  2385. TERN_(HAS_LCD_CONTRAST, ui.set_contrast(DEFAULT_LCD_CONTRAST));
  2386. //
  2387. // Controller Fan
  2388. //
  2389. TERN_(USE_CONTROLLER_FAN, controllerFan.reset());
  2390. //
  2391. // Power-Loss Recovery
  2392. //
  2393. TERN_(POWER_LOSS_RECOVERY, recovery.enable(ENABLED(PLR_ENABLED_DEFAULT)));
  2394. //
  2395. // Firmware Retraction
  2396. //
  2397. TERN_(FWRETRACT, fwretract.reset());
  2398. //
  2399. // Volumetric & Filament Size
  2400. //
  2401. #if DISABLED(NO_VOLUMETRICS)
  2402. parser.volumetric_enabled = ENABLED(VOLUMETRIC_DEFAULT_ON);
  2403. LOOP_L_N(q, COUNT(planner.filament_size))
  2404. planner.filament_size[q] = DEFAULT_NOMINAL_FILAMENT_DIA;
  2405. #if ENABLED(VOLUMETRIC_EXTRUDER_LIMIT)
  2406. LOOP_L_N(q, COUNT(planner.volumetric_extruder_limit))
  2407. planner.volumetric_extruder_limit[q] = DEFAULT_VOLUMETRIC_EXTRUDER_LIMIT;
  2408. #endif
  2409. #endif
  2410. endstops.enable_globally(ENABLED(ENDSTOPS_ALWAYS_ON_DEFAULT));
  2411. reset_stepper_drivers();
  2412. //
  2413. // Linear Advance
  2414. //
  2415. #if ENABLED(LIN_ADVANCE)
  2416. LOOP_L_N(i, EXTRUDERS) {
  2417. planner.extruder_advance_K[i] = LIN_ADVANCE_K;
  2418. TERN_(EXTRA_LIN_ADVANCE_K, other_extruder_advance_K[i] = LIN_ADVANCE_K);
  2419. }
  2420. #endif
  2421. //
  2422. // Motor Current PWM
  2423. //
  2424. #if HAS_MOTOR_CURRENT_PWM
  2425. constexpr uint32_t tmp_motor_current_setting[3] = PWM_MOTOR_CURRENT;
  2426. LOOP_L_N(q, 3)
  2427. stepper.digipot_current(q, (stepper.motor_current_setting[q] = tmp_motor_current_setting[q]));
  2428. #endif
  2429. //
  2430. // CNC Coordinate System
  2431. //
  2432. TERN_(CNC_COORDINATE_SYSTEMS, (void)gcode.select_coordinate_system(-1)); // Go back to machine space
  2433. //
  2434. // Skew Correction
  2435. //
  2436. #if ENABLED(SKEW_CORRECTION_GCODE)
  2437. planner.skew_factor.xy = XY_SKEW_FACTOR;
  2438. #if ENABLED(SKEW_CORRECTION_FOR_Z)
  2439. planner.skew_factor.xz = XZ_SKEW_FACTOR;
  2440. planner.skew_factor.yz = YZ_SKEW_FACTOR;
  2441. #endif
  2442. #endif
  2443. //
  2444. // Advanced Pause filament load & unload lengths
  2445. //
  2446. #if ENABLED(ADVANCED_PAUSE_FEATURE)
  2447. LOOP_L_N(e, EXTRUDERS) {
  2448. fc_settings[e].unload_length = FILAMENT_CHANGE_UNLOAD_LENGTH;
  2449. fc_settings[e].load_length = FILAMENT_CHANGE_FAST_LOAD_LENGTH;
  2450. }
  2451. #endif
  2452. #if ENABLED(PASSWORD_FEATURE)
  2453. #ifdef PASSWORD_DEFAULT_VALUE
  2454. password.is_set = true;
  2455. password.value = PASSWORD_DEFAULT_VALUE;
  2456. #else
  2457. password.is_set = false;
  2458. #endif
  2459. #endif
  2460. postprocess();
  2461. DEBUG_ECHO_START();
  2462. DEBUG_ECHOLNPGM("Hardcoded Default Settings Loaded");
  2463. TERN_(EXTENSIBLE_UI, ExtUI::onFactoryReset());
  2464. }
  2465. #if DISABLED(DISABLE_M503)
  2466. static void config_heading(const bool repl, PGM_P const pstr, const bool eol=true) {
  2467. if (!repl) {
  2468. SERIAL_ECHO_START();
  2469. SERIAL_ECHOPGM("; ");
  2470. serialprintPGM(pstr);
  2471. if (eol) SERIAL_EOL();
  2472. }
  2473. }
  2474. #define CONFIG_ECHO_START() do{ if (!forReplay) SERIAL_ECHO_START(); }while(0)
  2475. #define CONFIG_ECHO_MSG(STR) do{ CONFIG_ECHO_START(); SERIAL_ECHOLNPGM(STR); }while(0)
  2476. #define CONFIG_ECHO_HEADING(STR) config_heading(forReplay, PSTR(STR))
  2477. #if HAS_TRINAMIC_CONFIG
  2478. inline void say_M906(const bool forReplay) { CONFIG_ECHO_START(); SERIAL_ECHOPGM(" M906"); }
  2479. #if HAS_STEALTHCHOP
  2480. void say_M569(const bool forReplay, const char * const etc=nullptr, const bool newLine = false) {
  2481. CONFIG_ECHO_START();
  2482. SERIAL_ECHOPGM(" M569 S1");
  2483. if (etc) {
  2484. SERIAL_CHAR(' ');
  2485. serialprintPGM(etc);
  2486. }
  2487. if (newLine) SERIAL_EOL();
  2488. }
  2489. #endif
  2490. #if ENABLED(HYBRID_THRESHOLD)
  2491. inline void say_M913(const bool forReplay) { CONFIG_ECHO_START(); SERIAL_ECHOPGM(" M913"); }
  2492. #endif
  2493. #if USE_SENSORLESS
  2494. inline void say_M914() { SERIAL_ECHOPGM(" M914"); }
  2495. #endif
  2496. #endif
  2497. #if ENABLED(ADVANCED_PAUSE_FEATURE)
  2498. inline void say_M603(const bool forReplay) { CONFIG_ECHO_START(); SERIAL_ECHOPGM(" M603 "); }
  2499. #endif
  2500. inline void say_units(const bool colon) {
  2501. serialprintPGM(
  2502. #if ENABLED(INCH_MODE_SUPPORT)
  2503. parser.linear_unit_factor != 1.0 ? PSTR(" (in)") :
  2504. #endif
  2505. PSTR(" (mm)")
  2506. );
  2507. if (colon) SERIAL_ECHOLNPGM(":");
  2508. }
  2509. void report_M92(const bool echo=true, const int8_t e=-1);
  2510. /**
  2511. * M503 - Report current settings in RAM
  2512. *
  2513. * Unless specifically disabled, M503 is available even without EEPROM
  2514. */
  2515. void MarlinSettings::report(const bool forReplay) {
  2516. /**
  2517. * Announce current units, in case inches are being displayed
  2518. */
  2519. CONFIG_ECHO_START();
  2520. #if ENABLED(INCH_MODE_SUPPORT)
  2521. SERIAL_ECHOPGM(" G2");
  2522. SERIAL_CHAR(parser.linear_unit_factor == 1.0 ? '1' : '0');
  2523. SERIAL_ECHOPGM(" ;");
  2524. say_units(false);
  2525. #else
  2526. SERIAL_ECHOPGM(" G21 ; Units in mm");
  2527. say_units(false);
  2528. #endif
  2529. SERIAL_EOL();
  2530. #if HAS_LCD_MENU
  2531. // Temperature units - for Ultipanel temperature options
  2532. CONFIG_ECHO_START();
  2533. #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
  2534. SERIAL_ECHOPGM(" M149 ");
  2535. SERIAL_CHAR(parser.temp_units_code());
  2536. SERIAL_ECHOPGM(" ; Units in ");
  2537. serialprintPGM(parser.temp_units_name());
  2538. #else
  2539. SERIAL_ECHOLNPGM(" M149 C ; Units in Celsius");
  2540. #endif
  2541. #endif
  2542. SERIAL_EOL();
  2543. #if EXTRUDERS && DISABLED(NO_VOLUMETRICS)
  2544. /**
  2545. * Volumetric extrusion M200
  2546. */
  2547. if (!forReplay) {
  2548. config_heading(forReplay, PSTR("Filament settings:"), false);
  2549. if (parser.volumetric_enabled)
  2550. SERIAL_EOL();
  2551. else
  2552. SERIAL_ECHOLNPGM(" Disabled");
  2553. }
  2554. #if EXTRUDERS == 1
  2555. CONFIG_ECHO_START();
  2556. SERIAL_ECHOLNPAIR(" M200 S", int(parser.volumetric_enabled)
  2557. , " D", LINEAR_UNIT(planner.filament_size[0])
  2558. #if ENABLED(VOLUMETRIC_EXTRUDER_LIMIT)
  2559. , " L", LINEAR_UNIT(planner.volumetric_extruder_limit[0])
  2560. #endif
  2561. );
  2562. #else
  2563. LOOP_L_N(i, EXTRUDERS) {
  2564. CONFIG_ECHO_START();
  2565. SERIAL_ECHOLNPAIR(" M200 T", int(i)
  2566. , " D", LINEAR_UNIT(planner.filament_size[i])
  2567. #if ENABLED(VOLUMETRIC_EXTRUDER_LIMIT)
  2568. , " L", LINEAR_UNIT(planner.volumetric_extruder_limit[i])
  2569. #endif
  2570. );
  2571. }
  2572. CONFIG_ECHO_START();
  2573. SERIAL_ECHOLNPAIR(" M200 S", int(parser.volumetric_enabled));
  2574. #endif
  2575. #endif // EXTRUDERS && !NO_VOLUMETRICS
  2576. CONFIG_ECHO_HEADING("Steps per unit:");
  2577. report_M92(!forReplay);
  2578. CONFIG_ECHO_HEADING("Maximum feedrates (units/s):");
  2579. CONFIG_ECHO_START();
  2580. SERIAL_ECHOLNPAIR_P(
  2581. PSTR(" M203 X"), LINEAR_UNIT(planner.settings.max_feedrate_mm_s[X_AXIS])
  2582. , SP_Y_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[Y_AXIS])
  2583. , SP_Z_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[Z_AXIS])
  2584. #if DISABLED(DISTINCT_E_FACTORS)
  2585. , SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_feedrate_mm_s[E_AXIS])
  2586. #endif
  2587. );
  2588. #if ENABLED(DISTINCT_E_FACTORS)
  2589. LOOP_L_N(i, E_STEPPERS) {
  2590. CONFIG_ECHO_START();
  2591. SERIAL_ECHOLNPAIR_P(
  2592. PSTR(" M203 T"), (int)i
  2593. , SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_feedrate_mm_s[E_AXIS_N(i)])
  2594. );
  2595. }
  2596. #endif
  2597. CONFIG_ECHO_HEADING("Maximum Acceleration (units/s2):");
  2598. CONFIG_ECHO_START();
  2599. SERIAL_ECHOLNPAIR_P(
  2600. PSTR(" M201 X"), LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[X_AXIS])
  2601. , SP_Y_STR, LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[Y_AXIS])
  2602. , SP_Z_STR, LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[Z_AXIS])
  2603. #if DISABLED(DISTINCT_E_FACTORS)
  2604. , SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_acceleration_mm_per_s2[E_AXIS])
  2605. #endif
  2606. );
  2607. #if ENABLED(DISTINCT_E_FACTORS)
  2608. LOOP_L_N(i, E_STEPPERS) {
  2609. CONFIG_ECHO_START();
  2610. SERIAL_ECHOLNPAIR_P(
  2611. PSTR(" M201 T"), (int)i
  2612. , SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(i)])
  2613. );
  2614. }
  2615. #endif
  2616. CONFIG_ECHO_HEADING("Acceleration (units/s2): P<print_accel> R<retract_accel> T<travel_accel>");
  2617. CONFIG_ECHO_START();
  2618. SERIAL_ECHOLNPAIR_P(
  2619. PSTR(" M204 P"), LINEAR_UNIT(planner.settings.acceleration)
  2620. , PSTR(" R"), LINEAR_UNIT(planner.settings.retract_acceleration)
  2621. , SP_T_STR, LINEAR_UNIT(planner.settings.travel_acceleration)
  2622. );
  2623. CONFIG_ECHO_HEADING(
  2624. "Advanced: B<min_segment_time_us> S<min_feedrate> T<min_travel_feedrate>"
  2625. #if HAS_JUNCTION_DEVIATION
  2626. " J<junc_dev>"
  2627. #endif
  2628. #if HAS_CLASSIC_JERK
  2629. " X<max_x_jerk> Y<max_y_jerk> Z<max_z_jerk>"
  2630. TERN_(HAS_CLASSIC_E_JERK, " E<max_e_jerk>")
  2631. #endif
  2632. );
  2633. CONFIG_ECHO_START();
  2634. SERIAL_ECHOLNPAIR_P(
  2635. PSTR(" M205 B"), LINEAR_UNIT(planner.settings.min_segment_time_us)
  2636. , PSTR(" S"), LINEAR_UNIT(planner.settings.min_feedrate_mm_s)
  2637. , SP_T_STR, LINEAR_UNIT(planner.settings.min_travel_feedrate_mm_s)
  2638. #if HAS_JUNCTION_DEVIATION
  2639. , PSTR(" J"), LINEAR_UNIT(planner.junction_deviation_mm)
  2640. #endif
  2641. #if HAS_CLASSIC_JERK
  2642. , SP_X_STR, LINEAR_UNIT(planner.max_jerk.x)
  2643. , SP_Y_STR, LINEAR_UNIT(planner.max_jerk.y)
  2644. , SP_Z_STR, LINEAR_UNIT(planner.max_jerk.z)
  2645. #if HAS_CLASSIC_E_JERK
  2646. , SP_E_STR, LINEAR_UNIT(planner.max_jerk.e)
  2647. #endif
  2648. #endif
  2649. );
  2650. #if HAS_M206_COMMAND
  2651. CONFIG_ECHO_HEADING("Home offset:");
  2652. CONFIG_ECHO_START();
  2653. SERIAL_ECHOLNPAIR_P(
  2654. #if IS_CARTESIAN
  2655. PSTR(" M206 X"), LINEAR_UNIT(home_offset.x)
  2656. , SP_Y_STR, LINEAR_UNIT(home_offset.y)
  2657. , SP_Z_STR
  2658. #else
  2659. PSTR(" M206 Z")
  2660. #endif
  2661. , LINEAR_UNIT(home_offset.z)
  2662. );
  2663. #endif
  2664. #if HAS_HOTEND_OFFSET
  2665. CONFIG_ECHO_HEADING("Hotend offsets:");
  2666. CONFIG_ECHO_START();
  2667. LOOP_S_L_N(e, 1, HOTENDS) {
  2668. SERIAL_ECHOPAIR_P(
  2669. PSTR(" M218 T"), (int)e,
  2670. SP_X_STR, LINEAR_UNIT(hotend_offset[e].x),
  2671. SP_Y_STR, LINEAR_UNIT(hotend_offset[e].y)
  2672. );
  2673. SERIAL_ECHOLNPAIR_F_P(SP_Z_STR, LINEAR_UNIT(hotend_offset[e].z), 3);
  2674. }
  2675. #endif
  2676. /**
  2677. * Bed Leveling
  2678. */
  2679. #if HAS_LEVELING
  2680. #if ENABLED(MESH_BED_LEVELING)
  2681. CONFIG_ECHO_HEADING("Mesh Bed Leveling:");
  2682. #elif ENABLED(AUTO_BED_LEVELING_UBL)
  2683. config_heading(forReplay, PSTR(""), false);
  2684. if (!forReplay) {
  2685. ubl.echo_name();
  2686. SERIAL_CHAR(':');
  2687. SERIAL_EOL();
  2688. }
  2689. #elif HAS_ABL_OR_UBL
  2690. CONFIG_ECHO_HEADING("Auto Bed Leveling:");
  2691. #endif
  2692. CONFIG_ECHO_START();
  2693. SERIAL_ECHOLNPAIR_P(
  2694. PSTR(" M420 S"), planner.leveling_active ? 1 : 0
  2695. #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
  2696. , SP_Z_STR, LINEAR_UNIT(planner.z_fade_height)
  2697. #endif
  2698. );
  2699. #if ENABLED(MESH_BED_LEVELING)
  2700. if (leveling_is_valid()) {
  2701. LOOP_L_N(py, GRID_MAX_POINTS_Y) {
  2702. LOOP_L_N(px, GRID_MAX_POINTS_X) {
  2703. CONFIG_ECHO_START();
  2704. SERIAL_ECHOPAIR_P(PSTR(" G29 S3 I"), (int)px, PSTR(" J"), (int)py);
  2705. SERIAL_ECHOLNPAIR_F_P(SP_Z_STR, LINEAR_UNIT(mbl.z_values[px][py]), 5);
  2706. }
  2707. }
  2708. CONFIG_ECHO_START();
  2709. SERIAL_ECHOLNPAIR_F_P(PSTR(" G29 S4 Z"), LINEAR_UNIT(mbl.z_offset), 5);
  2710. }
  2711. #elif ENABLED(AUTO_BED_LEVELING_UBL)
  2712. if (!forReplay) {
  2713. SERIAL_EOL();
  2714. ubl.report_state();
  2715. SERIAL_EOL();
  2716. config_heading(false, PSTR("Active Mesh Slot: "), false);
  2717. SERIAL_ECHOLN(ubl.storage_slot);
  2718. config_heading(false, PSTR("EEPROM can hold "), false);
  2719. SERIAL_ECHO(calc_num_meshes());
  2720. SERIAL_ECHOLNPGM(" meshes.\n");
  2721. }
  2722. //ubl.report_current_mesh(); // This is too verbose for large meshes. A better (more terse)
  2723. // solution needs to be found.
  2724. #elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
  2725. if (leveling_is_valid()) {
  2726. LOOP_L_N(py, GRID_MAX_POINTS_Y) {
  2727. LOOP_L_N(px, GRID_MAX_POINTS_X) {
  2728. CONFIG_ECHO_START();
  2729. SERIAL_ECHOPAIR(" G29 W I", (int)px, " J", (int)py);
  2730. SERIAL_ECHOLNPAIR_F_P(SP_Z_STR, LINEAR_UNIT(z_values[px][py]), 5);
  2731. }
  2732. }
  2733. }
  2734. #endif
  2735. #endif // HAS_LEVELING
  2736. #if ENABLED(EDITABLE_SERVO_ANGLES)
  2737. CONFIG_ECHO_HEADING("Servo Angles:");
  2738. LOOP_L_N(i, NUM_SERVOS) {
  2739. switch (i) {
  2740. #if ENABLED(SWITCHING_EXTRUDER)
  2741. case SWITCHING_EXTRUDER_SERVO_NR:
  2742. #if EXTRUDERS > 3
  2743. case SWITCHING_EXTRUDER_E23_SERVO_NR:
  2744. #endif
  2745. #elif ENABLED(SWITCHING_NOZZLE)
  2746. case SWITCHING_NOZZLE_SERVO_NR:
  2747. #elif ENABLED(BLTOUCH) || (HAS_Z_SERVO_PROBE && defined(Z_SERVO_ANGLES))
  2748. case Z_PROBE_SERVO_NR:
  2749. #endif
  2750. CONFIG_ECHO_START();
  2751. SERIAL_ECHOLNPAIR(" M281 P", int(i), " L", servo_angles[i][0], " U", servo_angles[i][1]);
  2752. default: break;
  2753. }
  2754. }
  2755. #endif // EDITABLE_SERVO_ANGLES
  2756. #if HAS_SCARA_OFFSET
  2757. CONFIG_ECHO_HEADING("SCARA settings: S<seg-per-sec> P<theta-psi-offset> T<theta-offset>");
  2758. CONFIG_ECHO_START();
  2759. SERIAL_ECHOLNPAIR_P(
  2760. PSTR(" M665 S"), delta_segments_per_second
  2761. , SP_P_STR, scara_home_offset.a
  2762. , SP_T_STR, scara_home_offset.b
  2763. , SP_Z_STR, LINEAR_UNIT(scara_home_offset.z)
  2764. );
  2765. #elif ENABLED(DELTA)
  2766. CONFIG_ECHO_HEADING("Endstop adjustment:");
  2767. CONFIG_ECHO_START();
  2768. SERIAL_ECHOLNPAIR_P(
  2769. PSTR(" M666 X"), LINEAR_UNIT(delta_endstop_adj.a)
  2770. , SP_Y_STR, LINEAR_UNIT(delta_endstop_adj.b)
  2771. , SP_Z_STR, LINEAR_UNIT(delta_endstop_adj.c)
  2772. );
  2773. CONFIG_ECHO_HEADING("Delta settings: L<diagonal rod> R<radius> H<height> S<segments per sec> XYZ<tower angle trim> ABC<rod trim>");
  2774. CONFIG_ECHO_START();
  2775. SERIAL_ECHOLNPAIR_P(
  2776. PSTR(" M665 L"), LINEAR_UNIT(delta_diagonal_rod)
  2777. , PSTR(" R"), LINEAR_UNIT(delta_radius)
  2778. , PSTR(" H"), LINEAR_UNIT(delta_height)
  2779. , PSTR(" S"), delta_segments_per_second
  2780. , SP_X_STR, LINEAR_UNIT(delta_tower_angle_trim.a)
  2781. , SP_Y_STR, LINEAR_UNIT(delta_tower_angle_trim.b)
  2782. , SP_Z_STR, LINEAR_UNIT(delta_tower_angle_trim.c)
  2783. , PSTR(" A"), LINEAR_UNIT(delta_diagonal_rod_trim.a)
  2784. , PSTR(" B"), LINEAR_UNIT(delta_diagonal_rod_trim.b)
  2785. , PSTR(" C"), LINEAR_UNIT(delta_diagonal_rod_trim.c)
  2786. );
  2787. #elif HAS_EXTRA_ENDSTOPS
  2788. CONFIG_ECHO_HEADING("Endstop adjustment:");
  2789. CONFIG_ECHO_START();
  2790. SERIAL_ECHOPGM(" M666");
  2791. #if ENABLED(X_DUAL_ENDSTOPS)
  2792. SERIAL_ECHOLNPAIR_P(SP_X_STR, LINEAR_UNIT(endstops.x2_endstop_adj));
  2793. #endif
  2794. #if ENABLED(Y_DUAL_ENDSTOPS)
  2795. SERIAL_ECHOLNPAIR_P(SP_Y_STR, LINEAR_UNIT(endstops.y2_endstop_adj));
  2796. #endif
  2797. #if ENABLED(Z_MULTI_ENDSTOPS)
  2798. #if NUM_Z_STEPPER_DRIVERS >= 3
  2799. SERIAL_ECHOPAIR(" S2 Z", LINEAR_UNIT(endstops.z3_endstop_adj));
  2800. CONFIG_ECHO_START();
  2801. SERIAL_ECHOPAIR(" M666 S3 Z", LINEAR_UNIT(endstops.z3_endstop_adj));
  2802. #if NUM_Z_STEPPER_DRIVERS >= 4
  2803. CONFIG_ECHO_START();
  2804. SERIAL_ECHOPAIR(" M666 S4 Z", LINEAR_UNIT(endstops.z4_endstop_adj));
  2805. #endif
  2806. #else
  2807. SERIAL_ECHOLNPAIR_P(SP_Z_STR, LINEAR_UNIT(endstops.z2_endstop_adj));
  2808. #endif
  2809. #endif
  2810. #endif // [XYZ]_DUAL_ENDSTOPS
  2811. #if PREHEAT_COUNT
  2812. CONFIG_ECHO_HEADING("Material heatup parameters:");
  2813. LOOP_L_N(i, PREHEAT_COUNT) {
  2814. CONFIG_ECHO_START();
  2815. SERIAL_ECHOLNPAIR_P(
  2816. PSTR(" M145 S"), (int)i
  2817. #if HAS_HOTEND
  2818. , PSTR(" H"), TEMP_UNIT(ui.material_preset[i].hotend_temp)
  2819. #endif
  2820. #if HAS_HEATED_BED
  2821. , SP_B_STR, TEMP_UNIT(ui.material_preset[i].bed_temp)
  2822. #endif
  2823. #if HAS_FAN
  2824. , PSTR(" F"), ui.material_preset[i].fan_speed
  2825. #endif
  2826. );
  2827. }
  2828. #endif
  2829. #if HAS_PID_HEATING
  2830. CONFIG_ECHO_HEADING("PID settings:");
  2831. #if ENABLED(PIDTEMP)
  2832. HOTEND_LOOP() {
  2833. CONFIG_ECHO_START();
  2834. SERIAL_ECHOPAIR_P(
  2835. #if ENABLED(PID_PARAMS_PER_HOTEND)
  2836. PSTR(" M301 E"), e,
  2837. SP_P_STR
  2838. #else
  2839. PSTR(" M301 P")
  2840. #endif
  2841. , PID_PARAM(Kp, e)
  2842. , PSTR(" I"), unscalePID_i(PID_PARAM(Ki, e))
  2843. , PSTR(" D"), unscalePID_d(PID_PARAM(Kd, e))
  2844. );
  2845. #if ENABLED(PID_EXTRUSION_SCALING)
  2846. SERIAL_ECHOPAIR_P(SP_C_STR, PID_PARAM(Kc, e));
  2847. if (e == 0) SERIAL_ECHOPAIR(" L", thermalManager.lpq_len);
  2848. #endif
  2849. #if ENABLED(PID_FAN_SCALING)
  2850. SERIAL_ECHOPAIR(" F", PID_PARAM(Kf, e));
  2851. #endif
  2852. SERIAL_EOL();
  2853. }
  2854. #endif // PIDTEMP
  2855. #if ENABLED(PIDTEMPBED)
  2856. CONFIG_ECHO_START();
  2857. SERIAL_ECHOLNPAIR(
  2858. " M304 P", thermalManager.temp_bed.pid.Kp
  2859. , " I", unscalePID_i(thermalManager.temp_bed.pid.Ki)
  2860. , " D", unscalePID_d(thermalManager.temp_bed.pid.Kd)
  2861. );
  2862. #endif
  2863. #endif // PIDTEMP || PIDTEMPBED
  2864. #if HAS_USER_THERMISTORS
  2865. CONFIG_ECHO_HEADING("User thermistors:");
  2866. LOOP_L_N(i, USER_THERMISTORS)
  2867. thermalManager.log_user_thermistor(i, true);
  2868. #endif
  2869. #if HAS_LCD_CONTRAST
  2870. CONFIG_ECHO_HEADING("LCD Contrast:");
  2871. CONFIG_ECHO_START();
  2872. SERIAL_ECHOLNPAIR(" M250 C", ui.contrast);
  2873. #endif
  2874. TERN_(CONTROLLER_FAN_EDITABLE, M710_report(forReplay));
  2875. #if ENABLED(POWER_LOSS_RECOVERY)
  2876. CONFIG_ECHO_HEADING("Power-Loss Recovery:");
  2877. CONFIG_ECHO_START();
  2878. SERIAL_ECHOLNPAIR(" M413 S", int(recovery.enabled));
  2879. #endif
  2880. #if ENABLED(FWRETRACT)
  2881. CONFIG_ECHO_HEADING("Retract: S<length> F<units/m> Z<lift>");
  2882. CONFIG_ECHO_START();
  2883. SERIAL_ECHOLNPAIR_P(
  2884. PSTR(" M207 S"), LINEAR_UNIT(fwretract.settings.retract_length)
  2885. , PSTR(" W"), LINEAR_UNIT(fwretract.settings.swap_retract_length)
  2886. , PSTR(" F"), LINEAR_UNIT(MMS_TO_MMM(fwretract.settings.retract_feedrate_mm_s))
  2887. , SP_Z_STR, LINEAR_UNIT(fwretract.settings.retract_zraise)
  2888. );
  2889. CONFIG_ECHO_HEADING("Recover: S<length> F<units/m>");
  2890. CONFIG_ECHO_START();
  2891. SERIAL_ECHOLNPAIR(
  2892. " M208 S", LINEAR_UNIT(fwretract.settings.retract_recover_extra)
  2893. , " W", LINEAR_UNIT(fwretract.settings.swap_retract_recover_extra)
  2894. , " F", LINEAR_UNIT(MMS_TO_MMM(fwretract.settings.retract_recover_feedrate_mm_s))
  2895. );
  2896. #if ENABLED(FWRETRACT_AUTORETRACT)
  2897. CONFIG_ECHO_HEADING("Auto-Retract: S=0 to disable, 1 to interpret E-only moves as retract/recover");
  2898. CONFIG_ECHO_START();
  2899. SERIAL_ECHOLNPAIR(" M209 S", fwretract.autoretract_enabled ? 1 : 0);
  2900. #endif // FWRETRACT_AUTORETRACT
  2901. #endif // FWRETRACT
  2902. /**
  2903. * Probe Offset
  2904. */
  2905. #if HAS_BED_PROBE
  2906. config_heading(forReplay, PSTR("Z-Probe Offset"), false);
  2907. if (!forReplay) say_units(true);
  2908. CONFIG_ECHO_START();
  2909. SERIAL_ECHOLNPAIR_P(
  2910. #if HAS_PROBE_XY_OFFSET
  2911. PSTR(" M851 X"), LINEAR_UNIT(probe.offset_xy.x),
  2912. SP_Y_STR, LINEAR_UNIT(probe.offset_xy.y),
  2913. SP_Z_STR
  2914. #else
  2915. PSTR(" M851 X0 Y0 Z")
  2916. #endif
  2917. , LINEAR_UNIT(probe.offset.z)
  2918. );
  2919. #endif
  2920. /**
  2921. * Bed Skew Correction
  2922. */
  2923. #if ENABLED(SKEW_CORRECTION_GCODE)
  2924. CONFIG_ECHO_HEADING("Skew Factor: ");
  2925. CONFIG_ECHO_START();
  2926. #if ENABLED(SKEW_CORRECTION_FOR_Z)
  2927. SERIAL_ECHOPAIR_F(" M852 I", LINEAR_UNIT(planner.skew_factor.xy), 6);
  2928. SERIAL_ECHOPAIR_F(" J", LINEAR_UNIT(planner.skew_factor.xz), 6);
  2929. SERIAL_ECHOLNPAIR_F(" K", LINEAR_UNIT(planner.skew_factor.yz), 6);
  2930. #else
  2931. SERIAL_ECHOLNPAIR_F(" M852 S", LINEAR_UNIT(planner.skew_factor.xy), 6);
  2932. #endif
  2933. #endif
  2934. #if HAS_TRINAMIC_CONFIG
  2935. /**
  2936. * TMC stepper driver current
  2937. */
  2938. CONFIG_ECHO_HEADING("Stepper driver current:");
  2939. #if AXIS_IS_TMC(X) || AXIS_IS_TMC(Y) || AXIS_IS_TMC(Z)
  2940. say_M906(forReplay);
  2941. #if AXIS_IS_TMC(X)
  2942. SERIAL_ECHOPAIR_P(SP_X_STR, stepperX.getMilliamps());
  2943. #endif
  2944. #if AXIS_IS_TMC(Y)
  2945. SERIAL_ECHOPAIR_P(SP_Y_STR, stepperY.getMilliamps());
  2946. #endif
  2947. #if AXIS_IS_TMC(Z)
  2948. SERIAL_ECHOPAIR_P(SP_Z_STR, stepperZ.getMilliamps());
  2949. #endif
  2950. SERIAL_EOL();
  2951. #endif
  2952. #if AXIS_IS_TMC(X2) || AXIS_IS_TMC(Y2) || AXIS_IS_TMC(Z2)
  2953. say_M906(forReplay);
  2954. SERIAL_ECHOPGM(" I1");
  2955. #if AXIS_IS_TMC(X2)
  2956. SERIAL_ECHOPAIR_P(SP_X_STR, stepperX2.getMilliamps());
  2957. #endif
  2958. #if AXIS_IS_TMC(Y2)
  2959. SERIAL_ECHOPAIR_P(SP_Y_STR, stepperY2.getMilliamps());
  2960. #endif
  2961. #if AXIS_IS_TMC(Z2)
  2962. SERIAL_ECHOPAIR_P(SP_Z_STR, stepperZ2.getMilliamps());
  2963. #endif
  2964. SERIAL_EOL();
  2965. #endif
  2966. #if AXIS_IS_TMC(Z3)
  2967. say_M906(forReplay);
  2968. SERIAL_ECHOLNPAIR(" I2 Z", stepperZ3.getMilliamps());
  2969. #endif
  2970. #if AXIS_IS_TMC(Z4)
  2971. say_M906(forReplay);
  2972. SERIAL_ECHOLNPAIR(" I3 Z", stepperZ4.getMilliamps());
  2973. #endif
  2974. #if AXIS_IS_TMC(E0)
  2975. say_M906(forReplay);
  2976. SERIAL_ECHOLNPAIR(" T0 E", stepperE0.getMilliamps());
  2977. #endif
  2978. #if AXIS_IS_TMC(E1)
  2979. say_M906(forReplay);
  2980. SERIAL_ECHOLNPAIR(" T1 E", stepperE1.getMilliamps());
  2981. #endif
  2982. #if AXIS_IS_TMC(E2)
  2983. say_M906(forReplay);
  2984. SERIAL_ECHOLNPAIR(" T2 E", stepperE2.getMilliamps());
  2985. #endif
  2986. #if AXIS_IS_TMC(E3)
  2987. say_M906(forReplay);
  2988. SERIAL_ECHOLNPAIR(" T3 E", stepperE3.getMilliamps());
  2989. #endif
  2990. #if AXIS_IS_TMC(E4)
  2991. say_M906(forReplay);
  2992. SERIAL_ECHOLNPAIR(" T4 E", stepperE4.getMilliamps());
  2993. #endif
  2994. #if AXIS_IS_TMC(E5)
  2995. say_M906(forReplay);
  2996. SERIAL_ECHOLNPAIR(" T5 E", stepperE5.getMilliamps());
  2997. #endif
  2998. #if AXIS_IS_TMC(E6)
  2999. say_M906(forReplay);
  3000. SERIAL_ECHOLNPAIR(" T6 E", stepperE6.getMilliamps());
  3001. #endif
  3002. #if AXIS_IS_TMC(E7)
  3003. say_M906(forReplay);
  3004. SERIAL_ECHOLNPAIR(" T7 E", stepperE7.getMilliamps());
  3005. #endif
  3006. SERIAL_EOL();
  3007. /**
  3008. * TMC Hybrid Threshold
  3009. */
  3010. #if ENABLED(HYBRID_THRESHOLD)
  3011. CONFIG_ECHO_HEADING("Hybrid Threshold:");
  3012. #if AXIS_HAS_STEALTHCHOP(X) || AXIS_HAS_STEALTHCHOP(Y) || AXIS_HAS_STEALTHCHOP(Z)
  3013. say_M913(forReplay);
  3014. #if AXIS_HAS_STEALTHCHOP(X)
  3015. SERIAL_ECHOPAIR_P(SP_X_STR, stepperX.get_pwm_thrs());
  3016. #endif
  3017. #if AXIS_HAS_STEALTHCHOP(Y)
  3018. SERIAL_ECHOPAIR_P(SP_Y_STR, stepperY.get_pwm_thrs());
  3019. #endif
  3020. #if AXIS_HAS_STEALTHCHOP(Z)
  3021. SERIAL_ECHOPAIR_P(SP_Z_STR, stepperZ.get_pwm_thrs());
  3022. #endif
  3023. SERIAL_EOL();
  3024. #endif
  3025. #if AXIS_HAS_STEALTHCHOP(X2) || AXIS_HAS_STEALTHCHOP(Y2) || AXIS_HAS_STEALTHCHOP(Z2)
  3026. say_M913(forReplay);
  3027. SERIAL_ECHOPGM(" I1");
  3028. #if AXIS_HAS_STEALTHCHOP(X2)
  3029. SERIAL_ECHOPAIR_P(SP_X_STR, stepperX2.get_pwm_thrs());
  3030. #endif
  3031. #if AXIS_HAS_STEALTHCHOP(Y2)
  3032. SERIAL_ECHOPAIR_P(SP_Y_STR, stepperY2.get_pwm_thrs());
  3033. #endif
  3034. #if AXIS_HAS_STEALTHCHOP(Z2)
  3035. SERIAL_ECHOPAIR_P(SP_Z_STR, stepperZ2.get_pwm_thrs());
  3036. #endif
  3037. SERIAL_EOL();
  3038. #endif
  3039. #if AXIS_HAS_STEALTHCHOP(Z3)
  3040. say_M913(forReplay);
  3041. SERIAL_ECHOLNPAIR(" I2 Z", stepperZ3.get_pwm_thrs());
  3042. #endif
  3043. #if AXIS_HAS_STEALTHCHOP(Z4)
  3044. say_M913(forReplay);
  3045. SERIAL_ECHOLNPAIR(" I3 Z", stepperZ4.get_pwm_thrs());
  3046. #endif
  3047. #if AXIS_HAS_STEALTHCHOP(E0)
  3048. say_M913(forReplay);
  3049. SERIAL_ECHOLNPAIR(" T0 E", stepperE0.get_pwm_thrs());
  3050. #endif
  3051. #if AXIS_HAS_STEALTHCHOP(E1)
  3052. say_M913(forReplay);
  3053. SERIAL_ECHOLNPAIR(" T1 E", stepperE1.get_pwm_thrs());
  3054. #endif
  3055. #if AXIS_HAS_STEALTHCHOP(E2)
  3056. say_M913(forReplay);
  3057. SERIAL_ECHOLNPAIR(" T2 E", stepperE2.get_pwm_thrs());
  3058. #endif
  3059. #if AXIS_HAS_STEALTHCHOP(E3)
  3060. say_M913(forReplay);
  3061. SERIAL_ECHOLNPAIR(" T3 E", stepperE3.get_pwm_thrs());
  3062. #endif
  3063. #if AXIS_HAS_STEALTHCHOP(E4)
  3064. say_M913(forReplay);
  3065. SERIAL_ECHOLNPAIR(" T4 E", stepperE4.get_pwm_thrs());
  3066. #endif
  3067. #if AXIS_HAS_STEALTHCHOP(E5)
  3068. say_M913(forReplay);
  3069. SERIAL_ECHOLNPAIR(" T5 E", stepperE5.get_pwm_thrs());
  3070. #endif
  3071. #if AXIS_HAS_STEALTHCHOP(E6)
  3072. say_M913(forReplay);
  3073. SERIAL_ECHOLNPAIR(" T6 E", stepperE6.get_pwm_thrs());
  3074. #endif
  3075. #if AXIS_HAS_STEALTHCHOP(E7)
  3076. say_M913(forReplay);
  3077. SERIAL_ECHOLNPAIR(" T7 E", stepperE7.get_pwm_thrs());
  3078. #endif
  3079. SERIAL_EOL();
  3080. #endif // HYBRID_THRESHOLD
  3081. /**
  3082. * TMC Sensorless homing thresholds
  3083. */
  3084. #if USE_SENSORLESS
  3085. CONFIG_ECHO_HEADING("StallGuard threshold:");
  3086. #if X_SENSORLESS || Y_SENSORLESS || Z_SENSORLESS
  3087. CONFIG_ECHO_START();
  3088. say_M914();
  3089. #if X_SENSORLESS
  3090. SERIAL_ECHOPAIR_P(SP_X_STR, stepperX.homing_threshold());
  3091. #endif
  3092. #if Y_SENSORLESS
  3093. SERIAL_ECHOPAIR_P(SP_Y_STR, stepperY.homing_threshold());
  3094. #endif
  3095. #if Z_SENSORLESS
  3096. SERIAL_ECHOPAIR_P(SP_Z_STR, stepperZ.homing_threshold());
  3097. #endif
  3098. SERIAL_EOL();
  3099. #endif
  3100. #if X2_SENSORLESS || Y2_SENSORLESS || Z2_SENSORLESS
  3101. CONFIG_ECHO_START();
  3102. say_M914();
  3103. SERIAL_ECHOPGM(" I1");
  3104. #if X2_SENSORLESS
  3105. SERIAL_ECHOPAIR_P(SP_X_STR, stepperX2.homing_threshold());
  3106. #endif
  3107. #if Y2_SENSORLESS
  3108. SERIAL_ECHOPAIR_P(SP_Y_STR, stepperY2.homing_threshold());
  3109. #endif
  3110. #if Z2_SENSORLESS
  3111. SERIAL_ECHOPAIR_P(SP_Z_STR, stepperZ2.homing_threshold());
  3112. #endif
  3113. SERIAL_EOL();
  3114. #endif
  3115. #if Z3_SENSORLESS
  3116. CONFIG_ECHO_START();
  3117. say_M914();
  3118. SERIAL_ECHOLNPAIR(" I2 Z", stepperZ3.homing_threshold());
  3119. #endif
  3120. #if Z4_SENSORLESS
  3121. CONFIG_ECHO_START();
  3122. say_M914();
  3123. SERIAL_ECHOLNPAIR(" I3 Z", stepperZ4.homing_threshold());
  3124. #endif
  3125. #endif // USE_SENSORLESS
  3126. /**
  3127. * TMC stepping mode
  3128. */
  3129. #if HAS_STEALTHCHOP
  3130. CONFIG_ECHO_HEADING("Driver stepping mode:");
  3131. #if AXIS_HAS_STEALTHCHOP(X)
  3132. const bool chop_x = stepperX.get_stored_stealthChop_status();
  3133. #else
  3134. constexpr bool chop_x = false;
  3135. #endif
  3136. #if AXIS_HAS_STEALTHCHOP(Y)
  3137. const bool chop_y = stepperY.get_stored_stealthChop_status();
  3138. #else
  3139. constexpr bool chop_y = false;
  3140. #endif
  3141. #if AXIS_HAS_STEALTHCHOP(Z)
  3142. const bool chop_z = stepperZ.get_stored_stealthChop_status();
  3143. #else
  3144. constexpr bool chop_z = false;
  3145. #endif
  3146. if (chop_x || chop_y || chop_z) {
  3147. say_M569(forReplay);
  3148. if (chop_x) SERIAL_ECHOPGM_P(SP_X_STR);
  3149. if (chop_y) SERIAL_ECHOPGM_P(SP_Y_STR);
  3150. if (chop_z) SERIAL_ECHOPGM_P(SP_Z_STR);
  3151. SERIAL_EOL();
  3152. }
  3153. #if AXIS_HAS_STEALTHCHOP(X2)
  3154. const bool chop_x2 = stepperX2.get_stored_stealthChop_status();
  3155. #else
  3156. constexpr bool chop_x2 = false;
  3157. #endif
  3158. #if AXIS_HAS_STEALTHCHOP(Y2)
  3159. const bool chop_y2 = stepperY2.get_stored_stealthChop_status();
  3160. #else
  3161. constexpr bool chop_y2 = false;
  3162. #endif
  3163. #if AXIS_HAS_STEALTHCHOP(Z2)
  3164. const bool chop_z2 = stepperZ2.get_stored_stealthChop_status();
  3165. #else
  3166. constexpr bool chop_z2 = false;
  3167. #endif
  3168. if (chop_x2 || chop_y2 || chop_z2) {
  3169. say_M569(forReplay, PSTR("I1"));
  3170. if (chop_x2) SERIAL_ECHOPGM_P(SP_X_STR);
  3171. if (chop_y2) SERIAL_ECHOPGM_P(SP_Y_STR);
  3172. if (chop_z2) SERIAL_ECHOPGM_P(SP_Z_STR);
  3173. SERIAL_EOL();
  3174. }
  3175. #if AXIS_HAS_STEALTHCHOP(Z3)
  3176. if (stepperZ3.get_stored_stealthChop_status()) { say_M569(forReplay, PSTR("I2 Z"), true); }
  3177. #endif
  3178. #if AXIS_HAS_STEALTHCHOP(Z4)
  3179. if (stepperZ4.get_stored_stealthChop_status()) { say_M569(forReplay, PSTR("I3 Z"), true); }
  3180. #endif
  3181. #if AXIS_HAS_STEALTHCHOP(E0)
  3182. if (stepperE0.get_stored_stealthChop_status()) { say_M569(forReplay, PSTR("T0 E"), true); }
  3183. #endif
  3184. #if AXIS_HAS_STEALTHCHOP(E1)
  3185. if (stepperE1.get_stored_stealthChop_status()) { say_M569(forReplay, PSTR("T1 E"), true); }
  3186. #endif
  3187. #if AXIS_HAS_STEALTHCHOP(E2)
  3188. if (stepperE2.get_stored_stealthChop_status()) { say_M569(forReplay, PSTR("T2 E"), true); }
  3189. #endif
  3190. #if AXIS_HAS_STEALTHCHOP(E3)
  3191. if (stepperE3.get_stored_stealthChop_status()) { say_M569(forReplay, PSTR("T3 E"), true); }
  3192. #endif
  3193. #if AXIS_HAS_STEALTHCHOP(E4)
  3194. if (stepperE4.get_stored_stealthChop_status()) { say_M569(forReplay, PSTR("T4 E"), true); }
  3195. #endif
  3196. #if AXIS_HAS_STEALTHCHOP(E5)
  3197. if (stepperE5.get_stored_stealthChop_status()) { say_M569(forReplay, PSTR("T5 E"), true); }
  3198. #endif
  3199. #if AXIS_HAS_STEALTHCHOP(E6)
  3200. if (stepperE6.get_stored_stealthChop_status()) { say_M569(forReplay, PSTR("T6 E"), true); }
  3201. #endif
  3202. #if AXIS_HAS_STEALTHCHOP(E7)
  3203. if (stepperE7.get_stored_stealthChop_status()) { say_M569(forReplay, PSTR("T7 E"), true); }
  3204. #endif
  3205. #endif // HAS_STEALTHCHOP
  3206. #endif // HAS_TRINAMIC_CONFIG
  3207. /**
  3208. * Linear Advance
  3209. */
  3210. #if ENABLED(LIN_ADVANCE)
  3211. CONFIG_ECHO_HEADING("Linear Advance:");
  3212. #if EXTRUDERS < 2
  3213. CONFIG_ECHO_START();
  3214. SERIAL_ECHOLNPAIR(" M900 K", planner.extruder_advance_K[0]);
  3215. #else
  3216. LOOP_L_N(i, EXTRUDERS) {
  3217. CONFIG_ECHO_START();
  3218. SERIAL_ECHOLNPAIR(" M900 T", int(i), " K", planner.extruder_advance_K[i]);
  3219. }
  3220. #endif
  3221. #endif
  3222. #if HAS_MOTOR_CURRENT_PWM
  3223. CONFIG_ECHO_HEADING("Stepper motor currents:");
  3224. CONFIG_ECHO_START();
  3225. SERIAL_ECHOLNPAIR_P(
  3226. PSTR(" M907 X"), stepper.motor_current_setting[0]
  3227. , SP_Z_STR, stepper.motor_current_setting[1]
  3228. , SP_E_STR, stepper.motor_current_setting[2]
  3229. );
  3230. #endif
  3231. /**
  3232. * Advanced Pause filament load & unload lengths
  3233. */
  3234. #if ENABLED(ADVANCED_PAUSE_FEATURE)
  3235. CONFIG_ECHO_HEADING("Filament load/unload lengths:");
  3236. #if EXTRUDERS == 1
  3237. say_M603(forReplay);
  3238. SERIAL_ECHOLNPAIR("L", LINEAR_UNIT(fc_settings[0].load_length), " U", LINEAR_UNIT(fc_settings[0].unload_length));
  3239. #else
  3240. #define _ECHO_603(N) do{ say_M603(forReplay); SERIAL_ECHOLNPAIR("T" STRINGIFY(N) " L", LINEAR_UNIT(fc_settings[N].load_length), " U", LINEAR_UNIT(fc_settings[N].unload_length)); }while(0);
  3241. REPEAT(EXTRUDERS, _ECHO_603)
  3242. #endif
  3243. #endif
  3244. #if HAS_MULTI_EXTRUDER
  3245. CONFIG_ECHO_HEADING("Tool-changing:");
  3246. CONFIG_ECHO_START();
  3247. M217_report(true);
  3248. #endif
  3249. #if ENABLED(BACKLASH_GCODE)
  3250. CONFIG_ECHO_HEADING("Backlash compensation:");
  3251. CONFIG_ECHO_START();
  3252. SERIAL_ECHOLNPAIR_P(
  3253. PSTR(" M425 F"), backlash.get_correction()
  3254. , SP_X_STR, LINEAR_UNIT(backlash.distance_mm.x)
  3255. , SP_Y_STR, LINEAR_UNIT(backlash.distance_mm.y)
  3256. , SP_Z_STR, LINEAR_UNIT(backlash.distance_mm.z)
  3257. #ifdef BACKLASH_SMOOTHING_MM
  3258. , PSTR(" S"), LINEAR_UNIT(backlash.smoothing_mm)
  3259. #endif
  3260. );
  3261. #endif
  3262. #if HAS_FILAMENT_SENSOR
  3263. CONFIG_ECHO_HEADING("Filament runout sensor:");
  3264. CONFIG_ECHO_START();
  3265. SERIAL_ECHOLNPAIR(
  3266. " M412 S", int(runout.enabled)
  3267. #if HAS_FILAMENT_RUNOUT_DISTANCE
  3268. , " D", LINEAR_UNIT(runout.runout_distance())
  3269. #endif
  3270. );
  3271. #endif
  3272. }
  3273. #endif // !DISABLE_M503
  3274. #pragma pack(pop)