bissen21/Marlin_Firmware
1
0
Fork 0
Code Issues Pull Requests Projects Releases 4 Wiki Activity

Merge pull request #4054 from jbrazio/feature/g12-clean-tool

Browse Source 
Implements clean nozzle feature (Lulzbot's REWIPE)
This commit is contained in:
Scott Lahteine 2016-07-14 14:38:38 -07:00 committed by GitHub
commit 8bf6861af8
27 changed files with 1302 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.travis.yml
View File

@ -211,6 +211,12 @@ script:
- opt_enable PRINTCOUNTER
- build_marlin
#
# Test CLEAN_NOZZLE_FEATURE
#
- restore_configs
- opt_enable AUTO_BED_LEVELING_FEATURE CLEAN_NOZZLE_FEATURE FIX_MOUNTED_PROBE
- build_marlin
#
#
######## STANDARD LCD/PANELS ##############
#

48
Marlin/Configuration.h
View File

@ -787,6 +787,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 110
#define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

45
Marlin/Marlin_main.cpp
View File

@ -106,8 +106,9 @@
* G3 - CCW ARC
* G4 - Dwell S<seconds> or P<milliseconds>
* G5 - Cubic B-spline with XYZE destination and IJPQ offsets
* G10 - retract filament according to settings of M207
* G11 - retract recover filament according to settings of M208
* G10 - Retract filament according to settings of M207
* G11 - Retract recover filament according to settings of M208
* G12 - Clean tool
* G20 - Set input units to inches
* G21 - Set input units to millimeters
* G28 - Home one or more axes
@ -1695,6 +1696,10 @@ static void clean_up_after_endstop_or_probe_move() {
do_blocking_move_to(x, current_position[Y_AXIS], current_position[Z_AXIS], feed_rate);
}
inline void do_blocking_move_to_y(float y) {
do_blocking_move_to(current_position[X_AXIS], y, current_position[Z_AXIS]);
}
inline void do_blocking_move_to_z(float z, float feed_rate = 0.0) {
do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], z, feed_rate);
}
@ -2704,6 +2709,21 @@ inline void gcode_G4() {
#endif //FWRETRACT
#if ENABLED(NOZZLE_CLEAN_FEATURE) && ENABLED(AUTO_BED_LEVELING_FEATURE)
#include "nozzle.h"
inline void gcode_G12() {
// Don't allow nozzle cleaning without homing first
if (axis_unhomed_error(true, true, true)) { return; }
uint8_t const pattern = code_seen('P') ? code_value_ushort() : 0;
uint8_t const strokes = code_seen('S') ? code_value_ushort() : NOZZLE_CLEAN_STROKES;
uint8_t const objects = code_seen('T') ? code_value_ushort() : 3;
Nozzle::clean(pattern, strokes, objects);
}
#endif
#if ENABLED(INCH_MODE_SUPPORT)
/**
* G20: Set input mode to inches
@ -6750,12 +6770,10 @@ void process_next_command() {
// G2, G3
#if ENABLED(ARC_SUPPORT) && DISABLED(SCARA)
case 2: // G2 - CW ARC
case 3: // G3 - CCW ARC
gcode_G2_G3(codenum == 2);
break;
#endif
// G4 Dwell
@ -6764,23 +6782,25 @@ void process_next_command() {
break;
#if ENABLED(BEZIER_CURVE_SUPPORT)
// G5
case 5: // G5 - Cubic B_spline
gcode_G5();
break;
#endif // BEZIER_CURVE_SUPPORT
#if ENABLED(FWRETRACT)
case 10: // G10: retract
case 11: // G11: retract_recover
gcode_G10_G11(codenum == 10);
break;
#endif // FWRETRACT
#if ENABLED(NOZZLE_CLEAN_FEATURE) && HAS_BED_PROBE
case 12:
gcode_G12(); // G12: Clean Nozzle
break;
#endif // NOZZLE_CLEAN_FEATURE
#if ENABLED(INCH_MODE_SUPPORT)
case 20: //G20: Inch Mode
gcode_G20();
@ -6789,7 +6809,7 @@ void process_next_command() {
case 21: //G21: MM Mode
gcode_G21();
break;
#endif
#endif // INCH_MODE_SUPPORT
case 28: // G28: Home all axes, one at a time
gcode_G28();
@ -6799,7 +6819,7 @@ void process_next_command() {
case 29: // G29 Detailed Z probe, probes the bed at 3 or more points.
gcode_G29();
break;
#endif
#endif // AUTO_BED_LEVELING_FEATURE
#if HAS_BED_PROBE
@ -6818,7 +6838,6 @@ void process_next_command() {
break;
#endif // Z_PROBE_SLED
#endif // HAS_BED_PROBE
case 90: // G90
@ -6847,7 +6866,6 @@ void process_next_command() {
break;
#if ENABLED(SDSUPPORT)
case 20: // M20 - list SD card
gcode_M20(); break;
case 21: // M21 - init SD card
@ -6880,7 +6898,6 @@ void process_next_command() {
case 928: //M928 - Start SD write
gcode_M928(); break;
#endif //SDSUPPORT
case 31: //M31 take time since the start of the SD print or an M109 command
@ -6950,11 +6967,9 @@ void process_next_command() {
#endif
#if ENABLED(HOST_KEEPALIVE_FEATURE)
case 113: // M113: Set Host Keepalive interval
gcode_M113();
break;
#endif
case 140: // M140: Set bed temp

7
Marlin/SanityCheck.h
View File

@ -646,4 +646,11 @@
#error "ABS_PREHEAT_FAN_SPEED is now PREHEAT_2_FAN_SPEED. Please update your configuration."
#endif
/**
* Nozzle cleaning
*/
#if ENABLED(NOZZLE_CLEAN_FEATURE) && !HAS_BED_PROBE
#error Due to internal dependencies you must have a bed probe for NOZZLE_CLEAN_FEATURE to work
#endif
#endif //SANITYCHECK_H

54
Marlin/example_configurations/Cartesio/Configuration.h
View File

@ -268,12 +268,12 @@
#define DEFAULT_Kp 18
#define DEFAULT_Ki 1
#define DEFAULT_Kd 100
// Cartesio extruderV6 40W Volcano
//#define DEFAULT_Kp 50
//#define DEFAULT_Ki 9
//#define DEFAULT_Kd 70
// Cartesio extruderV6 40W Cyclops
//#define DEFAULT_Kp 18
//#define DEFAULT_Ki 1
@ -313,7 +313,7 @@
#define DEFAULT_bedKp 390
#define DEFAULT_bedKi 70
#define DEFAULT_bedKd 546
//24V 250W silicone heater on to 4mm glass CartesioM
//#define DEFAULT_bedKp 303
//#define DEFAULT_bedKi 42
@ -786,6 +786,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 110
#define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/Felix/Configuration.h
View File

@ -770,6 +770,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/Felix/DUAL/Configuration.h
View File

@ -768,6 +768,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/Hephestos/Configuration.h
View File

@ -779,6 +779,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = true; // set to true to invert the lo
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/Hephestos_2/Configuration.h
View File

@ -781,6 +781,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 110
#define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/K8200/Configuration.h
View File

@ -804,6 +804,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 60 // K8200: set back to 110 if you have an upgraded heatbed power supply
#define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/K8400/Configuration.h
View File

@ -787,6 +787,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = true; // set to true to invert the lo
#define PREHEAT_2_TEMP_BED 0
#define PREHEAT_2_FAN_SPEED 165 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/K8400/Dual Heads/Configuration.h → Marlin/example_configurations/K8400/Dual-head/Configuration.h
View File

@ -787,6 +787,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = true; // set to true to invert the lo
#define PREHEAT_2_TEMP_BED 0
#define PREHEAT_2_FAN_SPEED 165 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h
View File

@ -787,6 +787,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 110
#define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/RigidBot/Configuration.h
View File

@ -785,6 +785,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 110
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/SCARA/Configuration.h
View File

@ -795,6 +795,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/TAZ4/Configuration.h
View File

@ -808,6 +808,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 110
#define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/WITBOX/Configuration.h
View File

@ -779,6 +779,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = true; // set to true to invert the lo
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/adafruit/ST7565/Configuration.h
View File

@ -787,6 +787,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 110
#define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/delta/biv2.5/Configuration.h
View File

@ -882,6 +882,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = true; // set to true to invert the lo
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/delta/generic/Configuration.h
View File

@ -876,6 +876,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = true; // set to true to invert the lo
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/delta/kossel_mini/Configuration.h
View File

@ -879,6 +879,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/delta/kossel_pro/Configuration.h
View File

@ -879,6 +879,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/delta/kossel_xl/Configuration.h
View File

@ -881,6 +881,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/makibox/Configuration.h
View File

@ -790,6 +790,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

48
Marlin/example_configurations/tvrrug/Round2/Configuration.h
View File

@ -781,6 +781,54 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = true; // set to true to invert the lo
#define PREHEAT_2_TEMP_BED 100
#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255
//
// Clean Nozzle Feature -- EXPERIMENTAL
//
// When enabled allows the user to send G12 to start the nozzle cleaning
// process, the G-Code accepts two parameters:
// "P" for pattern selection
// "S" for defining the number of strokes/repetitions
//
// Available list of patterns:
// P0: This is the default pattern, this process requires a sponge type
// material at a fixed bed location, the cleaning process is based on
// "strokes" i.e. back-and-forth movements between the starting and end
// points.
//
// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T"
// defines the number of zig-zag triangles to be done. "S" defines the
// number of strokes aka one back-and-forth movement. As an example
// sending "G12 P1 S1 T3" will execute:
//
// --
// | (X0, Y1) | /\ /\ /\ | (X1, Y1)
// | | / \ / \ / \ |
// A | | / \ / \ / \ |
// | | / \ / \ / \ |
// | (X0, Y0) | / \/ \/ \ | (X1, Y0)
// -- +--------------------------------+
// |________|_________|_________|
// T1 T2 T3
//
// Caveats: End point Z should use the same value as Start point Z.
//
// Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments
// may change to add new functionality like different wipe patterns.
//
//#define NOZZLE_CLEAN_FEATURE
#if ENABLED(NOZZLE_CLEAN_FEATURE)
// Number of pattern repetitions
#define NOZZLE_CLEAN_STROKES 12
// { X, Y, Z}
#define NOZZLE_CLEAN_START_PT { 30, 30, (Z_MIN_POS + 5)}
#define NOZZLE_CLEAN_END_PT {100, 60, (Z_MIN_POS + 5)}
// Moves the nozzle to the parked position
#define NOZZLE_CLEAN_PARK
#endif
//
// Print job timer
//

154
Marlin/nozzle.h Normal file
View File

@ -0,0 +1,154 @@
/*
* 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/>.
*
*/
#ifndef __NOZZLE_H__
#define __NOZZLE_H__
#include "Marlin.h"
#include "point_t.h"
/**
* @brief Nozzle class
*
* @todo: Do not ignore the end.z value and allow XYZ movements
* @todo: Currently this feature needs HAS_BED_PROBE to be active
* due to the do_blocking_move_to*() functions.
*/
class Nozzle {
private:
/**
* @brief Stroke clean pattern
* @details Wipes the nozzle back and forth in a linear movement
*
* @param start point_t defining the starting point
* @param end point_t defining the ending point
* @param strokes number of strokes to execute
*/
static void stroke(point_t const &start, point_t const &end, uint8_t const &strokes)
__attribute__ ((optimize ("Os"))) {
#if ENABLED(NOZZLE_CLEAN_PARK)
// Store the current coords
point_t const initial = {
current_position[X_AXIS],
current_position[Y_AXIS],
current_position[Z_AXIS],
current_position[E_AXIS]
};
#endif
// Move to the starting point
do_blocking_move_to_xy(start.x, start.y);
do_blocking_move_to_z(start.z);
// Start the stroke pattern
for (uint8_t i = 0; i < (strokes >>1); i++) {
do_blocking_move_to_xy(end.x, end.y);
do_blocking_move_to_xy(start.x, start.y);
}
#if ENABLED(NOZZLE_CLEAN_PARK)
// Move the nozzle to the initial point
do_blocking_move_to_z(initial.z);
do_blocking_move_to_xy(initial.x, initial.y);
#endif
}
/**
* @brief Zig-zag clean pattern
* @details Apply a zig-zag cleanning pattern
*
* @param start point_t defining the starting point
* @param end point_t defining the ending point
* @param strokes number of strokes to execute
* @param objects number of objects to create
*/
static void zigzag(point_t const &start,
point_t const &end, uint8_t const &strokes, uint8_t const &objects)
__attribute__ ((optimize ("Os"))) {
float A = fabs(end.y - start.y); // [twice the] Amplitude
float P = fabs(end.x - start.x) / (objects << 1); // Period
// Don't allow impossible triangles
if (A <= 0.0f || P <= 0.0f ) return;
#if ENABLED(NOZZLE_CLEAN_PARK)
// Store the current coords
point_t const initial = {
current_position[X_AXIS],
current_position[Y_AXIS],
current_position[Z_AXIS],
current_position[E_AXIS]
};
#endif
for (uint8_t j = 0; j < strokes; j++) {
for (uint8_t i = 0; i < (objects << 1); i++) {
float const x = start.x + i * P;
float const y = start.y + (A/P) * (P - fabs(fmod((i*P), (2*P)) - P));
do_blocking_move_to_xy(x, y);
if (i == 0) do_blocking_move_to_z(start.z);
}
for (int i = (objects << 1); i > -1; i--) {
float const x = start.x + i * P;
float const y = start.y + (A/P) * (P - fabs(fmod((i*P), (2*P)) - P));
do_blocking_move_to_xy(x, y);
}
}
#if ENABLED(NOZZLE_CLEAN_PARK)
// Move the nozzle to the initial point
do_blocking_move_to_z(initial.z);
do_blocking_move_to_xy(initial.x, initial.y);
#endif
}
public:
/**
* @brief Clean the nozzle
* @details Starts the selected clean procedure pattern
*
* @param pattern one of the available patterns
* @param argument depends on the cleaning pattern
*/
static void clean(uint8_t const &pattern,
uint8_t const &strokes, uint8_t const &objects = 0)
__attribute__ ((optimize ("Os"))) {
switch (pattern) {
case 1:
Nozzle::zigzag(
NOZZLE_CLEAN_START_PT,
NOZZLE_CLEAN_END_PT, strokes, objects);
break;
default:
Nozzle::stroke(
NOZZLE_CLEAN_START_PT,
NOZZLE_CLEAN_END_PT, strokes);
}
}
};
#endif

46
Marlin/point_t.h Normal file
View File

@ -0,0 +1,46 @@
/**
* 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/>.
*
*/
#ifndef __POINT_T__
#define __POINT_T__
struct point_t {
float x;
float y;
float z;
float e;
point_t(float const x, float const y)
: point_t(x, y, NAN, NAN) {}
point_t(float const x, float const y, float const z)
: point_t(x, y, z, NAN) {}
point_t(float const x, float const y, float const z, float const e) {
this->x = x;
this->y = y;
this->z = z;
this->e = e;
}
};
#endif