andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Rejigger Filament Runout class (#12428)

pull/1/head
Scott Lahteine 6 years ago
committed by GitHub
parent
f4c128ecaa
commit
edfd106bc5
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 154 additions and 119 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 24
      Marlin/src/feature/runout.cpp
  2. 245
      Marlin/src/feature/runout.h
  3. 2
      Marlin/src/module/stepper.cpp
  4. 2
      Marlin/src/pins/pins.h

24
Marlin/src/feature/runout.cpp
View File

@ -30,23 +30,29 @@
#include "runout.h" #include "runout.h"
FilamentRunoutSensor runout; FilamentMonitor runout;
bool FilamentSensorBase::enabled = true, bool FilamentMonitorBase::enabled = true,
FilamentSensorBase::filament_ran_out; // = false 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, #if ENABLED(FILAMENT_MOTION_SENSOR)
FilamentSensorTypeEncoder::old_state; // = 0 uint8_t FilamentSensorEncoder::motion_detected,
FilamentSensorEncoder::old_state; // = 0
#endif
#if FILAMENT_RUNOUT_DISTANCE_MM > 0 #if FILAMENT_RUNOUT_DISTANCE_MM > 0
float RunoutResponseDelayed::runout_distance_mm = FILAMENT_RUNOUT_DISTANCE_MM; float RunoutResponseDelayed::runout_distance_mm = FILAMENT_RUNOUT_DISTANCE_MM;
int32_t RunoutResponseDelayed::steps_since_detection[EXTRUDERS]; volatile float RunoutResponseDelayed::runout_mm_countdown[EXTRUDERS];
#else #else
uint8_t RunoutResponseDebounced::runout_count; // = 0 int8_t RunoutResponseDebounced::runout_count; // = 0
#endif #endif
#endif // FILAMENT_RUNOUT_SENSOR #endif // FILAMENT_RUNOUT_SENSOR

245
Marlin/src/feature/runout.h
View File

@ -38,7 +38,7 @@
//#define FILAMENT_RUNOUT_SENSOR_DEBUG //#define FILAMENT_RUNOUT_SENSOR_DEBUG
class FilamentSensorBase { class FilamentMonitorBase {
public: public:
static bool enabled; static bool enabled;
@ -47,16 +47,17 @@ class FilamentSensorBase {
}; };
template<class RESPONSE_T, class SENSOR_T> template<class RESPONSE_T, class SENSOR_T>
class TFilamentSensor : public FilamentSensorBase { class TFilamentMonitor : public FilamentMonitorBase {
private: private:
typedef RESPONSE_T response_t; typedef RESPONSE_T response_t;
typedef SENSOR_T sensor_t; typedef SENSOR_T sensor_t;
static response_t response; static response_t response;
static sensor_t sensor; static sensor_t sensor;
public: public:
static void setup() { static inline void setup() {
sensor.setup(); sensor.setup();
reset();
} }
static inline void reset() { static inline void reset() {
@ -64,21 +65,34 @@ class TFilamentSensor : public FilamentSensorBase {
response.reset(); 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) { static inline void filament_present(const uint8_t extruder) {
response.filament_present(extruder); response.filament_present(extruder);
} }
static inline void block_complete(const block_t *b) { // Handle a block completion. RunoutResponseDelayed uses this to
response.block_complete(b); // add up the length of filament moved while the filament is out.
sensor.block_complete(b); 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 (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(); response.run();
sensor.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; filament_ran_out = true;
#if ENABLED(EXTENSIBLE_UI) #if ENABLED(EXTENSIBLE_UI)
UI::onFilamentRunout(); UI::onFilamentRunout();
@ -92,7 +106,7 @@ class TFilamentSensor : public FilamentSensorBase {
/*************************** FILAMENT PRESENCE SENSORS ***************************/ /*************************** FILAMENT PRESENCE SENSORS ***************************/
class FilamentSensorTypeBase { class FilamentSensorBase {
protected: protected:
static void filament_present(const uint8_t extruder); static void filament_present(const uint8_t extruder);
@ -153,155 +167,170 @@ class FilamentSensorTypeBase {
} }
}; };
/** #if ENABLED(FILAMENT_MOTION_SENSOR)
* This sensor is a simple endstop
* switch in the path of the filament. It detects
* filament runout, but not stripouts or jams.
*/
class FilamentSensorTypeSwitch : public FilamentSensorTypeBase { /**
private: * This sensor uses a magnetic encoder disc and a Hall effect
static bool poll_runout_pin(const uint8_t extruder) { * sensor (or a slotted disc and optical sensor). The state
const uint8_t runout_bits = poll_runout_pins(); * will toggle between 0 and 1 on filament movement. It can detect
#if NUM_RUNOUT_SENSORS == 1 * filament runout and stripouts or jams.
return runout_bits; // A single sensor applying to all extruders */
#else class FilamentSensorEncoder : public FilamentSensorBase {
#if ENABLED(DUAL_X_CARRIAGE) private:
if (dual_x_carriage_mode == DXC_DUPLICATION_MODE || dual_x_carriage_mode == DXC_SCALED_DUPLICATION_MODE) static uint8_t motion_detected;
return runout_bits; // Any extruder
else static inline void poll_motion_sensor() {
#elif ENABLED(DUAL_NOZZLE_DUPLICATION_MODE) static uint8_t old_state;
if (extruder_duplication_enabled) const uint8_t new_state = poll_runout_pins(),
return runout_bits; // Any extruder change = old_state ^ new_state;
else old_state = new_state;
#ifdef FILAMENT_RUNOUT_SENSOR_DEBUG
if (change) SERIAL_PROTOCOLLNPAIR("Motion detected: ", int(change));
#endif #endif
return TEST(runout_bits, extruder); // Specific extruder
#endif
}
public: motion_detected |= change;
static inline void block_complete(const block_t *b) {} }
static inline void run() { public:
if (!poll_runout_pin(active_extruder)) static inline void block_completed(const block_t* const b) {
filament_present(active_extruder); // 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;
}
// This filament sensor uses a magnetic encoder disc and a hall static inline void run() { poll_motion_sensor(); }
// 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.
class FilamentSensorTypeEncoder : public FilamentSensorTypeBase { #else
private:
static uint8_t motion_detected, old_state;
static void poll_motion_sensor() { /**
const uint8_t new_state = poll_runout_pins(), * This is a simple endstop switch in the path of the filament.
change = old_state ^ new_state; * It can detect filament runout, but not stripouts or jams.
old_state = new_state; */
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
}
#ifdef FILAMENT_RUNOUT_SENSOR_DEBUG public:
if (change) SERIAL_PROTOCOLLNPAIR("motion detected: ", change); static inline void block_completed(const block_t* const b) {}
#endif
motion_detected |= change; 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
}
};
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);
// Clear motion triggers for next block
motion_detected = 0;
}
static inline void run() { poll_motion_sensor(); } #endif // !FILAMENT_MOTION_SENSOR
};
/********************************* RESPONSE TYPE *********************************/ /********************************* RESPONSE TYPE *********************************/
#if FILAMENT_RUNOUT_DISTANCE_MM > 0 #if FILAMENT_RUNOUT_DISTANCE_MM > 0
// The RunoutResponseDelayed will trigger an runout event only after // RunoutResponseDelayed triggers a runout event only if the length
// RUNOUT_DISTANCE_MM of filament have been fed after a runout condition. // of filament specified by FILAMENT_RUNOUT_DISTANCE_MM has been fed
// during a runout condition.
class RunoutResponseDelayed { class RunoutResponseDelayed {
private: private:
static int32_t steps_since_detection[EXTRUDERS]; static volatile float runout_mm_countdown[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)]);
}
public: public:
static float runout_distance_mm; static float runout_distance_mm;
static inline bool has_runout() { static void reset() {
return get_mm_since_runout(active_extruder) > runout_distance_mm; LOOP_L_N(i, EXTRUDERS) filament_present(i);
}
static inline void filament_present(const uint8_t extruder) {
steps_since_detection[extruder] = 0;
} }
static inline void run() { static inline void run() {
#ifdef FILAMENT_RUNOUT_SENSOR_DEBUG #ifdef FILAMENT_RUNOUT_SENSOR_DEBUG
static uint16_t r = 0; static millis_t t = 0;
if ((r++ % 24000) == 0) { const millis_t ms = millis();
SERIAL_PROTOCOLPGM("mm since filament detection: "); if (ELAPSED(ms, t)) {
LOOP_L_N(i, NUM_RUNOUT_SENSORS) { t = millis() + 1000UL;
if (i > 0) SERIAL_PROTOCOLPGM(", "); LOOP_L_N(i, EXTRUDERS) {
SERIAL_PROTOCOL(get_mm_since_runout(i)); serialprintPGM(i ? PSTR(", ") : PSTR("Remaining mm: "));
SERIAL_PROTOCOL(runout_mm_countdown[i]);
} }
SERIAL_EOL(); SERIAL_EOL();
} }
#endif #endif
} }
static void reset() { static inline bool has_run_out() {
LOOP_L_N(i, NUM_RUNOUT_SENSORS) steps_since_detection[i] = 0; return runout_mm_countdown[active_extruder] < 0;
}
static inline void filament_present(const uint8_t extruder) {
runout_mm_countdown[extruder] = runout_distance_mm;
} }
static inline void block_complete(const block_t *b) { static inline void block_completed(const block_t* const b) {
steps_since_detection[b->extruder] += TEST(b->direction_bits, E_AXIS) ? -b->steps[E_AXIS] : b->steps[E_AXIS]; 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 #else // !FILAMENT_RUNOUT_DISTANCE_MM
// The RunoutResponseDebounced will trigger an runout event after // RunoutResponseDebounced triggers a runout event after a runout
// a runout condition is detected FIL_RUNOUT_THRESHOLD times in a row. // condition has been detected runout_threshold times in a row.
class RunoutResponseDebounced { class RunoutResponseDebounced {
private: private:
static constexpr uint8_t FIL_RUNOUT_THRESHOLD = 5; static constexpr int8_t runout_threshold = 5;
static uint8_t runout_count; static int8_t runout_count;
public: public:
static inline bool has_runout() { return runout_count > FIL_RUNOUT_THRESHOLD; } static inline void reset() { runout_count = runout_threshold; }
static inline void block_complete(const block_t *b) {} static inline void run() { runout_count--; }
static inline void filament_present(const uint8_t extruder) { runout_count = 0; UNUSED(extruder); } static inline bool has_run_out() { return runout_count < 0; }
static inline void run() { runout_count++; } static inline void block_completed(const block_t* const b) {}
static inline void reset() { runout_count = 0; } static inline void filament_present(const uint8_t extruder) { runout_count = runout_threshold; UNUSED(extruder); }
}; };
#endif // !FILAMENT_RUNOUT_DISTANCE_MM #endif // !FILAMENT_RUNOUT_DISTANCE_MM
/********************************* TEMPLATE SPECIALIZATION *********************************/ /********************************* TEMPLATE SPECIALIZATION *********************************/
typedef TFilamentSensor< typedef TFilamentMonitor<
#if FILAMENT_RUNOUT_DISTANCE_MM > 0 #if FILAMENT_RUNOUT_DISTANCE_MM > 0
#if ENABLED(FILAMENT_MOTION_SENSOR) #if ENABLED(FILAMENT_MOTION_SENSOR)
RunoutResponseDelayed, FilamentSensorTypeEncoder RunoutResponseDelayed, FilamentSensorEncoder
#else #else
RunoutResponseDelayed, FilamentSensorTypeSwitch RunoutResponseDelayed, FilamentSensorSwitch
#endif #endif
#else #else
RunoutResponseDebounced, FilamentSensorTypeSwitch RunoutResponseDebounced, FilamentSensorSwitch
#endif #endif
> FilamentRunoutSensor; > FilamentMonitor;
extern FilamentRunoutSensor runout; extern FilamentMonitor runout;

2
Marlin/src/module/stepper.cpp
View File

@ -1492,7 +1492,7 @@ uint32_t Stepper::stepper_block_phase_isr() {
// If current block is finished, reset pointer // If current block is finished, reset pointer
if (step_events_completed >= step_event_count) { if (step_events_completed >= step_event_count) {
#if FILAMENT_RUNOUT_DISTANCE_MM > 0 #if FILAMENT_RUNOUT_DISTANCE_MM > 0
runout.block_complete(current_block); runout.block_completed(current_block);
#endif #endif
axis_did_move = 0; axis_did_move = 0;
current_block = NULL; current_block = NULL;

2
Marlin/src/pins/pins.h
View File

@ -149,7 +149,7 @@
#elif MB(RAMPS_ENDER_4) #elif MB(RAMPS_ENDER_4)
#include "pins_RAMPS_ENDER_4.h" // ATmega2560 env:megaatmega2560 #include "pins_RAMPS_ENDER_4.h" // ATmega2560 env:megaatmega2560
#elif MB(RAMPS_CREALITY) #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) #elif MB(FYSETC_F6_13)
#include "pins_FYSETC_F6_13.h" // ATmega2560 env:megaatmega2560 #include "pins_FYSETC_F6_13.h" // ATmega2560 env:megaatmega2560

Write Preview
Loading…
Cancel
Save