2012-11-07 16:16:43 -06:00
|
|
|
#include "Marlin.h"
|
|
|
|
|
#include "planner.h"
|
|
|
|
|
#include "temperature.h"
|
|
|
|
|
#include "ultralcd.h"
|
|
|
|
|
#include "ConfigurationStore.h"
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
|
|
|
|
void _EEPROM_writeData(int &pos, uint8_t* value, uint8_t size)
|
|
|
|
|
{
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
eeprom_write_byte((unsigned char*)pos, *value);
|
|
|
|
|
pos++;
|
|
|
|
|
value++;
|
2012-11-07 16:16:43 -06:00
|
|
|
}while(--size);
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
}
|
2012-11-07 16:16:43 -06:00
|
|
|
#define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value))
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size)
|
|
|
|
|
{
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
*value = eeprom_read_byte((unsigned char*)pos);
|
|
|
|
|
pos++;
|
|
|
|
|
value++;
|
2012-11-07 16:16:43 -06:00
|
|
|
}while(--size);
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
}
|
2012-11-07 16:16:43 -06:00
|
|
|
#define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value))
|
|
|
|
|
//======================================================================================
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define EEPROM_OFFSET 100
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// IMPORTANT: Whenever there are changes made to the variables stored in EEPROM
|
|
|
|
|
// in the functions below, also increment the version number. This makes sure that
|
|
|
|
|
// 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.
|
2014-06-23 10:09:57 -05:00
|
|
|
|
2014-02-26 10:29:27 -06:00
|
|
|
#define EEPROM_VERSION "V10"
|
2014-06-23 10:09:57 -05:00
|
|
|
#ifdef DELTA
|
|
|
|
|
#undef EEPROM_VERSION
|
|
|
|
|
#define EEPROM_VERSION "V11"
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef SCARA
|
|
|
|
|
#undef EEPROM_VERSION
|
|
|
|
|
#define EEPROM_VERSION "V12"
|
2014-02-26 10:29:27 -06:00
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
|
|
|
|
|
#ifdef EEPROM_SETTINGS
|
|
|
|
|
void Config_StoreSettings()
|
|
|
|
|
{
|
|
|
|
|
char ver[4]= "000";
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
int i=EEPROM_OFFSET;
|
2012-11-07 16:16:43 -06:00
|
|
|
EEPROM_WRITE_VAR(i,ver); // invalidate data first
|
2014-06-23 10:09:57 -05:00
|
|
|
EEPROM_WRITE_VAR(i,axis_steps_per_unit);
|
2012-11-07 16:16:43 -06:00
|
|
|
EEPROM_WRITE_VAR(i,max_feedrate);
|
|
|
|
|
EEPROM_WRITE_VAR(i,max_acceleration_units_per_sq_second);
|
|
|
|
|
EEPROM_WRITE_VAR(i,acceleration);
|
|
|
|
|
EEPROM_WRITE_VAR(i,retract_acceleration);
|
|
|
|
|
EEPROM_WRITE_VAR(i,minimumfeedrate);
|
|
|
|
|
EEPROM_WRITE_VAR(i,mintravelfeedrate);
|
|
|
|
|
EEPROM_WRITE_VAR(i,minsegmenttime);
|
|
|
|
|
EEPROM_WRITE_VAR(i,max_xy_jerk);
|
|
|
|
|
EEPROM_WRITE_VAR(i,max_z_jerk);
|
|
|
|
|
EEPROM_WRITE_VAR(i,max_e_jerk);
|
2014-10-05 15:20:53 -05:00
|
|
|
EEPROM_WRITE_VAR(i,add_homing);
|
2013-08-27 18:15:20 -05:00
|
|
|
#ifdef DELTA
|
|
|
|
|
EEPROM_WRITE_VAR(i,endstop_adj);
|
2014-02-17 22:50:59 -06:00
|
|
|
EEPROM_WRITE_VAR(i,delta_radius);
|
|
|
|
|
EEPROM_WRITE_VAR(i,delta_diagonal_rod);
|
|
|
|
|
EEPROM_WRITE_VAR(i,delta_segments_per_second);
|
2013-08-27 18:15:20 -05:00
|
|
|
#endif
|
2012-11-10 07:37:01 -06:00
|
|
|
#ifndef ULTIPANEL
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
int plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP, plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP, plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED;
|
|
|
|
|
int absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP, absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP, absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
|
2012-11-10 07:37:01 -06:00
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
EEPROM_WRITE_VAR(i,plaPreheatHotendTemp);
|
|
|
|
|
EEPROM_WRITE_VAR(i,plaPreheatHPBTemp);
|
|
|
|
|
EEPROM_WRITE_VAR(i,plaPreheatFanSpeed);
|
|
|
|
|
EEPROM_WRITE_VAR(i,absPreheatHotendTemp);
|
|
|
|
|
EEPROM_WRITE_VAR(i,absPreheatHPBTemp);
|
|
|
|
|
EEPROM_WRITE_VAR(i,absPreheatFanSpeed);
|
2014-01-16 14:13:46 -06:00
|
|
|
EEPROM_WRITE_VAR(i,zprobe_zoffset);
|
2012-11-07 16:16:43 -06:00
|
|
|
#ifdef PIDTEMP
|
|
|
|
|
EEPROM_WRITE_VAR(i,Kp);
|
|
|
|
|
EEPROM_WRITE_VAR(i,Ki);
|
|
|
|
|
EEPROM_WRITE_VAR(i,Kd);
|
|
|
|
|
#else
|
2013-04-12 11:04:32 -05:00
|
|
|
float dummy = 3000.0f;
|
|
|
|
|
EEPROM_WRITE_VAR(i,dummy);
|
|
|
|
|
dummy = 0.0f;
|
|
|
|
|
EEPROM_WRITE_VAR(i,dummy);
|
|
|
|
|
EEPROM_WRITE_VAR(i,dummy);
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
#endif
|
2013-07-14 03:28:26 -05:00
|
|
|
#ifndef DOGLCD
|
|
|
|
|
int lcd_contrast = 32;
|
|
|
|
|
#endif
|
|
|
|
|
EEPROM_WRITE_VAR(i,lcd_contrast);
|
2014-06-23 10:09:57 -05:00
|
|
|
#ifdef SCARA
|
|
|
|
|
EEPROM_WRITE_VAR(i,axis_scaling); // Add scaling for SCARA
|
|
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
char ver2[4]=EEPROM_VERSION;
|
|
|
|
|
i=EEPROM_OFFSET;
|
|
|
|
|
EEPROM_WRITE_VAR(i,ver2); // validate data
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM("Settings Stored");
|
|
|
|
|
}
|
|
|
|
|
#endif //EEPROM_SETTINGS
|
|
|
|
|
|
|
|
|
|
|
2013-09-14 06:50:09 -05:00
|
|
|
#ifndef DISABLE_M503
|
2012-11-07 16:16:43 -06:00
|
|
|
void Config_PrintSettings()
|
|
|
|
|
{ // Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM("Steps per unit:");
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M92 X",axis_steps_per_unit[0]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Y",axis_steps_per_unit[1]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Z",axis_steps_per_unit[2]);
|
|
|
|
|
SERIAL_ECHOPAIR(" E",axis_steps_per_unit[3]);
|
|
|
|
|
SERIAL_ECHOLN("");
|
|
|
|
|
|
|
|
|
|
SERIAL_ECHO_START;
|
2014-06-23 10:09:57 -05:00
|
|
|
#ifdef SCARA
|
|
|
|
|
SERIAL_ECHOLNPGM("Scaling factors:");
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M365 X",axis_scaling[0]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Y",axis_scaling[1]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Z",axis_scaling[2]);
|
|
|
|
|
SERIAL_ECHOLN("");
|
|
|
|
|
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M203 X",max_feedrate[0]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Y",max_feedrate[1] );
|
|
|
|
|
SERIAL_ECHOPAIR(" Z", max_feedrate[2] );
|
|
|
|
|
SERIAL_ECHOPAIR(" E", max_feedrate[3]);
|
|
|
|
|
SERIAL_ECHOLN("");
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M201 X" ,max_acceleration_units_per_sq_second[0] );
|
|
|
|
|
SERIAL_ECHOPAIR(" Y" , max_acceleration_units_per_sq_second[1] );
|
|
|
|
|
SERIAL_ECHOPAIR(" Z" ,max_acceleration_units_per_sq_second[2] );
|
|
|
|
|
SERIAL_ECHOPAIR(" E" ,max_acceleration_units_per_sq_second[3]);
|
|
|
|
|
SERIAL_ECHOLN("");
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM("Acceleration: S=acceleration, T=retract acceleration");
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M204 S",acceleration );
|
|
|
|
|
SERIAL_ECHOPAIR(" T" ,retract_acceleration);
|
|
|
|
|
SERIAL_ECHOLN("");
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHO_START;
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
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)");
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M205 S",minimumfeedrate );
|
|
|
|
|
SERIAL_ECHOPAIR(" T" ,mintravelfeedrate );
|
|
|
|
|
SERIAL_ECHOPAIR(" B" ,minsegmenttime );
|
|
|
|
|
SERIAL_ECHOPAIR(" X" ,max_xy_jerk );
|
|
|
|
|
SERIAL_ECHOPAIR(" Z" ,max_z_jerk);
|
|
|
|
|
SERIAL_ECHOPAIR(" E" ,max_e_jerk);
|
|
|
|
|
SERIAL_ECHOLN("");
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM("Home offset (mm):");
|
|
|
|
|
SERIAL_ECHO_START;
|
2014-10-05 15:20:53 -05:00
|
|
|
SERIAL_ECHOPAIR(" M206 X",add_homing[0] );
|
|
|
|
|
SERIAL_ECHOPAIR(" Y" ,add_homing[1] );
|
|
|
|
|
SERIAL_ECHOPAIR(" Z" ,add_homing[2] );
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHOLN("");
|
2013-08-27 18:15:20 -05:00
|
|
|
#ifdef DELTA
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM("Endstop adjustement (mm):");
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M666 X",endstop_adj[0] );
|
|
|
|
|
SERIAL_ECHOPAIR(" Y" ,endstop_adj[1] );
|
|
|
|
|
SERIAL_ECHOPAIR(" Z" ,endstop_adj[2] );
|
2014-02-17 22:50:59 -06:00
|
|
|
SERIAL_ECHOLN("");
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM("Delta settings: L=delta_diagonal_rod, R=delta_radius, S=delta_segments_per_second");
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M665 L",delta_diagonal_rod );
|
|
|
|
|
SERIAL_ECHOPAIR(" R" ,delta_radius );
|
|
|
|
|
SERIAL_ECHOPAIR(" S" ,delta_segments_per_second );
|
|
|
|
|
SERIAL_ECHOLN("");
|
2013-08-27 18:15:20 -05:00
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
#ifdef PIDTEMP
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM("PID settings:");
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M301 P",Kp);
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
SERIAL_ECHOPAIR(" I" ,unscalePID_i(Ki));
|
|
|
|
|
SERIAL_ECHOPAIR(" D" ,unscalePID_d(Kd));
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHOLN("");
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef EEPROM_SETTINGS
|
|
|
|
|
void Config_RetrieveSettings()
|
|
|
|
|
{
|
|
|
|
|
int i=EEPROM_OFFSET;
|
|
|
|
|
char stored_ver[4];
|
|
|
|
|
char ver[4]=EEPROM_VERSION;
|
|
|
|
|
EEPROM_READ_VAR(i,stored_ver); //read stored version
|
|
|
|
|
// SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
|
|
|
|
|
if (strncmp(ver,stored_ver,3) == 0)
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
{
|
2012-11-07 16:16:43 -06:00
|
|
|
// version number match
|
2014-06-23 10:09:57 -05:00
|
|
|
EEPROM_READ_VAR(i,axis_steps_per_unit);
|
2012-11-07 16:16:43 -06:00
|
|
|
EEPROM_READ_VAR(i,max_feedrate);
|
|
|
|
|
EEPROM_READ_VAR(i,max_acceleration_units_per_sq_second);
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
|
|
|
|
// 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)
|
|
|
|
|
reset_acceleration_rates();
|
|
|
|
|
|
2012-11-07 16:16:43 -06:00
|
|
|
EEPROM_READ_VAR(i,acceleration);
|
|
|
|
|
EEPROM_READ_VAR(i,retract_acceleration);
|
|
|
|
|
EEPROM_READ_VAR(i,minimumfeedrate);
|
|
|
|
|
EEPROM_READ_VAR(i,mintravelfeedrate);
|
|
|
|
|
EEPROM_READ_VAR(i,minsegmenttime);
|
|
|
|
|
EEPROM_READ_VAR(i,max_xy_jerk);
|
|
|
|
|
EEPROM_READ_VAR(i,max_z_jerk);
|
|
|
|
|
EEPROM_READ_VAR(i,max_e_jerk);
|
2014-10-05 15:20:53 -05:00
|
|
|
EEPROM_READ_VAR(i,add_homing);
|
2013-08-27 18:15:20 -05:00
|
|
|
#ifdef DELTA
|
2014-02-17 22:50:59 -06:00
|
|
|
EEPROM_READ_VAR(i,endstop_adj);
|
|
|
|
|
EEPROM_READ_VAR(i,delta_radius);
|
|
|
|
|
EEPROM_READ_VAR(i,delta_diagonal_rod);
|
|
|
|
|
EEPROM_READ_VAR(i,delta_segments_per_second);
|
2013-08-27 18:15:20 -05:00
|
|
|
#endif
|
2012-11-10 07:37:01 -06:00
|
|
|
#ifndef ULTIPANEL
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
int plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed;
|
|
|
|
|
int absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed;
|
2012-11-10 07:37:01 -06:00
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
EEPROM_READ_VAR(i,plaPreheatHotendTemp);
|
|
|
|
|
EEPROM_READ_VAR(i,plaPreheatHPBTemp);
|
|
|
|
|
EEPROM_READ_VAR(i,plaPreheatFanSpeed);
|
|
|
|
|
EEPROM_READ_VAR(i,absPreheatHotendTemp);
|
|
|
|
|
EEPROM_READ_VAR(i,absPreheatHPBTemp);
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
EEPROM_READ_VAR(i,absPreheatFanSpeed);
|
2014-01-16 14:13:46 -06:00
|
|
|
EEPROM_READ_VAR(i,zprobe_zoffset);
|
2012-11-07 16:16:43 -06:00
|
|
|
#ifndef PIDTEMP
|
|
|
|
|
float Kp,Ki,Kd;
|
|
|
|
|
#endif
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
// do not need to scale PID values as the values in EEPROM are already scaled
|
2012-11-07 16:16:43 -06:00
|
|
|
EEPROM_READ_VAR(i,Kp);
|
|
|
|
|
EEPROM_READ_VAR(i,Ki);
|
|
|
|
|
EEPROM_READ_VAR(i,Kd);
|
2013-07-14 03:28:26 -05:00
|
|
|
#ifndef DOGLCD
|
|
|
|
|
int lcd_contrast;
|
|
|
|
|
#endif
|
|
|
|
|
EEPROM_READ_VAR(i,lcd_contrast);
|
2014-06-23 10:09:57 -05:00
|
|
|
#ifdef SCARA
|
|
|
|
|
EEPROM_READ_VAR(i,axis_scaling);
|
|
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
// Call updatePID (similar to when we have processed M301)
|
|
|
|
|
updatePID();
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHO_START;
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
SERIAL_ECHOLNPGM("Stored settings retrieved");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
Config_ResetDefault();
|
2012-11-07 16:16:43 -06:00
|
|
|
}
|
2013-09-14 06:50:09 -05:00
|
|
|
#ifdef EEPROM_CHITCHAT
|
|
|
|
|
Config_PrintSettings();
|
|
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
}
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
void Config_ResetDefault()
|
2012-11-07 16:16:43 -06:00
|
|
|
{
|
|
|
|
|
float tmp1[]=DEFAULT_AXIS_STEPS_PER_UNIT;
|
|
|
|
|
float tmp2[]=DEFAULT_MAX_FEEDRATE;
|
|
|
|
|
long tmp3[]=DEFAULT_MAX_ACCELERATION;
|
|
|
|
|
for (short i=0;i<4;i++)
|
|
|
|
|
{
|
|
|
|
|
axis_steps_per_unit[i]=tmp1[i];
|
|
|
|
|
max_feedrate[i]=tmp2[i];
|
|
|
|
|
max_acceleration_units_per_sq_second[i]=tmp3[i];
|
2014-06-23 10:09:57 -05:00
|
|
|
#ifdef SCARA
|
|
|
|
|
axis_scaling[i]=1;
|
|
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
}
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
|
|
|
|
// steps per sq second need to be updated to agree with the units per sq second
|
|
|
|
|
reset_acceleration_rates();
|
|
|
|
|
|
2012-11-07 16:16:43 -06:00
|
|
|
acceleration=DEFAULT_ACCELERATION;
|
|
|
|
|
retract_acceleration=DEFAULT_RETRACT_ACCELERATION;
|
|
|
|
|
minimumfeedrate=DEFAULT_MINIMUMFEEDRATE;
|
|
|
|
|
minsegmenttime=DEFAULT_MINSEGMENTTIME;
|
|
|
|
|
mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE;
|
|
|
|
|
max_xy_jerk=DEFAULT_XYJERK;
|
|
|
|
|
max_z_jerk=DEFAULT_ZJERK;
|
|
|
|
|
max_e_jerk=DEFAULT_EJERK;
|
2014-10-05 15:20:53 -05:00
|
|
|
add_homing[0] = add_homing[1] = add_homing[2] = 0;
|
2013-08-27 18:15:20 -05:00
|
|
|
#ifdef DELTA
|
2014-02-17 22:50:59 -06:00
|
|
|
endstop_adj[0] = endstop_adj[1] = endstop_adj[2] = 0;
|
|
|
|
|
delta_radius= DELTA_RADIUS;
|
|
|
|
|
delta_diagonal_rod= DELTA_DIAGONAL_ROD;
|
|
|
|
|
delta_segments_per_second= DELTA_SEGMENTS_PER_SECOND;
|
|
|
|
|
recalc_delta_settings(delta_radius, delta_diagonal_rod);
|
2013-08-27 18:15:20 -05:00
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
#ifdef ULTIPANEL
|
|
|
|
|
plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP;
|
|
|
|
|
plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP;
|
|
|
|
|
plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED;
|
|
|
|
|
absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP;
|
|
|
|
|
absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP;
|
|
|
|
|
absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
|
|
|
|
|
#endif
|
2014-01-17 09:09:58 -06:00
|
|
|
#ifdef ENABLE_AUTO_BED_LEVELING
|
2014-01-16 14:13:46 -06:00
|
|
|
zprobe_zoffset = -Z_PROBE_OFFSET_FROM_EXTRUDER;
|
2014-01-17 09:09:58 -06:00
|
|
|
#endif
|
2013-07-14 03:28:26 -05:00
|
|
|
#ifdef DOGLCD
|
|
|
|
|
lcd_contrast = DEFAULT_LCD_CONTRAST;
|
|
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
#ifdef PIDTEMP
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
Kp = DEFAULT_Kp;
|
|
|
|
|
Ki = scalePID_i(DEFAULT_Ki);
|
|
|
|
|
Kd = scalePID_d(DEFAULT_Kd);
|
|
|
|
|
|
|
|
|
|
// call updatePID (similar to when we have processed M301)
|
|
|
|
|
updatePID();
|
|
|
|
|
|
2012-11-07 16:16:43 -06:00
|
|
|
#ifdef PID_ADD_EXTRUSION_RATE
|
|
|
|
|
Kc = DEFAULT_Kc;
|
|
|
|
|
#endif//PID_ADD_EXTRUSION_RATE
|
|
|
|
|
#endif//PIDTEMP
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
|
|
|
|
|
|
2012-11-07 16:16:43 -06:00
|
|
|
}
|
