chmod script

Marlin/Configuration.h

@@ -1768,71 +1768,57 @@
  * Marlin knows a print job is running when:
  *  1. Running a print job from media started with M24.
  *  2. The Print Job Timer has been started with M75.
- *  3. The heaters were turned on and PRINTJOB_TIMER_AUTOSTART is enabled.
+ *  3. The heaters were turned on with a wait command (M109) and PRINTJOB_TIMER_AUTOSTART is enabled.
  *
  * RAMPS-based boards use SERVO3_PIN for the first runout sensor.
  * For other boards you may need to define FIL_RUNOUT_PIN, FIL_RUNOUT2_PIN, etc.
  */
 //#define FILAMENT_RUNOUT_SENSOR
 #if ENABLED(FILAMENT_RUNOUT_SENSOR)
-  #define FIL_RUNOUT_ENABLED_DEFAULT true // Enable the sensor on startup. Override with M412 followed by M500.
+  //#define NUM_RUNOUT_SENSORS 1      // Number of sensors, up to one per extruder. Define a FIL_RUNOUT#_PIN for each.
-  #define NUM_RUNOUT_SENSORS   1          // Number of sensors, up to one per extruder. Define a FIL_RUNOUT#_PIN for each.
+  #define FIL_RUNOUT_ENABLED { true } // Default enabled state for sensors E0[, E1[, E2[, E3...]]]. Override with M591EnnSn followed by M500.
-
+  #define FIL_RUNOUT_MODE    { 1 }    // Default mode for sensors E0[, E1[, E2[, E3...]]]. 0:NONE  1:Switch NO  2:Switch NC  7:Motion Sensor Override with M591EnPnn
-  #define FIL_RUNOUT_STATE     LOW        // Pin state indicating that filament is NOT present.
+  //#define WATCH_ALL_RUNOUT_SENSORS  // Execute runout script on any triggering sensor, not only for the active extruder.
-  #define FIL_RUNOUT_PULLUP               // Use internal pullup for filament runout pins.
+                                      // This is automatically enabled for MIXING_EXTRUDERs.
-  //#define FIL_RUNOUT_PULLDOWN           // Use internal pulldown for filament runout pins.
-  //#define WATCH_ALL_RUNOUT_SENSORS      // Execute runout script on any triggering sensor, not only for the active extruder.
-                                          // This is automatically enabled for MIXING_EXTRUDERs.
-
-  // Override individually if the runout sensors vary
-  //#define FIL_RUNOUT1_STATE LOW
-  //#define FIL_RUNOUT1_PULLUP
-  //#define FIL_RUNOUT1_PULLDOWN
-
-  //#define FIL_RUNOUT2_STATE LOW
-  //#define FIL_RUNOUT2_PULLUP
-  //#define FIL_RUNOUT2_PULLDOWN
-
-  //#define FIL_RUNOUT3_STATE LOW
-  //#define FIL_RUNOUT3_PULLUP
-  //#define FIL_RUNOUT3_PULLDOWN
-
-  //#define FIL_RUNOUT4_STATE LOW
-  //#define FIL_RUNOUT4_PULLUP
-  //#define FIL_RUNOUT4_PULLDOWN
-
-  //#define FIL_RUNOUT5_STATE LOW
-  //#define FIL_RUNOUT5_PULLUP
-  //#define FIL_RUNOUT5_PULLDOWN
-
-  //#define FIL_RUNOUT6_STATE LOW
-  //#define FIL_RUNOUT6_PULLUP
-  //#define FIL_RUNOUT6_PULLDOWN
-
-  //#define FIL_RUNOUT7_STATE LOW
-  //#define FIL_RUNOUT7_PULLUP
-  //#define FIL_RUNOUT7_PULLDOWN
-
-  //#define FIL_RUNOUT8_STATE LOW
-  //#define FIL_RUNOUT8_PULLUP
-  //#define FIL_RUNOUT8_PULLDOWN
 
   // Commands to execute on filament runout.
   // With multiple runout sensors use the %c placeholder for the current tool in commands (e.g., "M600 T%c")
-  // NOTE: After 'M412 H1' the host handles filament runout and this script does not apply.
+  // NOTE: After 'M591 H1' the host handles filament runout and this script does not apply.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 
-  // After a runout is detected, continue printing this length of filament
+  // In Mode 1 or 2, continue printing this length of filament after a run out occurs before executing the
-  // before executing the runout script. Useful for a sensor at the end of
+  // runout script. Useful for a sensor at the end of a feed tube or debounce on a flakey sensor.
-  // a feed tube. Requires 4 bytes SRAM per sensor, plus 4 bytes overhead.
+  // In Mode 7, extrusion distance to expect a change of state.
-  //#define FILAMENT_RUNOUT_DISTANCE_MM 25
+  // Override with M591EnLnn
+  #define FIL_RUNOUT_DISTANCE_MM { 15 }
 
-  #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+  #define FIL_RUNOUT_PULLUP           // Use internal pullup for filament runout pins.
-    // Enable this option to use an encoder disc that toggles the runout pin
+  //#define FIL_RUNOUT_PULLDOWN       // Use internal pulldown for filament runout pins.
-    // as the filament moves. (Be sure to set FILAMENT_RUNOUT_DISTANCE_MM
+
-    // large enough to avoid false positives.)
+  // Override individually if the runout sensors vary
-    //#define FILAMENT_MOTION_SENSOR
+  //#define FIL_RUNOUT1_PULLUP
-  #endif
+  //#define FIL_RUNOUT1_PULLDOWN
+
+  //#define FIL_RUNOUT2_PULLUP
+  //#define FIL_RUNOUT2_PULLDOWN
+
+  //#define FIL_RUNOUT3_PULLUP
+  //#define FIL_RUNOUT3_PULLDOWN
+
+  //#define FIL_RUNOUT4_PULLUP
+  //#define FIL_RUNOUT4_PULLDOWN
+
+  //#define FIL_RUNOUT5_PULLUP
+  //#define FIL_RUNOUT5_PULLDOWN
+
+  //#define FIL_RUNOUT6_PULLUP
+  //#define FIL_RUNOUT6_PULLDOWN
+
+  //#define FIL_RUNOUT7_PULLUP
+  //#define FIL_RUNOUT7_PULLDOWN
+
+  //#define FIL_RUNOUT8_PULLUP
+  //#define FIL_RUNOUT8_PULLDOWN
 #endif
 
 //===========================================================================

Marlin/src/feature/host_actions.cpp

