Merge pull request #44 from PavelSindler/MK2

German language added, updated spanish language messages, checking if…

Firmware/Configuration.h

@@ -5,7 +5,7 @@
 #include "Configuration_prusa.h"
 
 // Firmware version
-#define FW_version "3.0.10-RC1"
+#define FW_version "3.0.10"
 
 #define FW_PRUSA3D_MAGIC "PRUSA3DFW"
 #define FW_PRUSA3D_MAGIC_LEN 10

Firmware/Marlin.h

@@ -317,3 +317,13 @@ 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);
+
+extern void check_babystep();
+
+#ifdef DIS
+
+void d_setup();
+float d_ReadData();
+void bed_analysis(float x_dimension, float y_dimension, int x_points_num, int y_points_num, float shift_x, float shift_y);
+
+#endif

Firmware/Marlin_main.cpp

@@ -1155,7 +1155,9 @@ void setup()
     if (lang_selected >= LANG_NUM){
       lcd_mylang();
     }
-    
+
+	check_babystep(); //checking if Z babystep is in allowed range
+	
   if (calibration_status() == CALIBRATION_STATUS_ASSEMBLED ||
       calibration_status() == CALIBRATION_STATUS_UNKNOWN) {
       // Reset the babystepping values, so the printer will not move the Z axis up when the babystepping is enabled.
@@ -1553,7 +1555,7 @@ void get_command()
 // Return True if a character was found
 static inline bool    code_seen(char code) { return (strchr_pointer = strchr(CMDBUFFER_CURRENT_STRING, code)) != NULL; }
 static inline bool    code_seen(const char *code) { return (strchr_pointer = strstr(CMDBUFFER_CURRENT_STRING, code)) != NULL; }
-static inline float   code_value()         { return strtod(strchr_pointer+1, NULL); }
+static inline float   code_value()      { return strtod(strchr_pointer+1, NULL);}
 static inline long    code_value_long()    { return strtol(strchr_pointer+1, NULL, 10); }
 static inline int16_t code_value_short()   { return int16_t(strtol(strchr_pointer+1, NULL, 10)); };
 static inline uint8_t code_value_uint8()   { return uint8_t(strtol(strchr_pointer+1, NULL, 10)); };
@@ -1956,7 +1958,15 @@ void process_commands()
   int8_t SilentMode;
 #endif
   if(code_seen("PRUSA")){
-    if (code_seen("fv")) {
+	  if (code_seen("fn")) {
+		  if (farm_mode) {
+			  MYSERIAL.println(farm_no);
+		  }
+		  else {
+			  MYSERIAL.println("Not in farm mode.");
+		  }
+		  
+	}else if (code_seen("fv")) {
         // get file version
         #ifdef SDSUPPORT
         card.openFile(strchr_pointer + 3,true);
@@ -2756,8 +2766,37 @@ void process_commands()
      *  v Y-axis
      *
      */
+
+#ifdef DIS
+	case 77:
+	{
+		//G77 X200 Y150 XP100 YP15 XO10 Y015
+
+		//for 9 point mesh bed leveling G77 X203 Y196 XP3 YP3 XO0 YO0
+
+
+		//G77 X232 Y218 XP116 YP109 XO-11 YO0 
+
+		float dimension_x = 40;
+		float dimension_y = 40;
+		int points_x = 40;
+		int points_y = 40;
+		float offset_x = 74;
+		float offset_y = 33;
+
+		if (code_seen('X')) dimension_x = code_value();
+		if (code_seen('Y')) dimension_y = code_value();
+		if (code_seen('XP')) points_x = code_value();
+		if (code_seen('YP')) points_y = code_value();
+		if (code_seen('XO')) offset_x = code_value();
+		if (code_seen('YO')) offset_y = code_value();
+		
+		bed_analysis(dimension_x,dimension_y,points_x,points_y,offset_x,offset_y);
+		
+	} break;
 	
-	
+#endif
+
     case 80:
     case_G80:
         {
@@ -3087,9 +3126,17 @@ void process_commands()
 
   else if(code_seen('M'))
   {
-    switch( (int)code_value() )
+	  int index;
+	  for (index = 1; *(strchr_pointer + index) == ' ' || *(strchr_pointer + index) == '\t'; index++);
+	   
+	 /*for (++strchr_pointer; *strchr_pointer == ' ' || *strchr_pointer == '\t'; ++strchr_pointer);*/
+	  if (*(strchr_pointer+index) < '0' || *(strchr_pointer+index) > '9') {
+		  SERIAL_ECHOLNPGM("Invalid M code");
+	  } else
+    switch((int)code_value())
     {
 #ifdef ULTIPANEL
+
     case 0: // M0 - Unconditional stop - Wait for user button press on LCD
     case 1: // M1 - Conditional stop - Wait for user button press on LCD
     {
@@ -5104,7 +5151,7 @@ case 404:  //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
 	{
 		custom_message = true;
 		custom_message_type = 2;
-		lcd_setstatuspgm(MSG_UNLOADING_FILAMENT); //need to be tranlated to spanish language
+		lcd_setstatuspgm(MSG_UNLOADING_FILAMENT); 
 		
 		current_position[E_AXIS] -= 80;
 		plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 7000 / 60, active_extruder);
@@ -5122,98 +5169,109 @@ case 404:  //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
       gcode_LastN = Stopped_gcode_LastN;
       FlushSerialRequestResend();
     break;
+	default: SERIAL_ECHOLNPGM("Invalid M code.");
     }
+	
   } // end if(code_seen('M')) (end of M codes)
 
   else if(code_seen('T'))
   {
-    tmp_extruder = code_value();
+	  int index;
+	  for (index = 1; *(strchr_pointer + index) == ' ' || *(strchr_pointer + index) == '\t'; index++);
+	   
+	  if (*(strchr_pointer + index) < '0' || *(strchr_pointer + index) > '9') {
+		  SERIAL_ECHOLNPGM("Invalid T code.");
+	  }
+	  else {
+		  tmp_extruder = code_value();
 #ifdef SNMM
-          
-          st_synchronize();
-          delay(100);
-          
-          disable_e0();
-          disable_e1();
-          disable_e2();
-          
-          pinMode(E_MUX0_PIN,OUTPUT);
-          pinMode(E_MUX1_PIN,OUTPUT);
-          pinMode(E_MUX2_PIN,OUTPUT);
-          
-          delay(100);
-          SERIAL_ECHO_START;
-          SERIAL_ECHO("T:");
-          SERIAL_ECHOLN((int)tmp_extruder);
-          switch (tmp_extruder) {
-              case 1:
-                  WRITE(E_MUX0_PIN, HIGH);
-                  WRITE(E_MUX1_PIN, LOW);
-                  WRITE(E_MUX2_PIN, LOW);
-				  
-                  break;
-              case 2:
-                  WRITE(E_MUX0_PIN, LOW);
-                  WRITE(E_MUX1_PIN, HIGH);
-                  WRITE(E_MUX2_PIN, LOW);
-				  
-                  break;
-              case 3:
-                  WRITE(E_MUX0_PIN, HIGH);
-                  WRITE(E_MUX1_PIN, HIGH);
-                  WRITE(E_MUX2_PIN, LOW);
-				  
-                  break;
-              default:
-                  WRITE(E_MUX0_PIN, LOW);
-                  WRITE(E_MUX1_PIN, LOW);
-                  WRITE(E_MUX2_PIN, LOW);
-		
-                  break;
-          }
-          delay(100);
-          
+
+		  st_synchronize();
+		  delay(100);
+
+		  disable_e0();
+		  disable_e1();
+		  disable_e2();
+
+		  pinMode(E_MUX0_PIN, OUTPUT);
+		  pinMode(E_MUX1_PIN, OUTPUT);
+		  pinMode(E_MUX2_PIN, OUTPUT);
+
+		  delay(100);
+		  SERIAL_ECHO_START;
+		  SERIAL_ECHO("T:");
+		  SERIAL_ECHOLN((int)tmp_extruder);
+		  switch (tmp_extruder) {
+		  case 1:
+			  WRITE(E_MUX0_PIN, HIGH);
+			  WRITE(E_MUX1_PIN, LOW);
+			  WRITE(E_MUX2_PIN, LOW);
+
+			  break;
+		  case 2:
+			  WRITE(E_MUX0_PIN, LOW);
+			  WRITE(E_MUX1_PIN, HIGH);
+			  WRITE(E_MUX2_PIN, LOW);
+
+			  break;
+		  case 3:
+			  WRITE(E_MUX0_PIN, HIGH);
+			  WRITE(E_MUX1_PIN, HIGH);
+			  WRITE(E_MUX2_PIN, LOW);
+
+			  break;
+		  default:
+			  WRITE(E_MUX0_PIN, LOW);
+			  WRITE(E_MUX1_PIN, LOW);
+			  WRITE(E_MUX2_PIN, LOW);
+
+			  break;
+		  }
+		  delay(100);
+
 #else
-    if(tmp_extruder >= EXTRUDERS) {
-      SERIAL_ECHO_START;
-      SERIAL_ECHO("T");
-      SERIAL_ECHO(tmp_extruder);
-      SERIAL_ECHOLN(MSG_INVALID_EXTRUDER);
-    }
-    else {
-      boolean make_move = false;
-      if(code_seen('F')) {
-        make_move = true;
-        next_feedrate = code_value();
-        if(next_feedrate > 0.0) {
-          feedrate = next_feedrate;
-        }
-      }
-      #if EXTRUDERS > 1
-      if(tmp_extruder != active_extruder) {
-        // Save current position to return to after applying extruder offset
-        memcpy(destination, current_position, sizeof(destination));
-        // Offset extruder (only by XY)
-        int i;
-        for(i = 0; i < 2; i++) {
-           current_position[i] = current_position[i] -
-                                 extruder_offset[i][active_extruder] +
-                                 extruder_offset[i][tmp_extruder];
-        }
-        // Set the new active extruder and position
-        active_extruder = tmp_extruder;
-        plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
-        // Move to the old position if 'F' was in the parameters
-        if(make_move && Stopped == false) {
-           prepare_move();
-        }
-      }
-      #endif
-      SERIAL_ECHO_START;
-      SERIAL_ECHO(MSG_ACTIVE_EXTRUDER);
-      SERIAL_PROTOCOLLN((int)active_extruder);
-    }
+		  if (tmp_extruder >= EXTRUDERS) {
+			  SERIAL_ECHO_START;
+			  SERIAL_ECHOPGM("T");
+			  SERIAL_PROTOCOLLN((int)tmp_extruder);
+			  SERIAL_ECHOLNRPGM(MSG_INVALID_EXTRUDER);
+		  }
+		  else {
+			  boolean make_move = false;
+			  if (code_seen('F')) {
+				  make_move = true;
+				  next_feedrate = code_value();
+				  if (next_feedrate > 0.0) {
+					  feedrate = next_feedrate;
+				  }
+			  }
+#if EXTRUDERS > 1
+			  if (tmp_extruder != active_extruder) {
+				  // Save current position to return to after applying extruder offset
+				  memcpy(destination, current_position, sizeof(destination));
+				  // Offset extruder (only by XY)
+				  int i;
+				  for (i = 0; i < 2; i++) {
+					  current_position[i] = current_position[i] -
+						  extruder_offset[i][active_extruder] +
+						  extruder_offset[i][tmp_extruder];
+				  }
+				  // Set the new active extruder and position
+				  active_extruder = tmp_extruder;
+				  plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
+				  // Move to the old position if 'F' was in the parameters
+				  if (make_move && Stopped == false) {
+					  prepare_move();
+				  }
+			  }
 #endif
+			  SERIAL_ECHO_START;
+			  SERIAL_ECHORPGM(MSG_ACTIVE_EXTRUDER);
+			  SERIAL_PROTOCOLLN((int)active_extruder);
+		  }
+
+#endif
+	  }
   } // end if(code_seen('T')) (end of T codes)
 
   else
@@ -5673,7 +5731,7 @@ bool setTargetedHotend(int code){
       SERIAL_ECHO_START;
       switch(code){
         case 104:
-          SERIAL_ECHO(MSG_M104_INVALID_EXTRUDER);
+          SERIAL_ECHORPGM(MSG_M104_INVALID_EXTRUDER);
           break;
         case 105:
           SERIAL_ECHO(MSG_M105_INVALID_EXTRUDER);
@@ -5688,14 +5746,14 @@ bool setTargetedHotend(int code){
           SERIAL_ECHO(MSG_M221_INVALID_EXTRUDER);
           break;
       }
-      SERIAL_ECHOLN(tmp_extruder);
+      SERIAL_PROTOCOLLN((int)tmp_extruder);
       return true;
     }
   }
   return false;
 }
 
-void save_statistics(unsigned long _total_filament_used, unsigned long _total_print_time) //_total_filament_used unit: mm/100
+void save_statistics(unsigned long _total_filament_used, unsigned long _total_print_time) //_total_filament_used unit: mm/100; print time in s
 {
 	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)
 	{
@@ -5704,9 +5762,9 @@ void save_statistics(unsigned long _total_filament_used, unsigned long _total_pr
 	}
 
 	unsigned long _previous_filament = eeprom_read_dword((uint32_t *)EEPROM_FILAMENTUSED); //_previous_filament unit: cm
-	unsigned long _previous_time = eeprom_read_dword((uint32_t *)EEPROM_TOTALTIME);
+	unsigned long _previous_time = eeprom_read_dword((uint32_t *)EEPROM_TOTALTIME); //_previous_time unit: min
 
-	eeprom_update_dword((uint32_t *)EEPROM_TOTALTIME, _previous_time + (_total_print_time/60));
+	eeprom_update_dword((uint32_t *)EEPROM_TOTALTIME, _previous_time + (_total_print_time/60)); //EEPROM_TOTALTIME unit: min
 	eeprom_update_dword((uint32_t *)EEPROM_FILAMENTUSED, _previous_filament + (_total_filament_used / 1000));
 
 	total_filament_used = 0;
@@ -5756,3 +5814,253 @@ void delay_keep_alive(int ms)
         }
     }
 }
+
+void check_babystep() {
+	int babystep_z;
+	EEPROM_read_B(EEPROM_BABYSTEP_Z, &babystep_z);
+	if ((babystep_z < Z_BABYSTEP_MIN) || (babystep_z > Z_BABYSTEP_MAX)) {
+		babystep_z = 0; //if babystep value is out of min max range, set it to 0
+		SERIAL_ECHOLNPGM("Z live adjust out of range. Setting to 0");
+		EEPROM_save_B(EEPROM_BABYSTEP_Z, &babystep_z);
+		lcd_show_fullscreen_message_and_wait_P(PSTR("Z live adjust out of range. Setting to 0. Click to continue."));
+		lcd_update_enable(true);		
+	}	
+}
+#ifdef DIS
+void d_setup()
+{	
+	pinMode(D_DATACLOCK, INPUT_PULLUP);
+	pinMode(D_DATA, INPUT_PULLUP);
+	pinMode(D_REQUIRE, OUTPUT);
+	digitalWrite(D_REQUIRE, HIGH);
+}
+
+
+float d_ReadData()
+{
+	int digit[13];
+	String mergeOutput;
+	float output;
+
+	digitalWrite(D_REQUIRE, HIGH);
+	for (int i = 0; i<13; i++)
+	{
+		for (int j = 0; j < 4; j++)
+		{
+			while (digitalRead(D_DATACLOCK) == LOW) {}
+			while (digitalRead(D_DATACLOCK) == HIGH) {}
+			bitWrite(digit[i], j, digitalRead(D_DATA));
+		}
+	}
+
+	digitalWrite(D_REQUIRE, LOW);
+	mergeOutput = "";
+	output = 0;
+	for (int r = 5; r <= 10; r++) //Merge digits
+	{
+		mergeOutput += digit[r];
+	}
+	output = mergeOutput.toFloat();
+
+	if (digit[4] == 8) //Handle sign
+	{
+		output *= -1;
+	}
+
+	for (int i = digit[11]; i > 0; i--) //Handle floating point
+	{
+		output /= 10;
+	}
+
+	return output;
+
+}
+
+void bed_analysis(float x_dimension, float y_dimension, int x_points_num, int y_points_num, float shift_x, float shift_y) {
+	int t1 = 0;
+	int t_delay = 0;
+	int digit[13];
+	int m;
+	char str[3];
+	//String mergeOutput;
+	char mergeOutput[15];
+	float output;
+
+	int mesh_point = 0; //index number of calibration point
+	float bed_zero_ref_x = (-22.f + X_PROBE_OFFSET_FROM_EXTRUDER); //shift between zero point on bed and target and between probe and nozzle
+	float bed_zero_ref_y = (-0.6f + Y_PROBE_OFFSET_FROM_EXTRUDER);
+
+	float mesh_home_z_search = 4;
+	float row[x_points_num];
+	int ix = 0;
+	int iy = 0;
+
+	char* filename_wldsd = "wldsd.txt";
+	char data_wldsd[70];
+	char numb_wldsd[10];
+
+	d_setup();
+
+	if (!(axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] && axis_known_position[Z_AXIS])) {
+		// We don't know where we are! HOME!
+		// Push the commands to the front of the message queue in the reverse order!
+		// There shall be always enough space reserved for these commands.
+		repeatcommand_front(); // repeat G80 with all its parameters
+		
+		enquecommand_front_P((PSTR("G28 W0")));
+		enquecommand_front_P((PSTR("G1 Z5")));
+		return;
+	}
+	bool custom_message_old = custom_message;
+	unsigned int custom_message_type_old = custom_message_type;
+	unsigned int custom_message_state_old = custom_message_state;
+	custom_message = true;
+	custom_message_type = 1;
+	custom_message_state = (x_points_num * y_points_num) + 10;
+	lcd_update(1);
+
+	mbl.reset();
+	babystep_undo();
+
+	card.openFile(filename_wldsd, false);
+
+	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);
+
+	int XY_AXIS_FEEDRATE = homing_feedrate[X_AXIS] / 20;
+	int Z_PROBE_FEEDRATE = homing_feedrate[Z_AXIS] / 60;
+	int Z_LIFT_FEEDRATE = homing_feedrate[Z_AXIS] / 40;
+
+	setup_for_endstop_move(false);
+
+	SERIAL_PROTOCOLPGM("Num X,Y: ");
+	SERIAL_PROTOCOL(x_points_num);
+	SERIAL_PROTOCOLPGM(",");
+	SERIAL_PROTOCOL(y_points_num);
+	SERIAL_PROTOCOLPGM("\nZ search height: ");
+	SERIAL_PROTOCOL(mesh_home_z_search);
+	SERIAL_PROTOCOLPGM("\nDimension X,Y: ");
+	SERIAL_PROTOCOL(x_dimension);
+	SERIAL_PROTOCOLPGM(",");
+	SERIAL_PROTOCOL(y_dimension);
+	SERIAL_PROTOCOLLNPGM("\nMeasured points:");
+
+	while (mesh_point != x_points_num * y_points_num) {
+		ix = mesh_point % x_points_num; // from 0 to MESH_NUM_X_POINTS - 1
+		iy = mesh_point / x_points_num;
+		if (iy & 1) ix = (x_points_num - 1) - ix; // Zig zag
+		float z0 = 0.f;
+		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();
+
+
+		current_position[X_AXIS] = 13.f + ix * (x_dimension / (x_points_num - 1)) - bed_zero_ref_x + shift_x;
+		current_position[Y_AXIS] = 6.4f + iy * (y_dimension / (y_points_num - 1)) - bed_zero_ref_y + shift_y;
+
+		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();
+
+		if (!find_bed_induction_sensor_point_z(-10.f)) { //if we have data from z calibration max allowed difference is 1mm for each point, if we dont have data max difference is 10mm from initial point  
+			break;
+			card.closefile();
+		}
+
+
+		//memset(numb_wldsd, 0, sizeof(numb_wldsd));
+		//dtostrf(d_ReadData(), 8, 5, numb_wldsd);
+		//strcat(data_wldsd, numb_wldsd);
+
+
+		
+		//MYSERIAL.println(data_wldsd);
+		//delay(1000);
+		//delay(3000);
+		//t1 = millis();
+		
+		//while (digitalRead(D_DATACLOCK) == LOW) {}
+		//while (digitalRead(D_DATACLOCK) == HIGH) {}
+		memset(digit, 0, sizeof(digit));
+		//cli();
+		digitalWrite(D_REQUIRE, LOW);	
+		
+		for (int i = 0; i<13; i++)
+		{
+			//t1 = millis();
+			for (int j = 0; j < 4; j++)
+			{
+				while (digitalRead(D_DATACLOCK) == LOW) {}				
+				while (digitalRead(D_DATACLOCK) == HIGH) {}
+				bitWrite(digit[i], j, digitalRead(D_DATA));
+			}
+			//t_delay = (millis() - t1);
+			//SERIAL_PROTOCOLPGM(" ");
+			//SERIAL_PROTOCOL_F(t_delay, 5);
+			//SERIAL_PROTOCOLPGM(" ");
+		}
+		//sei();
+		digitalWrite(D_REQUIRE, HIGH);
+		mergeOutput[0] = '\0';
+		output = 0;
+		for (int r = 5; r <= 10; r++) //Merge digits
+		{			
+			sprintf(str, "%d", digit[r]);
+			strcat(mergeOutput, str);
+		}
+		
+		output = atof(mergeOutput);
+
+		if (digit[4] == 8) //Handle sign
+		{
+			output *= -1;
+		}
+
+		for (int i = digit[11]; i > 0; i--) //Handle floating point
+		{
+			output *= 0.1;
+		}
+		
+
+		//output = d_ReadData();
+
+		//row[ix] = current_position[Z_AXIS];
+
+		memset(data_wldsd, 0, sizeof(data_wldsd));
+
+		for (int i = 0; i <3; i++) {
+			memset(numb_wldsd, 0, sizeof(numb_wldsd));
+			dtostrf(current_position[i], 8, 5, numb_wldsd);
+			strcat(data_wldsd, numb_wldsd);
+			strcat(data_wldsd, ";");
+
+		}
+		memset(numb_wldsd, 0, sizeof(numb_wldsd));
+		dtostrf(output, 8, 5, numb_wldsd);
+		strcat(data_wldsd, numb_wldsd);
+		//strcat(data_wldsd, ";");
+		card.write_command(data_wldsd);
+
+		
+		//row[ix] = d_ReadData();
+		
+		row[ix] = output; // current_position[Z_AXIS];
+
+		if (iy % 2 == 1 ? ix == 0 : ix == x_points_num - 1) {
+			for (int i = 0; i < x_points_num; i++) {
+				SERIAL_PROTOCOLPGM(" ");
+				SERIAL_PROTOCOL_F(row[i], 5);
+
+
+			}
+			SERIAL_PROTOCOLPGM("\n");
+		}
+		custom_message_state--;
+		mesh_point++;
+		lcd_update(1);
+
+	}
+	card.closefile();
+
+}
+
+#endif

Firmware/langtool.pl

@@ -4,7 +4,7 @@
 use strict;
 use warnings;
 
-my @langs = ("en","cz","it","es","pl");
+my @langs = ("en","cz","it","es","pl","de");
 
 sub parselang 
 {

Firmware/language_all.cpp

@@ -10,17 +10,19 @@ const char * const MSG_ACTIVE_EXTRUDER_LANG_TABLE[1] PROGMEM = {
 	MSG_ACTIVE_EXTRUDER_EN
 };
 
-const char MSG_ADJUSTZ_EN[] PROGMEM = "Auto adjust Z ?";
+const char MSG_ADJUSTZ_EN[] PROGMEM = "Auto adjust Z?";
 const char MSG_ADJUSTZ_CZ[] PROGMEM = "Auto doladit Z ?";
 const char MSG_ADJUSTZ_IT[] PROGMEM = "Autoregolare Z?";
-const char MSG_ADJUSTZ_ES[] PROGMEM = "Auto Micropaso Z?";
+const char MSG_ADJUSTZ_ES[] PROGMEM = "Ajustar Eje Z";
 const char MSG_ADJUSTZ_PL[] PROGMEM = "Autodostroic Z?";
+const char MSG_ADJUSTZ_DE[] PROGMEM = "Auto Z einstellen?";
 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
+	MSG_ADJUSTZ_PL,
+	MSG_ADJUSTZ_DE
 };
 
 const char MSG_AMAX_EN[] PROGMEM = "Amax ";
@@ -36,12 +38,14 @@ const char * const MSG_AUTHOR_LANG_TABLE[1] PROGMEM = {
 const char MSG_AUTO_HOME_EN[] PROGMEM = "Auto home";
 const char MSG_AUTO_HOME_IT[] PROGMEM = "Trova origine";
 const char MSG_AUTO_HOME_ES[] PROGMEM = "Llevar al origen";
+const char MSG_AUTO_HOME_DE[] PROGMEM = "Startposition";
 const char * const MSG_AUTO_HOME_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_AUTO_HOME_EN,
 	MSG_AUTO_HOME_EN,
 	MSG_AUTO_HOME_IT,
 	MSG_AUTO_HOME_ES,
-	MSG_AUTO_HOME_EN
+	MSG_AUTO_HOME_EN,
+	MSG_AUTO_HOME_DE
 };
 
 const char MSG_A_RETRACT_EN[] PROGMEM = "A-retract";
@@ -77,14 +81,16 @@ const char * const MSG_BABYSTEP_Y_LANG_TABLE[1] PROGMEM = {
 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 = "Compensazione Z";
-const char MSG_BABYSTEP_Z_ES[] PROGMEM = "Micropaso Z";
+const char MSG_BABYSTEP_Z_ES[] PROGMEM = "Micropaso Eje Z";
 const char MSG_BABYSTEP_Z_PL[] PROGMEM = "Dostrojenie osy Z";
+const char MSG_BABYSTEP_Z_DE[] PROGMEM = "Z einstellen";
 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
+	MSG_BABYSTEP_Z_PL,
+	MSG_BABYSTEP_Z_DE
 };
 
 const char MSG_BABYSTEP_Z_NOT_SET_EN[] PROGMEM = "Distance between tip of the nozzle and the bed surface has not been set yet. Please follow the manual, chapter First steps, section First layer calibration.";
@@ -92,12 +98,14 @@ const char MSG_BABYSTEP_Z_NOT_SET_CZ[] PROGMEM = "Neni zkalibrovana vzdalenost t
 const char MSG_BABYSTEP_Z_NOT_SET_IT[] PROGMEM = "Distanza tra la punta dell'ugello e la superficie del letto non ancora imposta. Si prega di seguire il manuale, capitolo First steps, sezione First layer calibration.";
 const char MSG_BABYSTEP_Z_NOT_SET_ES[] PROGMEM = "Distancia entre la punta de la boquilla y la superficie de la cama no fijada aun. Por favor siga el manual, capitulo First steps, seccion First layer calibration.";
 const char MSG_BABYSTEP_Z_NOT_SET_PL[] PROGMEM = "Odleglosc dyszy od podkladki nie jest skalibrowana. Postepuj zgodnie z instrukcja rozdzial Zaczynamy, podrozdzial Kalibracja pierwszej warstwy.";
+const char MSG_BABYSTEP_Z_NOT_SET_DE[] PROGMEM = "Der Abstand zwischen der Spitze der Duese und der Bed ist noch nicht eingestellt. Bitte folgen Sie dem Handbuch, First steps, section First layer calibration.";
 const char * const MSG_BABYSTEP_Z_NOT_SET_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BABYSTEP_Z_NOT_SET_EN,
 	MSG_BABYSTEP_Z_NOT_SET_CZ,
 	MSG_BABYSTEP_Z_NOT_SET_IT,
 	MSG_BABYSTEP_Z_NOT_SET_ES,
-	MSG_BABYSTEP_Z_NOT_SET_PL
+	MSG_BABYSTEP_Z_NOT_SET_PL,
+	MSG_BABYSTEP_Z_NOT_SET_DE
 };
 
 const char MSG_BED_EN[] PROGMEM = "Bed";
