From 68c343a09a85183aba7c3e47a4b1eecf2cc61236 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Br=C3=A1zio?= Date: Thu, 14 Jul 2016 00:38:42 +0100 Subject: [PATCH] Added G12 configuration options to all configs --- Marlin/Configuration.h | 17 +++--- .../Cartesio/Configuration.h | 54 +++++++++++++++++-- .../Felix/Configuration.h | 48 +++++++++++++++++ .../Felix/DUAL/Configuration.h | 48 +++++++++++++++++ .../Hephestos/Configuration.h | 48 +++++++++++++++++ .../Hephestos_2/Configuration.h | 48 +++++++++++++++++ .../K8200/Configuration.h | 48 +++++++++++++++++ .../K8400/Configuration.h | 48 +++++++++++++++++ .../{Dual Heads => Dual-head}/Configuration.h | 48 +++++++++++++++++ .../RepRapWorld/Megatronics/Configuration.h | 48 +++++++++++++++++ .../RigidBot/Configuration.h | 48 +++++++++++++++++ .../SCARA/Configuration.h | 48 +++++++++++++++++ .../TAZ4/Configuration.h | 48 +++++++++++++++++ .../WITBOX/Configuration.h | 48 +++++++++++++++++ .../adafruit/ST7565/Configuration.h | 48 +++++++++++++++++ .../delta/biv2.5/Configuration.h | 48 +++++++++++++++++ .../delta/generic/Configuration.h | 48 +++++++++++++++++ .../delta/kossel_mini/Configuration.h | 48 +++++++++++++++++ .../delta/kossel_pro/Configuration.h | 48 +++++++++++++++++ .../delta/kossel_xl/Configuration.h | 48 +++++++++++++++++ .../makibox/Configuration.h | 48 +++++++++++++++++ .../tvrrug/Round2/Configuration.h | 48 +++++++++++++++++ 22 files changed, 1022 insertions(+), 9 deletions(-) rename Marlin/example_configurations/K8400/{Dual Heads => Dual-head}/Configuration.h (96%) diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index c455c50a67..96cb580689 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -821,13 +821,18 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l // Attention: This is an EXPERIMENTAL feature, in the future the G-code arguments // may change to add new functionality like different wipe patterns. // -//#define CLEAN_NOZZLE_FEATURE +//#define NOZZLE_CLEAN_FEATURE -#if ENABLED(CLEAN_NOZZLE_FEATURE) - #define CLEAN_NOZZLE_STROKES 12 - #define CLEAN_NOZZLE_START_PT { 30, 30, (Z_MIN_POS + 5), 0} - #define CLEAN_NOZZLE_END_PT {100, 60, (Z_MIN_POS + 5), 0} - // { X, Y, Z, E} +#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 // diff --git a/Marlin/example_configurations/Cartesio/Configuration.h b/Marlin/example_configurations/Cartesio/Configuration.h index a875ecce66..b4d1f08523 100644 --- a/Marlin/example_configurations/Cartesio/Configuration.h +++ b/Marlin/example_configurations/Cartesio/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/Felix/Configuration.h b/Marlin/example_configurations/Felix/Configuration.h index d3543127f8..50ace1c2d5 100644 --- a/Marlin/example_configurations/Felix/Configuration.h +++ b/Marlin/example_configurations/Felix/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/Felix/DUAL/Configuration.h b/Marlin/example_configurations/Felix/DUAL/Configuration.h index 097c1e2ee8..3c2be5a228 100644 --- a/Marlin/example_configurations/Felix/DUAL/Configuration.h +++ b/Marlin/example_configurations/Felix/DUAL/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/Hephestos/Configuration.h b/Marlin/example_configurations/Hephestos/Configuration.h index ad3d59088a..31ac6728fb 100644 --- a/Marlin/example_configurations/Hephestos/Configuration.h +++ b/Marlin/example_configurations/Hephestos/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/Hephestos_2/Configuration.h b/Marlin/example_configurations/Hephestos_2/Configuration.h index 0d6252eabd..5e31b0e99d 100644 --- a/Marlin/example_configurations/Hephestos_2/Configuration.h +++ b/Marlin/example_configurations/Hephestos_2/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/K8200/Configuration.h b/Marlin/example_configurations/K8200/Configuration.h index 2a1ed29817..37fe86722f 100644 --- a/Marlin/example_configurations/K8200/Configuration.h +++ b/Marlin/example_configurations/K8200/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/K8400/Configuration.h b/Marlin/example_configurations/K8400/Configuration.h index 6cec00cb21..c900fc263f 100644 --- a/Marlin/example_configurations/K8400/Configuration.h +++ b/Marlin/example_configurations/K8400/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/K8400/Dual Heads/Configuration.h b/Marlin/example_configurations/K8400/Dual-head/Configuration.h similarity index 96% rename from Marlin/example_configurations/K8400/Dual Heads/Configuration.h rename to Marlin/example_configurations/K8400/Dual-head/Configuration.h index 2dc75368a7..d69c5bdfe3 100644 --- a/Marlin/example_configurations/K8400/Dual Heads/Configuration.h +++ b/Marlin/example_configurations/K8400/Dual-head/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h b/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h index ab6c8dcd91..315010fe8f 100644 --- a/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h +++ b/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/RigidBot/Configuration.h b/Marlin/example_configurations/RigidBot/Configuration.h index f24a4ea076..829c8d8a54 100644 --- a/Marlin/example_configurations/RigidBot/Configuration.h +++ b/Marlin/example_configurations/RigidBot/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/SCARA/Configuration.h b/Marlin/example_configurations/SCARA/Configuration.h index b8addb2871..4d32f85a76 100644 --- a/Marlin/example_configurations/SCARA/Configuration.h +++ b/Marlin/example_configurations/SCARA/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/TAZ4/Configuration.h b/Marlin/example_configurations/TAZ4/Configuration.h index e2782de05e..f8f49db47b 100644 --- a/Marlin/example_configurations/TAZ4/Configuration.h +++ b/Marlin/example_configurations/TAZ4/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/WITBOX/Configuration.h b/Marlin/example_configurations/WITBOX/Configuration.h index 06a5ae8fb9..d4102ef995 100644 --- a/Marlin/example_configurations/WITBOX/Configuration.h +++ b/Marlin/example_configurations/WITBOX/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/adafruit/ST7565/Configuration.h b/Marlin/example_configurations/adafruit/ST7565/Configuration.h index be81a9a2e7..2bb90a191a 100644 --- a/Marlin/example_configurations/adafruit/ST7565/Configuration.h +++ b/Marlin/example_configurations/adafruit/ST7565/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/delta/biv2.5/Configuration.h b/Marlin/example_configurations/delta/biv2.5/Configuration.h index 5cc2ed9d18..981ae59dd7 100644 --- a/Marlin/example_configurations/delta/biv2.5/Configuration.h +++ b/Marlin/example_configurations/delta/biv2.5/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/delta/generic/Configuration.h b/Marlin/example_configurations/delta/generic/Configuration.h index 31d6b3551f..2fed91a1a6 100644 --- a/Marlin/example_configurations/delta/generic/Configuration.h +++ b/Marlin/example_configurations/delta/generic/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/delta/kossel_mini/Configuration.h b/Marlin/example_configurations/delta/kossel_mini/Configuration.h index 2699a97f45..9e97af3c32 100644 --- a/Marlin/example_configurations/delta/kossel_mini/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_mini/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/delta/kossel_pro/Configuration.h b/Marlin/example_configurations/delta/kossel_pro/Configuration.h index dddb9c4357..2b49bd039b 100644 --- a/Marlin/example_configurations/delta/kossel_pro/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_pro/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/delta/kossel_xl/Configuration.h b/Marlin/example_configurations/delta/kossel_xl/Configuration.h index 58b1626357..258ba72c9b 100644 --- a/Marlin/example_configurations/delta/kossel_xl/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_xl/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/makibox/Configuration.h b/Marlin/example_configurations/makibox/Configuration.h index 9a4be404e4..c51d75d36f 100644 --- a/Marlin/example_configurations/makibox/Configuration.h +++ b/Marlin/example_configurations/makibox/Configuration.h @@ -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 // diff --git a/Marlin/example_configurations/tvrrug/Round2/Configuration.h b/Marlin/example_configurations/tvrrug/Round2/Configuration.h index a135d4d7b8..eeee653041 100644 --- a/Marlin/example_configurations/tvrrug/Round2/Configuration.h +++ b/Marlin/example_configurations/tvrrug/Round2/Configuration.h @@ -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 //