⛙ Merge w/Marlin

Author: classicrocker883

Marlin/Configuration_adv.h

@@ -1168,7 +1168,10 @@
   //#define FT_MOTION_MENU                      // Provide a MarlinUI menu to set M493 and M494 parameters
   //#define FTM_HOME_AND_PROBE                  // Use FT Motion for homing / probing. Disable if FT Motion breaks these functions.
 
-  #define FTM_DEFAULT_DYNFREQ_MODE dynFreqMode_DISABLED // Default mode of dynamic frequency calculation. (DISABLED, Z_BASED, MASS_BASED)
+  //#define FTM_DYNAMIC_FREQ                    // Enable for linear adjustment of XY shaping frequency according to Z or E
+  #if ENABLED(FTM_DYNAMIC_FREQ)
+    #define FTM_DEFAULT_DYNFREQ_MODE dynFreqMode_DISABLED // Default mode of dynamic frequency calculation. (DISABLED, Z_BASED, MASS_BASED)
+  #endif
 
   #define FTM_DEFAULT_SHAPER_X      ftMotionShaper_NONE // Default shaper mode on X axis (NONE, ZV, ZVD, ZVDD, ZVDDD, EI, 2HEI, 3HEI, MZV)
   #define FTM_SHAPING_DEFAULT_FREQ_X   37.0f    // (Hz) Default peak frequency used by input shapers
@@ -1225,7 +1228,6 @@
   #define FTM_BUFFER_SIZE             128   // Window size for trajectory generation, must be a power of 2 (e.g 64, 128, 256, ...)
                                             // The total buffered time in seconds is (FTM_BUFFER_SIZE/FTM_FS)
   #define FTM_FS                     1000   // (Hz) Frequency for trajectory generation.
-  #define FTM_STEPPER_FS        2'000'000   // (Hz) Time resolution of stepper I/O update. Shouldn't affect CPU much (slower board testing needed)
   #define FTM_MIN_SHAPE_FREQ           20   // (Hz) Minimum shaping frequency, lower consumes more RAM
 
 #endif // FT_MOTION

Marlin/Version.h

@@ -41,7 +41,7 @@
  * here we define this default string as the date where the latest release
  * version was tagged.
  */
-//#define STRING_DISTRIBUTION_DATE "2025-12-01"
+//#define STRING_DISTRIBUTION_DATE "2025-12-03"
 
 #define STRING_DISTRIBUTION_DATE __DATE__
 #define STRING_DISTRIBUTION_TIME __TIME__

Marlin/src/HAL/STM32/timers.h

@@ -51,7 +51,7 @@
 #define TEMP_TIMER_FREQUENCY 1000   // Temperature::isr() is expected to be called at around 1kHz
 
 /// TODO: get rid of manual rate/prescale/ticks/cycles taken for procedures in stepper.cpp
-#define STEPPER_TIMER_RATE 2000000 // 2 Mhz
+#define STEPPER_TIMER_RATE 2'000'000 // 2 Mhz
 extern uint32_t GetStepperTimerClkFreq();
 #define STEPPER_TIMER_PRESCALE (GetStepperTimerClkFreq() / (STEPPER_TIMER_RATE))
 #define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000UL)               // (MHz) Stepper Timer ticks per µs

Marlin/src/feature/e_parser.h

@@ -86,6 +86,8 @@ class EmergencyParser {
 
   static void update(State &state, const uint8_t c);
 
+  static bool isEnabled() { return enabled; }
+
 private:
   static bool enabled;
 };

Marlin/src/feature/pause.cpp

