whitespace

Firmware/Marlin_main.cpp

@@ -2959,273 +2959,273 @@ void process_commands()
       #endif //FWRETRACT
     case 28: //G28 Home all Axis one at a time
     {
-		st_synchronize();
+        st_synchronize();
 
 #if 0
-		SERIAL_ECHOPGM("G28, initial ");  print_world_coordinates();
-		SERIAL_ECHOPGM("G28, initial ");  print_physical_coordinates();
+        SERIAL_ECHOPGM("G28, initial ");  print_world_coordinates();
+        SERIAL_ECHOPGM("G28, initial ");  print_physical_coordinates();
 #endif
 
-		// Flag for the display update routine and to disable the print cancelation during homing.
-		homing_flag = true;
-
-		// Which axes should be homed?
-		bool home_x = code_seen(axis_codes[X_AXIS]);
-		bool home_y = code_seen(axis_codes[Y_AXIS]);
-		bool home_z = code_seen(axis_codes[Z_AXIS]);
-		// calibrate?
-		bool calib = code_seen('C');
-		// Either all X,Y,Z codes are present, or none of them.
-		bool home_all_axes = home_x == home_y && home_x == home_z;
-		if (home_all_axes)
-			// No X/Y/Z code provided means to home all axes.
-			home_x = home_y = home_z = true;
+        // Flag for the display update routine and to disable the print cancelation during homing.
+        homing_flag = true;
+
+        // Which axes should be homed?
+        bool home_x = code_seen(axis_codes[X_AXIS]);
+        bool home_y = code_seen(axis_codes[Y_AXIS]);
+        bool home_z = code_seen(axis_codes[Z_AXIS]);
+        // calibrate?
+        bool calib = code_seen('C');
+        // Either all X,Y,Z codes are present, or none of them.
+        bool home_all_axes = home_x == home_y && home_x == home_z;
+        if (home_all_axes)
+            // No X/Y/Z code provided means to home all axes.
+            home_x = home_y = home_z = true;
 
 #ifdef ENABLE_AUTO_BED_LEVELING
-		plan_bed_level_matrix.set_to_identity();  //Reset the plane ("erase" all leveling data)
+        plan_bed_level_matrix.set_to_identity();  //Reset the plane ("erase" all leveling data)
 #endif //ENABLE_AUTO_BED_LEVELING
 
-												  // Reset world2machine_rotation_and_skew and world2machine_shift, therefore
-												  // the planner will not perform any adjustments in the XY plane. 
-												  // Wait for the motors to stop and update the current position with the absolute values.
-		world2machine_revert_to_uncorrected();
+                                                  // Reset world2machine_rotation_and_skew and world2machine_shift, therefore
+                                                  // the planner will not perform any adjustments in the XY plane. 
+                                                  // Wait for the motors to stop and update the current position with the absolute values.
+        world2machine_revert_to_uncorrected();
 
-		// For mesh bed leveling deactivate the matrix temporarily.
-		// It is necessary to disable the bed leveling for the X and Y homing moves, so that the move is performed
-		// in a single axis only.
-		// In case of re-homing the X or Y axes only, the mesh bed leveling is restored after G28.
+        // For mesh bed leveling deactivate the matrix temporarily.
+        // It is necessary to disable the bed leveling for the X and Y homing moves, so that the move is performed
+        // in a single axis only.
+        // In case of re-homing the X or Y axes only, the mesh bed leveling is restored after G28.
 #ifdef MESH_BED_LEVELING
-		uint8_t mbl_was_active = mbl.active;
-		mbl.active = 0;
-		current_position[Z_AXIS] = st_get_position_mm(Z_AXIS);
+        uint8_t mbl_was_active = mbl.active;
+        mbl.active = 0;
+        current_position[Z_AXIS] = st_get_position_mm(Z_AXIS);
 #endif
 
-		// Reset baby stepping to zero, if the babystepping has already been loaded before. The babystepsTodo value will be
-		// consumed during the first movements following this statement.
-		if (home_z)
-			babystep_undo();
+        // Reset baby stepping to zero, if the babystepping has already been loaded before. The babystepsTodo value will be
+        // consumed during the first movements following this statement.
+        if (home_z)
+            babystep_undo();
 
-		saved_feedrate = feedrate;
-		saved_feedmultiply = feedmultiply;
-		feedmultiply = 100;
-		previous_millis_cmd = millis();
+        saved_feedrate = feedrate;
+        saved_feedmultiply = feedmultiply;
+        feedmultiply = 100;
+        previous_millis_cmd = millis();
 
-		enable_endstops(true);
+        enable_endstops(true);
 
-		memcpy(destination, current_position, sizeof(destination));
-		feedrate = 0.0;
+        memcpy(destination, current_position, sizeof(destination));
+        feedrate = 0.0;
 
 #if Z_HOME_DIR > 0                      // If homing away from BED do Z first
-		if(home_z)
-			homeaxis(Z_AXIS);
+        if(home_z)
+            homeaxis(Z_AXIS);
 #endif
 
 #ifdef QUICK_HOME
-		// In the quick mode, if both x and y are to be homed, a diagonal move will be performed initially.
-		if(home_x && home_y)  //first diagonal move
-		{
-			current_position[X_AXIS] = 0;current_position[Y_AXIS] = 0;
+        // In the quick mode, if both x and y are to be homed, a diagonal move will be performed initially.
+        if(home_x && home_y)  //first diagonal move
+        {
+            current_position[X_AXIS] = 0;current_position[Y_AXIS] = 0;
 
-			int x_axis_home_dir = home_dir(X_AXIS);
+            int x_axis_home_dir = home_dir(X_AXIS);
 
-			plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
-			destination[X_AXIS] = 1.5 * max_length(X_AXIS) * x_axis_home_dir;destination[Y_AXIS] = 1.5 * max_length(Y_AXIS) * home_dir(Y_AXIS);
-			feedrate = homing_feedrate[X_AXIS];
-			if(homing_feedrate[Y_AXIS]<feedrate)
-				feedrate = homing_feedrate[Y_AXIS];
-			if (max_length(X_AXIS) > max_length(Y_AXIS)) {
-				feedrate *= sqrt(pow(max_length(Y_AXIS) / max_length(X_AXIS), 2) + 1);
-			} else {
-				feedrate *= sqrt(pow(max_length(X_AXIS) / max_length(Y_AXIS), 2) + 1);
-			}
-			plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate/60, active_extruder);
-			st_synchronize();
+            plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
+            destination[X_AXIS] = 1.5 * max_length(X_AXIS) * x_axis_home_dir;destination[Y_AXIS] = 1.5 * max_length(Y_AXIS) * home_dir(Y_AXIS);
+            feedrate = homing_feedrate[X_AXIS];
+            if(homing_feedrate[Y_AXIS]<feedrate)
+                feedrate = homing_feedrate[Y_AXIS];
+            if (max_length(X_AXIS) > max_length(Y_AXIS)) {
+                feedrate *= sqrt(pow(max_length(Y_AXIS) / max_length(X_AXIS), 2) + 1);
+            } else {
+                feedrate *= sqrt(pow(max_length(X_AXIS) / max_length(Y_AXIS), 2) + 1);
+            }
+            plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate/60, active_extruder);
+            st_synchronize();
 
-			axis_is_at_home(X_AXIS);
-			axis_is_at_home(Y_AXIS);
-			plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
-			destination[X_AXIS] = current_position[X_AXIS];
-			destination[Y_AXIS] = current_position[Y_AXIS];
-			plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate/60, active_extruder);
-			feedrate = 0.0;
-			st_synchronize();
-			endstops_hit_on_purpose();
+            axis_is_at_home(X_AXIS);
+            axis_is_at_home(Y_AXIS);
+            plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
+            destination[X_AXIS] = current_position[X_AXIS];
+            destination[Y_AXIS] = current_position[Y_AXIS];
+            plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate/60, active_extruder);
+            feedrate = 0.0;
+            st_synchronize();
+            endstops_hit_on_purpose();
 
