ConfigurationStore.cpp 15 KB

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