diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index cb47d7aced..d7d815fe97 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -981,13 +981,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1000,6 +1000,7 @@ // |________|_________|_________| // 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 @@ -1008,8 +1009,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 29d7499add..b7b4473c96 100755 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -3157,7 +3157,7 @@ inline void gcode_G4() { 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; + uint8_t const objects = code_seen('T') ? code_value_ushort() : NOZZLE_CLEAN_TRIANGLES; Nozzle::clean(pattern, strokes, objects); } diff --git a/Marlin/example_configurations/Cartesio/Configuration.h b/Marlin/example_configurations/Cartesio/Configuration.h index cca0d2ea91..f9dbc6cbbb 100644 --- a/Marlin/example_configurations/Cartesio/Configuration.h +++ b/Marlin/example_configurations/Cartesio/Configuration.h @@ -981,13 +981,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1008,8 +1008,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/Felix/Configuration.h b/Marlin/example_configurations/Felix/Configuration.h index 908cfb373e..3c5d6a9660 100644 --- a/Marlin/example_configurations/Felix/Configuration.h +++ b/Marlin/example_configurations/Felix/Configuration.h @@ -964,13 +964,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -991,8 +991,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/Felix/DUAL/Configuration.h b/Marlin/example_configurations/Felix/DUAL/Configuration.h index 19aa03afa8..847ffa95ac 100644 --- a/Marlin/example_configurations/Felix/DUAL/Configuration.h +++ b/Marlin/example_configurations/Felix/DUAL/Configuration.h @@ -964,13 +964,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -991,8 +991,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/Hephestos/Configuration.h b/Marlin/example_configurations/Hephestos/Configuration.h index cf3679c11b..0e0580bf13 100644 --- a/Marlin/example_configurations/Hephestos/Configuration.h +++ b/Marlin/example_configurations/Hephestos/Configuration.h @@ -973,13 +973,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1000,8 +1000,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/Hephestos_2/Configuration.h b/Marlin/example_configurations/Hephestos_2/Configuration.h index ff956fe80c..6a3f548c43 100644 --- a/Marlin/example_configurations/Hephestos_2/Configuration.h +++ b/Marlin/example_configurations/Hephestos_2/Configuration.h @@ -975,13 +975,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1002,8 +1002,11 @@ #define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { X_MIN_POS + 10, Y_MAX_POS - 9, (Z_MIN_POS + 0.5)} diff --git a/Marlin/example_configurations/K8200/Configuration.h b/Marlin/example_configurations/K8200/Configuration.h index a1c824ff74..06443e3cb8 100644 --- a/Marlin/example_configurations/K8200/Configuration.h +++ b/Marlin/example_configurations/K8200/Configuration.h @@ -1010,13 +1010,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1037,8 +1037,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/K8400/Configuration.h b/Marlin/example_configurations/K8400/Configuration.h index fbf2cd1717..c169e00984 100644 --- a/Marlin/example_configurations/K8400/Configuration.h +++ b/Marlin/example_configurations/K8400/Configuration.h @@ -981,13 +981,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1008,8 +1008,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/K8400/Dual-head/Configuration.h b/Marlin/example_configurations/K8400/Dual-head/Configuration.h index 3e1995f583..aa11b88169 100644 --- a/Marlin/example_configurations/K8400/Dual-head/Configuration.h +++ b/Marlin/example_configurations/K8400/Dual-head/Configuration.h @@ -981,13 +981,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1008,8 +1008,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h b/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h index b70133b870..bf23af2aef 100644 --- a/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h +++ b/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h @@ -981,13 +981,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1008,8 +1008,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/RigidBot/Configuration.h b/Marlin/example_configurations/RigidBot/Configuration.h index 60a72d2a70..617fe392b6 100644 --- a/Marlin/example_configurations/RigidBot/Configuration.h +++ b/Marlin/example_configurations/RigidBot/Configuration.h @@ -980,13 +980,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1007,8 +1007,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/SCARA/Configuration.h b/Marlin/example_configurations/SCARA/Configuration.h index ea01ec65f2..fb8c3330c0 100644 --- a/Marlin/example_configurations/SCARA/Configuration.h +++ b/Marlin/example_configurations/SCARA/Configuration.h @@ -996,13 +996,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1023,8 +1023,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/TAZ4/Configuration.h b/Marlin/example_configurations/TAZ4/Configuration.h index ab2db7ebab..36a0e8ebd5 100644 --- a/Marlin/example_configurations/TAZ4/Configuration.h +++ b/Marlin/example_configurations/TAZ4/Configuration.h @@ -1002,13 +1002,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1029,8 +1029,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/WITBOX/Configuration.h b/Marlin/example_configurations/WITBOX/Configuration.h index 33dfa8198a..bdacef218e 100644 --- a/Marlin/example_configurations/WITBOX/Configuration.h +++ b/Marlin/example_configurations/WITBOX/Configuration.h @@ -973,13 +973,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1000,8 +1000,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/adafruit/ST7565/Configuration.h b/Marlin/example_configurations/adafruit/ST7565/Configuration.h index fea4d4a302..6827cfc810 100644 --- a/Marlin/example_configurations/adafruit/ST7565/Configuration.h +++ b/Marlin/example_configurations/adafruit/ST7565/Configuration.h @@ -981,13 +981,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1008,8 +1008,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/delta/generic/Configuration.h b/Marlin/example_configurations/delta/generic/Configuration.h index 4c968713ba..97108ebf64 100644 --- a/Marlin/example_configurations/delta/generic/Configuration.h +++ b/Marlin/example_configurations/delta/generic/Configuration.h @@ -1068,13 +1068,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1095,8 +1095,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/delta/kossel_mini/Configuration.h b/Marlin/example_configurations/delta/kossel_mini/Configuration.h index da6484430f..39a8dcfb9a 100644 --- a/Marlin/example_configurations/delta/kossel_mini/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_mini/Configuration.h @@ -1071,13 +1071,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1098,8 +1098,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/delta/kossel_pro/Configuration.h b/Marlin/example_configurations/delta/kossel_pro/Configuration.h index fa64c060c1..2bf9aa34a7 100644 --- a/Marlin/example_configurations/delta/kossel_pro/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_pro/Configuration.h @@ -1070,13 +1070,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1097,8 +1097,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/delta/kossel_xl/Configuration.h b/Marlin/example_configurations/delta/kossel_xl/Configuration.h index 6aca74cff1..6fd3a1aae5 100644 --- a/Marlin/example_configurations/delta/kossel_xl/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_xl/Configuration.h @@ -1074,13 +1074,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1101,8 +1101,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/makibox/Configuration.h b/Marlin/example_configurations/makibox/Configuration.h index e2d7f0692f..9503c11221 100644 --- a/Marlin/example_configurations/makibox/Configuration.h +++ b/Marlin/example_configurations/makibox/Configuration.h @@ -984,13 +984,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1011,8 +1011,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/example_configurations/tvrrug/Round2/Configuration.h b/Marlin/example_configurations/tvrrug/Round2/Configuration.h index a88d943bc3..f2607066c7 100644 --- a/Marlin/example_configurations/tvrrug/Round2/Configuration.h +++ b/Marlin/example_configurations/tvrrug/Round2/Configuration.h @@ -977,13 +977,13 @@ // // 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. +// material at a fixed bed location. S defines "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 +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, // sending "G12 P1 S1 T3" will execute: // // -- @@ -1004,8 +1004,11 @@ //#define NOZZLE_CLEAN_FEATURE #if ENABLED(NOZZLE_CLEAN_FEATURE) - // Number of pattern repetitions + // Default number of pattern repetitions #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 // Specify positions as { X, Y, Z } #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} diff --git a/Marlin/nozzle.h b/Marlin/nozzle.h index 7486105545..14423adfbd 100644 --- a/Marlin/nozzle.h +++ b/Marlin/nozzle.h @@ -26,6 +26,14 @@ #include "Marlin.h" #include "point_t.h" +#if ENABLED(NOZZLE_CLEAN_FEATURE) + constexpr float nozzle_clean_start_point[4] = NOZZLE_CLEAN_START_POINT, + nozzle_clean_end_point[4] = NOZZLE_CLEAN_END_POINT, + nozzle_clean_length = fabs(nozzle_clean_start_point[X_AXIS] - nozzle_clean_end_point[X_AXIS]), //abs x size of wipe pad + nozzle_clean_height = fabs(nozzle_clean_start_point[Y_AXIS] - nozzle_clean_end_point[Y_AXIS]); //abs y size of wipe pad + constexpr bool nozzle_clean_horizontal = nozzle_clean_length >= nozzle_clean_height; //whether to zig-zag horizontally or vertically +#endif //NOZZLE_CLEAN_FEATURE + /** * @brief Nozzle class * @@ -92,8 +100,8 @@ class Nozzle { __attribute__((unused)) uint8_t const &objects ) __attribute__((optimize ("Os"))) { #if ENABLED(NOZZLE_CLEAN_FEATURE) - float A = fabs(end.y - start.y); // [twice the] Amplitude - float P = fabs(end.x - start.x) / (objects << 1); // Period + float A = nozzle_clean_horizontal ? nozzle_clean_height : nozzle_clean_length; // [twice the] Amplitude + float P = ( nozzle_clean_horizontal ? nozzle_clean_length : nozzle_clean_height ) / (objects << 1); // Period // Don't allow impossible triangles if (A <= 0.0f || P <= 0.0f ) return; @@ -110,16 +118,16 @@ class Nozzle { 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)); + float const x = start.x + ( nozzle_clean_horizontal ? i * P : (A/P) * (P - fabs(fmod((i*P), (2*P)) - P)) ); + float const y = start.y + (!nozzle_clean_horizontal ? i * P : (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)); + float const x = start.x + ( nozzle_clean_horizontal ? i * P : (A/P) * (P - fabs(fmod((i*P), (2*P)) - P)) ); + float const y = start.y + (!nozzle_clean_horizontal ? i * P : (A/P) * (P - fabs(fmod((i*P), (2*P)) - P)) ); do_blocking_move_to_xy(x, y); }