@@ -109,33 +117,38 @@ const char * const MSG_BED_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_EN,
 	MSG_BED_IT,
 	MSG_BED_ES,
-	MSG_BED_PL
+	MSG_BED_PL,
+	MSG_BED_EN
 };
 
 const char MSG_BED_CORRECTION_FRONT_EN[] PROGMEM = "Front side um";
 const char MSG_BED_CORRECTION_FRONT_CZ[] PROGMEM = "Vpredu [um]";
-const char MSG_BED_CORRECTION_FRONT_IT[] PROGMEM = "Lato ateriore um";
+const char MSG_BED_CORRECTION_FRONT_IT[] PROGMEM = "Lato ateriore";
 const char MSG_BED_CORRECTION_FRONT_ES[] PROGMEM = "Adelante  [um]";
 const char MSG_BED_CORRECTION_FRONT_PL[] PROGMEM = "Do przodu [um]";
+const char MSG_BED_CORRECTION_FRONT_DE[] PROGMEM = "Vorderseite [um]";
 const char * const MSG_BED_CORRECTION_FRONT_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_CORRECTION_FRONT_EN,
 	MSG_BED_CORRECTION_FRONT_CZ,
 	MSG_BED_CORRECTION_FRONT_IT,
 	MSG_BED_CORRECTION_FRONT_ES,
-	MSG_BED_CORRECTION_FRONT_PL
+	MSG_BED_CORRECTION_FRONT_PL,
+	MSG_BED_CORRECTION_FRONT_DE
 };
 
 const char MSG_BED_CORRECTION_LEFT_EN[] PROGMEM = "Left side  um";
 const char MSG_BED_CORRECTION_LEFT_CZ[] PROGMEM = "Vlevo  [um]";
-const char MSG_BED_CORRECTION_LEFT_IT[] PROGMEM = "Lato sinistro um";
+const char MSG_BED_CORRECTION_LEFT_IT[] PROGMEM = "Lato sinistro";
 const char MSG_BED_CORRECTION_LEFT_ES[] PROGMEM = "Izquierda [um]";
 const char MSG_BED_CORRECTION_LEFT_PL[] PROGMEM = "W lewo  [um]";
+const char MSG_BED_CORRECTION_LEFT_DE[] PROGMEM = "Linke Seite  [um]";
 const char * const MSG_BED_CORRECTION_LEFT_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_CORRECTION_LEFT_EN,
 	MSG_BED_CORRECTION_LEFT_CZ,
 	MSG_BED_CORRECTION_LEFT_IT,
 	MSG_BED_CORRECTION_LEFT_ES,
-	MSG_BED_CORRECTION_LEFT_PL
+	MSG_BED_CORRECTION_LEFT_PL,
+	MSG_BED_CORRECTION_LEFT_DE
 };
 
 const char MSG_BED_CORRECTION_MENU_EN[] PROGMEM = "Bed level correct";
@@ -143,12 +156,14 @@ const char MSG_BED_CORRECTION_MENU_CZ[] PROGMEM = "Korekce podlozky";
 const char MSG_BED_CORRECTION_MENU_IT[] PROGMEM = "Correz. liv.letto";
 const char MSG_BED_CORRECTION_MENU_ES[] PROGMEM = "Corr. de la cama";
 const char MSG_BED_CORRECTION_MENU_PL[] PROGMEM = "Korekta podkladki";
+const char MSG_BED_CORRECTION_MENU_DE[] PROGMEM = "Bed level Korrekt";
 const char * const MSG_BED_CORRECTION_MENU_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_CORRECTION_MENU_EN,
 	MSG_BED_CORRECTION_MENU_CZ,
 	MSG_BED_CORRECTION_MENU_IT,
 	MSG_BED_CORRECTION_MENU_ES,
-	MSG_BED_CORRECTION_MENU_PL
+	MSG_BED_CORRECTION_MENU_PL,
+	MSG_BED_CORRECTION_MENU_DE
 };
 
 const char MSG_BED_CORRECTION_REAR_EN[] PROGMEM = "Rear side  um";
@@ -156,12 +171,14 @@ const char MSG_BED_CORRECTION_REAR_CZ[] PROGMEM = "Vzadu  [um]";
 const char MSG_BED_CORRECTION_REAR_IT[] PROGMEM = "Lato posteriore";
 const char MSG_BED_CORRECTION_REAR_ES[] PROGMEM = "Atras     [um]";
 const char MSG_BED_CORRECTION_REAR_PL[] PROGMEM = "Do tylu  [um]";
+const char MSG_BED_CORRECTION_REAR_DE[] PROGMEM = "Rueckseite  [um]";
 const char * const MSG_BED_CORRECTION_REAR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_CORRECTION_REAR_EN,
 	MSG_BED_CORRECTION_REAR_CZ,
 	MSG_BED_CORRECTION_REAR_IT,
 	MSG_BED_CORRECTION_REAR_ES,
-	MSG_BED_CORRECTION_REAR_PL
+	MSG_BED_CORRECTION_REAR_PL,
+	MSG_BED_CORRECTION_REAR_DE
 };
 
 const char MSG_BED_CORRECTION_RESET_EN[] PROGMEM = "Reset";
@@ -171,41 +188,47 @@ const char * const MSG_BED_CORRECTION_RESET_LANG_TABLE[1] PROGMEM = {
 
 const char MSG_BED_CORRECTION_RIGHT_EN[] PROGMEM = "Right side um";
 const char MSG_BED_CORRECTION_RIGHT_CZ[] PROGMEM = "Vpravo [um]";
-const char MSG_BED_CORRECTION_RIGHT_IT[] PROGMEM = "Lato destro um";
+const char MSG_BED_CORRECTION_RIGHT_IT[] PROGMEM = "Lato destro";
 const char MSG_BED_CORRECTION_RIGHT_ES[] PROGMEM = "Derecha   [um]";
 const char MSG_BED_CORRECTION_RIGHT_PL[] PROGMEM = "W prawo [um]";
+const char MSG_BED_CORRECTION_RIGHT_DE[] PROGMEM = "Rechte Seite [um]";
 const char * const MSG_BED_CORRECTION_RIGHT_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_CORRECTION_RIGHT_EN,
 	MSG_BED_CORRECTION_RIGHT_CZ,
 	MSG_BED_CORRECTION_RIGHT_IT,
 	MSG_BED_CORRECTION_RIGHT_ES,
-	MSG_BED_CORRECTION_RIGHT_PL
+	MSG_BED_CORRECTION_RIGHT_PL,
+	MSG_BED_CORRECTION_RIGHT_DE
 };
 
 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_ES[] PROGMEM = "Base preparada";
 const char MSG_BED_DONE_PL[] PROGMEM = "Stolik OK.";
+const char MSG_BED_DONE_DE[] PROGMEM = "Bed 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
+	MSG_BED_DONE_PL,
+	MSG_BED_DONE_DE
 };
 
 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 = "Riscald. letto";
-const char MSG_BED_HEATING_ES[] PROGMEM = "Base Calentando";
+const char MSG_BED_HEATING_ES[] PROGMEM = "Calentando Base";
 const char MSG_BED_HEATING_PL[] PROGMEM = "Grzanie stolika..";
+const char MSG_BED_HEATING_DE[] PROGMEM = "Bed erwaermen";
 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
+	MSG_BED_HEATING_PL,
+	MSG_BED_HEATING_DE
 };
 
 const char MSG_BED_LEVELING_FAILED_POINT_HIGH_EN[] PROGMEM = "Bed leveling failed. Sensor triggered too high. Waiting for reset.";
@@ -213,12 +236,14 @@ const char MSG_BED_LEVELING_FAILED_POINT_HIGH_CZ[] PROGMEM = "Kalibrace Z selhal
 const char MSG_BED_LEVELING_FAILED_POINT_HIGH_IT[] PROGMEM = "Livellamento letto fallito.Risp sensore troppo prestoIn attesa di reset.";
 const char MSG_BED_LEVELING_FAILED_POINT_HIGH_ES[] PROGMEM = "Nivelacion fallada. Sensor funciona demasiado temprano. Esperando reset.";
 const char MSG_BED_LEVELING_FAILED_POINT_HIGH_PL[] PROGMEM = "Kalibracja Z nieudana. Sensor dotk. za wysoko. Czekam na reset.";
+const char MSG_BED_LEVELING_FAILED_POINT_HIGH_DE[] PROGMEM = "Z-Kalibrierung fehlgeschlg. Sensor zu hoch ausgeloest. Warte auf Reset.";
 const char * const MSG_BED_LEVELING_FAILED_POINT_HIGH_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_LEVELING_FAILED_POINT_HIGH_EN,
 	MSG_BED_LEVELING_FAILED_POINT_HIGH_CZ,
 	MSG_BED_LEVELING_FAILED_POINT_HIGH_IT,
 	MSG_BED_LEVELING_FAILED_POINT_HIGH_ES,
-	MSG_BED_LEVELING_FAILED_POINT_HIGH_PL
+	MSG_BED_LEVELING_FAILED_POINT_HIGH_PL,
+	MSG_BED_LEVELING_FAILED_POINT_HIGH_DE
 };
 
 const char MSG_BED_LEVELING_FAILED_POINT_LOW_EN[] PROGMEM = "Bed leveling failed. Sensor didnt trigger. Debris on nozzle? Waiting for reset.";
@@ -226,12 +251,14 @@ const char MSG_BED_LEVELING_FAILED_POINT_LOW_CZ[] PROGMEM = "Kalibrace Z selhala
 const char MSG_BED_LEVELING_FAILED_POINT_LOW_IT[] PROGMEM = "Livellamento letto fallito.NoRispSensor Residui su ugello? In attesa di reset.";
 const char MSG_BED_LEVELING_FAILED_POINT_LOW_ES[] PROGMEM = "Nivelacion fallada. Sensor no funciona. Escombros en Boqui.? Esperando reset.";
 const char MSG_BED_LEVELING_FAILED_POINT_LOW_PL[] PROGMEM = "Kalibracja nieudana. Sensor nie dotknal. Zanieczysz. dysza? Czekam na reset.";
+const char MSG_BED_LEVELING_FAILED_POINT_LOW_DE[] PROGMEM = "Z-Kal. fehlgeschlg. Sensor nicht ausgeloest. Schmutze Duese? Warte auf RST";
 const char * const MSG_BED_LEVELING_FAILED_POINT_LOW_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_LEVELING_FAILED_POINT_LOW_EN,
 	MSG_BED_LEVELING_FAILED_POINT_LOW_CZ,
 	MSG_BED_LEVELING_FAILED_POINT_LOW_IT,
 	MSG_BED_LEVELING_FAILED_POINT_LOW_ES,
-	MSG_BED_LEVELING_FAILED_POINT_LOW_PL
+	MSG_BED_LEVELING_FAILED_POINT_LOW_PL,
+	MSG_BED_LEVELING_FAILED_POINT_LOW_DE
 };
 
 const char MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_EN[] PROGMEM = "Bed leveling failed. Sensor disconnected or cable broken. Waiting for reset.";
@@ -239,12 +266,14 @@ const char MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_CZ[] PROGMEM = "Kalibrace
 const char MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_IT[] PROGMEM = "Livellamento letto fallito. Sensore discon. o Cavo Dann. In attesa di reset.";
 const char MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_ES[] PROGMEM = "Nivelacion fallada. Sensor desconectado o cables danados. Esperando reset.";
 const char MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_PL[] PROGMEM = "Kalibracja nieudana. Sensor odlaczony lub uszkodz. kabel. Czekam na reset.";
+const char MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_DE[] PROGMEM = "Z-Kalibrierung fehlgeschlg. Sensor nicht angeschlossen. Warte auf Reset.";
 const char * const MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_EN,
 	MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_CZ,
 	MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_IT,
 	MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_ES,
-	MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_PL
+	MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_PL,
+	MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_EN[] PROGMEM = "XYZ calibration failed. Front calibration points not reachable.";
@@ -252,12 +281,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_CZ[] PROGMEM = "K
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_IT[] PROGMEM = "Calibrazione XYZ fallita. Punti anteriori non raggiungibili.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_ES[] PROGMEM = "Calibracion XYZ fallad. Punto delanteros no alcanzables.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_PL[] PROGMEM = "Kalibr. XYZ nieudana. Przed. punkty kalibr. zbyt do przodu. Wyrownac drukarke.";
+const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_DE[] PROGMEM = "XYZ-Kalibrierung fehlgeschlagen. Vordere Kalibrierpunkte sind zu weit nach vorne.";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_BOTH_FAR_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_EN[] PROGMEM = "XYZ calibration failed. Left front calibration point not reachable.";
@@ -265,12 +296,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_CZ[] PROGMEM = "K
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_IT[] PROGMEM = "Calibrazione XYZ fallita. Punto anteriore sinistro non raggiungibile.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_ES[] PROGMEM = "Calibracion XYZ fallad. Punto delantero izquierdo no alcanzable.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_PL[] PROGMEM = "Kalibr. XYZ nieudana. Lewy przedni punkt zbyt do przodu. Wyrownac drukarke.";
+const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_DE[] PROGMEM = "XYZ-Kalibrierung fehlgeschlagen. Linker vorderer Kalibrierpunkt ist zu weit nach vorne.";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_LEFT_FAR_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_EN[] PROGMEM = "XYZ calibration failed. Right front calibration point not reachable.";
@@ -278,12 +311,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_CZ[] PROGMEM = "
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_IT[] PROGMEM = "Calibrazione XYZ fallita. Punto anteriore destro non raggiungibile.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_ES[] PROGMEM = "Calibracion XYZ fallad. Punto delantero derecho no alcanzable.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_PL[] PROGMEM = "Kalibr. XYZ nieudana. Prawy przedni punkt zbyt do przodu. Wyrownac drukarke.";
+const char MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_DE[] PROGMEM = "XYZ-Kalibrierung fehlgeschlagen. Rechter vorderer Kalibrierpunkt ist zu weit nach vorne.";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_FAILED_FRONT_RIGHT_FAR_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_EN[] PROGMEM = "XYZ calibration failed. Please consult the manual.";
@@ -291,12 +326,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_CZ[] PROGMEM = "Kalibrac
 const char MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_IT[] PROGMEM = "Calibrazione XYZ fallita. Si prega di consultare il manuale.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_ES[] PROGMEM = "Calibracion XYZ fallada. Consultar el manual por favor.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_PL[] PROGMEM = "Kalibracja XYZ niepowiedziona. Sprawdzic w instrukcji.";
+const char MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_DE[] PROGMEM = "XYZ-Kalibrierung fehlgeschlagen. Bitte schauen Sie in das Handbuch.";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_FITTING_FAILED_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_EN[] PROGMEM = "XYZ calibration ok. X/Y axes are perpendicular. Congratulations!";
@@ -304,12 +341,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_CZ[] PROGMEM = "Kalibrace XYZ v
 const char MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_IT[] PROGMEM = "Calibrazione XYZ OK. Gli assi X/Y sono perpendicolari. Complimenti!";
 const char MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_ES[] PROGMEM = "Calibracion XYZ ok. Ejes X/Y perpendiculares. Felicitaciones!";
 const char MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_PL[] PROGMEM = "Kalibracja XYZ ok. Osie X/Y sa prostopadle. Gratulacje!";
