pingu_98/Sprinter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor eeprom routines to make it possible to modify the value of a single parameter

Browse source
This commit is contained in:
Felipe Corrêa da Silva Sanches 2012-06-25 19:32:42 -03:00
parent 7975010946
commit e0d9840439
4 changed files with 64 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
Sprinter/Configuration.h
View file

@ -199,6 +199,11 @@ const long min_time_before_dir_change = 30; //milliseconds
#define DEFAULT_MINIMUMFEEDRATE 0.0 // minimum feedrate
#define DEFAULT_MINTRAVELFEEDRATE 0.0
#define _MIN_SEG_TIME 20000
#define DEFAULT_KP 2560
#define DEFAULT_KI 64
#define DEFAULT_KD 4096
// If defined the movements slow down when the look ahead buffer is only half full
#define SLOWDOWN

2
Sprinter/Sprinter.pde
View file

@ -249,6 +249,8 @@ float retract_acceleration = _RETRACT_ACCELERATION; // Normal acceleration mm/s^
float max_xy_jerk = _MAX_XY_JERK;
float max_z_jerk = _MAX_Z_JERK;
float max_e_jerk = _MAX_E_JERK;
unsigned long min_seg_time = _MIN_SEG_TIME;
unsigned int Kp = DEFAULT_KP, Ki = DEFAULT_KI, Kd = DEFAULT_KD;
long max_acceleration_units_per_sq_second[4] = _MAX_ACCELERATION_UNITS_PER_SQ_SECOND; // X, Y, Z and E max acceleration in mm/s^2 for printing moves or retracts

86
Sprinter/store_eeprom.cpp
View file

@ -29,21 +29,21 @@
//======================================================================================
//========================= Read / Write EEPROM =======================================
template <class T> int EEPROM_writeAnything(int &ee, const T& value)
template <class T> int EEPROM_write_setting(int address, const T& value)
{
const byte* p = (const byte*)(const void*)&value;
int i;
for (i = 0; i < (int)sizeof(value); i++)
eeprom_write_byte((unsigned char *)ee++, *p++);
eeprom_write_byte((unsigned char *)address++, *p++);
return i;
}
template <class T> int EEPROM_readAnything(int &ee, T& value)
template <class T> int EEPROM_read_setting(int address, T& value)
{
byte* p = (byte*)(void*)&value;
int i;
for (i = 0; i < (int)sizeof(value); i++)
*p++ = eeprom_read_byte((unsigned char *)ee++);
*p++ = eeprom_read_byte((unsigned char *)address++);
return i;
}
//======================================================================================
@ -51,35 +51,27 @@ template <class T> int EEPROM_readAnything(int &ee, T& value)
void EEPROM_StoreSettings()
{
unsigned long ul_help = 20000;
unsigned int ui_help = 0;
char ver[4]= "000";
int i=EEPROM_OFFSET;
EEPROM_writeAnything(i,ver); // invalidate data first
EEPROM_writeAnything(i,axis_steps_per_unit);
EEPROM_writeAnything(i,max_feedrate);
EEPROM_writeAnything(i,max_acceleration_units_per_sq_second);
EEPROM_writeAnything(i,move_acceleration);
EEPROM_writeAnything(i,retract_acceleration);
EEPROM_writeAnything(i,minimumfeedrate);
EEPROM_writeAnything(i,mintravelfeedrate);
EEPROM_writeAnything(i,ul_help); //Min Segment Time, not used yet
EEPROM_writeAnything(i,max_xy_jerk);
EEPROM_writeAnything(i,max_z_jerk);
EEPROM_writeAnything(i,max_e_jerk);
EEPROM_write_setting(EEPROM_OFFSET, ver); // invalidate data first
EEPROM_write_setting(axis_steps_per_unit_address, axis_steps_per_unit);
EEPROM_write_setting(max_feedrate_address, max_feedrate);
EEPROM_write_setting(max_acceleration_units_per_sq_second_address, max_acceleration_units_per_sq_second);
EEPROM_write_setting(move_acceleration_address, move_acceleration);
EEPROM_write_setting(retract_acceleration_address, retract_acceleration);
EEPROM_write_setting(minimumfeedrate_address, minimumfeedrate);
EEPROM_write_setting(mintravelfeedrate_address, mintravelfeedrate);
EEPROM_write_setting(min_seg_time_address, min_seg_time); //Min Segment Time, not used yet
EEPROM_write_setting(max_xy_jerk_address, max_xy_jerk);
EEPROM_write_setting(max_z_jerk_address, max_z_jerk);
EEPROM_write_setting(max_e_jerk_address, max_e_jerk);
//PID Settings, not used yet --> placeholder
ui_help = 2560;
EEPROM_writeAnything(i,ui_help); //Kp
ui_help = 64;
EEPROM_writeAnything(i,ui_help); //Ki
ui_help = 4096;
EEPROM_writeAnything(i,ui_help); //Kd
EEPROM_write_setting(Kp_address, Kp); //Kp
EEPROM_write_setting(Ki_address, Ki); //Ki
EEPROM_write_setting(Kd_address, Kd); //Kd
char ver2[4]=EEPROM_VERSION;
i=EEPROM_OFFSET;
EEPROM_writeAnything(i,ver2); // validate data
EEPROM_write_setting(EEPROM_OFFSET, ver2); // validate data
showString(PSTR("Settings Stored\r\n"));
}
@ -87,7 +79,6 @@ void EEPROM_StoreSettings()
void EEPROM_printSettings()
{
// if def=true, the default values will be used
#ifdef PRINT_EEPROM_SETTING
showString(PSTR("Steps per unit:\r\n"));
showString(PSTR(" M92 X"));
@ -163,27 +154,24 @@ void EEPROM_RetrieveSettings(bool def, bool printout)
int i=EEPROM_OFFSET;
char stored_ver[4];
char ver[4]=EEPROM_VERSION;
unsigned long ul_help = 0;
EEPROM_readAnything(i,stored_ver); //read stored version
EEPROM_read_setting(EEPROM_OFFSET,stored_ver); //read stored version
if ((!def)&&(strncmp(ver,stored_ver,3)==0))
{ // version number match
EEPROM_readAnything(i,axis_steps_per_unit);
EEPROM_readAnything(i,max_feedrate);
EEPROM_readAnything(i,max_acceleration_units_per_sq_second);
EEPROM_readAnything(i,move_acceleration);
EEPROM_readAnything(i,retract_acceleration);
EEPROM_readAnything(i,minimumfeedrate);
EEPROM_readAnything(i,mintravelfeedrate);
EEPROM_readAnything(i,ul_help); //min Segmenttime --> not used yet
EEPROM_readAnything(i,max_xy_jerk);
EEPROM_readAnything(i,max_z_jerk);
EEPROM_readAnything(i,max_e_jerk);
unsigned int Kp,Ki,Kd;
EEPROM_readAnything(i,Kp);
EEPROM_readAnything(i,Ki);
EEPROM_readAnything(i,Kd);
EEPROM_read_setting(axis_steps_per_unit_address, axis_steps_per_unit);
EEPROM_read_setting(max_feedrate_address, max_feedrate);
EEPROM_read_setting(max_acceleration_units_per_sq_second_address, max_acceleration_units_per_sq_second);
EEPROM_read_setting(move_acceleration_address, move_acceleration);
EEPROM_read_setting(retract_acceleration_address, retract_acceleration);
EEPROM_read_setting(minimumfeedrate_address, minimumfeedrate);
EEPROM_read_setting(mintravelfeedrate_address, mintravelfeedrate);
EEPROM_read_setting(min_seg_time_address, min_seg_time); //min Segmenttime --> not used yet
EEPROM_read_setting(max_xy_jerk_address, max_xy_jerk);
EEPROM_read_setting(max_z_jerk_address, max_z_jerk);
EEPROM_read_setting(max_e_jerk_address, max_e_jerk);
EEPROM_read_setting(Kp_address, Kp);
EEPROM_read_setting(Ki_address, Ki);
EEPROM_read_setting(Kd_address, Kd);
showString(PSTR("Stored settings retreived\r\n"));
}
@ -206,6 +194,10 @@ void EEPROM_RetrieveSettings(bool def, bool printout)
max_xy_jerk=_MAX_XY_JERK;
max_z_jerk=_MAX_Z_JERK;
max_e_jerk=_MAX_E_JERK;
min_seg_time=_MIN_SEG_TIME;
Kp = DEFAULT_KP;
Ki = DEFAULT_KI;
Kd = DEFAULT_KD;
showString(PSTR("Using Default settings\r\n"));
}

