FEEDRATE_MODE_SUPPORT. Adds G93 inverse time mode and G94 units per minute mode

Author: DerAndere1

Marlin/Configuration.h

@@ -2522,6 +2522,11 @@
 //
 //#define INCH_MODE_SUPPORT
 
+//
+// G93/G94 Feedrate mode support
+//
+//#define FEEDRATE_MODE_SUPPORT
+
 //
 // M149 Set temperature units support
 //

Marlin/src/core/language.h

@@ -148,6 +148,7 @@
 #define STR_ERR_MATERIAL_INDEX              "M145 S<index> out of range (0-1)"
 #define STR_ERR_M421_PARAMETERS             "M421 incorrect parameter usage"
 #define STR_ERR_BAD_PLANE_MODE              "G5 requires XY plane mode"
+#define STR_ERR_BAD_FEEDRATE_MODE           "G5 currently requires units/min feedrate mode"
 #define STR_ERR_MESH_XY                     "Mesh point out of range"
 #define STR_ERR_ARC_ARGS                    "G2/G3 bad parameters"
 #define STR_ERR_PROTECTED_PIN               "Protected Pin"

Marlin/src/feature/bedlevel/abl/bbl.cpp

@@ -78,7 +78,7 @@ void LevelingBilinear::extrapolate_one_point(const uint8_t x, const uint8_t y, c
   const float a = 2 * a1 - a2, b = 2 * b1 - b2, c = 2 * c1 - c2;
 
   // Take the average instead of the median
-  z_values[x][y] = (a + b + c) / 3.0;
+  z_values[x][y] = (a + b + c) / 3.0f;
   TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(x, y, z_values[x][y]));
 
   // Median is robust (ignores outliers).
