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

configuration_store.cpp 68KB

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