Marlin/EEPROMwrite.h

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