-			current_position[X_AXIS] = destination[X_AXIS];
-			current_position[Y_AXIS] = destination[Y_AXIS];
-			current_position[Z_AXIS] = destination[Z_AXIS];
-		}
+            current_position[X_AXIS] = destination[X_AXIS];
+            current_position[Y_AXIS] = destination[Y_AXIS];
+            current_position[Z_AXIS] = destination[Z_AXIS];
+        }
 #endif /* QUICK_HOME */
 
 #ifdef TMC2130	 
-		if(home_x)
-		{
-			if (!calib)
-				homeaxis(X_AXIS);
-			else
-				tmc2130_home_calibrate(X_AXIS);
-		}
+        if(home_x)
+        {
+            if (!calib)
+                homeaxis(X_AXIS);
+            else
+                tmc2130_home_calibrate(X_AXIS);
+        }
 
-		if(home_y)
-		{
-			if (!calib)
-				homeaxis(Y_AXIS);
-			else
-				tmc2130_home_calibrate(Y_AXIS);
-		}
+        if(home_y)
+        {
+            if (!calib)
+                homeaxis(Y_AXIS);
+            else
+                tmc2130_home_calibrate(Y_AXIS);
+        }
 #endif //TMC2130
 
 
-		if(code_seen(axis_codes[X_AXIS]) && code_value_long() != 0)
-			current_position[X_AXIS]=code_value()+add_homing[X_AXIS];
+        if(code_seen(axis_codes[X_AXIS]) && code_value_long() != 0)
+            current_position[X_AXIS]=code_value()+add_homing[X_AXIS];
 
