Merge remote-tracking branch 'origin/Marlin_v1' into Marlin_v1

Marlin/Configuration.h

 #ifndef __CONFIGURATION_H
 #define __CONFIGURATION_H
 
-//#define DEBUG_STEPS
 
-#define MM_PER_ARC_SEGMENT 1
-#define N_ARC_CORRECTION 25
+
+// This determines the communication speed of the printer
+//#define BAUDRATE 250000
+#define BAUDRATE 115200
+//#define BAUDRATE 230400
+
 
 // Frequency limit
 // See nophead's blog for more info
 // Teensylu = 8
 #define MOTHERBOARD 7
 
-
+//===========================================================================
+//=============================Thermal Settings  ============================
+//===========================================================================
 
 //// Thermistor settings:
 // 1 is 100k thermistor
 //#define BED_USES_THERMISTOR
 //#define BED_USES_AD595
 
-#define HEATER_CHECK_INTERVAL 50
-#define BED_CHECK_INTERVAL 5000
+#define HEATER_CHECK_INTERVAL 50 //ms
+#define BED_CHECK_INTERVAL 5000 //ms
 
+//// Experimental watchdog and minimal temp
+// The watchdog waits for the watchperiod in milliseconds whenever an M104 or M109 increases the target temperature
+// If the temperature has not increased at the end of that period, the target temperature is set to zero. It can be reset with another M104/M109
+/// CURRENTLY NOT IMPLEMENTED AND UNUSEABLE
+//#define WATCHPERIOD 5000 //5 seconds
 
-//// Endstop Settings
-#define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors
-// The pullups are needed if you directly connect a mechanical endswitch between the signal and ground pins.
-const bool ENDSTOPS_INVERTING = true; // set to true to invert the logic of the endstops. 
-// For optos H21LOB set to true, for Mendel-Parts newer optos TCST2103 set to false
+// Actual temperature must be close to target for this long before M109 returns success
+//#define TEMP_RESIDENCY_TIME 20  // (seconds)
+//#define TEMP_HYSTERESIS 5       // (C°) range of +/- temperatures considered "close" to the target one
 
-// This determines the communication speed of the printer
-#define BAUDRATE 250000
-//#define BAUDRATE 115200
-//#define BAUDRATE 230400
+//// The minimal temperature defines the temperature below which the heater will not be enabled
+#define HEATER_0_MINTEMP 5
+//#define HEATER_1_MINTEMP 5
+//#define BED_MINTEMP 5
 
-// Comment out (using // at the start of the line) to disable SD support:
 
-// #define ULTRA_LCD  //any lcd 
+// When temperature exceeds max temp, your heater will be switched off.
+// This feature exists to protect your hotend from overheating accidentally, but *NOT* from thermistor short/failure!
+// You should use MINTEMP for thermistor short/failure protection.
+#define HEATER_0_MAXTEMP 275
+//#define_HEATER_1_MAXTEMP 275
+//#define BED_MAXTEMP 150
 
-#define ULTIPANEL
-#ifdef ULTIPANEL
-  //#define NEWPANEL  //enable this if you have a click-encoder panel
-  #define SDSUPPORT
-  #define ULTRA_LCD
-  #define LCD_WIDTH 20
-  #define LCD_HEIGHT 4
-#else //no panel but just lcd 
-  #ifdef ULTRA_LCD
-    #define LCD_WIDTH 16
-    #define LCD_HEIGHT 2
+
+
+// PID settings:
+// Uncomment the following line to enable PID support.
+  
+#define PIDTEMP
+#ifdef PIDTEMP
+  //#define PID_DEBUG // Sends debug data to the serial port. 
+  //#define PID_OPENLOOP 1 // Puts PID in open loop. M104 sets the output power in %
+  
+  #define PID_MAX 255 // limits current to nozzle; 255=full current
+  #define PID_INTEGRAL_DRIVE_MAX 255  //limit for the integral term
+  #define K1 0.95 //smoothing factor withing the PID
+  #define PID_dT 0.1 //sampling period of the PID
+
+  //To develop some PID settings for your machine, you can initiall follow 
+  // the Ziegler-Nichols method.
+  // set Ki and Kd to zero. 
+  // heat with a defined Kp and see if the temperature stabilizes
+  // ideally you do this graphically with repg.
+  // the PID_CRITIAL_GAIN should be the Kp at which temperature oscillatins are not dampned out/decreas in amplitutde
+  // PID_SWING_AT_CRITIAL is the time for a full period of the oscillations at the critical Gain
+  // usually further manual tunine is necessary.
+
+  #define PID_CRITIAL_GAIN 3000
+  #define PID_SWING_AT_CRITIAL 45 //seconds
+  
+  #define PID_PI    //no differentail term
+  //#define PID_PID //normal PID
+
+  #ifdef PID_PID
+    //PID according to Ziegler-Nichols method
+    #define  DEFAULT_Kp  (0.6*PID_CRITIAL_GAIN)
+    #define  DEFAULT_Ki (2*Kp/PID_SWING_AT_CRITIAL*PID_dT)  
+    #define  DEFAULT_Kd (PID_SWING_AT_CRITIAL/8./PID_dT)  
   #endif
-#endif
+ 
+  #ifdef PID_PI
+    //PI according to Ziegler-Nichols method
+    #define  DEFAULT_Kp (PID_CRITIAL_GAIN/2.2) 
+    #define  DEFAULT_Ki (1.2*Kp/PID_SWING_AT_CRITIAL*PID_dT)
+    #define  DEFAULT_Kd (0)
+  #endif
+  
+  // this adds an experimental additional term to the heatingpower, proportional to the extrusion speed.
+  // if Kc is choosen well, the additional required power due to increased melting should be compensated.
+  #define PID_ADD_EXTRUSION_RATE  
+  #ifdef PID_ADD_EXTRUSION_RATE
+    #define  DEFAULT_Kc (3) //heatingpower=Kc*(e_speed)
+  #endif
+#endif // PIDTEMP
 
 
-//#define SDSUPPORT // Enable SD Card Support in Hardware Console
 
 
 
-const int dropsegments=5; //everything with this number of steps  will be ignored as move
 
-//// ADVANCED SETTINGS - to tweak parameters
 
-#include "thermistortables.h"
+
+
+//===========================================================================
+//=============================Mechanical Settings===========================
+//===========================================================================
+
+
+// Endstop Settings
+#define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors
+// The pullups are needed if you directly connect a mechanical endswitch between the signal and ground pins.
+const bool ENDSTOPS_INVERTING = true; // set to true to invert the logic of the endstops. 
+// For optos H21LOB set to true, for Mendel-Parts newer optos TCST2103 set to false
+
 
 // For Inverting Stepper Enable Pins (Active Low) use 0, Non Inverting (Active High) use 1
 #define X_ENABLE_ON 0
 #define DEFAULT_ZJERK                 0.4     // (mm/sec)
 
 
-// The watchdog waits for the watchperiod in milliseconds whenever an M104 or M109 increases the target temperature
-//this enables the watchdog interrupt.
-#define USE_WATCHDOG
-//you cannot reboot on a mega2560 due to a bug in he bootloader. Hence, you have to reset manually, and this is done hereby:
-#define RESET_MANUAL
-
-#define WATCHDOG_TIMEOUT 4
-
-
 
-//// Experimental watchdog and minimal temp
-// The watchdog waits for the watchperiod in milliseconds whenever an M104 or M109 increases the target temperature
-// If the temperature has not increased at the end of that period, the target temperature is set to zero. It can be reset with another M104/M109
-/// CURRENTLY NOT IMPLEMENTED AND UNUSEABLE
-//#define WATCHPERIOD 5000 //5 seconds
-
-// Actual temperature must be close to target for this long before M109 returns success
-//#define TEMP_RESIDENCY_TIME 20  // (seconds)
-//#define TEMP_HYSTERESIS 5       // (C°) range of +/- temperatures considered "close" to the target one
 
-//// The minimal temperature defines the temperature below which the heater will not be enabled
-//#define HEATER_0_MINTEMP 5
-//#define HEATER_1_MINTEMP 5
-//#define BED_MINTEMP 5
+//===========================================================================
+//=============================Additional Features===========================
+//===========================================================================
 
+// EEPROM
+// the microcontroller can store settings in the EEPROM, e.g. max velocity...
+// M500 - stores paramters in EEPROM
+// M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily).  
+// M502 - reverts to the default "factory settings".  You still need to store them in EEPROM afterwards if you want to.
+//define this to enable eeprom support
+#define EEPROM_SETTINGS
+//to disable EEPROM Serial responses and decrease program space by ~1700 byte: comment this out:
+// please keep turned on if you can.
+#define EEPROM_CHITCHAT
 
-// When temperature exceeds max temp, your heater will be switched off.
-// This feature exists to protect your hotend from overheating accidentally, but *NOT* from thermistor short/failure!
-// You should use MINTEMP for thermistor short/failure protection.
-//#define HEATER_0_MAXTEMP 275
-//#define_HEATER_1_MAXTEMP 275
-//#define BED_MAXTEMP 150
 
-/// PID settings:
-// Uncomment the following line to enable PID support.
-  
-#define PIDTEMP
-#ifdef PIDTEMP
-  //#define PID_DEBUG // Sends debug data to the serial port. 
-  //#define PID_OPENLOOP 1 // Puts PID in open loop. M104 sets the output power in %
-  
-  #define PID_MAX 255 // limits current to nozzle; 255=full current
-  #define PID_INTEGRAL_DRIVE_MAX 255  //limit for the integral term
-  #define K1 0.95 //smoothing factor withing the PID
-  #define PID_dT 0.1 //sampling period of the PID
+// The watchdog waits for the watchperiod in milliseconds whenever an M104 or M109 increases the target temperature
+// this enables the watchdog interrupt.
+#define USE_WATCHDOG
+// you cannot reboot on a mega2560 due to a bug in he bootloader. Hence, you have to reset manually, and this is done hereby:
+#define RESET_MANUAL
+#define WATCHDOG_TIMEOUT 4  //seconds
 
