Nozzle::clean() no longer requires HAS_BED_PROBE

Marlin/Configuration.h

   // Number of pattern repetitions
   #define NOZZLE_CLEAN_STROKES  12
 
-  //                            {  X,  Y,               Z}
-  #define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
-  #define NOZZLE_CLEAN_END_PT   {100, 60, (Z_MIN_POS + 5)}
+  // Specify positions as { X, Y, Z }
+  #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)}
+  #define NOZZLE_CLEAN_END_POINT   {100, 60, (Z_MIN_POS + 1)}
 
-  // Moves the nozzle to the parked position
-  #define NOZZLE_CLEAN_PARK
+  // Moves the nozzle to the initial position
+  #define NOZZLE_CLEAN_GOBACK
 #endif
 
 //

Marlin/Marlin.h

   #endif
 #endif
 
+/**
+ * Blocking movement and shorthand functions
+ */
+static void do_blocking_move_to(float x, float y, float z, float fr_mm_m=0.0);
+static void do_blocking_move_to_axis_pos(AxisEnum axis, float where, float fr_mm_m=0.0);
+static void do_blocking_move_to_x(float x, float fr_mm_m=0.0);
+static void do_blocking_move_to_y(float y);
+static void do_blocking_move_to_z(float z, float fr_mm_m=0.0);
+static void do_blocking_move_to_xy(float x, float y, float fr_mm_m=0.0);
+
 #endif //MARLIN_H

Marlin/Marlin_main.cpp

 #include "language.h"
 #include "pins_arduino.h"
 #include "math.h"
+#include "nozzle.h"
 
 #if ENABLED(USE_WATCHDOG)
   #include "watchdog.h"
  *  Plan a move to (X, Y, Z) and set the current_position
  *  The final current_position may not be the one that was requested
  */
-static void do_blocking_move_to(float x, float y, float z, float fr_mm_m = 0.0) {
+void do_blocking_move_to(float x, float y, float z, float fr_mm_m /*=0.0*/) {
   float old_feedrate_mm_m = feedrate_mm_m;
 
   #if ENABLED(DEBUG_LEVELING_FEATURE)
   feedrate_mm_m = old_feedrate_mm_m;
 }
 
-inline void do_blocking_move_to_x(float x, float fr_mm_m = 0.0) {
-  do_blocking_move_to(x, current_position[Y_AXIS], current_position[Z_AXIS], fr_mm_m);
-}
-
-inline void do_blocking_move_to_y(float y) {
-  do_blocking_move_to(current_position[X_AXIS], y, current_position[Z_AXIS]);
-}
-
-inline void do_blocking_move_to_xy(float x, float y, float fr_mm_m = 0.0) {
-  do_blocking_move_to(x, y, current_position[Z_AXIS], fr_mm_m);
-}
-
-inline void do_blocking_move_to_z(float z, float fr_mm_m = 0.0) {
-  do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], z, fr_mm_m);
+void do_blocking_move_to_axis_pos(AxisEnum axis, float where, float fr_mm_m/*=0.0*/) {
+  current_position[axis] = where;
+  do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], fr_mm_m);
 }
+void do_blocking_move_to_x(float x, float fr_mm_m/*=0.0*/) { do_blocking_move_to_axis_pos(X_AXIS, x, fr_mm_m); }
+void do_blocking_move_to_y(float y) { do_blocking_move_to_axis_pos(Y_AXIS, y); }
+void do_blocking_move_to_z(float z, float fr_mm_m/*=0.0*/) { do_blocking_move_to_axis_pos(Z_AXIS, z, fr_mm_m); }
+void do_blocking_move_to_xy(float x, float y, float fr_mm_m/*=0.0*/) { do_blocking_move_to(x, y, current_position[Z_AXIS], fr_mm_m); }
 
 //
 // Prepare to do endstop or probe moves
 
 #endif //FWRETRACT
 
-#if ENABLED(NOZZLE_CLEAN_FEATURE) && HAS_BED_PROBE
-  #include "nozzle.h"
-
+#if ENABLED(NOZZLE_CLEAN_FEATURE)
   /**
    * G12: Clean the nozzle
    */
 #endif
 
 #if ENABLED(NOZZLE_PARK_FEATURE)
