From b05a75655a202518e1cdac412d6af076c943420b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Br=C3=A1zio?= Date: Thu, 16 Jun 2016 05:18:44 +0100 Subject: [PATCH 1/4] Implements a nozzle cleaning pattern generator (G12) --- .travis.yml | 6 +++ Marlin/Configuration.h | 38 ++++++++++++++ Marlin/Marlin_main.cpp | 47 +++++++++++------ Marlin/SanityCheck.h | 7 +++ Marlin/clean_nozzle.h | 112 +++++++++++++++++++++++++++++++++++++++++ Marlin/point_t.h | 33 ++++++++++++ 6 files changed, 228 insertions(+), 15 deletions(-) create mode 100644 Marlin/clean_nozzle.h create mode 100644 Marlin/point_t.h diff --git a/.travis.yml b/.travis.yml index eb471fd11..4d003a95d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -211,6 +211,12 @@ script: - opt_enable PRINTCOUNTER - build_marlin # + # Test CLEAN_NOZZLE_FEATURE + # + - restore_configs + - opt_enable AUTO_BED_LEVELING_FEATURE CLEAN_NOZZLE_FEATURE FIX_MOUNTED_PROBE + - build_marlin + # # ######## STANDARD LCD/PANELS ############## # diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index 94c1d32e9..6c170ccf3 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -787,6 +787,44 @@ 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 (Xs, Ys) and (Xe, Ye), "S" +// defines the number of zig-zag triangles to be done. Each "side" +// cannot be less than 5mm. As an example "G12 P1 S3" will execute: +// +// /| /| /| (Xe, Ye) +// / | / | / | +// / | / | / | +// (Xs, Ys) / |/ |/ | +// +// +// 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 CLEAN_NOZZLE_FEATURE + +#if ENABLED(CLEAN_NOZZLE_FEATURE) + #define CLEAN_NOZZLE_STROKES 12 + #define CLEAN_NOZZLE_START_PT { 30, 30, (Z_MIN_POS + 1), 0} + #define CLEAN_NOZZLE_END_PT {100, 60, (Z_MIN_POS + 1), 0} + // { X, Y, Z, E} +#endif + // // Print job timer // diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 95b8a5c76..ac7c5f19e 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -106,8 +106,9 @@ * G3 - CCW ARC * G4 - Dwell S or P * G5 - Cubic B-spline with XYZE destination and IJPQ offsets - * G10 - retract filament according to settings of M207 - * G11 - retract recover filament according to settings of M208 + * G10 - Retract filament according to settings of M207 + * G11 - Retract recover filament according to settings of M208 + * G12 - Clean tool * G20 - Set input units to inches * G21 - Set input units to millimeters * G28 - Home one or more axes @@ -1703,6 +1704,10 @@ static void clean_up_after_endstop_or_probe_move() { do_blocking_move_to(x, current_position[Y_AXIS], current_position[Z_AXIS], feed_rate); } + inline void do_blocking_move_to_y(float y) { + do_blocking_move_to(current_position[X_AXIS], y, current_position[Z_AXIS]); + } + inline void do_blocking_move_to_z(float z, float feed_rate = 0.0) { do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], z, feed_rate); } @@ -2712,6 +2717,23 @@ inline void gcode_G4() { #endif //FWRETRACT +#if ENABLED(CLEAN_NOZZLE_FEATURE) && ENABLED(AUTO_BED_LEVELING_FEATURE) + #include "clean_nozzle.h" + + inline void gcode_G12() { + // Don't allow nozzle cleaning without homing first + if (!axis_homed[X_AXIS] || !axis_homed[Y_AXIS] || !axis_homed[Z_AXIS]) { + axis_unhomed_error(true); + return; + } + + uint8_t const pattern = code_seen('P') ? code_value_ushort() : 0; + uint8_t const strokes = code_seen('S') ? code_value_ushort() : CLEAN_NOZZLE_STROKES; + + CleanNozzle::start(pattern, strokes); + } +#endif + #if ENABLED(INCH_MODE_SUPPORT) /** * G20: Set input mode to inches @@ -6748,12 +6770,10 @@ void process_next_command() { // G2, G3 #if ENABLED(ARC_SUPPORT) && DISABLED(SCARA) - case 2: // G2 - CW ARC case 3: // G3 - CCW ARC gcode_G2_G3(codenum == 2); break; - #endif // G4 Dwell @@ -6762,23 +6782,25 @@ void process_next_command() { break; #if ENABLED(BEZIER_CURVE_SUPPORT) - // G5 case 5: // G5 - Cubic B_spline gcode_G5(); break; - #endif // BEZIER_CURVE_SUPPORT #if ENABLED(FWRETRACT) - case 10: // G10: retract case 11: // G11: retract_recover gcode_G10_G11(codenum == 10); break; - #endif // FWRETRACT + #if ENABLED(CLEAN_NOZZLE_FEATURE) && ENABLED(AUTO_BED_LEVELING_FEATURE) + case 12: + gcode_G12(); // G12: Clean Nozzle + break; + #endif // CLEAN_NOZZLE_FEATURE + #if ENABLED(INCH_MODE_SUPPORT) case 20: //G20: Inch Mode gcode_G20(); @@ -6787,7 +6809,7 @@ void process_next_command() { case 21: //G21: MM Mode gcode_G21(); break; - #endif + #endif // INCH_MODE_SUPPORT case 28: // G28: Home all axes, one at a time gcode_G28(); @@ -6797,7 +6819,7 @@ void process_next_command() { case 29: // G29 Detailed Z probe, probes the bed at 3 or more points. gcode_G29(); break; - #endif + #endif // AUTO_BED_LEVELING_FEATURE #if HAS_BED_PROBE @@ -6816,7 +6838,6 @@ void process_next_command() { break; #endif // Z_PROBE_SLED - #endif // HAS_BED_PROBE case 90: // G90 @@ -6845,7 +6866,6 @@ void process_next_command() { break; #if ENABLED(SDSUPPORT) - case 20: // M20 - list SD card gcode_M20(); break; case 21: // M21 - init SD card @@ -6878,7 +6898,6 @@ void process_next_command() { case 928: //M928 - Start SD write gcode_M928(); break; - #endif //SDSUPPORT case 31: //M31 take time since the start of the SD print or an M109 command @@ -6948,11 +6967,9 @@ void process_next_command() { #endif #if ENABLED(HOST_KEEPALIVE_FEATURE) - case 113: // M113: Set Host Keepalive interval gcode_M113(); break; - #endif case 140: // M140: Set bed temp diff --git a/Marlin/SanityCheck.h b/Marlin/SanityCheck.h index 3dc330885..812050066 100644 --- a/Marlin/SanityCheck.h +++ b/Marlin/SanityCheck.h @@ -646,4 +646,11 @@ #error "ABS_PREHEAT_FAN_SPEED is now PREHEAT_2_FAN_SPEED. Please update your configuration." #endif +/** + * Nozzle cleaning + */ +#if ENABLED(CLEAN_NOZZLE_FEATURE) && DISABLED(AUTO_BED_LEVELING_FEATURE) + #error You must enable AUTO_BED_LEVELING_FEATURE for CLEAN_NOZZLE_FEATURE to work +#endif + #endif //SANITYCHECK_H diff --git a/Marlin/clean_nozzle.h b/Marlin/clean_nozzle.h new file mode 100644 index 000000000..9670605b0 --- /dev/null +++ b/Marlin/clean_nozzle.h @@ -0,0 +1,112 @@ +/* + * Marlin 3D Printer Firmware + * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] + * + * Based on Sprinter and grbl. + * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +#ifndef __CLEAN_NOZZLE_H__ +#define __CLEAN_NOZZLE_H__ + +#include "Marlin.h" +#include "point_t.h" + +/** + * @brief CleanNozzle class + * + * @todo: Do not ignore the end.z value and allow XYZ movements + * @todo: Currently this feature needs AUTO_BED_LEVELING_FEATURE to be active + * due to the do_blocking_move_to*() functions. + */ +class CleanNozzle { + private: + /** + * @brief Stroke clean pattern + * @details Wipes the nozzle back and forth in a linear movement + * + * @param start point_t defining the starting point + * @param end point_t defining the ending point + * @param strokes number of strokes to execute + */ + static void stroke(point_t const &start, point_t const &end, uint8_t const &strokes) + __attribute__ ((optimize ("Os"))) { + // Move to the starting point + do_blocking_move_to_xy(start.x, start.y); + do_blocking_move_to_z(start.z); + + // Start the stroke pattern + for (uint8_t i = 0; i < (strokes >>1); i++) { + do_blocking_move_to_xy(end.x, end.y); + do_blocking_move_to_xy(start.x, start.y); + } + } + + /** + * @brief Zig-zag clean pattern + * @details Apply a zig-zag cleanning pattern + * + * @param start point_t defining the starting point + * @param end point_t defining the ending point + * @param triangles number of triangles to execute + */ + static void zigzag(point_t const &start, point_t const &end, uint8_t const &triangles) + __attribute__ ((optimize ("Os"))) { + // Move to the starting point + do_blocking_move_to_xy(start.x, start.y); + do_blocking_move_to_z(start.z); + + // Calculate the triangle side + float const a = fabs(end.x - start.x) / triangles; + + // Don't allow the sides (a, b) to be smaller than 5mm + if (a < 5 || fabs(end.y - start.y) < 5) return; + + // Start the zig-zag pattern + for (uint8_t i = 0; i < triangles; i++) { + float const x = start.x + (a * (i + 1)); + do_blocking_move_to_xy(x, end.y); + do_blocking_move_to_y(start.y); + } + } + + public: + /** + * @brief Clean the nozzle + * @details Starts the selected clean procedure pattern + * + * @param pattern one of the available patterns + * @param argument depends on the cleaning pattern + */ + static void start(uint8_t const &pattern, uint8_t const &argument) + __attribute__ ((optimize ("Os"))) { + switch (pattern) { + case 1: + CleanNozzle::zigzag( + CLEAN_NOZZLE_START_PT, + CLEAN_NOZZLE_END_PT, argument); + break; + + default: + CleanNozzle::stroke( + CLEAN_NOZZLE_START_PT, + CLEAN_NOZZLE_END_PT, argument); + } + } +}; + +#endif diff --git a/Marlin/point_t.h b/Marlin/point_t.h new file mode 100644 index 000000000..18dfe09c8 --- /dev/null +++ b/Marlin/point_t.h @@ -0,0 +1,33 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] + * + * Based on Sprinter and grbl. + * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +#ifndef __POINT_T__ +#define __POINT_T__ + +struct point_t { + float x; + float y; + float z; + float e; +}; + +#endif From 021544f5721442ba62ac339d91451f6caf2e7c5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Br=C3=A1zio?= Date: Thu, 23 Jun 2016 00:23:55 +0100 Subject: [PATCH 2/4] Improves G12 zig-zag pattern --- Marlin/Configuration.h | 27 ++++++++----- Marlin/Marlin_main.cpp | 5 ++- Marlin/{clean_nozzle.h => nozzle.h} | 63 +++++++++++++++++++---------- 3 files changed, 61 insertions(+), 34 deletions(-) rename Marlin/{clean_nozzle.h => nozzle.h} (61%) diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index 6c170ccf3..c455c50a6 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -801,15 +801,20 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l // "strokes" i.e. back-and-forth movements between the starting and end // points. // -// P1: This starts a zig-zag pattern between (Xs, Ys) and (Xe, Ye), "S" -// defines the number of zig-zag triangles to be done. Each "side" -// cannot be less than 5mm. As an example "G12 P1 S3" will execute: -// -// /| /| /| (Xe, Ye) -// / | / | / | -// / | / | / | -// (Xs, Ys) / |/ |/ | -// +// 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. // @@ -820,8 +825,8 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l #if ENABLED(CLEAN_NOZZLE_FEATURE) #define CLEAN_NOZZLE_STROKES 12 - #define CLEAN_NOZZLE_START_PT { 30, 30, (Z_MIN_POS + 1), 0} - #define CLEAN_NOZZLE_END_PT {100, 60, (Z_MIN_POS + 1), 0} + #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} #endif diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index ac7c5f19e..835b20fcd 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -2718,7 +2718,7 @@ inline void gcode_G4() { #endif //FWRETRACT #if ENABLED(CLEAN_NOZZLE_FEATURE) && ENABLED(AUTO_BED_LEVELING_FEATURE) - #include "clean_nozzle.h" + #include "nozzle.h" inline void gcode_G12() { // Don't allow nozzle cleaning without homing first @@ -2729,8 +2729,9 @@ 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() : CLEAN_NOZZLE_STROKES; + uint8_t const objects = code_seen('T') ? code_value_ushort() : 3; - CleanNozzle::start(pattern, strokes); + Nozzle::clean(pattern, strokes, objects); } #endif diff --git a/Marlin/clean_nozzle.h b/Marlin/nozzle.h similarity index 61% rename from Marlin/clean_nozzle.h rename to Marlin/nozzle.h index 9670605b0..796d18b34 100644 --- a/Marlin/clean_nozzle.h +++ b/Marlin/nozzle.h @@ -27,13 +27,13 @@ #include "point_t.h" /** - * @brief CleanNozzle class + * @brief Nozzle class * * @todo: Do not ignore the end.z value and allow XYZ movements * @todo: Currently this feature needs AUTO_BED_LEVELING_FEATURE to be active * due to the do_blocking_move_to*() functions. */ -class CleanNozzle { +class Nozzle { private: /** * @brief Stroke clean pattern @@ -62,26 +62,46 @@ class CleanNozzle { * * @param start point_t defining the starting point * @param end point_t defining the ending point - * @param triangles number of triangles to execute + * @param strokes number of strokes to execute + * @param objects number of objects to create */ - static void zigzag(point_t const &start, point_t const &end, uint8_t const &triangles) + static void zigzag(point_t const &start, + point_t const &end, uint8_t const &strokes, uint8_t const &objects) __attribute__ ((optimize ("Os"))) { - // Move to the starting point - do_blocking_move_to_xy(start.x, start.y); - do_blocking_move_to_z(start.z); + float A = fabs(end.y - start.y); // [twice the] Amplitude + float P = fabs(end.x - start.x) / (objects << 1); // Period - // Calculate the triangle side - float const a = fabs(end.x - start.x) / triangles; + // Don't allow impossible triangles + if (A <= 0.0f || P <= 0.0f ) return; - // Don't allow the sides (a, b) to be smaller than 5mm - if (a < 5 || fabs(end.y - start.y) < 5) return; + // Store the current coords + point_t const home = { + current_position[X_AXIS], + current_position[Y_AXIS], + current_position[Z_AXIS], + current_position[E_AXIS] + }; - // Start the zig-zag pattern - for (uint8_t i = 0; i < triangles; i++) { - float const x = start.x + (a * (i + 1)); - do_blocking_move_to_xy(x, end.y); - do_blocking_move_to_y(start.y); + for (uint8_t j = 0; j < strokes; j++) { + for (uint8_t i = 0; i < (objects << 1); i++) { + float const x = start.x + i * P; + float const y = start.y + (A/P) * (P - fabs(fmod((i*P), (2*P)) - P)); + + do_blocking_move_to_xy(x, y); + if (i == 0) do_blocking_move_to_z(start.z); + } + + for (int i = (objects << 1); i > -1; i--) { + float const x = start.x + i * P; + float const y = start.y + (A/P) * (P - fabs(fmod((i*P), (2*P)) - P)); + + do_blocking_move_to_xy(x, y); + } } + + // Move to home/start position + do_blocking_move_to_z(home.z); + do_blocking_move_to_xy(home.x, home.y); } public: @@ -92,19 +112,20 @@ class CleanNozzle { * @param pattern one of the available patterns * @param argument depends on the cleaning pattern */ - static void start(uint8_t const &pattern, uint8_t const &argument) + static void clean(uint8_t const &pattern, + uint8_t const &strokes, uint8_t const &objects = 0) __attribute__ ((optimize ("Os"))) { switch (pattern) { case 1: - CleanNozzle::zigzag( + Nozzle::zigzag( CLEAN_NOZZLE_START_PT, - CLEAN_NOZZLE_END_PT, argument); + CLEAN_NOZZLE_END_PT, strokes, objects); break; default: - CleanNozzle::stroke( + Nozzle::stroke( CLEAN_NOZZLE_START_PT, - CLEAN_NOZZLE_END_PT, argument); + CLEAN_NOZZLE_END_PT, strokes); } } }; From 4937f9ada4b2441cc2d2f84e3acd7f60e35f23f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Br=C3=A1zio?= Date: Thu, 14 Jul 2016 00:07:36 +0100 Subject: [PATCH 3/4] Minor G12 tweaks and point_t struct extension --- Marlin/Marlin_main.cpp | 13 ++++------ Marlin/SanityCheck.h | 4 +-- Marlin/nozzle.h | 55 +++++++++++++++++++++++++++++------------- Marlin/point_t.h | 13 ++++++++++ 4 files changed, 58 insertions(+), 27 deletions(-) diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 835b20fcd..523f8cf32 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -2717,18 +2717,15 @@ inline void gcode_G4() { #endif //FWRETRACT -#if ENABLED(CLEAN_NOZZLE_FEATURE) && ENABLED(AUTO_BED_LEVELING_FEATURE) +#if ENABLED(NOZZLE_CLEAN_FEATURE) && ENABLED(AUTO_BED_LEVELING_FEATURE) #include "nozzle.h" inline void gcode_G12() { // Don't allow nozzle cleaning without homing first - if (!axis_homed[X_AXIS] || !axis_homed[Y_AXIS] || !axis_homed[Z_AXIS]) { - axis_unhomed_error(true); - return; - } + if (axis_unhomed_error(true, true, true)) { return; } uint8_t const pattern = code_seen('P') ? code_value_ushort() : 0; - uint8_t const strokes = code_seen('S') ? code_value_ushort() : CLEAN_NOZZLE_STROKES; + uint8_t const strokes = code_seen('S') ? code_value_ushort() : NOZZLE_CLEAN_STROKES; uint8_t const objects = code_seen('T') ? code_value_ushort() : 3; Nozzle::clean(pattern, strokes, objects); @@ -6796,11 +6793,11 @@ void process_next_command() { break; #endif // FWRETRACT - #if ENABLED(CLEAN_NOZZLE_FEATURE) && ENABLED(AUTO_BED_LEVELING_FEATURE) + #if ENABLED(NOZZLE_CLEAN_FEATURE) && HAS_BED_PROBE case 12: gcode_G12(); // G12: Clean Nozzle break; - #endif // CLEAN_NOZZLE_FEATURE + #endif // NOZZLE_CLEAN_FEATURE #if ENABLED(INCH_MODE_SUPPORT) case 20: //G20: Inch Mode diff --git a/Marlin/SanityCheck.h b/Marlin/SanityCheck.h index 812050066..8334b1289 100644 --- a/Marlin/SanityCheck.h +++ b/Marlin/SanityCheck.h @@ -649,8 +649,8 @@ /** * Nozzle cleaning */ -#if ENABLED(CLEAN_NOZZLE_FEATURE) && DISABLED(AUTO_BED_LEVELING_FEATURE) - #error You must enable AUTO_BED_LEVELING_FEATURE for CLEAN_NOZZLE_FEATURE to work +#if ENABLED(NOZZLE_CLEAN_FEATURE) && !HAS_BED_PROBE + #error Due to internal dependencies you must have a bed probe for NOZZLE_CLEAN_FEATURE to work #endif #endif //SANITYCHECK_H diff --git a/Marlin/nozzle.h b/Marlin/nozzle.h index 796d18b34..02771a516 100644 --- a/Marlin/nozzle.h +++ b/Marlin/nozzle.h @@ -20,8 +20,8 @@ * */ -#ifndef __CLEAN_NOZZLE_H__ -#define __CLEAN_NOZZLE_H__ +#ifndef __NOZZLE_H__ +#define __NOZZLE_H__ #include "Marlin.h" #include "point_t.h" @@ -30,7 +30,7 @@ * @brief Nozzle class * * @todo: Do not ignore the end.z value and allow XYZ movements - * @todo: Currently this feature needs AUTO_BED_LEVELING_FEATURE to be active + * @todo: Currently this feature needs HAS_BED_PROBE to be active * due to the do_blocking_move_to*() functions. */ class Nozzle { @@ -45,6 +45,17 @@ class Nozzle { */ static void stroke(point_t const &start, point_t const &end, uint8_t const &strokes) __attribute__ ((optimize ("Os"))) { + + #if ENABLED(NOZZLE_CLEAN_PARK) + // Store the current coords + point_t const initial = { + current_position[X_AXIS], + current_position[Y_AXIS], + current_position[Z_AXIS], + current_position[E_AXIS] + }; + #endif + // Move to the starting point do_blocking_move_to_xy(start.x, start.y); do_blocking_move_to_z(start.z); @@ -54,6 +65,12 @@ class Nozzle { do_blocking_move_to_xy(end.x, end.y); do_blocking_move_to_xy(start.x, start.y); } + + #if ENABLED(NOZZLE_CLEAN_PARK) + // Move the nozzle to the initial point + do_blocking_move_to_z(initial.z); + do_blocking_move_to_xy(initial.x, initial.y); + #endif } /** @@ -74,13 +91,15 @@ class Nozzle { // Don't allow impossible triangles if (A <= 0.0f || P <= 0.0f ) return; - // Store the current coords - point_t const home = { - current_position[X_AXIS], - current_position[Y_AXIS], - current_position[Z_AXIS], - current_position[E_AXIS] - }; + #if ENABLED(NOZZLE_CLEAN_PARK) + // Store the current coords + point_t const initial = { + current_position[X_AXIS], + current_position[Y_AXIS], + current_position[Z_AXIS], + current_position[E_AXIS] + }; + #endif for (uint8_t j = 0; j < strokes; j++) { for (uint8_t i = 0; i < (objects << 1); i++) { @@ -99,9 +118,11 @@ class Nozzle { } } - // Move to home/start position - do_blocking_move_to_z(home.z); - do_blocking_move_to_xy(home.x, home.y); + #if ENABLED(NOZZLE_CLEAN_PARK) + // Move the nozzle to the initial point + do_blocking_move_to_z(initial.z); + do_blocking_move_to_xy(initial.x, initial.y); + #endif } public: @@ -118,14 +139,14 @@ class Nozzle { switch (pattern) { case 1: Nozzle::zigzag( - CLEAN_NOZZLE_START_PT, - CLEAN_NOZZLE_END_PT, strokes, objects); + NOZZLE_CLEAN_START_PT, + NOZZLE_CLEAN_END_PT, strokes, objects); break; default: Nozzle::stroke( - CLEAN_NOZZLE_START_PT, - CLEAN_NOZZLE_END_PT, strokes); + NOZZLE_CLEAN_START_PT, + NOZZLE_CLEAN_END_PT, strokes); } } }; diff --git a/Marlin/point_t.h b/Marlin/point_t.h index 18dfe09c8..dbad66858 100644 --- a/Marlin/point_t.h +++ b/Marlin/point_t.h @@ -28,6 +28,19 @@ struct point_t { float y; float z; float e; + + point_t(float const x, float const y) + : point_t(x, y, NAN, NAN) {} + + point_t(float const x, float const y, float const z) + : point_t(x, y, z, NAN) {} + + point_t(float const x, float const y, float const z, float const e) { + this->x = x; + this->y = y; + this->z = z; + this->e = e; + } }; #endif 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 4/4] 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 c455c50a6..96cb58068 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 a875ecce6..b4d1f0852 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 d3543127f..50ace1c2d 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 097c1e2ee..3c2be5a22 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 ad3d59088..31ac6728f 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 0d6252eab..5e31b0e99 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 2a1ed2981..37fe86722 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 6cec00cb2..c900fc263 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 2dc75368a..d69c5bdfe 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 ab6c8dcd9..315010fe8 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 f24a4ea07..829c8d8a5 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 b8addb287..4d32f85a7 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 e2782de05..f8f49db47 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 06a5ae8fb..d4102ef99 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 be81a9a2e..2bb90a191 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 5cc2ed9d1..981ae59dd 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 31d6b3551..2fed91a1a 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 2699a97f4..9e97af3c3 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 dddb9c435..2b49bd039 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 58b162635..258ba72c9 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 9a4be404e..c51d75d36 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 a135d4d7b..eeee65304 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 //