@@ -300,10 +300,10 @@ bool load_filament(const float slow_load_length/*=0*/, const float fast_load_len
           // Show "Purge More" / "Resume" menu and wait for reply
           KEEPALIVE_STATE(PAUSED_FOR_USER);
           marlin.user_resume();
+          pause_menu_response = PAUSE_RESPONSE_WAIT_FOR;
           #if ANY(HAS_MARLINUI_MENU, EXTENSIBLE_UI, DWIN_LCD_PROUI)
             ui.pause_show_message(PAUSE_MESSAGE_OPTION); // MarlinUI and MKS UI also set PAUSE_RESPONSE_WAIT_FOR
           #else
-            pause_menu_response = PAUSE_RESPONSE_WAIT_FOR;
             TERN_(SOVOL_SV06_RTS, rts.gotoPage(ID_PurgeMore_L, ID_PurgeMore_D));
           #endif
           while (pause_menu_response == PAUSE_RESPONSE_WAIT_FOR) marlin.idle_no_sleep();

Marlin/src/gcode/calibrate/G28.cpp

@@ -129,15 +129,14 @@
 #if ENABLED(Z_SAFE_HOMING)
 
   inline void home_z_safely() {
-
-    // Potentially disable Fixed-Time Motion for homing
-    TERN_(FT_MOTION, FTM_DISABLE_IN_SCOPE());
-
     DEBUG_SECTION(log_G28, "home_z_safely", DEBUGGING(LEVELING));
 
     // Disallow Z homing if X or Y homing is needed
     if (homing_needed_error(_BV(X_AXIS) | _BV(Y_AXIS))) return;
 
+    // Potentially disable Fixed-Time Motion for homing
+    TERN_(FT_MOTION, FTM_DISABLE_IN_SCOPE());
+
     sync_plan_position();
 
     /**

Marlin/src/gcode/control/M108_M112_M410.cpp

@@ -21,9 +21,6 @@
  */
 
 #include "../../inc/MarlinConfig.h"
-
-#if DISABLED(EMERGENCY_PARSER)
-
 #include "../gcode.h"
 #include "../../module/motion.h" // for quickstop_stepper
 
@@ -50,5 +47,3 @@ void GcodeSuite::M112() {
 void GcodeSuite::M410() {
   quickstop_stepper();
 }
-
-#endif // !EMERGENCY_PARSER

Marlin/src/gcode/feature/ft_motion/M493.cpp

@@ -208,12 +208,14 @@ void GcodeSuite::M493() {
   if (!parser.seen_any())
     flag.report = true;
 
+  ft_config_t &c = ftMotion.cfg;
+
   // Parse 'S' mode parameter.
   if (parser.seen('S')) {
     const bool active = parser.value_bool();
-    if (active != ftMotion.cfg.active) {
+    if (active != c.active) {
       stepper.ftMotion_syncPosition();
-      ftMotion.cfg.active = active;
+      c.active = active;
       flag.report = true;
     }
   }
@@ -228,8 +230,8 @@ void GcodeSuite::M493() {
       return;
     }
     auto set_shaper = [&](const AxisEnum axis, ftMotionShaper_t newsh) {
-      if (newsh != ftMotion.cfg.shaper[axis]) {
-        ftMotion.cfg.shaper[axis] = newsh;
+      if (newsh != c.shaper[axis]) {
+        c.shaper[axis] = newsh;
         flag.update = flag.report = true;
       }
     };
@@ -243,8 +245,8 @@ void GcodeSuite::M493() {
   // Parse 'H' Axis Synchronization parameter.
   if (parser.seenval('H')) {
     const bool enabled = parser.value_bool();
-    if (enabled != ftMotion.cfg.axis_sync_enabled) {
-      ftMotion.cfg.axis_sync_enabled = enabled;
+    if (enabled != c.axis_sync_enabled) {
+      c.axis_sync_enabled = enabled;
       flag.report = true;
     }
   }
@@ -263,30 +265,26 @@ void GcodeSuite::M493() {
             case dynFreqMode_MASS_BASED:
           #endif
           case dynFreqMode_DISABLED:
-            ftMotion.cfg.dynFreqMode = val;
+            c.dynFreqMode = val;
             flag.report = true;
             break;
           default:
             SERIAL_ECHOLN(F("?Invalid "), F("(D)ynamic Frequency Mode value."));
             break;
         }
       }
-      else {
-        SERIAL_ECHOLNPGM("?Wrong shaper for (D)ynamic Frequency Mode ", ftMotion.cfg.dynFreqMode, ".");
-      }
+      else
+        SERIAL_ECHOLNPGM("?Shaper required for (D)ynamic Frequency Mode ", c.dynFreqMode, ".");
     }
 
-    const bool modeUsesDynFreq = (
-         TERN0(HAS_DYNAMIC_FREQ_MM, ftMotion.cfg.dynFreqMode == dynFreqMode_Z_BASED)
-      || TERN0(HAS_DYNAMIC_FREQ_G,  ftMotion.cfg.dynFreqMode == dynFreqMode_MASS_BASED)
-    );
+    const bool modeUsesDynFreq = c.modeUsesDynFreq();
 
   #endif // HAS_DYNAMIC_FREQ
 
   // Frequency parameter
   const bool seenA = parser.seenval('A');
   const float baseFreqVal = seenA ? parser.value_float() : 0.0f;
-  const bool goodBaseFreq = seenA && WITHIN(baseFreqVal, FTM_MIN_SHAPE_FREQ, (FTM_FS) / 2);
+  const bool goodBaseFreq = seenA && c.goodBaseFreq(baseFreqVal);
   if (seenA && !goodBaseFreq)
     SERIAL_ECHOLN(F("?Invalid "), F("(A) Base Frequency value. ("), int(FTM_MIN_SHAPE_FREQ), C('-'), int((FTM_FS) / 2), C(')'));
 
@@ -301,14 +299,14 @@ void GcodeSuite::M493() {
   // Zeta parameter
   const bool seenI = parser.seenval('I');
   const float zetaVal = seenI ? parser.value_float() : 0.0f;
-  const bool goodZeta = seenI && WITHIN(zetaVal, 0.01f, 1.0f);
+  const bool goodZeta = seenI && c.goodZeta(zetaVal);
   if (seenI && !goodZeta)
     SERIAL_ECHOLN(F("?Invalid "), F("(I) Zeta value. (0.01-1.0)")); // Zeta out of range
 
   // Vibration Tolerance parameter
   const bool seenQ = parser.seenval('Q');
   const float vtolVal = seenQ ? parser.value_float() : 0.0f;
-  const bool goodVtol = seenQ && WITHIN(vtolVal, 0.00f, 1.0f);
+  const bool goodVtol = seenQ && c.goodVtol(vtolVal);
   if (seenQ && !goodVtol)
     SERIAL_ECHOLN(F("?Invalid "), F("(Q) Vibration Tolerance value. (0.0-1.0)")); // VTol out of range
 
@@ -323,18 +321,18 @@ void GcodeSuite::M493() {
         if (AXIS_IS_SHAPING(X)) {
           // TODO: Frequency minimum is dependent on the shaper used; the above check isn't always correct.
           if (goodBaseFreq) {
-            ftMotion.cfg.baseFreq.x = baseFreqVal;
+            c.baseFreq.x = baseFreqVal;
             flag.update = flag.report = true;
           }
         }
         else // Mode doesn't use frequency.
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_A_NAME), " [A] frequency.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_A_NAME), " (A) frequency.");
       }
 
       #if HAS_DYNAMIC_FREQ
         // Parse X frequency scaling parameter
         if (seenF && modeUsesDynFreq) {
-          ftMotion.cfg.dynFreqK.x = baseDynFreqVal;
+          c.dynFreqK.x = baseDynFreqVal;
           flag.report = true;
         }
       #endif
@@ -343,24 +341,24 @@ void GcodeSuite::M493() {
       if (seenI) {
         if (AXIS_IS_SHAPING(X)) {
           if (goodZeta) {
-            ftMotion.cfg.zeta.x = zetaVal;
+            c.zeta.x = zetaVal;
             flag.update = true;
           }
         }
         else
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_A_NAME), " zeta parameter.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_A_NAME), " (I) zeta parameter.");
       }
 
       // Parse X vtol parameter
       if (seenQ) {
         if (AXIS_IS_EISHAPING(X)) {
           if (goodVtol) {
-            ftMotion.cfg.vtol.x = vtolVal;
+            c.vtol.x = vtolVal;
             flag.update = true;
           }
         }
         else
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_A_NAME), " vtol parameter.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_A_NAME), " (Q) vtol parameter.");
       }
     }
 
@@ -374,18 +372,18 @@ void GcodeSuite::M493() {
       if (seenA) {
         if (AXIS_IS_SHAPING(Y)) {
           if (goodBaseFreq) {
-            ftMotion.cfg.baseFreq.y = baseFreqVal;
+            c.baseFreq.y = baseFreqVal;
             flag.update = flag.report = true;
           }
         }
         else // Mode doesn't use frequency.
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_B_NAME), " [A] frequency.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_B_NAME), " (A) frequency.");
       }
 
       #if HAS_DYNAMIC_FREQ
         // Parse Y frequency scaling parameter
         if (seenF && modeUsesDynFreq) {
-          ftMotion.cfg.dynFreqK.y = baseDynFreqVal;
+          c.dynFreqK.y = baseDynFreqVal;
           flag.report = true;
         }
       #endif
@@ -394,24 +392,24 @@ void GcodeSuite::M493() {
       if (seenI) {
         if (AXIS_IS_SHAPING(Y)) {
           if (goodZeta) {
-            ftMotion.cfg.zeta.y = zetaVal;
+            c.zeta.y = zetaVal;
             flag.update = true;
           }
         }
         else
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_B_NAME), " zeta parameter.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_B_NAME), " (I) zeta parameter.");
       }
 
       // Parse Y vtol parameter
       if (seenQ) {
         if (AXIS_IS_EISHAPING(Y)) {
           if (goodVtol) {
-            ftMotion.cfg.vtol.y = vtolVal;
+            c.vtol.y = vtolVal;
             flag.update = true;
           }
         }
         else
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_B_NAME), " vtol parameter.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_B_NAME), " (Q) vtol parameter.");
       }
     }
 
@@ -425,18 +423,18 @@ void GcodeSuite::M493() {
       if (seenA) {
         if (AXIS_IS_SHAPING(Z)) {
           if (goodBaseFreq) {
-            ftMotion.cfg.baseFreq.z = baseFreqVal;
+            c.baseFreq.z = baseFreqVal;
             flag.update = flag.report = true;
           }
         }
         else // Mode doesn't use frequency.
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_C_NAME), " [A] frequency.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_C_NAME), " (A) frequency.");
       }
 
       #if HAS_DYNAMIC_FREQ
         // Parse Z frequency scaling parameter
         if (seenF && modeUsesDynFreq) {
-          ftMotion.cfg.dynFreqK.z = baseDynFreqVal;
+          c.dynFreqK.z = baseDynFreqVal;
           flag.report = true;
         }
       #endif
@@ -445,24 +443,24 @@ void GcodeSuite::M493() {
       if (seenI) {
         if (AXIS_IS_SHAPING(Z)) {
           if (goodZeta) {
-            ftMotion.cfg.zeta.z = zetaVal;
+            c.zeta.z = zetaVal;
             flag.update = true;
           }
         }
         else
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_C_NAME), " zeta parameter.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_C_NAME), " (I) zeta parameter.");
       }
 
       // Parse Z vtol parameter
       if (seenQ) {
         if (AXIS_IS_EISHAPING(Z)) {
           if (goodVtol) {
-            ftMotion.cfg.vtol.z = vtolVal;
+            c.vtol.z = vtolVal;
             flag.update = true;
           }
         }
         else
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_C_NAME), " vtol parameter.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C(STEPPER_C_NAME), " (Q) vtol parameter.");
       }
     }
 