+const char MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_DE[] PROGMEM = "XYZ-Kalibrierung ok. X/Y-Achsen sind im Lot. Glueckwunsch!";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_PERFECT_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_EN[] PROGMEM = "XYZ calibration failed. Bed calibration point was not found.";
@@ -317,12 +356,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_CZ[] PROGMEM = "Kalibra
 const char MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_IT[] PROGMEM = "Calibrazione XYZ fallita. Il punto di calibrazione sul letto non e' stato trovato.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_ES[] PROGMEM = "Calibracion XYZ fallada. Puntos de calibracion en la cama no encontrados.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_PL[] PROGMEM = "Kalibr. XYZ nieudana. Kalibracyjny punkt podkladki nieznaleziony.";
+const char MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_DE[] PROGMEM = "XYZ-Kalibrierung fehlgeschlagen. Bed-Kalibrierpunkt nicht gefunden.";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_POINT_NOT_FOUND_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_EN[] PROGMEM = "XYZ callibration all right. Skew will be corrected automatically.";
@@ -330,12 +371,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_CZ[] PROGMEM = "Kalibrace
 const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_IT[] PROGMEM = "Calibrazion XYZ corretta. La distorsione verra' automaticamente compensata.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_ES[] PROGMEM = "Calibracion XYZ correcta. La inclinacion se corregira automaticamente.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_PL[] PROGMEM = "Kalibracja XYZ prawidlowa. Skosy beda automatycznie wyrownane przy druku.";
+const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_DE[] PROGMEM = "XYZ Kalibrierung in Ordnung. Schiefheit wird automatisch korrigiert.";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_EN[] PROGMEM = "XYZ calibration all right. X/Y axes are slightly skewed. Good job!";
@@ -343,12 +386,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_CZ[] PROGMEM = "Kalibrace XYZ
 const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_IT[] PROGMEM = "Calibrazion XYZ corretta. Assi X/Y leggermente storti. Ben fatto!";
 const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_ES[] PROGMEM = "Calibracion XYZ correcta. Los ejes X / Y estan ligeramente inclinados. Buen trabajo!";
 const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_PL[] PROGMEM = "Kalibracja XYZ prawidlowa. Osie X/Y lekko skosne. Dobra robota!";
+const char MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_DE[] PROGMEM = "XYZ Kalibrierung in Ordnung. X/Y Achsen sind etwas schief.";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_SKEW_MILD_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_EN[] PROGMEM = "XYZ calibration compromised. Front calibration points not reachable.";
@@ -356,12 +401,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_CZ[] PROGMEM = "
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_IT[] PROGMEM = "Calibrazione XYZ compromessa. Punti anteriori non raggiungibili.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_ES[] PROGMEM = "Calibrazion XYZ comprometida. Punto delanteros no alcanzables.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_PL[] PROGMEM = "Kalibr. XYZ niedokladna. Przednie punkty kalibr. Zbyt wys. do przodu.";
+const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_DE[] PROGMEM = "XYZ-Kalibrierung ungenau. Vordere Kalibrierpunkte sind zu weit nach vorne.";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_BOTH_FAR_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_EN[] PROGMEM = "XYZ calibration compromised. Left front calibration point not reachable.";
@@ -369,12 +416,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_CZ[] PROGMEM = "
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_IT[] PROGMEM = "Calibrazione XYZ compromessa. Punto anteriore sinistro non raggiungibile.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_ES[] PROGMEM = "Calibrazion XYZ comprometida. Punto delantero izquierdo no alcanzable.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_PL[] PROGMEM = "Kalibracja XYZ niedokladna. Lewy przedni punkt zbyt wysuniety do przodu.";
+const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_DE[] PROGMEM = "XYZ-Kalibrierung ungenau. Linker vorderer Kalibrierpunkt ist zu weit nach vorne.";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_LEFT_FAR_DE
 };
 
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_EN[] PROGMEM = "XYZ calibration compromised. Right front calibration point not reachable.";
@@ -382,12 +431,14 @@ const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_CZ[] PROGMEM =
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_IT[] PROGMEM = "Calibrazione XYZ compromessa. Punto anteriore destro non raggiungibile.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_ES[] PROGMEM = "Calibrazion XYZ comprometida. Punto delantero derecho no alcanzable.";
 const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_PL[] PROGMEM = "Kalibracja XYZ niedokladna. Prawy przedni punkt zbyt wysuniety do przodu.";
+const char MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_DE[] PROGMEM = "XYZ-Kalibrierung ungenau. Rechter vorderer Kalibrierpunkt ist zu weit nach vorne.";
 const char * const MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_EN,
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_CZ,
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_IT,
 	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_ES,
-	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_PL
+	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_PL,
+	MSG_BED_SKEW_OFFSET_DETECTION_WARNING_FRONT_RIGHT_FAR_DE
 };
 
 const char MSG_BEGIN_FILE_LIST_EN[] PROGMEM = "Begin file list";
@@ -405,23 +456,27 @@ const char MSG_CALIBRATE_BED_CZ[] PROGMEM = "Kalibrace XYZ";
 const char MSG_CALIBRATE_BED_IT[] PROGMEM = "Calibra XYZ";
 const char MSG_CALIBRATE_BED_ES[] PROGMEM = "Calibra XYZ";
 const char MSG_CALIBRATE_BED_PL[] PROGMEM = "Kalibracja XYZ";
+const char MSG_CALIBRATE_BED_DE[] PROGMEM = "Kalibrierung XYZ";
 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
+	MSG_CALIBRATE_BED_PL,
+	MSG_CALIBRATE_BED_DE
 };
 
 const char MSG_CALIBRATE_BED_RESET_EN[] PROGMEM = "Reset XYZ calibr.";
 const char MSG_CALIBRATE_BED_RESET_CZ[] PROGMEM = "Reset XYZ kalibr.";
 const char MSG_CALIBRATE_BED_RESET_PL[] PROGMEM = "Reset kalibr. XYZ";
+const char MSG_CALIBRATE_BED_RESET_DE[] PROGMEM = "Reset XYZ Kalibr.";
 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_EN,
 	MSG_CALIBRATE_BED_RESET_EN,
-	MSG_CALIBRATE_BED_RESET_PL
+	MSG_CALIBRATE_BED_RESET_PL,
+	MSG_CALIBRATE_BED_RESET_DE
 };
 
 const char MSG_CALIBRATE_E_EN[] PROGMEM = "Calibrate E";
@@ -429,25 +484,29 @@ const char MSG_CALIBRATE_E_CZ[] PROGMEM = "Kalibrovat E";
 const char MSG_CALIBRATE_E_IT[] PROGMEM = "Calibra E";
 const char MSG_CALIBRATE_E_ES[] PROGMEM = "Calibrar E";
 const char MSG_CALIBRATE_E_PL[] PROGMEM = "Kalibruj E";
+const char MSG_CALIBRATE_E_DE[] PROGMEM = "Kalibriere E";
 const char * const MSG_CALIBRATE_E_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_CALIBRATE_E_EN,
 	MSG_CALIBRATE_E_CZ,
 	MSG_CALIBRATE_E_IT,
 	MSG_CALIBRATE_E_ES,
-	MSG_CALIBRATE_E_PL
+	MSG_CALIBRATE_E_PL,
+	MSG_CALIBRATE_E_DE
 };
 
 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 = "Stampa da SD";
-const char MSG_CARD_MENU_ES[] PROGMEM = "Menu de SD";
+const char MSG_CARD_MENU_ES[] PROGMEM = "Menu tarjeta SD";
 const char MSG_CARD_MENU_PL[] PROGMEM = "Druk z SD";
+const char MSG_CARD_MENU_DE[] PROGMEM = "Drucken von 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
+	MSG_CARD_MENU_PL,
+	MSG_CARD_MENU_DE
 };
 
 const char MSG_CHANGE_EXTR_EN[] PROGMEM = "Change extruder";
@@ -455,38 +514,44 @@ const char MSG_CHANGE_EXTR_CZ[] PROGMEM = "Zmenit extruder";
 const char MSG_CHANGE_EXTR_IT[] PROGMEM = "Cambio estrusore.";
 const char MSG_CHANGE_EXTR_ES[] PROGMEM = "Cambiar extrusor.";
 const char MSG_CHANGE_EXTR_PL[] PROGMEM = "Zmienic ekstruder";
+const char MSG_CHANGE_EXTR_DE[] PROGMEM = "Wechsel extruder";
 const char * const MSG_CHANGE_EXTR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_CHANGE_EXTR_EN,
 	MSG_CHANGE_EXTR_CZ,
 	MSG_CHANGE_EXTR_IT,
 	MSG_CHANGE_EXTR_ES,
-	MSG_CHANGE_EXTR_PL
+	MSG_CHANGE_EXTR_PL,
+	MSG_CHANGE_EXTR_DE
 };
 
 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 = "Cambio riuscito!";
-const char MSG_CHANGE_SUCCESS_ES[] PROGMEM = "Cambiar bien!";
+const char MSG_CHANGE_SUCCESS_ES[] PROGMEM = "Cambio correcto";
 const char MSG_CHANGE_SUCCESS_PL[] PROGMEM = "Wymiana ok!";
+const char MSG_CHANGE_SUCCESS_DE[] PROGMEM = "Wechsel erfolgr.!";
 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
+	MSG_CHANGE_SUCCESS_PL,
+	MSG_CHANGE_SUCCESS_DE
 };
 
 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 = "Cambiando filam.";
-const char MSG_CHANGING_FILAMENT_ES[] PROGMEM = "Cambiando fil.!";
+const char MSG_CHANGING_FILAMENT_ES[] PROGMEM = "Cambiando filamento";
 const char MSG_CHANGING_FILAMENT_PL[] PROGMEM = "Wymiana filamentu";
+const char MSG_CHANGING_FILAMENT_DE[] PROGMEM = "Wechsel filament!";
 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
+	MSG_CHANGING_FILAMENT_PL,
+	MSG_CHANGING_FILAMENT_DE
 };
 
 const char MSG_CLEAN_NOZZLE_E_EN[] PROGMEM = "E calibration finished. Please clean the nozzle. Click when done.";
@@ -494,12 +559,14 @@ const char MSG_CLEAN_NOZZLE_E_CZ[] PROGMEM = "E kalibrace ukoncena. Prosim ocist
 const char MSG_CLEAN_NOZZLE_E_IT[] PROGMEM = "Calibrazione E terminata. Si prega di pulire l'ugello. Click per continuare.";
 const char MSG_CLEAN_NOZZLE_E_ES[] PROGMEM = "E calibrado. Limpiar la boquilla. Haga clic una vez terminado.";
 const char MSG_CLEAN_NOZZLE_E_PL[] PROGMEM = "Kalibracja E skonczona. Prosze oczyscic dysze. Potem potwierdzic przyciskiem. ";
+const char MSG_CLEAN_NOZZLE_E_DE[] PROGMEM = "E-Kalibrierung beendet. Bitte reinigen Sie die Duese. Klicken wenn fertig.";
 const char * const MSG_CLEAN_NOZZLE_E_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_CLEAN_NOZZLE_E_EN,
 	MSG_CLEAN_NOZZLE_E_CZ,
 	MSG_CLEAN_NOZZLE_E_IT,
 	MSG_CLEAN_NOZZLE_E_ES,
-	MSG_CLEAN_NOZZLE_E_PL
+	MSG_CLEAN_NOZZLE_E_PL,
+	MSG_CLEAN_NOZZLE_E_DE
 };
 
 const char MSG_CNG_SDCARD_EN[] PROGMEM = "Change SD card";
@@ -517,12 +584,14 @@ const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_CZ[] PROGMEM = "Dojely oba Z voziky k
 const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_IT[] PROGMEM = "I carrelli Z sin/des sono altezza max?";
 const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_ES[] PROGMEM = "Carros Z izq./der. estan arriba maximo?";
 const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_PL[] PROGMEM = "Oba wozki dojechaly do gornej ramy?";
+const char MSG_CONFIRM_CARRIAGE_AT_THE_TOP_DE[] PROGMEM = "Sind Z-Schlitten ganz oben?";
 const char * const MSG_CONFIRM_CARRIAGE_AT_THE_TOP_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_EN,
 	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_CZ,
 	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_IT,
 	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_ES,
-	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_PL
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_PL,
+	MSG_CONFIRM_CARRIAGE_AT_THE_TOP_DE
 };
 
 const char MSG_CONFIRM_NOZZLE_CLEAN_EN[] PROGMEM = "Please clean the nozzle for calibration. Click when done.";
@@ -530,12 +599,14 @@ const char MSG_CONFIRM_NOZZLE_CLEAN_CZ[] PROGMEM = "Pro uspesnou kalibraci ocist
 const char MSG_CONFIRM_NOZZLE_CLEAN_IT[] PROGMEM = "Pulire l'ugello per la calibrazione, poi fare click.";
 const char MSG_CONFIRM_NOZZLE_CLEAN_ES[] PROGMEM = "Limpiar boquilla para calibracion. Click cuando acabes.";
 const char MSG_CONFIRM_NOZZLE_CLEAN_PL[] PROGMEM = "Dla prawidl. kalibracji prosze oczyscic dysze. Potw. guzikiem.";
+const char MSG_CONFIRM_NOZZLE_CLEAN_DE[] PROGMEM = "Bitte reinigen Sie die D\x81se zur Kalibrierung. Klicken wenn fertig.";
 const char * const MSG_CONFIRM_NOZZLE_CLEAN_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_CONFIRM_NOZZLE_CLEAN_EN,
 	MSG_CONFIRM_NOZZLE_CLEAN_CZ,
 	MSG_CONFIRM_NOZZLE_CLEAN_IT,
 	MSG_CONFIRM_NOZZLE_CLEAN_ES,
-	MSG_CONFIRM_NOZZLE_CLEAN_PL
+	MSG_CONFIRM_NOZZLE_CLEAN_PL,
+	MSG_CONFIRM_NOZZLE_CLEAN_DE
 };
 
 const char MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_EN[] PROGMEM = "Filaments are now adjusted. Please clean the nozzle for calibration. Click when done.";
@@ -543,12 +614,14 @@ const char MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_CZ[] PROGMEM = "Filamenty jsou srovn
 const char MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_IT[] PROGMEM = "I filamenti sono regolati. Si prega di pulire l'ugello per la calibrazione. Click per continuare.";
 const char MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_ES[] PROGMEM = "Filamentos ajustados. Limpie la boquilla para calibracion. Haga clic una vez terminado.";
 const char MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_PL[] PROGMEM = "Dla prawidlowej kalibracji prosze oczyscic dysze. Potem potwierdzic przyciskiem.";
+const char MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_DE[] PROGMEM = "Filaments sind jetzt eingestellt. Bitte reinigen Sie die Duese zur Kalibrierung. Klicken wenn fertig.";
 const char * const MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_EN,
 	MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_CZ,
 	MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_IT,
 	MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_ES,
-	MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_PL
+	MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_PL,
+	MSG_CONFIRM_NOZZLE_CLEAN_FIL_ADJ_DE
 };
 
 const char MSG_CONTROL_EN[] PROGMEM = "Control";
@@ -561,25 +634,29 @@ 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 MSG_COOLDOWN_DE[] PROGMEM = "Abkuehlen";
 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
+	MSG_COOLDOWN_PL,
+	MSG_COOLDOWN_DE
 };
 
 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_ES[] PROGMEM = "Cambiado correct.?";
 const char MSG_CORRECTLY_PL[] PROGMEM = "Wymiana ok?";
+const char MSG_CORRECTLY_DE[] PROGMEM = "Wechsel 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
+	MSG_CORRECTLY_PL,
+	MSG_CORRECTLY_DE
 };
 
 const char MSG_COUNT_X_EN[] PROGMEM = " Count X: ";
@@ -592,23 +669,27 @@ const char MSG_DISABLE_STEPPERS_CZ[] PROGMEM = "Vypnout motory";
 const char MSG_DISABLE_STEPPERS_IT[] PROGMEM = "Disabilit motori";
 const char MSG_DISABLE_STEPPERS_ES[] PROGMEM = "Apagar motores";
 const char MSG_DISABLE_STEPPERS_PL[] PROGMEM = "Wylaczyc silniki";
+const char MSG_DISABLE_STEPPERS_DE[] PROGMEM = "Deaktiviere Motor";
 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
+	MSG_DISABLE_STEPPERS_PL,
+	MSG_DISABLE_STEPPERS_DE
 };
 
 const char MSG_DWELL_EN[] PROGMEM = "Sleep...";
 const char MSG_DWELL_IT[] PROGMEM = "Sospensione...";
-const char MSG_DWELL_ES[] PROGMEM = "Reposo...";
+const char MSG_DWELL_ES[] PROGMEM = "En espera";
+const char MSG_DWELL_DE[] PROGMEM = "Schlaf...";
 const char * const MSG_DWELL_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_DWELL_EN,
 	MSG_DWELL_EN,
 	MSG_DWELL_IT,
 	MSG_DWELL_ES,
-	MSG_DWELL_EN
+	MSG_DWELL_EN,
+	MSG_DWELL_DE
 };
 
 const char MSG_ENDSTOPS_HIT_EN[] PROGMEM = "endstops hit: ";
@@ -635,12 +716,14 @@ const char MSG_ERROR_EN[] PROGMEM = "ERROR:";
 const char MSG_ERROR_CZ[] PROGMEM = "CHYBA:";
 const char MSG_ERROR_IT[] PROGMEM = "ERRORE:";
 const char MSG_ERROR_PL[] PROGMEM = "BLAD:";
+const char MSG_ERROR_DE[] PROGMEM = "FEHLER:";
 const char * const MSG_ERROR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_ERROR_EN,
 	MSG_ERROR_CZ,
 	MSG_ERROR_IT,
 	MSG_ERROR_EN,
-	MSG_ERROR_PL
+	MSG_ERROR_PL,
+	MSG_ERROR_DE
 };
 
 const char MSG_ERR_CHECKSUM_MISMATCH_EN[] PROGMEM = "checksum mismatch, Last Line: ";
@@ -698,12 +781,14 @@ const char MSG_E_CAL_KNOB_CZ[] PROGMEM = "Otacejte tlacitkem dokud znacka nedosa
 const char MSG_E_CAL_KNOB_IT[] PROGMEM = "Girare la manopola affinche' il segno raggiunga il corpo dell'estrusore. Click per continuare.";
 const char MSG_E_CAL_KNOB_ES[] PROGMEM = "Rotar el mando hasta que la marca llegue al cuerpo del extrusor. Haga clic una vez terminado.";
 const char MSG_E_CAL_KNOB_PL[] PROGMEM = "Prosze otaczac przycisk poki znacznik nie dosiegnie ciala ekstrudera. Potwierdzic przyciskiem.";
+const char MSG_E_CAL_KNOB_DE[] PROGMEM = "Dreh den Knopf bis das Extruder Zeichen erreicht ist. Klicken wenn fertig.";
 const char * const MSG_E_CAL_KNOB_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_E_CAL_KNOB_EN,
 	MSG_E_CAL_KNOB_CZ,
 	MSG_E_CAL_KNOB_IT,
 	MSG_E_CAL_KNOB_ES,
-	MSG_E_CAL_KNOB_PL
+	MSG_E_CAL_KNOB_PL,
+	MSG_E_CAL_KNOB_DE
 };
 
 const char MSG_Enqueing_EN[] PROGMEM = "enqueing \"";
@@ -718,15 +803,17 @@ const char * const MSG_FACTOR_LANG_TABLE[1] PROGMEM = {
 
 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 = "Velocita ventola";
-const char MSG_FAN_SPEED_ES[] PROGMEM = "Ventilador";
+const char MSG_FAN_SPEED_IT[] PROGMEM = "Velocita vent.";
+const char MSG_FAN_SPEED_ES[] PROGMEM = "Velocidad Vent.";
 const char MSG_FAN_SPEED_PL[] PROGMEM = "Predkosc went.";
+const char MSG_FAN_SPEED_DE[] PROGMEM = "Lueftergeschw.";
 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
+	MSG_FAN_SPEED_PL,
+	MSG_FAN_SPEED_DE
 };
 
 const char MSG_FARM_CARD_MENU_EN[] PROGMEM = "Farm mode print";
@@ -739,12 +826,14 @@ const char MSG_FILAMENTCHANGE_CZ[] PROGMEM = "Vymenit filament";
 const char MSG_FILAMENTCHANGE_IT[] PROGMEM = "Camb. filamento";
 const char MSG_FILAMENTCHANGE_ES[] PROGMEM = "Cambiar filamento";
 const char MSG_FILAMENTCHANGE_PL[] PROGMEM = "Wymienic filament";
+const char MSG_FILAMENTCHANGE_DE[] PROGMEM = "Wechsel 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
+	MSG_FILAMENTCHANGE_PL,
+	MSG_FILAMENTCHANGE_DE
 };
 
 const char MSG_FILAMENT_CLEAN_EN[] PROGMEM = "Is color clear?";
@@ -752,12 +841,14 @@ const char MSG_FILAMENT_CLEAN_CZ[] PROGMEM = "Je barva cista?";
 const char MSG_FILAMENT_CLEAN_IT[] PROGMEM = "Il colore e' nitido?";
 const char MSG_FILAMENT_CLEAN_ES[] PROGMEM = "Es el nuevo color nitido?";
 const char MSG_FILAMENT_CLEAN_PL[] PROGMEM = "Czy kolor jest czysty?";
+const char MSG_FILAMENT_CLEAN_DE[] PROGMEM = "Ist Farbe klar?";
 const char * const MSG_FILAMENT_CLEAN_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_FILAMENT_CLEAN_EN,
 	MSG_FILAMENT_CLEAN_CZ,
 	MSG_FILAMENT_CLEAN_IT,
 	MSG_FILAMENT_CLEAN_ES,
-	MSG_FILAMENT_CLEAN_PL
+	MSG_FILAMENT_CLEAN_PL,
+	MSG_FILAMENT_CLEAN_DE
 };
 
 const char MSG_FILAMENT_LOADING_T0_EN[] PROGMEM = "Insert filament into extruder 1. Click when done.";