@@ -369,7 +369,7 @@ float LevelingBilinear::get_z_correction(const xy_pos_t &raw) {
    * Prepare a bilinear-leveled linear move on Cartesian,
    * splitting the move where it crosses grid borders.
    */
-  void LevelingBilinear::line_to_destination(const feedRate_t scaled_fr_mm_s, uint16_t x_splits, uint16_t y_splits) {
+  void LevelingBilinear::line_to_destination(const feedRate_t scaled_fr, uint16_t x_splits, uint16_t y_splits) {
     // Get current and destination cells for this line
     xy_int_t c1 { CELL_INDEX(x, current_position.x), CELL_INDEX(y, current_position.y) },
              c2 { CELL_INDEX(x, destination.x), CELL_INDEX(y, destination.y) };
@@ -385,6 +385,28 @@ float LevelingBilinear::get_z_correction(const xy_pos_t &raw) {
       return;
     }
 
+
+    const xyze_pos_t total = destination - current_position;
+
+    #if ENABLED(FEEDRATE_MODE_SUPPORT)
+      // Get the linear distance in XYZ
+      #if HAS_ROTATIONAL_AXES
+        bool cartes_move = true;
+      #endif
+      float cartesian_mm = get_move_distance(total OPTARG(HAS_ROTATIONAL_AXES, cartes_move));
+
+      // If the move is very short, check the E move distance
+      TERN_(HAS_EXTRUDERS, if (UNEAR_ZERO(cartesian_mm)) cartesian_mm = ABS(total.e));
+
+      const bool old_inverse_time_enabled = parser.inverse_time_enabled;
+
+      const feedrate_t scaled_fr_mm_s = (old_inverse_time_enabled && parser.print_move) ? cartesian_mm * scaled_fr : scaled_fr;
+      parser.inverse_time_enabled = false;
+
+    #else
+      const feedrate_t scaled_fr_mm_s = scaled_fr;
+    #endif
+
     #define LINE_SEGMENT_END(A) (current_position.A + (destination.A - current_position.A) * normalized_dist)
 
     float normalized_dist;
@@ -415,6 +437,7 @@ float LevelingBilinear::get_z_correction(const xy_pos_t &raw) {
       // This should be a rare case.
       current_position = destination;
       line_to_current_position(scaled_fr_mm_s);
+      parser.inverse_time_enabled = old_inverse_time_enabled;
       return;
     }
 
@@ -427,6 +450,7 @@ float LevelingBilinear::get_z_correction(const xy_pos_t &raw) {
     // Restore destination from stack
     destination = end;
     line_to_destination(scaled_fr_mm_s, x_splits, y_splits);
+    parser.inverse_time_enabled = old_inverse_time_enabled;
   }
 
 #endif // IS_CARTESIAN && !SEGMENT_LEVELED_MOVES

Marlin/src/feature/bedlevel/mbl/mesh_bed_leveling.cpp

@@ -64,15 +64,16 @@
     void mesh_bed_leveling::line_to_destination(const feedRate_t scaled_fr_mm_s, uint8_t x_splits, uint8_t y_splits) {
       // Get current and destination cells for this line
       xy_uint8_t scel = cell_indexes(current_position), ecel = cell_indexes(destination);
-      NOMORE(scel.x, GRID_MAX_CELLS_X - 1);
-      NOMORE(scel.y, GRID_MAX_CELLS_Y - 1);
-      NOMORE(ecel.x, GRID_MAX_CELLS_X - 1);
-      NOMORE(ecel.y, GRID_MAX_CELLS_Y - 1);
+      
+      segments = ecel - scel;
+      NOLESS(segments, 1);
+      
+      segment_fr = (parser.inverse_time_enabled && parser.print_move) ? scaled_fr_mm_s * segments : scaled_fr_mm_s;
 
       // Start and end in the same cell? No split needed.
       if (scel == ecel) {
         current_position = destination;
-        line_to_current_position(scaled_fr_mm_s);
+        line_to_current_position(segment_fr);
         return;
       }
 
@@ -105,19 +106,19 @@
         // Must already have been split on these border(s)
         // This should be a rare case.
         current_position = destination;
-        line_to_current_position(scaled_fr_mm_s);
+        line_to_current_position(segment_fr);
         return;
       }
 
       destination.z = MBL_SEGMENT_END(z);
       destination.e = MBL_SEGMENT_END(e);
 
       // Do the split and look for more borders
-      line_to_destination(scaled_fr_mm_s, x_splits, y_splits);
+      line_to_destination(segment_fr, x_splits, y_splits);
 
       // Restore destination from stack
       destination = dest;
-      line_to_destination(scaled_fr_mm_s, x_splits, y_splits);
+      line_to_destination(segment_fr, x_splits, y_splits);
     }
 
   #endif // IS_CARTESIAN && !SEGMENT_LEVELED_MOVES

Marlin/src/feature/bedlevel/ubl/ubl.h

@@ -297,7 +297,7 @@ class unified_bed_leveling {
   #if UBL_SEGMENTED
     static bool line_to_destination_segmented(const feedRate_t scaled_fr_mm_s);
   #else
-    static void line_to_destination_cartesian(const feedRate_t scaled_fr_mm_s, const uint8_t e);
+    static void line_to_destination_cartesian(const feedRate_t scaled_fr, const uint8_t e);
   #endif
 
   static bool mesh_is_valid() {

Marlin/src/feature/bedlevel/ubl/ubl_motion.cpp

@@ -46,7 +46,7 @@
   //       corners of cells. To fix the issue, simply check if the start/end of the line
   //       is very close to a cell boundary in advance and don't split the line there.
 
-  void unified_bed_leveling::line_to_destination_cartesian(const feedRate_t scaled_fr_mm_s, const uint8_t extruder) {
+  void unified_bed_leveling::line_to_destination_cartesian(const feedRate_t scaled_fr, const uint8_t extruder) {
     /**
      * Much of the nozzle movement will be within the same cell. So we will do as little computation
      * as possible to determine if this is the case. If this move is within the same cell, we will
@@ -60,6 +60,27 @@
       const xyze_pos_t &start = current_position, &end = destination;
     #endif
 
+    const xyze_pos_t total = end - start;
+
+    #if ENABLED(FEEDRATE_MODE_SUPPORT)
+      // Get the linear distance in XYZ
+      #if HAS_ROTATIONAL_AXES
+        bool cartes_move = true;
+      #endif
+      float cartesian_mm = get_move_distance(total OPTARG(HAS_ROTATIONAL_AXES, cartes_move));
+
+      // If the move is very short, check the E move distance
+      TERN_(HAS_EXTRUDERS, if (UNEAR_ZERO(cartesian_mm)) cartesian_mm = ABS(total.e));
+
+      const bool old_inverse_time_enabled = parser.inverse_time_enabled;
+
+      const feedRate_t scaled_fr_mm_s = (old_inverse_time_enabled && parser.print_move) ? cartesian_mm * scaled_fr : scaled_fr;
+      parser.inverse_time_enabled = false;
+
+    #else
+      const feedRate_t scaled_fr_mm_s = scaled_fr;
+    #endif
+
     const xy_uint8_t istart = cell_indexes(start), iend = cell_indexes(end);
 
     // A move within the same cell needs no splitting
@@ -79,6 +100,7 @@
           end.z += UBL_Z_RAISE_WHEN_OFF_MESH;
           planner.buffer_segment(end, scaled_fr_mm_s, extruder);
           current_position = destination;
+          TERN_(FEEDRATE_MODE_SUPPORT, parser.inverse_time_enabled = old_inverse_time_enabled);
           return;
         }
       #endif
@@ -97,6 +119,7 @@
       if (!isnan(z0)) end.z += z0;
       planner.buffer_segment(end, scaled_fr_mm_s, extruder);
       current_position = destination;
+      TERN_(FEEDRATE_MODE_SUPPORT, parser.inverse_time_enabled = old_inverse_time_enabled);
       return;
     }
 
@@ -105,7 +128,7 @@
      * case - crossing only one X or Y line - after details are worked out to reduce computation.
      */
 
-    const xy_float_t dist = end - start;
+    const xy_float_t dist = xy_float:t(total);
     const xy_bool_t neg { dist.x < 0, dist.y < 0 };
     const xy_uint8_t ineg { uint8_t(neg.x), uint8_t(neg.y) };
     const xy_float_t sign { neg.x ? -1.0f : 1.0f, neg.y ? -1.0f : 1.0f };
@@ -194,6 +217,7 @@
         goto FINAL_MOVE;
 
       current_position = destination;
+      TERN_(FEEDRATE_MODE_SUPPORT, parser.inverse_time_enabled = old_inverse_time_enabled);
       return;
     }
 
@@ -357,24 +381,58 @@
 
     const xyze_pos_t total = destination - current_position;
 
-    const float cart_xy_mm_2 = HYPOT2(total.x, total.y),
-                cart_xy_mm = SQRT(cart_xy_mm_2);                               // Total XY distance
+    // If the move is only in Z/E don't split up the move
+    if (!total.x && !total.y) {
+      planner.buffer_line(destination, scaled_fr_mm_s);
+      return false; // caller will update current_position
+    }
+
+    #if HAS_ROTATIONAL_AXES
+      bool cartes_move = true;
+    #endif
+    float cartesian_mm = get_move_distance(total OPTARG(HAS_ROTATIONAL_AXES, cartes_move));
+
+      // If the move is very short, check the E move distance
+    TERN_(HAS_EXTRUDERS, if (UNEAR_ZERO(cartesian_mm)) cartesian_mm = ABS(total.e));
+
+    // No E move either? Game over.
+    if (UNEAR_ZERO(cartesian_mm)) return true;
 
     #if IS_KINEMATIC
-      const float seconds = cart_xy_mm / scaled_fr_mm_s;                       // Duration of XY move at requested rate
+      // Minimum number of seconds to move the given distance
+      #if ENABLED(FEEDRATE_MODE_SUPPORT)
+        const float seconds = (parser.print_move && parser.inverse_time_enabled) ? RECIPROCAL(scaled_fr_mm_s) : cartesian_mm / (
+          #if ALL(HAS_ROTATIONAL_AXES, INCH_MODE_SUPPORT)
+            cartes_move ? scaled_fr_mm_s : LINEAR_UNIT(scaled_fr_mm_s)
+          #else
+            scaled_fr_mm_s
+          #endif
+        );
+      #else
+        const float seconds = cartesian_mm / (
+          #if ALL(HAS_ROTATIONAL_AXES, INCH_MODE_SUPPORT)
+            cartes_move ? scaled_fr_mm_s : LINEAR_UNIT(scaled_fr_mm_s)
+          #else
+            scaled_fr_mm_s
+          #endif
+        );
+      #endif
       uint16_t segments = LROUND(segments_per_second * seconds),               // Preferred number of segments for distance @ feedrate
-               seglimit = LROUND(cart_xy_mm * RECIPROCAL(SEGMENT_MIN_LENGTH)); // Number of segments at minimum segment length
+               seglimit = LROUND(cartesian_mm * RECIPROCAL(SEGMENT_MIN_LENGTH)); // Number of segments at minimum segment length
+    
       NOMORE(segments, seglimit);                                              // Limit to minimum segment length (fewer segments)
     #else
-      uint16_t segments = LROUND(cart_xy_mm * RECIPROCAL(SEGMENT_MIN_LENGTH)); // Cartesian fixed segment length
+      uint16_t segments = LROUND(cartesian_mm * RECIPROCAL(SEGMENT_MIN_LENGTH)); // Cartesian fixed segment length
     #endif
 
     NOLESS(segments, 1U);                                                      // Must have at least one segment
     const float inv_segments = 1.0f / segments;                                // Reciprocal to save calculation
 
     // Add hints to help optimize the move
-    PlannerHints hints(SQRT(cart_xy_mm_2 + sq(total.z)) * inv_segments);       // Length of each segment
-    #if ENABLED(FEEDRATE_SCALING)
+    PlannerHints hints(cartesian_mm * inv_segments);       // Length of each segment
+    #if IS_KINEMATIC && ENABLED(FEEDRATE_MODE_SUPPORT)
+      hints.inv_duration = segments / seconds;
+    #elif ENABLED(FEEDRATE_SCALING)
       hints.inv_duration = scaled_fr_mm_s / hints.millimeters;
     #endif
 

Marlin/src/gcode/bedlevel/G42.cpp

@@ -54,6 +54,8 @@ void GcodeSuite::G42() {
     return;
   }
 
+  TERN_(FEEDRATE_MODE_SUPPORT, parser.print_move = true);
+
   // Move to current_position, as modified by I, J, P parameters
   destination = current_position;
 
@@ -67,15 +69,17 @@ void GcodeSuite::G42() {
     }
   #endif
 
-  const feedRate_t fval = parser.linearval('F'),
-                   fr_mm_s = MMM_TO_MMS(fval > 0 ? fval : 0.0f);
+  const feedRate_t fval = parser.feedrateval('F'),
+                   fr_mm_s = MMM_TO_MMS(fval);
 
   // SCARA kinematic has "safe" XY raw moves
   #if IS_SCARA
     prepare_internal_fast_move_to_destination(fr_mm_s);
   #else
     prepare_internal_move_to_destination(fr_mm_s);
   #endif
+
+  TERN_(FEEDRATE_MODE_SUPPORT, parser.print_move = false);
 }
 
 #endif // HAS_MESH

Marlin/src/gcode/feature/camera/M240.cpp

@@ -134,12 +134,12 @@ void GcodeSuite::M240() {
 
     #ifdef PHOTO_RETRACT_MM
       const float rval = parser.linearval('R', _PHOTO_RETRACT_MM);
-      const feedRate_t sval = parser.feedrateval('S', TERN(ADVANCED_PAUSE_FEATURE, PAUSE_PARK_RETRACT_FEEDRATE, TERN(FWRETRACT, RETRACT_FEEDRATE, 45)));
+      const feedRate_t sval = MMM_TO_MMS(parser.feedrateval('S', TERN(ADVANCED_PAUSE_FEATURE, PAUSE_PARK_RETRACT_FEEDRATE, TERN(FWRETRACT, RETRACT_FEEDRATE, 45))));
       e_move_m240(-rval, sval);
     #endif
 
-    feedRate_t fr_mm_s = parser.feedrateval('F');
-    if (fr_mm_s) NOLESS(fr_mm_s, 10.0f);
+    feedRate_t fr_mm_s = MMM_TO_MMS(parser.feedrateval('F'));
+    if (fr_mm_s) NOLESS(fr_mm_s, TERN(FEEDRATE_MODE_SUPPORT, 0.01f, 10.0f));
 
     constexpr xyz_pos_t photo_position = PHOTO_POSITION;
     xyz_pos_t raw = {

Marlin/src/gcode/gcode.cpp

@@ -206,7 +206,7 @@ void GcodeSuite::get_destination_from_command() {
   #endif
 
   if (parser.floatval('F') > 0) {
-    const float fr_mm_min = parser.value_linear_units();
+    const float fr_mm_min = parser.value_feedrate();
     feedrate_mm_s = MMM_TO_MMS(fr_mm_min);
     // Update the cutter feed rate for use by M4 I set inline moves.
     TERN_(LASER_FEATURE, cutter.feedrate_mm_m = fr_mm_min);
@@ -468,6 +468,11 @@ void GcodeSuite::process_parsed_command(bool no_ok/*=false*/) {
 
       case 92: G92(); break;                                      // G92: Set current axis position(s)
 
+      #if ENABLED(FEEDRATE_MODE_SUPPORT)
+        case 93: G93(); break;                                  // G93: Set feedrate mode to inverse time
+        case 94: G94(); break;                                  // G94: Set feedrate mode to length units per minute
+      #endif
+
       #if ENABLED(CALIBRATION_GCODE)
         case 425: G425(); break;                                  // G425: Perform calibration with calibration cube
       #endif

Marlin/src/gcode/gcode.h

@@ -649,6 +649,12 @@ class GcodeSuite {
 
   static void G92();
 
+
+  #if ENABLED(FEEDRATE_MODE_SUPPORT)
+    static void G93();
+    static void G94();
+  #endif
+
   #if ENABLED(CALIBRATION_GCODE)
     static void G425();
   #endif