-  //To develop some PID settings for your machine, you can initiall follow 
-  // the Ziegler-Nichols method.
-  // set Ki and Kd to zero. 
-  // heat with a defined Kp and see if the temperature stabilizes
-  // ideally you do this graphically with repg.
-  // the PID_CRITIAL_GAIN should be the Kp at which temperature oscillatins are not dampned out/decreas in amplitutde
-  // PID_SWING_AT_CRITIAL is the time for a full period of the oscillations at the critical Gain
-  // usually further manual tunine is necessary.
 
-  #define PID_CRITIAL_GAIN 3000
-  #define PID_SWING_AT_CRITIAL 45 //seconds
-  
-  #define PID_PI    //no differentail term
-  //#define PID_PID //normal PID
 
-  #ifdef PID_PID
-    //PID according to Ziegler-Nichols method
-    #define  DEFAULT_Kp  (0.6*PID_CRITIAL_GAIN)
-    #define  DEFAULT_Ki (2*Kp/PID_SWING_AT_CRITIAL*PID_dT)  
-    #define  DEFAULT_Kd (PID_SWING_AT_CRITIAL/8./PID_dT)  
-  #endif
- 
-  #ifdef PID_PI
-    //PI according to Ziegler-Nichols method
-    #define  DEFAULT_Kp (PID_CRITIAL_GAIN/2.2) 
-    #define  DEFAULT_Ki (1.2*Kp/PID_SWING_AT_CRITIAL*PID_dT)
-    #define  DEFAULT_Kd (0)
-  #endif
-  
-  // this adds an experimental additional term to the heatingpower, proportional to the extrusion speed.
-  // if Kc is choosen well, the additional required power due to increased melting should be compensated.
-  #define PID_ADD_EXTRUSION_RATE  
-  #ifdef PID_ADD_EXTRUSION_RATE
-    #define  DEFAULT_Kc (5) //heatingpower=Kc*(e_speed)
-  #endif
-#endif // PIDTEMP
 
 // extruder advance constant (s2/mm3)
 //
 
 #endif // ADVANCE
 
+
+//LCD and SD support
+//#define ULTRA_LCD  //general lcd support, also 16x2
+//#define SDSUPPORT // Enable SD Card Support in Hardware Console
+
+#define ULTIPANEL
+#ifdef ULTIPANEL
+  #define NEWPANEL  //enable this if you have a click-encoder panel
+  #define SDSUPPORT
+  #define ULTRA_LCD
+  #define LCD_WIDTH 20
+  #define LCD_HEIGHT 4
+#else //no panel but just lcd 
+  #ifdef ULTRA_LCD
+    #define LCD_WIDTH 16
+    #define LCD_HEIGHT 2
+  #endif
+#endif
+
+// A debugging feature to compare calculated vs performed steps, to see if steps are lost by the software.
+//#define DEBUG_STEPS
+
+
+// Arc interpretation settings:
+#define MM_PER_ARC_SEGMENT 1
+#define N_ARC_CORRECTION 25
+
+
+//automatic temperature: just for testing, this is very dangerous, keep disabled!
+// not working yet.
+//Erik: the settings currently depend dramatically on skeinforge39 or 41.
+//#define AUTOTEMP
+#define AUTOTEMP_MIN 190
+#define AUTOTEMP_MAX 260
+#define AUTOTEMP_FACTOR 1000.  //current target temperature= min+largest buffered espeeds)*FACTOR
+
+
+
+const int dropsegments=0; //everything with less than this number of steps  will be ignored as move and joined with the next movement
+
+//===========================================================================
+//=============================Buffers           ============================
+//===========================================================================
+
+
+
 // The number of linear motions that can be in the plan at any give time.  
 // THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2, i.g. 8,16,32 because shifts and ors are used to do the ringbuffering.
 #if defined SDSUPPORT
   #define BLOCK_BUFFER_SIZE 8 // maximize block buffer
 #endif
 
+
 //The ASCII buffer for recieving from the serial:
 #define MAX_CMD_SIZE 96
 #define BUFSIZE 4
 
+
+#include "thermistortables.h"
+
 #endif //__CONFIGURATION_H

Marlin/EEPROMwrite.h

 }
 //======================================================================================
 
+
+
+
 #define EEPROM_OFFSET 100
 
 
 // ALSO:  always make sure the variables in the Store and retrieve sections are in the same order.
 #define EEPROM_VERSION "V04"  
 
-void StoreSettings() 
+inline void StoreSettings() 
 {
+#ifdef EEPROM_SETTINGS
   char ver[4]= "000";
   int i=EEPROM_OFFSET;
   EEPROM_writeAnything(i,ver); // invalidate data first 
   char ver2[4]=EEPROM_VERSION;
   i=EEPROM_OFFSET;
   EEPROM_writeAnything(i,ver2); // validate data
-  SERIAL_ECHOLN("Settings Stored");
+  SERIAL_ECHO_START;
+  SERIAL_ECHOLNPGM("Settings Stored");
+#endif //EEPROM_SETTINGS
 }
 
-void RetrieveSettings(bool def=false)
+inline void RetrieveSettings(bool def=false)
 {  // if def=true, the default values will be used
-  int i=EEPROM_OFFSET;
-  char stored_ver[4];
-  char ver[4]=EEPROM_VERSION;
-  EEPROM_readAnything(i,stored_ver); //read stored version
-  //  SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
-  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,acceleration);
-    EEPROM_readAnything(i,retract_acceleration);
-    EEPROM_readAnything(i,minimumfeedrate);
-    EEPROM_readAnything(i,mintravelfeedrate);
-    EEPROM_readAnything(i,minsegmenttime);
-    EEPROM_readAnything(i,max_xy_jerk);
-    EEPROM_readAnything(i,max_z_jerk);
-    #ifndef PIDTEMP
-      float Kp,Ki,Kd;
-    #endif
-    EEPROM_readAnything(i,Kp);
-    EEPROM_readAnything(i,Ki);
-    EEPROM_readAnything(i,Kd);
+  #ifdef EEPROM_SETTINGS
+    int i=EEPROM_OFFSET;
+    char stored_ver[4];
+    char ver[4]=EEPROM_VERSION;
+    EEPROM_readAnything(i,stored_ver); //read stored version
+    //  SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
+    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,acceleration);
+      EEPROM_readAnything(i,retract_acceleration);
+      EEPROM_readAnything(i,minimumfeedrate);
+      EEPROM_readAnything(i,mintravelfeedrate);
+      EEPROM_readAnything(i,minsegmenttime);
+      EEPROM_readAnything(i,max_xy_jerk);
+      EEPROM_readAnything(i,max_z_jerk);
+      #ifndef PIDTEMP
+        float Kp,Ki,Kd;
+      #endif
+      EEPROM_readAnything(i,Kp);
+      EEPROM_readAnything(i,Ki);
+      EEPROM_readAnything(i,Kd);
 
-    SERIAL_ECHOLN("Stored settings retreived:");
-  }
-  else 
-  {
-    float tmp1[]=DEFAULT_AXIS_STEPS_PER_UNIT;
-    float tmp2[]=DEFAULT_MAX_FEEDRATE;
-    long tmp3[]=DEFAULT_MAX_ACCELERATION;
-    for (short i=0;i<4;i++) 
+      SERIAL_ECHO_START;
+      SERIAL_ECHOLNPGM("Stored settings retreived:");
+    }
+    else 
     {
-      axis_steps_per_unit[i]=tmp1[i];  
-      max_feedrate[i]=tmp2[i];  
-      max_acceleration_units_per_sq_second[i]=tmp3[i];
+      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];
+      }
+      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;
+      SERIAL_ECHO_START;
+      SERIAL_ECHOLN("Using Default settings:");
     }
-    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;
-    SERIAL_ECHOLN("Using Default settings:");
-  }
-  SERIAL_ECHOLN("Steps per unit:");
-  SERIAL_ECHOLN("   M92 X"   <<_FLOAT(axis_steps_per_unit[0],3) << " Y" <<  _FLOAT(axis_steps_per_unit[1],3) << " Z" << _FLOAT(axis_steps_per_unit[2],3) << " E" << _FLOAT(axis_steps_per_unit[3],3));
-  SERIAL_ECHOLN("Maximum feedrates (mm/s):");
-  SERIAL_ECHOLN("   M203 X"  <<_FLOAT(max_feedrate[0]/60,2)<<" Y" << _FLOAT(max_feedrate[1]/60,2) << " Z" << _FLOAT(max_feedrate[2]/60,2) << " E" << _FLOAT(max_feedrate[3]/60,2));
-  SERIAL_ECHOLN("Maximum Acceleration (mm/s2):");
-  SERIAL_ECHOLN("   M201 X"  <<_FLOAT(max_acceleration_units_per_sq_second[0],0) << " Y" << _FLOAT(max_acceleration_units_per_sq_second[1],0) << " Z" << _FLOAT(max_acceleration_units_per_sq_second[2],0) << " E" << _FLOAT(max_acceleration_units_per_sq_second[3],0));
-  SERIAL_ECHOLN("Acceleration: S=acceleration, T=retract acceleration");
-  SERIAL_ECHOLN("   M204 S"  <<_FLOAT(acceleration,2) << " T" << _FLOAT(retract_acceleration,2));
-  SERIAL_ECHOLN("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)");
-  SERIAL_ECHOLN("   M205 S"  <<_FLOAT(minimumfeedrate/60,2) << " T" << _FLOAT(mintravelfeedrate/60,2) << " B" << _FLOAT(minsegmenttime,2) << " X" << _FLOAT(max_xy_jerk/60,2) << " Z" << _FLOAT(max_z_jerk/60,2));
-  #ifdef PIDTEMP
-    SERIAL_ECHOLN("PID settings:");
-    SERIAL_ECHOLN("   M301 P"  << _FLOAT(Kp,3) << " I" << _FLOAT(Ki,3) << " D" << _FLOAT(Kd,3));  
+  #ifdef EEPROM_CHITCHAT
+    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;
+      SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
+      SERIAL_ECHO_START;
+      SERIAL_ECHOPAIR("  M203 X",max_feedrate[0]/60);
+      SERIAL_ECHOPAIR(" Y",max_feedrate[1]/60 ); 
+      SERIAL_ECHOPAIR(" Z", max_feedrate[2]/60 ); 
+      SERIAL_ECHOPAIR(" E", max_feedrate[3]/60);
+      SERIAL_ECHOLN("");
+    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("");
+    SERIAL_ECHO_START;
+      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)");
+      SERIAL_ECHO_START;
+      SERIAL_ECHOPAIR("  M205 S",minimumfeedrate/60 ); 
+      SERIAL_ECHOPAIR(" T" ,mintravelfeedrate/60 ); 
+      SERIAL_ECHOPAIR(" B" ,minsegmenttime ); 
+      SERIAL_ECHOPAIR(" X" ,max_xy_jerk/60 ); 
+      SERIAL_ECHOPAIR(" Z" ,max_z_jerk/60);
+      SERIAL_ECHOLN(""); 
+    #ifdef PIDTEMP
+      SERIAL_ECHO_START;
+      SERIAL_ECHOLNPGM("PID settings:");
+      SERIAL_ECHO_START;
+      SERIAL_ECHOPAIR("   M301 P",Kp ); 
+      SERIAL_ECHOPAIR(" I" ,Ki ); 
+      SERIAL_ECHOPAIR(" D" ,Kd);
+      SERIAL_ECHOLN(""); 
+    #endif
   #endif