@@ -765,12 +856,14 @@ const char MSG_FILAMENT_LOADING_T0_CZ[] PROGMEM = "Vlo\x9Ete filament do extrude
 const char MSG_FILAMENT_LOADING_T0_IT[] PROGMEM = "Inserire filamento nell'estrusore 1. Click per continuare.";
 const char MSG_FILAMENT_LOADING_T0_ES[] PROGMEM = "Insertar filamento en el extrusor 1. Haga clic una vez terminado.";
 const char MSG_FILAMENT_LOADING_T0_PL[] PROGMEM = "Wloz filament do ekstrudera 1. Potwierdz przyciskiem.";
+const char MSG_FILAMENT_LOADING_T0_DE[] PROGMEM = "Filament in extruder 1 einlegen. Klicken wenn fertig.";
 const char * const MSG_FILAMENT_LOADING_T0_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_FILAMENT_LOADING_T0_EN,
 	MSG_FILAMENT_LOADING_T0_CZ,
 	MSG_FILAMENT_LOADING_T0_IT,
 	MSG_FILAMENT_LOADING_T0_ES,
-	MSG_FILAMENT_LOADING_T0_PL
+	MSG_FILAMENT_LOADING_T0_PL,
+	MSG_FILAMENT_LOADING_T0_DE
 };
 
 const char MSG_FILAMENT_LOADING_T1_EN[] PROGMEM = "Insert filament into extruder 2. Click when done.";
@@ -778,12 +871,14 @@ const char MSG_FILAMENT_LOADING_T1_CZ[] PROGMEM = "Vlo\x9Ete filament do extrude
 const char MSG_FILAMENT_LOADING_T1_IT[] PROGMEM = "Inserire filamento nell'estrusore 2. Click per continuare.";
 const char MSG_FILAMENT_LOADING_T1_ES[] PROGMEM = "Insertar filamento en el extrusor 2. Haga clic una vez terminado.";
 const char MSG_FILAMENT_LOADING_T1_PL[] PROGMEM = "Wloz filament do ekstrudera 2. Potwierdz przyciskiem.";
+const char MSG_FILAMENT_LOADING_T1_DE[] PROGMEM = "Filament in extruder 2 einlegen. Klicken wenn fertig.";
 const char * const MSG_FILAMENT_LOADING_T1_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_FILAMENT_LOADING_T1_EN,
 	MSG_FILAMENT_LOADING_T1_CZ,
 	MSG_FILAMENT_LOADING_T1_IT,
 	MSG_FILAMENT_LOADING_T1_ES,
-	MSG_FILAMENT_LOADING_T1_PL
+	MSG_FILAMENT_LOADING_T1_PL,
+	MSG_FILAMENT_LOADING_T1_DE
 };
 
 const char MSG_FILAMENT_LOADING_T2_EN[] PROGMEM = "Insert filament into extruder 3. Click when done.";
@@ -791,12 +886,14 @@ const char MSG_FILAMENT_LOADING_T2_CZ[] PROGMEM = "Vlo\x9Ete filament do extrude
 const char MSG_FILAMENT_LOADING_T2_IT[] PROGMEM = "Inserire filamento nell'estrusore 3. Click per continuare.";
 const char MSG_FILAMENT_LOADING_T2_ES[] PROGMEM = "Insertar filamento en el extrusor 3. Haga clic una vez terminado.";
 const char MSG_FILAMENT_LOADING_T2_PL[] PROGMEM = "Wloz filament do ekstrudera 3. Potwierdz przyciskiem.";
+const char MSG_FILAMENT_LOADING_T2_DE[] PROGMEM = "Filament in extruder 3 einlegen. Klicken wenn fertig.";
 const char * const MSG_FILAMENT_LOADING_T2_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_FILAMENT_LOADING_T2_EN,
 	MSG_FILAMENT_LOADING_T2_CZ,
 	MSG_FILAMENT_LOADING_T2_IT,
 	MSG_FILAMENT_LOADING_T2_ES,
-	MSG_FILAMENT_LOADING_T2_PL
+	MSG_FILAMENT_LOADING_T2_PL,
+	MSG_FILAMENT_LOADING_T2_DE
 };
 
 const char MSG_FILAMENT_LOADING_T3_EN[] PROGMEM = "Insert filament into extruder 4. Click when done.";
@@ -804,12 +901,14 @@ const char MSG_FILAMENT_LOADING_T3_CZ[] PROGMEM = "Vlo\x9Ete filament do extrude
 const char MSG_FILAMENT_LOADING_T3_IT[] PROGMEM = "Inserire filamento nell'estrusore 4. Click per continuare.";
 const char MSG_FILAMENT_LOADING_T3_ES[] PROGMEM = "Insertar filamento en el extrusor 4. Haga clic una vez terminado.";
 const char MSG_FILAMENT_LOADING_T3_PL[] PROGMEM = "Wloz filament do ekstrudera 4. Potwierdz przyciskiem.";
+const char MSG_FILAMENT_LOADING_T3_DE[] PROGMEM = "Filament in extruder 4 einlegen. Klicken wenn fertig.";
 const char * const MSG_FILAMENT_LOADING_T3_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_FILAMENT_LOADING_T3_EN,
 	MSG_FILAMENT_LOADING_T3_CZ,
 	MSG_FILAMENT_LOADING_T3_IT,
 	MSG_FILAMENT_LOADING_T3_ES,
-	MSG_FILAMENT_LOADING_T3_PL
+	MSG_FILAMENT_LOADING_T3_PL,
+	MSG_FILAMENT_LOADING_T3_DE
 };
 
 const char MSG_FILE_PRINTED_EN[] PROGMEM = "Done printing file";
@@ -827,12 +926,14 @@ const char MSG_FIL_ADJUSTING_CZ[] PROGMEM = "Probiha srovnani filamentu. Prosim
 const char MSG_FIL_ADJUSTING_IT[] PROGMEM = "Filamento in fase di regolazione. Attendere prego.";
 const char MSG_FIL_ADJUSTING_ES[] PROGMEM = "Ajustando filamentos. Esperar por favor.";
 const char MSG_FIL_ADJUSTING_PL[] PROGMEM = "Przebiega wyrownanie filamentow. Prosze czekac.";
+const char MSG_FIL_ADJUSTING_DE[] PROGMEM = "Einstellen Filament. Bitte warten.";
 const char * const MSG_FIL_ADJUSTING_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_FIL_ADJUSTING_EN,
 	MSG_FIL_ADJUSTING_CZ,
 	MSG_FIL_ADJUSTING_IT,
 	MSG_FIL_ADJUSTING_ES,
-	MSG_FIL_ADJUSTING_PL
+	MSG_FIL_ADJUSTING_PL,
+	MSG_FIL_ADJUSTING_DE
 };
 
 const char MSG_FIL_LOADED_CHECK_EN[] PROGMEM = "Is filament loaded?";
@@ -840,12 +941,14 @@ const char MSG_FIL_LOADED_CHECK_CZ[] PROGMEM = "Je filament zaveden?";
 const char MSG_FIL_LOADED_CHECK_IT[] PROGMEM = "Filamento caricato?";
 const char MSG_FIL_LOADED_CHECK_ES[] PROGMEM = "Esta cargado el filamento?";
 const char MSG_FIL_LOADED_CHECK_PL[] PROGMEM = "Czy filament jest wprowadzony?";
+const char MSG_FIL_LOADED_CHECK_DE[] PROGMEM = "Filament eingelegt?";
 const char * const MSG_FIL_LOADED_CHECK_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_FIL_LOADED_CHECK_EN,
 	MSG_FIL_LOADED_CHECK_CZ,
 	MSG_FIL_LOADED_CHECK_IT,
 	MSG_FIL_LOADED_CHECK_ES,
-	MSG_FIL_LOADED_CHECK_PL
+	MSG_FIL_LOADED_CHECK_PL,
+	MSG_FIL_LOADED_CHECK_DE
 };
 
 const char MSG_FIL_TUNING_EN[] PROGMEM = "Rotate the knob to adjust filament.";
@@ -853,12 +956,14 @@ const char MSG_FIL_TUNING_CZ[] PROGMEM = "Otacenim tlacitka doladte pozici filam
 const char MSG_FIL_TUNING_IT[] PROGMEM = "Girare la manopola per regolare il filamento";
 const char MSG_FIL_TUNING_ES[] PROGMEM = "Rotar el mando para ajustar el filamento.";
 const char MSG_FIL_TUNING_PL[] PROGMEM = "Obrotem przycisku dostroj pozycje filamentu.";
+const char MSG_FIL_TUNING_DE[] PROGMEM = "Knopf drehen um Filam. einzustellen.";
 const char * const MSG_FIL_TUNING_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_FIL_TUNING_EN,
 	MSG_FIL_TUNING_CZ,
 	MSG_FIL_TUNING_IT,
 	MSG_FIL_TUNING_ES,
-	MSG_FIL_TUNING_PL
+	MSG_FIL_TUNING_PL,
+	MSG_FIL_TUNING_DE
 };
 
 const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_EN[] PROGMEM = "Searching bed calibration point";
@@ -866,12 +971,14 @@ const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_CZ[] PROGMEM = "Hledam kalibracni
 const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_IT[] PROGMEM = "Ricerca del letto punto di calibraz.";
 const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_ES[] PROGMEM = "Buscando cama punto de calibracion";
 const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_PL[] PROGMEM = "Szukam punktu kalibracyjnego podkladki";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_DE[] PROGMEM = "Suchen Bed Kalibrierpunkt";
 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
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_PL,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE1_DE
 };
 
 const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_EN[] PROGMEM = " of 4";
@@ -879,12 +986,14 @@ const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_CZ[] PROGMEM = " z 4";
 const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_IT[] PROGMEM = " su 4";
 const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_ES[] PROGMEM = " de 4";
 const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_PL[] PROGMEM = " z 4";
+const char MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_DE[] PROGMEM = " von 4";
 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
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_PL,
+	MSG_FIND_BED_OFFSET_AND_SKEW_LINE2_DE
 };
 
 const char MSG_FLOW_EN[] PROGMEM = "Flow";
@@ -892,12 +1001,14 @@ 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 MSG_FLOW_DE[] PROGMEM = "Durchfluss";
 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
+	MSG_FLOW_PL,
+	MSG_FLOW_DE
 };
 
 const char MSG_FLOW0_EN[] PROGMEM = "Flow 0";
@@ -920,12 +1031,14 @@ const char MSG_FOLLOW_CALIBRATION_FLOW_CZ[] PROGMEM = "Tiskarna nebyla jeste zka
 const char MSG_FOLLOW_CALIBRATION_FLOW_IT[] PROGMEM = "Stampante ancora non calibrata. Si prega di seguire il manuale, capitolo PRIMI PASSI, sezione della calibrazione.";
 const char MSG_FOLLOW_CALIBRATION_FLOW_ES[] PROGMEM = "Impresora no esta calibrada todavia. Por favor usar el manual, el capitulo First steps, seleccion Calibration flow.";
 const char MSG_FOLLOW_CALIBRATION_FLOW_PL[] PROGMEM = "Drukarka nie zostala jeszcze skalibrowana. Prosze kierowac sie instrukcja, rozdzial Zaczynamy, podrozdzial Selftest.";
+const char MSG_FOLLOW_CALIBRATION_FLOW_DE[] PROGMEM = "Der Drucker wurde noch nicht kalibriert. Bitte folgen Sie dem Handbuch, Kapitel First steps, Abschnitt Calibration flow.";
 const char * const MSG_FOLLOW_CALIBRATION_FLOW_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_FOLLOW_CALIBRATION_FLOW_EN,
 	MSG_FOLLOW_CALIBRATION_FLOW_CZ,
 	MSG_FOLLOW_CALIBRATION_FLOW_IT,
 	MSG_FOLLOW_CALIBRATION_FLOW_ES,
-	MSG_FOLLOW_CALIBRATION_FLOW_PL
+	MSG_FOLLOW_CALIBRATION_FLOW_PL,
+	MSG_FOLLOW_CALIBRATION_FLOW_DE
 };
 
 const char MSG_FREE_MEMORY_EN[] PROGMEM = " Free Memory: ";
@@ -938,25 +1051,29 @@ 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 MSG_HEATING_DE[] PROGMEM = "Erwaermen";
 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
+	MSG_HEATING_PL,
+	MSG_HEATING_DE
 };
 
 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 = "Riscald. completo";
-const char MSG_HEATING_COMPLETE_ES[] PROGMEM = "Calentando listo.";
+const char MSG_HEATING_COMPLETE_ES[] PROGMEM = "Calentamiento final.";
 const char MSG_HEATING_COMPLETE_PL[] PROGMEM = "Grzanie OK.";
+const char MSG_HEATING_COMPLETE_DE[] PROGMEM = "Erwaermen 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
+	MSG_HEATING_COMPLETE_PL,
+	MSG_HEATING_COMPLETE_DE
 };
 
 const char MSG_HOMEYZ_EN[] PROGMEM = "Calibrate Z";
@@ -964,12 +1081,14 @@ 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 MSG_HOMEYZ_DE[] PROGMEM = "Kalibrieren 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
+	MSG_HOMEYZ_PL,
+	MSG_HOMEYZ_DE
 };
 
 const char MSG_HOMEYZ_DONE_EN[] PROGMEM = "Calibration done";
@@ -977,12 +1096,14 @@ const char MSG_HOMEYZ_DONE_CZ[] PROGMEM = "Kalibrace OK";
 const char MSG_HOMEYZ_DONE_IT[] PROGMEM = "Calibrazione OK";
 const char MSG_HOMEYZ_DONE_ES[] PROGMEM = "Calibracion OK";
 const char MSG_HOMEYZ_DONE_PL[] PROGMEM = "Kalibracja OK";
+const char MSG_HOMEYZ_DONE_DE[] PROGMEM = "Kalibrierung 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
+	MSG_HOMEYZ_DONE_PL,
+	MSG_HOMEYZ_DONE_DE
 };
 
 const char MSG_HOMEYZ_PROGRESS_EN[] PROGMEM = "Calibrating Z";
@@ -990,12 +1111,14 @@ 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 MSG_HOMEYZ_PROGRESS_DE[] PROGMEM = "Kalibriere 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
+	MSG_HOMEYZ_PROGRESS_PL,
+	MSG_HOMEYZ_PROGRESS_DE
 };
 
 const char MSG_HOTEND_OFFSET_EN[] PROGMEM = "Hotend offsets:";
@@ -1008,12 +1131,14 @@ const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_CZ[] PROGMEM = "Zlepsuji presno
 const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_IT[] PROGMEM = "Perfezion. il letto punto di calibraz.";
 const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_ES[] PROGMEM = "Mejorando cama punto de calibracion";
 const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_PL[] PROGMEM = "Poprawiam precyzyjnosc punktu kalibracyjnego";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_DE[] PROGMEM = "Verbesserung Bed Kalibrierpunkt";
 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
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_PL,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE1_DE
 };
 
 const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_EN[] PROGMEM = " of 9";
@@ -1021,12 +1146,14 @@ const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_CZ[] PROGMEM = " z 9";
 const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_IT[] PROGMEM = " su 9";
 const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_ES[] PROGMEM = " de 9";
 const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_PL[] PROGMEM = " z 9";
+const char MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_DE[] PROGMEM = " von 9";
 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
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_PL,
+	MSG_IMPROVE_BED_OFFSET_AND_SKEW_LINE2_DE
 };
 
 const char MSG_INIT_SDCARD_EN[] PROGMEM = "Init. SD card";
@@ -1037,14 +1164,16 @@ const char * const MSG_INIT_SDCARD_LANG_TABLE[1] PROGMEM = {
 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_ES[] PROGMEM = "Introducir filamento";
 const char MSG_INSERT_FILAMENT_PL[] PROGMEM = "Wprowadz filament";
+const char MSG_INSERT_FILAMENT_DE[] PROGMEM = "Filament einlegen";
 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
+	MSG_INSERT_FILAMENT_PL,
+	MSG_INSERT_FILAMENT_DE
 };
 
 const char MSG_INVALID_EXTRUDER_EN[] PROGMEM = "Invalid extruder";
@@ -1054,12 +1183,13 @@ const char * const MSG_INVALID_EXTRUDER_LANG_TABLE[1] PROGMEM = {
 
 const char MSG_KILLED_EN[] PROGMEM = "KILLED. ";
 const char MSG_KILLED_IT[] PROGMEM = "IN TILT.";
-const char MSG_KILLED_ES[] PROGMEM = "PARADA DE EMERG.";
+const char MSG_KILLED_ES[] PROGMEM = "PARADA DE EMERGENCIA";
 const char * const MSG_KILLED_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_KILLED_EN,
 	MSG_KILLED_EN,
 	MSG_KILLED_IT,
 	MSG_KILLED_ES,
+	MSG_KILLED_EN,
 	MSG_KILLED_EN
 };
 
@@ -1068,51 +1198,59 @@ 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 MSG_LANGUAGE_NAME_DE[] PROGMEM = "Deutsch";
 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
+	MSG_LANGUAGE_NAME_PL,
+	MSG_LANGUAGE_NAME_DE
 };
 
 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 = "Seleziona lingua";
-const char MSG_LANGUAGE_SELECT_ES[] PROGMEM = "Cambia la lengua ";
+const char MSG_LANGUAGE_SELECT_ES[] PROGMEM = "Cambiae el idioma";
 const char MSG_LANGUAGE_SELECT_PL[] PROGMEM = "Wybor jezyka";
+const char MSG_LANGUAGE_SELECT_DE[] PROGMEM = "Waehle Sprache";
 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
+	MSG_LANGUAGE_SELECT_PL,
+	MSG_LANGUAGE_SELECT_DE
 };
 
 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 = "Caricando colore";
-const char MSG_LOADING_COLOR_ES[] PROGMEM = "Cargando color";
+const char MSG_LOADING_COLOR_ES[] PROGMEM = "Cambiando color";
 const char MSG_LOADING_COLOR_PL[] PROGMEM = "Czyszcz. koloru";
+const char MSG_LOADING_COLOR_DE[] PROGMEM = "Lade Farbe";
 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
+	MSG_LOADING_COLOR_PL,
+	MSG_LOADING_COLOR_DE
 };
 
 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 = "Caricando filam.";
-const char MSG_LOADING_FILAMENT_ES[] PROGMEM = "Cargando fil.";
+const char MSG_LOADING_FILAMENT_ES[] PROGMEM = "Introduciendo filam.";
 const char MSG_LOADING_FILAMENT_PL[] PROGMEM = "Wprow. filamentu";
+const char MSG_LOADING_FILAMENT_DE[] PROGMEM = "Filament-Eifuehrung";
 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
+	MSG_LOADING_FILAMENT_PL,
+	MSG_LOADING_FILAMENT_DE
 };
 
 const char MSG_LOAD_EPROM_EN[] PROGMEM = "Load memory";
@@ -1123,14 +1261,16 @@ const char * const MSG_LOAD_EPROM_LANG_TABLE[1] PROGMEM = {
 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 = "Carica filamento";
-const char MSG_LOAD_FILAMENT_ES[] PROGMEM = "Poner filamento";
+const char MSG_LOAD_FILAMENT_ES[] PROGMEM = "Introducir filam.";
 const char MSG_LOAD_FILAMENT_PL[] PROGMEM = "Wprowadz filament";
+const char MSG_LOAD_FILAMENT_DE[] PROGMEM = "Lege Filament ein";
 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
+	MSG_LOAD_FILAMENT_PL,
+	MSG_LOAD_FILAMENT_DE
 };
 
 const char MSG_LOOSE_PULLEY_EN[] PROGMEM = "Loose pulley";
@@ -1138,12 +1278,14 @@ const char MSG_LOOSE_PULLEY_CZ[] PROGMEM = "Uvolnena remenicka";
 const char MSG_LOOSE_PULLEY_IT[] PROGMEM = "Puleggia lenta";
 const char MSG_LOOSE_PULLEY_ES[] PROGMEM = "Polea suelta";
 const char MSG_LOOSE_PULLEY_PL[] PROGMEM = "Kolo pasowe";
+const char MSG_LOOSE_PULLEY_DE[] PROGMEM = "Lose Riemenschei.";
 const char * const MSG_LOOSE_PULLEY_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_LOOSE_PULLEY_EN,
 	MSG_LOOSE_PULLEY_CZ,
 	MSG_LOOSE_PULLEY_IT,
 	MSG_LOOSE_PULLEY_ES,
-	MSG_LOOSE_PULLEY_PL
+	MSG_LOOSE_PULLEY_PL,
+	MSG_LOOSE_PULLEY_DE
 };
 
 const char MSG_M104_INVALID_EXTRUDER_EN[] PROGMEM = "M104 Invalid extruder ";
@@ -1191,12 +1333,14 @@ 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 MSG_MAIN_DE[] PROGMEM = "Hauptmenue";
 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
+	MSG_MAIN_PL,
+	MSG_MAIN_DE
 };
 
 const char MSG_MARK_FIL_EN[] PROGMEM = "Mark filament 100mm from extruder body. Click when done.";
@@ -1204,12 +1348,14 @@ const char MSG_MARK_FIL_CZ[] PROGMEM = "Oznacte filament 100 mm od tela extruder
 const char MSG_MARK_FIL_IT[] PROGMEM = "Segnare il filamento a 100 mm di distanza dal corpo dell'estrusore. Click per continuare.";
 const char MSG_MARK_FIL_ES[] PROGMEM = "Marque el filamento 100 mm por encima del final del extrusor. Hacer clic una vez terminado.";
 const char MSG_MARK_FIL_PL[] PROGMEM = "Prosze oznaczyc filament 100 mm od ciala ekstrudera. Potwierdzic przyciskiem.";