@@ -476,18 +474,18 @@ void GcodeSuite::M493() {
       if (seenA) {
         if (AXIS_IS_SHAPING(E)) {
           if (goodBaseFreq) {
-            ftMotion.cfg.baseFreq.e = baseFreqVal;
+            c.baseFreq.e = baseFreqVal;
             flag.update = flag.report = true;
           }
         }
         else // Mode doesn't use frequency.
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C('E'), " [A] frequency.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C('E'), " (A) frequency.");
       }
 
       #if HAS_DYNAMIC_FREQ
         // Parse E frequency scaling parameter
         if (seenF && modeUsesDynFreq) {
-          ftMotion.cfg.dynFreqK.e = baseDynFreqVal;
+          c.dynFreqK.e = baseDynFreqVal;
           flag.report = true;
         }
       #endif
@@ -496,24 +494,24 @@ void GcodeSuite::M493() {
       if (seenI) {
         if (AXIS_IS_SHAPING(E)) {
           if (goodZeta) {
-            ftMotion.cfg.zeta.e = zetaVal;
+            c.zeta.e = zetaVal;
             flag.update = true;
           }
         }
         else
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C('E'), " zeta parameter.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C('E'), " (I) zeta parameter.");
       }
 
       // Parse E vtol parameter
       if (seenQ) {
         if (AXIS_IS_EISHAPING(E)) {
           if (goodVtol) {
-            ftMotion.cfg.vtol.e = vtolVal;
+            c.vtol.e = vtolVal;
             flag.update = true;
           }
         }
         else
-          SERIAL_ECHOLNPGM("?Wrong mode for ", C('E'), " vtol parameter.");
+          SERIAL_ECHOLNPGM("?Wrong mode for ", C('E'), " (Q) vtol parameter.");
       }
     }