diff --git a/Marlin/src/feature/runout.cpp b/Marlin/src/feature/runout.cpp index a51cf5b9e..1a9f56cbe 100644 --- a/Marlin/src/feature/runout.cpp +++ b/Marlin/src/feature/runout.cpp @@ -30,23 +30,29 @@ #include "runout.h" -FilamentRunoutSensor runout; +FilamentMonitor runout; -bool FilamentSensorBase::enabled = true, - FilamentSensorBase::filament_ran_out; // = false +bool FilamentMonitorBase::enabled = true, + FilamentMonitorBase::filament_ran_out; // = false -void FilamentSensorTypeBase::filament_present(const uint8_t extruder) { - runout.filament_present(extruder); +/** + * Called by FilamentSensorSwitch::run when filament is detected. + * Called by FilamentSensorEncoder::block_completed when motion is detected. + */ +void FilamentSensorBase::filament_present(const uint8_t extruder) { + runout.filament_present(extruder); // calls response.filament_present(extruder) } -uint8_t FilamentSensorTypeEncoder::motion_detected, - FilamentSensorTypeEncoder::old_state; // = 0 +#if ENABLED(FILAMENT_MOTION_SENSOR) + uint8_t FilamentSensorEncoder::motion_detected, + FilamentSensorEncoder::old_state; // = 0 +#endif #if FILAMENT_RUNOUT_DISTANCE_MM > 0 float RunoutResponseDelayed::runout_distance_mm = FILAMENT_RUNOUT_DISTANCE_MM; - int32_t RunoutResponseDelayed::steps_since_detection[EXTRUDERS]; + volatile float RunoutResponseDelayed::runout_mm_countdown[EXTRUDERS]; #else - uint8_t RunoutResponseDebounced::runout_count; // = 0 + int8_t RunoutResponseDebounced::runout_count; // = 0 #endif #endif // FILAMENT_RUNOUT_SENSOR diff --git a/Marlin/src/feature/runout.h b/Marlin/src/feature/runout.h index cdcc385bd..e7c424234 100644 --- a/Marlin/src/feature/runout.h +++ b/Marlin/src/feature/runout.h @@ -38,7 +38,7 @@ //#define FILAMENT_RUNOUT_SENSOR_DEBUG -class FilamentSensorBase { +class FilamentMonitorBase { public: static bool enabled; @@ -47,16 +47,17 @@ class FilamentSensorBase { }; template -class TFilamentSensor : public FilamentSensorBase { +class TFilamentMonitor : public FilamentMonitorBase { private: typedef RESPONSE_T response_t; typedef SENSOR_T sensor_t; - static response_t response; - static sensor_t sensor; + static response_t response; + static sensor_t sensor; public: - static void setup() { + static inline void setup() { sensor.setup(); + reset(); } static inline void reset() { @@ -64,21 +65,34 @@ class TFilamentSensor : public FilamentSensorBase { response.reset(); } - // The sensor calls this method when filament is present + // Call this method when filament is present, + // so the response can reset its counter. static inline void filament_present(const uint8_t extruder) { response.filament_present(extruder); } - static inline void block_complete(const block_t *b) { - response.block_complete(b); - sensor.block_complete(b); + // Handle a block completion. RunoutResponseDelayed uses this to + // add up the length of filament moved while the filament is out. + static inline void block_completed(const block_t* const b) { + if (enabled) { + response.block_completed(b); + sensor.block_completed(b); + } } - static void run() { + // Give the response a chance to update its counter. + static inline void run() { if (enabled && !filament_ran_out && (IS_SD_PRINTING() || print_job_timer.isRunning())) { + #if FILAMENT_RUNOUT_DISTANCE_MM > 0 + cli(); // Prevent RunoutResponseDelayed::block_completed from accumulating here + #endif response.run(); sensor.run(); - if (response.has_runout()) { + const bool ran_out = response.has_run_out(); + #if FILAMENT_RUNOUT_DISTANCE_MM > 0 + sei(); + #endif + if (ran_out) { filament_ran_out = true; #if ENABLED(EXTENSIBLE_UI) UI::onFilamentRunout(); @@ -92,7 +106,7 @@ class TFilamentSensor : public FilamentSensorBase { /*************************** FILAMENT PRESENCE SENSORS ***************************/ -class FilamentSensorTypeBase { +class FilamentSensorBase { protected: static void filament_present(const uint8_t extruder); @@ -153,155 +167,170 @@ class FilamentSensorTypeBase { } }; -/** - * This sensor is a simple endstop - * switch in the path of the filament. It detects - * filament runout, but not stripouts or jams. - */ +#if ENABLED(FILAMENT_MOTION_SENSOR) -class FilamentSensorTypeSwitch : public FilamentSensorTypeBase { - private: - static bool poll_runout_pin(const uint8_t extruder) { - const uint8_t runout_bits = poll_runout_pins(); - #if NUM_RUNOUT_SENSORS == 1 - return runout_bits; // A single sensor applying to all extruders - #else - #if ENABLED(DUAL_X_CARRIAGE) - if (dual_x_carriage_mode == DXC_DUPLICATION_MODE || dual_x_carriage_mode == DXC_SCALED_DUPLICATION_MODE) - return runout_bits; // Any extruder - else - #elif ENABLED(DUAL_NOZZLE_DUPLICATION_MODE) - if (extruder_duplication_enabled) - return runout_bits; // Any extruder - else + /** + * This sensor uses a magnetic encoder disc and a Hall effect + * sensor (or a slotted disc and optical sensor). The state + * will toggle between 0 and 1 on filament movement. It can detect + * filament runout and stripouts or jams. + */ + class FilamentSensorEncoder : public FilamentSensorBase { + private: + static uint8_t motion_detected; + + static inline void poll_motion_sensor() { + static uint8_t old_state; + const uint8_t new_state = poll_runout_pins(), + change = old_state ^ new_state; + old_state = new_state; + + #ifdef FILAMENT_RUNOUT_SENSOR_DEBUG + if (change) SERIAL_PROTOCOLLNPAIR("Motion detected: ", int(change)); #endif - return TEST(runout_bits, extruder); // Specific extruder - #endif - } - public: - static inline void block_complete(const block_t *b) {} + motion_detected |= change; + } - static inline void run() { - if (!poll_runout_pin(active_extruder)) - filament_present(active_extruder); - } -}; + public: + static inline 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); -// This filament sensor uses a magnetic encoder disc and a hall -// effect sensor (or a slitted disc and an optical sensor). The state -// will toggle between 0 and 1 with filament movement. It can detect -// filament runout and stripouts or jams. + // Clear motion triggers for next block + motion_detected = 0; + } -class FilamentSensorTypeEncoder : public FilamentSensorTypeBase { - private: - static uint8_t motion_detected, old_state; + static inline void run() { poll_motion_sensor(); } + }; - static void poll_motion_sensor() { - const uint8_t new_state = poll_runout_pins(), - change = old_state ^ new_state; - old_state = new_state; +#else - #ifdef FILAMENT_RUNOUT_SENSOR_DEBUG - if (change) SERIAL_PROTOCOLLNPAIR("motion detected: ", change); - #endif + /** + * 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_pin(const uint8_t extruder) { + const uint8_t runout_bits = poll_runout_pins(); + #if NUM_RUNOUT_SENSORS == 1 + return runout_bits; // A single sensor applying to all extruders + #else + #if ENABLED(DUAL_X_CARRIAGE) + if (dual_x_carriage_mode == DXC_DUPLICATION_MODE || dual_x_carriage_mode == DXC_SCALED_DUPLICATION_MODE) + return runout_bits; // Any extruder + else + #elif ENABLED(DUAL_NOZZLE_DUPLICATION_MODE) + if (extruder_duplication_enabled) + return runout_bits; // Any extruder + else + #endif + return TEST(runout_bits, extruder); // Specific extruder + #endif + } - motion_detected |= change; - } + public: + static inline void block_completed(const block_t* const b) {} - public: - static void block_complete(const block_t *b) { - // If the just-executed block caused the sensor wheel - // to turn, reset the runout counter for that extruder. - if (TEST(motion_detected, b->extruder)) - filament_present(b->extruder); + static inline void run() { + const bool out = poll_runout_pin(active_extruder); + if (!out) filament_present(active_extruder); + #ifdef FILAMENT_RUNOUT_SENSOR_DEBUG + static bool was_out = false; + if (out != was_out) { + was_out = out; + SERIAL_PROTOCOL("Filament "); + serialprintPGM(out ? PSTR("OUT\n") : PSTR("IN\n")); + } + #endif + } + }; - // Clear motion triggers for next block - motion_detected = 0; - } - static inline void run() { poll_motion_sensor(); } -}; +#endif // !FILAMENT_MOTION_SENSOR /********************************* RESPONSE TYPE *********************************/ #if FILAMENT_RUNOUT_DISTANCE_MM > 0 - // The RunoutResponseDelayed will trigger an runout event only after - // RUNOUT_DISTANCE_MM of filament have been fed after a runout condition. + // RunoutResponseDelayed triggers a runout event only if the length + // of filament specified by FILAMENT_RUNOUT_DISTANCE_MM has been fed + // during a runout condition. class RunoutResponseDelayed { private: - static int32_t steps_since_detection[EXTRUDERS]; - - static float get_mm_since_runout(const uint8_t extruder) { - return (steps_since_detection[extruder] / planner.settings.axis_steps_per_mm[E_AXIS_N(extruder)]); - } + static volatile float runout_mm_countdown[EXTRUDERS]; public: static float runout_distance_mm; - static inline bool has_runout() { - return get_mm_since_runout(active_extruder) > runout_distance_mm; - } - - static inline void filament_present(const uint8_t extruder) { - steps_since_detection[extruder] = 0; + static void reset() { + LOOP_L_N(i, EXTRUDERS) filament_present(i); } static inline void run() { #ifdef FILAMENT_RUNOUT_SENSOR_DEBUG - static uint16_t r = 0; - if ((r++ % 24000) == 0) { - SERIAL_PROTOCOLPGM("mm since filament detection: "); - LOOP_L_N(i, NUM_RUNOUT_SENSORS) { - if (i > 0) SERIAL_PROTOCOLPGM(", "); - SERIAL_PROTOCOL(get_mm_since_runout(i)); + static millis_t t = 0; + const millis_t ms = millis(); + if (ELAPSED(ms, t)) { + t = millis() + 1000UL; + LOOP_L_N(i, EXTRUDERS) { + serialprintPGM(i ? PSTR(", ") : PSTR("Remaining mm: ")); + SERIAL_PROTOCOL(runout_mm_countdown[i]); } SERIAL_EOL(); } #endif } - static void reset() { - LOOP_L_N(i, NUM_RUNOUT_SENSORS) steps_since_detection[i] = 0; + static inline bool has_run_out() { + return runout_mm_countdown[active_extruder] < 0; } - static inline void block_complete(const block_t *b) { - steps_since_detection[b->extruder] += TEST(b->direction_bits, E_AXIS) ? -b->steps[E_AXIS] : b->steps[E_AXIS]; + static inline void filament_present(const uint8_t extruder) { + runout_mm_countdown[extruder] = runout_distance_mm; + } + + static inline void block_completed(const block_t* const b) { + const uint8_t e = b->extruder; + const int32_t steps = b->steps[E_AXIS]; + runout_mm_countdown[e] -= (TEST(b->direction_bits, E_AXIS) ? -steps : steps) * planner.steps_to_mm[E_AXIS_N(e)]; } }; #else // !FILAMENT_RUNOUT_DISTANCE_MM - // The RunoutResponseDebounced will trigger an runout event after - // a runout condition is detected FIL_RUNOUT_THRESHOLD times in a row. + // RunoutResponseDebounced triggers a runout event after a runout + // condition has been detected runout_threshold times in a row. class RunoutResponseDebounced { private: - static constexpr uint8_t FIL_RUNOUT_THRESHOLD = 5; - static uint8_t runout_count; + static constexpr int8_t runout_threshold = 5; + static int8_t runout_count; public: - static inline bool has_runout() { return runout_count > FIL_RUNOUT_THRESHOLD; } - static inline void block_complete(const block_t *b) {} - static inline void filament_present(const uint8_t extruder) { runout_count = 0; UNUSED(extruder); } - static inline void run() { runout_count++; } - static inline void reset() { runout_count = 0; } + static inline void reset() { runout_count = runout_threshold; } + static inline void run() { runout_count--; } + static inline bool has_run_out() { return runout_count < 0; } + static inline void block_completed(const block_t* const b) {} + static inline void filament_present(const uint8_t extruder) { runout_count = runout_threshold; UNUSED(extruder); } }; #endif // !FILAMENT_RUNOUT_DISTANCE_MM /********************************* TEMPLATE SPECIALIZATION *********************************/ -typedef TFilamentSensor< +typedef TFilamentMonitor< #if FILAMENT_RUNOUT_DISTANCE_MM > 0 #if ENABLED(FILAMENT_MOTION_SENSOR) - RunoutResponseDelayed, FilamentSensorTypeEncoder + RunoutResponseDelayed, FilamentSensorEncoder #else - RunoutResponseDelayed, FilamentSensorTypeSwitch + RunoutResponseDelayed, FilamentSensorSwitch #endif #else - RunoutResponseDebounced, FilamentSensorTypeSwitch + RunoutResponseDebounced, FilamentSensorSwitch #endif -> FilamentRunoutSensor; +> FilamentMonitor; -extern FilamentRunoutSensor runout; +extern FilamentMonitor runout; diff --git a/Marlin/src/module/stepper.cpp b/Marlin/src/module/stepper.cpp index e5bc14f36..e9593730c 100644 --- a/Marlin/src/module/stepper.cpp +++ b/Marlin/src/module/stepper.cpp @@ -1492,7 +1492,7 @@ uint32_t Stepper::stepper_block_phase_isr() { // If current block is finished, reset pointer if (step_events_completed >= step_event_count) { #if FILAMENT_RUNOUT_DISTANCE_MM > 0 - runout.block_complete(current_block); + runout.block_completed(current_block); #endif axis_did_move = 0; current_block = NULL; diff --git a/Marlin/src/pins/pins.h b/Marlin/src/pins/pins.h index 7b8c64bde..9160b135f 100644 --- a/Marlin/src/pins/pins.h +++ b/Marlin/src/pins/pins.h @@ -149,7 +149,7 @@ #elif MB(RAMPS_ENDER_4) #include "pins_RAMPS_ENDER_4.h" // ATmega2560 env:megaatmega2560 #elif MB(RAMPS_CREALITY) - #include "pins_RAMPS_CREALITY.h" // ATmega2560 env:megaatmega2560 + #include "pins_RAMPS_CREALITY.h" // ATmega2560 env:megaatmega2560 #elif MB(FYSETC_F6_13) #include "pins_FYSETC_F6_13.h" // ATmega2560 env:megaatmega2560