melch/Marlin
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added G12 configuration options to all configs

Browse Source
This commit is contained in:
João Brázio 2016-07-14 00:38:42 +01:00
parent 4937f9ada4
commit 68c343a09a
22 changed files with 1022 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
Marlin/Configuration.h
View File

@ -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
//

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
//