-		if(code_seen(axis_codes[Y_AXIS]) && code_value_long() != 0)
-			current_position[Y_AXIS]=code_value()+add_homing[Y_AXIS];
+        if(code_seen(axis_codes[Y_AXIS]) && code_value_long() != 0)
+            current_position[Y_AXIS]=code_value()+add_homing[Y_AXIS];
 
 #if Z_HOME_DIR < 0                      // If homing towards BED do Z last
 #ifndef Z_SAFE_HOMING
-		if(home_z) {
+        if(home_z) {
 #if defined (Z_RAISE_BEFORE_HOMING) && (Z_RAISE_BEFORE_HOMING > 0)
-			destination[Z_AXIS] = Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS) * (-1);    // Set destination away from bed
-			feedrate = max_feedrate[Z_AXIS];
-			plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate, active_extruder);
-			st_synchronize();
+            destination[Z_AXIS] = Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS) * (-1);    // Set destination away from bed
+            feedrate = max_feedrate[Z_AXIS];
+            plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate, active_extruder);
+            st_synchronize();
 #endif // defined (Z_RAISE_BEFORE_HOMING) && (Z_RAISE_BEFORE_HOMING > 0)
 #if (defined(MESH_BED_LEVELING) && !defined(MK1BP))  // If Mesh bed leveling, moxve X&Y to safe position for home