+    
+  #endif //EEPROM_SETTINGS
 }  
 
 #endif

Marlin/Marlin.h

 // Licence: GPL
 #include <WProgram.h>
 #include "fastio.h"
+#include <avr/pgmspace.h>
+#include "Configuration.h"
+
+//#define SERIAL_ECHO(x) Serial << "echo: " << x;
+//#define SERIAL_ECHOLN(x) Serial << "echo: "<<x<<endl;
+//#define SERIAL_ERROR(x) Serial << "Error: " << x;
+//#define SERIAL_ERRORLN(x) Serial << "Error: " << x<<endl;
+//#define SERIAL_PROTOCOL(x) Serial << x;
+//#define SERIAL_PROTOCOLLN(x) Serial << x<<endl;
+
+
+
+#define SERIAL_PROTOCOL(x) Serial.print(x);
+#define SERIAL_PROTOCOLPGM(x) serialprintPGM(PSTR(x));
+#define SERIAL_PROTOCOLLN(x) {Serial.print(x);Serial.write('\n');}
+#define SERIAL_PROTOCOLLNPGM(x) {serialprintPGM(PSTR(x));Serial.write('\n');}
+
+const char errormagic[] PROGMEM ="Error:";
+const char echomagic[] PROGMEM ="echo:";
+#define SERIAL_ERROR_START serialprintPGM(errormagic);
+#define SERIAL_ERROR(x) SERIAL_PROTOCOL(x)
+#define SERIAL_ERRORPGM(x) SERIAL_PROTOCOLPGM(x)
+#define SERIAL_ERRORLN(x) SERIAL_PROTOCOLLN(x)
+#define SERIAL_ERRORLNPGM(x) SERIAL_PROTOCOLLNPGM(x)
+
+#define SERIAL_ECHO_START serialprintPGM(echomagic);
+#define SERIAL_ECHO(x) SERIAL_PROTOCOL(x)
+#define SERIAL_ECHOPGM(x) SERIAL_PROTOCOLPGM(x)
+#define SERIAL_ECHOLN(x) SERIAL_PROTOCOLLN(x)
+#define SERIAL_ECHOLNPGM(x) SERIAL_PROTOCOLLNPGM(x)
+
+#define SERIAL_ECHOPAIR(name,value) {SERIAL_ECHOPGM(name);SERIAL_ECHO(value);}
+
+
+//things to write to serial from Programmemory. saves 400 to 2k of RAM.
+#define SerialprintPGM(x) serialprintPGM(PSTR(x))
+inline void serialprintPGM(const char *str)
+{
+  char ch=pgm_read_byte(str);
+  while(ch)
+  {
+    Serial.write(ch);
+    ch=pgm_read_byte(++str);
+  }
+}
 
-#include "streaming.h"
-#define SERIAL_ECHO(x) Serial << "echo: " << x;
-#define SERIAL_ECHOLN(x) Serial << "echo: "<<x<<endl;
-#define SERIAL_ERROR(x) Serial << "echo: ERROR: " << x;
-#define SERIAL_ERRORLN(x) Serial << "echo: ERROR: " << x<<endl;
 
 void get_command();
 void process_commands();
 
 extern float homing_feedrate[];
 extern bool axis_relative_modes[];
+extern float current_position[NUM_AXIS] ;
 
 #endif

Marlin/Marlin.pde

 #include "pins.h"
 #include "Marlin.h"
 #include "ultralcd.h"
-#include "streaming.h"
 #include "planner.h"
 #include "stepper.h"
 #include "temperature.h"
 #include "cardreader.h"
 
 
-char version_string[] = "1.0.0 Alpha 1";
+#define VERSION_STRING  "1.0.0 Alpha 1"
+
 
 
 
 // M205 -  advanced settings:  minimum travel speed S=while printing T=travel only,  B=minimum segment time X= maximum xy jerk, Z=maximum Z jerk
 // M220 - set speed factor override percentage S:factor in percent
 // M301 - Set PID parameters P I and D
+// M400 - Finish all moves
 // M500 - stores paramters in EEPROM
-// M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily).  D
+// M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily).  
 // M502 - reverts to the default "factory settings".  You still need to store them in EEPROM afterwards if you want to.
 
 //Stepper Movement Variables
 volatile int feedmultiply=100; //100->1 200->2
 int saved_feedmultiply;
 volatile bool feedmultiplychanged=false;
+float current_position[NUM_AXIS] = {  0.0, 0.0, 0.0, 0.0};
+
 
 //===========================================================================
 //=============================private variables=============================
 //===========================================================================
 const char axis_codes[NUM_AXIS] = {'X', 'Y', 'Z', 'E'};
 static float destination[NUM_AXIS] = {  0.0, 0.0, 0.0, 0.0};
-static float current_position[NUM_AXIS] = {  0.0, 0.0, 0.0, 0.0};
 static float offset[3] = {0.0, 0.0, 0.0};
 static bool home_all_axis = true;
 static float feedrate = 1500.0, next_feedrate, saved_feedrate;
 //===========================================================================
 
 