+const char MSG_MARK_FIL_DE[] PROGMEM = "Markier Filament 100mm vom Extrudergehaeuse. Klicken wenn Fertig.";
 const char * const MSG_MARK_FIL_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_MARK_FIL_EN,
 	MSG_MARK_FIL_CZ,
 	MSG_MARK_FIL_IT,
 	MSG_MARK_FIL_ES,
-	MSG_MARK_FIL_PL
+	MSG_MARK_FIL_PL,
+	MSG_MARK_FIL_DE
 };
 
 const char MSG_MAX_EN[] PROGMEM = " \002 Max";
@@ -1222,12 +1368,14 @@ const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_CZ[] PROGMEM = "Merim referenc
 const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_IT[] PROGMEM = "Misurare l'altezza di riferimento del punto di calibrazione";
 const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_ES[] PROGMEM = "Medir la altura del punto de la calibracion";
 const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_PL[] PROGMEM = "Okreslam wysokosc odniesienia punktu kalibracyjnego";
+const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_DE[] PROGMEM = "Messen der Referenzhoehe des Kalibrierpunktes";
 const char * const MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_EN,
 	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_CZ,
 	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_IT,
 	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_ES,
-	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_PL
+	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_PL,
+	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE1_DE
 };
 
 const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_EN[] PROGMEM = " of 9";
@@ -1235,12 +1383,14 @@ const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_CZ[] PROGMEM = " z 9";
 const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_IT[] PROGMEM = " su 9";
 const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_ES[] PROGMEM = " de 9";
 const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_PL[] PROGMEM = " z 9";
+const char MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_DE[] PROGMEM = " von 9";
 const char * const MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_EN,
 	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_CZ,
 	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_IT,
 	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_ES,
-	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_PL
+	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_PL,
+	MSG_MEASURE_BED_REFERENCE_HEIGHT_LINE2_DE
 };
 
 const char MSG_MENU_CALIBRATION_EN[] PROGMEM = "Calibration";
@@ -1248,12 +1398,14 @@ const char MSG_MENU_CALIBRATION_CZ[] PROGMEM = "Kalibrace";
 const char MSG_MENU_CALIBRATION_IT[] PROGMEM = "Calibrazione";
 const char MSG_MENU_CALIBRATION_ES[] PROGMEM = "Calibracion";
 const char MSG_MENU_CALIBRATION_PL[] PROGMEM = "Kalibracja";
+const char MSG_MENU_CALIBRATION_DE[] PROGMEM = "Kalibrierung";
 const char * const MSG_MENU_CALIBRATION_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_MENU_CALIBRATION_EN,
 	MSG_MENU_CALIBRATION_CZ,
 	MSG_MENU_CALIBRATION_IT,
 	MSG_MENU_CALIBRATION_ES,
-	MSG_MENU_CALIBRATION_PL
+	MSG_MENU_CALIBRATION_PL,
+	MSG_MENU_CALIBRATION_DE
 };
 
 const char MSG_MESH_BED_LEVELING_EN[] PROGMEM = "Mesh Bed Leveling";
@@ -1263,6 +1415,7 @@ const char * const MSG_MESH_BED_LEVELING_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_MESH_BED_LEVELING_EN,
 	MSG_MESH_BED_LEVELING_IT,
 	MSG_MESH_BED_LEVELING_EN,
+	MSG_MESH_BED_LEVELING_EN,
 	MSG_MESH_BED_LEVELING_EN
 };
 
@@ -1296,12 +1449,14 @@ 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 MSG_MOVE_AXIS_DE[] PROGMEM = "Bewege Achse";
 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
+	MSG_MOVE_AXIS_PL,
+	MSG_MOVE_AXIS_DE
 };
 
 const char MSG_MOVE_CARRIAGE_TO_THE_TOP_EN[] PROGMEM = "Calibrating XYZ. Rotate the knob to move the Z carriage up to the end stoppers. Click when done.";
@@ -1309,12 +1464,14 @@ const char MSG_MOVE_CARRIAGE_TO_THE_TOP_CZ[] PROGMEM = "Kalibrace XYZ. Otacenim
 const char MSG_MOVE_CARRIAGE_TO_THE_TOP_IT[] PROGMEM = "Calibrazione XYZ. Ruotare la manopola per alzare il carrello Z fino all'altezza massima. Click per terminare.";
 const char MSG_MOVE_CARRIAGE_TO_THE_TOP_ES[] PROGMEM = "Calibrando XYZ. Gira el boton para subir el carro Z hasta golpe piezas superioras. Despues haz clic.";
 const char MSG_MOVE_CARRIAGE_TO_THE_TOP_PL[] PROGMEM = "Kalibracja XYZ. Przekrec galke, aby przesunac os Z do gornych krancowek. Nacisnij, by potwierdzic.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_DE[] PROGMEM = "Kalibrieren von XYZ. Drehen Sie den Knopf, um den Z-Schlitten bis zum Anschlag zu bewegen. Klicken wenn fertig.";
 const char * const MSG_MOVE_CARRIAGE_TO_THE_TOP_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_MOVE_CARRIAGE_TO_THE_TOP_EN,
 	MSG_MOVE_CARRIAGE_TO_THE_TOP_CZ,
 	MSG_MOVE_CARRIAGE_TO_THE_TOP_IT,
 	MSG_MOVE_CARRIAGE_TO_THE_TOP_ES,
-	MSG_MOVE_CARRIAGE_TO_THE_TOP_PL
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_PL,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_DE
 };
 
 const char MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_EN[] PROGMEM = "Calibrating Z. Rotate the knob to move the Z carriage up to the end stoppers. Click when done.";
@@ -1322,22 +1479,25 @@ const char MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_CZ[] PROGMEM = "Kalibrace Z. Otacenim
 const char MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_IT[] PROGMEM = "Calibrazione Z. Ruotare la manopola per alzare il carrello Z fino all'altezza massima. Click per terminare.";
 const char MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_ES[] PROGMEM = "Calibrando Z. Gira el boton para subir el carro Z hasta golpe piezas superioras. Despues haz clic.";
 const char MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_PL[] PROGMEM = "Kalibracja Z. Przekrec galke, aby przesunac os Z do gornych krancowek. Nacisnij, by potwierdzic.";
+const char MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_DE[] PROGMEM = "Kalibrieren von Z. Drehen Sie den Knopf, um den Z-Schlitten bis zum Anschlag zu bewegen. Klicken wenn fertig.";
 const char * const MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_EN,
 	MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_CZ,
 	MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_IT,
 	MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_ES,
-	MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_PL
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_PL,
+	MSG_MOVE_CARRIAGE_TO_THE_TOP_Z_DE
 };
 
 const char MSG_MOVE_E_EN[] PROGMEM = "Extruder";
 const char MSG_MOVE_E_IT[] PROGMEM = "Muovi Estrusore";
-const char MSG_MOVE_E_ES[] PROGMEM = "Extrusor";
+const char MSG_MOVE_E_ES[] PROGMEM = "Extruir";
 const char * const MSG_MOVE_E_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_MOVE_E_EN,
 	MSG_MOVE_E_EN,
 	MSG_MOVE_E_IT,
 	MSG_MOVE_E_ES,
+	MSG_MOVE_E_EN,
 	MSG_MOVE_E_EN
 };
 
@@ -1346,12 +1506,14 @@ 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 MSG_MOVE_X_DE[] PROGMEM = "Bewege 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
+	MSG_MOVE_X_PL,
+	MSG_MOVE_X_DE
 };
 
 const char MSG_MOVE_Y_EN[] PROGMEM = "Move Y";
@@ -1359,12 +1521,14 @@ 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 MSG_MOVE_Y_DE[] PROGMEM = "Bewege 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
+	MSG_MOVE_Y_PL,
+	MSG_MOVE_Y_DE
 };
 
 const char MSG_MOVE_Z_EN[] PROGMEM = "Move Z";
@@ -1372,12 +1536,14 @@ 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 MSG_MOVE_Z_DE[] PROGMEM = "Bewege 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
+	MSG_MOVE_Z_PL,
+	MSG_MOVE_Z_DE
 };
 
 const char MSG_NEW_FIRMWARE_AVAILABLE_EN[] PROGMEM = "New firmware version available:";
@@ -1385,12 +1551,14 @@ const char MSG_NEW_FIRMWARE_AVAILABLE_CZ[] PROGMEM = "Vysla nova verze firmware:
 const char MSG_NEW_FIRMWARE_AVAILABLE_IT[] PROGMEM = "Nuova versione del firmware disponibile";
 const char MSG_NEW_FIRMWARE_AVAILABLE_ES[] PROGMEM = "Nuevo firmware disponible:";
 const char MSG_NEW_FIRMWARE_AVAILABLE_PL[] PROGMEM = "Wyszla nowa wersja firmware:";
+const char MSG_NEW_FIRMWARE_AVAILABLE_DE[] PROGMEM = "Neue Firmware Version verfuegbar:";
 const char * const MSG_NEW_FIRMWARE_AVAILABLE_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_NEW_FIRMWARE_AVAILABLE_EN,
 	MSG_NEW_FIRMWARE_AVAILABLE_CZ,
 	MSG_NEW_FIRMWARE_AVAILABLE_IT,
 	MSG_NEW_FIRMWARE_AVAILABLE_ES,
-	MSG_NEW_FIRMWARE_AVAILABLE_PL
+	MSG_NEW_FIRMWARE_AVAILABLE_PL,
+	MSG_NEW_FIRMWARE_AVAILABLE_DE
 };
 
 const char MSG_NEW_FIRMWARE_PLEASE_UPGRADE_EN[] PROGMEM = "Please upgrade.";
@@ -1398,62 +1566,72 @@ const char MSG_NEW_FIRMWARE_PLEASE_UPGRADE_CZ[] PROGMEM = "Prosim aktualizujte."
 const char MSG_NEW_FIRMWARE_PLEASE_UPGRADE_IT[] PROGMEM = "Prega aggiorna.";
 const char MSG_NEW_FIRMWARE_PLEASE_UPGRADE_ES[] PROGMEM = "Actualizar por favor";
 const char MSG_NEW_FIRMWARE_PLEASE_UPGRADE_PL[] PROGMEM = "Prosze zaktualizowac";
+const char MSG_NEW_FIRMWARE_PLEASE_UPGRADE_DE[] PROGMEM = "Bitte aktualisieren.";
 const char * const MSG_NEW_FIRMWARE_PLEASE_UPGRADE_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_NEW_FIRMWARE_PLEASE_UPGRADE_EN,
 	MSG_NEW_FIRMWARE_PLEASE_UPGRADE_CZ,
 	MSG_NEW_FIRMWARE_PLEASE_UPGRADE_IT,
 	MSG_NEW_FIRMWARE_PLEASE_UPGRADE_ES,
-	MSG_NEW_FIRMWARE_PLEASE_UPGRADE_PL
+	MSG_NEW_FIRMWARE_PLEASE_UPGRADE_PL,
+	MSG_NEW_FIRMWARE_PLEASE_UPGRADE_DE
 };
 
 const char MSG_NO_EN[] PROGMEM = "No";
 const char MSG_NO_CZ[] PROGMEM = "Ne";
 const char MSG_NO_PL[] PROGMEM = "Nie";
+const char MSG_NO_DE[] PROGMEM = "Nein";
 const char * const MSG_NO_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_NO_EN,
 	MSG_NO_CZ,
 	MSG_NO_EN,
 	MSG_NO_EN,
-	MSG_NO_PL
+	MSG_NO_PL,
+	MSG_NO_DE
 };
 
 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 = "Colore non puro";
-const char MSG_NOT_COLOR_ES[] PROGMEM = "Color no claro";
+const char MSG_NOT_COLOR_ES[] PROGMEM = "Color no homogeneo";
 const char MSG_NOT_COLOR_PL[] PROGMEM = "Kolor zanieczysz.";
+const char MSG_NOT_COLOR_DE[] PROGMEM = "Farbe nicht klar";
 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
+	MSG_NOT_COLOR_PL,
+	MSG_NOT_COLOR_DE
 };
 
 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. non caricato";
-const char MSG_NOT_LOADED_ES[] PROGMEM = "Fil. no cargado";
+const char MSG_NOT_LOADED_ES[] PROGMEM = "Fil. no introducido";
 const char MSG_NOT_LOADED_PL[] PROGMEM = "Brak filamentu";
+const char MSG_NOT_LOADED_DE[] PROGMEM = "Filam. nicht geladen";
 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
+	MSG_NOT_LOADED_PL,
+	MSG_NOT_LOADED_DE
 };
 
 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_ES[] PROGMEM = "Boquilla";
 const char MSG_NOZZLE_PL[] PROGMEM = "Dysza";
+const char MSG_NOZZLE_DE[] PROGMEM = "Duese";
 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
+	MSG_NOZZLE_PL,
+	MSG_NOZZLE_DE
 };
 
 const char MSG_NOZZLE1_EN[] PROGMEM = "Nozzle2";
@@ -1471,23 +1649,27 @@ const char MSG_NO_CARD_CZ[] PROGMEM = "Zadna SD karta";
 const char MSG_NO_CARD_IT[] PROGMEM = "Nessuna SD";
 const char MSG_NO_CARD_ES[] PROGMEM = "No hay tarjeta SD";
 const char MSG_NO_CARD_PL[] PROGMEM = "Brak karty SD";
+const char MSG_NO_CARD_DE[] PROGMEM = "Keine SD Karte";
 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
+	MSG_NO_CARD_PL,
+	MSG_NO_CARD_DE
 };
 
 const char MSG_NO_MOVE_EN[] 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_DE[] PROGMEM = "Keine Bewegung.";
 const char * const MSG_NO_MOVE_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_NO_MOVE_EN,
 	MSG_NO_MOVE_EN,
 	MSG_NO_MOVE_IT,
 	MSG_NO_MOVE_ES,
-	MSG_NO_MOVE_EN
+	MSG_NO_MOVE_EN,
+	MSG_NO_MOVE_DE
 };
 
 const char MSG_OFF_EN[] PROGMEM = "Off";
@@ -1507,12 +1689,17 @@ const char * const MSG_ON_LANG_TABLE[1] PROGMEM = {
 
 const char MSG_PAPER_EN[] PROGMEM = "Place a sheet of paper under the nozzle during the calibration of first 4 points. If the nozzle catches the paper, power off the printer immediately.";
 const char MSG_PAPER_CZ[] PROGMEM = "Umistete list papiru na podlozku a udrzujte jej pod tryskou behem mereni prvnich 4 bodu. Pokud tryska zachyti papir, vypnete tiskarnu.";
+const char MSG_PAPER_IT[] PROGMEM = "Porre un foglio sotto l'ugello durante la calibrazione dei primi 4 punti. In caso l'ugello muova il foglio spegnere prontamente la stampante.";
+const char MSG_PAPER_ES[] PROGMEM = "Colocar una hoja de papel sobre la superficie de impresion durante la calibracion de los primeros 4 puntos. Si la boquilla mueve el papel, apagar impresora inmediatamente.";
+const char MSG_PAPER_PL[] PROGMEM = "Umiesc kartke papieru na podkladce i trzymaj pod dysza podczas pomiaru pierwszych 4 punktow. Jesli dysza zahaczy o papier, wylacz drukarke.";
+const char MSG_PAPER_DE[] PROGMEM = "Legen ein Blatt Papier unter die Duese waehrend der Kalibrierung der ersten 4 Punkte. Wenn die Duese das Papier einfaengt, Drucker sofort ausschalten";
 const char * const MSG_PAPER_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_PAPER_EN,
 	MSG_PAPER_CZ,
-	MSG_PAPER_EN,
-	MSG_PAPER_EN,
-	MSG_PAPER_EN
+	MSG_PAPER_IT,
+	MSG_PAPER_ES,
+	MSG_PAPER_PL,
+	MSG_PAPER_DE
 };
 
 const char MSG_PAUSE_PRINT_EN[] PROGMEM = "Pause print";
@@ -1520,24 +1707,28 @@ const char MSG_PAUSE_PRINT_CZ[] PROGMEM = "Pozastavit tisk";
 const char MSG_PAUSE_PRINT_IT[] PROGMEM = "Metti in pausa";
 const char MSG_PAUSE_PRINT_ES[] PROGMEM = "Pausar impresion";
 const char MSG_PAUSE_PRINT_PL[] PROGMEM = "Przerwac druk";
+const char MSG_PAUSE_PRINT_DE[] PROGMEM = "Druck aussetzen";
 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
+	MSG_PAUSE_PRINT_PL,
+	MSG_PAUSE_PRINT_DE
 };
 
 const char MSG_PICK_Z_EN[] PROGMEM = "Pick print";
 const char MSG_PICK_Z_CZ[] PROGMEM = "Vyberte vytisk";
-const char MSG_PICK_Z_ES[] PROGMEM = "Vyberte vytisk";
+const char MSG_PICK_Z_ES[] PROGMEM = "Esc. Modelo Adecuado";
 const char MSG_PICK_Z_PL[] PROGMEM = "Vyberte vytisk";
+const char MSG_PICK_Z_DE[] PROGMEM = "Waehle Abdruck";
 const char * const MSG_PICK_Z_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_PICK_Z_EN,
 	MSG_PICK_Z_CZ,
 	MSG_PICK_Z_EN,
 	MSG_PICK_Z_ES,
-	MSG_PICK_Z_PL
+	MSG_PICK_Z_PL,
+	MSG_PICK_Z_DE
 };
 
 const char MSG_PLANNER_BUFFER_BYTES_EN[] PROGMEM = "  PlannerBufferBytes: ";
@@ -1548,14 +1739,16 @@ const char * const MSG_PLANNER_BUFFER_BYTES_LANG_TABLE[1] PROGMEM = {
 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_ES[] PROGMEM = "Por Favor Esperar";
 const char MSG_PLEASE_WAIT_PL[] PROGMEM = "Prosze czekac";
+const char MSG_PLEASE_WAIT_DE[] PROGMEM = "Bitte warten";
 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
+	MSG_PLEASE_WAIT_PL,
+	MSG_PLEASE_WAIT_DE
 };
 
 const char MSG_POSITION_UNKNOWN_EN[] PROGMEM = "Home X/Y before Z";
@@ -1573,50 +1766,59 @@ 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 MSG_PREHEAT_DE[] PROGMEM = "Vorwaermen";
 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
+	MSG_PREHEAT_PL,
+	MSG_PREHEAT_DE
 };
 
 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_ES[] PROGMEM = "Precalentar extrusor";
 const char MSG_PREHEAT_NOZZLE_PL[] PROGMEM = "Nagrzej dysze!";
+const char MSG_PREHEAT_NOZZLE_DE[] PROGMEM = "Worwaermen Duese";
 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
+	MSG_PREHEAT_NOZZLE_PL,
+	MSG_PREHEAT_NOZZLE_DE
 };
 
 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 = "e cliccare manopola";
-const char MSG_PRESS_ES[] PROGMEM = "y pulse el mando";
+const char MSG_PRESS_ES[] PROGMEM = "Pulsar el mando";
 const char MSG_PRESS_PL[] PROGMEM = "Nacisnij przycisk";
+const char MSG_PRESS_DE[] PROGMEM = "und Knopf druecken";
 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
+	MSG_PRESS_PL,
+	MSG_PRESS_DE
 };
 
 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 = "Impresion cancelada";
 const char MSG_PRINT_ABORTED_PL[] PROGMEM = "Druk przerwany";
+const char MSG_PRINT_ABORTED_DE[] PROGMEM = "Druck abgebrochen";
 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_EN,
-	MSG_PRINT_ABORTED_PL
+	MSG_PRINT_ABORTED_ES,
+	MSG_PRINT_ABORTED_PL,
+	MSG_PRINT_ABORTED_DE
 };
 
 const char MSG_PRUSA3D_EN[] PROGMEM = "prusa3d.com";
@@ -1627,7 +1829,8 @@ const char * const MSG_PRUSA3D_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_PRUSA3D_CZ,
 	MSG_PRUSA3D_EN,
 	MSG_PRUSA3D_EN,
-	MSG_PRUSA3D_PL
+	MSG_PRUSA3D_PL,
+	MSG_PRUSA3D_EN
 };
 
 const char MSG_PRUSA3D_FORUM_EN[] PROGMEM = "forum.prusa3d.com";
@@ -1638,7 +1841,8 @@ const char * const MSG_PRUSA3D_FORUM_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_PRUSA3D_FORUM_CZ,
 	MSG_PRUSA3D_FORUM_EN,
 	MSG_PRUSA3D_FORUM_EN,
-	MSG_PRUSA3D_FORUM_PL
+	MSG_PRUSA3D_FORUM_PL,
+	MSG_PRUSA3D_FORUM_EN
 };
 
 const char MSG_PRUSA3D_HOWTO_EN[] PROGMEM = "howto.prusa3d.com";
@@ -1649,20 +1853,23 @@ const char * const MSG_PRUSA3D_HOWTO_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_PRUSA3D_HOWTO_CZ,
 	MSG_PRUSA3D_HOWTO_EN,
 	MSG_PRUSA3D_HOWTO_EN,
-	MSG_PRUSA3D_HOWTO_PL
+	MSG_PRUSA3D_HOWTO_PL,
+	MSG_PRUSA3D_HOWTO_EN
 };
 
 const char MSG_REBOOT_EN[] PROGMEM = "Reboot the printer";
 const char MSG_REBOOT_CZ[] PROGMEM = "Restartujte tiskarnu";
 const char MSG_REBOOT_IT[] PROGMEM = "Riavvia stampante";
-const char MSG_REBOOT_ES[] PROGMEM = "Reiniciar la imp.";
+const char MSG_REBOOT_ES[] PROGMEM = "Reiniciar impresora";
 const char MSG_REBOOT_PL[] PROGMEM = "Restart drukarki";