@@ -198,7 +198,7 @@ void HostUI::action(FSTR_P const fstr, const bool eol) {
             #endif
             #if HAS_FILAMENT_SENSOR
               if (runout.filament_ran_out) {                      // Disable a triggered sensor
-                runout.enabled = false;
+                runout.enabled[active_extruder] = false;
                 runout.reset();
               }
             #endif

Marlin/src/feature/mmu/mmu2.cpp

@@ -141,7 +141,7 @@ uint8_t MMU2::get_current_tool() {
 }
 
 #if EITHER(HAS_PRUSA_MMU2S, MMU_EXTRUDER_SENSOR)
-  #define FILAMENT_PRESENT() (READ(FIL_RUNOUT1_PIN) != FIL_RUNOUT1_STATE)
+  #define FILAMENT_PRESENT() (READ(FIL_RUNOUT1_PIN) != runout.out_state())
 #endif
 
 void mmu2_attn_buzz(const bool two=false) {

Marlin/src/feature/pause.cpp

@@ -211,13 +211,22 @@ bool load_filament(const_float_t slow_load_length/*=0*/, const_float_t fast_load
     while (wait_for_user) {
       impatient_beep(max_beep_count);
       #if BOTH(FILAMENT_CHANGE_RESUME_ON_INSERT, FILAMENT_RUNOUT_SENSOR)
-        #if ENABLED(MULTI_FILAMENT_SENSOR)
+        #if MULTI_FILAMENT_SENSOR
-          #define _CASE_INSERTED(N) case N-1: if (READ(FIL_RUNOUT##N##_PIN) != FIL_RUNOUT##N##_STATE) wait_for_user = false; break;
+          LOOP_S_LE_N(i, 1, NUM_RUNOUT_SENSORS) {
-          switch (active_extruder) {
+            pin_t pin;
-            REPEAT_1(NUM_RUNOUT_SENSORS, _CASE_INSERTED)
+            switch (i) {
+              default: continue;
+              #define _CASE_RUNOUT(N) case N: pin = FIL_RUNOUT##N##_PIN; break;
+              REPEAT_1(NUM_RUNOUT_SENSORS, _CASE_RUNOUT)
+              #undef _CASE_RUNOUT
+            }
+            const RunoutMode rm = runout.mode[i - 1];
+            if (rm != RM_NONE && rm != RM_MOTION_SENSOR && extDigitalRead(pin) != runout.out_state(i - 1))
+              wait_for_user = false;
           }
         #else
-          if (READ(FIL_RUNOUT_PIN) != FIL_RUNOUT_STATE) wait_for_user = false;
+          if (READ(FIL_RUNOUT_PIN) != runout.out_state(active_extruder))
+            wait_for_user = false;
         #endif
       #endif
       idle_no_sleep();

Marlin/src/feature/runout.cpp

@@ -32,9 +32,9 @@
 
 FilamentMonitor runout;
 
-bool FilamentMonitorBase::enabled = true,
+bool FilamentMonitorBase::enabled[NUM_RUNOUT_SENSORS], // Initialized by settings.load
-     FilamentMonitorBase::filament_ran_out;  // = false
+     FilamentMonitorBase::filament_ran_out; // = false
-
+RunoutMode FilamentMonitorBase::mode[NUM_RUNOUT_SENSORS]; // Initialized by settings.load
 #if ENABLED(HOST_ACTION_COMMANDS)
   bool FilamentMonitorBase::host_handling; // = false
 #endif
@@ -45,15 +45,9 @@ bool FilamentMonitorBase::enabled = true,
   #include "../core/debug_out.h"
 #endif
 
-#if HAS_FILAMENT_RUNOUT_DISTANCE
+float RunoutResponseDelayed::runout_distance_mm[NUM_RUNOUT_SENSORS]; // Initialized by settings.load
-  float RunoutResponseDelayed::runout_distance_mm = FILAMENT_RUNOUT_DISTANCE_MM;
+volatile float RunoutResponseDelayed::runout_mm_countdown[NUM_RUNOUT_SENSORS];
-  volatile float RunoutResponseDelayed::runout_mm_countdown[NUM_RUNOUT_SENSORS];
+uint8_t FilamentSensorCore::motion_detected;
-  #if ENABLED(FILAMENT_MOTION_SENSOR)
-    uint8_t FilamentSensorEncoder::motion_detected;
-  #endif
-#else
-  int8_t RunoutResponseDebounced::runout_count[NUM_RUNOUT_SENSORS]; // = 0
-#endif
 
 //
 // Filament Runout event handler

Marlin/src/feature/runout.h

@@ -47,25 +47,37 @@ void event_filament_runout(const uint8_t extruder);
 
 template<class RESPONSE_T, class SENSOR_T>
 class TFilamentMonitor;
-class FilamentSensorEncoder;
+class FilamentSensorCore;
-class FilamentSensorSwitch;
 class RunoutResponseDelayed;
-class RunoutResponseDebounced;
 
 /********************************* TEMPLATE SPECIALIZATION *********************************/
 
 typedef TFilamentMonitor<
-          TERN(HAS_FILAMENT_RUNOUT_DISTANCE, RunoutResponseDelayed, RunoutResponseDebounced),
+          RunoutResponseDelayed,
-          TERN(FILAMENT_MOTION_SENSOR, FilamentSensorEncoder, FilamentSensorSwitch)
+          FilamentSensorCore
         > FilamentMonitor;
 
 extern FilamentMonitor runout;
 
 /*******************************************************************************************/
 
+enum RunoutMode : uint8_t {
+  RM_NONE,
+  RM_OUT_ON_LOW,
+  RM_OUT_ON_HIGH,
+  RM_RESERVED3,
+  RM_RESERVED4,
+  RM_RESERVED5,
+  RM_RESERVED6,
+  RM_MOTION_SENSOR
+};
+
 class FilamentMonitorBase {
   public:
-    static bool enabled, filament_ran_out;
+    static bool enabled[NUM_RUNOUT_SENSORS], filament_ran_out;
+    static RunoutMode mode[NUM_RUNOUT_SENSORS];
+
+    static uint8_t out_state(const uint8_t e=0) { return mode[e] == RM_OUT_ON_HIGH ? HIGH : LOW; }
 
     #if ENABLED(HOST_ACTION_COMMANDS)
       static bool host_handling;
@@ -95,19 +107,14 @@ class TFilamentMonitor : public FilamentMonitorBase {
 
     // Call this method when filament is present,
     // so the response can reset its counter.
-    static void filament_present(const uint8_t extruder) {
+    static void filament_present(const uint8_t e) { response.filament_present(e); }
-      response.filament_present(extruder);
+    static float& runout_distance(const uint8_t e=0) { return response.runout_distance_mm[e]; }
-    }
+    static void set_runout_distance(const_float_t mm, const uint8_t e=0) { response.runout_distance_mm[e] = mm; }
-
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      static float& runout_distance() { return response.runout_distance_mm; }
-      static void set_runout_distance(const_float_t mm) { response.runout_distance_mm = mm; }
-    #endif
 
     // Handle a block completion. RunoutResponseDelayed uses this to
     // add up the length of filament moved while the filament is out.
     static void block_completed(const block_t * const b) {
-      if (enabled) {
+      if (enabled[active_extruder]) {
         response.block_completed(b);
         sensor.block_completed(b);
       }
@@ -115,12 +122,12 @@ class TFilamentMonitor : public FilamentMonitorBase {
 
     // Give the response a chance to update its counter.
     static void run() {
-      if (enabled && !filament_ran_out && (printingIsActive() || did_pause_print)) {
+      if (enabled[active_extruder] && mode[active_extruder] != RM_NONE && !filament_ran_out && (printingIsActive() || did_pause_print)) {
-        TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, cli()); // Prevent RunoutResponseDelayed::block_completed from accumulating here
+        cli(); // Prevent RunoutResponseDelayed::block_completed from accumulating here
         response.run();
         sensor.run();
         const uint8_t runout_flags = response.has_run_out();
-        TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, sei());
+        sei();
         #if MULTI_FILAMENT_SENSOR
           #if ENABLED(WATCH_ALL_RUNOUT_SENSORS)
             const bool ran_out = !!runout_flags;  // any sensor triggers
@@ -213,103 +220,64 @@ class FilamentSensorBase {
 
     // Return a bitmask of runout flag states (1 bits always indicates runout)
     static uint8_t poll_runout_states() {
-      return poll_runout_pins() ^ uint8_t(0
+      #define _OR_INVERT(N) | (runout.out_state((N) - 1) ? 0 : _BV((N) - 1))
-        #if NUM_RUNOUT_SENSORS >= 1
+      return poll_runout_pins() ^ uint8_t(0 REPEAT_1(NUM_RUNOUT_SENSORS, _OR_INVERT));
-          | (FIL_RUNOUT1_STATE ? 0 : _BV(1 - 1))
+      #undef _OR_INVERT
-        #endif
-        #if NUM_RUNOUT_SENSORS >= 2
-          | (FIL_RUNOUT2_STATE ? 0 : _BV(2 - 1))
-        #endif
-        #if NUM_RUNOUT_SENSORS >= 3
-          | (FIL_RUNOUT3_STATE ? 0 : _BV(3 - 1))
-        #endif
-        #if NUM_RUNOUT_SENSORS >= 4
-          | (FIL_RUNOUT4_STATE ? 0 : _BV(4 - 1))
-        #endif
-        #if NUM_RUNOUT_SENSORS >= 5
-          | (FIL_RUNOUT5_STATE ? 0 : _BV(5 - 1))
-        #endif
-        #if NUM_RUNOUT_SENSORS >= 6
-          | (FIL_RUNOUT6_STATE ? 0 : _BV(6 - 1))
-        #endif
-        #if NUM_RUNOUT_SENSORS >= 7
-          | (FIL_RUNOUT7_STATE ? 0 : _BV(7 - 1))
-        #endif
-        #if NUM_RUNOUT_SENSORS >= 8
-          | (FIL_RUNOUT8_STATE ? 0 : _BV(8 - 1))
-        #endif
-      );
     }
 };
 
-#if ENABLED(FILAMENT_MOTION_SENSOR)
+class FilamentSensorCore : public FilamentSensorBase {
+  private:
+    static uint8_t motion_detected;
 
-  /**
+    static bool poll_runout_state(const uint8_t extruder) {
-   * This sensor uses a magnetic encoder disc and a Hall effect
+      const uint8_t runout_states = poll_runout_states();
-   * sensor (or a slotted disc and optical sensor). The state
+      #if MULTI_FILAMENT_SENSOR
-   * will toggle between 0 and 1 on filament movement. It can detect
+        if ( !TERN0(DUAL_X_CARRIAGE, idex_is_duplicating())
-   * filament runout and stripouts or jams.
+          && !TERN0(MULTI_NOZZLE_DUPLICATION, extruder_duplication_enabled)
-   */
+        ) return TEST(runout_states, extruder); // A specific extruder ran out
-  class FilamentSensorEncoder : public FilamentSensorBase {
+      #else
-    private:
+        UNUSED(extruder);
-      static uint8_t motion_detected;
+      #endif
+      return !!runout_states;                   // Any extruder ran out
+    }
 
-      static void poll_motion_sensor() {
+    static void poll_motion_sensor() {
-        static uint8_t old_state;
+      static uint8_t old_state;
-        const uint8_t new_state = poll_runout_pins(),
+      const uint8_t new_state = poll_runout_pins(),
-                      change    = old_state ^ new_state;
+                    change    = old_state ^ new_state;
-        old_state = new_state;
+      old_state = new_state;
 
-        #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
+      #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
-          if (change) {
+        if (change) {
-            SERIAL_ECHOPGM("Motion detected:");
+          SERIAL_ECHOPGM("Motion detected:");
-            LOOP_L_N(e, NUM_RUNOUT_SENSORS)
+          LOOP_L_N(e, NUM_RUNOUT_SENSORS)
-              if (TEST(change, e)) SERIAL_CHAR(' ', '0' + e);
+            if (TEST(change, e)) SERIAL_CHAR(' ', '0' + e);
-            SERIAL_EOL();
+          SERIAL_EOL();
-          }
+        }
-        #endif
+      #endif
 
-        motion_detected |= change;
+      motion_detected |= change;
+    }
+
+  public:
+    static void block_completed(const block_t * const b) {
+      if (runout.mode[active_extruder] != RM_MOTION_SENSOR) return;
+
+      // If the sensor wheel has moved since the last call to
+      // this method reset the runout counter for the extruder.
+      if (TEST(motion_detected, b->extruder))
+        filament_present(b->extruder);
+
+      // Clear motion triggers for next block
+      motion_detected = 0;
+    }
+
+    static void run() {
+      if (runout.mode[active_extruder] == RM_MOTION_SENSOR) {
+        poll_motion_sensor();
       }
-
+      else if (runout.mode[active_extruder] != RM_NONE) {
-    public:
-      static void block_completed(const block_t * const b) {
-        // If the sensor wheel has moved since the last call to
-        // this method reset the runout counter for the extruder.
-        if (TEST(motion_detected, b->extruder))
-          filament_present(b->extruder);
-
-        // Clear motion triggers for next block
-        motion_detected = 0;
-      }
-
-      static void run() { poll_motion_sensor(); }
-  };
-
-#else
-
-  /**
-   * This is a simple endstop switch in the path of the filament.
-   * It can detect filament runout, but not stripouts or jams.
-   */
-  class FilamentSensorSwitch : public FilamentSensorBase {
-    private:
-      static bool poll_runout_state(const uint8_t extruder) {
-        const uint8_t runout_states = poll_runout_states();
-        #if MULTI_FILAMENT_SENSOR
-          if ( !TERN0(DUAL_X_CARRIAGE, idex_is_duplicating())
-            && !TERN0(MULTI_NOZZLE_DUPLICATION, extruder_duplication_enabled)
-          ) return TEST(runout_states, extruder); // A specific extruder ran out
-        #else
-          UNUSED(extruder);
-        #endif
-        return !!runout_states;                   // Any extruder ran out
-      }
-
-    public:
-      static void block_completed(const block_t * const) {}
-
-      static void run() {
         LOOP_L_N(s, NUM_RUNOUT_SENSORS) {
           const bool out = poll_runout_state(s);
           if (!out) filament_present(s);
@@ -322,92 +290,55 @@ class FilamentSensorBase {
           #endif
         }
       }
-  };
+    }
+};
 
 
-#endif // !FILAMENT_MOTION_SENSOR
-
 /********************************* RESPONSE TYPE *********************************/
 
-#if HAS_FILAMENT_RUNOUT_DISTANCE
+// RunoutResponseDelayed triggers a runout event only if the length
+// of filament specified by FIL_RUNOUT_DISTANCE_MM has been fed
+// during a runout condition.
+class RunoutResponseDelayed {
+  private:
+    static volatile float runout_mm_countdown[NUM_RUNOUT_SENSORS];
 
-  // RunoutResponseDelayed triggers a runout event only if the length
+  public:
-  // of filament specified by FILAMENT_RUNOUT_DISTANCE_MM has been fed
+    static float runout_distance_mm[NUM_RUNOUT_SENSORS];
-  // during a runout condition.
-  class RunoutResponseDelayed {
-    private:
-      static volatile float runout_mm_countdown[NUM_RUNOUT_SENSORS];
 
-    public:
+    static void reset() {
-      static float runout_distance_mm;
+      LOOP_L_N(i, NUM_RUNOUT_SENSORS) filament_present(i);
+    }
 
-      static void reset() {
+    static void run() {
-        LOOP_L_N(i, NUM_RUNOUT_SENSORS) filament_present(i);
+      #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
-      }
+        static millis_t t = 0;
-
+        const millis_t ms = millis();
-      static void run() {
+        if (ELAPSED(ms, t)) {
-        #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
+          t = millis() + 1000UL;
-          static millis_t t = 0;
+          LOOP_L_N(i, NUM_RUNOUT_SENSORS)
-          const millis_t ms = millis();
+            SERIAL_ECHOF(i ? F(", ") : F("Remaining mm: "), runout_mm_countdown[i]);
-          if (ELAPSED(ms, t)) {
+          SERIAL_EOL();
-            t = millis() + 1000UL;
-            LOOP_L_N(i, NUM_RUNOUT_SENSORS)
-              SERIAL_ECHOF(i ? F(", ") : F("Remaining mm: "), runout_mm_countdown[i]);
-            SERIAL_EOL();
-          }
-        #endif
-      }
-
-      static uint8_t has_run_out() {
-        uint8_t runout_flags = 0;
-        LOOP_L_N(i, NUM_RUNOUT_SENSORS) if (runout_mm_countdown[i] < 0) SBI(runout_flags, i);
-        return runout_flags;
-      }
-
-      static void filament_present(const uint8_t extruder) {
-        runout_mm_countdown[extruder] = runout_distance_mm;
-      }
-
-      static void block_completed(const block_t * const b) {
-        if (b->steps.x || b->steps.y || b->steps.z || did_pause_print) { // Allow pause purge move to re-trigger runout state
-          // Only trigger on extrusion with XYZ movement to allow filament change and retract/recover.
-          const uint8_t e = b->extruder;
-          const int32_t steps = b->steps.e;
-          runout_mm_countdown[e] -= (TEST(b->direction_bits, E_AXIS) ? -steps : steps) * planner.mm_per_step[E_AXIS_N(e)];
         }
+      #endif
+    }
+
+    static uint8_t has_run_out() {
+      uint8_t runout_flags = 0;
+      LOOP_L_N(i, NUM_RUNOUT_SENSORS) if (runout_mm_countdown[i] < 0) SBI(runout_flags, i);
+      return runout_flags;
+    }
+
+    static void filament_present(const uint8_t extruder) {
+      runout_mm_countdown[extruder] = runout_distance_mm[extruder];
+    }
+
+    static void block_completed(const block_t * const b) {
+      if (b->steps.x || b->steps.y || b->steps.z || did_pause_print) { // Allow pause purge move to re-trigger runout state
+        // Only trigger on extrusion with XYZ movement to allow filament change and retract/recover.
+        const uint8_t e = b->extruder;
+        const int32_t steps = b->steps.e;
+        runout_mm_countdown[e] -= (TEST(b->direction_bits, E_AXIS) ? -steps : steps) * planner.mm_per_step[E_AXIS_N(e)];
       }
-  };
+    }
-
+};
-#else // !HAS_FILAMENT_RUNOUT_DISTANCE
-
-  // RunoutResponseDebounced triggers a runout event after a runout
-  // condition has been detected runout_threshold times in a row.
-
-  class RunoutResponseDebounced {
-    private:
-      static constexpr int8_t runout_threshold = FILAMENT_RUNOUT_THRESHOLD;
-      static int8_t runout_count[NUM_RUNOUT_SENSORS];
-
-    public:
-      static void reset() {
-        LOOP_L_N(i, NUM_RUNOUT_SENSORS) filament_present(i);
-      }
-
-      static void run() {
-        LOOP_L_N(i, NUM_RUNOUT_SENSORS) if (runout_count[i] >= 0) runout_count[i]--;
-      }
-
-      static uint8_t has_run_out() {
-        uint8_t runout_flags = 0;
-        LOOP_L_N(i, NUM_RUNOUT_SENSORS) if (runout_count[i] < 0) SBI(runout_flags, i);
-        return runout_flags;
-      }
-
-      static void block_completed(const block_t * const) { }
-
-      static void filament_present(const uint8_t extruder) {
-        runout_count[extruder] = runout_threshold;
-      }
-  };
-
-#endif // !HAS_FILAMENT_RUNOUT_DISTANCE

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

@@ -94,7 +94,7 @@ void GcodeSuite::M600() {
                                    // In this case, for duplicating modes set DXC_ext to the extruder that ran out.
       #if MULTI_FILAMENT_SENSOR
         if (idex_is_duplicating())
-          DXC_ext = (READ(FIL_RUNOUT2_PIN) == FIL_RUNOUT2_STATE) ? 1 : 0;
+          DXC_ext = (READ(FIL_RUNOUT2_PIN) == runout.out_state(1)) ? 1 : 0;
       #else
         DXC_ext = active_extruder;
       #endif

Marlin/src/gcode/feature/runout/M412.cpp

@@ -1,81 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-
-#include "../../../inc/MarlinConfig.h"
-
-#if HAS_FILAMENT_SENSOR
-
-#include "../../gcode.h"
-#include "../../../feature/runout.h"
-
-/**
- * M412: Enable / Disable filament runout detection
- *
- * Parameters
- *  R         : Reset the runout sensor
- *  S<bool>   : Reset and enable/disable the runout sensor
- *  H<bool>   : Enable/disable host handling of filament runout
- *  D<linear> : Extra distance to continue after runout is triggered
- */
-void GcodeSuite::M412() {
-  if (parser.seen("RS"
-    TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, "D")
-    TERN_(HOST_ACTION_COMMANDS, "H")
-  )) {
-    #if ENABLED(HOST_ACTION_COMMANDS)
-      if (parser.seen('H')) runout.host_handling = parser.value_bool();
-    #endif
-    const bool seenR = parser.seen_test('R'), seenS = parser.seen('S');
-    if (seenR || seenS) runout.reset();
-    if (seenS) runout.enabled = parser.value_bool();
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      if (parser.seenval('D')) runout.set_runout_distance(parser.value_linear_units());
-    #endif
-  }
-  else {
-    SERIAL_ECHO_START();
-    SERIAL_ECHOPGM("Filament runout ");
-    serialprint_onoff(runout.enabled);
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      SERIAL_ECHOPGM(" ; Distance ", runout.runout_distance(), "mm");
-    #endif
-    #if ENABLED(HOST_ACTION_COMMANDS)
-      SERIAL_ECHOPGM(" ; Host handling ");
-      serialprint_onoff(runout.host_handling);
-    #endif
-    SERIAL_EOL();
-  }
-}
-
-void GcodeSuite::M412_report(const bool forReplay/*=true*/) {
-  report_heading_etc(forReplay, F(STR_FILAMENT_RUNOUT_SENSOR));
-  SERIAL_ECHOPGM(
-    "  M412 S", runout.enabled
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      , " D", LINEAR_UNIT(runout.runout_distance())
-    #endif
-    , " ; Sensor "
-  );
-  serialprintln_onoff(runout.enabled);
-}
-
-#endif // HAS_FILAMENT_SENSOR

Marlin/src/gcode/feature/runout/M591.cpp

@@ -0,0 +1,97 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2022 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../../inc/MarlinConfig.h"
+
+#if HAS_FILAMENT_SENSOR
+
+#include "../../gcode.h"
+#include "../../../feature/runout.h"
+
+/**
+ * M591: Configure filament runout detection
+ *
+ * Parameters
+ *  R         : Reset the runout sensor
+ *  S<bool>   : Reset and enable/disable the runout sensor
+ *  H<bool>   : Enable/disable host handling of filament runout
+ *  L<linear> : Extra distance to continue after runout is triggered or motion interval
+ *  D<linear> : Alias for L
+ *  P<index>  : Mode 0 = NONE
+ *                   1 = Switch NO (HIGH = filament present)
+ *                   2 = Switch NC (LOW = filament present)
+ *                   3 = Encoder / Motion Sensor
+ */
+void GcodeSuite::M591() {
+  if (parser.seen("RSDP" TERN_(HOST_ACTION_COMMANDS, "H"))) {
+    #if ENABLED(HOST_ACTION_COMMANDS)
+      if (parser.seen('H')) runout.host_handling = parser.value_bool();
+    #endif
+    const bool seenR = parser.seen_test('R'), seenS = parser.seen('S');
+    if (seenR || seenS) runout.reset();
+    const uint8_t tool = TERN0(MULTI_FILAMENT_SENSOR, parser.ushortval('E', active_extruder));
+    if (seenS) runout.enabled[tool] = parser.value_bool();
+    if (parser.seenval('D') || parser.seenval('L')) runout.set_runout_distance(parser.value_linear_units(), tool);
+    if (parser.seenval('P')) {
+      const RunoutMode tmp_mode = (RunoutMode)parser.value_int();
+      switch (tmp_mode) {
+        case RM_NONE ... RM_OUT_ON_HIGH:
+        case RM_MOTION_SENSOR:
+          runout.mode[tool] = tmp_mode;
+          runout.setup();
+        default: break;
+      }
+    }
+  }
+  else {
+    #if DISABLED(SLIM_LCD_MENUS)
+      SERIAL_ECHO_START();
+      SERIAL_ECHOPGM("Filament runout ");
+      serialprint_onoff(runout.enabled[active_extruder]);
+      SERIAL_ECHOPGM(" ; Distance ", runout.runout_distance(active_extruder), "mm");
+      SERIAL_ECHOPGM(" ; Mode ", runout.mode[active_extruder]);
+      #if ENABLED(HOST_ACTION_COMMANDS)
+        SERIAL_ECHOPGM(" ; Host handling ");
+        serialprint_onoff(runout.host_handling);
+      #endif
+      SERIAL_EOL();
+    #else
+      M591_report(false);
+    #endif
+  }
+}
+
+void GcodeSuite::M591_report(const bool forReplay/*=true*/) {
+  report_heading_etc(forReplay, F(STR_FILAMENT_RUNOUT_SENSOR));
+  LOOP_S_L_N(e, 1, NUM_RUNOUT_SENSORS)
+    SERIAL_ECHOLNPGM(
+      "  M591"
+      #if MULTI_FILAMENT_SENSOR
+        " E", e,
+      #endif
+        " S", runout.enabled[e]
+      , " D", LINEAR_UNIT(runout.runout_distance(e))
+      , " P", runout.mode[e]
+    );
+}
+
+#endif // HAS_FILAMENT_SENSOR

Marlin/src/gcode/gcode.cpp

@@ -859,10 +859,6 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
         case 407: M407(); break;                                  // M407: Display measured filament diameter
       #endif
 
-      #if HAS_FILAMENT_SENSOR
-        case 412: M412(); break;                                  // M412: Enable/Disable filament runout detection
-      #endif
-
       #if HAS_MULTI_LANGUAGE
         case 414: M414(); break;                                  // M414: Select multi language menu
       #endif
@@ -933,6 +929,11 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
         case 575: M575(); break;                                  // M575: Set serial baudrate
       #endif
 
+      #if HAS_FILAMENT_SENSOR
+        case 412: M412(); break;                                  // M412: Alias for M591
+        case 591: M591(); break;                                  // M591: Configure filament runout detection
+      #endif
+
       #if HAS_SHAPING
         case 593: M593(); break;                                  // M593: Set Input Shaping parameters
       #endif

Marlin/src/gcode/gcode.h

@@ -234,7 +234,6 @@
  * M406 - Disable Filament Sensor flow control. (Requires FILAMENT_WIDTH_SENSOR)
  * M407 - Display measured filament diameter in millimeters. (Requires FILAMENT_WIDTH_SENSOR)
  * M410 - Quickstop. Abort all planned moves.
- * M412 - Enable / Disable Filament Runout Detection. (Requires FILAMENT_RUNOUT_SENSOR)
  * M413 - Enable / Disable Power-Loss Recovery. (Requires POWER_LOSS_RECOVERY)
  * M414 - Set language by index. (Requires LCD_LANGUAGE_2...)
  * M420 - Enable/Disable Leveling (with current values) S1=enable S0=disable (Requires MESH_BED_LEVELING or ABL)
@@ -259,6 +258,7 @@
  * M554 - Get or set IP gateway. (Requires enabled Ethernet port)
  * M569 - Enable stealthChop on an axis. (Requires at least one _DRIVER_TYPE to be TMC2130/2160/2208/2209/5130/5160)
  * M575 - Change the serial baud rate. (Requires BAUD_RATE_GCODE)
+ * M591 - Configure Filament Runout Detection. (Requires FILAMENT_RUNOUT_SENSOR)
  * M593 - Get or set input shaping parameters. (Requires INPUT_SHAPING_[XY])
  * M600 - Pause for filament change: "M600 X<pos> Y<pos> Z<raise> E<first_retract> L<later_retract>". (Requires ADVANCED_PAUSE_FEATURE)
  * M603 - Configure filament change: "M603 T<tool> U<unload_length> L<load_length>". (Requires ADVANCED_PAUSE_FEATURE)
@@ -1003,8 +1003,9 @@ private:
   #endif
 
   #if HAS_FILAMENT_SENSOR
-    static void M412();
+    static void M412() { M591(); }
-    static void M412_report(const bool forReplay=true);
+    static void M591();
+    static void M591_report(const bool forReplay=true);
   #endif
 
   #if HAS_MULTI_LANGUAGE

Marlin/src/gcode/host/M115.cpp

@@ -132,7 +132,7 @@ void GcodeSuite::M115() {
     // AUTOLEVEL (G29)
     cap_line(F("AUTOLEVEL"), ENABLED(HAS_AUTOLEVEL));
 
-    // RUNOUT (M412, M600)
+    // RUNOUT (M591, M600)
     cap_line(F("RUNOUT"), ENABLED(FILAMENT_RUNOUT_SENSOR));
 
     // Z_PROBE (G30)

Marlin/src/inc/Conditionals_LCD.h

@@ -1111,10 +1111,14 @@
  * Fill in undefined Filament Sensor options
  */
 #if ENABLED(FILAMENT_RUNOUT_SENSOR)
+  #define HAS_FILAMENT_SENSOR 1
+  #ifndef NUM_RUNOUT_SENSORS
+    #define NUM_RUNOUT_SENSORS E_STEPPERS
+  #endif
+  #if ENABLED(MIXING_EXTRUDER)
+    #define WATCH_ALL_RUNOUT_SENSORS
+  #endif
   #if NUM_RUNOUT_SENSORS >= 1
-    #ifndef FIL_RUNOUT1_STATE
-      #define FIL_RUNOUT1_STATE FIL_RUNOUT_STATE
-    #endif
     #ifndef FIL_RUNOUT1_PULLUP
       #define FIL_RUNOUT1_PULLUP FIL_RUNOUT_PULLUP
     #endif
@@ -1123,9 +1127,7 @@
     #endif
   #endif
   #if NUM_RUNOUT_SENSORS >= 2
-    #ifndef FIL_RUNOUT2_STATE
+    #define MULTI_FILAMENT_SENSOR 1
-      #define FIL_RUNOUT2_STATE FIL_RUNOUT_STATE
-    #endif
     #ifndef FIL_RUNOUT2_PULLUP
       #define FIL_RUNOUT2_PULLUP FIL_RUNOUT_PULLUP
     #endif
@@ -1134,9 +1136,6 @@
     #endif
   #endif
   #if NUM_RUNOUT_SENSORS >= 3
-    #ifndef FIL_RUNOUT3_STATE
-      #define FIL_RUNOUT3_STATE FIL_RUNOUT_STATE
-    #endif
     #ifndef FIL_RUNOUT3_PULLUP
       #define FIL_RUNOUT3_PULLUP FIL_RUNOUT_PULLUP
     #endif
@@ -1145,9 +1144,6 @@
     #endif
   #endif
   #if NUM_RUNOUT_SENSORS >= 4
-    #ifndef FIL_RUNOUT4_STATE
-      #define FIL_RUNOUT4_STATE FIL_RUNOUT_STATE
-    #endif
     #ifndef FIL_RUNOUT4_PULLUP
       #define FIL_RUNOUT4_PULLUP FIL_RUNOUT_PULLUP
     #endif
@@ -1156,9 +1152,6 @@
     #endif
   #endif
   #if NUM_RUNOUT_SENSORS >= 5
-    #ifndef FIL_RUNOUT5_STATE
-      #define FIL_RUNOUT5_STATE FIL_RUNOUT_STATE
-    #endif
     #ifndef FIL_RUNOUT5_PULLUP
       #define FIL_RUNOUT5_PULLUP FIL_RUNOUT_PULLUP
     #endif
@@ -1167,9 +1160,6 @@
     #endif
   #endif
   #if NUM_RUNOUT_SENSORS >= 6
-    #ifndef FIL_RUNOUT6_STATE
-      #define FIL_RUNOUT6_STATE FIL_RUNOUT_STATE
-    #endif
     #ifndef FIL_RUNOUT6_PULLUP
       #define FIL_RUNOUT6_PULLUP FIL_RUNOUT_PULLUP
     #endif
@@ -1178,9 +1168,6 @@
     #endif
   #endif
   #if NUM_RUNOUT_SENSORS >= 7
-    #ifndef FIL_RUNOUT7_STATE
-      #define FIL_RUNOUT7_STATE FIL_RUNOUT_STATE
-    #endif
     #ifndef FIL_RUNOUT7_PULLUP
       #define FIL_RUNOUT7_PULLUP FIL_RUNOUT_PULLUP
     #endif
@@ -1189,9 +1176,6 @@
     #endif
   #endif
   #if NUM_RUNOUT_SENSORS >= 8
-    #ifndef FIL_RUNOUT8_STATE
-      #define FIL_RUNOUT8_STATE FIL_RUNOUT_STATE
-    #endif
     #ifndef FIL_RUNOUT8_PULLUP
       #define FIL_RUNOUT8_PULLUP FIL_RUNOUT_PULLUP
     #endif
@@ -1663,3 +1647,28 @@
 #if defined(NEOPIXEL_BKGD_INDEX_FIRST) && !defined(NEOPIXEL_BKGD_INDEX_LAST)
   #define NEOPIXEL_BKGD_INDEX_LAST NEOPIXEL_BKGD_INDEX_FIRST
 #endif
+
+/*** TEMPORARY COMPATIBILITY ***/
+
+#if HAS_FILAMENT_SENSOR
+  #ifndef FIL_RUNOUT_ENABLED
+    #if FIL_RUNOUT_ENABLED_DEFAULT
+      #define FIL_RUNOUT_ENABLED ARRAY_N_1(NUM_RUNOUT_SENSORS, true)
+    #else
+      #define FIL_RUNOUT_ENABLED ARRAY_N_1(NUM_RUNOUT_SENSORS, false)
+    #endif
+  #endif
+  #ifndef FIL_RUNOUT_MODE
+    #if FIL_RUNOUT_STATE
+      #define FIL_RUNOUT_MODE ARRAY_N_1(NUM_RUNOUT_SENSORS, 1)
+    #else
+      #define FIL_RUNOUT_MODE ARRAY_N_1(NUM_RUNOUT_SENSORS, 2)
+    #endif
+  #endif
+  #ifndef FIL_RUNOUT_DISTANCE_MM
+    #define FIL_RUNOUT_DISTANCE_MM ARRAY_N_1(NUM_RUNOUT_SENSORS, 10)
+  #endif
+  #undef FIL_RUNOUT_ENABLED_DEFAULT
+  #undef FIL_RUNOUT_STATE
+  #undef FILAMENT_RUNOUT_DISTANCE_MM
+#endif

Marlin/src/inc/Conditionals_adv.h

@@ -99,11 +99,12 @@
   #undef PID_EXTRUSION_SCALING
   #undef LIN_ADVANCE
   #undef FILAMENT_RUNOUT_SENSOR
+  #undef FIL_RUNOUT_ENABLED
+  #undef FIL_RUNOUT_MODE
+  #undef FIL_RUNOUT_DISTANCE_MM
   #undef ADVANCED_PAUSE_FEATURE
-  #undef FILAMENT_RUNOUT_DISTANCE_MM
   #undef FILAMENT_LOAD_UNLOAD_GCODES
   #undef DISABLE_INACTIVE_EXTRUDER
-  #undef FILAMENT_LOAD_UNLOAD_GCODES
   #undef EXTRUDER_RUNOUT_PREVENT
   #undef PREVENT_COLD_EXTRUSION
   #undef PREVENT_LENGTHY_EXTRUDE
@@ -606,9 +607,6 @@
   #if NUM_RUNOUT_SENSORS > 1
     #define MULTI_FILAMENT_SENSOR 1
   #endif
-  #ifdef FILAMENT_RUNOUT_DISTANCE_MM
-    #define HAS_FILAMENT_RUNOUT_DISTANCE 1
-  #endif
   #if ENABLED(MIXING_EXTRUDER)
     #define WATCH_ALL_RUNOUT_SENSORS
   #endif

Marlin/src/inc/SanityCheck.h

@@ -570,9 +570,9 @@
   #error "SHORT_MANUAL_Z_MOVE is now FINE_MANUAL_MOVE, applying to Z on most printers."
 #elif defined(FIL_RUNOUT_INVERTING)
   #if FIL_RUNOUT_INVERTING
-    #error "FIL_RUNOUT_INVERTING true is now FIL_RUNOUT_STATE HIGH."
+    #error "FIL_RUNOUT_INVERTING true is now FIL_RUNOUT_MODE {HIGH}."
   #else
-    #error "FIL_RUNOUT_INVERTING false is now FIL_RUNOUT_STATE LOW."
+    #error "FIL_RUNOUT_INVERTING false is now FIL_RUNOUT_MODE {LOW}."
   #endif
 #elif defined(ASSISTED_TRAMMING_MENU_ITEM)
   #error "ASSISTED_TRAMMING_MENU_ITEM is deprecated and should be removed."
@@ -1086,10 +1086,71 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
     #error "You can't enable FIL_RUNOUT7_PULLUP and FIL_RUNOUT7_PULLDOWN at the same time."
   #elif BOTH(FIL_RUNOUT8_PULLUP, FIL_RUNOUT8_PULLDOWN)
     #error "You can't enable FIL_RUNOUT8_PULLUP and FIL_RUNOUT8_PULLDOWN at the same time."
-  #elif FILAMENT_RUNOUT_DISTANCE_MM < 0
-    #error "FILAMENT_RUNOUT_DISTANCE_MM must be greater than or equal to zero."
   #elif DISABLED(ADVANCED_PAUSE_FEATURE)
     static_assert(nullptr == strstr(FILAMENT_RUNOUT_SCRIPT, "M600"), "ADVANCED_PAUSE_FEATURE is required to use M600 with FILAMENT_RUNOUT_SENSOR.");
+  #elif defined(FIL_RUNOUT_ENABLED_DEFAULT)
+    #error "FIL_RUNOUT_ENABLED_DEFAULT is now set with the FILAMENT_RUNOUT_ENABLED array."
+  #elif defined(FILAMENT_RUNOUT_DISTANCE_MM)
+    #error "FILAMENT_RUNOUT_DISTANCE_MM is now set with the FIL_RUNOUT_DISTANCE_MM array."
+  #elif defined(FIL_RUNOUT_STATE) || defined(FIL_RUNOUT2_STATE) || defined(FIL_RUNOUT3_STATE) || defined(FIL_RUNOUT4_STATE) || defined(FIL_RUNOUT5_STATE) || defined(FIL_RUNOUT6_STATE) || defined(FIL_RUNOUT7_STATE) || defined(FIL_RUNOUT8_STATE)
+    #ifdef FIL_RUNOUT_STATE
+      #if FIL_RUNOUT_STATE
+        #error "FIL_RUNOUT_STATE HIGH is now set with FIL_RUNOUT_MODE { 2 ... }."
+      #else
+        #error "FIL_RUNOUT_STATE LOW is now set with FIL_RUNOUT_MODE { 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT2_STATE
+      #if FIL_RUNOUT2_STATE
+        #error "FIL_RUNOUT2_STATE HIGH is now set with FIL_RUNOUT_MODE { n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT2_STATE LOW is now set with FIL_RUNOUT_MODE { n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT3_STATE
+      #if FIL_RUNOUT3_STATE
+        #error "FIL_RUNOUT3_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT3_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT4_STATE
+      #if FIL_RUNOUT4_STATE
+        #error "FIL_RUNOUT4_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT4_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT5_STATE
+      #if FIL_RUNOUT5_STATE
+        #error "FIL_RUNOUT5_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT5_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, n, n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT6_STATE
+      #if FIL_RUNOUT6_STATE
+        #error "FIL_RUNOUT6_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, n, n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT6_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, n, n, n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT7_STATE
+      #if FIL_RUNOUT7_STATE
+        #error "FIL_RUNOUT7_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, n, n, n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT7_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, n, n, n, n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT8_STATE
+      #if FIL_RUNOUT8_STATE
+        #error "FIL_RUNOUT8_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, n, n, n, n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT8_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, n, n, n, n, n, 1 ... }."
+      #endif
+    #endif
+  #elif ENABLED(FILAMENT_MOTION_SENSOR)
+    #error "FILAMENT_MOTION_SENSOR is now set with FIL_RUNOUT_MODE { 7 ... }."
   #endif
 #endif
 
@@ -1329,8 +1390,6 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
     #error "MIXING_EXTRUDER is incompatible with SINGLENOZZLE."
   #elif ENABLED(DISABLE_INACTIVE_EXTRUDER)
     #error "MIXING_EXTRUDER is incompatible with DISABLE_INACTIVE_EXTRUDER."
-  #elif HAS_FILAMENT_RUNOUT_DISTANCE
-    #error "MIXING_EXTRUDER is incompatible with FILAMENT_RUNOUT_DISTANCE_MM."
   #endif
 #endif
 

Marlin/src/lcd/e3v2/jyersui/dwin.cpp

@@ -2726,7 +2726,7 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
       #define ADVANCED_UNLOAD (ADVANCED_LOAD + ENABLED(ADVANCED_PAUSE_FEATURE))
       #define ADVANCED_COLD_EXTRUDE  (ADVANCED_UNLOAD + ENABLED(PREVENT_COLD_EXTRUSION))
       #define ADVANCED_FILSENSORENABLED (ADVANCED_COLD_EXTRUDE + ENABLED(FILAMENT_RUNOUT_SENSOR))
-      #define ADVANCED_FILSENSORDISTANCE (ADVANCED_FILSENSORENABLED + ENABLED(HAS_FILAMENT_RUNOUT_DISTANCE))
+      #define ADVANCED_FILSENSORDISTANCE (ADVANCED_FILSENSORENABLED + 1)
       #define ADVANCED_POWER_LOSS (ADVANCED_FILSENSORDISTANCE + ENABLED(POWER_LOSS_RECOVERY))
       #define ADVANCED_TOTAL ADVANCED_POWER_LOSS
 
@@ -2816,24 +2816,22 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
           case ADVANCED_FILSENSORENABLED:
             if (draw) {
               Draw_Menu_Item(row, ICON_Extruder, F("Filament Sensor"));
-              Draw_Checkbox(row, runout.enabled);
+              Draw_Checkbox(row, runout.enabled[0]);
             }
             else {
-              runout.enabled = !runout.enabled;
+              runout.enabled[0] = !runout.enabled[0];
-              Draw_Checkbox(row, runout.enabled);
+              Draw_Checkbox(row, runout.enabled[0]);
             }
             break;
 
-          #if ENABLED(HAS_FILAMENT_RUNOUT_DISTANCE)
+          case ADVANCED_FILSENSORDISTANCE:
-            case ADVANCED_FILSENSORDISTANCE:
+            if (draw) {
-              if (draw) {
+              Draw_Menu_Item(row, ICON_MaxAccE, F("Runout Distance"));
-                Draw_Menu_Item(row, ICON_MaxAccE, F("Runout Distance"));
+              Draw_Float(runout.runout_distance(), row, false, 10);
-                Draw_Float(runout.runout_distance(), row, false, 10);
+            }
-              }
+            else
-              else
+              Modify_Value(runout.runout_distance(), 0, 999, 10);
-                Modify_Value(runout.runout_distance(), 0, 999, 10);
+            break;
-              break;
-          #endif
         #endif // FILAMENT_RUNOUT_SENSOR
 
         #if ENABLED(POWER_LOSS_RECOVERY)
@@ -3713,11 +3711,11 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
           case TUNE_FILSENSORENABLED:
             if (draw) {
               Draw_Menu_Item(row, ICON_Extruder, F("Filament Sensor"));
-              Draw_Checkbox(row, runout.enabled);
+              Draw_Checkbox(row, runout.enabled[0]);
             }
             else {
-              runout.enabled = !runout.enabled;
+              runout.enabled = !runout.enabled[0];
-              Draw_Checkbox(row, runout.enabled);
+              Draw_Checkbox(row, runout.enabled[0]);
             }
             break;
         #endif

Marlin/src/lcd/e3v2/proui/dwin.cpp

@@ -2322,14 +2322,12 @@ void SetPID(celsius_t t, heater_id_t h) {
 #if HAS_FILAMENT_SENSOR
   void SetRunoutEnable() {
     runout.reset();
-    runout.enabled = !runout.enabled;
+    runout.enabled[0] = !runout.enabled[0];
-    Draw_Chkb_Line(CurrentMenu->line(), runout.enabled);
+    Draw_Chkb_Line(CurrentMenu->line(), runout.enabled[0]);
     DWIN_UpdateLCD();
   }
-  #if HAS_FILAMENT_RUNOUT_DISTANCE
+  void ApplyRunoutDistance() { runout.set_runout_distance(MenuData.Value / MINUNITMULT); }
-    void ApplyRunoutDistance() { runout.set_runout_distance(MenuData.Value / MINUNITMULT); }
+  void SetRunoutDistance() { SetFloatOnClick(0, 999, UNITFDIGITS, runout.runout_distance(0), ApplyRunoutDistance); }
-    void SetRunoutDistance() { SetFloatOnClick(0, 999, UNITFDIGITS, runout.runout_distance(), ApplyRunoutDistance); }
-  #endif
 #endif
 
 #if ENABLED(ADVANCED_PAUSE_FEATURE)
@@ -2846,6 +2844,9 @@ void onDrawGetColorItem(MenuItemClass* menuitem, int8_t line) {
   DWIN_Draw_HLine(HMI_data.SplitLine_Color, 16, MYPOS(line + 1), 240);
 }
 
+#if HAS_FILAMENT_SENSOR
+  void onDrawRunoutEnable(MenuItemClass* menuitem, int8_t line) { onDrawChkbMenu(menuitem, line, runout.enabled[0]); }
+#endif
 
 void onDrawPIDi(MenuItemClass* menuitem, int8_t line) { onDrawFloatMenu(menuitem, line, 2, unscalePID_i(*(float*)static_cast<MenuItemPtrClass*>(menuitem)->value)); }
 void onDrawPIDd(MenuItemClass* menuitem, int8_t line) { onDrawFloatMenu(menuitem, line, 2, unscalePID_d(*(float*)static_cast<MenuItemPtrClass*>(menuitem)->value)); }
@@ -3320,10 +3321,10 @@ void Draw_FilSet_Menu() {
   if (SetMenu(FilSetMenu, GET_TEXT_F(MSG_FILAMENT_SET), 9)) {
     BACK_ITEM(Draw_AdvancedSettings_Menu);
     #if HAS_FILAMENT_SENSOR
-      EDIT_ITEM_F(ICON_Runout, MSG_RUNOUT_ENABLE, onDrawChkbMenu, SetRunoutEnable, &runout.enabled);
+      EDIT_ITEM_F(ICON_Runout, MSG_RUNOUT_ENABLE, onDrawChkbMenu, SetRunoutEnable, &runout.enabled[0]);
     #endif
     #if HAS_FILAMENT_RUNOUT_DISTANCE
-      EDIT_ITEM_F(ICON_Runout, MSG_RUNOUT_DISTANCE_MM, onDrawPFloatMenu, SetRunoutDistance, &runout.runout_distance());
+      EDIT_ITEM_F(ICON_Runout, MSG_RUNOUT_DISTANCE_MM, onDrawPFloatMenu, SetRunoutDistance, &runout.runout_distance(0));
     #endif
     #if ENABLED(PREVENT_COLD_EXTRUSION)
       EDIT_ITEM_F(ICON_ExtrudeMinT, MSG_EXTRUDER_MIN_TEMP, onDrawPIntMenu, SetExtMinT, &HMI_data.ExtMinT);

Marlin/src/lcd/e3v2/proui/endstop_diag.cpp

@@ -104,7 +104,7 @@ void ESDiagClass::Update() {
     ES_REPORT(Z_MIN);
   #endif
   #if HAS_FILAMENT_SENSOR
-    draw_es_state(READ(FIL_RUNOUT1_PIN) != FIL_RUNOUT1_STATE);
+    draw_es_state(READ(FIL_RUNOUT1_PIN) != runout.out_state());
   #endif
   DWIN_UpdateLCD();
 }

Marlin/src/lcd/extui/ftdi_eve_touch_ui/generic/endstop_state_screen.cpp

@@ -85,12 +85,12 @@ void EndstopStatesScreen::onRedraw(draw_mode_t) {
     PIN_DISABLED(5, 3, PSTR(STR_Z_MIN), Z_MIN)
   #endif
   #if ENABLED(FILAMENT_RUNOUT_SENSOR) && PIN_EXISTS(FIL_RUNOUT)
-    PIN_ENABLED (1, 4, GET_TEXT_F(MSG_RUNOUT_1), FIL_RUNOUT, FIL_RUNOUT1_STATE)
+    PIN_ENABLED (1, 4, GET_TEXT_F(MSG_RUNOUT_1), FIL_RUNOUT, !runout.out_state())
   #else
     PIN_DISABLED(1, 4, GET_TEXT_F(MSG_RUNOUT_1), FIL_RUNOUT)
   #endif
   #if BOTH(HAS_MULTI_EXTRUDER, FILAMENT_RUNOUT_SENSOR) && PIN_EXISTS(FIL_RUNOUT2)
-    PIN_ENABLED (3, 4, GET_TEXT_F(MSG_RUNOUT_2), FIL_RUNOUT2, FIL_RUNOUT2_STATE)
+    PIN_ENABLED (3, 4, GET_TEXT_F(MSG_RUNOUT_2), FIL_RUNOUT2, !runout.out_state(1))
   #else
     PIN_DISABLED(3, 4, GET_TEXT_F(MSG_RUNOUT_2), FIL_RUNOUT2)
   #endif

Marlin/src/lcd/extui/ftdi_eve_touch_ui/generic/filament_runout_screen.cpp

@@ -34,14 +34,13 @@ void FilamentRunoutScreen::onRedraw(draw_mode_t what) {
   w.heading(   GET_TEXT_F(MSG_FILAMENT));
   w.toggle( 2, GET_TEXT_F(MSG_RUNOUT_SENSOR), getFilamentRunoutEnabled());
 
-  #if HAS_FILAMENT_RUNOUT_DISTANCE
+  w.heading(GET_TEXT_F(MSG_RUNOUT_DISTANCE_MM));
-    w.heading(GET_TEXT_F(MSG_RUNOUT_DISTANCE_MM));
+  w.units(GET_TEXT_F(MSG_UNITS_MM));
-    w.units(GET_TEXT_F(MSG_UNITS_MM));
+  w.precision(0);
-    w.precision(0);
+  w.color(e_axis);
-    w.color(e_axis);
+  w.adjuster( 10, FPSTR(NUL_STR), getFilamentRunoutDistance_mm(), getFilamentRunoutEnabled());
-    w.adjuster( 10, FPSTR(NUL_STR), getFilamentRunoutDistance_mm(), getFilamentRunoutEnabled());
+  w.increments();
-    w.increments();
+
-  #endif
 }
 
 bool FilamentRunoutScreen::onTouchHeld(uint8_t tag) {
@@ -49,10 +48,8 @@ bool FilamentRunoutScreen::onTouchHeld(uint8_t tag) {
   const float increment = getIncrement();
   switch (tag) {
     case 2: setFilamentRunoutEnabled(!getFilamentRunoutEnabled()); break;
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
+    case  10: UI_DECREMENT(FilamentRunoutDistance_mm); break;
-      case  10: UI_DECREMENT(FilamentRunoutDistance_mm); break;
+    case  11: UI_INCREMENT(FilamentRunoutDistance_mm); break;
-      case  11: UI_INCREMENT(FilamentRunoutDistance_mm); break;
-    #endif
     default:
       return false;
   }

Marlin/src/lcd/extui/ui_api.cpp

@@ -683,15 +683,12 @@ namespace ExtUI {
   }
 
   #if HAS_FILAMENT_SENSOR
-    bool getFilamentRunoutEnabled()                 { return runout.enabled; }
+    bool getFilamentRunoutEnabled(const extruder_t extruder/*=E0*/)                 { return runout.enabled[extruder]; }
-    void setFilamentRunoutEnabled(const bool value) { runout.enabled = value; }
+    void setFilamentRunoutEnabled(const bool value, const extruder_t extruder/*=E0*/) { runout.enabled[extruder] = value; }
     bool getFilamentRunoutState()                   { return runout.filament_ran_out; }
     void setFilamentRunoutState(const bool value)   { runout.filament_ran_out = value; }
-
+    float getFilamentRunoutDistance_mm()                 { return runout.runout_distance(); }
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
+    void setFilamentRunoutDistance_mm(const_float_t value) { runout.set_runout_distance(constrain(value, 0, 999)); }
-      float getFilamentRunoutDistance_mm()                 { return runout.runout_distance(); }
-      void setFilamentRunoutDistance_mm(const_float_t value) { runout.set_runout_distance(constrain(value, 0, 999)); }
-    #endif
   #endif
 
   #if ENABLED(CASE_LIGHT_ENABLE)

Marlin/src/lcd/extui/ui_api.h

@@ -300,15 +300,12 @@ namespace ExtUI {
   #endif
 
   #if HAS_FILAMENT_SENSOR
-    bool getFilamentRunoutEnabled();
+    bool getFilamentRunoutEnabled(const extruder_t extruder=E0);
-    void setFilamentRunoutEnabled(const bool);
+    void setFilamentRunoutEnabled(const bool, const extruder_t extruder=E0);
     bool getFilamentRunoutState();
     void setFilamentRunoutState(const bool);
-
+    float getFilamentRunoutDistance_mm();
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
+    void setFilamentRunoutDistance_mm(const_float_t);
-      float getFilamentRunoutDistance_mm();
-      void setFilamentRunoutDistance_mm(const_float_t);
-    #endif
   #endif
 
   #if ENABLED(CASE_LIGHT_ENABLE)

Marlin/src/lcd/language/language_en.h

@@ -702,6 +702,11 @@ namespace Language_en {
   LSTR MSG_FILAMENT_CHANGE_NOZZLE         = _UxGT("  Nozzle: ");
   LSTR MSG_RUNOUT_SENSOR                  = _UxGT("Runout Sensor");
   LSTR MSG_RUNOUT_DISTANCE_MM             = _UxGT("Runout Dist mm");
+  LSTR MSG_RUNOUT_MODE                    = _UxGT("Runout Mode");
+  LSTR MSG_RUNOUT_MODE_HIGH               = _UxGT("Sensor High");
+  LSTR MSG_RUNOUT_MODE_LOW                = _UxGT("Sensor Low");
+  LSTR MSG_RUNOUT_MODE_MOTION             = _UxGT("Motion Encoder");
+  LSTR MSG_RUNOUT_MODE_NONE               = _UxGT("No Sensor");
   LSTR MSG_RUNOUT_ENABLE                  = _UxGT("Enable Runout");
   LSTR MSG_RUNOUT_ACTIVE                  = _UxGT("Runout Active");
   LSTR MSG_INVERT_EXTRUDER                = _UxGT("Invert Extruder");

Marlin/src/lcd/menu/menu_advanced.cpp

@@ -45,7 +45,7 @@
   #include "../../module/temperature.h"
 #endif
 
-#if HAS_FILAMENT_RUNOUT_DISTANCE
+#if HAS_FILAMENT_SENSOR
   #include "../../feature/runout.h"
 #endif
 
@@ -99,6 +99,33 @@ void menu_backlash();
 
 #endif
 
+#if HAS_FILAMENT_SENSOR && DISABLED(SLIM_LCD_MENUS)
+
+  void set_runout_mode_none(const uint8_t e)   { runout.mode[e] = RM_NONE; runout.setup(); }
+  void set_runout_mode_high(const uint8_t e)   { runout.mode[e] = RM_OUT_ON_HIGH; runout.setup(); }
+  void set_runout_mode_low(const uint8_t e)    { runout.mode[e] = RM_OUT_ON_LOW; runout.setup(); }
+  void set_runout_mode_motion(const uint8_t e) { runout.mode[e] = RM_MOTION_SENSOR; runout.setup(); }
+
+  #define RUNOUT_EDIT_ITEMS(F) do{ \
+    EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled[F]); \
+    ACTION_ITEM(MSG_RUNOUT_MODE_NONE,   []{ set_runout_mode_none(F);   }); \
+    ACTION_ITEM(MSG_RUNOUT_MODE_HIGH,   []{ set_runout_mode_high(F);   }); \
+    ACTION_ITEM(MSG_RUNOUT_MODE_LOW,    []{ set_runout_mode_low(F);    }); \
+    ACTION_ITEM(MSG_RUNOUT_MODE_MOTION, []{ set_runout_mode_motion(F); }); \
+    editable.decimal = runout.runout_distance(F); \
+    EDIT_ITEM_FAST(float3, MSG_RUNOUT_DISTANCE_MM, &editable.decimal, 1, 999, \
+      []{ runout.set_runout_distance(editable.decimal, F); }, true \
+    ); \
+  }while(0);
+
+  void menu_runout_config() {
+    START_MENU();
+    BACK_ITEM(MSG_CONFIGURATION);
+    REPEAT(NUM_RUNOUT_SENSORS, RUNOUT_EDIT_ITEMS);
+    END_MENU();
+  }
+#endif
+
 #if DISABLED(NO_VOLUMETRICS) || ENABLED(ADVANCED_PAUSE_FEATURE)
   //
   // Advanced Settings > Filament
@@ -152,11 +179,8 @@ void menu_backlash();
       #endif
     #endif
 
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
+    #if HAS_FILAMENT_SENSOR && DISABLED(SLIM_LCD_MENUS)
-      editable.decimal = runout.runout_distance();
+      SUBMENU(MSG_RUNOUT_MODE, menu_runout_config);
-      EDIT_ITEM_FAST(float3, MSG_RUNOUT_DISTANCE_MM, &editable.decimal, 1, 999,
-        []{ runout.set_runout_distance(editable.decimal); }, true
-      );
     #endif
 
     END_MENU();

Marlin/src/lcd/menu/menu_configuration.cpp

@@ -559,7 +559,7 @@ void menu_configuration() {
   #endif
 
   #if HAS_FILAMENT_SENSOR
-    EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled, runout.reset);
+    EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled[active_extruder], runout.reset);
   #endif
 
   #if HAS_FANCHECK

Marlin/src/lcd/menu/menu_filament.cpp

@@ -259,7 +259,7 @@ void menu_pause_option() {
   #if HAS_FILAMENT_SENSOR
     const bool still_out = runout.filament_ran_out;
     if (still_out)
-      EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled, runout.reset);
+      EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled[active_extruder], runout.reset);
   #else
     constexpr bool still_out = false;
   #endif

Marlin/src/module/endstops.cpp

@@ -50,6 +50,10 @@
   #include "../feature/joystick.h"
 #endif
 
+#if HAS_FILAMENT_SENSOR
+  #include "../feature/runout.h"
+#endif
+
 #if HAS_BED_PROBE
   #include "probe.h"
 #endif
@@ -668,22 +672,35 @@ void __O2 Endstops::report_states() {
   #if USES_Z_MIN_PROBE_PIN
     print_es_state(PROBE_TRIGGERED(), F(STR_Z_PROBE));
   #endif
-  #if MULTI_FILAMENT_SENSOR
+  #if HAS_FILAMENT_SENSOR
-    #define _CASE_RUNOUT(N) case N: pin = FIL_RUNOUT##N##_PIN; state = FIL_RUNOUT##N##_STATE; break;
     LOOP_S_LE_N(i, 1, NUM_RUNOUT_SENSORS) {
       pin_t pin;
-      uint8_t state;
       switch (i) {
         default: continue;
+        #define _CASE_RUNOUT(N) case N: pin = FIL_RUNOUT##N##_PIN; break;
         REPEAT_1(NUM_RUNOUT_SENSORS, _CASE_RUNOUT)
+        #undef _CASE_RUNOUT
       }
-      SERIAL_ECHOPGM(STR_FILAMENT);
+      const RunoutMode rm = runout.mode[i - 1];
-      if (i > 1) SERIAL_CHAR(' ', '0' + i);
+      const uint8_t outval = runout.out_state(i - 1);
-      print_es_state(extDigitalRead(pin) != state);
+
+      #if DISABLED(SLIM_LCD_MENUS)
+        SERIAL_ECHOPGM(STR_FILAMENT);
+        if (i > 1) SERIAL_CHAR(' ', '0' + i);
+        SERIAL_ECHOPGM(": ");
+        if (rm == RM_NONE)
+          SERIAL_ECHOLNPGM(STR_OFF);
+        else if (rm == RM_MOTION_SENSOR) {
+          SERIAL_ECHOPGM("MOTION : ");
+          print_es_state(extDigitalRead(pin) == outval);
+        }
+        else
+          SERIAL_ECHOLNPGM_P(extDigitalRead(pin) == outval ? PSTR("OUT") : PSTR("PRESENT"));
+      #else
+        print_es_state(extDigitalRead(pin) == outval, F(STR_FILAMENT));
+      #endif
     }
-    #undef _CASE_RUNOUT
+
-  #elif HAS_FILAMENT_SENSOR
-    print_es_state(READ(FIL_RUNOUT1_PIN) != FIL_RUNOUT1_STATE, F(STR_FILAMENT));
   #endif
 
   TERN_(BLTOUCH, bltouch._reset_SW_mode());

Marlin/src/module/settings.cpp

@@ -113,9 +113,6 @@
 
 #if HAS_FILAMENT_SENSOR
   #include "../feature/runout.h"
-  #ifndef FIL_RUNOUT_ENABLED_DEFAULT
-    #define FIL_RUNOUT_ENABLED_DEFAULT true
-  #endif
 #endif
 
 #if ENABLED(ADVANCE_K_EXTRA)
@@ -237,8 +234,11 @@ typedef struct SettingsDataStruct {
   //
   // FILAMENT_RUNOUT_SENSOR
   //
-  bool runout_sensor_enabled;                           // M412 S
+  #if HAS_FILAMENT_SENSOR
-  float runout_distance_mm;                             // M412 D
+    bool runout_enabled[NUM_RUNOUT_SENSORS];            // M591 S
+    float runout_distance_mm[NUM_RUNOUT_SENSORS];       // M591 D
+    uint8_t runout_mode[NUM_RUNOUT_SENSORS];            // M591 P
+  #endif
 
   //
   // ENABLE_LEVELING_FADE_HEIGHT
@@ -819,33 +819,23 @@ void MarlinSettings::postprocess() {
     //
     // Hotend Offsets, if any
     //
-    {
+    #if HAS_HOTEND_OFFSET
-      #if HAS_HOTEND_OFFSET
+      // Skip hotend 0 which must be 0
-        // Skip hotend 0 which must be 0
+      LOOP_S_L_N(e, 1, HOTENDS)
-        LOOP_S_L_N(e, 1, HOTENDS)
+        EEPROM_WRITE(hotend_offset[e]);
-          EEPROM_WRITE(hotend_offset[e]);
+    #endif
-      #endif
-    }
 
     //
     // Filament Runout Sensor
     //
+    #if HAS_FILAMENT_SENSOR
     {
-      #if HAS_FILAMENT_SENSOR
+      _FIELD_TEST(runout_enabled);
-        const bool &runout_sensor_enabled = runout.enabled;
+      LOOP_L_N(e, NUM_RUNOUT_SENSORS) EEPROM_WRITE(runout.enabled[e]);
-      #else
+      LOOP_L_N(e, NUM_RUNOUT_SENSORS) EEPROM_WRITE(runout.runout_distance(e));
-        constexpr int8_t runout_sensor_enabled = -1;
+      LOOP_L_N(e, NUM_RUNOUT_SENSORS) EEPROM_WRITE(runout.mode[e]);
-      #endif
-      _FIELD_TEST(runout_sensor_enabled);
-      EEPROM_WRITE(runout_sensor_enabled);
-
-      #if HAS_FILAMENT_RUNOUT_DISTANCE
-        const float &runout_distance_mm = runout.runout_distance();
-      #else
-        constexpr float runout_distance_mm = 0;
-      #endif
-      EEPROM_WRITE(runout_distance_mm);
     }
+    #endif
 
     //
     // Global Leveling
@@ -1781,22 +1771,28 @@ void MarlinSettings::postprocess() {
       //
       // Filament Runout Sensor
       //
+      #if HAS_FILAMENT_SENSOR
       {
-        int8_t runout_sensor_enabled;
+        _FIELD_TEST(runout_enabled);
-        _FIELD_TEST(runout_sensor_enabled);
-        EEPROM_READ(runout_sensor_enabled);
-        #if HAS_FILAMENT_SENSOR
-          runout.enabled = runout_sensor_enabled < 0 ? FIL_RUNOUT_ENABLED_DEFAULT : runout_sensor_enabled;
-        #endif
 
-        TERN_(HAS_FILAMENT_SENSOR, if (runout.enabled) runout.reset());
+        bool runout_enabled[NUM_RUNOUT_SENSORS];
+        float runout_distance_mm[NUM_RUNOUT_SENSORS];
+        RunoutMode runout_mode[NUM_RUNOUT_SENSORS];
 
-        float runout_distance_mm;
+        EEPROM_READ(runout_enabled);
         EEPROM_READ(runout_distance_mm);
-        #if HAS_FILAMENT_RUNOUT_DISTANCE
+        EEPROM_READ(runout_mode);
-          if (!validating) runout.set_runout_distance(runout_distance_mm);
+
-        #endif
+        if (!validating) {
+          LOOP_S_L_N(e, 0, NUM_RUNOUT_SENSORS) {
+            runout.enabled[e] = runout_enabled[e];
+            runout.set_runout_distance(runout_distance_mm[e], e);
+            runout.mode[e] = runout_mode[e];
+          }
+          runout.reset();
+        }
       }
+      #endif
 
       //
       // Global Leveling
@@ -2920,9 +2916,16 @@ void MarlinSettings::reset() {
   //
 
   #if HAS_FILAMENT_SENSOR
-    runout.enabled = FIL_RUNOUT_ENABLED_DEFAULT;
+    constexpr bool fred[] = FIL_RUNOUT_ENABLED;
+    constexpr uint8_t frm[] = FIL_RUNOUT_MODE;
+    constexpr float frd[] = FIL_RUNOUT_DISTANCE_MM;
+    static_assert(COUNT(fred) == NUM_RUNOUT_SENSORS, "FIL_RUNOUT_ENABLED must have NUM_RUNOUT_SENSORS values.");
+    static_assert(COUNT(frm) == NUM_RUNOUT_SENSORS, "FIL_RUNOUT_MODE must have NUM_RUNOUT_SENSORS values.");
+    static_assert(COUNT(frd) == NUM_RUNOUT_SENSORS, "FIL_RUNOUT_DISTANCE_MM must have NUM_RUNOUT_SENSORS values.");
+    COPY(runout.enabled, fred);
+    COPY(runout.mode, frm);
+    LOOP_L_N(e, NUM_RUNOUT_SENSORS) runout.set_runout_distance(frd[e], e);
     runout.reset();
-    TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, runout.set_runout_distance(FILAMENT_RUNOUT_DISTANCE_MM));
   #endif
 
   //
@@ -3682,7 +3685,7 @@ void MarlinSettings::reset() {
     //
     // Filament Runout Sensor
     //
-    TERN_(HAS_FILAMENT_SENSOR, gcode.M412_report(forReplay));
+    TERN_(HAS_FILAMENT_SENSOR, gcode.M591_report(forReplay));
 
     #if HAS_ETHERNET
       CONFIG_ECHO_HEADING("Ethernet");

Marlin/src/module/stepper.cpp

@@ -117,7 +117,7 @@ Stepper stepper; // Singleton
   #include "../feature/mixing.h"
 #endif
 
-#if HAS_FILAMENT_RUNOUT_DISTANCE
+#if HAS_FILAMENT_SENSOR
   #include "../feature/runout.h"
 #endif
 
@@ -2136,7 +2136,7 @@ uint32_t Stepper::block_phase_isr() {
           PAGE_SEGMENT_UPDATE_POS(E);
         }
       #endif
-      TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, runout.block_completed(current_block));
+      TERN_(HAS_FILAMENT_SENSOR, runout.block_completed(current_block));
       discard_current_block();
     }
     else {

buildroot/tests/BIGTREE_GTR_V1_0

@@ -12,8 +12,10 @@ opt_set MOTHERBOARD BOARD_BTT_GTR_V1_0 SERIAL_PORT -1 \
 # Not necessary to enable auto-fan for all extruders to hit problematic code paths
 opt_set E0_AUTO_FAN_PIN PC10 E1_AUTO_FAN_PIN PC11 E2_AUTO_FAN_PIN PC12 NEOPIXEL_PIN PF13 \
         X_DRIVER_TYPE TMC2208 Y_DRIVER_TYPE TMC2130 \
-        NUM_RUNOUT_SENSORS 8 FIL_RUNOUT_PIN 3 FIL_RUNOUT2_PIN 4 FIL_RUNOUT3_PIN 5 FIL_RUNOUT4_PIN 6 FIL_RUNOUT5_PIN 7 \
+        FIL_RUNOUT_ENABLED '{ true, true, true, true, true, true, true, true }' \
-        FIL_RUNOUT6_PIN 8 FIL_RUNOUT7_PIN 9 FIL_RUNOUT8_PIN 10 FIL_RUNOUT4_STATE HIGH FIL_RUNOUT8_STATE HIGH \
+        FIL_RUNOUT_MODE '{ 1, 1, 1, 1, 1, 1, 1, 1 }' \
+        FIL_RUNOUT_DISTANCE_MM '{ 0, 1, 5, 10, 5, 5, 5, 5 }' \
+        FIL_RUNOUT_PIN 3 FIL_RUNOUT2_PIN 4 FIL_RUNOUT3_PIN 5 FIL_RUNOUT4_PIN 6 FIL_RUNOUT5_PIN 7 FIL_RUNOUT6_PIN 8 FIL_RUNOUT7_PIN 9 FIL_RUNOUT8_PIN 10 \
         FILAMENT_RUNOUT_SCRIPT '"M600 T%c"'
 opt_enable REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER BLTOUCH NEOPIXEL_LED Z_SAFE_HOMING NOZZLE_PARK_FEATURE ADVANCED_PAUSE_FEATURE \
            FILAMENT_RUNOUT_SENSOR FIL_RUNOUT4_PULLUP FIL_RUNOUT8_PULLUP FILAMENT_CHANGE_RESUME_ON_INSERT PAUSE_REHEAT_FAST_RESUME

buildroot/tests/BIGTREE_GTR_V1_0_usb_flash_drive

@@ -16,7 +16,7 @@ opt_enable SDSUPPORT USB_FLASH_DRIVE_SUPPORT USE_OTG_USB_HOST \
 opt_set E0_AUTO_FAN_PIN PC10 E1_AUTO_FAN_PIN PC11 E2_AUTO_FAN_PIN PC12 NEOPIXEL_PIN PF13 \
         X_DRIVER_TYPE TMC2208 Y_DRIVER_TYPE TMC2130 \
         FIL_RUNOUT_PIN 3 FIL_RUNOUT2_PIN 4 FIL_RUNOUT3_PIN 5 FIL_RUNOUT4_PIN 6 FIL_RUNOUT5_PIN 7 FIL_RUNOUT6_PIN 8 FIL_RUNOUT7_PIN 9 FIL_RUNOUT8_PIN 10 \
-        FIL_RUNOUT4_STATE HIGH FIL_RUNOUT8_STATE HIGH
+        FIL_RUNOUT_MODE '{ 2, 2, 2, 1, 2, 2, 2, 1 }' FIL_RUNOUT_DISTANCE_MM '{ 0, 1, 5, 10, 5, 5, 5, 5 }'
 opt_enable FIL_RUNOUT4_PULLUP FIL_RUNOUT8_PULLUP
 exec_test $1 $2 "GTT GTR | OTG USB Flash Drive | 8 Extruders | Auto-Fan | Mixed TMC Drivers | Runout Sensors (distinct)" "$3"
 

buildroot/tests/DUE

@@ -19,7 +19,7 @@ opt_enable S_CURVE_ACCELERATION EEPROM_SETTINGS GCODE_MACROS \
            EEPROM_SETTINGS SDSUPPORT BINARY_FILE_TRANSFER \
            BLINKM PCA9533 PCA9632 RGB_LED RGB_LED_R_PIN RGB_LED_G_PIN RGB_LED_B_PIN \
            NEOPIXEL_LED NEOPIXEL_PIN CASE_LIGHT_ENABLE CASE_LIGHT_USE_NEOPIXEL CASE_LIGHT_USE_RGB_LED CASE_LIGHT_MENU \
-           NOZZLE_PARK_FEATURE ADVANCED_PAUSE_FEATURE FILAMENT_RUNOUT_DISTANCE_MM FILAMENT_RUNOUT_SENSOR \
+           NOZZLE_PARK_FEATURE ADVANCED_PAUSE_FEATURE FILAMENT_RUNOUT_SENSOR FIL_RUNOUT_DISTANCE_MM \
            AUTO_BED_LEVELING_BILINEAR Z_MIN_PROBE_REPEATABILITY_TEST DEBUG_LEVELING_FEATURE \
            SKEW_CORRECTION SKEW_CORRECTION_FOR_Z SKEW_CORRECTION_GCODE CALIBRATION_GCODE \
            BACKLASH_COMPENSATION BACKLASH_GCODE BAUD_RATE_GCODE BEZIER_CURVE_SUPPORT \

buildroot/tests/mega2560

@@ -61,7 +61,7 @@ restore_configs
 opt_set MOTHERBOARD BOARD_AZTEEG_X3_PRO NUM_SERVOS 1 \
         EXTRUDERS 5 TEMP_SENSOR_1 1 TEMP_SENSOR_2 1 TEMP_SENSOR_3 1 TEMP_SENSOR_4 1 \
         NUM_RUNOUT_SENSORS 5 FIL_RUNOUT2_PIN 44 FIL_RUNOUT3_PIN 45 FIL_RUNOUT4_PIN 46 FIL_RUNOUT5_PIN 47 \
-        FIL_RUNOUT3_STATE HIGH
+        FIL_RUNOUT_ENABLED '{ true, true, true, true, true }' FIL_RUNOUT_MODE '{ 1, 2, 7, 0, 1 }' FIL_RUNOUT_DISTANCE_MM '{ 15, 15, 15, 15, 15 }'
 opt_enable VIKI2 BOOT_MARLIN_LOGO_ANIMATED SDSUPPORT AUTO_REPORT_SD_STATUS \
            Z_PROBE_SERVO_NR Z_SERVO_ANGLES DEACTIVATE_SERVOS_AFTER_MOVE AUTO_BED_LEVELING_3POINT DEBUG_LEVELING_FEATURE \
            EEPROM_SETTINGS EEPROM_CHITCHAT M114_DETAIL AUTO_REPORT_POSITION \
@@ -75,9 +75,9 @@ exec_test $1 $2 "Multiple runout sensors (x5) | Distinct runout states" "$3"
 # Mixing Extruder with 5 steppers, Greek
 #
 restore_configs
-opt_set MOTHERBOARD BOARD_AZTEEG_X3_PRO MIXING_STEPPERS 5 LCD_LANGUAGE ru \
+opt_set MOTHERBOARD BOARD_AZTEEG_X3_PRO MIXING_STEPPERS 5 LCD_LANGUAGE ru REDUNDANT_PART_COOLING_FAN 1 \
-        NUM_RUNOUT_SENSORS E_STEPPERS REDUNDANT_PART_COOLING_FAN 1 \
+        FIL_RUNOUT2_PIN 16 FIL_RUNOUT3_PIN 17 FIL_RUNOUT4_PIN 4 FIL_RUNOUT5_PIN 5 \
-        FIL_RUNOUT2_PIN 16 FIL_RUNOUT3_PIN 17 FIL_RUNOUT4_PIN 4 FIL_RUNOUT5_PIN 5
+        FIL_RUNOUT_ENABLED '{ true, true, true, true, true }' FIL_RUNOUT_MODE '{ 1, 2, 7, 0, 1 }' FIL_RUNOUT_DISTANCE_MM '{ 15, 15, 15, 15, 15 }'
 opt_enable MIXING_EXTRUDER GRADIENT_MIX GRADIENT_VTOOL CR10_STOCKDISPLAY \
            USE_CONTROLLER_FAN CONTROLLER_FAN_EDITABLE CONTROLLER_FAN_IGNORE_Z \
            FILAMENT_RUNOUT_SENSOR ADVANCED_PAUSE_FEATURE NOZZLE_PARK_FEATURE INPUT_SHAPING_X INPUT_SHAPING_Y

buildroot/tests/rambo

@@ -15,7 +15,7 @@ opt_set MOTHERBOARD BOARD_RAMBO \
         TEMP_SENSOR_PROBE 1 TEMP_PROBE_PIN 12 \
         TEMP_SENSOR_CHAMBER 3 TEMP_CHAMBER_PIN 3 HEATER_CHAMBER_PIN 45 \
         GRID_MAX_POINTS_X 16 AUTO_POWER_E_TEMP 80 \
-        FANMUX0_PIN 53
+        FANMUX0_PIN 53 NUM_RUNOUT_SENSORS 1
 opt_disable Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN USE_WATCHDOG
 opt_enable USE_ZMAX_PLUG REPRAP_DISCOUNT_SMART_CONTROLLER LCD_PROGRESS_BAR LCD_PROGRESS_BAR_TEST \
            FIX_MOUNTED_PROBE CODEPENDENT_XY_HOMING PIDTEMPBED PTC_PROBE PTC_BED \