+extern "C"{
+  extern unsigned int __bss_end;
+  extern unsigned int __heap_start;
+  extern void *__brkval;
+
+  int freeMemory() {
+    int free_memory;
+
+    if((int)__brkval == 0)
+      free_memory = ((int)&free_memory) - ((int)&__bss_end);
+    else
+      free_memory = ((int)&free_memory) - ((int)__brkval);
+
+    return free_memory;
+  }
+}
+
 
 //adds an command to the main command buffer
 //thats really done in a non-safe way.
   {
     //this is dangerous if a mixing of serial and this happsens
     strcpy(&(cmdbuffer[bufindw][0]),cmd);
-    SERIAL_ECHOLN("enqueing \""<<cmdbuffer[bufindw]<<"\"");
+    SERIAL_ECHO_START;
+    SERIAL_ECHOPGM("enqueing \"");
+    SERIAL_ECHO(cmdbuffer[bufindw]);
+    SERIAL_ECHOLNPGM("\"");
     bufindw= (bufindw + 1)%BUFSIZE;
     buflen += 1;
   }
 void setup()
 { 
   Serial.begin(BAUDRATE);
-  SERIAL_ECHOLN("Marlin "<<version_string);
-  Serial.println("start");
+  SERIAL_ECHO_START;
+  SERIAL_ECHOLNPGM(VERSION_STRING);
+  SERIAL_PROTOCOLLNPGM("start");
+  SERIAL_ECHO_START;
+  SERIAL_ECHOPGM("Free Memory:");
+  SERIAL_ECHOLN(freeMemory());
   for(int8_t i = 0; i < BUFSIZE; i++)
   {
     fromsd[i] = false;
 	if(strstr(cmdbuffer[bufindr],"M29") == NULL)
 	{
 	  card.write_command(cmdbuffer[bufindr]);
-	  Serial.println("ok");
+	  SERIAL_PROTOCOLLNPGM("ok");
 	}
 	else
 	{
 	  card.closefile();
-	  Serial.println("Done saving file.");
+	  SERIAL_PROTOCOLLNPGM("Done saving file.");
 	}
       }
       else
   //check heater every n milliseconds
   manage_heater();
   manage_inactivity(1);
+  checkHitEndstops();
   LCD_STATUS;
 }
 
           strchr_pointer = strchr(cmdbuffer[bufindw], 'N');
           gcode_N = (strtol(&cmdbuffer[bufindw][strchr_pointer - cmdbuffer[bufindw] + 1], NULL, 10));
           if(gcode_N != gcode_LastN+1 && (strstr(cmdbuffer[bufindw], "M110") == NULL) ) {
-            Serial.print("Serial Error: Line Number is not Last Line Number+1, Last Line:");
-            Serial.println(gcode_LastN);
+            SERIAL_ERROR_START;
+            SERIAL_ERRORPGM("Line Number is not Last Line Number+1, Last Line:");
+            SERIAL_ERRORLN(gcode_LastN);
             //Serial.println(gcode_N);
             FlushSerialRequestResend();
             serial_count = 0;
             strchr_pointer = strchr(cmdbuffer[bufindw], '*');
 
             if( (int)(strtod(&cmdbuffer[bufindw][strchr_pointer - cmdbuffer[bufindw] + 1], NULL)) != checksum) {
-              Serial.print("Error: checksum mismatch, Last Line:");
-              Serial.println(gcode_LastN);
+              SERIAL_ERROR_START;
+              SERIAL_ERRORPGM("checksum mismatch, Last Line:");
+              SERIAL_ERRORLN(gcode_LastN);
               FlushSerialRequestResend();
               serial_count = 0;
               return;
           }
           else 
           {
-            Serial.print("Error: No Checksum with line number, Last Line:");
-            Serial.println(gcode_LastN);
+            SERIAL_ERROR_START;
+            SERIAL_ERRORPGM("No Checksum with line number, Last Line:");
+            SERIAL_ERRORLN(gcode_LastN);
             FlushSerialRequestResend();
             serial_count = 0;
             return;
         {
           if((strstr(cmdbuffer[bufindw], "*") != NULL))
           {
-            Serial.print("Error: No Line Number with checksum, Last Line:");
-            Serial.println(gcode_LastN);
+            SERIAL_ERROR_START;
+            SERIAL_ERRORPGM("No Line Number with checksum, Last Line:");
+            SERIAL_ERRORLN(gcode_LastN);
             serial_count = 0;
             return;
           }
             if(card.saving)
               break;
 	    #endif //SDSUPPORT
-            Serial.println("ok"); 
+            SERIAL_PROTOCOLLNPGM("ok"); 
             break;
           default:
             break;
     return;
   }
   while( !card.eof()  && buflen < BUFSIZE) {
-    
-    serial_char = card.get();
-    if(serial_char == '\n' || serial_char == '\r' || serial_char == ':' || serial_count >= (MAX_CMD_SIZE - 1)) 
+    int16_t n=card.get();
+    serial_char = (char)n;
+    if(serial_char == '\n' || serial_char == '\r' || serial_char == ':' || serial_count >= (MAX_CMD_SIZE - 1)||n==-1) 
     {
      
       if(card.eof()){
         card.sdprinting = false;
-        Serial.println("echo: Done printing file");
+        SERIAL_PROTOCOLLNPGM("Done printing file");
         stoptime=millis();
         char time[30];
         unsigned long t=(stoptime-starttime)/1000;
         int sec,min;
         min=t/60;
         sec=t%60;
-        sprintf(time,"echo: %i min, %i sec",min,sec);
-        Serial.println(time);
+        sprintf(time,"%i min, %i sec",min,sec);
+        SERIAL_ECHO_START;
+        SERIAL_ECHOLN(time);
         LCD_MESSAGE(time);
         card.checkautostart(true);
       }
       if(!comment_mode) cmdbuffer[bufindw][serial_count++] = serial_char;
     }
   }
+  
   #endif //SDSUPPORT
 
 }
     destination[LETTER##_AXIS] = 1.5 * LETTER##_MAX_LENGTH * LETTER##_HOME_DIR; \
     feedrate = homing_feedrate[LETTER##_AXIS]; \
     prepare_move(); \
+    st_synchronize();\
     \
     current_position[LETTER##_AXIS] = 0;\
     plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);\
     destination[LETTER##_AXIS] = -5 * LETTER##_HOME_DIR;\
     prepare_move(); \
+    st_synchronize();\
     \
     destination[LETTER##_AXIS] = 10 * LETTER##_HOME_DIR;\
     feedrate = homing_feedrate[LETTER##_AXIS]/2 ;  \
     prepare_move(); \
+    st_synchronize();\
     \
     current_position[LETTER##_AXIS] = (LETTER##_HOME_DIR == -1) ? 0 : LETTER##_MAX_LENGTH;\
     plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);\
     destination[LETTER##_AXIS] = current_position[LETTER##_AXIS];\
     feedrate = 0.0;\
+    st_synchronize();\
+    endstops_hit_on_purpose();\
   }
 
 inline void process_commands()
       previous_millis_cmd = millis();
       return;
     case 4: // G4 dwell
+      LCD_MESSAGEPGM("DWELL...");
       codenum = 0;
       if(code_seen('P')) codenum = code_value(); // milliseconds to wait
       if(code_seen('S')) codenum = code_value() * 1000; // seconds to wait
       feedrate = saved_feedrate;
       feedmultiply = saved_feedmultiply;
       previous_millis_cmd = millis();
+      endstops_hit_on_purpose();
       break;
     case 90: // G90
       relative_mode = false;
     #ifdef SDSUPPORT
 
     case 20: // M20 - list SD card
-      Serial.println("Begin file list");
+      SERIAL_PROTOCOLLNPGM("Begin file list");
       card.ls();
-      Serial.println("End file list");
+      SERIAL_PROTOCOLLNPGM("End file list");
       break;
     case 21: // M21 - init SD card
       
       card.initsd();
+      
       break;
     case 22: //M22 - release SD card
       card.release();
       int sec,min;
       min=t/60;
       sec=t%60;
-      sprintf(time,"echo: time needed %i min, %i sec",min,sec);
-      Serial.println(time);
+      sprintf(time,"%i min, %i sec",min,sec);
+      SERIAL_ECHO_START;
+      SERIAL_ECHOLN(time);
       LCD_MESSAGE(time);
     }
     break;
       if (code_seen('S')) setTargetBed(code_value());
       break;
     case 105: // M105
+      //SERIAL_ECHOLN(freeMemory());
+          
       #if (TEMP_0_PIN > -1) || defined (HEATER_USES_AD595)
-        tt = degHotend0();
-      #endif
-      #if TEMP_1_PIN > -1
-          bt = degBed();
-      #endif
-      #if (TEMP_0_PIN > -1) || defined (HEATER_USES_AD595)
-        Serial.print("ok T:");
-        Serial.print(tt); 
+        SERIAL_PROTOCOLPGM("ok T:");
+        SERIAL_PROTOCOL( degHotend0()); 
         #if TEMP_1_PIN > -1 
-          #ifdef PIDTEMP
-            Serial.print(" B:");
-            #if TEMP_1_PIN > -1
-              Serial.println(bt); 
-            #else
-              Serial.println(HeaterPower); 
-            #endif
-          #else //not PIDTEMP
-            Serial.println();
-           #endif //PIDTEMP
-         #else
-            Serial.println();
-          #endif //TEMP_1_PIN
-        #else
-          SERIAL_ERRORLN("No thermistors - no temp");
+          SERIAL_PROTOCOLPGM(" B:");  
+          SERIAL_PROTOCOL(degBed());
+        #endif //TEMP_1_PIN
+      #else
+        SERIAL_ERROR_START;
+        SERIAL_ERRORLNPGM("No thermistors - no temp");
+      #endif
+      #ifdef PIDTEMP
+        SERIAL_PROTOCOLPGM(" @:");
+        SERIAL_PROTOCOL( HeaterPower); 
+       
       #endif
+        SERIAL_PROTOCOLLN("");
       return;
       break;
     case 109: 
     {// M109 - Wait for extruder heater to reach target.
-        LCD_MESSAGE("Heating...");
+        LCD_MESSAGEPGM("Heating...");
         if (code_seen('S')) setTargetHotend0(code_value());
         
         setWatch();
         #endif //TEMP_RESIDENCY_TIME
         if( (millis() - codenum) > 1000 ) 
         { //Print Temp Reading every 1 second while heating up/cooling down
-          Serial.print("T:");
-        Serial.println( degHotend0() ); 
+          SERIAL_PROTOCOLPGM("T:");
+          SERIAL_PROTOCOLLN( degHotend0() ); 
           codenum = millis();
         }
         manage_heater();
           }
         #endif //TEMP_RESIDENCY_TIME
         }
-        LCD_MESSAGE("Heating done.");
+        LCD_MESSAGEPGM("Heating done.");
         starttime=millis();
       }
       break;
     case 190: // M190 - Wait bed for heater to reach target.
     #if TEMP_1_PIN > -1
+        LCD_MESSAGEPGM("Bed Heating.");
         if (code_seen('S')) setTargetBed(code_value());
         codenum = millis(); 
         while(isHeatingBed()) 
           if( (millis()-codenum) > 1000 ) //Print Temp Reading every 1 second while heating up.
           {
             float tt=degHotend0();
-            Serial.print("T:");
-            Serial.println( tt );
-            Serial.print("ok T:");
-            Serial.print( tt ); 
-            Serial.print(" B:");
-            Serial.println( degBed() ); 
+            SERIAL_PROTOCOLPGM("T:");
+            SERIAL_PROTOCOLLN(tt );
+            SERIAL_PROTOCOLPGM("ok T:");
+            SERIAL_PROTOCOL(tt );
+            SERIAL_PROTOCOLPGM(" B:");
+            SERIAL_PROTOCOLLN(degBed() ); 
             codenum = millis(); 
           }
           manage_heater();
         }
+        LCD_MESSAGEPGM("Bed done.");
     #endif
     break;
 
       else
       { 
         st_synchronize(); 
+        LCD_MESSAGEPGM("Free move.");
         disable_x(); 
         disable_y(); 
         disable_z(); 
       }
       break;
     case 115: // M115
-      Serial.println("FIRMWARE_NAME:Marlin; Sprinter/grbl mashup for gen6 FIRMWARE_URL:http://www.mendel-parts.com PROTOCOL_VERSION:1.0 MACHINE_TYPE:Mendel EXTRUDER_COUNT:1");
+      SerialprintPGM("FIRMWARE_NAME:Marlin; Sprinter/grbl mashup for gen6 FIRMWARE_URL:http://www.mendel-parts.com PROTOCOL_VERSION:1.0 MACHINE_TYPE:Mendel EXTRUDER_COUNT:1");
       break;
     case 114: // M114
-      Serial.print("X:");
-      Serial.print(current_position[X_AXIS]);
-      Serial.print("Y:");
-      Serial.print(current_position[Y_AXIS]);
-      Serial.print("Z:");
-      Serial.print(current_position[Z_AXIS]);
-      Serial.print("E:");      
-      Serial.print(current_position[E_AXIS]);
+      SERIAL_PROTOCOLPGM("X:");
+      SERIAL_PROTOCOL(current_position[X_AXIS]);
+      SERIAL_PROTOCOLPGM("Y:");
+      SERIAL_PROTOCOL(current_position[Y_AXIS]);
+      SERIAL_PROTOCOLPGM("Z:");
+      SERIAL_PROTOCOL(current_position[Z_AXIS]);
+      SERIAL_PROTOCOLPGM("E:");      
+      SERIAL_PROTOCOL(current_position[E_AXIS]);
       #ifdef DEBUG_STEPS
-        Serial.print(" Count X:");
-        Serial.print(float(count_position[X_AXIS])/axis_steps_per_unit[X_AXIS]);
-        Serial.print("Y:");
-        Serial.print(float(count_position[Y_AXIS])/axis_steps_per_unit[Y_AXIS]);
-        Serial.print("Z:");
-        Serial.println(float(count_position[Z_AXIS])/axis_steps_per_unit[Z_AXIS]);
+        SERIAL_PROTOCOLPGM(" Count X:");
+        SERIAL_PROTOCOL(float(count_position[X_AXIS])/axis_steps_per_unit[X_AXIS]);
+        SERIAL_PROTOCOLPGM("Y:");
+        SERIAL_PROTOCOL(float(count_position[Y_AXIS])/axis_steps_per_unit[Y_AXIS]);
+        SERIAL_PROTOCOLPGM("Z:");
+        SERIAL_PROTOCOL(float(count_position[Z_AXIS])/axis_steps_per_unit[Z_AXIS]);
       #endif
-      Serial.println("");
+      SERIAL_PROTOCOLLN("");
       break;
     case 119: // M119
       #if (X_MIN_PIN > -1)
-        Serial.print("x_min:");
-        Serial.print((READ(X_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
+        SERIAL_PROTOCOLPGM("x_min:");
+        SERIAL_PROTOCOL(((READ(X_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
       #endif
       #if (X_MAX_PIN > -1)
-        Serial.print("x_max:");
-        Serial.print((READ(X_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
+        SERIAL_PROTOCOLPGM("x_max:");
+        SERIAL_PROTOCOL(((READ(X_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
       #endif
       #if (Y_MIN_PIN > -1)
-        Serial.print("y_min:");
-        Serial.print((READ(Y_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
+        SERIAL_PROTOCOLPGM("y_min:");
+        SERIAL_PROTOCOL(((READ(Y_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
       #endif
       #if (Y_MAX_PIN > -1)
-        Serial.print("y_max:");
-        Serial.print((READ(Y_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
+        SERIAL_PROTOCOLPGM("y_max:");
+        SERIAL_PROTOCOL(((READ(Y_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
       #endif
       #if (Z_MIN_PIN > -1)
-        Serial.print("z_min:");
-        Serial.print((READ(Z_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
+        SERIAL_PROTOCOLPGM("z_min:");
+        SERIAL_PROTOCOL(((READ(Z_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
       #endif
       #if (Z_MAX_PIN > -1)
-        Serial.print("z_max:");
-        Serial.print((READ(Z_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
+        SERIAL_PROTOCOLPGM("z_max:");
+        SERIAL_PROTOCOL(((READ(Z_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
       #endif
-      Serial.println("");
+      SERIAL_PROTOCOLLN("");
       break;
       //TODO: update for all axis, use for loop
     case 201: // M201
       if(code_seen('P')) Kp = code_value();
       if(code_seen('I')) Ki = code_value()*PID_dT;
       if(code_seen('D')) Kd = code_value()/PID_dT;
+      #ifdef PID_ADD_EXTRUSION_RATE
+      if(code_seen('C')) Kc = code_value();
+      #endif
+      SERIAL_PROTOCOL("ok p:");
+      SERIAL_PROTOCOL(Kp);
+      SERIAL_PROTOCOL(" i:");
+      SERIAL_PROTOCOL(Ki/PID_dT);
+      SERIAL_PROTOCOL(" d:");
+      SERIAL_PROTOCOL(Kd*PID_dT);
+      #ifdef PID_ADD_EXTRUSION_RATE
+      SERIAL_PROTOCOL(" c:");
+      SERIAL_PROTOCOL(Kc*PID_dT);
+      #endif
+      SERIAL_PROTOCOLLN("");
+      
       break;
     #endif //PIDTEMP
+    case 400: // finish all moves
+    {
+      st_synchronize();
+    }
+    break;
     case 500: // Store settings in EEPROM
     {
         StoreSettings();
   }
   else
   {
-    Serial.print("echo: Unknown command:\"");
-    Serial.print(cmdbuffer[bufindr]);
-    Serial.println("\"");
+    SERIAL_ECHO_START;
+    SERIAL_ECHOPGM("Unknown command:\"");
+    SERIAL_ECHO(cmdbuffer[bufindr]);
+    SERIAL_ECHOLNPGM("\"");
   }
 
   ClearToSend();
 {
   //char cmdbuffer[bufindr][100]="Resend:";
   Serial.flush();
-  Serial.print("Resend:");
-  Serial.println(gcode_LastN + 1);
+  SERIAL_PROTOCOLPGM("Resend:");
+  SERIAL_PROTOCOLLN(gcode_LastN + 1);
   ClearToSend();
 }
 
   if(fromsd[bufindr])
     return;
   #endif //SDSUPPORT
-  Serial.println("ok"); 
+  SERIAL_PROTOCOLLNPGM("ok"); 
 }
 
 inline void get_coordinates()
   disable_e();
   
   if(PS_ON_PIN > -1) pinMode(PS_ON_PIN,INPUT);
-  SERIAL_ERRORLN("Printer halted. kill() called !!");
+  SERIAL_ERROR_START;
+  SERIAL_ERRORLNPGM("Printer halted. kill() called !!");
+  LCD_MESSAGEPGM("KILLED. ");
   while(1); // Wait for reset
 }
 

Marlin/cardreader.h

   
 
   inline void ls() {root.ls();};
-  inline bool eof() { sdpos = file.curPosition();return sdpos>=filesize ;};
-  inline char get() {  int16_t n = file.read(); return (n!=-1)?(char)n:'\n';};
+  inline bool eof() { return sdpos>=filesize ;};
+  inline int16_t get() {  sdpos = file.curPosition();return (int16_t)file.read();};
   inline void setIndex(long index) {sdpos = index;file.seekSet(index);};
 
 public:
   bool autostart_stilltocheck; //the sd start is delayed, because otherwise the serial cannot answer fast enought to make contact with the hostsoftware.
 };
   
+
+#else
+class CardReader
+{
+public:
+  inline CardReader(){};
+  
+  inline static void initsd(){};
+  inline static void write_command(char *buf){};
+  
+  inline static void checkautostart(bool x) {}; 
+  
+  inline static void closefile() {};
+  inline static void release(){};
+  inline static void startFileprint(){};
+  inline static void startFilewrite(char *name){};
+  inline static void pauseSDPrint(){};
+  inline static void getStatus(){};
+  
+  inline static void selectFile(char* name){};
+  inline static void getfilename(const uint8_t nr){};
+  inline static uint8_t getnrfilenames(){return 0;};
+  
+
+  inline static void ls() {};
+  inline static bool eof() {return true;};
+  inline static char get() {return 0;};
+  inline static void setIndex(){};
+};
 #endif //SDSUPPORT
   
   

Marlin/cardreader.pde

     if (!card.init(SPI_FULL_SPEED,SDSS))
     {
       //if (!card.init(SPI_HALF_SPEED,SDSS))
-      SERIAL_ECHOLN("SD init fail");
+      SERIAL_ECHO_START;
+      SERIAL_ECHOLNPGM("SD init fail");
     }
     else if (!volume.init(&card))
     {
-      SERIAL_ERRORLN("volume.init failed");
+      SERIAL_ERROR_START;
+      SERIAL_ERRORLNPGM("volume.init failed");
     }
     else if (!root.openRoot(&volume)) 
     {
-      SERIAL_ERRORLN("openRoot failed");
+      SERIAL_ERROR_START;
+      SERIAL_ERRORLNPGM("openRoot failed");
     }
     else 
     {
       cardOK = true;
-      SERIAL_ECHOLN("SD card ok");
+      SERIAL_ECHO_START;
+      SERIAL_ECHOLNPGM("SD card ok");
     }
   #endif //SDSS
 }
     file.close();
    
     if (file.open(&root, name, O_READ)) {
-      Serial.print("File opened:");
-      Serial.print(name);
-      Serial.print(" Size:");
       filesize = file.fileSize();
-      Serial.println(filesize);
+      SERIAL_PROTOCOLPGM("File opened:");
+      SERIAL_PROTOCOL(name);
+      SERIAL_PROTOCOLPGM(" Size:");
+      SERIAL_PROTOCOLLN(filesize);
       sdpos = 0;
       
-      Serial.println("File selected");
+      SERIAL_PROTOCOLLNPGM("File selected");
     }
     else{
-      Serial.println("file.open failed");
+      SERIAL_PROTOCOLLNPGM("file.open failed");
     }
   }
 }
     
     if (!file.open(&root, name, O_CREAT | O_APPEND | O_WRITE | O_TRUNC))
     {
-      Serial.print("open failed, File: ");
-      Serial.print(name);
-      Serial.print(".");
+      SERIAL_PROTOCOLPGM("open failed, File: ");
+      SERIAL_PROTOCOL(name);
+      SERIAL_PROTOCOLLNPGM(".");
     }
     else{
       saving = true;
-      Serial.print("Writing to file: ");
-      Serial.println(name);
+      SERIAL_PROTOCOLPGM("Writing to file: ");
+      SERIAL_PROTOCOLLN(name);
     }
   }
 }
 void CardReader::getStatus()
 {
   if(cardOK){
-    Serial.print("SD printing byte ");
-    Serial.print(sdpos);
-    Serial.print("/");
-    Serial.println(filesize);
+    SERIAL_PROTOCOLPGM("SD printing byte ");
+    SERIAL_PROTOCOL(sdpos);
+    SERIAL_PROTOCOLPGM("/");
+    SERIAL_PROTOCOLLN(filesize);
   }
   else{
-    Serial.println("Not SD printing");
+    SERIAL_PROTOCOLLNPGM("Not SD printing");
   }
 }
 void CardReader::write_command(char *buf)
   file.write(begin);
   if (file.writeError)
   {
-    SERIAL_ERRORLN("error writing to file");
+    SERIAL_ERROR_START;
+    SERIAL_ERRORLNPGM("error writing to file");
   }
 }
 

Marlin/planner.cpp

 static float previous_speed[4]; // Speed of previous path line segment
 static float previous_nominal_speed; // Nominal speed of previous path line segment
 
+#ifdef AUTOTEMP
+float high_e_speed=0;
+#endif
+
 
 //===========================================================================
 //=============================private variables ============================
   return(block);
 }
 
+#ifdef AUTOTEMP
+void getHighESpeed()
+{
+  if(degTargetHotend0()+2<AUTOTEMP_MIN)  //probably temperature set to zero.
+    return; //do nothing
+  float high=0;
+  char block_index = block_buffer_tail;
+  
+  while(block_index != block_buffer_head) {
+    float se=block_buffer[block_index].speed_e;
+    if(se>high)
+    {
+      high=se;
+    }
+    block_index = (block_index+1) & (BLOCK_BUFFER_SIZE - 1);
+  }
+  high_e_speed=high*axis_steps_per_unit[E_AXIS]/(1000000.0);  //so it is independent of the esteps/mm. before 
+   
+  float g=AUTOTEMP_MIN+high_e_speed*AUTOTEMP_FACTOR;
+  float t=constrain(AUTOTEMP_MIN,g,AUTOTEMP_MAX);
+  setTargetHotend0(t);
+  SERIAL_ECHO_START;
+  SERIAL_ECHOPAIR("highe",high_e_speed);
+  SERIAL_ECHOPAIR(" t",t);
+  SERIAL_ECHOLN("");
+}
+#endif
+
 void check_axes_activity() {
   unsigned char x_active = 0;
   unsigned char y_active = 0;  
   memcpy(position, target, sizeof(target)); // position[] = target[]
 
   planner_recalculate();
-  
+  #ifdef AUTOTEMP
+    getHighESpeed();
+  #endif
   st_wake_up();
 }
 
   previous_speed[2] = 0.0;
   previous_speed[3] = 0.0;
 }
-
+

Marlin/planner.h

 extern float max_z_jerk;
 extern float mintravelfeedrate;
 extern unsigned long axis_steps_per_sqr_second[NUM_AXIS];
-
-#endif
+#ifdef AUTOTEMP
+extern float high_e_speed;
+#endif
+#endif

Marlin/stepper.cpp

 #include "speed_lookuptable.h"
 
 
+
 //===========================================================================
 //=============================public variables  ============================
 //===========================================================================
 block_t *current_block;  // A pointer to the block currently being traced
 
 
+
 //===========================================================================
 //=============================private variables ============================
 //===========================================================================
 static unsigned short acc_step_rate; // needed for deccelaration start point
 static char step_loops;
 
-
+volatile long endstops_trigsteps[3]={0,0,0};
+volatile long endstops_stepsTotal,endstops_stepsDone;
+static volatile bool endstops_hit=false;
 
 // if DEBUG_STEPS is enabled, M114 can be used to compare two methods of determining the X,Y,Z position of the printer.
 // for debugging purposes only, should be disabled by default
 #define DISABLE_STEPPER_DRIVER_INTERRUPT() TIMSK1 &= ~(1<<OCIE1A)
 
 
+void endstops_triggered(const unsigned long &stepstaken)  
+{
+  //this will only work if there is no bufferig
+  //however, if you perform a move at which the endstops should be triggered, and wait for it to complete, i.e. by blocking command, it should work
+  //yes, it uses floats, but: if endstops are triggered, thats hopefully not critical anymore anyways.
+  //endstops_triggerpos;
+  
+  if(endstops_hit) //hitting a second time while the first hit is not reported
+    return;
+  if(current_block == NULL)
+    return;
+  endstops_stepsTotal=current_block->step_event_count;
+  endstops_stepsDone=stepstaken;
+  endstops_trigsteps[0]=current_block->steps_x;
+  endstops_trigsteps[1]=current_block->steps_y;
+  endstops_trigsteps[2]=current_block->steps_z;
+
+  endstops_hit=true;
+}
 
+void checkHitEndstops()
+{
+  if( !endstops_hit)
+   return;
+  float endstops_triggerpos[3]={0,0,0};
+  float ratiodone=endstops_stepsDone/float(endstops_stepsTotal);  //ratio of current_block thas was performed
+  
+  endstops_triggerpos[0]=current_position[0]-(endstops_trigsteps[0]*ratiodone)/float(axis_steps_per_unit[0]);
+  endstops_triggerpos[1]=current_position[1]-(endstops_trigsteps[1]*ratiodone)/float(axis_steps_per_unit[1]);
+  endstops_triggerpos[2]=current_position[2]-(endstops_trigsteps[2]*ratiodone)/float(axis_steps_per_unit[2]);
+ SERIAL_ECHO_START;
+ SERIAL_ECHOPGM("endstops hit: ");
+ SERIAL_ECHOPAIR(" X:",endstops_triggerpos[0]);
+ SERIAL_ECHOPAIR(" Y:",endstops_triggerpos[1]);
+ SERIAL_ECHOPAIR(" Z:",endstops_triggerpos[2]);
+ SERIAL_ECHOLN("");
+ endstops_hit=false;
+}
 
-
+void endstops_hit_on_purpose()
+{
+  endstops_hit=false;
+}
 
 //         __________________________
 //        /|                        |\     _________________         ^
 ISR(TIMER1_COMPA_vect)
 {        
   if(busy){ 
-/*    SERIAL_ERRORLN(*(unsigned short *)OCR1A<< " ISR overtaking itself.");*/
+    SERIAL_ERROR_START
+    SERIAL_ERROR(*(unsigned short *)OCR1A);
+    SERIAL_ERRORLNPGM(" ISR overtaking itself.");
     return; 
   } // The busy-flag is used to avoid reentering this interrupt
 
       #endif
       #if X_MIN_PIN > -1
             if(READ(X_MIN_PIN) != ENDSTOPS_INVERTING) {
+              endstops_triggered(step_events_completed);
               step_events_completed = current_block->step_event_count;
             }
       #endif
       #endif
       #if X_MAX_PIN > -1
         if((READ(X_MAX_PIN) != ENDSTOPS_INVERTING)  && (current_block->steps_x >0)){
+          endstops_triggered(step_events_completed);
           step_events_completed = current_block->step_event_count;
         }
         #endif
       #endif
       #if Y_MIN_PIN > -1
         if(READ(Y_MIN_PIN) != ENDSTOPS_INVERTING) {
+          endstops_triggered(step_events_completed);
           step_events_completed = current_block->step_event_count;
         }
       #endif
       #endif
       #if Y_MAX_PIN > -1
       if((READ(Y_MAX_PIN) != ENDSTOPS_INVERTING) && (current_block->steps_y >0)){
+          endstops_triggered(step_events_completed);
           step_events_completed = current_block->step_event_count;
         }
       #endif
       #endif
       #if Z_MIN_PIN > -1
         if(READ(Z_MIN_PIN) != ENDSTOPS_INVERTING) {
+          endstops_triggered(step_events_completed);
           step_events_completed = current_block->step_event_count;
         }
       #endif
       #endif
       #if Z_MAX_PIN > -1
         if((READ(Z_MAX_PIN) != ENDSTOPS_INVERTING)  && (current_block->steps_z >0)){
+          endstops_triggered(step_events_completed);
           step_events_completed = current_block->step_event_count;
         }
       #endif
     manage_inactivity(1);
     LCD_STATUS;
   }   
-}
+}

Marlin/stepper.h

   extern volatile long count_position[NUM_AXIS];
   extern volatile int count_direction[NUM_AXIS];
 #endif
+  
+void checkHitEndstops(); //call from somwhere to create an serial error message with the locations the endstops where hit, in case they were triggered
+void endstops_hit_on_purpose(); //avoid creation of the message, i.e. after homeing and before a routine call of checkHitEndstops();
+
+
 
 extern block_t *current_block;  // A pointer to the block currently being traced
+
+
 #endif

Marlin/streaming.h

-/*
-Streaming.h - Arduino library for supporting the << streaming operator
-Copyright (c) 2010 Mikal Hart.  All rights reserved.
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Lesser General Public
-License as published by the Free Software Foundation; either
-version 2.1 of the License, or (at your option) any later version.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public
-License along with this library; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-#ifndef ARDUINO_STREAMING
-#define ARDUINO_STREAMING
-
-//#include <WProgram.h>
-
-#define STREAMING_LIBRARY_VERSION 4
-
-// Generic template
-template<class T> 
-inline Print &operator <<(Print &stream, T arg) 
-{ stream.print(arg); return stream; }
-
-struct _BASED 
-{ 
-  long val; 
-  int base;
-  _BASED(long v, int b): val(v), base(b) 
-  {}
-};
-
-#define _HEX(a)     _BASED(a, HEX)
-#define _DEC(a)     _BASED(a, DEC)
-#define _OCT(a)     _BASED(a, OCT)
-#define _BIN(a)     _BASED(a, BIN)
-#define _BYTE(a)    _BASED(a, BYTE)
-
-// Specialization for class _BASED
-// Thanks to Arduino forum user Ben Combee who suggested this 
-// clever technique to allow for expressions like
-//   Serial << _HEX(a);
-
-inline Print &operator <<(Print &obj, const _BASED &arg)
-{ obj.print(arg.val, arg.base); return obj; } 
-
-#if ARDUINO >= 18
-// Specialization for class _FLOAT
-// Thanks to Michael Margolis for suggesting a way
-// to accommodate Arduino 0018's floating point precision
-// feature like this:
-//   Serial << _FLOAT(gps_latitude, 6); // 6 digits of precision
-
-struct _FLOAT
-{
-  float val;
-  int digits;
-  _FLOAT(double v, int d): val(v), digits(d)
-  {}
-};
-
-inline Print &operator <<(Print &obj, const _FLOAT &arg)
-{ obj.print(arg.val, arg.digits); return obj; }
-#endif
-
-// Specialization for enum _EndLineCode
-// Thanks to Arduino forum user Paul V. who suggested this
-// clever technique to allow for expressions like
-//   Serial << "Hello!" << endl;
-
-enum _EndLineCode { endl };
-
-inline Print &operator <<(Print &obj, _EndLineCode arg) 
-{ obj.println(); return obj; }
-
-#endif
-

Marlin/temperature.cpp

 #include "pins.h"
 #include "Marlin.h"
 #include "ultralcd.h"
-#include "streaming.h"
 #include "temperature.h"
 #include "watchdog.h"
 
 //            pTerm+=Kc*current_block->speed_e; //additional heating if extrusion speed is high
 //          #endif
           pid_output = constrain(pTerm + iTerm - dTerm, 0, PID_MAX);
+          
         }
     #endif //PID_OPENLOOP
     #ifdef PID_DEBUG
-     SERIAL_ECHOLN(" PIDDEBUG Input "<<pid_input<<" Output "<<pid_output" pTerm "<<pTerm<<" iTerm "<<iTerm<<" dTerm "<<dTerm);  
+     //SERIAL_ECHOLN(" PIDDEBUG Input "<<pid_input<<" Output "<<pid_output" pTerm "<<pTerm<<" iTerm "<<iTerm<<" dTerm "<<dTerm);  
     #endif //PID_DEBUG
+    HeaterPower=pid_output;
     analogWrite(HEATER_0_PIN, pid_output);
   #endif //PIDTEMP
 
 
     return (1023 * OVERSAMPLENR) - raw;
   #elif defined BED_USES_AD595
-    return celsius * (1024.0 / (5.0 * 100.0) ) * OVERSAMPLENR;
+    return lround(celsius * (1024.0 * OVERSAMPLENR/ (5.0 * 100.0) ) );
   #endif
 }
 
       temp_count++;
       break;
     default:
-      SERIAL_ERRORLN("Temp measurement error!");
+      SERIAL_ERROR_START;
+      SERIAL_ERRORLNPGM("Temp measurement error!");
       break;
   }
     
         if(current_raw[TEMPSENSOR_HOTEND_0] >= maxttemp_0) {
           target_raw[TEMPSENSOR_HOTEND_0] = 0;
           analogWrite(HEATER_0_PIN, 0);
-          SERIAL_ERRORLN("Temperature extruder 0 switched off. MAXTEMP triggered !!");
+          SERIAL_ERROR_START;
+          SERIAL_ERRORLNPGM("Temperature extruder 0 switched off. MAXTEMP triggered !!");
           kill();
         }
       #endif
         target_raw[TEMPSENSOR_HOTEND_1] = 0;
       if(current_raw[2] >= maxttemp_1) {
         analogWrite(HEATER_2_PIN, 0);
-        SERIAL_ERRORLN("Temperature extruder 1 switched off. MAXTEMP triggered !!");
+        SERIAL_ERROR_START;
+        SERIAL_ERRORLNPGM("Temperature extruder 1 switched off. MAXTEMP triggered !!");
         kill()
       }
     #endif
       if(current_raw[TEMPSENSOR_HOTEND_0] <= minttemp_0) {
         target_raw[TEMPSENSOR_HOTEND_0] = 0;
         analogWrite(HEATER_0_PIN, 0);
-        SERIAL_ERRORLN("Temperature extruder 0 switched off. MINTEMP triggered !!");
+        SERIAL_ERROR_START;
+        SERIAL_ERRORLNPGM("Temperature extruder 0 switched off. MINTEMP triggered !!");
         kill();
       }
     #endif
       if(current_raw[TEMPSENSOR_HOTEND_1] <= minttemp_1) {
         target_raw[TEMPSENSOR_HOTEND_1] = 0;
         analogWrite(HEATER_2_PIN, 0);
-        SERIAL_ERRORLN("Temperature extruder 1 switched off. MINTEMP triggered !!");
+        SERIAL_ERROR_START;
+        SERIAL_ERRORLNPGM("Temperature extruder 1 switched off. MINTEMP triggered !!");
         kill();
       }
     #endif
       if(current_raw[1] <= bed_minttemp) {
         target_raw[1] = 0;
         WRITE(HEATER_1_PIN, 0);
-        SERIAL_ERRORLN("Temperatur heated bed switched off. MINTEMP triggered !!");
+        SERIAL_ERROR_START;
+        SERIAL_ERRORLNPGM("Temperatur heated bed switched off. MINTEMP triggered !!");
         kill();
       }
     #endif
       if(current_raw[1] >= bed_maxttemp) {
         target_raw[1] = 0;
         WRITE(HEATER_1_PIN, 0);
-        SERIAL_ERRORLN("Temperature heated bed switched off. MAXTEMP triggered !!");
+        SERIAL_ERROR_START;
+        SERIAL_ERRORLNPGM("Temperature heated bed switched off. MAXTEMP triggered !!");
         kill();
       }
     #endif
   }
 }
 
-
+

Marlin/ultralcd.h

 
 
   #define LCD_MESSAGE(x) lcd_status(x);
+  #define LCD_MESSAGEPGM(x) lcd_statuspgm(PSTR(x));
   #define LCD_STATUS lcd_status()
 #else //no lcd
   #define LCD_STATUS

Marlin/ultralcd.pde

  
 static MainMenu menu;
 
+#include <avr/pgmspace.h>
+
+void lcdProgMemprint(const char *str)
+{
+  char ch=pgm_read_byte(str);
+  while(ch)
+  {
+    lcd.print(ch);
+    ch=pgm_read_byte(++str);
+  }
+}
+#define lcdprintPGM(x) lcdProgMemprint(PSTR(x))
+
 
 //===========================================================================
 //=============================functions         ============================
   strncpy(messagetext,message,LCD_WIDTH);
 }
 
+void lcd_statuspgm(const char* message)
+{
+  char ch=pgm_read_byte(message);
+  char *target=messagetext;
+  uint8_t cnt=0;
+  while(ch &&cnt<LCD_WIDTH)
+  {
+    *target=ch;
+    target++;
+    cnt++;
+    ch=pgm_read_byte(++message);
+  }
+}
+
 inline void clear()
 {
   lcd.clear();
   lcd.createChar(2,Thermometer);
   lcd.createChar(3,uplevel);
   lcd.createChar(4,refresh);
-  LCD_MESSAGE(fillto(LCD_WIDTH,"UltiMarlin ready."));
+  LCD_MESSAGEPGM("UltiMarlin ready.");
 }
 
 
     feedmultiplychanged=false;
     encoderpos=feedmultiply;
     clear();
-    lcd.setCursor(0,0);lcd.print("\002123/567\001 ");
+    lcd.setCursor(0,0);lcdprintPGM("\002123/567\001 ");
     #if defined BED_USES_THERMISTOR || defined BED_USES_AD595 
-      lcd.setCursor(10,0);lcd.print("B123/567\001 ");
+      lcd.setCursor(10,0);lcdprintPGM("B123/567\001 ");
     #endif
   }
     
     
     if(starttime!=oldtime)
     {
-      lcd.print(itostr2(time/60));lcd.print("h ");lcd.print(itostr2(time%60));lcd.print("m");
+      lcd.print(itostr2(time/60));lcdprintPGM("h ");lcd.print(itostr2(time%60));lcdprintPGM("m");
       oldtime=time;
     }
   }
   if((currentz!=oldzpos)||force_lcd_update)
   {
     lcd.setCursor(10,1);
-    lcd.print("Z:");lcd.print(itostr31(currentz));
+    lcdprintPGM("Z:");lcd.print(itostr31(currentz));
     oldzpos=currentz;
   }
   static int oldfeedmultiply=0;
   {
    oldfeedmultiply=curfeedmultiply;
    lcd.setCursor(0,2);
-   lcd.print(itostr3(curfeedmultiply));lcd.print("% ");
+   lcd.print(itostr3(curfeedmultiply));lcdprintPGM("% ");
   }
   if(messagetext[0]!='\0')
   {
   if(force_lcd_update)  //initial display of content
   {
     encoderpos=feedmultiply;
-    lcd.setCursor(0,0);lcd.print("\002123/567\001 ");
+    lcd.setCursor(0,0);lcdprintPGM("\002123/567\001 ");
     #if defined BED_USES_THERMISTOR || defined BED_USES_AD595 
-    lcd.setCursor(10,0);lcd.print("B123/567\001 ");
+    lcd.setCursor(10,0);lcdprintPGM("B123/567\001 ");
     #endif
   }
     
       {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Prepare");
+          lcd.setCursor(0,line);lcdprintPGM(" Prepare");
         }
         if((activeline==line) && CLICKED)
         {
       {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Auto Home");
+          lcd.setCursor(0,line);lcdprintPGM(" Auto Home");
         }
         if((activeline==line) && CLICKED)
         {
       {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Set Origin");
+          lcd.setCursor(0,line);lcdprintPGM(" Set Origin");
           
         }
         if((activeline==line) && CLICKED)
       {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Preheat"); 
+          lcd.setCursor(0,line);lcdprintPGM(" Preheat"); 
         }
         if((activeline==line) && CLICKED)
         {
       {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Extrude");
+          lcd.setCursor(0,line);lcdprintPGM(" Extrude");
         }
         if((activeline==line) && CLICKED)
         {
       {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Disable Steppers");
+          lcd.setCursor(0,line);lcdprintPGM(" Disable Steppers");
         }
         if((activeline==line) && CLICKED)
         {
       {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Control");
+          lcd.setCursor(0,line);lcdprintPGM(" Control");
         }
         if((activeline==line) && CLICKED)
         {
       {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" \002Nozzle:");
+          lcd.setCursor(0,line);lcdprintPGM(" \002Nozzle:");
           lcd.setCursor(13,line);lcd.print(ftostr3(intround(degHotend0())));
         }
         
       {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Fan speed:");
+          lcd.setCursor(0,line);lcdprintPGM(" Fan speed:");
           lcd.setCursor(13,line);lcd.print(ftostr3(fanpwm));
         }
         
     {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Acc:");
-          lcd.setCursor(13,line);lcd.print(itostr3(acceleration/100));lcd.print("00");
+          lcd.setCursor(0,line);lcdprintPGM(" Acc:");
+          lcd.setCursor(13,line);lcd.print(itostr3(acceleration/100));lcdprintPGM("00");
         }
         
         if((activeline==line) )
           {
             if(encoderpos<5) encoderpos=5;
             if(encoderpos>990) encoderpos=990;
-            lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcd.print("00");
+            lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcdprintPGM("00");
           }
         }
       }break;
       {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Vxy-jerk: ");
+          lcd.setCursor(0,line);lcdprintPGM(" Vxy-jerk: ");
           lcd.setCursor(13,line);lcd.print(itostr3(max_xy_jerk/60));
         }
         
       {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" PID-P: ");
+          lcd.setCursor(0,line);lcdprintPGM(" PID-P: ");
           lcd.setCursor(13,line);lcd.print(itostr4(Kp));
         }
         
       {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" PID-I: ");
+          lcd.setCursor(0,line);lcdprintPGM(" PID-I: ");
           lcd.setCursor(13,line);lcd.print(ftostr51(Ki));
         }
         
       {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" PID-D: ");
+          lcd.setCursor(0,line);lcdprintPGM(" PID-D: ");
           lcd.setCursor(13,line);lcd.print(itostr4(Kd));
         }
         
       {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" PID-C: ");
+          lcd.setCursor(0,line);lcdprintPGM(" PID-C: ");
           lcd.setCursor(13,line);lcd.print(itostr3(Kc));
         }
         
       {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Vmax ");
-          if(i==ItemC_vmaxx)lcd.print("x:");
-          if(i==ItemC_vmaxy)lcd.print("y:");
-          if(i==ItemC_vmaxz)lcd.print("z:");
-          if(i==ItemC_vmaxe)lcd.print("e:");
+          lcd.setCursor(0,line);lcdprintPGM(" Vmax ");
+          if(i==ItemC_vmaxx)lcdprintPGM("x:");
+          if(i==ItemC_vmaxy)lcdprintPGM("y:");
+          if(i==ItemC_vmaxz)lcdprintPGM("z:");
+          if(i==ItemC_vmaxe)lcdprintPGM("e:");
           lcd.setCursor(13,line);lcd.print(itostr3(max_feedrate[i-ItemC_vmaxx]/60));
         }
         
     {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Vmin:");
+          lcd.setCursor(0,line);lcdprintPGM(" Vmin:");
           lcd.setCursor(13,line);lcd.print(itostr3(minimumfeedrate/60));
         }
         
     {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" VTrav min:");
+          lcd.setCursor(0,line);lcdprintPGM(" VTrav min:");
           lcd.setCursor(13,line);lcd.print(itostr3(mintravelfeedrate/60));
         }
         
     {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Amax ");
-          if(i==ItemC_amaxx)lcd.print("x:");
-          if(i==ItemC_amaxy)lcd.print("y:");
-          if(i==ItemC_amaxz)lcd.print("z:");
-          if(i==ItemC_amaxe)lcd.print("e:");
-          lcd.setCursor(13,line);lcd.print(itostr3(max_acceleration_units_per_sq_second[i-ItemC_amaxx]/100));lcd.print("00");
+          lcd.setCursor(0,line);lcdprintPGM(" Amax ");
+          if(i==ItemC_amaxx)lcdprintPGM("x:");
+          if(i==ItemC_amaxy)lcdprintPGM("y:");
+          if(i==ItemC_amaxz)lcdprintPGM("z:");
+          if(i==ItemC_amaxe)lcdprintPGM("e:");
+          lcd.setCursor(13,line);lcd.print(itostr3(max_acceleration_units_per_sq_second[i-ItemC_amaxx]/100));lcdprintPGM("00");
         }
         
         if((activeline==line) )
           {
             if(encoderpos<1) encoderpos=1;
             if(encoderpos>990) encoderpos=990;
-            lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcd.print("00");
+            lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcdprintPGM("00");
           }
         }
       }break;
     {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" A-retract:");
-          lcd.setCursor(13,line);lcd.print(ftostr3(retract_acceleration/100));lcd.print("00");
+          lcd.setCursor(0,line);lcdprintPGM(" A-retract:");
+          lcd.setCursor(13,line);lcd.print(ftostr3(retract_acceleration/100));lcdprintPGM("00");
         }
         
         if((activeline==line) )
           {
             if(encoderpos<10) encoderpos=10;
             if(encoderpos>990) encoderpos=990;
-            lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcd.print("00");
+            lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcdprintPGM("00");
           }
         }
       }break;
          {
       if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" Esteps/mm:");
+          lcd.setCursor(0,line);lcdprintPGM(" Esteps/mm:");
           lcd.setCursor(13,line);lcd.print(itostr4(axis_steps_per_unit[3]));
         }
         
     {
       if(force_lcd_update)
       {
-        lcd.setCursor(0,line);lcd.print(" Store EPROM");
+        lcd.setCursor(0,line);lcdprintPGM(" Store EPROM");
       }
       if((activeline==line) && CLICKED)
       {
     {
       if(force_lcd_update)
       {
-        lcd.setCursor(0,line);lcd.print(" Load EPROM");
+        lcd.setCursor(0,line);lcdprintPGM(" Load EPROM");
       }
       if((activeline==line) && CLICKED)
       {
     {
       if(force_lcd_update)
       {
-        lcd.setCursor(0,line);lcd.print(" Restore Failsafe");
+        lcd.setCursor(0,line);lcdprintPGM(" Restore Failsafe");
       }
       if((activeline==line) && CLICKED)
       {
       {
         if(force_lcd_update)
         {
-          lcd.setCursor(0,line);lcd.print(" File");
+          lcd.setCursor(0,line);lcdprintPGM(" File");
         }
         if((activeline==line) && CLICKED)
         {
           if(true)
           #endif
           {
-            lcd.print(" \004Refresh");
+            lcdprintPGM(" \004Refresh");
           }
           else
           {
-            lcd.print(" \004Insert Card");
+            lcdprintPGM(" \004Insert Card");
           }
           
         }
         {
           card.getfilename(i-2);
           //Serial.print("Filenr:");Serial.println(i-2);
-          lcd.setCursor(0,line);lcd.print(" ");lcd.print(card.filename);
+          lcd.setCursor(0,line);lcdprintPGM(" ");lcd.print(card.filename);
         }
         if((activeline==line) && CLICKED)
         {
     { 
       case ItemM_watch:
       {
-        if(force_lcd_update) {lcd.setCursor(0,line);lcd.print(" Watch   \x7E");}
+        if(force_lcd_update) {lcd.setCursor(0,line);lcdprintPGM(" Watch   \x7E");}
         if((activeline==line)&&CLICKED)
         {
           BLOCK;
       } break;
       case ItemM_prepare:
       {
-        if(force_lcd_update) {lcd.setCursor(0,line);lcd.print(" Prepare \x7E");}
+        if(force_lcd_update) {lcd.setCursor(0,line);lcdprintPGM(" Prepare \x7E");}
         if((activeline==line)&&CLICKED)
         {
           BLOCK;
        
       case ItemM_control:
       {
-        if(force_lcd_update) {lcd.setCursor(0,line);lcd.print(" Control \x7E");}
+        if(force_lcd_update) {lcd.setCursor(0,line);lcdprintPGM(" Control \x7E");}
         if((activeline==line)&&CLICKED)
         {
           BLOCK;
           #endif
           {
             if(card.sdprinting)
-              lcd.print(" Stop Print   \x7E");
+              lcdprintPGM(" Stop Print   \x7E");
             else
-              lcd.print(" Card Menu    \x7E");
+              lcdprintPGM(" Card Menu    \x7E");
           }
           else
           {
-           lcd.print(" No Card"); 
+           lcdprintPGM(" No Card"); 
           }
         }
         #ifdef CARDINSERTED
       }break;
       #endif
       default: 
-        SERIAL_ERRORLN("Something is wrong in the MenuStructure.");
+        SERIAL_ERROR_START;
+        SERIAL_ERRORLNPGM("Something is wrong in the MenuStructure.");
       break;
     }
   }

Marlin/watchdog.pde

   {
  
     #ifdef RESET_MANUAL
-      LCD_MESSAGE("Please Reset!");
-      SERIAL_ERRORLN("Something is wrong, please turn off the printer.");
+      LCD_MESSAGEPGM("Please Reset!");
+      SERIAL_ERROR_START;
+      SERIAL_ERRORLNPGM("Something is wrong, please turn off the printer.");
     #else
-      LCD_MESSAGE("Timeout, resetting!");
+      LCD_MESSAGEPGM("Timeout, resetting!");
     #endif 
     //disable watchdog, it will survife reboot.
     WDTCSR |= (1<<WDCE) | (1<<WDE);