18
Sprinter/store_eeprom.h
View file

@ -27,7 +27,7 @@
// the default values are used whenever there is a change to the data, to prevent
// wrong data being written to the variables.
// ALSO: always make sure the variables in the Store and retrieve sections are in the same order.
#define EEPROM_VERSION "S02"
#define EEPROM_VERSION "S03"
extern float axis_steps_per_unit[4];
@ -40,7 +40,23 @@ extern float minimumfeedrate;
extern float max_xy_jerk;
extern float max_z_jerk;
extern float max_e_jerk;
extern unsigned long min_seg_time;
extern unsigned int Kp, Ki, Kd;
#define axis_steps_per_unit_address (EEPROM_OFFSET + 4)
#define max_feedrate_address (EEPROM_OFFSET + 20)
#define max_acceleration_units_per_sq_second_address (EEPROM_OFFSET + 36)
#define move_acceleration_address (EEPROM_OFFSET + 52)
#define retract_acceleration_address (EEPROM_OFFSET + 56)
#define mintravelfeedrate_address (EEPROM_OFFSET + 60)
#define minimumfeedrate_address (EEPROM_OFFSET + 64)
#define max_xy_jerk_address (EEPROM_OFFSET + 68)
#define max_z_jerk_address (EEPROM_OFFSET + 72)
#define max_e_jerk_address (EEPROM_OFFSET + 76)
#define min_seg_time_address (EEPROM_OFFSET + 80)
#define Kp_address (EEPROM_OFFSET + 84)
#define Ki_address (EEPROM_OFFSET + 86)
#define Kd_address (EEPROM_OFFSET + 88)
extern void EEPROM_RetrieveSettings(bool def, bool printout );
extern void EEPROM_printSettings();