EEPROMwrite.h 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
  1. #ifndef EEPROM_H
  2. #define EEPROM_H
  3. #include "Marlin.h"
  4. #include "planner.h"
  5. #include "temperature.h"
  6. //#include <EEPROM.h>
  7. template <class T> int EEPROM_writeAnything(int &ee, const T& value)
  8. {
  9. const byte* p = (const byte*)(const void*)&value;
  10. int i;
  11. for (i = 0; i < (int)sizeof(value); i++)
  12. eeprom_write_byte((unsigned char *)ee++, *p++);
  13. return i;
  14. }
  15. template <class T> int EEPROM_readAnything(int &ee, T& value)
  16. {
  17. byte* p = (byte*)(void*)&value;
  18. int i;
  19. for (i = 0; i < (int)sizeof(value); i++)
  20. *p++ = eeprom_read_byte((unsigned char *)ee++);
  21. return i;
  22. }
  23. //======================================================================================
  24. #define EEPROM_OFFSET 100
  25. // IMPORTANT: Whenever there are changes made to the variables stored in EEPROM
  26. // in the functions below, also increment the version number. This makes sure that
  27. // the default values are used whenever there is a change to the data, to prevent
  28. // wrong data being written to the variables.
  29. // ALSO: always make sure the variables in the Store and retrieve sections are in the same order.
  30. #define EEPROM_VERSION "V05"
  31. inline void EEPROM_StoreSettings()
  32. {
  33. #ifdef EEPROM_SETTINGS
  34. char ver[4]= "000";
  35. int i=EEPROM_OFFSET;
  36. EEPROM_writeAnything(i,ver); // invalidate data first
  37. EEPROM_writeAnything(i,axis_steps_per_unit);
  38. EEPROM_writeAnything(i,max_feedrate);
  39. EEPROM_writeAnything(i,max_acceleration_units_per_sq_second);
  40. EEPROM_writeAnything(i,acceleration);
  41. EEPROM_writeAnything(i,retract_acceleration);
  42. EEPROM_writeAnything(i,minimumfeedrate);
  43. EEPROM_writeAnything(i,mintravelfeedrate);
  44. EEPROM_writeAnything(i,minsegmenttime);
  45. EEPROM_writeAnything(i,max_xy_jerk);
  46. EEPROM_writeAnything(i,max_z_jerk);
  47. EEPROM_writeAnything(i,max_e_jerk);
  48. #ifdef PIDTEMP
  49. EEPROM_writeAnything(i,Kp);
  50. EEPROM_writeAnything(i,Ki);
  51. EEPROM_writeAnything(i,Kd);
  52. #else
  53. EEPROM_writeAnything(i,3000);
  54. EEPROM_writeAnything(i,0);
  55. EEPROM_writeAnything(i,0);
  56. #endif
  57. char ver2[4]=EEPROM_VERSION;
  58. i=EEPROM_OFFSET;
  59. EEPROM_writeAnything(i,ver2); // validate data
  60. SERIAL_ECHO_START;
  61. SERIAL_ECHOLNPGM("Settings Stored");
  62. #endif //EEPROM_SETTINGS
  63. }
  64. inline void EEPROM_printSettings()
  65. { // if def=true, the default values will be used
  66. #ifdef EEPROM_SETTINGS
  67. SERIAL_ECHO_START;
  68. SERIAL_ECHOLNPGM("Steps per unit:");
  69. SERIAL_ECHO_START;
  70. SERIAL_ECHOPAIR(" M92 X",axis_steps_per_unit[0]);
  71. SERIAL_ECHOPAIR(" Y",axis_steps_per_unit[1]);
  72. SERIAL_ECHOPAIR(" Z",axis_steps_per_unit[2]);
  73. SERIAL_ECHOPAIR(" E",axis_steps_per_unit[3]);
  74. SERIAL_ECHOLN("");
  75. SERIAL_ECHO_START;
  76. SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
  77. SERIAL_ECHO_START;
  78. SERIAL_ECHOPAIR(" M203 X",max_feedrate[0]);
  79. SERIAL_ECHOPAIR(" Y",max_feedrate[1] );
  80. SERIAL_ECHOPAIR(" Z", max_feedrate[2] );
  81. SERIAL_ECHOPAIR(" E", max_feedrate[3]);
  82. SERIAL_ECHOLN("");
  83. SERIAL_ECHO_START;
  84. SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
  85. SERIAL_ECHO_START;
  86. SERIAL_ECHOPAIR(" M201 X" ,max_acceleration_units_per_sq_second[0] );
  87. SERIAL_ECHOPAIR(" Y" , max_acceleration_units_per_sq_second[1] );
  88. SERIAL_ECHOPAIR(" Z" ,max_acceleration_units_per_sq_second[2] );
  89. SERIAL_ECHOPAIR(" E" ,max_acceleration_units_per_sq_second[3]);
  90. SERIAL_ECHOLN("");
  91. SERIAL_ECHO_START;
  92. SERIAL_ECHOLNPGM("Acceleration: S=acceleration, T=retract acceleration");
  93. SERIAL_ECHO_START;
  94. SERIAL_ECHOPAIR(" M204 S",acceleration );
  95. SERIAL_ECHOPAIR(" T" ,retract_acceleration);
  96. SERIAL_ECHOLN("");
  97. SERIAL_ECHO_START;
  98. 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)");
  99. SERIAL_ECHO_START;
  100. SERIAL_ECHOPAIR(" M205 S",minimumfeedrate );
  101. SERIAL_ECHOPAIR(" T" ,mintravelfeedrate );
  102. SERIAL_ECHOPAIR(" B" ,minsegmenttime );
  103. SERIAL_ECHOPAIR(" X" ,max_xy_jerk );
  104. SERIAL_ECHOPAIR(" Z" ,max_z_jerk);
  105. SERIAL_ECHOPAIR(" E" ,max_e_jerk);
  106. SERIAL_ECHOLN("");
  107. #ifdef PIDTEMP
  108. SERIAL_ECHO_START;
  109. SERIAL_ECHOLNPGM("PID settings:");
  110. SERIAL_ECHO_START;
  111. SERIAL_ECHOPAIR(" M301 P",Kp);
  112. SERIAL_ECHOPAIR(" I" ,Ki/PID_dT);
  113. SERIAL_ECHOPAIR(" D" ,Kd*PID_dT);
  114. SERIAL_ECHOLN("");
  115. #endif
  116. #endif
  117. }
  118. inline void EEPROM_RetrieveSettings(bool def=false)
  119. { // if def=true, the default values will be used
  120. #ifdef EEPROM_SETTINGS
  121. int i=EEPROM_OFFSET;
  122. char stored_ver[4];
  123. char ver[4]=EEPROM_VERSION;
  124. EEPROM_readAnything(i,stored_ver); //read stored version
  125. // SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
  126. if ((!def)&&(strncmp(ver,stored_ver,3)==0))
  127. { // version number match
  128. EEPROM_readAnything(i,axis_steps_per_unit);
  129. EEPROM_readAnything(i,max_feedrate);
  130. EEPROM_readAnything(i,max_acceleration_units_per_sq_second);
  131. EEPROM_readAnything(i,acceleration);
  132. EEPROM_readAnything(i,retract_acceleration);
  133. EEPROM_readAnything(i,minimumfeedrate);
  134. EEPROM_readAnything(i,mintravelfeedrate);
  135. EEPROM_readAnything(i,minsegmenttime);
  136. EEPROM_readAnything(i,max_xy_jerk);
  137. EEPROM_readAnything(i,max_z_jerk);
  138. EEPROM_readAnything(i,max_e_jerk);
  139. #ifndef PIDTEMP
  140. float Kp,Ki,Kd;
  141. #endif
  142. EEPROM_readAnything(i,Kp);
  143. EEPROM_readAnything(i,Ki);
  144. EEPROM_readAnything(i,Kd);
  145. SERIAL_ECHO_START;
  146. SERIAL_ECHOLNPGM("Stored settings retreived:");
  147. }
  148. else
  149. #endif
  150. {
  151. float tmp1[]=DEFAULT_AXIS_STEPS_PER_UNIT;
  152. float tmp2[]=DEFAULT_MAX_FEEDRATE;
  153. long tmp3[]=DEFAULT_MAX_ACCELERATION;
  154. for (short i=0;i<4;i++)
  155. {
  156. axis_steps_per_unit[i]=tmp1[i];
  157. max_feedrate[i]=tmp2[i];
  158. max_acceleration_units_per_sq_second[i]=tmp3[i];
  159. }
  160. acceleration=DEFAULT_ACCELERATION;
  161. retract_acceleration=DEFAULT_RETRACT_ACCELERATION;
  162. minimumfeedrate=DEFAULT_MINIMUMFEEDRATE;
  163. minsegmenttime=DEFAULT_MINSEGMENTTIME;
  164. mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE;
  165. max_xy_jerk=DEFAULT_XYJERK;
  166. max_z_jerk=DEFAULT_ZJERK;
  167. max_e_jerk=DEFAULT_EJERK;
  168. SERIAL_ECHO_START;
  169. SERIAL_ECHOLN("Using Default settings:");
  170. }
  171. #ifdef EEPROM_CHITCHAT
  172. EEPROM_printSettings();
  173. #endif
  174. }
  175. #endif