-			if (!(axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] ))
-			{
-				homeaxis(X_AXIS);
-				homeaxis(Y_AXIS);
-			}
-			// 1st mesh bed leveling measurement point, corrected.
-			world2machine_initialize();
-			world2machine(pgm_read_float(bed_ref_points), pgm_read_float(bed_ref_points+1), destination[X_AXIS], destination[Y_AXIS]);
-			world2machine_reset();
-			if (destination[Y_AXIS] < Y_MIN_POS)
-				destination[Y_AXIS] = Y_MIN_POS;
-			destination[Z_AXIS] = MESH_HOME_Z_SEARCH;    // Set destination away from bed
-			feedrate = homing_feedrate[Z_AXIS]/10;
-			current_position[Z_AXIS] = 0;
-			enable_endstops(false);
-			plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
-			plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate, active_extruder);
-			st_synchronize();
-			current_position[X_AXIS] = destination[X_AXIS];
-			current_position[Y_AXIS] = destination[Y_AXIS];
-			enable_endstops(true);
-			endstops_hit_on_purpose();
-			homeaxis(Z_AXIS);
+            if (!(axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] ))
+            {
+                homeaxis(X_AXIS);
+                homeaxis(Y_AXIS);
+            }
+            // 1st mesh bed leveling measurement point, corrected.
+            world2machine_initialize();
+            world2machine(pgm_read_float(bed_ref_points), pgm_read_float(bed_ref_points+1), destination[X_AXIS], destination[Y_AXIS]);
+            world2machine_reset();
+            if (destination[Y_AXIS] < Y_MIN_POS)
+                destination[Y_AXIS] = Y_MIN_POS;
+            destination[Z_AXIS] = MESH_HOME_Z_SEARCH;    // Set destination away from bed
+            feedrate = homing_feedrate[Z_AXIS]/10;
+            current_position[Z_AXIS] = 0;
+            enable_endstops(false);
+            plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
+            plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate, active_extruder);
+            st_synchronize();
+            current_position[X_AXIS] = destination[X_AXIS];
+            current_position[Y_AXIS] = destination[Y_AXIS];
+            enable_endstops(true);
+            endstops_hit_on_purpose();
+            homeaxis(Z_AXIS);
 #else // MESH_BED_LEVELING
-			homeaxis(Z_AXIS);
+            homeaxis(Z_AXIS);
 #endif // MESH_BED_LEVELING
-		}
+        }
 #else // defined(Z_SAFE_HOMING): Z Safe mode activated.
-		if(home_all_axes) {
-			destination[X_AXIS] = round(Z_SAFE_HOMING_X_POINT - X_PROBE_OFFSET_FROM_EXTRUDER);
-			destination[Y_AXIS] = round(Z_SAFE_HOMING_Y_POINT - Y_PROBE_OFFSET_FROM_EXTRUDER);
-			destination[Z_AXIS] = Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS) * (-1);    // Set destination away from bed
-			feedrate = XY_TRAVEL_SPEED/60;
-			current_position[Z_AXIS] = 0;
-
-			plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
-			plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate, active_extruder);
-			st_synchronize();
-			current_position[X_AXIS] = destination[X_AXIS];
-			current_position[Y_AXIS] = destination[Y_AXIS];
+        if(home_all_axes) {
+            destination[X_AXIS] = round(Z_SAFE_HOMING_X_POINT - X_PROBE_OFFSET_FROM_EXTRUDER);
+            destination[Y_AXIS] = round(Z_SAFE_HOMING_Y_POINT - Y_PROBE_OFFSET_FROM_EXTRUDER);
+            destination[Z_AXIS] = Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS) * (-1);    // Set destination away from bed
+            feedrate = XY_TRAVEL_SPEED/60;
+            current_position[Z_AXIS] = 0;
 
-			homeaxis(Z_AXIS);
-		}
-		// Let's see if X and Y are homed and probe is inside bed area.
-		if(home_z) {
-			if ( (axis_known_position[X_AXIS]) && (axis_known_position[Y_AXIS]) \
-				&& (current_position[X_AXIS]+X_PROBE_OFFSET_FROM_EXTRUDER >= X_MIN_POS) \
-				&& (current_position[X_AXIS]+X_PROBE_OFFSET_FROM_EXTRUDER <= X_MAX_POS) \
-				&& (current_position[Y_AXIS]+Y_PROBE_OFFSET_FROM_EXTRUDER >= Y_MIN_POS) \
-				&& (current_position[Y_AXIS]+Y_PROBE_OFFSET_FROM_EXTRUDER <= Y_MAX_POS)) {
-
-				current_position[Z_AXIS] = 0;
-				plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
-				destination[Z_AXIS] = Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS) * (-1);    // Set destination away from bed
-				feedrate = max_feedrate[Z_AXIS];
-				plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate, active_extruder);
-				st_synchronize();
+            plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
+            plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate, active_extruder);
+            st_synchronize();
+            current_position[X_AXIS] = destination[X_AXIS];
+            current_position[Y_AXIS] = destination[Y_AXIS];
 
