made progmem mainly, found one bug in cardreader, added a empty class for cardreader in case no sd support.

Marlin/EEPROMwrite.h

 }
 //======================================================================================
 
+#include <avr/pgmspace.h>
+
+void serialprintPGM(const char *str)
+{
+  char ch=pgm_read_byte(str);
+  while(ch)
+  {
+    Serial.print(ch);
+    ch=pgm_read_byte(++str);
+  }
+}
+#define SerialprintPGM(x) serialprintPGM(PSTR(x))
+
 #define EEPROM_OFFSET 100
 
 
   char ver2[4]=EEPROM_VERSION;
   i=EEPROM_OFFSET;
   EEPROM_writeAnything(i,ver2); // validate data
-  SERIAL_ECHOLN("Settings Stored");
+  SerialprintPGM("echo: Settings Stored\n");
 }
 
 void RetrieveSettings(bool def=false)
     EEPROM_readAnything(i,Ki);
     EEPROM_readAnything(i,Kd);
 
-    SERIAL_ECHOLN("Stored settings retreived:");
+    SerialprintPGM("echo: Stored settings retreived:\n");
   }
   else 
   {
     mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE;
     max_xy_jerk=DEFAULT_XYJERK;
     max_z_jerk=DEFAULT_ZJERK;
-    SERIAL_ECHOLN("Using Default settings:");
+    SerialprintPGM("echo: Using Default settings:\n");
   }
-  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));
+  SerialprintPGM("echo: Steps per unit:\n   M92 X");
+    Serial.print(axis_steps_per_unit[0]);
+    SerialprintPGM(" Y"); 
+    Serial.print(axis_steps_per_unit[1]);
+    SerialprintPGM(" Z");
+    Serial.print(axis_steps_per_unit[2]);
+    SerialprintPGM(" E");
+    Serial.print(axis_steps_per_unit[3]);
+    
+  SerialprintPGM("\nMaximum feedrates (mm/s):\n   M203 X"  );
+    Serial.print(max_feedrate[0]/60);
+    SerialprintPGM(" Y" ); 
+    Serial.print(max_feedrate[1]/60 ); 
+    SerialprintPGM(" Z" ); 
+    Serial.print(max_feedrate[2]/60 ); 
+    SerialprintPGM(" E" ); 
+    Serial.print(max_feedrate[3]/60);
+  SerialprintPGM("\nMaximum Acceleration (mm/s2):\n   M201 X"  );
+    Serial.print(max_acceleration_units_per_sq_second[0] ); 
+    SerialprintPGM(" Y" ); 
+    Serial.print(max_acceleration_units_per_sq_second[1] ); 
+    SerialprintPGM(" Z" ); 
+    Serial.print(max_acceleration_units_per_sq_second[2] );
+    SerialprintPGM(" E" ); 
+    Serial.print(max_acceleration_units_per_sq_second[3]);
+  SerialprintPGM("\necho: Acceleration: S=acceleration, T=retract acceleration\n   M204 S"  );
+    Serial.print(acceleration ); 
+    SerialprintPGM(" T" ); 
+    Serial.print(retract_acceleration);
+  SerialprintPGM("\necho: 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)");
+  SerialprintPGM("   M205 S"  );
+    Serial.print(minimumfeedrate/60 ); 
+    SerialprintPGM(" T" ); 
+    Serial.print(mintravelfeedrate/60 ); 
+    SerialprintPGM(" B" ); 
+    Serial.print(minsegmenttime ); 
+    SerialprintPGM(" X" ); 
+    Serial.print(max_xy_jerk/60 ); 
+    SerialprintPGM(" Z" ); 
+    Serial.print(max_z_jerk/60);
+    SerialprintPGM("\n" ); 
   #ifdef PIDTEMP
-    SERIAL_ECHOLN("PID settings:");
-    SERIAL_ECHOLN("   M301 P"  << _FLOAT(Kp,3) << " I" << _FLOAT(Ki,3) << " D" << _FLOAT(Kd,3));  
+    SerialprintPGM("PID settings:");
+    SerialprintPGM("   M301 P"  ); 
+    Serial.print(Kp ); 
+    SerialprintPGM(" I" ); 
+    Serial.print(Ki ); 
+    SerialprintPGM(" D" ); 
+    Serial.print(Kd);  
   #endif
 }  
 

Marlin/Marlin.h

 #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;
+#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;
 
 void get_command();
 void process_commands();

Marlin/Marlin.pde

 
 
 
+
 // look here for descriptions of gcodes: http://linuxcnc.org/handbook/gcode/g-code.html
 // http://objects.reprap.org/wiki/Mendel_User_Manual:_RepRapGCodes
 
 //===========================================================================
 
 