+const char MSG_REBOOT_DE[] PROGMEM = "Reboot den Printer";
 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
+	MSG_REBOOT_PL,
+	MSG_REBOOT_DE
 };
 
 const char MSG_RECTRACT_EN[] PROGMEM = "Rectract";
@@ -1695,25 +1902,29 @@ 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 MSG_RESUME_PRINT_DE[] PROGMEM = "Fortsetzen";
 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
+	MSG_RESUME_PRINT_PL,
+	MSG_RESUME_PRINT_DE
 };
 
 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_ES[] PROGMEM = "Resumiendo impresion";
 const char MSG_RESUMING_PL[] PROGMEM = "Wznowienie druku";
+const char MSG_RESUMING_DE[] PROGMEM = "Druck fortgesetzt";
 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
+	MSG_RESUMING_PL,
+	MSG_RESUMING_DE
 };
 
 const char MSG_SD_CANT_ENTER_SUBDIR_EN[] PROGMEM = "Cannot enter subdir: ";
@@ -1754,14 +1965,16 @@ const char * const MSG_SD_INIT_FAIL_LANG_TABLE[1] PROGMEM = {
 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 inserita";
-const char MSG_SD_INSERTED_ES[] PROGMEM = "Tarjeta colocada";
+const char MSG_SD_INSERTED_ES[] PROGMEM = "Tarjeta insertada";
 const char MSG_SD_INSERTED_PL[] PROGMEM = "Karta wlozona";
+const char MSG_SD_INSERTED_DE[] PROGMEM = "SD eingesetzt";
 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
+	MSG_SD_INSERTED_PL,
+	MSG_SD_INSERTED_DE
 };
 
 const char MSG_SD_NOT_PRINTING_EN[] PROGMEM = "Not SD printing";
@@ -1789,12 +2002,14 @@ const char MSG_SD_REMOVED_CZ[] PROGMEM = "Karta vyjmuta";
 const char MSG_SD_REMOVED_IT[] PROGMEM = "SD rimossa";
 const char MSG_SD_REMOVED_ES[] PROGMEM = "Tarjeta retirada";
 const char MSG_SD_REMOVED_PL[] PROGMEM = "Karta wyjeta";
+const char MSG_SD_REMOVED_DE[] PROGMEM = "SD entfernt ";
 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
+	MSG_SD_REMOVED_PL,
+	MSG_SD_REMOVED_DE
 };
 
 const char MSG_SD_SIZE_EN[] PROGMEM = " Size: ";
@@ -1820,12 +2035,14 @@ const char * const MSG_SD_WRITE_TO_FILE_LANG_TABLE[1] PROGMEM = {
 const char MSG_SELFTEST_EN[] PROGMEM = "Selftest         ";
 const char MSG_SELFTEST_IT[] PROGMEM = "Autotest";
 const char MSG_SELFTEST_ES[] PROGMEM = "Autotest";
+const char MSG_SELFTEST_DE[] PROGMEM = "Selbsttest       ";
 const char * const MSG_SELFTEST_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_EN,
 	MSG_SELFTEST_EN,
 	MSG_SELFTEST_IT,
 	MSG_SELFTEST_ES,
-	MSG_SELFTEST_EN
+	MSG_SELFTEST_EN,
+	MSG_SELFTEST_DE
 };
 
 const char MSG_SELFTEST_BEDHEATER_EN[] PROGMEM = "Bed / Heater";
@@ -1836,6 +2053,7 @@ const char * const MSG_SELFTEST_BEDHEATER_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_BEDHEATER_EN,
 	MSG_SELFTEST_BEDHEATER_IT,
 	MSG_SELFTEST_BEDHEATER_ES,
+	MSG_SELFTEST_BEDHEATER_EN,
 	MSG_SELFTEST_BEDHEATER_EN
 };
 
@@ -1844,12 +2062,14 @@ 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 MSG_SELFTEST_CHECK_ALLCORRECT_DE[] PROGMEM = "Alles richtig    ";
 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
+	MSG_SELFTEST_CHECK_ALLCORRECT_PL,
+	MSG_SELFTEST_CHECK_ALLCORRECT_DE
 };
 
 const char MSG_SELFTEST_CHECK_BED_EN[] PROGMEM = "Checking bed     ";
@@ -1857,12 +2077,14 @@ const char MSG_SELFTEST_CHECK_BED_CZ[] PROGMEM = "Kontrola bed     ";
 const char MSG_SELFTEST_CHECK_BED_IT[] PROGMEM = "Verifica letto";
 const char MSG_SELFTEST_CHECK_BED_ES[] PROGMEM = "Control de cama";
 const char MSG_SELFTEST_CHECK_BED_PL[] PROGMEM = "Kontrola bed     ";
+const char MSG_SELFTEST_CHECK_BED_DE[] PROGMEM = "Pr\x81fe 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
+	MSG_SELFTEST_CHECK_BED_PL,
+	MSG_SELFTEST_CHECK_BED_DE
 };
 
 const char MSG_SELFTEST_CHECK_ENDSTOPS_EN[] PROGMEM = "Checking endstops";
@@ -1870,12 +2092,14 @@ const char MSG_SELFTEST_CHECK_ENDSTOPS_CZ[] PROGMEM = "Kontrola endstops";
 const char MSG_SELFTEST_CHECK_ENDSTOPS_IT[] PROGMEM = "Verifica finecorsa";
 const char MSG_SELFTEST_CHECK_ENDSTOPS_ES[] PROGMEM = "Cont. topes final";
 const char MSG_SELFTEST_CHECK_ENDSTOPS_PL[] PROGMEM = "Kontrola endstops";
+const char MSG_SELFTEST_CHECK_ENDSTOPS_DE[] PROGMEM = "Pr\x81fe 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
+	MSG_SELFTEST_CHECK_ENDSTOPS_PL,
+	MSG_SELFTEST_CHECK_ENDSTOPS_DE
 };
 
 const char MSG_SELFTEST_CHECK_HOTEND_EN[] PROGMEM = "Checking hotend  ";
@@ -1883,12 +2107,14 @@ const char MSG_SELFTEST_CHECK_HOTEND_CZ[] PROGMEM = "Kontrola hotend  ";
 const char MSG_SELFTEST_CHECK_HOTEND_IT[] PROGMEM = "Verifica ugello";
 const char MSG_SELFTEST_CHECK_HOTEND_ES[] PROGMEM = "Control hotend ";
 const char MSG_SELFTEST_CHECK_HOTEND_PL[] PROGMEM = "Kontrola hotend  ";
+const char MSG_SELFTEST_CHECK_HOTEND_DE[] PROGMEM = "Pr\x81fe 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
+	MSG_SELFTEST_CHECK_HOTEND_PL,
+	MSG_SELFTEST_CHECK_HOTEND_DE
 };
 
 const char MSG_SELFTEST_CHECK_X_EN[] PROGMEM = "Checking X axis  ";
@@ -1896,12 +2122,14 @@ 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 MSG_SELFTEST_CHECK_X_DE[] PROGMEM = "Pr\x81fe X Achse    ";
 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
+	MSG_SELFTEST_CHECK_X_PL,
+	MSG_SELFTEST_CHECK_X_DE
 };
 
 const char MSG_SELFTEST_CHECK_Y_EN[] PROGMEM = "Checking Y axis  ";
@@ -1909,12 +2137,14 @@ 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 MSG_SELFTEST_CHECK_Y_DE[] PROGMEM = "Pr\x81fe Y Achse    ";
 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
+	MSG_SELFTEST_CHECK_Y_PL,
+	MSG_SELFTEST_CHECK_Y_DE
 };
 
 const char MSG_SELFTEST_CHECK_Z_EN[] PROGMEM = "Checking Z axis  ";
@@ -1922,12 +2152,14 @@ 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 MSG_SELFTEST_CHECK_Z_DE[] PROGMEM = "Pr\x81fe Z Achse    ";
 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
+	MSG_SELFTEST_CHECK_Z_PL,
+	MSG_SELFTEST_CHECK_Z_DE
 };
 
 const char MSG_SELFTEST_COOLING_FAN_EN[] PROGMEM = "Front print fan?";;
@@ -1935,12 +2167,14 @@ const char MSG_SELFTEST_COOLING_FAN_CZ[] PROGMEM = "Predni tiskovy vent?";;
 const char MSG_SELFTEST_COOLING_FAN_IT[] PROGMEM = "Vent di stampa ant.?";;
 const char MSG_SELFTEST_COOLING_FAN_ES[] PROGMEM = "Vent. al frente?";;
 const char MSG_SELFTEST_COOLING_FAN_PL[] PROGMEM = "Przodni went. druku?";;
+const char MSG_SELFTEST_COOLING_FAN_DE[] PROGMEM = "Vord. Frontluefter?";
 const char * const MSG_SELFTEST_COOLING_FAN_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_COOLING_FAN_EN,
 	MSG_SELFTEST_COOLING_FAN_CZ,
 	MSG_SELFTEST_COOLING_FAN_IT,
 	MSG_SELFTEST_COOLING_FAN_ES,
-	MSG_SELFTEST_COOLING_FAN_PL
+	MSG_SELFTEST_COOLING_FAN_PL,
+	MSG_SELFTEST_COOLING_FAN_DE
 };
 
 const char MSG_SELFTEST_ENDSTOP_EN[] PROGMEM = "Endstop";
@@ -1951,6 +2185,7 @@ const char * const MSG_SELFTEST_ENDSTOP_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_ENDSTOP_EN,
 	MSG_SELFTEST_ENDSTOP_IT,
 	MSG_SELFTEST_ENDSTOP_ES,
+	MSG_SELFTEST_ENDSTOP_EN,
 	MSG_SELFTEST_ENDSTOP_EN
 };
 
@@ -1962,29 +2197,34 @@ const char * const MSG_SELFTEST_ENDSTOPS_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_ENDSTOPS_EN,
 	MSG_SELFTEST_ENDSTOPS_IT,
 	MSG_SELFTEST_ENDSTOPS_ES,
+	MSG_SELFTEST_ENDSTOPS_EN,
 	MSG_SELFTEST_ENDSTOPS_EN
 };
 
 const char MSG_SELFTEST_ENDSTOP_NOTHIT_EN[] PROGMEM = "Endstop not hit";
 const char MSG_SELFTEST_ENDSTOP_NOTHIT_IT[] PROGMEM = "Finec. fuori por.";
 const char MSG_SELFTEST_ENDSTOP_NOTHIT_ES[] PROGMEM = "Tope fin. no toc.";
+const char MSG_SELFTEST_ENDSTOP_NOTHIT_DE[] PROGMEM = "End nicht getrof.";
 const char * const MSG_SELFTEST_ENDSTOP_NOTHIT_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_ENDSTOP_NOTHIT_EN,
 	MSG_SELFTEST_ENDSTOP_NOTHIT_EN,
 	MSG_SELFTEST_ENDSTOP_NOTHIT_IT,
 	MSG_SELFTEST_ENDSTOP_NOTHIT_ES,
-	MSG_SELFTEST_ENDSTOP_NOTHIT_EN
+	MSG_SELFTEST_ENDSTOP_NOTHIT_EN,
+	MSG_SELFTEST_ENDSTOP_NOTHIT_DE
 };
 
 const char MSG_SELFTEST_ERROR_EN[] PROGMEM = "Selftest error !";
 const char MSG_SELFTEST_ERROR_IT[] PROGMEM = "Autotest negativo";
 const char MSG_SELFTEST_ERROR_ES[] PROGMEM = "Autotest error!";
+const char MSG_SELFTEST_ERROR_DE[] PROGMEM = "Selbtest Fehler!";
 const char * const MSG_SELFTEST_ERROR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_ERROR_EN,
 	MSG_SELFTEST_ERROR_EN,
 	MSG_SELFTEST_ERROR_IT,
 	MSG_SELFTEST_ERROR_ES,
-	MSG_SELFTEST_ERROR_EN
+	MSG_SELFTEST_ERROR_EN,
+	MSG_SELFTEST_ERROR_DE
 };
 
 const char MSG_SELFTEST_EXTRUDER_FAN_EN[] PROGMEM = "Left hotend fan?";;
@@ -1992,12 +2232,14 @@ const char MSG_SELFTEST_EXTRUDER_FAN_CZ[] PROGMEM = "Levy vent na trysce?";;
 const char MSG_SELFTEST_EXTRUDER_FAN_IT[] PROGMEM = "Vent SX sull'ugello?";;
 const char MSG_SELFTEST_EXTRUDER_FAN_ES[] PROGMEM = "Vent. en la izg?";;
 const char MSG_SELFTEST_EXTRUDER_FAN_PL[] PROGMEM = "Lewy went na dysze?";;
+const char MSG_SELFTEST_EXTRUDER_FAN_DE[] PROGMEM = "Link. Hotendluefter?";
 const char * const MSG_SELFTEST_EXTRUDER_FAN_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_EXTRUDER_FAN_EN,
 	MSG_SELFTEST_EXTRUDER_FAN_CZ,
 	MSG_SELFTEST_EXTRUDER_FAN_IT,
 	MSG_SELFTEST_EXTRUDER_FAN_ES,
-	MSG_SELFTEST_EXTRUDER_FAN_PL
+	MSG_SELFTEST_EXTRUDER_FAN_PL,
+	MSG_SELFTEST_EXTRUDER_FAN_DE
 };
 
 const char MSG_SELFTEST_FAILED_EN[] PROGMEM = "Selftest failed  ";
@@ -2005,12 +2247,14 @@ 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 MSG_SELFTEST_FAILED_DE[] PROGMEM = "Selbtest fehlgeschlg";
 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
+	MSG_SELFTEST_FAILED_PL,
+	MSG_SELFTEST_FAILED_DE
 };
 
 const char MSG_SELFTEST_FAN_EN[] PROGMEM = "Fan test";;
@@ -2018,12 +2262,14 @@ const char MSG_SELFTEST_FAN_CZ[] PROGMEM = "Test ventilatoru";;
 const char MSG_SELFTEST_FAN_IT[] PROGMEM = "Prova del ventilator";;
 const char MSG_SELFTEST_FAN_ES[] PROGMEM = "Test del ventilador";;
 const char MSG_SELFTEST_FAN_PL[] PROGMEM = "Test wentylatora";;
+const char MSG_SELFTEST_FAN_DE[] PROGMEM = "Lueftertest";
 const char * const MSG_SELFTEST_FAN_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_FAN_EN,
 	MSG_SELFTEST_FAN_CZ,
 	MSG_SELFTEST_FAN_IT,
 	MSG_SELFTEST_FAN_ES,
-	MSG_SELFTEST_FAN_PL
+	MSG_SELFTEST_FAN_PL,
+	MSG_SELFTEST_FAN_DE
 };
 
 const char MSG_SELFTEST_FAN_NO_EN[] PROGMEM = "Not spinning";;
@@ -2031,12 +2277,14 @@ const char MSG_SELFTEST_FAN_NO_CZ[] PROGMEM = "Netoci se";;
 const char MSG_SELFTEST_FAN_NO_IT[] PROGMEM = "Non si gira";;
 const char MSG_SELFTEST_FAN_NO_ES[] PROGMEM = "Ventilador no gira";;
 const char MSG_SELFTEST_FAN_NO_PL[] PROGMEM = "Nekreci sie";;
+const char MSG_SELFTEST_FAN_NO_DE[] PROGMEM = "Dreht nicht";
 const char * const MSG_SELFTEST_FAN_NO_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_FAN_NO_EN,
 	MSG_SELFTEST_FAN_NO_CZ,
 	MSG_SELFTEST_FAN_NO_IT,
 	MSG_SELFTEST_FAN_NO_ES,
-	MSG_SELFTEST_FAN_NO_PL
+	MSG_SELFTEST_FAN_NO_PL,
+	MSG_SELFTEST_FAN_NO_DE
 };
 
 const char MSG_SELFTEST_FAN_YES_EN[] PROGMEM = "Spinning";;
@@ -2044,12 +2292,14 @@ const char MSG_SELFTEST_FAN_YES_CZ[] PROGMEM = "Toci se";;
 const char MSG_SELFTEST_FAN_YES_IT[] PROGMEM = "Gira";;
 const char MSG_SELFTEST_FAN_YES_ES[] PROGMEM = "Ventilador gira";;
 const char MSG_SELFTEST_FAN_YES_PL[] PROGMEM = "Kreci sie";;
+const char MSG_SELFTEST_FAN_YES_DE[] PROGMEM = "Dreht";
 const char * const MSG_SELFTEST_FAN_YES_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_FAN_YES_EN,
 	MSG_SELFTEST_FAN_YES_CZ,
 	MSG_SELFTEST_FAN_YES_IT,
 	MSG_SELFTEST_FAN_YES_ES,
-	MSG_SELFTEST_FAN_YES_PL
+	MSG_SELFTEST_FAN_YES_PL,
+	MSG_SELFTEST_FAN_YES_DE
 };
 
 const char MSG_SELFTEST_HEATERTHERMISTOR_EN[] PROGMEM = "Heater/Thermistor";
@@ -2060,6 +2310,7 @@ const char * const MSG_SELFTEST_HEATERTHERMISTOR_LANG_TABLE[LANG_NUM] PROGMEM =
 	MSG_SELFTEST_HEATERTHERMISTOR_EN,
 	MSG_SELFTEST_HEATERTHERMISTOR_IT,
 	MSG_SELFTEST_HEATERTHERMISTOR_ES,
+	MSG_SELFTEST_HEATERTHERMISTOR_EN,
 	MSG_SELFTEST_HEATERTHERMISTOR_EN
 };
 
@@ -2071,7 +2322,8 @@ const char * const MSG_SELFTEST_MOTOR_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_MOTOR_EN,
 	MSG_SELFTEST_MOTOR_IT,
 	MSG_SELFTEST_MOTOR_EN,
-	MSG_SELFTEST_MOTOR_PL
+	MSG_SELFTEST_MOTOR_PL,
+	MSG_SELFTEST_MOTOR_EN
 };
 
 const char MSG_SELFTEST_NOTCONNECTED_EN[] PROGMEM = "Not connected";
@@ -2079,22 +2331,26 @@ 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 MSG_SELFTEST_NOTCONNECTED_DE[] PROGMEM = "Nicht angeschlossen";
 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
+	MSG_SELFTEST_NOTCONNECTED_PL,
+	MSG_SELFTEST_NOTCONNECTED_DE
 };
 
 const char MSG_SELFTEST_OK_EN[] PROGMEM = "Self test OK";
 const char MSG_SELFTEST_OK_IT[] PROGMEM = "Autotest OK";
+const char MSG_SELFTEST_OK_DE[] PROGMEM = "Selbsttest OK";
 const char * const MSG_SELFTEST_OK_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_OK_EN,
 	MSG_SELFTEST_OK_EN,
 	MSG_SELFTEST_OK_IT,
 	MSG_SELFTEST_OK_EN,
-	MSG_SELFTEST_OK_EN
+	MSG_SELFTEST_OK_EN,
+	MSG_SELFTEST_OK_DE
 };
 
 const char MSG_SELFTEST_PLEASECHECK_EN[] PROGMEM = "Please check :";
@@ -2102,23 +2358,27 @@ const char MSG_SELFTEST_PLEASECHECK_CZ[] PROGMEM = "Zkontrolujte :";
 const char MSG_SELFTEST_PLEASECHECK_IT[] PROGMEM = "Verificare:";
 const char MSG_SELFTEST_PLEASECHECK_ES[] PROGMEM = "Controla :";
 const char MSG_SELFTEST_PLEASECHECK_PL[] PROGMEM = "Skontroluj :";
+const char MSG_SELFTEST_PLEASECHECK_DE[] PROGMEM = "Bitte pruefe:";
 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
+	MSG_SELFTEST_PLEASECHECK_PL,
+	MSG_SELFTEST_PLEASECHECK_DE
 };
 
 const char MSG_SELFTEST_START_EN[] PROGMEM = "Self test start  ";
 const char MSG_SELFTEST_START_IT[] PROGMEM = "Avvia autotest";
 const char MSG_SELFTEST_START_ES[] PROGMEM = "Autotest salida";
+const char MSG_SELFTEST_START_DE[] PROGMEM = "Selbsttest start ";
 const char * const MSG_SELFTEST_START_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SELFTEST_START_EN,
 	MSG_SELFTEST_START_EN,
 	MSG_SELFTEST_START_IT,
 	MSG_SELFTEST_START_ES,
-	MSG_SELFTEST_START_EN
+	MSG_SELFTEST_START_EN,
+	MSG_SELFTEST_START_DE
 };
 
 const char MSG_SELFTEST_WIRINGERROR_EN[] PROGMEM = "Wiring error";
@@ -2126,12 +2386,14 @@ 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 conexion";
 const char MSG_SELFTEST_WIRINGERROR_PL[] PROGMEM = "Blad polaczenia";
+const char MSG_SELFTEST_WIRINGERROR_DE[] PROGMEM = "Verdrahtungfehler";
 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
+	MSG_SELFTEST_WIRINGERROR_PL,
+	MSG_SELFTEST_WIRINGERROR_DE
 };
 
 const char MSG_SERIAL_ERROR_MENU_STRUCTURE_EN[] PROGMEM = "Error in menu structure";
@@ -2142,14 +2404,16 @@ const char * const MSG_SERIAL_ERROR_MENU_STRUCTURE_LANG_TABLE[1] PROGMEM = {
 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_ES[] PROGMEM = "Configuracion";
 const char MSG_SETTINGS_PL[] PROGMEM = "Ustawienia";
+const char MSG_SETTINGS_DE[] PROGMEM = "Einstellungen";
 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
+	MSG_SETTINGS_PL,
+	MSG_SETTINGS_DE
 };
 
 const char MSG_SET_HOME_OFFSETS_EN[] PROGMEM = "Set home offsets";