-				homeaxis(Z_AXIS);
-			} else if (!((axis_known_position[X_AXIS]) && (axis_known_position[Y_AXIS]))) {
-				LCD_MESSAGERPGM(MSG_POSITION_UNKNOWN);
-				SERIAL_ECHO_START;
-				SERIAL_ECHOLNRPGM(MSG_POSITION_UNKNOWN);
-			} else {
-				LCD_MESSAGERPGM(MSG_ZPROBE_OUT);
-				SERIAL_ECHO_START;
-				SERIAL_ECHOLNRPGM(MSG_ZPROBE_OUT);
-			}
-		}
+            homeaxis(Z_AXIS);
+        }
+        // Let's see if X and Y are homed and probe is inside bed area.
+        if(home_z) {
+            if ( (axis_known_position[X_AXIS]) && (axis_known_position[Y_AXIS]) \
+                && (current_position[X_AXIS]+X_PROBE_OFFSET_FROM_EXTRUDER >= X_MIN_POS) \
+                && (current_position[X_AXIS]+X_PROBE_OFFSET_FROM_EXTRUDER <= X_MAX_POS) \
+                && (current_position[Y_AXIS]+Y_PROBE_OFFSET_FROM_EXTRUDER >= Y_MIN_POS) \
+                && (current_position[Y_AXIS]+Y_PROBE_OFFSET_FROM_EXTRUDER <= Y_MAX_POS)) {
+
+                current_position[Z_AXIS] = 0;
+                plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
+                destination[Z_AXIS] = Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS) * (-1);    // Set destination away from bed
+                feedrate = max_feedrate[Z_AXIS];
+                plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate, active_extruder);
+                st_synchronize();
+
+                homeaxis(Z_AXIS);
+            } else if (!((axis_known_position[X_AXIS]) && (axis_known_position[Y_AXIS]))) {
+                LCD_MESSAGERPGM(MSG_POSITION_UNKNOWN);
+                SERIAL_ECHO_START;
+                SERIAL_ECHOLNRPGM(MSG_POSITION_UNKNOWN);
+            } else {
+                LCD_MESSAGERPGM(MSG_ZPROBE_OUT);
+                SERIAL_ECHO_START;
+                SERIAL_ECHOLNRPGM(MSG_ZPROBE_OUT);
+            }
+        }
 #endif // Z_SAFE_HOMING
 #endif // Z_HOME_DIR < 0
 
-		if(code_seen(axis_codes[Z_AXIS]) && code_value_long() != 0)
-			current_position[Z_AXIS]=code_value()+add_homing[Z_AXIS];
+        if(code_seen(axis_codes[Z_AXIS]) && code_value_long() != 0)
+            current_position[Z_AXIS]=code_value()+add_homing[Z_AXIS];
 #ifdef ENABLE_AUTO_BED_LEVELING
-		if(home_z)
-			current_position[Z_AXIS] += zprobe_zoffset;  //Add Z_Probe offset (the distance is negative)
+        if(home_z)
+            current_position[Z_AXIS] += zprobe_zoffset;  //Add Z_Probe offset (the distance is negative)
 #endif
 
-														 // Set the planner and stepper routine positions.
-														 // At this point the mesh bed leveling and world2machine corrections are disabled and current_position
-														 // contains the machine coordinates.
-		plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
+                                                         // Set the planner and stepper routine positions.
+                                                         // At this point the mesh bed leveling and world2machine corrections are disabled and current_position
+                                                         // contains the machine coordinates.
+        plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
 
 #ifdef ENDSTOPS_ONLY_FOR_HOMING
-		enable_endstops(false);
+        enable_endstops(false);
 #endif
 
