Automatic bed calibration by searching the 3x3 point matrix.

Fixed a problem with low RAM by re-vamping the langtool.

Firmware/Configuration.h

@@ -5,10 +5,12 @@
 #include "Configuration_prusa.h"
 
 // Firmware version
-#define FW_version "3.0.1"
+#define FW_version "3.0.2"
 
 
 
+// The total size of the EEPROM is
+// 4096 for the Atmega2560
 #define EEPROM_SILENT 4095
 #define EEPROM_LANG 4094
 #define EEPROM_BABYSTEP_X 4092
@@ -17,8 +19,12 @@
 #define EEPROM_BABYSTEP_Z_SET 4087
 #define EEPROM_BABYSTEP_Z0 4085
 #define EEPROM_FILAMENTUSED 4081
+// uint32_t
 #define EEPROM_TOTALTIME 4077
 
+#define EEPROM_BED_CALIBRATION_CENTER    (EEPROM_TOTALTIME-2*4)
+#define EEPROM_BED_CALIBRATION_VEC_X     (EEPROM_BED_CALIBRATION_CENTER-2*4)
+#define EEPROM_BED_CALIBRATION_VEC_Y     (EEPROM_BED_CALIBRATION_VEC_X-2*4)
 
 
 // This configuration file contains the basic settings.

Firmware/Firmware.sublime-project

@@ -0,0 +1,59 @@
+{
+	"build_systems":
+	[
+		{
+			"name": "compile",
+			"working_dir": "$project_path",
+  			"file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$",
+  			// Arduino build process:
+  			// https://www.arduino.cc/en/Hacking/BuildProcess
+			"shell_cmd": "\"c:\\Program Files (x86)\\Arduino\\arduino_debug.exe\" --pref build.path=..\\output --verify --board marlinAddon:avr:rambo -v --preserve-temp-files Firmware.ino"
+		},
+		{
+			"name": "compile & upload",
+			"working_dir": "$project_path",
+  			"file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$",
+  			//FIXME 
+  			// Better to use avrdude directly?
+  			// http://www.nongnu.org/avrdude/user-manual/avrdude_4.html
+  			// avrdude -F -v -pm168 -cstk500v1 -P\\.\COM4 -b19200 -D -Uflash:w:"file.hex":i
+  			// may need add path to avrdude config file: -C"c:\utils\arduino-0016\hardware\tools\avr\etc\avrdude.conf" if Arduino IDE installed in "c:\utils\arduino-0016\"
+  			// https://typeunsafe.wordpress.com/2011/07/22/programming-arduino-with-avrdude/
+			"shell_cmd": "\"c:\\Program Files (x86)\\Arduino\\arduino_debug.exe\" --pref build.path=..\\output --upload --port COM6 --board marlinAddon:avr:rambo -v --preserve-temp-files Firmware.ino"
+		},
+		{
+			"name": "map-data",
+			"working_dir": "$project_path",
+			// https://sourceware.org/binutils/docs-2.21/binutils/objdump.html
+			// Maybe it is better to generate map files by the linker?
+			// avr-gcc -g -mmcu=atmega8 -Wl,-Map,demo.map -o demo.elf demo.o
+			"shell_cmd": "\"c:\\Program Files (x86)\\Arduino\\hardware\\tools\\avr\\bin\\avr-objdump.exe\" -x -S -C -j .data ..\\output\\Firmware.ino.elf > ..\\output\\Firmware-data.map"
+		},
+		{
+			"name": "map-bss",
+			"working_dir": "$project_path",
+			// https://sourceware.org/binutils/docs-2.21/binutils/objdump.html
+			"shell_cmd": "\"c:\\Program Files (x86)\\Arduino\\hardware\\tools\\avr\\bin\\avr-objdump.exe\" -x -S -C -j .bss ..\\output\\Firmware.ino.elf > ..\\output\\Firmware-bss.map"
+		},
+		{
+			"name": "map-all",
+			"working_dir": "$project_path",
+			// https://sourceware.org/binutils/docs-2.21/binutils/objdump.html
+			"shell_cmd": "\"c:\\Program Files (x86)\\Arduino\\hardware\\tools\\avr\\bin\\avr-objdump.exe\" -x -S -C ..\\output\\Firmware.ino.elf > ..\\output\\Firmware-all.map"
+		},
+		{
+			"name": "disassemble",
+			"working_dir": "$project_path",
+			// https://sourceware.org/binutils/docs-2.21/binutils/objdump.html
+			"shell_cmd": "\"c:\\Program Files (x86)\\Arduino\\hardware\\tools\\avr\\bin\\avr-objdump.exe\" -h -w -S ..\\output\\Firmware.ino.elf > ..\\output\\Firmware.asm"
+		}
+	],
+	"folders":
+	[
+		{
+			"path": "."
+//	        "folder_exclude_patterns": [".svn", "._d", ".metadata", ".settings"],
+//	        "file_exclude_patterns": ["XS.c"]
+		}
+	]
+}

Firmware/Marlin.h

@@ -250,6 +250,7 @@ extern int extruder_multiply[EXTRUDERS]; // sets extrude multiply factor (in per
 extern float filament_size[EXTRUDERS]; // cross-sectional area of filament (in millimeters), typically around 1.75 or 2.85, 0 disables the volumetric calculations for the extruder.
 extern float volumetric_multiplier[EXTRUDERS]; // reciprocal of cross-sectional area of filament (in square millimeters), stored this way to reduce computational burden in planner
 extern float current_position[NUM_AXIS] ;
+extern float destination[NUM_AXIS] ;
 extern float add_homing[3];
 #ifdef DELTA
 extern float endstop_adj[3];
@@ -322,3 +323,6 @@ extern void digipot_i2c_init();
 
 extern void calculate_volumetric_multipliers();
 
+// Similar to the default Arduino delay function, 
+// but it keeps the background tasks running.
+extern void delay_keep_alive(int ms);

Firmware/Marlin_main.cpp

@@ -46,6 +46,7 @@
 
 #ifdef MESH_BED_LEVELING
   #include "mesh_bed_leveling.h"
+  #include "mesh_bed_calibration.h"
 #endif
 
 #include "ultralcd.h"
@@ -247,6 +248,8 @@ int value;
 int babystepLoad[3];
 
 float homing_feedrate[] = HOMING_FEEDRATE;
+// Currently only the extruder axis may be switched to a relative mode.
+// Other axes are always absolute or relative based on the common relative_mode flag.
 bool axis_relative_modes[] = AXIS_RELATIVE_MODES;
 int feedmultiply=100; //100->1 200->2
 int saved_feedmultiply;
@@ -260,8 +263,8 @@ int extruder_multiply[EXTRUDERS] = {100
   #endif
 };
 
-bool is_usb_printing;
-bool _doMeshL;
+bool is_usb_printing = false;
+bool _doMeshL = false;
 unsigned int  usb_printing_counter;
 
 int lcd_change_fil_state = 0;
@@ -406,20 +409,24 @@ const char echomagic[] PROGMEM = "echo:";
 //=============================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};
+float destination[NUM_AXIS] = {  0.0, 0.0, 0.0, 0.0};
 
 #ifndef DELTA
 static float delta[3] = {0.0, 0.0, 0.0};
 #endif
 
+// For tracing an arc
 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;
 static long gcode_N, gcode_LastN, Stopped_gcode_LastN = 0;
 
-static bool relative_mode = false;  //Determines Absolute or Relative Coordinates
+// Determines Absolute or Relative Coordinates.
+// Also there is bool axis_relative_modes[] per axis flag.
+static bool relative_mode = false;  
 
 static char cmdbuffer[BUFSIZE][MAX_CMD_SIZE];
+// Marking a line in the cmdbuffer. If false, the command is confirmed by sending an "OK" on the serial line.
 static bool fromsd[BUFSIZE];
 static int bufindr = 0;
 static int bufindw = 0;
@@ -498,11 +505,6 @@ void serial_echopair_P(const char *s_P, unsigned long v)
   }
 #endif //!SDSUPPORT
 
-#ifdef MESH_BED_LEVELING
-static void find_bed();
-#endif
-
-
 //adds an command to the main command buffer
 //thats really done in a non-safe way.
 //needs overworking someday
@@ -636,6 +638,20 @@ void setup()
   SERIAL_PROTOCOLLNPGM("start");
   SERIAL_ECHO_START;
 
+#if 0
+  SERIAL_ECHOLN("Reading eeprom from 0 to 100: start");
+  for (int i = 0; i < 4096; ++ i) {
+      int b = eeprom_read_byte((unsigned char*)i);
+      if (b != 255) {
+          SERIAL_ECHO(i);
+          SERIAL_ECHO(":");
+          SERIAL_ECHO(b);
+          SERIAL_ECHOLN("");
+      }
+  }
+  SERIAL_ECHOLN("Reading eeprom from 0 to 100: done");
+  #endif
+
   // Check startup - does nothing if bootloader sets MCUSR to 0
   byte mcu = MCUSR;
   if(mcu & 1) SERIAL_ECHOLNRPGM(MSG_POWERUP);
@@ -669,9 +685,6 @@ void setup()
   {
     fromsd[i] = false;
   }
-
-
-	  
   
   // loads data from EEPROM if available else uses defaults (and resets step acceleration rate)
   Config_RetrieveSettings();
@@ -995,7 +1008,9 @@ DEFINE_PGM_READ_ANY(signed char, byte);
 #define XYZ_CONSTS_FROM_CONFIG(type, array, CONFIG) \
 static const PROGMEM type array##_P[3] =        \
     { X_##CONFIG, Y_##CONFIG, Z_##CONFIG };     \
-static inline type array(int axis)          \
+static inline type array(int axis)              \
+    { return pgm_read_any(&array##_P[axis]); }  \
+type array##_ext(int axis)                      \
     { return pgm_read_any(&array##_P[axis]); }
 
 XYZ_CONSTS_FROM_CONFIG(float, base_min_pos,    MIN_POS);
@@ -1506,6 +1521,7 @@ void process_commands()
 
   // PRUSA GCODES
 
+/*
   if(code_seen('PRUSA')){
     if(code_seen('Fir')){
 
@@ -1519,12 +1535,15 @@ void process_commands()
       lcd_force_language_selection();
     } else if(code_seen('Lz')) {
       EEPROM_save_B(EEPROM_BABYSTEP_Z,0);
-    } else if (code_seen('Cal')) {
-		lcd_calibration();
-	}
+    } 
+    //else if (code_seen('Cal')) {
+		//  lcd_calibration();
+	  // }
 
   }
-  else if(code_seen('G'))
+  else 
+*/
+  if(code_seen('G'))
   {
     switch((int)code_value())
     {
@@ -1786,7 +1805,6 @@ void process_commands()
             mbl.active = 0;
         #endif
 
-
       saved_feedrate = feedrate;
       saved_feedmultiply = feedmultiply;
       feedmultiply = 100;
@@ -1939,15 +1957,17 @@ void process_commands()
               feedrate = max_feedrate[Z_AXIS];
               plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate, active_extruder);
               st_synchronize();
-            #endif
+            #endif // defined (Z_RAISE_BEFORE_HOMING) && (Z_RAISE_BEFORE_HOMING > 0)
             #ifdef MESH_BED_LEVELING // If Mesh bed leveling, moxve X&Y to safe position for home
-			  if (!(axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] )) 
-			  {
-				  HOMEAXIS(X);
-				  HOMEAXIS(Y);
-			  } 
-              destination[X_AXIS] = MESH_MIN_X - X_PROBE_OFFSET_FROM_EXTRUDER;
-              destination[Y_AXIS] = MESH_MIN_Y - Y_PROBE_OFFSET_FROM_EXTRUDER;
+      			  if (!(axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] )) 
+      			  {
+      				  HOMEAXIS(X);
+      				  HOMEAXIS(Y);
+      			  } 
+              // 1st mesh bed leveling measurement point, corrected.
+              mbl.get_meas_xy(0, 0, destination[X_AXIS], destination[Y_AXIS], false);
+              // destination[X_AXIS] = MESH_MIN_X - X_PROBE_OFFSET_FROM_EXTRUDER;
+              // destination[Y_AXIS] = MESH_MIN_Y - Y_PROBE_OFFSET_FROM_EXTRUDER;
               destination[Z_AXIS] = MESH_HOME_Z_SEARCH;    // Set destination away from bed
               feedrate = homing_feedrate[Z_AXIS]/10;
               current_position[Z_AXIS] = 0;
@@ -1959,11 +1979,11 @@ void process_commands()
               current_position[Y_AXIS] = destination[Y_AXIS];
               HOMEAXIS(Z);
   		        _doMeshL = true;
-        #else
-            HOMEAXIS(Z);
-            #endif
+            #else // MESH_BED_LEVELING
+              HOMEAXIS(Z);
+            #endif // MESH_BED_LEVELING
           }
-        #else                      // Z Safe mode activated.
+        #else // defined(Z_SAFE_HOMING): Z Safe mode activated.
           if(home_all_axis) {
             destination[X_AXIS] = round(Z_SAFE_HOMING_X_POINT - X_PROBE_OFFSET_FROM_EXTRUDER);
             destination[Y_AXIS] = round(Z_SAFE_HOMING_Y_POINT - Y_PROBE_OFFSET_FROM_EXTRUDER);
@@ -2005,10 +2025,8 @@ void process_commands()
                 SERIAL_ECHOLNRPGM(MSG_ZPROBE_OUT);
             }
           }
-        #endif
-      #endif
-
-
+        #endif // Z_SAFE_HOMING
+      #endif // Z_HOME_DIR < 0
 
       if(code_seen(axis_codes[Z_AXIS])) {
         if(code_value_long() != 0) {
@@ -2046,15 +2064,17 @@ void process_commands()
         }
       }
 #endif
+
 #ifdef MESH_BED_LEVELING
 	  if (code_seen('W'))
 	  {
 		  _doMeshL = false;
-		  SERIAL_ECHOLN("G80 disabled");
+      SERIAL_ECHOLN("G80 disabled");
 	  }
 
 	  if ( _doMeshL)
 	  {
+		  st_synchronize();
 		  enquecommand_P((PSTR("G80")));
 	  }
 #endif
@@ -2270,7 +2290,7 @@ void process_commands()
             // Firstly check if we know where we are
             if ( !( axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] && axis_known_position[Z_AXIS] ) ){
                 // We don't know where we are! HOME!
-                enquecommand_P((PSTR("G28")));
+                enquecommand_P((PSTR("G28 W0")));
                 enquecommand_P((PSTR("G80")));
                 break;
             }
@@ -2278,13 +2298,13 @@ void process_commands()
             mbl.reset();
 			            
             // Cycle through all points and probe them
-            current_position[X_AXIS] = MESH_MIN_X - X_PROBE_OFFSET_FROM_EXTRUDER;
-            current_position[Y_AXIS] = MESH_MIN_Y - Y_PROBE_OFFSET_FROM_EXTRUDER;
-            
-            plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[X_AXIS]/30, active_extruder);
-            
+            // First move up.
             current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
             plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS]/60, active_extruder);
+            // The move to the first calibration point.
+            mbl.get_meas_xy(0, 0, current_position[X_AXIS], current_position[Y_AXIS], false);            
+            plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[X_AXIS]/30, active_extruder);
+            // Wait until the move is finished.
             st_synchronize();
             
             int mesh_point = 0;
@@ -2301,7 +2321,6 @@ void process_commands()
                 // Move Z to proper distance
                 current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
                 plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder);
-                
                 st_synchronize();
                 
                 // Get cords of measuring point
@@ -2309,26 +2328,19 @@ void process_commands()
                 iy = mesh_point / MESH_MEAS_NUM_X_POINTS;
                 if (iy & 1) ix = (MESH_MEAS_NUM_X_POINTS - 1) - ix; // Zig zag
                 
-                current_position[X_AXIS] = mbl.get_meas_x(ix);
-                current_position[Y_AXIS] = mbl.get_meas_y(iy);
-                
-                current_position[X_AXIS] -= X_PROBE_OFFSET_FROM_EXTRUDER;
-                current_position[Y_AXIS] -= Y_PROBE_OFFSET_FROM_EXTRUDER;
+                mbl.get_meas_xy(ix, iy, current_position[X_AXIS], current_position[Y_AXIS], false);
+                enable_endstops(false);
                 plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], XY_AXIS_FEEDRATE, active_extruder);
-                
                 st_synchronize();
                 
                 // Go down until endstop is hit
-                
-                find_bed();
-                
-                
-                
+                find_bed_induction_sensor_point_z();
+                                
                 mbl.set_z(ix, iy, current_position[Z_AXIS]);
-				if (!IS_SD_PRINTING)
-				{
-					custom_message_state--;
-				}
+        				if (!IS_SD_PRINTING)
+        				{
+        					custom_message_state--;
+        				}
                 mesh_point++;
                 
             }
@@ -2343,16 +2355,14 @@ void process_commands()
             plan_buffer_line(current_position[X_AXIS], current_position[X_AXIS], current_position[Z_AXIS], current_position[E_AXIS], XY_AXIS_FEEDRATE, active_extruder);
             st_synchronize();
 			
-			if(card.sdprinting || is_usb_printing ) 
-			{
+			      if(card.sdprinting || is_usb_printing ) 
+			      {
                 if(eeprom_read_byte((unsigned char*)EEPROM_BABYSTEP_Z_SET) == 0x01)
-				{
+				        {
                     EEPROM_read_B(EEPROM_BABYSTEP_Z,&babystepLoad[2]);
                     babystepsTodo[Z_AXIS] = babystepLoad[2];
                 }
             }
-
-
         }
         break;
         
@@ -2388,7 +2398,7 @@ void process_commands()
         case 82:
             SERIAL_PROTOCOLLNPGM("Finding bed ");
             setup_for_endstop_move();
-            find_bed();
+            find_bed_induction_sensor_point_z();
             clean_up_after_endstop_move();
             SERIAL_PROTOCOLPGM("Bed found at: ");
             SERIAL_PROTOCOL_F(current_position[Z_AXIS], 5);
@@ -2705,6 +2715,102 @@ void process_commands()
       }
      break;
 
+    case 44:
+        reset_bed_offset_and_skew();
+        break;
+
+    case 45: // M45: mesh_bed_calibration
+        {
+            // Firstly check if we know where we are
+            if ( !( axis_known_position[X_AXIS] && axis_known_position[Y_AXIS]) ){
+                // We don't know where we are! HOME!
+                enquecommand_P((PSTR("G28 X0 Y0")));
+                enquecommand_P((PSTR("M45")));
+                break;
+            }
+            
+            setup_for_endstop_move();
+            find_bed_offset_and_skew();
+//            improve_bed_offset_and_skew();
+            clean_up_after_endstop_move();
+            current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
+            plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS],current_position[Z_AXIS] , current_position[E_AXIS], homing_feedrate[Z_AXIS]/40, active_extruder);
+            /*
+            current_position[X_AXIS] = X_MIN_POS+0.2;
+            current_position[Y_AXIS] = Y_MIN_POS+0.2;
+            current_position[Z_AXIS] = Z_MIN_POS;
+            plan_buffer_line(current_position[X_AXIS], current_position[X_AXIS], current_position[Z_AXIS], current_position[E_AXIS], XY_AXIS_FEEDRATE, active_extruder);
+            */
+            st_synchronize();
+        }
+    break;
+
+    case 46: // M46: mesh_bed_calibration with manual Z up
+        {
+            // Firstly check if we know where we are
+            if ( !( axis_known_position[X_AXIS] && axis_known_position[Y_AXIS]) ){
+                // We don't know where we are! HOME!
+                enquecommand_P((PSTR("G28 X0 Y0 W0"))); // W0 tells G28 to not perform mesh bed leveling.
+                enquecommand_P((PSTR("M46")));
+                break;
+            }
+
+            lcd_update_enable(false);
+            if (lcd_calibrate_z_end_stop_manual()) {
+              mbl.reset();
+              setup_for_endstop_move();
+              find_bed_offset_and_skew();
+//              improve_bed_offset_and_skew(1);
+              clean_up_after_endstop_move();
+              // Print head up.
+              current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
+              plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS],current_position[Z_AXIS] , current_position[E_AXIS], homing_feedrate[Z_AXIS]/40, active_extruder);
+              st_synchronize();
+            }
+            // lcd_update_enable(true);
+            //lcd_implementation_clear();
+            //lcd_return_to_status();
+            // lcd_update();
+            // Mesh bed leveling.
+            // enquecommand_P((PSTR("G80")));
+            // The iprovement.
+            
+            //enquecommand_P((PSTR("G80")));
+            enquecommand_P((PSTR("G28 X0 Y0 W0")));
+            enquecommand_P((PSTR("M47")));
+        }
+    break;
+
+    case 47:
+    {
+          // Firstly check if we know where we are
+          if ( !( axis_known_position[X_AXIS] && axis_known_position[Y_AXIS]) ) {
+              // We don't know where we are! HOME!
+              enquecommand_P((PSTR("G28 X0 Y0 W0"))); // W0 tells G28 to not perform mesh bed leveling.
+              enquecommand_P((PSTR("M47")));
+              break;
+          }
+          lcd_update_enable(false);
+          mbl.reset();
+          setup_for_endstop_move();
+          bool success = improve_bed_offset_and_skew(1);
+          clean_up_after_endstop_move();
+          // Print head up.
+          current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
+          plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS],current_position[Z_AXIS] , current_position[E_AXIS], homing_feedrate[Z_AXIS]/40, active_extruder);
+          st_synchronize();
+          lcd_update_enable(true);
+          lcd_update();
+          if (success)
+              // Mesh bed leveling.
+              enquecommand_P((PSTR("G80")));
+          break;
+    }
+
+ //   case 47:
+ //       lcd_diag_show_end_stops();
+ //       break;
+
 // M48 Z-Probe repeatability measurement function.
 //
 // Usage:   M48 <n #_samples> <X X_position_for_samples> <Y Y_position_for_samples> <V Verbose_Level> <Engage_probe_for_each_reading> <L legs_of_movement_prior_to_doing_probe>
@@ -4789,36 +4895,6 @@ void calculate_delta(float cartesian[3])
 
 
 #ifdef MESH_BED_LEVELING
-    
-    static void find_bed() {
-        feedrate = homing_feedrate[Z_AXIS];
-        
-        // move down until you find the bed
-        float zPosition = -10;
-        plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS], feedrate/60, active_extruder);
-        st_synchronize();
-        
-        // we have to let the planner know where we are right now as it is not where we said to go.
-        zPosition = st_get_position_mm(Z_AXIS);
-        plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS]);
-        
-        // move up the retract distance
-        zPosition += home_retract_mm(Z_AXIS);
-        plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS], feedrate/60, active_extruder);
-        st_synchronize();
-        
-        // move back down slowly to find bed
-        feedrate = homing_feedrate[Z_AXIS]/4;
-        zPosition -= home_retract_mm(Z_AXIS) * 2;
-        plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS], feedrate/60, active_extruder);
-        st_synchronize();
-        
-        current_position[Z_AXIS] = st_get_position_mm(Z_AXIS);
-        // make sure the planner knows where we are as it may be a bit different than we last said to move to
-        plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
-    }
-    
-    
     void mesh_plan_buffer_line(const float &x, const float &y, const float &z, const float &e, const float &feed_rate, const uint8_t extruder) {
         float dx = x - current_position[X_AXIS];
         float dy = y - current_position[Y_AXIS];
@@ -5467,4 +5543,21 @@ void calculate_volumetric_multipliers() {
 #endif
 #endif
 }
-
+
+void delay_keep_alive(int ms)
+{
+    for (;;) {
+        manage_heater();
+        manage_inactivity();
+        lcd_update();
+        if (ms == 0)
+            break;
+        else if (ms >= 50) {
+            delay(50);
+            ms -= 50;
+        } else {
+            delay(ms);
+            ms = 0;
+        }
+    }
+}

Firmware/langtool.pl

@@ -0,0 +1,153 @@
+#!/usr/bin/perl
+# Processes language_xx.h files into language.cpp and language.h
+
+use strict;
+use warnings;
+
+my @langs = ("en","cz","it","es","pl");
+
+sub parselang 
+{
+    my ($filename) = @_;
+ 	open(my $fh, '<:encoding(UTF-8)', $filename)
+  		or die "Could not open file '$filename' $!";
+  	# Create a new hash reference.
+	my $out = {};
+	while (my $line = <$fh>) {
+		chomp $line;
+		next if (index($line, 'MSG') == -1);
+    	$line =~ /(?is)\#define\s*(\S*)\s*(.*)/;
+    	my $symbol = $1;
+    	my $v = $2;
+    	next if (! defined $symbol or length($symbol) == 0);
+    	# Trim whitespaces from both sides
+    	$v =~ s/^\s+|\s+$//g;
+		#$string =~ s/" MACHINE_NAME "/Prusa i3/;
+		$v =~ s/" FIRMWARE_URL "/https:\/\/github.com\/prusa3d\/Prusa-i3-Plus\//;
+		$v =~ s/" PROTOCOL_VERSION "/1.0/;
+		$v =~ s/" STRINGIFY\(EXTRUDERS\) "/1/;
+		$v =~ s/" MACHINE_UUID "/00000000-0000-0000-0000-000000000000/;
+		${$out}{$symbol} = $v;
+	}
+	return $out;
+}
+
+my %texts;
+my $num_languages = 0;
+foreach my $lang (@langs) {
+	my $symbols = parselang("language_$lang.h");
+ 	foreach my $key (keys %{$symbols}) {
+ 		if (! (exists $texts{$key})) {
+	 		$texts{$key} = [];
+ 		}
+ 		my $strings = $texts{$key};
+ 		die "Symbol $key defined first in $lang, undefined in the preceding language files."
+ 			if (scalar(@$strings) != $num_languages);
+ 		push @$strings, ${$symbols}{$key};
+ 	}
+ 	$num_languages += 1;
+ 	foreach my $key (keys %texts) {
+ 		my $strings = $texts{$key};
+ 		if (scalar(@$strings) != $num_languages) {
+ 			# die "Symbol $key undefined in $lang."
+ 			print "Symbol $key undefined in $lang. Using the english variant.\n";
+ 			push @$strings, ${$strings}[0];
+ 		}
+ 	}
+}
+
+my $filename = 'language_all.h';
+open(my $fh, '>', $filename) or die "Could not open file '$filename' $!";
+
+# For the programmatic access to the program memory, read
+# http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html
+
+print $fh <<END
+#ifndef LANGUAGE_ALL_H
+#define LANGUAGE_ALL_H
+
+#define LANG_NUM (${num_languages})
+
+extern unsigned char lang_selected;
+
+#define LANG_TABLE_SELECT_EXPLICIT(TABLE, LANG) ((const char*)(pgm_read_ptr(TABLE + (LANG))))
+#define LANG_TABLE_SELECT(TABLE) LANG_TABLE_SELECT_EXPLICIT(TABLE, lang_selected)
+
+END
+;
+
+foreach my $key (sort(keys %texts)) {
+    print $fh "extern const char* const ${key}_LANG_TABLE[LANG_NUM];\n";
+	print $fh "#define $key LANG_TABLE_SELECT(${key}_LANG_TABLE)\n";
+	print $fh "#define ${key}_EXPLICIT(LANG) LANG_TABLE_SELECT_EXPLICIT(${key}_LANG_TABLE, LANG)\n"
+		if ($key eq "MSG_LANGUAGE_NAME" || $key eq "MSG_LANGUAGE_SELECT");
+}
+
+print $fh <<END
+
+extern char* CAT2(const char *s1,const char *s2);
+extern char* CAT4(const char *s1,const char *s2,const char *s3,const char *s4);
+
+#endif //LANGUAGE_ALL.H
+END
+;
+close $fh;
+print ".h created\n";
+
+
+
+$filename = 'language_all.cpp';
+open($fh, '>', $filename) or die "Could not open file '$filename' $!";
+
+print $fh <<'END'
+#include <avr/pgmspace.h>
+#include "configuration_prusa.h"
+#include "language_all.h"
+
+#define LCD_WIDTH 20
+extern unsigned char lang_selected;
+
+END
+;
+
+foreach my $key (sort(keys %texts)) {
+	my $strings = $texts{$key};
+	for (my $i = 0; $i <= $#{$strings}; $i ++) {
+		my $suffix = uc($langs[$i]);
+		print $fh "const char ${key}_${suffix}[] PROGMEM = ${$strings}[$i];\n";
+	}
+    print $fh "const char * const ${key}_LANG_TABLE[LANG_NUM] PROGMEM = {\n";
+	for (my $i = 0; $i <= $#{$strings}; $i ++) {
+		my $suffix = uc($langs[$i]);
+		print $fh "\t${key}_${suffix}";
+		print $fh ',' if $i < $#{$strings};
+		print $fh "\n";
+	}
+	print $fh "};\n\n";
+}
+
+print $fh <<'END'
+
+char langbuffer[LCD_WIDTH+1];
+char* CAT2(const char *s1,const char *s2) {
+  unsigned char len=0;
+  strncpy_P(langbuffer+len,s1,LCD_WIDTH-len);
+  len+=strlen_P(s1);
+  strncpy_P(langbuffer+len,s2,LCD_WIDTH-len);
+  return langbuffer;
+}
+char* CAT4(const char *s1,const char *s2,const char *s3,const char *s4) {
+  unsigned char len=0;
+  strncpy_P(langbuffer+len,s1,LCD_WIDTH-len);
+  len+=strlen_P(s1);
+  strncpy_P(langbuffer+len,s2,LCD_WIDTH-len);
+  len+=strlen_P(s2);
+  strncpy_P(langbuffer+len,s3,LCD_WIDTH-len);
+  len+=strlen_P(s3);
+  strncpy_P(langbuffer+len,s4,LCD_WIDTH-len);
+  return langbuffer;
+}
+END
+;
+
+print ".cpp created.\nDone!\n";

Firmware/language_all.cpp

@@ -1,2564 +1,3498 @@
-#include <avr/pgmspace.h>
-#include "Configuration_prusa.h"
-#define LCD_WIDTH 20
-extern unsigned char lang_selected;
-const char MSGEN0[] PROGMEM = { CUSTOM_MENDEL_NAME " ready." }; //WELCOME_MSG
-const char MSGCZ0[] PROGMEM = { CUSTOM_MENDEL_NAME " ok" }; //WELCOME_MSG
-const char MSGIT0[] PROGMEM = { CUSTOM_MENDEL_NAME " pronto." }; //WELCOME_MSG
-const char MSGES0[] PROGMEM = { CUSTOM_MENDEL_NAME " lista" }; //WELCOME_MSG
-const char MSGPL0[] PROGMEM = { CUSTOM_MENDEL_NAME " gotowa" }; //WELCOME_MSG
-const char MSGEN1[] PROGMEM = { "Card inserted" }; //MSG_SD_INSERTED
-const char MSGCZ1[] PROGMEM = { "Karta vlozena" }; //MSG_SD_INSERTED
-const char MSGIT1[] PROGMEM = { "SD Card inserita" }; //MSG_SD_INSERTED
-const char MSGES1[] PROGMEM = { "Tarjeta colocada" }; //MSG_SD_INSERTED
-const char MSGPL1[] PROGMEM = { "Karta wlozona" }; //MSG_SD_INSERTED
-const char MSGEN2[] PROGMEM = { "Card removed" }; //MSG_SD_REMOVED
-const char MSGCZ2[] PROGMEM = { "Karta vyjmuta" }; //MSG_SD_REMOVED
-const char MSGIT2[] PROGMEM = { "SD Card rimossa" }; //MSG_SD_REMOVED
-const char MSGES2[] PROGMEM = { "Tarjeta retirada" }; //MSG_SD_REMOVED
-const char MSGPL2[] PROGMEM = { "Karta wyjeta" }; //MSG_SD_REMOVED
-const char MSGEN3[] PROGMEM = { "Main" }; //MSG_MAIN
-const char MSGCZ3[] PROGMEM = { "Hlavni nabidka" }; //MSG_MAIN
-const char MSGIT3[] PROGMEM = { "Menu principale" }; //MSG_MAIN
-const char MSGES3[] PROGMEM = { "Menu principal" }; //MSG_MAIN
-const char MSGPL3[] PROGMEM = { "Menu glowne" }; //MSG_MAIN
-const char MSGEN4[] PROGMEM = { "Autostart" }; //MSG_AUTOSTART
-const char MSGCZ4[] PROGMEM = { "Autostart" }; //MSG_AUTOSTART
-const char MSGIT4[] PROGMEM = { "Autostart" }; //MSG_AUTOSTART
-const char MSGES4[] PROGMEM = { "Autostart" }; //MSG_AUTOSTART
-const char MSGPL4[] PROGMEM = { "Autostart" }; //MSG_AUTOSTART
-const char MSGEN5[] PROGMEM = { "Disable steppers" }; //MSG_DISABLE_STEPPERS
-const char MSGCZ5[] PROGMEM = { "Vypnout motory" }; //MSG_DISABLE_STEPPERS
-const char MSGIT5[] PROGMEM = { "Disabilita Motori" }; //MSG_DISABLE_STEPPERS
-const char MSGES5[] PROGMEM = { "Apagar motores" }; //MSG_DISABLE_STEPPERS
-const char MSGPL5[] PROGMEM = { "Wylaczyc silniki" }; //MSG_DISABLE_STEPPERS
-const char MSGEN6[] PROGMEM = { "Auto home" }; //MSG_AUTO_HOME
-const char MSGCZ6[] PROGMEM = { "Auto home" }; //MSG_AUTO_HOME
-const char MSGIT6[] PROGMEM = { "Auto Home" }; //MSG_AUTO_HOME
-const char MSGES6[] PROGMEM = { "Llevar al origen" }; //MSG_AUTO_HOME
-const char MSGPL6[] PROGMEM = { "Auto home" }; //MSG_AUTO_HOME
-const char MSGEN7[] PROGMEM = { "Set home offsets" }; //MSG_SET_HOME_OFFSETS
-const char MSGCZ7[] PROGMEM = { "Nastav pocatek home" }; //MSG_SET_HOME_OFFSETS
-const char MSGIT7[] PROGMEM = { "Set home offsets" }; //MSG_SET_HOME_OFFSETS
-const char MSGES7[] PROGMEM = { "Set home offsets" }; //MSG_SET_HOME_OFFSETS
-const char MSGPL7[] PROGMEM = { "Nastav pocatek home" }; //MSG_SET_HOME_OFFSETS
-const char MSGEN8[] PROGMEM = { "Set origin" }; //MSG_SET_ORIGIN
-const char MSGCZ8[] PROGMEM = { "Nastav pocatek" }; //MSG_SET_ORIGIN
-const char MSGIT8[] PROGMEM = { "Set origin" }; //MSG_SET_ORIGIN
-const char MSGES8[] PROGMEM = { "Set origin" }; //MSG_SET_ORIGIN
-const char MSGPL8[] PROGMEM = { "Nastav pocatek" }; //MSG_SET_ORIGIN
-const char MSGEN9[] PROGMEM = { "Preheat PLA" }; //MSG_PREHEAT_PLA
-const char MSGCZ9[] PROGMEM = { "Predehrev PLA" }; //MSG_PREHEAT_PLA
-const char MSGIT9[] PROGMEM = { "Preheat PLA" }; //MSG_PREHEAT_PLA
-const char MSGES9[] PROGMEM = { "Preheat PLA" }; //MSG_PREHEAT_PLA
-const char MSGPL9[] PROGMEM = { "Predehrev PLA" }; //MSG_PREHEAT_PLA
-const char MSGEN10[] PROGMEM = { "Preheat PLA 1" }; //MSG_PREHEAT_PLA0
-const char MSGCZ10[] PROGMEM = { "Predehrev PLA 1" }; //MSG_PREHEAT_PLA0
-const char MSGIT10[] PROGMEM = { "Preheat PLA 1" }; //MSG_PREHEAT_PLA0
-const char MSGES10[] PROGMEM = { "Preheat PLA 1" }; //MSG_PREHEAT_PLA0
-const char MSGPL10[] PROGMEM = { "Predehrev PLA 1" }; //MSG_PREHEAT_PLA0
-const char MSGEN11[] PROGMEM = { "Preheat PLA 2" }; //MSG_PREHEAT_PLA1
-const char MSGCZ11[] PROGMEM = { "Predehrev PLA 2" }; //MSG_PREHEAT_PLA1
-const char MSGIT11[] PROGMEM = { "Preheat PLA 2" }; //MSG_PREHEAT_PLA1
-const char MSGES11[] PROGMEM = { "Preheat PLA 2" }; //MSG_PREHEAT_PLA1
-const char MSGPL11[] PROGMEM = { "Predehrev PLA 2" }; //MSG_PREHEAT_PLA1
-const char MSGEN12[] PROGMEM = { "Preheat PLA 3" }; //MSG_PREHEAT_PLA2
-const char MSGCZ12[] PROGMEM = { "Predehrev PLA 3" }; //MSG_PREHEAT_PLA2
-const char MSGIT12[] PROGMEM = { "Preheat PLA 3" }; //MSG_PREHEAT_PLA2
-const char MSGES12[] PROGMEM = { "Preheat PLA 3" }; //MSG_PREHEAT_PLA2
-const char MSGPL12[] PROGMEM = { "Predehrev PLA 3" }; //MSG_PREHEAT_PLA2
-const char MSGEN13[] PROGMEM = { "Preheat PLA All" }; //MSG_PREHEAT_PLA012
-const char MSGCZ13[] PROGMEM = { "Predehrev PLA All" }; //MSG_PREHEAT_PLA012
-const char MSGIT13[] PROGMEM = { "Preheat PLA All" }; //MSG_PREHEAT_PLA012
-const char MSGES13[] PROGMEM = { "Preheat PLA All" }; //MSG_PREHEAT_PLA012
-const char MSGPL13[] PROGMEM = { "Predehrev PLA All" }; //MSG_PREHEAT_PLA012
-const char MSGEN14[] PROGMEM = { "Preheat PLA Bed" }; //MSG_PREHEAT_PLA_BEDONLY
-const char MSGCZ14[] PROGMEM = { "Predehrev PLA Bed" }; //MSG_PREHEAT_PLA_BEDONLY
-const char MSGIT14[] PROGMEM = { "Preheat PLA Bed" }; //MSG_PREHEAT_PLA_BEDONLY
-const char MSGES14[] PROGMEM = { "Preheat PLA Bed" }; //MSG_PREHEAT_PLA_BEDONLY
-const char MSGPL14[] PROGMEM = { "Predehrev PLA Bed" }; //MSG_PREHEAT_PLA_BEDONLY
-const char MSGEN15[] PROGMEM = { "Preheat PLA conf" }; //MSG_PREHEAT_PLA_SETTINGS
-const char MSGCZ15[] PROGMEM = { "Predehrev PLA conf" }; //MSG_PREHEAT_PLA_SETTINGS
-const char MSGIT15[] PROGMEM = { "Preheat PLA conf" }; //MSG_PREHEAT_PLA_SETTINGS
-const char MSGES15[] PROGMEM = { "Preheat PLA conf" }; //MSG_PREHEAT_PLA_SETTINGS
-const char MSGPL15[] PROGMEM = { "Predehrev PLA conf" }; //MSG_PREHEAT_PLA_SETTINGS
-const char MSGEN16[] PROGMEM = { "Preheat ABS" }; //MSG_PREHEAT_ABS
-const char MSGCZ16[] PROGMEM = { "Predehrev ABS" }; //MSG_PREHEAT_ABS
-const char MSGIT16[] PROGMEM = { "Preheat ABS" }; //MSG_PREHEAT_ABS
-const char MSGES16[] PROGMEM = { "Preheat ABS" }; //MSG_PREHEAT_ABS
-const char MSGPL16[] PROGMEM = { "Predehrev ABS" }; //MSG_PREHEAT_ABS
-const char MSGEN17[] PROGMEM = { "Preheat ABS 1" }; //MSG_PREHEAT_ABS0
-const char MSGCZ17[] PROGMEM = { "Predehrev ABS 1" }; //MSG_PREHEAT_ABS0
-const char MSGIT17[] PROGMEM = { "Preheat ABS 1" }; //MSG_PREHEAT_ABS0
-const char MSGES17[] PROGMEM = { "Preheat ABS 1" }; //MSG_PREHEAT_ABS0
-const char MSGPL17[] PROGMEM = { "Predehrev ABS 1" }; //MSG_PREHEAT_ABS0
-const char MSGEN18[] PROGMEM = { "Preheat ABS 2" }; //MSG_PREHEAT_ABS1
-const char MSGCZ18[] PROGMEM = { "Predehrev ABS 2" }; //MSG_PREHEAT_ABS1
-const char MSGIT18[] PROGMEM = { "Preheat ABS 2" }; //MSG_PREHEAT_ABS1
-const char MSGES18[] PROGMEM = { "Preheat ABS 2" }; //MSG_PREHEAT_ABS1
-const char MSGPL18[] PROGMEM = { "Predehrev ABS 2" }; //MSG_PREHEAT_ABS1
-const char MSGEN19[] PROGMEM = { "Preheat ABS 3" }; //MSG_PREHEAT_ABS2
-const char MSGCZ19[] PROGMEM = { "Predehrev ABS 3" }; //MSG_PREHEAT_ABS2
-const char MSGIT19[] PROGMEM = { "Preheat ABS 3" }; //MSG_PREHEAT_ABS2
-const char MSGES19[] PROGMEM = { "Preheat ABS 3" }; //MSG_PREHEAT_ABS2
-const char MSGPL19[] PROGMEM = { "Predehrev ABS 3" }; //MSG_PREHEAT_ABS2
-const char MSGEN20[] PROGMEM = { "Preheat ABS All" }; //MSG_PREHEAT_ABS012
-const char MSGCZ20[] PROGMEM = { "Predehrev ABS All" }; //MSG_PREHEAT_ABS012
-const char MSGIT20[] PROGMEM = { "Preheat ABS All" }; //MSG_PREHEAT_ABS012
-const char MSGES20[] PROGMEM = { "Preheat ABS All" }; //MSG_PREHEAT_ABS012
-const char MSGPL20[] PROGMEM = { "Predehrev ABS All" }; //MSG_PREHEAT_ABS012
-const char MSGEN21[] PROGMEM = { "Preheat ABS Bed" }; //MSG_PREHEAT_ABS_BEDONLY
-const char MSGCZ21[] PROGMEM = { "Predehrev ABS Bed" }; //MSG_PREHEAT_ABS_BEDONLY
-const char MSGIT21[] PROGMEM = { "Preheat ABS Bed" }; //MSG_PREHEAT_ABS_BEDONLY
-const char MSGES21[] PROGMEM = { "Preheat ABS Bed" }; //MSG_PREHEAT_ABS_BEDONLY
-const char MSGPL21[] PROGMEM = { "Predehrev ABS Bed" }; //MSG_PREHEAT_ABS_BEDONLY
-const char MSGEN22[] PROGMEM = { "Preheat ABS conf" }; //MSG_PREHEAT_ABS_SETTINGS
-const char MSGCZ22[] PROGMEM = { "Predehrev ABS conf" }; //MSG_PREHEAT_ABS_SETTINGS
-const char MSGIT22[] PROGMEM = { "Preheat ABS conf" }; //MSG_PREHEAT_ABS_SETTINGS
-const char MSGES22[] PROGMEM = { "Preheat ABS conf" }; //MSG_PREHEAT_ABS_SETTINGS
-const char MSGPL22[] PROGMEM = { "Predehrev ABS conf" }; //MSG_PREHEAT_ABS_SETTINGS
-const char MSGEN23[] PROGMEM = { "Cooldown" }; //MSG_COOLDOWN
-const char MSGCZ23[] PROGMEM = { "Zchladit" }; //MSG_COOLDOWN
-const char MSGIT23[] PROGMEM = { "Raffredda" }; //MSG_COOLDOWN
-const char MSGES23[] PROGMEM = { "Enfriar" }; //MSG_COOLDOWN
-const char MSGPL23[] PROGMEM = { "Wychlodzic" }; //MSG_COOLDOWN
-const char MSGEN24[] PROGMEM = { "Switch power on" }; //MSG_SWITCH_PS_ON
-const char MSGCZ24[] PROGMEM = { "Vypnout zdroj" }; //MSG_SWITCH_PS_ON
-const char MSGIT24[] PROGMEM = { "Switch power on" }; //MSG_SWITCH_PS_ON
-const char MSGES24[] PROGMEM = { "Switch power on" }; //MSG_SWITCH_PS_ON
-const char MSGPL24[] PROGMEM = { "Vypnout zdroj" }; //MSG_SWITCH_PS_ON
-const char MSGEN25[] PROGMEM = { "Switch power off" }; //MSG_SWITCH_PS_OFF
-const char MSGCZ25[] PROGMEM = { "Zapnout zdroj" }; //MSG_SWITCH_PS_OFF
-const char MSGIT25[] PROGMEM = { "Switch power off" }; //MSG_SWITCH_PS_OFF
-const char MSGES25[] PROGMEM = { "Switch power off" }; //MSG_SWITCH_PS_OFF
-const char MSGPL25[] PROGMEM = { "Zapnout zdroj" }; //MSG_SWITCH_PS_OFF
-const char MSGEN26[] PROGMEM = { "Extrude" }; //MSG_EXTRUDE
-const char MSGCZ26[] PROGMEM = { "Extrudovat" }; //MSG_EXTRUDE
-const char MSGIT26[] PROGMEM = { "Extrude" }; //MSG_EXTRUDE
-const char MSGES26[] PROGMEM = { "Extrude" }; //MSG_EXTRUDE
-const char MSGPL26[] PROGMEM = { "Extrudovat" }; //MSG_EXTRUDE
-const char MSGEN27[] PROGMEM = { "Retract" }; //MSG_RETRACT
-const char MSGCZ27[] PROGMEM = { "Retract" }; //MSG_RETRACT
-const char MSGIT27[] PROGMEM = { "Retract" }; //MSG_RETRACT
-const char MSGES27[] PROGMEM = { "Retract" }; //MSG_RETRACT
-const char MSGPL27[] PROGMEM = { "Retract" }; //MSG_RETRACT
-const char MSGEN28[] PROGMEM = { "Move axis" }; //MSG_MOVE_AXIS
-const char MSGCZ28[] PROGMEM = { "Posunout osu" }; //MSG_MOVE_AXIS
-const char MSGIT28[] PROGMEM = { "Muovi Asse" }; //MSG_MOVE_AXIS
-const char MSGES28[] PROGMEM = { "Mover ejes" }; //MSG_MOVE_AXIS
-const char MSGPL28[] PROGMEM = { "Ruch osi" }; //MSG_MOVE_AXIS
-const char MSGEN29[] PROGMEM = { "Move X" }; //MSG_MOVE_X
-const char MSGCZ29[] PROGMEM = { "Posunout X" }; //MSG_MOVE_X
-const char MSGIT29[] PROGMEM = { "Muovi X" }; //MSG_MOVE_X
-const char MSGES29[] PROGMEM = { "Mover X" }; //MSG_MOVE_X
-const char MSGPL29[] PROGMEM = { "Przesunac X" }; //MSG_MOVE_X
-const char MSGEN30[] PROGMEM = { "Move Y" }; //MSG_MOVE_Y
-const char MSGCZ30[] PROGMEM = { "Posunout Y" }; //MSG_MOVE_Y
-const char MSGIT30[] PROGMEM = { "Muovi Y" }; //MSG_MOVE_Y
-const char MSGES30[] PROGMEM = { "Mover Y" }; //MSG_MOVE_Y
-const char MSGPL30[] PROGMEM = { "Przesunac Y" }; //MSG_MOVE_Y
-const char MSGEN31[] PROGMEM = { "Move Z" }; //MSG_MOVE_Z
-const char MSGCZ31[] PROGMEM = { "Posunout Z" }; //MSG_MOVE_Z
-const char MSGIT31[] PROGMEM = { "Muovi Z" }; //MSG_MOVE_Z
-const char MSGES31[] PROGMEM = { "Mover Z" }; //MSG_MOVE_Z
-const char MSGPL31[] PROGMEM = { "Przesunac Z" }; //MSG_MOVE_Z
-const char MSGEN32[] PROGMEM = { "Extruder" }; //MSG_MOVE_E
-const char MSGCZ32[] PROGMEM = { "Extruder" }; //MSG_MOVE_E
-const char MSGIT32[] PROGMEM = { "Estrusore" }; //MSG_MOVE_E
-const char MSGES32[] PROGMEM = { "Extrusor" }; //MSG_MOVE_E
-const char MSGPL32[] PROGMEM = { "Extruder" }; //MSG_MOVE_E
-const char MSGEN33[] PROGMEM = { "Extruder2" }; //MSG_MOVE_E1
-const char MSGCZ33[] PROGMEM = { "Extruder2" }; //MSG_MOVE_E1
-const char MSGIT33[] PROGMEM = { "Extruder2" }; //MSG_MOVE_E1
-const char MSGES33[] PROGMEM = { "Extruder2" }; //MSG_MOVE_E1
-const char MSGPL33[] PROGMEM = { "Extruder2" }; //MSG_MOVE_E1
-const char MSGEN34[] PROGMEM = { "Extruder3" }; //MSG_MOVE_E2
-const char MSGCZ34[] PROGMEM = { "Extruder3" }; //MSG_MOVE_E2
-const char MSGIT34[] PROGMEM = { "Extruder3" }; //MSG_MOVE_E2
-const char MSGES34[] PROGMEM = { "Extruder3" }; //MSG_MOVE_E2
-const char MSGPL34[] PROGMEM = { "Extruder3" }; //MSG_MOVE_E2
-const char MSGEN35[] PROGMEM = { "Move 0.1mm" }; //MSG_MOVE_01MM
-const char MSGCZ35[] PROGMEM = { "Posunout o 0.1mm" }; //MSG_MOVE_01MM
-const char MSGIT35[] PROGMEM = { "Move 0.1mm" }; //MSG_MOVE_01MM
-const char MSGES35[] PROGMEM = { "Move 0.1mm" }; //MSG_MOVE_01MM
-const char MSGPL35[] PROGMEM = { "Posunout o 0.1mm" }; //MSG_MOVE_01MM
-const char MSGEN36[] PROGMEM = { "Move 1mm" }; //MSG_MOVE_1MM
-const char MSGCZ36[] PROGMEM = { "Posunout o 1mm" }; //MSG_MOVE_1MM
-const char MSGIT36[] PROGMEM = { "Move 1mm" }; //MSG_MOVE_1MM
-const char MSGES36[] PROGMEM = { "Move 1mm" }; //MSG_MOVE_1MM
-const char MSGPL36[] PROGMEM = { "Posunout o 1mm" }; //MSG_MOVE_1MM
-const char MSGEN37[] PROGMEM = { "Move 10mm" }; //MSG_MOVE_10MM
-const char MSGCZ37[] PROGMEM = { "Posunout o 10mm" }; //MSG_MOVE_10MM
-const char MSGIT37[] PROGMEM = { "Move 10mm" }; //MSG_MOVE_10MM
-const char MSGES37[] PROGMEM = { "Move 10mm" }; //MSG_MOVE_10MM
-const char MSGPL37[] PROGMEM = { "Posunout o 10mm" }; //MSG_MOVE_10MM
-const char MSGEN38[] PROGMEM = { "Speed" }; //MSG_SPEED
-const char MSGCZ38[] PROGMEM = { "Rychlost" }; //MSG_SPEED
-const char MSGIT38[] PROGMEM = { "Velcità" }; //MSG_SPEED
-const char MSGES38[] PROGMEM = { "Velocidad" }; //MSG_SPEED
-const char MSGPL38[] PROGMEM = { "Predkosc" }; //MSG_SPEED
-const char MSGEN39[] PROGMEM = { "Nozzle" }; //MSG_NOZZLE
-const char MSGCZ39[] PROGMEM = { "Tryska" }; //MSG_NOZZLE
-const char MSGIT39[] PROGMEM = { "Ugello" }; //MSG_NOZZLE
-const char MSGES39[] PROGMEM = { "Fusor" }; //MSG_NOZZLE
-const char MSGPL39[] PROGMEM = { "Dysza" }; //MSG_NOZZLE
-const char MSGEN40[] PROGMEM = { "Nozzle2" }; //MSG_NOZZLE1
-const char MSGCZ40[] PROGMEM = { "Tryska2" }; //MSG_NOZZLE1
-const char MSGIT40[] PROGMEM = { "Nozzle2" }; //MSG_NOZZLE1
-const char MSGES40[] PROGMEM = { "Nozzle2" }; //MSG_NOZZLE1
-const char MSGPL40[] PROGMEM = { "Tryska2" }; //MSG_NOZZLE1
-const char MSGEN41[] PROGMEM = { "Nozzle3" }; //MSG_NOZZLE2
-const char MSGCZ41[] PROGMEM = { "Tryska3" }; //MSG_NOZZLE2
-const char MSGIT41[] PROGMEM = { "Nozzle3" }; //MSG_NOZZLE2
-const char MSGES41[] PROGMEM = { "Nozzle3" }; //MSG_NOZZLE2
-const char MSGPL41[] PROGMEM = { "Tryska3" }; //MSG_NOZZLE2
-const char MSGEN42[] PROGMEM = { "Bed" }; //MSG_BED
-const char MSGCZ42[] PROGMEM = { "Bed" }; //MSG_BED
-const char MSGIT42[] PROGMEM = { "Piatto" }; //MSG_BED
-const char MSGES42[] PROGMEM = { "Base" }; //MSG_BED
-const char MSGPL42[] PROGMEM = { "Stolik" }; //MSG_BED
-const char MSGEN43[] PROGMEM = { "Fan speed" }; //MSG_FAN_SPEED
-const char MSGCZ43[] PROGMEM = { "Rychlost vent." }; //MSG_FAN_SPEED
-const char MSGIT43[] PROGMEM = { "Ventola" }; //MSG_FAN_SPEED
-const char MSGES43[] PROGMEM = { "Ventilador" }; //MSG_FAN_SPEED
-const char MSGPL43[] PROGMEM = { "Predkosc went." }; //MSG_FAN_SPEED
-const char MSGEN44[] PROGMEM = { "Flow" }; //MSG_FLOW
-const char MSGCZ44[] PROGMEM = { "Prutok" }; //MSG_FLOW
-const char MSGIT44[] PROGMEM = { "Flusso" }; //MSG_FLOW
-const char MSGES44[] PROGMEM = { "Flujo" }; //MSG_FLOW
-const char MSGPL44[] PROGMEM = { "Przeplyw" }; //MSG_FLOW
-const char MSGEN45[] PROGMEM = { "Flow 0" }; //MSG_FLOW0
-const char MSGCZ45[] PROGMEM = { "Prutok 0" }; //MSG_FLOW0
-const char MSGIT45[] PROGMEM = { "Flow 0" }; //MSG_FLOW0
-const char MSGES45[] PROGMEM = { "Flow 0" }; //MSG_FLOW0
-const char MSGPL45[] PROGMEM = { "Prutok 0" }; //MSG_FLOW0
-const char MSGEN46[] PROGMEM = { "Flow 1" }; //MSG_FLOW1
-const char MSGCZ46[] PROGMEM = { "Prutok 1" }; //MSG_FLOW1
-const char MSGIT46[] PROGMEM = { "Flow 1" }; //MSG_FLOW1
-const char MSGES46[] PROGMEM = { "Flow 1" }; //MSG_FLOW1
-const char MSGPL46[] PROGMEM = { "Prutok 1" }; //MSG_FLOW1
-const char MSGEN47[] PROGMEM = { "Flow 2" }; //MSG_FLOW2
-const char MSGCZ47[] PROGMEM = { "Prutok 2" }; //MSG_FLOW2
-const char MSGIT47[] PROGMEM = { "Flow 2" }; //MSG_FLOW2
-const char MSGES47[] PROGMEM = { "Flow 2" }; //MSG_FLOW2
-const char MSGPL47[] PROGMEM = { "Prutok 2" }; //MSG_FLOW2
-const char MSGEN48[] PROGMEM = { "Control" }; //MSG_CONTROL
-const char MSGCZ48[] PROGMEM = { "Kontrola" }; //MSG_CONTROL
-const char MSGIT48[] PROGMEM = { "Control" }; //MSG_CONTROL
-const char MSGES48[] PROGMEM = { "Control" }; //MSG_CONTROL
-const char MSGPL48[] PROGMEM = { "Kontrola" }; //MSG_CONTROL
-const char MSGEN49[] PROGMEM = { " \002 Min" }; //MSG_MIN
-const char MSGCZ49[] PROGMEM = { " \002 Min" }; //MSG_MIN
-const char MSGIT49[] PROGMEM = { " \002 Min" }; //MSG_MIN
-const char MSGES49[] PROGMEM = { " \002 Min" }; //MSG_MIN
-const char MSGPL49[] PROGMEM = { " \002 Min" }; //MSG_MIN
-const char MSGEN50[] PROGMEM = { " \002 Max" }; //MSG_MAX
-const char MSGCZ50[] PROGMEM = { " \002 Max" }; //MSG_MAX
-const char MSGIT50[] PROGMEM = { " \002 Max" }; //MSG_MAX
-const char MSGES50[] PROGMEM = { " \002 Max" }; //MSG_MAX
-const char MSGPL50[] PROGMEM = { " \002 Max" }; //MSG_MAX
-const char MSGEN51[] PROGMEM = { " \002 Fact" }; //MSG_FACTOR
-const char MSGCZ51[] PROGMEM = { " \002 Fact" }; //MSG_FACTOR
-const char MSGIT51[] PROGMEM = { " \002 Fact" }; //MSG_FACTOR
-const char MSGES51[] PROGMEM = { " \002 Fact" }; //MSG_FACTOR
-const char MSGPL51[] PROGMEM = { " \002 Fact" }; //MSG_FACTOR
-const char MSGEN52[] PROGMEM = { "Autotemp" }; //MSG_AUTOTEMP
-const char MSGCZ52[] PROGMEM = { "Autotemp" }; //MSG_AUTOTEMP
-const char MSGIT52[] PROGMEM = { "Autotemp" }; //MSG_AUTOTEMP
-const char MSGES52[] PROGMEM = { "Autotemp" }; //MSG_AUTOTEMP
-const char MSGPL52[] PROGMEM = { "Autotemp" }; //MSG_AUTOTEMP
-const char MSGEN53[] PROGMEM = { "On " }; //MSG_ON
-const char MSGCZ53[] PROGMEM = { "On " }; //MSG_ON
-const char MSGIT53[] PROGMEM = { "On " }; //MSG_ON
-const char MSGES53[] PROGMEM = { "On " }; //MSG_ON
-const char MSGPL53[] PROGMEM = { "On " }; //MSG_ON
-const char MSGEN54[] PROGMEM = { "Off" }; //MSG_OFF
-const char MSGCZ54[] PROGMEM = { "Off" }; //MSG_OFF
-const char MSGIT54[] PROGMEM = { "Off" }; //MSG_OFF
-const char MSGES54[] PROGMEM = { "Off" }; //MSG_OFF
-const char MSGPL54[] PROGMEM = { "Off" }; //MSG_OFF
-const char MSGEN55[] PROGMEM = { "PID-P" }; //MSG_PID_P
-const char MSGCZ55[] PROGMEM = { "PID-P" }; //MSG_PID_P
-const char MSGIT55[] PROGMEM = { "PID-P" }; //MSG_PID_P
-const char MSGES55[] PROGMEM = { "PID-P" }; //MSG_PID_P
-const char MSGPL55[] PROGMEM = { "PID-P" }; //MSG_PID_P
-const char MSGEN56[] PROGMEM = { "PID-I" }; //MSG_PID_I
-const char MSGCZ56[] PROGMEM = { "PID-I" }; //MSG_PID_I
-const char MSGIT56[] PROGMEM = { "PID-I" }; //MSG_PID_I
-const char MSGES56[] PROGMEM = { "PID-I" }; //MSG_PID_I
-const char MSGPL56[] PROGMEM = { "PID-I" }; //MSG_PID_I
-const char MSGEN57[] PROGMEM = { "PID-D" }; //MSG_PID_D
-const char MSGCZ57[] PROGMEM = { "PID-D" }; //MSG_PID_D
-const char MSGIT57[] PROGMEM = { "PID-D" }; //MSG_PID_D
-const char MSGES57[] PROGMEM = { "PID-D" }; //MSG_PID_D
-const char MSGPL57[] PROGMEM = { "PID-D" }; //MSG_PID_D
-const char MSGEN58[] PROGMEM = { "PID-C" }; //MSG_PID_C
-const char MSGCZ58[] PROGMEM = { "PID-C" }; //MSG_PID_C
-const char MSGIT58[] PROGMEM = { "PID-C" }; //MSG_PID_C
-const char MSGES58[] PROGMEM = { "PID-C" }; //MSG_PID_C
-const char MSGPL58[] PROGMEM = { "PID-C" }; //MSG_PID_C
-const char MSGEN59[] PROGMEM = { "Accel" }; //MSG_ACC
-const char MSGCZ59[] PROGMEM = { "Accel" }; //MSG_ACC
-const char MSGIT59[] PROGMEM = { "Accel" }; //MSG_ACC
-const char MSGES59[] PROGMEM = { "Accel" }; //MSG_ACC
-const char MSGPL59[] PROGMEM = { "Accel" }; //MSG_ACC
-const char MSGEN60[] PROGMEM = { "Vxy-jerk" }; //MSG_VXY_JERK
-const char MSGCZ60[] PROGMEM = { "Vxy-jerk" }; //MSG_VXY_JERK
-const char MSGIT60[] PROGMEM = { "Vxy-jerk" }; //MSG_VXY_JERK
-const char MSGES60[] PROGMEM = { "Vxy-jerk" }; //MSG_VXY_JERK
-const char MSGPL60[] PROGMEM = { "Vxy-jerk" }; //MSG_VXY_JERK
-const char MSGEN61[] PROGMEM = { "Vz-jerk" }; //MSG_VZ_JERK
-const char MSGCZ61[] PROGMEM = { "Vz-jerk" }; //MSG_VZ_JERK
-const char MSGIT61[] PROGMEM = { "Vz-jerk" }; //MSG_VZ_JERK
-const char MSGES61[] PROGMEM = { "Vz-jerk" }; //MSG_VZ_JERK
-const char MSGPL61[] PROGMEM = { "Vz-jerk" }; //MSG_VZ_JERK
-const char MSGEN62[] PROGMEM = { "Ve-jerk" }; //MSG_VE_JERK
-const char MSGCZ62[] PROGMEM = { "Ve-jerk" }; //MSG_VE_JERK
-const char MSGIT62[] PROGMEM = { "Ve-jerk" }; //MSG_VE_JERK
-const char MSGES62[] PROGMEM = { "Ve-jerk" }; //MSG_VE_JERK
-const char MSGPL62[] PROGMEM = { "Ve-jerk" }; //MSG_VE_JERK
-const char MSGEN63[] PROGMEM = { "Vmax " }; //MSG_VMAX
-const char MSGCZ63[] PROGMEM = { "Vmax " }; //MSG_VMAX
-const char MSGIT63[] PROGMEM = { "Vmax " }; //MSG_VMAX
-const char MSGES63[] PROGMEM = { "Vmax " }; //MSG_VMAX
-const char MSGPL63[] PROGMEM = { "Vmax " }; //MSG_VMAX
-const char MSGEN64[] PROGMEM = { "x" }; //MSG_X
-const char MSGCZ64[] PROGMEM = { "x" }; //MSG_X
-const char MSGIT64[] PROGMEM = { "x" }; //MSG_X
-const char MSGES64[] PROGMEM = { "x" }; //MSG_X
-const char MSGPL64[] PROGMEM = { "x" }; //MSG_X
-const char MSGEN65[] PROGMEM = { "y" }; //MSG_Y
-const char MSGCZ65[] PROGMEM = { "y" }; //MSG_Y
-const char MSGIT65[] PROGMEM = { "y" }; //MSG_Y
-const char MSGES65[] PROGMEM = { "y" }; //MSG_Y
-const char MSGPL65[] PROGMEM = { "y" }; //MSG_Y
-const char MSGEN66[] PROGMEM = { "z" }; //MSG_Z
-const char MSGCZ66[] PROGMEM = { "z" }; //MSG_Z
-const char MSGIT66[] PROGMEM = { "z" }; //MSG_Z
-const char MSGES66[] PROGMEM = { "z" }; //MSG_Z
-const char MSGPL66[] PROGMEM = { "z" }; //MSG_Z
-const char MSGEN67[] PROGMEM = { "e" }; //MSG_E
-const char MSGCZ67[] PROGMEM = { "e" }; //MSG_E
-const char MSGIT67[] PROGMEM = { "e" }; //MSG_E
-const char MSGES67[] PROGMEM = { "e" }; //MSG_E
-const char MSGPL67[] PROGMEM = { "e" }; //MSG_E
-const char MSGEN68[] PROGMEM = { "Vmin" }; //MSG_VMIN
-const char MSGCZ68[] PROGMEM = { "Vmin" }; //MSG_VMIN
-const char MSGIT68[] PROGMEM = { "Vmin" }; //MSG_VMIN
-const char MSGES68[] PROGMEM = { "Vmin" }; //MSG_VMIN
-const char MSGPL68[] PROGMEM = { "Vmin" }; //MSG_VMIN
-const char MSGEN69[] PROGMEM = { "VTrav min" }; //MSG_VTRAV_MIN
-const char MSGCZ69[] PROGMEM = { "VTrav min" }; //MSG_VTRAV_MIN
-const char MSGIT69[] PROGMEM = { "VTrav min" }; //MSG_VTRAV_MIN
-const char MSGES69[] PROGMEM = { "VTrav min" }; //MSG_VTRAV_MIN
-const char MSGPL69[] PROGMEM = { "VTrav min" }; //MSG_VTRAV_MIN
-const char MSGEN70[] PROGMEM = { "Amax " }; //MSG_AMAX
-const char MSGCZ70[] PROGMEM = { "Amax " }; //MSG_AMAX
-const char MSGIT70[] PROGMEM = { "Amax " }; //MSG_AMAX
-const char MSGES70[] PROGMEM = { "Amax " }; //MSG_AMAX
-const char MSGPL70[] PROGMEM = { "Amax " }; //MSG_AMAX
-const char MSGEN71[] PROGMEM = { "A-retract" }; //MSG_A_RETRACT
-const char MSGCZ71[] PROGMEM = { "A-retract" }; //MSG_A_RETRACT
-const char MSGIT71[] PROGMEM = { "A-retract" }; //MSG_A_RETRACT
-const char MSGES71[] PROGMEM = { "A-retract" }; //MSG_A_RETRACT
-const char MSGPL71[] PROGMEM = { "A-retract" }; //MSG_A_RETRACT
-const char MSGEN72[] PROGMEM = { "Xsteps/mm" }; //MSG_XSTEPS
-const char MSGCZ72[] PROGMEM = { "Xsteps/mm" }; //MSG_XSTEPS
-const char MSGIT72[] PROGMEM = { "Xsteps/mm" }; //MSG_XSTEPS
-const char MSGES72[] PROGMEM = { "Xsteps/mm" }; //MSG_XSTEPS
-const char MSGPL72[] PROGMEM = { "Xsteps/mm" }; //MSG_XSTEPS
-const char MSGEN73[] PROGMEM = { "Ysteps/mm" }; //MSG_YSTEPS
-const char MSGCZ73[] PROGMEM = { "Ysteps/mm" }; //MSG_YSTEPS
-const char MSGIT73[] PROGMEM = { "Ysteps/mm" }; //MSG_YSTEPS
-const char MSGES73[] PROGMEM = { "Ysteps/mm" }; //MSG_YSTEPS
-const char MSGPL73[] PROGMEM = { "Ysteps/mm" }; //MSG_YSTEPS
-const char MSGEN74[] PROGMEM = { "Zsteps/mm" }; //MSG_ZSTEPS
-const char MSGCZ74[] PROGMEM = { "Zsteps/mm" }; //MSG_ZSTEPS
-const char MSGIT74[] PROGMEM = { "Zsteps/mm" }; //MSG_ZSTEPS
-const char MSGES74[] PROGMEM = { "Zsteps/mm" }; //MSG_ZSTEPS
-const char MSGPL74[] PROGMEM = { "Zsteps/mm" }; //MSG_ZSTEPS
-const char MSGEN75[] PROGMEM = { "Esteps/mm" }; //MSG_ESTEPS
-const char MSGCZ75[] PROGMEM = { "Esteps/mm" }; //MSG_ESTEPS
-const char MSGIT75[] PROGMEM = { "Esteps/mm" }; //MSG_ESTEPS
-const char MSGES75[] PROGMEM = { "Esteps/mm" }; //MSG_ESTEPS
-const char MSGPL75[] PROGMEM = { "Esteps/mm" }; //MSG_ESTEPS
-const char MSGEN76[] PROGMEM = { "Temperature" }; //MSG_TEMPERATURE
-const char MSGCZ76[] PROGMEM = { "Teplota" }; //MSG_TEMPERATURE
-const char MSGIT76[] PROGMEM = { "Temperatura" }; //MSG_TEMPERATURE
-const char MSGES76[] PROGMEM = { "Temperatura" }; //MSG_TEMPERATURE
-const char MSGPL76[] PROGMEM = { "Temperatura" }; //MSG_TEMPERATURE
-const char MSGEN77[] PROGMEM = { "Motion" }; //MSG_MOTION
-const char MSGCZ77[] PROGMEM = { "Pohyb" }; //MSG_MOTION
-const char MSGIT77[] PROGMEM = { "Motion" }; //MSG_MOTION
-const char MSGES77[] PROGMEM = { "Motion" }; //MSG_MOTION
-const char MSGPL77[] PROGMEM = { "Pohyb" }; //MSG_MOTION
-const char MSGEN78[] PROGMEM = { "Filament" }; //MSG_VOLUMETRIC
-const char MSGCZ78[] PROGMEM = { "Filament" }; //MSG_VOLUMETRIC
-const char MSGIT78[] PROGMEM = { "Filament" }; //MSG_VOLUMETRIC
-const char MSGES78[] PROGMEM = { "Filament" }; //MSG_VOLUMETRIC
-const char MSGPL78[] PROGMEM = { "Filament" }; //MSG_VOLUMETRIC
-const char MSGEN79[] PROGMEM = { "E in mm3" }; //MSG_VOLUMETRIC_ENABLED
-const char MSGCZ79[] PROGMEM = { "E in mm3" }; //MSG_VOLUMETRIC_ENABLED
-const char MSGIT79[] PROGMEM = { "E in mm3" }; //MSG_VOLUMETRIC_ENABLED
-const char MSGES79[] PROGMEM = { "E in mm3" }; //MSG_VOLUMETRIC_ENABLED
-const char MSGPL79[] PROGMEM = { "E in mm3" }; //MSG_VOLUMETRIC_ENABLED
-const char MSGEN80[] PROGMEM = { "Fil. Dia. 1" }; //MSG_FILAMENT_SIZE_EXTRUDER_0
-const char MSGCZ80[] PROGMEM = { "Fil. Dia. 1" }; //MSG_FILAMENT_SIZE_EXTRUDER_0
-const char MSGIT80[] PROGMEM = { "Fil. Dia. 1" }; //MSG_FILAMENT_SIZE_EXTRUDER_0
-const char MSGES80[] PROGMEM = { "Fil. Dia. 1" }; //MSG_FILAMENT_SIZE_EXTRUDER_0
-const char MSGPL80[] PROGMEM = { "Fil. Dia. 1" }; //MSG_FILAMENT_SIZE_EXTRUDER_0
-const char MSGEN81[] PROGMEM = { "Fil. Dia. 2" }; //MSG_FILAMENT_SIZE_EXTRUDER_1
-const char MSGCZ81[] PROGMEM = { "Fil. Dia. 2" }; //MSG_FILAMENT_SIZE_EXTRUDER_1
-const char MSGIT81[] PROGMEM = { "Fil. Dia. 2" }; //MSG_FILAMENT_SIZE_EXTRUDER_1
-const char MSGES81[] PROGMEM = { "Fil. Dia. 2" }; //MSG_FILAMENT_SIZE_EXTRUDER_1
-const char MSGPL81[] PROGMEM = { "Fil. Dia. 2" }; //MSG_FILAMENT_SIZE_EXTRUDER_1
-const char MSGEN82[] PROGMEM = { "Fil. Dia. 3" }; //MSG_FILAMENT_SIZE_EXTRUDER_2
-const char MSGCZ82[] PROGMEM = { "Fil. Dia. 3" }; //MSG_FILAMENT_SIZE_EXTRUDER_2
-const char MSGIT82[] PROGMEM = { "Fil. Dia. 3" }; //MSG_FILAMENT_SIZE_EXTRUDER_2
-const char MSGES82[] PROGMEM = { "Fil. Dia. 3" }; //MSG_FILAMENT_SIZE_EXTRUDER_2
-const char MSGPL82[] PROGMEM = { "Fil. Dia. 3" }; //MSG_FILAMENT_SIZE_EXTRUDER_2
-const char MSGEN83[] PROGMEM = { "LCD contrast" }; //MSG_CONTRAST
-const char MSGCZ83[] PROGMEM = { "LCD contrast" }; //MSG_CONTRAST
-const char MSGIT83[] PROGMEM = { "LCD contrast" }; //MSG_CONTRAST
-const char MSGES83[] PROGMEM = { "LCD contrast" }; //MSG_CONTRAST
-const char MSGPL83[] PROGMEM = { "LCD contrast" }; //MSG_CONTRAST
-const char MSGEN84[] PROGMEM = { "Store memory" }; //MSG_STORE_EPROM
-const char MSGCZ84[] PROGMEM = { "Store memory" }; //MSG_STORE_EPROM
-const char MSGIT84[] PROGMEM = { "Store memory" }; //MSG_STORE_EPROM
-const char MSGES84[] PROGMEM = { "Store memory" }; //MSG_STORE_EPROM
-const char MSGPL84[] PROGMEM = { "Store memory" }; //MSG_STORE_EPROM
-const char MSGEN85[] PROGMEM = { "Load memory" }; //MSG_LOAD_EPROM
-const char MSGCZ85[] PROGMEM = { "Ulozit pamet" }; //MSG_LOAD_EPROM
-const char MSGIT85[] PROGMEM = { "Load memory" }; //MSG_LOAD_EPROM
-const char MSGES85[] PROGMEM = { "Load memory" }; //MSG_LOAD_EPROM
-const char MSGPL85[] PROGMEM = { "Ulozit pamet" }; //MSG_LOAD_EPROM
-const char MSGEN86[] PROGMEM = { "Restore failsafe" }; //MSG_RESTORE_FAILSAFE
-const char MSGCZ86[] PROGMEM = { "Obnovit vychozi" }; //MSG_RESTORE_FAILSAFE
-const char MSGIT86[] PROGMEM = { "Restore failsafe" }; //MSG_RESTORE_FAILSAFE
-const char MSGES86[] PROGMEM = { "Restore failsafe" }; //MSG_RESTORE_FAILSAFE
-const char MSGPL86[] PROGMEM = { "Obnovit vychozi" }; //MSG_RESTORE_FAILSAFE
-const char MSGEN87[] PROGMEM = { "Refresh" }; //MSG_REFRESH
-const char MSGCZ87[] PROGMEM = { "Obnovit" }; //MSG_REFRESH
-const char MSGIT87[] PROGMEM = { "Refresh" }; //MSG_REFRESH
-const char MSGES87[] PROGMEM = { "Refresh" }; //MSG_REFRESH
-const char MSGPL87[] PROGMEM = { "Obnovit" }; //MSG_REFRESH
-const char MSGEN88[] PROGMEM = { "Info screen" }; //MSG_WATCH
-const char MSGCZ88[] PROGMEM = { "Informace" }; //MSG_WATCH
-const char MSGIT88[] PROGMEM = { "Guarda" }; //MSG_WATCH
-const char MSGES88[] PROGMEM = { "Monitorizar" }; //MSG_WATCH
-const char MSGPL88[] PROGMEM = { "Informacje" }; //MSG_WATCH
-const char MSGEN89[] PROGMEM = { "Prepare" }; //MSG_PREPARE
-const char MSGCZ89[] PROGMEM = { "Priprava" }; //MSG_PREPARE
-const char MSGIT89[] PROGMEM = { "Prepare" }; //MSG_PREPARE
-const char MSGES89[] PROGMEM = { "Prepare" }; //MSG_PREPARE
-const char MSGPL89[] PROGMEM = { "Priprava" }; //MSG_PREPARE
-const char MSGEN90[] PROGMEM = { "Tune" }; //MSG_TUNE
-const char MSGCZ90[] PROGMEM = { "Ladit" }; //MSG_TUNE
-const char MSGIT90[] PROGMEM = { "Adatta" }; //MSG_TUNE
-const char MSGES90[] PROGMEM = { "Ajustar" }; //MSG_TUNE
-const char MSGPL90[] PROGMEM = { "Nastroic" }; //MSG_TUNE
-const char MSGEN91[] PROGMEM = { "Pause print" }; //MSG_PAUSE_PRINT
-const char MSGCZ91[] PROGMEM = { "Pozastavit tisk" }; //MSG_PAUSE_PRINT
-const char MSGIT91[] PROGMEM = { "Pausa" }; //MSG_PAUSE_PRINT
-const char MSGES91[] PROGMEM = { "Pausar impresion" }; //MSG_PAUSE_PRINT
-const char MSGPL91[] PROGMEM = { "Przerwac druk" }; //MSG_PAUSE_PRINT
-const char MSGEN92[] PROGMEM = { "Resume print" }; //MSG_RESUME_PRINT
-const char MSGCZ92[] PROGMEM = { "Pokracovat" }; //MSG_RESUME_PRINT
-const char MSGIT92[] PROGMEM = { "Riprendi stampa" }; //MSG_RESUME_PRINT
-const char MSGES92[] PROGMEM = { "Reanudar impres." }; //MSG_RESUME_PRINT
-const char MSGPL92[] PROGMEM = { "Kontynuowac" }; //MSG_RESUME_PRINT
-const char MSGEN93[] PROGMEM = { "Stop print" }; //MSG_STOP_PRINT
-const char MSGCZ93[] PROGMEM = { "Zastavit tisk" }; //MSG_STOP_PRINT
-const char MSGIT93[] PROGMEM = { "Arresta stampa" }; //MSG_STOP_PRINT
-const char MSGES93[] PROGMEM = { "Detener impresion" }; //MSG_STOP_PRINT
-const char MSGPL93[] PROGMEM = { "Zatrzymac druk" }; //MSG_STOP_PRINT
-const char MSGEN94[] PROGMEM = { "Print from SD" }; //MSG_CARD_MENU
-const char MSGCZ94[] PROGMEM = { "Tisk z SD" }; //MSG_CARD_MENU
-const char MSGIT94[] PROGMEM = { "Menu SD Carta" }; //MSG_CARD_MENU
-const char MSGES94[] PROGMEM = { "Menu de SD" }; //MSG_CARD_MENU
-const char MSGPL94[] PROGMEM = { "Druk z SD" }; //MSG_CARD_MENU
-const char MSGEN95[] PROGMEM = { "No SD card" }; //MSG_NO_CARD
-const char MSGCZ95[] PROGMEM = { "Zadna SD karta" }; //MSG_NO_CARD
-const char MSGIT95[] PROGMEM = { "No SD Carta" }; //MSG_NO_CARD
-const char MSGES95[] PROGMEM = { "No hay tarjeta SD" }; //MSG_NO_CARD
-const char MSGPL95[] PROGMEM = { "Brak karty SD" }; //MSG_NO_CARD
-const char MSGEN96[] PROGMEM = { "Sleep..." }; //MSG_DWELL
-const char MSGCZ96[] PROGMEM = { "Sleep..." }; //MSG_DWELL
-const char MSGIT96[] PROGMEM = { "Sospensione..." }; //MSG_DWELL
-const char MSGES96[] PROGMEM = { "Reposo..." }; //MSG_DWELL
-const char MSGPL96[] PROGMEM = { "Sleep..." }; //MSG_DWELL
-const char MSGEN97[] PROGMEM = { "Wait for user..." }; //MSG_USERWAIT
-const char MSGCZ97[] PROGMEM = { "Wait for user..." }; //MSG_USERWAIT
-const char MSGIT97[] PROGMEM = { "Attendi Utente..." }; //MSG_USERWAIT
-const char MSGES97[] PROGMEM = { "Esperando ordenes" }; //MSG_USERWAIT
-const char MSGPL97[] PROGMEM = { "Wait for user..." }; //MSG_USERWAIT
-const char MSGEN98[] PROGMEM = { "Resuming print" }; //MSG_RESUMING
-const char MSGCZ98[] PROGMEM = { "Obnoveni tisku" }; //MSG_RESUMING
-const char MSGIT98[] PROGMEM = { "Riprendi Stampa" }; //MSG_RESUMING
-const char MSGES98[] PROGMEM = { "Resumiendo impre." }; //MSG_RESUMING
-const char MSGPL98[] PROGMEM = { "Wznowienie druku" }; //MSG_RESUMING
-const char MSGEN99[] PROGMEM = { "Print aborted" }; //MSG_PRINT_ABORTED
-const char MSGCZ99[] PROGMEM = { "Tisk prerusen" }; //MSG_PRINT_ABORTED
-const char MSGIT99[] PROGMEM = { "Stampa abortita" }; //MSG_PRINT_ABORTED
-const char MSGES99[] PROGMEM = { "Print aborted" }; //MSG_PRINT_ABORTED
-const char MSGPL99[] PROGMEM = { "Druk przerwany" }; //MSG_PRINT_ABORTED
-const char MSGEN100[] PROGMEM = { "No move." }; //MSG_NO_MOVE
-const char MSGCZ100[] PROGMEM = { "No move." }; //MSG_NO_MOVE
-const char MSGIT100[] PROGMEM = { "Nessun Movimento" }; //MSG_NO_MOVE
-const char MSGES100[] PROGMEM = { "Sin movimiento" }; //MSG_NO_MOVE
-const char MSGPL100[] PROGMEM = { "No move." }; //MSG_NO_MOVE
-const char MSGEN101[] PROGMEM = { "KILLED. " }; //MSG_KILLED
-const char MSGCZ101[] PROGMEM = { "KILLED. " }; //MSG_KILLED
-const char MSGIT101[] PROGMEM = { "UCCISO " }; //MSG_KILLED
-const char MSGES101[] PROGMEM = { "PARADA DE EMERG." }; //MSG_KILLED
-const char MSGPL101[] PROGMEM = { "KILLED. " }; //MSG_KILLED
-const char MSGEN102[] PROGMEM = { "STOPPED. " }; //MSG_STOPPED
-const char MSGCZ102[] PROGMEM = { "STOPPED. " }; //MSG_STOPPED
-const char MSGIT102[] PROGMEM = { "ARRESTATO " }; //MSG_STOPPED
-const char MSGES102[] PROGMEM = { "PARADA" }; //MSG_STOPPED
-const char MSGPL102[] PROGMEM = { "STOPPED. " }; //MSG_STOPPED
-const char MSGEN103[] PROGMEM = { "Retract mm" }; //MSG_CONTROL_RETRACT
-const char MSGCZ103[] PROGMEM = { "Retract mm" }; //MSG_CONTROL_RETRACT
-const char MSGIT103[] PROGMEM = { "Retract mm" }; //MSG_CONTROL_RETRACT
-const char MSGES103[] PROGMEM = { "Retract mm" }; //MSG_CONTROL_RETRACT
-const char MSGPL103[] PROGMEM = { "Retract mm" }; //MSG_CONTROL_RETRACT
-const char MSGEN104[] PROGMEM = { "Swap Re.mm" }; //MSG_CONTROL_RETRACT_SWAP
-const char MSGCZ104[] PROGMEM = { "Swap Re.mm" }; //MSG_CONTROL_RETRACT_SWAP
-const char MSGIT104[] PROGMEM = { "Swap Re.mm" }; //MSG_CONTROL_RETRACT_SWAP
-const char MSGES104[] PROGMEM = { "Swap Re.mm" }; //MSG_CONTROL_RETRACT_SWAP
-const char MSGPL104[] PROGMEM = { "Swap Re.mm" }; //MSG_CONTROL_RETRACT_SWAP
-const char MSGEN105[] PROGMEM = { "Retract  V" }; //MSG_CONTROL_RETRACTF
-const char MSGCZ105[] PROGMEM = { "Retract  V" }; //MSG_CONTROL_RETRACTF
-const char MSGIT105[] PROGMEM = { "Retract  V" }; //MSG_CONTROL_RETRACTF
-const char MSGES105[] PROGMEM = { "Retract  V" }; //MSG_CONTROL_RETRACTF
-const char MSGPL105[] PROGMEM = { "Retract  V" }; //MSG_CONTROL_RETRACTF
-const char MSGEN106[] PROGMEM = { "Hop mm" }; //MSG_CONTROL_RETRACT_ZLIFT
-const char MSGCZ106[] PROGMEM = { "Hop mm" }; //MSG_CONTROL_RETRACT_ZLIFT
-const char MSGIT106[] PROGMEM = { "Hop mm" }; //MSG_CONTROL_RETRACT_ZLIFT
-const char MSGES106[] PROGMEM = { "Hop mm" }; //MSG_CONTROL_RETRACT_ZLIFT
-const char MSGPL106[] PROGMEM = { "Hop mm" }; //MSG_CONTROL_RETRACT_ZLIFT
-const char MSGEN107[] PROGMEM = { "UnRet +mm" }; //MSG_CONTROL_RETRACT_RECOVER
-const char MSGCZ107[] PROGMEM = { "UnRet +mm" }; //MSG_CONTROL_RETRACT_RECOVER
-const char MSGIT107[] PROGMEM = { "UnRet +mm" }; //MSG_CONTROL_RETRACT_RECOVER
-const char MSGES107[] PROGMEM = { "UnRet +mm" }; //MSG_CONTROL_RETRACT_RECOVER
-const char MSGPL107[] PROGMEM = { "UnRet +mm" }; //MSG_CONTROL_RETRACT_RECOVER
-const char MSGEN108[] PROGMEM = { "S UnRet+mm" }; //MSG_CONTROL_RETRACT_RECOVER_SWAP
-const char MSGCZ108[] PROGMEM = { "S UnRet+mm" }; //MSG_CONTROL_RETRACT_RECOVER_SWAP
-const char MSGIT108[] PROGMEM = { "S UnRet+mm" }; //MSG_CONTROL_RETRACT_RECOVER_SWAP
-const char MSGES108[] PROGMEM = { "S UnRet+mm" }; //MSG_CONTROL_RETRACT_RECOVER_SWAP
-const char MSGPL108[] PROGMEM = { "S UnRet+mm" }; //MSG_CONTROL_RETRACT_RECOVER_SWAP
-const char MSGEN109[] PROGMEM = { "UnRet  V" }; //MSG_CONTROL_RETRACT_RECOVERF
-const char MSGCZ109[] PROGMEM = { "UnRet  V" }; //MSG_CONTROL_RETRACT_RECOVERF
-const char MSGIT109[] PROGMEM = { "UnRet  V" }; //MSG_CONTROL_RETRACT_RECOVERF
-const char MSGES109[] PROGMEM = { "UnRet  V" }; //MSG_CONTROL_RETRACT_RECOVERF
-const char MSGPL109[] PROGMEM = { "UnRet  V" }; //MSG_CONTROL_RETRACT_RECOVERF
-const char MSGEN110[] PROGMEM = { "AutoRetr." }; //MSG_AUTORETRACT
-const char MSGCZ110[] PROGMEM = { "AutoRetr." }; //MSG_AUTORETRACT
-const char MSGIT110[] PROGMEM = { "AutoRetr." }; //MSG_AUTORETRACT
-const char MSGES110[] PROGMEM = { "AutoRetr." }; //MSG_AUTORETRACT
-const char MSGPL110[] PROGMEM = { "AutoRetr." }; //MSG_AUTORETRACT
-const char MSGEN111[] PROGMEM = { "Change filament" }; //MSG_FILAMENTCHANGE
-const char MSGCZ111[] PROGMEM = { "Vymenit filament" }; //MSG_FILAMENTCHANGE
-const char MSGIT111[] PROGMEM = { "Cambiare filamento" }; //MSG_FILAMENTCHANGE
-const char MSGES111[] PROGMEM = { "Cambiar filamento" }; //MSG_FILAMENTCHANGE
-const char MSGPL111[] PROGMEM = { "Wymienic filament" }; //MSG_FILAMENTCHANGE
-const char MSGEN112[] PROGMEM = { "Init. SD card" }; //MSG_INIT_SDCARD
-const char MSGCZ112[] PROGMEM = { "Inic. SD" }; //MSG_INIT_SDCARD
-const char MSGIT112[] PROGMEM = { "Init. SD card" }; //MSG_INIT_SDCARD
-const char MSGES112[] PROGMEM = { "Init. SD card" }; //MSG_INIT_SDCARD
-const char MSGPL112[] PROGMEM = { "Inic. SD" }; //MSG_INIT_SDCARD
-const char MSGEN113[] PROGMEM = { "Change SD card" }; //MSG_CNG_SDCARD
-const char MSGCZ113[] PROGMEM = { "Vymenit SD" }; //MSG_CNG_SDCARD
-const char MSGIT113[] PROGMEM = { "Change SD card" }; //MSG_CNG_SDCARD
-const char MSGES113[] PROGMEM = { "Change SD card" }; //MSG_CNG_SDCARD
-const char MSGPL113[] PROGMEM = { "Vymenit SD" }; //MSG_CNG_SDCARD
-const char MSGEN114[] PROGMEM = { "Z probe out. bed" }; //MSG_ZPROBE_OUT
-const char MSGCZ114[] PROGMEM = { "Z probe out. bed" }; //MSG_ZPROBE_OUT
-const char MSGIT114[] PROGMEM = { "Z probe out. bed" }; //MSG_ZPROBE_OUT
-const char MSGES114[] PROGMEM = { "Z probe out. bed" }; //MSG_ZPROBE_OUT
-const char MSGPL114[] PROGMEM = { "Z probe out. bed" }; //MSG_ZPROBE_OUT
-const char MSGEN115[] PROGMEM = { "Home X/Y before Z" }; //MSG_POSITION_UNKNOWN
-const char MSGCZ115[] PROGMEM = { "Home X/Y before Z" }; //MSG_POSITION_UNKNOWN
-const char MSGIT115[] PROGMEM = { "Home X/Y before Z" }; //MSG_POSITION_UNKNOWN
-const char MSGES115[] PROGMEM = { "Home X/Y before Z" }; //MSG_POSITION_UNKNOWN
-const char MSGPL115[] PROGMEM = { "Home X/Y before Z" }; //MSG_POSITION_UNKNOWN
-const char MSGEN116[] PROGMEM = { "Z Offset" }; //MSG_ZPROBE_ZOFFSET
-const char MSGCZ116[] PROGMEM = { "Z Offset" }; //MSG_ZPROBE_ZOFFSET
-const char MSGIT116[] PROGMEM = { "Z Offset" }; //MSG_ZPROBE_ZOFFSET
-const char MSGES116[] PROGMEM = { "Z Offset" }; //MSG_ZPROBE_ZOFFSET
-const char MSGPL116[] PROGMEM = { "Z Offset" }; //MSG_ZPROBE_ZOFFSET
-const char MSGEN117[] PROGMEM = { "Babystep X" }; //MSG_BABYSTEP_X
-const char MSGCZ117[] PROGMEM = { "Babystep X" }; //MSG_BABYSTEP_X
-const char MSGIT117[] PROGMEM = { "Babystep X" }; //MSG_BABYSTEP_X
-const char MSGES117[] PROGMEM = { "Babystep X" }; //MSG_BABYSTEP_X
-const char MSGPL117[] PROGMEM = { "Babystep X" }; //MSG_BABYSTEP_X
-const char MSGEN118[] PROGMEM = { "Babystep Y" }; //MSG_BABYSTEP_Y
-const char MSGCZ118[] PROGMEM = { "Babystep Y" }; //MSG_BABYSTEP_Y
-const char MSGIT118[] PROGMEM = { "Babystep Y" }; //MSG_BABYSTEP_Y
-const char MSGES118[] PROGMEM = { "Babystep Y" }; //MSG_BABYSTEP_Y
-const char MSGPL118[] PROGMEM = { "Babystep Y" }; //MSG_BABYSTEP_Y
-const char MSGEN119[] PROGMEM = { "Live adjust Z" }; //MSG_BABYSTEP_Z
-const char MSGCZ119[] PROGMEM = { "Doladeni osy Z" }; //MSG_BABYSTEP_Z
-const char MSGIT119[] PROGMEM = { "Babystep Z" }; //MSG_BABYSTEP_Z
-const char MSGES119[] PROGMEM = { "Micropaso Z" }; //MSG_BABYSTEP_Z
-const char MSGPL119[] PROGMEM = { "Dostrojenie osy Z" }; //MSG_BABYSTEP_Z
-const char MSGEN120[] PROGMEM = { "Endstop abort" }; //MSG_ENDSTOP_ABORT
-const char MSGCZ120[] PROGMEM = { "Endstop abort" }; //MSG_ENDSTOP_ABORT
-const char MSGIT120[] PROGMEM = { "Endstop abort" }; //MSG_ENDSTOP_ABORT
-const char MSGES120[] PROGMEM = { "Endstop abort" }; //MSG_ENDSTOP_ABORT
-const char MSGPL120[] PROGMEM = { "Endstop abort" }; //MSG_ENDSTOP_ABORT
-const char MSGEN121[] PROGMEM = { "Auto adjust Z ?" }; //MSG_ADJUSTZ
-const char MSGCZ121[] PROGMEM = { "Auto doladit Z ?" }; //MSG_ADJUSTZ
-const char MSGIT121[] PROGMEM = { "Auto regolare Z ?" }; //MSG_ADJUSTZ
-const char MSGES121[] PROGMEM = { "Auto Micropaso Z?" }; //MSG_ADJUSTZ
-const char MSGPL121[] PROGMEM = { "Autodostroic Z?" }; //MSG_ADJUSTZ
-const char MSGEN122[] PROGMEM = { "Pick print" }; //MSG_PICK_Z
-const char MSGCZ122[] PROGMEM = { "Vyberte vytisk" }; //MSG_PICK_Z
-const char MSGIT122[] PROGMEM = { "Vyberte vytisk" }; //MSG_PICK_Z
-const char MSGES122[] PROGMEM = { "Vyberte vytisk" }; //MSG_PICK_Z
-const char MSGPL122[] PROGMEM = { "Vyberte vytisk" }; //MSG_PICK_Z
-const char MSGEN123[] PROGMEM = { "Calibrate Z" }; //MSG_HOMEYZ
-const char MSGCZ123[] PROGMEM = { "Kalibrovat Z" }; //MSG_HOMEYZ
-const char MSGIT123[] PROGMEM = { "Calibra Z" }; //MSG_HOMEYZ
-const char MSGES123[] PROGMEM = { "Calibrar Z" }; //MSG_HOMEYZ
-const char MSGPL123[] PROGMEM = { "Kalibruj Z" }; //MSG_HOMEYZ
-const char MSGEN124[] PROGMEM = { "Calibrating Z" }; //MSG_HOMEYZ_PROGRESS
-const char MSGCZ124[] PROGMEM = { "Kalibruji Z" }; //MSG_HOMEYZ_PROGRESS
-const char MSGIT124[] PROGMEM = { "Calibrando Z" }; //MSG_HOMEYZ_PROGRESS
-const char MSGES124[] PROGMEM = { "Calibrando Z" }; //MSG_HOMEYZ_PROGRESS
-const char MSGPL124[] PROGMEM = { "Kalibruje Z" }; //MSG_HOMEYZ_PROGRESS
-const char MSGEN125[] PROGMEM = { "Calibration done" }; //MSG_HOMEYZ_DONE
-const char MSGCZ125[] PROGMEM = { "Kalibrace OK" }; //MSG_HOMEYZ_DONE
-const char MSGIT125[] PROGMEM = { "Calibratura OK" }; //MSG_HOMEYZ_DONE
-const char MSGES125[] PROGMEM = { "Calibración OK" }; //MSG_HOMEYZ_DONE
-const char MSGPL125[] PROGMEM = { "Kalibracja OK" }; //MSG_HOMEYZ_DONE
-const char MSGEN126[] PROGMEM = { "Settings" }; //MSG_SETTINGS
-const char MSGCZ126[] PROGMEM = { "Nastaveni" }; //MSG_SETTINGS
-const char MSGIT126[] PROGMEM = { "Impostazioni" }; //MSG_SETTINGS
-const char MSGES126[] PROGMEM = { "Ajuste" }; //MSG_SETTINGS
-const char MSGPL126[] PROGMEM = { "Ustawienia" }; //MSG_SETTINGS
-const char MSGEN127[] PROGMEM = { "Preheat" }; //MSG_PREHEAT
-const char MSGCZ127[] PROGMEM = { "Predehrev" }; //MSG_PREHEAT
-const char MSGIT127[] PROGMEM = { "Preriscalda" }; //MSG_PREHEAT
-const char MSGES127[] PROGMEM = { "Precalentar" }; //MSG_PREHEAT
-const char MSGPL127[] PROGMEM = { "Grzanie" }; //MSG_PREHEAT
-const char MSGEN128[] PROGMEM = { "Unload filament" }; //MSG_UNLOAD_FILAMENT
-const char MSGCZ128[] PROGMEM = { "Vyjmout filament" }; //MSG_UNLOAD_FILAMENT
-const char MSGIT128[] PROGMEM = { "Scaricare fil." }; //MSG_UNLOAD_FILAMENT
-const char MSGES128[] PROGMEM = { "Sacar filamento" }; //MSG_UNLOAD_FILAMENT
-const char MSGPL128[] PROGMEM = { "Wyjac filament" }; //MSG_UNLOAD_FILAMENT
-const char MSGEN129[] PROGMEM = { "Load filament" }; //MSG_LOAD_FILAMENT
-const char MSGCZ129[] PROGMEM = { "Zavest filament" }; //MSG_LOAD_FILAMENT
-const char MSGIT129[] PROGMEM = { "Caricare filamento" }; //MSG_LOAD_FILAMENT
-const char MSGES129[] PROGMEM = { "Introducir filamento" }; //MSG_LOAD_FILAMENT
-const char MSGPL129[] PROGMEM = { "Wprowadz filament" }; //MSG_LOAD_FILAMENT
-const char MSGEN130[] PROGMEM = { "Rectract" }; //MSG_RECTRACT
-const char MSGCZ130[] PROGMEM = { "Rectract" }; //MSG_RECTRACT
-const char MSGIT130[] PROGMEM = { "Rectract" }; //MSG_RECTRACT
-const char MSGES130[] PROGMEM = { "Rectract" }; //MSG_RECTRACT
-const char MSGPL130[] PROGMEM = { "Rectract" }; //MSG_RECTRACT
-const char MSGEN131[] PROGMEM = { "ERROR:" }; //MSG_ERROR
-const char MSGCZ131[] PROGMEM = { "CHYBA:" }; //MSG_ERROR
-const char MSGIT131[] PROGMEM = { "ERROR:" }; //MSG_ERROR
-const char MSGES131[] PROGMEM = { "ERROR:" }; //MSG_ERROR
-const char MSGPL131[] PROGMEM = { "BLAD:" }; //MSG_ERROR
-const char MSGEN132[] PROGMEM = { "Preheat the nozzle!" }; //MSG_PREHEAT_NOZZLE
-const char MSGCZ132[] PROGMEM = { "Predehrejte trysku!" }; //MSG_PREHEAT_NOZZLE
-const char MSGIT132[] PROGMEM = { "Preris. ugello!" }; //MSG_PREHEAT_NOZZLE
-const char MSGES132[] PROGMEM = { "Precal. extrusor!" }; //MSG_PREHEAT_NOZZLE
-const char MSGPL132[] PROGMEM = { "Nagrzej dysze!" }; //MSG_PREHEAT_NOZZLE
-const char MSGEN133[] PROGMEM = { "Support" }; //MSG_SUPPORT
-const char MSGCZ133[] PROGMEM = { "Podpora" }; //MSG_SUPPORT
-const char MSGIT133[] PROGMEM = { "Support" }; //MSG_SUPPORT
-const char MSGES133[] PROGMEM = { "Support" }; //MSG_SUPPORT
-const char MSGPL133[] PROGMEM = { "Pomoc" }; //MSG_SUPPORT
-const char MSGEN134[] PROGMEM = { "Changed correctly?" }; //MSG_CORRECTLY
-const char MSGCZ134[] PROGMEM = { "Vymena ok?" }; //MSG_CORRECTLY
-const char MSGIT134[] PROGMEM = { "Cambiato corr.?" }; //MSG_CORRECTLY
-const char MSGES134[] PROGMEM = { "Cambiado correc.?" }; //MSG_CORRECTLY
-const char MSGPL134[] PROGMEM = { "Wymiana ok?" }; //MSG_CORRECTLY
-const char MSGEN135[] PROGMEM = { "Yes" }; //MSG_YES
-const char MSGCZ135[] PROGMEM = { "Ano" }; //MSG_YES
-const char MSGIT135[] PROGMEM = { "Si" }; //MSG_YES
-const char MSGES135[] PROGMEM = { "Si" }; //MSG_YES
-const char MSGPL135[] PROGMEM = { "Tak" }; //MSG_YES
-const char MSGEN136[] PROGMEM = { "No" }; //MSG_NO
-const char MSGCZ136[] PROGMEM = { "Ne" }; //MSG_NO
-const char MSGIT136[] PROGMEM = { "No" }; //MSG_NO
-const char MSGES136[] PROGMEM = { "No" }; //MSG_NO
-const char MSGPL136[] PROGMEM = { "Nie" }; //MSG_NO
-const char MSGEN137[] PROGMEM = { "Filament not loaded" }; //MSG_NOT_LOADED
-const char MSGCZ137[] PROGMEM = { "Filament nezaveden" }; //MSG_NOT_LOADED
-const char MSGIT137[] PROGMEM = { "Fil. no cargado" }; //MSG_NOT_LOADED
-const char MSGES137[] PROGMEM = { "Fil. no cargado" }; //MSG_NOT_LOADED
-const char MSGPL137[] PROGMEM = { "Brak filamentu" }; //MSG_NOT_LOADED
-const char MSGEN138[] PROGMEM = { "Color not clear" }; //MSG_NOT_COLOR
-const char MSGCZ138[] PROGMEM = { "Barva neni cista" }; //MSG_NOT_COLOR
-const char MSGIT138[] PROGMEM = { "Color no claro" }; //MSG_NOT_COLOR
-const char MSGES138[] PROGMEM = { "Color no claro" }; //MSG_NOT_COLOR
-const char MSGPL138[] PROGMEM = { "Kolor zanieczysz." }; //MSG_NOT_COLOR
-const char MSGEN139[] PROGMEM = { "Loading filament" }; //MSG_LOADING_FILAMENT
-const char MSGCZ139[] PROGMEM = { "Zavadeni filamentu" }; //MSG_LOADING_FILAMENT
-const char MSGIT139[] PROGMEM = { "Cargando fil." }; //MSG_LOADING_FILAMENT
-const char MSGES139[] PROGMEM = { "Cargando fil." }; //MSG_LOADING_FILAMENT
-const char MSGPL139[] PROGMEM = { "Wprow. filamentu" }; //MSG_LOADING_FILAMENT
-const char MSGEN140[] PROGMEM = { "Please wait" }; //MSG_PLEASE_WAIT
-const char MSGCZ140[] PROGMEM = { "Prosim cekejte" }; //MSG_PLEASE_WAIT
-const char MSGIT140[] PROGMEM = { "Aspetta" }; //MSG_PLEASE_WAIT
-const char MSGES140[] PROGMEM = { "Espera" }; //MSG_PLEASE_WAIT
-const char MSGPL140[] PROGMEM = { "Prosze czekac" }; //MSG_PLEASE_WAIT
-const char MSGEN141[] PROGMEM = { "Loading color" }; //MSG_LOADING_COLOR
-const char MSGCZ141[] PROGMEM = { "Cisteni barvy" }; //MSG_LOADING_COLOR
-const char MSGIT141[] PROGMEM = { "Cargando color" }; //MSG_LOADING_COLOR
-const char MSGES141[] PROGMEM = { "Cargando color" }; //MSG_LOADING_COLOR
-const char MSGPL141[] PROGMEM = { "Czyszcz. koloru" }; //MSG_LOADING_COLOR
-const char MSGEN142[] PROGMEM = { "Change success!" }; //MSG_CHANGE_SUCCESS
-const char MSGCZ142[] PROGMEM = { "Zmena uspesna!" }; //MSG_CHANGE_SUCCESS
-const char MSGIT142[] PROGMEM = { "Cambia. riuscito!" }; //MSG_CHANGE_SUCCESS
-const char MSGES142[] PROGMEM = { "Cambiar bien!" }; //MSG_CHANGE_SUCCESS
-const char MSGPL142[] PROGMEM = { "Wymiana ok!" }; //MSG_CHANGE_SUCCESS
-const char MSGEN143[] PROGMEM = { "And press the knob" }; //MSG_PRESS
-const char MSGCZ143[] PROGMEM = { "A stisknete tlacitko" }; //MSG_PRESS
-const char MSGIT143[] PROGMEM = { "Y pulse el mando" }; //MSG_PRESS
-const char MSGES143[] PROGMEM = { "Y pulse el mando" }; //MSG_PRESS
-const char MSGPL143[] PROGMEM = { "Nacisnij przycisk" }; //MSG_PRESS
-const char MSGEN144[] PROGMEM = { "Insert filament" }; //MSG_INSERT_FILAMENT
-const char MSGCZ144[] PROGMEM = { "Vlozte filament" }; //MSG_INSERT_FILAMENT
-const char MSGIT144[] PROGMEM = { "Inserire filamento" }; //MSG_INSERT_FILAMENT
-const char MSGES144[] PROGMEM = { "Inserta filamento" }; //MSG_INSERT_FILAMENT
-const char MSGPL144[] PROGMEM = { "Wprowadz filament" }; //MSG_INSERT_FILAMENT
-const char MSGEN145[] PROGMEM = { "Changing filament!" }; //MSG_CHANGING_FILAMENT
-const char MSGCZ145[] PROGMEM = { "Vymena filamentu!" }; //MSG_CHANGING_FILAMENT
-const char MSGIT145[] PROGMEM = { "Mutevole fil.!" }; //MSG_CHANGING_FILAMENT
-const char MSGES145[] PROGMEM = { "Cambiando fil.!" }; //MSG_CHANGING_FILAMENT
-const char MSGPL145[] PROGMEM = { "Wymiana filamentu" }; //MSG_CHANGING_FILAMENT
-const char MSGEN146[] PROGMEM = { "Mode     [silent]" }; //MSG_SILENT_MODE_ON
-const char MSGCZ146[] PROGMEM = { "Mod       [tichy]" }; //MSG_SILENT_MODE_ON
-const char MSGIT146[] PROGMEM = { "Modo     [silenzioso]" }; //MSG_SILENT_MODE_ON
-const char MSGES146[] PROGMEM = { "Modo     [silencio]" }; //MSG_SILENT_MODE_ON
-const char MSGPL146[] PROGMEM = { "Mod       [cichy]" }; //MSG_SILENT_MODE_ON
-const char MSGEN147[] PROGMEM = { "Mode [high power]" }; //MSG_SILENT_MODE_OFF
-const char MSGCZ147[] PROGMEM = { "Mod  [vys. vykon]" }; //MSG_SILENT_MODE_OFF
-const char MSGIT147[] PROGMEM = { "Modo [piu forza]" }; //MSG_SILENT_MODE_OFF
-const char MSGES147[] PROGMEM = { "Modo [mas fuerza]" }; //MSG_SILENT_MODE_OFF
-const char MSGPL147[] PROGMEM = { "Mod [w wydajnosc]" }; //MSG_SILENT_MODE_OFF
-const char MSGEN148[] PROGMEM = { "Reboot the printer" }; //MSG_REBOOT
-const char MSGCZ148[] PROGMEM = { "Restartujte tiskarnu" }; //MSG_REBOOT
-const char MSGIT148[] PROGMEM = { "Riavvio la stamp." }; //MSG_REBOOT
-const char MSGES148[] PROGMEM = { "Reiniciar la imp." }; //MSG_REBOOT
-const char MSGPL148[] PROGMEM = { "Restart drukarki" }; //MSG_REBOOT
-const char MSGEN149[] PROGMEM = { " for take effect" }; //MSG_TAKE_EFFECT
-const char MSGCZ149[] PROGMEM = { " pro projeveni zmen" }; //MSG_TAKE_EFFECT
-const char MSGIT149[] PROGMEM = { " per mostrare i camb." }; //MSG_TAKE_EFFECT
-const char MSGES149[] PROGMEM = { "para tomar efecto" }; //MSG_TAKE_EFFECT
-const char MSGPL149[] PROGMEM = { "wprow. zmian" }; //MSG_TAKE_EFFECT
-const char MSGEN150[] PROGMEM = { "enqueing \"" }; //MSG_Enqueing
-const char MSGCZ150[] PROGMEM = { "enqueing \"" }; //MSG_Enqueing
-const char MSGIT150[] PROGMEM = { "enqueing \"" }; //MSG_Enqueing
-const char MSGES150[] PROGMEM = { "enqueing \"" }; //MSG_Enqueing
-const char MSGPL150[] PROGMEM = { "enqueing \"" }; //MSG_Enqueing
-const char MSGEN151[] PROGMEM = { "PowerUp" }; //MSG_POWERUP
-const char MSGCZ151[] PROGMEM = { "PowerUp" }; //MSG_POWERUP
-const char MSGIT151[] PROGMEM = { "PowerUp" }; //MSG_POWERUP
-const char MSGES151[] PROGMEM = { "PowerUp" }; //MSG_POWERUP
-const char MSGPL151[] PROGMEM = { "PowerUp" }; //MSG_POWERUP
-const char MSGEN152[] PROGMEM = { " External Reset" }; //MSG_EXTERNAL_RESET
-const char MSGCZ152[] PROGMEM = { " External Reset" }; //MSG_EXTERNAL_RESET
-const char MSGIT152[] PROGMEM = { " External Reset" }; //MSG_EXTERNAL_RESET
-const char MSGES152[] PROGMEM = { " External Reset" }; //MSG_EXTERNAL_RESET
-const char MSGPL152[] PROGMEM = { " External Reset" }; //MSG_EXTERNAL_RESET
-const char MSGEN153[] PROGMEM = { " Brown out Reset" }; //MSG_BROWNOUT_RESET
-const char MSGCZ153[] PROGMEM = { " Brown out Reset" }; //MSG_BROWNOUT_RESET
-const char MSGIT153[] PROGMEM = { " Brown out Reset" }; //MSG_BROWNOUT_RESET
-const char MSGES153[] PROGMEM = { " Brown out Reset" }; //MSG_BROWNOUT_RESET
-const char MSGPL153[] PROGMEM = { " Brown out Reset" }; //MSG_BROWNOUT_RESET
-const char MSGEN154[] PROGMEM = { " Watchdog Reset" }; //MSG_WATCHDOG_RESET
-const char MSGCZ154[] PROGMEM = { " Watchdog Reset" }; //MSG_WATCHDOG_RESET
-const char MSGIT154[] PROGMEM = { " Watchdog Reset" }; //MSG_WATCHDOG_RESET
-const char MSGES154[] PROGMEM = { " Watchdog Reset" }; //MSG_WATCHDOG_RESET
-const char MSGPL154[] PROGMEM = { " Watchdog Reset" }; //MSG_WATCHDOG_RESET
-const char MSGEN155[] PROGMEM = { " Software Reset" }; //MSG_SOFTWARE_RESET
-const char MSGCZ155[] PROGMEM = { " Software Reset" }; //MSG_SOFTWARE_RESET
-const char MSGIT155[] PROGMEM = { " Software Reset" }; //MSG_SOFTWARE_RESET
-const char MSGES155[] PROGMEM = { " Software Reset" }; //MSG_SOFTWARE_RESET
-const char MSGPL155[] PROGMEM = { " Software Reset" }; //MSG_SOFTWARE_RESET
-const char MSGEN156[] PROGMEM = { " | Author: " }; //MSG_AUTHOR
-const char MSGCZ156[] PROGMEM = { " | Author: " }; //MSG_AUTHOR
-const char MSGIT156[] PROGMEM = { " | Author: " }; //MSG_AUTHOR
-const char MSGES156[] PROGMEM = { " | Author: " }; //MSG_AUTHOR
-const char MSGPL156[] PROGMEM = { " | Author: " }; //MSG_AUTHOR
-const char MSGEN157[] PROGMEM = { " Last Updated: " }; //MSG_CONFIGURATION_VER
-const char MSGCZ157[] PROGMEM = { " Last Updated: " }; //MSG_CONFIGURATION_VER
-const char MSGIT157[] PROGMEM = { " Last Updated: " }; //MSG_CONFIGURATION_VER
-const char MSGES157[] PROGMEM = { " Last Updated: " }; //MSG_CONFIGURATION_VER
-const char MSGPL157[] PROGMEM = { " Last Updated: " }; //MSG_CONFIGURATION_VER
-const char MSGEN158[] PROGMEM = { " Free Memory: " }; //MSG_FREE_MEMORY
-const char MSGCZ158[] PROGMEM = { " Free Memory: " }; //MSG_FREE_MEMORY
-const char MSGIT158[] PROGMEM = { " Free Memory: " }; //MSG_FREE_MEMORY
-const char MSGES158[] PROGMEM = { " Free Memory: " }; //MSG_FREE_MEMORY
-const char MSGPL158[] PROGMEM = { " Free Memory: " }; //MSG_FREE_MEMORY
-const char MSGEN159[] PROGMEM = { "  PlannerBufferBytes: " }; //MSG_PLANNER_BUFFER_BYTES
-const char MSGCZ159[] PROGMEM = { "  PlannerBufferBytes: " }; //MSG_PLANNER_BUFFER_BYTES
-const char MSGIT159[] PROGMEM = { "  PlannerBufferBytes: " }; //MSG_PLANNER_BUFFER_BYTES
-const char MSGES159[] PROGMEM = { "  PlannerBufferBytes: " }; //MSG_PLANNER_BUFFER_BYTES
-const char MSGPL159[] PROGMEM = { "  PlannerBufferBytes: " }; //MSG_PLANNER_BUFFER_BYTES
-const char MSGEN160[] PROGMEM = { "ok" }; //MSG_OK
-const char MSGCZ160[] PROGMEM = { "ok" }; //MSG_OK
-const char MSGIT160[] PROGMEM = { "ok" }; //MSG_OK
-const char MSGES160[] PROGMEM = { "ok" }; //MSG_OK
-const char MSGPL160[] PROGMEM = { "ok" }; //MSG_OK
-const char MSGEN161[] PROGMEM = { "Done saving file." }; //MSG_FILE_SAVED
-const char MSGCZ161[] PROGMEM = { "Done saving file." }; //MSG_FILE_SAVED
-const char MSGIT161[] PROGMEM = { "Done saving file." }; //MSG_FILE_SAVED
-const char MSGES161[] PROGMEM = { "Done saving file." }; //MSG_FILE_SAVED
-const char MSGPL161[] PROGMEM = { "Done saving file." }; //MSG_FILE_SAVED
-const char MSGEN162[] PROGMEM = { "Line Number is not Last Line Number+1, Last Line: " }; //MSG_ERR_LINE_NO
-const char MSGCZ162[] PROGMEM = { "Line Number is not Last Line Number+1, Last Line: " }; //MSG_ERR_LINE_NO
-const char MSGIT162[] PROGMEM = { "Line Number is not Last Line Number+1, Last Line: " }; //MSG_ERR_LINE_NO
-const char MSGES162[] PROGMEM = { "Line Number is not Last Line Number+1, Last Line: " }; //MSG_ERR_LINE_NO
-const char MSGPL162[] PROGMEM = { "Line Number is not Last Line Number+1, Last Line: " }; //MSG_ERR_LINE_NO
-const char MSGEN163[] PROGMEM = { "checksum mismatch, Last Line: " }; //MSG_ERR_CHECKSUM_MISMATCH
-const char MSGCZ163[] PROGMEM = { "checksum mismatch, Last Line: " }; //MSG_ERR_CHECKSUM_MISMATCH
-const char MSGIT163[] PROGMEM = { "checksum mismatch, Last Line: " }; //MSG_ERR_CHECKSUM_MISMATCH
-const char MSGES163[] PROGMEM = { "checksum mismatch, Last Line: " }; //MSG_ERR_CHECKSUM_MISMATCH
-const char MSGPL163[] PROGMEM = { "checksum mismatch, Last Line: " }; //MSG_ERR_CHECKSUM_MISMATCH
-const char MSGEN164[] PROGMEM = { "No Checksum with line number, Last Line: " }; //MSG_ERR_NO_CHECKSUM
-const char MSGCZ164[] PROGMEM = { "No Checksum with line number, Last Line: " }; //MSG_ERR_NO_CHECKSUM
-const char MSGIT164[] PROGMEM = { "No Checksum with line number, Last Line: " }; //MSG_ERR_NO_CHECKSUM
-const char MSGES164[] PROGMEM = { "No Checksum with line number, Last Line: " }; //MSG_ERR_NO_CHECKSUM
-const char MSGPL164[] PROGMEM = { "No Checksum with line number, Last Line: " }; //MSG_ERR_NO_CHECKSUM
-const char MSGEN165[] PROGMEM = { "No Line Number with checksum, Last Line: " }; //MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM
-const char MSGCZ165[] PROGMEM = { "No Line Number with checksum, Last Line: " }; //MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM
-const char MSGIT165[] PROGMEM = { "No Line Number with checksum, Last Line: " }; //MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM
-const char MSGES165[] PROGMEM = { "No Line Number with checksum, Last Line: " }; //MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM
-const char MSGPL165[] PROGMEM = { "No Line Number with checksum, Last Line: " }; //MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM
-const char MSGEN166[] PROGMEM = { "Done printing file" }; //MSG_FILE_PRINTED
-const char MSGCZ166[] PROGMEM = { "Done printing file" }; //MSG_FILE_PRINTED
-const char MSGIT166[] PROGMEM = { "Done printing file" }; //MSG_FILE_PRINTED
-const char MSGES166[] PROGMEM = { "Done printing file" }; //MSG_FILE_PRINTED
-const char MSGPL166[] PROGMEM = { "Done printing file" }; //MSG_FILE_PRINTED
-const char MSGEN167[] PROGMEM = { "Begin file list" }; //MSG_BEGIN_FILE_LIST
-const char MSGCZ167[] PROGMEM = { "Begin file list" }; //MSG_BEGIN_FILE_LIST
-const char MSGIT167[] PROGMEM = { "Begin file list" }; //MSG_BEGIN_FILE_LIST
-const char MSGES167[] PROGMEM = { "Begin file list" }; //MSG_BEGIN_FILE_LIST
-const char MSGPL167[] PROGMEM = { "Begin file list" }; //MSG_BEGIN_FILE_LIST
-const char MSGEN168[] PROGMEM = { "End file list" }; //MSG_END_FILE_LIST
-const char MSGCZ168[] PROGMEM = { "End file list" }; //MSG_END_FILE_LIST
-const char MSGIT168[] PROGMEM = { "End file list" }; //MSG_END_FILE_LIST
-const char MSGES168[] PROGMEM = { "End file list" }; //MSG_END_FILE_LIST
-const char MSGPL168[] PROGMEM = { "End file list" }; //MSG_END_FILE_LIST
-const char MSGEN169[] PROGMEM = { "M104 Invalid extruder " }; //MSG_M104_INVALID_EXTRUDER
-const char MSGCZ169[] PROGMEM = { "M104 Invalid extruder " }; //MSG_M104_INVALID_EXTRUDER
-const char MSGIT169[] PROGMEM = { "M104 Invalid extruder " }; //MSG_M104_INVALID_EXTRUDER
-const char MSGES169[] PROGMEM = { "M104 Invalid extruder " }; //MSG_M104_INVALID_EXTRUDER
-const char MSGPL169[] PROGMEM = { "M104 Invalid extruder " }; //MSG_M104_INVALID_EXTRUDER
-const char MSGEN170[] PROGMEM = { "M105 Invalid extruder " }; //MSG_M105_INVALID_EXTRUDER
-const char MSGCZ170[] PROGMEM = { "M105 Invalid extruder " }; //MSG_M105_INVALID_EXTRUDER
-const char MSGIT170[] PROGMEM = { "M105 Invalid extruder " }; //MSG_M105_INVALID_EXTRUDER
-const char MSGES170[] PROGMEM = { "M105 Invalid extruder " }; //MSG_M105_INVALID_EXTRUDER
-const char MSGPL170[] PROGMEM = { "M105 Invalid extruder " }; //MSG_M105_INVALID_EXTRUDER
-const char MSGEN171[] PROGMEM = { "M200 Invalid extruder " }; //MSG_M200_INVALID_EXTRUDER
-const char MSGCZ171[] PROGMEM = { "M200 Invalid extruder " }; //MSG_M200_INVALID_EXTRUDER
-const char MSGIT171[] PROGMEM = { "M200 Invalid extruder " }; //MSG_M200_INVALID_EXTRUDER
-const char MSGES171[] PROGMEM = { "M200 Invalid extruder " }; //MSG_M200_INVALID_EXTRUDER
-const char MSGPL171[] PROGMEM = { "M200 Invalid extruder " }; //MSG_M200_INVALID_EXTRUDER
-const char MSGEN172[] PROGMEM = { "M218 Invalid extruder " }; //MSG_M218_INVALID_EXTRUDER
-const char MSGCZ172[] PROGMEM = { "M218 Invalid extruder " }; //MSG_M218_INVALID_EXTRUDER
-const char MSGIT172[] PROGMEM = { "M218 Invalid extruder " }; //MSG_M218_INVALID_EXTRUDER
-const char MSGES172[] PROGMEM = { "M218 Invalid extruder " }; //MSG_M218_INVALID_EXTRUDER
-const char MSGPL172[] PROGMEM = { "M218 Invalid extruder " }; //MSG_M218_INVALID_EXTRUDER
-const char MSGEN173[] PROGMEM = { "M221 Invalid extruder " }; //MSG_M221_INVALID_EXTRUDER
-const char MSGCZ173[] PROGMEM = { "M221 Invalid extruder " }; //MSG_M221_INVALID_EXTRUDER
-const char MSGIT173[] PROGMEM = { "M221 Invalid extruder " }; //MSG_M221_INVALID_EXTRUDER
-const char MSGES173[] PROGMEM = { "M221 Invalid extruder " }; //MSG_M221_INVALID_EXTRUDER
-const char MSGPL173[] PROGMEM = { "M221 Invalid extruder " }; //MSG_M221_INVALID_EXTRUDER
-const char MSGEN174[] PROGMEM = { "No thermistors - no temperature" }; //MSG_ERR_NO_THERMISTORS
-const char MSGCZ174[] PROGMEM = { "No thermistors - no temperature" }; //MSG_ERR_NO_THERMISTORS
-const char MSGIT174[] PROGMEM = { "No thermistors - no temperature" }; //MSG_ERR_NO_THERMISTORS
-const char MSGES174[] PROGMEM = { "No thermistors - no temperature" }; //MSG_ERR_NO_THERMISTORS
-const char MSGPL174[] PROGMEM = { "No thermistors - no temperature" }; //MSG_ERR_NO_THERMISTORS
-const char MSGEN175[] PROGMEM = { "M109 Invalid extruder " }; //MSG_M109_INVALID_EXTRUDER
-const char MSGCZ175[] PROGMEM = { "M109 Invalid extruder " }; //MSG_M109_INVALID_EXTRUDER
-const char MSGIT175[] PROGMEM = { "M109 Invalid extruder " }; //MSG_M109_INVALID_EXTRUDER
-const char MSGES175[] PROGMEM = { "M109 Invalid extruder " }; //MSG_M109_INVALID_EXTRUDER
-const char MSGPL175[] PROGMEM = { "M109 Invalid extruder " }; //MSG_M109_INVALID_EXTRUDER
-const char MSGEN176[] PROGMEM = { "Heating" }; //MSG_HEATING
-const char MSGCZ176[] PROGMEM = { "Zahrivani" }; //MSG_HEATING
-const char MSGIT176[] PROGMEM = { "Riscaldamento..." }; //MSG_HEATING
-const char MSGES176[] PROGMEM = { "Calentando..." }; //MSG_HEATING
-const char MSGPL176[] PROGMEM = { "Grzanie..." }; //MSG_HEATING
-const char MSGEN177[] PROGMEM = { "Heating done." }; //MSG_HEATING_COMPLETE
-const char MSGCZ177[] PROGMEM = { "Zahrivani OK." }; //MSG_HEATING_COMPLETE
-const char MSGIT177[] PROGMEM = { "Riscaldamento fatto." }; //MSG_HEATING_COMPLETE
-const char MSGES177[] PROGMEM = { "Calentando listo." }; //MSG_HEATING_COMPLETE
-const char MSGPL177[] PROGMEM = { "Grzanie OK." }; //MSG_HEATING_COMPLETE
-const char MSGEN178[] PROGMEM = { "Bed Heating" }; //MSG_BED_HEATING
-const char MSGCZ178[] PROGMEM = { "Zahrivani bed" }; //MSG_BED_HEATING
-const char MSGIT178[] PROGMEM = { "Piatto riscaldam." }; //MSG_BED_HEATING
-const char MSGES178[] PROGMEM = { "Base Calentando" }; //MSG_BED_HEATING
-const char MSGPL178[] PROGMEM = { "Grzanie stolika.." }; //MSG_BED_HEATING
-const char MSGEN179[] PROGMEM = { "Bed done" }; //MSG_BED_DONE
-const char MSGCZ179[] PROGMEM = { "Bed OK." }; //MSG_BED_DONE
-const char MSGIT179[] PROGMEM = { "Piatto fatto." }; //MSG_BED_DONE
-const char MSGES179[] PROGMEM = { "Base listo." }; //MSG_BED_DONE
-const char MSGPL179[] PROGMEM = { "Stolik OK." }; //MSG_BED_DONE
-const char MSGEN180[] PROGMEM = { "FIRMWARE_NAME:Marlin V1.0.2; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/prusa3d/Prusa-i3-Plus/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:" CUSTOM_MENDEL_NAME " EXTRUDER_COUNT:1 UUID:00000000-0000-0000-0000-000000000000\n" }; //MSG_M115_REPORT
-const char MSGCZ180[] PROGMEM = { "FIRMWARE_NAME:Marlin V1.0.2; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/prusa3d/Prusa-i3-Plus/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:" CUSTOM_MENDEL_NAME " EXTRUDER_COUNT:1 UUID:00000000-0000-0000-0000-000000000000\n" }; //MSG_M115_REPORT
-const char MSGIT180[] PROGMEM = { "FIRMWARE_NAME:Marlin V1.0.2; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/prusa3d/Prusa-i3-Plus/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:" CUSTOM_MENDEL_NAME " EXTRUDER_COUNT:1 UUID:00000000-0000-0000-0000-000000000000\n" }; //MSG_M115_REPORT
-const char MSGES180[] PROGMEM = { "FIRMWARE_NAME:Marlin V1.0.2; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/prusa3d/Prusa-i3-Plus/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:" CUSTOM_MENDEL_NAME " EXTRUDER_COUNT:1 UUID:00000000-0000-0000-0000-000000000000\n" }; //MSG_M115_REPORT
-const char MSGPL180[] PROGMEM = { "FIRMWARE_NAME:Marlin V1.0.2; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/prusa3d/Prusa-i3-Plus/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:" CUSTOM_MENDEL_NAME " EXTRUDER_COUNT:1 UUID:00000000-0000-0000-0000-000000000000\n" }; //MSG_M115_REPORT
-const char MSGEN181[] PROGMEM = { " Count X: " }; //MSG_COUNT_X
-const char MSGCZ181[] PROGMEM = { " Count X: " }; //MSG_COUNT_X
-const char MSGIT181[] PROGMEM = { " Count X: " }; //MSG_COUNT_X
-const char MSGES181[] PROGMEM = { " Count X: " }; //MSG_COUNT_X
-const char MSGPL181[] PROGMEM = { " Count X: " }; //MSG_COUNT_X
-const char MSGEN182[] PROGMEM = { "Printer halted. kill() called!" }; //MSG_ERR_KILLED
-const char MSGCZ182[] PROGMEM = { "Printer halted. kill() called!" }; //MSG_ERR_KILLED
-const char MSGIT182[] PROGMEM = { "Printer halted. kill() called!" }; //MSG_ERR_KILLED
-const char MSGES182[] PROGMEM = { "Printer halted. kill() called!" }; //MSG_ERR_KILLED
-const char MSGPL182[] PROGMEM = { "Printer halted. kill() called!" }; //MSG_ERR_KILLED
-const char MSGEN183[] PROGMEM = { "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)" }; //MSG_ERR_STOPPED
-const char MSGCZ183[] PROGMEM = { "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)" }; //MSG_ERR_STOPPED
-const char MSGIT183[] PROGMEM = { "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)" }; //MSG_ERR_STOPPED
-const char MSGES183[] PROGMEM = { "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)" }; //MSG_ERR_STOPPED
-const char MSGPL183[] PROGMEM = { "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)" }; //MSG_ERR_STOPPED
-const char MSGEN184[] PROGMEM = { "Resend: " }; //MSG_RESEND
-const char MSGCZ184[] PROGMEM = { "Resend: " }; //MSG_RESEND
-const char MSGIT184[] PROGMEM = { "Resend: " }; //MSG_RESEND
-const char MSGES184[] PROGMEM = { "Resend: " }; //MSG_RESEND
-const char MSGPL184[] PROGMEM = { "Resend: " }; //MSG_RESEND
-const char MSGEN185[] PROGMEM = { "Unknown command: \"" }; //MSG_UNKNOWN_COMMAND
-const char MSGCZ185[] PROGMEM = { "Unknown command: \"" }; //MSG_UNKNOWN_COMMAND
-const char MSGIT185[] PROGMEM = { "Unknown command: \"" }; //MSG_UNKNOWN_COMMAND
-const char MSGES185[] PROGMEM = { "Unknown command: \"" }; //MSG_UNKNOWN_COMMAND
-const char MSGPL185[] PROGMEM = { "Unknown command: \"" }; //MSG_UNKNOWN_COMMAND
-const char MSGEN186[] PROGMEM = { "Active Extruder: " }; //MSG_ACTIVE_EXTRUDER
-const char MSGCZ186[] PROGMEM = { "Active Extruder: " }; //MSG_ACTIVE_EXTRUDER
-const char MSGIT186[] PROGMEM = { "Active Extruder: " }; //MSG_ACTIVE_EXTRUDER
-const char MSGES186[] PROGMEM = { "Active Extruder: " }; //MSG_ACTIVE_EXTRUDER
-const char MSGPL186[] PROGMEM = { "Active Extruder: " }; //MSG_ACTIVE_EXTRUDER
-const char MSGEN187[] PROGMEM = { "Invalid extruder" }; //MSG_INVALID_EXTRUDER
-const char MSGCZ187[] PROGMEM = { "Invalid extruder" }; //MSG_INVALID_EXTRUDER
-const char MSGIT187[] PROGMEM = { "Invalid extruder" }; //MSG_INVALID_EXTRUDER
-const char MSGES187[] PROGMEM = { "Invalid extruder" }; //MSG_INVALID_EXTRUDER
-const char MSGPL187[] PROGMEM = { "Invalid extruder" }; //MSG_INVALID_EXTRUDER
-const char MSGEN188[] PROGMEM = { "x_min: " }; //MSG_X_MIN
-const char MSGCZ188[] PROGMEM = { "x_min: " }; //MSG_X_MIN
-const char MSGIT188[] PROGMEM = { "x_min: " }; //MSG_X_MIN
-const char MSGES188[] PROGMEM = { "x_min: " }; //MSG_X_MIN
-const char MSGPL188[] PROGMEM = { "x_min: " }; //MSG_X_MIN
-const char MSGEN189[] PROGMEM = { "x_max: " }; //MSG_X_MAX
-const char MSGCZ189[] PROGMEM = { "x_max: " }; //MSG_X_MAX
-const char MSGIT189[] PROGMEM = { "x_max: " }; //MSG_X_MAX
-const char MSGES189[] PROGMEM = { "x_max: " }; //MSG_X_MAX
-const char MSGPL189[] PROGMEM = { "x_max: " }; //MSG_X_MAX
-const char MSGEN190[] PROGMEM = { "y_min: " }; //MSG_Y_MIN
-const char MSGCZ190[] PROGMEM = { "y_min: " }; //MSG_Y_MIN
-const char MSGIT190[] PROGMEM = { "y_min: " }; //MSG_Y_MIN
-const char MSGES190[] PROGMEM = { "y_min: " }; //MSG_Y_MIN
-const char MSGPL190[] PROGMEM = { "y_min: " }; //MSG_Y_MIN
-const char MSGEN191[] PROGMEM = { "y_max: " }; //MSG_Y_MAX
-const char MSGCZ191[] PROGMEM = { "y_max: " }; //MSG_Y_MAX
-const char MSGIT191[] PROGMEM = { "y_max: " }; //MSG_Y_MAX
-const char MSGES191[] PROGMEM = { "y_max: " }; //MSG_Y_MAX
-const char MSGPL191[] PROGMEM = { "y_max: " }; //MSG_Y_MAX
-const char MSGEN192[] PROGMEM = { "z_min: " }; //MSG_Z_MIN
-const char MSGCZ192[] PROGMEM = { "z_min: " }; //MSG_Z_MIN
-const char MSGIT192[] PROGMEM = { "z_min: " }; //MSG_Z_MIN
-const char MSGES192[] PROGMEM = { "z_min: " }; //MSG_Z_MIN
-const char MSGPL192[] PROGMEM = { "z_min: " }; //MSG_Z_MIN
-const char MSGEN193[] PROGMEM = { "z_max: " }; //MSG_Z_MAX
-const char MSGCZ193[] PROGMEM = { "z_max: " }; //MSG_Z_MAX
-const char MSGIT193[] PROGMEM = { "z_max: " }; //MSG_Z_MAX
-const char MSGES193[] PROGMEM = { "z_max: " }; //MSG_Z_MAX
-const char MSGPL193[] PROGMEM = { "z_max: " }; //MSG_Z_MAX
-const char MSGEN194[] PROGMEM = { "Reporting endstop status" }; //MSG_M119_REPORT
-const char MSGCZ194[] PROGMEM = { "Reporting endstop status" }; //MSG_M119_REPORT
-const char MSGIT194[] PROGMEM = { "Reporting endstop status" }; //MSG_M119_REPORT
-const char MSGES194[] PROGMEM = { "Reporting endstop status" }; //MSG_M119_REPORT
-const char MSGPL194[] PROGMEM = { "Reporting endstop status" }; //MSG_M119_REPORT
-const char MSGEN195[] PROGMEM = { "TRIGGERED" }; //MSG_ENDSTOP_HIT
-const char MSGCZ195[] PROGMEM = { "TRIGGERED" }; //MSG_ENDSTOP_HIT
-const char MSGIT195[] PROGMEM = { "TRIGGERED" }; //MSG_ENDSTOP_HIT
-const char MSGES195[] PROGMEM = { "TRIGGERED" }; //MSG_ENDSTOP_HIT
-const char MSGPL195[] PROGMEM = { "TRIGGERED" }; //MSG_ENDSTOP_HIT
-const char MSGEN196[] PROGMEM = { "open" }; //MSG_ENDSTOP_OPEN
-const char MSGCZ196[] PROGMEM = { "open" }; //MSG_ENDSTOP_OPEN
-const char MSGIT196[] PROGMEM = { "open" }; //MSG_ENDSTOP_OPEN
-const char MSGES196[] PROGMEM = { "open" }; //MSG_ENDSTOP_OPEN
-const char MSGPL196[] PROGMEM = { "open" }; //MSG_ENDSTOP_OPEN
-const char MSGEN197[] PROGMEM = { "Hotend offsets:" }; //MSG_HOTEND_OFFSET
-const char MSGCZ197[] PROGMEM = { "Hotend offsets:" }; //MSG_HOTEND_OFFSET
-const char MSGIT197[] PROGMEM = { "Hotend offsets:" }; //MSG_HOTEND_OFFSET
-const char MSGES197[] PROGMEM = { "Hotend offsets:" }; //MSG_HOTEND_OFFSET
-const char MSGPL197[] PROGMEM = { "Hotend offsets:" }; //MSG_HOTEND_OFFSET
-const char MSGEN198[] PROGMEM = { "Cannot open subdir" }; //MSG_SD_CANT_OPEN_SUBDIR
-const char MSGCZ198[] PROGMEM = { "Cannot open subdir" }; //MSG_SD_CANT_OPEN_SUBDIR
-const char MSGIT198[] PROGMEM = { "Cannot open subdir" }; //MSG_SD_CANT_OPEN_SUBDIR
-const char MSGES198[] PROGMEM = { "Cannot open subdir" }; //MSG_SD_CANT_OPEN_SUBDIR
-const char MSGPL198[] PROGMEM = { "Cannot open subdir" }; //MSG_SD_CANT_OPEN_SUBDIR
-const char MSGEN199[] PROGMEM = { "SD init fail" }; //MSG_SD_INIT_FAIL
-const char MSGCZ199[] PROGMEM = { "SD init fail" }; //MSG_SD_INIT_FAIL
-const char MSGIT199[] PROGMEM = { "SD init fail" }; //MSG_SD_INIT_FAIL
-const char MSGES199[] PROGMEM = { "SD init fail" }; //MSG_SD_INIT_FAIL
-const char MSGPL199[] PROGMEM = { "SD init fail" }; //MSG_SD_INIT_FAIL
-const char MSGEN200[] PROGMEM = { "volume.init failed" }; //MSG_SD_VOL_INIT_FAIL
-const char MSGCZ200[] PROGMEM = { "volume.init failed" }; //MSG_SD_VOL_INIT_FAIL
-const char MSGIT200[] PROGMEM = { "volume.init failed" }; //MSG_SD_VOL_INIT_FAIL
-const char MSGES200[] PROGMEM = { "volume.init failed" }; //MSG_SD_VOL_INIT_FAIL
-const char MSGPL200[] PROGMEM = { "volume.init failed" }; //MSG_SD_VOL_INIT_FAIL
-const char MSGEN201[] PROGMEM = { "openRoot failed" }; //MSG_SD_OPENROOT_FAIL
-const char MSGCZ201[] PROGMEM = { "openRoot failed" }; //MSG_SD_OPENROOT_FAIL
-const char MSGIT201[] PROGMEM = { "openRoot failed" }; //MSG_SD_OPENROOT_FAIL
-const char MSGES201[] PROGMEM = { "openRoot failed" }; //MSG_SD_OPENROOT_FAIL
-const char MSGPL201[] PROGMEM = { "openRoot failed" }; //MSG_SD_OPENROOT_FAIL
-const char MSGEN202[] PROGMEM = { "SD card ok" }; //MSG_SD_CARD_OK
-const char MSGCZ202[] PROGMEM = { "SD card ok" }; //MSG_SD_CARD_OK
-const char MSGIT202[] PROGMEM = { "SD card ok" }; //MSG_SD_CARD_OK
-const char MSGES202[] PROGMEM = { "SD card ok" }; //MSG_SD_CARD_OK
-const char MSGPL202[] PROGMEM = { "SD card ok" }; //MSG_SD_CARD_OK
-const char MSGEN203[] PROGMEM = { "workDir open failed" }; //MSG_SD_WORKDIR_FAIL
-const char MSGCZ203[] PROGMEM = { "workDir open failed" }; //MSG_SD_WORKDIR_FAIL
-const char MSGIT203[] PROGMEM = { "workDir open failed" }; //MSG_SD_WORKDIR_FAIL
-const char MSGES203[] PROGMEM = { "workDir open failed" }; //MSG_SD_WORKDIR_FAIL
-const char MSGPL203[] PROGMEM = { "workDir open failed" }; //MSG_SD_WORKDIR_FAIL
-const char MSGEN204[] PROGMEM = { "open failed, File: " }; //MSG_SD_OPEN_FILE_FAIL
-const char MSGCZ204[] PROGMEM = { "open failed, File: " }; //MSG_SD_OPEN_FILE_FAIL
-const char MSGIT204[] PROGMEM = { "open failed, File: " }; //MSG_SD_OPEN_FILE_FAIL
-const char MSGES204[] PROGMEM = { "open failed, File: " }; //MSG_SD_OPEN_FILE_FAIL
-const char MSGPL204[] PROGMEM = { "open failed, File: " }; //MSG_SD_OPEN_FILE_FAIL
-const char MSGEN205[] PROGMEM = { "File opened: " }; //MSG_SD_FILE_OPENED
-const char MSGCZ205[] PROGMEM = { "File opened: " }; //MSG_SD_FILE_OPENED
-const char MSGIT205[] PROGMEM = { "File opened: " }; //MSG_SD_FILE_OPENED
-const char MSGES205[] PROGMEM = { "File opened: " }; //MSG_SD_FILE_OPENED
-const char MSGPL205[] PROGMEM = { "File opened: " }; //MSG_SD_FILE_OPENED
-const char MSGEN206[] PROGMEM = { " Size: " }; //MSG_SD_SIZE
-const char MSGCZ206[] PROGMEM = { " Size: " }; //MSG_SD_SIZE
-const char MSGIT206[] PROGMEM = { " Size: " }; //MSG_SD_SIZE
-const char MSGES206[] PROGMEM = { " Size: " }; //MSG_SD_SIZE
-const char MSGPL206[] PROGMEM = { " Size: " }; //MSG_SD_SIZE
-const char MSGEN207[] PROGMEM = { "File selected" }; //MSG_SD_FILE_SELECTED
-const char MSGCZ207[] PROGMEM = { "File selected" }; //MSG_SD_FILE_SELECTED
-const char MSGIT207[] PROGMEM = { "File selected" }; //MSG_SD_FILE_SELECTED
-const char MSGES207[] PROGMEM = { "File selected" }; //MSG_SD_FILE_SELECTED
-const char MSGPL207[] PROGMEM = { "File selected" }; //MSG_SD_FILE_SELECTED
-const char MSGEN208[] PROGMEM = { "Writing to file: " }; //MSG_SD_WRITE_TO_FILE
-const char MSGCZ208[] PROGMEM = { "Writing to file: " }; //MSG_SD_WRITE_TO_FILE
-const char MSGIT208[] PROGMEM = { "Writing to file: " }; //MSG_SD_WRITE_TO_FILE
-const char MSGES208[] PROGMEM = { "Writing to file: " }; //MSG_SD_WRITE_TO_FILE
-const char MSGPL208[] PROGMEM = { "Writing to file: " }; //MSG_SD_WRITE_TO_FILE
-const char MSGEN209[] PROGMEM = { "SD printing byte " }; //MSG_SD_PRINTING_BYTE
-const char MSGCZ209[] PROGMEM = { "SD printing byte " }; //MSG_SD_PRINTING_BYTE
-const char MSGIT209[] PROGMEM = { "SD printing byte " }; //MSG_SD_PRINTING_BYTE
-const char MSGES209[] PROGMEM = { "SD printing byte " }; //MSG_SD_PRINTING_BYTE
-const char MSGPL209[] PROGMEM = { "SD printing byte " }; //MSG_SD_PRINTING_BYTE
-const char MSGEN210[] PROGMEM = { "Not SD printing" }; //MSG_SD_NOT_PRINTING
-const char MSGCZ210[] PROGMEM = { "Not SD printing" }; //MSG_SD_NOT_PRINTING
-const char MSGIT210[] PROGMEM = { "Not SD printing" }; //MSG_SD_NOT_PRINTING
-const char MSGES210[] PROGMEM = { "Not SD printing" }; //MSG_SD_NOT_PRINTING
-const char MSGPL210[] PROGMEM = { "Not SD printing" }; //MSG_SD_NOT_PRINTING
-const char MSGEN211[] PROGMEM = { "error writing to file" }; //MSG_SD_ERR_WRITE_TO_FILE
-const char MSGCZ211[] PROGMEM = { "error writing to file" }; //MSG_SD_ERR_WRITE_TO_FILE
-const char MSGIT211[] PROGMEM = { "error writing to file" }; //MSG_SD_ERR_WRITE_TO_FILE
-const char MSGES211[] PROGMEM = { "error writing to file" }; //MSG_SD_ERR_WRITE_TO_FILE
-const char MSGPL211[] PROGMEM = { "error writing to file" }; //MSG_SD_ERR_WRITE_TO_FILE
-const char MSGEN212[] PROGMEM = { "Cannot enter subdir: " }; //MSG_SD_CANT_ENTER_SUBDIR
-const char MSGCZ212[] PROGMEM = { "Cannot enter subdir: " }; //MSG_SD_CANT_ENTER_SUBDIR
-const char MSGIT212[] PROGMEM = { "Cannot enter subdir: " }; //MSG_SD_CANT_ENTER_SUBDIR
-const char MSGES212[] PROGMEM = { "Cannot enter subdir: " }; //MSG_SD_CANT_ENTER_SUBDIR
-const char MSGPL212[] PROGMEM = { "Cannot enter subdir: " }; //MSG_SD_CANT_ENTER_SUBDIR
-const char MSGEN213[] PROGMEM = { "Steprate too high: " }; //MSG_STEPPER_TOO_HIGH
-const char MSGCZ213[] PROGMEM = { "Steprate too high: " }; //MSG_STEPPER_TOO_HIGH
-const char MSGIT213[] PROGMEM = { "Steprate too high: " }; //MSG_STEPPER_TOO_HIGH
-const char MSGES213[] PROGMEM = { "Steprate too high: " }; //MSG_STEPPER_TOO_HIGH
-const char MSGPL213[] PROGMEM = { "Steprate too high: " }; //MSG_STEPPER_TOO_HIGH
-const char MSGEN214[] PROGMEM = { "endstops hit: " }; //MSG_ENDSTOPS_HIT
-const char MSGCZ214[] PROGMEM = { "endstops hit: " }; //MSG_ENDSTOPS_HIT
-const char MSGIT214[] PROGMEM = { "endstops hit: " }; //MSG_ENDSTOPS_HIT
-const char MSGES214[] PROGMEM = { "endstops hit: " }; //MSG_ENDSTOPS_HIT
-const char MSGPL214[] PROGMEM = { "endstops hit: " }; //MSG_ENDSTOPS_HIT
-const char MSGEN215[] PROGMEM = { " cold extrusion prevented" }; //MSG_ERR_COLD_EXTRUDE_STOP
-const char MSGCZ215[] PROGMEM = { " cold extrusion prevented" }; //MSG_ERR_COLD_EXTRUDE_STOP
-const char MSGIT215[] PROGMEM = { " cold extrusion prevented" }; //MSG_ERR_COLD_EXTRUDE_STOP
-const char MSGES215[] PROGMEM = { " cold extrusion prevented" }; //MSG_ERR_COLD_EXTRUDE_STOP
-const char MSGPL215[] PROGMEM = { " cold extrusion prevented" }; //MSG_ERR_COLD_EXTRUDE_STOP
-const char MSGEN216[] PROGMEM = { " too long extrusion prevented" }; //MSG_ERR_LONG_EXTRUDE_STOP
-const char MSGCZ216[] PROGMEM = { " too long extrusion prevented" }; //MSG_ERR_LONG_EXTRUDE_STOP
-const char MSGIT216[] PROGMEM = { " too long extrusion prevented" }; //MSG_ERR_LONG_EXTRUDE_STOP
-const char MSGES216[] PROGMEM = { " too long extrusion prevented" }; //MSG_ERR_LONG_EXTRUDE_STOP
-const char MSGPL216[] PROGMEM = { " too long extrusion prevented" }; //MSG_ERR_LONG_EXTRUDE_STOP
-const char MSGEN217[] PROGMEM = { "Babystepping X" }; //MSG_BABYSTEPPING_X
-const char MSGCZ217[] PROGMEM = { "Babystepping X" }; //MSG_BABYSTEPPING_X
-const char MSGIT217[] PROGMEM = { "Babystepping X" }; //MSG_BABYSTEPPING_X
-const char MSGES217[] PROGMEM = { "Babystepping X" }; //MSG_BABYSTEPPING_X
-const char MSGPL217[] PROGMEM = { "Babystepping X" }; //MSG_BABYSTEPPING_X
-const char MSGEN218[] PROGMEM = { "Babystepping Y" }; //MSG_BABYSTEPPING_Y
-const char MSGCZ218[] PROGMEM = { "Babystepping Y" }; //MSG_BABYSTEPPING_Y
-const char MSGIT218[] PROGMEM = { "Babystepping Y" }; //MSG_BABYSTEPPING_Y
-const char MSGES218[] PROGMEM = { "Babystepping Y" }; //MSG_BABYSTEPPING_Y
-const char MSGPL218[] PROGMEM = { "Babystepping Y" }; //MSG_BABYSTEPPING_Y
-const char MSGEN219[] PROGMEM = { "Adjusting Z" }; //MSG_BABYSTEPPING_Z
-const char MSGCZ219[] PROGMEM = { "Dostavovani Z" }; //MSG_BABYSTEPPING_Z
-const char MSGIT219[] PROGMEM = { "Adjusting Z" }; //MSG_BABYSTEPPING_Z
-const char MSGES219[] PROGMEM = { "Adjusting Z" }; //MSG_BABYSTEPPING_Z
-const char MSGPL219[] PROGMEM = { "Dostavovani Z" }; //MSG_BABYSTEPPING_Z
-const char MSGEN220[] PROGMEM = { "Error in menu structure" }; //MSG_SERIAL_ERROR_MENU_STRUCTURE
-const char MSGCZ220[] PROGMEM = { "Error in menu structure" }; //MSG_SERIAL_ERROR_MENU_STRUCTURE
-const char MSGIT220[] PROGMEM = { "Error in menu structure" }; //MSG_SERIAL_ERROR_MENU_STRUCTURE
-const char MSGES220[] PROGMEM = { "Error in menu structure" }; //MSG_SERIAL_ERROR_MENU_STRUCTURE
-const char MSGPL220[] PROGMEM = { "Error in menu structure" }; //MSG_SERIAL_ERROR_MENU_STRUCTURE
-const char MSGEN221[] PROGMEM = { "English" }; //MSG_LANGUAGE_NAME
-const char MSGCZ221[] PROGMEM = { "Cestina" }; //MSG_LANGUAGE_NAME
-const char MSGIT221[] PROGMEM = { "Italiano" }; //MSG_LANGUAGE_NAME
-const char MSGES221[] PROGMEM = { "Espanol" }; //MSG_LANGUAGE_NAME
-const char MSGPL221[] PROGMEM = { "Polski" }; //MSG_LANGUAGE_NAME
-const char MSGEN222[] PROGMEM = { "Select language     " }; //MSG_LANGUAGE_SELECT
-const char MSGCZ222[] PROGMEM = { "Vyber jazyka        " }; //MSG_LANGUAGE_SELECT
-const char MSGIT222[] PROGMEM = { "Selez. la lingua" }; //MSG_LANGUAGE_SELECT
-const char MSGES222[] PROGMEM = { "Cambia la lengua " }; //MSG_LANGUAGE_SELECT
-const char MSGPL222[] PROGMEM = { "Wybor jezyka        " }; //MSG_LANGUAGE_SELECT
-const char MSGEN223[] PROGMEM = { "prusa3d.com" }; //MSG_PRUSA3D
-const char MSGCZ223[] PROGMEM = { "prusa3d.cz" }; //MSG_PRUSA3D
-const char MSGIT223[] PROGMEM = { "prusa3d.com" }; //MSG_PRUSA3D
-const char MSGES223[] PROGMEM = { "prusa3d.com" }; //MSG_PRUSA3D
-const char MSGPL223[] PROGMEM = { "prusa3d.cz" }; //MSG_PRUSA3D
-const char MSGEN224[] PROGMEM = { "forum.prusa3d.com" }; //MSG_PRUSA3D_FORUM
-const char MSGCZ224[] PROGMEM = { "forum.prusa3d.cz" }; //MSG_PRUSA3D_FORUM
-const char MSGIT224[] PROGMEM = { "forum.prusa3d.com" }; //MSG_PRUSA3D_FORUM
-const char MSGES224[] PROGMEM = { "forum.prusa3d.com" }; //MSG_PRUSA3D_FORUM
-const char MSGPL224[] PROGMEM = { "forum.prusa3d.cz" }; //MSG_PRUSA3D_FORUM
-const char MSGEN225[] PROGMEM = { "howto.prusa3d.com" }; //MSG_PRUSA3D_HOWTO
-const char MSGCZ225[] PROGMEM = { "howto.prusa3d.cz" }; //MSG_PRUSA3D_HOWTO
-const char MSGIT225[] PROGMEM = { "howto.prusa3d.com" }; //MSG_PRUSA3D_HOWTO
-const char MSGES225[] PROGMEM = { "howto.prusa3d.com" }; //MSG_PRUSA3D_HOWTO
-const char MSGPL225[] PROGMEM = { "howto.prusa3d.cz" }; //MSG_PRUSA3D_HOWTO
-const char MSGEN226[] PROGMEM = { "Selftest error !" }; //MSG_SELFTEST_ERROR
-const char MSGCZ226[] PROGMEM = { "Selftest error !" }; //MSG_SELFTEST_ERROR
-const char MSGIT226[] PROGMEM = { "Autotest negativo" }; //MSG_SELFTEST_ERROR
-const char MSGES226[] PROGMEM = { "¡Autotest error!" }; //MSG_SELFTEST_ERROR
-const char MSGPL226[] PROGMEM = { "Selftest error !" }; //MSG_SELFTEST_ERROR
-const char MSGEN227[] PROGMEM = { "Please check :" }; //MSG_SELFTEST_PLEASECHECK
-const char MSGCZ227[] PROGMEM = { "Zkontrolujte :" }; //MSG_SELFTEST_PLEASECHECK
-const char MSGIT227[] PROGMEM = { "Verifica:" }; //MSG_SELFTEST_PLEASECHECK
-const char MSGES227[] PROGMEM = { "Controla :" }; //MSG_SELFTEST_PLEASECHECK
-const char MSGPL227[] PROGMEM = { "Skontroluj :" }; //MSG_SELFTEST_PLEASECHECK
-const char MSGEN228[] PROGMEM = { "Not connected" }; //MSG_SELFTEST_NOTCONNECTED
-const char MSGCZ228[] PROGMEM = { "Nezapojeno    " }; //MSG_SELFTEST_NOTCONNECTED
-const char MSGIT228[] PROGMEM = { "Non connesso" }; //MSG_SELFTEST_NOTCONNECTED
-const char MSGES228[] PROGMEM = { "No hay conexion  " }; //MSG_SELFTEST_NOTCONNECTED
-const char MSGPL228[] PROGMEM = { "Nie podlaczono   " }; //MSG_SELFTEST_NOTCONNECTED
-const char MSGEN229[] PROGMEM = { "Heater/Thermistor" }; //MSG_SELFTEST_HEATERTHERMISTOR
-const char MSGCZ229[] PROGMEM = { "Heater/Thermistor" }; //MSG_SELFTEST_HEATERTHERMISTOR
-const char MSGIT229[] PROGMEM = { "Riscald./Termistore" }; //MSG_SELFTEST_HEATERTHERMISTOR
-const char MSGES229[] PROGMEM = { "Calent./Termistor" }; //MSG_SELFTEST_HEATERTHERMISTOR
-const char MSGPL229[] PROGMEM = { "Heater/Thermistor" }; //MSG_SELFTEST_HEATERTHERMISTOR
-const char MSGEN230[] PROGMEM = { "Bed / Heater" }; //MSG_SELFTEST_BEDHEATER
-const char MSGCZ230[] PROGMEM = { "Bed / Heater" }; //MSG_SELFTEST_BEDHEATER
-const char MSGIT230[] PROGMEM = { "Piastra/Riscaldatore" }; //MSG_SELFTEST_BEDHEATER
-const char MSGES230[] PROGMEM = { "Cama/Calentador" }; //MSG_SELFTEST_BEDHEATER
-const char MSGPL230[] PROGMEM = { "Bed / Heater" }; //MSG_SELFTEST_BEDHEATER
-const char MSGEN231[] PROGMEM = { "Wiring error" }; //MSG_SELFTEST_WIRINGERROR
-const char MSGCZ231[] PROGMEM = { "Chyba zapojeni" }; //MSG_SELFTEST_WIRINGERROR
-const char MSGIT231[] PROGMEM = { "Errore cablaggio" }; //MSG_SELFTEST_WIRINGERROR
-const char MSGES231[] PROGMEM = { "Error de conexión" }; //MSG_SELFTEST_WIRINGERROR
-const char MSGPL231[] PROGMEM = { "Blad polaczenia" }; //MSG_SELFTEST_WIRINGERROR
-const char MSGEN232[] PROGMEM = { "Endstops" }; //MSG_SELFTEST_ENDSTOPS
-const char MSGCZ232[] PROGMEM = { "Endstops" }; //MSG_SELFTEST_ENDSTOPS
-const char MSGIT232[] PROGMEM = { "Limiti corsa" }; //MSG_SELFTEST_ENDSTOPS
-const char MSGES232[] PROGMEM = { "Topes final" }; //MSG_SELFTEST_ENDSTOPS
-const char MSGPL232[] PROGMEM = { "Endstops" }; //MSG_SELFTEST_ENDSTOPS
-const char MSGEN233[] PROGMEM = { "Motor" }; //MSG_SELFTEST_MOTOR
-const char MSGCZ233[] PROGMEM = { "Motor" }; //MSG_SELFTEST_MOTOR
-const char MSGIT233[] PROGMEM = { "Motore" }; //MSG_SELFTEST_MOTOR
-const char MSGES233[] PROGMEM = { "Motor" }; //MSG_SELFTEST_MOTOR
-const char MSGPL233[] PROGMEM = { "Silnik" }; //MSG_SELFTEST_MOTOR
-const char MSGEN234[] PROGMEM = { "Endstop" }; //MSG_SELFTEST_ENDSTOP
-const char MSGCZ234[] PROGMEM = { "Endstop" }; //MSG_SELFTEST_ENDSTOP
-const char MSGIT234[] PROGMEM = { "Limite corsa" }; //MSG_SELFTEST_ENDSTOP
-const char MSGES234[] PROGMEM = { "Tope final" }; //MSG_SELFTEST_ENDSTOP
-const char MSGPL234[] PROGMEM = { "Endstop" }; //MSG_SELFTEST_ENDSTOP
-const char MSGEN235[] PROGMEM = { "Endstop not hit" }; //MSG_SELFTEST_ENDSTOP_NOTHIT
-const char MSGCZ235[] PROGMEM = { "Endstop not hit" }; //MSG_SELFTEST_ENDSTOP_NOTHIT
-const char MSGIT235[] PROGMEM = { "Lim. fuoriportata" }; //MSG_SELFTEST_ENDSTOP_NOTHIT
-const char MSGES235[] PROGMEM = { "Tope fin. no toc." }; //MSG_SELFTEST_ENDSTOP_NOTHIT
-const char MSGPL235[] PROGMEM = { "Endstop not hit" }; //MSG_SELFTEST_ENDSTOP_NOTHIT
-const char MSGEN236[] PROGMEM = { "Self test OK" }; //MSG_SELFTEST_OK
-const char MSGCZ236[] PROGMEM = { "Self test OK" }; //MSG_SELFTEST_OK
-const char MSGIT236[] PROGMEM = { "Autotest OK" }; //MSG_SELFTEST_OK
-const char MSGES236[] PROGMEM = { "Self test OK" }; //MSG_SELFTEST_OK
-const char MSGPL236[] PROGMEM = { "Self test OK" }; //MSG_SELFTEST_OK
-const char MSGEN237[] PROGMEM = { "Total filament :" }; //MSG_STATS_TOTALFILAMENT
-const char MSGCZ237[] PROGMEM = { "Filament celkem :" }; //MSG_STATS_TOTALFILAMENT
-const char MSGIT237[] PROGMEM = { "Filamento tot:" }; //MSG_STATS_TOTALFILAMENT
-const char MSGES237[] PROGMEM = { "Filamento total:" }; //MSG_STATS_TOTALFILAMENT
-const char MSGPL237[] PROGMEM = { "Filament lacznie :" }; //MSG_STATS_TOTALFILAMENT
-const char MSGEN238[] PROGMEM = { "Total print time :" }; //MSG_STATS_TOTALPRINTTIME
-const char MSGCZ238[] PROGMEM = { "Celkovy cas :" }; //MSG_STATS_TOTALPRINTTIME
-const char MSGIT238[] PROGMEM = { "Tempo stampa tot:" }; //MSG_STATS_TOTALPRINTTIME
-const char MSGES238[] PROGMEM = { "Tiempo total :" }; //MSG_STATS_TOTALPRINTTIME
-const char MSGPL238[] PROGMEM = { "Czas calkowity :" }; //MSG_STATS_TOTALPRINTTIME
-const char MSGEN239[] PROGMEM = { "Filament used:  " }; //MSG_STATS_FILAMENTUSED
-const char MSGCZ239[] PROGMEM = { "Filament :  " }; //MSG_STATS_FILAMENTUSED
-const char MSGIT239[] PROGMEM = { "Filamento:" }; //MSG_STATS_FILAMENTUSED
-const char MSGES239[] PROGMEM = { "Filamento :  " }; //MSG_STATS_FILAMENTUSED
-const char MSGPL239[] PROGMEM = { "Filament :  " }; //MSG_STATS_FILAMENTUSED
-const char MSGEN240[] PROGMEM = { "Print time:  " }; //MSG_STATS_PRINTTIME
-const char MSGCZ240[] PROGMEM = { "Cas tisku :  " }; //MSG_STATS_PRINTTIME
-const char MSGIT240[] PROGMEM = { "Tempo stampa:" }; //MSG_STATS_PRINTTIME
-const char MSGES240[] PROGMEM = { "Tiempo de imp.:" }; //MSG_STATS_PRINTTIME
-const char MSGPL240[] PROGMEM = { "Czas druku :  " }; //MSG_STATS_PRINTTIME
-const char MSGEN241[] PROGMEM = { "Self test start  " }; //MSG_SELFTEST_START
-const char MSGCZ241[] PROGMEM = { "Self test start  " }; //MSG_SELFTEST_START
-const char MSGIT241[] PROGMEM = { "Inizia autotest" }; //MSG_SELFTEST_START
-const char MSGES241[] PROGMEM = { "Autotest salida" }; //MSG_SELFTEST_START
-const char MSGPL241[] PROGMEM = { "Self test start  " }; //MSG_SELFTEST_START
-const char MSGEN242[] PROGMEM = { "Checking endstops" }; //MSG_SELFTEST_CHECK_ENDSTOPS
-const char MSGCZ242[] PROGMEM = { "Kontrola endstops" }; //MSG_SELFTEST_CHECK_ENDSTOPS
-const char MSGIT242[] PROGMEM = { "Verifica limiti" }; //MSG_SELFTEST_CHECK_ENDSTOPS
-const char MSGES242[] PROGMEM = { "Cont. topes final" }; //MSG_SELFTEST_CHECK_ENDSTOPS
-const char MSGPL242[] PROGMEM = { "Kontrola endstops" }; //MSG_SELFTEST_CHECK_ENDSTOPS
-const char MSGEN243[] PROGMEM = { "Checking hotend  " }; //MSG_SELFTEST_CHECK_HOTEND
-const char MSGCZ243[] PROGMEM = { "Kontrola hotend  " }; //MSG_SELFTEST_CHECK_HOTEND
-const char MSGIT243[] PROGMEM = { "Verifica lim temp" }; //MSG_SELFTEST_CHECK_HOTEND
-const char MSGES243[] PROGMEM = { "Control hotend " }; //MSG_SELFTEST_CHECK_HOTEND
-const char MSGPL243[] PROGMEM = { "Kontrola hotend  " }; //MSG_SELFTEST_CHECK_HOTEND
-const char MSGEN244[] PROGMEM = { "Checking X axis  " }; //MSG_SELFTEST_CHECK_X
-const char MSGCZ244[] PROGMEM = { "Kontrola X axis  " }; //MSG_SELFTEST_CHECK_X
-const char MSGIT244[] PROGMEM = { "Verifica asse X" }; //MSG_SELFTEST_CHECK_X
-const char MSGES244[] PROGMEM = { "Control del eje X" }; //MSG_SELFTEST_CHECK_X
-const char MSGPL244[] PROGMEM = { "Kontrola X axis  " }; //MSG_SELFTEST_CHECK_X
-const char MSGEN245[] PROGMEM = { "Checking Y axis  " }; //MSG_SELFTEST_CHECK_Y
-const char MSGCZ245[] PROGMEM = { "Kontrola Y axis  " }; //MSG_SELFTEST_CHECK_Y
-const char MSGIT245[] PROGMEM = { "Verifica asse Y" }; //MSG_SELFTEST_CHECK_Y
-const char MSGES245[] PROGMEM = { "Control del eje Y" }; //MSG_SELFTEST_CHECK_Y
-const char MSGPL245[] PROGMEM = { "Kontrola Y axis  " }; //MSG_SELFTEST_CHECK_Y
-const char MSGEN246[] PROGMEM = { "Checking Z axis  " }; //MSG_SELFTEST_CHECK_Z
-const char MSGCZ246[] PROGMEM = { "Kontrola Z axis  " }; //MSG_SELFTEST_CHECK_Z
-const char MSGIT246[] PROGMEM = { "Verifica asse Z" }; //MSG_SELFTEST_CHECK_Z
-const char MSGES246[] PROGMEM = { "Control del eje Z" }; //MSG_SELFTEST_CHECK_Z
-const char MSGPL246[] PROGMEM = { "Kontrola Z axis  " }; //MSG_SELFTEST_CHECK_Z
-const char MSGEN247[] PROGMEM = { "Checking bed     " }; //MSG_SELFTEST_CHECK_BED
-const char MSGCZ247[] PROGMEM = { "Kontrola bed     " }; //MSG_SELFTEST_CHECK_BED
-const char MSGIT247[] PROGMEM = { "Verifica piastra" }; //MSG_SELFTEST_CHECK_BED
-const char MSGES247[] PROGMEM = { "Control de cama" }; //MSG_SELFTEST_CHECK_BED
-const char MSGPL247[] PROGMEM = { "Kontrola bed     " }; //MSG_SELFTEST_CHECK_BED
-const char MSGEN248[] PROGMEM = { "All correct      " }; //MSG_SELFTEST_CHECK_ALLCORRECT
-const char MSGCZ248[] PROGMEM = { "Vse OK           " }; //MSG_SELFTEST_CHECK_ALLCORRECT
-const char MSGIT248[] PROGMEM = { "Nessun errore" }; //MSG_SELFTEST_CHECK_ALLCORRECT
-const char MSGES248[] PROGMEM = { "Todo bie " }; //MSG_SELFTEST_CHECK_ALLCORRECT
-const char MSGPL248[] PROGMEM = { "Wszystko OK      " }; //MSG_SELFTEST_CHECK_ALLCORRECT
-const char MSGEN249[] PROGMEM = { "Selftest         " }; //MSG_SELFTEST
-const char MSGCZ249[] PROGMEM = { "Selftest         " }; //MSG_SELFTEST
-const char MSGIT249[] PROGMEM = { "Autotest" }; //MSG_SELFTEST
-const char MSGES249[] PROGMEM = { "Autotest" }; //MSG_SELFTEST
-const char MSGPL249[] PROGMEM = { "Selftest         " }; //MSG_SELFTEST
-const char MSGEN250[] PROGMEM = { "Selftest failed  " }; //MSG_SELFTEST_FAILED
-const char MSGCZ250[] PROGMEM = { "Selftest selhal  " }; //MSG_SELFTEST_FAILED
-const char MSGIT250[] PROGMEM = { "Autotest fallito" }; //MSG_SELFTEST_FAILED
-const char MSGES250[] PROGMEM = { "Autotest fallado" }; //MSG_SELFTEST_FAILED
-const char MSGPL250[] PROGMEM = { "Selftest nieudany" }; //MSG_SELFTEST_FAILED
-const char MSGEN251[] PROGMEM = { "Statistics  " }; //MSG_STATISTICS
-const char MSGCZ251[] PROGMEM = { "Statistika  " }; //MSG_STATISTICS
-const char MSGIT251[] PROGMEM = { "Statistiche" }; //MSG_STATISTICS
-const char MSGES251[] PROGMEM = { "Estadistica  " }; //MSG_STATISTICS
-const char MSGPL251[] PROGMEM = { "Statystyka  " }; //MSG_STATISTICS
-const char MSGEN252[] PROGMEM = { "USB printing  " }; //MSG_USB_PRINTING
-const char MSGCZ252[] PROGMEM = { "Tisk z USB  " }; //MSG_USB_PRINTING
-const char MSGIT252[] PROGMEM = { "Stampa da USB" }; //MSG_USB_PRINTING
-const char MSGES252[] PROGMEM = { "Impresion de USB " }; //MSG_USB_PRINTING
-const char MSGPL252[] PROGMEM = { "Druk z USB  " }; //MSG_USB_PRINTING
-const char* MSGEN[]  = {MSGEN0, //WELCOME_MSG
-MSGEN1, //MSG_SD_INSERTED
-MSGEN2, //MSG_SD_REMOVED
-MSGEN3, //MSG_MAIN
-MSGEN4, //MSG_AUTOSTART
-MSGEN5, //MSG_DISABLE_STEPPERS
-MSGEN6, //MSG_AUTO_HOME
-MSGEN7, //MSG_SET_HOME_OFFSETS
-MSGEN8, //MSG_SET_ORIGIN
-MSGEN9, //MSG_PREHEAT_PLA
-MSGEN10, //MSG_PREHEAT_PLA0
-MSGEN11, //MSG_PREHEAT_PLA1
-MSGEN12, //MSG_PREHEAT_PLA2
-MSGEN13, //MSG_PREHEAT_PLA012
-MSGEN14, //MSG_PREHEAT_PLA_BEDONLY
-MSGEN15, //MSG_PREHEAT_PLA_SETTINGS
-MSGEN16, //MSG_PREHEAT_ABS
-MSGEN17, //MSG_PREHEAT_ABS0
-MSGEN18, //MSG_PREHEAT_ABS1
-MSGEN19, //MSG_PREHEAT_ABS2
-MSGEN20, //MSG_PREHEAT_ABS012
-MSGEN21, //MSG_PREHEAT_ABS_BEDONLY
-MSGEN22, //MSG_PREHEAT_ABS_SETTINGS
-MSGEN23, //MSG_COOLDOWN
-MSGEN24, //MSG_SWITCH_PS_ON
-MSGEN25, //MSG_SWITCH_PS_OFF
-MSGEN26, //MSG_EXTRUDE
-MSGEN27, //MSG_RETRACT
-MSGEN28, //MSG_MOVE_AXIS
-MSGEN29, //MSG_MOVE_X
-MSGEN30, //MSG_MOVE_Y
-MSGEN31, //MSG_MOVE_Z
-MSGEN32, //MSG_MOVE_E
-MSGEN33, //MSG_MOVE_E1
-MSGEN34, //MSG_MOVE_E2
-MSGEN35, //MSG_MOVE_01MM
-MSGEN36, //MSG_MOVE_1MM
-MSGEN37, //MSG_MOVE_10MM
-MSGEN38, //MSG_SPEED
-MSGEN39, //MSG_NOZZLE
-MSGEN40, //MSG_NOZZLE1
-MSGEN41, //MSG_NOZZLE2
-MSGEN42, //MSG_BED
-MSGEN43, //MSG_FAN_SPEED
-MSGEN44, //MSG_FLOW
-MSGEN45, //MSG_FLOW0
-MSGEN46, //MSG_FLOW1
-MSGEN47, //MSG_FLOW2
-MSGEN48, //MSG_CONTROL
-MSGEN49, //MSG_MIN
-MSGEN50, //MSG_MAX
-MSGEN51, //MSG_FACTOR
-MSGEN52, //MSG_AUTOTEMP
-MSGEN53, //MSG_ON
-MSGEN54, //MSG_OFF
-MSGEN55, //MSG_PID_P
-MSGEN56, //MSG_PID_I
-MSGEN57, //MSG_PID_D
-MSGEN58, //MSG_PID_C
-MSGEN59, //MSG_ACC
-MSGEN60, //MSG_VXY_JERK
-MSGEN61, //MSG_VZ_JERK
-MSGEN62, //MSG_VE_JERK
-MSGEN63, //MSG_VMAX
-MSGEN64, //MSG_X
-MSGEN65, //MSG_Y
-MSGEN66, //MSG_Z
-MSGEN67, //MSG_E
-MSGEN68, //MSG_VMIN
-MSGEN69, //MSG_VTRAV_MIN
-MSGEN70, //MSG_AMAX
-MSGEN71, //MSG_A_RETRACT
-MSGEN72, //MSG_XSTEPS
-MSGEN73, //MSG_YSTEPS
-MSGEN74, //MSG_ZSTEPS
-MSGEN75, //MSG_ESTEPS
-MSGEN76, //MSG_TEMPERATURE
-MSGEN77, //MSG_MOTION
-MSGEN78, //MSG_VOLUMETRIC
-MSGEN79, //MSG_VOLUMETRIC_ENABLED
-MSGEN80, //MSG_FILAMENT_SIZE_EXTRUDER_0
-MSGEN81, //MSG_FILAMENT_SIZE_EXTRUDER_1
-MSGEN82, //MSG_FILAMENT_SIZE_EXTRUDER_2
-MSGEN83, //MSG_CONTRAST
-MSGEN84, //MSG_STORE_EPROM
-MSGEN85, //MSG_LOAD_EPROM
-MSGEN86, //MSG_RESTORE_FAILSAFE
-MSGEN87, //MSG_REFRESH
-MSGEN88, //MSG_WATCH
-MSGEN89, //MSG_PREPARE
-MSGEN90, //MSG_TUNE
-MSGEN91, //MSG_PAUSE_PRINT
-MSGEN92, //MSG_RESUME_PRINT
-MSGEN93, //MSG_STOP_PRINT
-MSGEN94, //MSG_CARD_MENU
-MSGEN95, //MSG_NO_CARD
-MSGEN96, //MSG_DWELL
-MSGEN97, //MSG_USERWAIT
-MSGEN98, //MSG_RESUMING
-MSGEN99, //MSG_PRINT_ABORTED
-MSGEN100, //MSG_NO_MOVE
-MSGEN101, //MSG_KILLED
-MSGEN102, //MSG_STOPPED
-MSGEN103, //MSG_CONTROL_RETRACT
-MSGEN104, //MSG_CONTROL_RETRACT_SWAP
-MSGEN105, //MSG_CONTROL_RETRACTF
-MSGEN106, //MSG_CONTROL_RETRACT_ZLIFT
-MSGEN107, //MSG_CONTROL_RETRACT_RECOVER
-MSGEN108, //MSG_CONTROL_RETRACT_RECOVER_SWAP
-MSGEN109, //MSG_CONTROL_RETRACT_RECOVERF
-MSGEN110, //MSG_AUTORETRACT
-MSGEN111, //MSG_FILAMENTCHANGE
-MSGEN112, //MSG_INIT_SDCARD
-MSGEN113, //MSG_CNG_SDCARD
-MSGEN114, //MSG_ZPROBE_OUT
-MSGEN115, //MSG_POSITION_UNKNOWN
-MSGEN116, //MSG_ZPROBE_ZOFFSET
-MSGEN117, //MSG_BABYSTEP_X
-MSGEN118, //MSG_BABYSTEP_Y
-MSGEN119, //MSG_BABYSTEP_Z
-MSGEN120, //MSG_ENDSTOP_ABORT
-MSGEN121, //MSG_ADJUSTZ
-MSGEN122, //MSG_PICK_Z
-MSGEN123, //MSG_HOMEYZ
-MSGEN124, //MSG_HOMEYZ_PROGRESS
-MSGEN125, //MSG_HOMEYZ_DONE
-MSGEN126, //MSG_SETTINGS
-MSGEN127, //MSG_PREHEAT
-MSGEN128, //MSG_UNLOAD_FILAMENT
-MSGEN129, //MSG_LOAD_FILAMENT
-MSGEN130, //MSG_RECTRACT
-MSGEN131, //MSG_ERROR
-MSGEN132, //MSG_PREHEAT_NOZZLE
-MSGEN133, //MSG_SUPPORT
-MSGEN134, //MSG_CORRECTLY
-MSGEN135, //MSG_YES
-MSGEN136, //MSG_NO
-MSGEN137, //MSG_NOT_LOADED
-MSGEN138, //MSG_NOT_COLOR
-MSGEN139, //MSG_LOADING_FILAMENT
-MSGEN140, //MSG_PLEASE_WAIT
-MSGEN141, //MSG_LOADING_COLOR
-MSGEN142, //MSG_CHANGE_SUCCESS
-MSGEN143, //MSG_PRESS
-MSGEN144, //MSG_INSERT_FILAMENT
-MSGEN145, //MSG_CHANGING_FILAMENT
-MSGEN146, //MSG_SILENT_MODE_ON
-MSGEN147, //MSG_SILENT_MODE_OFF
-MSGEN148, //MSG_REBOOT
-MSGEN149, //MSG_TAKE_EFFECT
-MSGEN150, //MSG_Enqueing
-MSGEN151, //MSG_POWERUP
-MSGEN152, //MSG_EXTERNAL_RESET
-MSGEN153, //MSG_BROWNOUT_RESET
-MSGEN154, //MSG_WATCHDOG_RESET
-MSGEN155, //MSG_SOFTWARE_RESET
-MSGEN156, //MSG_AUTHOR
-MSGEN157, //MSG_CONFIGURATION_VER
-MSGEN158, //MSG_FREE_MEMORY
-MSGEN159, //MSG_PLANNER_BUFFER_BYTES
-MSGEN160, //MSG_OK
-MSGEN161, //MSG_FILE_SAVED
-MSGEN162, //MSG_ERR_LINE_NO
-MSGEN163, //MSG_ERR_CHECKSUM_MISMATCH
-MSGEN164, //MSG_ERR_NO_CHECKSUM
-MSGEN165, //MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM
-MSGEN166, //MSG_FILE_PRINTED
-MSGEN167, //MSG_BEGIN_FILE_LIST
-MSGEN168, //MSG_END_FILE_LIST
-MSGEN169, //MSG_M104_INVALID_EXTRUDER
-MSGEN170, //MSG_M105_INVALID_EXTRUDER
-MSGEN171, //MSG_M200_INVALID_EXTRUDER
-MSGEN172, //MSG_M218_INVALID_EXTRUDER
-MSGEN173, //MSG_M221_INVALID_EXTRUDER
-MSGEN174, //MSG_ERR_NO_THERMISTORS
-MSGEN175, //MSG_M109_INVALID_EXTRUDER
-MSGEN176, //MSG_HEATING
-MSGEN177, //MSG_HEATING_COMPLETE
-MSGEN178, //MSG_BED_HEATING
-MSGEN179, //MSG_BED_DONE
-MSGEN180, //MSG_M115_REPORT
-MSGEN181, //MSG_COUNT_X
-MSGEN182, //MSG_ERR_KILLED
-MSGEN183, //MSG_ERR_STOPPED
-MSGEN184, //MSG_RESEND
-MSGEN185, //MSG_UNKNOWN_COMMAND
-MSGEN186, //MSG_ACTIVE_EXTRUDER
-MSGEN187, //MSG_INVALID_EXTRUDER
-MSGEN188, //MSG_X_MIN
-MSGEN189, //MSG_X_MAX
-MSGEN190, //MSG_Y_MIN
-MSGEN191, //MSG_Y_MAX
-MSGEN192, //MSG_Z_MIN
-MSGEN193, //MSG_Z_MAX
-MSGEN194, //MSG_M119_REPORT
-MSGEN195, //MSG_ENDSTOP_HIT
-MSGEN196, //MSG_ENDSTOP_OPEN
-MSGEN197, //MSG_HOTEND_OFFSET
-MSGEN198, //MSG_SD_CANT_OPEN_SUBDIR
-MSGEN199, //MSG_SD_INIT_FAIL
-MSGEN200, //MSG_SD_VOL_INIT_FAIL
-MSGEN201, //MSG_SD_OPENROOT_FAIL
-MSGEN202, //MSG_SD_CARD_OK
-MSGEN203, //MSG_SD_WORKDIR_FAIL
-MSGEN204, //MSG_SD_OPEN_FILE_FAIL
-MSGEN205, //MSG_SD_FILE_OPENED
-MSGEN206, //MSG_SD_SIZE
-MSGEN207, //MSG_SD_FILE_SELECTED
-MSGEN208, //MSG_SD_WRITE_TO_FILE
-MSGEN209, //MSG_SD_PRINTING_BYTE
-MSGEN210, //MSG_SD_NOT_PRINTING
-MSGEN211, //MSG_SD_ERR_WRITE_TO_FILE
-MSGEN212, //MSG_SD_CANT_ENTER_SUBDIR
-MSGEN213, //MSG_STEPPER_TOO_HIGH
-MSGEN214, //MSG_ENDSTOPS_HIT
-MSGEN215, //MSG_ERR_COLD_EXTRUDE_STOP
-MSGEN216, //MSG_ERR_LONG_EXTRUDE_STOP
-MSGEN217, //MSG_BABYSTEPPING_X
-MSGEN218, //MSG_BABYSTEPPING_Y
-MSGEN219, //MSG_BABYSTEPPING_Z
-MSGEN220, //MSG_SERIAL_ERROR_MENU_STRUCTURE
-MSGEN221, //MSG_LANGUAGE_NAME
-MSGEN222, //MSG_LANGUAGE_SELECT
-MSGEN223, //MSG_PRUSA3D
-MSGEN224, //MSG_PRUSA3D_FORUM
-MSGEN225, //MSG_PRUSA3D_HOWTO
-MSGEN226, //MSG_SELFTEST_ERROR
-MSGEN227, //MSG_SELFTEST_PLEASECHECK
-MSGEN228, //MSG_SELFTEST_NOTCONNECTED
-MSGEN229, //MSG_SELFTEST_HEATERTHERMISTOR
-MSGEN230, //MSG_SELFTEST_BEDHEATER
-MSGEN231, //MSG_SELFTEST_WIRINGERROR
-MSGEN232, //MSG_SELFTEST_ENDSTOPS
-MSGEN233, //MSG_SELFTEST_MOTOR
-MSGEN234, //MSG_SELFTEST_ENDSTOP
-MSGEN235, //MSG_SELFTEST_ENDSTOP_NOTHIT
-MSGEN236, //MSG_SELFTEST_OK
-MSGEN237, //MSG_STATS_TOTALFILAMENT
-MSGEN238, //MSG_STATS_TOTALPRINTTIME
-MSGEN239, //MSG_STATS_FILAMENTUSED
-MSGEN240, //MSG_STATS_PRINTTIME
-MSGEN241, //MSG_SELFTEST_START
-MSGEN242, //MSG_SELFTEST_CHECK_ENDSTOPS
-MSGEN243, //MSG_SELFTEST_CHECK_HOTEND
-MSGEN244, //MSG_SELFTEST_CHECK_X
-MSGEN245, //MSG_SELFTEST_CHECK_Y
-MSGEN246, //MSG_SELFTEST_CHECK_Z
-MSGEN247, //MSG_SELFTEST_CHECK_BED
-MSGEN248, //MSG_SELFTEST_CHECK_ALLCORRECT
-MSGEN249, //MSG_SELFTEST
-MSGEN250, //MSG_SELFTEST_FAILED
-MSGEN251, //MSG_STATISTICS
-MSGEN252, //MSG_USB_PRINTING
-};
-const char* MSGCZ[]  = {MSGCZ0, //WELCOME_MSG
-MSGCZ1, //MSG_SD_INSERTED
-MSGCZ2, //MSG_SD_REMOVED
-MSGCZ3, //MSG_MAIN
-MSGCZ4, //MSG_AUTOSTART
-MSGCZ5, //MSG_DISABLE_STEPPERS
-MSGCZ6, //MSG_AUTO_HOME
-MSGCZ7, //MSG_SET_HOME_OFFSETS
-MSGCZ8, //MSG_SET_ORIGIN
-MSGCZ9, //MSG_PREHEAT_PLA
-MSGCZ10, //MSG_PREHEAT_PLA0
-MSGCZ11, //MSG_PREHEAT_PLA1
-MSGCZ12, //MSG_PREHEAT_PLA2
-MSGCZ13, //MSG_PREHEAT_PLA012
-MSGCZ14, //MSG_PREHEAT_PLA_BEDONLY
-MSGCZ15, //MSG_PREHEAT_PLA_SETTINGS
-MSGCZ16, //MSG_PREHEAT_ABS
-MSGCZ17, //MSG_PREHEAT_ABS0
-MSGCZ18, //MSG_PREHEAT_ABS1
-MSGCZ19, //MSG_PREHEAT_ABS2
-MSGCZ20, //MSG_PREHEAT_ABS012
-MSGCZ21, //MSG_PREHEAT_ABS_BEDONLY
-MSGCZ22, //MSG_PREHEAT_ABS_SETTINGS
-MSGCZ23, //MSG_COOLDOWN
-MSGCZ24, //MSG_SWITCH_PS_ON
-MSGCZ25, //MSG_SWITCH_PS_OFF
-MSGCZ26, //MSG_EXTRUDE
-MSGCZ27, //MSG_RETRACT
-MSGCZ28, //MSG_MOVE_AXIS
-MSGCZ29, //MSG_MOVE_X
-MSGCZ30, //MSG_MOVE_Y
-MSGCZ31, //MSG_MOVE_Z
-MSGCZ32, //MSG_MOVE_E
-MSGCZ33, //MSG_MOVE_E1
-MSGCZ34, //MSG_MOVE_E2
-MSGCZ35, //MSG_MOVE_01MM
-MSGCZ36, //MSG_MOVE_1MM
-MSGCZ37, //MSG_MOVE_10MM
-MSGCZ38, //MSG_SPEED
-MSGCZ39, //MSG_NOZZLE
-MSGCZ40, //MSG_NOZZLE1
-MSGCZ41, //MSG_NOZZLE2
-MSGCZ42, //MSG_BED
-MSGCZ43, //MSG_FAN_SPEED
-MSGCZ44, //MSG_FLOW
-MSGCZ45, //MSG_FLOW0
-MSGCZ46, //MSG_FLOW1
-MSGCZ47, //MSG_FLOW2
-MSGCZ48, //MSG_CONTROL
-MSGCZ49, //MSG_MIN
-MSGCZ50, //MSG_MAX
-MSGCZ51, //MSG_FACTOR
-MSGCZ52, //MSG_AUTOTEMP
-MSGCZ53, //MSG_ON
-MSGCZ54, //MSG_OFF
-MSGCZ55, //MSG_PID_P
-MSGCZ56, //MSG_PID_I
-MSGCZ57, //MSG_PID_D
-MSGCZ58, //MSG_PID_C
-MSGCZ59, //MSG_ACC
-MSGCZ60, //MSG_VXY_JERK
-MSGCZ61, //MSG_VZ_JERK
-MSGCZ62, //MSG_VE_JERK
-MSGCZ63, //MSG_VMAX
-MSGCZ64, //MSG_X
-MSGCZ65, //MSG_Y
-MSGCZ66, //MSG_Z
-MSGCZ67, //MSG_E
-MSGCZ68, //MSG_VMIN
-MSGCZ69, //MSG_VTRAV_MIN
-MSGCZ70, //MSG_AMAX
-MSGCZ71, //MSG_A_RETRACT
-MSGCZ72, //MSG_XSTEPS
-MSGCZ73, //MSG_YSTEPS
-MSGCZ74, //MSG_ZSTEPS
-MSGCZ75, //MSG_ESTEPS
-MSGCZ76, //MSG_TEMPERATURE
-MSGCZ77, //MSG_MOTION
-MSGCZ78, //MSG_VOLUMETRIC
-MSGCZ79, //MSG_VOLUMETRIC_ENABLED
-MSGCZ80, //MSG_FILAMENT_SIZE_EXTRUDER_0
-MSGCZ81, //MSG_FILAMENT_SIZE_EXTRUDER_1
-MSGCZ82, //MSG_FILAMENT_SIZE_EXTRUDER_2
-MSGCZ83, //MSG_CONTRAST
-MSGCZ84, //MSG_STORE_EPROM
-MSGCZ85, //MSG_LOAD_EPROM
-MSGCZ86, //MSG_RESTORE_FAILSAFE
-MSGCZ87, //MSG_REFRESH
-MSGCZ88, //MSG_WATCH
-MSGCZ89, //MSG_PREPARE
-MSGCZ90, //MSG_TUNE
-MSGCZ91, //MSG_PAUSE_PRINT
-MSGCZ92, //MSG_RESUME_PRINT
-MSGCZ93, //MSG_STOP_PRINT
-MSGCZ94, //MSG_CARD_MENU
-MSGCZ95, //MSG_NO_CARD
-MSGCZ96, //MSG_DWELL
-MSGCZ97, //MSG_USERWAIT
-MSGCZ98, //MSG_RESUMING
-MSGCZ99, //MSG_PRINT_ABORTED
-MSGCZ100, //MSG_NO_MOVE
-MSGCZ101, //MSG_KILLED
-MSGCZ102, //MSG_STOPPED
-MSGCZ103, //MSG_CONTROL_RETRACT
-MSGCZ104, //MSG_CONTROL_RETRACT_SWAP
-MSGCZ105, //MSG_CONTROL_RETRACTF
-MSGCZ106, //MSG_CONTROL_RETRACT_ZLIFT
-MSGCZ107, //MSG_CONTROL_RETRACT_RECOVER
-MSGCZ108, //MSG_CONTROL_RETRACT_RECOVER_SWAP
-MSGCZ109, //MSG_CONTROL_RETRACT_RECOVERF
-MSGCZ110, //MSG_AUTORETRACT
-MSGCZ111, //MSG_FILAMENTCHANGE
-MSGCZ112, //MSG_INIT_SDCARD
-MSGCZ113, //MSG_CNG_SDCARD
-MSGCZ114, //MSG_ZPROBE_OUT
-MSGCZ115, //MSG_POSITION_UNKNOWN
-MSGCZ116, //MSG_ZPROBE_ZOFFSET
-MSGCZ117, //MSG_BABYSTEP_X
-MSGCZ118, //MSG_BABYSTEP_Y
-MSGCZ119, //MSG_BABYSTEP_Z
-MSGCZ120, //MSG_ENDSTOP_ABORT
-MSGCZ121, //MSG_ADJUSTZ
-MSGCZ122, //MSG_PICK_Z
-MSGCZ123, //MSG_HOMEYZ
-MSGCZ124, //MSG_HOMEYZ_PROGRESS
-MSGCZ125, //MSG_HOMEYZ_DONE
-MSGCZ126, //MSG_SETTINGS
-MSGCZ127, //MSG_PREHEAT
-MSGCZ128, //MSG_UNLOAD_FILAMENT
-MSGCZ129, //MSG_LOAD_FILAMENT
-MSGCZ130, //MSG_RECTRACT
-MSGCZ131, //MSG_ERROR
-MSGCZ132, //MSG_PREHEAT_NOZZLE
-MSGCZ133, //MSG_SUPPORT
-MSGCZ134, //MSG_CORRECTLY
-MSGCZ135, //MSG_YES
-MSGCZ136, //MSG_NO
-MSGCZ137, //MSG_NOT_LOADED
-MSGCZ138, //MSG_NOT_COLOR
-MSGCZ139, //MSG_LOADING_FILAMENT
-MSGCZ140, //MSG_PLEASE_WAIT
-MSGCZ141, //MSG_LOADING_COLOR
-MSGCZ142, //MSG_CHANGE_SUCCESS
-MSGCZ143, //MSG_PRESS
-MSGCZ144, //MSG_INSERT_FILAMENT
-MSGCZ145, //MSG_CHANGING_FILAMENT
-MSGCZ146, //MSG_SILENT_MODE_ON
-MSGCZ147, //MSG_SILENT_MODE_OFF
-MSGCZ148, //MSG_REBOOT
-MSGCZ149, //MSG_TAKE_EFFECT
-MSGCZ150, //MSG_Enqueing
-MSGCZ151, //MSG_POWERUP
-MSGCZ152, //MSG_EXTERNAL_RESET
-MSGCZ153, //MSG_BROWNOUT_RESET
-MSGCZ154, //MSG_WATCHDOG_RESET
-MSGCZ155, //MSG_SOFTWARE_RESET
-MSGCZ156, //MSG_AUTHOR
-MSGCZ157, //MSG_CONFIGURATION_VER
-MSGCZ158, //MSG_FREE_MEMORY
-MSGCZ159, //MSG_PLANNER_BUFFER_BYTES
-MSGCZ160, //MSG_OK
-MSGCZ161, //MSG_FILE_SAVED
-MSGCZ162, //MSG_ERR_LINE_NO
-MSGCZ163, //MSG_ERR_CHECKSUM_MISMATCH
-MSGCZ164, //MSG_ERR_NO_CHECKSUM
-MSGCZ165, //MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM
-MSGCZ166, //MSG_FILE_PRINTED
-MSGCZ167, //MSG_BEGIN_FILE_LIST
-MSGCZ168, //MSG_END_FILE_LIST
-MSGCZ169, //MSG_M104_INVALID_EXTRUDER
-MSGCZ170, //MSG_M105_INVALID_EXTRUDER
-MSGCZ171, //MSG_M200_INVALID_EXTRUDER
-MSGCZ172, //MSG_M218_INVALID_EXTRUDER
-MSGCZ173, //MSG_M221_INVALID_EXTRUDER
-MSGCZ174, //MSG_ERR_NO_THERMISTORS
-MSGCZ175, //MSG_M109_INVALID_EXTRUDER
-MSGCZ176, //MSG_HEATING
-MSGCZ177, //MSG_HEATING_COMPLETE
-MSGCZ178, //MSG_BED_HEATING
-MSGCZ179, //MSG_BED_DONE
-MSGCZ180, //MSG_M115_REPORT
-MSGCZ181, //MSG_COUNT_X
-MSGCZ182, //MSG_ERR_KILLED
-MSGCZ183, //MSG_ERR_STOPPED
-MSGCZ184, //MSG_RESEND
-MSGCZ185, //MSG_UNKNOWN_COMMAND
-MSGCZ186, //MSG_ACTIVE_EXTRUDER
-MSGCZ187, //MSG_INVALID_EXTRUDER
-MSGCZ188, //MSG_X_MIN
-MSGCZ189, //MSG_X_MAX
-MSGCZ190, //MSG_Y_MIN
-MSGCZ191, //MSG_Y_MAX
-MSGCZ192, //MSG_Z_MIN
-MSGCZ193, //MSG_Z_MAX
-MSGCZ194, //MSG_M119_REPORT
-MSGCZ195, //MSG_ENDSTOP_HIT
-MSGCZ196, //MSG_ENDSTOP_OPEN
-MSGCZ197, //MSG_HOTEND_OFFSET
-MSGCZ198, //MSG_SD_CANT_OPEN_SUBDIR
-MSGCZ199, //MSG_SD_INIT_FAIL
-MSGCZ200, //MSG_SD_VOL_INIT_FAIL
-MSGCZ201, //MSG_SD_OPENROOT_FAIL
-MSGCZ202, //MSG_SD_CARD_OK
-MSGCZ203, //MSG_SD_WORKDIR_FAIL
-MSGCZ204, //MSG_SD_OPEN_FILE_FAIL
-MSGCZ205, //MSG_SD_FILE_OPENED
-MSGCZ206, //MSG_SD_SIZE
-MSGCZ207, //MSG_SD_FILE_SELECTED
-MSGCZ208, //MSG_SD_WRITE_TO_FILE
-MSGCZ209, //MSG_SD_PRINTING_BYTE
-MSGCZ210, //MSG_SD_NOT_PRINTING
-MSGCZ211, //MSG_SD_ERR_WRITE_TO_FILE
-MSGCZ212, //MSG_SD_CANT_ENTER_SUBDIR
-MSGCZ213, //MSG_STEPPER_TOO_HIGH
-MSGCZ214, //MSG_ENDSTOPS_HIT
-MSGCZ215, //MSG_ERR_COLD_EXTRUDE_STOP
-MSGCZ216, //MSG_ERR_LONG_EXTRUDE_STOP
-MSGCZ217, //MSG_BABYSTEPPING_X
-MSGCZ218, //MSG_BABYSTEPPING_Y
-MSGCZ219, //MSG_BABYSTEPPING_Z
-MSGCZ220, //MSG_SERIAL_ERROR_MENU_STRUCTURE
-MSGCZ221, //MSG_LANGUAGE_NAME
-MSGCZ222, //MSG_LANGUAGE_SELECT
-MSGCZ223, //MSG_PRUSA3D
-MSGCZ224, //MSG_PRUSA3D_FORUM
-MSGCZ225, //MSG_PRUSA3D_HOWTO
-MSGCZ226, //MSG_SELFTEST_ERROR
-MSGCZ227, //MSG_SELFTEST_PLEASECHECK
-MSGCZ228, //MSG_SELFTEST_NOTCONNECTED
-MSGCZ229, //MSG_SELFTEST_HEATERTHERMISTOR
-MSGCZ230, //MSG_SELFTEST_BEDHEATER
-MSGCZ231, //MSG_SELFTEST_WIRINGERROR
-MSGCZ232, //MSG_SELFTEST_ENDSTOPS
-MSGCZ233, //MSG_SELFTEST_MOTOR
-MSGCZ234, //MSG_SELFTEST_ENDSTOP
-MSGCZ235, //MSG_SELFTEST_ENDSTOP_NOTHIT
-MSGCZ236, //MSG_SELFTEST_OK
-MSGCZ237, //MSG_STATS_TOTALFILAMENT
-MSGCZ238, //MSG_STATS_TOTALPRINTTIME
-MSGCZ239, //MSG_STATS_FILAMENTUSED
-MSGCZ240, //MSG_STATS_PRINTTIME
-MSGCZ241, //MSG_SELFTEST_START
-MSGCZ242, //MSG_SELFTEST_CHECK_ENDSTOPS
-MSGCZ243, //MSG_SELFTEST_CHECK_HOTEND
-MSGCZ244, //MSG_SELFTEST_CHECK_X
-MSGCZ245, //MSG_SELFTEST_CHECK_Y
-MSGCZ246, //MSG_SELFTEST_CHECK_Z
-MSGCZ247, //MSG_SELFTEST_CHECK_BED
-MSGCZ248, //MSG_SELFTEST_CHECK_ALLCORRECT
-MSGCZ249, //MSG_SELFTEST
-MSGCZ250, //MSG_SELFTEST_FAILED
-MSGCZ251, //MSG_STATISTICS
-MSGCZ252, //MSG_USB_PRINTING
-};
-const char* MSGIT[]  = {MSGIT0, //WELCOME_MSG
-MSGIT1, //MSG_SD_INSERTED
-MSGIT2, //MSG_SD_REMOVED
-MSGIT3, //MSG_MAIN
-MSGIT4, //MSG_AUTOSTART
-MSGIT5, //MSG_DISABLE_STEPPERS
-MSGIT6, //MSG_AUTO_HOME
-MSGIT7, //MSG_SET_HOME_OFFSETS
-MSGIT8, //MSG_SET_ORIGIN
-MSGIT9, //MSG_PREHEAT_PLA
-MSGIT10, //MSG_PREHEAT_PLA0
-MSGIT11, //MSG_PREHEAT_PLA1
-MSGIT12, //MSG_PREHEAT_PLA2
-MSGIT13, //MSG_PREHEAT_PLA012
-MSGIT14, //MSG_PREHEAT_PLA_BEDONLY
-MSGIT15, //MSG_PREHEAT_PLA_SETTINGS
-MSGIT16, //MSG_PREHEAT_ABS
-MSGIT17, //MSG_PREHEAT_ABS0
-MSGIT18, //MSG_PREHEAT_ABS1
-MSGIT19, //MSG_PREHEAT_ABS2
-MSGIT20, //MSG_PREHEAT_ABS012
-MSGIT21, //MSG_PREHEAT_ABS_BEDONLY
-MSGIT22, //MSG_PREHEAT_ABS_SETTINGS
-MSGIT23, //MSG_COOLDOWN
-MSGIT24, //MSG_SWITCH_PS_ON
-MSGIT25, //MSG_SWITCH_PS_OFF
-MSGIT26, //MSG_EXTRUDE
-MSGIT27, //MSG_RETRACT
-MSGIT28, //MSG_MOVE_AXIS
-MSGIT29, //MSG_MOVE_X
-MSGIT30, //MSG_MOVE_Y
-MSGIT31, //MSG_MOVE_Z
-MSGIT32, //MSG_MOVE_E
-MSGIT33, //MSG_MOVE_E1
-MSGIT34, //MSG_MOVE_E2
-MSGIT35, //MSG_MOVE_01MM
-MSGIT36, //MSG_MOVE_1MM
-MSGIT37, //MSG_MOVE_10MM
-MSGIT38, //MSG_SPEED
-MSGIT39, //MSG_NOZZLE
-MSGIT40, //MSG_NOZZLE1
-MSGIT41, //MSG_NOZZLE2
-MSGIT42, //MSG_BED
-MSGIT43, //MSG_FAN_SPEED
-MSGIT44, //MSG_FLOW
-MSGIT45, //MSG_FLOW0
-MSGIT46, //MSG_FLOW1
-MSGIT47, //MSG_FLOW2
-MSGIT48, //MSG_CONTROL
-MSGIT49, //MSG_MIN
-MSGIT50, //MSG_MAX
-MSGIT51, //MSG_FACTOR
-MSGIT52, //MSG_AUTOTEMP
-MSGIT53, //MSG_ON
-MSGIT54, //MSG_OFF
-MSGIT55, //MSG_PID_P
-MSGIT56, //MSG_PID_I
-MSGIT57, //MSG_PID_D
-MSGIT58, //MSG_PID_C
-MSGIT59, //MSG_ACC
-MSGIT60, //MSG_VXY_JERK
-MSGIT61, //MSG_VZ_JERK
-MSGIT62, //MSG_VE_JERK
-MSGIT63, //MSG_VMAX
-MSGIT64, //MSG_X
-MSGIT65, //MSG_Y
-MSGIT66, //MSG_Z
-MSGIT67, //MSG_E
-MSGIT68, //MSG_VMIN
-MSGIT69, //MSG_VTRAV_MIN
-MSGIT70, //MSG_AMAX
-MSGIT71, //MSG_A_RETRACT
-MSGIT72, //MSG_XSTEPS
-MSGIT73, //MSG_YSTEPS
-MSGIT74, //MSG_ZSTEPS
-MSGIT75, //MSG_ESTEPS
-MSGIT76, //MSG_TEMPERATURE
-MSGIT77, //MSG_MOTION
-MSGIT78, //MSG_VOLUMETRIC
-MSGIT79, //MSG_VOLUMETRIC_ENABLED
-MSGIT80, //MSG_FILAMENT_SIZE_EXTRUDER_0
-MSGIT81, //MSG_FILAMENT_SIZE_EXTRUDER_1
-MSGIT82, //MSG_FILAMENT_SIZE_EXTRUDER_2
-MSGIT83, //MSG_CONTRAST
-MSGIT84, //MSG_STORE_EPROM
-MSGIT85, //MSG_LOAD_EPROM
-MSGIT86, //MSG_RESTORE_FAILSAFE
-MSGIT87, //MSG_REFRESH
-MSGIT88, //MSG_WATCH
-MSGIT89, //MSG_PREPARE
-MSGIT90, //MSG_TUNE
-MSGIT91, //MSG_PAUSE_PRINT
-MSGIT92, //MSG_RESUME_PRINT
-MSGIT93, //MSG_STOP_PRINT
-MSGIT94, //MSG_CARD_MENU
-MSGIT95, //MSG_NO_CARD
-MSGIT96, //MSG_DWELL
-MSGIT97, //MSG_USERWAIT
-MSGIT98, //MSG_RESUMING
-MSGIT99, //MSG_PRINT_ABORTED
-MSGIT100, //MSG_NO_MOVE
-MSGIT101, //MSG_KILLED
-MSGIT102, //MSG_STOPPED
-MSGIT103, //MSG_CONTROL_RETRACT
-MSGIT104, //MSG_CONTROL_RETRACT_SWAP
-MSGIT105, //MSG_CONTROL_RETRACTF
-MSGIT106, //MSG_CONTROL_RETRACT_ZLIFT
-MSGIT107, //MSG_CONTROL_RETRACT_RECOVER
-MSGIT108, //MSG_CONTROL_RETRACT_RECOVER_SWAP
-MSGIT109, //MSG_CONTROL_RETRACT_RECOVERF
-MSGIT110, //MSG_AUTORETRACT
-MSGIT111, //MSG_FILAMENTCHANGE
-MSGIT112, //MSG_INIT_SDCARD
-MSGIT113, //MSG_CNG_SDCARD
-MSGIT114, //MSG_ZPROBE_OUT
-MSGIT115, //MSG_POSITION_UNKNOWN
-MSGIT116, //MSG_ZPROBE_ZOFFSET
-MSGIT117, //MSG_BABYSTEP_X
-MSGIT118, //MSG_BABYSTEP_Y
-MSGIT119, //MSG_BABYSTEP_Z
-MSGIT120, //MSG_ENDSTOP_ABORT
-MSGIT121, //MSG_ADJUSTZ
-MSGIT122, //MSG_PICK_Z
-MSGIT123, //MSG_HOMEYZ
-MSGIT124, //MSG_HOMEYZ_PROGRESS
-MSGIT125, //MSG_HOMEYZ_DONE
-MSGIT126, //MSG_SETTINGS
-MSGIT127, //MSG_PREHEAT
-MSGIT128, //MSG_UNLOAD_FILAMENT
-MSGIT129, //MSG_LOAD_FILAMENT
-MSGIT130, //MSG_RECTRACT
-MSGIT131, //MSG_ERROR
-MSGIT132, //MSG_PREHEAT_NOZZLE
-MSGIT133, //MSG_SUPPORT
-MSGIT134, //MSG_CORRECTLY
-MSGIT135, //MSG_YES
-MSGIT136, //MSG_NO
-MSGIT137, //MSG_NOT_LOADED
-MSGIT138, //MSG_NOT_COLOR
-MSGIT139, //MSG_LOADING_FILAMENT
-MSGIT140, //MSG_PLEASE_WAIT
-MSGIT141, //MSG_LOADING_COLOR
-MSGIT142, //MSG_CHANGE_SUCCESS
-MSGIT143, //MSG_PRESS
-MSGIT144, //MSG_INSERT_FILAMENT
-MSGIT145, //MSG_CHANGING_FILAMENT
-MSGIT146, //MSG_SILENT_MODE_ON
-MSGIT147, //MSG_SILENT_MODE_OFF
-MSGIT148, //MSG_REBOOT
-MSGIT149, //MSG_TAKE_EFFECT
-MSGIT150, //MSG_Enqueing
-MSGIT151, //MSG_POWERUP
-MSGIT152, //MSG_EXTERNAL_RESET
-MSGIT153, //MSG_BROWNOUT_RESET
-MSGIT154, //MSG_WATCHDOG_RESET
-MSGIT155, //MSG_SOFTWARE_RESET
-MSGIT156, //MSG_AUTHOR
-MSGIT157, //MSG_CONFIGURATION_VER
-MSGIT158, //MSG_FREE_MEMORY
-MSGIT159, //MSG_PLANNER_BUFFER_BYTES
-MSGIT160, //MSG_OK
-MSGIT161, //MSG_FILE_SAVED
-MSGIT162, //MSG_ERR_LINE_NO
-MSGIT163, //MSG_ERR_CHECKSUM_MISMATCH
-MSGIT164, //MSG_ERR_NO_CHECKSUM
-MSGIT165, //MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM
-MSGIT166, //MSG_FILE_PRINTED
-MSGIT167, //MSG_BEGIN_FILE_LIST
-MSGIT168, //MSG_END_FILE_LIST
-MSGIT169, //MSG_M104_INVALID_EXTRUDER
-MSGIT170, //MSG_M105_INVALID_EXTRUDER
-MSGIT171, //MSG_M200_INVALID_EXTRUDER
-MSGIT172, //MSG_M218_INVALID_EXTRUDER
-MSGIT173, //MSG_M221_INVALID_EXTRUDER
-MSGIT174, //MSG_ERR_NO_THERMISTORS
-MSGIT175, //MSG_M109_INVALID_EXTRUDER
-MSGIT176, //MSG_HEATING
-MSGIT177, //MSG_HEATING_COMPLETE
-MSGIT178, //MSG_BED_HEATING
-MSGIT179, //MSG_BED_DONE
-MSGIT180, //MSG_M115_REPORT
-MSGIT181, //MSG_COUNT_X
-MSGIT182, //MSG_ERR_KILLED
-MSGIT183, //MSG_ERR_STOPPED
-MSGIT184, //MSG_RESEND
-MSGIT185, //MSG_UNKNOWN_COMMAND
-MSGIT186, //MSG_ACTIVE_EXTRUDER
-MSGIT187, //MSG_INVALID_EXTRUDER
-MSGIT188, //MSG_X_MIN
-MSGIT189, //MSG_X_MAX
-MSGIT190, //MSG_Y_MIN
-MSGIT191, //MSG_Y_MAX
-MSGIT192, //MSG_Z_MIN
-MSGIT193, //MSG_Z_MAX
-MSGIT194, //MSG_M119_REPORT
-MSGIT195, //MSG_ENDSTOP_HIT
-MSGIT196, //MSG_ENDSTOP_OPEN
-MSGIT197, //MSG_HOTEND_OFFSET
-MSGIT198, //MSG_SD_CANT_OPEN_SUBDIR
-MSGIT199, //MSG_SD_INIT_FAIL
-MSGIT200, //MSG_SD_VOL_INIT_FAIL
-MSGIT201, //MSG_SD_OPENROOT_FAIL
-MSGIT202, //MSG_SD_CARD_OK
-MSGIT203, //MSG_SD_WORKDIR_FAIL
-MSGIT204, //MSG_SD_OPEN_FILE_FAIL
-MSGIT205, //MSG_SD_FILE_OPENED
-MSGIT206, //MSG_SD_SIZE
-MSGIT207, //MSG_SD_FILE_SELECTED
-MSGIT208, //MSG_SD_WRITE_TO_FILE
-MSGIT209, //MSG_SD_PRINTING_BYTE
-MSGIT210, //MSG_SD_NOT_PRINTING
-MSGIT211, //MSG_SD_ERR_WRITE_TO_FILE
-MSGIT212, //MSG_SD_CANT_ENTER_SUBDIR
-MSGIT213, //MSG_STEPPER_TOO_HIGH
-MSGIT214, //MSG_ENDSTOPS_HIT
-MSGIT215, //MSG_ERR_COLD_EXTRUDE_STOP
-MSGIT216, //MSG_ERR_LONG_EXTRUDE_STOP
-MSGIT217, //MSG_BABYSTEPPING_X
-MSGIT218, //MSG_BABYSTEPPING_Y
-MSGIT219, //MSG_BABYSTEPPING_Z
-MSGIT220, //MSG_SERIAL_ERROR_MENU_STRUCTURE
-MSGIT221, //MSG_LANGUAGE_NAME
-MSGIT222, //MSG_LANGUAGE_SELECT
-MSGIT223, //MSG_PRUSA3D
-MSGIT224, //MSG_PRUSA3D_FORUM
-MSGIT225, //MSG_PRUSA3D_HOWTO
-MSGIT226, //MSG_SELFTEST_ERROR
-MSGIT227, //MSG_SELFTEST_PLEASECHECK
-MSGIT228, //MSG_SELFTEST_NOTCONNECTED
-MSGIT229, //MSG_SELFTEST_HEATERTHERMISTOR
-MSGIT230, //MSG_SELFTEST_BEDHEATER
-MSGIT231, //MSG_SELFTEST_WIRINGERROR
-MSGIT232, //MSG_SELFTEST_ENDSTOPS
-MSGIT233, //MSG_SELFTEST_MOTOR
-MSGIT234, //MSG_SELFTEST_ENDSTOP
-MSGIT235, //MSG_SELFTEST_ENDSTOP_NOTHIT
-MSGIT236, //MSG_SELFTEST_OK
-MSGIT237, //MSG_STATS_TOTALFILAMENT
-MSGIT238, //MSG_STATS_TOTALPRINTTIME
-MSGIT239, //MSG_STATS_FILAMENTUSED
-MSGIT240, //MSG_STATS_PRINTTIME
-MSGIT241, //MSG_SELFTEST_START
-MSGIT242, //MSG_SELFTEST_CHECK_ENDSTOPS
-MSGIT243, //MSG_SELFTEST_CHECK_HOTEND
-MSGIT244, //MSG_SELFTEST_CHECK_X
-MSGIT245, //MSG_SELFTEST_CHECK_Y
-MSGIT246, //MSG_SELFTEST_CHECK_Z
-MSGIT247, //MSG_SELFTEST_CHECK_BED
-MSGIT248, //MSG_SELFTEST_CHECK_ALLCORRECT
-MSGIT249, //MSG_SELFTEST
-MSGIT250, //MSG_SELFTEST_FAILED
-MSGIT251, //MSG_STATISTICS
-MSGIT252, //MSG_USB_PRINTING
-};
-const char* MSGES[]  = {MSGES0, //WELCOME_MSG
-MSGES1, //MSG_SD_INSERTED
-MSGES2, //MSG_SD_REMOVED
-MSGES3, //MSG_MAIN
-MSGES4, //MSG_AUTOSTART
-MSGES5, //MSG_DISABLE_STEPPERS
-MSGES6, //MSG_AUTO_HOME
-MSGES7, //MSG_SET_HOME_OFFSETS
-MSGES8, //MSG_SET_ORIGIN
-MSGES9, //MSG_PREHEAT_PLA
-MSGES10, //MSG_PREHEAT_PLA0
-MSGES11, //MSG_PREHEAT_PLA1
-MSGES12, //MSG_PREHEAT_PLA2
-MSGES13, //MSG_PREHEAT_PLA012
-MSGES14, //MSG_PREHEAT_PLA_BEDONLY
-MSGES15, //MSG_PREHEAT_PLA_SETTINGS
-MSGES16, //MSG_PREHEAT_ABS
-MSGES17, //MSG_PREHEAT_ABS0
-MSGES18, //MSG_PREHEAT_ABS1
-MSGES19, //MSG_PREHEAT_ABS2
-MSGES20, //MSG_PREHEAT_ABS012
-MSGES21, //MSG_PREHEAT_ABS_BEDONLY
-MSGES22, //MSG_PREHEAT_ABS_SETTINGS
-MSGES23, //MSG_COOLDOWN
-MSGES24, //MSG_SWITCH_PS_ON
-MSGES25, //MSG_SWITCH_PS_OFF
-MSGES26, //MSG_EXTRUDE
-MSGES27, //MSG_RETRACT
-MSGES28, //MSG_MOVE_AXIS
-MSGES29, //MSG_MOVE_X
-MSGES30, //MSG_MOVE_Y
-MSGES31, //MSG_MOVE_Z
-MSGES32, //MSG_MOVE_E
-MSGES33, //MSG_MOVE_E1
-MSGES34, //MSG_MOVE_E2
-MSGES35, //MSG_MOVE_01MM
-MSGES36, //MSG_MOVE_1MM
-MSGES37, //MSG_MOVE_10MM
-MSGES38, //MSG_SPEED
-MSGES39, //MSG_NOZZLE
-MSGES40, //MSG_NOZZLE1
-MSGES41, //MSG_NOZZLE2
-MSGES42, //MSG_BED
-MSGES43, //MSG_FAN_SPEED
-MSGES44, //MSG_FLOW
-MSGES45, //MSG_FLOW0
-MSGES46, //MSG_FLOW1
-MSGES47, //MSG_FLOW2
-MSGES48, //MSG_CONTROL
-MSGES49, //MSG_MIN
-MSGES50, //MSG_MAX
-MSGES51, //MSG_FACTOR
-MSGES52, //MSG_AUTOTEMP
-MSGES53, //MSG_ON
-MSGES54, //MSG_OFF
-MSGES55, //MSG_PID_P
-MSGES56, //MSG_PID_I
-MSGES57, //MSG_PID_D
-MSGES58, //MSG_PID_C
-MSGES59, //MSG_ACC
-MSGES60, //MSG_VXY_JERK
-MSGES61, //MSG_VZ_JERK
-MSGES62, //MSG_VE_JERK
-MSGES63, //MSG_VMAX
-MSGES64, //MSG_X
-MSGES65, //MSG_Y
-MSGES66, //MSG_Z
-MSGES67, //MSG_E
-MSGES68, //MSG_VMIN
-MSGES69, //MSG_VTRAV_MIN
-MSGES70, //MSG_AMAX
-MSGES71, //MSG_A_RETRACT
-MSGES72, //MSG_XSTEPS
-MSGES73, //MSG_YSTEPS
-MSGES74, //MSG_ZSTEPS
-MSGES75, //MSG_ESTEPS
-MSGES76, //MSG_TEMPERATURE
-MSGES77, //MSG_MOTION
-MSGES78, //MSG_VOLUMETRIC
-MSGES79, //MSG_VOLUMETRIC_ENABLED
-MSGES80, //MSG_FILAMENT_SIZE_EXTRUDER_0
-MSGES81, //MSG_FILAMENT_SIZE_EXTRUDER_1
-MSGES82, //MSG_FILAMENT_SIZE_EXTRUDER_2
-MSGES83, //MSG_CONTRAST
-MSGES84, //MSG_STORE_EPROM
-MSGES85, //MSG_LOAD_EPROM
-MSGES86, //MSG_RESTORE_FAILSAFE
-MSGES87, //MSG_REFRESH
-MSGES88, //MSG_WATCH
-MSGES89, //MSG_PREPARE
-MSGES90, //MSG_TUNE
-MSGES91, //MSG_PAUSE_PRINT
-MSGES92, //MSG_RESUME_PRINT
-MSGES93, //MSG_STOP_PRINT
-MSGES94, //MSG_CARD_MENU
-MSGES95, //MSG_NO_CARD
-MSGES96, //MSG_DWELL
-MSGES97, //MSG_USERWAIT
-MSGES98, //MSG_RESUMING
-MSGES99, //MSG_PRINT_ABORTED
-MSGES100, //MSG_NO_MOVE
-MSGES101, //MSG_KILLED
-MSGES102, //MSG_STOPPED
-MSGES103, //MSG_CONTROL_RETRACT
-MSGES104, //MSG_CONTROL_RETRACT_SWAP
-MSGES105, //MSG_CONTROL_RETRACTF
-MSGES106, //MSG_CONTROL_RETRACT_ZLIFT
-MSGES107, //MSG_CONTROL_RETRACT_RECOVER
-MSGES108, //MSG_CONTROL_RETRACT_RECOVER_SWAP
-MSGES109, //MSG_CONTROL_RETRACT_RECOVERF
-MSGES110, //MSG_AUTORETRACT
-MSGES111, //MSG_FILAMENTCHANGE
-MSGES112, //MSG_INIT_SDCARD
-MSGES113, //MSG_CNG_SDCARD
-MSGES114, //MSG_ZPROBE_OUT
-MSGES115, //MSG_POSITION_UNKNOWN
-MSGES116, //MSG_ZPROBE_ZOFFSET
-MSGES117, //MSG_BABYSTEP_X
-MSGES118, //MSG_BABYSTEP_Y
-MSGES119, //MSG_BABYSTEP_Z
-MSGES120, //MSG_ENDSTOP_ABORT
-MSGES121, //MSG_ADJUSTZ
-MSGES122, //MSG_PICK_Z
-MSGES123, //MSG_HOMEYZ
-MSGES124, //MSG_HOMEYZ_PROGRESS
-MSGES125, //MSG_HOMEYZ_DONE
-MSGES126, //MSG_SETTINGS
-MSGES127, //MSG_PREHEAT
-MSGES128, //MSG_UNLOAD_FILAMENT
-MSGES129, //MSG_LOAD_FILAMENT
-MSGES130, //MSG_RECTRACT
-MSGES131, //MSG_ERROR
-MSGES132, //MSG_PREHEAT_NOZZLE
-MSGES133, //MSG_SUPPORT
-MSGES134, //MSG_CORRECTLY
-MSGES135, //MSG_YES
-MSGES136, //MSG_NO
-MSGES137, //MSG_NOT_LOADED
-MSGES138, //MSG_NOT_COLOR
-MSGES139, //MSG_LOADING_FILAMENT
-MSGES140, //MSG_PLEASE_WAIT
-MSGES141, //MSG_LOADING_COLOR
-MSGES142, //MSG_CHANGE_SUCCESS
-MSGES143, //MSG_PRESS
-MSGES144, //MSG_INSERT_FILAMENT
-MSGES145, //MSG_CHANGING_FILAMENT
-MSGES146, //MSG_SILENT_MODE_ON
-MSGES147, //MSG_SILENT_MODE_OFF
-MSGES148, //MSG_REBOOT
-MSGES149, //MSG_TAKE_EFFECT
-MSGES150, //MSG_Enqueing
-MSGES151, //MSG_POWERUP
-MSGES152, //MSG_EXTERNAL_RESET
-MSGES153, //MSG_BROWNOUT_RESET
-MSGES154, //MSG_WATCHDOG_RESET
-MSGES155, //MSG_SOFTWARE_RESET
-MSGES156, //MSG_AUTHOR
-MSGES157, //MSG_CONFIGURATION_VER
-MSGES158, //MSG_FREE_MEMORY
-MSGES159, //MSG_PLANNER_BUFFER_BYTES
-MSGES160, //MSG_OK
-MSGES161, //MSG_FILE_SAVED
-MSGES162, //MSG_ERR_LINE_NO
-MSGES163, //MSG_ERR_CHECKSUM_MISMATCH
-MSGES164, //MSG_ERR_NO_CHECKSUM
-MSGES165, //MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM
-MSGES166, //MSG_FILE_PRINTED
-MSGES167, //MSG_BEGIN_FILE_LIST
-MSGES168, //MSG_END_FILE_LIST
-MSGES169, //MSG_M104_INVALID_EXTRUDER
-MSGES170, //MSG_M105_INVALID_EXTRUDER
-MSGES171, //MSG_M200_INVALID_EXTRUDER
-MSGES172, //MSG_M218_INVALID_EXTRUDER
-MSGES173, //MSG_M221_INVALID_EXTRUDER
-MSGES174, //MSG_ERR_NO_THERMISTORS
-MSGES175, //MSG_M109_INVALID_EXTRUDER
-MSGES176, //MSG_HEATING
-MSGES177, //MSG_HEATING_COMPLETE
-MSGES178, //MSG_BED_HEATING
-MSGES179, //MSG_BED_DONE
-MSGES180, //MSG_M115_REPORT
-MSGES181, //MSG_COUNT_X
-MSGES182, //MSG_ERR_KILLED
-MSGES183, //MSG_ERR_STOPPED
-MSGES184, //MSG_RESEND
-MSGES185, //MSG_UNKNOWN_COMMAND
-MSGES186, //MSG_ACTIVE_EXTRUDER
-MSGES187, //MSG_INVALID_EXTRUDER
-MSGES188, //MSG_X_MIN
-MSGES189, //MSG_X_MAX
-MSGES190, //MSG_Y_MIN
-MSGES191, //MSG_Y_MAX
-MSGES192, //MSG_Z_MIN
-MSGES193, //MSG_Z_MAX
-MSGES194, //MSG_M119_REPORT
-MSGES195, //MSG_ENDSTOP_HIT
-MSGES196, //MSG_ENDSTOP_OPEN
-MSGES197, //MSG_HOTEND_OFFSET
-MSGES198, //MSG_SD_CANT_OPEN_SUBDIR
-MSGES199, //MSG_SD_INIT_FAIL
-MSGES200, //MSG_SD_VOL_INIT_FAIL
-MSGES201, //MSG_SD_OPENROOT_FAIL
-MSGES202, //MSG_SD_CARD_OK
-MSGES203, //MSG_SD_WORKDIR_FAIL
-MSGES204, //MSG_SD_OPEN_FILE_FAIL
-MSGES205, //MSG_SD_FILE_OPENED
-MSGES206, //MSG_SD_SIZE
-MSGES207, //MSG_SD_FILE_SELECTED
-MSGES208, //MSG_SD_WRITE_TO_FILE
-MSGES209, //MSG_SD_PRINTING_BYTE
-MSGES210, //MSG_SD_NOT_PRINTING
-MSGES211, //MSG_SD_ERR_WRITE_TO_FILE
-MSGES212, //MSG_SD_CANT_ENTER_SUBDIR
-MSGES213, //MSG_STEPPER_TOO_HIGH
-MSGES214, //MSG_ENDSTOPS_HIT
-MSGES215, //MSG_ERR_COLD_EXTRUDE_STOP
-MSGES216, //MSG_ERR_LONG_EXTRUDE_STOP
-MSGES217, //MSG_BABYSTEPPING_X
-MSGES218, //MSG_BABYSTEPPING_Y
-MSGES219, //MSG_BABYSTEPPING_Z
-MSGES220, //MSG_SERIAL_ERROR_MENU_STRUCTURE
-MSGES221, //MSG_LANGUAGE_NAME
-MSGES222, //MSG_LANGUAGE_SELECT
-MSGES223, //MSG_PRUSA3D
-MSGES224, //MSG_PRUSA3D_FORUM
-MSGES225, //MSG_PRUSA3D_HOWTO
-MSGES226, //MSG_SELFTEST_ERROR
-MSGES227, //MSG_SELFTEST_PLEASECHECK
-MSGES228, //MSG_SELFTEST_NOTCONNECTED
-MSGES229, //MSG_SELFTEST_HEATERTHERMISTOR
-MSGES230, //MSG_SELFTEST_BEDHEATER
-MSGES231, //MSG_SELFTEST_WIRINGERROR
-MSGES232, //MSG_SELFTEST_ENDSTOPS
-MSGES233, //MSG_SELFTEST_MOTOR
-MSGES234, //MSG_SELFTEST_ENDSTOP
-MSGES235, //MSG_SELFTEST_ENDSTOP_NOTHIT
-MSGES236, //MSG_SELFTEST_OK
-MSGES237, //MSG_STATS_TOTALFILAMENT
-MSGES238, //MSG_STATS_TOTALPRINTTIME
-MSGES239, //MSG_STATS_FILAMENTUSED
-MSGES240, //MSG_STATS_PRINTTIME
-MSGES241, //MSG_SELFTEST_START
-MSGES242, //MSG_SELFTEST_CHECK_ENDSTOPS
-MSGES243, //MSG_SELFTEST_CHECK_HOTEND
-MSGES244, //MSG_SELFTEST_CHECK_X
-MSGES245, //MSG_SELFTEST_CHECK_Y
-MSGES246, //MSG_SELFTEST_CHECK_Z
-MSGES247, //MSG_SELFTEST_CHECK_BED
-MSGES248, //MSG_SELFTEST_CHECK_ALLCORRECT
-MSGES249, //MSG_SELFTEST
-MSGES250, //MSG_SELFTEST_FAILED
-MSGES251, //MSG_STATISTICS
-MSGES252, //MSG_USB_PRINTING
-};
-const char* MSGPL[]  = {MSGPL0, //WELCOME_MSG
-MSGPL1, //MSG_SD_INSERTED
-MSGPL2, //MSG_SD_REMOVED
-MSGPL3, //MSG_MAIN
-MSGPL4, //MSG_AUTOSTART
-MSGPL5, //MSG_DISABLE_STEPPERS
-MSGPL6, //MSG_AUTO_HOME
-MSGPL7, //MSG_SET_HOME_OFFSETS
-MSGPL8, //MSG_SET_ORIGIN
-MSGPL9, //MSG_PREHEAT_PLA
-MSGPL10, //MSG_PREHEAT_PLA0
-MSGPL11, //MSG_PREHEAT_PLA1
-MSGPL12, //MSG_PREHEAT_PLA2
-MSGPL13, //MSG_PREHEAT_PLA012
-MSGPL14, //MSG_PREHEAT_PLA_BEDONLY
-MSGPL15, //MSG_PREHEAT_PLA_SETTINGS
-MSGPL16, //MSG_PREHEAT_ABS
-MSGPL17, //MSG_PREHEAT_ABS0
-MSGPL18, //MSG_PREHEAT_ABS1
-MSGPL19, //MSG_PREHEAT_ABS2
-MSGPL20, //MSG_PREHEAT_ABS012
-MSGPL21, //MSG_PREHEAT_ABS_BEDONLY
-MSGPL22, //MSG_PREHEAT_ABS_SETTINGS
-MSGPL23, //MSG_COOLDOWN
-MSGPL24, //MSG_SWITCH_PS_ON
-MSGPL25, //MSG_SWITCH_PS_OFF
-MSGPL26, //MSG_EXTRUDE
-MSGPL27, //MSG_RETRACT
-MSGPL28, //MSG_MOVE_AXIS
-MSGPL29, //MSG_MOVE_X
-MSGPL30, //MSG_MOVE_Y
-MSGPL31, //MSG_MOVE_Z
-MSGPL32, //MSG_MOVE_E
-MSGPL33, //MSG_MOVE_E1
-MSGPL34, //MSG_MOVE_E2
-MSGPL35, //MSG_MOVE_01MM
-MSGPL36, //MSG_MOVE_1MM
-MSGPL37, //MSG_MOVE_10MM
-MSGPL38, //MSG_SPEED
-MSGPL39, //MSG_NOZZLE
-MSGPL40, //MSG_NOZZLE1
-MSGPL41, //MSG_NOZZLE2
-MSGPL42, //MSG_BED
-MSGPL43, //MSG_FAN_SPEED
-MSGPL44, //MSG_FLOW
-MSGPL45, //MSG_FLOW0
-MSGPL46, //MSG_FLOW1
-MSGPL47, //MSG_FLOW2
-MSGPL48, //MSG_CONTROL
-MSGPL49, //MSG_MIN
-MSGPL50, //MSG_MAX
-MSGPL51, //MSG_FACTOR
-MSGPL52, //MSG_AUTOTEMP
-MSGPL53, //MSG_ON
-MSGPL54, //MSG_OFF
-MSGPL55, //MSG_PID_P
-MSGPL56, //MSG_PID_I
-MSGPL57, //MSG_PID_D
-MSGPL58, //MSG_PID_C
-MSGPL59, //MSG_ACC
-MSGPL60, //MSG_VXY_JERK
-MSGPL61, //MSG_VZ_JERK
-MSGPL62, //MSG_VE_JERK
-MSGPL63, //MSG_VMAX
-MSGPL64, //MSG_X
-MSGPL65, //MSG_Y
-MSGPL66, //MSG_Z
-MSGPL67, //MSG_E
-MSGPL68, //MSG_VMIN
-MSGPL69, //MSG_VTRAV_MIN
-MSGPL70, //MSG_AMAX
-MSGPL71, //MSG_A_RETRACT
-MSGPL72, //MSG_XSTEPS
-MSGPL73, //MSG_YSTEPS
-MSGPL74, //MSG_ZSTEPS
-MSGPL75, //MSG_ESTEPS
-MSGPL76, //MSG_TEMPERATURE
-MSGPL77, //MSG_MOTION
-MSGPL78, //MSG_VOLUMETRIC
-MSGPL79, //MSG_VOLUMETRIC_ENABLED
-MSGPL80, //MSG_FILAMENT_SIZE_EXTRUDER_0
-MSGPL81, //MSG_FILAMENT_SIZE_EXTRUDER_1
-MSGPL82, //MSG_FILAMENT_SIZE_EXTRUDER_2
-MSGPL83, //MSG_CONTRAST
-MSGPL84, //MSG_STORE_EPROM
-MSGPL85, //MSG_LOAD_EPROM
-MSGPL86, //MSG_RESTORE_FAILSAFE
-MSGPL87, //MSG_REFRESH
-MSGPL88, //MSG_WATCH
-MSGPL89, //MSG_PREPARE
-MSGPL90, //MSG_TUNE
-MSGPL91, //MSG_PAUSE_PRINT
-MSGPL92, //MSG_RESUME_PRINT
-MSGPL93, //MSG_STOP_PRINT
-MSGPL94, //MSG_CARD_MENU
-MSGPL95, //MSG_NO_CARD
-MSGPL96, //MSG_DWELL
-MSGPL97, //MSG_USERWAIT
-MSGPL98, //MSG_RESUMING
-MSGPL99, //MSG_PRINT_ABORTED
-MSGPL100, //MSG_NO_MOVE
-MSGPL101, //MSG_KILLED
-MSGPL102, //MSG_STOPPED
-MSGPL103, //MSG_CONTROL_RETRACT
-MSGPL104, //MSG_CONTROL_RETRACT_SWAP
-MSGPL105, //MSG_CONTROL_RETRACTF
-MSGPL106, //MSG_CONTROL_RETRACT_ZLIFT
-MSGPL107, //MSG_CONTROL_RETRACT_RECOVER
-MSGPL108, //MSG_CONTROL_RETRACT_RECOVER_SWAP
-MSGPL109, //MSG_CONTROL_RETRACT_RECOVERF
-MSGPL110, //MSG_AUTORETRACT
-MSGPL111, //MSG_FILAMENTCHANGE
-MSGPL112, //MSG_INIT_SDCARD
-MSGPL113, //MSG_CNG_SDCARD
-MSGPL114, //MSG_ZPROBE_OUT
-MSGPL115, //MSG_POSITION_UNKNOWN
-MSGPL116, //MSG_ZPROBE_ZOFFSET
-MSGPL117, //MSG_BABYSTEP_X
-MSGPL118, //MSG_BABYSTEP_Y
-MSGPL119, //MSG_BABYSTEP_Z
-MSGPL120, //MSG_ENDSTOP_ABORT
-MSGPL121, //MSG_ADJUSTZ
-MSGPL122, //MSG_PICK_Z
-MSGPL123, //MSG_HOMEYZ
-MSGPL124, //MSG_HOMEYZ_PROGRESS
-MSGPL125, //MSG_HOMEYZ_DONE
-MSGPL126, //MSG_SETTINGS
-MSGPL127, //MSG_PREHEAT
-MSGPL128, //MSG_UNLOAD_FILAMENT
-MSGPL129, //MSG_LOAD_FILAMENT
-MSGPL130, //MSG_RECTRACT
-MSGPL131, //MSG_ERROR
-MSGPL132, //MSG_PREHEAT_NOZZLE
-MSGPL133, //MSG_SUPPORT
-MSGPL134, //MSG_CORRECTLY
-MSGPL135, //MSG_YES
-MSGPL136, //MSG_NO
-MSGPL137, //MSG_NOT_LOADED
-MSGPL138, //MSG_NOT_COLOR
-MSGPL139, //MSG_LOADING_FILAMENT
-MSGPL140, //MSG_PLEASE_WAIT
-MSGPL141, //MSG_LOADING_COLOR
-MSGPL142, //MSG_CHANGE_SUCCESS
-MSGPL143, //MSG_PRESS
-MSGPL144, //MSG_INSERT_FILAMENT
-MSGPL145, //MSG_CHANGING_FILAMENT
-MSGPL146, //MSG_SILENT_MODE_ON
-MSGPL147, //MSG_SILENT_MODE_OFF
-MSGPL148, //MSG_REBOOT
-MSGPL149, //MSG_TAKE_EFFECT
-MSGPL150, //MSG_Enqueing
-MSGPL151, //MSG_POWERUP
-MSGPL152, //MSG_EXTERNAL_RESET
-MSGPL153, //MSG_BROWNOUT_RESET
-MSGPL154, //MSG_WATCHDOG_RESET
-MSGPL155, //MSG_SOFTWARE_RESET
-MSGPL156, //MSG_AUTHOR
-MSGPL157, //MSG_CONFIGURATION_VER
-MSGPL158, //MSG_FREE_MEMORY
-MSGPL159, //MSG_PLANNER_BUFFER_BYTES
-MSGPL160, //MSG_OK
-MSGPL161, //MSG_FILE_SAVED
-MSGPL162, //MSG_ERR_LINE_NO
-MSGPL163, //MSG_ERR_CHECKSUM_MISMATCH
-MSGPL164, //MSG_ERR_NO_CHECKSUM
-MSGPL165, //MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM
-MSGPL166, //MSG_FILE_PRINTED
-MSGPL167, //MSG_BEGIN_FILE_LIST
-MSGPL168, //MSG_END_FILE_LIST
-MSGPL169, //MSG_M104_INVALID_EXTRUDER
-MSGPL170, //MSG_M105_INVALID_EXTRUDER
-MSGPL171, //MSG_M200_INVALID_EXTRUDER
-MSGPL172, //MSG_M218_INVALID_EXTRUDER
-MSGPL173, //MSG_M221_INVALID_EXTRUDER
-MSGPL174, //MSG_ERR_NO_THERMISTORS
-MSGPL175, //MSG_M109_INVALID_EXTRUDER
-MSGPL176, //MSG_HEATING
-MSGPL177, //MSG_HEATING_COMPLETE
-MSGPL178, //MSG_BED_HEATING
-MSGPL179, //MSG_BED_DONE
-MSGPL180, //MSG_M115_REPORT
-MSGPL181, //MSG_COUNT_X
-MSGPL182, //MSG_ERR_KILLED
-MSGPL183, //MSG_ERR_STOPPED
-MSGPL184, //MSG_RESEND
-MSGPL185, //MSG_UNKNOWN_COMMAND
-MSGPL186, //MSG_ACTIVE_EXTRUDER
-MSGPL187, //MSG_INVALID_EXTRUDER
-MSGPL188, //MSG_X_MIN
-MSGPL189, //MSG_X_MAX
-MSGPL190, //MSG_Y_MIN
-MSGPL191, //MSG_Y_MAX
-MSGPL192, //MSG_Z_MIN
-MSGPL193, //MSG_Z_MAX
-MSGPL194, //MSG_M119_REPORT
-MSGPL195, //MSG_ENDSTOP_HIT
-MSGPL196, //MSG_ENDSTOP_OPEN
-MSGPL197, //MSG_HOTEND_OFFSET
-MSGPL198, //MSG_SD_CANT_OPEN_SUBDIR
-MSGPL199, //MSG_SD_INIT_FAIL
-MSGPL200, //MSG_SD_VOL_INIT_FAIL
-MSGPL201, //MSG_SD_OPENROOT_FAIL
-MSGPL202, //MSG_SD_CARD_OK
-MSGPL203, //MSG_SD_WORKDIR_FAIL
-MSGPL204, //MSG_SD_OPEN_FILE_FAIL
-MSGPL205, //MSG_SD_FILE_OPENED
-MSGPL206, //MSG_SD_SIZE
-MSGPL207, //MSG_SD_FILE_SELECTED
-MSGPL208, //MSG_SD_WRITE_TO_FILE
-MSGPL209, //MSG_SD_PRINTING_BYTE
-MSGPL210, //MSG_SD_NOT_PRINTING
-MSGPL211, //MSG_SD_ERR_WRITE_TO_FILE
-MSGPL212, //MSG_SD_CANT_ENTER_SUBDIR
-MSGPL213, //MSG_STEPPER_TOO_HIGH
-MSGPL214, //MSG_ENDSTOPS_HIT
-MSGPL215, //MSG_ERR_COLD_EXTRUDE_STOP
-MSGPL216, //MSG_ERR_LONG_EXTRUDE_STOP
-MSGPL217, //MSG_BABYSTEPPING_X
-MSGPL218, //MSG_BABYSTEPPING_Y
-MSGPL219, //MSG_BABYSTEPPING_Z
-MSGPL220, //MSG_SERIAL_ERROR_MENU_STRUCTURE
-MSGPL221, //MSG_LANGUAGE_NAME
-MSGPL222, //MSG_LANGUAGE_SELECT
-MSGPL223, //MSG_PRUSA3D
-MSGPL224, //MSG_PRUSA3D_FORUM
-MSGPL225, //MSG_PRUSA3D_HOWTO
-MSGPL226, //MSG_SELFTEST_ERROR
-MSGPL227, //MSG_SELFTEST_PLEASECHECK
-MSGPL228, //MSG_SELFTEST_NOTCONNECTED
-MSGPL229, //MSG_SELFTEST_HEATERTHERMISTOR
-MSGPL230, //MSG_SELFTEST_BEDHEATER
-MSGPL231, //MSG_SELFTEST_WIRINGERROR
-MSGPL232, //MSG_SELFTEST_ENDSTOPS
-MSGPL233, //MSG_SELFTEST_MOTOR
-MSGPL234, //MSG_SELFTEST_ENDSTOP
-MSGPL235, //MSG_SELFTEST_ENDSTOP_NOTHIT
-MSGPL236, //MSG_SELFTEST_OK
-MSGPL237, //MSG_STATS_TOTALFILAMENT
-MSGPL238, //MSG_STATS_TOTALPRINTTIME
-MSGPL239, //MSG_STATS_FILAMENTUSED
-MSGPL240, //MSG_STATS_PRINTTIME
-MSGPL241, //MSG_SELFTEST_START
-MSGPL242, //MSG_SELFTEST_CHECK_ENDSTOPS
-MSGPL243, //MSG_SELFTEST_CHECK_HOTEND
-MSGPL244, //MSG_SELFTEST_CHECK_X
-MSGPL245, //MSG_SELFTEST_CHECK_Y
-MSGPL246, //MSG_SELFTEST_CHECK_Z
-MSGPL247, //MSG_SELFTEST_CHECK_BED
-MSGPL248, //MSG_SELFTEST_CHECK_ALLCORRECT
-MSGPL249, //MSG_SELFTEST
-MSGPL250, //MSG_SELFTEST_FAILED
-MSGPL251, //MSG_STATISTICS
-MSGPL252, //MSG_USB_PRINTING
-};
-
-
-const char** MSG_ALL[] = {MSGEN,MSGCZ,MSGIT,MSGES,MSGPL};
-char langbuffer[LCD_WIDTH+1];
-char* CAT2(const char *s1,const char *s2) {
-  unsigned char len=0;
-  strncpy_P(langbuffer+len,s1,LCD_WIDTH-len);
-  len+=strlen_P(s1);
-  strncpy_P(langbuffer+len,s2,LCD_WIDTH-len);
-  return langbuffer;
-}
-char* CAT4(const char *s1,const char *s2,const char *s3,const char *s4) {
-  unsigned char len=0;
-  strncpy_P(langbuffer+len,s1,LCD_WIDTH-len);
-  len+=strlen_P(s1);
-  strncpy_P(langbuffer+len,s2,LCD_WIDTH-len);
-  len+=strlen_P(s2);
-  strncpy_P(langbuffer+len,s3,LCD_WIDTH-len);
-  len+=strlen_P(s3);
-  strncpy_P(langbuffer+len,s4,LCD_WIDTH-len);
-  return langbuffer;
-}
-
-
-
+#include <avr/pgmspace.h>
+#include "configuration_prusa.h"
+#include "language_all.h"
+
+#define LCD_WIDTH 20
+extern unsigned char lang_selected;
+
+const char MSG_ACC_EN[] PROGMEM = "Accel";
+const char MSG_ACC_CZ[] PROGMEM = "Accel";
+const char MSG_ACC_IT[] PROGMEM = "Accel";
+const char MSG_ACC_ES[] PROGMEM = "Accel";
+const char MSG_ACC_PL[] PROGMEM = "Accel";
+const char * const MSG_ACC_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ACC_EN,
+	MSG_ACC_CZ,
+	MSG_ACC_IT,
+	MSG_ACC_ES,
+	MSG_ACC_PL
+};
+
+const char MSG_ACTIVE_EXTRUDER_EN[] PROGMEM = "Active Extruder: ";
+const char MSG_ACTIVE_EXTRUDER_CZ[] PROGMEM = "Active Extruder: ";
+const char MSG_ACTIVE_EXTRUDER_IT[] PROGMEM = "Active Extruder: ";
+const char MSG_ACTIVE_EXTRUDER_ES[] PROGMEM = "Active Extruder: ";
+const char MSG_ACTIVE_EXTRUDER_PL[] PROGMEM = "Active Extruder: ";
+const char * const MSG_ACTIVE_EXTRUDER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ACTIVE_EXTRUDER_EN,
+	MSG_ACTIVE_EXTRUDER_CZ,
+	MSG_ACTIVE_EXTRUDER_IT,
+	MSG_ACTIVE_EXTRUDER_ES,
+	MSG_ACTIVE_EXTRUDER_PL
+};
+
+const char MSG_ADJUSTZ_EN[] PROGMEM = "Auto adjust Z ?";
+const char MSG_ADJUSTZ_CZ[] PROGMEM = "Auto doladit Z ?";
+const char MSG_ADJUSTZ_IT[] PROGMEM = "Auto regolare Z ?";
+const char MSG_ADJUSTZ_ES[] PROGMEM = "Auto Micropaso Z?";
+const char MSG_ADJUSTZ_PL[] PROGMEM = "Autodostroic Z?";
+const char * const MSG_ADJUSTZ_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ADJUSTZ_EN,
+	MSG_ADJUSTZ_CZ,
+	MSG_ADJUSTZ_IT,
+	MSG_ADJUSTZ_ES,
+	MSG_ADJUSTZ_PL
+};
+
+const char MSG_AMAX_EN[] PROGMEM = "Amax ";
+const char MSG_AMAX_CZ[] PROGMEM = "Amax ";
+const char MSG_AMAX_IT[] PROGMEM = "Amax ";
+const char MSG_AMAX_ES[] PROGMEM = "Amax ";
+const char MSG_AMAX_PL[] PROGMEM = "Amax ";
+const char * const MSG_AMAX_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_AMAX_EN,
+	MSG_AMAX_CZ,
+	MSG_AMAX_IT,
+	MSG_AMAX_ES,
+	MSG_AMAX_PL
+};
+
+const char MSG_AUTHOR_EN[] PROGMEM = " | Author: ";
+const char MSG_AUTHOR_CZ[] PROGMEM = " | Author: ";
+const char MSG_AUTHOR_IT[] PROGMEM = " | Author: ";
+const char MSG_AUTHOR_ES[] PROGMEM = " | Author: ";
+const char MSG_AUTHOR_PL[] PROGMEM = " | Author: ";
+const char * const MSG_AUTHOR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_AUTHOR_EN,
+	MSG_AUTHOR_CZ,
+	MSG_AUTHOR_IT,
+	MSG_AUTHOR_ES,
+	MSG_AUTHOR_PL
+};
+
+const char MSG_AUTORETRACT_EN[] PROGMEM = "AutoRetr.";
+const char MSG_AUTORETRACT_CZ[] PROGMEM = "AutoRetr.";
+const char MSG_AUTORETRACT_IT[] PROGMEM = "AutoRetr.";
+const char MSG_AUTORETRACT_ES[] PROGMEM = "AutoRetr.";
+const char MSG_AUTORETRACT_PL[] PROGMEM = "AutoRetr.";
+const char * const MSG_AUTORETRACT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_AUTORETRACT_EN,
+	MSG_AUTORETRACT_CZ,
+	MSG_AUTORETRACT_IT,
+	MSG_AUTORETRACT_ES,
+	MSG_AUTORETRACT_PL
+};
+
+const char MSG_AUTOSTART_EN[] PROGMEM = "Autostart";
+const char MSG_AUTOSTART_CZ[] PROGMEM = "Autostart";
+const char MSG_AUTOSTART_IT[] PROGMEM = "Autostart";
+const char MSG_AUTOSTART_ES[] PROGMEM = "Autostart";
+const char MSG_AUTOSTART_PL[] PROGMEM = "Autostart";
+const char * const MSG_AUTOSTART_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_AUTOSTART_EN,
+	MSG_AUTOSTART_CZ,
+	MSG_AUTOSTART_IT,
+	MSG_AUTOSTART_ES,
+	MSG_AUTOSTART_PL
+};
+
+const char MSG_AUTOTEMP_EN[] PROGMEM = "Autotemp";
+const char MSG_AUTOTEMP_CZ[] PROGMEM = "Autotemp";
+const char MSG_AUTOTEMP_IT[] PROGMEM = "Autotemp";
+const char MSG_AUTOTEMP_ES[] PROGMEM = "Autotemp";
+const char MSG_AUTOTEMP_PL[] PROGMEM = "Autotemp";
+const char * const MSG_AUTOTEMP_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_AUTOTEMP_EN,
+	MSG_AUTOTEMP_CZ,
+	MSG_AUTOTEMP_IT,
+	MSG_AUTOTEMP_ES,
+	MSG_AUTOTEMP_PL
+};
+
+const char MSG_AUTO_HOME_EN[] PROGMEM = "Auto home";
+const char MSG_AUTO_HOME_CZ[] PROGMEM = "Auto home";
+const char MSG_AUTO_HOME_IT[] PROGMEM = "Auto Home";
+const char MSG_AUTO_HOME_ES[] PROGMEM = "Llevar al origen";
+const char MSG_AUTO_HOME_PL[] PROGMEM = "Auto home";
+const char * const MSG_AUTO_HOME_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_AUTO_HOME_EN,
+	MSG_AUTO_HOME_CZ,
+	MSG_AUTO_HOME_IT,
+	MSG_AUTO_HOME_ES,
+	MSG_AUTO_HOME_PL
+};
+
+const char MSG_A_RETRACT_EN[] PROGMEM = "A-retract";
+const char MSG_A_RETRACT_CZ[] PROGMEM = "A-retract";
+const char MSG_A_RETRACT_IT[] PROGMEM = "A-retract";
+const char MSG_A_RETRACT_ES[] PROGMEM = "A-retract";
+const char MSG_A_RETRACT_PL[] PROGMEM = "A-retract";
+const char * const MSG_A_RETRACT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_A_RETRACT_EN,
+	MSG_A_RETRACT_CZ,
+	MSG_A_RETRACT_IT,
+	MSG_A_RETRACT_ES,
+	MSG_A_RETRACT_PL
+};
+
+const char MSG_BABYSTEPPING_X_EN[] PROGMEM = "Babystepping X";
+const char MSG_BABYSTEPPING_X_CZ[] PROGMEM = "Babystepping X";
+const char MSG_BABYSTEPPING_X_IT[] PROGMEM = "Babystepping X";
+const char MSG_BABYSTEPPING_X_ES[] PROGMEM = "Babystepping X";
+const char MSG_BABYSTEPPING_X_PL[] PROGMEM = "Babystepping X";
+const char * const MSG_BABYSTEPPING_X_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BABYSTEPPING_X_EN,
+	MSG_BABYSTEPPING_X_CZ,
+	MSG_BABYSTEPPING_X_IT,
+	MSG_BABYSTEPPING_X_ES,
+	MSG_BABYSTEPPING_X_PL
+};
+
+const char MSG_BABYSTEPPING_Y_EN[] PROGMEM = "Babystepping Y";
+const char MSG_BABYSTEPPING_Y_CZ[] PROGMEM = "Babystepping Y";
+const char MSG_BABYSTEPPING_Y_IT[] PROGMEM = "Babystepping Y";
+const char MSG_BABYSTEPPING_Y_ES[] PROGMEM = "Babystepping Y";
+const char MSG_BABYSTEPPING_Y_PL[] PROGMEM = "Babystepping Y";
+const char * const MSG_BABYSTEPPING_Y_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BABYSTEPPING_Y_EN,
+	MSG_BABYSTEPPING_Y_CZ,
+	MSG_BABYSTEPPING_Y_IT,
+	MSG_BABYSTEPPING_Y_ES,
+	MSG_BABYSTEPPING_Y_PL
+};
+
+const char MSG_BABYSTEPPING_Z_EN[] PROGMEM = "Adjusting Z";
+const char MSG_BABYSTEPPING_Z_CZ[] PROGMEM = "Dostavovani Z";
+const char MSG_BABYSTEPPING_Z_IT[] PROGMEM = "Adjusting Z";
+const char MSG_BABYSTEPPING_Z_ES[] PROGMEM = "Adjusting Z";
+const char MSG_BABYSTEPPING_Z_PL[] PROGMEM = "Dostavovani Z";
+const char * const MSG_BABYSTEPPING_Z_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BABYSTEPPING_Z_EN,
+	MSG_BABYSTEPPING_Z_CZ,
+	MSG_BABYSTEPPING_Z_IT,
+	MSG_BABYSTEPPING_Z_ES,
+	MSG_BABYSTEPPING_Z_PL
+};
+
+const char MSG_BABYSTEP_X_EN[] PROGMEM = "Babystep X";
+const char MSG_BABYSTEP_X_CZ[] PROGMEM = "Babystep X";
+const char MSG_BABYSTEP_X_IT[] PROGMEM = "Babystep X";
+const char MSG_BABYSTEP_X_ES[] PROGMEM = "Babystep X";
+const char MSG_BABYSTEP_X_PL[] PROGMEM = "Babystep X";
+const char * const MSG_BABYSTEP_X_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BABYSTEP_X_EN,
+	MSG_BABYSTEP_X_CZ,
+	MSG_BABYSTEP_X_IT,
+	MSG_BABYSTEP_X_ES,
+	MSG_BABYSTEP_X_PL
+};
+
+const char MSG_BABYSTEP_Y_EN[] PROGMEM = "Babystep Y";
+const char MSG_BABYSTEP_Y_CZ[] PROGMEM = "Babystep Y";
+const char MSG_BABYSTEP_Y_IT[] PROGMEM = "Babystep Y";
+const char MSG_BABYSTEP_Y_ES[] PROGMEM = "Babystep Y";
+const char MSG_BABYSTEP_Y_PL[] PROGMEM = "Babystep Y";
+const char * const MSG_BABYSTEP_Y_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BABYSTEP_Y_EN,
+	MSG_BABYSTEP_Y_CZ,
+	MSG_BABYSTEP_Y_IT,
+	MSG_BABYSTEP_Y_ES,
+	MSG_BABYSTEP_Y_PL
+};
+
+const char MSG_BABYSTEP_Z_EN[] PROGMEM = "Live adjust Z";
+const char MSG_BABYSTEP_Z_CZ[] PROGMEM = "Doladeni osy Z";
+const char MSG_BABYSTEP_Z_IT[] PROGMEM = "Babystep Z";
+const char MSG_BABYSTEP_Z_ES[] PROGMEM = "Micropaso Z";
+const char MSG_BABYSTEP_Z_PL[] PROGMEM = "Dostrojenie osy Z";
+const char * const MSG_BABYSTEP_Z_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BABYSTEP_Z_EN,
+	MSG_BABYSTEP_Z_CZ,
+	MSG_BABYSTEP_Z_IT,
+	MSG_BABYSTEP_Z_ES,
+	MSG_BABYSTEP_Z_PL
+};
+
+const char MSG_BED_EN[] PROGMEM = "Bed";
+const char MSG_BED_CZ[] PROGMEM = "Bed";
+const char MSG_BED_IT[] PROGMEM = "Piatto";
+const char MSG_BED_ES[] PROGMEM = "Base";
+const char MSG_BED_PL[] PROGMEM = "Stolik";
+const char * const MSG_BED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BED_EN,
+	MSG_BED_CZ,
+	MSG_BED_IT,
+	MSG_BED_ES,
+	MSG_BED_PL
+};
+
+const char MSG_BED_DONE_EN[] PROGMEM = "Bed done";
+const char MSG_BED_DONE_CZ[] PROGMEM = "Bed OK.";
+const char MSG_BED_DONE_IT[] PROGMEM = "Piatto fatto.";
+const char MSG_BED_DONE_ES[] PROGMEM = "Base listo.";
+const char MSG_BED_DONE_PL[] PROGMEM = "Stolik OK.";
+const char * const MSG_BED_DONE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BED_DONE_EN,
+	MSG_BED_DONE_CZ,
+	MSG_BED_DONE_IT,
+	MSG_BED_DONE_ES,
+	MSG_BED_DONE_PL
+};
+
+const char MSG_BED_HEATING_EN[] PROGMEM = "Bed Heating";
+const char MSG_BED_HEATING_CZ[] PROGMEM = "Zahrivani bed";
+const char MSG_BED_HEATING_IT[] PROGMEM = "Piatto riscaldam.";
+const char MSG_BED_HEATING_ES[] PROGMEM = "Base Calentando";
+const char MSG_BED_HEATING_PL[] PROGMEM = "Grzanie stolika..";
+const char * const MSG_BED_HEATING_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BED_HEATING_EN,
+	MSG_BED_HEATING_CZ,
+	MSG_BED_HEATING_IT,
+	MSG_BED_HEATING_ES,
+	MSG_BED_HEATING_PL
+};
+
+const char MSG_BEGIN_FILE_LIST_EN[] PROGMEM = "Begin file list";
+const char MSG_BEGIN_FILE_LIST_CZ[] PROGMEM = "Begin file list";
+const char MSG_BEGIN_FILE_LIST_IT[] PROGMEM = "Begin file list";
+const char MSG_BEGIN_FILE_LIST_ES[] PROGMEM = "Begin file list";
+const char MSG_BEGIN_FILE_LIST_PL[] PROGMEM = "Begin file list";
+const char * const MSG_BEGIN_FILE_LIST_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BEGIN_FILE_LIST_EN,
+	MSG_BEGIN_FILE_LIST_CZ,
+	MSG_BEGIN_FILE_LIST_IT,
+	MSG_BEGIN_FILE_LIST_ES,
+	MSG_BEGIN_FILE_LIST_PL
+};
+
+const char MSG_BROWNOUT_RESET_EN[] PROGMEM = " Brown out Reset";
+const char MSG_BROWNOUT_RESET_CZ[] PROGMEM = " Brown out Reset";
+const char MSG_BROWNOUT_RESET_IT[] PROGMEM = " Brown out Reset";
+const char MSG_BROWNOUT_RESET_ES[] PROGMEM = " Brown out Reset";
+const char MSG_BROWNOUT_RESET_PL[] PROGMEM = " Brown out Reset";
+const char * const MSG_BROWNOUT_RESET_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_BROWNOUT_RESET_EN,
+	MSG_BROWNOUT_RESET_CZ,
+	MSG_BROWNOUT_RESET_IT,
+	MSG_BROWNOUT_RESET_ES,
+	MSG_BROWNOUT_RESET_PL
+};
+
+const char MSG_CALIBRATE_BED_EN[] PROGMEM = "Calibrate bed";
+const char MSG_CALIBRATE_BED_CZ[] PROGMEM = "Calibrate bed";
+const char MSG_CALIBRATE_BED_IT[] PROGMEM = "Calibrate bed";
+const char MSG_CALIBRATE_BED_ES[] PROGMEM = "Calibrate bed";
+const char MSG_CALIBRATE_BED_PL[] PROGMEM = "Calibrate bed";
+const char * const MSG_CALIBRATE_BED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CALIBRATE_BED_EN,
+	MSG_CALIBRATE_BED_CZ,
+	MSG_CALIBRATE_BED_IT,
+	MSG_CALIBRATE_BED_ES,
+	MSG_CALIBRATE_BED_PL
+};
+
+const char MSG_CALIBRATE_BED_RESET_EN[] PROGMEM = "Reset bed calibration";
+const char MSG_CALIBRATE_BED_RESET_CZ[] PROGMEM = "Reset bed calibration";
+const char MSG_CALIBRATE_BED_RESET_IT[] PROGMEM = "Reset bed calibration";
+const char MSG_CALIBRATE_BED_RESET_ES[] PROGMEM = "Reset bed calibration";
+const char MSG_CALIBRATE_BED_RESET_PL[] PROGMEM = "Reset bed calibration";
+const char * const MSG_CALIBRATE_BED_RESET_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CALIBRATE_BED_RESET_EN,
+	MSG_CALIBRATE_BED_RESET_CZ,
+	MSG_CALIBRATE_BED_RESET_IT,
+	MSG_CALIBRATE_BED_RESET_ES,
+	MSG_CALIBRATE_BED_RESET_PL
+};
+
+const char MSG_CARD_MENU_EN[] PROGMEM = "Print from SD";
+const char MSG_CARD_MENU_CZ[] PROGMEM = "Tisk z SD";
+const char MSG_CARD_MENU_IT[] PROGMEM = "Menu SD Carta";
+const char MSG_CARD_MENU_ES[] PROGMEM = "Menu de SD";
+const char MSG_CARD_MENU_PL[] PROGMEM = "Druk z SD";
+const char * const MSG_CARD_MENU_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CARD_MENU_EN,
+	MSG_CARD_MENU_CZ,
+	MSG_CARD_MENU_IT,
+	MSG_CARD_MENU_ES,
+	MSG_CARD_MENU_PL
+};
+
+const char MSG_CHANGE_SUCCESS_EN[] PROGMEM = "Change success!";
+const char MSG_CHANGE_SUCCESS_CZ[] PROGMEM = "Zmena uspesna!";
+const char MSG_CHANGE_SUCCESS_IT[] PROGMEM = "Cambia. riuscito!";
+const char MSG_CHANGE_SUCCESS_ES[] PROGMEM = "Cambiar bien!";
+const char MSG_CHANGE_SUCCESS_PL[] PROGMEM = "Wymiana ok!";
+const char * const MSG_CHANGE_SUCCESS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CHANGE_SUCCESS_EN,
+	MSG_CHANGE_SUCCESS_CZ,
+	MSG_CHANGE_SUCCESS_IT,
+	MSG_CHANGE_SUCCESS_ES,
+	MSG_CHANGE_SUCCESS_PL
+};
+
+const char MSG_CHANGING_FILAMENT_EN[] PROGMEM = "Changing filament!";
+const char MSG_CHANGING_FILAMENT_CZ[] PROGMEM = "Vymena filamentu!";
+const char MSG_CHANGING_FILAMENT_IT[] PROGMEM = "Mutevole fil.!";
+const char MSG_CHANGING_FILAMENT_ES[] PROGMEM = "Cambiando fil.!";
+const char MSG_CHANGING_FILAMENT_PL[] PROGMEM = "Wymiana filamentu";
+const char * const MSG_CHANGING_FILAMENT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CHANGING_FILAMENT_EN,
+	MSG_CHANGING_FILAMENT_CZ,
+	MSG_CHANGING_FILAMENT_IT,
+	MSG_CHANGING_FILAMENT_ES,
+	MSG_CHANGING_FILAMENT_PL
+};
+
+const char MSG_CNG_SDCARD_EN[] PROGMEM = "Change SD card";
+const char MSG_CNG_SDCARD_CZ[] PROGMEM = "Vymenit SD";
+const char MSG_CNG_SDCARD_IT[] PROGMEM = "Change SD card";
+const char MSG_CNG_SDCARD_ES[] PROGMEM = "Change SD card";
+const char MSG_CNG_SDCARD_PL[] PROGMEM = "Vymenit SD";
+const char * const MSG_CNG_SDCARD_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CNG_SDCARD_EN,
+	MSG_CNG_SDCARD_CZ,
+	MSG_CNG_SDCARD_IT,
+	MSG_CNG_SDCARD_ES,
+	MSG_CNG_SDCARD_PL
+};
+
+const char MSG_CONFIGURATION_VER_EN[] PROGMEM = " Last Updated: ";
+const char MSG_CONFIGURATION_VER_CZ[] PROGMEM = " Last Updated: ";
+const char MSG_CONFIGURATION_VER_IT[] PROGMEM = " Last Updated: ";
+const char MSG_CONFIGURATION_VER_ES[] PROGMEM = " Last Updated: ";
+const char MSG_CONFIGURATION_VER_PL[] PROGMEM = " Last Updated: ";
+const char * const MSG_CONFIGURATION_VER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONFIGURATION_VER_EN,
+	MSG_CONFIGURATION_VER_CZ,
+	MSG_CONFIGURATION_VER_IT,
+	MSG_CONFIGURATION_VER_ES,
+	MSG_CONFIGURATION_VER_PL
+};
+
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_EN[] PROGMEM = "Are both left and right Z carriages";
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_CZ[] PROGMEM = "Are both left and right Z carriages";
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_IT[] PROGMEM = "Are both left and right Z carriages";
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_ES[] PROGMEM = "Are both left and right Z carriages";
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_PL[] PROGMEM = "Are both left and right Z carriages";
+const char * const MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_EN,
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_CZ,
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_IT,
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_ES,
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_PL
+};
+
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_EN[] PROGMEM = "touching the end stops?";
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_CZ[] PROGMEM = "touching the end stops?";
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_IT[] PROGMEM = "touching the end stops?";
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_ES[] PROGMEM = "touching the end stops?";
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_PL[] PROGMEM = "touching the end stops?";
+const char * const MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_EN,
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_CZ,
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_IT,
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_ES,
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_PL
+};
+
+const char MSG_CONTRAST_EN[] PROGMEM = "LCD contrast";
+const char MSG_CONTRAST_CZ[] PROGMEM = "LCD contrast";
+const char MSG_CONTRAST_IT[] PROGMEM = "LCD contrast";
+const char MSG_CONTRAST_ES[] PROGMEM = "LCD contrast";
+const char MSG_CONTRAST_PL[] PROGMEM = "LCD contrast";
+const char * const MSG_CONTRAST_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONTRAST_EN,
+	MSG_CONTRAST_CZ,
+	MSG_CONTRAST_IT,
+	MSG_CONTRAST_ES,
+	MSG_CONTRAST_PL
+};
+
+const char MSG_CONTROL_EN[] PROGMEM = "Control";
+const char MSG_CONTROL_CZ[] PROGMEM = "Kontrola";
+const char MSG_CONTROL_IT[] PROGMEM = "Control";
+const char MSG_CONTROL_ES[] PROGMEM = "Control";
+const char MSG_CONTROL_PL[] PROGMEM = "Kontrola";
+const char * const MSG_CONTROL_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONTROL_EN,
+	MSG_CONTROL_CZ,
+	MSG_CONTROL_IT,
+	MSG_CONTROL_ES,
+	MSG_CONTROL_PL
+};
+
+const char MSG_CONTROL_RETRACT_EN[] PROGMEM = "Retract mm";
+const char MSG_CONTROL_RETRACT_CZ[] PROGMEM = "Retract mm";
+const char MSG_CONTROL_RETRACT_IT[] PROGMEM = "Retract mm";
+const char MSG_CONTROL_RETRACT_ES[] PROGMEM = "Retract mm";
+const char MSG_CONTROL_RETRACT_PL[] PROGMEM = "Retract mm";
+const char * const MSG_CONTROL_RETRACT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONTROL_RETRACT_EN,
+	MSG_CONTROL_RETRACT_CZ,
+	MSG_CONTROL_RETRACT_IT,
+	MSG_CONTROL_RETRACT_ES,
+	MSG_CONTROL_RETRACT_PL
+};
+
+const char MSG_CONTROL_RETRACTF_EN[] PROGMEM = "Retract  V";
+const char MSG_CONTROL_RETRACTF_CZ[] PROGMEM = "Retract  V";
+const char MSG_CONTROL_RETRACTF_IT[] PROGMEM = "Retract  V";
+const char MSG_CONTROL_RETRACTF_ES[] PROGMEM = "Retract  V";
+const char MSG_CONTROL_RETRACTF_PL[] PROGMEM = "Retract  V";
+const char * const MSG_CONTROL_RETRACTF_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONTROL_RETRACTF_EN,
+	MSG_CONTROL_RETRACTF_CZ,
+	MSG_CONTROL_RETRACTF_IT,
+	MSG_CONTROL_RETRACTF_ES,
+	MSG_CONTROL_RETRACTF_PL
+};
+
+const char MSG_CONTROL_RETRACT_RECOVER_EN[] PROGMEM = "UnRet +mm";
+const char MSG_CONTROL_RETRACT_RECOVER_CZ[] PROGMEM = "UnRet +mm";
+const char MSG_CONTROL_RETRACT_RECOVER_IT[] PROGMEM = "UnRet +mm";
+const char MSG_CONTROL_RETRACT_RECOVER_ES[] PROGMEM = "UnRet +mm";
+const char MSG_CONTROL_RETRACT_RECOVER_PL[] PROGMEM = "UnRet +mm";
+const char * const MSG_CONTROL_RETRACT_RECOVER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONTROL_RETRACT_RECOVER_EN,
+	MSG_CONTROL_RETRACT_RECOVER_CZ,
+	MSG_CONTROL_RETRACT_RECOVER_IT,
+	MSG_CONTROL_RETRACT_RECOVER_ES,
+	MSG_CONTROL_RETRACT_RECOVER_PL
+};
+
+const char MSG_CONTROL_RETRACT_RECOVERF_EN[] PROGMEM = "UnRet  V";
+const char MSG_CONTROL_RETRACT_RECOVERF_CZ[] PROGMEM = "UnRet  V";
+const char MSG_CONTROL_RETRACT_RECOVERF_IT[] PROGMEM = "UnRet  V";
+const char MSG_CONTROL_RETRACT_RECOVERF_ES[] PROGMEM = "UnRet  V";
+const char MSG_CONTROL_RETRACT_RECOVERF_PL[] PROGMEM = "UnRet  V";
+const char * const MSG_CONTROL_RETRACT_RECOVERF_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONTROL_RETRACT_RECOVERF_EN,
+	MSG_CONTROL_RETRACT_RECOVERF_CZ,
+	MSG_CONTROL_RETRACT_RECOVERF_IT,
+	MSG_CONTROL_RETRACT_RECOVERF_ES,
+	MSG_CONTROL_RETRACT_RECOVERF_PL
+};
+
+const char MSG_CONTROL_RETRACT_RECOVER_SWAP_EN[] PROGMEM = "S UnRet+mm";
+const char MSG_CONTROL_RETRACT_RECOVER_SWAP_CZ[] PROGMEM = "S UnRet+mm";
+const char MSG_CONTROL_RETRACT_RECOVER_SWAP_IT[] PROGMEM = "S UnRet+mm";
+const char MSG_CONTROL_RETRACT_RECOVER_SWAP_ES[] PROGMEM = "S UnRet+mm";
+const char MSG_CONTROL_RETRACT_RECOVER_SWAP_PL[] PROGMEM = "S UnRet+mm";
+const char * const MSG_CONTROL_RETRACT_RECOVER_SWAP_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONTROL_RETRACT_RECOVER_SWAP_EN,
+	MSG_CONTROL_RETRACT_RECOVER_SWAP_CZ,
+	MSG_CONTROL_RETRACT_RECOVER_SWAP_IT,
+	MSG_CONTROL_RETRACT_RECOVER_SWAP_ES,
+	MSG_CONTROL_RETRACT_RECOVER_SWAP_PL
+};
+
+const char MSG_CONTROL_RETRACT_SWAP_EN[] PROGMEM = "Swap Re.mm";
+const char MSG_CONTROL_RETRACT_SWAP_CZ[] PROGMEM = "Swap Re.mm";
+const char MSG_CONTROL_RETRACT_SWAP_IT[] PROGMEM = "Swap Re.mm";
+const char MSG_CONTROL_RETRACT_SWAP_ES[] PROGMEM = "Swap Re.mm";
+const char MSG_CONTROL_RETRACT_SWAP_PL[] PROGMEM = "Swap Re.mm";
+const char * const MSG_CONTROL_RETRACT_SWAP_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONTROL_RETRACT_SWAP_EN,
+	MSG_CONTROL_RETRACT_SWAP_CZ,
+	MSG_CONTROL_RETRACT_SWAP_IT,
+	MSG_CONTROL_RETRACT_SWAP_ES,
+	MSG_CONTROL_RETRACT_SWAP_PL
+};
+
+const char MSG_CONTROL_RETRACT_ZLIFT_EN[] PROGMEM = "Hop mm";
+const char MSG_CONTROL_RETRACT_ZLIFT_CZ[] PROGMEM = "Hop mm";
+const char MSG_CONTROL_RETRACT_ZLIFT_IT[] PROGMEM = "Hop mm";
+const char MSG_CONTROL_RETRACT_ZLIFT_ES[] PROGMEM = "Hop mm";
+const char MSG_CONTROL_RETRACT_ZLIFT_PL[] PROGMEM = "Hop mm";
+const char * const MSG_CONTROL_RETRACT_ZLIFT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CONTROL_RETRACT_ZLIFT_EN,
+	MSG_CONTROL_RETRACT_ZLIFT_CZ,
+	MSG_CONTROL_RETRACT_ZLIFT_IT,
+	MSG_CONTROL_RETRACT_ZLIFT_ES,
+	MSG_CONTROL_RETRACT_ZLIFT_PL
+};
+
+const char MSG_COOLDOWN_EN[] PROGMEM = "Cooldown";
+const char MSG_COOLDOWN_CZ[] PROGMEM = "Zchladit";
+const char MSG_COOLDOWN_IT[] PROGMEM = "Raffredda";
+const char MSG_COOLDOWN_ES[] PROGMEM = "Enfriar";
+const char MSG_COOLDOWN_PL[] PROGMEM = "Wychlodzic";
+const char * const MSG_COOLDOWN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_COOLDOWN_EN,
+	MSG_COOLDOWN_CZ,
+	MSG_COOLDOWN_IT,
+	MSG_COOLDOWN_ES,
+	MSG_COOLDOWN_PL
+};
+
+const char MSG_CORRECTLY_EN[] PROGMEM = "Changed correctly?";
+const char MSG_CORRECTLY_CZ[] PROGMEM = "Vymena ok?";
+const char MSG_CORRECTLY_IT[] PROGMEM = "Cambiato corr.?";
+const char MSG_CORRECTLY_ES[] PROGMEM = "Cambiado correc.?";
+const char MSG_CORRECTLY_PL[] PROGMEM = "Wymiana ok?";
+const char * const MSG_CORRECTLY_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_CORRECTLY_EN,
+	MSG_CORRECTLY_CZ,
+	MSG_CORRECTLY_IT,
+	MSG_CORRECTLY_ES,
+	MSG_CORRECTLY_PL
+};
+
+const char MSG_COUNT_X_EN[] PROGMEM = " Count X: ";
+const char MSG_COUNT_X_CZ[] PROGMEM = " Count X: ";
+const char MSG_COUNT_X_IT[] PROGMEM = " Count X: ";
+const char MSG_COUNT_X_ES[] PROGMEM = " Count X: ";
+const char MSG_COUNT_X_PL[] PROGMEM = " Count X: ";
+const char * const MSG_COUNT_X_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_COUNT_X_EN,
+	MSG_COUNT_X_CZ,
+	MSG_COUNT_X_IT,
+	MSG_COUNT_X_ES,
+	MSG_COUNT_X_PL
+};
+
+const char MSG_DISABLE_STEPPERS_EN[] PROGMEM = "Disable steppers";
+const char MSG_DISABLE_STEPPERS_CZ[] PROGMEM = "Vypnout motory";
+const char MSG_DISABLE_STEPPERS_IT[] PROGMEM = "Disabilita Motori";
+const char MSG_DISABLE_STEPPERS_ES[] PROGMEM = "Apagar motores";
+const char MSG_DISABLE_STEPPERS_PL[] PROGMEM = "Wylaczyc silniki";
+const char * const MSG_DISABLE_STEPPERS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_DISABLE_STEPPERS_EN,
+	MSG_DISABLE_STEPPERS_CZ,
+	MSG_DISABLE_STEPPERS_IT,
+	MSG_DISABLE_STEPPERS_ES,
+	MSG_DISABLE_STEPPERS_PL
+};
+
+const char MSG_DWELL_EN[] PROGMEM = "Sleep...";
+const char MSG_DWELL_CZ[] PROGMEM = "Sleep...";
+const char MSG_DWELL_IT[] PROGMEM = "Sospensione...";
+const char MSG_DWELL_ES[] PROGMEM = "Reposo...";
+const char MSG_DWELL_PL[] PROGMEM = "Sleep...";
+const char * const MSG_DWELL_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_DWELL_EN,
+	MSG_DWELL_CZ,
+	MSG_DWELL_IT,
+	MSG_DWELL_ES,
+	MSG_DWELL_PL
+};
+
+const char MSG_E_EN[] PROGMEM = "e";
+const char MSG_E_CZ[] PROGMEM = "e";
+const char MSG_E_IT[] PROGMEM = "e";
+const char MSG_E_ES[] PROGMEM = "e";
+const char MSG_E_PL[] PROGMEM = "e";
+const char * const MSG_E_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_E_EN,
+	MSG_E_CZ,
+	MSG_E_IT,
+	MSG_E_ES,
+	MSG_E_PL
+};
+
+const char MSG_ENDSTOPS_HIT_EN[] PROGMEM = "endstops hit: ";
+const char MSG_ENDSTOPS_HIT_CZ[] PROGMEM = "endstops hit: ";
+const char MSG_ENDSTOPS_HIT_IT[] PROGMEM = "endstops hit: ";
+const char MSG_ENDSTOPS_HIT_ES[] PROGMEM = "endstops hit: ";
+const char MSG_ENDSTOPS_HIT_PL[] PROGMEM = "endstops hit: ";
+const char * const MSG_ENDSTOPS_HIT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ENDSTOPS_HIT_EN,
+	MSG_ENDSTOPS_HIT_CZ,
+	MSG_ENDSTOPS_HIT_IT,
+	MSG_ENDSTOPS_HIT_ES,
+	MSG_ENDSTOPS_HIT_PL
+};
+
+const char MSG_ENDSTOP_ABORT_EN[] PROGMEM = "Endstop abort";
+const char MSG_ENDSTOP_ABORT_CZ[] PROGMEM = "Endstop abort";
+const char MSG_ENDSTOP_ABORT_IT[] PROGMEM = "Endstop abort";
+const char MSG_ENDSTOP_ABORT_ES[] PROGMEM = "Endstop abort";
+const char MSG_ENDSTOP_ABORT_PL[] PROGMEM = "Endstop abort";
+const char * const MSG_ENDSTOP_ABORT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ENDSTOP_ABORT_EN,
+	MSG_ENDSTOP_ABORT_CZ,
+	MSG_ENDSTOP_ABORT_IT,
+	MSG_ENDSTOP_ABORT_ES,
+	MSG_ENDSTOP_ABORT_PL
+};
+
+const char MSG_ENDSTOP_HIT_EN[] PROGMEM = "TRIGGERED";
+const char MSG_ENDSTOP_HIT_CZ[] PROGMEM = "TRIGGERED";
+const char MSG_ENDSTOP_HIT_IT[] PROGMEM = "TRIGGERED";
+const char MSG_ENDSTOP_HIT_ES[] PROGMEM = "TRIGGERED";
+const char MSG_ENDSTOP_HIT_PL[] PROGMEM = "TRIGGERED";
+const char * const MSG_ENDSTOP_HIT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ENDSTOP_HIT_EN,
+	MSG_ENDSTOP_HIT_CZ,
+	MSG_ENDSTOP_HIT_IT,
+	MSG_ENDSTOP_HIT_ES,
+	MSG_ENDSTOP_HIT_PL
+};
+
+const char MSG_ENDSTOP_OPEN_EN[] PROGMEM = "open";
+const char MSG_ENDSTOP_OPEN_CZ[] PROGMEM = "open";
+const char MSG_ENDSTOP_OPEN_IT[] PROGMEM = "open";
+const char MSG_ENDSTOP_OPEN_ES[] PROGMEM = "open";
+const char MSG_ENDSTOP_OPEN_PL[] PROGMEM = "open";
+const char * const MSG_ENDSTOP_OPEN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ENDSTOP_OPEN_EN,
+	MSG_ENDSTOP_OPEN_CZ,
+	MSG_ENDSTOP_OPEN_IT,
+	MSG_ENDSTOP_OPEN_ES,
+	MSG_ENDSTOP_OPEN_PL
+};
+
+const char MSG_END_FILE_LIST_EN[] PROGMEM = "End file list";
+const char MSG_END_FILE_LIST_CZ[] PROGMEM = "End file list";
+const char MSG_END_FILE_LIST_IT[] PROGMEM = "End file list";
+const char MSG_END_FILE_LIST_ES[] PROGMEM = "End file list";
+const char MSG_END_FILE_LIST_PL[] PROGMEM = "End file list";
+const char * const MSG_END_FILE_LIST_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_END_FILE_LIST_EN,
+	MSG_END_FILE_LIST_CZ,
+	MSG_END_FILE_LIST_IT,
+	MSG_END_FILE_LIST_ES,
+	MSG_END_FILE_LIST_PL
+};
+
+const char MSG_ERROR_EN[] PROGMEM = "ERROR:";
+const char MSG_ERROR_CZ[] PROGMEM = "CHYBA:";
+const char MSG_ERROR_IT[] PROGMEM = "ERROR:";
+const char MSG_ERROR_ES[] PROGMEM = "ERROR:";
+const char MSG_ERROR_PL[] PROGMEM = "BLAD:";
+const char * const MSG_ERROR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ERROR_EN,
+	MSG_ERROR_CZ,
+	MSG_ERROR_IT,
+	MSG_ERROR_ES,
+	MSG_ERROR_PL
+};
+
+const char MSG_ERR_CHECKSUM_MISMATCH_EN[] PROGMEM = "checksum mismatch, Last Line: ";
+const char MSG_ERR_CHECKSUM_MISMATCH_CZ[] PROGMEM = "checksum mismatch, Last Line: ";
+const char MSG_ERR_CHECKSUM_MISMATCH_IT[] PROGMEM = "checksum mismatch, Last Line: ";
+const char MSG_ERR_CHECKSUM_MISMATCH_ES[] PROGMEM = "checksum mismatch, Last Line: ";
+const char MSG_ERR_CHECKSUM_MISMATCH_PL[] PROGMEM = "checksum mismatch, Last Line: ";
+const char * const MSG_ERR_CHECKSUM_MISMATCH_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ERR_CHECKSUM_MISMATCH_EN,
+	MSG_ERR_CHECKSUM_MISMATCH_CZ,
+	MSG_ERR_CHECKSUM_MISMATCH_IT,
+	MSG_ERR_CHECKSUM_MISMATCH_ES,
+	MSG_ERR_CHECKSUM_MISMATCH_PL
+};
+
+const char MSG_ERR_COLD_EXTRUDE_STOP_EN[] PROGMEM = " cold extrusion prevented";
+const char MSG_ERR_COLD_EXTRUDE_STOP_CZ[] PROGMEM = " cold extrusion prevented";
+const char MSG_ERR_COLD_EXTRUDE_STOP_IT[] PROGMEM = " cold extrusion prevented";
+const char MSG_ERR_COLD_EXTRUDE_STOP_ES[] PROGMEM = " cold extrusion prevented";
+const char MSG_ERR_COLD_EXTRUDE_STOP_PL[] PROGMEM = " cold extrusion prevented";
+const char * const MSG_ERR_COLD_EXTRUDE_STOP_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ERR_COLD_EXTRUDE_STOP_EN,
+	MSG_ERR_COLD_EXTRUDE_STOP_CZ,
+	MSG_ERR_COLD_EXTRUDE_STOP_IT,
+	MSG_ERR_COLD_EXTRUDE_STOP_ES,
+	MSG_ERR_COLD_EXTRUDE_STOP_PL
+};
+
+const char MSG_ERR_KILLED_EN[] PROGMEM = "Printer halted. kill() called!";
+const char MSG_ERR_KILLED_CZ[] PROGMEM = "Printer halted. kill() called!";
+const char MSG_ERR_KILLED_IT[] PROGMEM = "Printer halted. kill() called!";
+const char MSG_ERR_KILLED_ES[] PROGMEM = "Printer halted. kill() called!";
+const char MSG_ERR_KILLED_PL[] PROGMEM = "Printer halted. kill() called!";
+const char * const MSG_ERR_KILLED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ERR_KILLED_EN,
+	MSG_ERR_KILLED_CZ,
+	MSG_ERR_KILLED_IT,
+	MSG_ERR_KILLED_ES,
+	MSG_ERR_KILLED_PL
+};
+
+const char MSG_ERR_LINE_NO_EN[] PROGMEM = "Line Number is not Last Line Number+1, Last Line: ";
+const char MSG_ERR_LINE_NO_CZ[] PROGMEM = "Line Number is not Last Line Number+1, Last Line: ";
+const char MSG_ERR_LINE_NO_IT[] PROGMEM = "Line Number is not Last Line Number+1, Last Line: ";
+const char MSG_ERR_LINE_NO_ES[] PROGMEM = "Line Number is not Last Line Number+1, Last Line: ";
+const char MSG_ERR_LINE_NO_PL[] PROGMEM = "Line Number is not Last Line Number+1, Last Line: ";
+const char * const MSG_ERR_LINE_NO_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ERR_LINE_NO_EN,
+	MSG_ERR_LINE_NO_CZ,
+	MSG_ERR_LINE_NO_IT,
+	MSG_ERR_LINE_NO_ES,
+	MSG_ERR_LINE_NO_PL
+};
+
+const char MSG_ERR_LONG_EXTRUDE_STOP_EN[] PROGMEM = " too long extrusion prevented";
+const char MSG_ERR_LONG_EXTRUDE_STOP_CZ[] PROGMEM = " too long extrusion prevented";
+const char MSG_ERR_LONG_EXTRUDE_STOP_IT[] PROGMEM = " too long extrusion prevented";
+const char MSG_ERR_LONG_EXTRUDE_STOP_ES[] PROGMEM = " too long extrusion prevented";
+const char MSG_ERR_LONG_EXTRUDE_STOP_PL[] PROGMEM = " too long extrusion prevented";
+const char * const MSG_ERR_LONG_EXTRUDE_STOP_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ERR_LONG_EXTRUDE_STOP_EN,
+	MSG_ERR_LONG_EXTRUDE_STOP_CZ,
+	MSG_ERR_LONG_EXTRUDE_STOP_IT,
+	MSG_ERR_LONG_EXTRUDE_STOP_ES,
+	MSG_ERR_LONG_EXTRUDE_STOP_PL
+};
+
+const char MSG_ERR_NO_CHECKSUM_EN[] PROGMEM = "No Checksum with line number, Last Line: ";
+const char MSG_ERR_NO_CHECKSUM_CZ[] PROGMEM = "No Checksum with line number, Last Line: ";
+const char MSG_ERR_NO_CHECKSUM_IT[] PROGMEM = "No Checksum with line number, Last Line: ";
+const char MSG_ERR_NO_CHECKSUM_ES[] PROGMEM = "No Checksum with line number, Last Line: ";
+const char MSG_ERR_NO_CHECKSUM_PL[] PROGMEM = "No Checksum with line number, Last Line: ";
+const char * const MSG_ERR_NO_CHECKSUM_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ERR_NO_CHECKSUM_EN,
+	MSG_ERR_NO_CHECKSUM_CZ,
+	MSG_ERR_NO_CHECKSUM_IT,
+	MSG_ERR_NO_CHECKSUM_ES,
+	MSG_ERR_NO_CHECKSUM_PL
+};
+
+const char MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_EN[] PROGMEM = "No Line Number with checksum, Last Line: ";
+const char MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_CZ[] PROGMEM = "No Line Number with checksum, Last Line: ";
+const char MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_IT[] PROGMEM = "No Line Number with checksum, Last Line: ";
+const char MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_ES[] PROGMEM = "No Line Number with checksum, Last Line: ";
+const char MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_PL[] PROGMEM = "No Line Number with checksum, Last Line: ";
+const char * const MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_EN,
+	MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_CZ,
+	MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_IT,
+	MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_ES,
+	MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_PL
+};
+
+const char MSG_ERR_NO_THERMISTORS_EN[] PROGMEM = "No thermistors - no temperature";
+const char MSG_ERR_NO_THERMISTORS_CZ[] PROGMEM = "No thermistors - no temperature";
+const char MSG_ERR_NO_THERMISTORS_IT[] PROGMEM = "No thermistors - no temperature";
+const char MSG_ERR_NO_THERMISTORS_ES[] PROGMEM = "No thermistors - no temperature";
+const char MSG_ERR_NO_THERMISTORS_PL[] PROGMEM = "No thermistors - no temperature";
+const char * const MSG_ERR_NO_THERMISTORS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ERR_NO_THERMISTORS_EN,
+	MSG_ERR_NO_THERMISTORS_CZ,
+	MSG_ERR_NO_THERMISTORS_IT,
+	MSG_ERR_NO_THERMISTORS_ES,
+	MSG_ERR_NO_THERMISTORS_PL
+};
+
+const char MSG_ERR_STOPPED_EN[] PROGMEM = "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)";
+const char MSG_ERR_STOPPED_CZ[] PROGMEM = "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)";
+const char MSG_ERR_STOPPED_IT[] PROGMEM = "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)";
+const char MSG_ERR_STOPPED_ES[] PROGMEM = "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)";
+const char MSG_ERR_STOPPED_PL[] PROGMEM = "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)";
+const char * const MSG_ERR_STOPPED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ERR_STOPPED_EN,
+	MSG_ERR_STOPPED_CZ,
+	MSG_ERR_STOPPED_IT,
+	MSG_ERR_STOPPED_ES,
+	MSG_ERR_STOPPED_PL
+};
+
+const char MSG_ESTEPS_EN[] PROGMEM = "Esteps/mm";
+const char MSG_ESTEPS_CZ[] PROGMEM = "Esteps/mm";
+const char MSG_ESTEPS_IT[] PROGMEM = "Esteps/mm";
+const char MSG_ESTEPS_ES[] PROGMEM = "Esteps/mm";
+const char MSG_ESTEPS_PL[] PROGMEM = "Esteps/mm";
+const char * const MSG_ESTEPS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ESTEPS_EN,
+	MSG_ESTEPS_CZ,
+	MSG_ESTEPS_IT,
+	MSG_ESTEPS_ES,
+	MSG_ESTEPS_PL
+};
+
+const char MSG_EXTERNAL_RESET_EN[] PROGMEM = " External Reset";
+const char MSG_EXTERNAL_RESET_CZ[] PROGMEM = " External Reset";
+const char MSG_EXTERNAL_RESET_IT[] PROGMEM = " External Reset";
+const char MSG_EXTERNAL_RESET_ES[] PROGMEM = " External Reset";
+const char MSG_EXTERNAL_RESET_PL[] PROGMEM = " External Reset";
+const char * const MSG_EXTERNAL_RESET_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_EXTERNAL_RESET_EN,
+	MSG_EXTERNAL_RESET_CZ,
+	MSG_EXTERNAL_RESET_IT,
+	MSG_EXTERNAL_RESET_ES,
+	MSG_EXTERNAL_RESET_PL
+};
+
+const char MSG_EXTRUDE_EN[] PROGMEM = "Extrude";
+const char MSG_EXTRUDE_CZ[] PROGMEM = "Extrudovat";
+const char MSG_EXTRUDE_IT[] PROGMEM = "Extrude";
+const char MSG_EXTRUDE_ES[] PROGMEM = "Extrude";
+const char MSG_EXTRUDE_PL[] PROGMEM = "Extrudovat";
+const char * const MSG_EXTRUDE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_EXTRUDE_EN,
+	MSG_EXTRUDE_CZ,
+	MSG_EXTRUDE_IT,
+	MSG_EXTRUDE_ES,
+	MSG_EXTRUDE_PL
+};
+
+const char MSG_Enqueing_EN[] PROGMEM = "enqueing \"";
+const char MSG_Enqueing_CZ[] PROGMEM = "enqueing \"";
+const char MSG_Enqueing_IT[] PROGMEM = "enqueing \"";
+const char MSG_Enqueing_ES[] PROGMEM = "enqueing \"";
+const char MSG_Enqueing_PL[] PROGMEM = "enqueing \"";
+const char * const MSG_Enqueing_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_Enqueing_EN,
+	MSG_Enqueing_CZ,
+	MSG_Enqueing_IT,
+	MSG_Enqueing_ES,
+	MSG_Enqueing_PL
+};
+
+const char MSG_FACTOR_EN[] PROGMEM = " \002 Fact";
+const char MSG_FACTOR_CZ[] PROGMEM = " \002 Fact";
+const char MSG_FACTOR_IT[] PROGMEM = " \002 Fact";
+const char MSG_FACTOR_ES[] PROGMEM = " \002 Fact";
+const char MSG_FACTOR_PL[] PROGMEM = " \002 Fact";
+const char * const MSG_FACTOR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FACTOR_EN,
+	MSG_FACTOR_CZ,
+	MSG_FACTOR_IT,
+	MSG_FACTOR_ES,
+	MSG_FACTOR_PL
+};
+
+const char MSG_FAN_SPEED_EN[] PROGMEM = "Fan speed";
+const char MSG_FAN_SPEED_CZ[] PROGMEM = "Rychlost vent.";
+const char MSG_FAN_SPEED_IT[] PROGMEM = "Ventola";
+const char MSG_FAN_SPEED_ES[] PROGMEM = "Ventilador";
+const char MSG_FAN_SPEED_PL[] PROGMEM = "Predkosc went.";
+const char * const MSG_FAN_SPEED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FAN_SPEED_EN,
+	MSG_FAN_SPEED_CZ,
+	MSG_FAN_SPEED_IT,
+	MSG_FAN_SPEED_ES,
+	MSG_FAN_SPEED_PL
+};
+
+const char MSG_FILAMENTCHANGE_EN[] PROGMEM = "Change filament";
+const char MSG_FILAMENTCHANGE_CZ[] PROGMEM = "Vymenit filament";
+const char MSG_FILAMENTCHANGE_IT[] PROGMEM = "Cambiare filamento";
+const char MSG_FILAMENTCHANGE_ES[] PROGMEM = "Cambiar filamento";
+const char MSG_FILAMENTCHANGE_PL[] PROGMEM = "Wymienic filament";
+const char * const MSG_FILAMENTCHANGE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FILAMENTCHANGE_EN,
+	MSG_FILAMENTCHANGE_CZ,
+	MSG_FILAMENTCHANGE_IT,
+	MSG_FILAMENTCHANGE_ES,
+	MSG_FILAMENTCHANGE_PL
+};
+
+const char MSG_FILAMENT_SIZE_EXTRUDER_0_EN[] PROGMEM = "Fil. Dia. 1";
+const char MSG_FILAMENT_SIZE_EXTRUDER_0_CZ[] PROGMEM = "Fil. Dia. 1";
+const char MSG_FILAMENT_SIZE_EXTRUDER_0_IT[] PROGMEM = "Fil. Dia. 1";
+const char MSG_FILAMENT_SIZE_EXTRUDER_0_ES[] PROGMEM = "Fil. Dia. 1";
+const char MSG_FILAMENT_SIZE_EXTRUDER_0_PL[] PROGMEM = "Fil. Dia. 1";
+const char * const MSG_FILAMENT_SIZE_EXTRUDER_0_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FILAMENT_SIZE_EXTRUDER_0_EN,
+	MSG_FILAMENT_SIZE_EXTRUDER_0_CZ,
+	MSG_FILAMENT_SIZE_EXTRUDER_0_IT,
+	MSG_FILAMENT_SIZE_EXTRUDER_0_ES,
+	MSG_FILAMENT_SIZE_EXTRUDER_0_PL
+};
+
+const char MSG_FILAMENT_SIZE_EXTRUDER_1_EN[] PROGMEM = "Fil. Dia. 2";
+const char MSG_FILAMENT_SIZE_EXTRUDER_1_CZ[] PROGMEM = "Fil. Dia. 2";
+const char MSG_FILAMENT_SIZE_EXTRUDER_1_IT[] PROGMEM = "Fil. Dia. 2";
+const char MSG_FILAMENT_SIZE_EXTRUDER_1_ES[] PROGMEM = "Fil. Dia. 2";
+const char MSG_FILAMENT_SIZE_EXTRUDER_1_PL[] PROGMEM = "Fil. Dia. 2";
+const char * const MSG_FILAMENT_SIZE_EXTRUDER_1_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FILAMENT_SIZE_EXTRUDER_1_EN,
+	MSG_FILAMENT_SIZE_EXTRUDER_1_CZ,
+	MSG_FILAMENT_SIZE_EXTRUDER_1_IT,
+	MSG_FILAMENT_SIZE_EXTRUDER_1_ES,
+	MSG_FILAMENT_SIZE_EXTRUDER_1_PL
+};
+
+const char MSG_FILAMENT_SIZE_EXTRUDER_2_EN[] PROGMEM = "Fil. Dia. 3";
+const char MSG_FILAMENT_SIZE_EXTRUDER_2_CZ[] PROGMEM = "Fil. Dia. 3";
+const char MSG_FILAMENT_SIZE_EXTRUDER_2_IT[] PROGMEM = "Fil. Dia. 3";
+const char MSG_FILAMENT_SIZE_EXTRUDER_2_ES[] PROGMEM = "Fil. Dia. 3";
+const char MSG_FILAMENT_SIZE_EXTRUDER_2_PL[] PROGMEM = "Fil. Dia. 3";
+const char * const MSG_FILAMENT_SIZE_EXTRUDER_2_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FILAMENT_SIZE_EXTRUDER_2_EN,
+	MSG_FILAMENT_SIZE_EXTRUDER_2_CZ,
+	MSG_FILAMENT_SIZE_EXTRUDER_2_IT,
+	MSG_FILAMENT_SIZE_EXTRUDER_2_ES,
+	MSG_FILAMENT_SIZE_EXTRUDER_2_PL
+};
+
+const char MSG_FILE_PRINTED_EN[] PROGMEM = "Done printing file";
+const char MSG_FILE_PRINTED_CZ[] PROGMEM = "Done printing file";
+const char MSG_FILE_PRINTED_IT[] PROGMEM = "Done printing file";
+const char MSG_FILE_PRINTED_ES[] PROGMEM = "Done printing file";
+const char MSG_FILE_PRINTED_PL[] PROGMEM = "Done printing file";
+const char * const MSG_FILE_PRINTED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FILE_PRINTED_EN,
+	MSG_FILE_PRINTED_CZ,
+	MSG_FILE_PRINTED_IT,
+	MSG_FILE_PRINTED_ES,
+	MSG_FILE_PRINTED_PL
+};
+
+const char MSG_FILE_SAVED_EN[] PROGMEM = "Done saving file.";
+const char MSG_FILE_SAVED_CZ[] PROGMEM = "Done saving file.";
+const char MSG_FILE_SAVED_IT[] PROGMEM = "Done saving file.";
+const char MSG_FILE_SAVED_ES[] PROGMEM = "Done saving file.";
+const char MSG_FILE_SAVED_PL[] PROGMEM = "Done saving file.";
+const char * const MSG_FILE_SAVED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FILE_SAVED_EN,
+	MSG_FILE_SAVED_CZ,
+	MSG_FILE_SAVED_IT,
+	MSG_FILE_SAVED_ES,
+	MSG_FILE_SAVED_PL
+};
+
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_EN[] PROGMEM = "Searching calibration";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_CZ[] PROGMEM = "Searching calibration";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_IT[] PROGMEM = "Searching calibration";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_ES[] PROGMEM = "Searching calibration";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_PL[] PROGMEM = "Searching calibration";
+const char * const MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_EN,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_CZ,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_IT,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_ES,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_PL
+};
+
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_EN[] PROGMEM = "point ";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_CZ[] PROGMEM = "point ";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_IT[] PROGMEM = "point ";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_ES[] PROGMEM = "point ";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_PL[] PROGMEM = "point ";
+const char * const MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_EN,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_CZ,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_IT,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_ES,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_PL
+};
+
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_EN[] PROGMEM = "of 4";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_CZ[] PROGMEM = "of 4";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_IT[] PROGMEM = "of 4";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_ES[] PROGMEM = "of 4";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_PL[] PROGMEM = "of 4";
+const char * const MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_EN,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_CZ,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_IT,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_ES,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_PL
+};
+
+const char MSG_FLOW_EN[] PROGMEM = "Flow";
+const char MSG_FLOW_CZ[] PROGMEM = "Prutok";
+const char MSG_FLOW_IT[] PROGMEM = "Flusso";
+const char MSG_FLOW_ES[] PROGMEM = "Flujo";
+const char MSG_FLOW_PL[] PROGMEM = "Przeplyw";
+const char * const MSG_FLOW_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FLOW_EN,
+	MSG_FLOW_CZ,
+	MSG_FLOW_IT,
+	MSG_FLOW_ES,
+	MSG_FLOW_PL
+};
+
+const char MSG_FLOW0_EN[] PROGMEM = "Flow 0";
+const char MSG_FLOW0_CZ[] PROGMEM = "Prutok 0";
+const char MSG_FLOW0_IT[] PROGMEM = "Flow 0";
+const char MSG_FLOW0_ES[] PROGMEM = "Flow 0";
+const char MSG_FLOW0_PL[] PROGMEM = "Prutok 0";
+const char * const MSG_FLOW0_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FLOW0_EN,
+	MSG_FLOW0_CZ,
+	MSG_FLOW0_IT,
+	MSG_FLOW0_ES,
+	MSG_FLOW0_PL
+};
+
+const char MSG_FLOW1_EN[] PROGMEM = "Flow 1";
+const char MSG_FLOW1_CZ[] PROGMEM = "Prutok 1";
+const char MSG_FLOW1_IT[] PROGMEM = "Flow 1";
+const char MSG_FLOW1_ES[] PROGMEM = "Flow 1";
+const char MSG_FLOW1_PL[] PROGMEM = "Prutok 1";
+const char * const MSG_FLOW1_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FLOW1_EN,
+	MSG_FLOW1_CZ,
+	MSG_FLOW1_IT,
+	MSG_FLOW1_ES,
+	MSG_FLOW1_PL
+};
+
+const char MSG_FLOW2_EN[] PROGMEM = "Flow 2";
+const char MSG_FLOW2_CZ[] PROGMEM = "Prutok 2";
+const char MSG_FLOW2_IT[] PROGMEM = "Flow 2";
+const char MSG_FLOW2_ES[] PROGMEM = "Flow 2";
+const char MSG_FLOW2_PL[] PROGMEM = "Prutok 2";
+const char * const MSG_FLOW2_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FLOW2_EN,
+	MSG_FLOW2_CZ,
+	MSG_FLOW2_IT,
+	MSG_FLOW2_ES,
+	MSG_FLOW2_PL
+};
+
+const char MSG_FREE_MEMORY_EN[] PROGMEM = " Free Memory: ";
+const char MSG_FREE_MEMORY_CZ[] PROGMEM = " Free Memory: ";
+const char MSG_FREE_MEMORY_IT[] PROGMEM = " Free Memory: ";
+const char MSG_FREE_MEMORY_ES[] PROGMEM = " Free Memory: ";
+const char MSG_FREE_MEMORY_PL[] PROGMEM = " Free Memory: ";
+const char * const MSG_FREE_MEMORY_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_FREE_MEMORY_EN,
+	MSG_FREE_MEMORY_CZ,
+	MSG_FREE_MEMORY_IT,
+	MSG_FREE_MEMORY_ES,
+	MSG_FREE_MEMORY_PL
+};
+
+const char MSG_HEATING_EN[] PROGMEM = "Heating";
+const char MSG_HEATING_CZ[] PROGMEM = "Zahrivani";
+const char MSG_HEATING_IT[] PROGMEM = "Riscaldamento...";
+const char MSG_HEATING_ES[] PROGMEM = "Calentando...";
+const char MSG_HEATING_PL[] PROGMEM = "Grzanie...";
+const char * const MSG_HEATING_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_HEATING_EN,
+	MSG_HEATING_CZ,
+	MSG_HEATING_IT,
+	MSG_HEATING_ES,
+	MSG_HEATING_PL
+};
+
+const char MSG_HEATING_COMPLETE_EN[] PROGMEM = "Heating done.";
+const char MSG_HEATING_COMPLETE_CZ[] PROGMEM = "Zahrivani OK.";
+const char MSG_HEATING_COMPLETE_IT[] PROGMEM = "Riscaldamento fatto.";
+const char MSG_HEATING_COMPLETE_ES[] PROGMEM = "Calentando listo.";
+const char MSG_HEATING_COMPLETE_PL[] PROGMEM = "Grzanie OK.";
+const char * const MSG_HEATING_COMPLETE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_HEATING_COMPLETE_EN,
+	MSG_HEATING_COMPLETE_CZ,
+	MSG_HEATING_COMPLETE_IT,
+	MSG_HEATING_COMPLETE_ES,
+	MSG_HEATING_COMPLETE_PL
+};
+
+const char MSG_HOMEYZ_EN[] PROGMEM = "Calibrate Z";
+const char MSG_HOMEYZ_CZ[] PROGMEM = "Kalibrovat Z";
+const char MSG_HOMEYZ_IT[] PROGMEM = "Calibra Z";
+const char MSG_HOMEYZ_ES[] PROGMEM = "Calibrar Z";
+const char MSG_HOMEYZ_PL[] PROGMEM = "Kalibruj Z";
+const char * const MSG_HOMEYZ_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_HOMEYZ_EN,
+	MSG_HOMEYZ_CZ,
+	MSG_HOMEYZ_IT,
+	MSG_HOMEYZ_ES,
+	MSG_HOMEYZ_PL
+};
+
+const char MSG_HOMEYZ_DONE_EN[] PROGMEM = "Calibration done";
+const char MSG_HOMEYZ_DONE_CZ[] PROGMEM = "Kalibrace OK";
+const char MSG_HOMEYZ_DONE_IT[] PROGMEM = "Calibratura OK";
+const char MSG_HOMEYZ_DONE_ES[] PROGMEM = "Calibraci\xF3n OK";
+const char MSG_HOMEYZ_DONE_PL[] PROGMEM = "Kalibracja OK";
+const char * const MSG_HOMEYZ_DONE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_HOMEYZ_DONE_EN,
+	MSG_HOMEYZ_DONE_CZ,
+	MSG_HOMEYZ_DONE_IT,
+	MSG_HOMEYZ_DONE_ES,
+	MSG_HOMEYZ_DONE_PL
+};
+
+const char MSG_HOMEYZ_PROGRESS_EN[] PROGMEM = "Calibrating Z";
+const char MSG_HOMEYZ_PROGRESS_CZ[] PROGMEM = "Kalibruji Z";
+const char MSG_HOMEYZ_PROGRESS_IT[] PROGMEM = "Calibrando Z";
+const char MSG_HOMEYZ_PROGRESS_ES[] PROGMEM = "Calibrando Z";
+const char MSG_HOMEYZ_PROGRESS_PL[] PROGMEM = "Kalibruje Z";
+const char * const MSG_HOMEYZ_PROGRESS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_HOMEYZ_PROGRESS_EN,
+	MSG_HOMEYZ_PROGRESS_CZ,
+	MSG_HOMEYZ_PROGRESS_IT,
+	MSG_HOMEYZ_PROGRESS_ES,
+	MSG_HOMEYZ_PROGRESS_PL
+};
+
+const char MSG_HOTEND_OFFSET_EN[] PROGMEM = "Hotend offsets:";
+const char MSG_HOTEND_OFFSET_CZ[] PROGMEM = "Hotend offsets:";
+const char MSG_HOTEND_OFFSET_IT[] PROGMEM = "Hotend offsets:";
+const char MSG_HOTEND_OFFSET_ES[] PROGMEM = "Hotend offsets:";
+const char MSG_HOTEND_OFFSET_PL[] PROGMEM = "Hotend offsets:";
+const char * const MSG_HOTEND_OFFSET_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_HOTEND_OFFSET_EN,
+	MSG_HOTEND_OFFSET_CZ,
+	MSG_HOTEND_OFFSET_IT,
+	MSG_HOTEND_OFFSET_ES,
+	MSG_HOTEND_OFFSET_PL
+};
+
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_EN[] PROGMEM = "Improving calibration";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_CZ[] PROGMEM = "Improving calibration";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_IT[] PROGMEM = "Improving calibration";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_ES[] PROGMEM = "Improving calibration";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_PL[] PROGMEM = "Improving calibration";
+const char * const MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_EN,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_CZ,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_IT,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_ES,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_PL
+};
+
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_EN[] PROGMEM = "point ";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_CZ[] PROGMEM = "point ";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_IT[] PROGMEM = "point ";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_ES[] PROGMEM = "point ";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_PL[] PROGMEM = "point ";
+const char * const MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_EN,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_CZ,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_IT,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_ES,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_PL
+};
+
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_EN[] PROGMEM = "of 9";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_CZ[] PROGMEM = "of 9";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_IT[] PROGMEM = "of 9";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_ES[] PROGMEM = "of 9";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_PL[] PROGMEM = "of 9";
+const char * const MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_EN,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_CZ,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_IT,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_ES,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_PL
+};
+
+const char MSG_INIT_SDCARD_EN[] PROGMEM = "Init. SD card";
+const char MSG_INIT_SDCARD_CZ[] PROGMEM = "Inic. SD";
+const char MSG_INIT_SDCARD_IT[] PROGMEM = "Init. SD card";
+const char MSG_INIT_SDCARD_ES[] PROGMEM = "Init. SD card";
+const char MSG_INIT_SDCARD_PL[] PROGMEM = "Inic. SD";
+const char * const MSG_INIT_SDCARD_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_INIT_SDCARD_EN,
+	MSG_INIT_SDCARD_CZ,
+	MSG_INIT_SDCARD_IT,
+	MSG_INIT_SDCARD_ES,
+	MSG_INIT_SDCARD_PL
+};
+
+const char MSG_INSERT_FILAMENT_EN[] PROGMEM = "Insert filament";
+const char MSG_INSERT_FILAMENT_CZ[] PROGMEM = "Vlozte filament";
+const char MSG_INSERT_FILAMENT_IT[] PROGMEM = "Inserire filamento";
+const char MSG_INSERT_FILAMENT_ES[] PROGMEM = "Inserta filamento";
+const char MSG_INSERT_FILAMENT_PL[] PROGMEM = "Wprowadz filament";
+const char * const MSG_INSERT_FILAMENT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_INSERT_FILAMENT_EN,
+	MSG_INSERT_FILAMENT_CZ,
+	MSG_INSERT_FILAMENT_IT,
+	MSG_INSERT_FILAMENT_ES,
+	MSG_INSERT_FILAMENT_PL
+};
+
+const char MSG_INVALID_EXTRUDER_EN[] PROGMEM = "Invalid extruder";
+const char MSG_INVALID_EXTRUDER_CZ[] PROGMEM = "Invalid extruder";
+const char MSG_INVALID_EXTRUDER_IT[] PROGMEM = "Invalid extruder";
+const char MSG_INVALID_EXTRUDER_ES[] PROGMEM = "Invalid extruder";
+const char MSG_INVALID_EXTRUDER_PL[] PROGMEM = "Invalid extruder";
+const char * const MSG_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_INVALID_EXTRUDER_EN,
+	MSG_INVALID_EXTRUDER_CZ,
+	MSG_INVALID_EXTRUDER_IT,
+	MSG_INVALID_EXTRUDER_ES,
+	MSG_INVALID_EXTRUDER_PL
+};
+
+const char MSG_KILLED_EN[] PROGMEM = "KILLED. ";
+const char MSG_KILLED_CZ[] PROGMEM = "KILLED. ";
+const char MSG_KILLED_IT[] PROGMEM = "UCCISO ";
+const char MSG_KILLED_ES[] PROGMEM = "PARADA DE EMERG.";
+const char MSG_KILLED_PL[] PROGMEM = "KILLED. ";
+const char * const MSG_KILLED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_KILLED_EN,
+	MSG_KILLED_CZ,
+	MSG_KILLED_IT,
+	MSG_KILLED_ES,
+	MSG_KILLED_PL
+};
+
+const char MSG_LANGUAGE_NAME_EN[] PROGMEM = "English";
+const char MSG_LANGUAGE_NAME_CZ[] PROGMEM = "Cestina";
+const char MSG_LANGUAGE_NAME_IT[] PROGMEM = "Italiano";
+const char MSG_LANGUAGE_NAME_ES[] PROGMEM = "Espanol";
+const char MSG_LANGUAGE_NAME_PL[] PROGMEM = "Polski";
+const char * const MSG_LANGUAGE_NAME_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_LANGUAGE_NAME_EN,
+	MSG_LANGUAGE_NAME_CZ,
+	MSG_LANGUAGE_NAME_IT,
+	MSG_LANGUAGE_NAME_ES,
+	MSG_LANGUAGE_NAME_PL
+};
+
+const char MSG_LANGUAGE_SELECT_EN[] PROGMEM = "Select language     ";
+const char MSG_LANGUAGE_SELECT_CZ[] PROGMEM = "Vyber jazyka        ";
+const char MSG_LANGUAGE_SELECT_IT[] PROGMEM = "Selez. la lingua";
+const char MSG_LANGUAGE_SELECT_ES[] PROGMEM = "Cambia la lengua ";
+const char MSG_LANGUAGE_SELECT_PL[] PROGMEM = "Wybor jezyka        ";
+const char * const MSG_LANGUAGE_SELECT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_LANGUAGE_SELECT_EN,
+	MSG_LANGUAGE_SELECT_CZ,
+	MSG_LANGUAGE_SELECT_IT,
+	MSG_LANGUAGE_SELECT_ES,
+	MSG_LANGUAGE_SELECT_PL
+};
+
+const char MSG_LOADING_COLOR_EN[] PROGMEM = "Loading color";
+const char MSG_LOADING_COLOR_CZ[] PROGMEM = "Cisteni barvy";
+const char MSG_LOADING_COLOR_IT[] PROGMEM = "Cargando color";
+const char MSG_LOADING_COLOR_ES[] PROGMEM = "Cargando color";
+const char MSG_LOADING_COLOR_PL[] PROGMEM = "Czyszcz. koloru";
+const char * const MSG_LOADING_COLOR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_LOADING_COLOR_EN,
+	MSG_LOADING_COLOR_CZ,
+	MSG_LOADING_COLOR_IT,
+	MSG_LOADING_COLOR_ES,
+	MSG_LOADING_COLOR_PL
+};
+
+const char MSG_LOADING_FILAMENT_EN[] PROGMEM = "Loading filament";
+const char MSG_LOADING_FILAMENT_CZ[] PROGMEM = "Zavadeni filamentu";
+const char MSG_LOADING_FILAMENT_IT[] PROGMEM = "Cargando fil.";
+const char MSG_LOADING_FILAMENT_ES[] PROGMEM = "Cargando fil.";
+const char MSG_LOADING_FILAMENT_PL[] PROGMEM = "Wprow. filamentu";
+const char * const MSG_LOADING_FILAMENT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_LOADING_FILAMENT_EN,
+	MSG_LOADING_FILAMENT_CZ,
+	MSG_LOADING_FILAMENT_IT,
+	MSG_LOADING_FILAMENT_ES,
+	MSG_LOADING_FILAMENT_PL
+};
+
+const char MSG_LOAD_EPROM_EN[] PROGMEM = "Load memory";
+const char MSG_LOAD_EPROM_CZ[] PROGMEM = "Ulozit pamet";
+const char MSG_LOAD_EPROM_IT[] PROGMEM = "Load memory";
+const char MSG_LOAD_EPROM_ES[] PROGMEM = "Load memory";
+const char MSG_LOAD_EPROM_PL[] PROGMEM = "Ulozit pamet";
+const char * const MSG_LOAD_EPROM_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_LOAD_EPROM_EN,
+	MSG_LOAD_EPROM_CZ,
+	MSG_LOAD_EPROM_IT,
+	MSG_LOAD_EPROM_ES,
+	MSG_LOAD_EPROM_PL
+};
+
+const char MSG_LOAD_FILAMENT_EN[] PROGMEM = "Load filament";
+const char MSG_LOAD_FILAMENT_CZ[] PROGMEM = "Zavest filament";
+const char MSG_LOAD_FILAMENT_IT[] PROGMEM = "Caricare filamento";
+const char MSG_LOAD_FILAMENT_ES[] PROGMEM = "Introducir filamento";
+const char MSG_LOAD_FILAMENT_PL[] PROGMEM = "Wprowadz filament";
+const char * const MSG_LOAD_FILAMENT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_LOAD_FILAMENT_EN,
+	MSG_LOAD_FILAMENT_CZ,
+	MSG_LOAD_FILAMENT_IT,
+	MSG_LOAD_FILAMENT_ES,
+	MSG_LOAD_FILAMENT_PL
+};
+
+const char MSG_M104_INVALID_EXTRUDER_EN[] PROGMEM = "M104 Invalid extruder ";
+const char MSG_M104_INVALID_EXTRUDER_CZ[] PROGMEM = "M104 Invalid extruder ";
+const char MSG_M104_INVALID_EXTRUDER_IT[] PROGMEM = "M104 Invalid extruder ";
+const char MSG_M104_INVALID_EXTRUDER_ES[] PROGMEM = "M104 Invalid extruder ";
+const char MSG_M104_INVALID_EXTRUDER_PL[] PROGMEM = "M104 Invalid extruder ";
+const char * const MSG_M104_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_M104_INVALID_EXTRUDER_EN,
+	MSG_M104_INVALID_EXTRUDER_CZ,
+	MSG_M104_INVALID_EXTRUDER_IT,
+	MSG_M104_INVALID_EXTRUDER_ES,
+	MSG_M104_INVALID_EXTRUDER_PL
+};
+
+const char MSG_M105_INVALID_EXTRUDER_EN[] PROGMEM = "M105 Invalid extruder ";
+const char MSG_M105_INVALID_EXTRUDER_CZ[] PROGMEM = "M105 Invalid extruder ";
+const char MSG_M105_INVALID_EXTRUDER_IT[] PROGMEM = "M105 Invalid extruder ";
+const char MSG_M105_INVALID_EXTRUDER_ES[] PROGMEM = "M105 Invalid extruder ";
+const char MSG_M105_INVALID_EXTRUDER_PL[] PROGMEM = "M105 Invalid extruder ";
+const char * const MSG_M105_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_M105_INVALID_EXTRUDER_EN,
+	MSG_M105_INVALID_EXTRUDER_CZ,
+	MSG_M105_INVALID_EXTRUDER_IT,
+	MSG_M105_INVALID_EXTRUDER_ES,
+	MSG_M105_INVALID_EXTRUDER_PL
+};
+
+const char MSG_M109_INVALID_EXTRUDER_EN[] PROGMEM = "M109 Invalid extruder ";
+const char MSG_M109_INVALID_EXTRUDER_CZ[] PROGMEM = "M109 Invalid extruder ";
+const char MSG_M109_INVALID_EXTRUDER_IT[] PROGMEM = "M109 Invalid extruder ";
+const char MSG_M109_INVALID_EXTRUDER_ES[] PROGMEM = "M109 Invalid extruder ";
+const char MSG_M109_INVALID_EXTRUDER_PL[] PROGMEM = "M109 Invalid extruder ";
+const char * const MSG_M109_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_M109_INVALID_EXTRUDER_EN,
+	MSG_M109_INVALID_EXTRUDER_CZ,
+	MSG_M109_INVALID_EXTRUDER_IT,
+	MSG_M109_INVALID_EXTRUDER_ES,
+	MSG_M109_INVALID_EXTRUDER_PL
+};
+
+const char MSG_M115_REPORT_EN[] PROGMEM = "FIRMWARE_NAME:Marlin V1.0.2; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/prusa3d/Prusa-i3-Plus/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:" CUSTOM_MENDEL_NAME " EXTRUDER_COUNT:1 UUID:00000000-0000-0000-0000-000000000000\n";
+const char MSG_M115_REPORT_CZ[] PROGMEM = "FIRMWARE_NAME:Marlin V1.0.2; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/prusa3d/Prusa-i3-Plus/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:" CUSTOM_MENDEL_NAME " EXTRUDER_COUNT:1 UUID:00000000-0000-0000-0000-000000000000\n";
+const char MSG_M115_REPORT_IT[] PROGMEM = "FIRMWARE_NAME:Marlin V1.0.2; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/prusa3d/Prusa-i3-Plus/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:" CUSTOM_MENDEL_NAME " EXTRUDER_COUNT:1 UUID:00000000-0000-0000-0000-000000000000\n";
+const char MSG_M115_REPORT_ES[] PROGMEM = "FIRMWARE_NAME:Marlin V1.0.2; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/prusa3d/Prusa-i3-Plus/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:" CUSTOM_MENDEL_NAME " EXTRUDER_COUNT:1 UUID:00000000-0000-0000-0000-000000000000\n";
+const char MSG_M115_REPORT_PL[] PROGMEM = "FIRMWARE_NAME:Marlin V1.0.2; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/prusa3d/Prusa-i3-Plus/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:" CUSTOM_MENDEL_NAME " EXTRUDER_COUNT:1 UUID:00000000-0000-0000-0000-000000000000\n";
+const char * const MSG_M115_REPORT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_M115_REPORT_EN,
+	MSG_M115_REPORT_CZ,
+	MSG_M115_REPORT_IT,
+	MSG_M115_REPORT_ES,
+	MSG_M115_REPORT_PL
+};
+
+const char MSG_M119_REPORT_EN[] PROGMEM = "Reporting endstop status";
+const char MSG_M119_REPORT_CZ[] PROGMEM = "Reporting endstop status";
+const char MSG_M119_REPORT_IT[] PROGMEM = "Reporting endstop status";
+const char MSG_M119_REPORT_ES[] PROGMEM = "Reporting endstop status";
+const char MSG_M119_REPORT_PL[] PROGMEM = "Reporting endstop status";
+const char * const MSG_M119_REPORT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_M119_REPORT_EN,
+	MSG_M119_REPORT_CZ,
+	MSG_M119_REPORT_IT,
+	MSG_M119_REPORT_ES,
+	MSG_M119_REPORT_PL
+};
+
+const char MSG_M200_INVALID_EXTRUDER_EN[] PROGMEM = "M200 Invalid extruder ";
+const char MSG_M200_INVALID_EXTRUDER_CZ[] PROGMEM = "M200 Invalid extruder ";
+const char MSG_M200_INVALID_EXTRUDER_IT[] PROGMEM = "M200 Invalid extruder ";
+const char MSG_M200_INVALID_EXTRUDER_ES[] PROGMEM = "M200 Invalid extruder ";
+const char MSG_M200_INVALID_EXTRUDER_PL[] PROGMEM = "M200 Invalid extruder ";
+const char * const MSG_M200_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_M200_INVALID_EXTRUDER_EN,
+	MSG_M200_INVALID_EXTRUDER_CZ,
+	MSG_M200_INVALID_EXTRUDER_IT,
+	MSG_M200_INVALID_EXTRUDER_ES,
+	MSG_M200_INVALID_EXTRUDER_PL
+};
+
+const char MSG_M218_INVALID_EXTRUDER_EN[] PROGMEM = "M218 Invalid extruder ";
+const char MSG_M218_INVALID_EXTRUDER_CZ[] PROGMEM = "M218 Invalid extruder ";
+const char MSG_M218_INVALID_EXTRUDER_IT[] PROGMEM = "M218 Invalid extruder ";
+const char MSG_M218_INVALID_EXTRUDER_ES[] PROGMEM = "M218 Invalid extruder ";
+const char MSG_M218_INVALID_EXTRUDER_PL[] PROGMEM = "M218 Invalid extruder ";
+const char * const MSG_M218_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_M218_INVALID_EXTRUDER_EN,
+	MSG_M218_INVALID_EXTRUDER_CZ,
+	MSG_M218_INVALID_EXTRUDER_IT,
+	MSG_M218_INVALID_EXTRUDER_ES,
+	MSG_M218_INVALID_EXTRUDER_PL
+};
+
+const char MSG_M221_INVALID_EXTRUDER_EN[] PROGMEM = "M221 Invalid extruder ";
+const char MSG_M221_INVALID_EXTRUDER_CZ[] PROGMEM = "M221 Invalid extruder ";
+const char MSG_M221_INVALID_EXTRUDER_IT[] PROGMEM = "M221 Invalid extruder ";
+const char MSG_M221_INVALID_EXTRUDER_ES[] PROGMEM = "M221 Invalid extruder ";
+const char MSG_M221_INVALID_EXTRUDER_PL[] PROGMEM = "M221 Invalid extruder ";
+const char * const MSG_M221_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_M221_INVALID_EXTRUDER_EN,
+	MSG_M221_INVALID_EXTRUDER_CZ,
+	MSG_M221_INVALID_EXTRUDER_IT,
+	MSG_M221_INVALID_EXTRUDER_ES,
+	MSG_M221_INVALID_EXTRUDER_PL
+};
+
+const char MSG_MAIN_EN[] PROGMEM = "Main";
+const char MSG_MAIN_CZ[] PROGMEM = "Hlavni nabidka";
+const char MSG_MAIN_IT[] PROGMEM = "Menu principale";
+const char MSG_MAIN_ES[] PROGMEM = "Menu principal";
+const char MSG_MAIN_PL[] PROGMEM = "Menu glowne";
+const char * const MSG_MAIN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MAIN_EN,
+	MSG_MAIN_CZ,
+	MSG_MAIN_IT,
+	MSG_MAIN_ES,
+	MSG_MAIN_PL
+};
+
+const char MSG_MAX_EN[] PROGMEM = " \002 Max";
+const char MSG_MAX_CZ[] PROGMEM = " \002 Max";
+const char MSG_MAX_IT[] PROGMEM = " \002 Max";
+const char MSG_MAX_ES[] PROGMEM = " \002 Max";
+const char MSG_MAX_PL[] PROGMEM = " \002 Max";
+const char * const MSG_MAX_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MAX_EN,
+	MSG_MAX_CZ,
+	MSG_MAX_IT,
+	MSG_MAX_ES,
+	MSG_MAX_PL
+};
+
+const char MSG_MIN_EN[] PROGMEM = " \002 Min";
+const char MSG_MIN_CZ[] PROGMEM = " \002 Min";
+const char MSG_MIN_IT[] PROGMEM = " \002 Min";
+const char MSG_MIN_ES[] PROGMEM = " \002 Min";
+const char MSG_MIN_PL[] PROGMEM = " \002 Min";
+const char * const MSG_MIN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MIN_EN,
+	MSG_MIN_CZ,
+	MSG_MIN_IT,
+	MSG_MIN_ES,
+	MSG_MIN_PL
+};
+
+const char MSG_MOTION_EN[] PROGMEM = "Motion";
+const char MSG_MOTION_CZ[] PROGMEM = "Pohyb";
+const char MSG_MOTION_IT[] PROGMEM = "Motion";
+const char MSG_MOTION_ES[] PROGMEM = "Motion";
+const char MSG_MOTION_PL[] PROGMEM = "Pohyb";
+const char * const MSG_MOTION_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOTION_EN,
+	MSG_MOTION_CZ,
+	MSG_MOTION_IT,
+	MSG_MOTION_ES,
+	MSG_MOTION_PL
+};
+
+const char MSG_MOVE_01MM_EN[] PROGMEM = "Move 0.1mm";
+const char MSG_MOVE_01MM_CZ[] PROGMEM = "Posunout o 0.1mm";
+const char MSG_MOVE_01MM_IT[] PROGMEM = "Move 0.1mm";
+const char MSG_MOVE_01MM_ES[] PROGMEM = "Move 0.1mm";
+const char MSG_MOVE_01MM_PL[] PROGMEM = "Posunout o 0.1mm";
+const char * const MSG_MOVE_01MM_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_01MM_EN,
+	MSG_MOVE_01MM_CZ,
+	MSG_MOVE_01MM_IT,
+	MSG_MOVE_01MM_ES,
+	MSG_MOVE_01MM_PL
+};
+
+const char MSG_MOVE_10MM_EN[] PROGMEM = "Move 10mm";
+const char MSG_MOVE_10MM_CZ[] PROGMEM = "Posunout o 10mm";
+const char MSG_MOVE_10MM_IT[] PROGMEM = "Move 10mm";
+const char MSG_MOVE_10MM_ES[] PROGMEM = "Move 10mm";
+const char MSG_MOVE_10MM_PL[] PROGMEM = "Posunout o 10mm";
+const char * const MSG_MOVE_10MM_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_10MM_EN,
+	MSG_MOVE_10MM_CZ,
+	MSG_MOVE_10MM_IT,
+	MSG_MOVE_10MM_ES,
+	MSG_MOVE_10MM_PL
+};
+
+const char MSG_MOVE_1MM_EN[] PROGMEM = "Move 1mm";
+const char MSG_MOVE_1MM_CZ[] PROGMEM = "Posunout o 1mm";
+const char MSG_MOVE_1MM_IT[] PROGMEM = "Move 1mm";
+const char MSG_MOVE_1MM_ES[] PROGMEM = "Move 1mm";
+const char MSG_MOVE_1MM_PL[] PROGMEM = "Posunout o 1mm";
+const char * const MSG_MOVE_1MM_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_1MM_EN,
+	MSG_MOVE_1MM_CZ,
+	MSG_MOVE_1MM_IT,
+	MSG_MOVE_1MM_ES,
+	MSG_MOVE_1MM_PL
+};
+
+const char MSG_MOVE_AXIS_EN[] PROGMEM = "Move axis";
+const char MSG_MOVE_AXIS_CZ[] PROGMEM = "Posunout osu";
+const char MSG_MOVE_AXIS_IT[] PROGMEM = "Muovi Asse";
+const char MSG_MOVE_AXIS_ES[] PROGMEM = "Mover ejes";
+const char MSG_MOVE_AXIS_PL[] PROGMEM = "Ruch osi";
+const char * const MSG_MOVE_AXIS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_AXIS_EN,
+	MSG_MOVE_AXIS_CZ,
+	MSG_MOVE_AXIS_IT,
+	MSG_MOVE_AXIS_ES,
+	MSG_MOVE_AXIS_PL
+};
+
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_EN[] PROGMEM = "Calibrating the machine.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_CZ[] PROGMEM = "Calibrating the machine.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_IT[] PROGMEM = "Calibrating the machine.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_ES[] PROGMEM = "Calibrating the machine.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_PL[] PROGMEM = "Calibrating the machine.";
+const char * const MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_EN,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_CZ,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_IT,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_ES,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_PL
+};
+
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_EN[] PROGMEM = "Please move the Z carriage up";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_CZ[] PROGMEM = "Please move the Z carriage up";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_IT[] PROGMEM = "Please move the Z carriage up";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_ES[] PROGMEM = "Please move the Z carriage up";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_PL[] PROGMEM = "Please move the Z carriage up";
+const char * const MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_EN,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_CZ,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_IT,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_ES,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_PL
+};
+
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_EN[] PROGMEM = "to the end stoppers.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_CZ[] PROGMEM = "to the end stoppers.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_IT[] PROGMEM = "to the end stoppers.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_ES[] PROGMEM = "to the end stoppers.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_PL[] PROGMEM = "to the end stoppers.";
+const char * const MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_EN,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_CZ,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_IT,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_ES,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_PL
+};
+
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_EN[] PROGMEM = "Click when done.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_CZ[] PROGMEM = "Click when done.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_IT[] PROGMEM = "Click when done.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_ES[] PROGMEM = "Click when done.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_PL[] PROGMEM = "Click when done.";
+const char * const MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_EN,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_CZ,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_IT,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_ES,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_PL
+};
+
+const char MSG_MOVE_E_EN[] PROGMEM = "Extruder";
+const char MSG_MOVE_E_CZ[] PROGMEM = "Extruder";
+const char MSG_MOVE_E_IT[] PROGMEM = "Estrusore";
+const char MSG_MOVE_E_ES[] PROGMEM = "Extrusor";
+const char MSG_MOVE_E_PL[] PROGMEM = "Extruder";
+const char * const MSG_MOVE_E_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_E_EN,
+	MSG_MOVE_E_CZ,
+	MSG_MOVE_E_IT,
+	MSG_MOVE_E_ES,
+	MSG_MOVE_E_PL
+};
+
+const char MSG_MOVE_E1_EN[] PROGMEM = "Extruder2";
+const char MSG_MOVE_E1_CZ[] PROGMEM = "Extruder2";
+const char MSG_MOVE_E1_IT[] PROGMEM = "Extruder2";
+const char MSG_MOVE_E1_ES[] PROGMEM = "Extruder2";
+const char MSG_MOVE_E1_PL[] PROGMEM = "Extruder2";
+const char * const MSG_MOVE_E1_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_E1_EN,
+	MSG_MOVE_E1_CZ,
+	MSG_MOVE_E1_IT,
+	MSG_MOVE_E1_ES,
+	MSG_MOVE_E1_PL
+};
+
+const char MSG_MOVE_E2_EN[] PROGMEM = "Extruder3";
+const char MSG_MOVE_E2_CZ[] PROGMEM = "Extruder3";
+const char MSG_MOVE_E2_IT[] PROGMEM = "Extruder3";
+const char MSG_MOVE_E2_ES[] PROGMEM = "Extruder3";
+const char MSG_MOVE_E2_PL[] PROGMEM = "Extruder3";
+const char * const MSG_MOVE_E2_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_E2_EN,
+	MSG_MOVE_E2_CZ,
+	MSG_MOVE_E2_IT,
+	MSG_MOVE_E2_ES,
+	MSG_MOVE_E2_PL
+};
+
+const char MSG_MOVE_X_EN[] PROGMEM = "Move X";
+const char MSG_MOVE_X_CZ[] PROGMEM = "Posunout X";
+const char MSG_MOVE_X_IT[] PROGMEM = "Muovi X";
+const char MSG_MOVE_X_ES[] PROGMEM = "Mover X";
+const char MSG_MOVE_X_PL[] PROGMEM = "Przesunac X";
+const char * const MSG_MOVE_X_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_X_EN,
+	MSG_MOVE_X_CZ,
+	MSG_MOVE_X_IT,
+	MSG_MOVE_X_ES,
+	MSG_MOVE_X_PL
+};
+
+const char MSG_MOVE_Y_EN[] PROGMEM = "Move Y";
+const char MSG_MOVE_Y_CZ[] PROGMEM = "Posunout Y";
+const char MSG_MOVE_Y_IT[] PROGMEM = "Muovi Y";
+const char MSG_MOVE_Y_ES[] PROGMEM = "Mover Y";
+const char MSG_MOVE_Y_PL[] PROGMEM = "Przesunac Y";
+const char * const MSG_MOVE_Y_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_Y_EN,
+	MSG_MOVE_Y_CZ,
+	MSG_MOVE_Y_IT,
+	MSG_MOVE_Y_ES,
+	MSG_MOVE_Y_PL
+};
+
+const char MSG_MOVE_Z_EN[] PROGMEM = "Move Z";
+const char MSG_MOVE_Z_CZ[] PROGMEM = "Posunout Z";
+const char MSG_MOVE_Z_IT[] PROGMEM = "Muovi Z";
+const char MSG_MOVE_Z_ES[] PROGMEM = "Mover Z";
+const char MSG_MOVE_Z_PL[] PROGMEM = "Przesunac Z";
+const char * const MSG_MOVE_Z_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_MOVE_Z_EN,
+	MSG_MOVE_Z_CZ,
+	MSG_MOVE_Z_IT,
+	MSG_MOVE_Z_ES,
+	MSG_MOVE_Z_PL
+};
+
+const char MSG_NO_EN[] PROGMEM = "No";
+const char MSG_NO_CZ[] PROGMEM = "Ne";
+const char MSG_NO_IT[] PROGMEM = "No";
+const char MSG_NO_ES[] PROGMEM = "No";
+const char MSG_NO_PL[] PROGMEM = "Nie";
+const char * const MSG_NO_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_NO_EN,
+	MSG_NO_CZ,
+	MSG_NO_IT,
+	MSG_NO_ES,
+	MSG_NO_PL
+};
+
+const char MSG_NOT_COLOR_EN[] PROGMEM = "Color not clear";
+const char MSG_NOT_COLOR_CZ[] PROGMEM = "Barva neni cista";
+const char MSG_NOT_COLOR_IT[] PROGMEM = "Color no claro";
+const char MSG_NOT_COLOR_ES[] PROGMEM = "Color no claro";
+const char MSG_NOT_COLOR_PL[] PROGMEM = "Kolor zanieczysz.";
+const char * const MSG_NOT_COLOR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_NOT_COLOR_EN,
+	MSG_NOT_COLOR_CZ,
+	MSG_NOT_COLOR_IT,
+	MSG_NOT_COLOR_ES,
+	MSG_NOT_COLOR_PL
+};
+
+const char MSG_NOT_LOADED_EN[] PROGMEM = "Filament not loaded";
+const char MSG_NOT_LOADED_CZ[] PROGMEM = "Filament nezaveden";
+const char MSG_NOT_LOADED_IT[] PROGMEM = "Fil. no cargado";
+const char MSG_NOT_LOADED_ES[] PROGMEM = "Fil. no cargado";
+const char MSG_NOT_LOADED_PL[] PROGMEM = "Brak filamentu";
+const char * const MSG_NOT_LOADED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_NOT_LOADED_EN,
+	MSG_NOT_LOADED_CZ,
+	MSG_NOT_LOADED_IT,
+	MSG_NOT_LOADED_ES,
+	MSG_NOT_LOADED_PL
+};
+
+const char MSG_NOZZLE_EN[] PROGMEM = "Nozzle";
+const char MSG_NOZZLE_CZ[] PROGMEM = "Tryska";
+const char MSG_NOZZLE_IT[] PROGMEM = "Ugello";
+const char MSG_NOZZLE_ES[] PROGMEM = "Fusor";
+const char MSG_NOZZLE_PL[] PROGMEM = "Dysza";
+const char * const MSG_NOZZLE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_NOZZLE_EN,
+	MSG_NOZZLE_CZ,
+	MSG_NOZZLE_IT,
+	MSG_NOZZLE_ES,
+	MSG_NOZZLE_PL
+};
+
+const char MSG_NOZZLE1_EN[] PROGMEM = "Nozzle2";
+const char MSG_NOZZLE1_CZ[] PROGMEM = "Tryska2";
+const char MSG_NOZZLE1_IT[] PROGMEM = "Nozzle2";
+const char MSG_NOZZLE1_ES[] PROGMEM = "Nozzle2";
+const char MSG_NOZZLE1_PL[] PROGMEM = "Tryska2";
+const char * const MSG_NOZZLE1_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_NOZZLE1_EN,
+	MSG_NOZZLE1_CZ,
+	MSG_NOZZLE1_IT,
+	MSG_NOZZLE1_ES,
+	MSG_NOZZLE1_PL
+};
+
+const char MSG_NOZZLE2_EN[] PROGMEM = "Nozzle3";
+const char MSG_NOZZLE2_CZ[] PROGMEM = "Tryska3";
+const char MSG_NOZZLE2_IT[] PROGMEM = "Nozzle3";
+const char MSG_NOZZLE2_ES[] PROGMEM = "Nozzle3";
+const char MSG_NOZZLE2_PL[] PROGMEM = "Tryska3";
+const char * const MSG_NOZZLE2_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_NOZZLE2_EN,
+	MSG_NOZZLE2_CZ,
+	MSG_NOZZLE2_IT,
+	MSG_NOZZLE2_ES,
+	MSG_NOZZLE2_PL
+};
+
+const char MSG_NO_CARD_EN[] PROGMEM = "No SD card";
+const char MSG_NO_CARD_CZ[] PROGMEM = "Zadna SD karta";
+const char MSG_NO_CARD_IT[] PROGMEM = "No SD Carta";
+const char MSG_NO_CARD_ES[] PROGMEM = "No hay tarjeta SD";
+const char MSG_NO_CARD_PL[] PROGMEM = "Brak karty SD";
+const char * const MSG_NO_CARD_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_NO_CARD_EN,
+	MSG_NO_CARD_CZ,
+	MSG_NO_CARD_IT,
+	MSG_NO_CARD_ES,
+	MSG_NO_CARD_PL
+};
+
+const char MSG_NO_MOVE_EN[] PROGMEM = "No move.";
+const char MSG_NO_MOVE_CZ[] PROGMEM = "No move.";
+const char MSG_NO_MOVE_IT[] PROGMEM = "Nessun Movimento";
+const char MSG_NO_MOVE_ES[] PROGMEM = "Sin movimiento";
+const char MSG_NO_MOVE_PL[] PROGMEM = "No move.";
+const char * const MSG_NO_MOVE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_NO_MOVE_EN,
+	MSG_NO_MOVE_CZ,
+	MSG_NO_MOVE_IT,
+	MSG_NO_MOVE_ES,
+	MSG_NO_MOVE_PL
+};
+
+const char MSG_OFF_EN[] PROGMEM = "Off";
+const char MSG_OFF_CZ[] PROGMEM = "Off";
+const char MSG_OFF_IT[] PROGMEM = "Off";
+const char MSG_OFF_ES[] PROGMEM = "Off";
+const char MSG_OFF_PL[] PROGMEM = "Off";
+const char * const MSG_OFF_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_OFF_EN,
+	MSG_OFF_CZ,
+	MSG_OFF_IT,
+	MSG_OFF_ES,
+	MSG_OFF_PL
+};
+
+const char MSG_OK_EN[] PROGMEM = "ok";
+const char MSG_OK_CZ[] PROGMEM = "ok";
+const char MSG_OK_IT[] PROGMEM = "ok";
+const char MSG_OK_ES[] PROGMEM = "ok";
+const char MSG_OK_PL[] PROGMEM = "ok";
+const char * const MSG_OK_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_OK_EN,
+	MSG_OK_CZ,
+	MSG_OK_IT,
+	MSG_OK_ES,
+	MSG_OK_PL
+};
+
+const char MSG_ON_EN[] PROGMEM = "On ";
+const char MSG_ON_CZ[] PROGMEM = "On ";
+const char MSG_ON_IT[] PROGMEM = "On ";
+const char MSG_ON_ES[] PROGMEM = "On ";
+const char MSG_ON_PL[] PROGMEM = "On ";
+const char * const MSG_ON_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ON_EN,
+	MSG_ON_CZ,
+	MSG_ON_IT,
+	MSG_ON_ES,
+	MSG_ON_PL
+};
+
+const char MSG_PAUSE_PRINT_EN[] PROGMEM = "Pause print";
+const char MSG_PAUSE_PRINT_CZ[] PROGMEM = "Pozastavit tisk";
+const char MSG_PAUSE_PRINT_IT[] PROGMEM = "Pausa";
+const char MSG_PAUSE_PRINT_ES[] PROGMEM = "Pausar impresion";
+const char MSG_PAUSE_PRINT_PL[] PROGMEM = "Przerwac druk";
+const char * const MSG_PAUSE_PRINT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PAUSE_PRINT_EN,
+	MSG_PAUSE_PRINT_CZ,
+	MSG_PAUSE_PRINT_IT,
+	MSG_PAUSE_PRINT_ES,
+	MSG_PAUSE_PRINT_PL
+};
+
+const char MSG_PICK_Z_EN[] PROGMEM = "Pick print";
+const char MSG_PICK_Z_CZ[] PROGMEM = "Vyberte vytisk";
+const char MSG_PICK_Z_IT[] PROGMEM = "Vyberte vytisk";
+const char MSG_PICK_Z_ES[] PROGMEM = "Vyberte vytisk";
+const char MSG_PICK_Z_PL[] PROGMEM = "Vyberte vytisk";
+const char * const MSG_PICK_Z_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PICK_Z_EN,
+	MSG_PICK_Z_CZ,
+	MSG_PICK_Z_IT,
+	MSG_PICK_Z_ES,
+	MSG_PICK_Z_PL
+};
+
+const char MSG_PID_C_EN[] PROGMEM = "PID-C";
+const char MSG_PID_C_CZ[] PROGMEM = "PID-C";
+const char MSG_PID_C_IT[] PROGMEM = "PID-C";
+const char MSG_PID_C_ES[] PROGMEM = "PID-C";
+const char MSG_PID_C_PL[] PROGMEM = "PID-C";
+const char * const MSG_PID_C_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PID_C_EN,
+	MSG_PID_C_CZ,
+	MSG_PID_C_IT,
+	MSG_PID_C_ES,
+	MSG_PID_C_PL
+};
+
+const char MSG_PID_D_EN[] PROGMEM = "PID-D";
+const char MSG_PID_D_CZ[] PROGMEM = "PID-D";
+const char MSG_PID_D_IT[] PROGMEM = "PID-D";
+const char MSG_PID_D_ES[] PROGMEM = "PID-D";
+const char MSG_PID_D_PL[] PROGMEM = "PID-D";
+const char * const MSG_PID_D_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PID_D_EN,
+	MSG_PID_D_CZ,
+	MSG_PID_D_IT,
+	MSG_PID_D_ES,
+	MSG_PID_D_PL
+};
+
+const char MSG_PID_I_EN[] PROGMEM = "PID-I";
+const char MSG_PID_I_CZ[] PROGMEM = "PID-I";
+const char MSG_PID_I_IT[] PROGMEM = "PID-I";
+const char MSG_PID_I_ES[] PROGMEM = "PID-I";
+const char MSG_PID_I_PL[] PROGMEM = "PID-I";
+const char * const MSG_PID_I_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PID_I_EN,
+	MSG_PID_I_CZ,
+	MSG_PID_I_IT,
+	MSG_PID_I_ES,
+	MSG_PID_I_PL
+};
+
+const char MSG_PID_P_EN[] PROGMEM = "PID-P";
+const char MSG_PID_P_CZ[] PROGMEM = "PID-P";
+const char MSG_PID_P_IT[] PROGMEM = "PID-P";
+const char MSG_PID_P_ES[] PROGMEM = "PID-P";
+const char MSG_PID_P_PL[] PROGMEM = "PID-P";
+const char * const MSG_PID_P_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PID_P_EN,
+	MSG_PID_P_CZ,
+	MSG_PID_P_IT,
+	MSG_PID_P_ES,
+	MSG_PID_P_PL
+};
+
+const char MSG_PLANNER_BUFFER_BYTES_EN[] PROGMEM = "  PlannerBufferBytes: ";
+const char MSG_PLANNER_BUFFER_BYTES_CZ[] PROGMEM = "  PlannerBufferBytes: ";
+const char MSG_PLANNER_BUFFER_BYTES_IT[] PROGMEM = "  PlannerBufferBytes: ";
+const char MSG_PLANNER_BUFFER_BYTES_ES[] PROGMEM = "  PlannerBufferBytes: ";
+const char MSG_PLANNER_BUFFER_BYTES_PL[] PROGMEM = "  PlannerBufferBytes: ";
+const char * const MSG_PLANNER_BUFFER_BYTES_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PLANNER_BUFFER_BYTES_EN,
+	MSG_PLANNER_BUFFER_BYTES_CZ,
+	MSG_PLANNER_BUFFER_BYTES_IT,
+	MSG_PLANNER_BUFFER_BYTES_ES,
+	MSG_PLANNER_BUFFER_BYTES_PL
+};
+
+const char MSG_PLEASE_WAIT_EN[] PROGMEM = "Please wait";
+const char MSG_PLEASE_WAIT_CZ[] PROGMEM = "Prosim cekejte";
+const char MSG_PLEASE_WAIT_IT[] PROGMEM = "Aspetta";
+const char MSG_PLEASE_WAIT_ES[] PROGMEM = "Espera";
+const char MSG_PLEASE_WAIT_PL[] PROGMEM = "Prosze czekac";
+const char * const MSG_PLEASE_WAIT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PLEASE_WAIT_EN,
+	MSG_PLEASE_WAIT_CZ,
+	MSG_PLEASE_WAIT_IT,
+	MSG_PLEASE_WAIT_ES,
+	MSG_PLEASE_WAIT_PL
+};
+
+const char MSG_POSITION_UNKNOWN_EN[] PROGMEM = "Home X/Y before Z";
+const char MSG_POSITION_UNKNOWN_CZ[] PROGMEM = "Home X/Y before Z";
+const char MSG_POSITION_UNKNOWN_IT[] PROGMEM = "Home X/Y before Z";
+const char MSG_POSITION_UNKNOWN_ES[] PROGMEM = "Home X/Y before Z";
+const char MSG_POSITION_UNKNOWN_PL[] PROGMEM = "Home X/Y before Z";
+const char * const MSG_POSITION_UNKNOWN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_POSITION_UNKNOWN_EN,
+	MSG_POSITION_UNKNOWN_CZ,
+	MSG_POSITION_UNKNOWN_IT,
+	MSG_POSITION_UNKNOWN_ES,
+	MSG_POSITION_UNKNOWN_PL
+};
+
+const char MSG_POWERUP_EN[] PROGMEM = "PowerUp";
+const char MSG_POWERUP_CZ[] PROGMEM = "PowerUp";
+const char MSG_POWERUP_IT[] PROGMEM = "PowerUp";
+const char MSG_POWERUP_ES[] PROGMEM = "PowerUp";
+const char MSG_POWERUP_PL[] PROGMEM = "PowerUp";
+const char * const MSG_POWERUP_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_POWERUP_EN,
+	MSG_POWERUP_CZ,
+	MSG_POWERUP_IT,
+	MSG_POWERUP_ES,
+	MSG_POWERUP_PL
+};
+
+const char MSG_PREHEAT_EN[] PROGMEM = "Preheat";
+const char MSG_PREHEAT_CZ[] PROGMEM = "Predehrev";
+const char MSG_PREHEAT_IT[] PROGMEM = "Preriscalda";
+const char MSG_PREHEAT_ES[] PROGMEM = "Precalentar";
+const char MSG_PREHEAT_PL[] PROGMEM = "Grzanie";
+const char * const MSG_PREHEAT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_EN,
+	MSG_PREHEAT_CZ,
+	MSG_PREHEAT_IT,
+	MSG_PREHEAT_ES,
+	MSG_PREHEAT_PL
+};
+
+const char MSG_PREHEAT_ABS_EN[] PROGMEM = "Preheat ABS";
+const char MSG_PREHEAT_ABS_CZ[] PROGMEM = "Predehrev ABS";
+const char MSG_PREHEAT_ABS_IT[] PROGMEM = "Preheat ABS";
+const char MSG_PREHEAT_ABS_ES[] PROGMEM = "Preheat ABS";
+const char MSG_PREHEAT_ABS_PL[] PROGMEM = "Predehrev ABS";
+const char * const MSG_PREHEAT_ABS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_ABS_EN,
+	MSG_PREHEAT_ABS_CZ,
+	MSG_PREHEAT_ABS_IT,
+	MSG_PREHEAT_ABS_ES,
+	MSG_PREHEAT_ABS_PL
+};
+
+const char MSG_PREHEAT_ABS0_EN[] PROGMEM = "Preheat ABS 1";
+const char MSG_PREHEAT_ABS0_CZ[] PROGMEM = "Predehrev ABS 1";
+const char MSG_PREHEAT_ABS0_IT[] PROGMEM = "Preheat ABS 1";
+const char MSG_PREHEAT_ABS0_ES[] PROGMEM = "Preheat ABS 1";
+const char MSG_PREHEAT_ABS0_PL[] PROGMEM = "Predehrev ABS 1";
+const char * const MSG_PREHEAT_ABS0_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_ABS0_EN,
+	MSG_PREHEAT_ABS0_CZ,
+	MSG_PREHEAT_ABS0_IT,
+	MSG_PREHEAT_ABS0_ES,
+	MSG_PREHEAT_ABS0_PL
+};
+
+const char MSG_PREHEAT_ABS012_EN[] PROGMEM = "Preheat ABS All";
+const char MSG_PREHEAT_ABS012_CZ[] PROGMEM = "Predehrev ABS All";
+const char MSG_PREHEAT_ABS012_IT[] PROGMEM = "Preheat ABS All";
+const char MSG_PREHEAT_ABS012_ES[] PROGMEM = "Preheat ABS All";
+const char MSG_PREHEAT_ABS012_PL[] PROGMEM = "Predehrev ABS All";
+const char * const MSG_PREHEAT_ABS012_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_ABS012_EN,
+	MSG_PREHEAT_ABS012_CZ,
+	MSG_PREHEAT_ABS012_IT,
+	MSG_PREHEAT_ABS012_ES,
+	MSG_PREHEAT_ABS012_PL
+};
+
+const char MSG_PREHEAT_ABS1_EN[] PROGMEM = "Preheat ABS 2";
+const char MSG_PREHEAT_ABS1_CZ[] PROGMEM = "Predehrev ABS 2";
+const char MSG_PREHEAT_ABS1_IT[] PROGMEM = "Preheat ABS 2";
+const char MSG_PREHEAT_ABS1_ES[] PROGMEM = "Preheat ABS 2";
+const char MSG_PREHEAT_ABS1_PL[] PROGMEM = "Predehrev ABS 2";
+const char * const MSG_PREHEAT_ABS1_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_ABS1_EN,
+	MSG_PREHEAT_ABS1_CZ,
+	MSG_PREHEAT_ABS1_IT,
+	MSG_PREHEAT_ABS1_ES,
+	MSG_PREHEAT_ABS1_PL
+};
+
+const char MSG_PREHEAT_ABS2_EN[] PROGMEM = "Preheat ABS 3";
+const char MSG_PREHEAT_ABS2_CZ[] PROGMEM = "Predehrev ABS 3";
+const char MSG_PREHEAT_ABS2_IT[] PROGMEM = "Preheat ABS 3";
+const char MSG_PREHEAT_ABS2_ES[] PROGMEM = "Preheat ABS 3";
+const char MSG_PREHEAT_ABS2_PL[] PROGMEM = "Predehrev ABS 3";
+const char * const MSG_PREHEAT_ABS2_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_ABS2_EN,
+	MSG_PREHEAT_ABS2_CZ,
+	MSG_PREHEAT_ABS2_IT,
+	MSG_PREHEAT_ABS2_ES,
+	MSG_PREHEAT_ABS2_PL
+};
+
+const char MSG_PREHEAT_ABS_BEDONLY_EN[] PROGMEM = "Preheat ABS Bed";
+const char MSG_PREHEAT_ABS_BEDONLY_CZ[] PROGMEM = "Predehrev ABS Bed";
+const char MSG_PREHEAT_ABS_BEDONLY_IT[] PROGMEM = "Preheat ABS Bed";
+const char MSG_PREHEAT_ABS_BEDONLY_ES[] PROGMEM = "Preheat ABS Bed";
+const char MSG_PREHEAT_ABS_BEDONLY_PL[] PROGMEM = "Predehrev ABS Bed";
+const char * const MSG_PREHEAT_ABS_BEDONLY_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_ABS_BEDONLY_EN,
+	MSG_PREHEAT_ABS_BEDONLY_CZ,
+	MSG_PREHEAT_ABS_BEDONLY_IT,
+	MSG_PREHEAT_ABS_BEDONLY_ES,
+	MSG_PREHEAT_ABS_BEDONLY_PL
+};
+
+const char MSG_PREHEAT_ABS_SETTINGS_EN[] PROGMEM = "Preheat ABS conf";
+const char MSG_PREHEAT_ABS_SETTINGS_CZ[] PROGMEM = "Predehrev ABS conf";
+const char MSG_PREHEAT_ABS_SETTINGS_IT[] PROGMEM = "Preheat ABS conf";
+const char MSG_PREHEAT_ABS_SETTINGS_ES[] PROGMEM = "Preheat ABS conf";
+const char MSG_PREHEAT_ABS_SETTINGS_PL[] PROGMEM = "Predehrev ABS conf";
+const char * const MSG_PREHEAT_ABS_SETTINGS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_ABS_SETTINGS_EN,
+	MSG_PREHEAT_ABS_SETTINGS_CZ,
+	MSG_PREHEAT_ABS_SETTINGS_IT,
+	MSG_PREHEAT_ABS_SETTINGS_ES,
+	MSG_PREHEAT_ABS_SETTINGS_PL
+};
+
+const char MSG_PREHEAT_NOZZLE_EN[] PROGMEM = "Preheat the nozzle!";
+const char MSG_PREHEAT_NOZZLE_CZ[] PROGMEM = "Predehrejte trysku!";
+const char MSG_PREHEAT_NOZZLE_IT[] PROGMEM = "Preris. ugello!";
+const char MSG_PREHEAT_NOZZLE_ES[] PROGMEM = "Precal. extrusor!";
+const char MSG_PREHEAT_NOZZLE_PL[] PROGMEM = "Nagrzej dysze!";
+const char * const MSG_PREHEAT_NOZZLE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_NOZZLE_EN,
+	MSG_PREHEAT_NOZZLE_CZ,
+	MSG_PREHEAT_NOZZLE_IT,
+	MSG_PREHEAT_NOZZLE_ES,
+	MSG_PREHEAT_NOZZLE_PL
+};
+
+const char MSG_PREHEAT_PLA_EN[] PROGMEM = "Preheat PLA";
+const char MSG_PREHEAT_PLA_CZ[] PROGMEM = "Predehrev PLA";
+const char MSG_PREHEAT_PLA_IT[] PROGMEM = "Preheat PLA";
+const char MSG_PREHEAT_PLA_ES[] PROGMEM = "Preheat PLA";
+const char MSG_PREHEAT_PLA_PL[] PROGMEM = "Predehrev PLA";
+const char * const MSG_PREHEAT_PLA_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_PLA_EN,
+	MSG_PREHEAT_PLA_CZ,
+	MSG_PREHEAT_PLA_IT,
+	MSG_PREHEAT_PLA_ES,
+	MSG_PREHEAT_PLA_PL
+};
+
+const char MSG_PREHEAT_PLA0_EN[] PROGMEM = "Preheat PLA 1";
+const char MSG_PREHEAT_PLA0_CZ[] PROGMEM = "Predehrev PLA 1";
+const char MSG_PREHEAT_PLA0_IT[] PROGMEM = "Preheat PLA 1";
+const char MSG_PREHEAT_PLA0_ES[] PROGMEM = "Preheat PLA 1";
+const char MSG_PREHEAT_PLA0_PL[] PROGMEM = "Predehrev PLA 1";
+const char * const MSG_PREHEAT_PLA0_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_PLA0_EN,
+	MSG_PREHEAT_PLA0_CZ,
+	MSG_PREHEAT_PLA0_IT,
+	MSG_PREHEAT_PLA0_ES,
+	MSG_PREHEAT_PLA0_PL
+};
+
+const char MSG_PREHEAT_PLA012_EN[] PROGMEM = "Preheat PLA All";
+const char MSG_PREHEAT_PLA012_CZ[] PROGMEM = "Predehrev PLA All";
+const char MSG_PREHEAT_PLA012_IT[] PROGMEM = "Preheat PLA All";
+const char MSG_PREHEAT_PLA012_ES[] PROGMEM = "Preheat PLA All";
+const char MSG_PREHEAT_PLA012_PL[] PROGMEM = "Predehrev PLA All";
+const char * const MSG_PREHEAT_PLA012_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_PLA012_EN,
+	MSG_PREHEAT_PLA012_CZ,
+	MSG_PREHEAT_PLA012_IT,
+	MSG_PREHEAT_PLA012_ES,
+	MSG_PREHEAT_PLA012_PL
+};
+
+const char MSG_PREHEAT_PLA1_EN[] PROGMEM = "Preheat PLA 2";
+const char MSG_PREHEAT_PLA1_CZ[] PROGMEM = "Predehrev PLA 2";
+const char MSG_PREHEAT_PLA1_IT[] PROGMEM = "Preheat PLA 2";
+const char MSG_PREHEAT_PLA1_ES[] PROGMEM = "Preheat PLA 2";
+const char MSG_PREHEAT_PLA1_PL[] PROGMEM = "Predehrev PLA 2";
+const char * const MSG_PREHEAT_PLA1_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_PLA1_EN,
+	MSG_PREHEAT_PLA1_CZ,
+	MSG_PREHEAT_PLA1_IT,
+	MSG_PREHEAT_PLA1_ES,
+	MSG_PREHEAT_PLA1_PL
+};
+
+const char MSG_PREHEAT_PLA2_EN[] PROGMEM = "Preheat PLA 3";
+const char MSG_PREHEAT_PLA2_CZ[] PROGMEM = "Predehrev PLA 3";
+const char MSG_PREHEAT_PLA2_IT[] PROGMEM = "Preheat PLA 3";
+const char MSG_PREHEAT_PLA2_ES[] PROGMEM = "Preheat PLA 3";
+const char MSG_PREHEAT_PLA2_PL[] PROGMEM = "Predehrev PLA 3";
+const char * const MSG_PREHEAT_PLA2_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_PLA2_EN,
+	MSG_PREHEAT_PLA2_CZ,
+	MSG_PREHEAT_PLA2_IT,
+	MSG_PREHEAT_PLA2_ES,
+	MSG_PREHEAT_PLA2_PL
+};
+
+const char MSG_PREHEAT_PLA_BEDONLY_EN[] PROGMEM = "Preheat PLA Bed";
+const char MSG_PREHEAT_PLA_BEDONLY_CZ[] PROGMEM = "Predehrev PLA Bed";
+const char MSG_PREHEAT_PLA_BEDONLY_IT[] PROGMEM = "Preheat PLA Bed";
+const char MSG_PREHEAT_PLA_BEDONLY_ES[] PROGMEM = "Preheat PLA Bed";
+const char MSG_PREHEAT_PLA_BEDONLY_PL[] PROGMEM = "Predehrev PLA Bed";
+const char * const MSG_PREHEAT_PLA_BEDONLY_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_PLA_BEDONLY_EN,
+	MSG_PREHEAT_PLA_BEDONLY_CZ,
+	MSG_PREHEAT_PLA_BEDONLY_IT,
+	MSG_PREHEAT_PLA_BEDONLY_ES,
+	MSG_PREHEAT_PLA_BEDONLY_PL
+};
+
+const char MSG_PREHEAT_PLA_SETTINGS_EN[] PROGMEM = "Preheat PLA conf";
+const char MSG_PREHEAT_PLA_SETTINGS_CZ[] PROGMEM = "Predehrev PLA conf";
+const char MSG_PREHEAT_PLA_SETTINGS_IT[] PROGMEM = "Preheat PLA conf";
+const char MSG_PREHEAT_PLA_SETTINGS_ES[] PROGMEM = "Preheat PLA conf";
+const char MSG_PREHEAT_PLA_SETTINGS_PL[] PROGMEM = "Predehrev PLA conf";
+const char * const MSG_PREHEAT_PLA_SETTINGS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREHEAT_PLA_SETTINGS_EN,
+	MSG_PREHEAT_PLA_SETTINGS_CZ,
+	MSG_PREHEAT_PLA_SETTINGS_IT,
+	MSG_PREHEAT_PLA_SETTINGS_ES,
+	MSG_PREHEAT_PLA_SETTINGS_PL
+};
+
+const char MSG_PREPARE_EN[] PROGMEM = "Prepare";
+const char MSG_PREPARE_CZ[] PROGMEM = "Priprava";
+const char MSG_PREPARE_IT[] PROGMEM = "Prepare";
+const char MSG_PREPARE_ES[] PROGMEM = "Prepare";
+const char MSG_PREPARE_PL[] PROGMEM = "Priprava";
+const char * const MSG_PREPARE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PREPARE_EN,
+	MSG_PREPARE_CZ,
+	MSG_PREPARE_IT,
+	MSG_PREPARE_ES,
+	MSG_PREPARE_PL
+};
+
+const char MSG_PRESS_EN[] PROGMEM = "And press the knob";
+const char MSG_PRESS_CZ[] PROGMEM = "A stisknete tlacitko";
+const char MSG_PRESS_IT[] PROGMEM = "Y pulse el mando";
+const char MSG_PRESS_ES[] PROGMEM = "Y pulse el mando";
+const char MSG_PRESS_PL[] PROGMEM = "Nacisnij przycisk";
+const char * const MSG_PRESS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PRESS_EN,
+	MSG_PRESS_CZ,
+	MSG_PRESS_IT,
+	MSG_PRESS_ES,
+	MSG_PRESS_PL
+};
+
+const char MSG_PRINT_ABORTED_EN[] PROGMEM = "Print aborted";
+const char MSG_PRINT_ABORTED_CZ[] PROGMEM = "Tisk prerusen";
+const char MSG_PRINT_ABORTED_IT[] PROGMEM = "Stampa abortita";
+const char MSG_PRINT_ABORTED_ES[] PROGMEM = "Print aborted";
+const char MSG_PRINT_ABORTED_PL[] PROGMEM = "Druk przerwany";
+const char * const MSG_PRINT_ABORTED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PRINT_ABORTED_EN,
+	MSG_PRINT_ABORTED_CZ,
+	MSG_PRINT_ABORTED_IT,
+	MSG_PRINT_ABORTED_ES,
+	MSG_PRINT_ABORTED_PL
+};
+
+const char MSG_PRUSA3D_EN[] PROGMEM = "prusa3d.com";
+const char MSG_PRUSA3D_CZ[] PROGMEM = "prusa3d.cz";
+const char MSG_PRUSA3D_IT[] PROGMEM = "prusa3d.com";
+const char MSG_PRUSA3D_ES[] PROGMEM = "prusa3d.com";
+const char MSG_PRUSA3D_PL[] PROGMEM = "prusa3d.cz";
+const char * const MSG_PRUSA3D_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PRUSA3D_EN,
+	MSG_PRUSA3D_CZ,
+	MSG_PRUSA3D_IT,
+	MSG_PRUSA3D_ES,
+	MSG_PRUSA3D_PL
+};
+
+const char MSG_PRUSA3D_FORUM_EN[] PROGMEM = "forum.prusa3d.com";
+const char MSG_PRUSA3D_FORUM_CZ[] PROGMEM = "forum.prusa3d.cz";
+const char MSG_PRUSA3D_FORUM_IT[] PROGMEM = "forum.prusa3d.com";
+const char MSG_PRUSA3D_FORUM_ES[] PROGMEM = "forum.prusa3d.com";
+const char MSG_PRUSA3D_FORUM_PL[] PROGMEM = "forum.prusa3d.cz";
+const char * const MSG_PRUSA3D_FORUM_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PRUSA3D_FORUM_EN,
+	MSG_PRUSA3D_FORUM_CZ,
+	MSG_PRUSA3D_FORUM_IT,
+	MSG_PRUSA3D_FORUM_ES,
+	MSG_PRUSA3D_FORUM_PL
+};
+
+const char MSG_PRUSA3D_HOWTO_EN[] PROGMEM = "howto.prusa3d.com";
+const char MSG_PRUSA3D_HOWTO_CZ[] PROGMEM = "howto.prusa3d.cz";
+const char MSG_PRUSA3D_HOWTO_IT[] PROGMEM = "howto.prusa3d.com";
+const char MSG_PRUSA3D_HOWTO_ES[] PROGMEM = "howto.prusa3d.com";
+const char MSG_PRUSA3D_HOWTO_PL[] PROGMEM = "howto.prusa3d.cz";
+const char * const MSG_PRUSA3D_HOWTO_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_PRUSA3D_HOWTO_EN,
+	MSG_PRUSA3D_HOWTO_CZ,
+	MSG_PRUSA3D_HOWTO_IT,
+	MSG_PRUSA3D_HOWTO_ES,
+	MSG_PRUSA3D_HOWTO_PL
+};
+
+const char MSG_REBOOT_EN[] PROGMEM = "Reboot the printer";
+const char MSG_REBOOT_CZ[] PROGMEM = "Restartujte tiskarnu";
+const char MSG_REBOOT_IT[] PROGMEM = "Riavvio la stamp.";
+const char MSG_REBOOT_ES[] PROGMEM = "Reiniciar la imp.";
+const char MSG_REBOOT_PL[] PROGMEM = "Restart drukarki";
+const char * const MSG_REBOOT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_REBOOT_EN,
+	MSG_REBOOT_CZ,
+	MSG_REBOOT_IT,
+	MSG_REBOOT_ES,
+	MSG_REBOOT_PL
+};
+
+const char MSG_RECTRACT_EN[] PROGMEM = "Rectract";
+const char MSG_RECTRACT_CZ[] PROGMEM = "Rectract";
+const char MSG_RECTRACT_IT[] PROGMEM = "Rectract";
+const char MSG_RECTRACT_ES[] PROGMEM = "Rectract";
+const char MSG_RECTRACT_PL[] PROGMEM = "Rectract";
+const char * const MSG_RECTRACT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_RECTRACT_EN,
+	MSG_RECTRACT_CZ,
+	MSG_RECTRACT_IT,
+	MSG_RECTRACT_ES,
+	MSG_RECTRACT_PL
+};
+
+const char MSG_REFRESH_EN[] PROGMEM = "Refresh";
+const char MSG_REFRESH_CZ[] PROGMEM = "Obnovit";
+const char MSG_REFRESH_IT[] PROGMEM = "Refresh";
+const char MSG_REFRESH_ES[] PROGMEM = "Refresh";
+const char MSG_REFRESH_PL[] PROGMEM = "Obnovit";
+const char * const MSG_REFRESH_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_REFRESH_EN,
+	MSG_REFRESH_CZ,
+	MSG_REFRESH_IT,
+	MSG_REFRESH_ES,
+	MSG_REFRESH_PL
+};
+
+const char MSG_RESEND_EN[] PROGMEM = "Resend: ";
+const char MSG_RESEND_CZ[] PROGMEM = "Resend: ";
+const char MSG_RESEND_IT[] PROGMEM = "Resend: ";
+const char MSG_RESEND_ES[] PROGMEM = "Resend: ";
+const char MSG_RESEND_PL[] PROGMEM = "Resend: ";
+const char * const MSG_RESEND_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_RESEND_EN,
+	MSG_RESEND_CZ,
+	MSG_RESEND_IT,
+	MSG_RESEND_ES,
+	MSG_RESEND_PL
+};
+
+const char MSG_RESTORE_FAILSAFE_EN[] PROGMEM = "Restore failsafe";
+const char MSG_RESTORE_FAILSAFE_CZ[] PROGMEM = "Obnovit vychozi";
+const char MSG_RESTORE_FAILSAFE_IT[] PROGMEM = "Restore failsafe";
+const char MSG_RESTORE_FAILSAFE_ES[] PROGMEM = "Restore failsafe";
+const char MSG_RESTORE_FAILSAFE_PL[] PROGMEM = "Obnovit vychozi";
+const char * const MSG_RESTORE_FAILSAFE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_RESTORE_FAILSAFE_EN,
+	MSG_RESTORE_FAILSAFE_CZ,
+	MSG_RESTORE_FAILSAFE_IT,
+	MSG_RESTORE_FAILSAFE_ES,
+	MSG_RESTORE_FAILSAFE_PL
+};
+
+const char MSG_RESUME_PRINT_EN[] PROGMEM = "Resume print";
+const char MSG_RESUME_PRINT_CZ[] PROGMEM = "Pokracovat";
+const char MSG_RESUME_PRINT_IT[] PROGMEM = "Riprendi stampa";
+const char MSG_RESUME_PRINT_ES[] PROGMEM = "Reanudar impres.";
+const char MSG_RESUME_PRINT_PL[] PROGMEM = "Kontynuowac";
+const char * const MSG_RESUME_PRINT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_RESUME_PRINT_EN,
+	MSG_RESUME_PRINT_CZ,
+	MSG_RESUME_PRINT_IT,
+	MSG_RESUME_PRINT_ES,
+	MSG_RESUME_PRINT_PL
+};
+
+const char MSG_RESUMING_EN[] PROGMEM = "Resuming print";
+const char MSG_RESUMING_CZ[] PROGMEM = "Obnoveni tisku";
+const char MSG_RESUMING_IT[] PROGMEM = "Riprendi Stampa";
+const char MSG_RESUMING_ES[] PROGMEM = "Resumiendo impre.";
+const char MSG_RESUMING_PL[] PROGMEM = "Wznowienie druku";
+const char * const MSG_RESUMING_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_RESUMING_EN,
+	MSG_RESUMING_CZ,
+	MSG_RESUMING_IT,
+	MSG_RESUMING_ES,
+	MSG_RESUMING_PL
+};
+
+const char MSG_RETRACT_EN[] PROGMEM = "Retract";
+const char MSG_RETRACT_CZ[] PROGMEM = "Retract";
+const char MSG_RETRACT_IT[] PROGMEM = "Retract";
+const char MSG_RETRACT_ES[] PROGMEM = "Retract";
+const char MSG_RETRACT_PL[] PROGMEM = "Retract";
+const char * const MSG_RETRACT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_RETRACT_EN,
+	MSG_RETRACT_CZ,
+	MSG_RETRACT_IT,
+	MSG_RETRACT_ES,
+	MSG_RETRACT_PL
+};
+
+const char MSG_SD_CANT_ENTER_SUBDIR_EN[] PROGMEM = "Cannot enter subdir: ";
+const char MSG_SD_CANT_ENTER_SUBDIR_CZ[] PROGMEM = "Cannot enter subdir: ";
+const char MSG_SD_CANT_ENTER_SUBDIR_IT[] PROGMEM = "Cannot enter subdir: ";
+const char MSG_SD_CANT_ENTER_SUBDIR_ES[] PROGMEM = "Cannot enter subdir: ";
+const char MSG_SD_CANT_ENTER_SUBDIR_PL[] PROGMEM = "Cannot enter subdir: ";
+const char * const MSG_SD_CANT_ENTER_SUBDIR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_CANT_ENTER_SUBDIR_EN,
+	MSG_SD_CANT_ENTER_SUBDIR_CZ,
+	MSG_SD_CANT_ENTER_SUBDIR_IT,
+	MSG_SD_CANT_ENTER_SUBDIR_ES,
+	MSG_SD_CANT_ENTER_SUBDIR_PL
+};
+
+const char MSG_SD_CANT_OPEN_SUBDIR_EN[] PROGMEM = "Cannot open subdir";
+const char MSG_SD_CANT_OPEN_SUBDIR_CZ[] PROGMEM = "Cannot open subdir";
+const char MSG_SD_CANT_OPEN_SUBDIR_IT[] PROGMEM = "Cannot open subdir";
+const char MSG_SD_CANT_OPEN_SUBDIR_ES[] PROGMEM = "Cannot open subdir";
+const char MSG_SD_CANT_OPEN_SUBDIR_PL[] PROGMEM = "Cannot open subdir";
+const char * const MSG_SD_CANT_OPEN_SUBDIR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_CANT_OPEN_SUBDIR_EN,
+	MSG_SD_CANT_OPEN_SUBDIR_CZ,
+	MSG_SD_CANT_OPEN_SUBDIR_IT,
+	MSG_SD_CANT_OPEN_SUBDIR_ES,
+	MSG_SD_CANT_OPEN_SUBDIR_PL
+};
+
+const char MSG_SD_CARD_OK_EN[] PROGMEM = "SD card ok";
+const char MSG_SD_CARD_OK_CZ[] PROGMEM = "SD card ok";
+const char MSG_SD_CARD_OK_IT[] PROGMEM = "SD card ok";
+const char MSG_SD_CARD_OK_ES[] PROGMEM = "SD card ok";
+const char MSG_SD_CARD_OK_PL[] PROGMEM = "SD card ok";
+const char * const MSG_SD_CARD_OK_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_CARD_OK_EN,
+	MSG_SD_CARD_OK_CZ,
+	MSG_SD_CARD_OK_IT,
+	MSG_SD_CARD_OK_ES,
+	MSG_SD_CARD_OK_PL
+};
+
+const char MSG_SD_ERR_WRITE_TO_FILE_EN[] PROGMEM = "error writing to file";
+const char MSG_SD_ERR_WRITE_TO_FILE_CZ[] PROGMEM = "error writing to file";
+const char MSG_SD_ERR_WRITE_TO_FILE_IT[] PROGMEM = "error writing to file";
+const char MSG_SD_ERR_WRITE_TO_FILE_ES[] PROGMEM = "error writing to file";
+const char MSG_SD_ERR_WRITE_TO_FILE_PL[] PROGMEM = "error writing to file";
+const char * const MSG_SD_ERR_WRITE_TO_FILE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_ERR_WRITE_TO_FILE_EN,
+	MSG_SD_ERR_WRITE_TO_FILE_CZ,
+	MSG_SD_ERR_WRITE_TO_FILE_IT,
+	MSG_SD_ERR_WRITE_TO_FILE_ES,
+	MSG_SD_ERR_WRITE_TO_FILE_PL
+};
+
+const char MSG_SD_FILE_OPENED_EN[] PROGMEM = "File opened: ";
+const char MSG_SD_FILE_OPENED_CZ[] PROGMEM = "File opened: ";
+const char MSG_SD_FILE_OPENED_IT[] PROGMEM = "File opened: ";
+const char MSG_SD_FILE_OPENED_ES[] PROGMEM = "File opened: ";
+const char MSG_SD_FILE_OPENED_PL[] PROGMEM = "File opened: ";
+const char * const MSG_SD_FILE_OPENED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_FILE_OPENED_EN,
+	MSG_SD_FILE_OPENED_CZ,
+	MSG_SD_FILE_OPENED_IT,
+	MSG_SD_FILE_OPENED_ES,
+	MSG_SD_FILE_OPENED_PL
+};
+
+const char MSG_SD_FILE_SELECTED_EN[] PROGMEM = "File selected";
+const char MSG_SD_FILE_SELECTED_CZ[] PROGMEM = "File selected";
+const char MSG_SD_FILE_SELECTED_IT[] PROGMEM = "File selected";
+const char MSG_SD_FILE_SELECTED_ES[] PROGMEM = "File selected";
+const char MSG_SD_FILE_SELECTED_PL[] PROGMEM = "File selected";
+const char * const MSG_SD_FILE_SELECTED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_FILE_SELECTED_EN,
+	MSG_SD_FILE_SELECTED_CZ,
+	MSG_SD_FILE_SELECTED_IT,
+	MSG_SD_FILE_SELECTED_ES,
+	MSG_SD_FILE_SELECTED_PL
+};
+
+const char MSG_SD_INIT_FAIL_EN[] PROGMEM = "SD init fail";
+const char MSG_SD_INIT_FAIL_CZ[] PROGMEM = "SD init fail";
+const char MSG_SD_INIT_FAIL_IT[] PROGMEM = "SD init fail";
+const char MSG_SD_INIT_FAIL_ES[] PROGMEM = "SD init fail";
+const char MSG_SD_INIT_FAIL_PL[] PROGMEM = "SD init fail";
+const char * const MSG_SD_INIT_FAIL_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_INIT_FAIL_EN,
+	MSG_SD_INIT_FAIL_CZ,
+	MSG_SD_INIT_FAIL_IT,
+	MSG_SD_INIT_FAIL_ES,
+	MSG_SD_INIT_FAIL_PL
+};
+
+const char MSG_SD_INSERTED_EN[] PROGMEM = "Card inserted";
+const char MSG_SD_INSERTED_CZ[] PROGMEM = "Karta vlozena";
+const char MSG_SD_INSERTED_IT[] PROGMEM = "SD Card inserita";
+const char MSG_SD_INSERTED_ES[] PROGMEM = "Tarjeta colocada";
+const char MSG_SD_INSERTED_PL[] PROGMEM = "Karta wlozona";
+const char * const MSG_SD_INSERTED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_INSERTED_EN,
+	MSG_SD_INSERTED_CZ,
+	MSG_SD_INSERTED_IT,
+	MSG_SD_INSERTED_ES,
+	MSG_SD_INSERTED_PL
+};
+
+const char MSG_SD_NOT_PRINTING_EN[] PROGMEM = "Not SD printing";
+const char MSG_SD_NOT_PRINTING_CZ[] PROGMEM = "Not SD printing";
+const char MSG_SD_NOT_PRINTING_IT[] PROGMEM = "Not SD printing";
+const char MSG_SD_NOT_PRINTING_ES[] PROGMEM = "Not SD printing";
+const char MSG_SD_NOT_PRINTING_PL[] PROGMEM = "Not SD printing";
+const char * const MSG_SD_NOT_PRINTING_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_NOT_PRINTING_EN,
+	MSG_SD_NOT_PRINTING_CZ,
+	MSG_SD_NOT_PRINTING_IT,
+	MSG_SD_NOT_PRINTING_ES,
+	MSG_SD_NOT_PRINTING_PL
+};
+
+const char MSG_SD_OPENROOT_FAIL_EN[] PROGMEM = "openRoot failed";
+const char MSG_SD_OPENROOT_FAIL_CZ[] PROGMEM = "openRoot failed";
+const char MSG_SD_OPENROOT_FAIL_IT[] PROGMEM = "openRoot failed";
+const char MSG_SD_OPENROOT_FAIL_ES[] PROGMEM = "openRoot failed";
+const char MSG_SD_OPENROOT_FAIL_PL[] PROGMEM = "openRoot failed";
+const char * const MSG_SD_OPENROOT_FAIL_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_OPENROOT_FAIL_EN,
+	MSG_SD_OPENROOT_FAIL_CZ,
+	MSG_SD_OPENROOT_FAIL_IT,
+	MSG_SD_OPENROOT_FAIL_ES,
+	MSG_SD_OPENROOT_FAIL_PL
+};
+
+const char MSG_SD_OPEN_FILE_FAIL_EN[] PROGMEM = "open failed, File: ";
+const char MSG_SD_OPEN_FILE_FAIL_CZ[] PROGMEM = "open failed, File: ";
+const char MSG_SD_OPEN_FILE_FAIL_IT[] PROGMEM = "open failed, File: ";
+const char MSG_SD_OPEN_FILE_FAIL_ES[] PROGMEM = "open failed, File: ";
+const char MSG_SD_OPEN_FILE_FAIL_PL[] PROGMEM = "open failed, File: ";
+const char * const MSG_SD_OPEN_FILE_FAIL_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_OPEN_FILE_FAIL_EN,
+	MSG_SD_OPEN_FILE_FAIL_CZ,
+	MSG_SD_OPEN_FILE_FAIL_IT,
+	MSG_SD_OPEN_FILE_FAIL_ES,
+	MSG_SD_OPEN_FILE_FAIL_PL
+};
+
+const char MSG_SD_PRINTING_BYTE_EN[] PROGMEM = "SD printing byte ";
+const char MSG_SD_PRINTING_BYTE_CZ[] PROGMEM = "SD printing byte ";
+const char MSG_SD_PRINTING_BYTE_IT[] PROGMEM = "SD printing byte ";
+const char MSG_SD_PRINTING_BYTE_ES[] PROGMEM = "SD printing byte ";
+const char MSG_SD_PRINTING_BYTE_PL[] PROGMEM = "SD printing byte ";
+const char * const MSG_SD_PRINTING_BYTE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_PRINTING_BYTE_EN,
+	MSG_SD_PRINTING_BYTE_CZ,
+	MSG_SD_PRINTING_BYTE_IT,
+	MSG_SD_PRINTING_BYTE_ES,
+	MSG_SD_PRINTING_BYTE_PL
+};
+
+const char MSG_SD_REMOVED_EN[] PROGMEM = "Card removed";
+const char MSG_SD_REMOVED_CZ[] PROGMEM = "Karta vyjmuta";
+const char MSG_SD_REMOVED_IT[] PROGMEM = "SD Card rimossa";
+const char MSG_SD_REMOVED_ES[] PROGMEM = "Tarjeta retirada";
+const char MSG_SD_REMOVED_PL[] PROGMEM = "Karta wyjeta";
+const char * const MSG_SD_REMOVED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_REMOVED_EN,
+	MSG_SD_REMOVED_CZ,
+	MSG_SD_REMOVED_IT,
+	MSG_SD_REMOVED_ES,
+	MSG_SD_REMOVED_PL
+};
+
+const char MSG_SD_SIZE_EN[] PROGMEM = " Size: ";
+const char MSG_SD_SIZE_CZ[] PROGMEM = " Size: ";
+const char MSG_SD_SIZE_IT[] PROGMEM = " Size: ";
+const char MSG_SD_SIZE_ES[] PROGMEM = " Size: ";
+const char MSG_SD_SIZE_PL[] PROGMEM = " Size: ";
+const char * const MSG_SD_SIZE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_SIZE_EN,
+	MSG_SD_SIZE_CZ,
+	MSG_SD_SIZE_IT,
+	MSG_SD_SIZE_ES,
+	MSG_SD_SIZE_PL
+};
+
+const char MSG_SD_VOL_INIT_FAIL_EN[] PROGMEM = "volume.init failed";
+const char MSG_SD_VOL_INIT_FAIL_CZ[] PROGMEM = "volume.init failed";
+const char MSG_SD_VOL_INIT_FAIL_IT[] PROGMEM = "volume.init failed";
+const char MSG_SD_VOL_INIT_FAIL_ES[] PROGMEM = "volume.init failed";
+const char MSG_SD_VOL_INIT_FAIL_PL[] PROGMEM = "volume.init failed";
+const char * const MSG_SD_VOL_INIT_FAIL_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_VOL_INIT_FAIL_EN,
+	MSG_SD_VOL_INIT_FAIL_CZ,
+	MSG_SD_VOL_INIT_FAIL_IT,
+	MSG_SD_VOL_INIT_FAIL_ES,
+	MSG_SD_VOL_INIT_FAIL_PL
+};
+
+const char MSG_SD_WORKDIR_FAIL_EN[] PROGMEM = "workDir open failed";
+const char MSG_SD_WORKDIR_FAIL_CZ[] PROGMEM = "workDir open failed";
+const char MSG_SD_WORKDIR_FAIL_IT[] PROGMEM = "workDir open failed";
+const char MSG_SD_WORKDIR_FAIL_ES[] PROGMEM = "workDir open failed";
+const char MSG_SD_WORKDIR_FAIL_PL[] PROGMEM = "workDir open failed";
+const char * const MSG_SD_WORKDIR_FAIL_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_WORKDIR_FAIL_EN,
+	MSG_SD_WORKDIR_FAIL_CZ,
+	MSG_SD_WORKDIR_FAIL_IT,
+	MSG_SD_WORKDIR_FAIL_ES,
+	MSG_SD_WORKDIR_FAIL_PL
+};
+
+const char MSG_SD_WRITE_TO_FILE_EN[] PROGMEM = "Writing to file: ";
+const char MSG_SD_WRITE_TO_FILE_CZ[] PROGMEM = "Writing to file: ";
+const char MSG_SD_WRITE_TO_FILE_IT[] PROGMEM = "Writing to file: ";
+const char MSG_SD_WRITE_TO_FILE_ES[] PROGMEM = "Writing to file: ";
+const char MSG_SD_WRITE_TO_FILE_PL[] PROGMEM = "Writing to file: ";
+const char * const MSG_SD_WRITE_TO_FILE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SD_WRITE_TO_FILE_EN,
+	MSG_SD_WRITE_TO_FILE_CZ,
+	MSG_SD_WRITE_TO_FILE_IT,
+	MSG_SD_WRITE_TO_FILE_ES,
+	MSG_SD_WRITE_TO_FILE_PL
+};
+
+const char MSG_SELFTEST_EN[] PROGMEM = "Selftest         ";
+const char MSG_SELFTEST_CZ[] PROGMEM = "Selftest         ";
+const char MSG_SELFTEST_IT[] PROGMEM = "Autotest";
+const char MSG_SELFTEST_ES[] PROGMEM = "Autotest";
+const char MSG_SELFTEST_PL[] PROGMEM = "Selftest         ";
+const char * const MSG_SELFTEST_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_EN,
+	MSG_SELFTEST_CZ,
+	MSG_SELFTEST_IT,
+	MSG_SELFTEST_ES,
+	MSG_SELFTEST_PL
+};
+
+const char MSG_SELFTEST_BEDHEATER_EN[] PROGMEM = "Bed / Heater";
+const char MSG_SELFTEST_BEDHEATER_CZ[] PROGMEM = "Bed / Heater";
+const char MSG_SELFTEST_BEDHEATER_IT[] PROGMEM = "Piastra/Riscaldatore";
+const char MSG_SELFTEST_BEDHEATER_ES[] PROGMEM = "Cama/Calentador";
+const char MSG_SELFTEST_BEDHEATER_PL[] PROGMEM = "Bed / Heater";
+const char * const MSG_SELFTEST_BEDHEATER_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_BEDHEATER_EN,
+	MSG_SELFTEST_BEDHEATER_CZ,
+	MSG_SELFTEST_BEDHEATER_IT,
+	MSG_SELFTEST_BEDHEATER_ES,
+	MSG_SELFTEST_BEDHEATER_PL
+};
+
+const char MSG_SELFTEST_CHECK_ALLCORRECT_EN[] PROGMEM = "All correct      ";
+const char MSG_SELFTEST_CHECK_ALLCORRECT_CZ[] PROGMEM = "Vse OK           ";
+const char MSG_SELFTEST_CHECK_ALLCORRECT_IT[] PROGMEM = "Nessun errore";
+const char MSG_SELFTEST_CHECK_ALLCORRECT_ES[] PROGMEM = "Todo bie ";
+const char MSG_SELFTEST_CHECK_ALLCORRECT_PL[] PROGMEM = "Wszystko OK      ";
+const char * const MSG_SELFTEST_CHECK_ALLCORRECT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_CHECK_ALLCORRECT_EN,
+	MSG_SELFTEST_CHECK_ALLCORRECT_CZ,
+	MSG_SELFTEST_CHECK_ALLCORRECT_IT,
+	MSG_SELFTEST_CHECK_ALLCORRECT_ES,
+	MSG_SELFTEST_CHECK_ALLCORRECT_PL
+};
+
+const char MSG_SELFTEST_CHECK_BED_EN[] PROGMEM = "Checking bed     ";
+const char MSG_SELFTEST_CHECK_BED_CZ[] PROGMEM = "Kontrola bed     ";
+const char MSG_SELFTEST_CHECK_BED_IT[] PROGMEM = "Verifica piastra";
+const char MSG_SELFTEST_CHECK_BED_ES[] PROGMEM = "Control de cama";
+const char MSG_SELFTEST_CHECK_BED_PL[] PROGMEM = "Kontrola bed     ";
+const char * const MSG_SELFTEST_CHECK_BED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_CHECK_BED_EN,
+	MSG_SELFTEST_CHECK_BED_CZ,
+	MSG_SELFTEST_CHECK_BED_IT,
+	MSG_SELFTEST_CHECK_BED_ES,
+	MSG_SELFTEST_CHECK_BED_PL
+};
+
+const char MSG_SELFTEST_CHECK_ENDSTOPS_EN[] PROGMEM = "Checking endstops";
+const char MSG_SELFTEST_CHECK_ENDSTOPS_CZ[] PROGMEM = "Kontrola endstops";
+const char MSG_SELFTEST_CHECK_ENDSTOPS_IT[] PROGMEM = "Verifica limiti";
+const char MSG_SELFTEST_CHECK_ENDSTOPS_ES[] PROGMEM = "Cont. topes final";
+const char MSG_SELFTEST_CHECK_ENDSTOPS_PL[] PROGMEM = "Kontrola endstops";
+const char * const MSG_SELFTEST_CHECK_ENDSTOPS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_CHECK_ENDSTOPS_EN,
+	MSG_SELFTEST_CHECK_ENDSTOPS_CZ,
+	MSG_SELFTEST_CHECK_ENDSTOPS_IT,
+	MSG_SELFTEST_CHECK_ENDSTOPS_ES,
+	MSG_SELFTEST_CHECK_ENDSTOPS_PL
+};
+
+const char MSG_SELFTEST_CHECK_HOTEND_EN[] PROGMEM = "Checking hotend  ";
+const char MSG_SELFTEST_CHECK_HOTEND_CZ[] PROGMEM = "Kontrola hotend  ";
+const char MSG_SELFTEST_CHECK_HOTEND_IT[] PROGMEM = "Verifica lim temp";
+const char MSG_SELFTEST_CHECK_HOTEND_ES[] PROGMEM = "Control hotend ";
+const char MSG_SELFTEST_CHECK_HOTEND_PL[] PROGMEM = "Kontrola hotend  ";
+const char * const MSG_SELFTEST_CHECK_HOTEND_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_CHECK_HOTEND_EN,
+	MSG_SELFTEST_CHECK_HOTEND_CZ,
+	MSG_SELFTEST_CHECK_HOTEND_IT,
+	MSG_SELFTEST_CHECK_HOTEND_ES,
+	MSG_SELFTEST_CHECK_HOTEND_PL
+};
+
+const char MSG_SELFTEST_CHECK_X_EN[] PROGMEM = "Checking X axis  ";
+const char MSG_SELFTEST_CHECK_X_CZ[] PROGMEM = "Kontrola X axis  ";
+const char MSG_SELFTEST_CHECK_X_IT[] PROGMEM = "Verifica asse X";
+const char MSG_SELFTEST_CHECK_X_ES[] PROGMEM = "Control del eje X";
+const char MSG_SELFTEST_CHECK_X_PL[] PROGMEM = "Kontrola X axis  ";
+const char * const MSG_SELFTEST_CHECK_X_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_CHECK_X_EN,
+	MSG_SELFTEST_CHECK_X_CZ,
+	MSG_SELFTEST_CHECK_X_IT,
+	MSG_SELFTEST_CHECK_X_ES,
+	MSG_SELFTEST_CHECK_X_PL
+};
+
+const char MSG_SELFTEST_CHECK_Y_EN[] PROGMEM = "Checking Y axis  ";
+const char MSG_SELFTEST_CHECK_Y_CZ[] PROGMEM = "Kontrola Y axis  ";
+const char MSG_SELFTEST_CHECK_Y_IT[] PROGMEM = "Verifica asse Y";
+const char MSG_SELFTEST_CHECK_Y_ES[] PROGMEM = "Control del eje Y";
+const char MSG_SELFTEST_CHECK_Y_PL[] PROGMEM = "Kontrola Y axis  ";
+const char * const MSG_SELFTEST_CHECK_Y_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_CHECK_Y_EN,
+	MSG_SELFTEST_CHECK_Y_CZ,
+	MSG_SELFTEST_CHECK_Y_IT,
+	MSG_SELFTEST_CHECK_Y_ES,
+	MSG_SELFTEST_CHECK_Y_PL
+};
+
+const char MSG_SELFTEST_CHECK_Z_EN[] PROGMEM = "Checking Z axis  ";
+const char MSG_SELFTEST_CHECK_Z_CZ[] PROGMEM = "Kontrola Z axis  ";
+const char MSG_SELFTEST_CHECK_Z_IT[] PROGMEM = "Verifica asse Z";
+const char MSG_SELFTEST_CHECK_Z_ES[] PROGMEM = "Control del eje Z";
+const char MSG_SELFTEST_CHECK_Z_PL[] PROGMEM = "Kontrola Z axis  ";
+const char * const MSG_SELFTEST_CHECK_Z_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_CHECK_Z_EN,
+	MSG_SELFTEST_CHECK_Z_CZ,
+	MSG_SELFTEST_CHECK_Z_IT,
+	MSG_SELFTEST_CHECK_Z_ES,
+	MSG_SELFTEST_CHECK_Z_PL
+};
+
+const char MSG_SELFTEST_ENDSTOP_EN[] PROGMEM = "Endstop";
+const char MSG_SELFTEST_ENDSTOP_CZ[] PROGMEM = "Endstop";
+const char MSG_SELFTEST_ENDSTOP_IT[] PROGMEM = "Limite corsa";
+const char MSG_SELFTEST_ENDSTOP_ES[] PROGMEM = "Tope final";
+const char MSG_SELFTEST_ENDSTOP_PL[] PROGMEM = "Endstop";
+const char * const MSG_SELFTEST_ENDSTOP_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_ENDSTOP_EN,
+	MSG_SELFTEST_ENDSTOP_CZ,
+	MSG_SELFTEST_ENDSTOP_IT,
+	MSG_SELFTEST_ENDSTOP_ES,
+	MSG_SELFTEST_ENDSTOP_PL
+};
+
+const char MSG_SELFTEST_ENDSTOPS_EN[] PROGMEM = "Endstops";
+const char MSG_SELFTEST_ENDSTOPS_CZ[] PROGMEM = "Endstops";
+const char MSG_SELFTEST_ENDSTOPS_IT[] PROGMEM = "Limiti corsa";
+const char MSG_SELFTEST_ENDSTOPS_ES[] PROGMEM = "Topes final";
+const char MSG_SELFTEST_ENDSTOPS_PL[] PROGMEM = "Endstops";
+const char * const MSG_SELFTEST_ENDSTOPS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_ENDSTOPS_EN,
+	MSG_SELFTEST_ENDSTOPS_CZ,
+	MSG_SELFTEST_ENDSTOPS_IT,
+	MSG_SELFTEST_ENDSTOPS_ES,
+	MSG_SELFTEST_ENDSTOPS_PL
+};
+
+const char MSG_SELFTEST_ENDSTOP_NOTHIT_EN[] PROGMEM = "Endstop not hit";
+const char MSG_SELFTEST_ENDSTOP_NOTHIT_CZ[] PROGMEM = "Endstop not hit";
+const char MSG_SELFTEST_ENDSTOP_NOTHIT_IT[] PROGMEM = "Lim. fuoriportata";
+const char MSG_SELFTEST_ENDSTOP_NOTHIT_ES[] PROGMEM = "Tope fin. no toc.";
+const char MSG_SELFTEST_ENDSTOP_NOTHIT_PL[] PROGMEM = "Endstop not hit";
+const char * const MSG_SELFTEST_ENDSTOP_NOTHIT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_ENDSTOP_NOTHIT_EN,
+	MSG_SELFTEST_ENDSTOP_NOTHIT_CZ,
+	MSG_SELFTEST_ENDSTOP_NOTHIT_IT,
+	MSG_SELFTEST_ENDSTOP_NOTHIT_ES,
+	MSG_SELFTEST_ENDSTOP_NOTHIT_PL
+};
+
+const char MSG_SELFTEST_ERROR_EN[] PROGMEM = "Selftest error !";
+const char MSG_SELFTEST_ERROR_CZ[] PROGMEM = "Selftest error !";
+const char MSG_SELFTEST_ERROR_IT[] PROGMEM = "Autotest negativo";
+const char MSG_SELFTEST_ERROR_ES[] PROGMEM = "\xA1Autotest error!";
+const char MSG_SELFTEST_ERROR_PL[] PROGMEM = "Selftest error !";
+const char * const MSG_SELFTEST_ERROR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_ERROR_EN,
+	MSG_SELFTEST_ERROR_CZ,
+	MSG_SELFTEST_ERROR_IT,
+	MSG_SELFTEST_ERROR_ES,
+	MSG_SELFTEST_ERROR_PL
+};
+
+const char MSG_SELFTEST_FAILED_EN[] PROGMEM = "Selftest failed  ";
+const char MSG_SELFTEST_FAILED_CZ[] PROGMEM = "Selftest selhal  ";
+const char MSG_SELFTEST_FAILED_IT[] PROGMEM = "Autotest fallito";
+const char MSG_SELFTEST_FAILED_ES[] PROGMEM = "Autotest fallado";
+const char MSG_SELFTEST_FAILED_PL[] PROGMEM = "Selftest nieudany";
+const char * const MSG_SELFTEST_FAILED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_FAILED_EN,
+	MSG_SELFTEST_FAILED_CZ,
+	MSG_SELFTEST_FAILED_IT,
+	MSG_SELFTEST_FAILED_ES,
+	MSG_SELFTEST_FAILED_PL
+};
+
+const char MSG_SELFTEST_HEATERTHERMISTOR_EN[] PROGMEM = "Heater/Thermistor";
+const char MSG_SELFTEST_HEATERTHERMISTOR_CZ[] PROGMEM = "Heater/Thermistor";
+const char MSG_SELFTEST_HEATERTHERMISTOR_IT[] PROGMEM = "Riscald./Termistore";
+const char MSG_SELFTEST_HEATERTHERMISTOR_ES[] PROGMEM = "Calent./Termistor";
+const char MSG_SELFTEST_HEATERTHERMISTOR_PL[] PROGMEM = "Heater/Thermistor";
+const char * const MSG_SELFTEST_HEATERTHERMISTOR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_HEATERTHERMISTOR_EN,
+	MSG_SELFTEST_HEATERTHERMISTOR_CZ,
+	MSG_SELFTEST_HEATERTHERMISTOR_IT,
+	MSG_SELFTEST_HEATERTHERMISTOR_ES,
+	MSG_SELFTEST_HEATERTHERMISTOR_PL
+};
+
+const char MSG_SELFTEST_MOTOR_EN[] PROGMEM = "Motor";
+const char MSG_SELFTEST_MOTOR_CZ[] PROGMEM = "Motor";
+const char MSG_SELFTEST_MOTOR_IT[] PROGMEM = "Motore";
+const char MSG_SELFTEST_MOTOR_ES[] PROGMEM = "Motor";
+const char MSG_SELFTEST_MOTOR_PL[] PROGMEM = "Silnik";
+const char * const MSG_SELFTEST_MOTOR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_MOTOR_EN,
+	MSG_SELFTEST_MOTOR_CZ,
+	MSG_SELFTEST_MOTOR_IT,
+	MSG_SELFTEST_MOTOR_ES,
+	MSG_SELFTEST_MOTOR_PL
+};
+
+const char MSG_SELFTEST_NOTCONNECTED_EN[] PROGMEM = "Not connected";
+const char MSG_SELFTEST_NOTCONNECTED_CZ[] PROGMEM = "Nezapojeno    ";
+const char MSG_SELFTEST_NOTCONNECTED_IT[] PROGMEM = "Non connesso";
+const char MSG_SELFTEST_NOTCONNECTED_ES[] PROGMEM = "No hay conexion  ";
+const char MSG_SELFTEST_NOTCONNECTED_PL[] PROGMEM = "Nie podlaczono   ";
+const char * const MSG_SELFTEST_NOTCONNECTED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_NOTCONNECTED_EN,
+	MSG_SELFTEST_NOTCONNECTED_CZ,
+	MSG_SELFTEST_NOTCONNECTED_IT,
+	MSG_SELFTEST_NOTCONNECTED_ES,
+	MSG_SELFTEST_NOTCONNECTED_PL
+};
+
+const char MSG_SELFTEST_OK_EN[] PROGMEM = "Self test OK";
+const char MSG_SELFTEST_OK_CZ[] PROGMEM = "Self test OK";
+const char MSG_SELFTEST_OK_IT[] PROGMEM = "Autotest OK";
+const char MSG_SELFTEST_OK_ES[] PROGMEM = "Self test OK";
+const char MSG_SELFTEST_OK_PL[] PROGMEM = "Self test OK";
+const char * const MSG_SELFTEST_OK_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_OK_EN,
+	MSG_SELFTEST_OK_CZ,
+	MSG_SELFTEST_OK_IT,
+	MSG_SELFTEST_OK_ES,
+	MSG_SELFTEST_OK_PL
+};
+
+const char MSG_SELFTEST_PLEASECHECK_EN[] PROGMEM = "Please check :";
+const char MSG_SELFTEST_PLEASECHECK_CZ[] PROGMEM = "Zkontrolujte :";
+const char MSG_SELFTEST_PLEASECHECK_IT[] PROGMEM = "Verifica:";
+const char MSG_SELFTEST_PLEASECHECK_ES[] PROGMEM = "Controla :";
+const char MSG_SELFTEST_PLEASECHECK_PL[] PROGMEM = "Skontroluj :";
+const char * const MSG_SELFTEST_PLEASECHECK_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_PLEASECHECK_EN,
+	MSG_SELFTEST_PLEASECHECK_CZ,
+	MSG_SELFTEST_PLEASECHECK_IT,
+	MSG_SELFTEST_PLEASECHECK_ES,
+	MSG_SELFTEST_PLEASECHECK_PL
+};
+
+const char MSG_SELFTEST_START_EN[] PROGMEM = "Self test start  ";
+const char MSG_SELFTEST_START_CZ[] PROGMEM = "Self test start  ";
+const char MSG_SELFTEST_START_IT[] PROGMEM = "Inizia autotest";
+const char MSG_SELFTEST_START_ES[] PROGMEM = "Autotest salida";
+const char MSG_SELFTEST_START_PL[] PROGMEM = "Self test start  ";
+const char * const MSG_SELFTEST_START_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_START_EN,
+	MSG_SELFTEST_START_CZ,
+	MSG_SELFTEST_START_IT,
+	MSG_SELFTEST_START_ES,
+	MSG_SELFTEST_START_PL
+};
+
+const char MSG_SELFTEST_WIRINGERROR_EN[] PROGMEM = "Wiring error";
+const char MSG_SELFTEST_WIRINGERROR_CZ[] PROGMEM = "Chyba zapojeni";
+const char MSG_SELFTEST_WIRINGERROR_IT[] PROGMEM = "Errore cablaggio";
+const char MSG_SELFTEST_WIRINGERROR_ES[] PROGMEM = "Error de conexi\xF3n";
+const char MSG_SELFTEST_WIRINGERROR_PL[] PROGMEM = "Blad polaczenia";
+const char * const MSG_SELFTEST_WIRINGERROR_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SELFTEST_WIRINGERROR_EN,
+	MSG_SELFTEST_WIRINGERROR_CZ,
+	MSG_SELFTEST_WIRINGERROR_IT,
+	MSG_SELFTEST_WIRINGERROR_ES,
+	MSG_SELFTEST_WIRINGERROR_PL
+};
+
+const char MSG_SERIAL_ERROR_MENU_STRUCTURE_EN[] PROGMEM = "Error in menu structure";
+const char MSG_SERIAL_ERROR_MENU_STRUCTURE_CZ[] PROGMEM = "Error in menu structure";
+const char MSG_SERIAL_ERROR_MENU_STRUCTURE_IT[] PROGMEM = "Error in menu structure";
+const char MSG_SERIAL_ERROR_MENU_STRUCTURE_ES[] PROGMEM = "Error in menu structure";
+const char MSG_SERIAL_ERROR_MENU_STRUCTURE_PL[] PROGMEM = "Error in menu structure";
+const char * const MSG_SERIAL_ERROR_MENU_STRUCTURE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SERIAL_ERROR_MENU_STRUCTURE_EN,
+	MSG_SERIAL_ERROR_MENU_STRUCTURE_CZ,
+	MSG_SERIAL_ERROR_MENU_STRUCTURE_IT,
+	MSG_SERIAL_ERROR_MENU_STRUCTURE_ES,
+	MSG_SERIAL_ERROR_MENU_STRUCTURE_PL
+};
+
+const char MSG_SETTINGS_EN[] PROGMEM = "Settings";
+const char MSG_SETTINGS_CZ[] PROGMEM = "Nastaveni";
+const char MSG_SETTINGS_IT[] PROGMEM = "Impostazioni";
+const char MSG_SETTINGS_ES[] PROGMEM = "Ajuste";
+const char MSG_SETTINGS_PL[] PROGMEM = "Ustawienia";
+const char * const MSG_SETTINGS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SETTINGS_EN,
+	MSG_SETTINGS_CZ,
+	MSG_SETTINGS_IT,
+	MSG_SETTINGS_ES,
+	MSG_SETTINGS_PL
+};
+
+const char MSG_SET_HOME_OFFSETS_EN[] PROGMEM = "Set home offsets";
+const char MSG_SET_HOME_OFFSETS_CZ[] PROGMEM = "Nastav pocatek home";
+const char MSG_SET_HOME_OFFSETS_IT[] PROGMEM = "Set home offsets";
+const char MSG_SET_HOME_OFFSETS_ES[] PROGMEM = "Set home offsets";
+const char MSG_SET_HOME_OFFSETS_PL[] PROGMEM = "Nastav pocatek home";
+const char * const MSG_SET_HOME_OFFSETS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SET_HOME_OFFSETS_EN,
+	MSG_SET_HOME_OFFSETS_CZ,
+	MSG_SET_HOME_OFFSETS_IT,
+	MSG_SET_HOME_OFFSETS_ES,
+	MSG_SET_HOME_OFFSETS_PL
+};
+
+const char MSG_SET_ORIGIN_EN[] PROGMEM = "Set origin";
+const char MSG_SET_ORIGIN_CZ[] PROGMEM = "Nastav pocatek";
+const char MSG_SET_ORIGIN_IT[] PROGMEM = "Set origin";
+const char MSG_SET_ORIGIN_ES[] PROGMEM = "Set origin";
+const char MSG_SET_ORIGIN_PL[] PROGMEM = "Nastav pocatek";
+const char * const MSG_SET_ORIGIN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SET_ORIGIN_EN,
+	MSG_SET_ORIGIN_CZ,
+	MSG_SET_ORIGIN_IT,
+	MSG_SET_ORIGIN_ES,
+	MSG_SET_ORIGIN_PL
+};
+
+const char MSG_SILENT_MODE_OFF_EN[] PROGMEM = "Mode [high power]";
+const char MSG_SILENT_MODE_OFF_CZ[] PROGMEM = "Mod  [vys. vykon]";
+const char MSG_SILENT_MODE_OFF_IT[] PROGMEM = "Modo [piu forza]";
+const char MSG_SILENT_MODE_OFF_ES[] PROGMEM = "Modo [mas fuerza]";
+const char MSG_SILENT_MODE_OFF_PL[] PROGMEM = "Mod [w wydajnosc]";
+const char * const MSG_SILENT_MODE_OFF_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SILENT_MODE_OFF_EN,
+	MSG_SILENT_MODE_OFF_CZ,
+	MSG_SILENT_MODE_OFF_IT,
+	MSG_SILENT_MODE_OFF_ES,
+	MSG_SILENT_MODE_OFF_PL
+};
+
+const char MSG_SILENT_MODE_ON_EN[] PROGMEM = "Mode     [silent]";
+const char MSG_SILENT_MODE_ON_CZ[] PROGMEM = "Mod       [tichy]";
+const char MSG_SILENT_MODE_ON_IT[] PROGMEM = "Modo     [silenzioso]";
+const char MSG_SILENT_MODE_ON_ES[] PROGMEM = "Modo     [silencio]";
+const char MSG_SILENT_MODE_ON_PL[] PROGMEM = "Mod       [cichy]";
+const char * const MSG_SILENT_MODE_ON_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SILENT_MODE_ON_EN,
+	MSG_SILENT_MODE_ON_CZ,
+	MSG_SILENT_MODE_ON_IT,
+	MSG_SILENT_MODE_ON_ES,
+	MSG_SILENT_MODE_ON_PL
+};
+
+const char MSG_SOFTWARE_RESET_EN[] PROGMEM = " Software Reset";
+const char MSG_SOFTWARE_RESET_CZ[] PROGMEM = " Software Reset";
+const char MSG_SOFTWARE_RESET_IT[] PROGMEM = " Software Reset";
+const char MSG_SOFTWARE_RESET_ES[] PROGMEM = " Software Reset";
+const char MSG_SOFTWARE_RESET_PL[] PROGMEM = " Software Reset";
+const char * const MSG_SOFTWARE_RESET_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SOFTWARE_RESET_EN,
+	MSG_SOFTWARE_RESET_CZ,
+	MSG_SOFTWARE_RESET_IT,
+	MSG_SOFTWARE_RESET_ES,
+	MSG_SOFTWARE_RESET_PL
+};
+
+const char MSG_SPEED_EN[] PROGMEM = "Speed";
+const char MSG_SPEED_CZ[] PROGMEM = "Rychlost";
+const char MSG_SPEED_IT[] PROGMEM = "Velcit�";
+const char MSG_SPEED_ES[] PROGMEM = "Velocidad";
+const char MSG_SPEED_PL[] PROGMEM = "Predkosc";
+const char * const MSG_SPEED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SPEED_EN,
+	MSG_SPEED_CZ,
+	MSG_SPEED_IT,
+	MSG_SPEED_ES,
+	MSG_SPEED_PL
+};
+
+const char MSG_STATISTICS_EN[] PROGMEM = "Statistics  ";
+const char MSG_STATISTICS_CZ[] PROGMEM = "Statistika  ";
+const char MSG_STATISTICS_IT[] PROGMEM = "Statistiche";
+const char MSG_STATISTICS_ES[] PROGMEM = "Estadistica  ";
+const char MSG_STATISTICS_PL[] PROGMEM = "Statystyka  ";
+const char * const MSG_STATISTICS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_STATISTICS_EN,
+	MSG_STATISTICS_CZ,
+	MSG_STATISTICS_IT,
+	MSG_STATISTICS_ES,
+	MSG_STATISTICS_PL
+};
+
+const char MSG_STATS_FILAMENTUSED_EN[] PROGMEM = "Filament used:  ";
+const char MSG_STATS_FILAMENTUSED_CZ[] PROGMEM = "Filament :  ";
+const char MSG_STATS_FILAMENTUSED_IT[] PROGMEM = "Filamento:";
+const char MSG_STATS_FILAMENTUSED_ES[] PROGMEM = "Filamento :  ";
+const char MSG_STATS_FILAMENTUSED_PL[] PROGMEM = "Filament :  ";
+const char * const MSG_STATS_FILAMENTUSED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_STATS_FILAMENTUSED_EN,
+	MSG_STATS_FILAMENTUSED_CZ,
+	MSG_STATS_FILAMENTUSED_IT,
+	MSG_STATS_FILAMENTUSED_ES,
+	MSG_STATS_FILAMENTUSED_PL
+};
+
+const char MSG_STATS_PRINTTIME_EN[] PROGMEM = "Print time:  ";
+const char MSG_STATS_PRINTTIME_CZ[] PROGMEM = "Cas tisku :  ";
+const char MSG_STATS_PRINTTIME_IT[] PROGMEM = "Tempo stampa:";
+const char MSG_STATS_PRINTTIME_ES[] PROGMEM = "Tiempo de imp.:";
+const char MSG_STATS_PRINTTIME_PL[] PROGMEM = "Czas druku :  ";
+const char * const MSG_STATS_PRINTTIME_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_STATS_PRINTTIME_EN,
+	MSG_STATS_PRINTTIME_CZ,
+	MSG_STATS_PRINTTIME_IT,
+	MSG_STATS_PRINTTIME_ES,
+	MSG_STATS_PRINTTIME_PL
+};
+
+const char MSG_STATS_TOTALFILAMENT_EN[] PROGMEM = "Total filament :";
+const char MSG_STATS_TOTALFILAMENT_CZ[] PROGMEM = "Filament celkem :";
+const char MSG_STATS_TOTALFILAMENT_IT[] PROGMEM = "Filamento tot:";
+const char MSG_STATS_TOTALFILAMENT_ES[] PROGMEM = "Filamento total:";
+const char MSG_STATS_TOTALFILAMENT_PL[] PROGMEM = "Filament lacznie :";
+const char * const MSG_STATS_TOTALFILAMENT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_STATS_TOTALFILAMENT_EN,
+	MSG_STATS_TOTALFILAMENT_CZ,
+	MSG_STATS_TOTALFILAMENT_IT,
+	MSG_STATS_TOTALFILAMENT_ES,
+	MSG_STATS_TOTALFILAMENT_PL
+};
+
+const char MSG_STATS_TOTALPRINTTIME_EN[] PROGMEM = "Total print time :";
+const char MSG_STATS_TOTALPRINTTIME_CZ[] PROGMEM = "Celkovy cas :";
+const char MSG_STATS_TOTALPRINTTIME_IT[] PROGMEM = "Tempo stampa tot:";
+const char MSG_STATS_TOTALPRINTTIME_ES[] PROGMEM = "Tiempo total :";
+const char MSG_STATS_TOTALPRINTTIME_PL[] PROGMEM = "Czas calkowity :";
+const char * const MSG_STATS_TOTALPRINTTIME_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_STATS_TOTALPRINTTIME_EN,
+	MSG_STATS_TOTALPRINTTIME_CZ,
+	MSG_STATS_TOTALPRINTTIME_IT,
+	MSG_STATS_TOTALPRINTTIME_ES,
+	MSG_STATS_TOTALPRINTTIME_PL
+};
+
+const char MSG_STEPPER_TOO_HIGH_EN[] PROGMEM = "Steprate too high: ";
+const char MSG_STEPPER_TOO_HIGH_CZ[] PROGMEM = "Steprate too high: ";
+const char MSG_STEPPER_TOO_HIGH_IT[] PROGMEM = "Steprate too high: ";
+const char MSG_STEPPER_TOO_HIGH_ES[] PROGMEM = "Steprate too high: ";
+const char MSG_STEPPER_TOO_HIGH_PL[] PROGMEM = "Steprate too high: ";
+const char * const MSG_STEPPER_TOO_HIGH_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_STEPPER_TOO_HIGH_EN,
+	MSG_STEPPER_TOO_HIGH_CZ,
+	MSG_STEPPER_TOO_HIGH_IT,
+	MSG_STEPPER_TOO_HIGH_ES,
+	MSG_STEPPER_TOO_HIGH_PL
+};
+
+const char MSG_STOPPED_EN[] PROGMEM = "STOPPED. ";
+const char MSG_STOPPED_CZ[] PROGMEM = "STOPPED. ";
+const char MSG_STOPPED_IT[] PROGMEM = "ARRESTATO ";
+const char MSG_STOPPED_ES[] PROGMEM = "PARADA";
+const char MSG_STOPPED_PL[] PROGMEM = "STOPPED. ";
+const char * const MSG_STOPPED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_STOPPED_EN,
+	MSG_STOPPED_CZ,
+	MSG_STOPPED_IT,
+	MSG_STOPPED_ES,
+	MSG_STOPPED_PL
+};
+
+const char MSG_STOP_PRINT_EN[] PROGMEM = "Stop print";
+const char MSG_STOP_PRINT_CZ[] PROGMEM = "Zastavit tisk";
+const char MSG_STOP_PRINT_IT[] PROGMEM = "Arresta stampa";
+const char MSG_STOP_PRINT_ES[] PROGMEM = "Detener impresion";
+const char MSG_STOP_PRINT_PL[] PROGMEM = "Zatrzymac druk";
+const char * const MSG_STOP_PRINT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_STOP_PRINT_EN,
+	MSG_STOP_PRINT_CZ,
+	MSG_STOP_PRINT_IT,
+	MSG_STOP_PRINT_ES,
+	MSG_STOP_PRINT_PL
+};
+
+const char MSG_STORE_EPROM_EN[] PROGMEM = "Store memory";
+const char MSG_STORE_EPROM_CZ[] PROGMEM = "Store memory";
+const char MSG_STORE_EPROM_IT[] PROGMEM = "Store memory";
+const char MSG_STORE_EPROM_ES[] PROGMEM = "Store memory";
+const char MSG_STORE_EPROM_PL[] PROGMEM = "Store memory";
+const char * const MSG_STORE_EPROM_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_STORE_EPROM_EN,
+	MSG_STORE_EPROM_CZ,
+	MSG_STORE_EPROM_IT,
+	MSG_STORE_EPROM_ES,
+	MSG_STORE_EPROM_PL
+};
+
+const char MSG_SUPPORT_EN[] PROGMEM = "Support";
+const char MSG_SUPPORT_CZ[] PROGMEM = "Podpora";
+const char MSG_SUPPORT_IT[] PROGMEM = "Support";
+const char MSG_SUPPORT_ES[] PROGMEM = "Support";
+const char MSG_SUPPORT_PL[] PROGMEM = "Pomoc";
+const char * const MSG_SUPPORT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SUPPORT_EN,
+	MSG_SUPPORT_CZ,
+	MSG_SUPPORT_IT,
+	MSG_SUPPORT_ES,
+	MSG_SUPPORT_PL
+};
+
+const char MSG_SWITCH_PS_OFF_EN[] PROGMEM = "Switch power off";
+const char MSG_SWITCH_PS_OFF_CZ[] PROGMEM = "Zapnout zdroj";
+const char MSG_SWITCH_PS_OFF_IT[] PROGMEM = "Switch power off";
+const char MSG_SWITCH_PS_OFF_ES[] PROGMEM = "Switch power off";
+const char MSG_SWITCH_PS_OFF_PL[] PROGMEM = "Zapnout zdroj";
+const char * const MSG_SWITCH_PS_OFF_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SWITCH_PS_OFF_EN,
+	MSG_SWITCH_PS_OFF_CZ,
+	MSG_SWITCH_PS_OFF_IT,
+	MSG_SWITCH_PS_OFF_ES,
+	MSG_SWITCH_PS_OFF_PL
+};
+
+const char MSG_SWITCH_PS_ON_EN[] PROGMEM = "Switch power on";
+const char MSG_SWITCH_PS_ON_CZ[] PROGMEM = "Vypnout zdroj";
+const char MSG_SWITCH_PS_ON_IT[] PROGMEM = "Switch power on";
+const char MSG_SWITCH_PS_ON_ES[] PROGMEM = "Switch power on";
+const char MSG_SWITCH_PS_ON_PL[] PROGMEM = "Vypnout zdroj";
+const char * const MSG_SWITCH_PS_ON_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_SWITCH_PS_ON_EN,
+	MSG_SWITCH_PS_ON_CZ,
+	MSG_SWITCH_PS_ON_IT,
+	MSG_SWITCH_PS_ON_ES,
+	MSG_SWITCH_PS_ON_PL
+};
+
+const char MSG_TAKE_EFFECT_EN[] PROGMEM = " for take effect";
+const char MSG_TAKE_EFFECT_CZ[] PROGMEM = " pro projeveni zmen";
+const char MSG_TAKE_EFFECT_IT[] PROGMEM = " per mostrare i camb.";
+const char MSG_TAKE_EFFECT_ES[] PROGMEM = "para tomar efecto";
+const char MSG_TAKE_EFFECT_PL[] PROGMEM = "wprow. zmian";
+const char * const MSG_TAKE_EFFECT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_TAKE_EFFECT_EN,
+	MSG_TAKE_EFFECT_CZ,
+	MSG_TAKE_EFFECT_IT,
+	MSG_TAKE_EFFECT_ES,
+	MSG_TAKE_EFFECT_PL
+};
+
+const char MSG_TEMPERATURE_EN[] PROGMEM = "Temperature";
+const char MSG_TEMPERATURE_CZ[] PROGMEM = "Teplota";
+const char MSG_TEMPERATURE_IT[] PROGMEM = "Temperatura";
+const char MSG_TEMPERATURE_ES[] PROGMEM = "Temperatura";
+const char MSG_TEMPERATURE_PL[] PROGMEM = "Temperatura";
+const char * const MSG_TEMPERATURE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_TEMPERATURE_EN,
+	MSG_TEMPERATURE_CZ,
+	MSG_TEMPERATURE_IT,
+	MSG_TEMPERATURE_ES,
+	MSG_TEMPERATURE_PL
+};
+
+const char MSG_TUNE_EN[] PROGMEM = "Tune";
+const char MSG_TUNE_CZ[] PROGMEM = "Ladit";
+const char MSG_TUNE_IT[] PROGMEM = "Adatta";
+const char MSG_TUNE_ES[] PROGMEM = "Ajustar";
+const char MSG_TUNE_PL[] PROGMEM = "Nastroic";
+const char * const MSG_TUNE_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_TUNE_EN,
+	MSG_TUNE_CZ,
+	MSG_TUNE_IT,
+	MSG_TUNE_ES,
+	MSG_TUNE_PL
+};
+
+const char MSG_UNKNOWN_COMMAND_EN[] PROGMEM = "Unknown command: \"";
+const char MSG_UNKNOWN_COMMAND_CZ[] PROGMEM = "Unknown command: \"";
+const char MSG_UNKNOWN_COMMAND_IT[] PROGMEM = "Unknown command: \"";
+const char MSG_UNKNOWN_COMMAND_ES[] PROGMEM = "Unknown command: \"";
+const char MSG_UNKNOWN_COMMAND_PL[] PROGMEM = "Unknown command: \"";
+const char * const MSG_UNKNOWN_COMMAND_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_UNKNOWN_COMMAND_EN,
+	MSG_UNKNOWN_COMMAND_CZ,
+	MSG_UNKNOWN_COMMAND_IT,
+	MSG_UNKNOWN_COMMAND_ES,
+	MSG_UNKNOWN_COMMAND_PL
+};
+
+const char MSG_UNLOAD_FILAMENT_EN[] PROGMEM = "Unload filament";
+const char MSG_UNLOAD_FILAMENT_CZ[] PROGMEM = "Vyjmout filament";
+const char MSG_UNLOAD_FILAMENT_IT[] PROGMEM = "Scaricare fil.";
+const char MSG_UNLOAD_FILAMENT_ES[] PROGMEM = "Sacar filamento";
+const char MSG_UNLOAD_FILAMENT_PL[] PROGMEM = "Wyjac filament";
+const char * const MSG_UNLOAD_FILAMENT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_UNLOAD_FILAMENT_EN,
+	MSG_UNLOAD_FILAMENT_CZ,
+	MSG_UNLOAD_FILAMENT_IT,
+	MSG_UNLOAD_FILAMENT_ES,
+	MSG_UNLOAD_FILAMENT_PL
+};
+
+const char MSG_USB_PRINTING_EN[] PROGMEM = "USB printing  ";
+const char MSG_USB_PRINTING_CZ[] PROGMEM = "Tisk z USB  ";
+const char MSG_USB_PRINTING_IT[] PROGMEM = "Stampa da USB";
+const char MSG_USB_PRINTING_ES[] PROGMEM = "Impresion de USB ";
+const char MSG_USB_PRINTING_PL[] PROGMEM = "Druk z USB  ";
+const char * const MSG_USB_PRINTING_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_USB_PRINTING_EN,
+	MSG_USB_PRINTING_CZ,
+	MSG_USB_PRINTING_IT,
+	MSG_USB_PRINTING_ES,
+	MSG_USB_PRINTING_PL
+};
+
+const char MSG_USERWAIT_EN[] PROGMEM = "Wait for user...";
+const char MSG_USERWAIT_CZ[] PROGMEM = "Wait for user...";
+const char MSG_USERWAIT_IT[] PROGMEM = "Attendi Utente...";
+const char MSG_USERWAIT_ES[] PROGMEM = "Esperando ordenes";
+const char MSG_USERWAIT_PL[] PROGMEM = "Wait for user...";
+const char * const MSG_USERWAIT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_USERWAIT_EN,
+	MSG_USERWAIT_CZ,
+	MSG_USERWAIT_IT,
+	MSG_USERWAIT_ES,
+	MSG_USERWAIT_PL
+};
+
+const char MSG_VE_JERK_EN[] PROGMEM = "Ve-jerk";
+const char MSG_VE_JERK_CZ[] PROGMEM = "Ve-jerk";
+const char MSG_VE_JERK_IT[] PROGMEM = "Ve-jerk";
+const char MSG_VE_JERK_ES[] PROGMEM = "Ve-jerk";
+const char MSG_VE_JERK_PL[] PROGMEM = "Ve-jerk";
+const char * const MSG_VE_JERK_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_VE_JERK_EN,
+	MSG_VE_JERK_CZ,
+	MSG_VE_JERK_IT,
+	MSG_VE_JERK_ES,
+	MSG_VE_JERK_PL
+};
+
+const char MSG_VMAX_EN[] PROGMEM = "Vmax ";
+const char MSG_VMAX_CZ[] PROGMEM = "Vmax ";
+const char MSG_VMAX_IT[] PROGMEM = "Vmax ";
+const char MSG_VMAX_ES[] PROGMEM = "Vmax ";
+const char MSG_VMAX_PL[] PROGMEM = "Vmax ";
+const char * const MSG_VMAX_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_VMAX_EN,
+	MSG_VMAX_CZ,
+	MSG_VMAX_IT,
+	MSG_VMAX_ES,
+	MSG_VMAX_PL
+};
+
+const char MSG_VMIN_EN[] PROGMEM = "Vmin";
+const char MSG_VMIN_CZ[] PROGMEM = "Vmin";
+const char MSG_VMIN_IT[] PROGMEM = "Vmin";
+const char MSG_VMIN_ES[] PROGMEM = "Vmin";
+const char MSG_VMIN_PL[] PROGMEM = "Vmin";
+const char * const MSG_VMIN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_VMIN_EN,
+	MSG_VMIN_CZ,
+	MSG_VMIN_IT,
+	MSG_VMIN_ES,
+	MSG_VMIN_PL
+};
+
+const char MSG_VOLUMETRIC_EN[] PROGMEM = "Filament";
+const char MSG_VOLUMETRIC_CZ[] PROGMEM = "Filament";
+const char MSG_VOLUMETRIC_IT[] PROGMEM = "Filament";
+const char MSG_VOLUMETRIC_ES[] PROGMEM = "Filament";
+const char MSG_VOLUMETRIC_PL[] PROGMEM = "Filament";
+const char * const MSG_VOLUMETRIC_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_VOLUMETRIC_EN,
+	MSG_VOLUMETRIC_CZ,
+	MSG_VOLUMETRIC_IT,
+	MSG_VOLUMETRIC_ES,
+	MSG_VOLUMETRIC_PL
+};
+
+const char MSG_VOLUMETRIC_ENABLED_EN[] PROGMEM = "E in mm3";
+const char MSG_VOLUMETRIC_ENABLED_CZ[] PROGMEM = "E in mm3";
+const char MSG_VOLUMETRIC_ENABLED_IT[] PROGMEM = "E in mm3";
+const char MSG_VOLUMETRIC_ENABLED_ES[] PROGMEM = "E in mm3";
+const char MSG_VOLUMETRIC_ENABLED_PL[] PROGMEM = "E in mm3";
+const char * const MSG_VOLUMETRIC_ENABLED_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_VOLUMETRIC_ENABLED_EN,
+	MSG_VOLUMETRIC_ENABLED_CZ,
+	MSG_VOLUMETRIC_ENABLED_IT,
+	MSG_VOLUMETRIC_ENABLED_ES,
+	MSG_VOLUMETRIC_ENABLED_PL
+};
+
+const char MSG_VTRAV_MIN_EN[] PROGMEM = "VTrav min";
+const char MSG_VTRAV_MIN_CZ[] PROGMEM = "VTrav min";
+const char MSG_VTRAV_MIN_IT[] PROGMEM = "VTrav min";
+const char MSG_VTRAV_MIN_ES[] PROGMEM = "VTrav min";
+const char MSG_VTRAV_MIN_PL[] PROGMEM = "VTrav min";
+const char * const MSG_VTRAV_MIN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_VTRAV_MIN_EN,
+	MSG_VTRAV_MIN_CZ,
+	MSG_VTRAV_MIN_IT,
+	MSG_VTRAV_MIN_ES,
+	MSG_VTRAV_MIN_PL
+};
+
+const char MSG_VXY_JERK_EN[] PROGMEM = "Vxy-jerk";
+const char MSG_VXY_JERK_CZ[] PROGMEM = "Vxy-jerk";
+const char MSG_VXY_JERK_IT[] PROGMEM = "Vxy-jerk";
+const char MSG_VXY_JERK_ES[] PROGMEM = "Vxy-jerk";
+const char MSG_VXY_JERK_PL[] PROGMEM = "Vxy-jerk";
+const char * const MSG_VXY_JERK_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_VXY_JERK_EN,
+	MSG_VXY_JERK_CZ,
+	MSG_VXY_JERK_IT,
+	MSG_VXY_JERK_ES,
+	MSG_VXY_JERK_PL
+};
+
+const char MSG_VZ_JERK_EN[] PROGMEM = "Vz-jerk";
+const char MSG_VZ_JERK_CZ[] PROGMEM = "Vz-jerk";
+const char MSG_VZ_JERK_IT[] PROGMEM = "Vz-jerk";
+const char MSG_VZ_JERK_ES[] PROGMEM = "Vz-jerk";
+const char MSG_VZ_JERK_PL[] PROGMEM = "Vz-jerk";
+const char * const MSG_VZ_JERK_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_VZ_JERK_EN,
+	MSG_VZ_JERK_CZ,
+	MSG_VZ_JERK_IT,
+	MSG_VZ_JERK_ES,
+	MSG_VZ_JERK_PL
+};
+
+const char MSG_WATCH_EN[] PROGMEM = "Info screen";
+const char MSG_WATCH_CZ[] PROGMEM = "Informace";
+const char MSG_WATCH_IT[] PROGMEM = "Guarda";
+const char MSG_WATCH_ES[] PROGMEM = "Monitorizar";
+const char MSG_WATCH_PL[] PROGMEM = "Informacje";
+const char * const MSG_WATCH_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_WATCH_EN,
+	MSG_WATCH_CZ,
+	MSG_WATCH_IT,
+	MSG_WATCH_ES,
+	MSG_WATCH_PL
+};
+
+const char MSG_WATCHDOG_RESET_EN[] PROGMEM = " Watchdog Reset";
+const char MSG_WATCHDOG_RESET_CZ[] PROGMEM = " Watchdog Reset";
+const char MSG_WATCHDOG_RESET_IT[] PROGMEM = " Watchdog Reset";
+const char MSG_WATCHDOG_RESET_ES[] PROGMEM = " Watchdog Reset";
+const char MSG_WATCHDOG_RESET_PL[] PROGMEM = " Watchdog Reset";
+const char * const MSG_WATCHDOG_RESET_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_WATCHDOG_RESET_EN,
+	MSG_WATCHDOG_RESET_CZ,
+	MSG_WATCHDOG_RESET_IT,
+	MSG_WATCHDOG_RESET_ES,
+	MSG_WATCHDOG_RESET_PL
+};
+
+const char MSG_X_EN[] PROGMEM = "x";
+const char MSG_X_CZ[] PROGMEM = "x";
+const char MSG_X_IT[] PROGMEM = "x";
+const char MSG_X_ES[] PROGMEM = "x";
+const char MSG_X_PL[] PROGMEM = "x";
+const char * const MSG_X_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_X_EN,
+	MSG_X_CZ,
+	MSG_X_IT,
+	MSG_X_ES,
+	MSG_X_PL
+};
+
+const char MSG_XSTEPS_EN[] PROGMEM = "Xsteps/mm";
+const char MSG_XSTEPS_CZ[] PROGMEM = "Xsteps/mm";
+const char MSG_XSTEPS_IT[] PROGMEM = "Xsteps/mm";
+const char MSG_XSTEPS_ES[] PROGMEM = "Xsteps/mm";
+const char MSG_XSTEPS_PL[] PROGMEM = "Xsteps/mm";
+const char * const MSG_XSTEPS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_XSTEPS_EN,
+	MSG_XSTEPS_CZ,
+	MSG_XSTEPS_IT,
+	MSG_XSTEPS_ES,
+	MSG_XSTEPS_PL
+};
+
+const char MSG_X_MAX_EN[] PROGMEM = "x_max: ";
+const char MSG_X_MAX_CZ[] PROGMEM = "x_max: ";
+const char MSG_X_MAX_IT[] PROGMEM = "x_max: ";
+const char MSG_X_MAX_ES[] PROGMEM = "x_max: ";
+const char MSG_X_MAX_PL[] PROGMEM = "x_max: ";
+const char * const MSG_X_MAX_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_X_MAX_EN,
+	MSG_X_MAX_CZ,
+	MSG_X_MAX_IT,
+	MSG_X_MAX_ES,
+	MSG_X_MAX_PL
+};
+
+const char MSG_X_MIN_EN[] PROGMEM = "x_min: ";
+const char MSG_X_MIN_CZ[] PROGMEM = "x_min: ";
+const char MSG_X_MIN_IT[] PROGMEM = "x_min: ";
+const char MSG_X_MIN_ES[] PROGMEM = "x_min: ";
+const char MSG_X_MIN_PL[] PROGMEM = "x_min: ";
+const char * const MSG_X_MIN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_X_MIN_EN,
+	MSG_X_MIN_CZ,
+	MSG_X_MIN_IT,
+	MSG_X_MIN_ES,
+	MSG_X_MIN_PL
+};
+
+const char MSG_Y_EN[] PROGMEM = "y";
+const char MSG_Y_CZ[] PROGMEM = "y";
+const char MSG_Y_IT[] PROGMEM = "y";
+const char MSG_Y_ES[] PROGMEM = "y";
+const char MSG_Y_PL[] PROGMEM = "y";
+const char * const MSG_Y_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_Y_EN,
+	MSG_Y_CZ,
+	MSG_Y_IT,
+	MSG_Y_ES,
+	MSG_Y_PL
+};
+
+const char MSG_YES_EN[] PROGMEM = "Yes";
+const char MSG_YES_CZ[] PROGMEM = "Ano";
+const char MSG_YES_IT[] PROGMEM = "Si";
+const char MSG_YES_ES[] PROGMEM = "Si";
+const char MSG_YES_PL[] PROGMEM = "Tak";
+const char * const MSG_YES_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_YES_EN,
+	MSG_YES_CZ,
+	MSG_YES_IT,
+	MSG_YES_ES,
+	MSG_YES_PL
+};
+
+const char MSG_YSTEPS_EN[] PROGMEM = "Ysteps/mm";
+const char MSG_YSTEPS_CZ[] PROGMEM = "Ysteps/mm";
+const char MSG_YSTEPS_IT[] PROGMEM = "Ysteps/mm";
+const char MSG_YSTEPS_ES[] PROGMEM = "Ysteps/mm";
+const char MSG_YSTEPS_PL[] PROGMEM = "Ysteps/mm";
+const char * const MSG_YSTEPS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_YSTEPS_EN,
+	MSG_YSTEPS_CZ,
+	MSG_YSTEPS_IT,
+	MSG_YSTEPS_ES,
+	MSG_YSTEPS_PL
+};
+
+const char MSG_Y_MAX_EN[] PROGMEM = "y_max: ";
+const char MSG_Y_MAX_CZ[] PROGMEM = "y_max: ";
+const char MSG_Y_MAX_IT[] PROGMEM = "y_max: ";
+const char MSG_Y_MAX_ES[] PROGMEM = "y_max: ";
+const char MSG_Y_MAX_PL[] PROGMEM = "y_max: ";
+const char * const MSG_Y_MAX_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_Y_MAX_EN,
+	MSG_Y_MAX_CZ,
+	MSG_Y_MAX_IT,
+	MSG_Y_MAX_ES,
+	MSG_Y_MAX_PL
+};
+
+const char MSG_Y_MIN_EN[] PROGMEM = "y_min: ";
+const char MSG_Y_MIN_CZ[] PROGMEM = "y_min: ";
+const char MSG_Y_MIN_IT[] PROGMEM = "y_min: ";
+const char MSG_Y_MIN_ES[] PROGMEM = "y_min: ";
+const char MSG_Y_MIN_PL[] PROGMEM = "y_min: ";
+const char * const MSG_Y_MIN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_Y_MIN_EN,
+	MSG_Y_MIN_CZ,
+	MSG_Y_MIN_IT,
+	MSG_Y_MIN_ES,
+	MSG_Y_MIN_PL
+};
+
+const char MSG_Z_EN[] PROGMEM = "z";
+const char MSG_Z_CZ[] PROGMEM = "z";
+const char MSG_Z_IT[] PROGMEM = "z";
+const char MSG_Z_ES[] PROGMEM = "z";
+const char MSG_Z_PL[] PROGMEM = "z";
+const char * const MSG_Z_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_Z_EN,
+	MSG_Z_CZ,
+	MSG_Z_IT,
+	MSG_Z_ES,
+	MSG_Z_PL
+};
+
+const char MSG_ZPROBE_OUT_EN[] PROGMEM = "Z probe out. bed";
+const char MSG_ZPROBE_OUT_CZ[] PROGMEM = "Z probe out. bed";
+const char MSG_ZPROBE_OUT_IT[] PROGMEM = "Z probe out. bed";
+const char MSG_ZPROBE_OUT_ES[] PROGMEM = "Z probe out. bed";
+const char MSG_ZPROBE_OUT_PL[] PROGMEM = "Z probe out. bed";
+const char * const MSG_ZPROBE_OUT_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ZPROBE_OUT_EN,
+	MSG_ZPROBE_OUT_CZ,
+	MSG_ZPROBE_OUT_IT,
+	MSG_ZPROBE_OUT_ES,
+	MSG_ZPROBE_OUT_PL
+};
+
+const char MSG_ZPROBE_ZOFFSET_EN[] PROGMEM = "Z Offset";
+const char MSG_ZPROBE_ZOFFSET_CZ[] PROGMEM = "Z Offset";
+const char MSG_ZPROBE_ZOFFSET_IT[] PROGMEM = "Z Offset";
+const char MSG_ZPROBE_ZOFFSET_ES[] PROGMEM = "Z Offset";
+const char MSG_ZPROBE_ZOFFSET_PL[] PROGMEM = "Z Offset";
+const char * const MSG_ZPROBE_ZOFFSET_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ZPROBE_ZOFFSET_EN,
+	MSG_ZPROBE_ZOFFSET_CZ,
+	MSG_ZPROBE_ZOFFSET_IT,
+	MSG_ZPROBE_ZOFFSET_ES,
+	MSG_ZPROBE_ZOFFSET_PL
+};
+
+const char MSG_ZSTEPS_EN[] PROGMEM = "Zsteps/mm";
+const char MSG_ZSTEPS_CZ[] PROGMEM = "Zsteps/mm";
+const char MSG_ZSTEPS_IT[] PROGMEM = "Zsteps/mm";
+const char MSG_ZSTEPS_ES[] PROGMEM = "Zsteps/mm";
+const char MSG_ZSTEPS_PL[] PROGMEM = "Zsteps/mm";
+const char * const MSG_ZSTEPS_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_ZSTEPS_EN,
+	MSG_ZSTEPS_CZ,
+	MSG_ZSTEPS_IT,
+	MSG_ZSTEPS_ES,
+	MSG_ZSTEPS_PL
+};
+
+const char MSG_Z_MAX_EN[] PROGMEM = "z_max: ";
+const char MSG_Z_MAX_CZ[] PROGMEM = "z_max: ";
+const char MSG_Z_MAX_IT[] PROGMEM = "z_max: ";
+const char MSG_Z_MAX_ES[] PROGMEM = "z_max: ";
+const char MSG_Z_MAX_PL[] PROGMEM = "z_max: ";
+const char * const MSG_Z_MAX_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_Z_MAX_EN,
+	MSG_Z_MAX_CZ,
+	MSG_Z_MAX_IT,
+	MSG_Z_MAX_ES,
+	MSG_Z_MAX_PL
+};
+
+const char MSG_Z_MIN_EN[] PROGMEM = "z_min: ";
+const char MSG_Z_MIN_CZ[] PROGMEM = "z_min: ";
+const char MSG_Z_MIN_IT[] PROGMEM = "z_min: ";
+const char MSG_Z_MIN_ES[] PROGMEM = "z_min: ";
+const char MSG_Z_MIN_PL[] PROGMEM = "z_min: ";
+const char * const MSG_Z_MIN_LANG_TABLE[LANG_NUM] PROGMEM = {
+	MSG_Z_MIN_EN,
+	MSG_Z_MIN_CZ,
+	MSG_Z_MIN_IT,
+	MSG_Z_MIN_ES,
+	MSG_Z_MIN_PL
+};
+
+const char WELCOME_MSG_EN[] PROGMEM = CUSTOM_MENDEL_NAME " ready.";
+const char WELCOME_MSG_CZ[] PROGMEM = CUSTOM_MENDEL_NAME " ok";
+const char WELCOME_MSG_IT[] PROGMEM = CUSTOM_MENDEL_NAME " pronto.";
+const char WELCOME_MSG_ES[] PROGMEM = CUSTOM_MENDEL_NAME " lista";
+const char WELCOME_MSG_PL[] PROGMEM = CUSTOM_MENDEL_NAME " gotowa";
+const char * const WELCOME_MSG_LANG_TABLE[LANG_NUM] PROGMEM = {
+	WELCOME_MSG_EN,
+	WELCOME_MSG_CZ,
+	WELCOME_MSG_IT,
+	WELCOME_MSG_ES,
+	WELCOME_MSG_PL
+};
+
+
+char langbuffer[LCD_WIDTH+1];
+char* CAT2(const char *s1,const char *s2) {
+  unsigned char len=0;
+  strncpy_P(langbuffer+len,s1,LCD_WIDTH-len);
+  len+=strlen_P(s1);
+  strncpy_P(langbuffer+len,s2,LCD_WIDTH-len);
+  return langbuffer;
+}
+char* CAT4(const char *s1,const char *s2,const char *s3,const char *s4) {
+  unsigned char len=0;
+  strncpy_P(langbuffer+len,s1,LCD_WIDTH-len);
+  len+=strlen_P(s1);
+  strncpy_P(langbuffer+len,s2,LCD_WIDTH-len);
+  len+=strlen_P(s2);
+  strncpy_P(langbuffer+len,s3,LCD_WIDTH-len);
+  len+=strlen_P(s3);
+  strncpy_P(langbuffer+len,s4,LCD_WIDTH-len);
+  return langbuffer;
+}

Firmware/language_all.h

@@ -1,267 +1,551 @@
-#ifndef LANGUAGE_ALL_H
-#define LANGUAGE_ALL_H
-
-extern unsigned char lang_selected;
-extern const char** MSG_ALL[];
-#define WELCOME_MSG MSG_ALL[lang_selected][0]
-#define MSG_SD_INSERTED MSG_ALL[lang_selected][1]
-#define MSG_SD_REMOVED MSG_ALL[lang_selected][2]
-#define MSG_MAIN MSG_ALL[lang_selected][3]
-#define MSG_AUTOSTART MSG_ALL[lang_selected][4]
-#define MSG_DISABLE_STEPPERS MSG_ALL[lang_selected][5]
-#define MSG_AUTO_HOME MSG_ALL[lang_selected][6]
-#define MSG_SET_HOME_OFFSETS MSG_ALL[lang_selected][7]
-#define MSG_SET_ORIGIN MSG_ALL[lang_selected][8]
-#define MSG_PREHEAT_PLA MSG_ALL[lang_selected][9]
-#define MSG_PREHEAT_PLA0 MSG_ALL[lang_selected][10]
-#define MSG_PREHEAT_PLA1 MSG_ALL[lang_selected][11]
-#define MSG_PREHEAT_PLA2 MSG_ALL[lang_selected][12]
-#define MSG_PREHEAT_PLA012 MSG_ALL[lang_selected][13]
-#define MSG_PREHEAT_PLA_BEDONLY MSG_ALL[lang_selected][14]
-#define MSG_PREHEAT_PLA_SETTINGS MSG_ALL[lang_selected][15]
-#define MSG_PREHEAT_ABS MSG_ALL[lang_selected][16]
-#define MSG_PREHEAT_ABS0 MSG_ALL[lang_selected][17]
-#define MSG_PREHEAT_ABS1 MSG_ALL[lang_selected][18]
-#define MSG_PREHEAT_ABS2 MSG_ALL[lang_selected][19]
-#define MSG_PREHEAT_ABS012 MSG_ALL[lang_selected][20]
-#define MSG_PREHEAT_ABS_BEDONLY MSG_ALL[lang_selected][21]
-#define MSG_PREHEAT_ABS_SETTINGS MSG_ALL[lang_selected][22]
-#define MSG_COOLDOWN MSG_ALL[lang_selected][23]
-#define MSG_SWITCH_PS_ON MSG_ALL[lang_selected][24]
-#define MSG_SWITCH_PS_OFF MSG_ALL[lang_selected][25]
-#define MSG_EXTRUDE MSG_ALL[lang_selected][26]
-#define MSG_RETRACT MSG_ALL[lang_selected][27]
-#define MSG_MOVE_AXIS MSG_ALL[lang_selected][28]
-#define MSG_MOVE_X MSG_ALL[lang_selected][29]
-#define MSG_MOVE_Y MSG_ALL[lang_selected][30]
-#define MSG_MOVE_Z MSG_ALL[lang_selected][31]
-#define MSG_MOVE_E MSG_ALL[lang_selected][32]
-#define MSG_MOVE_E1 MSG_ALL[lang_selected][33]
-#define MSG_MOVE_E2 MSG_ALL[lang_selected][34]
-#define MSG_MOVE_01MM MSG_ALL[lang_selected][35]
-#define MSG_MOVE_1MM MSG_ALL[lang_selected][36]
-#define MSG_MOVE_10MM MSG_ALL[lang_selected][37]
-#define MSG_SPEED MSG_ALL[lang_selected][38]
-#define MSG_NOZZLE MSG_ALL[lang_selected][39]
-#define MSG_NOZZLE1 MSG_ALL[lang_selected][40]
-#define MSG_NOZZLE2 MSG_ALL[lang_selected][41]
-#define MSG_BED MSG_ALL[lang_selected][42]
-#define MSG_FAN_SPEED MSG_ALL[lang_selected][43]
-#define MSG_FLOW MSG_ALL[lang_selected][44]
-#define MSG_FLOW0 MSG_ALL[lang_selected][45]
-#define MSG_FLOW1 MSG_ALL[lang_selected][46]
-#define MSG_FLOW2 MSG_ALL[lang_selected][47]
-#define MSG_CONTROL MSG_ALL[lang_selected][48]
-#define MSG_MIN MSG_ALL[lang_selected][49]
-#define MSG_MAX MSG_ALL[lang_selected][50]
-#define MSG_FACTOR MSG_ALL[lang_selected][51]
-#define MSG_AUTOTEMP MSG_ALL[lang_selected][52]
-#define MSG_ON MSG_ALL[lang_selected][53]
-#define MSG_OFF MSG_ALL[lang_selected][54]
-#define MSG_PID_P MSG_ALL[lang_selected][55]
-#define MSG_PID_I MSG_ALL[lang_selected][56]
-#define MSG_PID_D MSG_ALL[lang_selected][57]
-#define MSG_PID_C MSG_ALL[lang_selected][58]
-#define MSG_ACC MSG_ALL[lang_selected][59]
-#define MSG_VXY_JERK MSG_ALL[lang_selected][60]
-#define MSG_VZ_JERK MSG_ALL[lang_selected][61]
-#define MSG_VE_JERK MSG_ALL[lang_selected][62]
-#define MSG_VMAX MSG_ALL[lang_selected][63]
-#define MSG_X MSG_ALL[lang_selected][64]
-#define MSG_Y MSG_ALL[lang_selected][65]
-#define MSG_Z MSG_ALL[lang_selected][66]
-#define MSG_E MSG_ALL[lang_selected][67]
-#define MSG_VMIN MSG_ALL[lang_selected][68]
-#define MSG_VTRAV_MIN MSG_ALL[lang_selected][69]
-#define MSG_AMAX MSG_ALL[lang_selected][70]
-#define MSG_A_RETRACT MSG_ALL[lang_selected][71]
-#define MSG_XSTEPS MSG_ALL[lang_selected][72]
-#define MSG_YSTEPS MSG_ALL[lang_selected][73]
-#define MSG_ZSTEPS MSG_ALL[lang_selected][74]
-#define MSG_ESTEPS MSG_ALL[lang_selected][75]
-#define MSG_TEMPERATURE MSG_ALL[lang_selected][76]
-#define MSG_MOTION MSG_ALL[lang_selected][77]
-#define MSG_VOLUMETRIC MSG_ALL[lang_selected][78]
-#define MSG_VOLUMETRIC_ENABLED MSG_ALL[lang_selected][79]
-#define MSG_FILAMENT_SIZE_EXTRUDER_0 MSG_ALL[lang_selected][80]
-#define MSG_FILAMENT_SIZE_EXTRUDER_1 MSG_ALL[lang_selected][81]
-#define MSG_FILAMENT_SIZE_EXTRUDER_2 MSG_ALL[lang_selected][82]
-#define MSG_CONTRAST MSG_ALL[lang_selected][83]
-#define MSG_STORE_EPROM MSG_ALL[lang_selected][84]
-#define MSG_LOAD_EPROM MSG_ALL[lang_selected][85]
-#define MSG_RESTORE_FAILSAFE MSG_ALL[lang_selected][86]
-#define MSG_REFRESH MSG_ALL[lang_selected][87]
-#define MSG_WATCH MSG_ALL[lang_selected][88]
-#define MSG_PREPARE MSG_ALL[lang_selected][89]
-#define MSG_TUNE MSG_ALL[lang_selected][90]
-#define MSG_PAUSE_PRINT MSG_ALL[lang_selected][91]
-#define MSG_RESUME_PRINT MSG_ALL[lang_selected][92]
-#define MSG_STOP_PRINT MSG_ALL[lang_selected][93]
-#define MSG_CARD_MENU MSG_ALL[lang_selected][94]
-#define MSG_NO_CARD MSG_ALL[lang_selected][95]
-#define MSG_DWELL MSG_ALL[lang_selected][96]
-#define MSG_USERWAIT MSG_ALL[lang_selected][97]
-#define MSG_RESUMING MSG_ALL[lang_selected][98]
-#define MSG_PRINT_ABORTED MSG_ALL[lang_selected][99]
-#define MSG_NO_MOVE MSG_ALL[lang_selected][100]
-#define MSG_KILLED MSG_ALL[lang_selected][101]
-#define MSG_STOPPED MSG_ALL[lang_selected][102]
-#define MSG_CONTROL_RETRACT MSG_ALL[lang_selected][103]
-#define MSG_CONTROL_RETRACT_SWAP MSG_ALL[lang_selected][104]
-#define MSG_CONTROL_RETRACTF MSG_ALL[lang_selected][105]
-#define MSG_CONTROL_RETRACT_ZLIFT MSG_ALL[lang_selected][106]
-#define MSG_CONTROL_RETRACT_RECOVER MSG_ALL[lang_selected][107]
-#define MSG_CONTROL_RETRACT_RECOVER_SWAP MSG_ALL[lang_selected][108]
-#define MSG_CONTROL_RETRACT_RECOVERF MSG_ALL[lang_selected][109]
-#define MSG_AUTORETRACT MSG_ALL[lang_selected][110]
-#define MSG_FILAMENTCHANGE MSG_ALL[lang_selected][111]
-#define MSG_INIT_SDCARD MSG_ALL[lang_selected][112]
-#define MSG_CNG_SDCARD MSG_ALL[lang_selected][113]
-#define MSG_ZPROBE_OUT MSG_ALL[lang_selected][114]
-#define MSG_POSITION_UNKNOWN MSG_ALL[lang_selected][115]
-#define MSG_ZPROBE_ZOFFSET MSG_ALL[lang_selected][116]
-#define MSG_BABYSTEP_X MSG_ALL[lang_selected][117]
-#define MSG_BABYSTEP_Y MSG_ALL[lang_selected][118]
-#define MSG_BABYSTEP_Z MSG_ALL[lang_selected][119]
-#define MSG_ENDSTOP_ABORT MSG_ALL[lang_selected][120]
-#define MSG_ADJUSTZ MSG_ALL[lang_selected][121]
-#define MSG_PICK_Z MSG_ALL[lang_selected][122]
-#define MSG_HOMEYZ MSG_ALL[lang_selected][123]
-#define MSG_HOMEYZ_PROGRESS MSG_ALL[lang_selected][124]
-#define MSG_HOMEYZ_DONE MSG_ALL[lang_selected][125]
-#define MSG_SETTINGS MSG_ALL[lang_selected][126]
-#define MSG_PREHEAT MSG_ALL[lang_selected][127]
-#define MSG_UNLOAD_FILAMENT MSG_ALL[lang_selected][128]
-#define MSG_LOAD_FILAMENT MSG_ALL[lang_selected][129]
-#define MSG_RECTRACT MSG_ALL[lang_selected][130]
-#define MSG_ERROR MSG_ALL[lang_selected][131]
-#define MSG_PREHEAT_NOZZLE MSG_ALL[lang_selected][132]
-#define MSG_SUPPORT MSG_ALL[lang_selected][133]
-#define MSG_CORRECTLY MSG_ALL[lang_selected][134]
-#define MSG_YES MSG_ALL[lang_selected][135]
-#define MSG_NO MSG_ALL[lang_selected][136]
-#define MSG_NOT_LOADED MSG_ALL[lang_selected][137]
-#define MSG_NOT_COLOR MSG_ALL[lang_selected][138]
-#define MSG_LOADING_FILAMENT MSG_ALL[lang_selected][139]
-#define MSG_PLEASE_WAIT MSG_ALL[lang_selected][140]
-#define MSG_LOADING_COLOR MSG_ALL[lang_selected][141]
-#define MSG_CHANGE_SUCCESS MSG_ALL[lang_selected][142]
-#define MSG_PRESS MSG_ALL[lang_selected][143]
-#define MSG_INSERT_FILAMENT MSG_ALL[lang_selected][144]
-#define MSG_CHANGING_FILAMENT MSG_ALL[lang_selected][145]
-#define MSG_SILENT_MODE_ON MSG_ALL[lang_selected][146]
-#define MSG_SILENT_MODE_OFF MSG_ALL[lang_selected][147]
-#define MSG_REBOOT MSG_ALL[lang_selected][148]
-#define MSG_TAKE_EFFECT MSG_ALL[lang_selected][149]
-#define MSG_Enqueing MSG_ALL[lang_selected][150]
-#define MSG_POWERUP MSG_ALL[lang_selected][151]
-#define MSG_EXTERNAL_RESET MSG_ALL[lang_selected][152]
-#define MSG_BROWNOUT_RESET MSG_ALL[lang_selected][153]
-#define MSG_WATCHDOG_RESET MSG_ALL[lang_selected][154]
-#define MSG_SOFTWARE_RESET MSG_ALL[lang_selected][155]
-#define MSG_AUTHOR MSG_ALL[lang_selected][156]
-#define MSG_CONFIGURATION_VER MSG_ALL[lang_selected][157]
-#define MSG_FREE_MEMORY MSG_ALL[lang_selected][158]
-#define MSG_PLANNER_BUFFER_BYTES MSG_ALL[lang_selected][159]
-#define MSG_OK MSG_ALL[lang_selected][160]
-#define MSG_FILE_SAVED MSG_ALL[lang_selected][161]
-#define MSG_ERR_LINE_NO MSG_ALL[lang_selected][162]
-#define MSG_ERR_CHECKSUM_MISMATCH MSG_ALL[lang_selected][163]
-#define MSG_ERR_NO_CHECKSUM MSG_ALL[lang_selected][164]
-#define MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM MSG_ALL[lang_selected][165]
-#define MSG_FILE_PRINTED MSG_ALL[lang_selected][166]
-#define MSG_BEGIN_FILE_LIST MSG_ALL[lang_selected][167]
-#define MSG_END_FILE_LIST MSG_ALL[lang_selected][168]
-#define MSG_M104_INVALID_EXTRUDER MSG_ALL[lang_selected][169]
-#define MSG_M105_INVALID_EXTRUDER MSG_ALL[lang_selected][170]
-#define MSG_M200_INVALID_EXTRUDER MSG_ALL[lang_selected][171]
-#define MSG_M218_INVALID_EXTRUDER MSG_ALL[lang_selected][172]
-#define MSG_M221_INVALID_EXTRUDER MSG_ALL[lang_selected][173]
-#define MSG_ERR_NO_THERMISTORS MSG_ALL[lang_selected][174]
-#define MSG_M109_INVALID_EXTRUDER MSG_ALL[lang_selected][175]
-#define MSG_HEATING MSG_ALL[lang_selected][176]
-#define MSG_HEATING_COMPLETE MSG_ALL[lang_selected][177]
-#define MSG_BED_HEATING MSG_ALL[lang_selected][178]
-#define MSG_BED_DONE MSG_ALL[lang_selected][179]
-#define MSG_M115_REPORT MSG_ALL[lang_selected][180]
-#define MSG_COUNT_X MSG_ALL[lang_selected][181]
-#define MSG_ERR_KILLED MSG_ALL[lang_selected][182]
-#define MSG_ERR_STOPPED MSG_ALL[lang_selected][183]
-#define MSG_RESEND MSG_ALL[lang_selected][184]
-#define MSG_UNKNOWN_COMMAND MSG_ALL[lang_selected][185]
-#define MSG_ACTIVE_EXTRUDER MSG_ALL[lang_selected][186]
-#define MSG_INVALID_EXTRUDER MSG_ALL[lang_selected][187]
-#define MSG_X_MIN MSG_ALL[lang_selected][188]
-#define MSG_X_MAX MSG_ALL[lang_selected][189]
-#define MSG_Y_MIN MSG_ALL[lang_selected][190]
-#define MSG_Y_MAX MSG_ALL[lang_selected][191]
-#define MSG_Z_MIN MSG_ALL[lang_selected][192]
-#define MSG_Z_MAX MSG_ALL[lang_selected][193]
-#define MSG_M119_REPORT MSG_ALL[lang_selected][194]
-#define MSG_ENDSTOP_HIT MSG_ALL[lang_selected][195]
-#define MSG_ENDSTOP_OPEN MSG_ALL[lang_selected][196]
-#define MSG_HOTEND_OFFSET MSG_ALL[lang_selected][197]
-#define MSG_SD_CANT_OPEN_SUBDIR MSG_ALL[lang_selected][198]
-#define MSG_SD_INIT_FAIL MSG_ALL[lang_selected][199]
-#define MSG_SD_VOL_INIT_FAIL MSG_ALL[lang_selected][200]
-#define MSG_SD_OPENROOT_FAIL MSG_ALL[lang_selected][201]
-#define MSG_SD_CARD_OK MSG_ALL[lang_selected][202]
-#define MSG_SD_WORKDIR_FAIL MSG_ALL[lang_selected][203]
-#define MSG_SD_OPEN_FILE_FAIL MSG_ALL[lang_selected][204]
-#define MSG_SD_FILE_OPENED MSG_ALL[lang_selected][205]
-#define MSG_SD_SIZE MSG_ALL[lang_selected][206]
-#define MSG_SD_FILE_SELECTED MSG_ALL[lang_selected][207]
-#define MSG_SD_WRITE_TO_FILE MSG_ALL[lang_selected][208]
-#define MSG_SD_PRINTING_BYTE MSG_ALL[lang_selected][209]
-#define MSG_SD_NOT_PRINTING MSG_ALL[lang_selected][210]
-#define MSG_SD_ERR_WRITE_TO_FILE MSG_ALL[lang_selected][211]
-#define MSG_SD_CANT_ENTER_SUBDIR MSG_ALL[lang_selected][212]
-#define MSG_STEPPER_TOO_HIGH MSG_ALL[lang_selected][213]
-#define MSG_ENDSTOPS_HIT MSG_ALL[lang_selected][214]
-#define MSG_ERR_COLD_EXTRUDE_STOP MSG_ALL[lang_selected][215]
-#define MSG_ERR_LONG_EXTRUDE_STOP MSG_ALL[lang_selected][216]
-#define MSG_BABYSTEPPING_X MSG_ALL[lang_selected][217]
-#define MSG_BABYSTEPPING_Y MSG_ALL[lang_selected][218]
-#define MSG_BABYSTEPPING_Z MSG_ALL[lang_selected][219]
-#define MSG_SERIAL_ERROR_MENU_STRUCTURE MSG_ALL[lang_selected][220]
-#define MSG_LANGUAGE_NAME MSG_ALL[lang_selected][221]
-#define MSG_LANGUAGE_SELECT MSG_ALL[lang_selected][222]
-#define MSG_PRUSA3D MSG_ALL[lang_selected][223]
-#define MSG_PRUSA3D_FORUM MSG_ALL[lang_selected][224]
-#define MSG_PRUSA3D_HOWTO MSG_ALL[lang_selected][225]
-#define MSG_SELFTEST_ERROR MSG_ALL[lang_selected][226]
-#define MSG_SELFTEST_PLEASECHECK MSG_ALL[lang_selected][227]
-#define MSG_SELFTEST_NOTCONNECTED MSG_ALL[lang_selected][228]
-#define MSG_SELFTEST_HEATERTHERMISTOR MSG_ALL[lang_selected][229]
-#define MSG_SELFTEST_BEDHEATER MSG_ALL[lang_selected][230]
-#define MSG_SELFTEST_WIRINGERROR MSG_ALL[lang_selected][231]
-#define MSG_SELFTEST_ENDSTOPS MSG_ALL[lang_selected][232]
-#define MSG_SELFTEST_MOTOR MSG_ALL[lang_selected][233]
-#define MSG_SELFTEST_ENDSTOP MSG_ALL[lang_selected][234]
-#define MSG_SELFTEST_ENDSTOP_NOTHIT MSG_ALL[lang_selected][235]
-#define MSG_SELFTEST_OK MSG_ALL[lang_selected][236]
-#define MSG_STATS_TOTALFILAMENT MSG_ALL[lang_selected][237]
-#define MSG_STATS_TOTALPRINTTIME MSG_ALL[lang_selected][238]
-#define MSG_STATS_FILAMENTUSED MSG_ALL[lang_selected][239]
-#define MSG_STATS_PRINTTIME MSG_ALL[lang_selected][240]
-#define MSG_SELFTEST_START MSG_ALL[lang_selected][241]
-#define MSG_SELFTEST_CHECK_ENDSTOPS MSG_ALL[lang_selected][242]
-#define MSG_SELFTEST_CHECK_HOTEND MSG_ALL[lang_selected][243]
-#define MSG_SELFTEST_CHECK_X MSG_ALL[lang_selected][244]
-#define MSG_SELFTEST_CHECK_Y MSG_ALL[lang_selected][245]
-#define MSG_SELFTEST_CHECK_Z MSG_ALL[lang_selected][246]
-#define MSG_SELFTEST_CHECK_BED MSG_ALL[lang_selected][247]
-#define MSG_SELFTEST_CHECK_ALLCORRECT MSG_ALL[lang_selected][248]
-#define MSG_SELFTEST MSG_ALL[lang_selected][249]
-#define MSG_SELFTEST_FAILED MSG_ALL[lang_selected][250]
-#define MSG_STATISTICS MSG_ALL[lang_selected][251]
-#define MSG_USB_PRINTING MSG_ALL[lang_selected][252]
-#define LANGUAGE_NAME 221 
-#define LANGUAGE_SELECT 222 
-#define LANG_NUM 5 
-char* CAT2(const char *s1,const char *s2);
-char* CAT4(const char *s1,const char *s2,const char *s3,const char *s4);
-
-
-
-#endif //LANGUAGE_ALL.H
+#ifndef LANGUAGE_ALL_H
+#define LANGUAGE_ALL_H
+
+#define LANG_NUM (5)
+
+extern unsigned char lang_selected;
+
+#define LANG_TABLE_SELECT_EXPLICIT(TABLE, LANG) ((const char*)(pgm_read_ptr(TABLE + (LANG))))
+#define LANG_TABLE_SELECT(TABLE) LANG_TABLE_SELECT_EXPLICIT(TABLE, lang_selected)
+
+extern const char* const MSG_ACC_LANG_TABLE[LANG_NUM];
+#define MSG_ACC LANG_TABLE_SELECT(MSG_ACC_LANG_TABLE)
+extern const char* const MSG_ACTIVE_EXTRUDER_LANG_TABLE[LANG_NUM];
+#define MSG_ACTIVE_EXTRUDER LANG_TABLE_SELECT(MSG_ACTIVE_EXTRUDER_LANG_TABLE)
+extern const char* const MSG_ADJUSTZ_LANG_TABLE[LANG_NUM];
+#define MSG_ADJUSTZ LANG_TABLE_SELECT(MSG_ADJUSTZ_LANG_TABLE)
+extern const char* const MSG_AMAX_LANG_TABLE[LANG_NUM];
+#define MSG_AMAX LANG_TABLE_SELECT(MSG_AMAX_LANG_TABLE)
+extern const char* const MSG_AUTHOR_LANG_TABLE[LANG_NUM];
+#define MSG_AUTHOR LANG_TABLE_SELECT(MSG_AUTHOR_LANG_TABLE)
+extern const char* const MSG_AUTORETRACT_LANG_TABLE[LANG_NUM];
+#define MSG_AUTORETRACT LANG_TABLE_SELECT(MSG_AUTORETRACT_LANG_TABLE)
+extern const char* const MSG_AUTOSTART_LANG_TABLE[LANG_NUM];
+#define MSG_AUTOSTART LANG_TABLE_SELECT(MSG_AUTOSTART_LANG_TABLE)
+extern const char* const MSG_AUTOTEMP_LANG_TABLE[LANG_NUM];
+#define MSG_AUTOTEMP LANG_TABLE_SELECT(MSG_AUTOTEMP_LANG_TABLE)
+extern const char* const MSG_AUTO_HOME_LANG_TABLE[LANG_NUM];
+#define MSG_AUTO_HOME LANG_TABLE_SELECT(MSG_AUTO_HOME_LANG_TABLE)
+extern const char* const MSG_A_RETRACT_LANG_TABLE[LANG_NUM];
+#define MSG_A_RETRACT LANG_TABLE_SELECT(MSG_A_RETRACT_LANG_TABLE)
+extern const char* const MSG_BABYSTEPPING_X_LANG_TABLE[LANG_NUM];
+#define MSG_BABYSTEPPING_X LANG_TABLE_SELECT(MSG_BABYSTEPPING_X_LANG_TABLE)
+extern const char* const MSG_BABYSTEPPING_Y_LANG_TABLE[LANG_NUM];
+#define MSG_BABYSTEPPING_Y LANG_TABLE_SELECT(MSG_BABYSTEPPING_Y_LANG_TABLE)
+extern const char* const MSG_BABYSTEPPING_Z_LANG_TABLE[LANG_NUM];
+#define MSG_BABYSTEPPING_Z LANG_TABLE_SELECT(MSG_BABYSTEPPING_Z_LANG_TABLE)
+extern const char* const MSG_BABYSTEP_X_LANG_TABLE[LANG_NUM];
+#define MSG_BABYSTEP_X LANG_TABLE_SELECT(MSG_BABYSTEP_X_LANG_TABLE)
+extern const char* const MSG_BABYSTEP_Y_LANG_TABLE[LANG_NUM];
+#define MSG_BABYSTEP_Y LANG_TABLE_SELECT(MSG_BABYSTEP_Y_LANG_TABLE)
+extern const char* const MSG_BABYSTEP_Z_LANG_TABLE[LANG_NUM];
+#define MSG_BABYSTEP_Z LANG_TABLE_SELECT(MSG_BABYSTEP_Z_LANG_TABLE)
+extern const char* const MSG_BED_LANG_TABLE[LANG_NUM];
+#define MSG_BED LANG_TABLE_SELECT(MSG_BED_LANG_TABLE)
+extern const char* const MSG_BED_DONE_LANG_TABLE[LANG_NUM];
+#define MSG_BED_DONE LANG_TABLE_SELECT(MSG_BED_DONE_LANG_TABLE)
+extern const char* const MSG_BED_HEATING_LANG_TABLE[LANG_NUM];
+#define MSG_BED_HEATING LANG_TABLE_SELECT(MSG_BED_HEATING_LANG_TABLE)
+extern const char* const MSG_BEGIN_FILE_LIST_LANG_TABLE[LANG_NUM];
+#define MSG_BEGIN_FILE_LIST LANG_TABLE_SELECT(MSG_BEGIN_FILE_LIST_LANG_TABLE)
+extern const char* const MSG_BROWNOUT_RESET_LANG_TABLE[LANG_NUM];
+#define MSG_BROWNOUT_RESET LANG_TABLE_SELECT(MSG_BROWNOUT_RESET_LANG_TABLE)
+extern const char* const MSG_CALIBRATE_BED_LANG_TABLE[LANG_NUM];
+#define MSG_CALIBRATE_BED LANG_TABLE_SELECT(MSG_CALIBRATE_BED_LANG_TABLE)
+extern const char* const MSG_CALIBRATE_BED_RESET_LANG_TABLE[LANG_NUM];
+#define MSG_CALIBRATE_BED_RESET LANG_TABLE_SELECT(MSG_CALIBRATE_BED_RESET_LANG_TABLE)
+extern const char* const MSG_CARD_MENU_LANG_TABLE[LANG_NUM];
+#define MSG_CARD_MENU LANG_TABLE_SELECT(MSG_CARD_MENU_LANG_TABLE)
+extern const char* const MSG_CHANGE_SUCCESS_LANG_TABLE[LANG_NUM];
+#define MSG_CHANGE_SUCCESS LANG_TABLE_SELECT(MSG_CHANGE_SUCCESS_LANG_TABLE)
+extern const char* const MSG_CHANGING_FILAMENT_LANG_TABLE[LANG_NUM];
+#define MSG_CHANGING_FILAMENT LANG_TABLE_SELECT(MSG_CHANGING_FILAMENT_LANG_TABLE)
+extern const char* const MSG_CNG_SDCARD_LANG_TABLE[LANG_NUM];
+#define MSG_CNG_SDCARD LANG_TABLE_SELECT(MSG_CNG_SDCARD_LANG_TABLE)
+extern const char* const MSG_CONFIGURATION_VER_LANG_TABLE[LANG_NUM];
+#define MSG_CONFIGURATION_VER LANG_TABLE_SELECT(MSG_CONFIGURATION_VER_LANG_TABLE)
+extern const char* const MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_LANG_TABLE[LANG_NUM];
+#define MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1 LANG_TABLE_SELECT(MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1_LANG_TABLE)
+extern const char* const MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_LANG_TABLE[LANG_NUM];
+#define MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2 LANG_TABLE_SELECT(MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2_LANG_TABLE)
+extern const char* const MSG_CONTRAST_LANG_TABLE[LANG_NUM];
+#define MSG_CONTRAST LANG_TABLE_SELECT(MSG_CONTRAST_LANG_TABLE)
+extern const char* const MSG_CONTROL_LANG_TABLE[LANG_NUM];
+#define MSG_CONTROL LANG_TABLE_SELECT(MSG_CONTROL_LANG_TABLE)
+extern const char* const MSG_CONTROL_RETRACT_LANG_TABLE[LANG_NUM];
+#define MSG_CONTROL_RETRACT LANG_TABLE_SELECT(MSG_CONTROL_RETRACT_LANG_TABLE)
+extern const char* const MSG_CONTROL_RETRACTF_LANG_TABLE[LANG_NUM];
+#define MSG_CONTROL_RETRACTF LANG_TABLE_SELECT(MSG_CONTROL_RETRACTF_LANG_TABLE)
+extern const char* const MSG_CONTROL_RETRACT_RECOVER_LANG_TABLE[LANG_NUM];
+#define MSG_CONTROL_RETRACT_RECOVER LANG_TABLE_SELECT(MSG_CONTROL_RETRACT_RECOVER_LANG_TABLE)
+extern const char* const MSG_CONTROL_RETRACT_RECOVERF_LANG_TABLE[LANG_NUM];
+#define MSG_CONTROL_RETRACT_RECOVERF LANG_TABLE_SELECT(MSG_CONTROL_RETRACT_RECOVERF_LANG_TABLE)
+extern const char* const MSG_CONTROL_RETRACT_RECOVER_SWAP_LANG_TABLE[LANG_NUM];
+#define MSG_CONTROL_RETRACT_RECOVER_SWAP LANG_TABLE_SELECT(MSG_CONTROL_RETRACT_RECOVER_SWAP_LANG_TABLE)
+extern const char* const MSG_CONTROL_RETRACT_SWAP_LANG_TABLE[LANG_NUM];
+#define MSG_CONTROL_RETRACT_SWAP LANG_TABLE_SELECT(MSG_CONTROL_RETRACT_SWAP_LANG_TABLE)
+extern const char* const MSG_CONTROL_RETRACT_ZLIFT_LANG_TABLE[LANG_NUM];
+#define MSG_CONTROL_RETRACT_ZLIFT LANG_TABLE_SELECT(MSG_CONTROL_RETRACT_ZLIFT_LANG_TABLE)
+extern const char* const MSG_COOLDOWN_LANG_TABLE[LANG_NUM];
+#define MSG_COOLDOWN LANG_TABLE_SELECT(MSG_COOLDOWN_LANG_TABLE)
+extern const char* const MSG_CORRECTLY_LANG_TABLE[LANG_NUM];
+#define MSG_CORRECTLY LANG_TABLE_SELECT(MSG_CORRECTLY_LANG_TABLE)
+extern const char* const MSG_COUNT_X_LANG_TABLE[LANG_NUM];
+#define MSG_COUNT_X LANG_TABLE_SELECT(MSG_COUNT_X_LANG_TABLE)
+extern const char* const MSG_DISABLE_STEPPERS_LANG_TABLE[LANG_NUM];
+#define MSG_DISABLE_STEPPERS LANG_TABLE_SELECT(MSG_DISABLE_STEPPERS_LANG_TABLE)
+extern const char* const MSG_DWELL_LANG_TABLE[LANG_NUM];
+#define MSG_DWELL LANG_TABLE_SELECT(MSG_DWELL_LANG_TABLE)
+extern const char* const MSG_E_LANG_TABLE[LANG_NUM];
+#define MSG_E LANG_TABLE_SELECT(MSG_E_LANG_TABLE)
+extern const char* const MSG_ENDSTOPS_HIT_LANG_TABLE[LANG_NUM];
+#define MSG_ENDSTOPS_HIT LANG_TABLE_SELECT(MSG_ENDSTOPS_HIT_LANG_TABLE)
+extern const char* const MSG_ENDSTOP_ABORT_LANG_TABLE[LANG_NUM];
+#define MSG_ENDSTOP_ABORT LANG_TABLE_SELECT(MSG_ENDSTOP_ABORT_LANG_TABLE)
+extern const char* const MSG_ENDSTOP_HIT_LANG_TABLE[LANG_NUM];
+#define MSG_ENDSTOP_HIT LANG_TABLE_SELECT(MSG_ENDSTOP_HIT_LANG_TABLE)
+extern const char* const MSG_ENDSTOP_OPEN_LANG_TABLE[LANG_NUM];
+#define MSG_ENDSTOP_OPEN LANG_TABLE_SELECT(MSG_ENDSTOP_OPEN_LANG_TABLE)
+extern const char* const MSG_END_FILE_LIST_LANG_TABLE[LANG_NUM];
+#define MSG_END_FILE_LIST LANG_TABLE_SELECT(MSG_END_FILE_LIST_LANG_TABLE)
+extern const char* const MSG_ERROR_LANG_TABLE[LANG_NUM];
+#define MSG_ERROR LANG_TABLE_SELECT(MSG_ERROR_LANG_TABLE)
+extern const char* const MSG_ERR_CHECKSUM_MISMATCH_LANG_TABLE[LANG_NUM];
+#define MSG_ERR_CHECKSUM_MISMATCH LANG_TABLE_SELECT(MSG_ERR_CHECKSUM_MISMATCH_LANG_TABLE)
+extern const char* const MSG_ERR_COLD_EXTRUDE_STOP_LANG_TABLE[LANG_NUM];
+#define MSG_ERR_COLD_EXTRUDE_STOP LANG_TABLE_SELECT(MSG_ERR_COLD_EXTRUDE_STOP_LANG_TABLE)
+extern const char* const MSG_ERR_KILLED_LANG_TABLE[LANG_NUM];
+#define MSG_ERR_KILLED LANG_TABLE_SELECT(MSG_ERR_KILLED_LANG_TABLE)
+extern const char* const MSG_ERR_LINE_NO_LANG_TABLE[LANG_NUM];
+#define MSG_ERR_LINE_NO LANG_TABLE_SELECT(MSG_ERR_LINE_NO_LANG_TABLE)
+extern const char* const MSG_ERR_LONG_EXTRUDE_STOP_LANG_TABLE[LANG_NUM];
+#define MSG_ERR_LONG_EXTRUDE_STOP LANG_TABLE_SELECT(MSG_ERR_LONG_EXTRUDE_STOP_LANG_TABLE)
+extern const char* const MSG_ERR_NO_CHECKSUM_LANG_TABLE[LANG_NUM];
+#define MSG_ERR_NO_CHECKSUM LANG_TABLE_SELECT(MSG_ERR_NO_CHECKSUM_LANG_TABLE)
+extern const char* const MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_LANG_TABLE[LANG_NUM];
+#define MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM LANG_TABLE_SELECT(MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM_LANG_TABLE)
+extern const char* const MSG_ERR_NO_THERMISTORS_LANG_TABLE[LANG_NUM];
+#define MSG_ERR_NO_THERMISTORS LANG_TABLE_SELECT(MSG_ERR_NO_THERMISTORS_LANG_TABLE)
+extern const char* const MSG_ERR_STOPPED_LANG_TABLE[LANG_NUM];
+#define MSG_ERR_STOPPED LANG_TABLE_SELECT(MSG_ERR_STOPPED_LANG_TABLE)
+extern const char* const MSG_ESTEPS_LANG_TABLE[LANG_NUM];
+#define MSG_ESTEPS LANG_TABLE_SELECT(MSG_ESTEPS_LANG_TABLE)
+extern const char* const MSG_EXTERNAL_RESET_LANG_TABLE[LANG_NUM];
+#define MSG_EXTERNAL_RESET LANG_TABLE_SELECT(MSG_EXTERNAL_RESET_LANG_TABLE)
+extern const char* const MSG_EXTRUDE_LANG_TABLE[LANG_NUM];
+#define MSG_EXTRUDE LANG_TABLE_SELECT(MSG_EXTRUDE_LANG_TABLE)
+extern const char* const MSG_Enqueing_LANG_TABLE[LANG_NUM];
+#define MSG_Enqueing LANG_TABLE_SELECT(MSG_Enqueing_LANG_TABLE)
+extern const char* const MSG_FACTOR_LANG_TABLE[LANG_NUM];
+#define MSG_FACTOR LANG_TABLE_SELECT(MSG_FACTOR_LANG_TABLE)
+extern const char* const MSG_FAN_SPEED_LANG_TABLE[LANG_NUM];
+#define MSG_FAN_SPEED LANG_TABLE_SELECT(MSG_FAN_SPEED_LANG_TABLE)
+extern const char* const MSG_FILAMENTCHANGE_LANG_TABLE[LANG_NUM];
+#define MSG_FILAMENTCHANGE LANG_TABLE_SELECT(MSG_FILAMENTCHANGE_LANG_TABLE)
+extern const char* const MSG_FILAMENT_SIZE_EXTRUDER_0_LANG_TABLE[LANG_NUM];
+#define MSG_FILAMENT_SIZE_EXTRUDER_0 LANG_TABLE_SELECT(MSG_FILAMENT_SIZE_EXTRUDER_0_LANG_TABLE)
+extern const char* const MSG_FILAMENT_SIZE_EXTRUDER_1_LANG_TABLE[LANG_NUM];
+#define MSG_FILAMENT_SIZE_EXTRUDER_1 LANG_TABLE_SELECT(MSG_FILAMENT_SIZE_EXTRUDER_1_LANG_TABLE)
+extern const char* const MSG_FILAMENT_SIZE_EXTRUDER_2_LANG_TABLE[LANG_NUM];
+#define MSG_FILAMENT_SIZE_EXTRUDER_2 LANG_TABLE_SELECT(MSG_FILAMENT_SIZE_EXTRUDER_2_LANG_TABLE)
+extern const char* const MSG_FILE_PRINTED_LANG_TABLE[LANG_NUM];
+#define MSG_FILE_PRINTED LANG_TABLE_SELECT(MSG_FILE_PRINTED_LANG_TABLE)
+extern const char* const MSG_FILE_SAVED_LANG_TABLE[LANG_NUM];
+#define MSG_FILE_SAVED LANG_TABLE_SELECT(MSG_FILE_SAVED_LANG_TABLE)
+extern const char* const MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_LANG_TABLE[LANG_NUM];
+#define MSG_FIND_BED_OFFSET_AND_SKEW_LINE1 LANG_TABLE_SELECT(MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_LANG_TABLE)
+extern const char* const MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_LANG_TABLE[LANG_NUM];
+#define MSG_FIND_BED_OFFSET_AND_SKEW_LINE2 LANG_TABLE_SELECT(MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_LANG_TABLE)
+extern const char* const MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_LANG_TABLE[LANG_NUM];
+#define MSG_FIND_BED_OFFSET_AND_SKEW_LINE3 LANG_TABLE_SELECT(MSG_FIND_BED_OFFSET_AND_SKEW_LINE3_LANG_TABLE)
+extern const char* const MSG_FLOW_LANG_TABLE[LANG_NUM];
+#define MSG_FLOW LANG_TABLE_SELECT(MSG_FLOW_LANG_TABLE)
+extern const char* const MSG_FLOW0_LANG_TABLE[LANG_NUM];
+#define MSG_FLOW0 LANG_TABLE_SELECT(MSG_FLOW0_LANG_TABLE)
+extern const char* const MSG_FLOW1_LANG_TABLE[LANG_NUM];
+#define MSG_FLOW1 LANG_TABLE_SELECT(MSG_FLOW1_LANG_TABLE)
+extern const char* const MSG_FLOW2_LANG_TABLE[LANG_NUM];
+#define MSG_FLOW2 LANG_TABLE_SELECT(MSG_FLOW2_LANG_TABLE)
+extern const char* const MSG_FREE_MEMORY_LANG_TABLE[LANG_NUM];
+#define MSG_FREE_MEMORY LANG_TABLE_SELECT(MSG_FREE_MEMORY_LANG_TABLE)
+extern const char* const MSG_HEATING_LANG_TABLE[LANG_NUM];
+#define MSG_HEATING LANG_TABLE_SELECT(MSG_HEATING_LANG_TABLE)
+extern const char* const MSG_HEATING_COMPLETE_LANG_TABLE[LANG_NUM];
+#define MSG_HEATING_COMPLETE LANG_TABLE_SELECT(MSG_HEATING_COMPLETE_LANG_TABLE)
+extern const char* const MSG_HOMEYZ_LANG_TABLE[LANG_NUM];
+#define MSG_HOMEYZ LANG_TABLE_SELECT(MSG_HOMEYZ_LANG_TABLE)
+extern const char* const MSG_HOMEYZ_DONE_LANG_TABLE[LANG_NUM];
+#define MSG_HOMEYZ_DONE LANG_TABLE_SELECT(MSG_HOMEYZ_DONE_LANG_TABLE)
+extern const char* const MSG_HOMEYZ_PROGRESS_LANG_TABLE[LANG_NUM];
+#define MSG_HOMEYZ_PROGRESS LANG_TABLE_SELECT(MSG_HOMEYZ_PROGRESS_LANG_TABLE)
+extern const char* const MSG_HOTEND_OFFSET_LANG_TABLE[LANG_NUM];
+#define MSG_HOTEND_OFFSET LANG_TABLE_SELECT(MSG_HOTEND_OFFSET_LANG_TABLE)
+extern const char* const MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_LANG_TABLE[LANG_NUM];
+#define MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1 LANG_TABLE_SELECT(MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_LANG_TABLE)
+extern const char* const MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_LANG_TABLE[LANG_NUM];
+#define MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2 LANG_TABLE_SELECT(MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_LANG_TABLE)
+extern const char* const MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_LANG_TABLE[LANG_NUM];
+#define MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3 LANG_TABLE_SELECT(MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3_LANG_TABLE)
+extern const char* const MSG_INIT_SDCARD_LANG_TABLE[LANG_NUM];
+#define MSG_INIT_SDCARD LANG_TABLE_SELECT(MSG_INIT_SDCARD_LANG_TABLE)
+extern const char* const MSG_INSERT_FILAMENT_LANG_TABLE[LANG_NUM];
+#define MSG_INSERT_FILAMENT LANG_TABLE_SELECT(MSG_INSERT_FILAMENT_LANG_TABLE)
+extern const char* const MSG_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM];
+#define MSG_INVALID_EXTRUDER LANG_TABLE_SELECT(MSG_INVALID_EXTRUDER_LANG_TABLE)
+extern const char* const MSG_KILLED_LANG_TABLE[LANG_NUM];
+#define MSG_KILLED LANG_TABLE_SELECT(MSG_KILLED_LANG_TABLE)
+extern const char* const MSG_LANGUAGE_NAME_LANG_TABLE[LANG_NUM];
+#define MSG_LANGUAGE_NAME LANG_TABLE_SELECT(MSG_LANGUAGE_NAME_LANG_TABLE)
+#define MSG_LANGUAGE_NAME_EXPLICIT(LANG) LANG_TABLE_SELECT_EXPLICIT(MSG_LANGUAGE_NAME_LANG_TABLE, LANG)
+extern const char* const MSG_LANGUAGE_SELECT_LANG_TABLE[LANG_NUM];
+#define MSG_LANGUAGE_SELECT LANG_TABLE_SELECT(MSG_LANGUAGE_SELECT_LANG_TABLE)
+#define MSG_LANGUAGE_SELECT_EXPLICIT(LANG) LANG_TABLE_SELECT_EXPLICIT(MSG_LANGUAGE_SELECT_LANG_TABLE, LANG)
+extern const char* const MSG_LOADING_COLOR_LANG_TABLE[LANG_NUM];
+#define MSG_LOADING_COLOR LANG_TABLE_SELECT(MSG_LOADING_COLOR_LANG_TABLE)
+extern const char* const MSG_LOADING_FILAMENT_LANG_TABLE[LANG_NUM];
+#define MSG_LOADING_FILAMENT LANG_TABLE_SELECT(MSG_LOADING_FILAMENT_LANG_TABLE)
+extern const char* const MSG_LOAD_EPROM_LANG_TABLE[LANG_NUM];
+#define MSG_LOAD_EPROM LANG_TABLE_SELECT(MSG_LOAD_EPROM_LANG_TABLE)
+extern const char* const MSG_LOAD_FILAMENT_LANG_TABLE[LANG_NUM];
+#define MSG_LOAD_FILAMENT LANG_TABLE_SELECT(MSG_LOAD_FILAMENT_LANG_TABLE)
+extern const char* const MSG_M104_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM];
+#define MSG_M104_INVALID_EXTRUDER LANG_TABLE_SELECT(MSG_M104_INVALID_EXTRUDER_LANG_TABLE)
+extern const char* const MSG_M105_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM];
+#define MSG_M105_INVALID_EXTRUDER LANG_TABLE_SELECT(MSG_M105_INVALID_EXTRUDER_LANG_TABLE)
+extern const char* const MSG_M109_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM];
+#define MSG_M109_INVALID_EXTRUDER LANG_TABLE_SELECT(MSG_M109_INVALID_EXTRUDER_LANG_TABLE)
+extern const char* const MSG_M115_REPORT_LANG_TABLE[LANG_NUM];
+#define MSG_M115_REPORT LANG_TABLE_SELECT(MSG_M115_REPORT_LANG_TABLE)
+extern const char* const MSG_M119_REPORT_LANG_TABLE[LANG_NUM];
+#define MSG_M119_REPORT LANG_TABLE_SELECT(MSG_M119_REPORT_LANG_TABLE)
+extern const char* const MSG_M200_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM];
+#define MSG_M200_INVALID_EXTRUDER LANG_TABLE_SELECT(MSG_M200_INVALID_EXTRUDER_LANG_TABLE)
+extern const char* const MSG_M218_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM];
+#define MSG_M218_INVALID_EXTRUDER LANG_TABLE_SELECT(MSG_M218_INVALID_EXTRUDER_LANG_TABLE)
+extern const char* const MSG_M221_INVALID_EXTRUDER_LANG_TABLE[LANG_NUM];
+#define MSG_M221_INVALID_EXTRUDER LANG_TABLE_SELECT(MSG_M221_INVALID_EXTRUDER_LANG_TABLE)
+extern const char* const MSG_MAIN_LANG_TABLE[LANG_NUM];
+#define MSG_MAIN LANG_TABLE_SELECT(MSG_MAIN_LANG_TABLE)
+extern const char* const MSG_MAX_LANG_TABLE[LANG_NUM];
+#define MSG_MAX LANG_TABLE_SELECT(MSG_MAX_LANG_TABLE)
+extern const char* const MSG_MIN_LANG_TABLE[LANG_NUM];
+#define MSG_MIN LANG_TABLE_SELECT(MSG_MIN_LANG_TABLE)
+extern const char* const MSG_MOTION_LANG_TABLE[LANG_NUM];
+#define MSG_MOTION LANG_TABLE_SELECT(MSG_MOTION_LANG_TABLE)
+extern const char* const MSG_MOVE_01MM_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_01MM LANG_TABLE_SELECT(MSG_MOVE_01MM_LANG_TABLE)
+extern const char* const MSG_MOVE_10MM_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_10MM LANG_TABLE_SELECT(MSG_MOVE_10MM_LANG_TABLE)
+extern const char* const MSG_MOVE_1MM_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_1MM LANG_TABLE_SELECT(MSG_MOVE_1MM_LANG_TABLE)
+extern const char* const MSG_MOVE_AXIS_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_AXIS LANG_TABLE_SELECT(MSG_MOVE_AXIS_LANG_TABLE)
+extern const char* const MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1 LANG_TABLE_SELECT(MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1_LANG_TABLE)
+extern const char* const MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2 LANG_TABLE_SELECT(MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2_LANG_TABLE)
+extern const char* const MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3 LANG_TABLE_SELECT(MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3_LANG_TABLE)
+extern const char* const MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4 LANG_TABLE_SELECT(MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4_LANG_TABLE)
+extern const char* const MSG_MOVE_E_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_E LANG_TABLE_SELECT(MSG_MOVE_E_LANG_TABLE)
+extern const char* const MSG_MOVE_E1_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_E1 LANG_TABLE_SELECT(MSG_MOVE_E1_LANG_TABLE)
+extern const char* const MSG_MOVE_E2_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_E2 LANG_TABLE_SELECT(MSG_MOVE_E2_LANG_TABLE)
+extern const char* const MSG_MOVE_X_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_X LANG_TABLE_SELECT(MSG_MOVE_X_LANG_TABLE)
+extern const char* const MSG_MOVE_Y_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_Y LANG_TABLE_SELECT(MSG_MOVE_Y_LANG_TABLE)
+extern const char* const MSG_MOVE_Z_LANG_TABLE[LANG_NUM];
+#define MSG_MOVE_Z LANG_TABLE_SELECT(MSG_MOVE_Z_LANG_TABLE)
+extern const char* const MSG_NO_LANG_TABLE[LANG_NUM];
+#define MSG_NO LANG_TABLE_SELECT(MSG_NO_LANG_TABLE)
+extern const char* const MSG_NOT_COLOR_LANG_TABLE[LANG_NUM];
+#define MSG_NOT_COLOR LANG_TABLE_SELECT(MSG_NOT_COLOR_LANG_TABLE)
+extern const char* const MSG_NOT_LOADED_LANG_TABLE[LANG_NUM];
+#define MSG_NOT_LOADED LANG_TABLE_SELECT(MSG_NOT_LOADED_LANG_TABLE)
+extern const char* const MSG_NOZZLE_LANG_TABLE[LANG_NUM];
+#define MSG_NOZZLE LANG_TABLE_SELECT(MSG_NOZZLE_LANG_TABLE)
+extern const char* const MSG_NOZZLE1_LANG_TABLE[LANG_NUM];
+#define MSG_NOZZLE1 LANG_TABLE_SELECT(MSG_NOZZLE1_LANG_TABLE)
+extern const char* const MSG_NOZZLE2_LANG_TABLE[LANG_NUM];
+#define MSG_NOZZLE2 LANG_TABLE_SELECT(MSG_NOZZLE2_LANG_TABLE)
+extern const char* const MSG_NO_CARD_LANG_TABLE[LANG_NUM];
+#define MSG_NO_CARD LANG_TABLE_SELECT(MSG_NO_CARD_LANG_TABLE)
+extern const char* const MSG_NO_MOVE_LANG_TABLE[LANG_NUM];
+#define MSG_NO_MOVE LANG_TABLE_SELECT(MSG_NO_MOVE_LANG_TABLE)
+extern const char* const MSG_OFF_LANG_TABLE[LANG_NUM];
+#define MSG_OFF LANG_TABLE_SELECT(MSG_OFF_LANG_TABLE)
+extern const char* const MSG_OK_LANG_TABLE[LANG_NUM];
+#define MSG_OK LANG_TABLE_SELECT(MSG_OK_LANG_TABLE)
+extern const char* const MSG_ON_LANG_TABLE[LANG_NUM];
+#define MSG_ON LANG_TABLE_SELECT(MSG_ON_LANG_TABLE)
+extern const char* const MSG_PAUSE_PRINT_LANG_TABLE[LANG_NUM];
+#define MSG_PAUSE_PRINT LANG_TABLE_SELECT(MSG_PAUSE_PRINT_LANG_TABLE)
+extern const char* const MSG_PICK_Z_LANG_TABLE[LANG_NUM];
+#define MSG_PICK_Z LANG_TABLE_SELECT(MSG_PICK_Z_LANG_TABLE)
+extern const char* const MSG_PID_C_LANG_TABLE[LANG_NUM];
+#define MSG_PID_C LANG_TABLE_SELECT(MSG_PID_C_LANG_TABLE)
+extern const char* const MSG_PID_D_LANG_TABLE[LANG_NUM];
+#define MSG_PID_D LANG_TABLE_SELECT(MSG_PID_D_LANG_TABLE)
+extern const char* const MSG_PID_I_LANG_TABLE[LANG_NUM];
+#define MSG_PID_I LANG_TABLE_SELECT(MSG_PID_I_LANG_TABLE)
+extern const char* const MSG_PID_P_LANG_TABLE[LANG_NUM];
+#define MSG_PID_P LANG_TABLE_SELECT(MSG_PID_P_LANG_TABLE)
+extern const char* const MSG_PLANNER_BUFFER_BYTES_LANG_TABLE[LANG_NUM];
+#define MSG_PLANNER_BUFFER_BYTES LANG_TABLE_SELECT(MSG_PLANNER_BUFFER_BYTES_LANG_TABLE)
+extern const char* const MSG_PLEASE_WAIT_LANG_TABLE[LANG_NUM];
+#define MSG_PLEASE_WAIT LANG_TABLE_SELECT(MSG_PLEASE_WAIT_LANG_TABLE)
+extern const char* const MSG_POSITION_UNKNOWN_LANG_TABLE[LANG_NUM];
+#define MSG_POSITION_UNKNOWN LANG_TABLE_SELECT(MSG_POSITION_UNKNOWN_LANG_TABLE)
+extern const char* const MSG_POWERUP_LANG_TABLE[LANG_NUM];
+#define MSG_POWERUP LANG_TABLE_SELECT(MSG_POWERUP_LANG_TABLE)
+extern const char* const MSG_PREHEAT_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT LANG_TABLE_SELECT(MSG_PREHEAT_LANG_TABLE)
+extern const char* const MSG_PREHEAT_ABS_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_ABS LANG_TABLE_SELECT(MSG_PREHEAT_ABS_LANG_TABLE)
+extern const char* const MSG_PREHEAT_ABS0_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_ABS0 LANG_TABLE_SELECT(MSG_PREHEAT_ABS0_LANG_TABLE)
+extern const char* const MSG_PREHEAT_ABS012_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_ABS012 LANG_TABLE_SELECT(MSG_PREHEAT_ABS012_LANG_TABLE)
+extern const char* const MSG_PREHEAT_ABS1_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_ABS1 LANG_TABLE_SELECT(MSG_PREHEAT_ABS1_LANG_TABLE)
+extern const char* const MSG_PREHEAT_ABS2_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_ABS2 LANG_TABLE_SELECT(MSG_PREHEAT_ABS2_LANG_TABLE)
+extern const char* const MSG_PREHEAT_ABS_BEDONLY_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_ABS_BEDONLY LANG_TABLE_SELECT(MSG_PREHEAT_ABS_BEDONLY_LANG_TABLE)
+extern const char* const MSG_PREHEAT_ABS_SETTINGS_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_ABS_SETTINGS LANG_TABLE_SELECT(MSG_PREHEAT_ABS_SETTINGS_LANG_TABLE)
+extern const char* const MSG_PREHEAT_NOZZLE_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_NOZZLE LANG_TABLE_SELECT(MSG_PREHEAT_NOZZLE_LANG_TABLE)
+extern const char* const MSG_PREHEAT_PLA_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_PLA LANG_TABLE_SELECT(MSG_PREHEAT_PLA_LANG_TABLE)
+extern const char* const MSG_PREHEAT_PLA0_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_PLA0 LANG_TABLE_SELECT(MSG_PREHEAT_PLA0_LANG_TABLE)
+extern const char* const MSG_PREHEAT_PLA012_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_PLA012 LANG_TABLE_SELECT(MSG_PREHEAT_PLA012_LANG_TABLE)
+extern const char* const MSG_PREHEAT_PLA1_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_PLA1 LANG_TABLE_SELECT(MSG_PREHEAT_PLA1_LANG_TABLE)
+extern const char* const MSG_PREHEAT_PLA2_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_PLA2 LANG_TABLE_SELECT(MSG_PREHEAT_PLA2_LANG_TABLE)
+extern const char* const MSG_PREHEAT_PLA_BEDONLY_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_PLA_BEDONLY LANG_TABLE_SELECT(MSG_PREHEAT_PLA_BEDONLY_LANG_TABLE)
+extern const char* const MSG_PREHEAT_PLA_SETTINGS_LANG_TABLE[LANG_NUM];
+#define MSG_PREHEAT_PLA_SETTINGS LANG_TABLE_SELECT(MSG_PREHEAT_PLA_SETTINGS_LANG_TABLE)
+extern const char* const MSG_PREPARE_LANG_TABLE[LANG_NUM];
+#define MSG_PREPARE LANG_TABLE_SELECT(MSG_PREPARE_LANG_TABLE)
+extern const char* const MSG_PRESS_LANG_TABLE[LANG_NUM];
+#define MSG_PRESS LANG_TABLE_SELECT(MSG_PRESS_LANG_TABLE)
+extern const char* const MSG_PRINT_ABORTED_LANG_TABLE[LANG_NUM];
+#define MSG_PRINT_ABORTED LANG_TABLE_SELECT(MSG_PRINT_ABORTED_LANG_TABLE)
+extern const char* const MSG_PRUSA3D_LANG_TABLE[LANG_NUM];
+#define MSG_PRUSA3D LANG_TABLE_SELECT(MSG_PRUSA3D_LANG_TABLE)
+extern const char* const MSG_PRUSA3D_FORUM_LANG_TABLE[LANG_NUM];
+#define MSG_PRUSA3D_FORUM LANG_TABLE_SELECT(MSG_PRUSA3D_FORUM_LANG_TABLE)
+extern const char* const MSG_PRUSA3D_HOWTO_LANG_TABLE[LANG_NUM];
+#define MSG_PRUSA3D_HOWTO LANG_TABLE_SELECT(MSG_PRUSA3D_HOWTO_LANG_TABLE)
+extern const char* const MSG_REBOOT_LANG_TABLE[LANG_NUM];
+#define MSG_REBOOT LANG_TABLE_SELECT(MSG_REBOOT_LANG_TABLE)
+extern const char* const MSG_RECTRACT_LANG_TABLE[LANG_NUM];
+#define MSG_RECTRACT LANG_TABLE_SELECT(MSG_RECTRACT_LANG_TABLE)
+extern const char* const MSG_REFRESH_LANG_TABLE[LANG_NUM];
+#define MSG_REFRESH LANG_TABLE_SELECT(MSG_REFRESH_LANG_TABLE)
+extern const char* const MSG_RESEND_LANG_TABLE[LANG_NUM];
+#define MSG_RESEND LANG_TABLE_SELECT(MSG_RESEND_LANG_TABLE)
+extern const char* const MSG_RESTORE_FAILSAFE_LANG_TABLE[LANG_NUM];
+#define MSG_RESTORE_FAILSAFE LANG_TABLE_SELECT(MSG_RESTORE_FAILSAFE_LANG_TABLE)
+extern const char* const MSG_RESUME_PRINT_LANG_TABLE[LANG_NUM];
+#define MSG_RESUME_PRINT LANG_TABLE_SELECT(MSG_RESUME_PRINT_LANG_TABLE)
+extern const char* const MSG_RESUMING_LANG_TABLE[LANG_NUM];
+#define MSG_RESUMING LANG_TABLE_SELECT(MSG_RESUMING_LANG_TABLE)
+extern const char* const MSG_RETRACT_LANG_TABLE[LANG_NUM];
+#define MSG_RETRACT LANG_TABLE_SELECT(MSG_RETRACT_LANG_TABLE)
+extern const char* const MSG_SD_CANT_ENTER_SUBDIR_LANG_TABLE[LANG_NUM];
+#define MSG_SD_CANT_ENTER_SUBDIR LANG_TABLE_SELECT(MSG_SD_CANT_ENTER_SUBDIR_LANG_TABLE)
+extern const char* const MSG_SD_CANT_OPEN_SUBDIR_LANG_TABLE[LANG_NUM];
+#define MSG_SD_CANT_OPEN_SUBDIR LANG_TABLE_SELECT(MSG_SD_CANT_OPEN_SUBDIR_LANG_TABLE)
+extern const char* const MSG_SD_CARD_OK_LANG_TABLE[LANG_NUM];
+#define MSG_SD_CARD_OK LANG_TABLE_SELECT(MSG_SD_CARD_OK_LANG_TABLE)
+extern const char* const MSG_SD_ERR_WRITE_TO_FILE_LANG_TABLE[LANG_NUM];
+#define MSG_SD_ERR_WRITE_TO_FILE LANG_TABLE_SELECT(MSG_SD_ERR_WRITE_TO_FILE_LANG_TABLE)
+extern const char* const MSG_SD_FILE_OPENED_LANG_TABLE[LANG_NUM];
+#define MSG_SD_FILE_OPENED LANG_TABLE_SELECT(MSG_SD_FILE_OPENED_LANG_TABLE)
+extern const char* const MSG_SD_FILE_SELECTED_LANG_TABLE[LANG_NUM];
+#define MSG_SD_FILE_SELECTED LANG_TABLE_SELECT(MSG_SD_FILE_SELECTED_LANG_TABLE)
+extern const char* const MSG_SD_INIT_FAIL_LANG_TABLE[LANG_NUM];
+#define MSG_SD_INIT_FAIL LANG_TABLE_SELECT(MSG_SD_INIT_FAIL_LANG_TABLE)
+extern const char* const MSG_SD_INSERTED_LANG_TABLE[LANG_NUM];
+#define MSG_SD_INSERTED LANG_TABLE_SELECT(MSG_SD_INSERTED_LANG_TABLE)
+extern const char* const MSG_SD_NOT_PRINTING_LANG_TABLE[LANG_NUM];
+#define MSG_SD_NOT_PRINTING LANG_TABLE_SELECT(MSG_SD_NOT_PRINTING_LANG_TABLE)
+extern const char* const MSG_SD_OPENROOT_FAIL_LANG_TABLE[LANG_NUM];
+#define MSG_SD_OPENROOT_FAIL LANG_TABLE_SELECT(MSG_SD_OPENROOT_FAIL_LANG_TABLE)
+extern const char* const MSG_SD_OPEN_FILE_FAIL_LANG_TABLE[LANG_NUM];
+#define MSG_SD_OPEN_FILE_FAIL LANG_TABLE_SELECT(MSG_SD_OPEN_FILE_FAIL_LANG_TABLE)
+extern const char* const MSG_SD_PRINTING_BYTE_LANG_TABLE[LANG_NUM];
+#define MSG_SD_PRINTING_BYTE LANG_TABLE_SELECT(MSG_SD_PRINTING_BYTE_LANG_TABLE)
+extern const char* const MSG_SD_REMOVED_LANG_TABLE[LANG_NUM];
+#define MSG_SD_REMOVED LANG_TABLE_SELECT(MSG_SD_REMOVED_LANG_TABLE)
+extern const char* const MSG_SD_SIZE_LANG_TABLE[LANG_NUM];
+#define MSG_SD_SIZE LANG_TABLE_SELECT(MSG_SD_SIZE_LANG_TABLE)
+extern const char* const MSG_SD_VOL_INIT_FAIL_LANG_TABLE[LANG_NUM];
+#define MSG_SD_VOL_INIT_FAIL LANG_TABLE_SELECT(MSG_SD_VOL_INIT_FAIL_LANG_TABLE)
+extern const char* const MSG_SD_WORKDIR_FAIL_LANG_TABLE[LANG_NUM];
+#define MSG_SD_WORKDIR_FAIL LANG_TABLE_SELECT(MSG_SD_WORKDIR_FAIL_LANG_TABLE)
+extern const char* const MSG_SD_WRITE_TO_FILE_LANG_TABLE[LANG_NUM];
+#define MSG_SD_WRITE_TO_FILE LANG_TABLE_SELECT(MSG_SD_WRITE_TO_FILE_LANG_TABLE)
+extern const char* const MSG_SELFTEST_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST LANG_TABLE_SELECT(MSG_SELFTEST_LANG_TABLE)
+extern const char* const MSG_SELFTEST_BEDHEATER_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_BEDHEATER LANG_TABLE_SELECT(MSG_SELFTEST_BEDHEATER_LANG_TABLE)
+extern const char* const MSG_SELFTEST_CHECK_ALLCORRECT_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_CHECK_ALLCORRECT LANG_TABLE_SELECT(MSG_SELFTEST_CHECK_ALLCORRECT_LANG_TABLE)
+extern const char* const MSG_SELFTEST_CHECK_BED_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_CHECK_BED LANG_TABLE_SELECT(MSG_SELFTEST_CHECK_BED_LANG_TABLE)
+extern const char* const MSG_SELFTEST_CHECK_ENDSTOPS_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_CHECK_ENDSTOPS LANG_TABLE_SELECT(MSG_SELFTEST_CHECK_ENDSTOPS_LANG_TABLE)
+extern const char* const MSG_SELFTEST_CHECK_HOTEND_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_CHECK_HOTEND LANG_TABLE_SELECT(MSG_SELFTEST_CHECK_HOTEND_LANG_TABLE)
+extern const char* const MSG_SELFTEST_CHECK_X_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_CHECK_X LANG_TABLE_SELECT(MSG_SELFTEST_CHECK_X_LANG_TABLE)
+extern const char* const MSG_SELFTEST_CHECK_Y_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_CHECK_Y LANG_TABLE_SELECT(MSG_SELFTEST_CHECK_Y_LANG_TABLE)
+extern const char* const MSG_SELFTEST_CHECK_Z_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_CHECK_Z LANG_TABLE_SELECT(MSG_SELFTEST_CHECK_Z_LANG_TABLE)
+extern const char* const MSG_SELFTEST_ENDSTOP_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_ENDSTOP LANG_TABLE_SELECT(MSG_SELFTEST_ENDSTOP_LANG_TABLE)
+extern const char* const MSG_SELFTEST_ENDSTOPS_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_ENDSTOPS LANG_TABLE_SELECT(MSG_SELFTEST_ENDSTOPS_LANG_TABLE)
+extern const char* const MSG_SELFTEST_ENDSTOP_NOTHIT_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_ENDSTOP_NOTHIT LANG_TABLE_SELECT(MSG_SELFTEST_ENDSTOP_NOTHIT_LANG_TABLE)
+extern const char* const MSG_SELFTEST_ERROR_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_ERROR LANG_TABLE_SELECT(MSG_SELFTEST_ERROR_LANG_TABLE)
+extern const char* const MSG_SELFTEST_FAILED_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_FAILED LANG_TABLE_SELECT(MSG_SELFTEST_FAILED_LANG_TABLE)
+extern const char* const MSG_SELFTEST_HEATERTHERMISTOR_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_HEATERTHERMISTOR LANG_TABLE_SELECT(MSG_SELFTEST_HEATERTHERMISTOR_LANG_TABLE)
+extern const char* const MSG_SELFTEST_MOTOR_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_MOTOR LANG_TABLE_SELECT(MSG_SELFTEST_MOTOR_LANG_TABLE)
+extern const char* const MSG_SELFTEST_NOTCONNECTED_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_NOTCONNECTED LANG_TABLE_SELECT(MSG_SELFTEST_NOTCONNECTED_LANG_TABLE)
+extern const char* const MSG_SELFTEST_OK_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_OK LANG_TABLE_SELECT(MSG_SELFTEST_OK_LANG_TABLE)
+extern const char* const MSG_SELFTEST_PLEASECHECK_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_PLEASECHECK LANG_TABLE_SELECT(MSG_SELFTEST_PLEASECHECK_LANG_TABLE)
+extern const char* const MSG_SELFTEST_START_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_START LANG_TABLE_SELECT(MSG_SELFTEST_START_LANG_TABLE)
+extern const char* const MSG_SELFTEST_WIRINGERROR_LANG_TABLE[LANG_NUM];
+#define MSG_SELFTEST_WIRINGERROR LANG_TABLE_SELECT(MSG_SELFTEST_WIRINGERROR_LANG_TABLE)
+extern const char* const MSG_SERIAL_ERROR_MENU_STRUCTURE_LANG_TABLE[LANG_NUM];
+#define MSG_SERIAL_ERROR_MENU_STRUCTURE LANG_TABLE_SELECT(MSG_SERIAL_ERROR_MENU_STRUCTURE_LANG_TABLE)
+extern const char* const MSG_SETTINGS_LANG_TABLE[LANG_NUM];
+#define MSG_SETTINGS LANG_TABLE_SELECT(MSG_SETTINGS_LANG_TABLE)
+extern const char* const MSG_SET_HOME_OFFSETS_LANG_TABLE[LANG_NUM];
+#define MSG_SET_HOME_OFFSETS LANG_TABLE_SELECT(MSG_SET_HOME_OFFSETS_LANG_TABLE)
+extern const char* const MSG_SET_ORIGIN_LANG_TABLE[LANG_NUM];
+#define MSG_SET_ORIGIN LANG_TABLE_SELECT(MSG_SET_ORIGIN_LANG_TABLE)
+extern const char* const MSG_SILENT_MODE_OFF_LANG_TABLE[LANG_NUM];
+#define MSG_SILENT_MODE_OFF LANG_TABLE_SELECT(MSG_SILENT_MODE_OFF_LANG_TABLE)
+extern const char* const MSG_SILENT_MODE_ON_LANG_TABLE[LANG_NUM];
+#define MSG_SILENT_MODE_ON LANG_TABLE_SELECT(MSG_SILENT_MODE_ON_LANG_TABLE)
+extern const char* const MSG_SOFTWARE_RESET_LANG_TABLE[LANG_NUM];
+#define MSG_SOFTWARE_RESET LANG_TABLE_SELECT(MSG_SOFTWARE_RESET_LANG_TABLE)
+extern const char* const MSG_SPEED_LANG_TABLE[LANG_NUM];
+#define MSG_SPEED LANG_TABLE_SELECT(MSG_SPEED_LANG_TABLE)
+extern const char* const MSG_STATISTICS_LANG_TABLE[LANG_NUM];
+#define MSG_STATISTICS LANG_TABLE_SELECT(MSG_STATISTICS_LANG_TABLE)
+extern const char* const MSG_STATS_FILAMENTUSED_LANG_TABLE[LANG_NUM];
+#define MSG_STATS_FILAMENTUSED LANG_TABLE_SELECT(MSG_STATS_FILAMENTUSED_LANG_TABLE)
+extern const char* const MSG_STATS_PRINTTIME_LANG_TABLE[LANG_NUM];
+#define MSG_STATS_PRINTTIME LANG_TABLE_SELECT(MSG_STATS_PRINTTIME_LANG_TABLE)
+extern const char* const MSG_STATS_TOTALFILAMENT_LANG_TABLE[LANG_NUM];
+#define MSG_STATS_TOTALFILAMENT LANG_TABLE_SELECT(MSG_STATS_TOTALFILAMENT_LANG_TABLE)
+extern const char* const MSG_STATS_TOTALPRINTTIME_LANG_TABLE[LANG_NUM];
+#define MSG_STATS_TOTALPRINTTIME LANG_TABLE_SELECT(MSG_STATS_TOTALPRINTTIME_LANG_TABLE)
+extern const char* const MSG_STEPPER_TOO_HIGH_LANG_TABLE[LANG_NUM];
+#define MSG_STEPPER_TOO_HIGH LANG_TABLE_SELECT(MSG_STEPPER_TOO_HIGH_LANG_TABLE)
+extern const char* const MSG_STOPPED_LANG_TABLE[LANG_NUM];
+#define MSG_STOPPED LANG_TABLE_SELECT(MSG_STOPPED_LANG_TABLE)
+extern const char* const MSG_STOP_PRINT_LANG_TABLE[LANG_NUM];
+#define MSG_STOP_PRINT LANG_TABLE_SELECT(MSG_STOP_PRINT_LANG_TABLE)
+extern const char* const MSG_STORE_EPROM_LANG_TABLE[LANG_NUM];
+#define MSG_STORE_EPROM LANG_TABLE_SELECT(MSG_STORE_EPROM_LANG_TABLE)
+extern const char* const MSG_SUPPORT_LANG_TABLE[LANG_NUM];
+#define MSG_SUPPORT LANG_TABLE_SELECT(MSG_SUPPORT_LANG_TABLE)
+extern const char* const MSG_SWITCH_PS_OFF_LANG_TABLE[LANG_NUM];
+#define MSG_SWITCH_PS_OFF LANG_TABLE_SELECT(MSG_SWITCH_PS_OFF_LANG_TABLE)
+extern const char* const MSG_SWITCH_PS_ON_LANG_TABLE[LANG_NUM];
+#define MSG_SWITCH_PS_ON LANG_TABLE_SELECT(MSG_SWITCH_PS_ON_LANG_TABLE)
+extern const char* const MSG_TAKE_EFFECT_LANG_TABLE[LANG_NUM];
+#define MSG_TAKE_EFFECT LANG_TABLE_SELECT(MSG_TAKE_EFFECT_LANG_TABLE)
+extern const char* const MSG_TEMPERATURE_LANG_TABLE[LANG_NUM];
+#define MSG_TEMPERATURE LANG_TABLE_SELECT(MSG_TEMPERATURE_LANG_TABLE)
+extern const char* const MSG_TUNE_LANG_TABLE[LANG_NUM];
+#define MSG_TUNE LANG_TABLE_SELECT(MSG_TUNE_LANG_TABLE)
+extern const char* const MSG_UNKNOWN_COMMAND_LANG_TABLE[LANG_NUM];
+#define MSG_UNKNOWN_COMMAND LANG_TABLE_SELECT(MSG_UNKNOWN_COMMAND_LANG_TABLE)
+extern const char* const MSG_UNLOAD_FILAMENT_LANG_TABLE[LANG_NUM];
+#define MSG_UNLOAD_FILAMENT LANG_TABLE_SELECT(MSG_UNLOAD_FILAMENT_LANG_TABLE)
+extern const char* const MSG_USB_PRINTING_LANG_TABLE[LANG_NUM];
+#define MSG_USB_PRINTING LANG_TABLE_SELECT(MSG_USB_PRINTING_LANG_TABLE)
+extern const char* const MSG_USERWAIT_LANG_TABLE[LANG_NUM];
+#define MSG_USERWAIT LANG_TABLE_SELECT(MSG_USERWAIT_LANG_TABLE)
+extern const char* const MSG_VE_JERK_LANG_TABLE[LANG_NUM];
+#define MSG_VE_JERK LANG_TABLE_SELECT(MSG_VE_JERK_LANG_TABLE)
+extern const char* const MSG_VMAX_LANG_TABLE[LANG_NUM];
+#define MSG_VMAX LANG_TABLE_SELECT(MSG_VMAX_LANG_TABLE)
+extern const char* const MSG_VMIN_LANG_TABLE[LANG_NUM];
+#define MSG_VMIN LANG_TABLE_SELECT(MSG_VMIN_LANG_TABLE)
+extern const char* const MSG_VOLUMETRIC_LANG_TABLE[LANG_NUM];
+#define MSG_VOLUMETRIC LANG_TABLE_SELECT(MSG_VOLUMETRIC_LANG_TABLE)
+extern const char* const MSG_VOLUMETRIC_ENABLED_LANG_TABLE[LANG_NUM];
+#define MSG_VOLUMETRIC_ENABLED LANG_TABLE_SELECT(MSG_VOLUMETRIC_ENABLED_LANG_TABLE)
+extern const char* const MSG_VTRAV_MIN_LANG_TABLE[LANG_NUM];
+#define MSG_VTRAV_MIN LANG_TABLE_SELECT(MSG_VTRAV_MIN_LANG_TABLE)
+extern const char* const MSG_VXY_JERK_LANG_TABLE[LANG_NUM];
+#define MSG_VXY_JERK LANG_TABLE_SELECT(MSG_VXY_JERK_LANG_TABLE)
+extern const char* const MSG_VZ_JERK_LANG_TABLE[LANG_NUM];
+#define MSG_VZ_JERK LANG_TABLE_SELECT(MSG_VZ_JERK_LANG_TABLE)
+extern const char* const MSG_WATCH_LANG_TABLE[LANG_NUM];
+#define MSG_WATCH LANG_TABLE_SELECT(MSG_WATCH_LANG_TABLE)
+extern const char* const MSG_WATCHDOG_RESET_LANG_TABLE[LANG_NUM];
+#define MSG_WATCHDOG_RESET LANG_TABLE_SELECT(MSG_WATCHDOG_RESET_LANG_TABLE)
+extern const char* const MSG_X_LANG_TABLE[LANG_NUM];
+#define MSG_X LANG_TABLE_SELECT(MSG_X_LANG_TABLE)
+extern const char* const MSG_XSTEPS_LANG_TABLE[LANG_NUM];
+#define MSG_XSTEPS LANG_TABLE_SELECT(MSG_XSTEPS_LANG_TABLE)
+extern const char* const MSG_X_MAX_LANG_TABLE[LANG_NUM];
+#define MSG_X_MAX LANG_TABLE_SELECT(MSG_X_MAX_LANG_TABLE)
+extern const char* const MSG_X_MIN_LANG_TABLE[LANG_NUM];
+#define MSG_X_MIN LANG_TABLE_SELECT(MSG_X_MIN_LANG_TABLE)
+extern const char* const MSG_Y_LANG_TABLE[LANG_NUM];
+#define MSG_Y LANG_TABLE_SELECT(MSG_Y_LANG_TABLE)
+extern const char* const MSG_YES_LANG_TABLE[LANG_NUM];
+#define MSG_YES LANG_TABLE_SELECT(MSG_YES_LANG_TABLE)
+extern const char* const MSG_YSTEPS_LANG_TABLE[LANG_NUM];
+#define MSG_YSTEPS LANG_TABLE_SELECT(MSG_YSTEPS_LANG_TABLE)
+extern const char* const MSG_Y_MAX_LANG_TABLE[LANG_NUM];
+#define MSG_Y_MAX LANG_TABLE_SELECT(MSG_Y_MAX_LANG_TABLE)
+extern const char* const MSG_Y_MIN_LANG_TABLE[LANG_NUM];
+#define MSG_Y_MIN LANG_TABLE_SELECT(MSG_Y_MIN_LANG_TABLE)
+extern const char* const MSG_Z_LANG_TABLE[LANG_NUM];
+#define MSG_Z LANG_TABLE_SELECT(MSG_Z_LANG_TABLE)
+extern const char* const MSG_ZPROBE_OUT_LANG_TABLE[LANG_NUM];
+#define MSG_ZPROBE_OUT LANG_TABLE_SELECT(MSG_ZPROBE_OUT_LANG_TABLE)
+extern const char* const MSG_ZPROBE_ZOFFSET_LANG_TABLE[LANG_NUM];
+#define MSG_ZPROBE_ZOFFSET LANG_TABLE_SELECT(MSG_ZPROBE_ZOFFSET_LANG_TABLE)
+extern const char* const MSG_ZSTEPS_LANG_TABLE[LANG_NUM];
+#define MSG_ZSTEPS LANG_TABLE_SELECT(MSG_ZSTEPS_LANG_TABLE)
+extern const char* const MSG_Z_MAX_LANG_TABLE[LANG_NUM];
+#define MSG_Z_MAX LANG_TABLE_SELECT(MSG_Z_MAX_LANG_TABLE)
+extern const char* const MSG_Z_MIN_LANG_TABLE[LANG_NUM];
+#define MSG_Z_MIN LANG_TABLE_SELECT(MSG_Z_MIN_LANG_TABLE)
+extern const char* const WELCOME_MSG_LANG_TABLE[LANG_NUM];
+#define WELCOME_MSG LANG_TABLE_SELECT(WELCOME_MSG_LANG_TABLE)
+
+extern char* CAT2(const char *s1,const char *s2);
+extern char* CAT4(const char *s1,const char *s2,const char *s3,const char *s4);
+
+#endif //LANGUAGE_ALL.H

Firmware/language_en.h

@@ -271,6 +271,22 @@
 #define MSG_HOMEYZ_PROGRESS                 "Calibrating Z"
 #define MSG_HOMEYZ_DONE		                "Calibration done"
 
- 
+#define MSG_CALIBRATE_BED					"Calibrate bed"
+#define MSG_CALIBRATE_BED_RESET				"Reset bed calibration"
+
+#define MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1	"Calibrating the machine."
+#define MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2	"Please move the Z carriage up"
+#define MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3	"to the end stoppers."
+#define MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4	"Click when done."
+
+#define MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1	"Are both left and right Z carriages"
+#define MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2	"touching the end stops?"
+
+#define MSG_FIND_BED_OFFSET_AND_SKEW_LINE1	"Searching calibration"
+#define MSG_FIND_BED_OFFSET_AND_SKEW_LINE2	"point "
+#define MSG_FIND_BED_OFFSET_AND_SKEW_LINE3	"of 4"
+#define MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1	"Improving calibration"
+#define MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2	"point "
+#define MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3	"of 9"
 
 #endif // LANGUAGE_EN_H

Firmware/mesh_bed_calibration.cpp

@@ -0,0 +1,761 @@
+#include "Marlin.h"
+#include "Configuration.h"
+#include "language_all.h"
+#include "mesh_bed_calibration.h"
+#include "mesh_bed_leveling.h"
+#include "stepper.h"
+#include "ultralcd.h"
+// #include "qr_solve.h"
+
+extern float home_retract_mm_ext(int axis);
+
+static inline void go_xyz(float x, float y, float z, float fr)
+{
+    plan_buffer_line(x, y, z, current_position[E_AXIS], fr, active_extruder);
+    st_synchronize();
+}
+
+static inline void go_xy(float x, float y, float fr)
+{
+    plan_buffer_line(x, y, current_position[Z_AXIS], current_position[E_AXIS], fr, active_extruder);
+    st_synchronize();
+}
+
+static inline void go_to_current(float fr)
+{
+    plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], fr, active_extruder);
+    st_synchronize();
+}
+
+static inline void update_current_position_xyz()
+{
+      current_position[X_AXIS] = st_get_position_mm(X_AXIS);
+      current_position[Y_AXIS] = st_get_position_mm(Y_AXIS);
+      current_position[Z_AXIS] = st_get_position_mm(Z_AXIS);
+      plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
+}
+
+// At the current position, find the Z stop.
+inline void find_bed_induction_sensor_point_z() 
+{
+    bool endstops_enabled  = enable_endstops(true);
+    bool endstop_z_enabled = enable_z_endstop(false);
+
+    // move down until you find the bed
+    current_position[Z_AXIS] = -10;
+    go_to_current(homing_feedrate[Z_AXIS]/60);
+    // we have to let the planner know where we are right now as it is not where we said to go.
+    update_current_position_xyz();
+
+    // move up the retract distance
+    current_position[Z_AXIS] += home_retract_mm_ext(Z_AXIS);
+    go_to_current(homing_feedrate[Z_AXIS]/60);
+    
+    // move back down slowly to find bed
+    current_position[Z_AXIS] -= home_retract_mm_ext(Z_AXIS) * 2;
+    go_to_current(homing_feedrate[Z_AXIS]/(4*60));
+    // we have to let the planner know where we are right now as it is not where we said to go.
+    update_current_position_xyz();
+
+    enable_endstops(endstops_enabled);
+    enable_z_endstop(endstop_z_enabled);
+}
+
+// Search around the current_position[X,Y],
+// look for the induction sensor response.
+// Adjust the  current_position[X,Y,Z] to the center of the target dot and its response Z coordinate.
+#define FIND_BED_INDUCTION_SENSOR_POINT_X_RADIUS (8.f)
+#define FIND_BED_INDUCTION_SENSOR_POINT_Y_RADIUS (6.f)
+#define FIND_BED_INDUCTION_SENSOR_POINT_XY_STEP  (1.f)
+#define FIND_BED_INDUCTION_SENSOR_POINT_Z_STEP   (0.5f)
+inline bool find_bed_induction_sensor_point_xy()
+{
+    float feedrate = homing_feedrate[X_AXIS] / 60.f;
+    bool found = false;
+
+    {
+        float x0 = current_position[X_AXIS] - FIND_BED_INDUCTION_SENSOR_POINT_X_RADIUS;
+        float x1 = current_position[X_AXIS] + FIND_BED_INDUCTION_SENSOR_POINT_X_RADIUS;
+        float y0 = current_position[Y_AXIS] - FIND_BED_INDUCTION_SENSOR_POINT_Y_RADIUS;
+        float y1 = current_position[Y_AXIS] + FIND_BED_INDUCTION_SENSOR_POINT_Y_RADIUS;
+        uint8_t nsteps_y;
+        uint8_t i;
+        if (x0 < X_MIN_POS)
+            x0 = X_MIN_POS;
+        if (x1 > X_MAX_POS)
+            x1 = X_MAX_POS;
+        if (y0 < Y_MIN_POS)
+            y0 = Y_MIN_POS;
+        if (y1 > Y_MAX_POS)
+            y1 = Y_MAX_POS;
+        nsteps_y = int(ceil((y1 - y0) / FIND_BED_INDUCTION_SENSOR_POINT_XY_STEP));
+
+        enable_endstops(false);
+        bool  dir_positive = true;
+
+//        go_xyz(current_position[X_AXIS], current_position[Y_AXIS], MESH_HOME_Z_SEARCH, homing_feedrate[Z_AXIS]/60);
+        go_xyz(x0, y0, current_position[Z_AXIS], feedrate);
+        // Continously lower the Z axis.
+        endstops_hit_on_purpose();
+        enable_z_endstop(true);
+        while (current_position[Z_AXIS] > -10.f) {
+            // Do nsteps_y zig-zag movements.
+            current_position[Y_AXIS] = y0;
+            for (i = 0; i < nsteps_y; current_position[Y_AXIS] += (y1 - y0) / float(nsteps_y - 1), ++ i) {
+                // Run with a slightly decreasing Z axis, zig-zag movement. Stop at the Z end-stop.
+                current_position[Z_AXIS] -= FIND_BED_INDUCTION_SENSOR_POINT_Z_STEP / float(nsteps_y);
+                go_xyz(dir_positive ? x1 : x0, current_position[Y_AXIS], current_position[Z_AXIS], feedrate);
+                dir_positive = ! dir_positive;
+                if (endstop_z_hit_on_purpose())
+                    goto endloop;
+            }
+            for (i = 0; i < nsteps_y; current_position[Y_AXIS] -= (y1 - y0) / float(nsteps_y - 1), ++ i) {
+                // Run with a slightly decreasing Z axis, zig-zag movement. Stop at the Z end-stop.
+                current_position[Z_AXIS] -= FIND_BED_INDUCTION_SENSOR_POINT_Z_STEP / float(nsteps_y);
+                go_xyz(dir_positive ? x1 : x0, current_position[Y_AXIS], current_position[Z_AXIS], feedrate);
+                dir_positive = ! dir_positive;
+                if (endstop_z_hit_on_purpose())
+                    goto endloop;
+            }
+        }
+        endloop:
+//        SERIAL_ECHOLN("First hit");
+
+        // we have to let the planner know where we are right now as it is not where we said to go.
+        update_current_position_xyz();
+
+        // Search in this plane for the first hit. Zig-zag first in X, then in Y axis.
+        for (int8_t iter = 0; iter < 3; ++ iter) {
+            if (iter > 0) {
+                // Slightly lower the Z axis to get a reliable trigger.
+                current_position[Z_AXIS] -= 0.02f;
+                go_xyz(current_position[X_AXIS], current_position[Y_AXIS], MESH_HOME_Z_SEARCH, homing_feedrate[Z_AXIS]/60);
+            }
+
+            // Do nsteps_y zig-zag movements.
+            float a, b;
+            enable_endstops(false);
+            enable_z_endstop(false);
+            current_position[Y_AXIS] = y0;
+            go_xy(x0, current_position[Y_AXIS], feedrate);
+            enable_z_endstop(true);
+            found = false;
+            for (i = 0, dir_positive = true; i < nsteps_y; current_position[Y_AXIS] += (y1 - y0) / float(nsteps_y - 1), ++ i, dir_positive = ! dir_positive) {
+                go_xy(dir_positive ? x1 : x0, current_position[Y_AXIS], feedrate);
+                if (endstop_z_hit_on_purpose()) {
+                    found = true;
+                    break;
+                }
+            }
+            update_current_position_xyz();
+            if (! found) {
+//                SERIAL_ECHOLN("Search in Y - not found");
+                continue;
+            }
+//            SERIAL_ECHOLN("Search in Y - found");
+            a = current_position[Y_AXIS];
+
+            enable_z_endstop(false);
+            current_position[Y_AXIS] = y1;
+            go_xy(x0, current_position[Y_AXIS], feedrate);
+            enable_z_endstop(true);
+            found = false;
+            for (i = 0, dir_positive = true; i < nsteps_y; current_position[Y_AXIS] -= (y1 - y0) / float(nsteps_y - 1), ++ i, dir_positive = ! dir_positive) {
+                go_xy(dir_positive ? x1 : x0, current_position[Y_AXIS], feedrate);
+                if (endstop_z_hit_on_purpose()) {
+                    found = true;
+                    break;
+                }
+            }
+            update_current_position_xyz();
+            if (! found) {
+//                SERIAL_ECHOLN("Search in Y2 - not found");
+                continue;
+            }
+//            SERIAL_ECHOLN("Search in Y2 - found");
+            b = current_position[Y_AXIS];
+            current_position[Y_AXIS] = 0.5f * (a + b);
+
+            // Search in the X direction along a cross.
+            found = false;
+            enable_z_endstop(false);
+            go_xy(x0, current_position[Y_AXIS], feedrate);
+            enable_z_endstop(true);
+            go_xy(x1, current_position[Y_AXIS], feedrate);
+            update_current_position_xyz();
+            if (! endstop_z_hit_on_purpose()) {
+//                SERIAL_ECHOLN("Search X span 0 - not found");
+                continue;
+            }
+//            SERIAL_ECHOLN("Search X span 0 - found");
+            a = current_position[X_AXIS];
+            enable_z_endstop(false);
+            go_xy(x1, current_position[Y_AXIS], feedrate);
+            enable_z_endstop(true);
+            go_xy(x0, current_position[Y_AXIS], feedrate);
+            update_current_position_xyz();
+            if (! endstop_z_hit_on_purpose()) {
+//                SERIAL_ECHOLN("Search X span 1 - not found");
+                continue;
+            }
+//            SERIAL_ECHOLN("Search X span 1 - found");
+            b = current_position[X_AXIS];
+            // Go to the center.
+            enable_z_endstop(false);
+            current_position[X_AXIS] = 0.5f * (a + b);
+            go_xy(current_position[X_AXIS], current_position[Y_AXIS], feedrate);
+            found = true;
+
+#if 1
+            // Search in the Y direction along a cross.
+            found = false;
+            enable_z_endstop(false);
+            go_xy(current_position[X_AXIS], y0, feedrate);
+            enable_z_endstop(true);
+            go_xy(current_position[X_AXIS], y1, feedrate);
+            update_current_position_xyz();
+            if (! endstop_z_hit_on_purpose()) {
+//                SERIAL_ECHOLN("Search Y2 span 0 - not found");
+                continue;
+            }
+//            SERIAL_ECHOLN("Search Y2 span 0 - found");
+            a = current_position[Y_AXIS];
+            enable_z_endstop(false);
+            go_xy(current_position[X_AXIS], y1, feedrate);
+            enable_z_endstop(true);
+            go_xy(current_position[X_AXIS], y0, feedrate);
+            update_current_position_xyz();
+            if (! endstop_z_hit_on_purpose()) {
+//                SERIAL_ECHOLN("Search Y2 span 1 - not found");
+                continue;
+            }
+//            SERIAL_ECHOLN("Search Y2 span 1 - found");
+            b = current_position[Y_AXIS];
+            // Go to the center.
+            enable_z_endstop(false);
+            current_position[Y_AXIS] = 0.5f * (a + b);
+            go_xy(current_position[X_AXIS], current_position[Y_AXIS], feedrate);
+            found = true;
+#endif
+            break;
+        }
+    }
+
+    enable_z_endstop(false);
+    return found;
+}
+
+// Search around the current_position[X,Y,Z].
+// It is expected, that the induction sensor is switched on at the current position.
+// Look around this center point by painting a star around the point.
+inline bool improve_bed_induction_sensor_point()
+{
+    static const float search_radius = 8.f;
+
+    bool  endstops_enabled  = enable_endstops(false);
+    bool  endstop_z_enabled = enable_z_endstop(false);
+    bool  found = false;
+    float feedrate = homing_feedrate[X_AXIS] / 60.f;
+    float center_old_x = current_position[X_AXIS];
+    float center_old_y = current_position[Y_AXIS];
+    float center_x = 0.f;
+    float center_y = 0.f;
+
+    for (uint8_t iter = 0; iter < 4; ++ iter) {
+        switch (iter) {
+        case 0:
+            destination[X_AXIS] = center_old_x - search_radius * 0.707;
+            destination[Y_AXIS] = center_old_y - search_radius * 0.707;
+            break;
+        case 1:
+            destination[X_AXIS] = center_old_x + search_radius * 0.707;
+            destination[Y_AXIS] = center_old_y + search_radius * 0.707;
+            break;
+        case 2:
+            destination[X_AXIS] = center_old_x + search_radius * 0.707;
+            destination[Y_AXIS] = center_old_y - search_radius * 0.707;
+            break;
+        case 3:
+        default:
+            destination[X_AXIS] = center_old_x - search_radius * 0.707;
+            destination[Y_AXIS] = center_old_y + search_radius * 0.707;
+            break;
+        }
+
+        // Trim the vector from center_old_[x,y] to destination[x,y] by the bed dimensions.
+        float vx = destination[X_AXIS] - center_old_x;
+        float vy = destination[Y_AXIS] - center_old_y;
+        float l  = sqrt(vx*vx+vy*vy);
+        float t;
+        if (destination[X_AXIS] < X_MIN_POS) {
+            // Exiting the bed at xmin.
+            t = (center_x - X_MIN_POS) / l;
+            destination[X_AXIS] = X_MIN_POS;
+            destination[Y_AXIS] = center_old_y + t * vy;
+        } else if (destination[X_AXIS] > X_MAX_POS) {
+            // Exiting the bed at xmax.
+            t = (X_MAX_POS - center_x) / l;
+            destination[X_AXIS] = X_MAX_POS;
+            destination[Y_AXIS] = center_old_y + t * vy;
+        }
+        if (destination[Y_AXIS] < Y_MIN_POS) {
+            // Exiting the bed at ymin.
+            t = (center_y - Y_MIN_POS) / l;
+            destination[X_AXIS] = center_old_x + t * vx;
+            destination[Y_AXIS] = Y_MIN_POS;
+        } else if (destination[Y_AXIS] > Y_MAX_POS) {
+            // Exiting the bed at xmax.
+            t = (Y_MAX_POS - center_y) / l;
+            destination[X_AXIS] = center_old_x + t * vx;
+            destination[Y_AXIS] = Y_MAX_POS;
+        }
+
+        // Move away from the measurement point.
+        enable_endstops(false);
+        go_xy(destination[X_AXIS], destination[Y_AXIS], feedrate);
+        // Move towards the measurement point, until the induction sensor triggers.
+        enable_endstops(true);
+        go_xy(center_old_x, center_old_y, feedrate);
+        update_current_position_xyz();
+        center_x += current_position[X_AXIS];
+        center_y += current_position[Y_AXIS];
+    }
+
+    // Calculate the new center, move to the new center.
+    center_x /= 4.f;
+    center_y /= 4.f;
+    current_position[X_AXIS] = center_x;
+    current_position[Y_AXIS] = center_y;
+    enable_endstops(false);
+    go_xy(current_position[X_AXIS], current_position[Y_AXIS], feedrate);
+
+    enable_endstops(endstops_enabled);
+    enable_z_endstop(endstop_z_enabled);
+    return found;
+}
+
+// Search around the current_position[X,Y,Z].
+// It is expected, that the induction sensor is switched on at the current position.
+// Look around this center point by painting a star around the point.
+#define IMPROVE_BED_INDUCTION_SENSOR_SEARCH_RADIUS (8.f)
+inline bool improve_bed_induction_sensor_point2(bool lift_z_on_min_y)
+{
+    float center_old_x = current_position[X_AXIS];
+    float center_old_y = current_position[Y_AXIS];
+    float a, b;
+
+    enable_endstops(false);
+
+    {
+        float x0 = center_old_x - IMPROVE_BED_INDUCTION_SENSOR_SEARCH_RADIUS;
+        float x1 = center_old_x + IMPROVE_BED_INDUCTION_SENSOR_SEARCH_RADIUS;
+        if (x0 < X_MIN_POS)
+            x0 = X_MIN_POS;
+        if (x1 > X_MAX_POS)
+            x1 = X_MAX_POS;
+
+        // Search in the X direction along a cross.
+        enable_z_endstop(false);
+        go_xy(x0, current_position[Y_AXIS], homing_feedrate[X_AXIS] / 60.f);
+        enable_z_endstop(true);
+        go_xy(x1, current_position[Y_AXIS], homing_feedrate[X_AXIS] / 60.f);
+        update_current_position_xyz();
+        if (! endstop_z_hit_on_purpose())
+            return false;
+        a = current_position[X_AXIS];
+        enable_z_endstop(false);
+        go_xy(x1, current_position[Y_AXIS], homing_feedrate[X_AXIS] / 60.f);
+        enable_z_endstop(true);
+        go_xy(x0, current_position[Y_AXIS], homing_feedrate[X_AXIS] / 60.f);
+        update_current_position_xyz();
+        if (! endstop_z_hit_on_purpose())
+            return false;
+        b = current_position[X_AXIS];
+
+        // Go to the center.
+        enable_z_endstop(false);
+        current_position[X_AXIS] = 0.5f * (a + b);
+        go_xy(current_position[X_AXIS], current_position[Y_AXIS], homing_feedrate[X_AXIS] / 60.f);
+    }
+
+    {
+        float y0 = center_old_y - IMPROVE_BED_INDUCTION_SENSOR_SEARCH_RADIUS;
+        float y1 = center_old_y + IMPROVE_BED_INDUCTION_SENSOR_SEARCH_RADIUS;
+        if (y0 < Y_MIN_POS)
+            y0 = Y_MIN_POS;
+        if (y1 > Y_MAX_POS)
+            y1 = Y_MAX_POS;
+
+        // Search in the Y direction along a cross.
+        enable_z_endstop(false);
+        go_xy(current_position[X_AXIS], y0, homing_feedrate[X_AXIS] / 60.f);
+        if (lift_z_on_min_y) {
+            // The first row of points are very close to the end stop.
+            // Lift the sensor to disengage the trigger. This is necessary because of the sensor hysteresis.
+            go_xyz(current_position[X_AXIS], y0, current_position[Z_AXIS]+5.f, homing_feedrate[Z_AXIS] / 60.f);
+            // and go back.
+            go_xyz(current_position[X_AXIS], y0, current_position[Z_AXIS], homing_feedrate[Z_AXIS] / 60.f);
+        }
+        if (lift_z_on_min_y && (READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING) == 1) {
+            // Already triggering before we started the move.
+            // Shift the trigger point slightly outwards.
+            a = current_position[Y_AXIS] - 1.5f;
+        } else {
+            enable_z_endstop(true);
+            go_xy(current_position[X_AXIS], y1, homing_feedrate[X_AXIS] / 60.f);
+            update_current_position_xyz();
+            if (! endstop_z_hit_on_purpose())
+                return false;
+            a = current_position[Y_AXIS];
+        }
+        enable_z_endstop(false);
+        go_xy(current_position[X_AXIS], y1, homing_feedrate[X_AXIS] / 60.f);
+        enable_z_endstop(true);
+        go_xy(current_position[X_AXIS], y0, homing_feedrate[X_AXIS] / 60.f);
+        update_current_position_xyz();
+        if (! endstop_z_hit_on_purpose())
+            return false;
+        b = current_position[Y_AXIS];
+
+        // Go to the center.
+        enable_z_endstop(false);
+        current_position[Y_AXIS] = 0.5f * (a + b);
+        go_xy(current_position[X_AXIS], current_position[Y_AXIS], homing_feedrate[X_AXIS] / 60.f);
+    }
+
+    return true;
+}
+
+#define MESH_BED_CALIBRATION_SHOW_LCD
+
+bool find_bed_offset_and_skew()
+{
+    // Reusing the z_values memory for the measurement cache.
+    // 7x7=49 floats, good for 16 (x,y,z) vectors.
+    float *pts = &mbl.z_values[0][0];
+    float *vec_x = pts + 3 * 4;
+    float *vec_y = vec_x + 3;
+    float *cntr  = vec_y + 3;
+    memset(pts, 0, sizeof(float) * 7 * 7);
+
+#ifdef MESH_BED_CALIBRATION_SHOW_LCD
+    lcd_implementation_clear();
+    lcd_print_at_PGM(0, 0, MSG_FIND_BED_OFFSET_AND_SKEW_LINE1);
+#endif /* MESH_BED_CALIBRATION_SHOW_LCD */
+
+    // Collect the rear 2x3 points.
+    current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
+    for (int k = 0; k < 4; ++ k) {
+#ifdef MESH_BED_CALIBRATION_SHOW_LCD
+        lcd_print_at_PGM(0, 1, MSG_FIND_BED_OFFSET_AND_SKEW_LINE2);
+        lcd_implementation_print(k+1);
+        lcd_print_at_PGM(0, 2, MSG_FIND_BED_OFFSET_AND_SKEW_LINE3);
+#endif /* MESH_BED_CALIBRATION_SHOW_LCD */
+
+        int i, j;
+        switch (k) {
+            case 0: i = 1; j = 0; break;
+            case 1: i = 2; j = 1; break;
+            case 2: i = 1; j = 2; break;
+            case 3: i = 0; j = 1; break;
+        }
+        float *pt = pts + k * 3;
+        // Go up to z_initial.
+        go_to_current(homing_feedrate[Z_AXIS] / 60.f);
+        // Go to the measurement point position.
+        mbl.get_meas_xy(i, j, current_position[X_AXIS], current_position[Y_AXIS], true); // use default, uncorrected coordinates
+        go_to_current(homing_feedrate[X_AXIS] / 60.f);
+        if (! find_bed_induction_sensor_point_xy())
+            return false;
+        find_bed_induction_sensor_point_z();
+        pt[0] = current_position[X_AXIS];
+        pt[1] = current_position[Y_AXIS];
+        pt[2] = current_position[Z_AXIS];
+        // Start searching for the other points at 3mm above the last point.
+        current_position[Z_AXIS] += 3.f;
+        cntr[0] += pt[0];
+        cntr[1] += pt[1];
+        cntr[2] += pt[2];
+    }
+
+    // Average the X and Y vectors. They may not be perpendicular, if the printer is built incorrectly.
+    {
+        float  len;
+        // Average the center point.
+        cntr[0] *= 1.f/4.f;
+        cntr[1] *= 1.f/4.f;
+        cntr[2] *= 1.f/4.f;
+        // Average the X vector.
+        vec_x[0] = (pts[3 * 1 + 0] - pts[3 * 3 + 0]) / 2.f;
+        vec_x[1] = (pts[3 * 1 + 1] - pts[3 * 3 + 1]) / 2.f;
+        len = sqrt(vec_x[0]*vec_x[0] + vec_x[1]*vec_x[1]);
+        if (0) {
+        // if (len < MEAS_NUM_X_DIST) {
+            // Scale the vector up to MEAS_NUM_X_DIST lenght.
+            float factor = MEAS_NUM_X_DIST / len;
+            vec_x[0] *= factor;
+            vec_x[0] *= factor;
+        } else {
+            // The vector is longer than MEAS_NUM_X_DIST. The X/Y axes are skewed.
+            // Verify the maximum skew?
+        }
+        // Average the Y vector.
+        vec_y[0] = (pts[3 * 2 + 0] - pts[3 * 0 + 0]) / 2.f;
+        vec_y[1] = (pts[3 * 2 + 1] - pts[3 * 0 + 1]) / 2.f;
+        len = sqrt(vec_y[0]*vec_y[0] + vec_y[1]*vec_y[1]);
+        if (0) {
+        // if (len < MEAS_NUM_Y_DIST) {
+            // Scale the vector up to MEAS_NUM_X_DIST lenght.
+            float factor = MEAS_NUM_Y_DIST / len;
+            vec_y[1] *= factor;
+            vec_y[1] *= factor;
+        } else {
+            // The vector is longer than MEAS_NUM_X_DIST. The X/Y axes are skewed.
+            // Verify the maximum skew?
+        }
+
+        // Fearlessly store the calibration values into the eeprom.
+        eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_CENTER+0), cntr [0]);
+        eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_CENTER+4), cntr [1]);
+        eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_VEC_X +0), vec_x[0]);
+        eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_VEC_X +4), vec_x[1]);
+        eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_VEC_Y +0), vec_y[0]);
+        eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_VEC_Y +4), vec_y[1]);
+
+#if 0
+        SERIAL_ECHOLN("Calibration done.");
+        SERIAL_ECHO("Center: ");
+        SERIAL_ECHO(cntr[0]);
+        SERIAL_ECHO(",");
+        SERIAL_ECHO(cntr[1]);
+        SERIAL_ECHO(", x: ");
+        SERIAL_ECHO(vec_x[0]);
+        SERIAL_ECHO(",");
+        SERIAL_ECHO(vec_x[1]);
+        SERIAL_ECHO(", y: ");
+        SERIAL_ECHO(vec_y[0]);
+        SERIAL_ECHO(",");
+        SERIAL_ECHO(vec_y[1]);
+        SERIAL_ECHOLN("");
+#endif
+    }
+    return true;
+}
+
+bool improve_bed_offset_and_skew(int8_t method)
+{
+    // Reusing the z_values memory for the measurement cache.
+    // 7x7=49 floats, good for 16 (x,y,z) vectors.
+    float *pts = &mbl.z_values[0][0];
+    float *vec_x = pts + 2 * 9;
+    float *vec_y = vec_x + 2;
+    float *cntr  = vec_y + 2;
+    memset(pts, 0, sizeof(float) * 7 * 7);
+
+    bool endstops_enabled  = enable_endstops(false);
+    bool endstop_z_enabled = enable_z_endstop(false);
+
+#ifdef MESH_BED_CALIBRATION_SHOW_LCD
+    lcd_implementation_clear();
+    lcd_print_at_PGM(0, 0, MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1);
+#endif /* MESH_BED_CALIBRATION_SHOW_LCD */
+
+    // Collect a matrix of 9x9 points.
+    for (int8_t mesh_point = 0; mesh_point < 9; ++ mesh_point) {
+        int ix = mesh_point % MESH_MEAS_NUM_X_POINTS;
+        int iy = mesh_point / MESH_MEAS_NUM_X_POINTS;
+        if (iy & 1) ix = (MESH_MEAS_NUM_X_POINTS - 1) - ix; // Zig zag
+        // Print the decrasing ID of the measurement point.
+#ifdef MESH_BED_CALIBRATION_SHOW_LCD
+        lcd_print_at_PGM(0, 1, MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2);
+        lcd_implementation_print_at(7, 1, mesh_point+1);
+        lcd_print_at_PGM(0, 2, MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE3);
+#endif /* MESH_BED_CALIBRATION_SHOW_LCD */
+
+        // Move up.
+        current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
+        enable_endstops(false);
+        enable_z_endstop(false);
+        go_to_current(homing_feedrate[Z_AXIS]/60);
+        // Go to the measurement point.
+        // Use the coorrected coordinate, which is a result of find_bed_offset_and_skew().
+        mbl.get_meas_xy(ix, iy, current_position[X_AXIS], current_position[Y_AXIS], false);
+        go_to_current(homing_feedrate[X_AXIS]/60);
+        // Find its Z position by running the normal vertical search.
+//        delay_keep_alive(3000);
+        find_bed_induction_sensor_point_z();
+//        delay_keep_alive(3000);
+        // Improve the point position by searching its center in a current plane.
+        int8_t n_errors = 3;
+        for (int8_t iter = 0; iter < 4; ++ iter) {
+            bool found = false;
+            switch (method) {
+                case 0: found = improve_bed_induction_sensor_point(); break;
+                case 1: found = improve_bed_induction_sensor_point2(iy == 0); break;
+                default: break;
+            }
+            if (! found) {
+                if (n_errors -- == 0) {
+                    // Give up.
+                    goto canceled;
+                } else {
+                    // Try to move the Z axis down a bit to increase a chance of the sensor to trigger.
+                    current_position[Z_AXIS] -= 0.025f;
+                    enable_endstops(false);
+                    enable_z_endstop(false);
+                    go_to_current(homing_feedrate[Z_AXIS]);
+                }
+            }
+        }
+//        delay_keep_alive(3000);
+        float *pt = pts + 2 * (ix + iy * 3);
+        pt[0] = current_position[X_AXIS];
+        pt[1] = current_position[Y_AXIS];
+        cntr[0] += pt[0];
+        cntr[1] += pt[1];
+    }
+
+    // Average the X and Y vectors. They may not be perpendicular, if the printer is built incorrectly.
+    // Average the center point.
+    cntr[0] *= 1.f/9.f;
+    cntr[1] *= 1.f/9.f;
+    // Average the X vector.
+    vec_x[0] = (pts[2 * 2 + 0] - pts[2 * 0 + 0] + pts[2 * 5 + 0] - pts[2 * 3 + 0] + pts[2 * 8 + 0] - pts[2 * 6 + 0]) / 6.f;
+    vec_x[1] = (pts[2 * 2 + 1] - pts[2 * 0 + 1] + pts[2 * 5 + 1] - pts[2 * 3 + 1] + pts[2 * 8 + 1] - pts[2 * 6 + 1]) / 6.f;
+    // Average the Y vector.
+    vec_y[0] = (pts[2 * 6 + 0] - pts[2 * 0 + 0] + pts[2 * 7 + 0] - pts[2 * 1 + 0] + pts[2 * 8 + 0] - pts[2 * 2 + 0]) / 6.f;
+    vec_y[1] = (pts[2 * 6 + 1] - pts[2 * 0 + 1] + pts[2 * 7 + 1] - pts[2 * 1 + 1] + pts[2 * 8 + 1] - pts[2 * 2 + 1]) / 6.f;
+
+#if 1
+    // Fearlessly store the calibration values into the eeprom.
+    eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_CENTER+0), cntr [0]);
+    eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_CENTER+4), cntr [1]);
+    eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_VEC_X +0), vec_x[0]);
+    eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_VEC_X +4), vec_x[1]);
+    eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_VEC_Y +0), vec_y[0]);
+    eeprom_update_float((float*)(EEPROM_BED_CALIBRATION_VEC_Y +4), vec_y[1]);
+#endif
+
+#if 0
+    // and let us know the result.
+    SERIAL_ECHOLN("Calibration done.");
+    SERIAL_ECHO("Center: ");
+    SERIAL_ECHO(cntr[0]);
+    SERIAL_ECHO(",");
+    SERIAL_ECHO(cntr[1]);
+    SERIAL_ECHO(", x: ");
+    SERIAL_ECHO(vec_x[0]);
+    SERIAL_ECHO(",");
+    SERIAL_ECHO(vec_x[1]);
+    SERIAL_ECHO(", y: ");
+    SERIAL_ECHO(vec_y[0]);
+    SERIAL_ECHO(",");
+    SERIAL_ECHO(vec_y[1]);
+    SERIAL_ECHOLN("");
+#endif
+
+    enable_endstops(endstops_enabled);
+    enable_z_endstop(endstop_z_enabled);
+    return true;
+
+canceled:
+    enable_endstops(endstops_enabled);
+    enable_z_endstop(endstop_z_enabled);
+    return false;
+}
+
+void reset_bed_offset_and_skew()
+{
+    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+0), 0x0FFFFFFFF);
+    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+4), 0x0FFFFFFFF);
+    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +0), 0x0FFFFFFFF);
+    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +4), 0x0FFFFFFFF);
+    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +0), 0x0FFFFFFFF);
+    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +4), 0x0FFFFFFFF);
+}
+
+static const float[9][2] PROGMEM bed_points = {
+};
+
+bool calculate_machine_skew_and_offset_LS(
+    // Matrix of 9 2D points (18 floats)
+    float *pts,
+    // Resulting correction matrix.
+    float *vec_x,
+    float *vec_y,
+    float *cntr,
+    // Temporary values, 49-18-(2*3)=25 floats
+    float *temp
+{
+    {
+        // Create covariance matrix for A, collect the right hand side b.
+        float A[3][3] = { 0.f };
+        float b[3] = { 0.f };
+        float acc;
+        for (uint8_t r = 0; r < 3; ++ r) {
+            for (uint8_t c = 0; c < 3; ++ c) {
+                acc = 0;
+                for (uint8_t i = 0; i < 9; ++ i) {
+                    float a = (r == 2) ? 1.f : pts[2 * i + r];
+                    float b = (c == 2) ? 1.f : pts[2 * i + c];
+                    acc += a * b;
+                }
+                A[r][c] = acc;
+            }
+            acc = 0.f;
+            for (uint8_t i = 0; i < 9; ++ i) {
+                float a = (r == 2) ? 1.f : pts[2 * i + r];
+                float b = pgm_read_float(&coeff2[i][0]);
+                acc += a * b;
+            }
+            b[r] = acc;
+        }
+        // Solve the linear equation for ax, bx, cx.
+        float x[3] = { 0.f };
+        for (uint8_t iter = 0; iter < 100; ++ iter) {
+            x[0] = (b[0] - A[1] * x[1] - A[2] * x[2]) / A[0];
+            x[1] = (b[1] - A[0] * x[0] - A[2] * x[2]) / A[1];
+            x[2] = (b[2] - A[0] * x[0] - A[1] * x[1]) / A[2];
+        }
+        // Store the result to the output variables.
+        vec_x[0] = x[0];
+        vec_y[0] = x[1];
+        cntr[0] = x[2];
+
+        // Recalculate b for the y values.
+        for (uint8_t r = 0; r < 3; ++ r) {
+            acc = 0.f;
+            for (uint8_t i = 0; i < 9; ++ i) {
+                float a = (r == 2) ? 1.f : pts[2 * i + r];
+                float b = pgm_read_float(&coeff2[i][1]);
+                acc += a * b;
+            }
+            b[r] = acc;
+        }
+        // Solve the linear equation for ay, by, cy.
+        x[0] = 0.f, x[1] = 0.f; x[2] = 0.f;
+        for (uint8_t iter = 0; iter < 100; ++ iter) {
+            x[0] = (b[0] - A[1] * x[1] - A[2] * x[2]) / A[0];
+            x[1] = (b[1] - A[0] * x[0] - A[2] * x[2]) / A[1];
+            x[2] = (b[2] - A[0] * x[0] - A[1] * x[1]) / A[2];
+        }
+        // Store the result to the output variables.
+        vec_x[1] = x[0];
+        vec_y[1] = x[1];
+        cntr[1] = x[2];
+    }
+
+    // Normalize the vectors. We expect, that the machine axes may be skewed a bit, but the distances are correct.
+    // l shall be very close to 1 already.
+    float l = sqrt(vec_x[0]*vec_x[0] + vec_x[1] * vec_x[1]);
+    vec_x[0] /= l;
+    vec_x[1] /= l;
+    l = sqrt(vec_y[0]*vec_y[0] + vec_y[1] * vec_y[1]);
+    vec_y[0] /= l;
+    vec_y[1] /= l;
+
+
+
+    // Invert the transformation matrix made of vec_x, vec_y and cntr.
+
+}

Firmware/mesh_bed_calibration.h

@@ -0,0 +1,11 @@
+#ifndef MESH_BED_CALIBRATION_H
+#define MESH_BED_CALIBRATION_H
+
+extern void find_bed_induction_sensor_point_z();
+extern bool find_bed_induction_sensor_point_xy();
+
+extern bool find_bed_offset_and_skew();
+extern bool improve_bed_offset_and_skew(int8_t method);
+extern void reset_bed_offset_and_skew();
+
+#endif /* MESH_BED_CALIBRATION_H */

Firmware/mesh_bed_leveling.cpp

@@ -1,4 +1,5 @@
 #include "mesh_bed_leveling.h"
+#include "Configuration.h"
 
 #ifdef MESH_BED_LEVELING
 
@@ -13,6 +14,77 @@ void mesh_bed_leveling::reset() {
             z_values[y][x] = 0;
 }
 
+static inline bool vec_undef(const float v[2])
+{
+    const uint32_t *vx = (const uint32_t*)v;
+    return vx[0] == 0x0FFFFFFFF || vx[1] == 0x0FFFFFFFF;
+}
+
+void mesh_bed_leveling::get_meas_xy(int ix, int iy, float &x, float &y, bool use_default)
+{
+    float cntr[2] = {
+        eeprom_read_float((float*)(EEPROM_BED_CALIBRATION_CENTER+0)),
+        eeprom_read_float((float*)(EEPROM_BED_CALIBRATION_CENTER+4))
+    };
+    float vec_x[2] = {
+        eeprom_read_float((float*)(EEPROM_BED_CALIBRATION_VEC_X +0)),
+        eeprom_read_float((float*)(EEPROM_BED_CALIBRATION_VEC_X +4))
+    };
+    float vec_y[2] = {
+        eeprom_read_float((float*)(EEPROM_BED_CALIBRATION_VEC_Y +0)),
+        eeprom_read_float((float*)(EEPROM_BED_CALIBRATION_VEC_Y +4))
+    };
+
+    if (use_default || vec_undef(cntr) || vec_undef(vec_x) || vec_undef(vec_y)) {
+        // Default, uncorrected positions of the calibration points. Works well for correctly built printers.
+        x = float(MESH_MIN_X) + float(MEAS_NUM_X_DIST) * float(ix) - X_PROBE_OFFSET_FROM_EXTRUDER;
+        //FIXME
+        //x -= 5.f;
+        y = float(MESH_MIN_Y) + float(MEAS_NUM_Y_DIST) * float(iy) - Y_PROBE_OFFSET_FROM_EXTRUDER;
+    } else {
+#if 0
+        SERIAL_ECHO("Running bed leveling. Calibration data: ");
+        SERIAL_ECHO(cntr[0]);
+        SERIAL_ECHO(",");
+        SERIAL_ECHO(cntr[1]);
+        SERIAL_ECHO(", x: ");
+        SERIAL_ECHO(vec_x[0]);
+        SERIAL_ECHO(",");
+        SERIAL_ECHO(vec_x[1]);
+        SERIAL_ECHO(", y: ");
+        SERIAL_ECHO(vec_y[0]);
+        SERIAL_ECHO(",");
+        SERIAL_ECHO(vec_y[1]);
+        SERIAL_ECHOLN("");
+#endif
+
+        x = cntr[0];
+        y = cntr[1];
+        if (ix < 1) {
+            x -= vec_x[0];
+            y -= vec_x[1];
+        } else if (ix > 1) {
+            x += vec_x[0];
+            y += vec_x[1];
+        }
+        if (iy < 1) {
+            x -= vec_y[0];
+            y -= vec_y[1];
+        } else if (iy > 1) {
+            x += vec_y[0];
+            y += vec_y[1];
+        }
+
+#if 0
+        SERIAL_ECHO("Calibration point position: ");
+        SERIAL_ECHO(x);
+        SERIAL_ECHO(",");
+        SERIAL_ECHO(y);
+        SERIAL_ECHOLN("");
+#endif
+    }
+}
+
 #if MESH_NUM_X_POINTS>=5 && MESH_NUM_Y_POINTS>=5 && (MESH_NUM_X_POINTS&1)==1 && (MESH_NUM_Y_POINTS&1)==1
 // Works for an odd number of MESH_NUM_X_POINTS and MESH_NUM_Y_POINTS
 void mesh_bed_leveling::upsample_3x3()

Firmware/mesh_bed_leveling.h

@@ -21,11 +21,13 @@ public:
     void upsample_3x3();
 #endif
     
-    float get_x(int i) { return float(MESH_MIN_X) + float(MESH_X_DIST) * float(i); }
-    float get_y(int i) { return float(MESH_MIN_Y) + float(MESH_Y_DIST) * float(i); }
+    static float get_x(int i) { return float(MESH_MIN_X) + float(MESH_X_DIST) * float(i); }
+    static float get_y(int i) { return float(MESH_MIN_Y) + float(MESH_Y_DIST) * float(i); }
     
-    float get_meas_x(int i) { return float(MESH_MIN_X) + float(MEAS_NUM_X_DIST) * float(i); }
-    float get_meas_y(int i) { return float(MESH_MIN_Y) + float(MEAS_NUM_Y_DIST) * float(i); }
+    // Measurement point for the Z probe.
+    // If use_default=true, then the default positions for a correctly built printer are used.
+    // Otherwise a correction matrix is pulled from the EEPROM if available.
+    static void get_meas_xy(int ix, int iy, float &x, float &y, bool use_default);
     
     void set_z(int ix, int iy, float z) { z_values[iy][ix] = z; }
     

Firmware/pins.h

@@ -23,7 +23,7 @@
 * Rambo Pin Assignments 1.3
 ******************************************************************/
 #if MOTHERBOARD == 302
-  #define MINI-RAMBO
+  #define MINI_RAMBO
   
 #endif
 #if MOTHERBOARD == 301 || MOTHERBOARD == 302
@@ -109,7 +109,7 @@
   #else
     #define HEATER_2_PIN -1
   #endif
-  #ifdef MINI-RAMBO
+  #ifdef MINI_RAMBO
 
     #define ELECTRONICS "RAMBo13a"
 

Firmware/stepper.cpp

@@ -86,6 +86,7 @@ static bool old_z_min_endstop=false;
 static bool old_z_max_endstop=false;
 
 static bool check_endstops = true;
+static bool check_z_endstop = false;
 
 int8_t SilentMode;
 
@@ -209,16 +210,35 @@ void checkHitEndstops()
  }
 }
 
-void endstops_hit_on_purpose()
+bool endstops_hit_on_purpose()
 {
+  bool hit = endstop_x_hit || endstop_y_hit || endstop_z_hit;
   endstop_x_hit=false;
   endstop_y_hit=false;
   endstop_z_hit=false;
+  return hit;
 }
 
-void enable_endstops(bool check)
+bool endstop_z_hit_on_purpose()
 {
+  bool hit = endstop_z_hit;
+  endstop_z_hit=false;
+  return hit;
+}
+
+bool enable_endstops(bool check)
+{
+  bool old = check_endstops;
   check_endstops = check;
+  return old;
+}
+
+bool enable_z_endstop(bool check)
+{
+  bool old = check_z_endstop;
+  check_z_endstop = check;
+  endstop_z_hit=false;
+  return old;
 }
 
 //         __________________________
@@ -496,7 +516,7 @@ ISR(TIMER1_COMPA_vect)
       #endif
 
       count_direction[Z_AXIS]=-1;
-      CHECK_ENDSTOPS
+      if(check_endstops && ! check_z_endstop)
       {
         #if defined(Z_MIN_PIN) && Z_MIN_PIN > -1
           bool z_min_endstop=(READ(Z_MIN_PIN) != Z_MIN_ENDSTOP_INVERTING);
@@ -531,6 +551,21 @@ ISR(TIMER1_COMPA_vect)
       }
     }
 
+    // Supporting stopping on a trigger of the Z-stop induction sensor, not only for the Z-minus movements.
+    #if defined(Z_MIN_PIN) && Z_MIN_PIN > -1
+    if(check_z_endstop) {
+        // Check the Z min end-stop no matter what.
+        // Good for searching for the center of an induction target.
+        bool z_min_endstop=(READ(Z_MIN_PIN) != Z_MIN_ENDSTOP_INVERTING);
+        if(z_min_endstop && old_z_min_endstop) {
+          endstops_trigsteps[Z_AXIS] = count_position[Z_AXIS];
+          endstop_z_hit=true;
+          step_events_completed = current_block->step_event_count;
+        }
+        old_z_min_endstop = z_min_endstop;
+    }
+    #endif
+
     #ifndef ADVANCE
       if ((out_bits & (1<<E_AXIS)) != 0) {  // -direction
         REV_E_DIR();

Firmware/stepper.h

@@ -72,9 +72,12 @@ void st_wake_up();
 
   
 void checkHitEndstops(); //call from somewhere 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 homing and before a routine call of checkHitEndstops();
+bool endstops_hit_on_purpose(); //avoid creation of the message, i.e. after homing and before a routine call of checkHitEndstops();
+bool endstop_z_hit_on_purpose();
 
-void enable_endstops(bool check); // Enable/disable endstop checking
+
+bool enable_endstops(bool check); // Enable/disable endstop checking. Return the old value.
+bool enable_z_endstop(bool check);
 
 void checkStepperErrors(); //Print errors detected by the stepper
 

Firmware/ultralcd.cpp

@@ -1,3053 +1,3204 @@
-#include "temperature.h"
-#include "ultralcd.h"
-#ifdef ULTRA_LCD
-#include "Marlin.h"
-#include "language.h"
-#include "cardreader.h"
-#include "temperature.h"
-#include "stepper.h"
-#include "ConfigurationStore.h"
-#include <string.h>
-//#include "Configuration.h"
-
-
-
-#define _STRINGIFY(s) #s
-
-
-int8_t encoderDiff; /* encoderDiff is updated from interrupt context and added to encoderPosition every LCD update */
-
-extern int lcd_change_fil_state;
-
-int babystepMem[3];
-float babystepMemMM[3];
-
-union Data
-{
-  byte b[2];
-  int value;
-};
-
-int8_t ReInitLCD = 0;
-
-int8_t SDscrool = 0;
-
-int8_t SilentModeMenu = 0;
-
-int lcd_commands_type=0;
-int lcd_commands_step=0;
-bool isPrintPaused = false;
-
-/* Configuration settings */
-int plaPreheatHotendTemp;
-int plaPreheatHPBTemp;
-int plaPreheatFanSpeed;
-
-int absPreheatHotendTemp;
-int absPreheatHPBTemp;
-int absPreheatFanSpeed;
-
-int ppPreheatHotendTemp = PP_PREHEAT_HOTEND_TEMP;
-int ppPreheatHPBTemp = PP_PREHEAT_HPB_TEMP;
-int ppPreheatFanSpeed = PP_PREHEAT_FAN_SPEED;
-
-int petPreheatHotendTemp = PET_PREHEAT_HOTEND_TEMP;
-int petPreheatHPBTemp = PET_PREHEAT_HPB_TEMP;
-int petPreheatFanSpeed = PET_PREHEAT_FAN_SPEED;
-
-int hipsPreheatHotendTemp = HIPS_PREHEAT_HOTEND_TEMP;
-int hipsPreheatHPBTemp = HIPS_PREHEAT_HPB_TEMP;
-int hipsPreheatFanSpeed = HIPS_PREHEAT_FAN_SPEED;
-
-int flexPreheatHotendTemp = FLEX_PREHEAT_HOTEND_TEMP;
-int flexPreheatHPBTemp = FLEX_PREHEAT_HPB_TEMP;
-int flexPreheatFanSpeed = FLEX_PREHEAT_FAN_SPEED;
-
-
-
-#ifdef FILAMENT_LCD_DISPLAY
-unsigned long message_millis = 0;
-#endif
-
-#ifdef ULTIPANEL
-static float manual_feedrate[] = MANUAL_FEEDRATE;
-#endif // ULTIPANEL
-
-/* !Configuration settings */
-
-//Function pointer to menu functions.
-typedef void (*menuFunc_t)();
-
-uint8_t lcd_status_message_level;
-char lcd_status_message[LCD_WIDTH + 1] = ""; //////WELCOME!
-unsigned char firstrun = 1;
-
-#ifdef DOGLCD
-#include "dogm_lcd_implementation.h"
-#else
-#include "ultralcd_implementation_hitachi_HD44780.h"
-#endif
-
-/** forward declarations **/
-
-void copy_and_scalePID_i();
-void copy_and_scalePID_d();
-
-/* Different menus */
-static void lcd_status_screen();
-#ifdef ULTIPANEL
-extern bool powersupply;
-static void lcd_main_menu();
-static void lcd_tune_menu();
-static void lcd_prepare_menu();
-static void lcd_move_menu();
-static void lcd_control_menu();
-static void lcd_settings_menu();
-static void lcd_language_menu();
-static void lcd_control_temperature_menu();
-static void lcd_control_temperature_preheat_pla_settings_menu();
-static void lcd_control_temperature_preheat_abs_settings_menu();
-static void lcd_control_motion_menu();
-static void lcd_control_volumetric_menu();
-
-#ifdef DOGLCD
-static void lcd_set_contrast();
-#endif
-static void lcd_control_retract_menu();
-static void lcd_sdcard_menu();
-
-#ifdef DELTA_CALIBRATION_MENU
-static void lcd_delta_calibrate_menu();
-#endif // DELTA_CALIBRATION_MENU
-
-static void lcd_quick_feedback();//Cause an LCD refresh, and give the user visual or audible feedback that something has happened
-
-/* Different types of actions that can be used in menu items. */
-static void menu_action_back(menuFunc_t data);
-static void menu_action_submenu(menuFunc_t data);
-static void menu_action_gcode(const char* pgcode);
-static void menu_action_function(menuFunc_t data);
-static void menu_action_setlang(unsigned char lang);
-static void menu_action_sdfile(const char* filename, char* longFilename);
-static void menu_action_sddirectory(const char* filename, char* longFilename);
-static void menu_action_setting_edit_bool(const char* pstr, bool* ptr);
-static void menu_action_setting_edit_int3(const char* pstr, int* ptr, int minValue, int maxValue);
-static void menu_action_setting_edit_float3(const char* pstr, float* ptr, float minValue, float maxValue);
-static void menu_action_setting_edit_float32(const char* pstr, float* ptr, float minValue, float maxValue);
-static void menu_action_setting_edit_float43(const char* pstr, float* ptr, float minValue, float maxValue);
-static void menu_action_setting_edit_float5(const char* pstr, float* ptr, float minValue, float maxValue);
-static void menu_action_setting_edit_float51(const char* pstr, float* ptr, float minValue, float maxValue);
-static void menu_action_setting_edit_float52(const char* pstr, float* ptr, float minValue, float maxValue);
-static void menu_action_setting_edit_long5(const char* pstr, unsigned long* ptr, unsigned long minValue, unsigned long maxValue);
-static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, menuFunc_t callbackFunc);
-static void menu_action_setting_edit_callback_int3(const char* pstr, int* ptr, int minValue, int maxValue, menuFunc_t callbackFunc);
-static void menu_action_setting_edit_callback_float3(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-static void menu_action_setting_edit_callback_float32(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-static void menu_action_setting_edit_callback_float43(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-static void menu_action_setting_edit_callback_float5(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-static void menu_action_setting_edit_callback_float51(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-static void menu_action_setting_edit_callback_float52(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-static void menu_action_setting_edit_callback_long5(const char* pstr, unsigned long* ptr, unsigned long minValue, unsigned long maxValue, menuFunc_t callbackFunc);
-
-#define ENCODER_FEEDRATE_DEADZONE 10
-
-#if !defined(LCD_I2C_VIKI)
-#ifndef ENCODER_STEPS_PER_MENU_ITEM
-#define ENCODER_STEPS_PER_MENU_ITEM 5
-#endif
-#ifndef ENCODER_PULSES_PER_STEP
-#define ENCODER_PULSES_PER_STEP 1
-#endif
-#else
-#ifndef ENCODER_STEPS_PER_MENU_ITEM
-#define ENCODER_STEPS_PER_MENU_ITEM 2 // VIKI LCD rotary encoder uses a different number of steps per rotation
-#endif
-#ifndef ENCODER_PULSES_PER_STEP
-#define ENCODER_PULSES_PER_STEP 1
-#endif
-#endif
-
-
-/* Helper macros for menus */
-#define START_MENU() do { \
-    if (encoderPosition > 0x8000) encoderPosition = 0; \
-    if (encoderPosition / ENCODER_STEPS_PER_MENU_ITEM < currentMenuViewOffset) currentMenuViewOffset = encoderPosition / ENCODER_STEPS_PER_MENU_ITEM;\
-    uint8_t _lineNr = currentMenuViewOffset, _menuItemNr; \
-    bool wasClicked = LCD_CLICKED;\
-    for(uint8_t _drawLineNr = 0; _drawLineNr < LCD_HEIGHT; _drawLineNr++, _lineNr++) { \
-      _menuItemNr = 0;
-
-#define MENU_ITEM(type, label, args...) do { \
-    if (_menuItemNr == _lineNr) { \
-      if (lcdDrawUpdate) { \
-        const char* _label_pstr = (label); \
-        if ((encoderPosition / ENCODER_STEPS_PER_MENU_ITEM) == _menuItemNr) { \
-          lcd_implementation_drawmenu_ ## type ## _selected (_drawLineNr, _label_pstr , ## args ); \
-        }else{\
-          lcd_implementation_drawmenu_ ## type (_drawLineNr, _label_pstr , ## args ); \
-        }\
-      }\
-      if (wasClicked && (encoderPosition / ENCODER_STEPS_PER_MENU_ITEM) == _menuItemNr) {\
-        lcd_quick_feedback(); \
-        menu_action_ ## type ( args ); \
-        return;\
-      }\
-    }\
-    _menuItemNr++;\
-  } while(0)
-
-#define MENU_ITEM_DUMMY() do { _menuItemNr++; } while(0)
-#define MENU_ITEM_EDIT(type, label, args...) MENU_ITEM(setting_edit_ ## type, label, (label) , ## args )
-#define MENU_ITEM_EDIT_CALLBACK(type, label, args...) MENU_ITEM(setting_edit_callback_ ## type, label, (label) , ## args )
-#define END_MENU() \
-  if (encoderPosition / ENCODER_STEPS_PER_MENU_ITEM >= _menuItemNr) encoderPosition = _menuItemNr * ENCODER_STEPS_PER_MENU_ITEM - 1; \
-  if ((uint8_t)(encoderPosition / ENCODER_STEPS_PER_MENU_ITEM) >= currentMenuViewOffset + LCD_HEIGHT) { currentMenuViewOffset = (encoderPosition / ENCODER_STEPS_PER_MENU_ITEM) - LCD_HEIGHT + 1; lcdDrawUpdate = 1; _lineNr = currentMenuViewOffset - 1; _drawLineNr = -1; } \
-  } } while(0)
-
-/** Used variables to keep track of the menu */
-#ifndef REPRAPWORLD_KEYPAD
-volatile uint8_t buttons;//Contains the bits of the currently pressed buttons.
-#else
-volatile uint8_t buttons_reprapworld_keypad; // to store the reprapworld_keypad shift register values
-#endif
-#ifdef LCD_HAS_SLOW_BUTTONS
-volatile uint8_t slow_buttons;//Contains the bits of the currently pressed buttons.
-#endif
-uint8_t currentMenuViewOffset;              /* scroll offset in the current menu */
-uint32_t blocking_enc;
-uint8_t lastEncoderBits;
-uint32_t encoderPosition;
-#if (SDCARDDETECT > 0)
-bool lcd_oldcardstatus;
-#endif
-#endif //ULTIPANEL
-
-menuFunc_t currentMenu = lcd_status_screen; /* function pointer to the currently active menu */
-uint32_t lcd_next_update_millis;
-uint8_t lcd_status_update_delay;
-bool ignore_click = false;
-bool wait_for_unclick;
-uint8_t lcdDrawUpdate = 2;                  /* Set to none-zero when the LCD needs to draw, decreased after every draw. Set to 2 in LCD routines so the LCD gets at least 1 full redraw (first redraw is partial) */
-
-//prevMenu and prevEncoderPosition are used to store the previous menu location when editing settings.
-menuFunc_t prevMenu = NULL;
-uint16_t prevEncoderPosition;
-//Variables used when editing values.
-const char* editLabel;
-void* editValue;
-int32_t minEditValue, maxEditValue;
-menuFunc_t callbackFunc;
-
-// place-holders for Ki and Kd edits
-float raw_Ki, raw_Kd;
-
-static void lcd_goto_menu(menuFunc_t menu, const uint32_t encoder = 0, const bool feedback = true) {
-  if (currentMenu != menu) {
-    currentMenu = menu;
-    encoderPosition = encoder;
-    if (feedback) lcd_quick_feedback();
-
-    // For LCD_PROGRESS_BAR re-initialize the custom characters
-#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
-    lcd_set_custom_characters(menu == lcd_status_screen);
-#endif
-  }
-}
-
-/* Main status screen. It's up to the implementation specific part to show what is needed. As this is very display dependent */
-/*
-extern char langbuffer[];
-void lcd_printPGM(const char *s1) {
-  strncpy_P(langbuffer,s1,LCD_WIDTH);
-  lcd.print(langbuffer);
-}
-*/
-unsigned char langsel;
-
-void set_language_from_EEPROM() {
-  unsigned char eep = eeprom_read_byte((unsigned char*)EEPROM_LANG);
-  if (eep < LANG_NUM)
-  {
-    lang_selected = eep;
-    langsel = 0;
-  }
-  else
-  {
-    lang_selected = 1;
-    langsel = 1;
-  }
-}
-
-void lcd_mylang();
-static void lcd_status_screen()
-{
-	
-  if (firstrun == 1) 
-  {
-    firstrun = 0;
-    set_language_from_EEPROM();
-    strncpy_P(lcd_status_message, WELCOME_MSG, LCD_WIDTH);
-	
-	if (eeprom_read_byte((uint8_t *)EEPROM_TOTALTIME) == 255 && eeprom_read_byte((uint8_t *)EEPROM_TOTALTIME + 1) == 255 && eeprom_read_byte((uint8_t *)EEPROM_TOTALTIME + 2) == 255 && eeprom_read_byte((uint8_t *)EEPROM_TOTALTIME + 3) == 255)
-	{
-		eeprom_update_dword((uint32_t *)EEPROM_TOTALTIME, 0);
-		eeprom_update_dword((uint32_t *)EEPROM_FILAMENTUSED, 0);
-	}
-	
-	if (langsel) {
-      //strncpy_P(lcd_status_message, PSTR(">>>>>>>>>>>> PRESS v"), LCD_WIDTH);
-      lcd_mylang();
-    }
-  }
-
-  
-  if (lcd_status_update_delay)
-    lcd_status_update_delay--;
-  else
-    lcdDrawUpdate = 1;
-  if (lcdDrawUpdate)
-  {
-    ReInitLCD++;
-
-
-    if (ReInitLCD == 30) {
-      lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
-#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
-        currentMenu == lcd_status_screen
-#endif
-      );
-      ReInitLCD = 0 ;
-    } else {
-
-      if ((ReInitLCD % 10) == 0) {
-        //lcd_implementation_nodisplay();
-        lcd_implementation_init_noclear( // to maybe revive the LCD if static electricity killed it.
-#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
-          currentMenu == lcd_status_screen
-#endif
-        );
-
-      }
-
-    }
-
-
-    //lcd_implementation_display();
-    lcd_implementation_status_screen();
-    //lcd_implementation_clear();
-
-
-
-
-
-
-
-    lcd_status_update_delay = 10;   /* redraw the main screen every second. This is easier then trying keep track of all things that change on the screen */
-	if (lcd_commands_type != 0)
-	{
-		lcd_commands();
-	}
-	
-
-  }
-#ifdef ULTIPANEL
-
-  bool current_click = LCD_CLICKED;
-
-  if (ignore_click) {
-    if (wait_for_unclick) {
-      if (!current_click) {
-        ignore_click = wait_for_unclick = false;
-      }
-      else {
-        current_click = false;
-      }
-    }
-    else if (current_click) {
-      lcd_quick_feedback();
-      wait_for_unclick = true;
-      current_click = false;
-    }
-  }
-
-
-  //if (--langsel ==0) {langsel=1;current_click=true;}
-
-  if (current_click)
-  {
-
-    lcd_goto_menu(lcd_main_menu);
-    lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
-#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
-      currentMenu == lcd_status_screen
-#endif
-    );
-#ifdef FILAMENT_LCD_DISPLAY
-    message_millis = millis();  // get status message to show up for a while
-#endif
-  }
-
-#ifdef ULTIPANEL_FEEDMULTIPLY
-  // Dead zone at 100% feedrate
-  if ((feedmultiply < 100 && (feedmultiply + int(encoderPosition)) > 100) ||
-      (feedmultiply > 100 && (feedmultiply + int(encoderPosition)) < 100))
-  {
-    encoderPosition = 0;
-    feedmultiply = 100;
-  }
-
-  if (feedmultiply == 100 && int(encoderPosition) > ENCODER_FEEDRATE_DEADZONE)
-  {
-    feedmultiply += int(encoderPosition) - ENCODER_FEEDRATE_DEADZONE;
-    encoderPosition = 0;
-  }
-  else if (feedmultiply == 100 && int(encoderPosition) < -ENCODER_FEEDRATE_DEADZONE)
-  {
-    feedmultiply += int(encoderPosition) + ENCODER_FEEDRATE_DEADZONE;
-    encoderPosition = 0;
-  }
-  else if (feedmultiply != 100)
-  {
-    feedmultiply += int(encoderPosition);
-    encoderPosition = 0;
-  }
-#endif //ULTIPANEL_FEEDMULTIPLY
-
-  if (feedmultiply < 10)
-    feedmultiply = 10;
-  else if (feedmultiply > 999)
-    feedmultiply = 999;
-#endif //ULTIPANEL
-}
-
-#ifdef ULTIPANEL
-
-void lcd_commands()
-{
-	if (lcd_commands_type == 1)   //// load filament sequence
-	{
-		if (lcd_commands_step == 0) { lcd_commands_step = 5; custom_message = true; }
-			if (lcd_commands_step == 1 && !blocks_queued())
-			{
-				lcd_commands_step = 0;
-				lcd_commands_type = 0;
-				lcd_setstatuspgm(WELCOME_MSG);
-				disable_z();
-				custom_message = false;
-				custom_message_type = 0;
-			}
-			if (lcd_commands_step == 2 && !blocks_queued())
-			{
-				lcd_setstatuspgm(MSG_LOADING_FILAMENT);
-				enquecommand_P(PSTR(LOAD_FILAMENT_2));
-				lcd_commands_step = 1;
-			}
-			if (lcd_commands_step == 3 && !blocks_queued())
-			{
-				enquecommand_P(PSTR(LOAD_FILAMENT_1));
-				lcd_commands_step = 2;
-			}
-			if (lcd_commands_step == 4 && !blocks_queued())
-			{
-				lcd_setstatuspgm(MSG_INSERT_FILAMENT);
-				enquecommand_P(PSTR(LOAD_FILAMENT_0));
-				lcd_commands_step = 3;
-			}
-			if (lcd_commands_step == 5 && !blocks_queued())
-			{
-				lcd_setstatuspgm(MSG_PLEASE_WAIT);
-				enable_z();
-				custom_message = true;
-				custom_message_type = 2;
-				lcd_commands_step = 4;
-			}
-
- 
-		
-		
-		
-	}
-
-	if (lcd_commands_type == 2)   /// stop print
-	{
-
-		if (lcd_commands_step == 0) { lcd_commands_step = 6; custom_message = true;	}
-
-		if (lcd_commands_step == 1 && !blocks_queued())
-		{
-			lcd_commands_step = 0;
-			lcd_commands_type = 0;
-			lcd_setstatuspgm(WELCOME_MSG);
-			custom_message = false;
-		}
-		if (lcd_commands_step == 2 && !blocks_queued())
-		{
-			setTargetBed(0);
-			setTargetHotend(0, 0);
-			setTargetHotend(0, 1);
-			setTargetHotend(0, 2);
-			manage_heater();
-			lcd_setstatuspgm(WELCOME_MSG);
-			cancel_heatup = false;
-			lcd_commands_step = 1;
-		}
-		if (lcd_commands_step == 3 && !blocks_queued())
-		{
-			enquecommand_P(PSTR("M84"));
-			autotempShutdown();
-			lcd_commands_step = 2;
-		}
-		if (lcd_commands_step == 4 && !blocks_queued())
-		{
-			enquecommand_P(PSTR("G90"));
-			#ifdef X_CANCEL_POS 
-			enquecommand_P(PSTR("G1 X"  STRINGIFY(X_CANCEL_POS) " Y" STRINGIFY(Y_CANCEL_POS) " E0 F7000"));
-			#else
-			enquecommand_P(PSTR("G1 X50 Y" STRINGIFY(Y_MAX_POS) " E0 F7000"));
-			#endif
-			lcd_ignore_click(false);
-			lcd_commands_step = 3;
-		}
-		if (lcd_commands_step == 5 && !blocks_queued())
-		{
-			lcd_setstatuspgm(MSG_PRINT_ABORTED);
-			enquecommand_P(PSTR("G91"));
-			enquecommand_P(PSTR("G1 Z15 F1500"));
-			lcd_commands_step = 4;
-		}
-		if (lcd_commands_step == 6 && !blocks_queued())
-		{
-			lcd_setstatuspgm(MSG_PRINT_ABORTED);
-			cancel_heatup = true;
-			setTargetBed(0);
-			setTargetHotend(0, 0);
-			setTargetHotend(0, 1);
-			setTargetHotend(0, 2);
-			manage_heater();
-			lcd_commands_step = 5;
-		}
-
-	}
-
-	if (lcd_commands_type == 3)
-	{
-		lcd_commands_type = 0;
-	}
-
-}
-
-static void lcd_return_to_status() {
-  lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
-#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
-    currentMenu == lcd_status_screen
-#endif
-  );
-
-    lcd_goto_menu(lcd_status_screen, 0, false);
-}
-
-static void lcd_sdcard_pause() {
-  card.pauseSDPrint();
-  isPrintPaused = true;
-  lcdDrawUpdate = 3;
-}
-
-static void lcd_sdcard_resume() {
-	card.startFileprint();
-	isPrintPaused = false;
-	lcdDrawUpdate = 3;
-}
-
-float move_menu_scale;
-static void lcd_move_menu_axis();
-
-
-
-/* Menu implementation */
-
-
-void lcd_preheat_pla()
-{
-  setTargetHotend0(plaPreheatHotendTemp);
-  setTargetBed(plaPreheatHPBTemp);
-  fanSpeed = 0;
-  lcd_return_to_status();
-  setWatch(); // heater sanity check timer
-}
-
-void lcd_preheat_abs()
-{
-  setTargetHotend0(absPreheatHotendTemp);
-  setTargetBed(absPreheatHPBTemp);
-  fanSpeed = 0;
-  lcd_return_to_status();
-  setWatch(); // heater sanity check timer
-}
-
-void lcd_preheat_pp()
-{
-  setTargetHotend0(ppPreheatHotendTemp);
-  setTargetBed(ppPreheatHPBTemp);
-  fanSpeed = 0;
-  lcd_return_to_status();
-  setWatch(); // heater sanity check timer
-}
-
-void lcd_preheat_pet()
-{
-  setTargetHotend0(petPreheatHotendTemp);
-  setTargetBed(petPreheatHPBTemp);
-  fanSpeed = 0;
-  lcd_return_to_status();
-  setWatch(); // heater sanity check timer
-}
-
-void lcd_preheat_hips()
-{
-  setTargetHotend0(hipsPreheatHotendTemp);
-  setTargetBed(hipsPreheatHPBTemp);
-  fanSpeed = 0;
-  lcd_return_to_status();
-  setWatch(); // heater sanity check timer
-}
-
-void lcd_preheat_flex()
-{
-  setTargetHotend0(flexPreheatHotendTemp);
-  setTargetBed(flexPreheatHPBTemp);
-  fanSpeed = 0;
-  lcd_return_to_status();
-  setWatch(); // heater sanity check timer
-}
-
-
-void lcd_cooldown()
-{
-  setTargetHotend0(0);
-  setTargetHotend1(0);
-  setTargetHotend2(0);
-  setTargetBed(0);
-  fanSpeed = 0;
-  lcd_return_to_status();
-}
-
-
-
-static void lcd_preheat_menu()
-{
-  START_MENU();
-
-  MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
-
-  MENU_ITEM(function, PSTR("ABS  -  " STRINGIFY(ABS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(ABS_PREHEAT_HPB_TEMP)), lcd_preheat_abs);
-  MENU_ITEM(function, PSTR("PLA  -  " STRINGIFY(PLA_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PLA_PREHEAT_HPB_TEMP)), lcd_preheat_pla);
-  MENU_ITEM(function, PSTR("PET  -  " STRINGIFY(PET_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PET_PREHEAT_HPB_TEMP)), lcd_preheat_pet);
-  MENU_ITEM(function, PSTR("HIPS -  " STRINGIFY(HIPS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(HIPS_PREHEAT_HPB_TEMP)), lcd_preheat_hips);
-  MENU_ITEM(function, PSTR("PP   -  " STRINGIFY(PP_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PP_PREHEAT_HPB_TEMP)), lcd_preheat_pp);
-  MENU_ITEM(function, PSTR("FLEX -  " STRINGIFY(FLEX_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(FLEX_PREHEAT_HPB_TEMP)), lcd_preheat_flex);
-
-  MENU_ITEM(function, MSG_COOLDOWN, lcd_cooldown);
-
-  END_MENU();
-}
-
-static void lcd_support_menu()
-{
-  START_MENU();
-
-  MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
-
-  MENU_ITEM(back, PSTR(MSG_FW_VERSION " - " FW_version), lcd_main_menu);
-  MENU_ITEM(back, MSG_PRUSA3D, lcd_main_menu);
-  MENU_ITEM(back, MSG_PRUSA3D_FORUM, lcd_main_menu);
-  MENU_ITEM(back, MSG_PRUSA3D_HOWTO, lcd_main_menu);
-  MENU_ITEM(back, PSTR("------------"), lcd_main_menu);
-  MENU_ITEM(back, PSTR(FILAMENT_SIZE), lcd_main_menu);
-  MENU_ITEM(back, PSTR(ELECTRONICS),lcd_main_menu);
-  MENU_ITEM(back, PSTR(NOZZLE_TYPE),lcd_main_menu);
-  MENU_ITEM(back, PSTR("------------"), lcd_main_menu);
-  MENU_ITEM(back, PSTR("Date: "), lcd_main_menu);
-  MENU_ITEM(back, PSTR(__DATE__), lcd_main_menu);
-
-  END_MENU();
-}
-
-void lcd_unLoadFilament()
-{
-
-  if (degHotend0() > EXTRUDE_MINTEMP) {
-
-    enquecommand_P(PSTR(UNLOAD_FILAMENT_0));
-    enquecommand_P(PSTR(UNLOAD_FILAMENT_1));
-
-  } else {
-
-    lcd_implementation_clear();
-    lcd.setCursor(0, 0);
-    lcd_printPGM(MSG_ERROR);
-    lcd.setCursor(0, 2);
-    lcd_printPGM(MSG_PREHEAT_NOZZLE);
-
-    delay(2000);
-    lcd_implementation_clear();
-  }
-
-  lcd_return_to_status();
-}
-
-void lcd_change_filament() {
-
-  lcd_implementation_clear();
-
-  lcd.setCursor(0, 1);
-
-  lcd_printPGM(MSG_CHANGING_FILAMENT);
-
-
-}
-
-
-void lcd_wait_interact() {
-
-  lcd_implementation_clear();
-
-  lcd.setCursor(0, 1);
-
-  lcd_printPGM(MSG_INSERT_FILAMENT);
-  lcd.setCursor(0, 2);
-  lcd_printPGM(MSG_PRESS);
-
-}
-
-
-void lcd_change_success() {
-
-  lcd_implementation_clear();
-
-  lcd.setCursor(0, 2);
-
-  lcd_printPGM(MSG_CHANGE_SUCCESS);
-
-
-}
-
-
-void lcd_loading_color() {
-
-  lcd_implementation_clear();
-
-  lcd.setCursor(0, 0);
-
-  lcd_printPGM(MSG_LOADING_COLOR);
-  lcd.setCursor(0, 2);
-  lcd_printPGM(MSG_PLEASE_WAIT);
-
-
-  for (int i = 0; i < 20; i++) {
-
-    lcd.setCursor(i, 3);
-    lcd.print(".");
-    for (int j = 0; j < 10 ; j++) {
-      manage_heater();
-      manage_inactivity(true);
-      delay(85);
-
-    }
-
-
-  }
-
-}
-
-
-void lcd_loading_filament() {
-
-
-  lcd_implementation_clear();
-
-  lcd.setCursor(0, 0);
-
-  lcd_printPGM(MSG_LOADING_FILAMENT);
-  lcd.setCursor(0, 2);
-  lcd_printPGM(MSG_PLEASE_WAIT);
-
-
-  for (int i = 0; i < 20; i++) {
-
-    lcd.setCursor(i, 3);
-    lcd.print(".");
-    for (int j = 0; j < 10 ; j++) {
-      manage_heater();
-      manage_inactivity(true);
-      delay(110);
-
-    }
-
-
-  }
-
-}
-
-void lcd_alright() {
-  int enc_dif = 0;
-  int cursor_pos = 1;
-
-
-
-
-  lcd_implementation_clear();
-
-  lcd.setCursor(0, 0);
-
-  lcd_printPGM(MSG_CORRECTLY);
-
-  lcd.setCursor(1, 1);
-
-  lcd_printPGM(MSG_YES);
-
-  lcd.setCursor(1, 2);
-
-  lcd_printPGM(MSG_NOT_LOADED);
-
-
-  lcd.setCursor(1, 3);
-  lcd_printPGM(MSG_NOT_COLOR);
-
-
-  lcd.setCursor(0, 1);
-
-  lcd.print(">");
-
-
-  enc_dif = encoderDiff;
-
-  while (lcd_change_fil_state == 0) {
-
-    manage_heater();
-    manage_inactivity(true);
-
-    if ( abs((enc_dif - encoderDiff)) > 4 ) {
-
-      if ( (abs(enc_dif - encoderDiff)) > 1 ) {
-        if (enc_dif > encoderDiff ) {
-          cursor_pos --;
-        }
-
-        if (enc_dif < encoderDiff  ) {
-          cursor_pos ++;
-        }
-
-        if (cursor_pos > 3) {
-          cursor_pos = 3;
-        }
-
-        if (cursor_pos < 1) {
-          cursor_pos = 1;
-        }
-        lcd.setCursor(0, 1);
-        lcd.print(" ");
-        lcd.setCursor(0, 2);
-        lcd.print(" ");
-        lcd.setCursor(0, 3);
-        lcd.print(" ");
-        lcd.setCursor(0, cursor_pos);
-        lcd.print(">");
-        enc_dif = encoderDiff;
-        delay(100);
-      }
-
-    }
-
-
-    if (lcd_clicked()) {
-
-      lcd_change_fil_state = cursor_pos;
-      delay(500);
-
-    }
-
-
-
-  };
-
-
-  lcd_implementation_clear();
-  lcd_return_to_status();
-
-}
-
-
-
-void lcd_LoadFilament()
-{
-  if (degHotend0() > EXTRUDE_MINTEMP) 
-  {
-	  custom_message = true;
-	  lcd_commands_type = 1;
-	  SERIAL_ECHOLN("Loading filament");
-	  // commands() will handle the rest
-  } 
-  else 
-  {
-
-    lcd_implementation_clear();
-    lcd.setCursor(0, 0);
-    lcd_printPGM(MSG_ERROR);
-    lcd.setCursor(0, 2);
-	lcd_printPGM(MSG_PREHEAT_NOZZLE);
-    delay(2000);
-    lcd_implementation_clear();
-  }
-  lcd_return_to_status();
-}
-
-
-static void lcd_menu_statistics()
-{
-
-	if (IS_SD_PRINTING)
-	{
-		int _met = total_filament_used / 100000;
-		int _cm = (total_filament_used - (_met * 100000))/10;
-		
-		int _t = (millis() - starttime) / 1000;
-
-		int _h = _t / 3600;
-		int _m = (_t - (_h * 60)) / 60;
-		int _s = _t - ((_h * 3600) + (_m * 60));
-		
-		lcd.setCursor(0, 0);
-		lcd_printPGM(MSG_STATS_FILAMENTUSED);
-
-		lcd.setCursor(6, 1);
-		lcd.print(itostr3(_met));
-		lcd.print("m ");
-		lcd.print(ftostr32ns(_cm));
-		lcd.print("cm");
-		
-		lcd.setCursor(0, 2);
-		lcd_printPGM(MSG_STATS_PRINTTIME);
-
-		lcd.setCursor(8, 3);
-		lcd.print(itostr2(_h));
-		lcd.print("h ");
-		lcd.print(itostr2(_m));
-		lcd.print("m ");
-		lcd.print(itostr2(_s));
-		lcd.print("s");
-
-		if (lcd_clicked())
-		{
-			lcd_quick_feedback();
-			lcd_return_to_status();
-		}
-	}
-	else
-	{
-		unsigned long _filament = eeprom_read_dword((uint32_t *)EEPROM_FILAMENTUSED);
-		unsigned long _time = eeprom_read_dword((uint32_t *)EEPROM_TOTALTIME);
-		uint8_t _days, _hours, _minutes;
-
-		float _filament_m = (float)_filament;
-		int _filament_km = (_filament >= 100000) ? _filament / 100000 : 0;
-		if (_filament_km > 0)  _filament_m = _filament - (_filament_km * 100000);
-
-		_days = _time / 1440;
-		_hours = (_time - (_days * 1440)) / 60;
-		_minutes = _time - ((_days * 1440) + (_hours * 60));
-
-		lcd_implementation_clear();
-
-		lcd.setCursor(0, 0);
-		lcd_printPGM(MSG_STATS_TOTALFILAMENT);
-		lcd.setCursor(17 - strlen(ftostr32ns(_filament_m)), 1);
-		lcd.print(ftostr32ns(_filament_m));
-
-		if (_filament_km > 0)
-		{
-			lcd.setCursor(17 - strlen(ftostr32ns(_filament_m)) - 3, 1);
-			lcd.print("km");
-			lcd.setCursor(17 - strlen(ftostr32ns(_filament_m)) - 8, 1);
-			lcd.print(itostr4(_filament_km));
-		}
-
-
-		lcd.setCursor(18, 1);
-		lcd.print("m");
-
-		lcd.setCursor(0, 2);
-		lcd_printPGM(MSG_STATS_TOTALPRINTTIME);;
-
-		lcd.setCursor(18, 3);
-		lcd.print("m");
-		lcd.setCursor(14, 3);
-		lcd.print(itostr3(_minutes));
-
-		lcd.setCursor(14, 3);
-		lcd.print(":");
-
-		lcd.setCursor(12, 3);
-		lcd.print("h");
-		lcd.setCursor(9, 3);
-		lcd.print(itostr3(_hours));
-
-		lcd.setCursor(9, 3);
-		lcd.print(":");
-
-		lcd.setCursor(7, 3);
-		lcd.print("d");
-		lcd.setCursor(4, 3);
-		lcd.print(itostr3(_days));
-
-
-
-		while (!lcd_clicked())
-		{
-			manage_heater();
-			manage_inactivity(true);
-			delay(100);
-		}
-
-		lcd_quick_feedback();
-		lcd_return_to_status();
-	}
-}
-
-
-static void _lcd_move(const char *name, int axis, int min, int max) {
-  if (encoderPosition != 0) {
-    refresh_cmd_timeout();
-    current_position[axis] += float((int)encoderPosition) * move_menu_scale;
-    if (min_software_endstops && current_position[axis] < min) current_position[axis] = min;
-    if (max_software_endstops && current_position[axis] > max) current_position[axis] = max;
-    encoderPosition = 0;
-#ifdef DELTA
-    calculate_delta(current_position);
-    plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis] / 60, active_extruder);
-#else
-    plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis] / 60, active_extruder);
-#endif
-    lcdDrawUpdate = 1;
-  }
-  if (lcdDrawUpdate) lcd_implementation_drawedit(name, ftostr31(current_position[axis]));
-  if (LCD_CLICKED) lcd_goto_menu(lcd_move_menu_axis);
-}
-
-
-static void lcd_move_e()
-{
-  if (encoderPosition != 0)
-  {
-    current_position[E_AXIS] += float((int)encoderPosition) * move_menu_scale;
-    encoderPosition = 0;
-#ifdef DELTA
-    calculate_delta(current_position);
-    plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS], manual_feedrate[E_AXIS] / 60, active_extruder);
-#else
-    plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[E_AXIS] / 60, active_extruder);
-#endif
-    lcdDrawUpdate = 1;
-  }
-  if (lcdDrawUpdate)
-  {
-    lcd_implementation_drawedit(PSTR("Extruder"), ftostr31(current_position[E_AXIS]));
-  }
-  if (LCD_CLICKED) lcd_goto_menu(lcd_move_menu_axis);
-}
-
-
-void EEPROM_save_B(int pos, int* value)
-{
-  union Data data;
-  data.value = *value;
-
-  eeprom_write_byte((unsigned char*)pos, data.b[0]);
-  eeprom_write_byte((unsigned char*)pos + 1, data.b[1]);
-
-
-}
-
-void EEPROM_read_B(int pos, int* value)
-{
-  union Data data;
-  data.b[0] = eeprom_read_byte((unsigned char*)pos);
-  data.b[1] = eeprom_read_byte((unsigned char*)pos + 1);
-  *value = data.value;
-
-}
-
-
-
-static void lcd_move_x() {
-  _lcd_move(PSTR("X"), X_AXIS, X_MIN_POS, X_MAX_POS);
-}
-static void lcd_move_y() {
-  _lcd_move(PSTR("Y"), Y_AXIS, Y_MIN_POS, Y_MAX_POS);
-}
-static void lcd_move_z() {
-  _lcd_move(PSTR("Z"), Z_AXIS, Z_MIN_POS, Z_MAX_POS);
-}
-
-
-
-static void _lcd_babystep(int axis, const char *msg) {
-  if (encoderPosition != 0) 
-  {
-    babystepsTodo[axis] += (int)encoderPosition;
-    babystepMem[axis] += (int)encoderPosition;
-    babystepMemMM[axis] = babystepMem[axis]/axis_steps_per_unit[Z_AXIS];
-	delay(50);
-	encoderPosition = 0;
-    lcdDrawUpdate = 1;
-  }
-  if (lcdDrawUpdate) lcd_implementation_drawedit_2(msg, ftostr13ns(babystepMemMM[axis]));
-  if (LCD_CLICKED) lcd_goto_menu(lcd_main_menu);
-  EEPROM_save_B(EEPROM_BABYSTEP_X, &babystepMem[0]);
-  EEPROM_save_B(EEPROM_BABYSTEP_Y, &babystepMem[1]);
-  EEPROM_save_B(EEPROM_BABYSTEP_Z, &babystepMem[2]);
-}
-
-static void lcd_babystep_x() {
-  _lcd_babystep(X_AXIS, (MSG_BABYSTEPPING_X));
-}
-static void lcd_babystep_y() {
-  _lcd_babystep(Y_AXIS, (MSG_BABYSTEPPING_Y));
-}
-
-
-static void lcd_babystep_z() {
-  _lcd_babystep(Z_AXIS, (MSG_BABYSTEPPING_Z));
-}
-
-
-void lcd_adjust_z() {
-  int enc_dif = 0;
-  int cursor_pos = 1;
-  int fsm = 0;
-
-
-
-
-  lcd_implementation_clear();
-  lcd.setCursor(0, 0);
-  lcd_printPGM(MSG_ADJUSTZ);
-  lcd.setCursor(1, 1);
-  lcd_printPGM(MSG_YES);
-
-  lcd.setCursor(1, 2);
-
-  lcd_printPGM(MSG_NO);
-
-  lcd.setCursor(0, 1);
-
-  lcd.print(">");
-
-
-  enc_dif = encoderDiff;
-
-  while (fsm == 0) {
-
-    manage_heater();
-    manage_inactivity(true);
-
-    if ( abs((enc_dif - encoderDiff)) > 4 ) {
-
-      if ( (abs(enc_dif - encoderDiff)) > 1 ) {
-        if (enc_dif > encoderDiff ) {
-          cursor_pos --;
-        }
-
-        if (enc_dif < encoderDiff  ) {
-          cursor_pos ++;
-        }
-
-        if (cursor_pos > 2) {
-          cursor_pos = 2;
-        }
-
-        if (cursor_pos < 1) {
-          cursor_pos = 1;
-        }
-        lcd.setCursor(0, 1);
-        lcd.print(" ");
-        lcd.setCursor(0, 2);
-        lcd.print(" ");
-        lcd.setCursor(0, cursor_pos);
-        lcd.print(">");
-        enc_dif = encoderDiff;
-        delay(100);
-      }
-
-    }
-
-
-    if (lcd_clicked()) {
-      fsm = cursor_pos;
-      if (fsm == 1) {
-        EEPROM_read_B(EEPROM_BABYSTEP_X, &babystepMem[0]);
-        EEPROM_read_B(EEPROM_BABYSTEP_Y, &babystepMem[1]);
-        EEPROM_read_B(EEPROM_BABYSTEP_Z, &babystepMem[2]);
-        babystepsTodo[Z_AXIS] = babystepMem[2];
-      } else {
-        babystepMem[0] = 0;
-        babystepMem[1] = 0;
-        babystepMem[2] = 0;
-
-        EEPROM_save_B(EEPROM_BABYSTEP_X, &babystepMem[0]);
-        EEPROM_save_B(EEPROM_BABYSTEP_Y, &babystepMem[1]);
-        EEPROM_save_B(EEPROM_BABYSTEP_Z, &babystepMem[2]);
-      }
-      delay(500);
-    }
-  };
-
-  lcd_implementation_clear();
-  lcd_return_to_status();
-
-}
-
-void lcd_calibration() {
-}
-
-
-
-void lcd_pick_babystep(){
-    int enc_dif = 0;
-    int cursor_pos = 1;
-    int fsm = 0;
-    
-    
-    
-    
-    lcd_implementation_clear();
-    
-    lcd.setCursor(0, 0);
-    
-    lcd_printPGM(MSG_PICK_Z);
-    
-    
-    lcd.setCursor(3, 2);
-    
-    lcd.print("1");
-    
-    lcd.setCursor(3, 3);
-    
-    lcd.print("2");
-    
-    lcd.setCursor(12, 2);
-    
-    lcd.print("3");
-    
-    lcd.setCursor(12, 3);
-    
-    lcd.print("4");
-    
-    lcd.setCursor(1, 2);
-    
-    lcd.print(">");
-    
-    
-    enc_dif = encoderDiff;
-    
-    while (fsm == 0) {
-        
-        manage_heater();
-        manage_inactivity(true);
-        
-        if ( abs((enc_dif - encoderDiff)) > 4 ) {
-            
-            if ( (abs(enc_dif - encoderDiff)) > 1 ) {
-                if (enc_dif > encoderDiff ) {
-                    cursor_pos --;
-                }
-                
-                if (enc_dif < encoderDiff  ) {
-                    cursor_pos ++;
-                }
-                
-                if (cursor_pos > 4) {
-                    cursor_pos = 4;
-                }
-                
-                if (cursor_pos < 1) {
-                    cursor_pos = 1;
-                }
-
-                
-                lcd.setCursor(1, 2);
-                lcd.print(" ");
-                lcd.setCursor(1, 3);
-                lcd.print(" ");
-                lcd.setCursor(10, 2);
-                lcd.print(" ");
-                lcd.setCursor(10, 3);
-                lcd.print(" ");
-                
-                if (cursor_pos < 3) {
-                    lcd.setCursor(1, cursor_pos+1);
-                    lcd.print(">");
-                }else{
-                    lcd.setCursor(10, cursor_pos-1);
-                    lcd.print(">");
-                }
-                
-   
-                enc_dif = encoderDiff;
-                delay(100);
-            }
-            
-        }
-        
-        
-        if (lcd_clicked()) {
-            fsm = cursor_pos;
-            
-            EEPROM_read_B(EEPROM_BABYSTEP_Z0+((fsm-1)*2),&babystepMem[2]);
-            EEPROM_save_B(EEPROM_BABYSTEP_Z,&babystepMem[2]);
-            eeprom_write_byte((unsigned char*)EEPROM_BABYSTEP_Z_SET, 0x01);
-            delay(500);
-            
-        }
-        
-        
-        
-    };
-    
-    
-    lcd_implementation_clear();
-    lcd_return_to_status();
-}
-
-void lcd_move_menu_axis()
-{
-  START_MENU();
-  MENU_ITEM(back, MSG_SETTINGS, lcd_settings_menu);
-  MENU_ITEM(submenu, MSG_MOVE_X, lcd_move_x);
-  MENU_ITEM(submenu, MSG_MOVE_Y, lcd_move_y);
-  if (move_menu_scale < 10.0)
-  {
-	  if (!isPrintPaused)
-	  {
-		  MENU_ITEM(submenu, MSG_MOVE_Z, lcd_move_z);
-	  }
-	  MENU_ITEM(submenu, MSG_MOVE_E, lcd_move_e);
-  }
-  END_MENU();
-}
-
-static void lcd_move_menu_1mm()
-{
-  move_menu_scale = 1.0;
-  lcd_move_menu_axis();
-}
-
-
-void EEPROM_save(int pos, uint8_t* value, uint8_t size)
-{
-  do
-  {
-    eeprom_write_byte((unsigned char*)pos, *value);
-    pos++;
-    value++;
-  } while (--size);
-}
-
-void EEPROM_read(int pos, uint8_t* value, uint8_t size)
-{
-  do
-  {
-    *value = eeprom_read_byte((unsigned char*)pos);
-    pos++;
-    value++;
-  } while (--size);
-}
-
-
-
-static void lcd_silent_mode_set() {
-  SilentModeMenu = !SilentModeMenu;
-  EEPROM_save(EEPROM_SILENT, (uint8_t*)&SilentModeMenu, sizeof(SilentModeMenu));
-  digipot_init();
-  lcd_goto_menu(lcd_settings_menu, 7);
-}
-static void lcd_set_lang(unsigned char lang) {
-  lang_selected = lang;
-  firstrun = 1;
-  eeprom_write_byte((unsigned char *)EEPROM_LANG, lang);/*langsel=0;*/if (langsel == 1)langsel = 2;
-}
-
-void lcd_force_language_selection() {
-  eeprom_write_byte((unsigned char *)EEPROM_LANG, 255);
-}
-
-static void lcd_language_menu()
-{
-  START_MENU();
-  if (!langsel) {
-    MENU_ITEM(back, MSG_SETTINGS, lcd_settings_menu);
-  }
-  if (langsel == 2) {
-    MENU_ITEM(back, MSG_WATCH, lcd_status_screen);
-  }
-  for (int i=0;i<LANG_NUM;i++){
-    MENU_ITEM(setlang, MSG_ALL[i][LANGUAGE_NAME], i);
-  }
-  //MENU_ITEM(setlang, MSG_ALL[1][LANGUAGE_NAME], 1);
-  END_MENU();
-}
-
-void lcd_mesh_bedleveling()
-{
-
-	enquecommand_P(PSTR("G80"));
-	lcd_return_to_status();
-}
-
-
-static void lcd_settings_menu()
-{
-  EEPROM_read(EEPROM_SILENT, (uint8_t*)&SilentModeMenu, sizeof(SilentModeMenu));
-  START_MENU();
-
-  MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
-
-  MENU_ITEM(submenu, MSG_TEMPERATURE, lcd_control_temperature_menu);
-  MENU_ITEM(submenu, MSG_MOVE_AXIS, lcd_move_menu_1mm);
-  
-  if (!isPrintPaused)
-  {
-#ifndef MESH_BED_LEVELING
-	  MENU_ITEM(gcode, MSG_HOMEYZ, PSTR("G28 Z"));
-#else
-	  MENU_ITEM(submenu, MSG_HOMEYZ, lcd_mesh_bedleveling);
-#endif
-  }
-
-  if (!isPrintPaused)
-  {
-	  MENU_ITEM(gcode, MSG_DISABLE_STEPPERS, PSTR("M84"));
-	  MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
-  }
-
-  if (SilentModeMenu == 0) {
-    MENU_ITEM(function, MSG_SILENT_MODE_OFF, lcd_silent_mode_set);
-  } else {
-    MENU_ITEM(function, MSG_SILENT_MODE_ON, lcd_silent_mode_set);
-  }
-
-    EEPROM_read_B(EEPROM_BABYSTEP_X, &babystepMem[0]);
-    EEPROM_read_B(EEPROM_BABYSTEP_Y, &babystepMem[1]);
-    EEPROM_read_B(EEPROM_BABYSTEP_Z, &babystepMem[2]);
-    babystepMemMM[2] = babystepMem[2]/axis_steps_per_unit[Z_AXIS];
-  
-	if (!isPrintPaused)
-	{
-		MENU_ITEM(submenu, MSG_BABYSTEP_Z, lcd_babystep_z);//8
-	}
-	MENU_ITEM(submenu, MSG_LANGUAGE_SELECT, lcd_language_menu);
-	if (!isPrintPaused)
-	{
-		MENU_ITEM(submenu, MSG_SELFTEST, lcd_selftest);
-	}
-  
-	END_MENU();
-}
-/*
-void lcd_mylang_top(int hlaska) {
-    lcd.setCursor(0,0);
-    lcd.print("                    ");
-    lcd.setCursor(0,0);
-    lcd_printPGM(MSG_ALL[hlaska-1][LANGUAGE_SELECT]);   
-}
-
-void lcd_mylang_drawmenu(int cursor) {
-  int first = 0;
-  if (cursor>2) first = cursor-2;
-  if (cursor==LANG_NUM) first = LANG_NUM-3;
-  lcd.setCursor(0, 1);
-  lcd.print("                    ");
-  lcd.setCursor(1, 1);
-  lcd_printPGM(MSG_ALL[first][LANGUAGE_NAME]);
-
-  lcd.setCursor(0, 2);
-  lcd.print("                    ");
-  lcd.setCursor(1, 2);
-  lcd_printPGM(MSG_ALL[first+1][LANGUAGE_NAME]);
-
-  lcd.setCursor(0, 3);
-  lcd.print("                    ");
-  lcd.setCursor(1, 3);
-  lcd_printPGM(MSG_ALL[first+2][LANGUAGE_NAME]);  
-  
-  if (cursor==1) lcd.setCursor(0, 1);
-  if (cursor>1 && cursor<LANG_NUM) lcd.setCursor(0, 2);
-  if (cursor==LANG_NUM) lcd.setCursor(0, 3);
-
-  lcd.print(">");
-  
-  if (cursor<LANG_NUM-1) {
-    lcd.setCursor(19,3);
-    lcd.print("\x01");
-  }
-  if (cursor>2) {
-    lcd.setCursor(19,1);
-    lcd.print("^");
-  }  
-}
-*/
-
-void lcd_mylang_drawmenu(int cursor) {
-  int first = 0;
-  if (cursor>3) first = cursor-3;
-  if (cursor==LANG_NUM && LANG_NUM>4) first = LANG_NUM-4;
-  if (cursor==LANG_NUM && LANG_NUM==4) first = LANG_NUM-4;
-
-
-  lcd.setCursor(0, 0);
-  lcd.print("                    ");
-  lcd.setCursor(1, 0);
-  lcd_printPGM(MSG_ALL[first+0][LANGUAGE_NAME]);
-
-  lcd.setCursor(0, 1);
-  lcd.print("                    ");
-  lcd.setCursor(1, 1);
-  lcd_printPGM(MSG_ALL[first+1][LANGUAGE_NAME]);
-
-  lcd.setCursor(0, 2);
-  lcd.print("                    ");
-
-  if (LANG_NUM > 2){
-    lcd.setCursor(1, 2);
-    lcd_printPGM(MSG_ALL[first+2][LANGUAGE_NAME]);
-  }
-
-  lcd.setCursor(0, 3);
-  lcd.print("                    ");
-  if (LANG_NUM>3) {
-    lcd.setCursor(1, 3);
-    lcd_printPGM(MSG_ALL[first+3][LANGUAGE_NAME]);
-  }
-  
-  if (cursor==1) lcd.setCursor(0, 0);
-  if (cursor==2) lcd.setCursor(0, 1);
-  if (cursor>2) lcd.setCursor(0, 2);
-  if (cursor==LANG_NUM && LANG_NUM>3) lcd.setCursor(0, 3);
-
-  lcd.print(">");
-  
-  if (cursor<LANG_NUM-1 && LANG_NUM>4) {
-    lcd.setCursor(19,3);
-    lcd.print("\x01");
-  }
-  if (cursor>3 && LANG_NUM>4) {
-    lcd.setCursor(19,0);
-    lcd.print("^");
-  }  
-}
- 
-void lcd_set_custom_characters_arrows();
-void lcd_set_custom_characters_degree();
-
-void lcd_mylang_drawcursor(int cursor) {
-  
-  if (cursor==1) lcd.setCursor(0, 1);
-  if (cursor>1 && cursor<LANG_NUM) lcd.setCursor(0, 2);
-  if (cursor==LANG_NUM) lcd.setCursor(0, 3);
-
-  lcd.print(">");
-  
-}  
-
-void lcd_mylang() {
-  int enc_dif = 0;
-  int cursor_pos = 1;
-  lang_selected=255;
-  int hlaska=1;
-  int counter=0;
-  lcd_set_custom_characters_arrows();
-
-  lcd_implementation_clear();
-
-  //lcd_mylang_top(hlaska);
-
-  lcd_mylang_drawmenu(cursor_pos);
-
-
-  enc_dif = encoderDiff;
-
-  while ( (lang_selected == 255) && (MYSERIAL.available() < 2) ) {
-
-    manage_heater();
-    manage_inactivity(true);
-
-    if ( abs((enc_dif - encoderDiff)) > 4 ) {
-
-      //if ( (abs(enc_dif - encoderDiff)) > 1 ) {
-        if (enc_dif > encoderDiff ) {
-          cursor_pos --;
-        }
-
-        if (enc_dif < encoderDiff  ) {
-          cursor_pos ++;
-        }
-
-        if (cursor_pos > LANG_NUM) {
-          cursor_pos = LANG_NUM;
-        }
-
-        if (cursor_pos < 1) {
-          cursor_pos = 1;
-        }
-
-        lcd_mylang_drawmenu(cursor_pos);
-        enc_dif = encoderDiff;
-        delay(100);
-      //}
-
-    } else delay(20);
-
-
-    if (lcd_clicked()) {
-
-      lcd_set_lang(cursor_pos-1);
-      delay(500);
-
-    }
-    /*
-    if (++counter == 80) {
-      hlaska++;
-      if(hlaska>LANG_NUM) hlaska=1;
-      lcd_mylang_top(hlaska);
-      lcd_mylang_drawcursor(cursor_pos);
-      counter=0;
-    }
-    */
-  };
-
-  if(MYSERIAL.available() > 1){
-    lang_selected = 0;
-    firstrun = 0;
-  }
-
-  lcd_set_custom_characters_degree();
-  lcd_implementation_clear();
-  lcd_return_to_status();
-
-}
-
-
-
-
-static void lcd_main_menu()
-{
-
-  SDscrool = 0;
-  /*
-  if (langsel == 1)
-  {
-    lcd_goto_menu(lcd_language_menu);
-  }
-  */
-  START_MENU();
-
-  // Majkl superawesome menu
-
-  
- MENU_ITEM(back, MSG_WATCH, lcd_status_screen);
-
-  if ( ( IS_SD_PRINTING || is_usb_printing ) && (current_position[Z_AXIS] < 0.5) ) 
-  {
-    EEPROM_read_B(EEPROM_BABYSTEP_X, &babystepMem[0]);
-	EEPROM_read_B(EEPROM_BABYSTEP_Y, &babystepMem[1]);
-	EEPROM_read_B(EEPROM_BABYSTEP_Z, &babystepMem[2]);
-	
-	MENU_ITEM(submenu, MSG_BABYSTEP_Z, lcd_babystep_z);//8
-  }
-
-
-  if ( movesplanned() || IS_SD_PRINTING || is_usb_printing )
-  {
-    MENU_ITEM(submenu, MSG_TUNE, lcd_tune_menu);
-  } else 
-  {
-    MENU_ITEM(submenu, MSG_PREHEAT, lcd_preheat_menu);
-  }
-
-#ifdef SDSUPPORT
-  if (card.cardOK)
-  {
-    if (card.isFileOpen())
-    {
-		if (card.sdprinting)
-		{
-			MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause);
-		}
-		else
-		{
-			MENU_ITEM(function, MSG_RESUME_PRINT, lcd_sdcard_resume);
-		}
-		MENU_ITEM(submenu, MSG_STOP_PRINT, lcd_sdcard_stop);
-	}
-	else
-	{
-		if (!is_usb_printing)
-		{
-			MENU_ITEM(submenu, MSG_CARD_MENU, lcd_sdcard_menu);
-		}
-#if SDCARDDETECT < 1
-      MENU_ITEM(gcode, MSG_CNG_SDCARD, PSTR("M21"));  // SD-card changed by user
-#endif
-    }
-  } else 
-  {
-    MENU_ITEM(submenu, MSG_NO_CARD, lcd_sdcard_menu);
-#if SDCARDDETECT < 1
-    MENU_ITEM(gcode, MSG_INIT_SDCARD, PSTR("M21")); // Manually initialize the SD-card via user interface
-#endif
-  }
-#endif
-
-
-  if (IS_SD_PRINTING || is_usb_printing)
-  {
-  } 
-  else 
-  {
-    MENU_ITEM(function, MSG_LOAD_FILAMENT, lcd_LoadFilament);
-    MENU_ITEM(function, MSG_UNLOAD_FILAMENT, lcd_unLoadFilament);
-    MENU_ITEM(submenu, MSG_SETTINGS, lcd_settings_menu);
-  }
-
-  if (!is_usb_printing)
-  {
-	  MENU_ITEM(submenu, MSG_STATISTICS, lcd_menu_statistics);
-  }
-  MENU_ITEM(submenu, MSG_SUPPORT, lcd_support_menu);
-
-  END_MENU();
-}
-
-
-
-#ifdef SDSUPPORT
-static void lcd_autostart_sd()
-{
-  card.lastnr = 0;
-  card.setroot();
-  card.checkautostart(true);
-}
-#endif
-
-
-
-static void lcd_silent_mode_set_tune() {
-  SilentModeMenu = !SilentModeMenu;
-  EEPROM_save(EEPROM_SILENT, (uint8_t*)&SilentModeMenu, sizeof(SilentModeMenu));
-  digipot_init();
-  lcd_goto_menu(lcd_tune_menu, 9);
-}
-
-static void lcd_tune_menu()
-{
-  EEPROM_read(EEPROM_SILENT, (uint8_t*)&SilentModeMenu, sizeof(SilentModeMenu));
-
-  
-
-  START_MENU();
-  MENU_ITEM(back, MSG_MAIN, lcd_main_menu); //1
-  MENU_ITEM_EDIT(int3, MSG_SPEED, &feedmultiply, 10, 999);//2
-
-  MENU_ITEM_EDIT(int3, MSG_NOZZLE, &target_temperature[0], 0, HEATER_0_MAXTEMP - 10);//3
-  MENU_ITEM_EDIT(int3, MSG_BED, &target_temperature_bed, 0, BED_MAXTEMP - 10);//4
-
-  MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &fanSpeed, 0, 255);//5
-  MENU_ITEM_EDIT(int3, MSG_FLOW, &extrudemultiply, 10, 999);//6
-#ifdef FILAMENTCHANGEENABLE
-  MENU_ITEM(gcode, MSG_FILAMENTCHANGE, PSTR("M600"));//7
-#endif
-  
-  if (SilentModeMenu == 0) {
-    MENU_ITEM(function, MSG_SILENT_MODE_OFF, lcd_silent_mode_set_tune);
-  } else {
-    MENU_ITEM(function, MSG_SILENT_MODE_ON, lcd_silent_mode_set_tune);
-  }
-  END_MENU();
-}
-
-
-
-
-static void lcd_move_menu_01mm()
-{
-  move_menu_scale = 0.1;
-  lcd_move_menu_axis();
-}
-
-static void lcd_control_temperature_menu()
-{
-#ifdef PIDTEMP
-  // set up temp variables - undo the default scaling
-  raw_Ki = unscalePID_i(Ki);
-  raw_Kd = unscalePID_d(Kd);
-#endif
-
-  START_MENU();
-  MENU_ITEM(back, MSG_SETTINGS, lcd_settings_menu);
-  //MENU_ITEM(back, MSG_CONTROL, lcd_control_menu);
-#if TEMP_SENSOR_0 != 0
-  MENU_ITEM_EDIT(int3, MSG_NOZZLE, &target_temperature[0], 0, HEATER_0_MAXTEMP - 10);
-#endif
-#if TEMP_SENSOR_1 != 0
-  MENU_ITEM_EDIT(int3, MSG_NOZZLE1, &target_temperature[1], 0, HEATER_1_MAXTEMP - 10);
-#endif
-#if TEMP_SENSOR_2 != 0
-  MENU_ITEM_EDIT(int3, MSG_NOZZLE2, &target_temperature[2], 0, HEATER_2_MAXTEMP - 10);
-#endif
-#if TEMP_SENSOR_BED != 0
-  MENU_ITEM_EDIT(int3, MSG_BED, &target_temperature_bed, 0, BED_MAXTEMP - 3);
-#endif
-  MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &fanSpeed, 0, 255);
-#if defined AUTOTEMP && (TEMP_SENSOR_0 != 0)
-  MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &autotemp_enabled);
-  MENU_ITEM_EDIT(float3, MSG_MIN, &autotemp_min, 0, HEATER_0_MAXTEMP - 10);
-  MENU_ITEM_EDIT(float3, MSG_MAX, &autotemp_max, 0, HEATER_0_MAXTEMP - 10);
-  MENU_ITEM_EDIT(float32, MSG_FACTOR, &autotemp_factor, 0.0, 1.0);
-#endif
-
-  END_MENU();
-}
-
-
-#if SDCARDDETECT == -1
-static void lcd_sd_refresh()
-{
-  card.initsd();
-  currentMenuViewOffset = 0;
-}
-#endif
-static void lcd_sd_updir()
-{
-  SDscrool = 0;
-  card.updir();
-  currentMenuViewOffset = 0;
-}
-
-
-void lcd_sdcard_stop()
-{
-	
-	lcd.setCursor(0, 0);
-	lcd_printPGM(MSG_STOP_PRINT);
-	lcd.setCursor(2, 2);
-	lcd_printPGM(MSG_NO);
-	lcd.setCursor(2, 3);
-	lcd_printPGM(MSG_YES);
-	lcd.setCursor(0, 2); lcd.print(" ");
-	lcd.setCursor(0, 3); lcd.print(" ");
-
-	if ((int32_t)encoderPosition > 2) { encoderPosition = 2; }
-	if ((int32_t)encoderPosition < 1) { encoderPosition = 1; }
-	
-	lcd.setCursor(0, 1 + encoderPosition);
-	lcd.print(">");
-
-	if (lcd_clicked())
-	{
-		if ((int32_t)encoderPosition == 1)
-		{
-			lcd_return_to_status();
-		}
-		if ((int32_t)encoderPosition == 2)
-		{
-				cancel_heatup = true;
-				quickStop();
-				lcd_setstatuspgm(MSG_PRINT_ABORTED);
-				card.sdprinting = false;
-				card.closefile();
-
-				stoptime = millis();
-				unsigned long t = (stoptime - starttime) / 1000;
-				save_statistics(total_filament_used, t);
-
-				lcd_return_to_status();
-				lcd_ignore_click(true);
-				lcd_commands_type = 2;
-		}
-	}
-
-}
-
-void lcd_sdcard_menu()
-{
-
-	int tempScrool = 0;
-  if (lcdDrawUpdate == 0 && LCD_CLICKED == 0)
-    //delay(100);
-    return; // nothing to do (so don't thrash the SD card)
-  uint16_t fileCnt = card.getnrfilenames();
-
-  START_MENU();
-  MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
-  card.getWorkDirName();
-  if (card.filename[0] == '/')
-  {
-#if SDCARDDETECT == -1
-    MENU_ITEM(function, LCD_STR_REFRESH MSG_REFRESH, lcd_sd_refresh);
-#endif
-  } else {
-    MENU_ITEM(function, LCD_STR_FOLDER "..", lcd_sd_updir);
-  }
-
-  for (uint16_t i = 0; i < fileCnt; i++)
-  {
-    if (_menuItemNr == _lineNr)
-    {
-#ifndef SDCARD_RATHERRECENTFIRST
-      card.getfilename(i);
-#else
-      card.getfilename(fileCnt - 1 - i);
-#endif
-      if (card.filenameIsDir)
-      {
-        MENU_ITEM(sddirectory, MSG_CARD_MENU, card.filename, card.longFilename);
-      } else {
-
-        MENU_ITEM(sdfile, MSG_CARD_MENU, card.filename, card.longFilename);
-
-
-
-
-      }
-    } else {
-      MENU_ITEM_DUMMY();
-    }
-  }
-  END_MENU();
-}
-
-#define menu_edit_type(_type, _name, _strFunc, scale) \
-  void menu_edit_ ## _name () \
-  { \
-    if ((int32_t)encoderPosition < 0) encoderPosition = 0; \
-    if ((int32_t)encoderPosition > maxEditValue) encoderPosition = maxEditValue; \
-    if (lcdDrawUpdate) \
-      lcd_implementation_drawedit(editLabel, _strFunc(((_type)((int32_t)encoderPosition + minEditValue)) / scale)); \
-    if (LCD_CLICKED) \
-    { \
-      *((_type*)editValue) = ((_type)((int32_t)encoderPosition + minEditValue)) / scale; \
-      lcd_goto_menu(prevMenu, prevEncoderPosition); \
-    } \
-  } \
-  void menu_edit_callback_ ## _name () { \
-    menu_edit_ ## _name (); \
-    if (LCD_CLICKED) (*callbackFunc)(); \
-  } \
-  static void menu_action_setting_edit_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue) \
-  { \
-    prevMenu = currentMenu; \
-    prevEncoderPosition = encoderPosition; \
-    \
-    lcdDrawUpdate = 2; \
-    currentMenu = menu_edit_ ## _name; \
-    \
-    editLabel = pstr; \
-    editValue = ptr; \
-    minEditValue = minValue * scale; \
-    maxEditValue = maxValue * scale - minEditValue; \
-    encoderPosition = (*ptr) * scale - minEditValue; \
-  }\
-  static void menu_action_setting_edit_callback_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue, menuFunc_t callback) \
-  { \
-    prevMenu = currentMenu; \
-    prevEncoderPosition = encoderPosition; \
-    \
-    lcdDrawUpdate = 2; \
-    currentMenu = menu_edit_callback_ ## _name; \
-    \
-    editLabel = pstr; \
-    editValue = ptr; \
-    minEditValue = minValue * scale; \
-    maxEditValue = maxValue * scale - minEditValue; \
-    encoderPosition = (*ptr) * scale - minEditValue; \
-    callbackFunc = callback;\
-  }
-menu_edit_type(int, int3, itostr3, 1)
-menu_edit_type(float, float3, ftostr3, 1)
-menu_edit_type(float, float32, ftostr32, 100)
-menu_edit_type(float, float43, ftostr43, 1000)
-menu_edit_type(float, float5, ftostr5, 0.01)
-menu_edit_type(float, float51, ftostr51, 10)
-menu_edit_type(float, float52, ftostr52, 100)
-menu_edit_type(unsigned long, long5, ftostr5, 0.01)
-
-
-static void lcd_selftest()
-{
-	int _progress = 0;
-	bool _result = false;
-
-	_progress = lcd_selftest_screen(-1, _progress, 4, true, 2000);
-
-	_progress = lcd_selftest_screen(0, _progress, 3, true, 2000);
-	_result = lcd_selfcheck_endstops();
-
-	if (_result)
-	{
-		_progress = lcd_selftest_screen(1, _progress, 3, true, 1000);
-		_result = lcd_selfcheck_check_heater(false);
-	}
-
-	if (_result)
-	{
-		_progress = lcd_selftest_screen(2, _progress, 3, true, 2000);
-		_result = lcd_selfcheck_axis(0, X_MAX_POS);
-	}
-
-	if (_result)
-	{
-		_progress = lcd_selftest_screen(3, _progress, 3, true, 1500);
-		_result = lcd_selfcheck_axis(1, Y_MAX_POS);
-	}
-
-	if (_result)
-	{
-		current_position[X_AXIS] = current_position[X_AXIS] - 3;
-		current_position[Y_AXIS] = current_position[Y_AXIS] - 14;
-		_progress = lcd_selftest_screen(4, _progress, 3, true, 1500);
-		_result = lcd_selfcheck_axis(2, Z_MAX_POS);
-	}
-
-	if (_result)
-	{
-		_progress = lcd_selftest_screen(5, _progress, 3, true, 2000);
-		_result = lcd_selfcheck_check_heater(true);
-	}
-	if (_result)
-	{
-		_progress = lcd_selftest_screen(6, _progress, 3, true, 5000);
-	}
-	else
-	{
-		_progress = lcd_selftest_screen(7, _progress, 3, true, 5000);
-	}
-
-	lcd_implementation_clear();
-	lcd_next_update_millis = millis() + LCD_UPDATE_INTERVAL;
-
-	if (_result)
-	{
-		LCD_ALERTMESSAGERPGM(MSG_SELFTEST_OK);
-	}
-	else
-	{
-		LCD_ALERTMESSAGERPGM(MSG_SELFTEST_FAILED);
-	}
-}
-static bool lcd_selfcheck_endstops()
-{
-	bool _result = true;
-
-	if (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1 || READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1 || READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1)
-	{
-		current_position[0] = (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? current_position[0] = current_position[0] + 10 : current_position[0];
-		current_position[1] = (READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1) ? current_position[1] = current_position[1] + 10 : current_position[1];
-		current_position[2] = (READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1) ? current_position[2] = current_position[2] + 10 : current_position[2];
-	}
-	plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[0] / 60, active_extruder);
-	delay(500);
-
-	if (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1 || READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1 || READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1)
-	{
-		_result = false;
-		String  _error = String((READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? "X" : "") +
-			String((READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1) ? "Y" : "") +
-			String((READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1) ? "Z" : "");
-		lcd_selftest_error(3, _error.c_str(), "");
-	}
-	manage_heater();
-	manage_inactivity();
-	return _result;
-}
-static bool lcd_selfcheck_axis(int _axis, int _travel)
-{
-	bool _stepdone = false;
-	bool _stepresult = false;
-	int _progress = 0;
-	int _travel_done = 0;
-	int _err_endstop = 0;
-	int _lcd_refresh = 0;
-	_travel = _travel + (_travel / 10);
-
-	do {
-
-		if (_axis == 2)
-		{
-			current_position[_axis] = current_position[_axis] - 1;
-		}
-		else
-		{
-			current_position[_axis] = current_position[_axis] - 3;
-		}
-
-		plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder);
-		st_synchronize();
-
-		if (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1 || READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1 || READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1)
-		{
-			if (_axis == 0)
-			{
-				_stepresult = (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? true : false;
-				_err_endstop = (READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1) ? 1 : 2;
-				disable_x();
-			}
-			if (_axis == 1)
-			{
-				_stepresult = (READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1) ? true : false;
-				_err_endstop = (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? 0 : 2;
-				disable_y();
-			}
-			if (_axis == 2)
-			{
-				_stepresult = (READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1) ? true : false;
-				_err_endstop = (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? 0 : 1;
-				disable_z();
-			}
-			_stepdone = true;
-		}
-
-		if (_lcd_refresh < 6)
-		{
-			_lcd_refresh++;
-		}
-		else
-		{
-			_progress = lcd_selftest_screen(2 + _axis, _progress, 3, false, 0);
-			_lcd_refresh = 0;
-		}
-
-		manage_heater();
-		manage_inactivity();
-
-		delay(100);
-		(_travel_done <= _travel) ? _travel_done++ : _stepdone = true;
-
-	} while (!_stepdone);
-
-
-	current_position[_axis] = current_position[_axis] + 15;
-	plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder);
-
-	if (!_stepresult)
-	{
-		const char *_error_1;
-		const char *_error_2;
-
-		if (_axis == X_AXIS) _error_1 = "X";
-		if (_axis == Y_AXIS) _error_1 = "Y";
-		if (_axis == Z_AXIS) _error_1 = "Z";
-
-		if (_err_endstop == 0) _error_2 = "X";
-		if (_err_endstop == 1) _error_2 = "Y";
-		if (_err_endstop == 2) _error_2 = "Z";
-
-		if (_travel_done >= _travel)
-		{
-			lcd_selftest_error(5, _error_1, _error_2);
-		}
-		else
-		{
-			lcd_selftest_error(4, _error_1, _error_2);
-		}
-	}
-
-	return _stepresult;
-}
-static bool lcd_selfcheck_check_heater(bool _isbed)
-{
-	int _counter = 0;
-	int _progress = 0;
-	bool _stepresult = false;
-	bool _docycle = true;
-
-	int _checked_snapshot = (_isbed) ? degBed() : degHotend(0);
-	int _opposite_snapshot = (_isbed) ? degHotend(0) : degBed();
-	int _cycles = (_isbed) ? 120 : 30;
-
-	target_temperature[0] = (_isbed) ? 0 : 100;
-	target_temperature_bed = (_isbed) ? 100 : 0;
-	manage_heater();
-	manage_inactivity();
-
-	do {
-		_counter++;
-		(_counter < _cycles) ? _docycle = true : _docycle = false;
-
-		manage_heater();
-		manage_inactivity();
-		_progress = (_isbed) ? lcd_selftest_screen(5, _progress, 2, false, 400) : lcd_selftest_screen(1, _progress, 2, false, 400);
-
-	} while (_docycle);
-
-	target_temperature[0] = 0;
-	target_temperature_bed = 0;
-	manage_heater();
-
-	int _checked_result = (_isbed) ? degBed() - _checked_snapshot : degHotend(0) - _checked_snapshot;
-	int _opposite_result = (_isbed) ? degHotend(0) - _opposite_snapshot : degBed() - _opposite_snapshot;
-
-	if (_opposite_result < (_isbed) ? 10 : 3)
-	{
-		if (_checked_result >= (_isbed) ? 3 : 10)
-		{
-			_stepresult = true;
-		}
-		else
-		{
-			lcd_selftest_error(1, "", "");
-		}
-	}
-	else
-	{
-		lcd_selftest_error(2, "", "");
-	}
-
-	manage_heater();
-	manage_inactivity();
-	return _stepresult;
-
-}
-static void lcd_selftest_error(int _error_no, const char *_error_1, const char *_error_2)
-{
-	lcd_implementation_quick_feedback();
-
-	target_temperature[0] = 0;
-	target_temperature_bed = 0;
-	manage_heater();
-	manage_inactivity();
-
-	lcd_implementation_clear();
-
-	lcd.setCursor(0, 0);
-	lcd_printPGM(MSG_SELFTEST_ERROR);
-	lcd.setCursor(0, 1);
-	lcd_printPGM(MSG_SELFTEST_PLEASECHECK);
-
-	switch (_error_no)
-	{
-	case 1:
-		lcd.setCursor(0, 2);
-		lcd_printPGM(MSG_SELFTEST_HEATERTHERMISTOR);
-		lcd.setCursor(0, 3);
-		lcd_printPGM(MSG_SELFTEST_NOTCONNECTED);
-		break;
-	case 2:
-		lcd.setCursor(0, 2);
-		lcd_printPGM(MSG_SELFTEST_BEDHEATER);
-		lcd.setCursor(0, 3);
-		lcd_printPGM(MSG_SELFTEST_WIRINGERROR);
-		break;
-	case 3:
-		lcd.setCursor(0, 2);
-		lcd_printPGM(MSG_SELFTEST_ENDSTOPS);
-		lcd.setCursor(0, 3);
-		lcd_printPGM(MSG_SELFTEST_WIRINGERROR);
-		lcd.setCursor(17, 3);
-		lcd.print(_error_1);
-		break;
-	case 4:
-		lcd.setCursor(0, 2);
-		lcd_printPGM(MSG_SELFTEST_MOTOR);
-		lcd.setCursor(18, 2);
-		lcd.print(_error_1);
-		lcd.setCursor(0, 3);
-		lcd_printPGM(MSG_SELFTEST_ENDSTOP);
-		lcd.setCursor(18, 3);
-		lcd.print(_error_2);
-		break;
-	case 5:
-		lcd.setCursor(0, 2);
-		lcd_printPGM(MSG_SELFTEST_ENDSTOP_NOTHIT);
-		lcd.setCursor(0, 3);
-		lcd_printPGM(MSG_SELFTEST_MOTOR);
-		lcd.setCursor(18, 3);
-		lcd.print(_error_1);
-		break;
-
-	}
-
-	delay(1000);
-	lcd_implementation_quick_feedback();
-
-	do {
-		delay(100);
-		manage_heater();
-		manage_inactivity();
-	} while (!lcd_clicked());
-
-	LCD_ALERTMESSAGERPGM(MSG_SELFTEST_FAILED);
-	lcd_return_to_status();
-
-}
-static int lcd_selftest_screen(int _step, int _progress, int _progress_scale, bool _clear, int _delay)
-{
-	lcd_next_update_millis = millis() + (LCD_UPDATE_INTERVAL * 10000);
-
-	int _step_block = 0;
-	const char *_indicator = (_progress > _progress_scale) ? "-" : "|";
-
-	if (_clear) lcd_implementation_clear();
-
-
-	lcd.setCursor(0, 0);
-
-	if (_step == -1) lcd_printPGM(MSG_SELFTEST_START);
-	if (_step == 0) lcd_printPGM(MSG_SELFTEST_CHECK_ENDSTOPS);
-	if (_step == 1) lcd_printPGM(MSG_SELFTEST_CHECK_HOTEND);
-	if (_step == 2) lcd_printPGM(MSG_SELFTEST_CHECK_X);
-	if (_step == 3) lcd_printPGM(MSG_SELFTEST_CHECK_Y);
-	if (_step == 4) lcd_printPGM(MSG_SELFTEST_CHECK_Z);
-	if (_step == 5) lcd_printPGM(MSG_SELFTEST_CHECK_BED);
-	if (_step == 6) lcd_printPGM(MSG_SELFTEST_CHECK_ALLCORRECT);
-	if (_step == 7) lcd_printPGM(MSG_SELFTEST_FAILED);
-
-	lcd.setCursor(0, 1);
-	lcd.print("--------------------");
-
-	_step_block = 1;
-	lcd_selftest_screen_step(3, 9, ((_step == _step_block) ? 1 : (_step < _step_block) ? 0 : 2), "Hotend", _indicator);
-
-	_step_block = 2;
-	lcd_selftest_screen_step(2, 2, ((_step == _step_block) ? 1 : (_step < _step_block) ? 0 : 2), "X", _indicator);
-
-	_step_block = 3;
-	lcd_selftest_screen_step(2, 8, ((_step == _step_block) ? 1 : (_step < _step_block) ? 0 : 2), "Y", _indicator);
-
-	_step_block = 4;
-	lcd_selftest_screen_step(2, 14, ((_step == _step_block) ? 1 : (_step < _step_block) ? 0 : 2), "Z", _indicator);
-
-	_step_block = 5;
-	lcd_selftest_screen_step(3, 0, ((_step == _step_block) ? 1 : (_step < _step_block) ? 0 : 2), "Bed", _indicator);
-
-
-	if (_delay > 0) delay(_delay);
-	_progress++;
-
-	return (_progress > _progress_scale * 2) ? 0 : _progress;
-}
-static void lcd_selftest_screen_step(int _row, int _col, int _state, const char *_name, const char *_indicator)
-{
-	lcd.setCursor(_col, _row);
-
-	switch (_state)
-	{
-	case 1:
-		lcd.print(_name);
-		lcd.setCursor(_col + strlen(_name), _row);
-		lcd.print(":");
-		lcd.setCursor(_col + strlen(_name) + 1, _row);
-		lcd.print(_indicator);
-		break;
-	case 2:
-		lcd.print(_name);
-		lcd.setCursor(_col + strlen(_name), _row);
-		lcd.print(":");
-		lcd.setCursor(_col + strlen(_name) + 1, _row);
-		lcd.print("OK");
-		break;
-	default:
-		lcd.print(_name);
-	}
-}
-
-
-/** End of menus **/
-
-static void lcd_quick_feedback()
-{
-  lcdDrawUpdate = 2;
-  blocking_enc = millis() + 500;
-  lcd_implementation_quick_feedback();
-}
-
-/** Menu action functions **/
-static void menu_action_back(menuFunc_t data) {
-  lcd_goto_menu(data);
-}
-static void menu_action_submenu(menuFunc_t data) {
-  lcd_goto_menu(data);
-}
-static void menu_action_gcode(const char* pgcode) {
-  enquecommand_P(pgcode);
-}
-static void menu_action_setlang(unsigned char lang) {
-  lcd_set_lang(lang);
-}
-static void menu_action_function(menuFunc_t data) {
-  (*data)();
-}
-static void menu_action_sdfile(const char* filename, char* longFilename)
-{
-  char cmd[30];
-  char* c;
-  sprintf_P(cmd, PSTR("M23 %s"), filename);
-  for (c = &cmd[4]; *c; c++)
-    *c = tolower(*c);
-  enquecommand(cmd);
-  enquecommand_P(PSTR("M24"));
-  lcd_return_to_status();
-}
-static void menu_action_sddirectory(const char* filename, char* longFilename)
-{
-  card.chdir(filename);
-  encoderPosition = 0;
-}
-static void menu_action_setting_edit_bool(const char* pstr, bool* ptr)
-{
-  *ptr = !(*ptr);
-}
-static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, menuFunc_t callback)
-{
-  menu_action_setting_edit_bool(pstr, ptr);
-  (*callback)();
-}
-#endif//ULTIPANEL
-
-/** LCD API **/
-void lcd_init()
-{
-  lcd_implementation_init();
-
-#ifdef NEWPANEL
-  SET_INPUT(BTN_EN1);
-  SET_INPUT(BTN_EN2);
-  WRITE(BTN_EN1, HIGH);
-  WRITE(BTN_EN2, HIGH);
-#if BTN_ENC > 0
-  SET_INPUT(BTN_ENC);
-  WRITE(BTN_ENC, HIGH);
-#endif
-#ifdef REPRAPWORLD_KEYPAD
-  pinMode(SHIFT_CLK, OUTPUT);
-  pinMode(SHIFT_LD, OUTPUT);
-  pinMode(SHIFT_OUT, INPUT);
-  WRITE(SHIFT_OUT, HIGH);
-  WRITE(SHIFT_LD, HIGH);
-#endif
-#else  // Not NEWPANEL
-#ifdef SR_LCD_2W_NL // Non latching 2 wire shift register
-  pinMode (SR_DATA_PIN, OUTPUT);
-  pinMode (SR_CLK_PIN, OUTPUT);
-#elif defined(SHIFT_CLK)
-  pinMode(SHIFT_CLK, OUTPUT);
-  pinMode(SHIFT_LD, OUTPUT);
-  pinMode(SHIFT_EN, OUTPUT);
-  pinMode(SHIFT_OUT, INPUT);
-  WRITE(SHIFT_OUT, HIGH);
-  WRITE(SHIFT_LD, HIGH);
-  WRITE(SHIFT_EN, LOW);
-#else
-#ifdef ULTIPANEL
-#error ULTIPANEL requires an encoder
-#endif
-#endif // SR_LCD_2W_NL
-#endif//!NEWPANEL
-
-#if defined (SDSUPPORT) && defined(SDCARDDETECT) && (SDCARDDETECT > 0)
-  pinMode(SDCARDDETECT, INPUT);
-  WRITE(SDCARDDETECT, HIGH);
-  lcd_oldcardstatus = IS_SD_INSERTED;
-#endif//(SDCARDDETECT > 0)
-#ifdef LCD_HAS_SLOW_BUTTONS
-  slow_buttons = 0;
-#endif
-  lcd_buttons_update();
-#ifdef ULTIPANEL
-  encoderDiff = 0;
-#endif
-}
-
-
-
-
-//#include <avr/pgmspace.h>
-
-
-void lcd_update()
-{
-	static unsigned long timeoutToStatus = 0;
-
-
-#ifdef LCD_HAS_SLOW_BUTTONS
-  slow_buttons = lcd_implementation_read_slow_buttons(); // buttons which take too long to read in interrupt context
-#endif
-
-  lcd_buttons_update();
-
-#if (SDCARDDETECT > 0)
-  if ((IS_SD_INSERTED != lcd_oldcardstatus && lcd_detected()))
-  {
-	  lcdDrawUpdate = 2;
-	  lcd_oldcardstatus = IS_SD_INSERTED;
-	  lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
-#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
-		  currentMenu == lcd_status_screen
-#endif
-	  );
-
-	  if (lcd_oldcardstatus)
-	  {
-		  card.initsd();
-		  LCD_MESSAGERPGM(MSG_SD_INSERTED);
-	  }
-	  else
-	  {
-		  card.release();
-		  LCD_MESSAGERPGM(MSG_SD_REMOVED);
-	  }
-  }
-#endif//CARDINSERTED
-
-  if (lcd_next_update_millis < millis())
-  {
-#ifdef ULTIPANEL
-#ifdef REPRAPWORLD_KEYPAD
-	  if (REPRAPWORLD_KEYPAD_MOVE_Z_UP) {
-		  reprapworld_keypad_move_z_up();
-	  }
-	  if (REPRAPWORLD_KEYPAD_MOVE_Z_DOWN) {
-		  reprapworld_keypad_move_z_down();
-	  }
-	  if (REPRAPWORLD_KEYPAD_MOVE_X_LEFT) {
-		  reprapworld_keypad_move_x_left();
-	  }
-	  if (REPRAPWORLD_KEYPAD_MOVE_X_RIGHT) {
-		  reprapworld_keypad_move_x_right();
-	  }
-	  if (REPRAPWORLD_KEYPAD_MOVE_Y_DOWN) {
-		  reprapworld_keypad_move_y_down();
-	  }
-	  if (REPRAPWORLD_KEYPAD_MOVE_Y_UP) {
-		  reprapworld_keypad_move_y_up();
-	  }
-	  if (REPRAPWORLD_KEYPAD_MOVE_HOME) {
-		  reprapworld_keypad_move_home();
-	  }
-#endif
-	  if (abs(encoderDiff) >= ENCODER_PULSES_PER_STEP)
-	  {
-		  lcdDrawUpdate = 1;
-		  encoderPosition += encoderDiff / ENCODER_PULSES_PER_STEP;
-		  encoderDiff = 0;
-		  timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS;
-	  }
-	  if (LCD_CLICKED)
-		  timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS;
-#endif//ULTIPANEL
-
-#ifdef DOGLCD        // Changes due to different driver architecture of the DOGM display
-	  blink++;     // Variable for fan animation and alive dot
-	  u8g.firstPage();
-	  do
-	  {
-		  u8g.setFont(u8g_font_6x10_marlin);
-		  u8g.setPrintPos(125, 0);
-		  if (blink % 2) u8g.setColorIndex(1); else u8g.setColorIndex(0); // Set color for the alive dot
-		  u8g.drawPixel(127, 63); // draw alive dot
-		  u8g.setColorIndex(1); // black on white
-		  (*currentMenu)();
-		  if (!lcdDrawUpdate)  break; // Terminate display update, when nothing new to draw. This must be done before the last dogm.next()
-	  } while (u8g.nextPage());
-#else
-	  (*currentMenu)();
-#endif
-
-#ifdef LCD_HAS_STATUS_INDICATORS
-	  lcd_implementation_update_indicators();
-#endif
-
-#ifdef ULTIPANEL
-	  if (timeoutToStatus < millis() && currentMenu != lcd_status_screen)
-	  {
-		  lcd_return_to_status();
-		  lcdDrawUpdate = 2;
-	  }
-#endif//ULTIPANEL
-	  if (lcdDrawUpdate == 2) lcd_implementation_clear();
-	  if (lcdDrawUpdate) lcdDrawUpdate--;
-	  lcd_next_update_millis = millis() + LCD_UPDATE_INTERVAL;
-	  }
-   
-}
-
-void lcd_ignore_click(bool b)
-{
-  ignore_click = b;
-  wait_for_unclick = false;
-}
-
-void lcd_finishstatus() {
-  int len = strlen(lcd_status_message);
-  if (len > 0) {
-    while (len < LCD_WIDTH) {
-      lcd_status_message[len++] = ' ';
-    }
-  }
-  lcd_status_message[LCD_WIDTH] = '\0';
-#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
-#if PROGRESS_MSG_EXPIRE > 0
-  messageTick =
-#endif
-    progressBarTick = millis();
-#endif
-  lcdDrawUpdate = 2;
-
-#ifdef FILAMENT_LCD_DISPLAY
-  message_millis = millis();  //get status message to show up for a while
-#endif
-}
-void lcd_setstatus(const char* message)
-{
-  if (lcd_status_message_level > 0)
-    return;
-  strncpy(lcd_status_message, message, LCD_WIDTH);
-  lcd_finishstatus();
-}
-void lcd_setstatuspgm(const char* message)
-{
-  if (lcd_status_message_level > 0)
-    return;
-  strncpy_P(lcd_status_message, message, LCD_WIDTH);
-  lcd_finishstatus();
-}
-void lcd_setalertstatuspgm(const char* message)
-{
-  lcd_setstatuspgm(message);
-  lcd_status_message_level = 1;
-#ifdef ULTIPANEL
-  lcd_return_to_status();
-#endif//ULTIPANEL
-}
-void lcd_reset_alert_level()
-{
-  lcd_status_message_level = 0;
-}
-
-#ifdef DOGLCD
-void lcd_setcontrast(uint8_t value)
-{
-  lcd_contrast = value & 63;
-  u8g.setContrast(lcd_contrast);
-}
-#endif
-
-#ifdef ULTIPANEL
-/* Warning: This function is called from interrupt context */
-void lcd_buttons_update()
-{
-#ifdef NEWPANEL
-  uint8_t newbutton = 0;
-  if (READ(BTN_EN1) == 0)  newbutton |= EN_A;
-  if (READ(BTN_EN2) == 0)  newbutton |= EN_B;
-#if BTN_ENC > 0
-  if ((blocking_enc < millis()) && (READ(BTN_ENC) == 0))
-    newbutton |= EN_C;
-#endif
-  buttons = newbutton;
-#ifdef LCD_HAS_SLOW_BUTTONS
-  buttons |= slow_buttons;
-#endif
-#ifdef REPRAPWORLD_KEYPAD
-  // for the reprapworld_keypad
-  uint8_t newbutton_reprapworld_keypad = 0;
-  WRITE(SHIFT_LD, LOW);
-  WRITE(SHIFT_LD, HIGH);
-  for (int8_t i = 0; i < 8; i++) {
-    newbutton_reprapworld_keypad = newbutton_reprapworld_keypad >> 1;
-    if (READ(SHIFT_OUT))
-      newbutton_reprapworld_keypad |= (1 << 7);
-    WRITE(SHIFT_CLK, HIGH);
-    WRITE(SHIFT_CLK, LOW);
-  }
-  buttons_reprapworld_keypad = ~newbutton_reprapworld_keypad; //invert it, because a pressed switch produces a logical 0
-#endif
-#else   //read it from the shift register
-  uint8_t newbutton = 0;
-  WRITE(SHIFT_LD, LOW);
-  WRITE(SHIFT_LD, HIGH);
-  unsigned char tmp_buttons = 0;
-  for (int8_t i = 0; i < 8; i++)
-  {
-    newbutton = newbutton >> 1;
-    if (READ(SHIFT_OUT))
-      newbutton |= (1 << 7);
-    WRITE(SHIFT_CLK, HIGH);
-    WRITE(SHIFT_CLK, LOW);
-  }
-  buttons = ~newbutton; //invert it, because a pressed switch produces a logical 0
-#endif//!NEWPANEL
-
-  //manage encoder rotation
-  uint8_t enc = 0;
-  if (buttons & EN_A) enc |= B01;
-  if (buttons & EN_B) enc |= B10;
-  if (enc != lastEncoderBits)
-  {
-    switch (enc)
-    {
-      case encrot0:
-        if (lastEncoderBits == encrot3)
-          encoderDiff++;
-        else if (lastEncoderBits == encrot1)
-          encoderDiff--;
-        break;
-      case encrot1:
-        if (lastEncoderBits == encrot0)
-          encoderDiff++;
-        else if (lastEncoderBits == encrot2)
-          encoderDiff--;
-        break;
-      case encrot2:
-        if (lastEncoderBits == encrot1)
-          encoderDiff++;
-        else if (lastEncoderBits == encrot3)
-          encoderDiff--;
-        break;
-      case encrot3:
-        if (lastEncoderBits == encrot2)
-          encoderDiff++;
-        else if (lastEncoderBits == encrot0)
-          encoderDiff--;
-        break;
-    }
-  }
-  lastEncoderBits = enc;
-}
-
-bool lcd_detected(void)
-{
-#if (defined(LCD_I2C_TYPE_MCP23017) || defined(LCD_I2C_TYPE_MCP23008)) && defined(DETECT_DEVICE)
-  return lcd.LcdDetected() == 1;
-#else
-  return true;
-#endif
-}
-
-void lcd_buzz(long duration, uint16_t freq)
-{
-#ifdef LCD_USE_I2C_BUZZER
-  lcd.buzz(duration, freq);
-#endif
-}
-
-bool lcd_clicked()
-{
-  return LCD_CLICKED;
-}
-#endif//ULTIPANEL
-
-/********************************/
-/** Float conversion utilities **/
-/********************************/
-//  convert float to string with +123.4 format
-char conv[8];
-char *ftostr3(const float &x)
-{
-  return itostr3((int)x);
-}
-
-char *itostr2(const uint8_t &x)
-{
-  //sprintf(conv,"%5.1f",x);
-  int xx = x;
-  conv[0] = (xx / 10) % 10 + '0';
-  conv[1] = (xx) % 10 + '0';
-  conv[2] = 0;
-  return conv;
-}
-
-// Convert float to string with 123.4 format, dropping sign
-char *ftostr31(const float &x)
-{
-  int xx = x * 10;
-  conv[0] = (xx >= 0) ? '+' : '-';
-  xx = abs(xx);
-  conv[1] = (xx / 1000) % 10 + '0';
-  conv[2] = (xx / 100) % 10 + '0';
-  conv[3] = (xx / 10) % 10 + '0';
-  conv[4] = '.';
-  conv[5] = (xx) % 10 + '0';
-  conv[6] = 0;
-  return conv;
-}
-
-// Convert float to string with 123.4 format
-char *ftostr31ns(const float &x)
-{
-  int xx = x * 10;
-  //conv[0]=(xx>=0)?'+':'-';
-  xx = abs(xx);
-  conv[0] = (xx / 1000) % 10 + '0';
-  conv[1] = (xx / 100) % 10 + '0';
-  conv[2] = (xx / 10) % 10 + '0';
-  conv[3] = '.';
-  conv[4] = (xx) % 10 + '0';
-  conv[5] = 0;
-  return conv;
-}
-
-char *ftostr32(const float &x)
-{
-  long xx = x * 100;
-  if (xx >= 0)
-    conv[0] = (xx / 10000) % 10 + '0';
-  else
-    conv[0] = '-';
-  xx = abs(xx);
-  conv[1] = (xx / 1000) % 10 + '0';
-  conv[2] = (xx / 100) % 10 + '0';
-  conv[3] = '.';
-  conv[4] = (xx / 10) % 10 + '0';
-  conv[5] = (xx) % 10 + '0';
-  conv[6] = 0;
-  return conv;
-}
-
-//// Convert float to rj string with 123.45 format
-char *ftostr32ns(const float &x) {
-	long xx = abs(x);
-	conv[0] = xx >= 10000 ? (xx / 10000) % 10 + '0' : ' ';
-	conv[1] = xx >= 1000 ? (xx / 1000) % 10 + '0' : ' ';
-	conv[2] = xx >= 100 ? (xx / 100) % 10 + '0' : '0';
-	conv[3] = '.';
-	conv[4] = (xx / 10) % 10 + '0';
-	conv[5] = xx % 10 + '0';
-	return conv;
-}
-
-
-// Convert float to string with 1.234 format
-char *ftostr43(const float &x)
-{
-  long xx = x * 1000;
-  if (xx >= 0)
-    conv[0] = (xx / 1000) % 10 + '0';
-  else
-    conv[0] = '-';
-  xx = abs(xx);
-  conv[1] = '.';
-  conv[2] = (xx / 100) % 10 + '0';
-  conv[3] = (xx / 10) % 10 + '0';
-  conv[4] = (xx) % 10 + '0';
-  conv[5] = 0;
-  return conv;
-}
-
-//Float to string with 1.23 format
-char *ftostr12ns(const float &x)
-{
-  long xx = x * 100;
-
-  xx = abs(xx);
-  conv[0] = (xx / 100) % 10 + '0';
-  conv[1] = '.';
-  conv[2] = (xx / 10) % 10 + '0';
-  conv[3] = (xx) % 10 + '0';
-  conv[4] = 0;
-  return conv;
-}
-
-//Float to string with 1.234 format
-char *ftostr13ns(const float &x)
-{
-    long xx = x * 1000;
-    if (xx >= 0)
-        conv[0] = ' ';
-    else
-        conv[0] = '-';
-    xx = abs(xx);
-    conv[1] = (xx / 1000) % 10 + '0';
-    conv[2] = '.';
-    conv[3] = (xx / 100) % 10 + '0';
-    conv[4] = (xx / 10) % 10 + '0';
-    conv[5] = (xx) % 10 + '0';
-    conv[6] = 0;
-    return conv;
-}
-
-//  convert float to space-padded string with -_23.4_ format
-char *ftostr32sp(const float &x) {
-  long xx = abs(x * 100);
-  uint8_t dig;
-
-  if (x < 0) { // negative val = -_0
-    conv[0] = '-';
-    dig = (xx / 1000) % 10;
-    conv[1] = dig ? '0' + dig : ' ';
-  }
-  else { // positive val = __0
-    dig = (xx / 10000) % 10;
-    if (dig) {
-      conv[0] = '0' + dig;
-      conv[1] = '0' + (xx / 1000) % 10;
-    }
-    else {
-      conv[0] = ' ';
-      dig = (xx / 1000) % 10;
-      conv[1] = dig ? '0' + dig : ' ';
-    }
-  }
-
-  conv[2] = '0' + (xx / 100) % 10; // lsd always
-
-  dig = xx % 10;
-  if (dig) { // 2 decimal places
-    conv[5] = '0' + dig;
-    conv[4] = '0' + (xx / 10) % 10;
-    conv[3] = '.';
-  }
-  else { // 1 or 0 decimal place
-    dig = (xx / 10) % 10;
-    if (dig) {
-      conv[4] = '0' + dig;
-      conv[3] = '.';
-    }
-    else {
-      conv[3] = conv[4] = ' ';
-    }
-    conv[5] = ' ';
-  }
-  conv[6] = '\0';
-  return conv;
-}
-
-char *itostr31(const int &xx)
-{
-  conv[0] = (xx >= 0) ? '+' : '-';
-  conv[1] = (xx / 1000) % 10 + '0';
-  conv[2] = (xx / 100) % 10 + '0';
-  conv[3] = (xx / 10) % 10 + '0';
-  conv[4] = '.';
-  conv[5] = (xx) % 10 + '0';
-  conv[6] = 0;
-  return conv;
-}
-
-// Convert int to rj string with 123 or -12 format
-char *itostr3(const int &x)
-{
-  int xx = x;
-  if (xx < 0) {
-    conv[0] = '-';
-    xx = -xx;
-  } else if (xx >= 100)
-    conv[0] = (xx / 100) % 10 + '0';
-  else
-    conv[0] = ' ';
-  if (xx >= 10)
-    conv[1] = (xx / 10) % 10 + '0';
-  else
-    conv[1] = ' ';
-  conv[2] = (xx) % 10 + '0';
-  conv[3] = 0;
-  return conv;
-}
-
-// Convert int to lj string with 123 format
-char *itostr3left(const int &xx)
-{
-  if (xx >= 100)
-  {
-    conv[0] = (xx / 100) % 10 + '0';
-    conv[1] = (xx / 10) % 10 + '0';
-    conv[2] = (xx) % 10 + '0';
-    conv[3] = 0;
-  }
-  else if (xx >= 10)
-  {
-    conv[0] = (xx / 10) % 10 + '0';
-    conv[1] = (xx) % 10 + '0';
-    conv[2] = 0;
-  }
-  else
-  {
-    conv[0] = (xx) % 10 + '0';
-    conv[1] = 0;
-  }
-  return conv;
-}
-
-// Convert int to rj string with 1234 format
-char *itostr4(const int &xx) {
-  conv[0] = xx >= 1000 ? (xx / 1000) % 10 + '0' : ' ';
-  conv[1] = xx >= 100 ? (xx / 100) % 10 + '0' : ' ';
-  conv[2] = xx >= 10 ? (xx / 10) % 10 + '0' : ' ';
-  conv[3] = xx % 10 + '0';
-  conv[4] = 0;
-  return conv;
-}
-
-// Convert float to rj string with 12345 format
-char *ftostr5(const float &x) {
-  long xx = abs(x);
-  conv[0] = xx >= 10000 ? (xx / 10000) % 10 + '0' : ' ';
-  conv[1] = xx >= 1000 ? (xx / 1000) % 10 + '0' : ' ';
-  conv[2] = xx >= 100 ? (xx / 100) % 10 + '0' : ' ';
-  conv[3] = xx >= 10 ? (xx / 10) % 10 + '0' : ' ';
-  conv[4] = xx % 10 + '0';
-  conv[5] = 0;
-  return conv;
-}
-
-// Convert float to string with +1234.5 format
-char *ftostr51(const float &x)
-{
-  long xx = x * 10;
-  conv[0] = (xx >= 0) ? '+' : '-';
-  xx = abs(xx);
-  conv[1] = (xx / 10000) % 10 + '0';
-  conv[2] = (xx / 1000) % 10 + '0';
-  conv[3] = (xx / 100) % 10 + '0';
-  conv[4] = (xx / 10) % 10 + '0';
-  conv[5] = '.';
-  conv[6] = (xx) % 10 + '0';
-  conv[7] = 0;
-  return conv;
-}
-
-// Convert float to string with +123.45 format
-char *ftostr52(const float &x)
-{
-  long xx = x * 100;
-  conv[0] = (xx >= 0) ? '+' : '-';
-  xx = abs(xx);
-  conv[1] = (xx / 10000) % 10 + '0';
-  conv[2] = (xx / 1000) % 10 + '0';
-  conv[3] = (xx / 100) % 10 + '0';
-  conv[4] = '.';
-  conv[5] = (xx / 10) % 10 + '0';
-  conv[6] = (xx) % 10 + '0';
-  conv[7] = 0;
-  return conv;
-}
-
-// Callback for after editing PID i value
-// grab the PID i value out of the temp variable; scale it; then update the PID driver
-void copy_and_scalePID_i()
-{
-#ifdef PIDTEMP
-  Ki = scalePID_i(raw_Ki);
-  updatePID();
-#endif
-}
-
-// Callback for after editing PID d value
-// grab the PID d value out of the temp variable; scale it; then update the PID driver
-void copy_and_scalePID_d()
-{
-#ifdef PIDTEMP
-  Kd = scalePID_d(raw_Kd);
-  updatePID();
-#endif
-}
-
+#include "temperature.h"
+#include "ultralcd.h"
+#ifdef ULTRA_LCD
+#include "Marlin.h"
+#include "language.h"
+#include "cardreader.h"
+#include "temperature.h"
+#include "stepper.h"
+#include "ConfigurationStore.h"
+#include <string.h>
+//#include "Configuration.h"
+
+
+
+#define _STRINGIFY(s) #s
+
+
+int8_t encoderDiff; /* encoderDiff is updated from interrupt context and added to encoderPosition every LCD update */
+
+extern int lcd_change_fil_state;
+
+int babystepMem[3];
+float babystepMemMM[3];
+
+union Data
+{
+  byte b[2];
+  int value;
+};
+
+int8_t ReInitLCD = 0;
+
+int8_t SDscrool = 0;
+
+int8_t SilentModeMenu = 0;
+
+int lcd_commands_type=0;
+int lcd_commands_step=0;
+bool isPrintPaused = false;
+
+/* Configuration settings */
+int plaPreheatHotendTemp;
+int plaPreheatHPBTemp;
+int plaPreheatFanSpeed;
+
+int absPreheatHotendTemp;
+int absPreheatHPBTemp;
+int absPreheatFanSpeed;
+
+int ppPreheatHotendTemp = PP_PREHEAT_HOTEND_TEMP;
+int ppPreheatHPBTemp = PP_PREHEAT_HPB_TEMP;
+int ppPreheatFanSpeed = PP_PREHEAT_FAN_SPEED;
+
+int petPreheatHotendTemp = PET_PREHEAT_HOTEND_TEMP;
+int petPreheatHPBTemp = PET_PREHEAT_HPB_TEMP;
+int petPreheatFanSpeed = PET_PREHEAT_FAN_SPEED;
+
+int hipsPreheatHotendTemp = HIPS_PREHEAT_HOTEND_TEMP;
+int hipsPreheatHPBTemp = HIPS_PREHEAT_HPB_TEMP;
+int hipsPreheatFanSpeed = HIPS_PREHEAT_FAN_SPEED;
+
+int flexPreheatHotendTemp = FLEX_PREHEAT_HOTEND_TEMP;
+int flexPreheatHPBTemp = FLEX_PREHEAT_HPB_TEMP;
+int flexPreheatFanSpeed = FLEX_PREHEAT_FAN_SPEED;
+
+
+
+#ifdef FILAMENT_LCD_DISPLAY
+unsigned long message_millis = 0;
+#endif
+
+#ifdef ULTIPANEL
+static float manual_feedrate[] = MANUAL_FEEDRATE;
+#endif // ULTIPANEL
+
+/* !Configuration settings */
+
+//Function pointer to menu functions.
+typedef void (*menuFunc_t)();
+
+uint8_t lcd_status_message_level;
+char lcd_status_message[LCD_WIDTH + 1] = ""; //////WELCOME!
+unsigned char firstrun = 1;
+
+#ifdef DOGLCD
+#include "dogm_lcd_implementation.h"
+#else
+#include "ultralcd_implementation_hitachi_HD44780.h"
+#endif
+
+/** forward declarations **/
+
+void copy_and_scalePID_i();
+void copy_and_scalePID_d();
+
+/* Different menus */
+static void lcd_status_screen();
+#ifdef ULTIPANEL
+extern bool powersupply;
+static void lcd_main_menu();
+static void lcd_tune_menu();
+static void lcd_prepare_menu();
+static void lcd_move_menu();
+static void lcd_control_menu();
+static void lcd_settings_menu();
+static void lcd_language_menu();
+static void lcd_control_temperature_menu();
+static void lcd_control_temperature_preheat_pla_settings_menu();
+static void lcd_control_temperature_preheat_abs_settings_menu();
+static void lcd_control_motion_menu();
+static void lcd_control_volumetric_menu();
+
+#ifdef DOGLCD
+static void lcd_set_contrast();
+#endif
+static void lcd_control_retract_menu();
+static void lcd_sdcard_menu();
+
+#ifdef DELTA_CALIBRATION_MENU
+static void lcd_delta_calibrate_menu();
+#endif // DELTA_CALIBRATION_MENU
+
+static void lcd_quick_feedback();//Cause an LCD refresh, and give the user visual or audible feedback that something has happened
+
+/* Different types of actions that can be used in menu items. */
+static void menu_action_back(menuFunc_t data);
+static void menu_action_submenu(menuFunc_t data);
+static void menu_action_gcode(const char* pgcode);
+static void menu_action_function(menuFunc_t data);
+static void menu_action_setlang(unsigned char lang);
+static void menu_action_sdfile(const char* filename, char* longFilename);
+static void menu_action_sddirectory(const char* filename, char* longFilename);
+static void menu_action_setting_edit_bool(const char* pstr, bool* ptr);
+static void menu_action_setting_edit_int3(const char* pstr, int* ptr, int minValue, int maxValue);
+static void menu_action_setting_edit_float3(const char* pstr, float* ptr, float minValue, float maxValue);
+static void menu_action_setting_edit_float32(const char* pstr, float* ptr, float minValue, float maxValue);
+static void menu_action_setting_edit_float43(const char* pstr, float* ptr, float minValue, float maxValue);
+static void menu_action_setting_edit_float5(const char* pstr, float* ptr, float minValue, float maxValue);
+static void menu_action_setting_edit_float51(const char* pstr, float* ptr, float minValue, float maxValue);
+static void menu_action_setting_edit_float52(const char* pstr, float* ptr, float minValue, float maxValue);
+static void menu_action_setting_edit_long5(const char* pstr, unsigned long* ptr, unsigned long minValue, unsigned long maxValue);
+static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, menuFunc_t callbackFunc);
+static void menu_action_setting_edit_callback_int3(const char* pstr, int* ptr, int minValue, int maxValue, menuFunc_t callbackFunc);
+static void menu_action_setting_edit_callback_float3(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
+static void menu_action_setting_edit_callback_float32(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
+static void menu_action_setting_edit_callback_float43(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
+static void menu_action_setting_edit_callback_float5(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
+static void menu_action_setting_edit_callback_float51(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
+static void menu_action_setting_edit_callback_float52(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
+static void menu_action_setting_edit_callback_long5(const char* pstr, unsigned long* ptr, unsigned long minValue, unsigned long maxValue, menuFunc_t callbackFunc);
+
+#define ENCODER_FEEDRATE_DEADZONE 10
+
+#if !defined(LCD_I2C_VIKI)
+#ifndef ENCODER_STEPS_PER_MENU_ITEM
+#define ENCODER_STEPS_PER_MENU_ITEM 5
+#endif
+#ifndef ENCODER_PULSES_PER_STEP
+#define ENCODER_PULSES_PER_STEP 1
+#endif
+#else
+#ifndef ENCODER_STEPS_PER_MENU_ITEM
+#define ENCODER_STEPS_PER_MENU_ITEM 2 // VIKI LCD rotary encoder uses a different number of steps per rotation
+#endif
+#ifndef ENCODER_PULSES_PER_STEP
+#define ENCODER_PULSES_PER_STEP 1
+#endif
+#endif
+
+
+/* Helper macros for menus */
+#define START_MENU() do { \
+    if (encoderPosition > 0x8000) encoderPosition = 0; \
+    if (encoderPosition / ENCODER_STEPS_PER_MENU_ITEM < currentMenuViewOffset) currentMenuViewOffset = encoderPosition / ENCODER_STEPS_PER_MENU_ITEM;\
+    uint8_t _lineNr = currentMenuViewOffset, _menuItemNr; \
+    bool wasClicked = LCD_CLICKED;\
+    for(uint8_t _drawLineNr = 0; _drawLineNr < LCD_HEIGHT; _drawLineNr++, _lineNr++) { \
+      _menuItemNr = 0;
+
+#define MENU_ITEM(type, label, args...) do { \
+    if (_menuItemNr == _lineNr) { \
+      if (lcdDrawUpdate) { \
+        const char* _label_pstr = (label); \
+        if ((encoderPosition / ENCODER_STEPS_PER_MENU_ITEM) == _menuItemNr) { \
+          lcd_implementation_drawmenu_ ## type ## _selected (_drawLineNr, _label_pstr , ## args ); \
+        }else{\
+          lcd_implementation_drawmenu_ ## type (_drawLineNr, _label_pstr , ## args ); \
+        }\
+      }\
+      if (wasClicked && (encoderPosition / ENCODER_STEPS_PER_MENU_ITEM) == _menuItemNr) {\
+        lcd_quick_feedback(); \
+        menu_action_ ## type ( args ); \
+        return;\
+      }\
+    }\
+    _menuItemNr++;\
+  } while(0)
+
+#define MENU_ITEM_DUMMY() do { _menuItemNr++; } while(0)
+#define MENU_ITEM_EDIT(type, label, args...) MENU_ITEM(setting_edit_ ## type, label, (label) , ## args )
+#define MENU_ITEM_EDIT_CALLBACK(type, label, args...) MENU_ITEM(setting_edit_callback_ ## type, label, (label) , ## args )
+#define END_MENU() \
+  if (encoderPosition / ENCODER_STEPS_PER_MENU_ITEM >= _menuItemNr) encoderPosition = _menuItemNr * ENCODER_STEPS_PER_MENU_ITEM - 1; \
+  if ((uint8_t)(encoderPosition / ENCODER_STEPS_PER_MENU_ITEM) >= currentMenuViewOffset + LCD_HEIGHT) { currentMenuViewOffset = (encoderPosition / ENCODER_STEPS_PER_MENU_ITEM) - LCD_HEIGHT + 1; lcdDrawUpdate = 1; _lineNr = currentMenuViewOffset - 1; _drawLineNr = -1; } \
+  } } while(0)
+
+/** Used variables to keep track of the menu */
+#ifndef REPRAPWORLD_KEYPAD
+volatile uint8_t buttons;//Contains the bits of the currently pressed buttons.
+#else
+volatile uint8_t buttons_reprapworld_keypad; // to store the reprapworld_keypad shift register values
+#endif
+#ifdef LCD_HAS_SLOW_BUTTONS
+volatile uint8_t slow_buttons;//Contains the bits of the currently pressed buttons.
+#endif
+uint8_t currentMenuViewOffset;              /* scroll offset in the current menu */
+uint32_t blocking_enc;
+uint8_t lastEncoderBits;
+uint32_t encoderPosition;
+#if (SDCARDDETECT > 0)
+bool lcd_oldcardstatus;
+#endif
+#endif //ULTIPANEL
+
+menuFunc_t currentMenu = lcd_status_screen; /* function pointer to the currently active menu */
+uint32_t lcd_next_update_millis;
+uint8_t lcd_status_update_delay;
+bool ignore_click = false;
+bool wait_for_unclick;
+uint8_t lcdDrawUpdate = 2;                  /* Set to none-zero when the LCD needs to draw, decreased after every draw. Set to 2 in LCD routines so the LCD gets at least 1 full redraw (first redraw is partial) */
+
+//prevMenu and prevEncoderPosition are used to store the previous menu location when editing settings.
+menuFunc_t prevMenu = NULL;
+uint16_t prevEncoderPosition;
+//Variables used when editing values.
+const char* editLabel;
+void* editValue;
+int32_t minEditValue, maxEditValue;
+menuFunc_t callbackFunc;
+
+// place-holders for Ki and Kd edits
+float raw_Ki, raw_Kd;
+
+static void lcd_goto_menu(menuFunc_t menu, const uint32_t encoder = 0, const bool feedback = true) {
+  if (currentMenu != menu) {
+    currentMenu = menu;
+    encoderPosition = encoder;
+    if (feedback) lcd_quick_feedback();
+
+    // For LCD_PROGRESS_BAR re-initialize the custom characters
+#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
+    lcd_set_custom_characters(menu == lcd_status_screen);
+#endif
+  }
+}
+
+/* Main status screen. It's up to the implementation specific part to show what is needed. As this is very display dependent */
+/*
+extern char langbuffer[];
+void lcd_printPGM(const char *s1) {
+  strncpy_P(langbuffer,s1,LCD_WIDTH);
+  lcd.print(langbuffer);
+}
+*/
+unsigned char langsel;
+
+void set_language_from_EEPROM() {
+  unsigned char eep = eeprom_read_byte((unsigned char*)EEPROM_LANG);
+  if (eep < LANG_NUM)
+  {
+    lang_selected = eep;
+    langsel = 0;
+  }
+  else
+  {
+    lang_selected = 1;
+    langsel = 1;
+  }
+}
+
+void lcd_mylang();
+static void lcd_status_screen()
+{
+	
+  if (firstrun == 1) 
+  {
+    firstrun = 0;
+    set_language_from_EEPROM();
+    strncpy_P(lcd_status_message, WELCOME_MSG, LCD_WIDTH);
+	
+	if (eeprom_read_byte((uint8_t *)EEPROM_TOTALTIME) == 255 && eeprom_read_byte((uint8_t *)EEPROM_TOTALTIME + 1) == 255 && eeprom_read_byte((uint8_t *)EEPROM_TOTALTIME + 2) == 255 && eeprom_read_byte((uint8_t *)EEPROM_TOTALTIME + 3) == 255)
+	{
+		eeprom_update_dword((uint32_t *)EEPROM_TOTALTIME, 0);
+		eeprom_update_dword((uint32_t *)EEPROM_FILAMENTUSED, 0);
+	}
+	
+	if (langsel) {
+      //strncpy_P(lcd_status_message, PSTR(">>>>>>>>>>>> PRESS v"), LCD_WIDTH);
+      lcd_mylang();
+    }
+  }
+
+  
+  if (lcd_status_update_delay)
+    lcd_status_update_delay--;
+  else
+    lcdDrawUpdate = 1;
+  if (lcdDrawUpdate)
+  {
+    ReInitLCD++;
+
+
+    if (ReInitLCD == 30) {
+      lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
+#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
+        currentMenu == lcd_status_screen
+#endif
+      );
+      ReInitLCD = 0 ;
+    } else {
+
+      if ((ReInitLCD % 10) == 0) {
+        //lcd_implementation_nodisplay();
+        lcd_implementation_init_noclear( // to maybe revive the LCD if static electricity killed it.
+#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
+          currentMenu == lcd_status_screen
+#endif
+        );
+
+      }
+
+    }
+
+
+    //lcd_implementation_display();
+    lcd_implementation_status_screen();
+    //lcd_implementation_clear();
+
+
+
+
+
+
+
+    lcd_status_update_delay = 10;   /* redraw the main screen every second. This is easier then trying keep track of all things that change on the screen */
+	if (lcd_commands_type != 0)
+	{
+		lcd_commands();
+	}
+	
+
+  }
+#ifdef ULTIPANEL
+
+  bool current_click = LCD_CLICKED;
+
+  if (ignore_click) {
+    if (wait_for_unclick) {
+      if (!current_click) {
+        ignore_click = wait_for_unclick = false;
+      }
+      else {
+        current_click = false;
+      }
+    }
+    else if (current_click) {
+      lcd_quick_feedback();
+      wait_for_unclick = true;
+      current_click = false;
+    }
+  }
+
+
+  //if (--langsel ==0) {langsel=1;current_click=true;}
+
+  if (current_click)
+  {
+
+    lcd_goto_menu(lcd_main_menu);
+    lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
+#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
+      currentMenu == lcd_status_screen
+#endif
+    );
+#ifdef FILAMENT_LCD_DISPLAY
+    message_millis = millis();  // get status message to show up for a while
+#endif
+  }
+
+#ifdef ULTIPANEL_FEEDMULTIPLY
+  // Dead zone at 100% feedrate
+  if ((feedmultiply < 100 && (feedmultiply + int(encoderPosition)) > 100) ||
+      (feedmultiply > 100 && (feedmultiply + int(encoderPosition)) < 100))
+  {
+    encoderPosition = 0;
+    feedmultiply = 100;
+  }
+
+  if (feedmultiply == 100 && int(encoderPosition) > ENCODER_FEEDRATE_DEADZONE)
+  {
+    feedmultiply += int(encoderPosition) - ENCODER_FEEDRATE_DEADZONE;
+    encoderPosition = 0;
+  }
+  else if (feedmultiply == 100 && int(encoderPosition) < -ENCODER_FEEDRATE_DEADZONE)
+  {
+    feedmultiply += int(encoderPosition) + ENCODER_FEEDRATE_DEADZONE;
+    encoderPosition = 0;
+  }
+  else if (feedmultiply != 100)
+  {
+    feedmultiply += int(encoderPosition);
+    encoderPosition = 0;
+  }
+#endif //ULTIPANEL_FEEDMULTIPLY
+
+  if (feedmultiply < 10)
+    feedmultiply = 10;
+  else if (feedmultiply > 999)
+    feedmultiply = 999;
+#endif //ULTIPANEL
+}
+
+#ifdef ULTIPANEL
+
+void lcd_commands()
+{
+	if (lcd_commands_type == 1)   //// load filament sequence
+	{
+		if (lcd_commands_step == 0) { lcd_commands_step = 5; custom_message = true; }
+			if (lcd_commands_step == 1 && !blocks_queued())
+			{
+				lcd_commands_step = 0;
+				lcd_commands_type = 0;
+				lcd_setstatuspgm(WELCOME_MSG);
+				disable_z();
+				custom_message = false;
+				custom_message_type = 0;
+			}
+			if (lcd_commands_step == 2 && !blocks_queued())
+			{
+				lcd_setstatuspgm(MSG_LOADING_FILAMENT);
+				enquecommand_P(PSTR(LOAD_FILAMENT_2));
+				lcd_commands_step = 1;
+			}
+			if (lcd_commands_step == 3 && !blocks_queued())
+			{
+				enquecommand_P(PSTR(LOAD_FILAMENT_1));
+				lcd_commands_step = 2;
+			}
+			if (lcd_commands_step == 4 && !blocks_queued())
+			{
+				lcd_setstatuspgm(MSG_INSERT_FILAMENT);
+				enquecommand_P(PSTR(LOAD_FILAMENT_0));
+				lcd_commands_step = 3;
+			}
+			if (lcd_commands_step == 5 && !blocks_queued())
+			{
+				lcd_setstatuspgm(MSG_PLEASE_WAIT);
+				enable_z();
+				custom_message = true;
+				custom_message_type = 2;
+				lcd_commands_step = 4;
+			}
+
+ 
+		
+		
+		
+	}
+
+	if (lcd_commands_type == 2)   /// stop print
+	{
+
+		if (lcd_commands_step == 0) { lcd_commands_step = 6; custom_message = true;	}
+
+		if (lcd_commands_step == 1 && !blocks_queued())
+		{
+			lcd_commands_step = 0;
+			lcd_commands_type = 0;
+			lcd_setstatuspgm(WELCOME_MSG);
+			custom_message = false;
+		}
+		if (lcd_commands_step == 2 && !blocks_queued())
+		{
+			setTargetBed(0);
+			setTargetHotend(0, 0);
+			setTargetHotend(0, 1);
+			setTargetHotend(0, 2);
+			manage_heater();
+			lcd_setstatuspgm(WELCOME_MSG);
+			cancel_heatup = false;
+			lcd_commands_step = 1;
+		}
+		if (lcd_commands_step == 3 && !blocks_queued())
+		{
+			enquecommand_P(PSTR("M84"));
+			autotempShutdown();
+			lcd_commands_step = 2;
+		}
+		if (lcd_commands_step == 4 && !blocks_queued())
+		{
+			enquecommand_P(PSTR("G90"));
+			#ifdef X_CANCEL_POS 
+			enquecommand_P(PSTR("G1 X"  STRINGIFY(X_CANCEL_POS) " Y" STRINGIFY(Y_CANCEL_POS) " E0 F7000"));
+			#else
+			enquecommand_P(PSTR("G1 X50 Y" STRINGIFY(Y_MAX_POS) " E0 F7000"));
+			#endif
+			lcd_ignore_click(false);
+			lcd_commands_step = 3;
+		}
+		if (lcd_commands_step == 5 && !blocks_queued())
+		{
+			lcd_setstatuspgm(MSG_PRINT_ABORTED);
+			enquecommand_P(PSTR("G91"));
+			enquecommand_P(PSTR("G1 Z15 F1500"));
+			lcd_commands_step = 4;
+		}
+		if (lcd_commands_step == 6 && !blocks_queued())
+		{
+			lcd_setstatuspgm(MSG_PRINT_ABORTED);
+			cancel_heatup = true;
+			setTargetBed(0);
+			setTargetHotend(0, 0);
+			setTargetHotend(0, 1);
+			setTargetHotend(0, 2);
+			manage_heater();
+			lcd_commands_step = 5;
+		}
+
+	}
+
+	if (lcd_commands_type == 3)
+	{
+		lcd_commands_type = 0;
+	}
+
+}
+
+static void lcd_return_to_status() {
+  lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
+#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
+    currentMenu == lcd_status_screen
+#endif
+  );
+
+    lcd_goto_menu(lcd_status_screen, 0, false);
+}
+
+static void lcd_sdcard_pause() {
+  card.pauseSDPrint();
+  isPrintPaused = true;
+  lcdDrawUpdate = 3;
+}
+
+static void lcd_sdcard_resume() {
+	card.startFileprint();
+	isPrintPaused = false;
+	lcdDrawUpdate = 3;
+}
+
+float move_menu_scale;
+static void lcd_move_menu_axis();
+
+
+
+/* Menu implementation */
+
+
+void lcd_preheat_pla()
+{
+  setTargetHotend0(plaPreheatHotendTemp);
+  setTargetBed(plaPreheatHPBTemp);
+  fanSpeed = 0;
+  lcd_return_to_status();
+  setWatch(); // heater sanity check timer
+}
+
+void lcd_preheat_abs()
+{
+  setTargetHotend0(absPreheatHotendTemp);
+  setTargetBed(absPreheatHPBTemp);
+  fanSpeed = 0;
+  lcd_return_to_status();
+  setWatch(); // heater sanity check timer
+}
+
+void lcd_preheat_pp()
+{
+  setTargetHotend0(ppPreheatHotendTemp);
+  setTargetBed(ppPreheatHPBTemp);
+  fanSpeed = 0;
+  lcd_return_to_status();
+  setWatch(); // heater sanity check timer
+}
+
+void lcd_preheat_pet()
+{
+  setTargetHotend0(petPreheatHotendTemp);
+  setTargetBed(petPreheatHPBTemp);
+  fanSpeed = 0;
+  lcd_return_to_status();
+  setWatch(); // heater sanity check timer
+}
+
+void lcd_preheat_hips()
+{
+  setTargetHotend0(hipsPreheatHotendTemp);
+  setTargetBed(hipsPreheatHPBTemp);
+  fanSpeed = 0;
+  lcd_return_to_status();
+  setWatch(); // heater sanity check timer
+}
+
+void lcd_preheat_flex()
+{
+  setTargetHotend0(flexPreheatHotendTemp);
+  setTargetBed(flexPreheatHPBTemp);
+  fanSpeed = 0;
+  lcd_return_to_status();
+  setWatch(); // heater sanity check timer
+}
+
+
+void lcd_cooldown()
+{
+  setTargetHotend0(0);
+  setTargetHotend1(0);
+  setTargetHotend2(0);
+  setTargetBed(0);
+  fanSpeed = 0;
+  lcd_return_to_status();
+}
+
+
+
+static void lcd_preheat_menu()
+{
+  START_MENU();
+
+  MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
+
+  MENU_ITEM(function, PSTR("ABS  -  " STRINGIFY(ABS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(ABS_PREHEAT_HPB_TEMP)), lcd_preheat_abs);
+  MENU_ITEM(function, PSTR("PLA  -  " STRINGIFY(PLA_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PLA_PREHEAT_HPB_TEMP)), lcd_preheat_pla);
+  MENU_ITEM(function, PSTR("PET  -  " STRINGIFY(PET_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PET_PREHEAT_HPB_TEMP)), lcd_preheat_pet);
+  MENU_ITEM(function, PSTR("HIPS -  " STRINGIFY(HIPS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(HIPS_PREHEAT_HPB_TEMP)), lcd_preheat_hips);
+  MENU_ITEM(function, PSTR("PP   -  " STRINGIFY(PP_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PP_PREHEAT_HPB_TEMP)), lcd_preheat_pp);
+  MENU_ITEM(function, PSTR("FLEX -  " STRINGIFY(FLEX_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(FLEX_PREHEAT_HPB_TEMP)), lcd_preheat_flex);
+
+  MENU_ITEM(function, MSG_COOLDOWN, lcd_cooldown);
+
+  END_MENU();
+}
+
+static void lcd_support_menu()
+{
+  START_MENU();
+
+  MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
+
+  MENU_ITEM(back, PSTR(MSG_FW_VERSION " - " FW_version), lcd_main_menu);
+  MENU_ITEM(back, MSG_PRUSA3D, lcd_main_menu);
+  MENU_ITEM(back, MSG_PRUSA3D_FORUM, lcd_main_menu);
+  MENU_ITEM(back, MSG_PRUSA3D_HOWTO, lcd_main_menu);
+  MENU_ITEM(back, PSTR("------------"), lcd_main_menu);
+  MENU_ITEM(back, PSTR(FILAMENT_SIZE), lcd_main_menu);
+  MENU_ITEM(back, PSTR(ELECTRONICS),lcd_main_menu);
+  MENU_ITEM(back, PSTR(NOZZLE_TYPE),lcd_main_menu);
+  MENU_ITEM(back, PSTR("------------"), lcd_main_menu);
+  MENU_ITEM(back, PSTR("Date: "), lcd_main_menu);
+  MENU_ITEM(back, PSTR(__DATE__), lcd_main_menu);
+
+  END_MENU();
+}
+
+void lcd_unLoadFilament()
+{
+
+  if (degHotend0() > EXTRUDE_MINTEMP) {
+
+    enquecommand_P(PSTR(UNLOAD_FILAMENT_0));
+    enquecommand_P(PSTR(UNLOAD_FILAMENT_1));
+
+  } else {
+
+    lcd_implementation_clear();
+    lcd.setCursor(0, 0);
+    lcd_printPGM(MSG_ERROR);
+    lcd.setCursor(0, 2);
+    lcd_printPGM(MSG_PREHEAT_NOZZLE);
+
+    delay(2000);
+    lcd_implementation_clear();
+  }
+
+  lcd_return_to_status();
+}
+
+void lcd_change_filament() {
+
+  lcd_implementation_clear();
+
+  lcd.setCursor(0, 1);
+
+  lcd_printPGM(MSG_CHANGING_FILAMENT);
+
+
+}
+
+
+void lcd_wait_interact() {
+
+  lcd_implementation_clear();
+
+  lcd.setCursor(0, 1);
+
+  lcd_printPGM(MSG_INSERT_FILAMENT);
+  lcd.setCursor(0, 2);
+  lcd_printPGM(MSG_PRESS);
+
+}
+
+
+void lcd_change_success() {
+
+  lcd_implementation_clear();
+
+  lcd.setCursor(0, 2);
+
+  lcd_printPGM(MSG_CHANGE_SUCCESS);
+
+
+}
+
+
+void lcd_loading_color() {
+
+  lcd_implementation_clear();
+
+  lcd.setCursor(0, 0);
+
+  lcd_printPGM(MSG_LOADING_COLOR);
+  lcd.setCursor(0, 2);
+  lcd_printPGM(MSG_PLEASE_WAIT);
+
+
+  for (int i = 0; i < 20; i++) {
+
+    lcd.setCursor(i, 3);
+    lcd.print(".");
+    for (int j = 0; j < 10 ; j++) {
+      manage_heater();
+      manage_inactivity(true);
+      delay(85);
+
+    }
+
+
+  }
+
+}
+
+
+void lcd_loading_filament() {
+
+
+  lcd_implementation_clear();
+
+  lcd.setCursor(0, 0);
+
+  lcd_printPGM(MSG_LOADING_FILAMENT);
+  lcd.setCursor(0, 2);
+  lcd_printPGM(MSG_PLEASE_WAIT);
+
+
+  for (int i = 0; i < 20; i++) {
+
+    lcd.setCursor(i, 3);
+    lcd.print(".");
+    for (int j = 0; j < 10 ; j++) {
+      manage_heater();
+      manage_inactivity(true);
+      delay(110);
+
+    }
+
+
+  }
+
+}
+
+void lcd_alright() {
+  int enc_dif = 0;
+  int cursor_pos = 1;
+
+
+
+
+  lcd_implementation_clear();
+
+  lcd.setCursor(0, 0);
+
+  lcd_printPGM(MSG_CORRECTLY);
+
+  lcd.setCursor(1, 1);
+
+  lcd_printPGM(MSG_YES);
+
+  lcd.setCursor(1, 2);
+
+  lcd_printPGM(MSG_NOT_LOADED);
+
+
+  lcd.setCursor(1, 3);
+  lcd_printPGM(MSG_NOT_COLOR);
+
+
+  lcd.setCursor(0, 1);
+
+  lcd.print(">");
+
+
+  enc_dif = encoderDiff;
+
+  while (lcd_change_fil_state == 0) {
+
+    manage_heater();
+    manage_inactivity(true);
+
+    if ( abs((enc_dif - encoderDiff)) > 4 ) {
+
+      if ( (abs(enc_dif - encoderDiff)) > 1 ) {
+        if (enc_dif > encoderDiff ) {
+          cursor_pos --;
+        }
+
+        if (enc_dif < encoderDiff  ) {
+          cursor_pos ++;
+        }
+
+        if (cursor_pos > 3) {
+          cursor_pos = 3;
+        }
+
+        if (cursor_pos < 1) {
+          cursor_pos = 1;
+        }
+        lcd.setCursor(0, 1);
+        lcd.print(" ");
+        lcd.setCursor(0, 2);
+        lcd.print(" ");
+        lcd.setCursor(0, 3);
+        lcd.print(" ");
+        lcd.setCursor(0, cursor_pos);
+        lcd.print(">");
+        enc_dif = encoderDiff;
+        delay(100);
+      }
+
+    }
+
+
+    if (lcd_clicked()) {
+
+      lcd_change_fil_state = cursor_pos;
+      delay(500);
+
+    }
+
+
+
+  };
+
+
+  lcd_implementation_clear();
+  lcd_return_to_status();
+
+}
+
+
+
+void lcd_LoadFilament()
+{
+  if (degHotend0() > EXTRUDE_MINTEMP) 
+  {
+	  custom_message = true;
+	  lcd_commands_type = 1;
+	  SERIAL_ECHOLN("Loading filament");
+	  // commands() will handle the rest
+  } 
+  else 
+  {
+
+    lcd_implementation_clear();
+    lcd.setCursor(0, 0);
+    lcd_printPGM(MSG_ERROR);
+    lcd.setCursor(0, 2);
+	lcd_printPGM(MSG_PREHEAT_NOZZLE);
+    delay(2000);
+    lcd_implementation_clear();
+  }
+  lcd_return_to_status();
+}
+
+
+static void lcd_menu_statistics()
+{
+
+	if (IS_SD_PRINTING)
+	{
+		int _met = total_filament_used / 100000;
+		int _cm = (total_filament_used - (_met * 100000))/10;
+		
+		int _t = (millis() - starttime) / 1000;
+
+		int _h = _t / 3600;
+		int _m = (_t - (_h * 60)) / 60;
+		int _s = _t - ((_h * 3600) + (_m * 60));
+		
+		lcd.setCursor(0, 0);
+		lcd_printPGM(MSG_STATS_FILAMENTUSED);
+
+		lcd.setCursor(6, 1);
+		lcd.print(itostr3(_met));
+		lcd.print("m ");
+		lcd.print(ftostr32ns(_cm));
+		lcd.print("cm");
+		
+		lcd.setCursor(0, 2);
+		lcd_printPGM(MSG_STATS_PRINTTIME);
+
+		lcd.setCursor(8, 3);
+		lcd.print(itostr2(_h));
+		lcd.print("h ");
+		lcd.print(itostr2(_m));
+		lcd.print("m ");
+		lcd.print(itostr2(_s));
+		lcd.print("s");
+
+		if (lcd_clicked())
+		{
+			lcd_quick_feedback();
+			lcd_return_to_status();
+		}
+	}
+	else
+	{
+		unsigned long _filament = eeprom_read_dword((uint32_t *)EEPROM_FILAMENTUSED);
+		unsigned long _time = eeprom_read_dword((uint32_t *)EEPROM_TOTALTIME);
+		uint8_t _days, _hours, _minutes;
+
+		float _filament_m = (float)_filament;
+		int _filament_km = (_filament >= 100000) ? _filament / 100000 : 0;
+		if (_filament_km > 0)  _filament_m = _filament - (_filament_km * 100000);
+
+		_days = _time / 1440;
+		_hours = (_time - (_days * 1440)) / 60;
+		_minutes = _time - ((_days * 1440) + (_hours * 60));
+
+		lcd_implementation_clear();
+
+		lcd.setCursor(0, 0);
+		lcd_printPGM(MSG_STATS_TOTALFILAMENT);
+		lcd.setCursor(17 - strlen(ftostr32ns(_filament_m)), 1);
+		lcd.print(ftostr32ns(_filament_m));
+
+		if (_filament_km > 0)
+		{
+			lcd.setCursor(17 - strlen(ftostr32ns(_filament_m)) - 3, 1);
+			lcd.print("km");
+			lcd.setCursor(17 - strlen(ftostr32ns(_filament_m)) - 8, 1);
+			lcd.print(itostr4(_filament_km));
+		}
+
+
+		lcd.setCursor(18, 1);
+		lcd.print("m");
+
+		lcd.setCursor(0, 2);
+		lcd_printPGM(MSG_STATS_TOTALPRINTTIME);;
+
+		lcd.setCursor(18, 3);
+		lcd.print("m");
+		lcd.setCursor(14, 3);
+		lcd.print(itostr3(_minutes));
+
+		lcd.setCursor(14, 3);
+		lcd.print(":");
+
+		lcd.setCursor(12, 3);
+		lcd.print("h");
+		lcd.setCursor(9, 3);
+		lcd.print(itostr3(_hours));
+
+		lcd.setCursor(9, 3);
+		lcd.print(":");
+
+		lcd.setCursor(7, 3);
+		lcd.print("d");
+		lcd.setCursor(4, 3);
+		lcd.print(itostr3(_days));
+
+
+
+		while (!lcd_clicked())
+		{
+			manage_heater();
+			manage_inactivity(true);
+			delay(100);
+		}
+
+		lcd_quick_feedback();
+		lcd_return_to_status();
+	}
+}
+
+
+static void _lcd_move(const char *name, int axis, int min, int max) {
+  if (encoderPosition != 0) {
+    refresh_cmd_timeout();
+    current_position[axis] += float((int)encoderPosition) * move_menu_scale;
+    if (min_software_endstops && current_position[axis] < min) current_position[axis] = min;
+    if (max_software_endstops && current_position[axis] > max) current_position[axis] = max;
+    encoderPosition = 0;
+#ifdef DELTA
+    calculate_delta(current_position);
+    plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis] / 60, active_extruder);
+#else
+    plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis] / 60, active_extruder);
+#endif
+    lcdDrawUpdate = 1;
+  }
+  if (lcdDrawUpdate) lcd_implementation_drawedit(name, ftostr31(current_position[axis]));
+  if (LCD_CLICKED) lcd_goto_menu(lcd_move_menu_axis);
+}
+
+
+static void lcd_move_e()
+{
+  if (encoderPosition != 0)
+  {
+    current_position[E_AXIS] += float((int)encoderPosition) * move_menu_scale;
+    encoderPosition = 0;
+#ifdef DELTA
+    calculate_delta(current_position);
+    plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS], manual_feedrate[E_AXIS] / 60, active_extruder);
+#else
+    plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[E_AXIS] / 60, active_extruder);
+#endif
+    lcdDrawUpdate = 1;
+  }
+  if (lcdDrawUpdate)
+  {
+    lcd_implementation_drawedit(PSTR("Extruder"), ftostr31(current_position[E_AXIS]));
+  }
+  if (LCD_CLICKED) lcd_goto_menu(lcd_move_menu_axis);
+}
+
+
+void EEPROM_save_B(int pos, int* value)
+{
+  union Data data;
+  data.value = *value;
+
+  eeprom_write_byte((unsigned char*)pos, data.b[0]);
+  eeprom_write_byte((unsigned char*)pos + 1, data.b[1]);
+
+
+}
+
+void EEPROM_read_B(int pos, int* value)
+{
+  union Data data;
+  data.b[0] = eeprom_read_byte((unsigned char*)pos);
+  data.b[1] = eeprom_read_byte((unsigned char*)pos + 1);
+  *value = data.value;
+
+}
+
+
+
+static void lcd_move_x() {
+  _lcd_move(PSTR("X"), X_AXIS, X_MIN_POS, X_MAX_POS);
+}
+static void lcd_move_y() {
+  _lcd_move(PSTR("Y"), Y_AXIS, Y_MIN_POS, Y_MAX_POS);
+}
+static void lcd_move_z() {
+  _lcd_move(PSTR("Z"), Z_AXIS, Z_MIN_POS, Z_MAX_POS);
+}
+
+
+
+static void _lcd_babystep(int axis, const char *msg) {
+  if (encoderPosition != 0) 
+  {
+    babystepsTodo[axis] += (int)encoderPosition;
+    babystepMem[axis] += (int)encoderPosition;
+    babystepMemMM[axis] = babystepMem[axis]/axis_steps_per_unit[Z_AXIS];
+	delay(50);
+	encoderPosition = 0;
+    lcdDrawUpdate = 1;
+  }
+  if (lcdDrawUpdate) lcd_implementation_drawedit_2(msg, ftostr13ns(babystepMemMM[axis]));
+  if (LCD_CLICKED) lcd_goto_menu(lcd_main_menu);
+  EEPROM_save_B(EEPROM_BABYSTEP_X, &babystepMem[0]);
+  EEPROM_save_B(EEPROM_BABYSTEP_Y, &babystepMem[1]);
+  EEPROM_save_B(EEPROM_BABYSTEP_Z, &babystepMem[2]);
+}
+
+static void lcd_babystep_x() {
+  _lcd_babystep(X_AXIS, (MSG_BABYSTEPPING_X));
+}
+static void lcd_babystep_y() {
+  _lcd_babystep(Y_AXIS, (MSG_BABYSTEPPING_Y));
+}
+static void lcd_babystep_z() {
+	_lcd_babystep(Z_AXIS, (MSG_BABYSTEPPING_Z));
+}
+
+
+void lcd_adjust_z() {
+  int enc_dif = 0;
+  int cursor_pos = 1;
+  int fsm = 0;
+
+
+
+
+  lcd_implementation_clear();
+  lcd.setCursor(0, 0);
+  lcd_printPGM(MSG_ADJUSTZ);
+  lcd.setCursor(1, 1);
+  lcd_printPGM(MSG_YES);
+
+  lcd.setCursor(1, 2);
+
+  lcd_printPGM(MSG_NO);
+
+  lcd.setCursor(0, 1);
+
+  lcd.print(">");
+
+
+  enc_dif = encoderDiff;
+
+  while (fsm == 0) {
+
+    manage_heater();
+    manage_inactivity(true);
+
+    if ( abs((enc_dif - encoderDiff)) > 4 ) {
+
+      if ( (abs(enc_dif - encoderDiff)) > 1 ) {
+        if (enc_dif > encoderDiff ) {
+          cursor_pos --;
+        }
+
+        if (enc_dif < encoderDiff  ) {
+          cursor_pos ++;
+        }
+
+        if (cursor_pos > 2) {
+          cursor_pos = 2;
+        }
+
+        if (cursor_pos < 1) {
+          cursor_pos = 1;
+        }
+        lcd.setCursor(0, 1);
+        lcd.print(" ");
+        lcd.setCursor(0, 2);
+        lcd.print(" ");
+        lcd.setCursor(0, cursor_pos);
+        lcd.print(">");
+        enc_dif = encoderDiff;
+        delay(100);
+      }
+
+    }
+
+
+    if (lcd_clicked()) {
+      fsm = cursor_pos;
+      if (fsm == 1) {
+        EEPROM_read_B(EEPROM_BABYSTEP_X, &babystepMem[0]);
+        EEPROM_read_B(EEPROM_BABYSTEP_Y, &babystepMem[1]);
+        EEPROM_read_B(EEPROM_BABYSTEP_Z, &babystepMem[2]);
+        babystepsTodo[Z_AXIS] = babystepMem[2];
+      } else {
+        babystepMem[0] = 0;
+        babystepMem[1] = 0;
+        babystepMem[2] = 0;
+
+        EEPROM_save_B(EEPROM_BABYSTEP_X, &babystepMem[0]);
+        EEPROM_save_B(EEPROM_BABYSTEP_Y, &babystepMem[1]);
+        EEPROM_save_B(EEPROM_BABYSTEP_Z, &babystepMem[2]);
+      }
+      delay(500);
+    }
+  };
+
+  lcd_implementation_clear();
+  lcd_return_to_status();
+
+}
+
+// Lets the user move the Z carriage up to the end stoppers.
+// When done, it sets the current Z to Z_MAX_POS and returns true.
+// Otherwise the Z calibration is not changed and false is returned.
+bool lcd_calibrate_z_end_stop_manual()
+{
+    const unsigned long max_inactive_time = 60 * 1000; // 60 seconds
+    unsigned long previous_millis_cmd = millis();
+    int8_t        cursor_pos;
+    int8_t        enc_dif = 0;
+
+    // Until confirmed by the confirmation dialog.
+    for (;;) {
+        previous_millis_cmd = millis();
+        lcd_implementation_clear();
+        lcd.setCursor(0, 0);
+        lcd_printPGM(MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE1);
+        lcd.setCursor(0, 1);
+        lcd_printPGM(MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE2);
+        lcd.setCursor(0, 2);
+        lcd_printPGM(MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE3);
+        lcd.setCursor(0, 3);
+        lcd_printPGM(MSG_MOVE_CARRIAGE_TO_THE_TOP_LINE4);
+        // Until the user finishes the z up movement.
+        enc_dif = encoderDiff;
+        for (;;) {
+            if (millis() - previous_millis_cmd >  max_inactive_time)
+                goto canceled;
+            manage_heater();
+            manage_inactivity(true);
+            if (abs((enc_dif - encoderDiff)) > 4) {
+                if (abs(enc_dif - encoderDiff) > 1) {
+                    previous_millis_cmd = millis();
+                    // Only move up, whatever the user does.
+                    current_position[Z_AXIS] += fabs(enc_dif - encoderDiff);
+                    plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[Z_AXIS] / 60, active_extruder);
+        //            delay(10);
+                    enc_dif = encoderDiff;
+                }
+            }
+            if (lcd_clicked()) {
+                // Wait until the Z up movement is finished.
+                st_synchronize();
+                while (lcd_clicked()) ;
+                delay(10);
+                while (lcd_clicked()) ;
+                break;
+            }
+        }
+
+        // Let the user confirm, that the Z carriage is at the top end stoppers.
+        lcd_implementation_clear();
+        lcd.setCursor(0, 0);
+        lcd_printPGM(MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE1);
+        lcd.setCursor(0, 1);
+        lcd_printPGM(MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LINE2);
+        lcd.setCursor(1, 2);
+        lcd_printPGM(MSG_YES);
+        lcd.setCursor(1, 3);
+        lcd_printPGM(MSG_NO);
+        cursor_pos = 3;
+        lcd.setCursor(0, cursor_pos);
+        lcd_printPGM(PSTR(">"));
+
+        previous_millis_cmd = millis();
+        enc_dif = encoderDiff;
+        for (;;) {
+            if (millis() - previous_millis_cmd >  max_inactive_time)
+                goto canceled;
+            manage_heater();
+            manage_inactivity(true);
+            if (abs((enc_dif - encoderDiff)) > 4) {
+                if (abs(enc_dif - encoderDiff) > 1) {
+                    lcd.setCursor(0, 2);
+                    if (enc_dif > encoderDiff && cursor_pos == 4) {
+                        lcd_printPGM((PSTR(" ")));
+                        lcd.setCursor(0, 3);
+                        lcd_printPGM((PSTR(">")));
+                        -- cursor_pos;
+                    } else if (enc_dif < encoderDiff && cursor_pos == 3) {
+                        ++ cursor_pos;
+                        lcd_printPGM((PSTR(">")));
+                        lcd.setCursor(0, 3);
+                        lcd_printPGM((PSTR(" ")));
+                    }
+                    enc_dif = encoderDiff;
+                }
+            }
+            if (lcd_clicked()) {
+                while (lcd_clicked()) ;
+                delay(10);
+                while (lcd_clicked()) ;
+                if (cursor_pos == 3) {
+                    // Perform another round of the Z up dialog.
+                    break;
+                }
+                goto calibrated;
+            }
+        }
+    }
+
+calibrated:
+    current_position[Z_AXIS] = Z_MAX_POS;
+    plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
+    return true;
+
+canceled:
+    return false;
+}
+
+// Lets the user move the Z carriage up to the end stoppers.
+// When done, it sets the current Z to Z_MAX_POS and returns true.
+// Otherwise the Z calibration is not changed and false is returned.
+void lcd_diag_show_end_stops()
+{
+    int enc_dif = encoderDiff;
+    lcd_implementation_clear();
+    lcd.setCursor(0, 0);
+    lcd_printPGM((PSTR("End stops diag")));
+    for (;;) {
+        manage_heater();
+        manage_inactivity(true);
+        lcd.setCursor(0, 1);
+        lcd_printPGM((READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? (PSTR("X1")) : (PSTR("X0")));
+        lcd.setCursor(0, 2);
+        lcd_printPGM((READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1) ? (PSTR("Y1")) : (PSTR("Y0")));
+        lcd.setCursor(0, 3);
+        lcd_printPGM((READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1) ? (PSTR("Z1")) : (PSTR("Z0")));
+        if (lcd_clicked()) {
+            while (lcd_clicked()) ;
+            delay(10);
+            while (lcd_clicked()) ;
+            break;
+        }
+    }
+    lcd_implementation_clear();
+    lcd_return_to_status();
+}
+
+void lcd_pick_babystep(){
+    int enc_dif = 0;
+    int cursor_pos = 1;
+    int fsm = 0;
+    
+    
+    
+    
+    lcd_implementation_clear();
+    
+    lcd.setCursor(0, 0);
+    
+    lcd_printPGM(MSG_PICK_Z);
+    
+    
+    lcd.setCursor(3, 2);
+    
+    lcd.print("1");
+    
+    lcd.setCursor(3, 3);
+    
+    lcd.print("2");
+    
+    lcd.setCursor(12, 2);
+    
+    lcd.print("3");
+    
+    lcd.setCursor(12, 3);
+    
+    lcd.print("4");
+    
+    lcd.setCursor(1, 2);
+    
+    lcd.print(">");
+    
+    
+    enc_dif = encoderDiff;
+    
+    while (fsm == 0) {
+        
+        manage_heater();
+        manage_inactivity(true);
+        
+        if ( abs((enc_dif - encoderDiff)) > 4 ) {
+            
+            if ( (abs(enc_dif - encoderDiff)) > 1 ) {
+                if (enc_dif > encoderDiff ) {
+                    cursor_pos --;
+                }
+                
+                if (enc_dif < encoderDiff  ) {
+                    cursor_pos ++;
+                }
+                
+                if (cursor_pos > 4) {
+                    cursor_pos = 4;
+                }
+                
+                if (cursor_pos < 1) {
+                    cursor_pos = 1;
+                }
+
+                
+                lcd.setCursor(1, 2);
+                lcd.print(" ");
+                lcd.setCursor(1, 3);
+                lcd.print(" ");
+                lcd.setCursor(10, 2);
+                lcd.print(" ");
+                lcd.setCursor(10, 3);
+                lcd.print(" ");
+                
+                if (cursor_pos < 3) {
+                    lcd.setCursor(1, cursor_pos+1);
+                    lcd.print(">");
+                }else{
+                    lcd.setCursor(10, cursor_pos-1);
+                    lcd.print(">");
+                }
+                
+   
+                enc_dif = encoderDiff;
+                delay(100);
+            }
+            
+        }
+        
+        
+        if (lcd_clicked()) {
+            fsm = cursor_pos;
+            
+            EEPROM_read_B(EEPROM_BABYSTEP_Z0+((fsm-1)*2),&babystepMem[2]);
+            EEPROM_save_B(EEPROM_BABYSTEP_Z,&babystepMem[2]);
+            eeprom_write_byte((unsigned char*)EEPROM_BABYSTEP_Z_SET, 0x01);
+            delay(500);
+            
+        }
+        
+        
+        
+    };
+    
+    
+    lcd_implementation_clear();
+    lcd_return_to_status();
+}
+
+void lcd_move_menu_axis()
+{
+  START_MENU();
+  MENU_ITEM(back, MSG_SETTINGS, lcd_settings_menu);
+  MENU_ITEM(submenu, MSG_MOVE_X, lcd_move_x);
+  MENU_ITEM(submenu, MSG_MOVE_Y, lcd_move_y);
+  if (move_menu_scale < 10.0)
+  {
+	  if (!isPrintPaused)
+	  {
+		  MENU_ITEM(submenu, MSG_MOVE_Z, lcd_move_z);
+	  }
+	  MENU_ITEM(submenu, MSG_MOVE_E, lcd_move_e);
+  }
+  END_MENU();
+}
+
+static void lcd_move_menu_1mm()
+{
+  move_menu_scale = 1.0;
+  lcd_move_menu_axis();
+}
+
+
+void EEPROM_save(int pos, uint8_t* value, uint8_t size)
+{
+  do
+  {
+    eeprom_write_byte((unsigned char*)pos, *value);
+    pos++;
+    value++;
+  } while (--size);
+}
+
+void EEPROM_read(int pos, uint8_t* value, uint8_t size)
+{
+  do
+  {
+    *value = eeprom_read_byte((unsigned char*)pos);
+    pos++;
+    value++;
+  } while (--size);
+}
+
+
+
+static void lcd_silent_mode_set() {
+  SilentModeMenu = !SilentModeMenu;
+  EEPROM_save(EEPROM_SILENT, (uint8_t*)&SilentModeMenu, sizeof(SilentModeMenu));
+  digipot_init();
+  lcd_goto_menu(lcd_settings_menu, 7);
+}
+static void lcd_set_lang(unsigned char lang) {
+  lang_selected = lang;
+  firstrun = 1;
+  eeprom_write_byte((unsigned char *)EEPROM_LANG, lang);/*langsel=0;*/if (langsel == 1)langsel = 2;
+}
+
+void lcd_force_language_selection() {
+  eeprom_write_byte((unsigned char *)EEPROM_LANG, 255);
+}
+
+static void lcd_language_menu()
+{
+  START_MENU();
+  if (!langsel) {
+    MENU_ITEM(back, MSG_SETTINGS, lcd_settings_menu);
+  }
+  if (langsel == 2) {
+    MENU_ITEM(back, MSG_WATCH, lcd_status_screen);
+  }
+  for (int i=0;i<LANG_NUM;i++){
+    MENU_ITEM(setlang, MSG_LANGUAGE_NAME_EXPLICIT(i), i);
+  }
+  //MENU_ITEM(setlang, MSG_LANGUAGE_NAME_EXPLICIT(1), 1);
+  END_MENU();
+}
+
+void lcd_mesh_bedleveling()
+{
+
+	enquecommand_P(PSTR("G80"));
+	lcd_return_to_status();
+}
+
+void lcd_mesh_calibration()
+{
+  enquecommand_P(PSTR("M46"));
+  lcd_return_to_status();
+}
+
+void lcd_mesh_calibration_reset()
+{
+  enquecommand_P(PSTR("M44"));
+  lcd_return_to_status();
+}
+
+static void lcd_settings_menu()
+{
+  EEPROM_read(EEPROM_SILENT, (uint8_t*)&SilentModeMenu, sizeof(SilentModeMenu));
+  START_MENU();
+
+  MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
+
+  MENU_ITEM(submenu, MSG_TEMPERATURE, lcd_control_temperature_menu);
+  MENU_ITEM(submenu, MSG_MOVE_AXIS, lcd_move_menu_1mm);
+  
+  if (!isPrintPaused)
+  {
+#ifndef MESH_BED_LEVELING
+	  MENU_ITEM(gcode, MSG_HOMEYZ, PSTR("G28 Z"));
+#else
+	  MENU_ITEM(submenu, MSG_HOMEYZ, lcd_mesh_bedleveling);
+#endif
+  }
+
+  if (!isPrintPaused)
+  {
+	  MENU_ITEM(gcode, MSG_DISABLE_STEPPERS, PSTR("M84"));
+	  MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
+  }
+
+  if (SilentModeMenu == 0) {
+    MENU_ITEM(function, MSG_SILENT_MODE_OFF, lcd_silent_mode_set);
+  } else {
+    MENU_ITEM(function, MSG_SILENT_MODE_ON, lcd_silent_mode_set);
+  }
+
+    EEPROM_read_B(EEPROM_BABYSTEP_X, &babystepMem[0]);
+    EEPROM_read_B(EEPROM_BABYSTEP_Y, &babystepMem[1]);
+    EEPROM_read_B(EEPROM_BABYSTEP_Z, &babystepMem[2]);
+    babystepMemMM[2] = babystepMem[2]/axis_steps_per_unit[Z_AXIS];
+  
+	if (!isPrintPaused)
+	{
+		MENU_ITEM(submenu, MSG_BABYSTEP_Z, lcd_babystep_z);//8
+	}
+	MENU_ITEM(submenu, MSG_LANGUAGE_SELECT, lcd_language_menu);
+	if (!isPrintPaused)
+	{
+		MENU_ITEM(submenu, MSG_SELFTEST, lcd_selftest);
+    MENU_ITEM(submenu, MSG_CALIBRATE_BED, lcd_mesh_calibration);
+    MENU_ITEM(submenu, MSG_CALIBRATE_BED_RESET, lcd_mesh_calibration_reset);
+	}
+  
+	END_MENU();
+}
+/*
+void lcd_mylang_top(int hlaska) {
+    lcd.setCursor(0,0);
+    lcd.print("                    ");
+    lcd.setCursor(0,0);
+    lcd_printPGM(MSG_ALL[hlaska-1][LANGUAGE_SELECT]);   
+}
+
+void lcd_mylang_drawmenu(int cursor) {
+  int first = 0;
+  if (cursor>2) first = cursor-2;
+  if (cursor==LANG_NUM) first = LANG_NUM-3;
+  lcd.setCursor(0, 1);
+  lcd.print("                    ");
+  lcd.setCursor(1, 1);
+  lcd_printPGM(MSG_ALL[first][LANGUAGE_NAME]);
+
+  lcd.setCursor(0, 2);
+  lcd.print("                    ");
+  lcd.setCursor(1, 2);
+  lcd_printPGM(MSG_ALL[first+1][LANGUAGE_NAME]);
+
+  lcd.setCursor(0, 3);
+  lcd.print("                    ");
+  lcd.setCursor(1, 3);
+  lcd_printPGM(MSG_ALL[first+2][LANGUAGE_NAME]);  
+  
+  if (cursor==1) lcd.setCursor(0, 1);
+  if (cursor>1 && cursor<LANG_NUM) lcd.setCursor(0, 2);
+  if (cursor==LANG_NUM) lcd.setCursor(0, 3);
+
+  lcd.print(">");
+  
+  if (cursor<LANG_NUM-1) {
+    lcd.setCursor(19,3);
+    lcd.print("\x01");
+  }
+  if (cursor>2) {
+    lcd.setCursor(19,1);
+    lcd.print("^");
+  }  
+}
+*/
+
+void lcd_mylang_drawmenu(int cursor) {
+  int first = 0;
+  if (cursor>3) first = cursor-3;
+  if (cursor==LANG_NUM && LANG_NUM>4) first = LANG_NUM-4;
+  if (cursor==LANG_NUM && LANG_NUM==4) first = LANG_NUM-4;
+
+
+  lcd.setCursor(0, 0);
+  lcd.print("                    ");
+  lcd.setCursor(1, 0);
+  lcd_printPGM(MSG_LANGUAGE_NAME_EXPLICIT(first+0));
+
+  lcd.setCursor(0, 1);
+  lcd.print("                    ");
+  lcd.setCursor(1, 1);
+  lcd_printPGM(MSG_LANGUAGE_NAME_EXPLICIT(first+1));
+
+  lcd.setCursor(0, 2);
+  lcd.print("                    ");
+
+  if (LANG_NUM > 2){
+    lcd.setCursor(1, 2);
+    lcd_printPGM(MSG_LANGUAGE_NAME_EXPLICIT(first+2));
+  }
+
+  lcd.setCursor(0, 3);
+  lcd.print("                    ");
+  if (LANG_NUM>3) {
+    lcd.setCursor(1, 3);
+    lcd_printPGM(MSG_LANGUAGE_NAME_EXPLICIT(first+3));
+  }
+  
+  if (cursor==1) lcd.setCursor(0, 0);
+  if (cursor==2) lcd.setCursor(0, 1);
+  if (cursor>2) lcd.setCursor(0, 2);
+  if (cursor==LANG_NUM && LANG_NUM>3) lcd.setCursor(0, 3);
+
+  lcd.print(">");
+  
+  if (cursor<LANG_NUM-1 && LANG_NUM>4) {
+    lcd.setCursor(19,3);
+    lcd.print("\x01");
+  }
+  if (cursor>3 && LANG_NUM>4) {
+    lcd.setCursor(19,0);
+    lcd.print("^");
+  }  
+}
+ 
+void lcd_set_custom_characters_arrows();
+void lcd_set_custom_characters_degree();
+
+void lcd_mylang_drawcursor(int cursor) {
+  
+  if (cursor==1) lcd.setCursor(0, 1);
+  if (cursor>1 && cursor<LANG_NUM) lcd.setCursor(0, 2);
+  if (cursor==LANG_NUM) lcd.setCursor(0, 3);
+
+  lcd.print(">");
+  
+}  
+
+void lcd_mylang() {
+  int enc_dif = 0;
+  int cursor_pos = 1;
+  lang_selected=255;
+  int hlaska=1;
+  int counter=0;
+  lcd_set_custom_characters_arrows();
+
+  lcd_implementation_clear();
+
+  //lcd_mylang_top(hlaska);
+
+  lcd_mylang_drawmenu(cursor_pos);
+
+
+  enc_dif = encoderDiff;
+
+  while ( (lang_selected == 255) && (MYSERIAL.available() < 2) ) {
+
+    manage_heater();
+    manage_inactivity(true);
+
+    if ( abs((enc_dif - encoderDiff)) > 4 ) {
+
+      //if ( (abs(enc_dif - encoderDiff)) > 1 ) {
+        if (enc_dif > encoderDiff ) {
+          cursor_pos --;
+        }
+
+        if (enc_dif < encoderDiff  ) {
+          cursor_pos ++;
+        }
+
+        if (cursor_pos > LANG_NUM) {
+          cursor_pos = LANG_NUM;
+        }
+
+        if (cursor_pos < 1) {
+          cursor_pos = 1;
+        }
+
+        lcd_mylang_drawmenu(cursor_pos);
+        enc_dif = encoderDiff;
+        delay(100);
+      //}
+
+    } else delay(20);
+
+
+    if (lcd_clicked()) {
+
+      lcd_set_lang(cursor_pos-1);
+      delay(500);
+
+    }
+    /*
+    if (++counter == 80) {
+      hlaska++;
+      if(hlaska>LANG_NUM) hlaska=1;
+      lcd_mylang_top(hlaska);
+      lcd_mylang_drawcursor(cursor_pos);
+      counter=0;
+    }
+    */
+  };
+
+  if(MYSERIAL.available() > 1){
+    lang_selected = 0;
+    firstrun = 0;
+  }
+
+  lcd_set_custom_characters_degree();
+  lcd_implementation_clear();
+  lcd_return_to_status();
+
+}
+
+
+
+
+static void lcd_main_menu()
+{
+
+  SDscrool = 0;
+  /*
+  if (langsel == 1)
+  {
+    lcd_goto_menu(lcd_language_menu);
+  }
+  */
+  START_MENU();
+
+  // Majkl superawesome menu
+
+  
+ MENU_ITEM(back, MSG_WATCH, lcd_status_screen);
+
+  if ( ( IS_SD_PRINTING || is_usb_printing ) && (current_position[Z_AXIS] < 0.5) ) 
+  {
+    EEPROM_read_B(EEPROM_BABYSTEP_X, &babystepMem[0]);
+	EEPROM_read_B(EEPROM_BABYSTEP_Y, &babystepMem[1]);
+	EEPROM_read_B(EEPROM_BABYSTEP_Z, &babystepMem[2]);
+	MENU_ITEM(submenu, MSG_BABYSTEP_Z, lcd_babystep_z);//8
+  }
+
+
+  if ( movesplanned() || IS_SD_PRINTING || is_usb_printing )
+  {
+    MENU_ITEM(submenu, MSG_TUNE, lcd_tune_menu);
+  } else 
+  {
+    MENU_ITEM(submenu, MSG_PREHEAT, lcd_preheat_menu);
+  }
+
+#ifdef SDSUPPORT
+  if (card.cardOK)
+  {
+    if (card.isFileOpen())
+    {
+		if (card.sdprinting)
+		{
+			MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause);
+		}
+		else
+		{
+			MENU_ITEM(function, MSG_RESUME_PRINT, lcd_sdcard_resume);
+		}
+		MENU_ITEM(submenu, MSG_STOP_PRINT, lcd_sdcard_stop);
+	}
+	else
+	{
+		if (!is_usb_printing)
+		{
+			MENU_ITEM(submenu, MSG_CARD_MENU, lcd_sdcard_menu);
+		}
+#if SDCARDDETECT < 1
+      MENU_ITEM(gcode, MSG_CNG_SDCARD, PSTR("M21"));  // SD-card changed by user
+#endif
+    }
+  } else 
+  {
+    MENU_ITEM(submenu, MSG_NO_CARD, lcd_sdcard_menu);
+#if SDCARDDETECT < 1
+    MENU_ITEM(gcode, MSG_INIT_SDCARD, PSTR("M21")); // Manually initialize the SD-card via user interface
+#endif
+  }
+#endif
+
+
+  if (IS_SD_PRINTING || is_usb_printing)
+  {
+  } 
+  else 
+  {
+    MENU_ITEM(function, MSG_LOAD_FILAMENT, lcd_LoadFilament);
+    MENU_ITEM(function, MSG_UNLOAD_FILAMENT, lcd_unLoadFilament);
+    MENU_ITEM(submenu, MSG_SETTINGS, lcd_settings_menu);
+  }
+
+  if (!is_usb_printing)
+  {
+	  MENU_ITEM(submenu, MSG_STATISTICS, lcd_menu_statistics);
+  }
+  MENU_ITEM(submenu, MSG_SUPPORT, lcd_support_menu);
+
+  END_MENU();
+}
+
+
+
+#ifdef SDSUPPORT
+static void lcd_autostart_sd()
+{
+  card.lastnr = 0;
+  card.setroot();
+  card.checkautostart(true);
+}
+#endif
+
+
+
+static void lcd_silent_mode_set_tune() {
+  SilentModeMenu = !SilentModeMenu;
+  EEPROM_save(EEPROM_SILENT, (uint8_t*)&SilentModeMenu, sizeof(SilentModeMenu));
+  digipot_init();
+  lcd_goto_menu(lcd_tune_menu, 9);
+}
+
+static void lcd_tune_menu()
+{
+  EEPROM_read(EEPROM_SILENT, (uint8_t*)&SilentModeMenu, sizeof(SilentModeMenu));
+
+  
+
+  START_MENU();
+  MENU_ITEM(back, MSG_MAIN, lcd_main_menu); //1
+  MENU_ITEM_EDIT(int3, MSG_SPEED, &feedmultiply, 10, 999);//2
+
+  MENU_ITEM_EDIT(int3, MSG_NOZZLE, &target_temperature[0], 0, HEATER_0_MAXTEMP - 10);//3
+  MENU_ITEM_EDIT(int3, MSG_BED, &target_temperature_bed, 0, BED_MAXTEMP - 10);//4
+
+  MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &fanSpeed, 0, 255);//5
+  MENU_ITEM_EDIT(int3, MSG_FLOW, &extrudemultiply, 10, 999);//6
+#ifdef FILAMENTCHANGEENABLE
+  MENU_ITEM(gcode, MSG_FILAMENTCHANGE, PSTR("M600"));//7
+#endif
+  
+  if (SilentModeMenu == 0) {
+    MENU_ITEM(function, MSG_SILENT_MODE_OFF, lcd_silent_mode_set_tune);
+  } else {
+    MENU_ITEM(function, MSG_SILENT_MODE_ON, lcd_silent_mode_set_tune);
+  }
+  END_MENU();
+}
+
+
+
+
+static void lcd_move_menu_01mm()
+{
+  move_menu_scale = 0.1;
+  lcd_move_menu_axis();
+}
+
+static void lcd_control_temperature_menu()
+{
+#ifdef PIDTEMP
+  // set up temp variables - undo the default scaling
+  raw_Ki = unscalePID_i(Ki);
+  raw_Kd = unscalePID_d(Kd);
+#endif
+
+  START_MENU();
+  MENU_ITEM(back, MSG_SETTINGS, lcd_settings_menu);
+  //MENU_ITEM(back, MSG_CONTROL, lcd_control_menu);
+#if TEMP_SENSOR_0 != 0
+  MENU_ITEM_EDIT(int3, MSG_NOZZLE, &target_temperature[0], 0, HEATER_0_MAXTEMP - 10);
+#endif
+#if TEMP_SENSOR_1 != 0
+  MENU_ITEM_EDIT(int3, MSG_NOZZLE1, &target_temperature[1], 0, HEATER_1_MAXTEMP - 10);
+#endif
+#if TEMP_SENSOR_2 != 0
+  MENU_ITEM_EDIT(int3, MSG_NOZZLE2, &target_temperature[2], 0, HEATER_2_MAXTEMP - 10);
+#endif
+#if TEMP_SENSOR_BED != 0
+  MENU_ITEM_EDIT(int3, MSG_BED, &target_temperature_bed, 0, BED_MAXTEMP - 3);
+#endif
+  MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &fanSpeed, 0, 255);
+#if defined AUTOTEMP && (TEMP_SENSOR_0 != 0)
+  MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &autotemp_enabled);
+  MENU_ITEM_EDIT(float3, MSG_MIN, &autotemp_min, 0, HEATER_0_MAXTEMP - 10);
+  MENU_ITEM_EDIT(float3, MSG_MAX, &autotemp_max, 0, HEATER_0_MAXTEMP - 10);
+  MENU_ITEM_EDIT(float32, MSG_FACTOR, &autotemp_factor, 0.0, 1.0);
+#endif
+
+  END_MENU();
+}
+
+
+#if SDCARDDETECT == -1
+static void lcd_sd_refresh()
+{
+  card.initsd();
+  currentMenuViewOffset = 0;
+}
+#endif
+static void lcd_sd_updir()
+{
+  SDscrool = 0;
+  card.updir();
+  currentMenuViewOffset = 0;
+}
+
+
+void lcd_sdcard_stop()
+{
+	
+	lcd.setCursor(0, 0);
+	lcd_printPGM(MSG_STOP_PRINT);
+	lcd.setCursor(2, 2);
+	lcd_printPGM(MSG_NO);
+	lcd.setCursor(2, 3);
+	lcd_printPGM(MSG_YES);
+	lcd.setCursor(0, 2); lcd.print(" ");
+	lcd.setCursor(0, 3); lcd.print(" ");
+
+	if ((int32_t)encoderPosition > 2) { encoderPosition = 2; }
+	if ((int32_t)encoderPosition < 1) { encoderPosition = 1; }
+	
+	lcd.setCursor(0, 1 + encoderPosition);
+	lcd.print(">");
+
+	if (lcd_clicked())
+	{
+		if ((int32_t)encoderPosition == 1)
+		{
+			lcd_return_to_status();
+		}
+		if ((int32_t)encoderPosition == 2)
+		{
+				cancel_heatup = true;
+				quickStop();
+				lcd_setstatuspgm(MSG_PRINT_ABORTED);
+				card.sdprinting = false;
+				card.closefile();
+
+				stoptime = millis();
+				unsigned long t = (stoptime - starttime) / 1000;
+				save_statistics(total_filament_used, t);
+
+				lcd_return_to_status();
+				lcd_ignore_click(true);
+				lcd_commands_type = 2;
+		}
+	}
+
+}
+
+void lcd_sdcard_menu()
+{
+
+	int tempScrool = 0;
+  if (lcdDrawUpdate == 0 && LCD_CLICKED == 0)
+    //delay(100);
+    return; // nothing to do (so don't thrash the SD card)
+  uint16_t fileCnt = card.getnrfilenames();
+
+  START_MENU();
+  MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
+  card.getWorkDirName();
+  if (card.filename[0] == '/')
+  {
+#if SDCARDDETECT == -1
+    MENU_ITEM(function, LCD_STR_REFRESH MSG_REFRESH, lcd_sd_refresh);
+#endif
+  } else {
+    MENU_ITEM(function, LCD_STR_FOLDER "..", lcd_sd_updir);
+  }
+
+  for (uint16_t i = 0; i < fileCnt; i++)
+  {
+    if (_menuItemNr == _lineNr)
+    {
+#ifndef SDCARD_RATHERRECENTFIRST
+      card.getfilename(i);
+#else
+      card.getfilename(fileCnt - 1 - i);
+#endif
+      if (card.filenameIsDir)
+      {
+        MENU_ITEM(sddirectory, MSG_CARD_MENU, card.filename, card.longFilename);
+      } else {
+
+        MENU_ITEM(sdfile, MSG_CARD_MENU, card.filename, card.longFilename);
+
+
+
+
+      }
+    } else {
+      MENU_ITEM_DUMMY();
+    }
+  }
+  END_MENU();
+}
+
+#define menu_edit_type(_type, _name, _strFunc, scale) \
+  void menu_edit_ ## _name () \
+  { \
+    if ((int32_t)encoderPosition < 0) encoderPosition = 0; \
+    if ((int32_t)encoderPosition > maxEditValue) encoderPosition = maxEditValue; \
+    if (lcdDrawUpdate) \
+      lcd_implementation_drawedit(editLabel, _strFunc(((_type)((int32_t)encoderPosition + minEditValue)) / scale)); \
+    if (LCD_CLICKED) \
+    { \
+      *((_type*)editValue) = ((_type)((int32_t)encoderPosition + minEditValue)) / scale; \
+      lcd_goto_menu(prevMenu, prevEncoderPosition); \
+    } \
+  } \
+  void menu_edit_callback_ ## _name () { \
+    menu_edit_ ## _name (); \
+    if (LCD_CLICKED) (*callbackFunc)(); \
+  } \
+  static void menu_action_setting_edit_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue) \
+  { \
+    prevMenu = currentMenu; \
+    prevEncoderPosition = encoderPosition; \
+    \
+    lcdDrawUpdate = 2; \
+    currentMenu = menu_edit_ ## _name; \
+    \
+    editLabel = pstr; \
+    editValue = ptr; \
+    minEditValue = minValue * scale; \
+    maxEditValue = maxValue * scale - minEditValue; \
+    encoderPosition = (*ptr) * scale - minEditValue; \
+  }\
+  static void menu_action_setting_edit_callback_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue, menuFunc_t callback) \
+  { \
+    prevMenu = currentMenu; \
+    prevEncoderPosition = encoderPosition; \
+    \
+    lcdDrawUpdate = 2; \
+    currentMenu = menu_edit_callback_ ## _name; \
+    \
+    editLabel = pstr; \
+    editValue = ptr; \
+    minEditValue = minValue * scale; \
+    maxEditValue = maxValue * scale - minEditValue; \
+    encoderPosition = (*ptr) * scale - minEditValue; \
+    callbackFunc = callback;\
+  }
+menu_edit_type(int, int3, itostr3, 1)
+menu_edit_type(float, float3, ftostr3, 1)
+menu_edit_type(float, float32, ftostr32, 100)
+menu_edit_type(float, float43, ftostr43, 1000)
+menu_edit_type(float, float5, ftostr5, 0.01)
+menu_edit_type(float, float51, ftostr51, 10)
+menu_edit_type(float, float52, ftostr52, 100)
+menu_edit_type(unsigned long, long5, ftostr5, 0.01)
+
+
+static void lcd_selftest()
+{
+	int _progress = 0;
+	bool _result = false;
+
+	_progress = lcd_selftest_screen(-1, _progress, 4, true, 2000);
+
+	_progress = lcd_selftest_screen(0, _progress, 3, true, 2000);
+	_result = lcd_selfcheck_endstops();
+
+	if (_result)
+	{
+		_progress = lcd_selftest_screen(1, _progress, 3, true, 1000);
+		_result = lcd_selfcheck_check_heater(false);
+	}
+
+	if (_result)
+	{
+		_progress = lcd_selftest_screen(2, _progress, 3, true, 2000);
+		_result = lcd_selfcheck_axis(0, X_MAX_POS);
+	}
+
+	if (_result)
+	{
+		_progress = lcd_selftest_screen(3, _progress, 3, true, 1500);
+		_result = lcd_selfcheck_axis(1, Y_MAX_POS);
+	}
+
+	if (_result)
+	{
+		current_position[X_AXIS] = current_position[X_AXIS] - 3;
+		current_position[Y_AXIS] = current_position[Y_AXIS] - 14;
+		_progress = lcd_selftest_screen(4, _progress, 3, true, 1500);
+		_result = lcd_selfcheck_axis(2, Z_MAX_POS);
+	}
+
+	if (_result)
+	{
+		_progress = lcd_selftest_screen(5, _progress, 3, true, 2000);
+		_result = lcd_selfcheck_check_heater(true);
+	}
+	if (_result)
+	{
+		_progress = lcd_selftest_screen(6, _progress, 3, true, 5000);
+	}
+	else
+	{
+		_progress = lcd_selftest_screen(7, _progress, 3, true, 5000);
+	}
+
+	lcd_implementation_clear();
+	lcd_next_update_millis = millis() + LCD_UPDATE_INTERVAL;
+
+	if (_result)
+	{
+		LCD_ALERTMESSAGERPGM(MSG_SELFTEST_OK);
+	}
+	else
+	{
+		LCD_ALERTMESSAGERPGM(MSG_SELFTEST_FAILED);
+	}
+}
+static bool lcd_selfcheck_endstops()
+{
+	bool _result = true;
+
+	if (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1 || READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1 || READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1)
+	{
+		current_position[0] = (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? current_position[0] = current_position[0] + 10 : current_position[0];
+		current_position[1] = (READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1) ? current_position[1] = current_position[1] + 10 : current_position[1];
+		current_position[2] = (READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1) ? current_position[2] = current_position[2] + 10 : current_position[2];
+	}
+	plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[0] / 60, active_extruder);
+	delay(500);
+
+	if (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1 || READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1 || READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1)
+	{
+		_result = false;
+		String  _error = String((READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? "X" : "") +
+			String((READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1) ? "Y" : "") +
+			String((READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1) ? "Z" : "");
+		lcd_selftest_error(3, _error.c_str(), "");
+	}
+	manage_heater();
+	manage_inactivity();
+	return _result;
+}
+static bool lcd_selfcheck_axis(int _axis, int _travel)
+{
+	bool _stepdone = false;
+	bool _stepresult = false;
+	int _progress = 0;
+	int _travel_done = 0;
+	int _err_endstop = 0;
+	int _lcd_refresh = 0;
+	_travel = _travel + (_travel / 10);
+
+	do {
+
+		if (_axis == 2)
+		{
+			current_position[_axis] = current_position[_axis] - 1;
+		}
+		else
+		{
+			current_position[_axis] = current_position[_axis] - 3;
+		}
+
+		plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder);
+		st_synchronize();
+
+		if (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1 || READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1 || READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1)
+		{
+			if (_axis == 0)
+			{
+				_stepresult = (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? true : false;
+				_err_endstop = (READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1) ? 1 : 2;
+				disable_x();
+			}
+			if (_axis == 1)
+			{
+				_stepresult = (READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1) ? true : false;
+				_err_endstop = (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? 0 : 2;
+				disable_y();
+			}
+			if (_axis == 2)
+			{
+				_stepresult = (READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING == 1) ? true : false;
+				_err_endstop = (READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) ? 0 : 1;
+				disable_z();
+			}
+			_stepdone = true;
+		}
+
+		if (_lcd_refresh < 6)
+		{
+			_lcd_refresh++;
+		}
+		else
+		{
+			_progress = lcd_selftest_screen(2 + _axis, _progress, 3, false, 0);
+			_lcd_refresh = 0;
+		}
+
+		manage_heater();
+		manage_inactivity();
+
+		delay(100);
+		(_travel_done <= _travel) ? _travel_done++ : _stepdone = true;
+
+	} while (!_stepdone);
+
+
+	current_position[_axis] = current_position[_axis] + 15;
+	plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder);
+
+	if (!_stepresult)
+	{
+		const char *_error_1;
+		const char *_error_2;
+
+		if (_axis == X_AXIS) _error_1 = "X";
+		if (_axis == Y_AXIS) _error_1 = "Y";
+		if (_axis == Z_AXIS) _error_1 = "Z";
+
+		if (_err_endstop == 0) _error_2 = "X";
+		if (_err_endstop == 1) _error_2 = "Y";
+		if (_err_endstop == 2) _error_2 = "Z";
+
+		if (_travel_done >= _travel)
+		{
+			lcd_selftest_error(5, _error_1, _error_2);
+		}
+		else
+		{
+			lcd_selftest_error(4, _error_1, _error_2);
+		}
+	}
+
+	return _stepresult;
+}
+static bool lcd_selfcheck_check_heater(bool _isbed)
+{
+	int _counter = 0;
+	int _progress = 0;
+	bool _stepresult = false;
+	bool _docycle = true;
+
+	int _checked_snapshot = (_isbed) ? degBed() : degHotend(0);
+	int _opposite_snapshot = (_isbed) ? degHotend(0) : degBed();
+	int _cycles = (_isbed) ? 120 : 30;
+
+	target_temperature[0] = (_isbed) ? 0 : 100;
+	target_temperature_bed = (_isbed) ? 100 : 0;
+	manage_heater();
+	manage_inactivity();
+
+	do {
+		_counter++;
+		(_counter < _cycles) ? _docycle = true : _docycle = false;
+
+		manage_heater();
+		manage_inactivity();
+		_progress = (_isbed) ? lcd_selftest_screen(5, _progress, 2, false, 400) : lcd_selftest_screen(1, _progress, 2, false, 400);
+
+	} while (_docycle);
+
+	target_temperature[0] = 0;
+	target_temperature_bed = 0;
+	manage_heater();
+
+	int _checked_result = (_isbed) ? degBed() - _checked_snapshot : degHotend(0) - _checked_snapshot;
+	int _opposite_result = (_isbed) ? degHotend(0) - _opposite_snapshot : degBed() - _opposite_snapshot;
+
+	if (_opposite_result < (_isbed) ? 10 : 3)
+	{
+		if (_checked_result >= (_isbed) ? 3 : 10)
+		{
+			_stepresult = true;
+		}
+		else
+		{
+			lcd_selftest_error(1, "", "");
+		}
+	}
+	else
+	{
+		lcd_selftest_error(2, "", "");
+	}
+
+	manage_heater();
+	manage_inactivity();
+	return _stepresult;
+
+}
+static void lcd_selftest_error(int _error_no, const char *_error_1, const char *_error_2)
+{
+	lcd_implementation_quick_feedback();
+
+	target_temperature[0] = 0;
+	target_temperature_bed = 0;
+	manage_heater();
+	manage_inactivity();
+
+	lcd_implementation_clear();
+
+	lcd.setCursor(0, 0);
+	lcd_printPGM(MSG_SELFTEST_ERROR);
+	lcd.setCursor(0, 1);
+	lcd_printPGM(MSG_SELFTEST_PLEASECHECK);
+
+	switch (_error_no)
+	{
+	case 1:
+		lcd.setCursor(0, 2);
+		lcd_printPGM(MSG_SELFTEST_HEATERTHERMISTOR);
+		lcd.setCursor(0, 3);
+		lcd_printPGM(MSG_SELFTEST_NOTCONNECTED);
+		break;
+	case 2:
+		lcd.setCursor(0, 2);
+		lcd_printPGM(MSG_SELFTEST_BEDHEATER);
+		lcd.setCursor(0, 3);
+		lcd_printPGM(MSG_SELFTEST_WIRINGERROR);
+		break;
+	case 3:
+		lcd.setCursor(0, 2);
+		lcd_printPGM(MSG_SELFTEST_ENDSTOPS);
+		lcd.setCursor(0, 3);
+		lcd_printPGM(MSG_SELFTEST_WIRINGERROR);
+		lcd.setCursor(17, 3);
+		lcd.print(_error_1);
+		break;
+	case 4:
+		lcd.setCursor(0, 2);
+		lcd_printPGM(MSG_SELFTEST_MOTOR);
+		lcd.setCursor(18, 2);
+		lcd.print(_error_1);
+		lcd.setCursor(0, 3);
+		lcd_printPGM(MSG_SELFTEST_ENDSTOP);
+		lcd.setCursor(18, 3);
+		lcd.print(_error_2);
+		break;
+	case 5:
+		lcd.setCursor(0, 2);
+		lcd_printPGM(MSG_SELFTEST_ENDSTOP_NOTHIT);
+		lcd.setCursor(0, 3);
+		lcd_printPGM(MSG_SELFTEST_MOTOR);
+		lcd.setCursor(18, 3);
+		lcd.print(_error_1);
+		break;
+
+	}
+
+	delay(1000);
+	lcd_implementation_quick_feedback();
+
+	do {
+		delay(100);
+		manage_heater();
+		manage_inactivity();
+	} while (!lcd_clicked());
+
+	LCD_ALERTMESSAGERPGM(MSG_SELFTEST_FAILED);
+	lcd_return_to_status();
+
+}
+static int lcd_selftest_screen(int _step, int _progress, int _progress_scale, bool _clear, int _delay)
+{
+	lcd_next_update_millis = millis() + (LCD_UPDATE_INTERVAL * 10000);
+
+	int _step_block = 0;
+	const char *_indicator = (_progress > _progress_scale) ? "-" : "|";
+
+	if (_clear) lcd_implementation_clear();
+
+
+	lcd.setCursor(0, 0);
+
+	if (_step == -1) lcd_printPGM(MSG_SELFTEST_START);
+	if (_step == 0) lcd_printPGM(MSG_SELFTEST_CHECK_ENDSTOPS);
+	if (_step == 1) lcd_printPGM(MSG_SELFTEST_CHECK_HOTEND);
+	if (_step == 2) lcd_printPGM(MSG_SELFTEST_CHECK_X);
+	if (_step == 3) lcd_printPGM(MSG_SELFTEST_CHECK_Y);
+	if (_step == 4) lcd_printPGM(MSG_SELFTEST_CHECK_Z);
+	if (_step == 5) lcd_printPGM(MSG_SELFTEST_CHECK_BED);
+	if (_step == 6) lcd_printPGM(MSG_SELFTEST_CHECK_ALLCORRECT);
+	if (_step == 7) lcd_printPGM(MSG_SELFTEST_FAILED);
+
+	lcd.setCursor(0, 1);
+	lcd.print("--------------------");
+
+	_step_block = 1;
+	lcd_selftest_screen_step(3, 9, ((_step == _step_block) ? 1 : (_step < _step_block) ? 0 : 2), "Hotend", _indicator);
+
+	_step_block = 2;
+	lcd_selftest_screen_step(2, 2, ((_step == _step_block) ? 1 : (_step < _step_block) ? 0 : 2), "X", _indicator);
+
+	_step_block = 3;
+	lcd_selftest_screen_step(2, 8, ((_step == _step_block) ? 1 : (_step < _step_block) ? 0 : 2), "Y", _indicator);
+
+	_step_block = 4;
+	lcd_selftest_screen_step(2, 14, ((_step == _step_block) ? 1 : (_step < _step_block) ? 0 : 2), "Z", _indicator);
+
+	_step_block = 5;
+	lcd_selftest_screen_step(3, 0, ((_step == _step_block) ? 1 : (_step < _step_block) ? 0 : 2), "Bed", _indicator);
+
+
+	if (_delay > 0) delay(_delay);
+	_progress++;
+
+	return (_progress > _progress_scale * 2) ? 0 : _progress;
+}
+static void lcd_selftest_screen_step(int _row, int _col, int _state, const char *_name, const char *_indicator)
+{
+	lcd.setCursor(_col, _row);
+
+	switch (_state)
+	{
+	case 1:
+		lcd.print(_name);
+		lcd.setCursor(_col + strlen(_name), _row);
+		lcd.print(":");
+		lcd.setCursor(_col + strlen(_name) + 1, _row);
+		lcd.print(_indicator);
+		break;
+	case 2:
+		lcd.print(_name);
+		lcd.setCursor(_col + strlen(_name), _row);
+		lcd.print(":");
+		lcd.setCursor(_col + strlen(_name) + 1, _row);
+		lcd.print("OK");
+		break;
+	default:
+		lcd.print(_name);
+	}
+}
+
+
+/** End of menus **/
+
+static void lcd_quick_feedback()
+{
+  lcdDrawUpdate = 2;
+  blocking_enc = millis() + 500;
+  lcd_implementation_quick_feedback();
+}
+
+/** Menu action functions **/
+static void menu_action_back(menuFunc_t data) {
+  lcd_goto_menu(data);
+}
+static void menu_action_submenu(menuFunc_t data) {
+  lcd_goto_menu(data);
+}
+static void menu_action_gcode(const char* pgcode) {
+  enquecommand_P(pgcode);
+}
+static void menu_action_setlang(unsigned char lang) {
+  lcd_set_lang(lang);
+}
+static void menu_action_function(menuFunc_t data) {
+  (*data)();
+}
+static void menu_action_sdfile(const char* filename, char* longFilename)
+{
+  char cmd[30];
+  char* c;
+  sprintf_P(cmd, PSTR("M23 %s"), filename);
+  for (c = &cmd[4]; *c; c++)
+    *c = tolower(*c);
+  enquecommand(cmd);
+  enquecommand_P(PSTR("M24"));
+  lcd_return_to_status();
+}
+static void menu_action_sddirectory(const char* filename, char* longFilename)
+{
+  card.chdir(filename);
+  encoderPosition = 0;
+}
+static void menu_action_setting_edit_bool(const char* pstr, bool* ptr)
+{
+  *ptr = !(*ptr);
+}
+static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, menuFunc_t callback)
+{
+  menu_action_setting_edit_bool(pstr, ptr);
+  (*callback)();
+}
+#endif//ULTIPANEL
+
+/** LCD API **/
+void lcd_init()
+{
+  lcd_implementation_init();
+
+#ifdef NEWPANEL
+  SET_INPUT(BTN_EN1);
+  SET_INPUT(BTN_EN2);
+  WRITE(BTN_EN1, HIGH);
+  WRITE(BTN_EN2, HIGH);
+#if BTN_ENC > 0
+  SET_INPUT(BTN_ENC);
+  WRITE(BTN_ENC, HIGH);
+#endif
+#ifdef REPRAPWORLD_KEYPAD
+  pinMode(SHIFT_CLK, OUTPUT);
+  pinMode(SHIFT_LD, OUTPUT);
+  pinMode(SHIFT_OUT, INPUT);
+  WRITE(SHIFT_OUT, HIGH);
+  WRITE(SHIFT_LD, HIGH);
+#endif
+#else  // Not NEWPANEL
+#ifdef SR_LCD_2W_NL // Non latching 2 wire shift register
+  pinMode (SR_DATA_PIN, OUTPUT);
+  pinMode (SR_CLK_PIN, OUTPUT);
+#elif defined(SHIFT_CLK)
+  pinMode(SHIFT_CLK, OUTPUT);
+  pinMode(SHIFT_LD, OUTPUT);
+  pinMode(SHIFT_EN, OUTPUT);
+  pinMode(SHIFT_OUT, INPUT);
+  WRITE(SHIFT_OUT, HIGH);
+  WRITE(SHIFT_LD, HIGH);
+  WRITE(SHIFT_EN, LOW);
+#else
+#ifdef ULTIPANEL
+#error ULTIPANEL requires an encoder
+#endif
+#endif // SR_LCD_2W_NL
+#endif//!NEWPANEL
+
+#if defined (SDSUPPORT) && defined(SDCARDDETECT) && (SDCARDDETECT > 0)
+  pinMode(SDCARDDETECT, INPUT);
+  WRITE(SDCARDDETECT, HIGH);
+  lcd_oldcardstatus = IS_SD_INSERTED;
+#endif//(SDCARDDETECT > 0)
+#ifdef LCD_HAS_SLOW_BUTTONS
+  slow_buttons = 0;
+#endif
+  lcd_buttons_update();
+#ifdef ULTIPANEL
+  encoderDiff = 0;
+#endif
+}
+
+
+
+
+//#include <avr/pgmspace.h>
+
+static volatile bool lcd_update_enabled = true;
+
+void lcd_update_enable(bool enabled)
+{
+    lcd_update_enabled = enabled;
+}
+
+void lcd_update()
+{
+	static unsigned long timeoutToStatus = 0;
+
+  if (! lcd_update_enabled)
+      return;
+
+#ifdef LCD_HAS_SLOW_BUTTONS
+  slow_buttons = lcd_implementation_read_slow_buttons(); // buttons which take too long to read in interrupt context
+#endif
+
+  lcd_buttons_update();
+
+#if (SDCARDDETECT > 0)
+  if ((IS_SD_INSERTED != lcd_oldcardstatus && lcd_detected()))
+  {
+	  lcdDrawUpdate = 2;
+	  lcd_oldcardstatus = IS_SD_INSERTED;
+	  lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
+#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
+		  currentMenu == lcd_status_screen
+#endif
+	  );
+
+	  if (lcd_oldcardstatus)
+	  {
+		  card.initsd();
+		  LCD_MESSAGERPGM(MSG_SD_INSERTED);
+	  }
+	  else
+	  {
+		  card.release();
+		  LCD_MESSAGERPGM(MSG_SD_REMOVED);
+	  }
+  }
+#endif//CARDINSERTED
+
+  if (lcd_next_update_millis < millis())
+  {
+#ifdef ULTIPANEL
+#ifdef REPRAPWORLD_KEYPAD
+	  if (REPRAPWORLD_KEYPAD_MOVE_Z_UP) {
+		  reprapworld_keypad_move_z_up();
+	  }
+	  if (REPRAPWORLD_KEYPAD_MOVE_Z_DOWN) {
+		  reprapworld_keypad_move_z_down();
+	  }
+	  if (REPRAPWORLD_KEYPAD_MOVE_X_LEFT) {
+		  reprapworld_keypad_move_x_left();
+	  }
+	  if (REPRAPWORLD_KEYPAD_MOVE_X_RIGHT) {
+		  reprapworld_keypad_move_x_right();
+	  }
+	  if (REPRAPWORLD_KEYPAD_MOVE_Y_DOWN) {
+		  reprapworld_keypad_move_y_down();
+	  }
+	  if (REPRAPWORLD_KEYPAD_MOVE_Y_UP) {
+		  reprapworld_keypad_move_y_up();
+	  }
+	  if (REPRAPWORLD_KEYPAD_MOVE_HOME) {
+		  reprapworld_keypad_move_home();
+	  }
+#endif
+	  if (abs(encoderDiff) >= ENCODER_PULSES_PER_STEP)
+	  {
+		  lcdDrawUpdate = 1;
+		  encoderPosition += encoderDiff / ENCODER_PULSES_PER_STEP;
+		  encoderDiff = 0;
+		  timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS;
+	  }
+	  if (LCD_CLICKED)
+		  timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS;
+#endif//ULTIPANEL
+
+#ifdef DOGLCD        // Changes due to different driver architecture of the DOGM display
+	  blink++;     // Variable for fan animation and alive dot
+	  u8g.firstPage();
+	  do
+	  {
+		  u8g.setFont(u8g_font_6x10_marlin);
+		  u8g.setPrintPos(125, 0);
+		  if (blink % 2) u8g.setColorIndex(1); else u8g.setColorIndex(0); // Set color for the alive dot
+		  u8g.drawPixel(127, 63); // draw alive dot
+		  u8g.setColorIndex(1); // black on white
+		  (*currentMenu)();
+		  if (!lcdDrawUpdate)  break; // Terminate display update, when nothing new to draw. This must be done before the last dogm.next()
+	  } while (u8g.nextPage());
+#else
+	  (*currentMenu)();
+#endif
+
+#ifdef LCD_HAS_STATUS_INDICATORS
+	  lcd_implementation_update_indicators();
+#endif
+
+#ifdef ULTIPANEL
+	  if (timeoutToStatus < millis() && currentMenu != lcd_status_screen)
+	  {
+		  lcd_return_to_status();
+		  lcdDrawUpdate = 2;
+	  }
+#endif//ULTIPANEL
+	  if (lcdDrawUpdate == 2) lcd_implementation_clear();
+	  if (lcdDrawUpdate) lcdDrawUpdate--;
+	  lcd_next_update_millis = millis() + LCD_UPDATE_INTERVAL;
+	  }
+   
+}
+
+void lcd_ignore_click(bool b)
+{
+  ignore_click = b;
+  wait_for_unclick = false;
+}
+
+void lcd_finishstatus() {
+  int len = strlen(lcd_status_message);
+  if (len > 0) {
+    while (len < LCD_WIDTH) {
+      lcd_status_message[len++] = ' ';
+    }
+  }
+  lcd_status_message[LCD_WIDTH] = '\0';
+#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
+#if PROGRESS_MSG_EXPIRE > 0
+  messageTick =
+#endif
+    progressBarTick = millis();
+#endif
+  lcdDrawUpdate = 2;
+
+#ifdef FILAMENT_LCD_DISPLAY
+  message_millis = millis();  //get status message to show up for a while
+#endif
+}
+void lcd_setstatus(const char* message)
+{
+  if (lcd_status_message_level > 0)
+    return;
+  strncpy(lcd_status_message, message, LCD_WIDTH);
+  lcd_finishstatus();
+}
+void lcd_setstatuspgm(const char* message)
+{
+  if (lcd_status_message_level > 0)
+    return;
+  strncpy_P(lcd_status_message, message, LCD_WIDTH);
+  lcd_finishstatus();
+}
+void lcd_setalertstatuspgm(const char* message)
+{
+  lcd_setstatuspgm(message);
+  lcd_status_message_level = 1;
+#ifdef ULTIPANEL
+  lcd_return_to_status();
+#endif//ULTIPANEL
+}
+void lcd_reset_alert_level()
+{
+  lcd_status_message_level = 0;
+}
+
+#ifdef DOGLCD
+void lcd_setcontrast(uint8_t value)
+{
+  lcd_contrast = value & 63;
+  u8g.setContrast(lcd_contrast);
+}
+#endif
+
+#ifdef ULTIPANEL
+/* Warning: This function is called from interrupt context */
+void lcd_buttons_update()
+{
+#ifdef NEWPANEL
+  uint8_t newbutton = 0;
+  if (READ(BTN_EN1) == 0)  newbutton |= EN_A;
+  if (READ(BTN_EN2) == 0)  newbutton |= EN_B;
+#if BTN_ENC > 0
+  if ((blocking_enc < millis()) && (READ(BTN_ENC) == 0))
+    newbutton |= EN_C;
+#endif
+  buttons = newbutton;
+#ifdef LCD_HAS_SLOW_BUTTONS
+  buttons |= slow_buttons;
+#endif
+#ifdef REPRAPWORLD_KEYPAD
+  // for the reprapworld_keypad
+  uint8_t newbutton_reprapworld_keypad = 0;
+  WRITE(SHIFT_LD, LOW);
+  WRITE(SHIFT_LD, HIGH);
+  for (int8_t i = 0; i < 8; i++) {
+    newbutton_reprapworld_keypad = newbutton_reprapworld_keypad >> 1;
+    if (READ(SHIFT_OUT))
+      newbutton_reprapworld_keypad |= (1 << 7);
+    WRITE(SHIFT_CLK, HIGH);
+    WRITE(SHIFT_CLK, LOW);
+  }
+  buttons_reprapworld_keypad = ~newbutton_reprapworld_keypad; //invert it, because a pressed switch produces a logical 0
+#endif
+#else   //read it from the shift register
+  uint8_t newbutton = 0;
+  WRITE(SHIFT_LD, LOW);
+  WRITE(SHIFT_LD, HIGH);
+  unsigned char tmp_buttons = 0;
+  for (int8_t i = 0; i < 8; i++)
+  {
+    newbutton = newbutton >> 1;
+    if (READ(SHIFT_OUT))
+      newbutton |= (1 << 7);
+    WRITE(SHIFT_CLK, HIGH);
+    WRITE(SHIFT_CLK, LOW);
+  }
+  buttons = ~newbutton; //invert it, because a pressed switch produces a logical 0
+#endif//!NEWPANEL
+
+  //manage encoder rotation
+  uint8_t enc = 0;
+  if (buttons & EN_A) enc |= B01;
+  if (buttons & EN_B) enc |= B10;
+  if (enc != lastEncoderBits)
+  {
+    switch (enc)
+    {
+      case encrot0:
+        if (lastEncoderBits == encrot3)
+          encoderDiff++;
+        else if (lastEncoderBits == encrot1)
+          encoderDiff--;
+        break;
+      case encrot1:
+        if (lastEncoderBits == encrot0)
+          encoderDiff++;
+        else if (lastEncoderBits == encrot2)
+          encoderDiff--;
+        break;
+      case encrot2:
+        if (lastEncoderBits == encrot1)
+          encoderDiff++;
+        else if (lastEncoderBits == encrot3)
+          encoderDiff--;
+        break;
+      case encrot3:
+        if (lastEncoderBits == encrot2)
+          encoderDiff++;
+        else if (lastEncoderBits == encrot0)
+          encoderDiff--;
+        break;
+    }
+  }
+  lastEncoderBits = enc;
+}
+
+bool lcd_detected(void)
+{
+#if (defined(LCD_I2C_TYPE_MCP23017) || defined(LCD_I2C_TYPE_MCP23008)) && defined(DETECT_DEVICE)
+  return lcd.LcdDetected() == 1;
+#else
+  return true;
+#endif
+}
+
+void lcd_buzz(long duration, uint16_t freq)
+{
+#ifdef LCD_USE_I2C_BUZZER
+  lcd.buzz(duration, freq);
+#endif
+}
+
+bool lcd_clicked()
+{
+  return LCD_CLICKED;
+}
+#endif//ULTIPANEL
+
+/********************************/
+/** Float conversion utilities **/
+/********************************/
+//  convert float to string with +123.4 format
+char conv[8];
+char *ftostr3(const float &x)
+{
+  return itostr3((int)x);
+}
+
+char *itostr2(const uint8_t &x)
+{
+  //sprintf(conv,"%5.1f",x);
+  int xx = x;
+  conv[0] = (xx / 10) % 10 + '0';
+  conv[1] = (xx) % 10 + '0';
+  conv[2] = 0;
+  return conv;
+}
+
+// Convert float to string with 123.4 format, dropping sign
+char *ftostr31(const float &x)
+{
+  int xx = x * 10;
+  conv[0] = (xx >= 0) ? '+' : '-';
+  xx = abs(xx);
+  conv[1] = (xx / 1000) % 10 + '0';
+  conv[2] = (xx / 100) % 10 + '0';
+  conv[3] = (xx / 10) % 10 + '0';
+  conv[4] = '.';
+  conv[5] = (xx) % 10 + '0';
+  conv[6] = 0;
+  return conv;
+}
+
+// Convert float to string with 123.4 format
+char *ftostr31ns(const float &x)
+{
+  int xx = x * 10;
+  //conv[0]=(xx>=0)?'+':'-';
+  xx = abs(xx);
+  conv[0] = (xx / 1000) % 10 + '0';
+  conv[1] = (xx / 100) % 10 + '0';
+  conv[2] = (xx / 10) % 10 + '0';
+  conv[3] = '.';
+  conv[4] = (xx) % 10 + '0';
+  conv[5] = 0;
+  return conv;
+}
+
+char *ftostr32(const float &x)
+{
+  long xx = x * 100;
+  if (xx >= 0)
+    conv[0] = (xx / 10000) % 10 + '0';
+  else
+    conv[0] = '-';
+  xx = abs(xx);
+  conv[1] = (xx / 1000) % 10 + '0';
+  conv[2] = (xx / 100) % 10 + '0';
+  conv[3] = '.';
+  conv[4] = (xx / 10) % 10 + '0';
+  conv[5] = (xx) % 10 + '0';
+  conv[6] = 0;
+  return conv;
+}
+
+//// Convert float to rj string with 123.45 format
+char *ftostr32ns(const float &x) {
+	long xx = abs(x);
+	conv[0] = xx >= 10000 ? (xx / 10000) % 10 + '0' : ' ';
+	conv[1] = xx >= 1000 ? (xx / 1000) % 10 + '0' : ' ';
+	conv[2] = xx >= 100 ? (xx / 100) % 10 + '0' : '0';
+	conv[3] = '.';
+	conv[4] = (xx / 10) % 10 + '0';
+	conv[5] = xx % 10 + '0';
+	return conv;
+}
+
+
+// Convert float to string with 1.234 format
+char *ftostr43(const float &x)
+{
+  long xx = x * 1000;
+  if (xx >= 0)
+    conv[0] = (xx / 1000) % 10 + '0';
+  else
+    conv[0] = '-';
+  xx = abs(xx);
+  conv[1] = '.';
+  conv[2] = (xx / 100) % 10 + '0';
+  conv[3] = (xx / 10) % 10 + '0';
+  conv[4] = (xx) % 10 + '0';
+  conv[5] = 0;
+  return conv;
+}
+
+//Float to string with 1.23 format
+char *ftostr12ns(const float &x)
+{
+  long xx = x * 100;
+
+  xx = abs(xx);
+  conv[0] = (xx / 100) % 10 + '0';
+  conv[1] = '.';
+  conv[2] = (xx / 10) % 10 + '0';
+  conv[3] = (xx) % 10 + '0';
+  conv[4] = 0;
+  return conv;
+}
+
+//Float to string with 1.234 format
+char *ftostr13ns(const float &x)
+{
+    long xx = x * 1000;
+    if (xx >= 0)
+        conv[0] = ' ';
+    else
+        conv[0] = '-';
+    xx = abs(xx);
+    conv[1] = (xx / 1000) % 10 + '0';
+    conv[2] = '.';
+    conv[3] = (xx / 100) % 10 + '0';
+    conv[4] = (xx / 10) % 10 + '0';
+    conv[5] = (xx) % 10 + '0';
+    conv[6] = 0;
+    return conv;
+}
+
+//  convert float to space-padded string with -_23.4_ format
+char *ftostr32sp(const float &x) {
+  long xx = abs(x * 100);
+  uint8_t dig;
+
+  if (x < 0) { // negative val = -_0
+    conv[0] = '-';
+    dig = (xx / 1000) % 10;
+    conv[1] = dig ? '0' + dig : ' ';
+  }
+  else { // positive val = __0
+    dig = (xx / 10000) % 10;
+    if (dig) {
+      conv[0] = '0' + dig;
+      conv[1] = '0' + (xx / 1000) % 10;
+    }
+    else {
+      conv[0] = ' ';
+      dig = (xx / 1000) % 10;
+      conv[1] = dig ? '0' + dig : ' ';
+    }
+  }
+
+  conv[2] = '0' + (xx / 100) % 10; // lsd always
+
+  dig = xx % 10;
+  if (dig) { // 2 decimal places
+    conv[5] = '0' + dig;
+    conv[4] = '0' + (xx / 10) % 10;
+    conv[3] = '.';
+  }
+  else { // 1 or 0 decimal place
+    dig = (xx / 10) % 10;
+    if (dig) {
+      conv[4] = '0' + dig;
+      conv[3] = '.';
+    }
+    else {
+      conv[3] = conv[4] = ' ';
+    }
+    conv[5] = ' ';
+  }
+  conv[6] = '\0';
+  return conv;
+}
+
+char *itostr31(const int &xx)
+{
+  conv[0] = (xx >= 0) ? '+' : '-';
+  conv[1] = (xx / 1000) % 10 + '0';
+  conv[2] = (xx / 100) % 10 + '0';
+  conv[3] = (xx / 10) % 10 + '0';
+  conv[4] = '.';
+  conv[5] = (xx) % 10 + '0';
+  conv[6] = 0;
+  return conv;
+}
+
+// Convert int to rj string with 123 or -12 format
+char *itostr3(const int &x)
+{
+  int xx = x;
+  if (xx < 0) {
+    conv[0] = '-';
+    xx = -xx;
+  } else if (xx >= 100)
+    conv[0] = (xx / 100) % 10 + '0';
+  else
+    conv[0] = ' ';
+  if (xx >= 10)
+    conv[1] = (xx / 10) % 10 + '0';
+  else
+    conv[1] = ' ';
+  conv[2] = (xx) % 10 + '0';
+  conv[3] = 0;
+  return conv;
+}
+
+// Convert int to lj string with 123 format
+char *itostr3left(const int &xx)
+{
+  if (xx >= 100)
+  {
+    conv[0] = (xx / 100) % 10 + '0';
+    conv[1] = (xx / 10) % 10 + '0';
+    conv[2] = (xx) % 10 + '0';
+    conv[3] = 0;
+  }
+  else if (xx >= 10)
+  {
+    conv[0] = (xx / 10) % 10 + '0';
+    conv[1] = (xx) % 10 + '0';
+    conv[2] = 0;
+  }
+  else
+  {
+    conv[0] = (xx) % 10 + '0';
+    conv[1] = 0;
+  }
+  return conv;
+}
+
+// Convert int to rj string with 1234 format
+char *itostr4(const int &xx) {
+  conv[0] = xx >= 1000 ? (xx / 1000) % 10 + '0' : ' ';
+  conv[1] = xx >= 100 ? (xx / 100) % 10 + '0' : ' ';
+  conv[2] = xx >= 10 ? (xx / 10) % 10 + '0' : ' ';
+  conv[3] = xx % 10 + '0';
+  conv[4] = 0;
+  return conv;
+}
+
+// Convert float to rj string with 12345 format
+char *ftostr5(const float &x) {
+  long xx = abs(x);
+  conv[0] = xx >= 10000 ? (xx / 10000) % 10 + '0' : ' ';
+  conv[1] = xx >= 1000 ? (xx / 1000) % 10 + '0' : ' ';
+  conv[2] = xx >= 100 ? (xx / 100) % 10 + '0' : ' ';
+  conv[3] = xx >= 10 ? (xx / 10) % 10 + '0' : ' ';
+  conv[4] = xx % 10 + '0';
+  conv[5] = 0;
+  return conv;
+}
+
+// Convert float to string with +1234.5 format
+char *ftostr51(const float &x)
+{
+  long xx = x * 10;
+  conv[0] = (xx >= 0) ? '+' : '-';
+  xx = abs(xx);
+  conv[1] = (xx / 10000) % 10 + '0';
+  conv[2] = (xx / 1000) % 10 + '0';
+  conv[3] = (xx / 100) % 10 + '0';
+  conv[4] = (xx / 10) % 10 + '0';
+  conv[5] = '.';
+  conv[6] = (xx) % 10 + '0';
+  conv[7] = 0;
+  return conv;
+}
+
+// Convert float to string with +123.45 format
+char *ftostr52(const float &x)
+{
+  long xx = x * 100;
+  conv[0] = (xx >= 0) ? '+' : '-';
+  xx = abs(xx);
+  conv[1] = (xx / 10000) % 10 + '0';
+  conv[2] = (xx / 1000) % 10 + '0';
+  conv[3] = (xx / 100) % 10 + '0';
+  conv[4] = '.';
+  conv[5] = (xx / 10) % 10 + '0';
+  conv[6] = (xx) % 10 + '0';
+  conv[7] = 0;
+  return conv;
+}
+
+// Callback for after editing PID i value
+// grab the PID i value out of the temp variable; scale it; then update the PID driver
+void copy_and_scalePID_i()
+{
+#ifdef PIDTEMP
+  Ki = scalePID_i(raw_Ki);
+  updatePID();
+#endif
+}
+
+// Callback for after editing PID d value
+// grab the PID d value out of the temp variable; scale it; then update the PID driver
+void copy_and_scalePID_d()
+{
+#ifdef PIDTEMP
+  Kd = scalePID_d(raw_Kd);
+  updatePID();
+#endif
+}
+
 #endif //ULTRA_LCD

Firmware/ultralcd.h

@@ -6,6 +6,8 @@
 #ifdef ULTRA_LCD
 
   void lcd_update();
+  // Call with a false parameter to suppress the LCD update from various places like the planner or the temp control.
+  void lcd_update_enable(bool enable);
   void lcd_init();
   void lcd_setstatus(const char* message);
   void lcd_setstatuspgm(const char* message);
@@ -23,7 +25,6 @@
   void lcd_loading_color();
   void lcd_force_language_selection();
   void lcd_sdcard_stop();
-  void lcd_calibration();
   
   bool lcd_detected(void);
 
@@ -36,6 +37,9 @@
   static void lcd_selftest_error(int _error_no, const char *_error_1, const char *_error_2);
   static void lcd_menu_statistics();
 
+  extern bool lcd_calibrate_z_end_stop_manual();
+  extern void lcd_diag_show_end_stops();
+
 #ifdef DOGLCD
   extern int lcd_contrast;
   void lcd_setcontrast(uint8_t value);
@@ -154,4 +158,16 @@ char *ftostr5(const float &x);
 char *ftostr51(const float &x);
 char *ftostr52(const float &x);
 
+
+extern void lcd_implementation_clear();
+extern void lcd_printPGM(const char* str);
+extern void lcd_print_at_PGM(uint8_t x, uint8_t y, const char* str);
+extern void lcd_implementation_print(const char *str);
+extern void lcd_implementation_print(int8_t i);
+extern void lcd_implementation_print_at(uint8_t x, uint8_t y, int8_t i);
+extern void lcd_implementation_print(int i);
+extern void lcd_implementation_print_at(uint8_t x, uint8_t y, int i);
+extern void lcd_implementation_print(float f);
+extern void lcd_implementation_print_at(uint8_t x, uint8_t y, const char *str);
+
 #endif //ULTRALCD_H

Firmware/ultralcd_implementation_hitachi_HD44780.h

@@ -567,12 +567,12 @@ static void lcd_implementation_display()
     lcd.display();
 }
 
-static void lcd_implementation_clear()
+void lcd_implementation_clear()
 {
     lcd.clear();
 }
 /* Arduino < 1.0.0 is missing a function to print PROGMEM strings, so we need to implement our own */
-static void lcd_printPGM(const char* str)
+void lcd_printPGM(const char* str)
 {
     char c;
     while((c = pgm_read_byte(str++)) != '\0')
@@ -580,6 +580,55 @@ static void lcd_printPGM(const char* str)
         lcd.write(c);
     }
 }
+
+void lcd_print_at_PGM(uint8_t x, uint8_t y, const char* str)
+{
+    lcd.setCursor(x, y);
+    char c;
+    while((c = pgm_read_byte(str++)) != '\0')
+    {
+        lcd.write(c);
+    }
+}
+
+void lcd_implementation_print(int8_t i)
+{
+    lcd.print(i);
+}
+
+void lcd_implementation_print_at(uint8_t x, uint8_t y, int8_t i)
+{
+    lcd.setCursor(x, y);
+    lcd.print(i);
+}
+
+void lcd_implementation_print(int i)
+{
+    lcd.print(i);
+}
+
+void lcd_implementation_print_at(uint8_t x, uint8_t y, int i)
+{
+    lcd.setCursor(x, y);
+    lcd.print(i);
+}
+
+void lcd_implementation_print(float f)
+{
+    lcd.print(f);
+}
+
+void lcd_implementation_print(const char *str)
+{
+    lcd.print(str);
+}
+
+void lcd_implementation_print_at(uint8_t x, uint8_t y, const char *str)
+{
+    lcd.setCursor(x, y);
+    lcd.print(str);
+}
+
 /*
 
 20x4   |01234567890123456789|