@@ -2167,25 +2431,29 @@ const char MSG_SHOW_END_STOPS_CZ[] PROGMEM = "Stav konc. spin.";
 const char MSG_SHOW_END_STOPS_IT[] PROGMEM = "Stato finecorsa";
 const char MSG_SHOW_END_STOPS_ES[] PROGMEM = "Ensena tope final";
 const char MSG_SHOW_END_STOPS_PL[] PROGMEM = "Pokaz krancowki";
+const char MSG_SHOW_END_STOPS_DE[] PROGMEM = "Anzeigen endstops";
 const char * const MSG_SHOW_END_STOPS_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_SHOW_END_STOPS_EN,
 	MSG_SHOW_END_STOPS_CZ,
 	MSG_SHOW_END_STOPS_IT,
 	MSG_SHOW_END_STOPS_ES,
-	MSG_SHOW_END_STOPS_PL
+	MSG_SHOW_END_STOPS_PL,
+	MSG_SHOW_END_STOPS_DE
 };
 
 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 = "Mode [forte]";
-const char MSG_SILENT_MODE_OFF_ES[] PROGMEM = "Modo [mas fuerza]";
+const char MSG_SILENT_MODE_OFF_IT[] PROGMEM = "Mode      [forte]";
+const char MSG_SILENT_MODE_OFF_ES[] PROGMEM = "Modo [rend.pleno]";
 const char MSG_SILENT_MODE_OFF_PL[] PROGMEM = "Mod [w wydajnosc]";
+const char MSG_SILENT_MODE_OFF_DE[] PROGMEM = "Mode [Hohe Leist]";
 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
+	MSG_SILENT_MODE_OFF_PL,
+	MSG_SILENT_MODE_OFF_DE
 };
 
 const char MSG_SILENT_MODE_ON_EN[] PROGMEM = "Mode     [silent]";
@@ -2193,12 +2461,14 @@ 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 MSG_SILENT_MODE_ON_DE[] PROGMEM = "Mode     [leise]";
 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
+	MSG_SILENT_MODE_ON_PL,
+	MSG_SILENT_MODE_ON_DE
 };
 
 const char MSG_SOFTWARE_RESET_EN[] PROGMEM = " Software Reset";
@@ -2211,12 +2481,14 @@ const char MSG_SPEED_CZ[] PROGMEM = "Rychlost";
 const char MSG_SPEED_IT[] PROGMEM = "Velocita";
 const char MSG_SPEED_ES[] PROGMEM = "Velocidad";
 const char MSG_SPEED_PL[] PROGMEM = "Predkosc";
+const char MSG_SPEED_DE[] PROGMEM = "Geschwindigkeit";
 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
+	MSG_SPEED_PL,
+	MSG_SPEED_DE
 };
 
 const char MSG_STACK_ERROR_EN[] PROGMEM = "Error - static memory has been overwritten";
@@ -2229,12 +2501,14 @@ 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 MSG_STATISTICS_DE[] PROGMEM = "Statistiken ";
 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
+	MSG_STATISTICS_PL,
+	MSG_STATISTICS_DE
 };
 
 const char MSG_STATS_FILAMENTUSED_EN[] PROGMEM = "Filament used:  ";
@@ -2242,12 +2516,14 @@ const char MSG_STATS_FILAMENTUSED_CZ[] PROGMEM = "Filament :  ";
 const char MSG_STATS_FILAMENTUSED_IT[] PROGMEM = "Filamento usato:";
 const char MSG_STATS_FILAMENTUSED_ES[] PROGMEM = "Filamento :  ";
 const char MSG_STATS_FILAMENTUSED_PL[] PROGMEM = "Filament :  ";
+const char MSG_STATS_FILAMENTUSED_DE[] PROGMEM = "Filamentverbrauch:";
 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
+	MSG_STATS_FILAMENTUSED_PL,
+	MSG_STATS_FILAMENTUSED_DE
 };
 
 const char MSG_STATS_PRINTTIME_EN[] PROGMEM = "Print time:  ";
@@ -2255,12 +2531,14 @@ const char MSG_STATS_PRINTTIME_CZ[] PROGMEM = "Cas tisku :  ";
 const char MSG_STATS_PRINTTIME_IT[] PROGMEM = "Tempo di stampa:";
 const char MSG_STATS_PRINTTIME_ES[] PROGMEM = "Tiempo de imp.:";
 const char MSG_STATS_PRINTTIME_PL[] PROGMEM = "Czas druku :  ";
+const char MSG_STATS_PRINTTIME_DE[] PROGMEM = "Druckzeit:  ";
 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
+	MSG_STATS_PRINTTIME_PL,
+	MSG_STATS_PRINTTIME_DE
 };
 
 const char MSG_STATS_TOTALFILAMENT_EN[] PROGMEM = "Total filament :";
@@ -2268,12 +2546,14 @@ 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 MSG_STATS_TOTALFILAMENT_DE[] PROGMEM = "Totales Filament:";
 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
+	MSG_STATS_TOTALFILAMENT_PL,
+	MSG_STATS_TOTALFILAMENT_DE
 };
 
 const char MSG_STATS_TOTALPRINTTIME_EN[] PROGMEM = "Total print time :";
@@ -2281,12 +2561,14 @@ 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 MSG_STATS_TOTALPRINTTIME_DE[] PROGMEM = "Totale Druckzeit:";
 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
+	MSG_STATS_TOTALPRINTTIME_PL,
+	MSG_STATS_TOTALPRINTTIME_DE
 };
 
 const char MSG_STEPPER_TOO_HIGH_EN[] PROGMEM = "Steprate too high: ";
@@ -2297,12 +2579,14 @@ const char * const MSG_STEPPER_TOO_HIGH_LANG_TABLE[1] PROGMEM = {
 const char MSG_STOPPED_EN[] PROGMEM = "STOPPED. ";
 const char MSG_STOPPED_IT[] PROGMEM = "ARRESTATO.";
 const char MSG_STOPPED_ES[] PROGMEM = "PARADA";
+const char MSG_STOPPED_DE[] PROGMEM = "GESTOPPT. ";
 const char * const MSG_STOPPED_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_STOPPED_EN,
 	MSG_STOPPED_EN,
 	MSG_STOPPED_IT,
 	MSG_STOPPED_ES,
-	MSG_STOPPED_EN
+	MSG_STOPPED_EN,
+	MSG_STOPPED_DE
 };
 
 const char MSG_STOP_PRINT_EN[] PROGMEM = "Stop print";
@@ -2310,12 +2594,14 @@ 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 MSG_STOP_PRINT_DE[] PROGMEM = "Druck halten";
 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
+	MSG_STOP_PRINT_PL,
+	MSG_STOP_PRINT_DE
 };
 
 const char MSG_STORE_EPROM_EN[] PROGMEM = "Store memory";
@@ -2325,48 +2611,56 @@ const char * const MSG_STORE_EPROM_LANG_TABLE[1] PROGMEM = {
 
 const char MSG_SUPPORT_EN[] PROGMEM = "Support";
 const char MSG_SUPPORT_CZ[] PROGMEM = "Podpora";
+const char MSG_SUPPORT_ES[] PROGMEM = "Soporte";
 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_EN,
-	MSG_SUPPORT_EN,
-	MSG_SUPPORT_PL
+	MSG_SUPPORT_ES,
+	MSG_SUPPORT_PL,
+	MSG_SUPPORT_EN
 };
 
 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_PL[] PROGMEM = "Zapnout zdroj";
+const char MSG_SWITCH_PS_OFF_DE[] PROGMEM = "Netzteil AUS";
 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_EN,
 	MSG_SWITCH_PS_OFF_EN,
-	MSG_SWITCH_PS_OFF_PL
+	MSG_SWITCH_PS_OFF_PL,
+	MSG_SWITCH_PS_OFF_DE
 };
 
 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_PL[] PROGMEM = "Vypnout zdroj";
+const char MSG_SWITCH_PS_ON_DE[] PROGMEM = "Netzteil EIN";
 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_EN,
 	MSG_SWITCH_PS_ON_EN,
-	MSG_SWITCH_PS_ON_PL
+	MSG_SWITCH_PS_ON_PL,
+	MSG_SWITCH_PS_ON_DE
 };
 
 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 attualizzare";
-const char MSG_TAKE_EFFECT_ES[] PROGMEM = "para tomar efecto";
-const char MSG_TAKE_EFFECT_PL[] PROGMEM = "wprow. zmian";
+const char MSG_TAKE_EFFECT_ES[] PROGMEM = " para aplicar cambios";
+const char MSG_TAKE_EFFECT_PL[] PROGMEM = " wprow. zmian";
+const char MSG_TAKE_EFFECT_DE[] PROGMEM = " um wirksam zu sein";
 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
+	MSG_TAKE_EFFECT_PL,
+	MSG_TAKE_EFFECT_DE
 };
 
 const char MSG_TEMPERATURE_EN[] PROGMEM = "Temperature";
@@ -2374,12 +2668,14 @@ 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 MSG_TEMPERATURE_DE[] PROGMEM = "Temperatur";
 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
+	MSG_TEMPERATURE_PL,
+	MSG_TEMPERATURE_DE
 };
 
 const char MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_OFF_EN[] PROGMEM = "SD card [normal]";
@@ -2389,7 +2685,8 @@ const char * const MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_OFF_LANG_TABLE[LANG_NUM]
 	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_OFF_EN,
 	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_OFF_EN,
 	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_OFF_EN,
-	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_OFF_PL
+	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_OFF_PL,
+	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_OFF_EN
 };
 
 const char MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_ON_EN[] PROGMEM = "SD card [FlshAir]";
@@ -2399,7 +2696,8 @@ const char * const MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_ON_LANG_TABLE[LANG_NUM] P
 	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_ON_EN,
 	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_ON_EN,
 	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_ON_EN,
-	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_ON_PL
+	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_ON_PL,
+	MSG_TOSHIBA_FLASH_AIR_COMPATIBILITY_ON_EN
 };
 
 const char MSG_TUNE_EN[] PROGMEM = "Tune";
@@ -2407,12 +2705,14 @@ const char MSG_TUNE_CZ[] PROGMEM = "Ladit";
 const char MSG_TUNE_IT[] PROGMEM = "Regola";
 const char MSG_TUNE_ES[] PROGMEM = "Ajustar";
 const char MSG_TUNE_PL[] PROGMEM = "Nastroic";
+const char MSG_TUNE_DE[] PROGMEM = "Feineinstellen";
 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
+	MSG_TUNE_PL,
+	MSG_TUNE_DE
 };
 
 const char MSG_UNKNOWN_COMMAND_EN[] PROGMEM = "Unknown command: \"";
@@ -2425,25 +2725,29 @@ const char MSG_UNLOADING_FILAMENT_CZ[] PROGMEM = "Vysouvam filament";
 const char MSG_UNLOADING_FILAMENT_IT[] PROGMEM = "Rilasc. filamento";
 const char MSG_UNLOADING_FILAMENT_ES[] PROGMEM = "Soltando filamento";
 const char MSG_UNLOADING_FILAMENT_PL[] PROGMEM = "Wysuwam filament";
+const char MSG_UNLOADING_FILAMENT_DE[] PROGMEM = "Filam. auswerfen";
 const char * const MSG_UNLOADING_FILAMENT_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_UNLOADING_FILAMENT_EN,
 	MSG_UNLOADING_FILAMENT_CZ,
 	MSG_UNLOADING_FILAMENT_IT,
 	MSG_UNLOADING_FILAMENT_ES,
-	MSG_UNLOADING_FILAMENT_PL
+	MSG_UNLOADING_FILAMENT_PL,
+	MSG_UNLOADING_FILAMENT_DE
 };
 
 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 = "Scarica filamento";
-const char MSG_UNLOAD_FILAMENT_ES[] PROGMEM = "Sacar filamento";
+const char MSG_UNLOAD_FILAMENT_ES[] PROGMEM = "Soltar filamento";
 const char MSG_UNLOAD_FILAMENT_PL[] PROGMEM = "Wyjac filament";
+const char MSG_UNLOAD_FILAMENT_DE[] PROGMEM = "Entnehm 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
+	MSG_UNLOAD_FILAMENT_PL,
+	MSG_UNLOAD_FILAMENT_DE
 };
 
 const char MSG_USB_PRINTING_EN[] PROGMEM = "USB printing  ";
@@ -2456,18 +2760,21 @@ const char * const MSG_USB_PRINTING_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_USB_PRINTING_CZ,
 	MSG_USB_PRINTING_IT,
 	MSG_USB_PRINTING_ES,
-	MSG_USB_PRINTING_PL
+	MSG_USB_PRINTING_PL,
+	MSG_USB_PRINTING_EN
 };
 
 const char MSG_USERWAIT_EN[] PROGMEM = "Wait for user...";
 const char MSG_USERWAIT_IT[] PROGMEM = "Attendendo utente";
 const char MSG_USERWAIT_ES[] PROGMEM = "Esperando ordenes";
+const char MSG_USERWAIT_DE[] PROGMEM = "Warte auf user...";
 const char * const MSG_USERWAIT_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_USERWAIT_EN,
 	MSG_USERWAIT_EN,
 	MSG_USERWAIT_IT,
 	MSG_USERWAIT_ES,
-	MSG_USERWAIT_EN
+	MSG_USERWAIT_EN,
+	MSG_USERWAIT_DE
 };
 
 const char MSG_VMIN_EN[] PROGMEM = "Vmin";
@@ -2492,15 +2799,17 @@ const char * const MSG_VTRAV_MIN_LANG_TABLE[1] PROGMEM = {
 
 const char MSG_WAITING_TEMP_EN[] PROGMEM = "Waiting for nozzle and bed cooling";
 const char MSG_WAITING_TEMP_CZ[] PROGMEM = "Cekani na zchladnuti trysky a podlozky.";
-const char MSG_WAITING_TEMP_IT[] PROGMEM = "In attesa del raffreddamento della testina e del piatto.";
+const char MSG_WAITING_TEMP_IT[] PROGMEM = "In attesa del raffreddamento della testina e del piatto";
 const char MSG_WAITING_TEMP_ES[] PROGMEM = "Esperando enfriamiento de la cama y del extrusor.";
 const char MSG_WAITING_TEMP_PL[] PROGMEM = "Oczekiwanie na wychlodzenie dyszy i podkladki.";
+const char MSG_WAITING_TEMP_DE[] PROGMEM = "Warten auf Abkuehlung von Heater und Bed.";
 const char * const MSG_WAITING_TEMP_LANG_TABLE[LANG_NUM] PROGMEM = {
 	MSG_WAITING_TEMP_EN,
 	MSG_WAITING_TEMP_CZ,
 	MSG_WAITING_TEMP_IT,
 	MSG_WAITING_TEMP_ES,
-	MSG_WAITING_TEMP_PL
+	MSG_WAITING_TEMP_PL,
+	MSG_WAITING_TEMP_DE
 };
 
 const char MSG_WATCH_EN[] PROGMEM = "Info screen";
@@ -2508,12 +2817,14 @@ const char MSG_WATCH_CZ[] PROGMEM = "Informace";
 const char MSG_WATCH_IT[] PROGMEM = "Schermata info";
 const char MSG_WATCH_ES[] PROGMEM = "Monitorizar";
 const char MSG_WATCH_PL[] PROGMEM = "Informacje";
+const char MSG_WATCH_DE[] PROGMEM = "Information";
 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
+	MSG_WATCH_PL,
+	MSG_WATCH_DE
 };
 
 const char MSG_WATCHDOG_RESET_EN[] PROGMEM = " Watchdog Reset";
@@ -2536,12 +2847,14 @@ 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 MSG_YES_DE[] PROGMEM = "Ja";
 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
+	MSG_YES_PL,
+	MSG_YES_DE
 };
 
 const char MSG_Y_MAX_EN[] PROGMEM = "y_max: ";
@@ -2576,15 +2889,17 @@ const char * const MSG_Z_MIN_LANG_TABLE[1] PROGMEM = {
 
 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 "pronta.";
-const char WELCOME_MSG_ES[] PROGMEM = CUSTOM_MENDEL_NAME " lista";
+const char WELCOME_MSG_IT[] PROGMEM = CUSTOM_MENDEL_NAME " pronta.";
+const char WELCOME_MSG_ES[] PROGMEM = CUSTOM_MENDEL_NAME " prep.";
 const char WELCOME_MSG_PL[] PROGMEM = CUSTOM_MENDEL_NAME " gotowa";
+const char WELCOME_MSG_DE[] PROGMEM = CUSTOM_MENDEL_NAME " klar.";
 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
+	WELCOME_MSG_PL,
+	WELCOME_MSG_DE
 };
 
 

Firmware/language_all.h

@@ -7,6 +7,7 @@
 #define LANG_ID_IT 2
 #define LANG_ID_ES 3
 #define LANG_ID_PL 4
+#define LANG_ID_DE 5
 // Language is not defined and it shall be selected from the menu.
 #define LANG_ID_FORCE_SELECTION 254
 // Language is not defined on a virgin RAMBo board.
@@ -16,7 +17,7 @@
 #define LANG_ID_DEFAULT LANG_ID_CZ
 
 // Number of languages available in the language table.
-#define LANG_NUM 5
+#define LANG_NUM 6
 
 // Currectly active language selection.
 extern unsigned char lang_selected;

Firmware/language_en.h

@@ -27,7 +27,7 @@
 #define MSG_NOZZLE1                         "Nozzle2"
 #define MSG_NOZZLE2                         "Nozzle3"
 #define MSG_BED                             "Bed"
-#define MSG_FAN_SPEED                       "Fan speed"
+#define(length=14) MSG_FAN_SPEED                       "Fan speed"
 #define MSG_FLOW                            "Flow"
 #define MSG_FLOW0                           "Flow 0"
 #define MSG_FLOW1                           "Flow 1"
@@ -64,7 +64,7 @@
 #define MSG_BABYSTEP_X                      "Babystep X"
 #define MSG_BABYSTEP_Y                      "Babystep Y"
 #define MSG_BABYSTEP_Z                      "Live adjust Z"
-#define MSG_ADJUSTZ							"Auto adjust Z ?"
+#define MSG_ADJUSTZ							"Auto adjust Z?"
 #define MSG_PICK_Z							"Pick print"
 
 #define MSG_SETTINGS                         "Settings"
@@ -166,7 +166,7 @@
 #define MSG_SELFTEST_OK						"Self test OK"
 #define MSG_LOOSE_PULLEY					"Loose pulley"
 
-#define MSG_SELFTEST_FAN					"Fan test";
+#define(length=20) MSG_SELFTEST_FAN					"Fan test";
 #define(length=20) MSG_SELFTEST_COOLING_FAN			"Front print fan?";
 #define(length=20) MSG_SELFTEST_EXTRUDER_FAN			"Left hotend fan?";
 #define MSG_SELFTEST_FAN_YES				"Spinning";
@@ -251,7 +251,7 @@
 #define(length=20, lines=8) MSG_CLEAN_NOZZLE_E				"E calibration finished. Please clean the nozzle. Click when done."
 #define(length=20, lines=3) MSG_WAITING_TEMP				"Waiting for nozzle and bed cooling"
 #define(length=20, lines=2) MSG_FILAMENT_CLEAN				"Is color clear?"
-#define(lenght=20, lines=1) MSG_UNLOADING_FILAMENT			"Unloading filament"
+#define(lenght=20) MSG_UNLOADING_FILAMENT			"Unloading filament"
 #define(length=20, lines=8) MSG_PAPER						"Place a sheet of paper under the nozzle during the calibration of first 4 points. If the nozzle catches the paper, power off the printer immediately."
 
 #define MSG_BED_CORRECTION_MENU									"Bed level correct"

Firmware/language_es.h

@@ -6,8 +6,8 @@
  *
  */
 
-#define WELCOME_MSG                         CUSTOM_MENDEL_NAME " lista"
-#define MSG_SD_INSERTED                     "Tarjeta colocada"
+#define WELCOME_MSG                         CUSTOM_MENDEL_NAME " prep."
+#define MSG_SD_INSERTED                     "Tarjeta insertada"
 #define MSG_SD_REMOVED                      "Tarjeta retirada"
 #define MSG_MAIN                            "Menu principal"
 #define MSG_DISABLE_STEPPERS                "Apagar motores"
@@ -17,11 +17,11 @@
 #define MSG_MOVE_X                          "Mover X"
 #define MSG_MOVE_Y                          "Mover Y"
 #define MSG_MOVE_Z                          "Mover Z"
-#define MSG_MOVE_E                          "Extrusor"
+#define MSG_MOVE_E                          "Extruir"
 #define MSG_SPEED                           "Velocidad"
-#define MSG_NOZZLE                          "Fusor"
+#define MSG_NOZZLE                          "Boquilla"
 #define MSG_BED                             "Base"
-#define MSG_FAN_SPEED                       "Ventilador"
+#define MSG_FAN_SPEED                       "Velocidad Vent."
 #define MSG_FLOW                            "Flujo"
 #define MSG_TEMPERATURE                     "Temperatura"
 #define MSG_WATCH                           "Monitorizar"
@@ -29,49 +29,49 @@
 #define MSG_PAUSE_PRINT                     "Pausar impresion"
 #define MSG_RESUME_PRINT                    "Reanudar impres."
 #define MSG_STOP_PRINT                      "Detener impresion"
-#define MSG_CARD_MENU                       "Menu de SD"
+#define MSG_CARD_MENU                       "Menu tarjeta SD"
 #define MSG_NO_CARD                         "No hay tarjeta SD"
-#define MSG_DWELL                           "Reposo..."
+#define MSG_DWELL                           "En espera"
 #define MSG_USERWAIT                        "Esperando ordenes"
