ConfigurationStore.cpp 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446
  1. #include "Marlin.h"
  2. #include "planner.h"
  3. #include "temperature.h"
  4. #include "ultralcd.h"
  5. #include "ConfigurationStore.h"
  6. #include "Configuration_prusa.h"
  7. #ifdef MESH_BED_LEVELING
  8. #include "mesh_bed_leveling.h"
  9. #endif
  10. #ifdef DEBUG_EEPROM_WRITE
  11. #define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value), #value)
  12. #else //DEBUG_EEPROM_WRITE
  13. #define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value), 0)
  14. #endif //DEBUG_EEPROM_WRITE
  15. void _EEPROM_writeData(int &pos, uint8_t* value, uint8_t size, char* name)
  16. {
  17. #ifdef DEBUG_EEPROM_WRITE
  18. printf_P(PSTR("EEPROM_WRITE_VAR addr=0x%04x size=0x%02hhx name=%s\n"), pos, size, name);
  19. #endif //DEBUG_EEPROM_WRITE
  20. while (size--) {
  21. uint8_t * const p = (uint8_t * const)pos;
  22. uint8_t v = *value;
  23. // EEPROM has only ~100,000 write cycles,
  24. // so only write bytes that have changed!
  25. if (v != eeprom_read_byte(p)) {
  26. eeprom_write_byte(p, v);
  27. if (eeprom_read_byte(p) != v) {
  28. SERIAL_ECHOLNPGM("EEPROM Error");
  29. return;
  30. }
  31. }
  32. pos++;
  33. value++;
  34. };
  35. }
  36. #ifdef DEBUG_EEPROM_READ
  37. #define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value), #value)
  38. #else //DEBUG_EEPROM_READ
  39. #define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value), 0)
  40. #endif //DEBUG_EEPROM_READ
  41. void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size, char* name)
  42. {
  43. #ifdef DEBUG_EEPROM_READ
  44. printf_P(PSTR("EEPROM_READ_VAR addr=0x%04x size=0x%02hhx name=%s\n"), pos, size, name);
  45. #endif //DEBUG_EEPROM_READ
  46. do
  47. {
  48. *value = eeprom_read_byte((unsigned char*)pos);
  49. pos++;
  50. value++;
  51. }while(--size);
  52. }
  53. //======================================================================================
  54. #define EEPROM_OFFSET 20
  55. #define EEPROM_M500_SIZE 188 //bytes
  56. // IMPORTANT: Whenever there are changes made to the variables stored in EEPROM
  57. // in the functions below, also increment the version number and update EEPROM_M500_SIZE. This makes sure that
  58. // the default values are used whenever there is a change to the data, to prevent
  59. // wrong data being written to the variables.
  60. // ALSO: always make sure the variables in the Store and retrieve sections are in the same order.
  61. #define EEPROM_VERSION "V3"
  62. #ifdef EEPROM_SETTINGS
  63. void Config_StoreSettings(uint16_t offset)
  64. {
  65. char ver[4]= "000";
  66. int i = offset;
  67. EEPROM_WRITE_VAR(i,ver); // invalidate data first
  68. EEPROM_WRITE_VAR(i,axis_steps_per_unit);
  69. EEPROM_WRITE_VAR(i,max_feedrate_normal);
  70. EEPROM_WRITE_VAR(i,max_acceleration_units_per_sq_second_normal);
  71. EEPROM_WRITE_VAR(i,acceleration);
  72. EEPROM_WRITE_VAR(i,retract_acceleration);
  73. EEPROM_WRITE_VAR(i,minimumfeedrate);
  74. EEPROM_WRITE_VAR(i,mintravelfeedrate);
  75. EEPROM_WRITE_VAR(i,minsegmenttime);
  76. EEPROM_WRITE_VAR(i,max_jerk[X_AXIS]);
  77. EEPROM_WRITE_VAR(i,max_jerk[Y_AXIS]);
  78. EEPROM_WRITE_VAR(i,max_jerk[Z_AXIS]);
  79. EEPROM_WRITE_VAR(i,max_jerk[E_AXIS]);
  80. EEPROM_WRITE_VAR(i,add_homing);
  81. /* EEPROM_WRITE_VAR(i,plaPreheatHotendTemp);
  82. EEPROM_WRITE_VAR(i,plaPreheatHPBTemp);
  83. EEPROM_WRITE_VAR(i,plaPreheatFanSpeed);
  84. EEPROM_WRITE_VAR(i,absPreheatHotendTemp);
  85. EEPROM_WRITE_VAR(i,absPreheatHPBTemp);
  86. EEPROM_WRITE_VAR(i,absPreheatFanSpeed);
  87. */
  88. EEPROM_WRITE_VAR(i,zprobe_zoffset);
  89. #ifdef PIDTEMP
  90. EEPROM_WRITE_VAR(i,Kp);
  91. EEPROM_WRITE_VAR(i,Ki);
  92. EEPROM_WRITE_VAR(i,Kd);
  93. #else
  94. float dummy = 3000.0f;
  95. EEPROM_WRITE_VAR(i,dummy);
  96. dummy = 0.0f;
  97. EEPROM_WRITE_VAR(i,dummy);
  98. EEPROM_WRITE_VAR(i,dummy);
  99. #endif
  100. #ifdef PIDTEMPBED
  101. EEPROM_WRITE_VAR(i, bedKp);
  102. EEPROM_WRITE_VAR(i, bedKi);
  103. EEPROM_WRITE_VAR(i, bedKd);
  104. #endif
  105. int lcd_contrast = 0;
  106. EEPROM_WRITE_VAR(i,lcd_contrast);
  107. #ifdef FWRETRACT
  108. EEPROM_WRITE_VAR(i,autoretract_enabled);
  109. EEPROM_WRITE_VAR(i,retract_length);
  110. #if EXTRUDERS > 1
  111. EEPROM_WRITE_VAR(i,retract_length_swap);
  112. #endif
  113. EEPROM_WRITE_VAR(i,retract_feedrate);
  114. EEPROM_WRITE_VAR(i,retract_zlift);
  115. EEPROM_WRITE_VAR(i,retract_recover_length);
  116. #if EXTRUDERS > 1
  117. EEPROM_WRITE_VAR(i,retract_recover_length_swap);
  118. #endif
  119. EEPROM_WRITE_VAR(i,retract_recover_feedrate);
  120. #endif
  121. // Save filament sizes
  122. EEPROM_WRITE_VAR(i, volumetric_enabled);
  123. EEPROM_WRITE_VAR(i, filament_size[0]);
  124. #if EXTRUDERS > 1
  125. EEPROM_WRITE_VAR(i, filament_size[1]);
  126. #if EXTRUDERS > 2
  127. EEPROM_WRITE_VAR(i, filament_size[2]);
  128. #endif
  129. #endif
  130. EEPROM_WRITE_VAR(i,max_feedrate_silent);
  131. EEPROM_WRITE_VAR(i,max_acceleration_units_per_sq_second_silent);
  132. if (EEPROM_M500_SIZE + EEPROM_OFFSET == i) {
  133. char ver2[4] = EEPROM_VERSION;
  134. i = offset;
  135. EEPROM_WRITE_VAR(i, ver2); // validate data
  136. SERIAL_ECHO_START;
  137. SERIAL_ECHOLNPGM("Settings Stored");
  138. }
  139. else { //size of eeprom M500 section probably changed by mistake and data are not valid; do not validate data by storing eeprom version
  140. //M500 EEPROM section will be erased on next printer reboot and default vaules will be used
  141. puts_P(PSTR("Data stored to EEPROM not valid."));
  142. }
  143. }
  144. #endif //EEPROM_SETTINGS
  145. #ifndef DISABLE_M503
  146. void Config_PrintSettings(uint8_t level)
  147. { // Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown
  148. #ifdef TMC2130
  149. printf_P(PSTR(
  150. "%SSteps per unit:\n%S M92 X%.2f Y%.2f Z%.2f E%.2f\n"
  151. "%SMaximum feedrates - normal (mm/s):\n%S M203 X%.2f Y%.2f Z%.2f E%.2f\n"
  152. "%SMaximum feedrates - stealth (mm/s):\n%S M203 X%.2f Y%.2f Z%.2f E%.2f\n"
  153. "%SMaximum acceleration - normal (mm/s2):\n%S M201 X%lu Y%lu Z%lu E%lu\n"
  154. "%SMaximum acceleration - stealth (mm/s2):\n%S M201 X%lu Y%lu Z%lu E%lu\n"
  155. "%SAcceleration: S=acceleration, T=retract acceleration\n%S M204 S%.2f T%.2f\n"
  156. "%SAdvanced variables: S=Min feedrate (mm/s), T=Min travel feedrate (mm/s), B=minimum segment time (ms), X=maximum XY jerk (mm/s), Z=maximum Z jerk (mm/s), E=maximum E jerk (mm/s)\n%S M205 S%.2f T%.2f B%.2f X%.2f Y%.2f Z%.2f E%.2f\n"
  157. "%SHome offset (mm):\n%S M206 X%.2f Y%.2f Z%.2f\n"
  158. ),
  159. echomagic, echomagic, axis_steps_per_unit[X_AXIS], axis_steps_per_unit[Y_AXIS], axis_steps_per_unit[Z_AXIS], axis_steps_per_unit[E_AXIS],
  160. echomagic, echomagic, max_feedrate_normal[X_AXIS], max_feedrate_normal[Y_AXIS], max_feedrate_normal[Z_AXIS], max_feedrate_normal[E_AXIS],
  161. echomagic, echomagic, max_feedrate_silent[X_AXIS], max_feedrate_silent[Y_AXIS], max_feedrate_silent[Z_AXIS], max_feedrate_silent[E_AXIS],
  162. echomagic, echomagic, max_acceleration_units_per_sq_second_normal[X_AXIS], max_acceleration_units_per_sq_second_normal[Y_AXIS], max_acceleration_units_per_sq_second_normal[Z_AXIS], max_acceleration_units_per_sq_second_normal[E_AXIS],
  163. echomagic, echomagic, max_acceleration_units_per_sq_second_silent[X_AXIS], max_acceleration_units_per_sq_second_silent[Y_AXIS], max_acceleration_units_per_sq_second_silent[Z_AXIS], max_acceleration_units_per_sq_second_silent[E_AXIS],
  164. echomagic, echomagic, acceleration, retract_acceleration,
  165. echomagic, echomagic, minimumfeedrate, mintravelfeedrate, minsegmenttime, max_jerk[X_AXIS], max_jerk[Y_AXIS], max_jerk[Z_AXIS], max_jerk[E_AXIS],
  166. echomagic, echomagic, add_homing[X_AXIS], add_homing[Y_AXIS], add_homing[Z_AXIS]
  167. #else //TMC2130
  168. printf_P(PSTR(
  169. "%SSteps per unit:\n%S M92 X%.2f Y%.2f Z%.2f E%.2f\n"
  170. "%SMaximum feedrates (mm/s):\n%S M203 X%.2f Y%.2f Z%.2f E%.2f\n"
  171. "%SMaximum acceleration (mm/s2):\n%S M201 X%lu Y%lu Z%lu E%lu\n"
  172. "%SAcceleration: S=acceleration, T=retract acceleration\n%S M204 S%.2f T%.2f\n"
  173. "%SAdvanced variables: S=Min feedrate (mm/s), T=Min travel feedrate (mm/s), B=minimum segment time (ms), X=maximum XY jerk (mm/s), Z=maximum Z jerk (mm/s), E=maximum E jerk (mm/s)\n%S M205 S%.2f T%.2f B%.2f X%.2f Y%.2f Z%.2f E%.2f\n"
  174. "%SHome offset (mm):\n%S M206 X%.2f Y%.2f Z%.2f\n"
  175. ),
  176. echomagic, echomagic, axis_steps_per_unit[X_AXIS], axis_steps_per_unit[Y_AXIS], axis_steps_per_unit[Z_AXIS], axis_steps_per_unit[E_AXIS],
  177. echomagic, echomagic, max_feedrate[X_AXIS], max_feedrate[Y_AXIS], max_feedrate[Z_AXIS], max_feedrate[E_AXIS],
  178. echomagic, echomagic, max_acceleration_units_per_sq_second[X_AXIS], max_acceleration_units_per_sq_second[Y_AXIS], max_acceleration_units_per_sq_second[Z_AXIS], max_acceleration_units_per_sq_second[E_AXIS],
  179. echomagic, echomagic, acceleration, retract_acceleration,
  180. echomagic, echomagic, minimumfeedrate, mintravelfeedrate, minsegmenttime, max_jerk[X_AXIS], max_jerk[Y_AXIS], max_jerk[Z_AXIS], max_jerk[E_AXIS],
  181. echomagic, echomagic, add_homing[X_AXIS], add_homing[Y_AXIS], add_homing[Z_AXIS]
  182. #endif //TMC2130
  183. );
  184. #ifdef PIDTEMP
  185. printf_P(PSTR("%SPID settings:\n%S M301 P%.2f I%.2f D%.2f\n"),
  186. echomagic, echomagic, Kp, unscalePID_i(Ki), unscalePID_d(Kd));
  187. #endif
  188. #ifdef PIDTEMPBED
  189. printf_P(PSTR("%SPID heatbed settings:\n%S M304 P%.2f I%.2f D%.2f\n"),
  190. echomagic, echomagic, bedKp, unscalePID_i(bedKi), unscalePID_d(bedKd));
  191. #endif
  192. #ifdef FWRETRACT
  193. printf_P(PSTR(
  194. "%SRetract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)\n%S M207 S%.2f F%.2f Z%.2f\n"
  195. "%SRecover: S=Extra length (mm) F:Speed (mm/m)\n%S M208 S%.2f F%.2f\n"
  196. "%SAuto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries\n%S M209 S%d\n"
  197. ),
  198. echomagic, echomagic, retract_length, retract_feedrate*60, retract_zlift,
  199. echomagic, echomagic, retract_recover_length, retract_recover_feedrate*60,
  200. echomagic, echomagic, (autoretract_enabled ? 1 : 0)
  201. );
  202. #if EXTRUDERS > 1
  203. printf_P(PSTR("%SMulti-extruder settings:\n%S Swap retract length (mm): %.2f\n%S Swap rec. addl. length (mm): %.2f\n"),
  204. echomagic, echomagic, retract_length_swap, echomagic, retract_recover_length_swap);
  205. #endif
  206. if (volumetric_enabled) {
  207. printf_P(PSTR("%SFilament settings:\n%S M200 D%.2f\n"),
  208. echomagic, echomagic, filament_size[0]);
  209. #if EXTRUDERS > 1
  210. printf_P(PSTR("%S M200 T1 D%.2f\n"),
  211. echomagic, echomagic, filament_size[1]);
  212. #if EXTRUDERS > 2
  213. printf_P(PSTR("%S M200 T1 D%.2f\n"),
  214. echomagic, echomagic, filament_size[2]);
  215. #endif
  216. #endif
  217. } else {
  218. printf_P(PSTR("%SFilament settings: Disabled\n"), echomagic);
  219. }
  220. #endif
  221. if (level >= 10) {
  222. #ifdef LIN_ADVANCE
  223. printf_P(PSTR("%SLinear advance settings:\n M900 K%.2f E/D = %.2f\n"),
  224. echomagic, extruder_advance_k, advance_ed_ratio);
  225. #endif //LIN_ADVANCE
  226. }
  227. }
  228. #endif
  229. #ifdef EEPROM_SETTINGS
  230. bool Config_RetrieveSettings(uint16_t offset)
  231. {
  232. int i=offset;
  233. bool previous_settings_retrieved = true;
  234. char stored_ver[4];
  235. char ver[4]=EEPROM_VERSION;
  236. EEPROM_READ_VAR(i,stored_ver); //read stored version
  237. // SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
  238. if (strncmp(ver,stored_ver,3) == 0)
  239. {
  240. // version number match
  241. EEPROM_READ_VAR(i,axis_steps_per_unit);
  242. EEPROM_READ_VAR(i,max_feedrate_normal);
  243. EEPROM_READ_VAR(i,max_acceleration_units_per_sq_second_normal);
  244. // steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner)
  245. EEPROM_READ_VAR(i,acceleration);
  246. EEPROM_READ_VAR(i,retract_acceleration);
  247. EEPROM_READ_VAR(i,minimumfeedrate);
  248. EEPROM_READ_VAR(i,mintravelfeedrate);
  249. EEPROM_READ_VAR(i,minsegmenttime);
  250. EEPROM_READ_VAR(i,max_jerk[X_AXIS]);
  251. EEPROM_READ_VAR(i,max_jerk[Y_AXIS]);
  252. EEPROM_READ_VAR(i,max_jerk[Z_AXIS]);
  253. EEPROM_READ_VAR(i,max_jerk[E_AXIS]);
  254. if (max_jerk[X_AXIS] > DEFAULT_XJERK) max_jerk[X_AXIS] = DEFAULT_XJERK;
  255. if (max_jerk[Y_AXIS] > DEFAULT_YJERK) max_jerk[Y_AXIS] = DEFAULT_YJERK;
  256. EEPROM_READ_VAR(i,add_homing);
  257. /*
  258. EEPROM_READ_VAR(i,plaPreheatHotendTemp);
  259. EEPROM_READ_VAR(i,plaPreheatHPBTemp);
  260. EEPROM_READ_VAR(i,plaPreheatFanSpeed);
  261. EEPROM_READ_VAR(i,absPreheatHotendTemp);
  262. EEPROM_READ_VAR(i,absPreheatHPBTemp);
  263. EEPROM_READ_VAR(i,absPreheatFanSpeed);
  264. */
  265. EEPROM_READ_VAR(i,zprobe_zoffset);
  266. #ifndef PIDTEMP
  267. float Kp,Ki,Kd;
  268. #endif
  269. // do not need to scale PID values as the values in EEPROM are already scaled
  270. EEPROM_READ_VAR(i,Kp);
  271. EEPROM_READ_VAR(i,Ki);
  272. EEPROM_READ_VAR(i,Kd);
  273. #ifdef PIDTEMPBED
  274. EEPROM_READ_VAR(i, bedKp);
  275. EEPROM_READ_VAR(i, bedKi);
  276. EEPROM_READ_VAR(i, bedKd);
  277. #endif
  278. int lcd_contrast;
  279. EEPROM_READ_VAR(i,lcd_contrast);
  280. #ifdef FWRETRACT
  281. EEPROM_READ_VAR(i,autoretract_enabled);
  282. EEPROM_READ_VAR(i,retract_length);
  283. #if EXTRUDERS > 1
  284. EEPROM_READ_VAR(i,retract_length_swap);
  285. #endif
  286. EEPROM_READ_VAR(i,retract_feedrate);
  287. EEPROM_READ_VAR(i,retract_zlift);
  288. EEPROM_READ_VAR(i,retract_recover_length);
  289. #if EXTRUDERS > 1
  290. EEPROM_READ_VAR(i,retract_recover_length_swap);
  291. #endif
  292. EEPROM_READ_VAR(i,retract_recover_feedrate);
  293. #endif
  294. EEPROM_READ_VAR(i, volumetric_enabled);
  295. EEPROM_READ_VAR(i, filament_size[0]);
  296. #if EXTRUDERS > 1
  297. EEPROM_READ_VAR(i, filament_size[1]);
  298. #if EXTRUDERS > 2
  299. EEPROM_READ_VAR(i, filament_size[2]);
  300. #endif
  301. #endif
  302. calculate_extruder_multipliers();
  303. EEPROM_READ_VAR(i,max_feedrate_silent);
  304. EEPROM_READ_VAR(i,max_acceleration_units_per_sq_second_silent);
  305. #ifdef TMC2130
  306. for (uint8_t j = X_AXIS; j <= Y_AXIS; j++)
  307. {
  308. if (max_feedrate_normal[j] > NORMAL_MAX_FEEDRATE_XY)
  309. max_feedrate_normal[j] = NORMAL_MAX_FEEDRATE_XY;
  310. if (max_feedrate_silent[j] > SILENT_MAX_FEEDRATE_XY)
  311. max_feedrate_silent[j] = SILENT_MAX_FEEDRATE_XY;
  312. if (max_acceleration_units_per_sq_second_normal[j] > NORMAL_MAX_ACCEL_XY)
  313. max_acceleration_units_per_sq_second_normal[j] = NORMAL_MAX_ACCEL_XY;
  314. if (max_acceleration_units_per_sq_second_silent[j] > SILENT_MAX_ACCEL_XY)
  315. max_acceleration_units_per_sq_second_silent[j] = SILENT_MAX_ACCEL_XY;
  316. }
  317. #endif //TMC2130
  318. reset_acceleration_rates();
  319. // Call updatePID (similar to when we have processed M301)
  320. updatePID();
  321. SERIAL_ECHO_START;
  322. SERIAL_ECHOLNPGM("Stored settings retrieved");
  323. }
  324. else
  325. {
  326. Config_ResetDefault();
  327. //Return false to inform user that eeprom version was changed and firmware is using default hardcoded settings now.
  328. //In case that storing to eeprom was not used yet, do not inform user that hardcoded settings are used.
  329. if (eeprom_read_byte((uint8_t *)offset) != 0xFF ||
  330. eeprom_read_byte((uint8_t *)offset + 1) != 0xFF ||
  331. eeprom_read_byte((uint8_t *)offset + 2) != 0xFF) {
  332. previous_settings_retrieved = false;
  333. }
  334. }
  335. #ifdef EEPROM_CHITCHAT
  336. Config_PrintSettings();
  337. #endif
  338. return previous_settings_retrieved;
  339. }
  340. #endif
  341. void Config_ResetDefault()
  342. {
  343. float tmp1[]=DEFAULT_AXIS_STEPS_PER_UNIT;
  344. float tmp2[]=DEFAULT_MAX_FEEDRATE;
  345. long tmp3[]=DEFAULT_MAX_ACCELERATION;
  346. float tmp4[]=DEFAULT_MAX_FEEDRATE_SILENT;
  347. long tmp5[]=DEFAULT_MAX_ACCELERATION_SILENT;
  348. for (short i=0;i<4;i++)
  349. {
  350. axis_steps_per_unit[i]=tmp1[i];
  351. max_feedrate_normal[i]=tmp2[i];
  352. max_acceleration_units_per_sq_second_normal[i]=tmp3[i];
  353. max_feedrate_silent[i]=tmp4[i];
  354. max_acceleration_units_per_sq_second_silent[i]=tmp5[i];
  355. }
  356. // steps per sq second need to be updated to agree with the units per sq second
  357. reset_acceleration_rates();
  358. acceleration=DEFAULT_ACCELERATION;
  359. retract_acceleration=DEFAULT_RETRACT_ACCELERATION;
  360. minimumfeedrate=DEFAULT_MINIMUMFEEDRATE;
  361. minsegmenttime=DEFAULT_MINSEGMENTTIME;
  362. mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE;
  363. max_jerk[X_AXIS] = DEFAULT_XJERK;
  364. max_jerk[Y_AXIS] = DEFAULT_YJERK;
  365. max_jerk[Z_AXIS] = DEFAULT_ZJERK;
  366. max_jerk[E_AXIS] = DEFAULT_EJERK;
  367. add_homing[X_AXIS] = add_homing[Y_AXIS] = add_homing[Z_AXIS] = 0;
  368. #ifdef ENABLE_AUTO_BED_LEVELING
  369. zprobe_zoffset = -Z_PROBE_OFFSET_FROM_EXTRUDER;
  370. #endif
  371. #ifdef PIDTEMP
  372. Kp = DEFAULT_Kp;
  373. Ki = scalePID_i(DEFAULT_Ki);
  374. Kd = scalePID_d(DEFAULT_Kd);
  375. // call updatePID (similar to when we have processed M301)
  376. updatePID();
  377. #ifdef PID_ADD_EXTRUSION_RATE
  378. Kc = DEFAULT_Kc;
  379. #endif//PID_ADD_EXTRUSION_RATE
  380. #endif//PIDTEMP
  381. #ifdef FWRETRACT
  382. autoretract_enabled = false;
  383. retract_length = RETRACT_LENGTH;
  384. #if EXTRUDERS > 1
  385. retract_length_swap = RETRACT_LENGTH_SWAP;
  386. #endif
  387. retract_feedrate = RETRACT_FEEDRATE;
  388. retract_zlift = RETRACT_ZLIFT;
  389. retract_recover_length = RETRACT_RECOVER_LENGTH;
  390. #if EXTRUDERS > 1
  391. retract_recover_length_swap = RETRACT_RECOVER_LENGTH_SWAP;
  392. #endif
  393. retract_recover_feedrate = RETRACT_RECOVER_FEEDRATE;
  394. #endif
  395. volumetric_enabled = false;
  396. filament_size[0] = DEFAULT_NOMINAL_FILAMENT_DIA;
  397. #if EXTRUDERS > 1
  398. filament_size[1] = DEFAULT_NOMINAL_FILAMENT_DIA;
  399. #if EXTRUDERS > 2
  400. filament_size[2] = DEFAULT_NOMINAL_FILAMENT_DIA;
  401. #endif
  402. #endif
  403. calculate_extruder_multipliers();
  404. SERIAL_ECHO_START;
  405. SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
  406. }