-  #include "nozzle.h"
-
   /**
    * G27: Park the nozzle
    */
         }
         // For each G29 S2...
         if (probe_point == 0) {
-          // For the intial G29 S2 make Z a positive value (e.g., 4.0)
+          // For the initial G29 S2 make Z a positive value (e.g., 4.0)
           current_position[Z_AXIS] = MESH_HOME_SEARCH_Z
             #if Z_HOME_DIR > 0
               + Z_MAX_POS
           break;
       #endif // FWRETRACT
 
-      #if ENABLED(NOZZLE_CLEAN_FEATURE) && HAS_BED_PROBE
+      #if ENABLED(NOZZLE_CLEAN_FEATURE)
         case 12:
           gcode_G12(); // G12: Nozzle Clean
           break;

Marlin/SanityCheck.h

   #error "ENDSTOPS_ONLY_FOR_HOMING is deprecated. Use (disable) ENDSTOPS_ALWAYS_ON_DEFAULT instead."
 #endif
 
-/**
- * Nozzle cleaning
- */
-#if ENABLED(NOZZLE_CLEAN_FEATURE) && !HAS_BED_PROBE
-  #error Due to internal dependencies you must have a bed probe for NOZZLE_CLEAN_FEATURE to work
-#endif
-
 #endif //SANITYCHECK_H

Marlin/nozzle.h

     ) __attribute__((optimize ("Os"))) {
       #if ENABLED(NOZZLE_CLEAN_FEATURE)
 
-        #if ENABLED(NOZZLE_CLEAN_PARK)
+        #if ENABLED(NOZZLE_CLEAN_GOBACK)
           // Store the current coords
           point_t const initial = {
             current_position[X_AXIS],
             current_position[Z_AXIS],
             current_position[E_AXIS]
           };
-        #endif // NOZZLE_CLEAN_PARK
+        #endif // NOZZLE_CLEAN_GOBACK
 
         // Move to the starting point
         do_blocking_move_to_xy(start.x, start.y);
           do_blocking_move_to_xy(start.x, start.y);
         }
 
-        #if ENABLED(NOZZLE_CLEAN_PARK)
+        #if ENABLED(NOZZLE_CLEAN_GOBACK)
           // Move the nozzle to the initial point
           do_blocking_move_to_z(initial.z);
           do_blocking_move_to_xy(initial.x, initial.y);
-        #endif // NOZZLE_CLEAN_PARK
+        #endif // NOZZLE_CLEAN_GOBACK
 
       #endif // NOZZLE_CLEAN_FEATURE
     }
         // Don't allow impossible triangles
         if (A <= 0.0f || P <= 0.0f ) return;
 
-        #if ENABLED(NOZZLE_CLEAN_PARK)
+        #if ENABLED(NOZZLE_CLEAN_GOBACK)
           // Store the current coords
           point_t const initial = {
             current_position[X_AXIS],
             current_position[Z_AXIS],
             current_position[E_AXIS]
           };
-        #endif // NOZZLE_CLEAN_PARK
+        #endif // NOZZLE_CLEAN_GOBACK
 
         for (uint8_t j = 0; j < strokes; j++) {
           for (uint8_t i = 0; i < (objects << 1); i++) {
           }
         }
 
-        #if ENABLED(NOZZLE_CLEAN_PARK)
+        #if ENABLED(NOZZLE_CLEAN_GOBACK)
           // Move the nozzle to the initial point
           do_blocking_move_to_z(initial.z);
           do_blocking_move_to_xy(initial.x, initial.y);
-        #endif // NOZZLE_CLEAN_PARK
+        #endif // NOZZLE_CLEAN_GOBACK
 
       #endif // NOZZLE_CLEAN_FEATURE
     }
         switch (pattern) {
           case 1:
             Nozzle::zigzag(
-              NOZZLE_CLEAN_START_PT,
-              NOZZLE_CLEAN_END_PT, strokes, objects);
+              NOZZLE_CLEAN_START_POINT,
+              NOZZLE_CLEAN_END_POINT, strokes, objects);
             break;
 
           default:
             Nozzle::stroke(
-              NOZZLE_CLEAN_START_PT,
-              NOZZLE_CLEAN_END_PT, strokes);
+              NOZZLE_CLEAN_START_POINT,
+              NOZZLE_CLEAN_END_POINT, strokes);
         }
       #endif // NOZZLE_CLEAN_FEATURE
     }