-#define MSG_RESUMING                        "Resumiendo impre."
-#define MSG_PRINT_ABORTED                   "Print aborted"
+#define MSG_RESUMING                        "Resumiendo impresion"
+#define MSG_PRINT_ABORTED                   "Impresion cancelada" 
 #define MSG_NO_MOVE                         "Sin movimiento"
-#define MSG_KILLED                          "PARADA DE EMERG."
+#define MSG_KILLED                          "PARADA DE EMERGENCIA"
 #define MSG_STOPPED                         "PARADA"
 #define MSG_FILAMENTCHANGE                  "Cambiar filamento"
-#define MSG_BABYSTEP_Z                      "Micropaso Z"
-#define MSG_ADJUSTZ							"Auto Micropaso Z?"
-#define MSG_PICK_Z							"Vyberte vytisk"
+#define MSG_BABYSTEP_Z                      "Micropaso Eje Z"
+#define MSG_ADJUSTZ			    "Ajustar Eje Z"			
+#define MSG_PICK_Z			    "Esc. Modelo Adecuado"
 
-#define MSG_SETTINGS                        "Ajuste"
+#define MSG_SETTINGS                        "Configuracion"
 #define MSG_PREHEAT                         "Precalentar"
-#define MSG_UNLOAD_FILAMENT                 "Sacar filamento"
-#define MSG_LOAD_FILAMENT					"Poner filamento"
+#define MSG_UNLOAD_FILAMENT                 "Soltar filamento"
+#define MSG_LOAD_FILAMENT		    "Introducir filam."
 #define MSG_ERROR							"ERROR:"
-#define MSG_PREHEAT_NOZZLE                  "Precal. extrusor!"
-#define MSG_SUPPORT							"Support"
-#define MSG_CORRECTLY						"Cambiado correc.?"
+#define MSG_PREHEAT_NOZZLE                  "Precalentar extrusor"
+#define MSG_SUPPORT			    "Soporte"
+#define MSG_CORRECTLY			    "Cambiado correct.?"
 #define MSG_YES								"Si"
 #define MSG_NO								"No"
-#define MSG_NOT_LOADED 						"Fil. no cargado"
-#define MSG_NOT_COLOR 						"Color no claro"
-#define MSG_LOADING_FILAMENT				"Cargando fil."
-#define MSG_PLEASE_WAIT						"Espera"
-#define MSG_LOADING_COLOR					"Cargando color"
-#define MSG_CHANGE_SUCCESS					"Cambiar bien!"
-#define MSG_PRESS							"y pulse el mando"
-#define MSG_INSERT_FILAMENT					"Inserta filamento"
-#define MSG_CHANGING_FILAMENT				"Cambiando fil.!"
+#define MSG_NOT_LOADED 			    "Fil. no introducido"
+#define MSG_NOT_COLOR 			    "Color no homogeneo"
+#define MSG_LOADING_FILAMENT		    "Introduciendo filam."
+#define MSG_PLEASE_WAIT			    "Por Favor Esperar"
+#define MSG_LOADING_COLOR                   "Cambiando color" 
+#define MSG_CHANGE_SUCCESS		    "Cambio correcto"
+#define MSG_PRESS			    "Pulsar el mando"
+#define MSG_INSERT_FILAMENT		    "Introducir filamento"
+#define MSG_CHANGING_FILAMENT		    "Cambiando filamento"
 #define MSG_SILENT_MODE_ON					"Modo   [silencio]"
-#define MSG_SILENT_MODE_OFF					"Modo [mas fuerza]" 
-#define MSG_REBOOT							"Reiniciar la imp."
-#define MSG_TAKE_EFFECT						"para tomar efecto"											
+#define MSG_SILENT_MODE_OFF		    "Modo [rend.pleno]" 
+#define MSG_REBOOT			    "Reiniciar impresora"
+#define MSG_TAKE_EFFECT			    " para aplicar cambios" 
 #define MSG_HEATING                         "Calentando..."
-#define MSG_HEATING_COMPLETE                "Calentando listo."
-#define MSG_BED_HEATING                     "Base Calentando"
-#define MSG_BED_DONE                        "Base listo."
+#define MSG_HEATING_COMPLETE                "Calentamiento final."
+#define MSG_BED_HEATING                     "Calentando Base"
+#define MSG_BED_DONE                        "Base preparada"
 #define MSG_LANGUAGE_NAME					"Espanol"
-#define MSG_LANGUAGE_SELECT					"Cambia la lengua "
+#define MSG_LANGUAGE_SELECT		    "Cambiae el idioma"
 #define MSG_PRUSA3D							"prusa3d.com"
 #define MSG_PRUSA3D_FORUM					"forum.prusa3d.com"
 #define MSG_PRUSA3D_HOWTO					"howto.prusa3d.com"
@@ -252,4 +252,5 @@
 #define MSG_CLEAN_NOZZLE_E								"E calibrado. Limpiar la boquilla. Haga clic una vez terminado."
 #define MSG_WAITING_TEMP								"Esperando enfriamiento de la cama y del extrusor."
 #define MSG_FILAMENT_CLEAN								"Es el nuevo color nitido?"
-#define MSG_UNLOADING_FILAMENT							"Soltando filamento"
+#define MSG_UNLOADING_FILAMENT							"Soltando filamento"
+#define MSG_PAPER										"Colocar una hoja de papel sobre la superficie de impresion durante la calibracion de los primeros 4 puntos. Si la boquilla mueve el papel, apagar impresora inmediatamente."

Firmware/language_it.h

@@ -1,4 +1,4 @@
-#define WELCOME_MSG                         CUSTOM_MENDEL_NAME "pronta."
+#define WELCOME_MSG                         CUSTOM_MENDEL_NAME " pronta."
 #define MSG_SD_INSERTED                     "SD inserita"
 #define MSG_SD_REMOVED                      "SD rimossa"
 #define MSG_MAIN                            "Menu principale"
@@ -22,7 +22,7 @@
 #define MSG_NOZZLE1                         "Nozzle2"
 #define MSG_NOZZLE2                         "Nozzle3"
 #define MSG_BED                             "Letto"
-#define MSG_FAN_SPEED                       "Velocita ventola"
+#define MSG_FAN_SPEED                       "Velocita vent."
 #define MSG_FLOW                            "Flusso"
 #define MSG_TEMPERATURE                     "Temperatura"
 #define MSG_MOTION                          "Motion"
@@ -84,7 +84,7 @@
 #define MSG_LOAD_FILAMENT                   "Carica filamento"
 
 #define MSG_SILENT_MODE_ON		    "Modo [silenzioso]"
-#define MSG_SILENT_MODE_OFF		    "Mode [forte]" 
+#define MSG_SILENT_MODE_OFF		    "Mode      [forte]" 
 #define MSG_REBOOT			    "Riavvia stampante"
 #define MSG_TAKE_EFFECT			    " per attualizzare"
 
@@ -220,9 +220,9 @@
 #define MSG_BABYSTEP_Z_NOT_SET							"Distanza tra la punta dell'ugello e la superficie del letto non ancora imposta. Si prega di seguire il manuale, capitolo First steps, sezione First layer calibration."
 
 #define MSG_BED_CORRECTION_MENU							"Correz. liv.letto"
-#define MSG_BED_CORRECTION_LEFT							"Lato sinistro um"
-#define MSG_BED_CORRECTION_RIGHT						"Lato destro um"
-#define MSG_BED_CORRECTION_FRONT						"Lato ateriore um"
+#define MSG_BED_CORRECTION_LEFT							"Lato sinistro"
+#define MSG_BED_CORRECTION_RIGHT						"Lato destro"
+#define MSG_BED_CORRECTION_FRONT						"Lato ateriore"
 #define MSG_BED_CORRECTION_REAR							"Lato posteriore"
 #define MSG_BED_CORRECTION_RESET						"Reset"			
 
@@ -245,6 +245,7 @@
 #define MSG_E_CAL_KNOB									"Girare la manopola affinche' il segno raggiunga il corpo dell'estrusore. Click per continuare."
 #define MSG_MARK_FIL									"Segnare il filamento a 100 mm di distanza dal corpo dell'estrusore. Click per continuare."
 #define MSG_CLEAN_NOZZLE_E								"Calibrazione E terminata. Si prega di pulire l'ugello. Click per continuare."
-#define MSG_WAITING_TEMP								"In attesa del raffreddamento della testina e del piatto."
+#define MSG_WAITING_TEMP								"In attesa del raffreddamento della testina e del piatto"
 #define MSG_FILAMENT_CLEAN								"Il colore e' nitido?"
-#define MSG_UNLOADING_FILAMENT							"Rilasc. filamento"
+#define MSG_UNLOADING_FILAMENT							"Rilasc. filamento"
+#define MSG_PAPER										"Porre un foglio sotto l'ugello durante la calibrazione dei primi 4 punti. In caso l'ugello muova il foglio spegnere prontamente la stampante."

Firmware/language_pl.h

@@ -64,7 +64,7 @@
 #define MSG_SILENT_MODE_ON                                      "Mod       [cichy]"
 #define MSG_SILENT_MODE_OFF                                     "Mod [w wydajnosc]" 
 #define MSG_REBOOT                                                      "Restart drukarki"
-#define MSG_TAKE_EFFECT                                         "wprow. zmian"   
+#define MSG_TAKE_EFFECT                                         " wprow. zmian"   
 #define MSG_HEATING                         "Grzanie..."
 #define MSG_HEATING_COMPLETE                "Grzanie OK."
 #define MSG_BED_HEATING                     "Grzanie stolika.."
@@ -258,4 +258,5 @@
 #define MSG_CLEAN_NOZZLE_E										"Kalibracja E skonczona. Prosze oczyscic dysze. Potem potwierdzic przyciskiem. "
 #define MSG_WAITING_TEMP										"Oczekiwanie na wychlodzenie dyszy i podkladki."
 #define MSG_FILAMENT_CLEAN										"Czy kolor jest czysty?"
-#define MSG_UNLOADING_FILAMENT									"Wysuwam filament"
+#define MSG_UNLOADING_FILAMENT									"Wysuwam filament"
+#define MSG_PAPER												"Umiesc kartke papieru na podkladce i trzymaj pod dysza podczas pomiaru pierwszych 4 punktow. Jesli dysza zahaczy o papier, wylacz drukarke."

Firmware/mesh_bed_calibration.cpp

@@ -2156,8 +2156,11 @@ void babystep_apply()
     // Apply Z height correction aka baby stepping before mesh bed leveling gets activated.
     if(calibration_status() == CALIBRATION_STATUS_CALIBRATED)
     {
-        // End of G80: Apply the baby stepping value.
+		check_babystep(); //checking if babystep is in allowed range, otherwise setting babystep to 0
+		
+		// End of G80: Apply the baby stepping value.
         EEPROM_read_B(EEPROM_BABYSTEP_Z,&babystepLoadZ);
+							
     #if 0
         SERIAL_ECHO("Z baby step: ");
         SERIAL_ECHO(babystepLoadZ);

Firmware/pins.h

@@ -71,7 +71,15 @@
 
 
 #endif
-  // The SDSS pin uses a different pin mapping from file Sd2PinMap.h
+ 
+#ifdef DIS
+#define D_REQUIRE 30
+#define D_DATA 20
+#define D_DATACLOCK 21
+
+#endif
+
+// The SDSS pin uses a different pin mapping from file Sd2PinMap.h
 #define SDSS               53
 
 #ifndef SDSUPPORT

Firmware/ultralcd.cpp

@@ -1096,7 +1096,6 @@ void lcd_menu_statistics()
 		int _cm = (total_filament_used - (_met * 100000))/10;
 		
 		int _t = (millis() - starttime) / 1000;
-
 		int _h = _t / 3600;
 		int _m = (_t - (_h * 3600)) / 60;
 		int _s = _t - ((_h * 3600) + (_m * 60));
@@ -1130,8 +1129,10 @@ void lcd_menu_statistics()
 	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;
+		unsigned long _time = eeprom_read_dword((uint32_t *)EEPROM_TOTALTIME); //in minutes
+		
+		uint8_t _hours, _minutes;
+		uint32_t _days;
 
 		float _filament_m = (float)_filament;
 		int _filament_km = (_filament >= 100000) ? _filament / 100000 : 0;
@@ -1287,13 +1288,18 @@ static void _lcd_babystep(int axis, const char *msg)
         // Menu was entered.
         // Initialize its status.
         menuData.babyStep.status = 1;
-        EEPROM_read_B(EEPROM_BABYSTEP_X, &menuData.babyStep.babystepMem[0]);
+		check_babystep();
+
+		EEPROM_read_B(EEPROM_BABYSTEP_X, &menuData.babyStep.babystepMem[0]);
         EEPROM_read_B(EEPROM_BABYSTEP_Y, &menuData.babyStep.babystepMem[1]);
         EEPROM_read_B(EEPROM_BABYSTEP_Z, &menuData.babyStep.babystepMem[2]);
+		
         menuData.babyStep.babystepMemMM[0] = menuData.babyStep.babystepMem[0]/axis_steps_per_unit[X_AXIS];
         menuData.babyStep.babystepMemMM[1] = menuData.babyStep.babystepMem[1]/axis_steps_per_unit[Y_AXIS];
         menuData.babyStep.babystepMemMM[2] = menuData.babyStep.babystepMem[2]/axis_steps_per_unit[Z_AXIS];
         lcdDrawUpdate = 1;
+		//SERIAL_ECHO("Z baby step: ");
+		//SERIAL_ECHO(menuData.babyStep.babystepMem[2]);
         // Wait 90 seconds before closing the live adjust dialog.
         lcd_timeoutToStatus = millis() + 90000;
     }
@@ -1301,11 +1307,18 @@ static void _lcd_babystep(int axis, const char *msg)
   if (encoderPosition != 0) 
   {
 	if (homing_flag) encoderPosition = 0;
-    CRITICAL_SECTION_START
-    babystepsTodo[axis] += (int)encoderPosition;
-    CRITICAL_SECTION_END
+
     menuData.babyStep.babystepMem[axis] += (int)encoderPosition;
-    menuData.babyStep.babystepMemMM[axis] = menuData.babyStep.babystepMem[axis]/axis_steps_per_unit[Z_AXIS];
+	if (axis == 2) {
+		if (menuData.babyStep.babystepMem[axis] < Z_BABYSTEP_MIN) menuData.babyStep.babystepMem[axis] = Z_BABYSTEP_MIN; //-3999 -> -9.99 mm
+		else  if (menuData.babyStep.babystepMem[axis] > Z_BABYSTEP_MAX) menuData.babyStep.babystepMem[axis] = Z_BABYSTEP_MAX; //0
+		else {
+			CRITICAL_SECTION_START
+				babystepsTodo[axis] += (int)encoderPosition;
+			CRITICAL_SECTION_END		
+		}
+	}
+    menuData.babyStep.babystepMemMM[axis] = menuData.babyStep.babystepMem[axis]/axis_steps_per_unit[axis]; 
 	  delay(50);
 	  encoderPosition = 0;
     lcdDrawUpdate = 1;
@@ -1745,13 +1758,13 @@ int8_t lcd_show_fullscreen_message_yes_no_and_wait_P(const char *msg, bool allow
 		manage_inactivity(true);
 		if (abs(enc_dif - encoderDiff) > 4) {
 			lcd.setCursor(0, 2);
-				if (enc_dif > encoderDiff && yes) {
+				if (enc_dif < encoderDiff && yes) {
 					lcd_printPGM((PSTR(" ")));
 					lcd.setCursor(0, 3);
 					lcd_printPGM((PSTR(">")));
 					yes = false;
 				}
-				else if (enc_dif < encoderDiff && !yes) {
+				else if (enc_dif > encoderDiff && !yes) {
 					lcd_printPGM((PSTR(">")));
 					lcd.setCursor(0, 3);
 					lcd_printPGM((PSTR(" ")));
@@ -2343,7 +2356,7 @@ static void lcd_settings_menu()
   
 	if (!isPrintPaused && !homing_flag)
 	{
-		MENU_ITEM(submenu, MSG_BABYSTEP_Z, lcd_babystep_z);//8
+		MENU_ITEM(submenu, MSG_BABYSTEP_Z, lcd_babystep_z);
 	}
 	MENU_ITEM(submenu, MSG_LANGUAGE_SELECT, lcd_language_menu);
 
@@ -3038,7 +3051,7 @@ static void lcd_main_menu()
 
   
  MENU_ITEM(back, MSG_WATCH, lcd_status_screen);
-    if (farm_mode && !IS_SD_PRINTING )
+   /* if (farm_mode && !IS_SD_PRINTING )
     {
     
         int tempScrool = 0;
@@ -3085,7 +3098,7 @@ static void lcd_main_menu()
         MENU_ITEM(back, PSTR("- - - - - - - - -"), lcd_status_screen);
     
         
-    }
+    }*/
     
     
     
@@ -3321,7 +3334,7 @@ void lcd_sdcard_stop()
 				card.closefile();
 
 				stoptime = millis();
-				unsigned long t = (stoptime - starttime) / 1000;
+				unsigned long t = (stoptime - starttime) / 1000; //time in s
 				save_statistics(total_filament_used, t);
 
 				lcd_return_to_status();
@@ -3577,7 +3590,7 @@ static void lcd_selftest()
 
 	if (_result)
 	{
-		_progress = lcd_selftest_screen(2, _progress, 3, true, 2000);
+		_progress = lcd_selftest_screen(2, _progress, 3, true, 0);
 		_result = lcd_selfcheck_pulleys(X_AXIS);
 	}
 
@@ -3590,7 +3603,7 @@ static void lcd_selftest()
 
 	if (_result)
 	{
-		_progress = lcd_selftest_screen(3, _progress, 3, true, 1500);
+		_progress = lcd_selftest_screen(3, _progress, 3, true, 0);
 		_result = lcd_selfcheck_pulleys(Y_AXIS);
 	}
 
@@ -3601,8 +3614,7 @@ static void lcd_selftest()
 		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);
-		current_position[Z_AXIS] = current_position[Z_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);
+		enquecommand_P(PSTR("G28 W"));
 	}
 
 	if (_result)
@@ -3644,15 +3656,7 @@ static bool lcd_selfcheck_axis(int _axis, int _travel)
 	_travel = _travel + (_travel / 10);
 
 	do {
-
-		/*if (_axis == 2)
-		{*/
-			current_position[_axis] = current_position[_axis] - 1;
-		/*}
-		else
-		{
-			current_position[_axis] = current_position[_axis] - 3;
-		}*/
+		current_position[_axis] = current_position[_axis] - 1;
 
 		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();
@@ -3663,19 +3667,21 @@ static bool lcd_selfcheck_axis(int _axis, int _travel)
 			{
 				_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();
+				/*disable_x();
+				disable_y();
+				disable_z();*/
 			}
 			_stepdone = true;
 		}
@@ -3691,7 +3697,7 @@ static bool lcd_selfcheck_axis(int _axis, int _travel)
 		}
 
 		manage_heater();
-		manage_inactivity();
+		manage_inactivity(true);
 
 		//delay(100);
 		(_travel_done <= _travel) ? _travel_done++ : _stepdone = true;
@@ -3739,7 +3745,7 @@ static bool lcd_selfcheck_pulleys(int axis)
 	int i;
 	unsigned long timeout_counter;
 	refresh_cmd_timeout();
-
+	manage_inactivity(true);
 
 	if (axis == 0) move = 50; //X_AXIS 
 		else move = 50; //Y_AXIS
@@ -3753,6 +3759,7 @@ static bool lcd_selfcheck_pulleys(int axis)
 			current_position[axis] = current_position[axis] + move;
 			digipot_current(0, 850); //set motor current higher
 			plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], 200, active_extruder);
+			st_synchronize();
 			if (SilentModeMenu == 1) digipot_current(0, tmp_motor[0]); //set back to normal operation currents
 			else digipot_current(0, tmp_motor_loud[0]); //set motor current back			
 			current_position[axis] = current_position[axis] - move;
@@ -3765,13 +3772,14 @@ static bool lcd_selfcheck_pulleys(int axis)
 		}
 		timeout_counter = millis() + 2500;
 		endstop_triggered = false;
-		
+		manage_inactivity(true);
 		while (!endstop_triggered) {
 			if ((READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING == 1) || (READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING == 1)) {
 				endstop_triggered = true;
 				if (current_position_init - 1 <= current_position[axis] && current_position_init + 1 >= 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);
+					st_synchronize();
 					return(true);
 				}
 				else {
@@ -3813,7 +3821,7 @@ static bool lcd_selfcheck_endstops()
 		lcd_selftest_error(3, _error.c_str(), "");
 	}
 	manage_heater();
-	manage_inactivity();
+	manage_inactivity(true);
 	return _result;
 }
 
@@ -3831,14 +3839,14 @@ static bool lcd_selfcheck_check_heater(bool _isbed)
 	target_temperature[0] = (_isbed) ? 0 : 100;
 	target_temperature_bed = (_isbed) ? 100 : 0;
 	manage_heater();
-	manage_inactivity();
+	manage_inactivity(true);
 
 	do {
 		_counter++;
 		(_counter < _cycles) ? _docycle = true : _docycle = false;
 
 		manage_heater();
-		manage_inactivity();
+		manage_inactivity(true);
 		_progress = (_isbed) ? lcd_selftest_screen(5, _progress, 2, false, 400) : lcd_selftest_screen(1, _progress, 2, false, 400);
 
 	} while (_docycle);
@@ -3867,7 +3875,7 @@ static bool lcd_selfcheck_check_heater(bool _isbed)
 	}
 
 	manage_heater();
-	manage_inactivity();
+	manage_inactivity(true);
 	return _stepresult;
 
 }
@@ -4073,6 +4081,7 @@ static bool lcd_selftest_fan_dialog(int _fan)
 
 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;