LCD menu_move: Treat rotational axes in angular degrees

Marlin/Configuration.h

@@ -1275,10 +1275,16 @@
  *   M204 P    Acceleration
  *   M204 R    Retract Acceleration
  *   M204 T    Travel Acceleration
+ *   M204 I    Angular Acceleration
+ *   M204 J    Angular Travel Acceleration
  */
-#define DEFAULT_ACCELERATION          3000    // X, Y, Z and E acceleration for printing moves
-#define DEFAULT_RETRACT_ACCELERATION  3000    // E acceleration for retracts
-#define DEFAULT_TRAVEL_ACCELERATION   3000    // X, Y, Z acceleration for travel (non printing) moves
+#define DEFAULT_ACCELERATION                  3000  // X, Y, Z ... and E acceleration for printing moves
+#define DEFAULT_RETRACT_ACCELERATION          3000  // E acceleration for retracts
+#define DEFAULT_TRAVEL_ACCELERATION           3000  // X, Y, Z ... acceleration for travel (non printing) moves
+#if ENABLED(AXIS4_ROTATES)
+  #define DEFAULT_ANGULAR_ACCELERATION        3000  // I, J, K acceleration for rotational-only printing moves
+  #define DEFAULT_ANGULAR_TRAVEL_ACCELERATION 3000  // I, J, K acceleration for rotational-only travel (non printing) moves
+#endif
 
 /**
  * Default Jerk limits (mm/s)

Marlin/Configuration_adv.h

@@ -1253,8 +1253,12 @@
 #define DISABLE_IDLE_E    // Shut down all idle extruders
 
 // Default Minimum Feedrates for printing and travel moves
-#define DEFAULT_MINIMUMFEEDRATE       0.0     // (mm/s. °/s for rotational-only moves) Minimum feedrate. Set with M205 S.
-#define DEFAULT_MINTRAVELFEEDRATE     0.0     // (mm/s. °/s for rotational-only moves) Minimum travel feedrate. Set with M205 T.
+#define DEFAULT_MINIMUMFEEDRATE             0.0     // (mm/s) Minimum feedrate. Set with M205 S.
+#define DEFAULT_MINTRAVELFEEDRATE           0.0     // (mm/s) Minimum travel feedrate. Set with M205 T.
+#if HAS_ROTATIONAL_AXES
+  #define DEFAULT_ANGULAR_MINIMUMFEEDRATE   0.0     // (°/s) Minimum feedrate for rotational-only moves. Set with M205 P.
+  #define DEFAULT_ANGULAR_MINTRAVELFEEDRATE 0.0     // (°/s) Minimum travel feedrate for rotational-only moves. Set with M205 Q.
+#endif
 
 // Minimum time that a segment needs to take as the buffer gets emptied
 #define DEFAULT_MINSEGMENTTIME        20000   // (µs) Set with M205 B.
@@ -3975,6 +3979,7 @@
 #ifdef G0_FEEDRATE
   //#define VARIABLE_G0_FEEDRATE // The G0 feedrate is set by F in G0 motion mode
 #endif
+//#define G0_ANGULAR_FEEDRATE 2700 // (°/min)
 
 /**
  * Startup commands

Marlin/src/core/types.h

@@ -297,6 +297,8 @@ typedef IF<TERN0(ABL_USES_GRID, (GRID_MAX_POINTS > 255)), uint16_t, uint8_t>::ty
 // Conversion macros
 #define MMM_TO_MMS(MM_M) feedRate_t(static_cast<float>(MM_M) / 60.0f)
 #define MMS_TO_MMM(MM_S) (static_cast<float>(MM_S) * 60.0f)
+#define DPM_TO_DPS(DP_M) feedRate_t(static_cast<float>(DP_M) / 60.0f)
+#define DPS_TO_DPM(DP_S) (static_cast<float>(DP_S) * 60.0f)
 
 // Packaged character for C macro and other usage
 typedef struct SerialChar { char c; SerialChar(char n) : c(n) { } } serial_char_t;

Marlin/src/feature/tramming.cpp

@@ -41,7 +41,7 @@ PGM_P const tramming_point_name[] PROGMEM = { REPLIST_1(_NR_TRAM_NAMES, _TRAM_NA
   void move_to_tramming_wait_pos() {
     constexpr xyz_pos_t wait_pos = ASSISTED_TRAMMING_WAIT_POSITION;
     if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Moving away");
-    do_blocking_move_to(wait_pos, XY_PROBE_FEEDRATE_MM_S);
+    do_blocking_move_to(wait_pos, XY_PROBE_FEEDRATE_MM_S OPTARG(HAS_ROTATIONAL_AXES, XY_PROBE_FEEDRATE_MM_S));
   }
 
 #endif

Marlin/src/gcode/calibrate/G425.cpp

@@ -143,7 +143,7 @@ struct measurements_t {
 #endif
 
 inline void calibration_move() {
-  do_blocking_move_to((xyz_pos_t)current_position, MMM_TO_MMS(CALIBRATION_FEEDRATE_TRAVEL));
+  do_blocking_move_to((xyz_pos_t)current_position, MMM_TO_MMS(CALIBRATION_FEEDRATE_TRAVEL) OPTARG(HAS_ROTATIONAL_AXES, MMM_TO_MMS(CALIBRATION_FEEDRATE_TRAVEL)));
 }
 
 /**
@@ -212,7 +212,7 @@ float measuring_movement(const AxisEnum axis, const int dir, const bool stop_sta
   destination = current_position;
   for (float travel = 0; travel < limit; travel += step) {
     destination[axis] += dir * step;
-    do_blocking_move_to((xyz_pos_t)destination, mms);
+    do_blocking_move_to((xyz_pos_t)destination, mms OPTARG(HAS_ROTATIONAL_AXES, mms));
     planner.synchronize();
     if (read_calibration_pin() == stop_state) break;
   }
@@ -247,7 +247,7 @@ inline float measure(const AxisEnum axis, const int dir, const bool stop_state,
   // Move back to the starting position
   destination = current_position;
   destination[axis] = start_pos;
-  do_blocking_move_to((xyz_pos_t)destination, MMM_TO_MMS(CALIBRATION_FEEDRATE_TRAVEL));
+  do_blocking_move_to((xyz_pos_t)destination, MMM_TO_MMS(CALIBRATION_FEEDRATE_TRAVEL) OPTARG(HAS_ROTATIONAL_AXES, MMM_TO_MMS(CALIBRATION_FEEDRATE_TRAVEL)));
   return measured_pos;
 }
 

Marlin/src/gcode/config/M200-M205.cpp

@@ -246,9 +246,13 @@ void GcodeSuite::M203_report(const bool forReplay/*=true*/) {
  *    P<accel> Printing moves
  *    R<accel> Retract only (no X, Y, Z) moves
  *    T<accel> Travel (non printing) moves
+ *
+ * With any rotational axes:
+ *    I<accel> Angular printing moves
+ *    J<accel> Angular Travel (non-printing) moves
  */
 void GcodeSuite::M204() {
-  if (!parser.seen("PRST"))
+  if (!parser.seen("PRST" TERN_(HAS_ROTATIONAL_AXES, "IJ")))
     return M204_report();
   else {
     //planner.synchronize();
@@ -257,6 +261,10 @@ void GcodeSuite::M204() {
     if (parser.seenval('P')) planner.settings.acceleration = parser.value_linear_units();
     if (parser.seenval('R')) planner.settings.retract_acceleration = parser.value_linear_units();
     if (parser.seenval('T')) planner.settings.travel_acceleration = parser.value_linear_units();
+    #if HAS_ROTATIONAL_AXES
+      if (parser.seenval('I')) planner.settings.angular_acceleration = parser.value_float();
+      if (parser.seenval('J')) planner.settings.angular_travel_acceleration = parser.value_float();
+    #endif
   }
 }
 
@@ -268,6 +276,10 @@ void GcodeSuite::M204_report(const bool forReplay/*=true*/) {
       PSTR("  M204 P"), LINEAR_UNIT(planner.settings.acceleration)
     , PSTR(" R"), LINEAR_UNIT(planner.settings.retract_acceleration)
     , SP_T_STR, LINEAR_UNIT(planner.settings.travel_acceleration)
+    #if HAS_ROTATIONAL_AXES
+      , PSTR(" I"), planner.settings.angular_acceleration
+      , PSTR(" J"), planner.settings.angular_travel_acceleration
+    #endif
   );
 }
 
@@ -296,6 +308,10 @@ void GcodeSuite::M204_report(const bool forReplay/*=true*/) {
  *
  * Without CLASSIC_JERK:
  *    J(mm)          : Junction Deviation
+ *
+ * With any rotational axes
+ *    P<°/s>         : Min Angular Feed Rate
+ *    Q<°/s>         : Min Angular Travel Feed Rate
  */
 void GcodeSuite::M205() {
   if (!parser.seen_any()) return M205_report();
@@ -304,6 +320,10 @@ void GcodeSuite::M205() {
   if (parser.seenval(M205_MIN_SEG_TIME_PARAM)) planner.settings.min_segment_time_us = parser.value_ulong();
   if (parser.seenval('S')) planner.settings.min_feedrate_mm_s = parser.value_linear_units();
   if (parser.seenval('T')) planner.settings.min_travel_feedrate_mm_s = parser.value_linear_units();
+  #if HAS_ROTATIONAL_AXES
+    if (parser.seenval('P')) planner.settings.min_feedrate_deg_s = parser.value_float();
+    if (parser.seenval('Q')) planner.settings.min_travel_feedrate_deg_s = parser.value_float();
+  #endif
   #if HAS_JUNCTION_DEVIATION
     if (parser.seenval('J')) {
       const float junc_dev = parser.value_linear_units();
@@ -356,6 +376,10 @@ void GcodeSuite::M205_report(const bool forReplay/*=true*/) {
       PSTR("  M205 " M205_MIN_SEG_TIME_STR), LINEAR_UNIT(planner.settings.min_segment_time_us)
     , PSTR(" S"), LINEAR_UNIT(planner.settings.min_feedrate_mm_s)
     , SP_T_STR, LINEAR_UNIT(planner.settings.min_travel_feedrate_mm_s)
+    #if HAS_ROTATIONAL_AXES
+      , SP_P_STR, planner.settings.min_feedrate_deg_s
+      , PSTR(" Q"), planner.settings.min_travel_feedrate_deg_s
+    #endif
     #if HAS_JUNCTION_DEVIATION
       , PSTR(" J"), LINEAR_UNIT(planner.junction_deviation_mm)
     #endif

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

@@ -144,6 +144,9 @@ void GcodeSuite::M240() {
 
     feedRate_t fr_mm_s = parser.feedrateval('F');
     if (fr_mm_s) NOLESS(fr_mm_s, 10.0f);
+    #if HAS_ROTATIONAL_AXES
+      const feedRate_t fr_deg_s = LINEAR_UNIT(fr_mm_s);
+    #endif
 
     constexpr xyz_pos_t photo_position = PHOTO_POSITION;
     xyz_pos_t raw = {
@@ -152,7 +155,7 @@ void GcodeSuite::M240() {
       (parser.seenval('Z') ? parser.value_linear_units() : photo_position.z) + current_position.z
     };
     apply_motion_limits(raw);
-    do_blocking_move_to(raw, fr_mm_s);
+    do_blocking_move_to(raw, fr_mm_s OPTARG(HAS_ROTATIONAL_AXES, fr_deg_s));
 
     #ifdef PHOTO_SWITCH_POSITION
       constexpr xy_pos_t photo_switch_position = PHOTO_SWITCH_POSITION;
@@ -187,7 +190,7 @@ void GcodeSuite::M240() {
       const millis_t timeout = millis() + parser.intval('P', PHOTO_DELAY_MS);
       while (PENDING(millis(), timeout)) idle();
     #endif
-    do_blocking_move_to(old_pos, fr_mm_s);
+    do_blocking_move_to(old_pos, fr_mm_s OPTARG(HAS_ROTATIONAL_AXES, fr_deg_s));
     #ifdef PHOTO_RETRACT_MM
       e_move_m240(rval, sval);
     #endif

Marlin/src/gcode/feature/pause/G61.cpp

@@ -71,13 +71,19 @@ void GcodeSuite::G61() {
   if (!TEST(saved_slots[slot >> 3], slot & 0x07)) return;
 
   // Apply any given feedrate over 0.0
-  REMEMBER(saved, feedrate_mm_s);
+  REMEMBER(saved_fr, feedrate_mm_s);
+  #if HAS_ROTATIONAL_AXES
+    REMEMBER(saved_afr, feedrate_deg_s);
+  #endif
   const float fr = parser.linearval('F');
-  if (fr > 0.0) feedrate_mm_s = MMM_TO_MMS(fr);
+  if (fr > 0.0f) {
+    feedrate_mm_s = fr;
+    TERN_(HAS_ROTATIONAL_AXES, feedrate_deg_s = LINEAR_UNIT(fr));
+  }
 
   if (!parser.seen_axis()) {
     DEBUG_ECHOLNPGM("Default position restore");
-    do_blocking_move_to(stored_position[slot], feedrate_mm_s);
+    do_blocking_move_to(stored_position[slot], feedrate_mm_s OPTARG(HAS_ROTATIONAL_AXES, feedrate_deg_s));
     SYNC_E(stored_position[slot].e);
   }
   else {

Marlin/src/gcode/gcode.cpp

@@ -201,6 +201,7 @@ void GcodeSuite::get_destination_from_command() {
 
   if (parser.floatval('F') > 0) {
     feedrate_mm_s = parser.value_feedrate();
+    TERN_(HAS_ROTATIONAL_AXES, feedrate_deg_s = LINEAR_UNIT(feedrate_mm_s));
     // Update the cutter feed rate for use by M4 I set inline moves.
     TERN_(LASER_FEATURE, cutter.feedrate_mm_m = MMS_TO_MMM(feedrate_mm_s));
   }

Marlin/src/gcode/motion/G0_G1.cpp

@@ -39,6 +39,9 @@ extern xyze_pos_t destination;
 
 #if ENABLED(VARIABLE_G0_FEEDRATE)
   feedRate_t fast_move_feedrate = MMM_TO_MMS(G0_FEEDRATE);
+  #if HAS_ROTATIONAL_AXES
+    feedRate_t fast_move_angular_feedrate = DPM_TO_DPS(G0_ANGULAR_FEEDRATE);
+  #endif
 #endif
 
 /**
@@ -51,23 +54,35 @@ void GcodeSuite::G0_G1(TERN_(HAS_FAST_MOVES, const bool fast_move/*=false*/)) {
 
   #ifdef G0_FEEDRATE
     feedRate_t old_feedrate;
+    #if HAS_ROTATIONAL_AXES
+      feedRate_t old_angular_feedrate;
+    #endif
     #if ENABLED(VARIABLE_G0_FEEDRATE)
       if (fast_move) {
-        old_feedrate = feedrate_mm_s;             // Back up the (old) motion mode feedrate
-        feedrate_mm_s = fast_move_feedrate;       // Get G0 feedrate from last usage
+        old_feedrate = feedrate_mm_s;                                         // Back up the (old) motion mode feedrate
+        feedrate_mm_s = fast_move_feedrate;                                   // Get G0 feedrate from last usage
+        #if HAS_ROTATIONAL_AXES
+          old_angular_feedrate = feedrate_deg_s;                              // Back up the (old) motion mode angular feedrate
+          feedrate_deg_s = fast_move_angular_feedrate;                        // Get G0 angular feedrate from last usage with rotational axes
+        #endif
       }
     #endif
   #endif
 
-  get_destination_from_command();                 // Get X Y [Z[I[J[K]]]] [E] F (and set cutter power)
+  get_destination_from_command();                                             // Get X Y [Z[I[J[K]]]] [E] F (and set cutter power)
 
   #ifdef G0_FEEDRATE
     if (fast_move) {
       #if ENABLED(VARIABLE_G0_FEEDRATE)
-        fast_move_feedrate = feedrate_mm_s;       // Save feedrate for the next G0
+        fast_move_feedrate = feedrate_mm_s;                                   // Save feedrate for the next G0
+        TERN_(ROTATIONAL_AXES, fast_move_angular_feedrate = feedrate_deg_s);  // Save angular feedrate for the next G0
       #else
-        old_feedrate = feedrate_mm_s;             // Back up the (new) motion mode feedrate
-        feedrate_mm_s = MMM_TO_MMS(G0_FEEDRATE);  // Get the fixed G0 feedrate
+        old_feedrate = feedrate_mm_s;                                         // Back up the (new) motion mode feedrate
+        feedrate_mm_s = MMM_TO_MMS(G0_FEEDRATE);                              // Get the fixed G0 feedrate
+        #if HAS_ROTATIONAL_AXES
+          old_angular_feedrate = feedrate_deg_s;                              // Back up the (new) motion mode angular feedrate
+          feedrate_deg_s = DPM_TO_DPS(G0_ANGULAR_FEEDRATE);                   // Get the fixed G0 angular feedrate
+        #endif
       #endif
     }
   #endif
@@ -100,6 +115,9 @@ void GcodeSuite::G0_G1(TERN_(HAS_FAST_MOVES, const bool fast_move/*=false*/)) {
   #ifdef G0_FEEDRATE
     // Restore the motion mode feedrate
     if (fast_move) feedrate_mm_s = old_feedrate;
+    #if HAS_ROTATIONAL_AXES
+      if (fast_move) feedrate_deg_s = old_angular_feedrate;
+    #endif
   #endif
 
   #if ENABLED(NANODLP_Z_SYNC)

Marlin/src/gcode/motion/G2_G3.cpp

@@ -218,7 +218,7 @@ void plan_arc(
   }
 
   // Feedrate for the move, scaled by the feedrate multiplier
-  const feedRate_t scaled_fr_mm_s = MMS_SCALED(feedrate_mm_s);
+  const feedRate_t scaled_fr_mm_s = FR_SCALED(feedrate_mm_s);
 
   // Get the ideal segment length for the move based on settings
   const float ideal_segment_mm = (

Marlin/src/gcode/motion/G5.cpp

@@ -61,7 +61,7 @@ void GcodeSuite::G5() {
       { parser.linearval('P'), parser.linearval('Q') }
     };
 
-    cubic_b_spline(current_position, destination, offsets, MMS_SCALED(feedrate_mm_s), active_extruder);
+    cubic_b_spline(current_position, destination, offsets, FR_SCALED(feedrate_mm_s), active_extruder OPTARG(HAS_ROTATIONAL_AXES, FR_SCALED(feedrate_deg_s)));
     current_position = destination;
   }
 }

Marlin/src/gcode/parser.h

@@ -331,6 +331,8 @@ class GCodeParser {
 
   #else
 
+    static float axis_unit_factor(const AxisEnum) { return 1.0f; }
+
     static constexpr float mm_to_linear_unit(const_float_t mm)     { return mm; }
     static constexpr float mm_to_volumetric_unit(const_float_t mm) { return mm; }
 

Marlin/src/gcode/probe/G38.cpp

@@ -81,6 +81,9 @@ inline bool G38_run_probe() {
       planner.synchronize();
 
       REMEMBER(fr, feedrate_mm_s, feedrate_mm_s * 0.25);
+      #if HAS_ROTATIONAL_AXES
+        REMEMBER(angular_fr, feedrate_deg_s, feedrate_deg_s * 0.25);
+      #endif
 
       // Bump the target more slowly
       destination -= retract_mm * 2;
@@ -116,7 +119,10 @@ void GcodeSuite::G38(const int8_t subcode) {
   // If any axis has enough movement, do the move
   LOOP_NUM_AXES(i)
     if (ABS(destination[i] - current_position[i]) >= G38_MINIMUM_MOVE) {
-      if (!parser.seenval('F')) feedrate_mm_s = homing_feedrate((AxisEnum)i);
+      if (!parser.seenval('F')) {
+        feedrate_mm_s = homing_feedrate((AxisEnum)i);
+        TERN_(HAS_ROTATIONAL_AXES, feedrate_deg_s = homing_feedrate((AxisEnum)i));
+      }
       // If G38.2 fails throw an error
       if (!G38_run_probe() && error_on_fail) SERIAL_ERROR_MSG("Failed to reach target");
       break;

Marlin/src/inc/Conditionals_LCD.h

@@ -506,6 +506,9 @@
 #else
   #define ROTATIONAL_AXES 0
 #endif
+#if ROTATIONAL_AXES
+  #define HAS_ROTATIONAL_AXES 1
+#endif
 
 #if ROTATIONAL_AXES
   #define HAS_ROTATIONAL_AXES 1

Marlin/src/lcd/marlinui.cpp

@@ -856,14 +856,20 @@ void MarlinUI::init() {
         // previous invocation is being blocked. Modifications to offset shouldn't be made while
         // processing is true or the planner will get out of sync.
         processing = true;
-        prepare_internal_move_to_destination(fr);  // will set current_position from destination
+        prepare_internal_move_to_destination(fr OPTARG(HAS_ROTATIONAL_AXES, fr));  // will set current_position from destination
         processing = false;
 
       #else
 
+        #if HAS_ROTATIONAL_AXES
+          PlannerHints hints;
+          hints.fr_deg_s = fr;
+        #endif
+
         // For Cartesian / Core motion simply move to the current_position
-        planner.buffer_line(current_position, fr,
-          TERN_(MULTI_E_MANUAL, axis == E_AXIS ? e_index :) active_extruder
+        planner.buffer_line(current_position, fr
+          , TERN_(MULTI_E_MANUAL, axis == E_AXIS ? e_index :) active_extruder
+          OPTARG(HAS_ROTATIONAL_AXES, hints)
         );
 
         //SERIAL_ECHOLNPGM("Add planner.move with Axis ", C(AXIS_CHAR(axis)), " at FR ", fr_mm_s);

Marlin/src/lcd/menu/menu_motion.cpp

@@ -68,7 +68,7 @@ void lcd_move_axis(const AxisEnum axis) {
       }
     #endif
 
-    // Get the new position
+    // Get the new mm / degree position
     const float diff = float(int32_t(ui.encoderPosition)) * ui.manual_move.menu_scale;
     (void)ui.manual_move.apply_diff(axis, diff, min, max);
     ui.manual_move.soon(axis);
@@ -78,7 +78,7 @@ void lcd_move_axis(const AxisEnum axis) {
   if (ui.should_draw()) {
     MenuEditItemBase::itemIndex = axis;
     const float pos = ui.manual_move.axis_value(axis);
-    if (parser.using_inch_units() && !parser.axis_is_rotational(axis)) {
+    if (parser.axis_unit_factor(axis) != 1.0f && !parser.axis_is_rotational(axis)) {
       const float imp_pos = parser.per_axis_value(axis, pos);
       MenuEditItemBase::draw_edit_screen(GET_TEXT_F(MSG_MOVE_N), ftostr63(imp_pos));
     }
@@ -163,7 +163,7 @@ void _menu_move_distance(const AxisEnum axis, const screenFunc_t func, const int
   #endif
   #define __MOVE_SUB(L,T,D) if (rotational[axis] || _LINEAR_LIMIT(D)) SUBMENU_S(F(T), L, []{ _goto_manual_move(D); })
 
-  if (rotational[axis]) {
+  if (parser.axis_is_rotational(axis)) {
     #ifdef MANUAL_MOVE_DISTANCE_DEG
       #define _MOVE_DEG(D) __MOVE_SUB(MSG_MOVE_N_DEG, STRINGIFY(D), D);
       MAP(_MOVE_DEG, MANUAL_MOVE_DISTANCE_DEG)