You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
308 lines
9.4 KiB
C++
308 lines
9.4 KiB
C++
/**
|
|
* Marlin 3D Printer Firmware
|
|
* Copyright (C) 2016 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 <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
#pragma once
|
|
|
|
/**
|
|
* feature/runout.h - Runout sensor support
|
|
*/
|
|
|
|
#include "../sd/cardreader.h"
|
|
#include "../module/printcounter.h"
|
|
#include "../module/stepper.h"
|
|
#include "../gcode/queue.h"
|
|
|
|
#include "../inc/MarlinConfig.h"
|
|
|
|
#if ENABLED(EXTENSIBLE_UI)
|
|
#include "../lcd/extensible_ui/ui_api.h"
|
|
#endif
|
|
|
|
//#define FILAMENT_RUNOUT_SENSOR_DEBUG
|
|
|
|
class FilamentSensorBase {
|
|
public:
|
|
static bool enabled;
|
|
|
|
protected:
|
|
static bool filament_ran_out;
|
|
};
|
|
|
|
template<class RESPONSE_T, class SENSOR_T>
|
|
class TFilamentSensor : public FilamentSensorBase {
|
|
private:
|
|
typedef RESPONSE_T response_t;
|
|
typedef SENSOR_T sensor_t;
|
|
static response_t response;
|
|
static sensor_t sensor;
|
|
|
|
public:
|
|
static void setup() {
|
|
sensor.setup();
|
|
}
|
|
|
|
static inline void reset() {
|
|
filament_ran_out = false;
|
|
response.reset();
|
|
}
|
|
|
|
// The sensor calls this method when filament is present
|
|
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);
|
|
}
|
|
|
|
static void run() {
|
|
if (enabled && !filament_ran_out && (IS_SD_PRINTING() || print_job_timer.isRunning())) {
|
|
response.run();
|
|
sensor.run();
|
|
if (response.has_runout()) {
|
|
filament_ran_out = true;
|
|
#if ENABLED(EXTENSIBLE_UI)
|
|
UI::onFilamentRunout();
|
|
#endif
|
|
enqueue_and_echo_commands_P(PSTR(FILAMENT_RUNOUT_SCRIPT));
|
|
planner.synchronize();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/*************************** FILAMENT PRESENCE SENSORS ***************************/
|
|
|
|
class FilamentSensorTypeBase {
|
|
protected:
|
|
static void filament_present(const uint8_t extruder);
|
|
|
|
public:
|
|
static void setup() {
|
|
#if ENABLED(FIL_RUNOUT_PULLUP)
|
|
#define INIT_RUNOUT_PIN(P) SET_INPUT_PULLUP(P)
|
|
#elif ENABLED(FIL_RUNOUT_PULLDOWN)
|
|
#define INIT_RUNOUT_PIN(P) SET_INPUT_PULLDOWN(P)
|
|
#else
|
|
#define INIT_RUNOUT_PIN(P) SET_INPUT(P)
|
|
#endif
|
|
|
|
INIT_RUNOUT_PIN(FIL_RUNOUT_PIN);
|
|
#if NUM_RUNOUT_SENSORS > 1
|
|
INIT_RUNOUT_PIN(FIL_RUNOUT2_PIN);
|
|
#if NUM_RUNOUT_SENSORS > 2
|
|
INIT_RUNOUT_PIN(FIL_RUNOUT3_PIN);
|
|
#if NUM_RUNOUT_SENSORS > 3
|
|
INIT_RUNOUT_PIN(FIL_RUNOUT4_PIN);
|
|
#if NUM_RUNOUT_SENSORS > 4
|
|
INIT_RUNOUT_PIN(FIL_RUNOUT5_PIN);
|
|
#if NUM_RUNOUT_SENSORS > 5
|
|
INIT_RUNOUT_PIN(FIL_RUNOUT6_PIN);
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
#if FIL_RUNOUT_INVERTING
|
|
#define FIL_RUNOUT_INVERT_MASK (_BV(NUM_RUNOUT_SENSORS) - 1)
|
|
#else
|
|
#define FIL_RUNOUT_INVERT_MASK 0
|
|
#endif
|
|
|
|
// Return a bitmask of all runout sensor states
|
|
static uint8_t poll_runout_pins() {
|
|
return (
|
|
(READ(FIL_RUNOUT_PIN ) ? _BV(0) : 0)
|
|
#if NUM_RUNOUT_SENSORS > 1
|
|
| (READ(FIL_RUNOUT2_PIN) ? _BV(1) : 0)
|
|
#if NUM_RUNOUT_SENSORS > 2
|
|
| (READ(FIL_RUNOUT3_PIN) ? _BV(2) : 0)
|
|
#if NUM_RUNOUT_SENSORS > 3
|
|
| (READ(FIL_RUNOUT4_PIN) ? _BV(3) : 0)
|
|
#if NUM_RUNOUT_SENSORS > 4
|
|
| (READ(FIL_RUNOUT5_PIN) ? _BV(4) : 0)
|
|
#if NUM_RUNOUT_SENSORS > 5
|
|
| (READ(FIL_RUNOUT6_PIN) ? _BV(5) : 0)
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#endif
|
|
) ^ FIL_RUNOUT_INVERT_MASK;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 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:
|
|
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
|
|
}
|
|
|
|
public:
|
|
FORCE_INLINE static void block_complete(const block_t *b) {}
|
|
|
|
FORCE_INLINE static void run() {
|
|
if (!poll_runout_pin(active_extruder))
|
|
filament_present(active_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.
|
|
|
|
class FilamentSensorTypeEncoder : public FilamentSensorTypeBase {
|
|
private:
|
|
static uint8_t motion_detected, old_state;
|
|
|
|
static void poll_motion_sensor() {
|
|
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: ", change);
|
|
#endif
|
|
|
|
motion_detected |= change;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
FORCE_INLINE static void run() { poll_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.
|
|
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)]);
|
|
}
|
|
|
|
public:
|
|
static float runout_distance_mm;
|
|
|
|
FORCE_INLINE static 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 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));
|
|
}
|
|
SERIAL_EOL();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void reset() {
|
|
LOOP_L_N(i, NUM_RUNOUT_SENSORS) steps_since_detection[i] = 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];
|
|
}
|
|
};
|
|
|
|
#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.
|
|
|
|
class RunoutResponseDebounced {
|
|
private:
|
|
static constexpr uint8_t FIL_RUNOUT_THRESHOLD = 5;
|
|
static uint8_t runout_count;
|
|
public:
|
|
FORCE_INLINE static bool has_runout() { return runout_count > FIL_RUNOUT_THRESHOLD; }
|
|
FORCE_INLINE static void block_complete(const block_t *b) {}
|
|
FORCE_INLINE static void filament_present(const uint8_t extruder) { runout_count = 0; UNUSED(extruder); }
|
|
FORCE_INLINE static void run() { runout_count++; }
|
|
FORCE_INLINE static void reset() { runout_count = 0; }
|
|
};
|
|
|
|
#endif // !FILAMENT_RUNOUT_DISTANCE_MM
|
|
|
|
/********************************* TEMPLATE SPECIALIZATION *********************************/
|
|
|
|
typedef TFilamentSensor<
|
|
#if FILAMENT_RUNOUT_DISTANCE_MM > 0
|
|
#if ENABLED(FILAMENT_MOTION_SENSOR)
|
|
RunoutResponseDelayed, FilamentSensorTypeEncoder
|
|
#else
|
|
RunoutResponseDelayed, FilamentSensorTypeSwitch
|
|
#endif
|
|
#else
|
|
RunoutResponseDebounced, FilamentSensorTypeSwitch
|
|
#endif
|
|
> FilamentRunoutSensor;
|
|
|
|
extern FilamentRunoutSensor runout;
|