-		feedrate = saved_feedrate;
-		feedmultiply = saved_feedmultiply;
-		previous_millis_cmd = millis();
-		endstops_hit_on_purpose();
+        feedrate = saved_feedrate;
+        feedmultiply = saved_feedmultiply;
+        previous_millis_cmd = millis();
+        endstops_hit_on_purpose();
 #ifndef MESH_BED_LEVELING
-		// If MESH_BED_LEVELING is not active, then it is the original Prusa i3.
-		// Offer the user to load the baby step value, which has been adjusted at the previous print session.
-		if(card.sdprinting && eeprom_read_word((uint16_t *)EEPROM_BABYSTEP_Z))
-			lcd_adjust_z();
+        // If MESH_BED_LEVELING is not active, then it is the original Prusa i3.
+        // Offer the user to load the baby step value, which has been adjusted at the previous print session.
+        if(card.sdprinting && eeprom_read_word((uint16_t *)EEPROM_BABYSTEP_Z))
+            lcd_adjust_z();
 #endif
 
-		// Load the machine correction matrix
-		world2machine_initialize();
-		// and correct the current_position XY axes to match the transformed coordinate system.
-		world2machine_update_current();
+        // Load the machine correction matrix
+        world2machine_initialize();
+        // and correct the current_position XY axes to match the transformed coordinate system.
+        world2machine_update_current();
 
 #if (defined(MESH_BED_LEVELING) && !defined(MK1BP))
-		if (code_seen(axis_codes[X_AXIS]) || code_seen(axis_codes[Y_AXIS]) || code_seen('W') || code_seen(axis_codes[Z_AXIS]))
-		{
-			if (! home_z && mbl_was_active) {
-				// Re-enable the mesh bed leveling if only the X and Y axes were re-homed.
-				mbl.active = true;
-				// and re-adjust the current logical Z axis with the bed leveling offset applicable at the current XY position.
-				current_position[Z_AXIS] -= mbl.get_z(st_get_position_mm(X_AXIS), st_get_position_mm(Y_AXIS));
-			}
-		}
-		else
-		{
-			st_synchronize();
-			homing_flag = false;
-			// Push the commands to the front of the message queue in the reverse order!
-			// There shall be always enough space reserved for these commands.
-			// enquecommand_front_P((PSTR("G80")));
-			goto case_G80;
-		}
+        if (code_seen(axis_codes[X_AXIS]) || code_seen(axis_codes[Y_AXIS]) || code_seen('W') || code_seen(axis_codes[Z_AXIS]))
+        {
+            if (! home_z && mbl_was_active) {
+                // Re-enable the mesh bed leveling if only the X and Y axes were re-homed.
+                mbl.active = true;
+                // and re-adjust the current logical Z axis with the bed leveling offset applicable at the current XY position.
+                current_position[Z_AXIS] -= mbl.get_z(st_get_position_mm(X_AXIS), st_get_position_mm(Y_AXIS));
+            }
+        }
+        else
+        {
+            st_synchronize();
+            homing_flag = false;
+            // Push the commands to the front of the message queue in the reverse order!
+            // There shall be always enough space reserved for these commands.
+            // enquecommand_front_P((PSTR("G80")));
+            goto case_G80;
+        }
 #endif
 
-		if (farm_mode) { prusa_statistics(20); };
+        if (farm_mode) { prusa_statistics(20); };
 
-		homing_flag = false;
+        homing_flag = false;
 #if 0
-		SERIAL_ECHOPGM("G28, final ");  print_world_coordinates();
-		SERIAL_ECHOPGM("G28, final ");  print_physical_coordinates();
-		SERIAL_ECHOPGM("G28, final ");  print_mesh_bed_leveling_table();
+        SERIAL_ECHOPGM("G28, final ");  print_world_coordinates();
+        SERIAL_ECHOPGM("G28, final ");  print_physical_coordinates();
+        SERIAL_ECHOPGM("G28, final ");  print_mesh_bed_leveling_table();
 #endif
-		break;
+        break;
     }
 #ifdef ENABLE_AUTO_BED_LEVELING
     case 29: // G29 Detailed Z-Probe, probes the bed at 3 or more points.