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.

ConfigurationStore.cpp 9.5KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294
  1. #include "Marlin.h"
  2. #include "planner.h"
  3. #include "temperature.h"
  4. #include "ultralcd.h"
  5. #include "ConfigurationStore.h"
  6. void _EEPROM_writeData(int &pos, uint8_t* value, uint8_t size)
  7. {
  8. do
  9. {
  10. eeprom_write_byte((unsigned char*)pos, *value);
  11. pos++;
  12. value++;
  13. }while(--size);
  14. }
  15. #define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value))
  16. void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size)
  17. {
  18. do
  19. {
  20. *value = eeprom_read_byte((unsigned char*)pos);
  21. pos++;
  22. value++;
  23. }while(--size);
  24. }
  25. #define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value))
  26. //======================================================================================
  27. #define EEPROM_OFFSET 100
  28. // IMPORTANT: Whenever there are changes made to the variables stored in EEPROM
  29. // in the functions below, also increment the version number. This makes sure that
  30. // the default values are used whenever there is a change to the data, to prevent
  31. // wrong data being written to the variables.
  32. // ALSO: always make sure the variables in the Store and retrieve sections are in the same order.
  33. #define EEPROM_VERSION "V09"
  34. #ifdef EEPROM_SETTINGS
  35. void Config_StoreSettings()
  36. {
  37. char ver[4]= "000";
  38. int i=EEPROM_OFFSET;
  39. EEPROM_WRITE_VAR(i,ver); // invalidate data first
  40. EEPROM_WRITE_VAR(i,axis_steps_per_unit);
  41. EEPROM_WRITE_VAR(i,max_feedrate);
  42. EEPROM_WRITE_VAR(i,max_acceleration_units_per_sq_second);
  43. EEPROM_WRITE_VAR(i,acceleration);
  44. EEPROM_WRITE_VAR(i,retract_acceleration);
  45. EEPROM_WRITE_VAR(i,minimumfeedrate);
  46. EEPROM_WRITE_VAR(i,mintravelfeedrate);
  47. EEPROM_WRITE_VAR(i,minsegmenttime);
  48. EEPROM_WRITE_VAR(i,max_xy_jerk);
  49. EEPROM_WRITE_VAR(i,max_z_jerk);
  50. EEPROM_WRITE_VAR(i,max_e_jerk);
  51. EEPROM_WRITE_VAR(i,add_homeing);
  52. #ifdef DELTA
  53. EEPROM_WRITE_VAR(i,endstop_adj);
  54. #endif
  55. #ifndef ULTIPANEL
  56. int plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP, plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP, plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED;
  57. int absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP, absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP, absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
  58. #endif
  59. EEPROM_WRITE_VAR(i,plaPreheatHotendTemp);
  60. EEPROM_WRITE_VAR(i,plaPreheatHPBTemp);
  61. EEPROM_WRITE_VAR(i,plaPreheatFanSpeed);
  62. EEPROM_WRITE_VAR(i,absPreheatHotendTemp);
  63. EEPROM_WRITE_VAR(i,absPreheatHPBTemp);
  64. EEPROM_WRITE_VAR(i,absPreheatFanSpeed);
  65. #ifdef PIDTEMP
  66. EEPROM_WRITE_VAR(i,Kp);
  67. EEPROM_WRITE_VAR(i,Ki);
  68. EEPROM_WRITE_VAR(i,Kd);
  69. #else
  70. float dummy = 3000.0f;
  71. EEPROM_WRITE_VAR(i,dummy);
  72. dummy = 0.0f;
  73. EEPROM_WRITE_VAR(i,dummy);
  74. EEPROM_WRITE_VAR(i,dummy);
  75. #endif
  76. #ifndef DOGLCD
  77. int lcd_contrast = 32;
  78. #endif
  79. EEPROM_WRITE_VAR(i,lcd_contrast);
  80. char ver2[4]=EEPROM_VERSION;
  81. i=EEPROM_OFFSET;
  82. EEPROM_WRITE_VAR(i,ver2); // validate data
  83. SERIAL_ECHO_START;
  84. SERIAL_ECHOLNPGM("Settings Stored");
  85. }
  86. #endif //EEPROM_SETTINGS
  87. #ifndef DISABLE_M503
  88. void Config_PrintSettings()
  89. { // Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown
  90. SERIAL_ECHO_START;
  91. SERIAL_ECHOLNPGM("Steps per unit:");
  92. SERIAL_ECHO_START;
  93. SERIAL_ECHOPAIR(" M92 X",axis_steps_per_unit[0]);
  94. SERIAL_ECHOPAIR(" Y",axis_steps_per_unit[1]);
  95. SERIAL_ECHOPAIR(" Z",axis_steps_per_unit[2]);
  96. SERIAL_ECHOPAIR(" E",axis_steps_per_unit[3]);
  97. SERIAL_ECHOLN("");
  98. SERIAL_ECHO_START;
  99. SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
  100. SERIAL_ECHO_START;
  101. SERIAL_ECHOPAIR(" M203 X",max_feedrate[0]);
  102. SERIAL_ECHOPAIR(" Y",max_feedrate[1] );
  103. SERIAL_ECHOPAIR(" Z", max_feedrate[2] );
  104. SERIAL_ECHOPAIR(" E", max_feedrate[3]);
  105. SERIAL_ECHOLN("");
  106. SERIAL_ECHO_START;
  107. SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
  108. SERIAL_ECHO_START;
  109. SERIAL_ECHOPAIR(" M201 X" ,max_acceleration_units_per_sq_second[0] );
  110. SERIAL_ECHOPAIR(" Y" , max_acceleration_units_per_sq_second[1] );
  111. SERIAL_ECHOPAIR(" Z" ,max_acceleration_units_per_sq_second[2] );
  112. SERIAL_ECHOPAIR(" E" ,max_acceleration_units_per_sq_second[3]);
  113. SERIAL_ECHOLN("");
  114. SERIAL_ECHO_START;
  115. SERIAL_ECHOLNPGM("Acceleration: S=acceleration, T=retract acceleration");
  116. SERIAL_ECHO_START;
  117. SERIAL_ECHOPAIR(" M204 S",acceleration );
  118. SERIAL_ECHOPAIR(" T" ,retract_acceleration);
  119. SERIAL_ECHOLN("");
  120. SERIAL_ECHO_START;
  121. SERIAL_ECHOLNPGM("Advanced 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)");
  122. SERIAL_ECHO_START;
  123. SERIAL_ECHOPAIR(" M205 S",minimumfeedrate );
  124. SERIAL_ECHOPAIR(" T" ,mintravelfeedrate );
  125. SERIAL_ECHOPAIR(" B" ,minsegmenttime );
  126. SERIAL_ECHOPAIR(" X" ,max_xy_jerk );
  127. SERIAL_ECHOPAIR(" Z" ,max_z_jerk);
  128. SERIAL_ECHOPAIR(" E" ,max_e_jerk);
  129. SERIAL_ECHOLN("");
  130. SERIAL_ECHO_START;
  131. SERIAL_ECHOLNPGM("Home offset (mm):");
  132. SERIAL_ECHO_START;
  133. SERIAL_ECHOPAIR(" M206 X",add_homeing[0] );
  134. SERIAL_ECHOPAIR(" Y" ,add_homeing[1] );
  135. SERIAL_ECHOPAIR(" Z" ,add_homeing[2] );
  136. SERIAL_ECHOLN("");
  137. #ifdef DELTA
  138. SERIAL_ECHO_START;
  139. SERIAL_ECHOLNPGM("Endstop adjustement (mm):");
  140. SERIAL_ECHO_START;
  141. SERIAL_ECHOPAIR(" M666 X",endstop_adj[0] );
  142. SERIAL_ECHOPAIR(" Y" ,endstop_adj[1] );
  143. SERIAL_ECHOPAIR(" Z" ,endstop_adj[2] );
  144. SERIAL_ECHOLN("");
  145. #endif
  146. #ifdef PIDTEMP
  147. SERIAL_ECHO_START;
  148. SERIAL_ECHOLNPGM("PID settings:");
  149. SERIAL_ECHO_START;
  150. SERIAL_ECHOPAIR(" M301 P",Kp);
  151. SERIAL_ECHOPAIR(" I" ,unscalePID_i(Ki));
  152. SERIAL_ECHOPAIR(" D" ,unscalePID_d(Kd));
  153. SERIAL_ECHOLN("");
  154. #endif
  155. }
  156. #endif
  157. #ifdef EEPROM_SETTINGS
  158. void Config_RetrieveSettings()
  159. {
  160. int i=EEPROM_OFFSET;
  161. char stored_ver[4];
  162. char ver[4]=EEPROM_VERSION;
  163. EEPROM_READ_VAR(i,stored_ver); //read stored version
  164. // SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
  165. if (strncmp(ver,stored_ver,3) == 0)
  166. {
  167. // version number match
  168. EEPROM_READ_VAR(i,axis_steps_per_unit);
  169. EEPROM_READ_VAR(i,max_feedrate);
  170. EEPROM_READ_VAR(i,max_acceleration_units_per_sq_second);
  171. // 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)
  172. reset_acceleration_rates();
  173. EEPROM_READ_VAR(i,acceleration);
  174. EEPROM_READ_VAR(i,retract_acceleration);
  175. EEPROM_READ_VAR(i,minimumfeedrate);
  176. EEPROM_READ_VAR(i,mintravelfeedrate);
  177. EEPROM_READ_VAR(i,minsegmenttime);
  178. EEPROM_READ_VAR(i,max_xy_jerk);
  179. EEPROM_READ_VAR(i,max_z_jerk);
  180. EEPROM_READ_VAR(i,max_e_jerk);
  181. EEPROM_READ_VAR(i,add_homeing);
  182. #ifdef DELTA
  183. EEPROM_READ_VAR(i,endstop_adj);
  184. #endif
  185. #ifndef ULTIPANEL
  186. int plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed;
  187. int absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed;
  188. #endif
  189. EEPROM_READ_VAR(i,plaPreheatHotendTemp);
  190. EEPROM_READ_VAR(i,plaPreheatHPBTemp);
  191. EEPROM_READ_VAR(i,plaPreheatFanSpeed);
  192. EEPROM_READ_VAR(i,absPreheatHotendTemp);
  193. EEPROM_READ_VAR(i,absPreheatHPBTemp);
  194. EEPROM_READ_VAR(i,absPreheatFanSpeed);
  195. #ifndef PIDTEMP
  196. float Kp,Ki,Kd;
  197. #endif
  198. // do not need to scale PID values as the values in EEPROM are already scaled
  199. EEPROM_READ_VAR(i,Kp);
  200. EEPROM_READ_VAR(i,Ki);
  201. EEPROM_READ_VAR(i,Kd);
  202. #ifndef DOGLCD
  203. int lcd_contrast;
  204. #endif
  205. EEPROM_READ_VAR(i,lcd_contrast);
  206. // Call updatePID (similar to when we have processed M301)
  207. updatePID();
  208. SERIAL_ECHO_START;
  209. SERIAL_ECHOLNPGM("Stored settings retrieved");
  210. }
  211. else
  212. {
  213. Config_ResetDefault();
  214. }
  215. #ifdef EEPROM_CHITCHAT
  216. Config_PrintSettings();
  217. #endif
  218. }
  219. #endif
  220. void Config_ResetDefault()
  221. {
  222. float tmp1[]=DEFAULT_AXIS_STEPS_PER_UNIT;
  223. float tmp2[]=DEFAULT_MAX_FEEDRATE;
  224. long tmp3[]=DEFAULT_MAX_ACCELERATION;
  225. for (short i=0;i<4;i++)
  226. {
  227. axis_steps_per_unit[i]=tmp1[i];
  228. max_feedrate[i]=tmp2[i];
  229. max_acceleration_units_per_sq_second[i]=tmp3[i];
  230. }
  231. // steps per sq second need to be updated to agree with the units per sq second
  232. reset_acceleration_rates();
  233. acceleration=DEFAULT_ACCELERATION;
  234. retract_acceleration=DEFAULT_RETRACT_ACCELERATION;
  235. minimumfeedrate=DEFAULT_MINIMUMFEEDRATE;
  236. minsegmenttime=DEFAULT_MINSEGMENTTIME;
  237. mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE;
  238. max_xy_jerk=DEFAULT_XYJERK;
  239. max_z_jerk=DEFAULT_ZJERK;
  240. max_e_jerk=DEFAULT_EJERK;
  241. add_homeing[0] = add_homeing[1] = add_homeing[2] = 0;
  242. #ifdef DELTA
  243. endstop_adj[0] = endstop_adj[1] = endstop_adj[2] = 0;
  244. #endif
  245. #ifdef ULTIPANEL
  246. plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP;
  247. plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP;
  248. plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED;
  249. absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP;
  250. absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP;
  251. absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
  252. #endif
  253. #ifdef DOGLCD
  254. lcd_contrast = DEFAULT_LCD_CONTRAST;
  255. #endif
  256. #ifdef PIDTEMP
  257. Kp = DEFAULT_Kp;
  258. Ki = scalePID_i(DEFAULT_Ki);
  259. Kd = scalePID_d(DEFAULT_Kd);
  260. // call updatePID (similar to when we have processed M301)
  261. updatePID();
  262. #ifdef PID_ADD_EXTRUSION_RATE
  263. Kc = DEFAULT_Kc;
  264. #endif//PID_ADD_EXTRUSION_RATE
  265. #endif//PIDTEMP
  266. SERIAL_ECHO_START;
  267. SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
  268. }