+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.
 { 
   Serial.begin(BAUDRATE);
   SERIAL_ECHOLN("Marlin "<<version_string);
-  Serial.println("start");
+  SERIAL_PROTOCOLLN("start");
+  Serial.print("echo: Free Memory:");
+  serial.println(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_PROTOCOLLN("ok");
 	}
 	else
 	{
 	  card.closefile();
-	  Serial.println("Done saving file.");
+	  SERIAL_PROTOCOLLN("Done saving file.");
 	}
       }
       else
           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_ERRORLN("Line Number is not Last Line Number+1, Last Line:"<<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_ERRORLN("checksum mismatch, Last Line:"<<gcode_LastN);
               FlushSerialRequestResend();
               serial_count = 0;
               return;
           }
           else 
           {
-            Serial.print("Error: No Checksum with line number, Last Line:");
-            Serial.println(gcode_LastN);
+            SERIAL_ERRORLN("No Checksum with line number, Last Line:"<<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_ERRORLN("No Line Number with checksum, Last Line:"<<gcode_LastN);
             serial_count = 0;
             return;
           }
             if(card.saving)
               break;
 	    #endif //SDSUPPORT
-            Serial.println("ok"); 
+            SERIAL_PROTOCOLLN("ok"); 
             break;
           default:
             break;
      
       if(card.eof()){
         card.sdprinting = false;
-        Serial.println("echo: Done printing file");
+        SERIAL_PROTOCOL("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_ECHOLN(time);
         LCD_MESSAGE(time);
         card.checkautostart(true);
       }
     #ifdef SDSUPPORT
 
     case 20: // M20 - list SD card
-      Serial.println("Begin file list");
+      SERIAL_PROTOCOLLN("Begin file list");
       card.ls();
-      Serial.println("End file list");
+      SERIAL_PROTOCOLLN("End file list");
       break;
     case 21: // M21 - init SD card
       
       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_ERRORLN(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
           bt = degBed();
       #endif
       #if (TEMP_0_PIN > -1) || defined (HEATER_USES_AD595)
-        Serial.print("ok T:");
-        Serial.print(tt); 
+        SERIAL_PROTOCOL("ok T:");
+        SERIAL_PROTOCOL(tt); 
         #if TEMP_1_PIN > -1 
           #ifdef PIDTEMP
-            Serial.print(" B:");
+            SERIAL_PROTOCOL(" B:");
             #if TEMP_1_PIN > -1
-              Serial.println(bt); 
+              SERIAL_PROTOCOLLN(bt); 
             #else
-              Serial.println(HeaterPower); 
+              SERIAL_PROTOCOLLN(HeaterPower); 
             #endif
           #else //not PIDTEMP
-            Serial.println();
+            SERIAL_PROTOCOLLN("");
            #endif //PIDTEMP
          #else
-            Serial.println();
+            SERIAL_PROTOCOLLN("");
           #endif //TEMP_1_PIN
         #else
           SERIAL_ERRORLN("No thermistors - no temp");
         #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_PROTOCOLLN("T:"<< degHotend0() ); 
           codenum = millis();
         }
         manage_heater();
           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_PROTOCOLLN("T:"<<tt );
+            SERIAL_PROTOCOLLN("ok T:"<<tt <<" B:"<<degBed() ); 
             codenum = millis(); 
           }
           manage_heater();
       }
       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");
+      SERIAL_PROTOCOLLN("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_PROTOCOL("X:");
+      SERIAL_PROTOCOL(current_position[X_AXIS]);
+      SERIAL_PROTOCOL("Y:");
+      SERIAL_PROTOCOL(current_position[Y_AXIS]);
+      SERIAL_PROTOCOL("Z:");
+      SERIAL_PROTOCOL(current_position[Z_AXIS]);
+      SERIAL_PROTOCOL("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_PROTOCOL(" Count X:");
+        SERIAL_PROTOCOL(float(count_position[X_AXIS])/axis_steps_per_unit[X_AXIS]);
+        SERIAL_PROTOCOL("Y:");
+        SERIAL_PROTOCOL(float(count_position[Y_AXIS])/axis_steps_per_unit[Y_AXIS]);
+        SERIAL_PROTOCOL("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_PROTOCOL("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_PROTOCOL("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_PROTOCOL("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_PROTOCOL("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_PROTOCOL("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_PROTOCOL("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
   }
   else
   {
-    Serial.print("echo: Unknown command:\"");
-    Serial.print(cmdbuffer[bufindr]);
-    Serial.println("\"");
+    SERIAL_ECHOLN("Unknown command:\""<<cmdbuffer[bufindr]<<"\"");
   }
 
   ClearToSend();
 {
   //char cmdbuffer[bufindr][100]="Resend:";
   Serial.flush();
-  Serial.print("Resend:");
-  Serial.println(gcode_LastN + 1);
+  SERIAL_PROTOCOLLN("Resend:"<<gcode_LastN + 1);
   ClearToSend();
 }
 
   if(fromsd[bufindr])
     return;
   #endif //SDSUPPORT
-  Serial.println("ok"); 
+  SERIAL_PROTOCOLLN("ok"); 
 }
 
 inline void get_coordinates()

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 char get() {  int16_t n = file.read(); return (n==-1)?'\n':(char)n;};
   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

     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_PROTOCOLLN("File opened:"<<name<<" Size:"<<filesize);
       sdpos = 0;
       
-      Serial.println("File selected");
+      SERIAL_PROTOCOLLN("File selected");
     }
     else{
-      Serial.println("file.open failed");
+      SERIAL_PROTOCOLLN("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_PROTOCOLLN("open failed, File: "<<name<<".");
     }
     else{
       saving = true;
-      Serial.print("Writing to file: ");
-      Serial.println(name);
+      SERIAL_PROTOCOLLN("Writing to file: "<<name);
     }
   }
 }
 void CardReader::getStatus()
 {
   if(cardOK){
-    Serial.print("SD printing byte ");
-    Serial.print(sdpos);
-    Serial.print("/");
-    Serial.println(filesize);
+    SERIAL_PROTOCOLLN("SD printing byte "<<sdpos<<"/"<<filesize);
   }
   else{
-    Serial.println("Not SD printing");
+    SERIAL_PROTOCOLLN("Not SD printing");
   }
 }
 void CardReader::write_command(char *buf)

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         ============================
     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