diff --git a/.gitignore b/.gitignore index 20ab769bd..fd57a4e12 100755 --- a/.gitignore +++ b/.gitignore @@ -42,7 +42,7 @@ applet/ *.i *.ii *.swp - +tags # # C++ diff --git a/.travis.yml b/.travis.yml index 86d4f6798..a2c766f58 100644 --- a/.travis.yml +++ b/.travis.yml @@ -117,6 +117,12 @@ script: - opt_set ABL_GRID_POINTS_Y 16 - build_marlin # + # Test a simple build of AUTO_BED_LEVELING_UBL + # + - restore_configs + - opt_enable AUTO_BED_LEVELING_UBL FIX_MOUNTED_PROBE EEPROM_SETTINGS G3D_PANEL + - build_marlin + # # Test a Sled Z Probe # - restore_configs diff --git a/Marlin/Conditionals_post.h b/Marlin/Conditionals_post.h index c024f30ed..659484080 100644 --- a/Marlin/Conditionals_post.h +++ b/Marlin/Conditionals_post.h @@ -667,7 +667,7 @@ */ #define ABL_PLANAR (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT)) #define ABL_GRID (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)) - #define HAS_ABL (ABL_PLANAR || ABL_GRID) + #define HAS_ABL (ABL_PLANAR || ABL_GRID || ENABLED(AUTO_BED_LEVELING_UBL)) #define PLANNER_LEVELING (HAS_ABL || ENABLED(MESH_BED_LEVELING)) #define HAS_PROBING_PROCEDURE (HAS_ABL || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)) diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index 11c05018d..cf92e5f81 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad with NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -603,8 +604,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -742,34 +742,7 @@ #endif //=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING - -//=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -793,10 +766,23 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL + /** * Enable detailed logging of G28, G29, M48, etc. @@ -805,6 +791,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -825,11 +818,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -853,7 +841,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h index cd842f502..af217e50d 100644 --- a/Marlin/Configuration_adv.h +++ b/Marlin/Configuration_adv.h @@ -631,6 +631,13 @@ #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #endif +#if ENABLED(AUTO_BED_LEVELING_UBL) + #define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET) + #define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET)) + #define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET) + #define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET)) +#endif + // @section extras // Arc interpretation settings: @@ -1036,7 +1043,7 @@ #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave /** - * Add M43 command for pins info and testing + * Add M43, M44 and M45 commands for pins info and testing */ //#define PINS_DEBUGGING diff --git a/Marlin/G26_Mesh_Validation_Tool.cpp b/Marlin/G26_Mesh_Validation_Tool.cpp new file mode 100644 index 000000000..5cda27f05 --- /dev/null +++ b/Marlin/G26_Mesh_Validation_Tool.cpp @@ -0,0 +1,1001 @@ +/** + * 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 . + * + */ + +/** + * Marlin Firmware -- G26 - Mesh Validation Tool + */ + +#define EXTRUSION_MULTIPLIER 1.0 // This is too much clutter for the main Configuration.h file But +#define RETRACTION_MULTIPLIER 1.0 // some user have expressed an interest in being able to customize +#define NOZZLE 0.3 // these numbers for thier printer so they don't need to type all +#define FILAMENT 1.75 // the options every time they do a Mesh Validation Print. +#define LAYER_HEIGHT 0.2 +#define PRIME_LENGTH 10.0 // So, we put these number in an easy to find and change place. +#define BED_TEMP 60.0 +#define HOTEND_TEMP 205.0 +#define OOOOZE_AMOUNT 0.3 + +#include "Marlin.h" +#include "Configuration.h" +#include "planner.h" +#include "stepper.h" +#include "temperature.h" +#include "UBL.h" +#include "ultralcd.h" + +#if ENABLED(AUTO_BED_LEVELING_UBL) + + #define SIZE_OF_INTERSECTION_CIRCLES 5 + #define SIZE_OF_CROSS_HAIRS 3 // cross hairs inside the circle. This number should be + // less than SIZE_OR_INTERSECTION_CIRCLES + + /** + * Roxy's G26 Mesh Validation Tool + * + * G26 Is a Mesh Validation Tool intended to provide support for the Marlin Unified Bed Leveling System. + * In order to fully utilize and benefit from the Marlin Unified Bed Leveling System an accurate Mesh must + * be defined. G29 is designed to allow the user to quickly validate the correctness of her Mesh. It will + * first heat the bed and nozzle. It will then print lines and circles along the Mesh Cell boundaries and + * the intersections of those lines (respectively). + * + * This action allows the user to immediately see where the Mesh is properly defined and where it needs to + * be edited. The command will generate the Mesh lines closest to the nozzle's starting position. Alternatively + * the user can specify the X and Y position of interest with command parameters. This allows the user to + * focus on a particular area of the Mesh where attention is needed. + * + * B # Bed Set the Bed Temperature. If not specified, a default of 60 C. will be assumed. + * + * C Current When searching for Mesh Intersection points to draw, use the current nozzle location + * as the base for any distance comparison. + * + * D Disable Disable the Unified Bed Leveling System. In the normal case the user is invoking this + * command to see how well a Mesh as been adjusted to match a print surface. In order to do + * this the Unified Bed Leveling System is turned on by the G26 command. The D parameter + * alters the command's normal behaviour and disables the Unified Bed Leveling System even if + * it is on. + * + * H # Hotend Set the Nozzle Temperature. If not specified, a default of 205 C. will be assumed. + * + * F # Filament Used to specify the diameter of the filament being used. If not specified + * 1.75mm filament is assumed. If you are not getting acceptable results by using the + * 'correct' numbers, you can scale this number up or down a little bit to change the amount + * of filament that is being extruded during the printing of the various lines on the bed. + * + * K Keep-On Keep the heaters turned on at the end of the command. + * + * L # Layer Layer height. (Height of nozzle above bed) If not specified .20mm will be used. + * + * Q # Multiplier Retraction Multiplier. Normally not needed. Retraction defaults to 1.0mm and + * un-retraction is at 1.2mm These numbers will be scaled by the specified amount + * + * N # Nozzle Used to control the size of nozzle diameter. If not specified, a .4mm nozzle is assumed. + * + * O # Ooooze How much your nozzle will Ooooze filament while getting in position to print. This + * is over kill, but using this parameter will let you get the very first 'cicle' perfect + * so you have a trophy to peel off of the bed and hang up to show how perfectly you have your + * Mesh calibrated. If not specified, a filament length of .3mm is assumed. + * + * P # Prime Prime the nozzle with specified length of filament. If this parameter is not + * given, no prime action will take place. If the parameter specifies an amount, that much + * will be purged before continuing. If no amount is specified the command will start + * purging filament until the user provides an LCD Click and then it will continue with + * printing the Mesh. You can carefully remove the spent filament with a needle nose + * pliers while holding the LCD Click wheel in a depressed state. + * + * R # Random Randomize the order that the circles are drawn on the bed. The search for the closest + * undrawn cicle is still done. But the distance to the location for each circle has a + * random number of the size specified added to it. Specifying R50 will give an interesting + * deviation from the normal behaviour on a 10 x 10 Mesh. + * + * X # X coordinate Specify the starting location of the drawing activity. + * + * Y # Y coordinate Specify the starting location of the drawing activity. + */ + + extern int UBL_has_control_of_LCD_Panel; + extern float feedrate; + //extern bool relative_mode; + extern Planner planner; + //#if ENABLED(ULTRA_LCD) + extern char lcd_status_message[]; + //#endif + extern float destination[]; + extern void set_destination_to_current(); + extern void set_current_to_destination(); + extern float code_value_float(); + extern bool code_value_bool(); + extern bool code_has_value(); + extern void lcd_init(); + #define PLANNER_XY_FEEDRATE() (min(planner.max_feedrate_mm_s[X_AXIS], planner.max_feedrate_mm_s[Y_AXIS])) //bob + bool prepare_move_to_destination_cartesian(); + void line_to_destination(); + void line_to_destination(float ); + void gcode_G28(); + void sync_plan_position_e(); + void un_retract_filament(); + void retract_filament(); + void look_for_lines_to_connect(); + bool parse_G26_parameters(); + void move_to(const float&, const float&, const float&, const float&) ; + void print_line_from_here_to_there(float sx, float sy, float sz, float ex, float ey, float ez); + bool turn_on_heaters(); + bool prime_nozzle(); + void chirp_at_user(); + + static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16], Continue_with_closest = 0; + float G26_E_AXIS_feedrate = 0.020, + Random_Deviation = 0.0, + Layer_Height = LAYER_HEIGHT; + + bool retracted = false; // We keep track of the state of the nozzle to know if it + // is currently retracted or not. This allows us to be + // less careful because mis-matched retractions and un-retractions + // won't leave us in a bad state. + #if ENABLED(ULTRA_LCD) + void lcd_setstatus(const char* message, bool persist); + #endif + + float valid_trig_angle(float); + mesh_index_pair find_closest_circle_to_print(float, float); + void debug_current_and_destination(char *title); + void UBL_line_to_destination(const float&, const float&, const float&, const float&, const float&, uint8_t); + //uint16_t x_splits = 0xFFFF, uint16_t y_splits = 0xFFFF); /* needed for the old mesh_buffer_line() routine */ + + static float E_Pos_Delta, + Extrusion_Multiplier = EXTRUSION_MULTIPLIER, + Retraction_Multiplier = RETRACTION_MULTIPLIER, + Nozzle = NOZZLE, + Filament = FILAMENT, + Prime_Length = PRIME_LENGTH, + X_Pos, Y_Pos, + bed_temp = BED_TEMP, + hotend_temp = HOTEND_TEMP, + Ooooze_Amount = OOOOZE_AMOUNT; + + int8_t Prime_Flag = 0; + + bool Keep_Heaters_On = false, + G26_Debug_flag = false; + + /** + * These support functions allow the use of large bit arrays of flags that take very + * little RAM. Currently they are limited to being 16x16 in size. Changing the declaration + * to unsigned long will allow us to go to 32x32 if higher resolution Mesh's are needed + * in the future. + */ + void bit_clear(uint16_t bits[16], uint8_t x, uint8_t y) { CBI(bits[y], x); } + void bit_set(uint16_t bits[16], uint8_t x, uint8_t y) { SBI(bits[y], x); } + bool is_bit_set(uint16_t bits[16], uint8_t x, uint8_t y) { return TEST(bits[y], x); } + + /** + * G26: Mesh Validation Pattern generation. + * + * Used to interactively edit UBL's Mesh by placing the + * nozzle in a problem area and doing a G29 P4 R command. + */ + void gcode_G26() { + float circle_x, circle_y, x, y, xe, ye, tmp, + start_angle, end_angle; + int i, xi, yi, lcd_init_counter = 0; + mesh_index_pair location; + + if (axis_unhomed_error(true, true, true)) // Don't allow Mesh Validation without homing first + gcode_G28(); + + if (parse_G26_parameters()) return; // If the paramter parsing did not go OK, we abort the command + + if (current_position[Z_AXIS] < Z_CLEARANCE_BETWEEN_PROBES) { + do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES); + stepper.synchronize(); + set_current_to_destination(); + } + + if (turn_on_heaters()) // Turn on the heaters, leave the command if anything + goto LEAVE; // has gone wrong. + + axis_relative_modes[E_AXIS] = false; // Get things setup so we can take control of the + //relative_mode = false; // planner and stepper motors! + current_position[E_AXIS] = 0.0; + sync_plan_position_e(); + + if (Prime_Flag && prime_nozzle()) // if prime_nozzle() returns an error, we just bail out. + goto LEAVE; + + /** + * Bed is preheated + * + * Nozzle is at temperature + * + * Filament is primed! + * + * It's "Show Time" !!! + */ + + // Clear all of the flags we need + ZERO(circle_flags); + ZERO(horizontal_mesh_line_flags); + ZERO(vertical_mesh_line_flags); + + // + // Move nozzle to the specified height for the first layer + // + set_destination_to_current(); + destination[Z_AXIS] = Layer_Height; + move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 0.0); + move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], Ooooze_Amount); + + UBL_has_control_of_LCD_Panel = 1; // Take control of the LCD Panel! + debug_current_and_destination((char *)"Starting G26 Mesh Validation Pattern."); + + do { + if (G29_lcd_clicked()) { // Check if the user wants to stop the Mesh Validation + strcpy(lcd_status_message, "Mesh Validation Stopped."); // We can't do lcd_setstatus() without having it continue; + while (G29_lcd_clicked()) idle(); // Debounce the switch click + #if ENABLED(ULTRA_LCD) + lcd_setstatus("Mesh Validation Stopped.", true); + lcd_quick_feedback(); + #endif + goto LEAVE; + } + + if (Continue_with_closest) + location = find_closest_circle_to_print(current_position[X_AXIS], current_position[Y_AXIS]); + else + location = find_closest_circle_to_print(X_Pos, Y_Pos); // Find the closest Mesh Intersection to where we are now. + + if (location.x_index >= 0 && location.y_index >= 0) { + circle_x = blm.map_x_index_to_bed_location(location.x_index); + circle_y = blm.map_y_index_to_bed_location(location.y_index); + + // Let's do a couple of quick sanity checks. We can pull this code out later if we never see it catch a problem + #ifdef DELTA + if (HYPOT2(circle_x, circle_y) > sq(DELTA_PRINTABLE_RADIUS)) { + SERIAL_PROTOCOLLNPGM("?Error: Attempt to print outside of DELTA_PRINTABLE_RADIUS."); + goto LEAVE; + } + #endif + + if (circle_x < X_MIN_POS || circle_x > X_MAX_POS || circle_y < Y_MIN_POS || circle_y > Y_MAX_POS) { + SERIAL_PROTOCOLLNPGM("?Error: Attempt to print off the bed."); + goto LEAVE; + } + + xi = location.x_index; // Just to shrink the next few lines and make them easier to understand + yi = location.y_index; + + if (G26_Debug_flag) { + SERIAL_ECHOPGM(" Doing circle at: (xi="); + SERIAL_ECHO(xi); + SERIAL_ECHOPGM(", yi="); + SERIAL_ECHO(yi); + SERIAL_ECHOLNPGM(")"); + } + + start_angle = 0.0; // assume it is going to be a full circle + end_angle = 360.0; + if (xi == 0) { // Check for bottom edge + start_angle = -90.0; + end_angle = 90.0; + if (yi == 0) // it is an edge, check for the two left corners + start_angle = 0.0; + else if (yi == UBL_MESH_NUM_Y_POINTS - 1) + end_angle = 0.0; + } + else if (xi == UBL_MESH_NUM_X_POINTS - 1) { // Check for top edge + start_angle = 90.0; + end_angle = 270.0; + if (yi == 0) // it is an edge, check for the two right corners + end_angle = 180.0; + else if (yi == UBL_MESH_NUM_Y_POINTS - 1) + start_angle = 180.0; + } + else if (yi == 0) { + start_angle = 0.0; // only do the top side of the cirlce + end_angle = 180.0; + } + else if (yi == UBL_MESH_NUM_Y_POINTS - 1) { + start_angle = 180.0; // only do the bottom side of the cirlce + end_angle = 360.0; + } + + /** + * Declare and generate a sin() & cos() table to be used during the circle drawing. This will lighten + * the CPU load and make the arc drawing faster and more smooth + */ + float sin_table[360 / 30 + 1], cos_table[360 / 30 + 1]; + int tmp_div_30; + for (i = 0; i <= 360 / 30; i++) { + cos_table[i] = SIZE_OF_INTERSECTION_CIRCLES * cos(RADIANS(valid_trig_angle(i * 30.0))); + sin_table[i] = SIZE_OF_INTERSECTION_CIRCLES * sin(RADIANS(valid_trig_angle(i * 30.0))); + } + + for (tmp = start_angle; tmp < end_angle - 0.1; tmp += 30.0) { + tmp_div_30 = tmp / 30.0; + if (tmp_div_30 < 0) tmp_div_30 += 360 / 30; + + x = circle_x + cos_table[tmp_div_30]; // for speed, these are now a lookup table entry + y = circle_y + sin_table[tmp_div_30]; + + if (tmp_div_30 > 11) tmp_div_30 -= 360 / 30; + xe = circle_x + cos_table[tmp_div_30 + 1]; // for speed, these are now a lookup table entry + ye = circle_y + sin_table[tmp_div_30 + 1]; + #ifdef DELTA + if (HYPOT2(x, y) > sq(DELTA_PRINTABLE_RADIUS)) // Check to make sure this part of + continue; // the 'circle' is on the bed. If + #else // not, we need to skip + x = constrain(x, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops + y = constrain(y, Y_MIN_POS + 1, Y_MAX_POS - 1); + xe = constrain(xe, X_MIN_POS + 1, X_MAX_POS - 1); + ye = constrain(ye, Y_MIN_POS + 1, Y_MAX_POS - 1); + #endif + + if (G26_Debug_flag) { + char ccc, *cptr, seg_msg[50], seg_num[10]; + strcpy(seg_msg, " segment: "); + strcpy(seg_num, " \n"); + cptr = (char *) "01234567890ABCDEF????????"; + ccc = cptr[tmp_div_30]; + seg_num[1] = ccc; + strcat(seg_msg, seg_num); + debug_current_and_destination(seg_msg); + } + + print_line_from_here_to_there(x, y, Layer_Height, xe, ye, Layer_Height); + } + lcd_init_counter++; + if (lcd_init_counter > 10) { + lcd_init_counter = 0; + lcd_init(); // Some people's LCD Displays are locking up. This might help them + } + + debug_current_and_destination((char *)"Looking for lines to connect."); + look_for_lines_to_connect(); + debug_current_and_destination((char *)"Done with line connect."); + } + + debug_current_and_destination((char *)"Done with current circle."); + + } + while (location.x_index >= 0 && location.y_index >= 0) ; + + LEAVE: + + retract_filament(); + destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES; // Raise the nozzle + + debug_current_and_destination((char *)"ready to do Z-Raise."); + move_to( destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 0); // Raise the nozzle + debug_current_and_destination((char *)"done doing Z-Raise."); + + destination[X_AXIS] = X_Pos; // Move back to the starting position + destination[Y_AXIS] = Y_Pos; + destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES; // Keep the nozzle where it is + + move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 0); // Move back to the starting position + debug_current_and_destination((char *)"done doing X/Y move."); + + UBL_has_control_of_LCD_Panel = 0; // Give back control of the LCD Panel! + + if (!Keep_Heaters_On) { + #if HAS_TEMP_BED + thermalManager.setTargetBed(0.0); + #endif + thermalManager.setTargetHotend(0.0, 0); + } + lcd_init(); // Some people's LCD Displays are locking up. This might help them + } + + + float valid_trig_angle(float d) { + while (d > 360.0) d -= 360.0; + while (d < 0.0) d += 360.0; + return d; + } + + mesh_index_pair find_closest_circle_to_print( float X, float Y) { + float f, mx, my, dx, dy, closest = 99999.99; + mesh_index_pair return_val; + + return_val.x_index = return_val.y_index = -1; + + for (uint8_t i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { + for (uint8_t j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { + if (!is_bit_set(circle_flags, i, j)) { + mx = blm.map_x_index_to_bed_location(i); // We found a circle that needs to be printed + my = blm.map_y_index_to_bed_location(j); + + dx = X - mx; // Get the distance to this intersection + dy = Y - my; + f = HYPOT(dx, dy); + + dx = X_Pos - mx; // It is possible that we are being called with the values + dy = Y_Pos - my; // to let us find the closest circle to the start position. + f += HYPOT(dx, dy) / 15.0; // But if this is not the case, + // we are going to add in a small + // weighting to the distance calculation to help it choose + // a better place to continue. + + if (Random_Deviation > 1.0) + f += random(0.0, Random_Deviation); // Add in the specified amount of Random Noise to our search + + if (f < closest) { + closest = f; // We found a closer location that is still + return_val.x_index = i; // un-printed --- save the data for it + return_val.y_index = j; + return_val.distance= closest; + } + } + } + } + bit_set(circle_flags, return_val.x_index, return_val.y_index); // Mark this location as done. + return return_val; + } + + void look_for_lines_to_connect() { + float sx, sy, ex, ey; + + for (uint8_t i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { + for (uint8_t j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { + + if (i < UBL_MESH_NUM_X_POINTS) { // We can't connect to anything to the right than UBL_MESH_NUM_X_POINTS. + // This is already a half circle because we are at the edge of the bed. + + if (is_bit_set(circle_flags, i, j) && is_bit_set(circle_flags, i + 1, j)) { // check if we can do a line to the left + if (!is_bit_set(horizontal_mesh_line_flags, i, j)) { + + // + // We found two circles that need a horizontal line to connect them + // Print it! + // + sx = blm.map_x_index_to_bed_location(i); + sx = sx + SIZE_OF_INTERSECTION_CIRCLES - SIZE_OF_CROSS_HAIRS; // get the right edge of the circle + sy = blm.map_y_index_to_bed_location(j); + + ex = blm.map_x_index_to_bed_location(i + 1); + ex = ex - SIZE_OF_INTERSECTION_CIRCLES + SIZE_OF_CROSS_HAIRS; // get the left edge of the circle + ey = sy; + + sx = constrain(sx, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops + sy = constrain(sy, Y_MIN_POS + 1, Y_MAX_POS - 1); + ex = constrain(ex, X_MIN_POS + 1, X_MAX_POS - 1); + ey = constrain(ey, Y_MIN_POS + 1, Y_MAX_POS - 1); + + if (G26_Debug_flag) { + SERIAL_ECHOPGM(" Connecting with horizontal line (sx="); + SERIAL_ECHO(sx); + SERIAL_ECHOPGM(", sy="); + SERIAL_ECHO(sy); + SERIAL_ECHOPGM(") -> (ex="); + SERIAL_ECHO(ex); + SERIAL_ECHOPGM(", ey="); + SERIAL_ECHO(ey); + SERIAL_ECHOLNPGM(")"); + debug_current_and_destination((char *)"Connecting horizontal line."); + } + + print_line_from_here_to_there(sx, sy, Layer_Height, ex, ey, Layer_Height); + bit_set(horizontal_mesh_line_flags, i, j); // Mark it as done so we don't do it again + } + } + + if (j < UBL_MESH_NUM_Y_POINTS) { // We can't connect to anything further back than UBL_MESH_NUM_Y_POINTS. + // This is already a half circle because we are at the edge of the bed. + + if (is_bit_set(circle_flags, i, j) && is_bit_set(circle_flags, i, j + 1)) { // check if we can do a line straight down + if (!is_bit_set( vertical_mesh_line_flags, i, j)) { + // + // We found two circles that need a vertical line to connect them + // Print it! + // + sx = blm.map_x_index_to_bed_location(i); + sy = blm.map_y_index_to_bed_location(j); + sy = sy + SIZE_OF_INTERSECTION_CIRCLES - SIZE_OF_CROSS_HAIRS; // get the top edge of the circle + + ex = sx; + ey = blm.map_y_index_to_bed_location(j + 1); + ey = ey - SIZE_OF_INTERSECTION_CIRCLES + SIZE_OF_CROSS_HAIRS; // get the bottom edge of the circle + + sx = constrain(sx, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops + sy = constrain(sy, Y_MIN_POS + 1, Y_MAX_POS - 1); + ex = constrain(ex, X_MIN_POS + 1, X_MAX_POS - 1); + ey = constrain(ey, Y_MIN_POS + 1, Y_MAX_POS - 1); + + if (G26_Debug_flag) { + SERIAL_ECHOPGM(" Connecting with vertical line (sx="); + SERIAL_ECHO(sx); + SERIAL_ECHOPGM(", sy="); + SERIAL_ECHO(sy); + SERIAL_ECHOPGM(") -> (ex="); + SERIAL_ECHO(ex); + SERIAL_ECHOPGM(", ey="); + SERIAL_ECHO(ey); + SERIAL_ECHOLNPGM(")"); + debug_current_and_destination((char *)"Connecting vertical line."); + } + print_line_from_here_to_there(sx, sy, Layer_Height, ex, ey, Layer_Height); + bit_set( vertical_mesh_line_flags, i, j); // Mark it as done so we don't do it again + } + } + } + } + } + } + } + + void debug_current_and_destination(char *title) { + float dx, dy, de, xy_dist, fpmm; + + // if the title message starts with a '!' it is so important, we are going to + // ignore the status of the G26_Debug_Flag + if (*title != '!' && !G26_Debug_flag) return; + + dx = current_position[X_AXIS] - destination[X_AXIS]; + dy = current_position[Y_AXIS] - destination[Y_AXIS]; + de = destination[E_AXIS] - current_position[E_AXIS]; + if (de == 0.0) return; + + xy_dist = HYPOT(dx, dy); + if (xy_dist == 0.0) { + return; + //SERIAL_ECHOPGM(" FPMM="); + //fpmm = de; + //SERIAL_PROTOCOL_F(fpmm, 6); + } + else { + SERIAL_ECHOPGM(" fpmm="); + fpmm = de / xy_dist; + SERIAL_PROTOCOL_F(fpmm, 6); + } + + SERIAL_ECHOPGM(" current=( "); + SERIAL_PROTOCOL_F(current_position[X_AXIS], 6); + SERIAL_ECHOPGM(", "); + SERIAL_PROTOCOL_F(current_position[Y_AXIS], 6); + SERIAL_ECHOPGM(", "); + SERIAL_PROTOCOL_F(current_position[Z_AXIS], 6); + SERIAL_ECHOPGM(", "); + SERIAL_PROTOCOL_F(current_position[E_AXIS], 6); + SERIAL_ECHOPGM(" ) destination=( "); + if (current_position[X_AXIS] == destination[X_AXIS]) + SERIAL_ECHOPGM("-------------"); + else + SERIAL_PROTOCOL_F(destination[X_AXIS], 6); + + SERIAL_ECHOPGM(", "); + + if (current_position[Y_AXIS] == destination[Y_AXIS]) + SERIAL_ECHOPGM("-------------"); + else + SERIAL_PROTOCOL_F(destination[Y_AXIS], 6); + + SERIAL_ECHOPGM(", "); + + if (current_position[Z_AXIS] == destination[Z_AXIS]) + SERIAL_ECHOPGM("-------------"); + else + SERIAL_PROTOCOL_F(destination[Z_AXIS], 6); + + SERIAL_ECHOPGM(", "); + + if (current_position[E_AXIS] == destination[E_AXIS]) + SERIAL_ECHOPGM("-------------"); + else + SERIAL_PROTOCOL_F(destination[E_AXIS], 6); + + SERIAL_ECHOPGM(" ) "); + SERIAL_ECHO(title); + SERIAL_EOL; + + SET_INPUT_PULLUP(66); // Roxy's Left Switch is on pin 66. Right Switch is on pin 65 + + //if (been_to_2_6) { + //while ((digitalRead(66) & 0x01) != 0) + // idle(); + //} + } + + void move_to(const float &x, const float &y, const float &z, const float &e_delta) { + float feed_value; + static float last_z = -999.99; + + bool has_XY_component = (x != current_position[X_AXIS] || y != current_position[Y_AXIS]); // Check if X or Y is involved in the movement. + + if (G26_Debug_flag) { + SERIAL_ECHOPAIR("in move_to() has_XY_component:", (int)has_XY_component); + SERIAL_EOL; + } + + if (z != last_z) { + + if (G26_Debug_flag) { + SERIAL_ECHOPAIR("in move_to() changing Z to ", (int)z); + SERIAL_EOL; + } + last_z = z; + feed_value = planner.max_feedrate_mm_s[Z_AXIS]/(3.0); // Base the feed rate off of the configured Z_AXIS feed rate + + destination[X_AXIS] = current_position[X_AXIS]; + destination[Y_AXIS] = current_position[Y_AXIS]; + destination[Z_AXIS] = z; // We know the last_z==z or we wouldn't be in this block of code. + destination[E_AXIS] = current_position[E_AXIS]; + + UBL_line_to_destination(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feed_value, 0); + + stepper.synchronize(); + set_destination_to_current(); + + if (G26_Debug_flag) + debug_current_and_destination((char *)" in move_to() done with Z move"); + } + + // Check if X or Y is involved in the movement. + // Yes: a 'normal' movement. No: a retract() or un_retract() + feed_value = has_XY_component ? PLANNER_XY_FEEDRATE() / 10.0 : planner.max_feedrate_mm_s[E_AXIS] / 1.5; + + if (G26_Debug_flag) { + SERIAL_ECHOPAIR("in move_to() feed_value for XY:", feed_value); + SERIAL_EOL; + } + + destination[X_AXIS] = x; + destination[Y_AXIS] = y; + destination[E_AXIS] += e_delta; + + if (G26_Debug_flag) + debug_current_and_destination((char *)" in move_to() doing last move"); + + UBL_line_to_destination(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feed_value, 0); + + if (G26_Debug_flag) + debug_current_and_destination((char *)" in move_to() after last move"); + + stepper.synchronize(); + set_destination_to_current(); + } + + void retract_filament() { + if (!retracted) { // Only retract if we are not already retracted! + retracted = true; + if (G26_Debug_flag) SERIAL_ECHOLNPGM(" Decided to do retract."); + move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], -1.0 * Retraction_Multiplier); + if (G26_Debug_flag) SERIAL_ECHOLNPGM(" Retraction done."); + } + } + + void un_retract_filament() { + if (retracted) { // Only un-retract if we are retracted. + move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 1.2 * Retraction_Multiplier); + retracted = false; + if (G26_Debug_flag) SERIAL_ECHOLNPGM(" unretract done."); + } + } + + /** + * print_line_from_here_to_there() takes two cartesian coordinates and draws a line from one + * to the other. But there are really three sets of coordinates involved. The first coordinate + * is the present location of the nozzle. We don't necessarily want to print from this location. + * We first need to move the nozzle to the start of line segment where we want to print. Once + * there, we can use the two coordinates supplied to draw the line. + * + * Note: Although we assume the first set of coordinates is the start of the line and the second + * set of coordinates is the end of the line, it does not always work out that way. This function + * optimizes the movement to minimize the travel distance before it can start printing. This saves + * a lot of time and eleminates a lot of non-sensical movement of the nozzle. However, it does + * cause a lot of very little short retracement of th nozzle when it draws the very first line + * segment of a 'circle'. The time this requires is very short and is easily saved by the other + * cases where the optimization comes into play. + */ + void print_line_from_here_to_there( float sx, float sy, float sz, float ex, float ey, float ez) { + float dx, dy, dx_s, dy_s, dx_e, dy_e, dist_start, dist_end, Line_Length; + + dx_s = current_position[X_AXIS] - sx; // find our distance from the start of the actual line segment + dy_s = current_position[Y_AXIS] - sy; + dist_start = HYPOT2(dx_s, dy_s); // We don't need to do a sqrt(), we can compare the distance^2 + // to save computation time + dx_e = current_position[X_AXIS] - ex; // find our distance from the end of the actual line segment + dy_e = current_position[Y_AXIS] - ey; + dist_end = HYPOT2(dx_e, dy_e); + + dx = ex - sx; + dy = ey - sy; + Line_Length = HYPOT(dx, dy); + + // If the end point of the line is closer to the nozzle, we are going to + // flip the direction of this line. We will print it from the end to the start. + // On very small lines we don't do the optimization because it just isn't worth it. + // + if (dist_end < dist_start && (SIZE_OF_INTERSECTION_CIRCLES) < abs(Line_Length)) { + if (G26_Debug_flag) + SERIAL_ECHOLNPGM(" Reversing start and end of print_line_from_here_to_there()"); + print_line_from_here_to_there(ex, ey, ez, sx, sy, sz); + return; + } + + // Now decide if we should retract. + + if (dist_start > 2.0) { + retract_filament(); + if (G26_Debug_flag) + SERIAL_ECHOLNPGM(" filament retracted."); + } + move_to(sx, sy, sz, 0.0); // Get to the starting point with no extrusion + + E_Pos_Delta = Line_Length * G26_E_AXIS_feedrate * Extrusion_Multiplier; + + un_retract_filament(); + if (G26_Debug_flag) { + SERIAL_ECHOLNPGM(" doing printing move."); + debug_current_and_destination((char *)"doing final move_to() inside print_line_from_here_to_there()"); + } + move_to(ex, ey, ez, E_Pos_Delta); // Get to the ending point with an appropriate amount of extrusion + } + + /** + * This function used to be inline code in G26. But there are so many + * parameters it made sense to turn them into static globals and get + * this code out of sight of the main routine. + */ + bool parse_G26_parameters() { + + Extrusion_Multiplier = EXTRUSION_MULTIPLIER; + Retraction_Multiplier = RETRACTION_MULTIPLIER; + Nozzle = NOZZLE; + Filament = FILAMENT; + Layer_Height = LAYER_HEIGHT; + Prime_Length = PRIME_LENGTH; + bed_temp = BED_TEMP; + hotend_temp = HOTEND_TEMP; + Ooooze_Amount = OOOOZE_AMOUNT; + Prime_Flag = 0; + Keep_Heaters_On = false; + + if (code_seen('B')) { + bed_temp = code_value_float(); + if (bed_temp < 15.0 || bed_temp > 140.0) { + SERIAL_PROTOCOLLNPGM("?Specified bed temperature not plausible."); + return UBL_ERR; + } + } + + if (code_seen('C')) Continue_with_closest++; + + if (code_seen('L')) { + Layer_Height = code_value_float(); + if (Layer_Height<0.0 || Layer_Height>2.0) { + SERIAL_PROTOCOLLNPGM("?Specified layer height not plausible."); + return UBL_ERR; + } + } + + if (code_seen('Q')) { + if (code_has_value()) { + Retraction_Multiplier = code_value_float(); + if (Retraction_Multiplier<.05 || Retraction_Multiplier>15.0) { + SERIAL_PROTOCOLLNPGM("?Specified Retraction Multiplier not plausible."); + return UBL_ERR; + } + } + else { + SERIAL_PROTOCOLLNPGM("?Retraction Multiplier must be specified."); + return UBL_ERR; + } + } + + if (code_seen('N')) { + Nozzle = code_value_float(); + if (Nozzle < 0.1 || Nozzle > 1.0) { + SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible."); + return UBL_ERR; + } + } + + if (code_seen('K')) Keep_Heaters_On++; + + if (code_seen('O') && code_has_value()) + Ooooze_Amount = code_value_float(); + + if (code_seen('P')) { + if (!code_has_value()) + Prime_Flag = -1; + else { + Prime_Flag++; + Prime_Length = code_value_float(); + if (Prime_Length < 0.0 || Prime_Length > 25.0) { + SERIAL_PROTOCOLLNPGM("?Specified prime length not plausible."); + return UBL_ERR; + } + } + } + + if (code_seen('F')) { + Filament = code_value_float(); + if (Filament < 1.0 || Filament > 4.0) { + SERIAL_PROTOCOLLNPGM("?Specified filament size not plausible."); + return UBL_ERR; + } + } + Extrusion_Multiplier *= sq(1.75) / sq(Filament); // If we aren't using 1.75mm filament, we need to + // scale up or down the length needed to get the + // same volume of filament + Extrusion_Multiplier *= Filament * sq(Nozzle) / sq(0.3); // Scale up by nozzle size + + if (code_seen('H')) { + hotend_temp = code_value_float(); + if (hotend_temp < 165.0 || hotend_temp > 280.0) { + SERIAL_PROTOCOLLNPGM("?Specified nozzle temperature not plausible."); + return UBL_ERR; + } + } + + if (code_seen('R')) { + randomSeed(millis()); + Random_Deviation = code_has_value() ? code_value_float() : 50.0; + } + + X_Pos = current_position[X_AXIS]; + Y_Pos = current_position[Y_AXIS]; + + if (code_seen('X')) { + X_Pos = code_value_float(); + if (X_Pos < X_MIN_POS || X_Pos > X_MAX_POS) { + SERIAL_PROTOCOLLNPGM("?Specified X coordinate not plausible."); + return UBL_ERR; + } + } + else + + if (code_seen('Y')) { + Y_Pos = code_value_float(); + if (Y_Pos < Y_MIN_POS || Y_Pos > Y_MAX_POS) { + SERIAL_PROTOCOLLNPGM("?Specified Y coordinate not plausible."); + return UBL_ERR; + } + } + + /** + * We save the question of what to do with the Unified Bed Leveling System's Activation until the very + * end. The reason is, if one of the parameters specified up above is incorrect, we don't want to + * alter the system's status. We wait until we know everything is correct before altering the state + * of the system. + */ + blm.state.active = !code_seen('D'); + + return UBL_OK; + } + + /** + * Turn on the bed and nozzle heat and + * wait for them to get up to temperature. + */ + bool turn_on_heaters() { + #if HAS_TEMP_BED + #if ENABLED(ULTRA_LCD) + if (bed_temp > 25) { + lcd_setstatus("G26 Heating Bed.", true); + lcd_quick_feedback(); + #endif + UBL_has_control_of_LCD_Panel++; + thermalManager.setTargetBed(bed_temp); + while (abs(thermalManager.degBed() - bed_temp) > 3) { + if (G29_lcd_clicked()) { + strcpy(lcd_status_message, "Leaving G26"); // We can't do lcd_setstatus() without having it continue; + while (G29_lcd_clicked()) idle(); // Debounce the switch + lcd_setstatus("Leaving G26", true); // Now we do it right. + return UBL_ERR; + } + idle(); + } + #if ENABLED(ULTRA_LCD) + } + lcd_setstatus("G26 Heating Nozzle.", true); + lcd_quick_feedback(); + #endif + #endif + + // Start heating the nozzle and wait for it to reach temperature. + thermalManager.setTargetHotend(hotend_temp, 0); + while (abs(thermalManager.degHotend(0) - hotend_temp) > 3) { + if (G29_lcd_clicked()) { + strcpy(lcd_status_message, "Leaving G26"); // We can't do lcd_setstatus() without having it continue; + while (G29_lcd_clicked()) idle(); // Debounce the switch + lcd_setstatus("Leaving G26", true); // Now we do it right. + return UBL_ERR; + } + idle(); + } + + #if ENABLED(ULTRA_LCD) + lcd_setstatus("", true); + lcd_quick_feedback(); + #endif + return UBL_OK; + } + + /** + * Prime the nozzle if needed. Return true on error. + */ + bool prime_nozzle() { + float Total_Prime = 0.0; + + if (Prime_Flag == -1) { // The user wants to control how much filament gets purged + lcd_setstatus("User Controled Prime", true); + chirp_at_user(); + + set_destination_to_current(); + + un_retract_filament(); // Lets make sure the G26 command doesn't think the filament is + // retracted(). We are here because we want to prime the nozzle. + // So let's just unretract just to be sure. + + UBL_has_control_of_LCD_Panel++; + while (!G29_lcd_clicked()) { + chirp_at_user(); + destination[E_AXIS] += 0.25; + #ifdef PREVENT_LENGTHY_EXTRUDE + Total_Prime += 0.25; + if (Total_Prime >= EXTRUDE_MAXLENGTH) return UBL_ERR; + #endif + UBL_line_to_destination( + destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], + //planner.max_feedrate_mm_s[E_AXIS] / 15.0, 0, 0xFFFF, 0xFFFF); + planner.max_feedrate_mm_s[E_AXIS] / 15.0, 0 + ); + + stepper.synchronize(); // Without this synchronize, the purge is more consistent, + // but because the planner has a buffer, we won't be able + // to stop as quickly. So we put up with the less smooth + // action to give the user a more responsive 'Stop'. + set_destination_to_current(); + idle(); + } + + strcpy(lcd_status_message, "Done Priming"); // We can't do lcd_setstatus() without having it continue; + // So... We cheat to get a message up. + + while (G29_lcd_clicked()) idle(); // Debounce the switch + + #if ENABLED(ULTRA_LCD) + UBL_has_control_of_LCD_Panel = 0; + lcd_setstatus("Done Priming", true); // Now we do it right. + lcd_quick_feedback(); + #endif + } + else { + #if ENABLED(ULTRA_LCD) + lcd_setstatus("Fixed Length Prime.", true); + lcd_quick_feedback(); + #endif + set_destination_to_current(); + destination[E_AXIS] += Prime_Length; + UBL_line_to_destination( + destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], + //planner.max_feedrate_mm_s[E_AXIS] / 15.0, 0, 0xFFFF, 0xFFFF); + planner.max_feedrate_mm_s[E_AXIS] / 15.0, 0 + ); + stepper.synchronize(); + set_destination_to_current(); + retract_filament(); + } + return UBL_OK; + } + +#endif // AUTO_BED_LEVELING_UBL diff --git a/Marlin/M100_Free_Mem_Chk.cpp b/Marlin/M100_Free_Mem_Chk.cpp index d82434e97..58589614d 100644 --- a/Marlin/M100_Free_Mem_Chk.cpp +++ b/Marlin/M100_Free_Mem_Chk.cpp @@ -35,7 +35,7 @@ * M100 C x Corrupts x locations within the free memory block. This is useful to check the * correctness of the M100 F and M100 D commands. * - * Initial version by Roxy-3DPrintBoard + * Initial version by Roxy-3D */ #define M100_FREE_MEMORY_DUMPER // Comment out to remove Dump sub-command #define M100_FREE_MEMORY_CORRUPTOR // Comment out to remove Corrupt sub-command @@ -51,10 +51,9 @@ extern char __bss_end; // Utility functions used by M100 to get its work done. // +#include "hex_print_routines.h" + char* top_of_stack(); -void prt_hex_nibble(unsigned int); -void prt_hex_byte(unsigned int); -void prt_hex_word(unsigned int); int how_many_E5s_are_here(char*); void gcode_M100() { @@ -211,27 +210,6 @@ char* top_of_stack() { return &x + 1; // x is pulled on return; } -// -// 3 support routines to print hex numbers. We can print a nibble, byte and word -// - -void prt_hex_nibble(unsigned int n) { - if (n <= 9) - SERIAL_ECHO(n); - else - SERIAL_ECHO((char)('A' + n - 10)); -} - -void prt_hex_byte(unsigned int b) { - prt_hex_nibble((b & 0xf0) >> 4); - prt_hex_nibble(b & 0x0f); -} - -void prt_hex_word(unsigned int w) { - prt_hex_byte((w & 0xff00) >> 8); - prt_hex_byte(w & 0x0ff); -} - // how_many_E5s_are_here() is a utility function to easily find out how many 0xE5's are // at the specified location. Having this logic as a function simplifies the search code. // diff --git a/Marlin/Marlin.h b/Marlin/Marlin.h index 1ce190b45..e77fc4615 100644 --- a/Marlin/Marlin.h +++ b/Marlin/Marlin.h @@ -40,6 +40,7 @@ #include "fastio.h" #include "utility.h" + #ifdef USBCON #include "HardwareSerial.h" #if ENABLED(BLUETOOTH) @@ -82,6 +83,7 @@ extern const char errormagic[] PROGMEM; #define SERIAL_ECHOLNPGM(x) SERIAL_PROTOCOLLNPGM(x) #define SERIAL_ECHOPAIR(name,value) SERIAL_PROTOCOLPAIR(name, value) #define SERIAL_ECHOLNPAIR(name, value) SERIAL_PROTOCOLLNPAIR(name, value) +#define SERIAL_ECHO_F(x,y) SERIAL_PROTOCOL_F(x,y) #define SERIAL_ERROR_START (serialprintPGM(errormagic)) #define SERIAL_ERROR(x) SERIAL_PROTOCOL(x) @@ -95,6 +97,7 @@ void serial_echopair_P(const char* s_P, int v); void serial_echopair_P(const char* s_P, long v); void serial_echopair_P(const char* s_P, float v); void serial_echopair_P(const char* s_P, double v); +void serial_echopair_P(const char* s_P, unsigned int v); void serial_echopair_P(const char* s_P, unsigned long v); FORCE_INLINE void serial_echopair_P(const char* s_P, uint8_t v) { serial_echopair_P(s_P, (int)v); } FORCE_INLINE void serial_echopair_P(const char* s_P, uint16_t v) { serial_echopair_P(s_P, (int)v); } diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 5a329e040..b8a52c78e 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -1,6 +1,6 @@ /** * Marlin 3D Printer Firmware - * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] + * Copyright (C) 2016, 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] * * Based on Sprinter and grbl. * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm @@ -234,6 +234,10 @@ #include "duration_t.h" #include "types.h" +#if ENABLED(AUTO_BED_LEVELING_UBL) + #include "UBL.h" +#endif + #if HAS_ABL #include "vector_3.h" #if ENABLED(AUTO_BED_LEVELING_LINEAR) @@ -297,6 +301,10 @@ G38_endstop_hit = false; #endif +#if ENABLED(AUTO_BED_LEVELING_UBL) + bed_leveling blm; +#endif + bool Running = true; uint8_t marlin_debug_flags = DEBUG_NONE; @@ -315,7 +323,7 @@ float current_position[XYZE] = { 0.0 }; * Set with 'gcode_get_destination' or 'set_destination_to_current'. * 'line_to_destination' sets 'current_position' to 'destination'. */ -static float destination[XYZE] = { 0.0 }; +float destination[XYZE] = { 0.0 }; /** * axis_homed @@ -706,7 +714,7 @@ static void report_current_position(); SERIAL_ECHOPAIR("(", x); SERIAL_ECHOPAIR(", ", y); SERIAL_ECHOPAIR(", ", z); - SERIAL_ECHOPGM(")"); + SERIAL_CHAR(')'); if (suffix) serialprintPGM(suffix); else SERIAL_EOL; @@ -1760,7 +1768,7 @@ static void clean_up_after_endstop_or_probe_move() { #endif //HAS_BED_PROBE #if ENABLED(Z_PROBE_ALLEN_KEY) || ENABLED(Z_PROBE_SLED) || HAS_PROBING_PROCEDURE || HOTENDS > 1 || ENABLED(NOZZLE_CLEAN_FEATURE) || ENABLED(NOZZLE_PARK_FEATURE) - static bool axis_unhomed_error(const bool x, const bool y, const bool z) { + bool axis_unhomed_error(const bool x, const bool y, const bool z) { const bool xx = x && !axis_homed[X_AXIS], yy = y && !axis_homed[Y_AXIS], zz = z && !axis_homed[Z_AXIS]; @@ -2009,7 +2017,7 @@ static void clean_up_after_endstop_or_probe_move() { #endif // returns false for ok and true for failure - static bool set_probe_deployed(bool deploy) { + bool set_probe_deployed(bool deploy) { #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) { @@ -2196,7 +2204,8 @@ static void clean_up_after_endstop_or_probe_move() { // - Raise to the BETWEEN height // - Return the probed Z position // - static float probe_pt(const float &x, const float &y, const bool stow = true, const int verbose_level = 1) { +//float probe_pt(const float &x, const float &y, const bool stow = true, const int verbose_level = 1) { + float probe_pt(const float x, const float y, const bool stow, const int verbose_level) { #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) { SERIAL_ECHOPAIR(">>> probe_pt(", x); @@ -3291,10 +3300,12 @@ inline void gcode_G4() { SERIAL_ECHOPGM("BILINEAR"); #elif ENABLED(AUTO_BED_LEVELING_3POINT) SERIAL_ECHOPGM("3POINT"); + #elif ENABLED(AUTO_BED_LEVELING_UBL) + SERIAL_ECHOPGM("UBL"); #endif if (planner.abl_enabled) { SERIAL_ECHOLNPGM(" (enabled)"); - #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT) + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT) || ENABLED(AUTO_BED_LEVELING_UBL) float diff[XYZ] = { stepper.get_axis_position_mm(X_AXIS) - current_position[X_AXIS], stepper.get_axis_position_mm(Y_AXIS) - current_position[Y_AXIS], @@ -3842,7 +3853,7 @@ inline void gcode_G28() { report_current_position(); } -#elif HAS_ABL +#elif HAS_ABL && DISABLED(AUTO_BED_LEVELING_UBL) /** * G29: Detailed Z probe, probes the bed at 3 or more points. @@ -4395,7 +4406,7 @@ inline void gcode_G28() { SYNC_PLAN_POSITION_KINEMATIC(); } -#endif // HAS_ABL +#endif // HAS_ABL && DISABLED(AUTO_BED_LEVELING_UBL) #if HAS_BED_PROBE @@ -7005,6 +7016,8 @@ void quickstop_stepper() { bed_level_virt_print(); #endif } + #elif ENABLED(AUTO_BED_LEVELING_UBL) + blm.display_map(0); // Right now, we only support one type of map #elif ENABLED(MESH_BED_LEVELING) if (mbl.has_mesh()) { SERIAL_ECHOLNPGM("Mesh Bed Level data:"); @@ -8315,6 +8328,12 @@ void process_next_command() { break; #endif // INCH_MODE_SUPPORT + #if ENABLED(AUTO_BED_LEVELING_UBL) + case 26: // G26: Mesh Validation Pattern generation + gcode_G26(); + break; + #endif // AUTO_BED_LEVELING_UBL + #if ENABLED(NOZZLE_PARK_FEATURE) case 27: // G27: Nozzle Park gcode_G27(); @@ -8326,7 +8345,8 @@ void process_next_command() { break; #if PLANNER_LEVELING - case 29: // G29 Detailed Z probe, probes the bed at 3 or more points. + case 29: // G29 Detailed Z probe, probes the bed at 3 or more points, + // or provides access to the UBL System if enabled. gcode_G29(); break; #endif // PLANNER_LEVELING @@ -8433,12 +8453,24 @@ void process_next_command() { gcode_M43(); break; #endif + #if ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST) case 48: // M48: Z probe repeatability test gcode_M48(); break; #endif // Z_MIN_PROBE_REPEATABILITY_TEST + #if ENABLED(AUTO_BED_LEVELING_UBL) + case 49: // M49: Turn on or off G26_Debug_flag for verbose output + if (G26_Debug_flag) { + SERIAL_PROTOCOLPGM("UBL Debug Flag turned off.\n"); + G26_Debug_flag = 0; } + else { + SERIAL_PROTOCOLPGM("UBL Debug Flag turned on.\n"); + G26_Debug_flag++; } + break; + #endif // Z_MIN_PROBE_REPEATABILITY_TEST + case 75: // M75: Start print timer gcode_M75(); break; case 76: // M76: Pause print timer @@ -9078,7 +9110,7 @@ void ok_to_send() { SERIAL_ECHOLNPAIR(" offset=", offset); } last_offset = offset; - //*/ + */ return offset; } @@ -9564,6 +9596,18 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { return false; } else + #elif ENABLED(AUTO_BED_LEVELING_UBL) + if (blm.state.active) { + +// UBL_line_to_destination(MMS_SCALED(feedrate_mm_s)); + + UBL_line_to_destination(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], +// (feedrate*(1.0/60.0))*(feedrate_percentage*(1.0/100.0) ), active_extruder); + MMS_SCALED(feedrate_mm_s), active_extruder); + + return false; + } + else #elif ENABLED(AUTO_BED_LEVELING_BILINEAR) if (planner.abl_enabled) { bilinear_line_to_destination(MMS_SCALED(feedrate_mm_s)); @@ -10565,9 +10609,9 @@ void setup() { #endif #if ENABLED(RGB_LED) - pinMode(RGB_LED_R_PIN, OUTPUT); - pinMode(RGB_LED_G_PIN, OUTPUT); - pinMode(RGB_LED_B_PIN, OUTPUT); + SET_OUTPUT(RGB_LED_R_PIN); + SET_OUTPUT(RGB_LED_G_PIN); + SET_OUTPUT(RGB_LED_B_PIN); #endif lcd_init(); diff --git a/Marlin/SanityCheck.h b/Marlin/SanityCheck.h index fb943a5e7..8958743e7 100644 --- a/Marlin/SanityCheck.h +++ b/Marlin/SanityCheck.h @@ -388,10 +388,13 @@ static_assert(1 >= 0 #if ENABLED(AUTO_BED_LEVELING_BILINEAR) + 1 #endif + #if ENABLED(AUTO_BED_LEVELING_UBL) + + 1 + #endif #if ENABLED(MESH_BED_LEVELING) + 1 #endif - , "Select only one of: MESH_BED_LEVELING, AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_3POINT, or AUTO_BED_LEVELING_BILINEAR." + , "Select only one of: MESH_BED_LEVELING, AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_3POINT, AUTO_BED_LEVELING_BILINEAR or AUTO_BED_LEVELING_UBL." ); /** @@ -403,6 +406,21 @@ static_assert(1 >= 0 #elif MESH_NUM_X_POINTS > 9 || MESH_NUM_Y_POINTS > 9 #error "MESH_NUM_X_POINTS and MESH_NUM_Y_POINTS must be less than 10." #endif +#elif ENABLED(MANUAL_BED_LEVELING) + #error "MANUAL_BED_LEVELING only applies to MESH_BED_LEVELING." +#endif + +/** + * Unified Bed Leveling + */ +#if ENABLED(AUTO_BED_LEVELING_UBL) + #if ENABLED(DELTA) + #error "AUTO_BED_LEVELING_UBL does not yet support DELTA printers." + #elif DISABLED(NEWPANEL) + #error "AUTO_BED_LEVELING_UBL requires an LCD controller." + #elif UBL_MESH_NUM_X_POINTS > 15 || UBL_MESH_NUM_Y_POINTS > 15 + #error "UBL_MESH_NUM_X_POINTS and UBL_MESH_NUM_Y_POINTS must be less than 16." + #endif #endif /** @@ -434,6 +452,7 @@ static_assert(1 >= 0 , "Please enable only one probe: PROBE_MANUALLY, FIX_MOUNTED_PROBE, Z Servo, BLTOUCH, Z_PROBE_ALLEN_KEY, or Z_PROBE_SLED." ); + #if PROBE_SELECTED /** @@ -577,21 +596,26 @@ static_assert(1 >= 0 #endif #endif #else // !ABL_GRID - - // Check the triangulation points - #if ABL_PROBE_PT_1_X < MIN_PROBE_X || ABL_PROBE_PT_1_X > MAX_PROBE_X - #error "The given ABL_PROBE_PT_1_X can't be reached by the Z probe." - #elif ABL_PROBE_PT_2_X < MIN_PROBE_X || ABL_PROBE_PT_2_X > MAX_PROBE_X - #error "The given ABL_PROBE_PT_2_X can't be reached by the Z probe." - #elif ABL_PROBE_PT_3_X < MIN_PROBE_X || ABL_PROBE_PT_3_X > MAX_PROBE_X - #error "The given ABL_PROBE_PT_3_X can't be reached by the Z probe." - #elif ABL_PROBE_PT_1_Y < MIN_PROBE_Y || ABL_PROBE_PT_1_Y > MAX_PROBE_Y - #error "The given ABL_PROBE_PT_1_Y can't be reached by the Z probe." - #elif ABL_PROBE_PT_2_Y < MIN_PROBE_Y || ABL_PROBE_PT_2_Y > MAX_PROBE_Y - #error "The given ABL_PROBE_PT_2_Y can't be reached by the Z probe." - #elif ABL_PROBE_PT_3_Y < MIN_PROBE_Y || ABL_PROBE_PT_3_Y > MAX_PROBE_Y - #error "The given ABL_PROBE_PT_3_Y can't be reached by the Z probe." - #endif + #if ENABLED(AUTO_BED_LEVELING_UBL) + #ifndef EEPROM_SETTINGS + #error "AUTO_BED_LEVELING_UBL requires EEPROM_SETTINGS. Please update your configuration." + #endif + #else // !UBL + // Check the triangulation points + #if ABL_PROBE_PT_1_X < MIN_PROBE_X || ABL_PROBE_PT_1_X > MAX_PROBE_X + #error "The given ABL_PROBE_PT_1_X can't be reached by the Z probe." + #elif ABL_PROBE_PT_2_X < MIN_PROBE_X || ABL_PROBE_PT_2_X > MAX_PROBE_X + #error "The given ABL_PROBE_PT_2_X can't be reached by the Z probe." + #elif ABL_PROBE_PT_3_X < MIN_PROBE_X || ABL_PROBE_PT_3_X > MAX_PROBE_X + #error "The given ABL_PROBE_PT_3_X can't be reached by the Z probe." + #elif ABL_PROBE_PT_1_Y < MIN_PROBE_Y || ABL_PROBE_PT_1_Y > MAX_PROBE_Y + #error "The given ABL_PROBE_PT_1_Y can't be reached by the Z probe." + #elif ABL_PROBE_PT_2_Y < MIN_PROBE_Y || ABL_PROBE_PT_2_Y > MAX_PROBE_Y + #error "The given ABL_PROBE_PT_2_Y can't be reached by the Z probe." + #elif ABL_PROBE_PT_3_Y < MIN_PROBE_Y || ABL_PROBE_PT_3_Y > MAX_PROBE_Y + #error "The given ABL_PROBE_PT_3_Y can't be reached by the Z probe." + #endif + #endif // !AUTO_BED_LEVEING_UBL #endif // !ABL_GRID diff --git a/Marlin/UBL.h b/Marlin/UBL.h new file mode 100644 index 000000000..2c2627628 --- /dev/null +++ b/Marlin/UBL.h @@ -0,0 +1,331 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (C) 2016, 2017 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 . + * + */ + +#include "Marlin.h" +#include "math.h" + +#ifndef UNIFIED_BED_LEVELING_H +#define UNIFIED_BED_LEVELING_H + + #if ENABLED(AUTO_BED_LEVELING_UBL) + + #define UBL_OK false + #define UBL_ERR true + + typedef struct { + int x_index, y_index; + float distance; // Not always used. But when populated, it is the distance + // from the search location + } mesh_index_pair; + + struct vector { double dx, dy, dz; }; + + enum Mesh_Point_Type { INVALID, REAL, SET_IN_BITMAP }; + + bool axis_unhomed_error(bool, bool, bool); + void dump(char *str, float f); + bool G29_lcd_clicked(); + void probe_entire_mesh(float, float, bool, bool); + void UBL_line_to_destination(const float&, const float&, const float&, const float&, const float&, uint8_t); + void manually_probe_remaining_mesh(float, float, float, float, bool); + struct vector tilt_mesh_based_on_3pts(float, float, float); + void new_set_bed_level_equation_3pts(float, float, float); + float measure_business_card_thickness(float); + mesh_index_pair find_closest_mesh_point_of_type(Mesh_Point_Type, float, float, bool, unsigned int[16]); + void Find_Mean_Mesh_Height(); + void Shift_Mesh_Height(); + bool G29_Parameter_Parsing(); + void G29_What_Command(); + void G29_EEPROM_Dump(); + void G29_Kompare_Current_Mesh_to_Stored_Mesh(); + void fine_tune_mesh(float, float, float, bool); + void bit_clear(uint16_t bits[16], uint8_t x, uint8_t y); + void bit_set(uint16_t bits[16], uint8_t x, uint8_t y); + bool is_bit_set(uint16_t bits[16], uint8_t x, uint8_t y); + char *ftostr43sign(const float&, char); + + void gcode_G26(); + void gcode_G28(); + void gcode_G29(); + extern char conv[9]; + + void save_UBL_active_state_and_disable(); + void restore_UBL_active_state_and_leave(); + + /////////////////////////////////////////////////////////////////////////////////////////////////////// + + #if ENABLED(ULTRA_LCD) + extern char lcd_status_message[]; + void lcd_quick_feedback(); + #endif + + enum MBLStatus { MBL_STATUS_NONE = 0, MBL_STATUS_HAS_MESH_BIT = 0, MBL_STATUS_ACTIVE_BIT = 1 }; + + #define MESH_X_DIST ((float(UBL_MESH_MAX_X) - float(UBL_MESH_MIN_X)) / (float(UBL_MESH_NUM_X_POINTS) - 1.0)) + #define MESH_Y_DIST ((float(UBL_MESH_MAX_Y) - float(UBL_MESH_MIN_Y)) / (float(UBL_MESH_NUM_Y_POINTS) - 1.0)) + + extern bool G26_Debug_flag; + extern float last_specified_z; + extern float fade_scaling_factor_for_current_height; + extern float z_values[UBL_MESH_NUM_X_POINTS][UBL_MESH_NUM_Y_POINTS]; + extern float mesh_index_to_X_location[UBL_MESH_NUM_X_POINTS + 1]; // +1 just because of paranoia that we might end up on the + extern float mesh_index_to_Y_location[UBL_MESH_NUM_Y_POINTS + 1]; // the last Mesh Line and that is the start of a whole new cell + + class bed_leveling { + public: + struct ubl_state { + bool active = false; + float z_offset = 0.0; + int EEPROM_storage_slot = -1, + n_x = UBL_MESH_NUM_X_POINTS, + n_y = UBL_MESH_NUM_Y_POINTS; + float mesh_x_min = UBL_MESH_MIN_X, + mesh_y_min = UBL_MESH_MIN_Y, + mesh_x_max = UBL_MESH_MAX_X, + mesh_y_max = UBL_MESH_MAX_Y, + mesh_x_dist = MESH_X_DIST, + mesh_y_dist = MESH_Y_DIST, + G29_Correction_Fade_Height = 10.0, + G29_Fade_Height_Multiplier = 1.0 / 10.0; // It is cheaper to do a floating point multiply than a floating + // point divide. So, we keep this number in both forms. The first + // is for the user. The second one is the one that is actually used + // again and again and again during the correction calculations. + + unsigned char padding[24]; // This is just to allow room to add state variables without + // changing the location of data structures in the EEPROM. + // This is for compatability with future versions to keep + // people from having to regenerate thier mesh data. + // + // If you change the contents of this struct, please adjust + // the padding[] to keep the size the same! + } state, pre_initialized; + + bed_leveling(); + // ~bed_leveling(); // No destructor because this object never goes away! + + void display_map(int); + + void reset(); + void invalidate(); + + void store_state(); + void load_state(); + void store_mesh(int); + void load_mesh(int); + + bool sanity_check(); + + FORCE_INLINE float map_x_index_to_bed_location(int8_t i){ return ((float) UBL_MESH_MIN_X) + (((float) MESH_X_DIST) * (float) i); }; + FORCE_INLINE float map_y_index_to_bed_location(int8_t i){ return ((float) UBL_MESH_MIN_Y) + (((float) MESH_Y_DIST) * (float) i); }; + + void set_z(const int8_t px, const int8_t py, const float z) { z_values[px][py] = z; } + + int8_t get_cell_index_x(float x) { + int8_t cx = (x - (UBL_MESH_MIN_X)) * (1.0 / (MESH_X_DIST)); + return constrain(cx, 0, (UBL_MESH_NUM_X_POINTS) - 1); // -1 is appropriate if we want all movement to the X_MAX + } // position. But with this defined this way, it is possible + // to extrapolate off of this point even further out. Probably + // that is OK because something else should be keeping that from + // happening and should not be worried about at this level. + int8_t get_cell_index_y(float y) { + int8_t cy = (y - (UBL_MESH_MIN_Y)) * (1.0 / (MESH_Y_DIST)); + return constrain(cy, 0, (UBL_MESH_NUM_Y_POINTS) - 1); // -1 is appropriate if we want all movement to the Y_MAX + } // position. But with this defined this way, it is possible + // to extrapolate off of this point even further out. Probably + // that is OK because something else should be keeping that from + // happening and should not be worried about at this level. + + int8_t find_closest_x_index(float x) { + int8_t px = (x - (UBL_MESH_MIN_X) + (MESH_X_DIST) * 0.5) * (1.0 / (MESH_X_DIST)); + return (px >= 0 && px < (UBL_MESH_NUM_X_POINTS)) ? px : -1; + } + + int8_t find_closest_y_index(float y) { + int8_t py = (y - (UBL_MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * (1.0 / (MESH_Y_DIST)); + return (py >= 0 && py < (UBL_MESH_NUM_Y_POINTS)) ? py : -1; + } + + /** + * z2 --| + * z0 | | + * | | + (z2-z1) + * z1 | | | + * ---+-------------+--------+-- --| + * a1 a0 a2 + * |<---delta_a---------->| + * + * calc_z0 is the basis for all the Mesh Based correction. It is used to + * find the expected Z Height at a position between two known Z-Height locations + * + * It is farly expensive with its 4 floating point additions and 2 floating point + * multiplications. + */ + inline float calc_z0(float a0, float a1, float z1, float a2, float z2) { + float delta_z = (z2 - z1); + float delta_a = (a0 - a1) / (a2 - a1); + return z1 + delta_a * delta_z; + } + + /** + * get_z_correction_at_Y_intercept(float x0, int x1_i, int yi) only takes + * three parameters. It assumes the x0 point is on a Mesh line denoted by yi. In theory + * we could use get_cell_index_x(float x) to obtain the 2nd parameter x1_i but any code calling + * the get_z_correction_along_vertical_mesh_line_at_specific_X routine will already have + * the X index of the x0 intersection available and we don't want to perform any extra floating + * point operations. + */ + inline float get_z_correction_along_horizontal_mesh_line_at_specific_X(float x0, int x1_i, int yi) { + if (x1_i < 0 || yi < 0 || x1_i >= UBL_MESH_NUM_X_POINTS || yi >= UBL_MESH_NUM_Y_POINTS) { + SERIAL_ECHOPAIR("? in get_z_correction_along_horizontal_mesh_line_at_specific_X(x0=", x0); + SERIAL_ECHOPAIR(",x1_i=", x1_i); + SERIAL_ECHOPAIR(",yi=", yi); + SERIAL_CHAR(')'); + SERIAL_EOL; + return NAN; + } + + const float a0ma1diva2ma1 = (x0 - mesh_index_to_X_location[x1_i]) * (1.0 / (MESH_X_DIST)), + z1 = z_values[x1_i][yi], + z2 = z_values[x1_i + 1][yi], + dz = (z2 - z1); + + return z1 + a0ma1diva2ma1 * dz; + } + + // + // See comments above for get_z_correction_along_horizontal_mesh_line_at_specific_X + // + inline float get_z_correction_along_vertical_mesh_line_at_specific_Y(float y0, int xi, int y1_i) { + if (xi < 0 || y1_i < 0 || xi >= UBL_MESH_NUM_X_POINTS || y1_i >= UBL_MESH_NUM_Y_POINTS) { + SERIAL_ECHOPAIR("? in get_z_correction_along_vertical_mesh_line_at_specific_X(y0=", y0); + SERIAL_ECHOPAIR(", x1_i=", xi); + SERIAL_ECHOPAIR(", yi=", y1_i); + SERIAL_CHAR(')'); + SERIAL_EOL; + return NAN; + } + + const float a0ma1diva2ma1 = (y0 - mesh_index_to_Y_location[y1_i]) * (1.0 / (MESH_Y_DIST)), + z1 = z_values[xi][y1_i], + z2 = z_values[xi][y1_i + 1], + dz = (z2 - z1); + + return z1 + a0ma1diva2ma1 * dz; + } + + /** + * This is the generic Z-Correction. It works anywhere within a Mesh Cell. It first + * does a linear interpolation along both of the bounding X-Mesh-Lines to find the + * Z-Height at both ends. Then it does a linear interpolation of these heights based + * on the Y position within the cell. + */ + float get_z_correction(float x0, float y0) { + int8_t cx = get_cell_index_x(x0), + cy = get_cell_index_y(y0); + + if (cx < 0 || cy < 0 || cx >= UBL_MESH_NUM_X_POINTS || cy >= UBL_MESH_NUM_Y_POINTS) { + + SERIAL_ECHOPAIR("? in get_z_correction(x0=", x0); + SERIAL_ECHOPAIR(", y0=", y0); + SERIAL_CHAR(')'); + SERIAL_EOL; + + #if ENABLED(ULTRA_LCD) + strcpy(lcd_status_message, "get_z_correction() indexes out of range."); + lcd_quick_feedback(); + #endif + return 0.0; // this used to return state.z_offset + } + + float z1 = calc_z0(x0, + map_x_index_to_bed_location(cx), z_values[cx][cy], + map_x_index_to_bed_location(cx + 1), z_values[cx + 1][cy]); + float z2 = calc_z0(x0, + map_x_index_to_bed_location(cx), z_values[cx][cy + 1], + map_x_index_to_bed_location(cx + 1), z_values[cx + 1][cy + 1]); + float z0 = calc_z0(y0, + map_y_index_to_bed_location(cy), z1, + map_y_index_to_bed_location(cy + 1), z2); + + #if ENABLED(DEBUG_LEVELING_FEATURE) + if (DEBUGGING(MESH_ADJUST)) { + SERIAL_ECHOPAIR(" raw get_z_correction(", x0); + SERIAL_ECHOPAIR(",", y0); + SERIAL_ECHOPGM(")="); + SERIAL_PROTOCOL_F(z0, 6); + } + #endif + + #if ENABLED(DEBUG_LEVELING_FEATURE) + if (DEBUGGING(MESH_ADJUST)) { + SERIAL_ECHOPGM(" >>>---> "); + SERIAL_PROTOCOL_F(z0, 6); + SERIAL_EOL; + } + #endif + + if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN + z0 = 0.0; // in blm.z_values[][] and propagate through the + // calculations. If our correction is NAN, we throw it out + // because part of the Mesh is undefined and we don't have the + // information we need to complete the height correction. + + #if ENABLED(DEBUG_LEVELING_FEATURE) + if (DEBUGGING(MESH_ADJUST)) { + SERIAL_ECHOPGM("??? Yikes! NAN in get_z_correction( "); + SERIAL_ECHO(x0); + SERIAL_ECHOPGM(", "); + SERIAL_ECHO(y0); + SERIAL_ECHOLNPGM(" )"); + } + #endif + } + return z0; // there used to be a +state.z_offset on this line + } + + /** + * This routine is used to scale the Z correction depending upon the current nozzle height. It is + * optimized for speed. It avoids floating point operations by checking if the requested scaling + * factor is going to be the same as the last time the function calculated a value. If so, it just + * returns it. + * + * If it must do a calcuation, it will return a scaling factor of 0.0 if the UBL System is not active + * or if the current Z Height is past the specified 'Fade Height' + */ + FORCE_INLINE float fade_scaling_factor_for_Z(float current_z) { + if (last_specified_z == current_z) + return fade_scaling_factor_for_current_height; + + last_specified_z = current_z; + fade_scaling_factor_for_current_height = + state.active && current_z < state.G29_Correction_Fade_Height + ? 1.0 - (current_z * state.G29_Fade_Height_Multiplier) + : 0.0; + return fade_scaling_factor_for_current_height; + } + }; + + extern bed_leveling blm; + extern int Unified_Bed_Leveling_EEPROM_start; + +#endif // AUTO_BED_LEVELING_UBL +#endif // UNIFIED_BED_LEVELING_H \ No newline at end of file diff --git a/Marlin/UBL_Bed_Leveling.cpp b/Marlin/UBL_Bed_Leveling.cpp new file mode 100644 index 000000000..feff74e97 --- /dev/null +++ b/Marlin/UBL_Bed_Leveling.cpp @@ -0,0 +1,296 @@ +/** + * 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 . + * + */ + +#include "Marlin.h" +#include "math.h" + +#if ENABLED(AUTO_BED_LEVELING_UBL) + #include "UBL.h" + #include "hex_print_routines.h" + + /** + * These variables used to be declared inside the bed_leveling class. We are going to still declare + * them within the .cpp file for bed leveling. But there is only one instance of the bed leveling + * object and we can get rid of a level of inderection by not making them 'member data'. So, in the + * interest of speed, we do it this way. When we move to a 32-Bit processor, they can be moved + * back inside the bed leveling class. + */ + float last_specified_z, + fade_scaling_factor_for_current_height, + z_values[UBL_MESH_NUM_X_POINTS][UBL_MESH_NUM_Y_POINTS], + mesh_index_to_X_location[UBL_MESH_NUM_X_POINTS + 1], // +1 just because of paranoia that we might end up on the + mesh_index_to_Y_location[UBL_MESH_NUM_Y_POINTS + 1]; // the last Mesh Line and that is the start of a whole new cell + + bed_leveling::bed_leveling() { + for (uint8_t i = 0; i <= UBL_MESH_NUM_X_POINTS; i++) // We go one past what we expect to ever need for safety + mesh_index_to_X_location[i] = double(UBL_MESH_MIN_X) + double(MESH_X_DIST) * double(i); + + for (uint8_t i = 0; i <= UBL_MESH_NUM_Y_POINTS; i++) // We go one past what we expect to ever need for safety + mesh_index_to_Y_location[i] = double(UBL_MESH_MIN_Y) + double(MESH_Y_DIST) * double(i); + + reset(); + } + + void bed_leveling::store_state() { + int k = E2END - sizeof(blm.state); + eeprom_write_block((void *)&blm.state, (void *)k, sizeof(blm.state)); + } + + void bed_leveling::load_state() { + int k = E2END - sizeof(blm.state); + eeprom_read_block((void *)&blm.state, (void *)k, sizeof(blm.state)); + + if (sanity_check()) + SERIAL_PROTOCOLLNPGM("?In load_state() sanity_check() failed.\n"); + + // These lines can go away in a few weeks. They are just + // to make sure people updating thier firmware won't be using + if (blm.state.G29_Fade_Height_Multiplier != 1.0 / blm.state.G29_Correction_Fade_Height) { // an incomplete Bed_Leveling.state structure. For speed + blm.state.G29_Fade_Height_Multiplier = 1.0 / blm.state.G29_Correction_Fade_Height; // we now multiply by the inverse of the Fade Height instead of + store_state(); // dividing by it. Soon... all of the old structures will be + } // updated, but until then, we try to ease the transition + // for our Beta testers. + } + + void bed_leveling::load_mesh(int m) { + int k = E2END - sizeof(blm.state), + j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values); + + if (m == -1) { + SERIAL_PROTOCOLLNPGM("?No mesh saved in EEPROM. Zeroing mesh in memory.\n"); + reset(); + return; + } + + if (m < 0 || m >= j || Unified_Bed_Leveling_EEPROM_start <= 0) { + SERIAL_PROTOCOLLNPGM("?EEPROM storage not available to load mesh.\n"); + return; + } + + j = k - (m + 1) * sizeof(z_values); + eeprom_read_block((void *)&z_values , (void *)j, sizeof(z_values)); + + SERIAL_PROTOCOLPGM("Mesh loaded from slot "); + SERIAL_PROTOCOL(m); + SERIAL_PROTOCOLPGM(" at offset 0x"); + prt_hex_word(j); + SERIAL_EOL; + } + + void bed_leveling:: store_mesh(int m) { + int k = E2END - sizeof(state), + j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values); + + if (m < 0 || m >= j || Unified_Bed_Leveling_EEPROM_start <= 0) { + SERIAL_PROTOCOLLNPGM("?EEPROM storage not available to load mesh.\n"); + SERIAL_PROTOCOL(m); + SERIAL_PROTOCOLLNPGM(" mesh slots available.\n"); + SERIAL_PROTOCOLLNPAIR("E2END : ", E2END); + SERIAL_PROTOCOLLNPAIR("k : ", k); + SERIAL_PROTOCOLLNPAIR("j : ", j); + SERIAL_PROTOCOLLNPAIR("m : ", m); + SERIAL_EOL; + return; + } + + j = k - (m + 1) * sizeof(z_values); + eeprom_write_block((const void *)&z_values, (void *)j, sizeof(z_values)); + + SERIAL_PROTOCOLPGM("Mesh saved in slot "); + SERIAL_PROTOCOL(m); + SERIAL_PROTOCOLPGM(" at offset 0x"); + prt_hex_word(j); + SERIAL_EOL; + } + + void bed_leveling::reset() { + state.active = false; + state.z_offset = 0; + state.EEPROM_storage_slot = -1; + + ZERO(z_values); + + last_specified_z = -999.9; // We can't pre-initialize these values in the declaration + fade_scaling_factor_for_current_height = 0.0; // due to C++11 constraints + } + + void bed_leveling::invalidate() { + prt_hex_word((unsigned int)this); + SERIAL_EOL; + + state.active = false; + state.z_offset = 0; + for (int x = 0; x < UBL_MESH_NUM_X_POINTS; x++) + for (int y = 0; y < UBL_MESH_NUM_Y_POINTS; y++) + z_values[x][y] = NAN; + } + + void bed_leveling::display_map(int map_type) { + float f, current_xi, current_yi; + int8_t i, j; + UNUSED(map_type); + + SERIAL_PROTOCOLLNPGM("\nBed Topography Report:\n"); + + SERIAL_ECHOPAIR("(", 0); + SERIAL_ECHOPAIR(", ", UBL_MESH_NUM_Y_POINTS - 1); + SERIAL_ECHOPGM(") "); + + current_xi = blm.get_cell_index_x(current_position[X_AXIS] + (MESH_X_DIST) / 2.0); + current_yi = blm.get_cell_index_y(current_position[Y_AXIS] + (MESH_Y_DIST) / 2.0); + + for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++) + SERIAL_ECHOPGM(" "); + + SERIAL_ECHOPAIR("(", UBL_MESH_NUM_X_POINTS - 1); + SERIAL_ECHOPAIR(",", UBL_MESH_NUM_Y_POINTS - 1); + SERIAL_ECHOLNPGM(")"); + + // if (map_type || 1) { + SERIAL_ECHOPAIR("(", UBL_MESH_MIN_X); + SERIAL_ECHOPAIR(",", UBL_MESH_MAX_Y); + SERIAL_CHAR(')'); + + for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++) + SERIAL_ECHOPGM(" "); + + SERIAL_ECHOPAIR("(", UBL_MESH_MAX_X); + SERIAL_ECHOPAIR(",", UBL_MESH_MAX_Y); + SERIAL_ECHOLNPGM(")"); + // } + + for (j = UBL_MESH_NUM_Y_POINTS - 1; j >= 0; j--) { + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { + f = z_values[i][j]; + + // is the nozzle here? if so, mark the number + SERIAL_CHAR(i == current_xi && j == current_yi ? '[' : ' '); + + if (isnan(f)) + SERIAL_PROTOCOLPGM(" . "); + else { + // if we don't do this, the columns won't line up nicely + if (f >= 0.0) SERIAL_CHAR(' '); + SERIAL_PROTOCOL_F(f, 5); + idle(); + } + if (i == current_xi && j == current_yi) // is the nozzle here? if so, finish marking the number + SERIAL_CHAR(']'); + else + SERIAL_PROTOCOL(" "); + + SERIAL_CHAR(' '); + } + SERIAL_EOL; + if (j) { // we want the (0,0) up tight against the block of numbers + SERIAL_CHAR(' '); + SERIAL_EOL; + } + } + + // if (map_type) { + SERIAL_ECHOPAIR("(", int(UBL_MESH_MIN_X)); + SERIAL_ECHOPAIR(",", int(UBL_MESH_MIN_Y)); + SERIAL_ECHOPGM(") "); + + for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++) + SERIAL_ECHOPGM(" "); + + SERIAL_ECHOPAIR("(", int(UBL_MESH_MAX_X)); + SERIAL_ECHOPAIR(",", int(UBL_MESH_MIN_Y)); + SERIAL_CHAR(')'); + // } + + SERIAL_ECHOPAIR("(", 0); + SERIAL_ECHOPAIR(",", 0); + SERIAL_ECHOPGM(") "); + + for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++) + SERIAL_ECHOPGM(" "); + + SERIAL_ECHOPAIR("(", UBL_MESH_NUM_X_POINTS-1); + SERIAL_ECHOPAIR(",", 0); + SERIAL_CHAR(')'); + + SERIAL_CHAR(' '); + SERIAL_EOL; + } + + bool bed_leveling::sanity_check() { + uint8_t error_flag = 0; + + if (state.n_x != UBL_MESH_NUM_X_POINTS) { + SERIAL_PROTOCOLLNPGM("?UBL_MESH_NUM_X_POINTS set wrong\n"); + error_flag++; + } + + if (state.n_y != UBL_MESH_NUM_Y_POINTS) { + SERIAL_PROTOCOLLNPGM("?UBL_MESH_NUM_Y_POINTS set wrong\n"); + error_flag++; + } + + if (state.mesh_x_min != UBL_MESH_MIN_X) { + SERIAL_PROTOCOLLNPGM("?UBL_MESH_MIN_X set wrong\n"); + error_flag++; + } + + if (state.mesh_y_min != UBL_MESH_MIN_Y) { + SERIAL_PROTOCOLLNPGM("?UBL_MESH_MIN_Y set wrong\n"); + error_flag++; + } + + if (state.mesh_x_max != UBL_MESH_MAX_X) { + SERIAL_PROTOCOLLNPGM("?UBL_MESH_MAX_X set wrong\n"); + error_flag++; + } + + if (state.mesh_y_max != UBL_MESH_MAX_Y) { + SERIAL_PROTOCOLLNPGM("?UBL_MESH_MAX_Y set wrong\n"); + error_flag++; + } + + if (state.mesh_x_dist != MESH_X_DIST) { + SERIAL_PROTOCOLLNPGM("?MESH_X_DIST set wrong\n"); + error_flag++; + } + + if (state.mesh_y_dist != MESH_Y_DIST) { + SERIAL_PROTOCOLLNPGM("?MESH_Y_DIST set wrong\n"); + error_flag++; + } + + int k = E2END - sizeof(blm.state), + j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values); + + if (j < 1) { + SERIAL_PROTOCOLLNPGM("?No EEPROM storage available for a mesh of this size.\n"); + error_flag++; + } + + // SERIAL_PROTOCOLPGM("?sanity_check() return value: "); + // SERIAL_PROTOCOL(error_flag); + // SERIAL_EOL; + + return !!error_flag; + } + +#endif // AUTO_BED_LEVELING_UBL diff --git a/Marlin/UBL_G29.cpp b/Marlin/UBL_G29.cpp new file mode 100644 index 000000000..7f4bdf368 --- /dev/null +++ b/Marlin/UBL_G29.cpp @@ -0,0 +1,1455 @@ +/** + * 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 . + * + */ + +#include "Marlin.h" +#if ENABLED(AUTO_BED_LEVELING_UBL) + //#include "vector_3.h" + //#include "qr_solve.h" + + #include "UBL.h" + #include "hex_print_routines.h" + #include "configuration_store.h" + #include "planner.h" + #include "ultralcd.h" + + #include + + void lcd_babystep_z(); + void lcd_return_to_status(); + bool lcd_clicked(); + void lcd_implementation_clear(); + void lcd_mesh_edit_setup(float inital); + float lcd_mesh_edit(); + void lcd_z_offset_edit_setup(float); + float lcd_z_offset_edit(); + + extern float meshedit_done; + extern long babysteps_done; + extern float code_value_float(); + extern bool code_value_bool(); + extern bool code_has_value(); + extern float probe_pt(float x, float y, bool, int); + extern float zprobe_zoffset; + extern bool set_probe_deployed(bool); + #define DEPLOY_PROBE() set_probe_deployed(true) + #define STOW_PROBE() set_probe_deployed(false) + bool ProbeStay = true; + float ubl_3_point_1_X = UBL_PROBE_PT_1_X; + float ubl_3_point_1_Y = UBL_PROBE_PT_1_Y; + float ubl_3_point_2_X = UBL_PROBE_PT_2_X; + float ubl_3_point_2_Y = UBL_PROBE_PT_2_Y; + float ubl_3_point_3_X = UBL_PROBE_PT_3_X; + float ubl_3_point_3_Y = UBL_PROBE_PT_3_Y; + + #define SIZE_OF_LITTLE_RAISE 0 + #define BIG_RAISE_NOT_NEEDED 0 + extern void lcd_quick_feedback(); + + /** + * G29: Unified Bed Leveling by Roxy + */ + + // Transform required to compensate for bed level + //extern matrix_3x3 plan_bed_level_matrix; + + /** + * Get the position applying the bed level matrix + */ + + //vector_3 plan_get_position(); + + // static void set_bed_level_equation_lsq(double* plane_equation_coefficients); + // static void set_bed_level_equation_3pts(float z_at_pt_1, float z_at_pt_2, float z_at_pt_3); + + /** + * G29: Mesh Based Compensation System + * + * Parameters understood by this leveling system: + * + * A Activate Activate the Unified Bed Leveling system. + * + * B # Business Use the 'Business Card' mode of the Manual Probe subsystem. This is invoked as + * G29 P2 B The mode of G29 P2 allows you to use a bussiness card or recipe card + * as a shim that the nozzle will pinch as it is lowered. The idea is that you + * can easily feel the nozzle getting to the same height by the amount of resistance + * the business card exhibits to movement. You should try to achieve the same amount + * of resistance on each probed point to facilitate accurate and repeatable measurements. + * You should be very careful not to drive the nozzle into the bussiness card with a + * lot of force as it is very possible to cause damage to your printer if your are + * careless. If you use the B option with G29 P2 B you can leave the number parameter off + * on its first use to enable measurement of the business card thickness. Subsequent usage + * of the B parameter can have the number previously measured supplied to the command. + * Incidently, you are much better off using something like a Spark Gap feeler gauge than + * something that compresses like a Business Card. + * + * C Continue Continue, Constant, Current Location. This is not a primary command. C is used to + * further refine the behaviour of several other commands. Issuing a G29 P1 C will + * continue the generation of a partially constructed Mesh without invalidating what has + * been done. Issuing a G29 P2 C will tell the Manual Probe subsystem to use the current + * location in its search for the closest unmeasured Mesh Point. When used with a G29 Z C + * it indicates to use the current location instead of defaulting to the center of the print bed. + * + * D Disable Disable the Unified Bed Leveling system. + * + * E Stow_probe Stow the probe after each sampled point. + * + * F # Fade * Fade the amount of Mesh Based Compensation over a specified height. At the specified height, + * no correction is applied and natural printer kenimatics take over. If no number is specified + * for the command, 10mm is assummed to be reasonable. + * + * G # Grid * Perform a Grid Based Leveling of the current Mesh using a grid with n points on + * a side. + * + * H # Height Specify the Height to raise the nozzle after each manual probe of the bed. The + * default is 5mm. + * + * I # Invalidate Invalidate specified number of Mesh Points. The nozzle location is used unless + * the X and Y parameter are used. If no number is specified, only the closest Mesh + * point to the location is invalidated. The M parameter is available as well to produce + * a map after the operation. This command is useful to invalidate a portion of the + * Mesh so it can be adjusted using other tools in the Unified Bed Leveling System. When + * attempting to invalidate an isolated bad point in the mesh, the M option will indicate + * where the nozzle is positioned in the Mesh with (#). You can move the nozzle around on + * the bed and use this feature to select the center of the area (or cell) you want to + * invalidate. + * + * K # Kompare Kompare current Mesh with stored Mesh # replacing current Mesh with the result. This + * command litterly performs a difference between two Mesh. + * + * L Load * Load Mesh from the previously activated location in the EEPROM. + * + * L # Load * Load Mesh from the specified location in the EEPROM. Set this location as activated + * for subsequent Load and Store operations. + * + * O Map * Display the Mesh Map Topology. + * The parameter can be specified alone (ie. G29 O) or in combination with many of the + * other commands. The Mesh Map option works with all of the Phase + * commands (ie. G29 P4 R 5 X 50 Y100 C -.1 O) + * + * N No Home G29 normally insists that a G28 has been performed. You can over rule this with an + * N option. In general, you should not do this. This can only be done safely with + * commands that do not move the nozzle. + * + * The P or Phase commands are used for the bulk of the work to setup a Mesh. In general, your Mesh will + * start off being initialized with a G29 P0 or a G29 P1. Further refinement of the Mesh happens with + * each additional Phase that processes it. + * + * P0 Phase 0 Zero Mesh Data and turn off the Mesh Compensation System. This reverts the + * 3D Printer to the same state it was in before the Unified Bed Leveling Compensation + * was turned on. Setting the entire Mesh to Zero is a special case that allows + * a subsequent G or T leveling operation for backward compatability. + * + * P1 Phase 1 Invalidate entire Mesh and continue with automatic generation of the Mesh data using + * the Z-Probe. Depending upon the values of DELTA_PROBEABLE_RADIUS and + * DELTA_PRINTABLE_RADIUS some area of the bed will not have Mesh Data automatically + * generated. This will be handled in Phase 2. If the Phase 1 command is given the + * C (Continue) parameter it does not invalidate the Mesh prior to automatically + * probing needed locations. This allows you to invalidate portions of the Mesh but still + * use the automatic probing capabilities of the Unified Bed Leveling System. An X and Y + * parameter can be given to prioritize where the command should be trying to measure points. + * If the X and Y parameters are not specified the current probe position is used. Phase 1 + * allows you to specify the M (Map) parameter so you can watch the generation of the Mesh. + * Phase 1 also watches for the LCD Panel's Encoder Switch being held in a depressed state. + * It will suspend generation of the Mesh if it sees the user request that. (This check is + * only done between probe points. You will need to press and hold the switch until the + * Phase 1 command can detect it.) + * + * P2 Phase 2 Probe areas of the Mesh that can not be automatically handled. Phase 2 respects an H + * parameter to control the height between Mesh points. The default height for movement + * between Mesh points is 5mm. A smaller number can be used to make this part of the + * calibration less time consuming. You will be running the nozzle down until it just barely + * touches the glass. You should have the nozzle clean with no plastic obstructing your view. + * Use caution and move slowly. It is possible to damage your printer if you are careless. + * Note that this command will use the configuration #define SIZE_OF_LITTLE_RAISE if the + * nozzle is moving a distance of less than BIG_RAISE_NOT_NEEDED. + * + * The H parameter can be set negative if your Mesh dips in a large area. You can press + * and hold the LCD Panel's encoder wheel to terminate the current Phase 2 command. You + * can then re-issue the G29 P 2 command with an H parameter that is more suitable for the + * area you are manually probing. Note that the command tries to start you in a corner + * of the bed where movement will be predictable. You can force the location to be used in + * the distance calculations by using the X and Y parameters. You may find it is helpful to + * print out a Mesh Map (G29 O ) to understand where the mesh is invalidated and where + * the nozzle will need to move in order to complete the command. The C parameter is + * available on the Phase 2 command also and indicates the search for points to measure should + * be done based on the current location of the nozzle. + * + * A B parameter is also available for this command and described up above. It places the + * manual probe subsystem into Business Card mode where the thickness of a business care is + * measured and then used to accurately set the nozzle height in all manual probing for the + * duration of the command. (S for Shim mode would be a better parameter name, but S is needed + * for Save or Store of the Mesh to EEPROM) A Business card can be used, but you will have + * better results if you use a flexible Shim that does not compress very much. That makes it + * easier for you to get the nozzle to press with similar amounts of force against the shim so you + * can get accurate measurements. As you are starting to touch the nozzle against the shim try + * to get it to grasp the shim with the same force as when you measured the thickness of the + * shim at the start of the command. + * + * Phase 2 allows the O (Map) parameter to be specified. This helps the user see the progression + * of the Mesh being built. + * + * P3 Phase 3 Fill the unpopulated regions of the Mesh with a fixed value. The C parameter is used to + * specify the Constant value to fill all invalid areas of the Mesh. If no C parameter is + * specified, a value of 0.0 is assumed. The R parameter can be given to specify the number + * of points to set. If the R parameter is specified the current nozzle position is used to + * find the closest points to alter unless the X and Y parameter are used to specify the fill + * location. + * + * P4 Phase 4 Fine tune the Mesh. The Delta Mesh Compensation System assume the existance of + * an LCD Panel. It is possible to fine tune the mesh without the use of an LCD Panel. + * (More work and details on doing this later!) + * The System will search for the closest Mesh Point to the nozzle. It will move the + * nozzle to this location. The user can use the LCD Panel to carefully adjust the nozzle + * so it is just barely touching the bed. When the user clicks the control, the System + * will lock in that height for that point in the Mesh Compensation System. + * + * Phase 4 has several additional parameters that the user may find helpful. Phase 4 + * can be started at a specific location by specifying an X and Y parameter. Phase 4 + * can be requested to continue the adjustment of Mesh Points by using the R(epeat) + * parameter. If the Repetition count is not specified, it is assumed the user wishes + * to adjust the entire matrix. The nozzle is moved to the Mesh Point being edited. + * The command can be terminated early (or after the area of interest has been edited) by + * pressing and holding the encoder wheel until the system recognizes the exit request. + * Phase 4's general form is G29 P4 [R # of points] [X position] [Y position] + * + * Phase 4 is intended to be used with the G26 Mesh Validation Command. Using the + * information left on the printer's bed from the G26 command it is very straight forward + * and easy to fine tune the Mesh. One concept that is important to remember and that + * will make using the Phase 4 command easy to use is this: You are editing the Mesh Points. + * If you have too little clearance and not much plastic was extruded in an area, you want to + * LOWER the Mesh Point at the location. If you did not get good adheasion, you want to + * RAISE the Mesh Point at that location. + * + * + * P5 Phase 5 Find Mean Mesh Height and Standard Deviation. Typically, it is easier to use and + * work with the Mesh if it is Mean Adjusted. You can specify a C parameter to + * Correct the Mesh to a 0.00 Mean Height. Adding a C parameter will automatically + * execute a G29 P6 C . + * + * P6 Phase 6 Shift Mesh height. The entire Mesh's height is adjusted by the height specified + * with the C parameter. Being able to adjust the height of a Mesh is useful tool. It + * can be used to compensate for poorly calibrated Z-Probes and other errors. Ideally, + * you should have the Mesh adjusted for a Mean Height of 0.00 and the Z-Probe measuring + * 0.000 at the Z Home location. + * + * Q Test * Load specified Test Pattern to assist in checking correct operation of system. This + * command is not anticipated to be of much value to the typical user. It is intended + * for developers to help them verify correct operation of the Unified Bed Leveling System. + * + * S Store Store the current Mesh in the Activated area of the EEPROM. It will also store the + * current state of the Unified Bed Leveling system in the EEPROM. + * + * S # Store Store the current Mesh at the specified location in EEPROM. Activate this location + * for subsequent Load and Store operations. It will also store the current state of + * the Unified Bed Leveling system in the EEPROM. + * + * S -1 Store Store the current Mesh as a print out that is suitable to be feed back into + * the system at a later date. The text generated can be saved and later sent by PronterFace or + * Repetier Host to reconstruct the current mesh on another machine. + * + * T 3-Point Perform a 3 Point Bed Leveling on the current Mesh + * + * W What? Display valuable data the Unified Bed Leveling System knows. + * + * X # * * Specify X Location for this line of commands + * + * Y # * * Specify Y Location for this line of commands + * + * Z Zero * Probes to set the Z Height of the nozzle. The entire Mesh can be raised or lowered + * by just doing a G29 Z + * + * Z # Zero * The entire Mesh can be raised or lowered to conform with the specified difference. + * zprobe_zoffset is added to the calculation. + * + * + * Release Notes: + * You MUST do a M502 & M500 pair of commands to initialize the storage. Failure to do this + * will cause all kinds of problems. Enabling EEPROM Storage is highly recommended. With + * EEPROM Storage of the mesh, you are limited to 3-Point and Grid Leveling. (G29 P0 T and + * G29 P0 G respectively.) + * + * Z-Probe Sleds are not currently fully supported. There were too many complications caused + * by them to support them in the Unified Bed Leveling code. Support for them will be handled + * better in the upcoming Z-Probe Object that will happen during the Code Clean Up phase. (That + * is what they really are: A special case of the Z-Probe.) When a Z-Probe Object appears, it + * should slip in under the Unified Bed Leveling code without major trauma. + * + * When you do a G28 and then a G29 P1 to automatically build your first mesh, you are going to notice + * the Unified Bed Leveling probes points further and further away from the starting location. (The + * starting location defaults to the center of the bed.) The original Grid and Mesh leveling used + * a Zig Zag pattern. The new pattern is better, especially for people with Delta printers. This + * allows you to get the center area of the Mesh populated (and edited) quicker. This allows you to + * perform a small print and check out your settings quicker. You do not need to populate the + * entire mesh to use it. (You don't want to spend a lot of time generating a mesh only to realize + * you don't have the resolution or zprobe_zoffset set correctly. The Mesh generation + * gathers points closest to where the nozzle is located unless you specify an (X,Y) coordinate pair. + * + * The Unified Bed Leveling uses a lot of EEPROM storage to hold its data. And it takes some effort + * to get this Mesh data correct for a user's printer. We do not want this data destroyed as + * new versions of Marlin add or subtract to the items stored in EEPROM. So, for the benefit of + * the users, we store the Mesh data at the end of the EEPROM and do not keep it contiguous with the + * other data stored in the EEPROM. (For sure the developers are going to complain about this, but + * this is going to be helpful to the users!) + * + * The foundation of this Bed Leveling System is built on Epatel's Mesh Bed Leveling code. A big + * 'Thanks!' to him and the creators of 3-Point and Grid Based leveling. Combining thier contributions + * we now have the functionality and features of all three systems combined. + */ + + int Unified_Bed_Leveling_EEPROM_start = -1; + int UBL_has_control_of_LCD_Panel = 0; + volatile int G29_encoderDiff = 0; // This is volatile because it is getting changed at interrupt time. + + // We keep the simple parameter flags and values as 'static' because we break out the + // parameter parsing into a support routine. + + static int G29_Verbose_Level = 0, Test_Value = 0, + Phase_Value = -1, Repetition_Cnt = 1; + static bool Repeat_Flag = UBL_OK, C_Flag = false, X_Flag = UBL_OK, Y_Flag = UBL_OK, Statistics_Flag = UBL_OK, Business_Card_Mode = false; + static float X_Pos = 0.0, Y_Pos = 0.0, Height_Value = 5.0, measured_z, card_thickness = 0.0, Constant = 0.0; + static int Storage_Slot = 0, Test_Pattern = 0; + + #if ENABLED(ULTRA_LCD) + void lcd_setstatus(const char* message, bool persist); + #endif + + void gcode_G29() { + mesh_index_pair location; + int i, j, k; + float Z1, Z2, Z3; + + G29_Verbose_Level = 0; // These may change, but let's get some reasonable values into them. + Repeat_Flag = UBL_OK; + Repetition_Cnt = 1; + C_Flag = false; + + SERIAL_PROTOCOLPGM("Unified_Bed_Leveling_EEPROM_start="); + SERIAL_PROTOCOLLN(Unified_Bed_Leveling_EEPROM_start); + + if (Unified_Bed_Leveling_EEPROM_start < 0) { + SERIAL_PROTOCOLLNPGM("?You need to enable your EEPROM and initialize it "); + SERIAL_PROTOCOLLNPGM("with M502, M500, M501 in that order.\n"); + return; + } + + if (!code_seen('N') && axis_unhomed_error(true, true, true)) // Don't allow auto-leveling without homing first + gcode_G28(); + + if (G29_Parameter_Parsing()) return; // abort if parsing the simple parameters causes a problem, + + // Invalidate Mesh Points. This command is a little bit asymetrical because + // it directly specifies the repetition count and does not use the 'R' parameter. + if (code_seen('I')) { + Repetition_Cnt = code_has_value() ? code_value_int() : 1; + while (Repetition_Cnt--) { + location = find_closest_mesh_point_of_type(REAL, X_Pos, Y_Pos, 0, NULL); // The '0' says we want to use the nozzle's position + if (location.x_index < 0) { + SERIAL_PROTOCOLLNPGM("Entire Mesh invalidated.\n"); + break; // No more invalid Mesh Points to populate + } + z_values[location.x_index][location.y_index] = NAN; + } + SERIAL_PROTOCOLLNPGM("Locations invalidated.\n"); + } + + if (code_seen('Q')) { + + if (code_has_value()) Test_Pattern = code_value_int(); + + if (Test_Pattern < 0 || Test_Pattern > 4) { + SERIAL_PROTOCOLLNPGM("Invalid Test_Pattern value. (0-4)\n"); + return; + } + SERIAL_PROTOCOLLNPGM("Loading Test_Pattern values.\n"); + switch (Test_Pattern) { + case 0: + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { // Create a bowl shape. This is + for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { // similar to what a user would see with + Z1 = 0.5 * (UBL_MESH_NUM_X_POINTS) - i; // a poorly calibrated Delta. + Z2 = 0.5 * (UBL_MESH_NUM_Y_POINTS) - j; + z_values[i][j] += 2.0 * HYPOT(Z1, Z2); + } + } + break; + case 1: + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { // Create a diagonal line several Mesh + z_values[i][i] += 9.999; // cells thick that is raised + if (i < UBL_MESH_NUM_Y_POINTS - 1) + z_values[i][i + 1] += 9.999; // We want the altered line several mesh points thick + if (i > 0) + z_values[i][i - 1] += 9.999; // We want the altered line several mesh points thick + } + break; + case 2: + // Allow the user to specify the height because 10mm is + // a little bit extreme in some cases. + for (i = (UBL_MESH_NUM_X_POINTS) / 3.0; i < 2 * ((UBL_MESH_NUM_X_POINTS) / 3.0); i++) // Create a rectangular raised area in + for (j = (UBL_MESH_NUM_Y_POINTS) / 3.0; j < 2 * ((UBL_MESH_NUM_Y_POINTS) / 3.0); j++) // the center of the bed + z_values[i][j] += code_seen('C') ? Constant : 9.99; + break; + case 3: + break; + } + } + + if (code_seen('P')) { + Phase_Value = code_value_int(); + if (Phase_Value < 0 || Phase_Value > 7) { + SERIAL_PROTOCOLLNPGM("Invalid Phase value. (0-4)\n"); + return; + } + switch (Phase_Value) { + // + // Zero Mesh Data + // + case 0: + blm.reset(); + SERIAL_PROTOCOLLNPGM("Mesh zeroed.\n"); + break; + // + // Invalidate Entire Mesh and Automatically Probe Mesh in areas that can be reached by the probe + // + case 1: + if (!code_seen('C') ) { + blm.invalidate(); + SERIAL_PROTOCOLLNPGM("Mesh invalidated. Probing mesh.\n"); + } + if (G29_Verbose_Level > 1) { + SERIAL_ECHOPGM("Probing Mesh Points Closest to ("); + SERIAL_ECHO(X_Pos); + SERIAL_ECHOPAIR(",", Y_Pos); + SERIAL_PROTOCOLLNPGM(")\n"); + } + probe_entire_mesh( X_Pos+X_PROBE_OFFSET_FROM_EXTRUDER, Y_Pos+Y_PROBE_OFFSET_FROM_EXTRUDER, + code_seen('O') || code_seen('M'), code_seen('E')); + break; + // + // Manually Probe Mesh in areas that can not be reached by the probe + // + case 2: + SERIAL_PROTOCOLLNPGM("Manually probing unreachable mesh locations.\n"); + do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES); + if (!X_Flag && !Y_Flag) { // use a good default location for the path + X_Pos = X_MIN_POS; + Y_Pos = Y_MIN_POS; + if (X_PROBE_OFFSET_FROM_EXTRUDER > 0) // The flipped > and < operators on these two comparisons is + X_Pos = X_MAX_POS; // intentional. It should cause the probed points to follow a + + if (Y_PROBE_OFFSET_FROM_EXTRUDER < 0) // nice path on Cartesian printers. It may make sense to + Y_Pos = Y_MAX_POS; // have Delta printers default to the center of the bed. + + } // For now, until that is decided, it can be forced with the X + // and Y parameters. + if (code_seen('C')) { + X_Pos = current_position[X_AXIS]; + Y_Pos = current_position[Y_AXIS]; + } + + Height_Value = code_seen('H') && code_has_value() ? code_value_float() : Z_CLEARANCE_BETWEEN_PROBES; + + if ((Business_Card_Mode = code_seen('B'))) { + card_thickness = code_has_value() ? code_value_float() : measure_business_card_thickness(Height_Value); + + if (fabs(card_thickness) > 1.5) { + SERIAL_PROTOCOLLNPGM("?Error in Business Card measurment.\n"); + return; + } + } + manually_probe_remaining_mesh( X_Pos, Y_Pos, Height_Value, card_thickness, code_seen('O') || code_seen('M')); + break; + // + // Populate invalid Mesh areas with a constant + // + case 3: + Height_Value = 0.0; // Assume 0.0 until proven otherwise + if (code_seen('C')) Height_Value = Constant; + // If no repetition is specified, do the whole Mesh + if (!Repeat_Flag) Repetition_Cnt = 9999; + while (Repetition_Cnt--) { + location = find_closest_mesh_point_of_type( INVALID, X_Pos, Y_Pos, 0, NULL); // The '0' says we want to use the nozzle's position + if (location.x_index < 0) break; // No more invalid Mesh Points to populate + z_values[location.x_index][location.y_index] = Height_Value; + } + break; + // + // Fine Tune (Or Edit) the Mesh + // + case 4: + fine_tune_mesh(X_Pos, Y_Pos, Height_Value, code_seen('O') || code_seen('M')); + break; + case 5: + Find_Mean_Mesh_Height(); + break; + case 6: + Shift_Mesh_Height(); + break; + + case 10: + UBL_has_control_of_LCD_Panel++; // Debug code... Pan no attention to this stuff + SERIAL_ECHO_START; + SERIAL_ECHOPGM("Checking G29 has control of LCD Panel:\n"); + while(!G29_lcd_clicked()) { + idle(); + delay(250); + SERIAL_PROTOCOL(G29_encoderDiff); + G29_encoderDiff = 0; + SERIAL_EOL; + } + while (G29_lcd_clicked()) idle(); + UBL_has_control_of_LCD_Panel = 0;; + SERIAL_ECHOPGM("G29 giving back control of LCD Panel.\n"); + break; + } + } + + if (code_seen('T')) { + Z1 = probe_pt(ubl_3_point_1_X, ubl_3_point_1_Y, false /*Stow Flag*/, G29_Verbose_Level) + zprobe_zoffset; + Z2 = probe_pt(ubl_3_point_2_X, ubl_3_point_2_Y, false /*Stow Flag*/, G29_Verbose_Level) + zprobe_zoffset; + Z3 = probe_pt(ubl_3_point_3_X, ubl_3_point_3_Y, true /*Stow Flag*/, G29_Verbose_Level) + zprobe_zoffset; + + // We need to adjust Z1, Z2, Z3 by the Mesh Height at these points. Just because they are non-zero doesn't mean + // the Mesh is tilted! (We need to compensate each probe point by what the Mesh says that location's height is) + + Z1 -= blm.get_z_correction(ubl_3_point_1_X, ubl_3_point_1_Y); + Z2 -= blm.get_z_correction(ubl_3_point_2_X, ubl_3_point_2_Y); + Z3 -= blm.get_z_correction(ubl_3_point_3_X, ubl_3_point_3_Y); + + do_blocking_move_to_xy((X_MAX_POS - (X_MIN_POS)) / 2.0, (Y_MAX_POS - (Y_MIN_POS)) / 2.0); + tilt_mesh_based_on_3pts(Z1, Z2, Z3); + } + + // + // Much of the 'What?' command can be eliminated. But until we are fully debugged, it is + // good to have the extra information. Soon... we prune this to just a few items + // + if (code_seen('W')) G29_What_Command(); + + // + // When we are fully debugged, the EEPROM dump command will get deleted also. But + // right now, it is good to have the extra information. Soon... we prune this. + // + if (code_seen('J')) G29_EEPROM_Dump(); // EEPROM Dump + + // + // When we are fully debugged, this may go away. But there are some valid + // use cases for the users. So we can wait and see what to do with it. + // + + if (code_seen('K')) // Kompare Current Mesh Data to Specified Stored Mesh + G29_Kompare_Current_Mesh_to_Stored_Mesh(); + + // + // Load a Mesh from the EEPROM + // + + if (code_seen('L')) { // Load Current Mesh Data + Storage_Slot = code_has_value() ? code_value_int() : blm.state.EEPROM_storage_slot; + + k = E2END - sizeof(blm.state); + j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values); + + if (Storage_Slot < 0 || Storage_Slot >= j || Unified_Bed_Leveling_EEPROM_start <= 0) { + SERIAL_PROTOCOLLNPGM("?EEPROM storage not available for use.\n"); + return; + } + blm.load_mesh(Storage_Slot); + blm.state.EEPROM_storage_slot = Storage_Slot; + if (Storage_Slot != blm.state.EEPROM_storage_slot) + blm.store_state(); + SERIAL_PROTOCOLLNPGM("Done.\n"); + } + + // + // Store a Mesh in the EEPROM + // + + if (code_seen('S')) { // Store (or Save) Current Mesh Data + Storage_Slot = code_has_value() ? code_value_int() : blm.state.EEPROM_storage_slot; + + if (Storage_Slot == -1) { // Special case, we are going to 'Export' the mesh to the + SERIAL_ECHOPGM("G29 I 999\n"); // host in a form it can be reconstructed on a different machine + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { + for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { + if (!isnan(z_values[i][j])) { + SERIAL_ECHOPAIR("M421 I ", i); + SERIAL_ECHOPAIR(" J ", j); + SERIAL_ECHOPGM(" Z "); + SERIAL_PROTOCOL_F(z_values[i][j], 6); + SERIAL_EOL; + } + } + } + return; + } + + int k = E2END - sizeof(blm.state), + j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values); + + if (Storage_Slot < 0 || Storage_Slot >= j || Unified_Bed_Leveling_EEPROM_start <= 0) { + SERIAL_PROTOCOLLNPGM("?EEPROM storage not available for use.\n"); + SERIAL_PROTOCOLLNPAIR("?Use 0 to ", j - 1); + goto LEAVE; + } + blm.store_mesh(Storage_Slot); + blm.state.EEPROM_storage_slot = Storage_Slot; + // + // if (Storage_Slot != blm.state.EEPROM_storage_slot) + blm.store_state(); // Always save an updated copy of the UBL State info + + SERIAL_PROTOCOLLNPGM("Done.\n"); + } + + if (code_seen('O') || code_seen('M')) { + i = code_has_value() ? code_value_int() : 0; + blm.display_map(i); + } + + if (code_seen('Z')) { + if (code_has_value()) { + blm.state.z_offset = code_value_float(); // do the simple case. Just lock in the specified value + } + else { + save_UBL_active_state_and_disable(); + //measured_z = probe_pt(X_Pos + X_PROBE_OFFSET_FROM_EXTRUDER, Y_Pos+Y_PROBE_OFFSET_FROM_EXTRUDER, ProbeDeployAndStow, G29_Verbose_Level); + + measured_z = 1.5; + do_blocking_move_to_z(measured_z); // Get close to the bed, but leave some space so we don't damage anything + // The user is not going to be locking in a new Z-Offset very often so + // it won't be that painful to spin the Encoder Wheel for 1.5mm + lcd_implementation_clear(); + lcd_z_offset_edit_setup(measured_z); + do { + measured_z = lcd_z_offset_edit(); + idle(); + do_blocking_move_to_z(measured_z); + } while (!G29_lcd_clicked()); + + UBL_has_control_of_LCD_Panel = 1; // There is a race condition for the Encoder Wheel getting clicked. + // It could get detected in lcd_mesh_edit (actually _lcd_mesh_fine_tune( ) + // or here. So, until we are done looking for a long Encoder Wheel Press, + // we need to take control of the panel + millis_t nxt = millis() + 1500UL; + lcd_return_to_status(); + while (G29_lcd_clicked()) { // debounce and watch for abort + idle(); + if (ELAPSED(millis(), nxt)) { + SERIAL_PROTOCOLLNPGM("\nZ-Offset Adjustment Stopped."); + do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); + lcd_setstatus("Z-Offset Stopped", true); + + while (G29_lcd_clicked()) idle(); + + UBL_has_control_of_LCD_Panel = 0; + restore_UBL_active_state_and_leave(); + goto LEAVE; + } + } + UBL_has_control_of_LCD_Panel = 0; + delay(20); // We don't want any switch noise. + + blm.state.z_offset = measured_z; + + lcd_implementation_clear(); + restore_UBL_active_state_and_leave(); + } + } + + LEAVE: + #if ENABLED(ULTRA_LCD) + lcd_setstatus(" ", true); + lcd_quick_feedback(); + #endif + UBL_has_control_of_LCD_Panel = 0; + } + + void Find_Mean_Mesh_Height() { + int i, j, n; + float sum, sum_of_diff_squared, sigma, difference, mean; + + sum = sum_of_diff_squared = 0.0; + n = 0; + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { + for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { + if (!isnan(z_values[i][j])) { + sum += z_values[i][j]; + n++; + } + } + } + mean = sum / n; + // + // Now do the sumation of the squares of difference from mean + // + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { + for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { + if (!isnan(z_values[i][j])) { + difference = (z_values[i][j] - mean); + sum_of_diff_squared += difference * difference; + } + } + } + SERIAL_ECHOLNPAIR("# of samples: ", n); + SERIAL_ECHOPGM("Mean Mesh Height: "); + SERIAL_PROTOCOL_F(mean, 6); + SERIAL_EOL; + + sigma = sqrt( sum_of_diff_squared / (n + 1)); + SERIAL_ECHOPGM("Standard Deviation: "); + SERIAL_PROTOCOL_F(sigma, 6); + SERIAL_EOL; + + if (C_Flag) + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) + for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) + if (!isnan(z_values[i][j])) + z_values[i][j] -= mean + Constant; + } + + void Shift_Mesh_Height( ) { + for (uint8_t i = 0; i < UBL_MESH_NUM_X_POINTS; i++) + for (uint8_t j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) + if (!isnan(z_values[i][j])) + z_values[i][j] += Constant; + } + + // probe_entire_mesh(X_Pos, Y_Pos) probes all invalidated locations of the mesh that can be reached + // by the probe. It attempts to fill in locations closest to the nozzle's start location first. + + void probe_entire_mesh(float X_Pos, float Y_Pos, bool do_UBL_MESH_Map, bool stow_probe) { + mesh_index_pair location; + float xProbe, yProbe, measured_z; + + UBL_has_control_of_LCD_Panel++; + save_UBL_active_state_and_disable(); // we don't do bed level correction because we want the raw data when we probe + DEPLOY_PROBE(); + + do { + if (G29_lcd_clicked()) { + SERIAL_PROTOCOLLNPGM("\nMesh only partially populated."); + lcd_quick_feedback(); + while (G29_lcd_clicked()) idle(); + UBL_has_control_of_LCD_Panel = 0; + STOW_PROBE(); + restore_UBL_active_state_and_leave(); + return; + } + location = find_closest_mesh_point_of_type( INVALID, X_Pos, Y_Pos, 1, NULL); // the '1' says we want the location to be relative to the probe + if (location.x_index>=0 && location.y_index>=0) { + xProbe = blm.map_x_index_to_bed_location(location.x_index); + yProbe = blm.map_y_index_to_bed_location(location.y_index); + if (xProbe < MIN_PROBE_X || xProbe > MAX_PROBE_X || yProbe < MIN_PROBE_Y || yProbe > MAX_PROBE_Y) { + SERIAL_PROTOCOLLNPGM("?Error: Attempt to probe off the bed."); + UBL_has_control_of_LCD_Panel = 0; + goto LEAVE; + } + measured_z = probe_pt(xProbe, yProbe, stow_probe, G29_Verbose_Level); + z_values[location.x_index][location.y_index] = measured_z + Z_PROBE_OFFSET_FROM_EXTRUDER; + } + + if (do_UBL_MESH_Map) blm.display_map(1); + } while (location.x_index >= 0 && location.y_index >= 0); + + LEAVE: + STOW_PROBE(); + restore_UBL_active_state_and_leave(); + + X_Pos = constrain( X_Pos-X_PROBE_OFFSET_FROM_EXTRUDER, X_MIN_POS, X_MAX_POS); + Y_Pos = constrain( Y_Pos-Y_PROBE_OFFSET_FROM_EXTRUDER, Y_MIN_POS, Y_MAX_POS); + + do_blocking_move_to_xy(X_Pos, Y_Pos); + } + + struct vector tilt_mesh_based_on_3pts(float pt1, float pt2, float pt3) { + struct vector v1, v2, normal; + float c, d, t; + int i, j; + + v1.dx = (ubl_3_point_1_X - ubl_3_point_2_X); + v1.dy = (ubl_3_point_1_Y - ubl_3_point_2_Y); + v1.dz = (pt1 - pt2); + + v2.dx = (ubl_3_point_3_X - ubl_3_point_2_X); + v2.dy = (ubl_3_point_3_Y - ubl_3_point_2_Y); + v2.dz = (pt3 - pt2); + + // do cross product + + normal.dx = v1.dy * v2.dz - v1.dz * v2.dy; + normal.dy = v1.dz * v2.dx - v1.dx * v2.dz; + normal.dz = v1.dx * v2.dy - v1.dy * v2.dx; + + // printf("[%f,%f,%f] ", normal.dx, normal.dy, normal.dz); + + normal.dx /= normal.dz; // This code does two things. This vector is normal to the tilted plane. + normal.dy /= normal.dz; // However, we don't know its direction. We need it to point up. So if + normal.dz /= normal.dz; // Z is negative, we need to invert the sign of all components of the vector + // We also need Z to be unity because we are going to be treating this triangle + // as the sin() and cos() of the bed's tilt + + // + // All of 3 of these points should give us the same d constant + // + t = normal.dx * ubl_3_point_1_X + normal.dy * ubl_3_point_1_Y; + d = t + normal.dz * pt1; + c = d - t; + SERIAL_ECHOPGM("d from 1st point: "); + SERIAL_PROTOCOL_F(d, 6); + SERIAL_ECHOPGM(" c: "); + SERIAL_PROTOCOL_F(c, 6); + SERIAL_EOL; + t = normal.dx * ubl_3_point_2_X + normal.dy * ubl_3_point_2_Y; + d = t + normal.dz * pt2; + c = d - t; + SERIAL_ECHOPGM("d from 2nd point: "); + SERIAL_PROTOCOL_F(d, 6); + SERIAL_ECHOPGM(" c: "); + SERIAL_PROTOCOL_F(c, 6); + SERIAL_EOL; + t = normal.dx * ubl_3_point_3_X + normal.dy * ubl_3_point_3_Y; + d = t + normal.dz * pt3; + c = d - t; + SERIAL_ECHOPGM("d from 3rd point: "); + SERIAL_PROTOCOL_F(d, 6); + SERIAL_ECHOPGM(" c: "); + SERIAL_PROTOCOL_F(c, 6); + SERIAL_EOL; + + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { + for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { + c = -((normal.dx * (UBL_MESH_MIN_X + i * (MESH_X_DIST)) + normal.dy * (UBL_MESH_MIN_Y + j * (MESH_Y_DIST))) - d); + z_values[i][j] += c; + } + } + return normal; + } + + float use_encoder_wheel_to_measure_point() { + UBL_has_control_of_LCD_Panel++; + while (!G29_lcd_clicked()) { // we need the loop to move the nozzle based on the encoder wheel here! + idle(); + if (G29_encoderDiff != 0) { + float new_z; + // We define a new variable so we can know ahead of time where we are trying to go. + // The reason is we want G29_encoderDiff cleared so an interrupt can update it even before the move + // is complete. (So the dial feels responsive to user) + new_z = current_position[Z_AXIS] + 0.01 * float(G29_encoderDiff); + G29_encoderDiff = 0; + do_blocking_move_to_z(new_z); + } + } + while (G29_lcd_clicked()) idle(); // debounce and wait + UBL_has_control_of_LCD_Panel--; + return current_position[Z_AXIS]; + } + + float measure_business_card_thickness(float Height_Value) { + float Z1, Z2; + + UBL_has_control_of_LCD_Panel++; + save_UBL_active_state_and_disable(); // we don't do bed level correction because we want the raw data when we probe + + SERIAL_PROTOCOLLNPGM("Place Shim Under Nozzle and Perform Measurement."); + do_blocking_move_to_z(Height_Value); + do_blocking_move_to_xy((float(X_MAX_POS) - float(X_MIN_POS)) / 2.0, (float(Y_MAX_POS) - float(Y_MIN_POS)) / 2.0); + //, min( planner.max_feedrate_mm_s[X_AXIS], planner.max_feedrate_mm_s[Y_AXIS])/2.0); + + Z1 = use_encoder_wheel_to_measure_point(); + do_blocking_move_to_z(current_position[Z_AXIS] + SIZE_OF_LITTLE_RAISE); + UBL_has_control_of_LCD_Panel = 0; + + SERIAL_PROTOCOLLNPGM("Remove Shim and Measure Bed Height."); + Z2 = use_encoder_wheel_to_measure_point(); + do_blocking_move_to_z(current_position[Z_AXIS] + SIZE_OF_LITTLE_RAISE); + + if (G29_Verbose_Level > 1) { + SERIAL_ECHOPGM("Business Card is: "); + SERIAL_PROTOCOL_F(abs(Z1 - Z2), 6); + SERIAL_PROTOCOLLNPGM("mm thick."); + } + restore_UBL_active_state_and_leave(); + return abs(Z1 - Z2); + } + + void manually_probe_remaining_mesh(float X_Pos, float Y_Pos, float z_clearance, float card_thickness, bool do_UBL_MESH_Map) { + mesh_index_pair location; + float last_x, last_y, dx, dy, + xProbe, yProbe; + unsigned long cnt; + + UBL_has_control_of_LCD_Panel++; + last_x = last_y = -9999.99; + save_UBL_active_state_and_disable(); // we don't do bed level correction because we want the raw data when we probe + do_blocking_move_to_z(z_clearance); + do_blocking_move_to_xy(X_Pos, Y_Pos); + + do { + if (do_UBL_MESH_Map) blm.display_map(1); + + location = find_closest_mesh_point_of_type(INVALID, X_Pos, Y_Pos, 0, NULL); // The '0' says we want to use the nozzle's position + // It doesn't matter if the probe can not reach the + // NAN location. This is a manual probe. + if (location.x_index < 0 && location.y_index < 0) continue; + + xProbe = blm.map_x_index_to_bed_location(location.x_index); + yProbe = blm.map_y_index_to_bed_location(location.y_index); + if (xProbe < (X_MIN_POS) || xProbe > (X_MAX_POS) || yProbe < (Y_MIN_POS) || yProbe > (Y_MAX_POS)) { + SERIAL_PROTOCOLLNPGM("?Error: Attempt to probe off the bed."); + UBL_has_control_of_LCD_Panel = 0; + goto LEAVE; + } + + dx = xProbe - last_x; + dy = yProbe - last_y; + + if (HYPOT(dx, dy) < BIG_RAISE_NOT_NEEDED) + do_blocking_move_to_z(current_position[Z_AXIS] + SIZE_OF_LITTLE_RAISE); + else + do_blocking_move_to_z(z_clearance); + + last_x = xProbe; + last_y = yProbe; + do_blocking_move_to_xy(xProbe, yProbe); + + while (!G29_lcd_clicked()) { // we need the loop to move the nozzle based on the encoder wheel here! + idle(); + if (G29_encoderDiff) { + float new_z; + // We define a new variable so we can know ahead of time where we are trying to go. + // The reason is we want G29_encoderDiff cleared so an interrupt can update it even before the move + // is complete. (So the dial feels responsive to user) + new_z = current_position[Z_AXIS] + float(G29_encoderDiff) / 100.0; + G29_encoderDiff = 0; + do_blocking_move_to_z(new_z); + } + } + + cnt = millis(); + while (G29_lcd_clicked()) { // debounce and watch for abort + idle(); + if (millis() - cnt > 1500L) { + SERIAL_PROTOCOLLNPGM("\nMesh only partially populated."); + do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); + lcd_quick_feedback(); + while (G29_lcd_clicked()) idle(); + UBL_has_control_of_LCD_Panel = 0; + restore_UBL_active_state_and_leave(); + return; + } + } + + z_values[location.x_index][location.y_index] = current_position[Z_AXIS] - card_thickness; + if (G29_Verbose_Level > 2) { + SERIAL_PROTOCOL("Mesh Point Measured at: "); + SERIAL_PROTOCOL_F(z_values[location.x_index][location.y_index], 6); + SERIAL_EOL; + } + } while (location.x_index >= 0 && location.y_index >= 0); + + if (do_UBL_MESH_Map) blm.display_map(1); + + LEAVE: + restore_UBL_active_state_and_leave(); + do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); + do_blocking_move_to_xy(X_Pos, Y_Pos); + } + + bool G29_Parameter_Parsing() { + + #if ENABLED(ULTRA_LCD) + lcd_setstatus("Doing G29 UBL !", true); + lcd_quick_feedback(); + #endif + + X_Pos = current_position[X_AXIS]; + Y_Pos = current_position[Y_AXIS]; + X_Flag = Y_Flag = Repeat_Flag = UBL_OK; + Constant = 0.0; + Repetition_Cnt = 1; + + if ((X_Flag = code_seen('X'))) { + X_Pos = code_value_float(); + if (X_Pos < X_MIN_POS || X_Pos > X_MAX_POS) { + SERIAL_PROTOCOLLNPGM("Invalid X location specified.\n"); + return UBL_ERR; + } + } + + if ((Y_Flag = code_seen('Y'))) { + Y_Pos = code_value_float(); + if (Y_Pos < Y_MIN_POS || Y_Pos > Y_MAX_POS) { + SERIAL_PROTOCOLLNPGM("Invalid Y location specified.\n"); + return UBL_ERR; + } + } + + if (X_Flag != Y_Flag) { + SERIAL_PROTOCOLLNPGM("Both X & Y locations must be specified.\n"); + return UBL_ERR; + } + + G29_Verbose_Level = 0; + if (code_seen('V')) { + G29_Verbose_Level = code_value_int(); + if (G29_Verbose_Level < 0 || G29_Verbose_Level > 4) { + SERIAL_PROTOCOLLNPGM("Invalid Verbose Level specified. (0-4)\n"); + return UBL_ERR; + } + } + + if (code_seen('A')) { // Activate the Unified Bed Leveling System + blm.state.active = 1; + SERIAL_PROTOCOLLNPGM("Unified Bed Leveling System activated.\n"); + blm.store_state(); + } + + if ((C_Flag = code_seen('C')) && code_has_value()) + Constant = code_value_float(); + + if (code_seen('D')) { // Disable the Unified Bed Leveling System + blm.state.active = 0; + SERIAL_PROTOCOLLNPGM("Unified Bed Leveling System de-activated.\n"); + blm.store_state(); + } + + if (code_seen('F')) { + blm.state.G29_Correction_Fade_Height = 10.00; + if (code_has_value()) { + blm.state.G29_Correction_Fade_Height = code_value_float(); + blm.state.G29_Fade_Height_Multiplier = 1.0 / blm.state.G29_Correction_Fade_Height; + } + if (blm.state.G29_Correction_Fade_Height<0.0 || blm.state.G29_Correction_Fade_Height>100.0) { + SERIAL_PROTOCOLLNPGM("?Bed Level Correction Fade Height Not Plausable.\n"); + blm.state.G29_Correction_Fade_Height = 10.00; + blm.state.G29_Fade_Height_Multiplier = 1.0 / blm.state.G29_Correction_Fade_Height; + return UBL_ERR; + } + } + + if ((Repeat_Flag = code_seen('R'))) { + Repetition_Cnt = code_has_value() ? code_value_int() : 9999; + if (Repetition_Cnt < 1) { + SERIAL_PROTOCOLLNPGM("Invalid Repetition count.\n"); + return UBL_ERR; + } + } + return UBL_OK; + } + + /** + * This function goes away after G29 debug is complete. But for right now, it is a handy + * routine to dump binary data structures. + */ + void dump(char *str, float f) { + char *ptr; + + SERIAL_PROTOCOL(str); + SERIAL_PROTOCOL_F(f, 8); + SERIAL_PROTOCOL(" "); + ptr = (char *)&f; + for (uint8_t i = 0; i < 4; i++) { + SERIAL_PROTOCOL(" "); + prt_hex_byte(*ptr++); + } + SERIAL_PROTOCOL(" isnan()="); + SERIAL_PROTOCOL(isnan(f)); + SERIAL_PROTOCOL(" isinf()="); + SERIAL_PROTOCOL(isinf(f)); + + constexpr float g = INFINITY; + if (f == -g) + SERIAL_PROTOCOL(" Minus Infinity detected."); + + SERIAL_EOL; + } + + static int UBL_state_at_invokation = 0, + UBL_state_recursion_chk = 0; + + void save_UBL_active_state_and_disable() { + UBL_state_recursion_chk++; + if (UBL_state_recursion_chk != 1) { + SERIAL_ECHOLNPGM("save_UBL_active_state_and_disabled() called multiple times in a row."); + lcd_setstatus("save_UBL_active() error", true); + lcd_quick_feedback(); + return; + } + UBL_state_at_invokation = blm.state.active; + blm.state.active = 0; + return; + } + + void restore_UBL_active_state_and_leave() { + if (--UBL_state_recursion_chk) { + SERIAL_ECHOLNPGM("restore_UBL_active_state_and_leave() called too many times."); + lcd_setstatus("restore_UBL_active() error", true); + lcd_quick_feedback(); + return; + } + blm.state.active = UBL_state_at_invokation; + } + + /** + * Much of the 'What?' command can be eliminated. But until we are fully debugged, it is + * good to have the extra information. Soon... we prune this to just a few items + */ + void G29_What_Command() { + int k, i; + k = E2END - Unified_Bed_Leveling_EEPROM_start; + Statistics_Flag++; + + SERIAL_PROTOCOLPGM("Version #4: 10/30/2016 branch \n"); + SERIAL_PROTOCOLPGM("Unified Bed Leveling System "); + if (blm.state.active) + SERIAL_PROTOCOLPGM("Active."); + else + SERIAL_PROTOCOLPGM("Inactive."); + SERIAL_PROTOCOLLNPGM(" ------------------------------------- <----<<<"); // These arrows are just to help me + + if (blm.state.EEPROM_storage_slot == 0xFFFF) { + SERIAL_PROTOCOLPGM("No Mesh Loaded."); + SERIAL_PROTOCOLLNPGM(" ------------------------------------- <----<<<"); // These arrows are just to help me + // find this info buried in the clutter + } + else { + SERIAL_PROTOCOLPGM("Mesh: "); + prt_hex_word(blm.state.EEPROM_storage_slot); + SERIAL_PROTOCOLPGM(" Loaded. "); + SERIAL_PROTOCOLLNPGM(" -------------------------------------------------------- <----<<<"); // These arrows are just to help me + // find this info buried in the clutter + } + + SERIAL_ECHOPAIR("\nG29_Correction_Fade_Height : ", blm.state.G29_Correction_Fade_Height ); + SERIAL_PROTOCOLPGM(" ------------------------------------- <----<<< \n"); // These arrows are just to help me + // find this info buried in the clutter + idle(); + + SERIAL_ECHOPGM("z_offset: "); + SERIAL_PROTOCOL_F(blm.state.z_offset, 6); + SERIAL_PROTOCOLLNPGM(" ------------------------------------------------------------ <----<<<"); + + SERIAL_PROTOCOLPGM("X-Axis Mesh Points at: "); + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { + SERIAL_PROTOCOL_F( blm.map_x_index_to_bed_location(i), 1); + SERIAL_PROTOCOLPGM(" "); + } + SERIAL_EOL; + SERIAL_PROTOCOLPGM("Y-Axis Mesh Points at: "); + for (i = 0; i < UBL_MESH_NUM_Y_POINTS; i++) { + SERIAL_PROTOCOL_F( blm.map_y_index_to_bed_location(i), 1); + SERIAL_PROTOCOLPGM(" "); + } + SERIAL_EOL; + + #if HAS_KILL + SERIAL_ECHOPAIR("Kill pin on :", KILL_PIN); + SERIAL_ECHOLNPAIR(" state:", READ(KILL_PIN)); + #endif + + SERIAL_ECHOLNPAIR("UBL_state_at_invokation :", UBL_state_at_invokation); + SERIAL_ECHOLNPAIR("UBL_state_recursion_chk :", UBL_state_recursion_chk); + + SERIAL_EOL; + SERIAL_PROTOCOLPGM("Free EEPROM space starts at: 0x"); + prt_hex_word(Unified_Bed_Leveling_EEPROM_start); + SERIAL_EOL; + idle(); + + SERIAL_PROTOCOLPGM("end of EEPROM : "); + prt_hex_word(E2END); + SERIAL_EOL; + idle(); + + SERIAL_PROTOCOLLNPAIR("sizeof(blm) : ", (int)sizeof(blm)); + SERIAL_EOL; + SERIAL_PROTOCOLLNPAIR("z_value[][] size: ", (int)sizeof(z_values)); + SERIAL_EOL; + + SERIAL_PROTOCOLPGM("EEPROM free for UBL: 0x"); + prt_hex_word(k); + SERIAL_EOL; + idle(); + + SERIAL_PROTOCOLPGM("EEPROM can hold 0x"); + prt_hex_word(k / sizeof(z_values)); + SERIAL_PROTOCOLPGM(" meshes. \n"); + + SERIAL_PROTOCOLPGM("sizeof(stat) :"); + prt_hex_word(sizeof(blm.state)); + SERIAL_EOL; + idle(); + + SERIAL_ECHOPAIR("\nUBL_MESH_NUM_X_POINTS ", UBL_MESH_NUM_X_POINTS); + SERIAL_ECHOPAIR("\nUBL_MESH_NUM_Y_POINTS ", UBL_MESH_NUM_Y_POINTS); + SERIAL_ECHOPAIR("\nUBL_MESH_MIN_X ", UBL_MESH_MIN_X); + SERIAL_ECHOPAIR("\nUBL_MESH_MIN_Y ", UBL_MESH_MIN_Y); + SERIAL_ECHOPAIR("\nUBL_MESH_MAX_X ", UBL_MESH_MAX_X); + SERIAL_ECHOPAIR("\nUBL_MESH_MAX_Y ", UBL_MESH_MAX_Y); + SERIAL_ECHOPGM("\nMESH_X_DIST "); + SERIAL_PROTOCOL_F(MESH_X_DIST, 6); + SERIAL_ECHOPGM("\nMESH_Y_DIST "); + SERIAL_PROTOCOL_F(MESH_Y_DIST, 6); + SERIAL_EOL; + idle(); + + SERIAL_ECHOPAIR("\nsizeof(block_t): ", (int)sizeof(block_t)); + SERIAL_ECHOPAIR("\nsizeof(planner.block_buffer): ", (int)sizeof(planner.block_buffer)); + SERIAL_ECHOPAIR("\nsizeof(char): ", (int)sizeof(char)); + SERIAL_ECHOPAIR(" sizeof(unsigned char): ", (int)sizeof(unsigned char)); + SERIAL_ECHOPAIR("\nsizeof(int): ", (int)sizeof(int)); + SERIAL_ECHOPAIR(" sizeof(unsigned int): ", (int)sizeof(unsigned int)); + SERIAL_ECHOPAIR("\nsizeof(long): ", (int)sizeof(long)); + SERIAL_ECHOPAIR(" sizeof(unsigned long int): ", (int)sizeof(unsigned long int)); + SERIAL_ECHOPAIR("\nsizeof(float): ", (int)sizeof(float)); + SERIAL_ECHOPAIR(" sizeof(double): ", (int)sizeof(double)); + SERIAL_ECHOPAIR("\nsizeof(void *): ", (int)sizeof(void *)); + struct pf { void *p_f(); } ptr_func; + SERIAL_ECHOPAIR(" sizeof(struct pf): ", (int)sizeof(pf)); + SERIAL_ECHOPAIR(" sizeof(void *()): ", (int)sizeof(ptr_func)); + SERIAL_EOL; + + idle(); + + if (!blm.sanity_check()) + SERIAL_PROTOCOLLNPGM("Unified Bed Leveling sanity checks passed."); + } + + /** + * When we are fully debugged, the EEPROM dump command will get deleted also. But + * right now, it is good to have the extra information. Soon... we prune this. + */ + void G29_EEPROM_Dump() { + unsigned char cccc; + int i, j, kkkk; + + SERIAL_ECHO_START; + SERIAL_ECHOPGM("EEPROM Dump:\n"); + for (i = 0; i < E2END + 1; i += 16) { + if (i & 0x3 == 0) idle(); + prt_hex_word(i); + SERIAL_ECHOPGM(": "); + for (j = 0; j < 16; j++) { + kkkk = i + j; + eeprom_read_block(&cccc, (void *)kkkk, 1); + prt_hex_byte(cccc); + SERIAL_ECHO(' '); + } + SERIAL_EOL; + } + SERIAL_EOL; + return; + } + + /** + * When we are fully debugged, this may go away. But there are some valid + * use cases for the users. So we can wait and see what to do with it. + */ + void G29_Kompare_Current_Mesh_to_Stored_Mesh() { + float tmp_z_values[UBL_MESH_NUM_X_POINTS][UBL_MESH_NUM_Y_POINTS]; + int i, j, k; + + if (!code_has_value()) { + SERIAL_PROTOCOLLNPGM("?Mesh # required.\n"); + return; + } + Storage_Slot = code_value_int(); + + k = E2END - sizeof(blm.state); + j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(tmp_z_values); + + if (Storage_Slot < 0 || Storage_Slot > j || Unified_Bed_Leveling_EEPROM_start <= 0) { + SERIAL_PROTOCOLLNPGM("?EEPROM storage not available for use.\n"); + return; + } + + j = k - (Storage_Slot + 1) * sizeof(tmp_z_values); + eeprom_read_block((void *)&tmp_z_values, (void *)j, sizeof(tmp_z_values)); + + SERIAL_ECHOPAIR("Subtracting Mesh ", Storage_Slot); + SERIAL_PROTOCOLPGM(" loaded from EEPROM address "); // Soon, we can remove the extra clutter of printing + prt_hex_word(j); // the address in the EEPROM where the Mesh is stored. + SERIAL_EOL; + + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) + for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) + z_values[i][j] = z_values[i][j] - tmp_z_values[i][j]; + } + + mesh_index_pair find_closest_mesh_point_of_type(Mesh_Point_Type type, float X, float Y, bool probe_as_reference, unsigned int bits[16]) { + int i, j; + float f, px, py, mx, my, dx, dy, closest = 99999.99; + float current_x, current_y, distance; + mesh_index_pair return_val; + + return_val.x_index = return_val.y_index = -1; + + current_x = current_position[X_AXIS]; + current_y = current_position[Y_AXIS]; + + px = X; // Get our reference position. Either the nozzle or + py = Y; // the probe location. + if (probe_as_reference) { + px -= X_PROBE_OFFSET_FROM_EXTRUDER; + py -= Y_PROBE_OFFSET_FROM_EXTRUDER; + } + + for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { + for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { + + if ( (type == INVALID && isnan(z_values[i][j])) // Check to see if this location holds the right thing + || (type == REAL && !isnan(z_values[i][j])) + || (type == SET_IN_BITMAP && is_bit_set(bits, i, j)) + ) { + + // We only get here if we found a Mesh Point of the specified type + + mx = blm.map_x_index_to_bed_location(i); // Check if we can probe this mesh location + my = blm.map_y_index_to_bed_location(j); + + // If we are using the probe as the reference + // there are some locations we can't get to. + // We prune these out of the list and ignore + // them until the next Phase where we do the + // manual nozzle probing. + if (probe_as_reference + && (mx < (MIN_PROBE_X) || mx > (MAX_PROBE_X)) + && (my < (MIN_PROBE_Y) || my > (MAX_PROBE_Y)) + ) continue; + + dx = px - mx; // We can get to it. Let's see if it is the + dy = py - my; // closest location to the nozzle. + distance = HYPOT(dx, dy); + + dx = current_x - mx; // We are going to add in a weighting factor that considers + dy = current_y - my; // the current location of the nozzle. If two locations are equal + distance += HYPOT(dx, dy) * 0.01; // distance from the measurement location, we are going to give + + if (distance < closest) { + closest = distance; // We found a closer location with + return_val.x_index = i; // the specified type of mesh value. + return_val.y_index = j; + return_val.distance = closest; + } + } + } + } + return return_val; + } + + void fine_tune_mesh(float X_Pos, float Y_Pos, float Height_Value, bool do_UBL_MESH_Map) { + mesh_index_pair location; + float xProbe, yProbe, new_z; + uint16_t i, not_done[16]; + long round_off; + + save_UBL_active_state_and_disable(); + memset(not_done, 0xFF, sizeof(not_done)); + + #if ENABLED(ULTRA_LCD) + lcd_setstatus("Fine Tuning Mesh.", true); + #endif + + do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); + do_blocking_move_to_xy(X_Pos, Y_Pos); + do { + if (do_UBL_MESH_Map) blm.display_map(1); + + location = find_closest_mesh_point_of_type( SET_IN_BITMAP, X_Pos, Y_Pos, 0, not_done); // The '0' says we want to use the nozzle's position + // It doesn't matter if the probe can not reach this + // location. This is a manual edit of the Mesh Point. + if (location.x_index < 0 && location.y_index < 0) continue; // abort if we can't find any more points. + + bit_clear(not_done, location.x_index, location.y_index); // Mark this location as 'adjusted' so we will find a + // different location the next time through the loop + + xProbe = blm.map_x_index_to_bed_location(location.x_index); + yProbe = blm.map_y_index_to_bed_location(location.y_index); + if (xProbe < X_MIN_POS || xProbe > X_MAX_POS || yProbe < Y_MIN_POS || yProbe > Y_MAX_POS) { // In theory, we don't need this check. + SERIAL_PROTOCOLLNPGM("?Error: Attempt to edit off the bed."); // This really can't happen, but for now, + UBL_has_control_of_LCD_Panel = 0; // Let's do the check. + goto FINE_TUNE_EXIT; + } + + do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); // Move the nozzle to where we are going to edit + do_blocking_move_to_xy(xProbe, yProbe); + new_z = z_values[location.x_index][location.y_index] + 0.001; + + round_off = (int32_t)(new_z * 1000.0 + 2.5); // we chop off the last digits just to be clean. We are rounding to the + round_off -= (round_off % 5L); // closest 0 or 5 at the 3rd decimal place. + new_z = ((float)(round_off)) / 1000.0; + + //SERIAL_ECHOPGM("Mesh Point Currently At: "); + //SERIAL_PROTOCOL_F(new_z, 6); + //SERIAL_EOL; + + lcd_implementation_clear(); + lcd_mesh_edit_setup(new_z); + UBL_has_control_of_LCD_Panel++; + do { + new_z = lcd_mesh_edit(); + idle(); + } while (!G29_lcd_clicked()); + + UBL_has_control_of_LCD_Panel = 1; // There is a race condition for the Encoder Wheel getting clicked. + // It could get detected in lcd_mesh_edit (actually _lcd_mesh_fine_tune( ) + // or here. + millis_t nxt = millis() + 1500UL; + lcd_return_to_status(); + while (G29_lcd_clicked()) { // debounce and watch for abort + idle(); + if (ELAPSED(millis(), nxt)) { + lcd_return_to_status(); + SERIAL_PROTOCOLLNPGM("\nFine Tuning of Mesh Stopped."); + do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); + lcd_setstatus("Mesh Editing Stopped", true); + + while (G29_lcd_clicked()) idle(); + + UBL_has_control_of_LCD_Panel = 0; + goto FINE_TUNE_EXIT; + } + } + //UBL_has_control_of_LCD_Panel = 0; + delay(20); // We don't want any switch noise. + + z_values[location.x_index][location.y_index] = new_z; + + lcd_implementation_clear(); + + } while (location.x_index >= 0 && location.y_index >= 0 && --Repetition_Cnt); + + FINE_TUNE_EXIT: + + if (do_UBL_MESH_Map) blm.display_map(1); + restore_UBL_active_state_and_leave(); + do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); + + do_blocking_move_to_xy(X_Pos, Y_Pos); + + UBL_has_control_of_LCD_Panel = 0; + + #if ENABLED(ULTRA_LCD) + lcd_setstatus("Done Editing Mesh", true); + #endif + SERIAL_ECHOLNPGM("Done Editing Mesh."); + } + +#endif // AUTO_BED_LEVELING_UBL diff --git a/Marlin/UBL_line_to_destination.cpp b/Marlin/UBL_line_to_destination.cpp new file mode 100644 index 000000000..bb3956dc3 --- /dev/null +++ b/Marlin/UBL_line_to_destination.cpp @@ -0,0 +1,553 @@ +/** + * 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 . + * + */ +#include "Marlin.h" + +#if ENABLED(AUTO_BED_LEVELING_UBL) + + #include "UBL.h" + #include "planner.h" + #include + #include + + extern void set_current_to_destination(); + extern bool G26_Debug_flag; + void debug_current_and_destination(char *title); + + void wait_for_button_press(); + + void UBL_line_to_destination(const float &x_end, const float &y_end, const float &z_end, const float &e_end, const float &feed_rate, uint8_t extruder) { + + int cell_start_xi, cell_start_yi, cell_dest_xi, cell_dest_yi; + int left_flag, down_flag; + int current_xi, current_yi; + int dxi, dyi, xi_cnt, yi_cnt; + bool use_X_dist, inf_normalized_flag, inf_m_flag; + float x_start, y_start; + float x, y, z1, z2, z0 /*, z_optimized */; + float next_mesh_line_x, next_mesh_line_y, a0ma1diva2ma1; + float on_axis_distance, e_normalized_dist, e_position, e_start, z_normalized_dist, z_position, z_start; + float dx, dy, adx, ady, m, c; + + // + // Much of the nozzle movement will be within the same cell. So we will do as little computation + // as possible to determine if this is the case. If this move is within the same cell, we will + // just do the required Z-Height correction, call the Planner's buffer_line() routine, and leave + // + + x_start = current_position[X_AXIS]; + y_start = current_position[Y_AXIS]; + z_start = current_position[Z_AXIS]; + e_start = current_position[E_AXIS]; + + cell_start_xi = blm.get_cell_index_x(x_start); + cell_start_yi = blm.get_cell_index_y(y_start); + cell_dest_xi = blm.get_cell_index_x(x_end); + cell_dest_yi = blm.get_cell_index_y(y_end); + + if (G26_Debug_flag!=0) { + SERIAL_ECHOPGM(" UBL_line_to_destination(xe="); + SERIAL_ECHO(x_end); + SERIAL_ECHOPGM(",ye="); + SERIAL_ECHO(y_end); + SERIAL_ECHOPGM(",ze="); + SERIAL_ECHO(z_end); + SERIAL_ECHOPGM(",ee="); + SERIAL_ECHO(e_end); + SERIAL_ECHOPGM(")\n"); + debug_current_and_destination( (char *) "Start of UBL_line_to_destination()"); + } + + if ((cell_start_xi == cell_dest_xi) && (cell_start_yi == cell_dest_yi)) { // if the whole move is within the same cell, + // we don't need to break up the move + // + // If we are moving off the print bed, we are going to allow the move at this level. + // But we detect it and isolate it. For now, we just pass along the request. + // + + if (cell_dest_xi<0 || cell_dest_yi<0 || cell_dest_xi >= UBL_MESH_NUM_X_POINTS || cell_dest_yi >= UBL_MESH_NUM_Y_POINTS) { + + // Note: There is no Z Correction in this case. We are off the grid and don't know what + // a reasonable correction would be. + + planner.buffer_line(x_end, y_end, z_end + blm.state.z_offset, e_end, feed_rate, extruder); + set_current_to_destination(); + if (G26_Debug_flag!=0) { + debug_current_and_destination( (char *) "out of bounds in UBL_line_to_destination()"); + } + return; + } + + // we can optimize some floating point operations here. We could call float get_z_correction(float x0, float y0) to + // generate the correction for us. But we can lighten the load on the CPU by doing a modified version of the function. + // We are going to only calculate the amount we are from the first mesh line towards the second mesh line once. + // We will use this fraction in both of the original two Z Height calculations for the bi-linear interpolation. And, + // instead of doing a generic divide of the distance, we know the distance is MESH_X_DIST so we can use the preprocessor + // to create a 1-over number for us. That will allow us to do a floating point multiply instead of a floating point divide. + + FINAL_MOVE: + a0ma1diva2ma1 = (x_end - mesh_index_to_X_location[cell_dest_xi]) * (float) (1.0 / MESH_X_DIST); + + z1 = z_values[cell_dest_xi][cell_dest_yi] + + (z_values[cell_dest_xi + 1][cell_dest_yi] - z_values[cell_dest_xi][cell_dest_yi]) * a0ma1diva2ma1; + + z2 = z_values[cell_dest_xi][cell_dest_yi+1] + + (z_values[cell_dest_xi+1][cell_dest_yi+1] - z_values[cell_dest_xi][cell_dest_yi+1]) * a0ma1diva2ma1; + + // we are done with the fractional X distance into the cell. Now with the two Z-Heights we have calculated, we + // are going to apply the Y-Distance into the cell to interpolate the final Z correction. + + a0ma1diva2ma1 = (y_end - mesh_index_to_Y_location[cell_dest_yi]) * (float) (1.0 / MESH_Y_DIST); + + z0 = z1 + (z2 - z1) * a0ma1diva2ma1; + + // debug code to use non-optimized get_z_correction() and to do a sanity check + // that the correct value is being passed to planner.buffer_line() + // + /* + z_optimized = z0; + z0 = blm.get_z_correction( x_end, y_end); + if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) ) { + debug_current_and_destination( (char *) "FINAL_MOVE: z_correction()"); + if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN "); + if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN "); + SERIAL_ECHOPAIR(" x_end=", x_end); + SERIAL_ECHOPAIR(" y_end=", y_end); + SERIAL_ECHOPAIR(" z0=", z0); + SERIAL_ECHOPAIR(" z_optimized=", z_optimized); + SERIAL_ECHOPAIR(" err=",fabs(z_optimized - z0)); + SERIAL_EOL; + } + */ + z0 = z0 * blm.fade_scaling_factor_for_Z( z_end ); + + if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN + z0 = 0.0; // in z_values[][] and propagate through the + // calculations. If our correction is NAN, we throw it out + // because part of the Mesh is undefined and we don't have the + // information we need to complete the height correction. + } + + planner.buffer_line(x_end, y_end, z_end + z0 + blm.state.z_offset, e_end, feed_rate, extruder); + if (G26_Debug_flag!=0) { + debug_current_and_destination( (char *) "FINAL_MOVE in UBL_line_to_destination()"); + } + set_current_to_destination(); + return; + } + + // + // If we get here, we are processing a move that crosses at least one Mesh Line. We will check + // for the simple case of just crossing X or just crossing Y Mesh Lines after we get all the details + // of the move figured out. We can process the easy case of just crossing an X or Y Mesh Line with less + // computation and in fact most lines are of this nature. We will check for that in the following + // blocks of code: + + left_flag = 0; + down_flag = 0; + inf_m_flag = false; + inf_normalized_flag = false; + + dx = x_end - x_start; + dy = y_end - y_start; + + if (dx<0.0) { // figure out which way we need to move to get to the next cell + dxi = -1; + adx = -dx; // absolute value of dx. We already need to check if dx and dy are negative. + } + else { // We may as well generate the appropriate values for adx and ady right now + dxi = 1; // to save setting up the abs() function call and actually doing the call. + adx = dx; + } + if (dy<0.0) { + dyi = -1; + ady = -dy; // absolute value of dy + } + else { + dyi = 1; + ady = dy; + } + + if (dx<0.0) left_flag = 1; + if (dy<0.0) down_flag = 1; + if (cell_start_xi == cell_dest_xi) dxi = 0; + if (cell_start_yi == cell_dest_yi) dyi = 0; + + // + // Compute the scaling factor for the extruder for each partial move. + // We need to watch out for zero length moves because it will cause us to + // have an infinate scaling factor. We are stuck doing a floating point + // divide to get our scaling factor, but after that, we just multiply by this + // number. We also pick our scaling factor based on whether the X or Y + // component is larger. We use the biggest of the two to preserve precision. + // + if ( adx > ady ) { + use_X_dist = true; + on_axis_distance = x_end-x_start; + } + else { + use_X_dist = false; + on_axis_distance = y_end-y_start; + } + e_position = e_end - e_start; + e_normalized_dist = e_position / on_axis_distance; + + z_position = z_end - z_start; + z_normalized_dist = z_position / on_axis_distance; + + if (e_normalized_dist==INFINITY || e_normalized_dist==-INFINITY) { + inf_normalized_flag = true; + } + current_xi = cell_start_xi; + current_yi = cell_start_yi; + + m = dy / dx; + c = y_start - m*x_start; + if (m == INFINITY || m == -INFINITY) { + inf_m_flag = true; + } + // + // This block handles vertical lines. These are lines that stay within the same + // X Cell column. They do not need to be perfectly vertical. They just can + // not cross into another X Cell column. + // + if (dxi == 0) { // Check for a vertical line + current_yi += down_flag; // Line is heading down, we just want to go to the bottom + while (current_yi != cell_dest_yi + down_flag) { + current_yi += dyi; + next_mesh_line_y = mesh_index_to_Y_location[current_yi]; + if (inf_m_flag) { + x = x_start; // if the slope of the line is infinite, we won't do the calculations + } + // we know the next X is the same so we can recover and continue! + else { + x = (next_mesh_line_y - c) / m; // Calculate X at the next Y mesh line + } + + z0 = blm.get_z_correction_along_horizontal_mesh_line_at_specific_X(x, current_xi, current_yi); + + // + // debug code to use non-optimized get_z_correction() and to do a sanity check + // that the correct value is being passed to planner.buffer_line() + // + /* + z_optimized = z0; + z0 = blm.get_z_correction( x, next_mesh_line_y); + if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) ) { + debug_current_and_destination( (char *) "VERTICAL z_correction()"); + if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN "); + if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN "); + SERIAL_ECHOPAIR(" x=", x); + SERIAL_ECHOPAIR(" next_mesh_line_y=", next_mesh_line_y); + SERIAL_ECHOPAIR(" z0=", z0); + SERIAL_ECHOPAIR(" z_optimized=", z_optimized); + SERIAL_ECHOPAIR(" err=",fabs(z_optimized-z0)); + SERIAL_ECHO("\n"); + } + */ + + z0 = z0 * blm.fade_scaling_factor_for_Z( z_end ); + + if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN + z0 = 0.0; // in z_values[][] and propagate through the + // calculations. If our correction is NAN, we throw it out + // because part of the Mesh is undefined and we don't have the + // information we need to complete the height correction. + } + y = mesh_index_to_Y_location[current_yi]; + + // Without this check, it is possible for the algorythm to generate a zero length move in the case + // where the line is heading down and it is starting right on a Mesh Line boundary. For how often that + // happens, it might be best to remove the check and always 'schedule' the move because + // the planner.buffer_line() routine will filter it if that happens. + if ( y!=y_start) { + if ( inf_normalized_flag == false ) { + on_axis_distance = y - y_start; // we don't need to check if the extruder position + e_position = e_start + on_axis_distance * e_normalized_dist; // is based on X or Y because this is a vertical move + z_position = z_start + on_axis_distance * z_normalized_dist; + } + else { + e_position = e_start; + z_position = z_start; + } + + planner.buffer_line(x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder); + } //else printf("FIRST MOVE PRUNED "); + } + // + // Check if we are at the final destination. Usually, we won't be, but if it is on a Y Mesh Line, we are done. + // + if (G26_Debug_flag!=0) { + debug_current_and_destination( (char *) "vertical move done in UBL_line_to_destination()"); + } + if (current_position[X_AXIS] != x_end || current_position[Y_AXIS] != y_end) { + goto FINAL_MOVE; + } + set_current_to_destination(); + return; + } + + // + // This block handles horizontal lines. These are lines that stay within the same + // Y Cell row. They do not need to be perfectly horizontal. They just can + // not cross into another Y Cell row. + // + + if (dyi == 0) { // Check for a horiziontal line + current_xi += left_flag; // Line is heading left, we just want to go to the left + // edge of this cell for the first move. + while (current_xi != cell_dest_xi + left_flag) { + current_xi += dxi; + next_mesh_line_x = mesh_index_to_X_location[current_xi]; + y = m * next_mesh_line_x + c; // Calculate X at the next Y mesh line + + z0 = blm.get_z_correction_along_vertical_mesh_line_at_specific_Y(y, current_xi, current_yi); + + // + // debug code to use non-optimized get_z_correction() and to do a sanity check + // that the correct value is being passed to planner.buffer_line() + // + /* + z_optimized = z0; + z0 = blm.get_z_correction( next_mesh_line_x, y); + if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) ) { + debug_current_and_destination( (char *) "HORIZONTAL z_correction()"); + if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN "); + if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN "); + SERIAL_ECHOPAIR(" next_mesh_line_x=", next_mesh_line_x); + SERIAL_ECHOPAIR(" y=", y); + SERIAL_ECHOPAIR(" z0=", z0); + SERIAL_ECHOPAIR(" z_optimized=", z_optimized); + SERIAL_ECHOPAIR(" err=",fabs(z_optimized-z0)); + SERIAL_ECHO("\n"); + } + */ + + z0 = z0 * blm.fade_scaling_factor_for_Z( z_end ); + + if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN + z0 = 0.0; // in z_values[][] and propagate through the + // calculations. If our correction is NAN, we throw it out + // because part of the Mesh is undefined and we don't have the + // information we need to complete the height correction. + } + x = mesh_index_to_X_location[current_xi]; + + // Without this check, it is possible for the algorythm to generate a zero length move in the case + // where the line is heading left and it is starting right on a Mesh Line boundary. For how often + // that happens, it might be best to remove the check and always 'schedule' the move because + // the planner.buffer_line() routine will filter it if that happens. + if ( x!=x_start) { + if ( inf_normalized_flag == false ) { + on_axis_distance = x - x_start; // we don't need to check if the extruder position + e_position = e_start + on_axis_distance * e_normalized_dist; // is based on X or Y because this is a horizontal move + z_position = z_start + on_axis_distance * z_normalized_dist; + } + else { + e_position = e_start; + z_position = z_start; + } + + planner.buffer_line(x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder); + } //else printf("FIRST MOVE PRUNED "); + } + if (G26_Debug_flag!=0) { + debug_current_and_destination( (char *) "horizontal move done in UBL_line_to_destination()"); + } + if (current_position[X_AXIS] != x_end || current_position[Y_AXIS] != y_end) { + goto FINAL_MOVE; + } + set_current_to_destination(); + return; + } + + // + // + // + // + // This block handles the generic case of a line crossing both X and Y + // Mesh lines. + // + // + // + // + + xi_cnt = cell_start_xi - cell_dest_xi; + if ( xi_cnt < 0 ) { + xi_cnt = -xi_cnt; + } + + yi_cnt = cell_start_yi - cell_dest_yi; + if ( yi_cnt < 0 ) { + yi_cnt = -yi_cnt; + } + + current_xi += left_flag; + current_yi += down_flag; + + while ( xi_cnt>0 || yi_cnt>0 ) { + + next_mesh_line_x = mesh_index_to_X_location[current_xi + dxi]; + next_mesh_line_y = mesh_index_to_Y_location[current_yi + dyi]; + + y = m * next_mesh_line_x + c; // Calculate Y at the next X mesh line + x = (next_mesh_line_y-c) / m; // Calculate X at the next Y mesh line (we don't have to worry + // about m being equal to 0.0 If this was the case, we would have + // detected this as a vertical line move up above and we wouldn't + // be down here doing a generic type of move. + + if ((left_flag && (x>next_mesh_line_x)) || (!left_flag && (x .01 || isnan(z0) || isnan(z_optimized) ) { + debug_current_and_destination( (char *) "General_1: z_correction()"); + if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN "); + if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN "); { + SERIAL_ECHOPAIR(" x=", x); + } + SERIAL_ECHOPAIR(" next_mesh_line_y=", next_mesh_line_y); + SERIAL_ECHOPAIR(" z0=", z0); + SERIAL_ECHOPAIR(" z_optimized=", z_optimized); + SERIAL_ECHOPAIR(" err=",fabs(z_optimized-z0)); + SERIAL_ECHO("\n"); + } + */ + + z0 = z0 * blm.fade_scaling_factor_for_Z( z_end ); + if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN + z0 = 0.0; // in z_values[][] and propagate through the + // calculations. If our correction is NAN, we throw it out + // because part of the Mesh is undefined and we don't have the + // information we need to complete the height correction. + } + + if ( inf_normalized_flag == false ) { + if ( use_X_dist ) { + on_axis_distance = x - x_start; + } + else { + on_axis_distance = next_mesh_line_y - y_start; + } + e_position = e_start + on_axis_distance * e_normalized_dist; + z_position = z_start + on_axis_distance * z_normalized_dist; + } + else { + e_position = e_start; + z_position = z_start; + } + planner.buffer_line(x, next_mesh_line_y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder); + current_yi += dyi; + yi_cnt--; + } + else { + // + // Yes! Crossing a X Mesh Line next + // + z0 = blm.get_z_correction_along_vertical_mesh_line_at_specific_Y(y, current_xi+dxi, current_yi-down_flag); + + + // + // debug code to use non-optimized get_z_correction() and to do a sanity check + // that the correct value is being passed to planner.buffer_line() + // + /* + z_optimized = z0; + z0 = blm.get_z_correction( next_mesh_line_x, y); + if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) ) { + debug_current_and_destination( (char *) "General_2: z_correction()"); + if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN "); + if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN "); + SERIAL_ECHOPAIR(" next_mesh_line_x=", next_mesh_line_x); + SERIAL_ECHOPAIR(" y=", y); + SERIAL_ECHOPAIR(" z0=", z0); + SERIAL_ECHOPAIR(" z_optimized=", z_optimized); + SERIAL_ECHOPAIR(" err=",fabs(z_optimized-z0)); + SERIAL_ECHO("\n"); + } + */ + + z0 = z0 * blm.fade_scaling_factor_for_Z( z_end ); + + if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN + z0 = 0.0; // in z_values[][] and propagate through the + // calculations. If our correction is NAN, we throw it out + // because part of the Mesh is undefined and we don't have the + // information we need to complete the height correction. + } + if ( inf_normalized_flag == false ) { + if ( use_X_dist ) { + on_axis_distance = next_mesh_line_x - x_start; + } + else { + on_axis_distance = y - y_start; + } + e_position = e_start + on_axis_distance * e_normalized_dist; + z_position = z_start + on_axis_distance * z_normalized_dist; + } + else { + e_position = e_start; + z_position = z_start; + } + + planner.buffer_line(next_mesh_line_x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder); + current_xi += dxi; + xi_cnt--; + } + } + if (G26_Debug_flag) { + debug_current_and_destination( (char *) "generic move done in UBL_line_to_destination()"); + } + if (current_position[0] != x_end || current_position[1] != y_end) { + goto FINAL_MOVE; + } + set_current_to_destination(); + return; + } + + void wait_for_button_press() { + // if ( !been_to_2_6 ) + //return; // bob - I think this should be commented out + + SET_INPUT_PULLUP(66); // Roxy's Left Switch is on pin 66. Right Switch is on pin 65 + SET_OUTPUT(64); + while (READ(66) & 0x01) idle(); + + delay(50); + while (!(READ(66) & 0x01)) idle(); + delay(50); + } + +#endif + + diff --git a/Marlin/configuration_store.cpp b/Marlin/configuration_store.cpp index 0d31bee5d..ffe9fc36e 100644 --- a/Marlin/configuration_store.cpp +++ b/Marlin/configuration_store.cpp @@ -164,6 +164,10 @@ #include "stepper_indirection.h" #endif +#if ENABLED(AUTO_BED_LEVELING_UBL) + #include "UBL.h" +#endif + #if ENABLED(ABL_BILINEAR_SUBDIVISION) extern void bed_level_virt_interpolate(); #endif @@ -534,6 +538,11 @@ void Config_Postprocess() { SERIAL_ECHOPAIR("Settings Stored (", eeprom_size - (EEPROM_OFFSET)); SERIAL_ECHOLNPGM(" bytes)"); } + #if ENABLED(AUTO_BED_LEVELING_UBL) + blm.store_state(); + if (blm.state.EEPROM_storage_slot >= 0) + blm.store_mesh(blm.state.EEPROM_storage_slot); + #endif } /** @@ -832,8 +841,45 @@ void Config_Postprocess() { SERIAL_ERRORLNPGM("EEPROM checksum mismatch"); Config_ResetDefault(); } - } + #if ENABLED(AUTO_BED_LEVELING_UBL) + Unified_Bed_Leveling_EEPROM_start = (eeprom_index + 32) & 0xFFF8; // Pad the end of configuration data so it + // can float up or down a little bit without + // disrupting the Unified Bed Leveling data + blm.load_state(); + + SERIAL_ECHOPGM(" UBL "); + if (!blm.state.active) SERIAL_ECHO("not "); + SERIAL_ECHOLNPGM("active!"); + + if (!blm.sanity_check()) { + int tmp_mesh; // We want to preserve whether the UBL System is Active + bool tmp_active; // If it is, we want to preserve the Mesh that is being used. + tmp_mesh = blm.state.EEPROM_storage_slot; + tmp_active = blm.state.active; + SERIAL_ECHOLNPGM("\nInitializing Bed Leveling State to current firmware settings.\n"); + blm.state = blm.pre_initialized; // Initialize with the pre_initialized data structure + blm.state.EEPROM_storage_slot = tmp_mesh; // But then restore some data we don't want mangled + blm.state.active = tmp_active; + } + else { + SERIAL_PROTOCOLPGM("?Unable to enable Unified Bed Leveling.\n"); + blm.state = blm.pre_initialized; + blm.reset(); + blm.store_state(); + } + + if (blm.state.EEPROM_storage_slot >= 0) { + blm.load_mesh(blm.state.EEPROM_storage_slot); + SERIAL_ECHOPAIR("Mesh ", blm.state.EEPROM_storage_slot); + SERIAL_ECHOLNPGM(" loaded from storage."); + } + else { + blm.reset(); + SERIAL_ECHOPGM("UBL System reset() \n"); + } + #endif + } #if ENABLED(EEPROM_CHITCHAT) Config_PrintSettings(); #endif @@ -1126,6 +1172,42 @@ void Config_ResetDefault() { SERIAL_ECHOPAIR(" Z", home_offset[Z_AXIS]); SERIAL_EOL; #endif + #if ENABLED(AUTO_BED_LEVELING_UBL) + SERIAL_ECHOLNPGM("Unified Bed Leveling:"); + CONFIG_ECHO_START; + + SERIAL_ECHOPGM("System is: "); + if (blm.state.active) + SERIAL_ECHOLNPGM("Active\n"); + else + SERIAL_ECHOLNPGM("Deactive\n"); + + SERIAL_ECHOPAIR("Active Mesh Slot: ", blm.state.EEPROM_storage_slot); + SERIAL_EOL; + + SERIAL_ECHOPGM("z_offset: "); + SERIAL_ECHO_F(blm.state.z_offset, 6); + SERIAL_EOL; + + SERIAL_ECHOPAIR("EEPROM can hold ", (int)((E2END - sizeof(blm.state) - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values))); + SERIAL_ECHOLNPGM(" meshes. \n"); + + SERIAL_ECHOPAIR("\nUBL_MESH_NUM_X_POINTS ", UBL_MESH_NUM_X_POINTS); + SERIAL_ECHOPAIR("\nUBL_MESH_NUM_Y_POINTS ", UBL_MESH_NUM_Y_POINTS); + + SERIAL_ECHOPAIR("\nUBL_MESH_MIN_X ", UBL_MESH_MIN_X); + SERIAL_ECHOPAIR("\nUBL_MESH_MIN_Y ", UBL_MESH_MIN_Y); + + SERIAL_ECHOPAIR("\nUBL_MESH_MAX_X ", UBL_MESH_MAX_X); + SERIAL_ECHOPAIR("\nUBL_MESH_MAX_Y ", UBL_MESH_MAX_Y); + + SERIAL_ECHOPGM("\nMESH_X_DIST "); + SERIAL_ECHO_F(MESH_X_DIST, 6); + SERIAL_ECHOPGM("\nMESH_Y_DIST "); + SERIAL_ECHO_F(MESH_Y_DIST, 6); + SERIAL_EOL; + SERIAL_EOL; + #endif #if HOTENDS > 1 CONFIG_ECHO_START; diff --git a/Marlin/example_configurations/Cartesio/Configuration.h b/Marlin/example_configurations/Cartesio/Configuration.h index 7c9e1f216..28b7feff7 100644 --- a/Marlin/example_configurations/Cartesio/Configuration.h +++ b/Marlin/example_configurations/Cartesio/Configuration.h @@ -232,6 +232,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -603,8 +604,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -741,35 +741,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -793,10 +767,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -805,6 +791,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -825,11 +818,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -853,7 +841,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/Felix/Configuration.h b/Marlin/example_configurations/Felix/Configuration.h index 577637919..446834072 100644 --- a/Marlin/example_configurations/Felix/Configuration.h +++ b/Marlin/example_configurations/Felix/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -586,8 +587,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -724,35 +724,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -776,10 +750,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -788,6 +774,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -808,11 +801,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. diff --git a/Marlin/example_configurations/Felix/DUAL/Configuration.h b/Marlin/example_configurations/Felix/DUAL/Configuration.h index c4858da72..3f64aeeab 100644 --- a/Marlin/example_configurations/Felix/DUAL/Configuration.h +++ b/Marlin/example_configurations/Felix/DUAL/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -586,8 +587,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -724,35 +724,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -776,10 +750,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -788,6 +774,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -808,11 +801,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -836,7 +824,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/Hephestos/Configuration.h b/Marlin/example_configurations/Hephestos/Configuration.h index 6c3a4cdd1..1c7bd92c0 100644 --- a/Marlin/example_configurations/Hephestos/Configuration.h +++ b/Marlin/example_configurations/Hephestos/Configuration.h @@ -234,6 +234,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -595,8 +596,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -733,35 +733,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -785,10 +759,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -797,6 +783,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -817,11 +810,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -845,7 +833,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/Hephestos_2/Configuration.h b/Marlin/example_configurations/Hephestos_2/Configuration.h index 2d805a3e7..b5a717b6d 100644 --- a/Marlin/example_configurations/Hephestos_2/Configuration.h +++ b/Marlin/example_configurations/Hephestos_2/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -597,8 +598,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -735,35 +735,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -787,10 +761,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT -#define AUTO_BED_LEVELING_LINEAR +//#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -799,6 +785,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -819,11 +812,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -847,7 +835,42 @@ #define ABL_PROBE_PT_3_X ((X_MIN_POS + X_MAX_POS) / 2) #define ABL_PROBE_PT_3_Y Y_MAX_POS - (Y_PROBE_OFFSET_FROM_EXTRUDER) -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/K8200/Configuration.h b/Marlin/example_configurations/K8200/Configuration.h index e160c2d67..dfc6e9dc1 100644 --- a/Marlin/example_configurations/K8200/Configuration.h +++ b/Marlin/example_configurations/K8200/Configuration.h @@ -251,6 +251,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -632,8 +633,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -770,35 +770,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -822,10 +796,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -834,6 +820,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -854,11 +847,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -882,7 +870,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/K8400/Configuration.h b/Marlin/example_configurations/K8400/Configuration.h index 28738bd7a..90b944919 100644 --- a/Marlin/example_configurations/K8400/Configuration.h +++ b/Marlin/example_configurations/K8400/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -603,8 +604,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -741,35 +741,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -793,10 +767,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -805,6 +791,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -825,11 +818,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -853,7 +841,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/K8400/Dual-head/Configuration.h b/Marlin/example_configurations/K8400/Dual-head/Configuration.h index a70f637fc..ee8ad72d8 100644 --- a/Marlin/example_configurations/K8400/Dual-head/Configuration.h +++ b/Marlin/example_configurations/K8400/Dual-head/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -603,8 +604,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -741,35 +741,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -793,10 +767,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -805,6 +791,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -825,11 +818,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -853,7 +841,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h b/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h index f3fe5a604..2295b2200 100644 --- a/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h +++ b/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -603,8 +604,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -741,35 +741,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -793,10 +767,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -805,6 +791,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -825,11 +818,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -853,7 +841,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/RigidBot/Configuration.h b/Marlin/example_configurations/RigidBot/Configuration.h index ac65922db..c922d4a72 100644 --- a/Marlin/example_configurations/RigidBot/Configuration.h +++ b/Marlin/example_configurations/RigidBot/Configuration.h @@ -234,6 +234,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -602,8 +603,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -740,35 +740,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -792,10 +766,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -804,6 +790,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -824,11 +817,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -852,7 +840,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. @@ -1434,7 +1457,7 @@ // leaving it undefined or defining as 0 will disable the servo subsystem // If unsure, leave commented / disabled // -#define NUM_SERVOS 0 // DGlass3D - Servo index starts with 0 for M280 command +//#define NUM_SERVOS 3 // Servo index starts with 0 for M280 command // Delay (in milliseconds) before the next move will start, to give the servo time to reach its target angle. // 300ms is a good value but you can try less delay. diff --git a/Marlin/example_configurations/Roxys_printers/Folger_Tech_i3_2020/Configuration.h b/Marlin/example_configurations/Roxys_printers/Folger_Tech_i3_2020/Configuration.h new file mode 100644 index 000000000..39adcd2ab --- /dev/null +++ b/Marlin/example_configurations/Roxys_printers/Folger_Tech_i3_2020/Configuration.h @@ -0,0 +1,1503 @@ +/** + * 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 . + * + */ + +/** + * Configuration.h + * + * Basic settings such as: + * + * - Type of electronics + * - Type of temperature sensor + * - Printer geometry + * - Endstop configuration + * - LCD controller + * - Extra features + * + * Advanced settings can be found in Configuration_adv.h + * + */ +#ifndef CONFIGURATION_H +#define CONFIGURATION_H + +/** + * + * *********************************** + * ** ATTENTION TO ALL DEVELOPERS ** + * *********************************** + * + * You must increment this version number for every significant change such as, + * but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option. + * + * Note: Update also Version.h ! + */ +#define CONFIGURATION_H_VERSION 010100 + +//=========================================================================== +//============================= Getting Started ============================= +//=========================================================================== + +/** + * Here are some standard links for getting your machine calibrated: + * + * http://reprap.org/wiki/Calibration + * http://youtu.be/wAL9d7FgInk + * http://calculator.josefprusa.cz + * http://reprap.org/wiki/Triffid_Hunter%27s_Calibration_Guide + * http://www.thingiverse.com/thing:5573 + * https://sites.google.com/site/repraplogphase/calibration-of-your-reprap + * http://www.thingiverse.com/thing:298812 + */ + +//=========================================================================== +//============================= DELTA Printer =============================== +//=========================================================================== +// For a Delta printer replace the configuration files with the files in the +// example_configurations/delta directory. +// + +//=========================================================================== +//============================= SCARA Printer =============================== +//=========================================================================== +// For a Scara printer replace the configuration files with the files in the +// example_configurations/SCARA directory. +// + +// @section info + +// User-specified version info of this build to display in [Pronterface, etc] terminal window during +// startup. Implementation of an idea by Prof Braino to inform user that any changes made to this +// build by the user have been successfully uploaded into firmware. +#define STRING_CONFIG_H_AUTHOR "(none, default config)" // Who made the changes. +#define CUSTOM_MACHINE_NAME "UBL5.0 FT2020" +#define SHOW_BOOTSCREEN +#define STRING_SPLASH_LINE1 SHORT_BUILD_VERSION // will be shown during bootup in line 1 +#define STRING_SPLASH_LINE2 WEBSITE_URL // will be shown during bootup in line 2 + +// +// *** VENDORS PLEASE READ ***************************************************** +// +// Marlin now allow you to have a vendor boot image to be displayed on machine +// start. When SHOW_CUSTOM_BOOTSCREEN is defined Marlin will first show your +// custom boot image and then the default Marlin boot image is shown. +// +// We suggest for you to take advantage of this new feature and keep the Marlin +// boot image unmodified. For an example have a look at the bq Hephestos 2 +// example configuration folder. +// +//#define SHOW_CUSTOM_BOOTSCREEN +// @section machine + +/** + * Select which serial port on the board will be used for communication with the host. + * This allows the connection of wireless adapters (for instance) to non-default port pins. + * Serial port 0 is always used by the Arduino bootloader regardless of this setting. + * + * :[0, 1, 2, 3, 4, 5, 6, 7] + */ +#define SERIAL_PORT 0 + +/** + * This setting determines the communication speed of the printer. + * + * 250000 works in most cases, but you might try a lower speed if + * you commonly experience drop-outs during host printing. + * + * :[2400, 9600, 19200, 38400, 57600, 115200, 250000] + */ +#define BAUDRATE 250000 + +// Enable the Bluetooth serial interface on AT90USB devices +//#define BLUETOOTH + +// The following define selects which electronics board you have. +// Please choose the name from boards.h that matches your setup +#ifndef MOTHERBOARD + #define MOTHERBOARD BOARD_RAMPS_14_EFB +#endif + +// Optional custom name for your RepStrap or other custom machine +// Displayed in the LCD "Ready" message +//#define CUSTOM_MACHINE_NAME "3D Printer" + +// Define this to set a unique identifier for this printer, (Used by some programs to differentiate between machines) +// You can use an online service to generate a random UUID. (eg http://www.uuidgenerator.net/version4) +//#define MACHINE_UUID "00000000-0000-0000-0000-000000000000" + +// This defines the number of extruders +// :[1, 2, 3, 4] +#define EXTRUDERS 1 + +// Enable if your E steppers or extruder gear ratios are not identical +//#define DISTINCT_E_FACTORS + +// For Cyclops or any "multi-extruder" that shares a single nozzle. +//#define SINGLENOZZLE + +// A dual extruder that uses a single stepper motor +// Don't forget to set SSDE_SERVO_ANGLES and HOTEND_OFFSET_X/Y/Z +//#define SWITCHING_EXTRUDER +#if ENABLED(SWITCHING_EXTRUDER) + #define SWITCHING_EXTRUDER_SERVO_NR 0 + #define SWITCHING_EXTRUDER_SERVO_ANGLES { 0, 90 } // Angles for E0, E1 + //#define HOTEND_OFFSET_Z {0.0, 0.0} +#endif + +/** + * "Mixing Extruder" + * - Adds a new code, M165, to set the current mix factors. + * - Extends the stepping routines to move multiple steppers in proportion to the mix. + * - Optional support for Repetier Host M163, M164, and virtual extruder. + * - This implementation supports only a single extruder. + * - Enable DIRECT_MIXING_IN_G1 for Pia Taubert's reference implementation + */ +//#define MIXING_EXTRUDER +#if ENABLED(MIXING_EXTRUDER) + #define MIXING_STEPPERS 2 // Number of steppers in your mixing extruder + #define MIXING_VIRTUAL_TOOLS 16 // Use the Virtual Tool method with M163 and M164 + //#define DIRECT_MIXING_IN_G1 // Allow ABCDHI mix factors in G1 movement commands +#endif + +// Offset of the extruders (uncomment if using more than one and relying on firmware to position when changing). +// The offset has to be X=0, Y=0 for the extruder 0 hotend (default extruder). +// For the other hotends it is their distance from the extruder 0 hotend. +//#define HOTEND_OFFSET_X {0.0, 20.00} // (in mm) for each extruder, offset of the hotend on the X axis +//#define HOTEND_OFFSET_Y {0.0, 5.00} // (in mm) for each extruder, offset of the hotend on the Y axis + +/** + * Select your power supply here. Use 0 if you haven't connected the PS_ON_PIN + * + * 0 = No Power Switch + * 1 = ATX + * 2 = X-Box 360 203Watts (the blue wire connected to PS_ON and the red wire to VCC) + * + * :{ 0:'No power switch', 1:'ATX', 2:'X-Box 360' } + */ +#define POWER_SUPPLY 0 + +#if POWER_SUPPLY > 0 + // Enable this option to leave the PSU off at startup. + // Power to steppers and heaters will need to be turned on with M80. + //#define PS_DEFAULT_OFF +#endif + +// @section temperature + +//=========================================================================== +//============================= Thermal Settings ============================ +//=========================================================================== + +/** + * --NORMAL IS 4.7kohm PULLUP!-- 1kohm pullup can be used on hotend sensor, using correct resistor and table + * + * Temperature sensors available: + * + * -3 : thermocouple with MAX31855 (only for sensor 0) + * -2 : thermocouple with MAX6675 (only for sensor 0) + * -1 : thermocouple with AD595 + * 0 : not used + * 1 : 100k thermistor - best choice for EPCOS 100k (4.7k pullup) + * 2 : 200k thermistor - ATC Semitec 204GT-2 (4.7k pullup) + * 3 : Mendel-parts thermistor (4.7k pullup) + * 4 : 10k thermistor !! do not use it for a hotend. It gives bad resolution at high temp. !! + * 5 : 100K thermistor - ATC Semitec 104GT-2 (Used in ParCan & J-Head) (4.7k pullup) + * 6 : 100k EPCOS - Not as accurate as table 1 (created using a fluke thermocouple) (4.7k pullup) + * 7 : 100k Honeywell thermistor 135-104LAG-J01 (4.7k pullup) + * 71 : 100k Honeywell thermistor 135-104LAF-J01 (4.7k pullup) + * 8 : 100k 0603 SMD Vishay NTCS0603E3104FXT (4.7k pullup) + * 9 : 100k GE Sensing AL03006-58.2K-97-G1 (4.7k pullup) + * 10 : 100k RS thermistor 198-961 (4.7k pullup) + * 11 : 100k beta 3950 1% thermistor (4.7k pullup) + * 12 : 100k 0603 SMD Vishay NTCS0603E3104FXT (4.7k pullup) (calibrated for Makibox hot bed) + * 13 : 100k Hisens 3950 1% up to 300°C for hotend "Simple ONE " & "Hotend "All In ONE" + * 20 : the PT100 circuit found in the Ultimainboard V2.x + * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 + * 66 : 4.7M High Temperature thermistor from Dyze Design + * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad with NTC 100K MGB18-104F39050L32 thermistor + * + * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. + * (but gives greater accuracy and more stable PID) + * 51 : 100k thermistor - EPCOS (1k pullup) + * 52 : 200k thermistor - ATC Semitec 204GT-2 (1k pullup) + * 55 : 100k thermistor - ATC Semitec 104GT-2 (Used in ParCan & J-Head) (1k pullup) + * + * 1047 : Pt1000 with 4k7 pullup + * 1010 : Pt1000 with 1k pullup (non standard) + * 147 : Pt100 with 4k7 pullup + * 110 : Pt100 with 1k pullup (non standard) + * + * Use these for Testing or Development purposes. NEVER for production machine. + * 998 : Dummy Table that ALWAYS reads 25°C or the temperature defined below. + * 999 : Dummy Table that ALWAYS reads 100°C or the temperature defined below. + * + * :{ '0': "Not used", '1':"100k / 4.7k - EPCOS", '2':"200k / 4.7k - ATC Semitec 204GT-2", '3':"Mendel-parts / 4.7k", '4':"10k !! do not use for a hotend. Bad resolution at high temp. !!", '5':"100K / 4.7k - ATC Semitec 104GT-2 (Used in ParCan & J-Head)", '6':"100k / 4.7k EPCOS - Not as accurate as Table 1", '7':"100k / 4.7k Honeywell 135-104LAG-J01", '8':"100k / 4.7k 0603 SMD Vishay NTCS0603E3104FXT", '9':"100k / 4.7k GE Sensing AL03006-58.2K-97-G1", '10':"100k / 4.7k RS 198-961", '11':"100k / 4.7k beta 3950 1%", '12':"100k / 4.7k 0603 SMD Vishay NTCS0603E3104FXT (calibrated for Makibox hot bed)", '13':"100k Hisens 3950 1% up to 300°C for hotend 'Simple ONE ' & hotend 'All In ONE'", '20':"PT100 (Ultimainboard V2.x)", '51':"100k / 1k - EPCOS", '52':"200k / 1k - ATC Semitec 204GT-2", '55':"100k / 1k - ATC Semitec 104GT-2 (Used in ParCan & J-Head)", '60':"100k Maker's Tool Works Kapton Bed Thermistor beta=3950", '66':"Dyze Design 4.7M High Temperature thermistor", '70':"the 100K thermistor found in the bq Hephestos 2", '71':"100k / 4.7k Honeywell 135-104LAF-J01", '147':"Pt100 / 4.7k", '1047':"Pt1000 / 4.7k", '110':"Pt100 / 1k (non-standard)", '1010':"Pt1000 / 1k (non standard)", '-3':"Thermocouple + MAX31855 (only for sensor 0)", '-2':"Thermocouple + MAX6675 (only for sensor 0)", '-1':"Thermocouple + AD595",'998':"Dummy 1", '999':"Dummy 2" } + */ +#define TEMP_SENSOR_0 5 +#define TEMP_SENSOR_1 0 +#define TEMP_SENSOR_2 0 +#define TEMP_SENSOR_3 0 +#define TEMP_SENSOR_BED 1 + +// Dummy thermistor constant temperature readings, for use with 998 and 999 +#define DUMMY_THERMISTOR_998_VALUE 25 +#define DUMMY_THERMISTOR_999_VALUE 100 + +// Use temp sensor 1 as a redundant sensor with sensor 0. If the readings +// from the two sensors differ too much the print will be aborted. +//#define TEMP_SENSOR_1_AS_REDUNDANT +#define MAX_REDUNDANT_TEMP_SENSOR_DIFF 10 + +// Extruder temperature must be close to target for this long before M109 returns success +#define TEMP_RESIDENCY_TIME 10 // (seconds) +#define TEMP_HYSTERESIS 3 // (degC) range of +/- temperatures considered "close" to the target one +#define TEMP_WINDOW 1 // (degC) Window around target to start the residency timer x degC early. + +// Bed temperature must be close to target for this long before M190 returns success +#define TEMP_BED_RESIDENCY_TIME 10 // (seconds) +#define TEMP_BED_HYSTERESIS 3 // (degC) range of +/- temperatures considered "close" to the target one +#define TEMP_BED_WINDOW 1 // (degC) Window around target to start the residency timer x degC early. + +// The minimal temperature defines the temperature below which the heater will not be enabled It is used +// to check that the wiring to the thermistor is not broken. +// Otherwise this would lead to the heater being powered on all the time. +#define HEATER_0_MINTEMP 5 +#define HEATER_1_MINTEMP 5 +#define HEATER_2_MINTEMP 5 +#define HEATER_3_MINTEMP 5 +#define BED_MINTEMP 5 + +// When temperature exceeds max temp, your heater will be switched off. +// This feature exists to protect your hotend from overheating accidentally, but *NOT* from thermistor short/failure! +// You should use MINTEMP for thermistor short/failure protection. +#define HEATER_0_MAXTEMP 245 +#define HEATER_1_MAXTEMP 245 +#define HEATER_2_MAXTEMP 245 +#define HEATER_3_MAXTEMP 245 +#define BED_MAXTEMP 115 + +//=========================================================================== +//============================= PID Settings ================================ +//=========================================================================== +// PID Tuning Guide here: http://reprap.org/wiki/PID_Tuning + +// Comment the following line to disable PID and enable bang-bang. +#define PIDTEMP +#define BANG_MAX 255 // limits current to nozzle while in bang-bang mode; 255=full current +#define PID_MAX BANG_MAX // limits current to nozzle while PID is active (see PID_FUNCTIONAL_RANGE below); 255=full current +#if ENABLED(PIDTEMP) + //#define PID_AUTOTUNE_MENU // Add PID Autotune to the LCD "Temperature" menu to run M303 and apply the result. + //#define PID_DEBUG // Sends debug data to the serial port. + //#define PID_OPENLOOP 1 // Puts PID in open loop. M104/M140 sets the output power from 0 to PID_MAX + //#define SLOW_PWM_HEATERS // PWM with very low frequency (roughly 0.125Hz=8s) and minimum state time of approximately 1s useful for heaters driven by a relay + //#define PID_PARAMS_PER_HOTEND // Uses separate PID parameters for each extruder (useful for mismatched extruders) + // Set/get with gcode: M301 E[extruder number, 0-2] + #define PID_FUNCTIONAL_RANGE 10 // If the temperature difference between the target temperature and the actual temperature + // is more than PID_FUNCTIONAL_RANGE then the PID will be shut off and the heater will be set to min/max. + #define K1 0.95 //smoothing factor within the PID + + // If you are using a pre-configured hotend then you can use one of the value sets by uncommenting it + // Ultimaker + #define DEFAULT_Kp 11.50 + #define DEFAULT_Ki 0.50 + #define DEFAULT_Kd 60.00 + + // MakerGear + //#define DEFAULT_Kp 7.0 + //#define DEFAULT_Ki 0.1 + //#define DEFAULT_Kd 12 + + // Mendel Parts V9 on 12V + //#define DEFAULT_Kp 63.0 + //#define DEFAULT_Ki 2.25 + //#define DEFAULT_Kd 440 + +#endif // PIDTEMP + +//=========================================================================== +//============================= PID > Bed Temperature Control =============== +//=========================================================================== +// Select PID or bang-bang with PIDTEMPBED. If bang-bang, BED_LIMIT_SWITCHING will enable hysteresis +// +// Uncomment this to enable PID on the bed. It uses the same frequency PWM as the extruder. +// If your PID_dT is the default, and correct for your hardware/configuration, that means 7.689Hz, +// which is fine for driving a square wave into a resistive load and does not significantly impact you FET heating. +// This also works fine on a Fotek SSR-10DA Solid State Relay into a 250W heater. +// If your configuration is significantly different than this and you don't understand the issues involved, you probably +// shouldn't use bed PID until someone else verifies your hardware works. +// If this is enabled, find your own PID constants below. +#define PIDTEMPBED + +//#define BED_LIMIT_SWITCHING + +// This sets the max power delivered to the bed, and replaces the HEATER_BED_DUTY_CYCLE_DIVIDER option. +// all forms of bed control obey this (PID, bang-bang, bang-bang with hysteresis) +// setting this to anything other than 255 enables a form of PWM to the bed just like HEATER_BED_DUTY_CYCLE_DIVIDER did, +// so you shouldn't use it unless you are OK with PWM on your bed. (see the comment on enabling PIDTEMPBED) +#define MAX_BED_POWER 255 // limits duty cycle to bed; 255=full current + +#if ENABLED(PIDTEMPBED) + + //#define PID_BED_DEBUG // Sends debug data to the serial port. + + //120V 250W silicone heater into 4mm borosilicate (MendelMax 1.5+) + //from FOPDT model - kp=.39 Tp=405 Tdead=66, Tc set to 79.2, aggressive factor of .15 (vs .1, 1, 10) + #define DEFAULT_bedKp 250.0 + #define DEFAULT_bedKi 18.0 + #define DEFAULT_bedKd 950.0 + + //120V 250W silicone heater into 4mm borosilicate (MendelMax 1.5+) + //from pidautotune + //#define DEFAULT_bedKp 97.1 + //#define DEFAULT_bedKi 1.41 + //#define DEFAULT_bedKd 1675.16 + + // FIND YOUR OWN: "M303 E-1 C8 S90" to run autotune on the bed at 90 degreesC for 8 cycles. +#endif // PIDTEMPBED + +// @section extruder + +// This option prevents extrusion if the temperature is below EXTRUDE_MINTEMP. +// It also enables the M302 command to set the minimum extrusion temperature +// or to allow moving the extruder regardless of the hotend temperature. +// *** IT IS HIGHLY RECOMMENDED TO LEAVE THIS OPTION ENABLED! *** +#define PREVENT_COLD_EXTRUSION +#define EXTRUDE_MINTEMP 170 + +// This option prevents a single extrusion longer than EXTRUDE_MAXLENGTH. +// Note that for Bowden Extruders a too-small value here may prevent loading. +#define PREVENT_LENGTHY_EXTRUDE +#define EXTRUDE_MAXLENGTH 200 + +//=========================================================================== +//======================== Thermal Runaway Protection ======================= +//=========================================================================== + +/** + * Thermal Protection protects your printer from damage and fire if a + * thermistor falls out or temperature sensors fail in any way. + * + * The issue: If a thermistor falls out or a temperature sensor fails, + * Marlin can no longer sense the actual temperature. Since a disconnected + * thermistor reads as a low temperature, the firmware will keep the heater on. + * + * If you get "Thermal Runaway" or "Heating failed" errors the + * details can be tuned in Configuration_adv.h + */ + +#define THERMAL_PROTECTION_HOTENDS // Enable thermal protection for all extruders +#define THERMAL_PROTECTION_BED // Enable thermal protection for the heated bed + +//=========================================================================== +//============================= Mechanical Settings ========================= +//=========================================================================== + +// @section machine + +// Uncomment one of these options to enable CoreXY, CoreXZ, or CoreYZ kinematics +// either in the usual order or reversed +//#define COREXY +//#define COREXZ +//#define COREYZ +//#define COREYX +//#define COREZX +//#define COREZY + +// Enable this option for Toshiba steppers +//#define CONFIG_STEPPERS_TOSHIBA + +//=========================================================================== +//============================== Endstop Settings =========================== +//=========================================================================== + +// @section homing + +// Specify here all the endstop connectors that are connected to any endstop or probe. +// Almost all printers will be using one per axis. Probes will use one or more of the +// extra connectors. Leave undefined any used for non-endstop and non-probe purposes. +#define USE_XMIN_PLUG +#define USE_YMIN_PLUG +#define USE_ZMIN_PLUG +//#define USE_XMAX_PLUG +//#define USE_YMAX_PLUG +//#define USE_ZMAX_PLUG + +// coarse Endstop Settings +#define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors + +#if DISABLED(ENDSTOPPULLUPS) + // fine endstop settings: Individual pullups. will be ignored if ENDSTOPPULLUPS is defined + //#define ENDSTOPPULLUP_XMAX + //#define ENDSTOPPULLUP_YMAX + //#define ENDSTOPPULLUP_ZMAX + //#define ENDSTOPPULLUP_XMIN + //#define ENDSTOPPULLUP_YMIN + //#define ENDSTOPPULLUP_ZMIN + //#define ENDSTOPPULLUP_ZMIN_PROBE +#endif + +// Mechanical endstop with COM to ground and NC to Signal uses "false" here (most common setup). +#define X_MIN_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. +#define Y_MIN_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. +#define Z_MIN_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. +#define X_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Y_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Z_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Z_MIN_PROBE_ENDSTOP_INVERTING true // set to true to invert the logic of the probe. + +// Enable this feature if all enabled endstop pins are interrupt-capable. +// This will remove the need to poll the interrupt pins, saving many CPU cycles. +//#define ENDSTOP_INTERRUPTS_FEATURE + +//============================================================================= +//============================== Movement Settings ============================ +//============================================================================= +// @section motion + +/** + * Default Settings + * + * These settings can be reset by M502 + * + * You can set distinct factors for each E stepper, if needed. + * If fewer factors are given, the last will apply to the rest. + * + * Note that if EEPROM is enabled, saved values will override these. + */ + +/** + * Default Axis Steps Per Unit (steps/mm) + * Override with M92 + * X, Y, Z, E0 [, E1[, E2[, E3]]] + */ +#define DEFAULT_AXIS_STEPS_PER_UNIT { 80, 80, 4000, 52.2 } + +/** + * Default Max Feed Rate (mm/s) + * Override with M203 + * X, Y, Z, E0 [, E1[, E2[, E3]]] + */ +#define DEFAULT_MAX_FEEDRATE { 250, 250, 2, 17 } + +/** + * Default Max Acceleration (change/s) change = mm/s + * (Maximum start speed for accelerated moves) + * Override with M201 + * X, Y, Z, E0 [, E1[, E2[, E3]]] + */ +#define DEFAULT_MAX_ACCELERATION { 1000, 1000, 4, 750 } + + +/** + * Default Acceleration (change/s) change = mm/s + * Override with M204 + * + * M204 P Acceleration + * M204 R Retract Acceleration + * M204 T Travel Acceleration + */ +#define DEFAULT_ACCELERATION 500 // X, Y, Z and E acceleration for printing moves +#define DEFAULT_RETRACT_ACCELERATION 400 // E acceleration for retracts +#define DEFAULT_TRAVEL_ACCELERATION 400 // X, Y, Z acceleration for travel (non printing) moves + +/** + * Default Jerk (mm/s) + * Override with M205 X Y Z E + * + * "Jerk" specifies the minimum speed change that requires acceleration. + * When changing speed and direction, if the difference is less than the + * value set here, it may happen instantaneously. + */ +#define DEFAULT_XJERK 17.0 +#define DEFAULT_YJERK 17.0 +#define DEFAULT_ZJERK 0.4 +#define DEFAULT_EJERK 4.0 + + +//=========================================================================== +//============================= Z Probe Options ============================= +//=========================================================================== +// @section probes + +// +// Probe Type +// Probes are sensors/switches that are activated / deactivated before/after use. +// +// Allen Key Probes, Servo Probes, Z-Sled Probes, FIX_MOUNTED_PROBE, etc. +// You must activate one of these to use Auto Bed Leveling below. +// +// Use M851 to set the Z probe vertical offset from the nozzle. Store with M500. +// + +// A Fix-Mounted Probe either doesn't deploy or needs manual deployment. +// For example an inductive probe, or a setup that uses the nozzle to probe. +// An inductive probe must be deactivated to go below +// its trigger-point if hardware endstops are active. +//#define FIX_MOUNTED_PROBE + +// The BLTouch probe emulates a servo probe. +// The default connector is SERVO 0. Set Z_ENDSTOP_SERVO_NR below to override. +//#define BLTOUCH + +// Z Servo Probe, such as an endstop switch on a rotating arm. +#define Z_ENDSTOP_SERVO_NR 0 +#define Z_SERVO_ANGLES {40,85} // Z Servo Deploy and Stow angles + +// Enable if you have a Z probe mounted on a sled like those designed by Charles Bell. +//#define Z_PROBE_SLED +//#define SLED_DOCKING_OFFSET 5 // The extra distance the X axis must travel to pickup the sled. 0 should be fine but you can push it further if you'd like. + +// Z Probe to nozzle (X,Y) offset, relative to (0, 0). +// X and Y offsets must be integers. +// +// In the following example the X and Y offsets are both positive: +// #define X_PROBE_OFFSET_FROM_EXTRUDER 10 +// #define Y_PROBE_OFFSET_FROM_EXTRUDER 10 +// +// +-- BACK ---+ +// | | +// L | (+) P | R <-- probe (20,20) +// E | | I +// F | (-) N (+) | G <-- nozzle (10,10) +// T | | H +// | (-) | T +// | | +// O-- FRONT --+ +// (0,0) +#define X_PROBE_OFFSET_FROM_EXTRUDER 38 // X offset: -left +right [of the nozzle] +#define Y_PROBE_OFFSET_FROM_EXTRUDER -7 // Y offset: -front +behind [the nozzle] +#define Z_PROBE_OFFSET_FROM_EXTRUDER -9.65 // Z offset: -below +above [the nozzle] + +// X and Y axis travel speed (mm/m) between probes +#define XY_PROBE_SPEED 7500 +// Speed for the first approach when double-probing (with PROBE_DOUBLE_TOUCH) +#define Z_PROBE_SPEED_FAST HOMING_FEEDRATE_Z +// Speed for the "accurate" probe of each point +#define Z_PROBE_SPEED_SLOW (Z_PROBE_SPEED_FAST / 2) +// Use double touch for probing +//#define PROBE_DOUBLE_TOUCH + +// +// Allen Key Probe is defined in the Delta example configurations. +// + +// *** PLEASE READ ALL INSTRUCTIONS BELOW FOR SAFETY! *** +// +// To continue using the Z-min-endstop for homing, be sure to disable Z_SAFE_HOMING. +// Example: To park the head outside the bed area when homing with G28. +// +// To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. +// +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. +// +// - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. +// - Use 5V for powered (usu. inductive) sensors. +// - Otherwise connect: +// - normally-closed switches to GND and D32. +// - normally-open switches to 5V and D32. +// +// Normally-closed switches are advised and are the default. +// + +// +// The Z_MIN_PROBE_PIN sets the Arduino pin to use. (See your board's pins file.) +// Since the RAMPS Aux4->D32 pin maps directly to the Arduino D32 pin, D32 is the +// default pin for all RAMPS-based boards. Most boards use the X_MAX_PIN by default. +// To use a different pin you can override it here. +// +// WARNING: +// Setting the wrong pin may have unexpected and potentially disastrous consequences. +// Use with caution and do your homework. +// +//#define Z_MIN_PROBE_PIN X_MAX_PIN + +// +// Enable Z_MIN_PROBE_ENDSTOP to use _both_ a Z Probe and a Z-min-endstop on the same machine. +// With this option the Z_MIN_PROBE_PIN will only be used for probing, never for homing. +// +//#define Z_MIN_PROBE_ENDSTOP + +// Enable Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN to use the Z_MIN_PIN for your Z_MIN_PROBE. +// The Z_MIN_PIN will then be used for both Z-homing and probing. +#define Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN + +// To use a probe you must enable one of the two options above! + +// Enable Z Probe Repeatability test to see how accurate your probe is +#define Z_MIN_PROBE_REPEATABILITY_TEST + +/** + * Z probes require clearance when deploying, stowing, and moving between + * probe points to avoid hitting the bed and other hardware. + * Servo-mounted probes require extra space for the arm to rotate. + * Inductive probes need space to keep from triggering early. + * + * Use these settings to specify the distance (mm) to raise the probe (or + * lower the bed). The values set here apply over and above any (negative) + * probe Z Offset set with Z_PROBE_OFFSET_FROM_EXTRUDER, M851, or the LCD. + * Only integer values >= 1 are valid here. + * + * Example: `M851 Z-5` with a CLEARANCE of 4 => 9mm from bed to nozzle. + * But: `M851 Z+1` with a CLEARANCE of 2 => 2mm from bed to nozzle. + */ +#define Z_CLEARANCE_DEPLOY_PROBE 3 // Z Clearance for Deploy/Stow +#define Z_CLEARANCE_BETWEEN_PROBES 3 // Z Clearance between probe points + +// +// For M851 give a range for adjusting the Z probe offset +// +#define Z_PROBE_OFFSET_RANGE_MIN -20 +#define Z_PROBE_OFFSET_RANGE_MAX 20 + +// For Inverting Stepper Enable Pins (Active Low) use 0, Non Inverting (Active High) use 1 +// :{ 0:'Low', 1:'High' } +#define X_ENABLE_ON 0 +#define Y_ENABLE_ON 0 +#define Z_ENABLE_ON 0 +#define E_ENABLE_ON 0 // For all extruders + +// Disables axis stepper immediately when it's not being used. +// WARNING: When motors turn off there is a chance of losing position accuracy! +#define DISABLE_X false +#define DISABLE_Y false +#define DISABLE_Z false +// Warn on display about possibly reduced accuracy +//#define DISABLE_REDUCED_ACCURACY_WARNING + +// @section extruder + +#define DISABLE_E false // For all extruders +#define DISABLE_INACTIVE_EXTRUDER true //disable only inactive extruders and keep active extruder enabled + +// @section machine + +// Invert the stepper direction. Change (or reverse the motor connector) if an axis goes the wrong way. +#define INVERT_X_DIR false +#define INVERT_Y_DIR true +#define INVERT_Z_DIR true + +// @section extruder + +// For direct drive extruder v9 set to true, for geared extruder set to false. +#define INVERT_E0_DIR true +#define INVERT_E1_DIR false +#define INVERT_E2_DIR false +#define INVERT_E3_DIR false + +// @section homing + +#define Z_HOMING_HEIGHT 2 // (in mm) Minimal z height before homing (G28) for Z clearance above the bed, clamps, ... + // Be sure you have this distance over your Z_MAX_POS in case. + +// Direction of endstops when homing; 1=MAX, -1=MIN +// :[-1,1] +#define X_HOME_DIR -1 +#define Y_HOME_DIR -1 +#define Z_HOME_DIR -1 + +// @section machine + +// Travel limits after homing (units are in mm) +#define X_MIN_POS 0 +#define Y_MIN_POS 0 +#define Z_MIN_POS 0 +#define X_MAX_POS 203 +#define Y_MAX_POS 180 +#define Z_MAX_POS 175 + +// If enabled, axes won't move below MIN_POS in response to movement commands. +//#define MIN_SOFTWARE_ENDSTOPS +// If enabled, axes won't move above MAX_POS in response to movement commands. +#define MAX_SOFTWARE_ENDSTOPS + +/** + * Filament Runout Sensor + * A mechanical or opto endstop is used to check for the presence of filament. + * + * RAMPS-based boards use SERVO3_PIN. + * For other boards you may need to define FIL_RUNOUT_PIN. + * By default the firmware assumes HIGH = has filament, LOW = ran out + */ +//#define FILAMENT_RUNOUT_SENSOR +#if ENABLED(FILAMENT_RUNOUT_SENSOR) + #define FIL_RUNOUT_INVERTING false // set to true to invert the logic of the sensor. + #define ENDSTOPPULLUP_FIL_RUNOUT // Uncomment to use internal pullup for filament runout pins if the sensor is defined. + #define FILAMENT_RUNOUT_SCRIPT "M600" +#endif + +//=========================================================================== +//=============================== Bed Leveling ============================== +//=========================================================================== +// @section bedlevel + +/** + * Select one form of Auto Bed Leveling below. + * + * If you're also using the Probe for Z Homing, it's + * highly recommended to enable Z_SAFE_HOMING also! + * + * - 3POINT + * Probe 3 arbitrary points on the bed (that aren't collinear) + * You specify the XY coordinates of all 3 points. + * The result is a single tilted plane. Best for a flat bed. + * + * - LINEAR + * Probe several points in a grid. + * You specify the rectangle and the density of sample points. + * The result is a single tilted plane. Best for a flat bed. + * + * - BILINEAR + * Probe several points in a grid. + * You specify the rectangle and the density of sample points. + * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. + */ +//#define AUTO_BED_LEVELING_3POINT +//#define AUTO_BED_LEVELING_LINEAR +//#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL + + +/** + * Enable detailed logging of G28, G29, M48, etc. + * Turn on with the command 'M111 S32'. + * NOTE: Requires a lot of PROGMEM! + */ +//#define DEBUG_LEVELING_FEATURE + +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + +#if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) + + // Set the number of grid points per dimension. + #define ABL_GRID_MAX_POINTS_X 3 + #define ABL_GRID_MAX_POINTS_Y ABL_GRID_MAX_POINTS_X + + // Set the boundaries for probing (where the probe can reach). + #define LEFT_PROBE_BED_POSITION 39 + #define RIGHT_PROBE_BED_POSITION 170 + #define FRONT_PROBE_BED_POSITION 10 + #define BACK_PROBE_BED_POSITION 170 + + // The Z probe minimum outer margin (to validate G29 parameters). + #define MIN_PROBE_EDGE 10 + + // Probe along the Y axis, advancing X after each column + //#define PROBE_Y_FIRST + + #if ENABLED(AUTO_BED_LEVELING_BILINEAR) + + // + // Experimental Subdivision of the grid by Catmull-Rom method. + // Synthesizes intermediate points to produce a more detailed mesh. + // + //#define ABL_BILINEAR_SUBDIVISION + #if ENABLED(ABL_BILINEAR_SUBDIVISION) + // Number of subdivisions between probe points + #define BILINEAR_SUBDIVISIONS 3 + #endif + + #endif + +#elif ENABLED(AUTO_BED_LEVELING_3POINT) + + // 3 arbitrary points to probe. + // A simple cross-product is used to estimate the plane of the bed. + #define ABL_PROBE_PT_1_X 39 + #define ABL_PROBE_PT_1_Y 170 + #define ABL_PROBE_PT_2_X 39 + #define ABL_PROBE_PT_2_Y 10 + #define ABL_PROBE_PT_3_X 170 + #define ABL_PROBE_PT_3_Y 10 + +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING + +/** + * Commands to execute at the end of G29 probing. + * Useful to retract or move the Z probe out of the way. + */ +//#define Z_PROBE_END_SCRIPT "G1 Z10 F12000\nG1 X15 Y330\nG1 Z0.5\nG1 Z10" + + +// @section homing + +// The center of the bed is at (X=0, Y=0) +//#define BED_CENTER_AT_0_0 + +// Manually set the home position. Leave these undefined for automatic settings. +// For DELTA this is the top-center of the Cartesian print volume. +#define MANUAL_X_HOME_POS 100 +#define MANUAL_Y_HOME_POS 100 +#define MANUAL_Z_HOME_POS 20 + +// Use "Z Safe Homing" to avoid homing with a Z probe outside the bed area. +// +// With this feature enabled: +// +// - Allow Z homing only after X and Y homing AND stepper drivers still enabled. +// - If stepper drivers time out, it will need X and Y homing again before Z homing. +// - Move the Z probe (or nozzle) to a defined XY point before Z Homing when homing all axes (G28). +// - Prevent Z homing when the Z probe is outside bed area. +#define Z_SAFE_HOMING + +#if ENABLED(Z_SAFE_HOMING) + #define Z_SAFE_HOMING_X_POINT ((X_MIN_POS + X_MAX_POS) / 2) // X point for Z homing when homing all axis (G28). + #define Z_SAFE_HOMING_Y_POINT ((Y_MIN_POS + Y_MAX_POS) / 2) // Y point for Z homing when homing all axis (G28). +#endif + +// Homing speeds (mm/m) +#define HOMING_FEEDRATE_XY (40*60) +#define HOMING_FEEDRATE_Z (55) + +//============================================================================= +//============================= Additional Features =========================== +//============================================================================= + +// @section extras + +// +// EEPROM +// +// The microcontroller can store settings in the EEPROM, e.g. max velocity... +// M500 - stores parameters in EEPROM +// M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily). +// M502 - reverts to the default "factory settings". You still need to store them in EEPROM afterwards if you want to. +//define this to enable EEPROM support +#define EEPROM_SETTINGS + +#if ENABLED(EEPROM_SETTINGS) + // To disable EEPROM Serial responses and decrease program space by ~1700 byte: comment this out: + #define EEPROM_CHITCHAT // Please keep turned on if you can. +#endif + +// +// Host Keepalive +// +// When enabled Marlin will send a busy status message to the host +// every couple of seconds when it can't accept commands. +// +//#define HOST_KEEPALIVE_FEATURE // Disable this if your host doesn't like keepalive messages +#define DEFAULT_KEEPALIVE_INTERVAL 2 // Number of seconds between "busy" messages. Set with M113. + +// +// M100 Free Memory Watcher +// +#define M100_FREE_MEMORY_WATCHER // uncomment to add the M100 Free Memory Watcher for debug purpose + +// +// G20/G21 Inch mode support +// +//#define INCH_MODE_SUPPORT + +// +// M149 Set temperature units support +// +//#define TEMPERATURE_UNITS_SUPPORT + +// @section temperature + +// Preheat Constants +#define PREHEAT_1_TEMP_HOTEND 180 +#define PREHEAT_1_TEMP_BED 70 +#define PREHEAT_1_FAN_SPEED 0 // Value from 0 to 255 + +#define PREHEAT_2_TEMP_HOTEND 240 +#define PREHEAT_2_TEMP_BED 110 +#define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255 + +// +// Nozzle Park -- EXPERIMENTAL +// +// When enabled allows the user to define a special XYZ position, inside the +// machine's topology, to park the nozzle when idle or when receiving the G27 +// command. +// +// The "P" paramenter controls what is the action applied to the Z axis: +// P0: (Default) If current Z-pos is lower than Z-park then the nozzle will +// be raised to reach Z-park height. +// +// P1: No matter the current Z-pos, the nozzle will be raised/lowered to +// reach Z-park height. +// +// P2: The nozzle height will be raised by Z-park amount but never going over +// the machine's limit of Z_MAX_POS. +// +//#define NOZZLE_PARK_FEATURE + +#if ENABLED(NOZZLE_PARK_FEATURE) + // Specify a park position as { X, Y, Z } + #define NOZZLE_PARK_POINT { (X_MIN_POS + 10), (Y_MAX_POS - 10), 20 } +#endif + +// +// 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. S defines "strokes" i.e. +// back-and-forth movements between the starting and end points. +// +// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T" +// defines the number of zig-zag triangles to be done. "S" defines the +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, +// sending "G12 P1 S1 T3" will execute: +// +// -- +// | (X0, Y1) | /\ /\ /\ | (X1, Y1) +// | | / \ / \ / \ | +// A | | / \ / \ / \ | +// | | / \ / \ / \ | +// | (X0, Y0) | / \/ \/ \ | (X1, Y0) +// -- +--------------------------------+ +// |________|_________|_________| +// T1 T2 T3 +// +// P2: This starts a circular pattern with circle with middle in +// NOZZLE_CLEAN_CIRCLE_MIDDLE radius of R and stroke count of S. +// Before starting the circle nozzle goes to NOZZLE_CLEAN_START_POINT. +// +// 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) + // Default number of pattern repetitions + #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 + + // Specify positions as { X, Y, Z } + #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} + #define NOZZLE_CLEAN_END_POINT {100, 60, (Z_MIN_POS + 1)} + + // Circular pattern radius + #define NOZZLE_CLEAN_CIRCLE_RADIUS 6.5 + // Circular pattern circle fragments number + #define NOZZLE_CLEAN_CIRCLE_FN 10 + // Middle point of circle + #define NOZZLE_CLEAN_CIRCLE_MIDDLE NOZZLE_CLEAN_START_POINT + + // Moves the nozzle to the initial position + #define NOZZLE_CLEAN_GOBACK +#endif + +// +// Print job timer +// +// Enable this option to automatically start and stop the +// print job timer when M104/M109/M190 commands are received. +// M104 (extruder without wait) - high temp = none, low temp = stop timer +// M109 (extruder with wait) - high temp = start timer, low temp = stop timer +// M190 (bed with wait) - high temp = start timer, low temp = none +// +// In all cases the timer can be started and stopped using +// the following commands: +// +// - M75 - Start the print job timer +// - M76 - Pause the print job timer +// - M77 - Stop the print job timer +#define PRINTJOB_TIMER_AUTOSTART + +// +// Print Counter +// +// When enabled Marlin will keep track of some print statistical data such as: +// - Total print jobs +// - Total successful print jobs +// - Total failed print jobs +// - Total time printing +// +// This information can be viewed by the M78 command. +//#define PRINTCOUNTER + +//============================================================================= +//============================= LCD and SD support ============================ +//============================================================================= + +// @section lcd + +// +// LCD LANGUAGE +// +// Here you may choose the language used by Marlin on the LCD menus, the following +// list of languages are available: +// en, an, bg, ca, cn, cz, de, el, el-gr, es, eu, fi, fr, gl, hr, it, +// kana, kana_utf8, nl, pl, pt, pt_utf8, pt-br, pt-br_utf8, ru, tr, uk, test +// +// :{ 'en':'English', 'an':'Aragonese', 'bg':'Bulgarian', 'ca':'Catalan', 'cn':'Chinese', 'cz':'Czech', 'de':'German', 'el':'Greek', 'el-gr':'Greek (Greece)', 'es':'Spanish', 'eu':'Basque-Euskera', 'fi':'Finnish', 'fr':'French', 'gl':'Galician', 'hr':'Croatian', 'it':'Italian', 'kana':'Japanese', 'kana_utf8':'Japanese (UTF8)', 'nl':'Dutch', 'pl':'Polish', 'pt':'Portuguese', 'pt-br':'Portuguese (Brazilian)', 'pt-br_utf8':'Portuguese (Brazilian UTF8)', 'pt_utf8':'Portuguese (UTF8)', 'ru':'Russian', 'tr':'Turkish', 'uk':'Ukrainian', 'test':'TEST' } +// +#define LCD_LANGUAGE en + +// +// LCD Character Set +// +// Note: This option is NOT applicable to Graphical Displays. +// +// All character-based LCD's provide ASCII plus one of these +// language extensions: +// +// - JAPANESE ... the most common +// - WESTERN ... with more accented characters +// - CYRILLIC ... for the Russian language +// +// To determine the language extension installed on your controller: +// +// - Compile and upload with LCD_LANGUAGE set to 'test' +// - Click the controller to view the LCD menu +// - The LCD will display Japanese, Western, or Cyrillic text +// +// See https://github.com/MarlinFirmware/Marlin/wiki/LCD-Language +// +// :['JAPANESE', 'WESTERN', 'CYRILLIC'] +// +#define DISPLAY_CHARSET_HD44780 JAPANESE + +// +// LCD TYPE +// +// You may choose ULTRA_LCD if you have character based LCD with 16x2, 16x4, 20x2, +// 20x4 char/lines or DOGLCD for the full graphics display with 128x64 pixels +// (ST7565R family). (This option will be set automatically for certain displays.) +// +// IMPORTANT NOTE: The U8glib library is required for Full Graphic Display! +// https://github.com/olikraus/U8glib_Arduino +// +//#define ULTRA_LCD // Character based +//#define DOGLCD // Full graphics display + +// +// SD CARD +// +// SD Card support is disabled by default. If your controller has an SD slot, +// you must uncomment the following option or it won't work. +// +//#define SDSUPPORT + +// +// SD CARD: SPI SPEED +// +// Uncomment ONE of the following items to use a slower SPI transfer +// speed. This is usually required if you're getting volume init errors. +// +//#define SPI_SPEED SPI_HALF_SPEED +//#define SPI_SPEED SPI_QUARTER_SPEED +//#define SPI_SPEED SPI_EIGHTH_SPEED + +// +// SD CARD: ENABLE CRC +// +// Use CRC checks and retries on the SD communication. +// +//#define SD_CHECK_AND_RETRY + +// +// ENCODER SETTINGS +// +// This option overrides the default number of encoder pulses needed to +// produce one step. Should be increased for high-resolution encoders. +// +//#define ENCODER_PULSES_PER_STEP 1 + +// +// Use this option to override the number of step signals required to +// move between next/prev menu items. +// +//#define ENCODER_STEPS_PER_MENU_ITEM 5 + +/** + * Encoder Direction Options + * + * Test your encoder's behavior first with both options disabled. + * + * Reversed Value Edit and Menu Nav? Enable REVERSE_ENCODER_DIRECTION. + * Reversed Menu Navigation only? Enable REVERSE_MENU_DIRECTION. + * Reversed Value Editing only? Enable BOTH options. + */ + +// +// This option reverses the encoder direction everywhere +// +// Set this option if CLOCKWISE causes values to DECREASE +// +//#define REVERSE_ENCODER_DIRECTION + +// +// This option reverses the encoder direction for navigating LCD menus. +// +// If CLOCKWISE normally moves DOWN this makes it go UP. +// If CLOCKWISE normally moves UP this makes it go DOWN. +// +#define REVERSE_MENU_DIRECTION + +// +// Individual Axis Homing +// +// Add individual axis homing items (Home X, Home Y, and Home Z) to the LCD menu. +// +//#define INDIVIDUAL_AXIS_HOMING_MENU + +// +// SPEAKER/BUZZER +// +// If you have a speaker that can produce tones, enable it here. +// By default Marlin assumes you have a buzzer with a fixed frequency. +// +//#define SPEAKER + +// +// The duration and frequency for the UI feedback sound. +// Set these to 0 to disable audio feedback in the LCD menus. +// +// Note: Test audio output with the G-Code: +// M300 S P +// +//#define LCD_FEEDBACK_FREQUENCY_DURATION_MS 100 +//#define LCD_FEEDBACK_FREQUENCY_HZ 1000 + +// +// CONTROLLER TYPE: Standard +// +// Marlin supports a wide variety of controllers. +// Enable one of the following options to specify your controller. +// + +// +// ULTIMAKER Controller. +// +//#define ULTIMAKERCONTROLLER + +// +// ULTIPANEL as seen on Thingiverse. +// +//#define ULTIPANEL + +// +// Cartesio UI +// http://mauk.cc/webshop/cartesio-shop/electronics/user-interface +// +//#define CARTESIO_UI + +// +// PanelOne from T3P3 (via RAMPS 1.4 AUX2/AUX3) +// http://reprap.org/wiki/PanelOne +// +//#define PANEL_ONE + +// +// MaKr3d Makr-Panel with graphic controller and SD support. +// http://reprap.org/wiki/MaKr3d_MaKrPanel +// +//#define MAKRPANEL + +// +// ReprapWorld Graphical LCD +// https://reprapworld.com/?products_details&products_id/1218 +// +//#define REPRAPWORLD_GRAPHICAL_LCD + +// +// Activate one of these if you have a Panucatt Devices +// Viki 2.0 or mini Viki with Graphic LCD +// http://panucatt.com +// +//#define VIKI2 +//#define miniVIKI + +// +// Adafruit ST7565 Full Graphic Controller. +// https://github.com/eboston/Adafruit-ST7565-Full-Graphic-Controller/ +// +//#define ELB_FULL_GRAPHIC_CONTROLLER + +// +// RepRapDiscount Smart Controller. +// http://reprap.org/wiki/RepRapDiscount_Smart_Controller +// +// Note: Usually sold with a white PCB. +// +#define REPRAP_DISCOUNT_SMART_CONTROLLER + +// +// GADGETS3D G3D LCD/SD Controller +// http://reprap.org/wiki/RAMPS_1.3/1.4_GADGETS3D_Shield_with_Panel +// +// Note: Usually sold with a blue PCB. +// +//#define G3D_PANEL + +// +// RepRapDiscount FULL GRAPHIC Smart Controller +// http://reprap.org/wiki/RepRapDiscount_Full_Graphic_Smart_Controller +// +//#define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER + +// +// MakerLab Mini Panel with graphic +// controller and SD support - http://reprap.org/wiki/Mini_panel +// +//#define MINIPANEL + +// +// RepRapWorld REPRAPWORLD_KEYPAD v1.1 +// http://reprapworld.com/?products_details&products_id=202&cPath=1591_1626 +// +// REPRAPWORLD_KEYPAD_MOVE_STEP sets how much should the robot move when a key +// is pressed, a value of 10.0 means 10mm per click. +// +//#define REPRAPWORLD_KEYPAD +//#define REPRAPWORLD_KEYPAD_MOVE_STEP 1.0 + +// +// RigidBot Panel V1.0 +// http://www.inventapart.com/ +// +//#define RIGIDBOT_PANEL + +// +// BQ LCD Smart Controller shipped by +// default with the BQ Hephestos 2 and Witbox 2. +// +//#define BQ_LCD_SMART_CONTROLLER + +// +// CONTROLLER TYPE: I2C +// +// Note: These controllers require the installation of Arduino's LiquidCrystal_I2C +// library. For more info: https://github.com/kiyoshigawa/LiquidCrystal_I2C +// + +// +// Elefu RA Board Control Panel +// http://www.elefu.com/index.php?route=product/product&product_id=53 +// +//#define RA_CONTROL_PANEL + +// +// Sainsmart YW Robot (LCM1602) LCD Display +// +//#define LCD_I2C_SAINSMART_YWROBOT + +// +// Generic LCM1602 LCD adapter +// +//#define LCM1602 + +// +// PANELOLU2 LCD with status LEDs, +// separate encoder and click inputs. +// +// Note: This controller requires Arduino's LiquidTWI2 library v1.2.3 or later. +// For more info: https://github.com/lincomatic/LiquidTWI2 +// +// Note: The PANELOLU2 encoder click input can either be directly connected to +// a pin (if BTN_ENC defined to != -1) or read through I2C (when BTN_ENC == -1). +// +//#define LCD_I2C_PANELOLU2 + +// +// Panucatt VIKI LCD with status LEDs, +// integrated click & L/R/U/D buttons, separate encoder inputs. +// +//#define LCD_I2C_VIKI + +// +// SSD1306 OLED full graphics generic display +// +//#define U8GLIB_SSD1306 + +// +// SAV OLEd LCD module support using either SSD1306 or SH1106 based LCD modules +// +//#define SAV_3DGLCD +#if ENABLED(SAV_3DGLCD) + //#define U8GLIB_SSD1306 + #define U8GLIB_SH1106 +#endif + +// +// CONTROLLER TYPE: Shift register panels +// +// 2 wire Non-latching LCD SR from https://goo.gl/aJJ4sH +// LCD configuration: http://reprap.org/wiki/SAV_3D_LCD +// +//#define SAV_3DLCD + +//============================================================================= +//=============================== Extra Features ============================== +//============================================================================= + +// @section extras + +// Increase the FAN PWM frequency. Removes the PWM noise but increases heating in the FET/Arduino +//#define FAST_PWM_FAN + +// Use software PWM to drive the fan, as for the heaters. This uses a very low frequency +// which is not as annoying as with the hardware PWM. On the other hand, if this frequency +// is too low, you should also increment SOFT_PWM_SCALE. +//#define FAN_SOFT_PWM + +// Incrementing this by 1 will double the software PWM frequency, +// affecting heaters, and the fan if FAN_SOFT_PWM is enabled. +// However, control resolution will be halved for each increment; +// at zero value, there are 128 effective control positions. +#define SOFT_PWM_SCALE 0 + +// Temperature status LEDs that display the hotend and bed temperature. +// If all hotends and bed temperature and temperature setpoint are < 54C then the BLUE led is on. +// Otherwise the RED led is on. There is 1C hysteresis. +//#define TEMP_STAT_LEDS + +// M240 Triggers a camera by emulating a Canon RC-1 Remote +// Data from: http://www.doc-diy.net/photo/rc-1_hacked/ +//#define PHOTOGRAPH_PIN 23 + +// SkeinForge sends the wrong arc g-codes when using Arc Point as fillet procedure +//#define SF_ARC_FIX + +// Support for the BariCUDA Paste Extruder. +//#define BARICUDA + +//define BlinkM/CyzRgb Support +//#define BLINKM + +// Support for an RGB LED using 3 separate pins with optional PWM +//#define RGB_LED +#if ENABLED(RGB_LED) + #define RGB_LED_R_PIN 34 + #define RGB_LED_G_PIN 43 + #define RGB_LED_B_PIN 35 +#endif + +/*********************************************************************\ +* R/C SERVO support +* Sponsored by TrinityLabs, Reworked by codexmas +**********************************************************************/ + +// Number of servos +// +// If you select a configuration below, this will receive a default value and does not need to be set manually +// set it manually if you have more servos than extruders and wish to manually control some +// leaving it undefined or defining as 0 will disable the servo subsystem +// If unsure, leave commented / disabled +// +#define NUM_SERVOS 2 // Servo index starts with 0 for M280 command + +// Delay (in milliseconds) before the next move will start, to give the servo time to reach its target angle. +// 300ms is a good value but you can try less delay. +// If the servo can't reach the requested position, increase it. +#define SERVO_DELAY 500 + +// Servo deactivation +// +// With this option servos are powered only during movement, then turned off to prevent jitter. +#define DEACTIVATE_SERVOS_AFTER_MOVE + +/**********************************************************************\ + * Support for a filament diameter sensor + * Also allows adjustment of diameter at print time (vs at slicing) + * Single extruder only at this point (extruder 0) + * + * Motherboards + * 34 - RAMPS1.4 - uses Analog input 5 on the AUX2 connector + * 81 - Printrboard - Uses Analog input 2 on the Exp1 connector (version B,C,D,E) + * 301 - Rambo - uses Analog input 3 + * Note may require analog pins to be defined for different motherboards + **********************************************************************/ +// Uncomment below to enable +//#define FILAMENT_WIDTH_SENSOR + +#define DEFAULT_NOMINAL_FILAMENT_DIA 1.75 //Enter the diameter (in mm) of the filament generally used (3.0 mm or 1.75 mm) - this is then used in the slicer software. Used for sensor reading validation + +#if ENABLED(FILAMENT_WIDTH_SENSOR) + #define FILAMENT_SENSOR_EXTRUDER_NUM 0 //The number of the extruder that has the filament sensor (0,1,2) + #define MEASUREMENT_DELAY_CM 14 //measurement delay in cm. This is the distance from filament sensor to middle of barrel + + #define MEASURED_UPPER_LIMIT 3.30 //upper limit factor used for sensor reading validation in mm + #define MEASURED_LOWER_LIMIT 1.90 //lower limit factor for sensor reading validation in mm + #define MAX_MEASUREMENT_DELAY 20 //delay buffer size in bytes (1 byte = 1cm)- limits maximum measurement delay allowable (must be larger than MEASUREMENT_DELAY_CM and lower number saves RAM) + + #define DEFAULT_MEASURED_FILAMENT_DIA DEFAULT_NOMINAL_FILAMENT_DIA //set measured to nominal initially + + //When using an LCD, uncomment the line below to display the Filament sensor data on the last line instead of status. Status will appear for 5 sec. + //#define FILAMENT_LCD_DISPLAY +#endif + +#endif // CONFIGURATION_H diff --git a/Marlin/example_configurations/Roxys_printers/Folger_Tech_i3_2020/Configuration_adv.h b/Marlin/example_configurations/Roxys_printers/Folger_Tech_i3_2020/Configuration_adv.h new file mode 100644 index 000000000..996396411 --- /dev/null +++ b/Marlin/example_configurations/Roxys_printers/Folger_Tech_i3_2020/Configuration_adv.h @@ -0,0 +1,1091 @@ +/** + * 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 . + * + */ + +/** + * Configuration_adv.h + * + * Advanced settings. + * Only change these if you know exactly what you're doing. + * Some of these settings can damage your printer if improperly set! + * + * Basic settings can be found in Configuration.h + * + */ +#ifndef CONFIGURATION_ADV_H +#define CONFIGURATION_ADV_H + +/** + * + * *********************************** + * ** ATTENTION TO ALL DEVELOPERS ** + * *********************************** + * + * You must increment this version number for every significant change such as, + * but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option. + * + * Note: Update also Version.h ! + */ +#define CONFIGURATION_ADV_H_VERSION 010100 + +// @section temperature + +//=========================================================================== +//=============================Thermal Settings ============================ +//=========================================================================== + +#if DISABLED(PIDTEMPBED) + #define BED_CHECK_INTERVAL 5000 // ms between checks in bang-bang control + #if ENABLED(BED_LIMIT_SWITCHING) + #define BED_HYSTERESIS 2 // Only disable heating if T>target+BED_HYSTERESIS and enable heating if T>target-BED_HYSTERESIS + #endif +#endif + +/** + * Thermal Protection protects your printer from damage and fire if a + * thermistor falls out or temperature sensors fail in any way. + * + * The issue: If a thermistor falls out or a temperature sensor fails, + * Marlin can no longer sense the actual temperature. Since a disconnected + * thermistor reads as a low temperature, the firmware will keep the heater on. + * + * The solution: Once the temperature reaches the target, start observing. + * If the temperature stays too far below the target (hysteresis) for too long (period), + * the firmware will halt the machine as a safety precaution. + * + * If you get false positives for "Thermal Runaway" increase THERMAL_PROTECTION_HYSTERESIS and/or THERMAL_PROTECTION_PERIOD + */ +#if ENABLED(THERMAL_PROTECTION_HOTENDS) + #define THERMAL_PROTECTION_PERIOD 40 // Seconds + #define THERMAL_PROTECTION_HYSTERESIS 2 // Degrees Celsius + + /** + * Whenever an M104 or M109 increases the target temperature the firmware will wait for the + * WATCH_TEMP_PERIOD to expire, and if the temperature hasn't increased by WATCH_TEMP_INCREASE + * degrees, the machine is halted, requiring a hard reset. This test restarts with any M104/M109, + * but only if the current temperature is far enough below the target for a reliable test. + * + * If you get false positives for "Heating failed" increase WATCH_TEMP_PERIOD and/or decrease WATCH_TEMP_INCREASE + * WATCH_TEMP_INCREASE should not be below 2. + */ + #define WATCH_TEMP_PERIOD 40 // Seconds + #define WATCH_TEMP_INCREASE 2 // Degrees Celsius +#endif + +/** + * Thermal Protection parameters for the bed are just as above for hotends. + */ +#if ENABLED(THERMAL_PROTECTION_BED) + #define THERMAL_PROTECTION_BED_PERIOD 40 // Seconds + #define THERMAL_PROTECTION_BED_HYSTERESIS 2 // Degrees Celsius + + /** + * Whenever an M140 or M190 increases the target temperature the firmware will wait for the + * WATCH_BED_TEMP_PERIOD to expire, and if the temperature hasn't increased by WATCH_BED_TEMP_INCREASE + * degrees, the machine is halted, requiring a hard reset. This test restarts with any M140/M190, + * but only if the current temperature is far enough below the target for a reliable test. + * + * If you get too many "Heating failed" errors, increase WATCH_BED_TEMP_PERIOD and/or decrease + * WATCH_BED_TEMP_INCREASE. (WATCH_BED_TEMP_INCREASE should not be below 2.) + */ + #define WATCH_BED_TEMP_PERIOD 60 // Seconds + #define WATCH_BED_TEMP_INCREASE 2 // Degrees Celsius +#endif + +#if ENABLED(PIDTEMP) + // this adds an experimental additional term to the heating power, proportional to the extrusion speed. + // if Kc is chosen well, the additional required power due to increased melting should be compensated. + //#define PID_EXTRUSION_SCALING + #if ENABLED(PID_EXTRUSION_SCALING) + #define DEFAULT_Kc (100) //heating power=Kc*(e_speed) + #define LPQ_MAX_LEN 50 + #endif +#endif + +/** + * Automatic Temperature: + * The hotend target temperature is calculated by all the buffered lines of gcode. + * The maximum buffered steps/sec of the extruder motor is called "se". + * Start autotemp mode with M109 S B F + * The target temperature is set to mintemp+factor*se[steps/sec] and is limited by + * mintemp and maxtemp. Turn this off by executing M109 without F* + * Also, if the temperature is set to a value below mintemp, it will not be changed by autotemp. + * On an Ultimaker, some initial testing worked with M109 S215 B260 F1 in the start.gcode + */ +#define AUTOTEMP +#if ENABLED(AUTOTEMP) + #define AUTOTEMP_OLDWEIGHT 0.98 +#endif + +//Show Temperature ADC value +//The M105 command return, besides traditional information, the ADC value read from temperature sensors. +//#define SHOW_TEMP_ADC_VALUES + +/** + * High Temperature Thermistor Support + * + * Thermistors able to support high temperature tend to have a hard time getting + * good readings at room and lower temperatures. This means HEATER_X_RAW_LO_TEMP + * will probably be caught when the heating element first turns on during the + * preheating process, which will trigger a min_temp_error as a safety measure + * and force stop everything. + * To circumvent this limitation, we allow for a preheat time (during which, + * min_temp_error won't be triggered) and add a min_temp buffer to handle + * aberrant readings. + * + * If you want to enable this feature for your hotend thermistor(s) + * uncomment and set values > 0 in the constants below + */ + +// The number of consecutive low temperature errors that can occur +// before a min_temp_error is triggered. (Shouldn't be more than 10.) +//#define MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED 0 + +// The number of milliseconds a hotend will preheat before starting to check +// the temperature. This value should NOT be set to the time it takes the +// hot end to reach the target temperature, but the time it takes to reach +// the minimum temperature your thermistor can read. The lower the better/safer. +// This shouldn't need to be more than 30 seconds (30000) +//#define MILLISECONDS_PREHEAT_TIME 0 + +// @section extruder + +// Extruder runout prevention. +// If the machine is idle and the temperature over MINTEMP +// then extrude some filament every couple of SECONDS. +//#define EXTRUDER_RUNOUT_PREVENT +#if ENABLED(EXTRUDER_RUNOUT_PREVENT) + #define EXTRUDER_RUNOUT_MINTEMP 190 + #define EXTRUDER_RUNOUT_SECONDS 30 + #define EXTRUDER_RUNOUT_SPEED 1500 // mm/m + #define EXTRUDER_RUNOUT_EXTRUDE 5 // mm +#endif + +// @section temperature + +//These defines help to calibrate the AD595 sensor in case you get wrong temperature measurements. +//The measured temperature is defined as "actualTemp = (measuredTemp * TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET" +#define TEMP_SENSOR_AD595_OFFSET 0.0 +#define TEMP_SENSOR_AD595_GAIN 1.0 + +//This is for controlling a fan to cool down the stepper drivers +//it will turn on when any driver is enabled +//and turn off after the set amount of seconds from last driver being disabled again +#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) +#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run +#define CONTROLLERFAN_SPEED 255 // == full speed + +// When first starting the main fan, run it at full speed for the +// given number of milliseconds. This gets the fan spinning reliably +// before setting a PWM value. (Does not work with software PWM for fan on Sanguinololu) +//#define FAN_KICKSTART_TIME 100 + +// This defines the minimal speed for the main fan, run in PWM mode +// to enable uncomment and set minimal PWM speed for reliable running (1-255) +// if fan speed is [1 - (FAN_MIN_PWM-1)] it is set to FAN_MIN_PWM +//#define FAN_MIN_PWM 50 + +// @section extruder + +/** + * Extruder cooling fans + * + * Extruder auto fans automatically turn on when their extruders' + * temperatures go above EXTRUDER_AUTO_FAN_TEMPERATURE. + * + * Your board's pins file specifies the recommended pins. Override those here + * or set to -1 to disable completely. + * + * Multiple extruders can be assigned to the same pin in which case + * the fan will turn on when any selected extruder is above the threshold. + */ +#define E0_AUTO_FAN_PIN -1 +#define E1_AUTO_FAN_PIN -1 +#define E2_AUTO_FAN_PIN -1 +#define E3_AUTO_FAN_PIN -1 +#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 +#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed + +// Define a pin to turn case light on/off +//#define CASE_LIGHT_PIN 4 +#if PIN_EXISTS(CASE_LIGHT) + #define INVERT_CASE_LIGHT false // Set to true if HIGH is the OFF state (active low) + //#define CASE_LIGHT_DEFAULT_ON // Uncomment to set default state to on + //#define MENU_ITEM_CASE_LIGHT // Uncomment to have a Case Light On / Off entry in main menu +#endif + +//=========================================================================== +//============================ Mechanical Settings ========================== +//=========================================================================== + +// @section homing + +// If you want endstops to stay on (by default) even when not homing +// enable this option. Override at any time with M120, M121. +//#define ENDSTOPS_ALWAYS_ON_DEFAULT + +// @section extras + +//#define Z_LATE_ENABLE // Enable Z the last moment. Needed if your Z driver overheats. + +// Dual X Steppers +// Uncomment this option to drive two X axis motors. +// The next unused E driver will be assigned to the second X stepper. +//#define X_DUAL_STEPPER_DRIVERS +#if ENABLED(X_DUAL_STEPPER_DRIVERS) + // Set true if the two X motors need to rotate in opposite directions + #define INVERT_X2_VS_X_DIR true +#endif + + +// Dual Y Steppers +// Uncomment this option to drive two Y axis motors. +// The next unused E driver will be assigned to the second Y stepper. +//#define Y_DUAL_STEPPER_DRIVERS +#if ENABLED(Y_DUAL_STEPPER_DRIVERS) + // Set true if the two Y motors need to rotate in opposite directions + #define INVERT_Y2_VS_Y_DIR true +#endif + +// A single Z stepper driver is usually used to drive 2 stepper motors. +// Uncomment this option to use a separate stepper driver for each Z axis motor. +// The next unused E driver will be assigned to the second Z stepper. +//#define Z_DUAL_STEPPER_DRIVERS + +#if ENABLED(Z_DUAL_STEPPER_DRIVERS) + + // Z_DUAL_ENDSTOPS is a feature to enable the use of 2 endstops for both Z steppers - Let's call them Z stepper and Z2 stepper. + // That way the machine is capable to align the bed during home, since both Z steppers are homed. + // There is also an implementation of M666 (software endstops adjustment) to this feature. + // After Z homing, this adjustment is applied to just one of the steppers in order to align the bed. + // One just need to home the Z axis and measure the distance difference between both Z axis and apply the math: Z adjust = Z - Z2. + // If the Z stepper axis is closer to the bed, the measure Z > Z2 (yes, it is.. think about it) and the Z adjust would be positive. + // Play a little bit with small adjustments (0.5mm) and check the behaviour. + // The M119 (endstops report) will start reporting the Z2 Endstop as well. + + //#define Z_DUAL_ENDSTOPS + + #if ENABLED(Z_DUAL_ENDSTOPS) + #define Z2_USE_ENDSTOP _XMAX_ + #endif + +#endif // Z_DUAL_STEPPER_DRIVERS + +// Enable this for dual x-carriage printers. +// A dual x-carriage design has the advantage that the inactive extruder can be parked which +// prevents hot-end ooze contaminating the print. It also reduces the weight of each x-carriage +// allowing faster printing speeds. Connect your X2 stepper to the first unused E plug. +//#define DUAL_X_CARRIAGE +#if ENABLED(DUAL_X_CARRIAGE) + // Configuration for second X-carriage + // Note: the first x-carriage is defined as the x-carriage which homes to the minimum endstop; + // the second x-carriage always homes to the maximum endstop. + #define X2_MIN_POS 80 // set minimum to ensure second x-carriage doesn't hit the parked first X-carriage + #define X2_MAX_POS 353 // set maximum to the distance between toolheads when both heads are homed + #define X2_HOME_DIR 1 // the second X-carriage always homes to the maximum endstop position + #define X2_HOME_POS X2_MAX_POS // default home position is the maximum carriage position + // However: In this mode the HOTEND_OFFSET_X value for the second extruder provides a software + // override for X2_HOME_POS. This also allow recalibration of the distance between the two endstops + // without modifying the firmware (through the "M218 T1 X???" command). + // Remember: you should set the second extruder x-offset to 0 in your slicer. + + // There are a few selectable movement modes for dual x-carriages using M605 S + // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results + // as long as it supports dual x-carriages. (M605 S0) + // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so + // that additional slicer support is not required. (M605 S1) + // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all + // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at + // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) + + // This is the default power-up mode which can be later using M605. + #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE + + // Default settings in "Auto-park Mode" + #define TOOLCHANGE_PARK_ZLIFT 0.2 // the distance to raise Z axis when parking an extruder + #define TOOLCHANGE_UNPARK_ZLIFT 1 // the distance to raise Z axis when unparking an extruder + + // Default x offset in duplication mode (typically set to half print bed width) + #define DEFAULT_DUPLICATION_X_OFFSET 100 + +#endif //DUAL_X_CARRIAGE + +// @section homing + +//homing hits the endstop, then retracts by this distance, before it tries to slowly bump again: +#define X_HOME_BUMP_MM 5 +#define Y_HOME_BUMP_MM 5 +#define Z_HOME_BUMP_MM 2 +#define HOMING_BUMP_DIVISOR {2, 2, 4} // Re-Bump Speed Divisor (Divides the Homing Feedrate) +//#define QUICK_HOME //if this is defined, if both x and y are to be homed, a diagonal move will be performed initially. + +// When G28 is called, this option will make Y home before X +//#define HOME_Y_BEFORE_X + +// @section machine + +#define AXIS_RELATIVE_MODES {false, false, false, false} + +// Allow duplication mode with a basic dual-nozzle extruder +//#define DUAL_NOZZLE_DUPLICATION_MODE + +// By default pololu step drivers require an active high signal. However, some high power drivers require an active low signal as step. +#define INVERT_X_STEP_PIN false +#define INVERT_Y_STEP_PIN false +#define INVERT_Z_STEP_PIN false +#define INVERT_E_STEP_PIN false + +// Default stepper release if idle. Set to 0 to deactivate. +// Steppers will shut down DEFAULT_STEPPER_DEACTIVE_TIME seconds after the last move when DISABLE_INACTIVE_? is true. +// Time can be set by M18 and M84. +#define DEFAULT_STEPPER_DEACTIVE_TIME 120 +#define DISABLE_INACTIVE_X true +#define DISABLE_INACTIVE_Y true +#define DISABLE_INACTIVE_Z true // set to false if the nozzle will fall down on your printed part when print has finished. +#define DISABLE_INACTIVE_E true + +#define DEFAULT_MINIMUMFEEDRATE 0.0 // minimum feedrate +#define DEFAULT_MINTRAVELFEEDRATE 0.0 + +// @section lcd + +#if ENABLED(ULTIPANEL) + #define MANUAL_FEEDRATE {50*60, 50*60, 4*60, 60} // Feedrates for manual moves along X, Y, Z, E from panel + #define ULTIPANEL_FEEDMULTIPLY // Comment to disable setting feedrate multiplier via encoder +#endif + +// @section extras + +// minimum time in microseconds that a movement needs to take if the buffer is emptied. +#define DEFAULT_MINSEGMENTTIME 20000 + +// If defined the movements slow down when the look ahead buffer is only half full +#define SLOWDOWN + +// Frequency limit +// See nophead's blog for more info +// Not working O +//#define XY_FREQUENCY_LIMIT 15 + +// Minimum planner junction speed. Sets the default minimum speed the planner plans for at the end +// of the buffer and all stops. This should not be much greater than zero and should only be changed +// if unwanted behavior is observed on a user's machine when running at very slow speeds. +#define MINIMUM_PLANNER_SPEED 0.05// (mm/sec) + +// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. +#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] + +// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) +#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) + +// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) +//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps + +// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro +//#define DIGIPOT_I2C +// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 +#define DIGIPOT_I2C_NUM_CHANNELS 8 +// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS +#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} + +//=========================================================================== +//=============================Additional Features=========================== +//=========================================================================== + +#define ENCODER_RATE_MULTIPLIER // If defined, certain menu edit operations automatically multiply the steps when the encoder is moved quickly +#define ENCODER_10X_STEPS_PER_SEC 75 // If the encoder steps per sec exceeds this value, multiply steps moved x10 to quickly advance the value +#define ENCODER_100X_STEPS_PER_SEC 160 // If the encoder steps per sec exceeds this value, multiply steps moved x100 to really quickly advance the value + +//#define CHDK 4 //Pin for triggering CHDK to take a picture see how to use it here http://captain-slow.dk/2014/03/09/3d-printing-timelapses/ +#define CHDK_DELAY 50 //How long in ms the pin should stay HIGH before going LOW again + +// @section lcd + +// Include a page of printer information in the LCD Main Menu +//#define LCD_INFO_MENU + +// On the Info Screen, display XY with one decimal place when possible +//#define LCD_DECIMAL_SMALL_XY + +// The timeout (in ms) to return to the status screen from sub-menus +//#define LCD_TIMEOUT_TO_STATUS 15000 + +#if ENABLED(SDSUPPORT) + + // Some RAMPS and other boards don't detect when an SD card is inserted. You can work + // around this by connecting a push button or single throw switch to the pin defined + // as SD_DETECT_PIN in your board's pins definitions. + // This setting should be disabled unless you are using a push button, pulling the pin to ground. + // Note: This is always disabled for ULTIPANEL (except ELB_FULL_GRAPHIC_CONTROLLER). + #define SD_DETECT_INVERTED + + #define SD_FINISHED_STEPPERRELEASE true //if sd support and the file is finished: disable steppers? + #define SD_FINISHED_RELEASECOMMAND "M84 X Y Z E" // You might want to keep the z enabled so your bed stays in place. + + #define SDCARD_RATHERRECENTFIRST //reverse file order of sd card menu display. Its sorted practically after the file system block order. + // if a file is deleted, it frees a block. hence, the order is not purely chronological. To still have auto0.g accessible, there is again the option to do that. + // using: + //#define MENU_ADDAUTOSTART + + /** + * Sort SD file listings in alphabetical order. + * + * With this option enabled, items on SD cards will be sorted + * by name for easier navigation. + * + * By default... + * + * - Use the slowest -but safest- method for sorting. + * - Folders are sorted to the top. + * - The sort key is statically allocated. + * - No added G-code (M34) support. + * - 40 item sorting limit. (Items after the first 40 are unsorted.) + * + * SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the + * compiler to calculate the worst-case usage and throw an error if the SRAM + * limit is exceeded. + * + * - SDSORT_USES_RAM provides faster sorting via a static directory buffer. + * - SDSORT_USES_STACK does the same, but uses a local stack-based buffer. + * - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!) + * - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!) + */ + //#define SDCARD_SORT_ALPHA + + // SD Card Sorting options + #if ENABLED(SDCARD_SORT_ALPHA) + #define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256). + #define FOLDER_SORTING -1 // -1=above 0=none 1=below + #define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code. + #define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting. + #define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.) + #define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option. + #define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use! + #endif + + // Show a progress bar on HD44780 LCDs for SD printing + //#define LCD_PROGRESS_BAR + + #if ENABLED(LCD_PROGRESS_BAR) + // Amount of time (ms) to show the bar + #define PROGRESS_BAR_BAR_TIME 2000 + // Amount of time (ms) to show the status message + #define PROGRESS_BAR_MSG_TIME 3000 + // Amount of time (ms) to retain the status message (0=forever) + #define PROGRESS_MSG_EXPIRE 0 + // Enable this to show messages for MSG_TIME then hide them + //#define PROGRESS_MSG_ONCE + // Add a menu item to test the progress bar: + //#define LCD_PROGRESS_BAR_TEST + #endif + + // This allows hosts to request long names for files and folders with M33 + //#define LONG_FILENAME_HOST_SUPPORT + + // This option allows you to abort SD printing when any endstop is triggered. + // This feature must be enabled with "M540 S1" or from the LCD menu. + // To have any effect, endstops must be enabled during SD printing. + //#define ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED + +#endif // SDSUPPORT + +/** + * Additional options for Graphical Displays + * + * Use the optimizations here to improve printing performance, + * which can be adversely affected by graphical display drawing, + * especially when doing several short moves, and when printing + * on DELTA and SCARA machines. + * + * Some of these options may result in the display lagging behind + * controller events, as there is a trade-off between reliable + * printing performance versus fast display updates. + */ +#if ENABLED(DOGLCD) + // Enable to save many cycles by drawing a hollow frame on the Info Screen + #define XYZ_HOLLOW_FRAME + + // Enable to save many cycles by drawing a hollow frame on Menu Screens + #define MENU_HOLLOW_FRAME + + // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. + // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. + //#define USE_BIG_EDIT_FONT + + // A smaller font may be used on the Info Screen. Costs 2300 bytes of PROGMEM. + // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. + //#define USE_SMALL_INFOFONT + + // Enable this option and reduce the value to optimize screen updates. + // The normal delay is 10µs. Use the lowest value that still gives a reliable display. + //#define DOGM_SPI_DELAY_US 5 +#endif // DOGLCD + +// @section safety + +// The hardware watchdog should reset the microcontroller disabling all outputs, +// in case the firmware gets stuck and doesn't do temperature regulation. +#define USE_WATCHDOG + +#if ENABLED(USE_WATCHDOG) + // If you have a watchdog reboot in an ArduinoMega2560 then the device will hang forever, as a watchdog reset will leave the watchdog on. + // The "WATCHDOG_RESET_MANUAL" goes around this by not using the hardware reset. + // However, THIS FEATURE IS UNSAFE!, as it will only work if interrupts are disabled. And the code could hang in an interrupt routine with interrupts disabled. + //#define WATCHDOG_RESET_MANUAL +#endif + +// @section lcd + +// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process +// it can e.g. be used to change z-positions in the print startup phase in real-time +// does not respect endstops! +//#define BABYSTEPPING +#if ENABLED(Roxy_work) + #define BABYSTEPPING +#endif +#if ENABLED(BABYSTEPPING) + #define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions + //not implemented for deltabots! + #define BABYSTEP_INVERT_Z false //true for inverse movements in Z + #define BABYSTEP_MULTIPLICATOR 2 //faster movements +#endif + +// @section extruder + +// extruder advance constant (s2/mm3) +// +// advance (steps) = STEPS_PER_CUBIC_MM_E * EXTRUDER_ADVANCE_K * cubic mm per second ^ 2 +// +// Hooke's law says: force = k * distance +// Bernoulli's principle says: v ^ 2 / 2 + g . h + pressure / density = constant +// so: v ^ 2 is proportional to number of steps we advance the extruder +//#define ADVANCE + +#if ENABLED(ADVANCE) + #define EXTRUDER_ADVANCE_K .0 + #define D_FILAMENT 2.85 +#endif + +/** + * Implementation of linear pressure control + * + * Assumption: advance = k * (delta velocity) + * K=0 means advance disabled. + * See Marlin documentation for calibration instructions. + */ +//#define LIN_ADVANCE + +#if ENABLED(LIN_ADVANCE) + #define LIN_ADVANCE_K 75 + + /** + * Some Slicers produce Gcode with randomly jumping extrusion widths occasionally. + * For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width. + * While this is harmless for normal printing (the fluid nature of the filament will + * close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption. + * + * For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio + * to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures + * if the slicer is using variable widths or layer heights within one print! + * + * This option sets the default E:D ratio at startup. Use `M905` to override this value. + * + * Example: `M905 W0.4 H0.2 D1.75`, where: + * - W is the extrusion width in mm + * - H is the layer height in mm + * - D is the filament diameter in mm + * + * Set to 0 to auto-detect the ratio based on given Gcode G1 print moves. + * + * Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode. + * Cura (as of this writing) may produce Gcode incompatible with the automatic mode. + */ + #define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI) + // Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135 +#endif + +// @section leveling + +// Default mesh area is an area with an inset margin on the print area. +// Below are the macros that are used to define the borders for the mesh area, +// made available here for specialized needs, ie dual extruder setup. +#if ENABLED(MESH_BED_LEVELING) + #define MESH_MIN_X (X_MIN_POS + MESH_INSET) + #define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) + #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) + #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) +#endif + +#if ENABLED(AUTO_BED_LEVELING_UBL) + #define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET) + #define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET)) + #define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET) + #define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET)) +#endif + +// @section extras + +// Arc interpretation settings: +#define ARC_SUPPORT // Disabling this saves ~2738 bytes +#define MM_PER_ARC_SEGMENT 1 +#define N_ARC_CORRECTION 25 + +// Support for G5 with XYZE destination and IJPQ offsets. Requires ~2666 bytes. +//#define BEZIER_CURVE_SUPPORT + +// G38.2 and G38.3 Probe Target +//#define G38_PROBE_TARGET +#if ENABLED(G38_PROBE_TARGET) + #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) +#endif + +// Moves (or segments) with fewer steps than this will be joined with the next move +#define MIN_STEPS_PER_SEGMENT 6 + +// The minimum pulse width (in µs) for stepping a stepper. +// Set this if you find stepping unreliable, or if using a very fast CPU. +#define MINIMUM_STEPPER_PULSE 0 // (µs) The smallest stepper pulse allowed + +// @section temperature + +// Control heater 0 and heater 1 in parallel. +//#define HEATERS_PARALLEL + +//=========================================================================== +//================================= Buffers ================================= +//=========================================================================== + +// @section hidden + +// The number of linear motions that can be in the plan at any give time. +// THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2, i.g. 8,16,32 because shifts and ors are used to do the ring-buffering. +#if ENABLED(SDSUPPORT) + #define BLOCK_BUFFER_SIZE 16 // SD,LCD,Buttons take more memory, block buffer needs to be smaller +#else + #define BLOCK_BUFFER_SIZE 16 // maximize block buffer +#endif + +// @section serial + +// The ASCII buffer for serial input +#define MAX_CMD_SIZE 96 +#define BUFSIZE 4 + +// Transfer Buffer Size +// To save 386 bytes of PROGMEM (and TX_BUFFER_SIZE+3 bytes of RAM) set to 0. +// To buffer a simple "ok" you need 4 bytes. +// For ADVANCED_OK (M105) you need 32 bytes. +// For debug-echo: 128 bytes for the optimal speed. +// Other output doesn't need to be that speedy. +// :[0, 2, 4, 8, 16, 32, 64, 128, 256] +#define TX_BUFFER_SIZE 0 + +// Enable an emergency-command parser to intercept certain commands as they +// enter the serial receive buffer, so they cannot be blocked. +// Currently handles M108, M112, M410 +// Does not work on boards using AT90USB (USBCON) processors! +//#define EMERGENCY_PARSER + +// Bad Serial-connections can miss a received command by sending an 'ok' +// Therefore some clients abort after 30 seconds in a timeout. +// Some other clients start sending commands while receiving a 'wait'. +// This "wait" is only sent when the buffer is empty. 1 second is a good value here. +//#define NO_TIMEOUTS 1000 // Milliseconds + +// Some clients will have this feature soon. This could make the NO_TIMEOUTS unnecessary. +//#define ADVANCED_OK + +// @section fwretract + +// Firmware based and LCD controlled retract +// M207 and M208 can be used to define parameters for the retraction. +// The retraction can be called by the slicer using G10 and G11 +// until then, intended retractions can be detected by moves that only extrude and the direction. +// the moves are than replaced by the firmware controlled ones. + +//#define FWRETRACT //ONLY PARTIALLY TESTED +#if ENABLED(FWRETRACT) + #define MIN_RETRACT 0.1 //minimum extruded mm to accept a automatic gcode retraction attempt + #define RETRACT_LENGTH 3 //default retract length (positive mm) + #define RETRACT_LENGTH_SWAP 13 //default swap retract length (positive mm), for extruder change + #define RETRACT_FEEDRATE 45 //default feedrate for retracting (mm/s) + #define RETRACT_ZLIFT 0 //default retract Z-lift + #define RETRACT_RECOVER_LENGTH 0 //default additional recover length (mm, added to retract length when recovering) + #define RETRACT_RECOVER_LENGTH_SWAP 0 //default additional swap recover length (mm, added to retract length when recovering from extruder change) + #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) +#endif + +/** + * Filament Change + * Experimental filament change support. + * Adds the GCode M600 for initiating filament change. + * + * Requires an LCD display. + * This feature is required for the default FILAMENT_RUNOUT_SCRIPT. + */ +//#define FILAMENT_CHANGE_FEATURE +#if ENABLED(Roxy_work) + #define FILAMENT_CHANGE_FEATURE +#endif +#if ENABLED(FILAMENT_CHANGE_FEATURE) + #define FILAMENT_CHANGE_X_POS 3 // X position of hotend + #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend + #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) + #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) + #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) + #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s + #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm + // It is a short retract used immediately after print interrupt before move to filament exchange position + #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast + #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm + // Longer length for bowden printers to unload filament from whole bowden tube, + // shorter length for printers without bowden to unload filament from extruder only, + // 0 to disable unloading for manual unloading + #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast + #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm + // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, + // Short or zero length for printers without bowden where loading is not used + #define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate + #define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend, + // 0 to disable for manual extrusion + // Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, + // or until outcoming filament color is not clear for filament color change + #define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45L // Turn off nozzle if user doesn't change filament within this time limit in seconds + #define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5L // Number of alert beeps before printer goes quiet + #define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change + // even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME. +#endif + +// @section tmc + +/** + * Enable this section if you have TMC26X motor drivers. + * You will need to import the TMC26XStepper library into the Arduino IDE for this + * (https://github.com/trinamic/TMC26XStepper.git) + */ +//#define HAVE_TMCDRIVER + +#if ENABLED(HAVE_TMCDRIVER) + + //#define X_IS_TMC + //#define X2_IS_TMC + //#define Y_IS_TMC + //#define Y2_IS_TMC + //#define Z_IS_TMC + //#define Z2_IS_TMC + //#define E0_IS_TMC + //#define E1_IS_TMC + //#define E2_IS_TMC + //#define E3_IS_TMC + + #define X_MAX_CURRENT 1000 // in mA + #define X_SENSE_RESISTOR 91 // in mOhms + #define X_MICROSTEPS 16 // number of microsteps + + #define X2_MAX_CURRENT 1000 + #define X2_SENSE_RESISTOR 91 + #define X2_MICROSTEPS 16 + + #define Y_MAX_CURRENT 1000 + #define Y_SENSE_RESISTOR 91 + #define Y_MICROSTEPS 16 + + #define Y2_MAX_CURRENT 1000 + #define Y2_SENSE_RESISTOR 91 + #define Y2_MICROSTEPS 16 + + #define Z_MAX_CURRENT 1000 + #define Z_SENSE_RESISTOR 91 + #define Z_MICROSTEPS 16 + + #define Z2_MAX_CURRENT 1000 + #define Z2_SENSE_RESISTOR 91 + #define Z2_MICROSTEPS 16 + + #define E0_MAX_CURRENT 1000 + #define E0_SENSE_RESISTOR 91 + #define E0_MICROSTEPS 16 + + #define E1_MAX_CURRENT 1000 + #define E1_SENSE_RESISTOR 91 + #define E1_MICROSTEPS 16 + + #define E2_MAX_CURRENT 1000 + #define E2_SENSE_RESISTOR 91 + #define E2_MICROSTEPS 16 + + #define E3_MAX_CURRENT 1000 + #define E3_SENSE_RESISTOR 91 + #define E3_MICROSTEPS 16 + +#endif + +// @section TMC2130 + +/** + * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. + * + * You'll also need the TMC2130Stepper Arduino library + * (https://github.com/teemuatlut/TMC2130Stepper). + * + * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to + * the hardware SPI interface on your board and define the required CS pins + * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). + */ +//#define HAVE_TMC2130 + +#if ENABLED(HAVE_TMC2130) + #define STEALTHCHOP + + /** + * Let Marlin automatically control stepper current. + * This is still an experimental feature. + * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered, + * then decrease current by CURRENT_STEP until temperature prewarn is cleared. + * Adjusting starts from X/Y/Z/E_MAX_CURRENT but will not increase over AUTO_ADJUST_MAX + */ + //#define AUTOMATIC_CURRENT_CONTROL + #define CURRENT_STEP 50 // [mA] + #define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak + + // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY + //#define X_IS_TMC2130 + //#define X2_IS_TMC2130 + //#define Y_IS_TMC2130 + //#define Y2_IS_TMC2130 + //#define Z_IS_TMC2130 + //#define Z2_IS_TMC2130 + //#define E0_IS_TMC2130 + //#define E1_IS_TMC2130 + //#define E2_IS_TMC2130 + //#define E3_IS_TMC2130 + + /** + * Stepper driver settings + */ + + #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130 + #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current + #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256 + + #define X_MAX_CURRENT 1000 // rms current in mA + #define X_MICROSTEPS 16 // FULLSTEP..256 + #define X_CHIP_SELECT 40 // Pin + + #define Y_MAX_CURRENT 1000 + #define Y_MICROSTEPS 16 + #define Y_CHIP_SELECT 42 + + #define Z_MAX_CURRENT 1000 + #define Z_MICROSTEPS 16 + #define Z_CHIP_SELECT 65 + + //#define X2_MAX_CURRENT 1000 + //#define X2_MICROSTEPS 16 + //#define X2_CHIP_SELECT -1 + + //#define Y2_MAX_CURRENT 1000 + //#define Y2_MICROSTEPS 16 + //#define Y2_CHIP_SELECT -1 + + //#define Z2_MAX_CURRENT 1000 + //#define Z2_MICROSTEPS 16 + //#define Z2_CHIP_SELECT -1 + + //#define E0_MAX_CURRENT 1000 + //#define E0_MICROSTEPS 16 + //#define E0_CHIP_SELECT -1 + + //#define E1_MAX_CURRENT 1000 + //#define E1_MICROSTEPS 16 + //#define E1_CHIP_SELECT -1 + + //#define E2_MAX_CURRENT 1000 + //#define E2_MICROSTEPS 16 + //#define E2_CHIP_SELECT -1 + + //#define E3_MAX_CURRENT 1000 + //#define E3_MICROSTEPS 16 + //#define E3_CHIP_SELECT -1 + + /** + * You can set your own advanced settings by filling in predefined functions. + * A list of available functions can be found on the library github page + * https://github.com/teemuatlut/TMC2130Stepper + * + * Example: + * #define TMC2130_ADV() { \ + * stepperX.diag0_temp_prewarn(1); \ + * stepperX.interpolate(0); \ + * } + */ + #define TMC2130_ADV() { } + +#endif // ENABLED(HAVE_TMC2130) + +/** + * Enable this section if you have L6470 motor drivers. + * You need to import the L6470 library into the Arduino IDE for this. + * (https://github.com/ameyer/Arduino-L6470) + */ + +// @section l6470 + +//#define HAVE_L6470DRIVER +#if ENABLED(HAVE_L6470DRIVER) + + //#define X_IS_L6470 + //#define X2_IS_L6470 + //#define Y_IS_L6470 + //#define Y2_IS_L6470 + //#define Z_IS_L6470 + //#define Z2_IS_L6470 + //#define E0_IS_L6470 + //#define E1_IS_L6470 + //#define E2_IS_L6470 + //#define E3_IS_L6470 + + #define X_MICROSTEPS 16 // number of microsteps + #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high + #define X_OVERCURRENT 2000 // maxc current in mA. If the current goes over this value, the driver will switch off + #define X_STALLCURRENT 1500 // current in mA where the driver will detect a stall + + #define X2_MICROSTEPS 16 + #define X2_K_VAL 50 + #define X2_OVERCURRENT 2000 + #define X2_STALLCURRENT 1500 + + #define Y_MICROSTEPS 16 + #define Y_K_VAL 50 + #define Y_OVERCURRENT 2000 + #define Y_STALLCURRENT 1500 + + #define Y2_MICROSTEPS 16 + #define Y2_K_VAL 50 + #define Y2_OVERCURRENT 2000 + #define Y2_STALLCURRENT 1500 + + #define Z_MICROSTEPS 16 + #define Z_K_VAL 50 + #define Z_OVERCURRENT 2000 + #define Z_STALLCURRENT 1500 + + #define Z2_MICROSTEPS 16 + #define Z2_K_VAL 50 + #define Z2_OVERCURRENT 2000 + #define Z2_STALLCURRENT 1500 + + #define E0_MICROSTEPS 16 + #define E0_K_VAL 50 + #define E0_OVERCURRENT 2000 + #define E0_STALLCURRENT 1500 + + #define E1_MICROSTEPS 16 + #define E1_K_VAL 50 + #define E1_OVERCURRENT 2000 + #define E1_STALLCURRENT 1500 + + #define E2_MICROSTEPS 16 + #define E2_K_VAL 50 + #define E2_OVERCURRENT 2000 + #define E2_STALLCURRENT 1500 + + #define E3_MICROSTEPS 16 + #define E3_K_VAL 50 + #define E3_OVERCURRENT 2000 + #define E3_STALLCURRENT 1500 + +#endif + +/** + * TWI/I2C BUS + * + * This feature is an EXPERIMENTAL feature so it shall not be used on production + * machines. Enabling this will allow you to send and receive I2C data from slave + * devices on the bus. + * + * ; Example #1 + * ; This macro send the string "Marlin" to the slave device with address 0x63 (99) + * ; It uses multiple M260 commands with one B arg + * M260 A99 ; Target slave address + * M260 B77 ; M + * M260 B97 ; a + * M260 B114 ; r + * M260 B108 ; l + * M260 B105 ; i + * M260 B110 ; n + * M260 S1 ; Send the current buffer + * + * ; Example #2 + * ; Request 6 bytes from slave device with address 0x63 (99) + * M261 A99 B5 + * + * ; Example #3 + * ; Example serial output of a M261 request + * echo:i2c-reply: from:99 bytes:5 data:hello + */ + +// @section i2cbus + +//#define EXPERIMENTAL_I2CBUS +#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave + +/** + * Add M43, M44 and M45 commands for pins info and testing + */ +#define PINS_DEBUGGING + +/** + * Auto-report temperatures with M155 S + */ +//#define AUTO_REPORT_TEMPERATURES + +/** + * Include capabilities in M115 output + */ +//#define EXTENDED_CAPABILITIES_REPORT + +/** + * Double-click the Encoder button on the Status Screen for Z Babystepping. + */ +#define DOUBLECLICK_FOR_Z_BABYSTEPPING +#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds. + // Note: You may need to add extra time to mitigate controller latency. + +/** + * Volumetric extrusion default state + * Activate to make volumetric extrusion the default method, + * with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter. + * + * M200 D0 to disable, M200 Dn to set a new diameter. + */ +//#define VOLUMETRIC_DEFAULT_ON + +/** + * Enable this option for a leaner build of Marlin that removes all + * workspace offsets, simplifying coordinate transformations, leveling, etc. + * + * - M206 and M428 are disabled. + * - G92 will revert to its behavior from Marlin 1.0. + */ +//#define NO_WORKSPACE_OFFSETS + +#endif // CONFIGURATION_ADV_H diff --git a/Marlin/example_configurations/Roxys_printers/gMax_1.5+/Configuration.h b/Marlin/example_configurations/Roxys_printers/gMax_1.5+/Configuration.h new file mode 100644 index 000000000..3d59a763c --- /dev/null +++ b/Marlin/example_configurations/Roxys_printers/gMax_1.5+/Configuration.h @@ -0,0 +1,1500 @@ +/** + * 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 . + * + */ + +/** + * Configuration.h + * + * Basic settings such as: + * + * - Type of electronics + * - Type of temperature sensor + * - Printer geometry + * - Endstop configuration + * - LCD controller + * - Extra features + * + * Advanced settings can be found in Configuration_adv.h + * + */ +#ifndef CONFIGURATION_H +#define CONFIGURATION_H + +/** + * + * *********************************** + * ** ATTENTION TO ALL DEVELOPERS ** + * *********************************** + * + * You must increment this version number for every significant change such as, + * but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option. + * + * Note: Update also Version.h ! + */ +#define CONFIGURATION_H_VERSION 010100 + +//=========================================================================== +//============================= Getting Started ============================= +//=========================================================================== + +/** + * Here are some standard links for getting your machine calibrated: + * + * http://reprap.org/wiki/Calibration + * http://youtu.be/wAL9d7FgInk + * http://calculator.josefprusa.cz + * http://reprap.org/wiki/Triffid_Hunter%27s_Calibration_Guide + * http://www.thingiverse.com/thing:5573 + * https://sites.google.com/site/repraplogphase/calibration-of-your-reprap + * http://www.thingiverse.com/thing:298812 + */ + +//=========================================================================== +//============================= DELTA Printer =============================== +//=========================================================================== +// For a Delta printer replace the configuration files with the files in the +// example_configurations/delta directory. +// + +//=========================================================================== +//============================= SCARA Printer =============================== +//=========================================================================== +// For a Scara printer replace the configuration files with the files in the +// example_configurations/SCARA directory. +// + +// @section info + +// User-specified version info of this build to display in [Pronterface, etc] terminal window during +// startup. Implementation of an idea by Prof Braino to inform user that any changes made to this +// build by the user have been successfully uploaded into firmware. +#define STRING_CONFIG_H_AUTHOR "(none, default config)" // Who made the changes. +#define SHOW_BOOTSCREEN +#define STRING_SPLASH_LINE1 SHORT_BUILD_VERSION // will be shown during bootup in line 1 +#define STRING_SPLASH_LINE2 WEBSITE_URL // will be shown during bootup in line 2 + +// +// *** VENDORS PLEASE READ ***************************************************** +// +// Marlin now allow you to have a vendor boot image to be displayed on machine +// start. When SHOW_CUSTOM_BOOTSCREEN is defined Marlin will first show your +// custom boot image and then the default Marlin boot image is shown. +// +// We suggest for you to take advantage of this new feature and keep the Marlin +// boot image unmodified. For an example have a look at the bq Hephestos 2 +// example configuration folder. +// +//#define SHOW_CUSTOM_BOOTSCREEN +// @section machine + +/** + * Select which serial port on the board will be used for communication with the host. + * This allows the connection of wireless adapters (for instance) to non-default port pins. + * Serial port 0 is always used by the Arduino bootloader regardless of this setting. + * + * :[0, 1, 2, 3, 4, 5, 6, 7] + */ +#define SERIAL_PORT 0 + +/** + * This setting determines the communication speed of the printer. + * + * 250000 works in most cases, but you might try a lower speed if + * you commonly experience drop-outs during host printing. + * + * :[2400, 9600, 19200, 38400, 57600, 115200, 250000] + */ +#define BAUDRATE 250000 + +// Enable the Bluetooth serial interface on AT90USB devices +//#define BLUETOOTH + +// The following define selects which electronics board you have. +// Please choose the name from boards.h that matches your setup +#ifndef MOTHERBOARD + #define MOTHERBOARD BOARD_RAMPS_14_EFB +#endif + +// Optional custom name for your RepStrap or other custom machine +// Displayed in the LCD "Ready" message +//#define CUSTOM_MACHINE_NAME "3D Printer" + +// Define this to set a unique identifier for this printer, (Used by some programs to differentiate between machines) +// You can use an online service to generate a random UUID. (eg http://www.uuidgenerator.net/version4) +//#define MACHINE_UUID "00000000-0000-0000-0000-000000000000" + +// This defines the number of extruders +// :[1, 2, 3, 4] +#define EXTRUDERS 1 + +// Enable if your E steppers or extruder gear ratios are not identical +//#define DISTINCT_E_FACTORS + +// For Cyclops or any "multi-extruder" that shares a single nozzle. +//#define SINGLENOZZLE + +// A dual extruder that uses a single stepper motor +// Don't forget to set SSDE_SERVO_ANGLES and HOTEND_OFFSET_X/Y/Z +//#define SWITCHING_EXTRUDER +#if ENABLED(SWITCHING_EXTRUDER) + #define SWITCHING_EXTRUDER_SERVO_NR 0 + #define SWITCHING_EXTRUDER_SERVO_ANGLES { 0, 90 } // Angles for E0, E1 + //#define HOTEND_OFFSET_Z {0.0, 0.0} +#endif + +/** + * "Mixing Extruder" + * - Adds a new code, M165, to set the current mix factors. + * - Extends the stepping routines to move multiple steppers in proportion to the mix. + * - Optional support for Repetier Host M163, M164, and virtual extruder. + * - This implementation supports only a single extruder. + * - Enable DIRECT_MIXING_IN_G1 for Pia Taubert's reference implementation + */ +//#define MIXING_EXTRUDER +#if ENABLED(MIXING_EXTRUDER) + #define MIXING_STEPPERS 2 // Number of steppers in your mixing extruder + #define MIXING_VIRTUAL_TOOLS 16 // Use the Virtual Tool method with M163 and M164 + //#define DIRECT_MIXING_IN_G1 // Allow ABCDHI mix factors in G1 movement commands +#endif + +// Offset of the extruders (uncomment if using more than one and relying on firmware to position when changing). +// The offset has to be X=0, Y=0 for the extruder 0 hotend (default extruder). +// For the other hotends it is their distance from the extruder 0 hotend. +//#define HOTEND_OFFSET_X {0.0, 20.00} // (in mm) for each extruder, offset of the hotend on the X axis +//#define HOTEND_OFFSET_Y {0.0, 5.00} // (in mm) for each extruder, offset of the hotend on the Y axis + +/** + * Select your power supply here. Use 0 if you haven't connected the PS_ON_PIN + * + * 0 = No Power Switch + * 1 = ATX + * 2 = X-Box 360 203Watts (the blue wire connected to PS_ON and the red wire to VCC) + * + * :{ 0:'No power switch', 1:'ATX', 2:'X-Box 360' } + */ +#define POWER_SUPPLY 0 + +#if POWER_SUPPLY > 0 + // Enable this option to leave the PSU off at startup. + // Power to steppers and heaters will need to be turned on with M80. + //#define PS_DEFAULT_OFF +#endif + +// @section temperature + +//=========================================================================== +//============================= Thermal Settings ============================ +//=========================================================================== + +/** + * --NORMAL IS 4.7kohm PULLUP!-- 1kohm pullup can be used on hotend sensor, using correct resistor and table + * + * Temperature sensors available: + * + * -3 : thermocouple with MAX31855 (only for sensor 0) + * -2 : thermocouple with MAX6675 (only for sensor 0) + * -1 : thermocouple with AD595 + * 0 : not used + * 1 : 100k thermistor - best choice for EPCOS 100k (4.7k pullup) + * 2 : 200k thermistor - ATC Semitec 204GT-2 (4.7k pullup) + * 3 : Mendel-parts thermistor (4.7k pullup) + * 4 : 10k thermistor !! do not use it for a hotend. It gives bad resolution at high temp. !! + * 5 : 100K thermistor - ATC Semitec 104GT-2 (Used in ParCan & J-Head) (4.7k pullup) + * 6 : 100k EPCOS - Not as accurate as table 1 (created using a fluke thermocouple) (4.7k pullup) + * 7 : 100k Honeywell thermistor 135-104LAG-J01 (4.7k pullup) + * 71 : 100k Honeywell thermistor 135-104LAF-J01 (4.7k pullup) + * 8 : 100k 0603 SMD Vishay NTCS0603E3104FXT (4.7k pullup) + * 9 : 100k GE Sensing AL03006-58.2K-97-G1 (4.7k pullup) + * 10 : 100k RS thermistor 198-961 (4.7k pullup) + * 11 : 100k beta 3950 1% thermistor (4.7k pullup) + * 12 : 100k 0603 SMD Vishay NTCS0603E3104FXT (4.7k pullup) (calibrated for Makibox hot bed) + * 13 : 100k Hisens 3950 1% up to 300°C for hotend "Simple ONE " & "Hotend "All In ONE" + * 20 : the PT100 circuit found in the Ultimainboard V2.x + * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 + * 66 : 4.7M High Temperature thermistor from Dyze Design + * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad with NTC 100K MGB18-104F39050L32 thermistor + * + * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. + * (but gives greater accuracy and more stable PID) + * 51 : 100k thermistor - EPCOS (1k pullup) + * 52 : 200k thermistor - ATC Semitec 204GT-2 (1k pullup) + * 55 : 100k thermistor - ATC Semitec 104GT-2 (Used in ParCan & J-Head) (1k pullup) + * + * 1047 : Pt1000 with 4k7 pullup + * 1010 : Pt1000 with 1k pullup (non standard) + * 147 : Pt100 with 4k7 pullup + * 110 : Pt100 with 1k pullup (non standard) + * + * Use these for Testing or Development purposes. NEVER for production machine. + * 998 : Dummy Table that ALWAYS reads 25°C or the temperature defined below. + * 999 : Dummy Table that ALWAYS reads 100°C or the temperature defined below. + * + * :{ '0': "Not used", '1':"100k / 4.7k - EPCOS", '2':"200k / 4.7k - ATC Semitec 204GT-2", '3':"Mendel-parts / 4.7k", '4':"10k !! do not use for a hotend. Bad resolution at high temp. !!", '5':"100K / 4.7k - ATC Semitec 104GT-2 (Used in ParCan & J-Head)", '6':"100k / 4.7k EPCOS - Not as accurate as Table 1", '7':"100k / 4.7k Honeywell 135-104LAG-J01", '8':"100k / 4.7k 0603 SMD Vishay NTCS0603E3104FXT", '9':"100k / 4.7k GE Sensing AL03006-58.2K-97-G1", '10':"100k / 4.7k RS 198-961", '11':"100k / 4.7k beta 3950 1%", '12':"100k / 4.7k 0603 SMD Vishay NTCS0603E3104FXT (calibrated for Makibox hot bed)", '13':"100k Hisens 3950 1% up to 300°C for hotend 'Simple ONE ' & hotend 'All In ONE'", '20':"PT100 (Ultimainboard V2.x)", '51':"100k / 1k - EPCOS", '52':"200k / 1k - ATC Semitec 204GT-2", '55':"100k / 1k - ATC Semitec 104GT-2 (Used in ParCan & J-Head)", '60':"100k Maker's Tool Works Kapton Bed Thermistor beta=3950", '66':"Dyze Design 4.7M High Temperature thermistor", '70':"the 100K thermistor found in the bq Hephestos 2", '71':"100k / 4.7k Honeywell 135-104LAF-J01", '147':"Pt100 / 4.7k", '1047':"Pt1000 / 4.7k", '110':"Pt100 / 1k (non-standard)", '1010':"Pt1000 / 1k (non standard)", '-3':"Thermocouple + MAX31855 (only for sensor 0)", '-2':"Thermocouple + MAX6675 (only for sensor 0)", '-1':"Thermocouple + AD595",'998':"Dummy 1", '999':"Dummy 2" } + */ +#define TEMP_SENSOR_0 1 +#define TEMP_SENSOR_1 0 +#define TEMP_SENSOR_2 0 +#define TEMP_SENSOR_3 0 +#define TEMP_SENSOR_BED 0 + +// Dummy thermistor constant temperature readings, for use with 998 and 999 +#define DUMMY_THERMISTOR_998_VALUE 25 +#define DUMMY_THERMISTOR_999_VALUE 100 + +// Use temp sensor 1 as a redundant sensor with sensor 0. If the readings +// from the two sensors differ too much the print will be aborted. +//#define TEMP_SENSOR_1_AS_REDUNDANT +#define MAX_REDUNDANT_TEMP_SENSOR_DIFF 10 + +// Extruder temperature must be close to target for this long before M109 returns success +#define TEMP_RESIDENCY_TIME 10 // (seconds) +#define TEMP_HYSTERESIS 3 // (degC) range of +/- temperatures considered "close" to the target one +#define TEMP_WINDOW 1 // (degC) Window around target to start the residency timer x degC early. + +// Bed temperature must be close to target for this long before M190 returns success +#define TEMP_BED_RESIDENCY_TIME 10 // (seconds) +#define TEMP_BED_HYSTERESIS 3 // (degC) range of +/- temperatures considered "close" to the target one +#define TEMP_BED_WINDOW 1 // (degC) Window around target to start the residency timer x degC early. + +// The minimal temperature defines the temperature below which the heater will not be enabled It is used +// to check that the wiring to the thermistor is not broken. +// Otherwise this would lead to the heater being powered on all the time. +#define HEATER_0_MINTEMP 5 +#define HEATER_1_MINTEMP 5 +#define HEATER_2_MINTEMP 5 +#define HEATER_3_MINTEMP 5 +#define BED_MINTEMP 5 + +// When temperature exceeds max temp, your heater will be switched off. +// This feature exists to protect your hotend from overheating accidentally, but *NOT* from thermistor short/failure! +// You should use MINTEMP for thermistor short/failure protection. +#define HEATER_0_MAXTEMP 275 +#define HEATER_1_MAXTEMP 275 +#define HEATER_2_MAXTEMP 275 +#define HEATER_3_MAXTEMP 275 +#define BED_MAXTEMP 150 + +//=========================================================================== +//============================= PID Settings ================================ +//=========================================================================== +// PID Tuning Guide here: http://reprap.org/wiki/PID_Tuning + +// Comment the following line to disable PID and enable bang-bang. +#define PIDTEMP +#define BANG_MAX 255 // limits current to nozzle while in bang-bang mode; 255=full current +#define PID_MAX BANG_MAX // limits current to nozzle while PID is active (see PID_FUNCTIONAL_RANGE below); 255=full current +#if ENABLED(PIDTEMP) + //#define PID_AUTOTUNE_MENU // Add PID Autotune to the LCD "Temperature" menu to run M303 and apply the result. + //#define PID_DEBUG // Sends debug data to the serial port. + //#define PID_OPENLOOP 1 // Puts PID in open loop. M104/M140 sets the output power from 0 to PID_MAX + //#define SLOW_PWM_HEATERS // PWM with very low frequency (roughly 0.125Hz=8s) and minimum state time of approximately 1s useful for heaters driven by a relay + //#define PID_PARAMS_PER_HOTEND // Uses separate PID parameters for each extruder (useful for mismatched extruders) + // Set/get with gcode: M301 E[extruder number, 0-2] + #define PID_FUNCTIONAL_RANGE 10 // If the temperature difference between the target temperature and the actual temperature + // is more than PID_FUNCTIONAL_RANGE then the PID will be shut off and the heater will be set to min/max. + #define K1 0.95 //smoothing factor within the PID + + // If you are using a pre-configured hotend then you can use one of the value sets by uncommenting it + // Ultimaker + #define DEFAULT_Kp 22.2 + #define DEFAULT_Ki 1.08 + #define DEFAULT_Kd 114 + + // MakerGear + //#define DEFAULT_Kp 7.0 + //#define DEFAULT_Ki 0.1 + //#define DEFAULT_Kd 12 + + // Mendel Parts V9 on 12V + //#define DEFAULT_Kp 63.0 + //#define DEFAULT_Ki 2.25 + //#define DEFAULT_Kd 440 + +#endif // PIDTEMP + +//=========================================================================== +//============================= PID > Bed Temperature Control =============== +//=========================================================================== +// Select PID or bang-bang with PIDTEMPBED. If bang-bang, BED_LIMIT_SWITCHING will enable hysteresis +// +// Uncomment this to enable PID on the bed. It uses the same frequency PWM as the extruder. +// If your PID_dT is the default, and correct for your hardware/configuration, that means 7.689Hz, +// which is fine for driving a square wave into a resistive load and does not significantly impact you FET heating. +// This also works fine on a Fotek SSR-10DA Solid State Relay into a 250W heater. +// If your configuration is significantly different than this and you don't understand the issues involved, you probably +// shouldn't use bed PID until someone else verifies your hardware works. +// If this is enabled, find your own PID constants below. +//#define PIDTEMPBED + +//#define BED_LIMIT_SWITCHING + +// This sets the max power delivered to the bed, and replaces the HEATER_BED_DUTY_CYCLE_DIVIDER option. +// all forms of bed control obey this (PID, bang-bang, bang-bang with hysteresis) +// setting this to anything other than 255 enables a form of PWM to the bed just like HEATER_BED_DUTY_CYCLE_DIVIDER did, +// so you shouldn't use it unless you are OK with PWM on your bed. (see the comment on enabling PIDTEMPBED) +#define MAX_BED_POWER 255 // limits duty cycle to bed; 255=full current + +#if ENABLED(PIDTEMPBED) + + //#define PID_BED_DEBUG // Sends debug data to the serial port. + + //120V 250W silicone heater into 4mm borosilicate (MendelMax 1.5+) + //from FOPDT model - kp=.39 Tp=405 Tdead=66, Tc set to 79.2, aggressive factor of .15 (vs .1, 1, 10) + #define DEFAULT_bedKp 10.00 + #define DEFAULT_bedKi .023 + #define DEFAULT_bedKd 305.4 + + //120V 250W silicone heater into 4mm borosilicate (MendelMax 1.5+) + //from pidautotune + //#define DEFAULT_bedKp 97.1 + //#define DEFAULT_bedKi 1.41 + //#define DEFAULT_bedKd 1675.16 + + // FIND YOUR OWN: "M303 E-1 C8 S90" to run autotune on the bed at 90 degreesC for 8 cycles. +#endif // PIDTEMPBED + +// @section extruder + +// This option prevents extrusion if the temperature is below EXTRUDE_MINTEMP. +// It also enables the M302 command to set the minimum extrusion temperature +// or to allow moving the extruder regardless of the hotend temperature. +// *** IT IS HIGHLY RECOMMENDED TO LEAVE THIS OPTION ENABLED! *** +#define PREVENT_COLD_EXTRUSION +#define EXTRUDE_MINTEMP 170 + +// This option prevents a single extrusion longer than EXTRUDE_MAXLENGTH. +// Note that for Bowden Extruders a too-small value here may prevent loading. +#define PREVENT_LENGTHY_EXTRUDE +#define EXTRUDE_MAXLENGTH 200 + +//=========================================================================== +//======================== Thermal Runaway Protection ======================= +//=========================================================================== + +/** + * Thermal Protection protects your printer from damage and fire if a + * thermistor falls out or temperature sensors fail in any way. + * + * The issue: If a thermistor falls out or a temperature sensor fails, + * Marlin can no longer sense the actual temperature. Since a disconnected + * thermistor reads as a low temperature, the firmware will keep the heater on. + * + * If you get "Thermal Runaway" or "Heating failed" errors the + * details can be tuned in Configuration_adv.h + */ + +#define THERMAL_PROTECTION_HOTENDS // Enable thermal protection for all extruders +#define THERMAL_PROTECTION_BED // Enable thermal protection for the heated bed + +//=========================================================================== +//============================= Mechanical Settings ========================= +//=========================================================================== + +// @section machine + +// Uncomment one of these options to enable CoreXY, CoreXZ, or CoreYZ kinematics +// either in the usual order or reversed +//#define COREXY +//#define COREXZ +//#define COREYZ +//#define COREYX +//#define COREZX +//#define COREZY + +// Enable this option for Toshiba steppers +//#define CONFIG_STEPPERS_TOSHIBA + +//=========================================================================== +//============================== Endstop Settings =========================== +//=========================================================================== + +// @section homing + +// Specify here all the endstop connectors that are connected to any endstop or probe. +// Almost all printers will be using one per axis. Probes will use one or more of the +// extra connectors. Leave undefined any used for non-endstop and non-probe purposes. +#define USE_XMIN_PLUG +#define USE_YMIN_PLUG +#define USE_ZMIN_PLUG +//#define USE_XMAX_PLUG +//#define USE_YMAX_PLUG +//#define USE_ZMAX_PLUG + +// coarse Endstop Settings +#define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors + +#if DISABLED(ENDSTOPPULLUPS) + // fine endstop settings: Individual pullups. will be ignored if ENDSTOPPULLUPS is defined + //#define ENDSTOPPULLUP_XMAX + //#define ENDSTOPPULLUP_YMAX + //#define ENDSTOPPULLUP_ZMAX + //#define ENDSTOPPULLUP_XMIN + //#define ENDSTOPPULLUP_YMIN + //#define ENDSTOPPULLUP_ZMIN + //#define ENDSTOPPULLUP_ZMIN_PROBE +#endif + +// Mechanical endstop with COM to ground and NC to Signal uses "false" here (most common setup). +#define X_MIN_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Y_MIN_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Z_MIN_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define X_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Y_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Z_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Z_MIN_PROBE_ENDSTOP_INVERTING false // set to true to invert the logic of the probe. + +// Enable this feature if all enabled endstop pins are interrupt-capable. +// This will remove the need to poll the interrupt pins, saving many CPU cycles. +//#define ENDSTOP_INTERRUPTS_FEATURE + +//============================================================================= +//============================== Movement Settings ============================ +//============================================================================= +// @section motion + +/** + * Default Settings + * + * These settings can be reset by M502 + * + * You can set distinct factors for each E stepper, if needed. + * If fewer factors are given, the last will apply to the rest. + * + * Note that if EEPROM is enabled, saved values will override these. + */ + +/** + * Default Axis Steps Per Unit (steps/mm) + * Override with M92 + * X, Y, Z, E0 [, E1[, E2[, E3]]] + */ +#define DEFAULT_AXIS_STEPS_PER_UNIT { 80, 80, 4000, 500 } + +/** + * Default Max Feed Rate (mm/s) + * Override with M203 + * X, Y, Z, E0 [, E1[, E2[, E3]]] + */ +#define DEFAULT_MAX_FEEDRATE { 300, 300, 5, 25 } + +/** + * Default Max Acceleration (change/s) change = mm/s + * (Maximum start speed for accelerated moves) + * Override with M201 + * X, Y, Z, E0 [, E1[, E2[, E3]]] + */ +#define DEFAULT_MAX_ACCELERATION { 3000, 3000, 100, 10000 } + +/** + * Default Acceleration (change/s) change = mm/s + * Override with M204 + * + * M204 P Acceleration + * M204 R Retract Acceleration + * M204 T Travel Acceleration + */ +#define DEFAULT_ACCELERATION 3000 // X, Y, Z and E acceleration for printing moves +#define DEFAULT_RETRACT_ACCELERATION 3000 // E acceleration for retracts +#define DEFAULT_TRAVEL_ACCELERATION 3000 // X, Y, Z acceleration for travel (non printing) moves + +/** + * Default Jerk (mm/s) + * Override with M205 X Y Z E + * + * "Jerk" specifies the minimum speed change that requires acceleration. + * When changing speed and direction, if the difference is less than the + * value set here, it may happen instantaneously. + */ +#define DEFAULT_XJERK 20.0 +#define DEFAULT_YJERK 20.0 +#define DEFAULT_ZJERK 0.4 +#define DEFAULT_EJERK 5.0 + + +//=========================================================================== +//============================= Z Probe Options ============================= +//=========================================================================== +// @section probes + +// +// Probe Type +// Probes are sensors/switches that are activated / deactivated before/after use. +// +// Allen Key Probes, Servo Probes, Z-Sled Probes, FIX_MOUNTED_PROBE, etc. +// You must activate one of these to use Auto Bed Leveling below. +// +// Use M851 to set the Z probe vertical offset from the nozzle. Store with M500. +// + +// A Fix-Mounted Probe either doesn't deploy or needs manual deployment. +// For example an inductive probe, or a setup that uses the nozzle to probe. +// An inductive probe must be deactivated to go below +// its trigger-point if hardware endstops are active. +//#define FIX_MOUNTED_PROBE + +// The BLTouch probe emulates a servo probe. +// The default connector is SERVO 0. Set Z_ENDSTOP_SERVO_NR below to override. +//#define BLTOUCH + +// Z Servo Probe, such as an endstop switch on a rotating arm. +//#define Z_ENDSTOP_SERVO_NR 0 +//#define Z_SERVO_ANGLES {70,0} // Z Servo Deploy and Stow angles + +// Enable if you have a Z probe mounted on a sled like those designed by Charles Bell. +//#define Z_PROBE_SLED +//#define SLED_DOCKING_OFFSET 5 // The extra distance the X axis must travel to pickup the sled. 0 should be fine but you can push it further if you'd like. + +// Z Probe to nozzle (X,Y) offset, relative to (0, 0). +// X and Y offsets must be integers. +// +// In the following example the X and Y offsets are both positive: +// #define X_PROBE_OFFSET_FROM_EXTRUDER 10 +// #define Y_PROBE_OFFSET_FROM_EXTRUDER 10 +// +// +-- BACK ---+ +// | | +// L | (+) P | R <-- probe (20,20) +// E | | I +// F | (-) N (+) | G <-- nozzle (10,10) +// T | | H +// | (-) | T +// | | +// O-- FRONT --+ +// (0,0) +#define X_PROBE_OFFSET_FROM_EXTRUDER 10 // X offset: -left +right [of the nozzle] +#define Y_PROBE_OFFSET_FROM_EXTRUDER 10 // Y offset: -front +behind [the nozzle] +#define Z_PROBE_OFFSET_FROM_EXTRUDER 0 // Z offset: -below +above [the nozzle] + +// X and Y axis travel speed (mm/m) between probes +#define XY_PROBE_SPEED 8000 +// Speed for the first approach when double-probing (with PROBE_DOUBLE_TOUCH) +#define Z_PROBE_SPEED_FAST HOMING_FEEDRATE_Z +// Speed for the "accurate" probe of each point +#define Z_PROBE_SPEED_SLOW (Z_PROBE_SPEED_FAST / 2) +// Use double touch for probing +//#define PROBE_DOUBLE_TOUCH + +// +// Allen Key Probe is defined in the Delta example configurations. +// + +// *** PLEASE READ ALL INSTRUCTIONS BELOW FOR SAFETY! *** +// +// To continue using the Z-min-endstop for homing, be sure to disable Z_SAFE_HOMING. +// Example: To park the head outside the bed area when homing with G28. +// +// To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. +// +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. +// +// - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. +// - Use 5V for powered (usu. inductive) sensors. +// - Otherwise connect: +// - normally-closed switches to GND and D32. +// - normally-open switches to 5V and D32. +// +// Normally-closed switches are advised and are the default. +// + +// +// The Z_MIN_PROBE_PIN sets the Arduino pin to use. (See your board's pins file.) +// Since the RAMPS Aux4->D32 pin maps directly to the Arduino D32 pin, D32 is the +// default pin for all RAMPS-based boards. Most boards use the X_MAX_PIN by default. +// To use a different pin you can override it here. +// +// WARNING: +// Setting the wrong pin may have unexpected and potentially disastrous consequences. +// Use with caution and do your homework. +// +//#define Z_MIN_PROBE_PIN X_MAX_PIN + +// +// Enable Z_MIN_PROBE_ENDSTOP to use _both_ a Z Probe and a Z-min-endstop on the same machine. +// With this option the Z_MIN_PROBE_PIN will only be used for probing, never for homing. +// +//#define Z_MIN_PROBE_ENDSTOP + +// Enable Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN to use the Z_MIN_PIN for your Z_MIN_PROBE. +// The Z_MIN_PIN will then be used for both Z-homing and probing. +#define Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN + +// To use a probe you must enable one of the two options above! + +// Enable Z Probe Repeatability test to see how accurate your probe is +//#define Z_MIN_PROBE_REPEATABILITY_TEST + +/** + * Z probes require clearance when deploying, stowing, and moving between + * probe points to avoid hitting the bed and other hardware. + * Servo-mounted probes require extra space for the arm to rotate. + * Inductive probes need space to keep from triggering early. + * + * Use these settings to specify the distance (mm) to raise the probe (or + * lower the bed). The values set here apply over and above any (negative) + * probe Z Offset set with Z_PROBE_OFFSET_FROM_EXTRUDER, M851, or the LCD. + * Only integer values >= 1 are valid here. + * + * Example: `M851 Z-5` with a CLEARANCE of 4 => 9mm from bed to nozzle. + * But: `M851 Z+1` with a CLEARANCE of 2 => 2mm from bed to nozzle. + */ +#define Z_CLEARANCE_DEPLOY_PROBE 10 // Z Clearance for Deploy/Stow +#define Z_CLEARANCE_BETWEEN_PROBES 5 // Z Clearance between probe points + +// +// For M851 give a range for adjusting the Z probe offset +// +#define Z_PROBE_OFFSET_RANGE_MIN -20 +#define Z_PROBE_OFFSET_RANGE_MAX 20 + +// For Inverting Stepper Enable Pins (Active Low) use 0, Non Inverting (Active High) use 1 +// :{ 0:'Low', 1:'High' } +#define X_ENABLE_ON 0 +#define Y_ENABLE_ON 0 +#define Z_ENABLE_ON 0 +#define E_ENABLE_ON 0 // For all extruders + +// Disables axis stepper immediately when it's not being used. +// WARNING: When motors turn off there is a chance of losing position accuracy! +#define DISABLE_X false +#define DISABLE_Y false +#define DISABLE_Z false +// Warn on display about possibly reduced accuracy +//#define DISABLE_REDUCED_ACCURACY_WARNING + +// @section extruder + +#define DISABLE_E false // For all extruders +#define DISABLE_INACTIVE_EXTRUDER true //disable only inactive extruders and keep active extruder enabled + +// @section machine + +// Invert the stepper direction. Change (or reverse the motor connector) if an axis goes the wrong way. +#define INVERT_X_DIR false +#define INVERT_Y_DIR true +#define INVERT_Z_DIR false + +// @section extruder + +// For direct drive extruder v9 set to true, for geared extruder set to false. +#define INVERT_E0_DIR false +#define INVERT_E1_DIR false +#define INVERT_E2_DIR false +#define INVERT_E3_DIR false + +// @section homing + +//#define Z_HOMING_HEIGHT 4 // (in mm) Minimal z height before homing (G28) for Z clearance above the bed, clamps, ... + // Be sure you have this distance over your Z_MAX_POS in case. + +// Direction of endstops when homing; 1=MAX, -1=MIN +// :[-1,1] +#define X_HOME_DIR -1 +#define Y_HOME_DIR -1 +#define Z_HOME_DIR -1 + +// @section machine + +// Travel limits after homing (units are in mm) +#define X_MIN_POS 0 +#define Y_MIN_POS 0 +#define Z_MIN_POS 0 +#define X_MAX_POS 200 +#define Y_MAX_POS 200 +#define Z_MAX_POS 200 + +// If enabled, axes won't move below MIN_POS in response to movement commands. +#define MIN_SOFTWARE_ENDSTOPS +// If enabled, axes won't move above MAX_POS in response to movement commands. +#define MAX_SOFTWARE_ENDSTOPS + +/** + * Filament Runout Sensor + * A mechanical or opto endstop is used to check for the presence of filament. + * + * RAMPS-based boards use SERVO3_PIN. + * For other boards you may need to define FIL_RUNOUT_PIN. + * By default the firmware assumes HIGH = has filament, LOW = ran out + */ +//#define FILAMENT_RUNOUT_SENSOR +#if ENABLED(FILAMENT_RUNOUT_SENSOR) + #define FIL_RUNOUT_INVERTING false // set to true to invert the logic of the sensor. + #define ENDSTOPPULLUP_FIL_RUNOUT // Uncomment to use internal pullup for filament runout pins if the sensor is defined. + #define FILAMENT_RUNOUT_SCRIPT "M600" +#endif + +//=========================================================================== +//=============================== Bed Leveling ============================== +//=========================================================================== +// @section bedlevel + +/** + * Select one form of Auto Bed Leveling below. + * + * If you're also using the Probe for Z Homing, it's + * highly recommended to enable Z_SAFE_HOMING also! + * + * - 3POINT + * Probe 3 arbitrary points on the bed (that aren't collinear) + * You specify the XY coordinates of all 3 points. + * The result is a single tilted plane. Best for a flat bed. + * + * - LINEAR + * Probe several points in a grid. + * You specify the rectangle and the density of sample points. + * The result is a single tilted plane. Best for a flat bed. + * + * - BILINEAR + * Probe several points in a grid. + * You specify the rectangle and the density of sample points. + * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. + */ +//#define AUTO_BED_LEVELING_3POINT +//#define AUTO_BED_LEVELING_LINEAR +//#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL + +/** + * Enable detailed logging of G28, G29, M48, etc. + * Turn on with the command 'M111 S32'. + * NOTE: Requires a lot of PROGMEM! + */ +//#define DEBUG_LEVELING_FEATURE + +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + +#if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) + + // Set the number of grid points per dimension. + #define ABL_GRID_MAX_POINTS_X 3 + #define ABL_GRID_MAX_POINTS_Y ABL_GRID_MAX_POINTS_X + + // Set the boundaries for probing (where the probe can reach). + #define LEFT_PROBE_BED_POSITION 15 + #define RIGHT_PROBE_BED_POSITION 170 + #define FRONT_PROBE_BED_POSITION 20 + #define BACK_PROBE_BED_POSITION 170 + + // The Z probe minimum outer margin (to validate G29 parameters). + #define MIN_PROBE_EDGE 10 + + // Probe along the Y axis, advancing X after each column + //#define PROBE_Y_FIRST + + #if ENABLED(AUTO_BED_LEVELING_BILINEAR) + + // + // Experimental Subdivision of the grid by Catmull-Rom method. + // Synthesizes intermediate points to produce a more detailed mesh. + // + //#define ABL_BILINEAR_SUBDIVISION + #if ENABLED(ABL_BILINEAR_SUBDIVISION) + // Number of subdivisions between probe points + #define BILINEAR_SUBDIVISIONS 3 + #endif + + #endif + +#elif ENABLED(AUTO_BED_LEVELING_3POINT) + + // 3 arbitrary points to probe. + // A simple cross-product is used to estimate the plane of the bed. + #define ABL_PROBE_PT_1_X 15 + #define ABL_PROBE_PT_1_Y 180 + #define ABL_PROBE_PT_2_X 15 + #define ABL_PROBE_PT_2_Y 20 + #define ABL_PROBE_PT_3_X 170 + #define ABL_PROBE_PT_3_Y 20 + +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING + +/** + * Commands to execute at the end of G29 probing. + * Useful to retract or move the Z probe out of the way. + */ +//#define Z_PROBE_END_SCRIPT "G1 Z10 F12000\nG1 X15 Y330\nG1 Z0.5\nG1 Z10" + + +// @section homing + +// The center of the bed is at (X=0, Y=0) +//#define BED_CENTER_AT_0_0 + +// Manually set the home position. Leave these undefined for automatic settings. +// For DELTA this is the top-center of the Cartesian print volume. +//#define MANUAL_X_HOME_POS 0 +//#define MANUAL_Y_HOME_POS 0 +//#define MANUAL_Z_HOME_POS 0 + +// Use "Z Safe Homing" to avoid homing with a Z probe outside the bed area. +// +// With this feature enabled: +// +// - Allow Z homing only after X and Y homing AND stepper drivers still enabled. +// - If stepper drivers time out, it will need X and Y homing again before Z homing. +// - Move the Z probe (or nozzle) to a defined XY point before Z Homing when homing all axes (G28). +// - Prevent Z homing when the Z probe is outside bed area. +//#define Z_SAFE_HOMING + +#if ENABLED(Z_SAFE_HOMING) + #define Z_SAFE_HOMING_X_POINT ((X_MIN_POS + X_MAX_POS) / 2) // X point for Z homing when homing all axis (G28). + #define Z_SAFE_HOMING_Y_POINT ((Y_MIN_POS + Y_MAX_POS) / 2) // Y point for Z homing when homing all axis (G28). +#endif + +// Homing speeds (mm/m) +#define HOMING_FEEDRATE_XY (50*60) +#define HOMING_FEEDRATE_Z (4*60) + +//============================================================================= +//============================= Additional Features =========================== +//============================================================================= + +// @section extras + +// +// EEPROM +// +// The microcontroller can store settings in the EEPROM, e.g. max velocity... +// M500 - stores parameters in EEPROM +// M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily). +// M502 - reverts to the default "factory settings". You still need to store them in EEPROM afterwards if you want to. +//define this to enable EEPROM support +//#define EEPROM_SETTINGS + +#if ENABLED(EEPROM_SETTINGS) + // To disable EEPROM Serial responses and decrease program space by ~1700 byte: comment this out: + #define EEPROM_CHITCHAT // Please keep turned on if you can. +#endif + +// +// Host Keepalive +// +// When enabled Marlin will send a busy status message to the host +// every couple of seconds when it can't accept commands. +// +#define HOST_KEEPALIVE_FEATURE // Disable this if your host doesn't like keepalive messages +#define DEFAULT_KEEPALIVE_INTERVAL 2 // Number of seconds between "busy" messages. Set with M113. + +// +// M100 Free Memory Watcher +// +//#define M100_FREE_MEMORY_WATCHER // uncomment to add the M100 Free Memory Watcher for debug purpose + +// +// G20/G21 Inch mode support +// +//#define INCH_MODE_SUPPORT + +// +// M149 Set temperature units support +// +//#define TEMPERATURE_UNITS_SUPPORT + +// @section temperature + +// Preheat Constants +#define PREHEAT_1_TEMP_HOTEND 180 +#define PREHEAT_1_TEMP_BED 70 +#define PREHEAT_1_FAN_SPEED 0 // Value from 0 to 255 + +#define PREHEAT_2_TEMP_HOTEND 240 +#define PREHEAT_2_TEMP_BED 110 +#define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255 + +// +// Nozzle Park -- EXPERIMENTAL +// +// When enabled allows the user to define a special XYZ position, inside the +// machine's topology, to park the nozzle when idle or when receiving the G27 +// command. +// +// The "P" paramenter controls what is the action applied to the Z axis: +// P0: (Default) If current Z-pos is lower than Z-park then the nozzle will +// be raised to reach Z-park height. +// +// P1: No matter the current Z-pos, the nozzle will be raised/lowered to +// reach Z-park height. +// +// P2: The nozzle height will be raised by Z-park amount but never going over +// the machine's limit of Z_MAX_POS. +// +//#define NOZZLE_PARK_FEATURE + +#if ENABLED(NOZZLE_PARK_FEATURE) + // Specify a park position as { X, Y, Z } + #define NOZZLE_PARK_POINT { (X_MIN_POS + 10), (Y_MAX_POS - 10), 20 } +#endif + +// +// 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. S defines "strokes" i.e. +// back-and-forth movements between the starting and end points. +// +// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T" +// defines the number of zig-zag triangles to be done. "S" defines the +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, +// sending "G12 P1 S1 T3" will execute: +// +// -- +// | (X0, Y1) | /\ /\ /\ | (X1, Y1) +// | | / \ / \ / \ | +// A | | / \ / \ / \ | +// | | / \ / \ / \ | +// | (X0, Y0) | / \/ \/ \ | (X1, Y0) +// -- +--------------------------------+ +// |________|_________|_________| +// T1 T2 T3 +// +// P2: This starts a circular pattern with circle with middle in +// NOZZLE_CLEAN_CIRCLE_MIDDLE radius of R and stroke count of S. +// Before starting the circle nozzle goes to NOZZLE_CLEAN_START_POINT. +// +// 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) + // Default number of pattern repetitions + #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 + + // Specify positions as { X, Y, Z } + #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} + #define NOZZLE_CLEAN_END_POINT {100, 60, (Z_MIN_POS + 1)} + + // Circular pattern radius + #define NOZZLE_CLEAN_CIRCLE_RADIUS 6.5 + // Circular pattern circle fragments number + #define NOZZLE_CLEAN_CIRCLE_FN 10 + // Middle point of circle + #define NOZZLE_CLEAN_CIRCLE_MIDDLE NOZZLE_CLEAN_START_POINT + + // Moves the nozzle to the initial position + #define NOZZLE_CLEAN_GOBACK +#endif + +// +// Print job timer +// +// Enable this option to automatically start and stop the +// print job timer when M104/M109/M190 commands are received. +// M104 (extruder without wait) - high temp = none, low temp = stop timer +// M109 (extruder with wait) - high temp = start timer, low temp = stop timer +// M190 (bed with wait) - high temp = start timer, low temp = none +// +// In all cases the timer can be started and stopped using +// the following commands: +// +// - M75 - Start the print job timer +// - M76 - Pause the print job timer +// - M77 - Stop the print job timer +#define PRINTJOB_TIMER_AUTOSTART + +// +// Print Counter +// +// When enabled Marlin will keep track of some print statistical data such as: +// - Total print jobs +// - Total successful print jobs +// - Total failed print jobs +// - Total time printing +// +// This information can be viewed by the M78 command. +//#define PRINTCOUNTER + +//============================================================================= +//============================= LCD and SD support ============================ +//============================================================================= + +// @section lcd + +// +// LCD LANGUAGE +// +// Here you may choose the language used by Marlin on the LCD menus, the following +// list of languages are available: +// en, an, bg, ca, cn, cz, de, el, el-gr, es, eu, fi, fr, gl, hr, it, +// kana, kana_utf8, nl, pl, pt, pt_utf8, pt-br, pt-br_utf8, ru, tr, uk, test +// +// :{ 'en':'English', 'an':'Aragonese', 'bg':'Bulgarian', 'ca':'Catalan', 'cn':'Chinese', 'cz':'Czech', 'de':'German', 'el':'Greek', 'el-gr':'Greek (Greece)', 'es':'Spanish', 'eu':'Basque-Euskera', 'fi':'Finnish', 'fr':'French', 'gl':'Galician', 'hr':'Croatian', 'it':'Italian', 'kana':'Japanese', 'kana_utf8':'Japanese (UTF8)', 'nl':'Dutch', 'pl':'Polish', 'pt':'Portuguese', 'pt-br':'Portuguese (Brazilian)', 'pt-br_utf8':'Portuguese (Brazilian UTF8)', 'pt_utf8':'Portuguese (UTF8)', 'ru':'Russian', 'tr':'Turkish', 'uk':'Ukrainian', 'test':'TEST' } +// +#define LCD_LANGUAGE en + +// +// LCD Character Set +// +// Note: This option is NOT applicable to Graphical Displays. +// +// All character-based LCD's provide ASCII plus one of these +// language extensions: +// +// - JAPANESE ... the most common +// - WESTERN ... with more accented characters +// - CYRILLIC ... for the Russian language +// +// To determine the language extension installed on your controller: +// +// - Compile and upload with LCD_LANGUAGE set to 'test' +// - Click the controller to view the LCD menu +// - The LCD will display Japanese, Western, or Cyrillic text +// +// See https://github.com/MarlinFirmware/Marlin/wiki/LCD-Language +// +// :['JAPANESE', 'WESTERN', 'CYRILLIC'] +// +#define DISPLAY_CHARSET_HD44780 JAPANESE + +// +// LCD TYPE +// +// You may choose ULTRA_LCD if you have character based LCD with 16x2, 16x4, 20x2, +// 20x4 char/lines or DOGLCD for the full graphics display with 128x64 pixels +// (ST7565R family). (This option will be set automatically for certain displays.) +// +// IMPORTANT NOTE: The U8glib library is required for Full Graphic Display! +// https://github.com/olikraus/U8glib_Arduino +// +//#define ULTRA_LCD // Character based +//#define DOGLCD // Full graphics display + +// +// SD CARD +// +// SD Card support is disabled by default. If your controller has an SD slot, +// you must uncomment the following option or it won't work. +// +//#define SDSUPPORT + +// +// SD CARD: SPI SPEED +// +// Uncomment ONE of the following items to use a slower SPI transfer +// speed. This is usually required if you're getting volume init errors. +// +//#define SPI_SPEED SPI_HALF_SPEED +//#define SPI_SPEED SPI_QUARTER_SPEED +//#define SPI_SPEED SPI_EIGHTH_SPEED + +// +// SD CARD: ENABLE CRC +// +// Use CRC checks and retries on the SD communication. +// +//#define SD_CHECK_AND_RETRY + +// +// ENCODER SETTINGS +// +// This option overrides the default number of encoder pulses needed to +// produce one step. Should be increased for high-resolution encoders. +// +//#define ENCODER_PULSES_PER_STEP 1 + +// +// Use this option to override the number of step signals required to +// move between next/prev menu items. +// +//#define ENCODER_STEPS_PER_MENU_ITEM 5 + +/** + * Encoder Direction Options + * + * Test your encoder's behavior first with both options disabled. + * + * Reversed Value Edit and Menu Nav? Enable REVERSE_ENCODER_DIRECTION. + * Reversed Menu Navigation only? Enable REVERSE_MENU_DIRECTION. + * Reversed Value Editing only? Enable BOTH options. + */ + +// +// This option reverses the encoder direction everywhere +// +// Set this option if CLOCKWISE causes values to DECREASE +// +//#define REVERSE_ENCODER_DIRECTION + +// +// This option reverses the encoder direction for navigating LCD menus. +// +// If CLOCKWISE normally moves DOWN this makes it go UP. +// If CLOCKWISE normally moves UP this makes it go DOWN. +// +//#define REVERSE_MENU_DIRECTION + +// +// Individual Axis Homing +// +// Add individual axis homing items (Home X, Home Y, and Home Z) to the LCD menu. +// +//#define INDIVIDUAL_AXIS_HOMING_MENU + +// +// SPEAKER/BUZZER +// +// If you have a speaker that can produce tones, enable it here. +// By default Marlin assumes you have a buzzer with a fixed frequency. +// +//#define SPEAKER + +// +// The duration and frequency for the UI feedback sound. +// Set these to 0 to disable audio feedback in the LCD menus. +// +// Note: Test audio output with the G-Code: +// M300 S P +// +//#define LCD_FEEDBACK_FREQUENCY_DURATION_MS 100 +//#define LCD_FEEDBACK_FREQUENCY_HZ 1000 + +// +// CONTROLLER TYPE: Standard +// +// Marlin supports a wide variety of controllers. +// Enable one of the following options to specify your controller. +// + +// +// ULTIMAKER Controller. +// +//#define ULTIMAKERCONTROLLER + +// +// ULTIPANEL as seen on Thingiverse. +// +//#define ULTIPANEL + +// +// Cartesio UI +// http://mauk.cc/webshop/cartesio-shop/electronics/user-interface +// +//#define CARTESIO_UI + +// +// PanelOne from T3P3 (via RAMPS 1.4 AUX2/AUX3) +// http://reprap.org/wiki/PanelOne +// +//#define PANEL_ONE + +// +// MaKr3d Makr-Panel with graphic controller and SD support. +// http://reprap.org/wiki/MaKr3d_MaKrPanel +// +//#define MAKRPANEL + +// +// ReprapWorld Graphical LCD +// https://reprapworld.com/?products_details&products_id/1218 +// +//#define REPRAPWORLD_GRAPHICAL_LCD + +// +// Activate one of these if you have a Panucatt Devices +// Viki 2.0 or mini Viki with Graphic LCD +// http://panucatt.com +// +//#define VIKI2 +//#define miniVIKI + +// +// Adafruit ST7565 Full Graphic Controller. +// https://github.com/eboston/Adafruit-ST7565-Full-Graphic-Controller/ +// +//#define ELB_FULL_GRAPHIC_CONTROLLER + +// +// RepRapDiscount Smart Controller. +// http://reprap.org/wiki/RepRapDiscount_Smart_Controller +// +// Note: Usually sold with a white PCB. +// +//#define REPRAP_DISCOUNT_SMART_CONTROLLER + +// +// GADGETS3D G3D LCD/SD Controller +// http://reprap.org/wiki/RAMPS_1.3/1.4_GADGETS3D_Shield_with_Panel +// +// Note: Usually sold with a blue PCB. +// +//#define G3D_PANEL + +// +// RepRapDiscount FULL GRAPHIC Smart Controller +// http://reprap.org/wiki/RepRapDiscount_Full_Graphic_Smart_Controller +// +//#define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER + +// +// MakerLab Mini Panel with graphic +// controller and SD support - http://reprap.org/wiki/Mini_panel +// +//#define MINIPANEL + +// +// RepRapWorld REPRAPWORLD_KEYPAD v1.1 +// http://reprapworld.com/?products_details&products_id=202&cPath=1591_1626 +// +// REPRAPWORLD_KEYPAD_MOVE_STEP sets how much should the robot move when a key +// is pressed, a value of 10.0 means 10mm per click. +// +//#define REPRAPWORLD_KEYPAD +//#define REPRAPWORLD_KEYPAD_MOVE_STEP 1.0 + +// +// RigidBot Panel V1.0 +// http://www.inventapart.com/ +// +//#define RIGIDBOT_PANEL + +// +// BQ LCD Smart Controller shipped by +// default with the BQ Hephestos 2 and Witbox 2. +// +//#define BQ_LCD_SMART_CONTROLLER + +// +// CONTROLLER TYPE: I2C +// +// Note: These controllers require the installation of Arduino's LiquidCrystal_I2C +// library. For more info: https://github.com/kiyoshigawa/LiquidCrystal_I2C +// + +// +// Elefu RA Board Control Panel +// http://www.elefu.com/index.php?route=product/product&product_id=53 +// +//#define RA_CONTROL_PANEL + +// +// Sainsmart YW Robot (LCM1602) LCD Display +// +//#define LCD_I2C_SAINSMART_YWROBOT + +// +// Generic LCM1602 LCD adapter +// +//#define LCM1602 + +// +// PANELOLU2 LCD with status LEDs, +// separate encoder and click inputs. +// +// Note: This controller requires Arduino's LiquidTWI2 library v1.2.3 or later. +// For more info: https://github.com/lincomatic/LiquidTWI2 +// +// Note: The PANELOLU2 encoder click input can either be directly connected to +// a pin (if BTN_ENC defined to != -1) or read through I2C (when BTN_ENC == -1). +// +//#define LCD_I2C_PANELOLU2 + +// +// Panucatt VIKI LCD with status LEDs, +// integrated click & L/R/U/D buttons, separate encoder inputs. +// +//#define LCD_I2C_VIKI + +// +// SSD1306 OLED full graphics generic display +// +//#define U8GLIB_SSD1306 + +// +// SAV OLEd LCD module support using either SSD1306 or SH1106 based LCD modules +// +//#define SAV_3DGLCD +#if ENABLED(SAV_3DGLCD) + //#define U8GLIB_SSD1306 + #define U8GLIB_SH1106 +#endif + +// +// CONTROLLER TYPE: Shift register panels +// +// 2 wire Non-latching LCD SR from https://goo.gl/aJJ4sH +// LCD configuration: http://reprap.org/wiki/SAV_3D_LCD +// +//#define SAV_3DLCD + +//============================================================================= +//=============================== Extra Features ============================== +//============================================================================= + +// @section extras + +// Increase the FAN PWM frequency. Removes the PWM noise but increases heating in the FET/Arduino +//#define FAST_PWM_FAN + +// Use software PWM to drive the fan, as for the heaters. This uses a very low frequency +// which is not as annoying as with the hardware PWM. On the other hand, if this frequency +// is too low, you should also increment SOFT_PWM_SCALE. +//#define FAN_SOFT_PWM + +// Incrementing this by 1 will double the software PWM frequency, +// affecting heaters, and the fan if FAN_SOFT_PWM is enabled. +// However, control resolution will be halved for each increment; +// at zero value, there are 128 effective control positions. +#define SOFT_PWM_SCALE 0 + +// Temperature status LEDs that display the hotend and bed temperature. +// If all hotends and bed temperature and temperature setpoint are < 54C then the BLUE led is on. +// Otherwise the RED led is on. There is 1C hysteresis. +//#define TEMP_STAT_LEDS + +// M240 Triggers a camera by emulating a Canon RC-1 Remote +// Data from: http://www.doc-diy.net/photo/rc-1_hacked/ +//#define PHOTOGRAPH_PIN 23 + +// SkeinForge sends the wrong arc g-codes when using Arc Point as fillet procedure +//#define SF_ARC_FIX + +// Support for the BariCUDA Paste Extruder. +//#define BARICUDA + +//define BlinkM/CyzRgb Support +//#define BLINKM + +// Support for an RGB LED using 3 separate pins with optional PWM +//#define RGB_LED +#if ENABLED(RGB_LED) + #define RGB_LED_R_PIN 34 + #define RGB_LED_G_PIN 43 + #define RGB_LED_B_PIN 35 +#endif + +/*********************************************************************\ +* R/C SERVO support +* Sponsored by TrinityLabs, Reworked by codexmas +**********************************************************************/ + +// Number of servos +// +// If you select a configuration below, this will receive a default value and does not need to be set manually +// set it manually if you have more servos than extruders and wish to manually control some +// leaving it undefined or defining as 0 will disable the servo subsystem +// If unsure, leave commented / disabled +// +//#define NUM_SERVOS 3 // Servo index starts with 0 for M280 command + +// Delay (in milliseconds) before the next move will start, to give the servo time to reach its target angle. +// 300ms is a good value but you can try less delay. +// If the servo can't reach the requested position, increase it. +#define SERVO_DELAY 300 + +// Servo deactivation +// +// With this option servos are powered only during movement, then turned off to prevent jitter. +//#define DEACTIVATE_SERVOS_AFTER_MOVE + +/**********************************************************************\ + * Support for a filament diameter sensor + * Also allows adjustment of diameter at print time (vs at slicing) + * Single extruder only at this point (extruder 0) + * + * Motherboards + * 34 - RAMPS1.4 - uses Analog input 5 on the AUX2 connector + * 81 - Printrboard - Uses Analog input 2 on the Exp1 connector (version B,C,D,E) + * 301 - Rambo - uses Analog input 3 + * Note may require analog pins to be defined for different motherboards + **********************************************************************/ +// Uncomment below to enable +//#define FILAMENT_WIDTH_SENSOR + +#define DEFAULT_NOMINAL_FILAMENT_DIA 3.00 //Enter the diameter (in mm) of the filament generally used (3.0 mm or 1.75 mm) - this is then used in the slicer software. Used for sensor reading validation + +#if ENABLED(FILAMENT_WIDTH_SENSOR) + #define FILAMENT_SENSOR_EXTRUDER_NUM 0 //The number of the extruder that has the filament sensor (0,1,2) + #define MEASUREMENT_DELAY_CM 14 //measurement delay in cm. This is the distance from filament sensor to middle of barrel + + #define MEASURED_UPPER_LIMIT 3.30 //upper limit factor used for sensor reading validation in mm + #define MEASURED_LOWER_LIMIT 1.90 //lower limit factor for sensor reading validation in mm + #define MAX_MEASUREMENT_DELAY 20 //delay buffer size in bytes (1 byte = 1cm)- limits maximum measurement delay allowable (must be larger than MEASUREMENT_DELAY_CM and lower number saves RAM) + + #define DEFAULT_MEASURED_FILAMENT_DIA DEFAULT_NOMINAL_FILAMENT_DIA //set measured to nominal initially + + //When using an LCD, uncomment the line below to display the Filament sensor data on the last line instead of status. Status will appear for 5 sec. + //#define FILAMENT_LCD_DISPLAY +#endif + +#endif // CONFIGURATION_H diff --git a/Marlin/example_configurations/Roxys_printers/gMax_1.5+/Configuration_adv.h b/Marlin/example_configurations/Roxys_printers/gMax_1.5+/Configuration_adv.h new file mode 100644 index 000000000..af217e50d --- /dev/null +++ b/Marlin/example_configurations/Roxys_printers/gMax_1.5+/Configuration_adv.h @@ -0,0 +1,1085 @@ +/** + * 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 . + * + */ + +/** + * Configuration_adv.h + * + * Advanced settings. + * Only change these if you know exactly what you're doing. + * Some of these settings can damage your printer if improperly set! + * + * Basic settings can be found in Configuration.h + * + */ +#ifndef CONFIGURATION_ADV_H +#define CONFIGURATION_ADV_H + +/** + * + * *********************************** + * ** ATTENTION TO ALL DEVELOPERS ** + * *********************************** + * + * You must increment this version number for every significant change such as, + * but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option. + * + * Note: Update also Version.h ! + */ +#define CONFIGURATION_ADV_H_VERSION 010100 + +// @section temperature + +//=========================================================================== +//=============================Thermal Settings ============================ +//=========================================================================== + +#if DISABLED(PIDTEMPBED) + #define BED_CHECK_INTERVAL 5000 // ms between checks in bang-bang control + #if ENABLED(BED_LIMIT_SWITCHING) + #define BED_HYSTERESIS 2 // Only disable heating if T>target+BED_HYSTERESIS and enable heating if T>target-BED_HYSTERESIS + #endif +#endif + +/** + * Thermal Protection protects your printer from damage and fire if a + * thermistor falls out or temperature sensors fail in any way. + * + * The issue: If a thermistor falls out or a temperature sensor fails, + * Marlin can no longer sense the actual temperature. Since a disconnected + * thermistor reads as a low temperature, the firmware will keep the heater on. + * + * The solution: Once the temperature reaches the target, start observing. + * If the temperature stays too far below the target (hysteresis) for too long (period), + * the firmware will halt the machine as a safety precaution. + * + * If you get false positives for "Thermal Runaway" increase THERMAL_PROTECTION_HYSTERESIS and/or THERMAL_PROTECTION_PERIOD + */ +#if ENABLED(THERMAL_PROTECTION_HOTENDS) + #define THERMAL_PROTECTION_PERIOD 40 // Seconds + #define THERMAL_PROTECTION_HYSTERESIS 4 // Degrees Celsius + + /** + * Whenever an M104 or M109 increases the target temperature the firmware will wait for the + * WATCH_TEMP_PERIOD to expire, and if the temperature hasn't increased by WATCH_TEMP_INCREASE + * degrees, the machine is halted, requiring a hard reset. This test restarts with any M104/M109, + * but only if the current temperature is far enough below the target for a reliable test. + * + * If you get false positives for "Heating failed" increase WATCH_TEMP_PERIOD and/or decrease WATCH_TEMP_INCREASE + * WATCH_TEMP_INCREASE should not be below 2. + */ + #define WATCH_TEMP_PERIOD 20 // Seconds + #define WATCH_TEMP_INCREASE 2 // Degrees Celsius +#endif + +/** + * Thermal Protection parameters for the bed are just as above for hotends. + */ +#if ENABLED(THERMAL_PROTECTION_BED) + #define THERMAL_PROTECTION_BED_PERIOD 20 // Seconds + #define THERMAL_PROTECTION_BED_HYSTERESIS 2 // Degrees Celsius + + /** + * Whenever an M140 or M190 increases the target temperature the firmware will wait for the + * WATCH_BED_TEMP_PERIOD to expire, and if the temperature hasn't increased by WATCH_BED_TEMP_INCREASE + * degrees, the machine is halted, requiring a hard reset. This test restarts with any M140/M190, + * but only if the current temperature is far enough below the target for a reliable test. + * + * If you get too many "Heating failed" errors, increase WATCH_BED_TEMP_PERIOD and/or decrease + * WATCH_BED_TEMP_INCREASE. (WATCH_BED_TEMP_INCREASE should not be below 2.) + */ + #define WATCH_BED_TEMP_PERIOD 60 // Seconds + #define WATCH_BED_TEMP_INCREASE 2 // Degrees Celsius +#endif + +#if ENABLED(PIDTEMP) + // this adds an experimental additional term to the heating power, proportional to the extrusion speed. + // if Kc is chosen well, the additional required power due to increased melting should be compensated. + //#define PID_EXTRUSION_SCALING + #if ENABLED(PID_EXTRUSION_SCALING) + #define DEFAULT_Kc (100) //heating power=Kc*(e_speed) + #define LPQ_MAX_LEN 50 + #endif +#endif + +/** + * Automatic Temperature: + * The hotend target temperature is calculated by all the buffered lines of gcode. + * The maximum buffered steps/sec of the extruder motor is called "se". + * Start autotemp mode with M109 S B F + * The target temperature is set to mintemp+factor*se[steps/sec] and is limited by + * mintemp and maxtemp. Turn this off by executing M109 without F* + * Also, if the temperature is set to a value below mintemp, it will not be changed by autotemp. + * On an Ultimaker, some initial testing worked with M109 S215 B260 F1 in the start.gcode + */ +#define AUTOTEMP +#if ENABLED(AUTOTEMP) + #define AUTOTEMP_OLDWEIGHT 0.98 +#endif + +//Show Temperature ADC value +//The M105 command return, besides traditional information, the ADC value read from temperature sensors. +//#define SHOW_TEMP_ADC_VALUES + +/** + * High Temperature Thermistor Support + * + * Thermistors able to support high temperature tend to have a hard time getting + * good readings at room and lower temperatures. This means HEATER_X_RAW_LO_TEMP + * will probably be caught when the heating element first turns on during the + * preheating process, which will trigger a min_temp_error as a safety measure + * and force stop everything. + * To circumvent this limitation, we allow for a preheat time (during which, + * min_temp_error won't be triggered) and add a min_temp buffer to handle + * aberrant readings. + * + * If you want to enable this feature for your hotend thermistor(s) + * uncomment and set values > 0 in the constants below + */ + +// The number of consecutive low temperature errors that can occur +// before a min_temp_error is triggered. (Shouldn't be more than 10.) +//#define MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED 0 + +// The number of milliseconds a hotend will preheat before starting to check +// the temperature. This value should NOT be set to the time it takes the +// hot end to reach the target temperature, but the time it takes to reach +// the minimum temperature your thermistor can read. The lower the better/safer. +// This shouldn't need to be more than 30 seconds (30000) +//#define MILLISECONDS_PREHEAT_TIME 0 + +// @section extruder + +// Extruder runout prevention. +// If the machine is idle and the temperature over MINTEMP +// then extrude some filament every couple of SECONDS. +//#define EXTRUDER_RUNOUT_PREVENT +#if ENABLED(EXTRUDER_RUNOUT_PREVENT) + #define EXTRUDER_RUNOUT_MINTEMP 190 + #define EXTRUDER_RUNOUT_SECONDS 30 + #define EXTRUDER_RUNOUT_SPEED 1500 // mm/m + #define EXTRUDER_RUNOUT_EXTRUDE 5 // mm +#endif + +// @section temperature + +//These defines help to calibrate the AD595 sensor in case you get wrong temperature measurements. +//The measured temperature is defined as "actualTemp = (measuredTemp * TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET" +#define TEMP_SENSOR_AD595_OFFSET 0.0 +#define TEMP_SENSOR_AD595_GAIN 1.0 + +//This is for controlling a fan to cool down the stepper drivers +//it will turn on when any driver is enabled +//and turn off after the set amount of seconds from last driver being disabled again +#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) +#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run +#define CONTROLLERFAN_SPEED 255 // == full speed + +// When first starting the main fan, run it at full speed for the +// given number of milliseconds. This gets the fan spinning reliably +// before setting a PWM value. (Does not work with software PWM for fan on Sanguinololu) +//#define FAN_KICKSTART_TIME 100 + +// This defines the minimal speed for the main fan, run in PWM mode +// to enable uncomment and set minimal PWM speed for reliable running (1-255) +// if fan speed is [1 - (FAN_MIN_PWM-1)] it is set to FAN_MIN_PWM +//#define FAN_MIN_PWM 50 + +// @section extruder + +/** + * Extruder cooling fans + * + * Extruder auto fans automatically turn on when their extruders' + * temperatures go above EXTRUDER_AUTO_FAN_TEMPERATURE. + * + * Your board's pins file specifies the recommended pins. Override those here + * or set to -1 to disable completely. + * + * Multiple extruders can be assigned to the same pin in which case + * the fan will turn on when any selected extruder is above the threshold. + */ +#define E0_AUTO_FAN_PIN -1 +#define E1_AUTO_FAN_PIN -1 +#define E2_AUTO_FAN_PIN -1 +#define E3_AUTO_FAN_PIN -1 +#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 +#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed + +// Define a pin to turn case light on/off +//#define CASE_LIGHT_PIN 4 +#if PIN_EXISTS(CASE_LIGHT) + #define INVERT_CASE_LIGHT false // Set to true if HIGH is the OFF state (active low) + //#define CASE_LIGHT_DEFAULT_ON // Uncomment to set default state to on + //#define MENU_ITEM_CASE_LIGHT // Uncomment to have a Case Light On / Off entry in main menu +#endif + +//=========================================================================== +//============================ Mechanical Settings ========================== +//=========================================================================== + +// @section homing + +// If you want endstops to stay on (by default) even when not homing +// enable this option. Override at any time with M120, M121. +//#define ENDSTOPS_ALWAYS_ON_DEFAULT + +// @section extras + +//#define Z_LATE_ENABLE // Enable Z the last moment. Needed if your Z driver overheats. + +// Dual X Steppers +// Uncomment this option to drive two X axis motors. +// The next unused E driver will be assigned to the second X stepper. +//#define X_DUAL_STEPPER_DRIVERS +#if ENABLED(X_DUAL_STEPPER_DRIVERS) + // Set true if the two X motors need to rotate in opposite directions + #define INVERT_X2_VS_X_DIR true +#endif + + +// Dual Y Steppers +// Uncomment this option to drive two Y axis motors. +// The next unused E driver will be assigned to the second Y stepper. +//#define Y_DUAL_STEPPER_DRIVERS +#if ENABLED(Y_DUAL_STEPPER_DRIVERS) + // Set true if the two Y motors need to rotate in opposite directions + #define INVERT_Y2_VS_Y_DIR true +#endif + +// A single Z stepper driver is usually used to drive 2 stepper motors. +// Uncomment this option to use a separate stepper driver for each Z axis motor. +// The next unused E driver will be assigned to the second Z stepper. +//#define Z_DUAL_STEPPER_DRIVERS + +#if ENABLED(Z_DUAL_STEPPER_DRIVERS) + + // Z_DUAL_ENDSTOPS is a feature to enable the use of 2 endstops for both Z steppers - Let's call them Z stepper and Z2 stepper. + // That way the machine is capable to align the bed during home, since both Z steppers are homed. + // There is also an implementation of M666 (software endstops adjustment) to this feature. + // After Z homing, this adjustment is applied to just one of the steppers in order to align the bed. + // One just need to home the Z axis and measure the distance difference between both Z axis and apply the math: Z adjust = Z - Z2. + // If the Z stepper axis is closer to the bed, the measure Z > Z2 (yes, it is.. think about it) and the Z adjust would be positive. + // Play a little bit with small adjustments (0.5mm) and check the behaviour. + // The M119 (endstops report) will start reporting the Z2 Endstop as well. + + //#define Z_DUAL_ENDSTOPS + + #if ENABLED(Z_DUAL_ENDSTOPS) + #define Z2_USE_ENDSTOP _XMAX_ + #endif + +#endif // Z_DUAL_STEPPER_DRIVERS + +// Enable this for dual x-carriage printers. +// A dual x-carriage design has the advantage that the inactive extruder can be parked which +// prevents hot-end ooze contaminating the print. It also reduces the weight of each x-carriage +// allowing faster printing speeds. Connect your X2 stepper to the first unused E plug. +//#define DUAL_X_CARRIAGE +#if ENABLED(DUAL_X_CARRIAGE) + // Configuration for second X-carriage + // Note: the first x-carriage is defined as the x-carriage which homes to the minimum endstop; + // the second x-carriage always homes to the maximum endstop. + #define X2_MIN_POS 80 // set minimum to ensure second x-carriage doesn't hit the parked first X-carriage + #define X2_MAX_POS 353 // set maximum to the distance between toolheads when both heads are homed + #define X2_HOME_DIR 1 // the second X-carriage always homes to the maximum endstop position + #define X2_HOME_POS X2_MAX_POS // default home position is the maximum carriage position + // However: In this mode the HOTEND_OFFSET_X value for the second extruder provides a software + // override for X2_HOME_POS. This also allow recalibration of the distance between the two endstops + // without modifying the firmware (through the "M218 T1 X???" command). + // Remember: you should set the second extruder x-offset to 0 in your slicer. + + // There are a few selectable movement modes for dual x-carriages using M605 S + // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results + // as long as it supports dual x-carriages. (M605 S0) + // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so + // that additional slicer support is not required. (M605 S1) + // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all + // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at + // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) + + // This is the default power-up mode which can be later using M605. + #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE + + // Default settings in "Auto-park Mode" + #define TOOLCHANGE_PARK_ZLIFT 0.2 // the distance to raise Z axis when parking an extruder + #define TOOLCHANGE_UNPARK_ZLIFT 1 // the distance to raise Z axis when unparking an extruder + + // Default x offset in duplication mode (typically set to half print bed width) + #define DEFAULT_DUPLICATION_X_OFFSET 100 + +#endif //DUAL_X_CARRIAGE + +// @section homing + +//homing hits the endstop, then retracts by this distance, before it tries to slowly bump again: +#define X_HOME_BUMP_MM 5 +#define Y_HOME_BUMP_MM 5 +#define Z_HOME_BUMP_MM 2 +#define HOMING_BUMP_DIVISOR {2, 2, 4} // Re-Bump Speed Divisor (Divides the Homing Feedrate) +//#define QUICK_HOME //if this is defined, if both x and y are to be homed, a diagonal move will be performed initially. + +// When G28 is called, this option will make Y home before X +//#define HOME_Y_BEFORE_X + +// @section machine + +#define AXIS_RELATIVE_MODES {false, false, false, false} + +// Allow duplication mode with a basic dual-nozzle extruder +//#define DUAL_NOZZLE_DUPLICATION_MODE + +// By default pololu step drivers require an active high signal. However, some high power drivers require an active low signal as step. +#define INVERT_X_STEP_PIN false +#define INVERT_Y_STEP_PIN false +#define INVERT_Z_STEP_PIN false +#define INVERT_E_STEP_PIN false + +// Default stepper release if idle. Set to 0 to deactivate. +// Steppers will shut down DEFAULT_STEPPER_DEACTIVE_TIME seconds after the last move when DISABLE_INACTIVE_? is true. +// Time can be set by M18 and M84. +#define DEFAULT_STEPPER_DEACTIVE_TIME 120 +#define DISABLE_INACTIVE_X true +#define DISABLE_INACTIVE_Y true +#define DISABLE_INACTIVE_Z true // set to false if the nozzle will fall down on your printed part when print has finished. +#define DISABLE_INACTIVE_E true + +#define DEFAULT_MINIMUMFEEDRATE 0.0 // minimum feedrate +#define DEFAULT_MINTRAVELFEEDRATE 0.0 + +// @section lcd + +#if ENABLED(ULTIPANEL) + #define MANUAL_FEEDRATE {50*60, 50*60, 4*60, 60} // Feedrates for manual moves along X, Y, Z, E from panel + #define ULTIPANEL_FEEDMULTIPLY // Comment to disable setting feedrate multiplier via encoder +#endif + +// @section extras + +// minimum time in microseconds that a movement needs to take if the buffer is emptied. +#define DEFAULT_MINSEGMENTTIME 20000 + +// If defined the movements slow down when the look ahead buffer is only half full +#define SLOWDOWN + +// Frequency limit +// See nophead's blog for more info +// Not working O +//#define XY_FREQUENCY_LIMIT 15 + +// Minimum planner junction speed. Sets the default minimum speed the planner plans for at the end +// of the buffer and all stops. This should not be much greater than zero and should only be changed +// if unwanted behavior is observed on a user's machine when running at very slow speeds. +#define MINIMUM_PLANNER_SPEED 0.05// (mm/sec) + +// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. +#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] + +// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) +#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) + +// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) +//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps + +// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro +//#define DIGIPOT_I2C +// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 +#define DIGIPOT_I2C_NUM_CHANNELS 8 +// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS +#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} + +//=========================================================================== +//=============================Additional Features=========================== +//=========================================================================== + +#define ENCODER_RATE_MULTIPLIER // If defined, certain menu edit operations automatically multiply the steps when the encoder is moved quickly +#define ENCODER_10X_STEPS_PER_SEC 75 // If the encoder steps per sec exceeds this value, multiply steps moved x10 to quickly advance the value +#define ENCODER_100X_STEPS_PER_SEC 160 // If the encoder steps per sec exceeds this value, multiply steps moved x100 to really quickly advance the value + +//#define CHDK 4 //Pin for triggering CHDK to take a picture see how to use it here http://captain-slow.dk/2014/03/09/3d-printing-timelapses/ +#define CHDK_DELAY 50 //How long in ms the pin should stay HIGH before going LOW again + +// @section lcd + +// Include a page of printer information in the LCD Main Menu +//#define LCD_INFO_MENU + +// On the Info Screen, display XY with one decimal place when possible +//#define LCD_DECIMAL_SMALL_XY + +// The timeout (in ms) to return to the status screen from sub-menus +//#define LCD_TIMEOUT_TO_STATUS 15000 + +#if ENABLED(SDSUPPORT) + + // Some RAMPS and other boards don't detect when an SD card is inserted. You can work + // around this by connecting a push button or single throw switch to the pin defined + // as SD_DETECT_PIN in your board's pins definitions. + // This setting should be disabled unless you are using a push button, pulling the pin to ground. + // Note: This is always disabled for ULTIPANEL (except ELB_FULL_GRAPHIC_CONTROLLER). + #define SD_DETECT_INVERTED + + #define SD_FINISHED_STEPPERRELEASE true //if sd support and the file is finished: disable steppers? + #define SD_FINISHED_RELEASECOMMAND "M84 X Y Z E" // You might want to keep the z enabled so your bed stays in place. + + #define SDCARD_RATHERRECENTFIRST //reverse file order of sd card menu display. Its sorted practically after the file system block order. + // if a file is deleted, it frees a block. hence, the order is not purely chronological. To still have auto0.g accessible, there is again the option to do that. + // using: + //#define MENU_ADDAUTOSTART + + /** + * Sort SD file listings in alphabetical order. + * + * With this option enabled, items on SD cards will be sorted + * by name for easier navigation. + * + * By default... + * + * - Use the slowest -but safest- method for sorting. + * - Folders are sorted to the top. + * - The sort key is statically allocated. + * - No added G-code (M34) support. + * - 40 item sorting limit. (Items after the first 40 are unsorted.) + * + * SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the + * compiler to calculate the worst-case usage and throw an error if the SRAM + * limit is exceeded. + * + * - SDSORT_USES_RAM provides faster sorting via a static directory buffer. + * - SDSORT_USES_STACK does the same, but uses a local stack-based buffer. + * - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!) + * - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!) + */ + //#define SDCARD_SORT_ALPHA + + // SD Card Sorting options + #if ENABLED(SDCARD_SORT_ALPHA) + #define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256). + #define FOLDER_SORTING -1 // -1=above 0=none 1=below + #define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code. + #define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting. + #define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.) + #define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option. + #define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use! + #endif + + // Show a progress bar on HD44780 LCDs for SD printing + //#define LCD_PROGRESS_BAR + + #if ENABLED(LCD_PROGRESS_BAR) + // Amount of time (ms) to show the bar + #define PROGRESS_BAR_BAR_TIME 2000 + // Amount of time (ms) to show the status message + #define PROGRESS_BAR_MSG_TIME 3000 + // Amount of time (ms) to retain the status message (0=forever) + #define PROGRESS_MSG_EXPIRE 0 + // Enable this to show messages for MSG_TIME then hide them + //#define PROGRESS_MSG_ONCE + // Add a menu item to test the progress bar: + //#define LCD_PROGRESS_BAR_TEST + #endif + + // This allows hosts to request long names for files and folders with M33 + //#define LONG_FILENAME_HOST_SUPPORT + + // This option allows you to abort SD printing when any endstop is triggered. + // This feature must be enabled with "M540 S1" or from the LCD menu. + // To have any effect, endstops must be enabled during SD printing. + //#define ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED + +#endif // SDSUPPORT + +/** + * Additional options for Graphical Displays + * + * Use the optimizations here to improve printing performance, + * which can be adversely affected by graphical display drawing, + * especially when doing several short moves, and when printing + * on DELTA and SCARA machines. + * + * Some of these options may result in the display lagging behind + * controller events, as there is a trade-off between reliable + * printing performance versus fast display updates. + */ +#if ENABLED(DOGLCD) + // Enable to save many cycles by drawing a hollow frame on the Info Screen + #define XYZ_HOLLOW_FRAME + + // Enable to save many cycles by drawing a hollow frame on Menu Screens + #define MENU_HOLLOW_FRAME + + // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. + // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. + //#define USE_BIG_EDIT_FONT + + // A smaller font may be used on the Info Screen. Costs 2300 bytes of PROGMEM. + // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. + //#define USE_SMALL_INFOFONT + + // Enable this option and reduce the value to optimize screen updates. + // The normal delay is 10µs. Use the lowest value that still gives a reliable display. + //#define DOGM_SPI_DELAY_US 5 +#endif // DOGLCD + +// @section safety + +// The hardware watchdog should reset the microcontroller disabling all outputs, +// in case the firmware gets stuck and doesn't do temperature regulation. +#define USE_WATCHDOG + +#if ENABLED(USE_WATCHDOG) + // If you have a watchdog reboot in an ArduinoMega2560 then the device will hang forever, as a watchdog reset will leave the watchdog on. + // The "WATCHDOG_RESET_MANUAL" goes around this by not using the hardware reset. + // However, THIS FEATURE IS UNSAFE!, as it will only work if interrupts are disabled. And the code could hang in an interrupt routine with interrupts disabled. + //#define WATCHDOG_RESET_MANUAL +#endif + +// @section lcd + +// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process +// it can e.g. be used to change z-positions in the print startup phase in real-time +// does not respect endstops! +//#define BABYSTEPPING +#if ENABLED(BABYSTEPPING) + #define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions + //not implemented for deltabots! + #define BABYSTEP_INVERT_Z false //true for inverse movements in Z + #define BABYSTEP_MULTIPLICATOR 1 //faster movements +#endif + +// @section extruder + +// extruder advance constant (s2/mm3) +// +// advance (steps) = STEPS_PER_CUBIC_MM_E * EXTRUDER_ADVANCE_K * cubic mm per second ^ 2 +// +// Hooke's law says: force = k * distance +// Bernoulli's principle says: v ^ 2 / 2 + g . h + pressure / density = constant +// so: v ^ 2 is proportional to number of steps we advance the extruder +//#define ADVANCE + +#if ENABLED(ADVANCE) + #define EXTRUDER_ADVANCE_K .0 + #define D_FILAMENT 2.85 +#endif + +/** + * Implementation of linear pressure control + * + * Assumption: advance = k * (delta velocity) + * K=0 means advance disabled. + * See Marlin documentation for calibration instructions. + */ +//#define LIN_ADVANCE + +#if ENABLED(LIN_ADVANCE) + #define LIN_ADVANCE_K 75 + + /** + * Some Slicers produce Gcode with randomly jumping extrusion widths occasionally. + * For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width. + * While this is harmless for normal printing (the fluid nature of the filament will + * close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption. + * + * For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio + * to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures + * if the slicer is using variable widths or layer heights within one print! + * + * This option sets the default E:D ratio at startup. Use `M905` to override this value. + * + * Example: `M905 W0.4 H0.2 D1.75`, where: + * - W is the extrusion width in mm + * - H is the layer height in mm + * - D is the filament diameter in mm + * + * Set to 0 to auto-detect the ratio based on given Gcode G1 print moves. + * + * Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode. + * Cura (as of this writing) may produce Gcode incompatible with the automatic mode. + */ + #define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI) + // Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135 +#endif + +// @section leveling + +// Default mesh area is an area with an inset margin on the print area. +// Below are the macros that are used to define the borders for the mesh area, +// made available here for specialized needs, ie dual extruder setup. +#if ENABLED(MESH_BED_LEVELING) + #define MESH_MIN_X (X_MIN_POS + MESH_INSET) + #define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) + #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) + #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) +#endif + +#if ENABLED(AUTO_BED_LEVELING_UBL) + #define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET) + #define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET)) + #define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET) + #define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET)) +#endif + +// @section extras + +// Arc interpretation settings: +#define ARC_SUPPORT // Disabling this saves ~2738 bytes +#define MM_PER_ARC_SEGMENT 1 +#define N_ARC_CORRECTION 25 + +// Support for G5 with XYZE destination and IJPQ offsets. Requires ~2666 bytes. +//#define BEZIER_CURVE_SUPPORT + +// G38.2 and G38.3 Probe Target +//#define G38_PROBE_TARGET +#if ENABLED(G38_PROBE_TARGET) + #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) +#endif + +// Moves (or segments) with fewer steps than this will be joined with the next move +#define MIN_STEPS_PER_SEGMENT 6 + +// The minimum pulse width (in µs) for stepping a stepper. +// Set this if you find stepping unreliable, or if using a very fast CPU. +#define MINIMUM_STEPPER_PULSE 0 // (µs) The smallest stepper pulse allowed + +// @section temperature + +// Control heater 0 and heater 1 in parallel. +//#define HEATERS_PARALLEL + +//=========================================================================== +//================================= Buffers ================================= +//=========================================================================== + +// @section hidden + +// The number of linear motions that can be in the plan at any give time. +// THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2, i.g. 8,16,32 because shifts and ors are used to do the ring-buffering. +#if ENABLED(SDSUPPORT) + #define BLOCK_BUFFER_SIZE 16 // SD,LCD,Buttons take more memory, block buffer needs to be smaller +#else + #define BLOCK_BUFFER_SIZE 16 // maximize block buffer +#endif + +// @section serial + +// The ASCII buffer for serial input +#define MAX_CMD_SIZE 96 +#define BUFSIZE 4 + +// Transfer Buffer Size +// To save 386 bytes of PROGMEM (and TX_BUFFER_SIZE+3 bytes of RAM) set to 0. +// To buffer a simple "ok" you need 4 bytes. +// For ADVANCED_OK (M105) you need 32 bytes. +// For debug-echo: 128 bytes for the optimal speed. +// Other output doesn't need to be that speedy. +// :[0, 2, 4, 8, 16, 32, 64, 128, 256] +#define TX_BUFFER_SIZE 0 + +// Enable an emergency-command parser to intercept certain commands as they +// enter the serial receive buffer, so they cannot be blocked. +// Currently handles M108, M112, M410 +// Does not work on boards using AT90USB (USBCON) processors! +//#define EMERGENCY_PARSER + +// Bad Serial-connections can miss a received command by sending an 'ok' +// Therefore some clients abort after 30 seconds in a timeout. +// Some other clients start sending commands while receiving a 'wait'. +// This "wait" is only sent when the buffer is empty. 1 second is a good value here. +//#define NO_TIMEOUTS 1000 // Milliseconds + +// Some clients will have this feature soon. This could make the NO_TIMEOUTS unnecessary. +//#define ADVANCED_OK + +// @section fwretract + +// Firmware based and LCD controlled retract +// M207 and M208 can be used to define parameters for the retraction. +// The retraction can be called by the slicer using G10 and G11 +// until then, intended retractions can be detected by moves that only extrude and the direction. +// the moves are than replaced by the firmware controlled ones. + +//#define FWRETRACT //ONLY PARTIALLY TESTED +#if ENABLED(FWRETRACT) + #define MIN_RETRACT 0.1 //minimum extruded mm to accept a automatic gcode retraction attempt + #define RETRACT_LENGTH 3 //default retract length (positive mm) + #define RETRACT_LENGTH_SWAP 13 //default swap retract length (positive mm), for extruder change + #define RETRACT_FEEDRATE 45 //default feedrate for retracting (mm/s) + #define RETRACT_ZLIFT 0 //default retract Z-lift + #define RETRACT_RECOVER_LENGTH 0 //default additional recover length (mm, added to retract length when recovering) + #define RETRACT_RECOVER_LENGTH_SWAP 0 //default additional swap recover length (mm, added to retract length when recovering from extruder change) + #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) +#endif + +/** + * Filament Change + * Experimental filament change support. + * Adds the GCode M600 for initiating filament change. + * + * Requires an LCD display. + * This feature is required for the default FILAMENT_RUNOUT_SCRIPT. + */ +//#define FILAMENT_CHANGE_FEATURE +#if ENABLED(FILAMENT_CHANGE_FEATURE) + #define FILAMENT_CHANGE_X_POS 3 // X position of hotend + #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend + #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) + #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) + #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) + #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s + #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm + // It is a short retract used immediately after print interrupt before move to filament exchange position + #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast + #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm + // Longer length for bowden printers to unload filament from whole bowden tube, + // shorter length for printers without bowden to unload filament from extruder only, + // 0 to disable unloading for manual unloading + #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast + #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm + // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, + // Short or zero length for printers without bowden where loading is not used + #define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate + #define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend, + // 0 to disable for manual extrusion + // Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, + // or until outcoming filament color is not clear for filament color change + #define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45L // Turn off nozzle if user doesn't change filament within this time limit in seconds + #define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5L // Number of alert beeps before printer goes quiet + #define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change + // even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME. +#endif + +// @section tmc + +/** + * Enable this section if you have TMC26X motor drivers. + * You will need to import the TMC26XStepper library into the Arduino IDE for this + * (https://github.com/trinamic/TMC26XStepper.git) + */ +//#define HAVE_TMCDRIVER + +#if ENABLED(HAVE_TMCDRIVER) + + //#define X_IS_TMC + //#define X2_IS_TMC + //#define Y_IS_TMC + //#define Y2_IS_TMC + //#define Z_IS_TMC + //#define Z2_IS_TMC + //#define E0_IS_TMC + //#define E1_IS_TMC + //#define E2_IS_TMC + //#define E3_IS_TMC + + #define X_MAX_CURRENT 1000 // in mA + #define X_SENSE_RESISTOR 91 // in mOhms + #define X_MICROSTEPS 16 // number of microsteps + + #define X2_MAX_CURRENT 1000 + #define X2_SENSE_RESISTOR 91 + #define X2_MICROSTEPS 16 + + #define Y_MAX_CURRENT 1000 + #define Y_SENSE_RESISTOR 91 + #define Y_MICROSTEPS 16 + + #define Y2_MAX_CURRENT 1000 + #define Y2_SENSE_RESISTOR 91 + #define Y2_MICROSTEPS 16 + + #define Z_MAX_CURRENT 1000 + #define Z_SENSE_RESISTOR 91 + #define Z_MICROSTEPS 16 + + #define Z2_MAX_CURRENT 1000 + #define Z2_SENSE_RESISTOR 91 + #define Z2_MICROSTEPS 16 + + #define E0_MAX_CURRENT 1000 + #define E0_SENSE_RESISTOR 91 + #define E0_MICROSTEPS 16 + + #define E1_MAX_CURRENT 1000 + #define E1_SENSE_RESISTOR 91 + #define E1_MICROSTEPS 16 + + #define E2_MAX_CURRENT 1000 + #define E2_SENSE_RESISTOR 91 + #define E2_MICROSTEPS 16 + + #define E3_MAX_CURRENT 1000 + #define E3_SENSE_RESISTOR 91 + #define E3_MICROSTEPS 16 + +#endif + +// @section TMC2130 + +/** + * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. + * + * You'll also need the TMC2130Stepper Arduino library + * (https://github.com/teemuatlut/TMC2130Stepper). + * + * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to + * the hardware SPI interface on your board and define the required CS pins + * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). + */ +//#define HAVE_TMC2130 + +#if ENABLED(HAVE_TMC2130) + #define STEALTHCHOP + + /** + * Let Marlin automatically control stepper current. + * This is still an experimental feature. + * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered, + * then decrease current by CURRENT_STEP until temperature prewarn is cleared. + * Adjusting starts from X/Y/Z/E_MAX_CURRENT but will not increase over AUTO_ADJUST_MAX + */ + //#define AUTOMATIC_CURRENT_CONTROL + #define CURRENT_STEP 50 // [mA] + #define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak + + // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY + //#define X_IS_TMC2130 + //#define X2_IS_TMC2130 + //#define Y_IS_TMC2130 + //#define Y2_IS_TMC2130 + //#define Z_IS_TMC2130 + //#define Z2_IS_TMC2130 + //#define E0_IS_TMC2130 + //#define E1_IS_TMC2130 + //#define E2_IS_TMC2130 + //#define E3_IS_TMC2130 + + /** + * Stepper driver settings + */ + + #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130 + #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current + #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256 + + #define X_MAX_CURRENT 1000 // rms current in mA + #define X_MICROSTEPS 16 // FULLSTEP..256 + #define X_CHIP_SELECT 40 // Pin + + #define Y_MAX_CURRENT 1000 + #define Y_MICROSTEPS 16 + #define Y_CHIP_SELECT 42 + + #define Z_MAX_CURRENT 1000 + #define Z_MICROSTEPS 16 + #define Z_CHIP_SELECT 65 + + //#define X2_MAX_CURRENT 1000 + //#define X2_MICROSTEPS 16 + //#define X2_CHIP_SELECT -1 + + //#define Y2_MAX_CURRENT 1000 + //#define Y2_MICROSTEPS 16 + //#define Y2_CHIP_SELECT -1 + + //#define Z2_MAX_CURRENT 1000 + //#define Z2_MICROSTEPS 16 + //#define Z2_CHIP_SELECT -1 + + //#define E0_MAX_CURRENT 1000 + //#define E0_MICROSTEPS 16 + //#define E0_CHIP_SELECT -1 + + //#define E1_MAX_CURRENT 1000 + //#define E1_MICROSTEPS 16 + //#define E1_CHIP_SELECT -1 + + //#define E2_MAX_CURRENT 1000 + //#define E2_MICROSTEPS 16 + //#define E2_CHIP_SELECT -1 + + //#define E3_MAX_CURRENT 1000 + //#define E3_MICROSTEPS 16 + //#define E3_CHIP_SELECT -1 + + /** + * You can set your own advanced settings by filling in predefined functions. + * A list of available functions can be found on the library github page + * https://github.com/teemuatlut/TMC2130Stepper + * + * Example: + * #define TMC2130_ADV() { \ + * stepperX.diag0_temp_prewarn(1); \ + * stepperX.interpolate(0); \ + * } + */ + #define TMC2130_ADV() { } + +#endif // ENABLED(HAVE_TMC2130) + +/** + * Enable this section if you have L6470 motor drivers. + * You need to import the L6470 library into the Arduino IDE for this. + * (https://github.com/ameyer/Arduino-L6470) + */ + +// @section l6470 + +//#define HAVE_L6470DRIVER +#if ENABLED(HAVE_L6470DRIVER) + + //#define X_IS_L6470 + //#define X2_IS_L6470 + //#define Y_IS_L6470 + //#define Y2_IS_L6470 + //#define Z_IS_L6470 + //#define Z2_IS_L6470 + //#define E0_IS_L6470 + //#define E1_IS_L6470 + //#define E2_IS_L6470 + //#define E3_IS_L6470 + + #define X_MICROSTEPS 16 // number of microsteps + #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high + #define X_OVERCURRENT 2000 // maxc current in mA. If the current goes over this value, the driver will switch off + #define X_STALLCURRENT 1500 // current in mA where the driver will detect a stall + + #define X2_MICROSTEPS 16 + #define X2_K_VAL 50 + #define X2_OVERCURRENT 2000 + #define X2_STALLCURRENT 1500 + + #define Y_MICROSTEPS 16 + #define Y_K_VAL 50 + #define Y_OVERCURRENT 2000 + #define Y_STALLCURRENT 1500 + + #define Y2_MICROSTEPS 16 + #define Y2_K_VAL 50 + #define Y2_OVERCURRENT 2000 + #define Y2_STALLCURRENT 1500 + + #define Z_MICROSTEPS 16 + #define Z_K_VAL 50 + #define Z_OVERCURRENT 2000 + #define Z_STALLCURRENT 1500 + + #define Z2_MICROSTEPS 16 + #define Z2_K_VAL 50 + #define Z2_OVERCURRENT 2000 + #define Z2_STALLCURRENT 1500 + + #define E0_MICROSTEPS 16 + #define E0_K_VAL 50 + #define E0_OVERCURRENT 2000 + #define E0_STALLCURRENT 1500 + + #define E1_MICROSTEPS 16 + #define E1_K_VAL 50 + #define E1_OVERCURRENT 2000 + #define E1_STALLCURRENT 1500 + + #define E2_MICROSTEPS 16 + #define E2_K_VAL 50 + #define E2_OVERCURRENT 2000 + #define E2_STALLCURRENT 1500 + + #define E3_MICROSTEPS 16 + #define E3_K_VAL 50 + #define E3_OVERCURRENT 2000 + #define E3_STALLCURRENT 1500 + +#endif + +/** + * TWI/I2C BUS + * + * This feature is an EXPERIMENTAL feature so it shall not be used on production + * machines. Enabling this will allow you to send and receive I2C data from slave + * devices on the bus. + * + * ; Example #1 + * ; This macro send the string "Marlin" to the slave device with address 0x63 (99) + * ; It uses multiple M260 commands with one B arg + * M260 A99 ; Target slave address + * M260 B77 ; M + * M260 B97 ; a + * M260 B114 ; r + * M260 B108 ; l + * M260 B105 ; i + * M260 B110 ; n + * M260 S1 ; Send the current buffer + * + * ; Example #2 + * ; Request 6 bytes from slave device with address 0x63 (99) + * M261 A99 B5 + * + * ; Example #3 + * ; Example serial output of a M261 request + * echo:i2c-reply: from:99 bytes:5 data:hello + */ + +// @section i2cbus + +//#define EXPERIMENTAL_I2CBUS +#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave + +/** + * Add M43, M44 and M45 commands for pins info and testing + */ +//#define PINS_DEBUGGING + +/** + * Auto-report temperatures with M155 S + */ +//#define AUTO_REPORT_TEMPERATURES + +/** + * Include capabilities in M115 output + */ +//#define EXTENDED_CAPABILITIES_REPORT + +/** + * Double-click the Encoder button on the Status Screen for Z Babystepping. + */ +//#define DOUBLECLICK_FOR_Z_BABYSTEPPING +#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds. + // Note: You may need to add extra time to mitigate controller latency. + +/** + * Volumetric extrusion default state + * Activate to make volumetric extrusion the default method, + * with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter. + * + * M200 D0 to disable, M200 Dn to set a new diameter. + */ +//#define VOLUMETRIC_DEFAULT_ON + +/** + * Enable this option for a leaner build of Marlin that removes all + * workspace offsets, simplifying coordinate transformations, leveling, etc. + * + * - M206 and M428 are disabled. + * - G92 will revert to its behavior from Marlin 1.0. + */ +//#define NO_WORKSPACE_OFFSETS + +#endif // CONFIGURATION_ADV_H diff --git a/Marlin/example_configurations/Roxys_printers/original_release_files/Configuration.h b/Marlin/example_configurations/Roxys_printers/original_release_files/Configuration.h new file mode 100644 index 000000000..a288deefb --- /dev/null +++ b/Marlin/example_configurations/Roxys_printers/original_release_files/Configuration.h @@ -0,0 +1,1505 @@ +/** + * 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 . + * + */ + +/** + * Configuration.h + * + * Basic settings such as: + * + * - Type of electronics + * - Type of temperature sensor + * - Printer geometry + * - Endstop configuration + * - LCD controller + * - Extra features + * + * Advanced settings can be found in Configuration_adv.h + * + */ +#ifndef CONFIGURATION_H +#define CONFIGURATION_H + +/** + * + * *********************************** + * ** ATTENTION TO ALL DEVELOPERS ** + * *********************************** + * + * You must increment this version number for every significant change such as, + * but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option. + * + * Note: Update also Version.h ! + */ +#define CONFIGURATION_H_VERSION 010100 + +//=========================================================================== +//============================= Getting Started ============================= +//=========================================================================== + +/** + * Here are some standard links for getting your machine calibrated: + * + * http://reprap.org/wiki/Calibration + * http://youtu.be/wAL9d7FgInk + * http://calculator.josefprusa.cz + * http://reprap.org/wiki/Triffid_Hunter%27s_Calibration_Guide + * http://www.thingiverse.com/thing:5573 + * https://sites.google.com/site/repraplogphase/calibration-of-your-reprap + * http://www.thingiverse.com/thing:298812 + */ + +//=========================================================================== +//============================= DELTA Printer =============================== +//=========================================================================== +// For a Delta printer replace the configuration files with the files in the +// example_configurations/delta directory. +// + +//=========================================================================== +//============================= SCARA Printer =============================== +//=========================================================================== +// For a Scara printer replace the configuration files with the files in the +// example_configurations/SCARA directory. +// + +// @section info + +// User-specified version info of this build to display in [Pronterface, etc] terminal window during +// startup. Implementation of an idea by Prof Braino to inform user that any changes made to this +// build by the user have been successfully uploaded into firmware. +#define STRING_CONFIG_H_AUTHOR "(none, default config)" // Who made the changes. +#define SHOW_BOOTSCREEN +#define STRING_SPLASH_LINE1 SHORT_BUILD_VERSION // will be shown during bootup in line 1 +#define STRING_SPLASH_LINE2 WEBSITE_URL // will be shown during bootup in line 2 + +// +// *** VENDORS PLEASE READ ***************************************************** +// +// Marlin now allow you to have a vendor boot image to be displayed on machine +// start. When SHOW_CUSTOM_BOOTSCREEN is defined Marlin will first show your +// custom boot image and then the default Marlin boot image is shown. +// +// We suggest for you to take advantage of this new feature and keep the Marlin +// boot image unmodified. For an example have a look at the bq Hephestos 2 +// example configuration folder. +// +//#define SHOW_CUSTOM_BOOTSCREEN +// @section machine + +/** + * Select which serial port on the board will be used for communication with the host. + * This allows the connection of wireless adapters (for instance) to non-default port pins. + * Serial port 0 is always used by the Arduino bootloader regardless of this setting. + * + * :[0, 1, 2, 3, 4, 5, 6, 7] + */ +#define SERIAL_PORT 0 + +/** + * This setting determines the communication speed of the printer. + * + * 250000 works in most cases, but you might try a lower speed if + * you commonly experience drop-outs during host printing. + * + * :[2400, 9600, 19200, 38400, 57600, 115200, 250000] + */ +#define BAUDRATE 250000 + +// Enable the Bluetooth serial interface on AT90USB devices +//#define BLUETOOTH + +// The following define selects which electronics board you have. +// Please choose the name from boards.h that matches your setup +#ifndef MOTHERBOARD + #define MOTHERBOARD BOARD_RAMPS_14_EFB +#endif + +// Optional custom name for your RepStrap or other custom machine +// Displayed in the LCD "Ready" message +//#define CUSTOM_MACHINE_NAME "3D Printer" + +// Define this to set a unique identifier for this printer, (Used by some programs to differentiate between machines) +// You can use an online service to generate a random UUID. (eg http://www.uuidgenerator.net/version4) +//#define MACHINE_UUID "00000000-0000-0000-0000-000000000000" + +// This defines the number of extruders +// :[1, 2, 3, 4] +#define EXTRUDERS 1 + +// Enable if your E steppers or extruder gear ratios are not identical +//#define DISTINCT_E_FACTORS + +// For Cyclops or any "multi-extruder" that shares a single nozzle. +//#define SINGLENOZZLE + +// A dual extruder that uses a single stepper motor +// Don't forget to set SSDE_SERVO_ANGLES and HOTEND_OFFSET_X/Y/Z +//#define SWITCHING_EXTRUDER +#if ENABLED(SWITCHING_EXTRUDER) + #define SWITCHING_EXTRUDER_SERVO_NR 0 + #define SWITCHING_EXTRUDER_SERVO_ANGLES { 0, 90 } // Angles for E0, E1 + //#define HOTEND_OFFSET_Z {0.0, 0.0} +#endif + +/** + * "Mixing Extruder" + * - Adds a new code, M165, to set the current mix factors. + * - Extends the stepping routines to move multiple steppers in proportion to the mix. + * - Optional support for Repetier Host M163, M164, and virtual extruder. + * - This implementation supports only a single extruder. + * - Enable DIRECT_MIXING_IN_G1 for Pia Taubert's reference implementation + */ +//#define MIXING_EXTRUDER +#if ENABLED(MIXING_EXTRUDER) + #define MIXING_STEPPERS 2 // Number of steppers in your mixing extruder + #define MIXING_VIRTUAL_TOOLS 16 // Use the Virtual Tool method with M163 and M164 + //#define DIRECT_MIXING_IN_G1 // Allow ABCDHI mix factors in G1 movement commands +#endif + +// Offset of the extruders (uncomment if using more than one and relying on firmware to position when changing). +// The offset has to be X=0, Y=0 for the extruder 0 hotend (default extruder). +// For the other hotends it is their distance from the extruder 0 hotend. +//#define HOTEND_OFFSET_X {0.0, 20.00} // (in mm) for each extruder, offset of the hotend on the X axis +//#define HOTEND_OFFSET_Y {0.0, 5.00} // (in mm) for each extruder, offset of the hotend on the Y axis + +/** + * Select your power supply here. Use 0 if you haven't connected the PS_ON_PIN + * + * 0 = No Power Switch + * 1 = ATX + * 2 = X-Box 360 203Watts (the blue wire connected to PS_ON and the red wire to VCC) + * + * :{ 0:'No power switch', 1:'ATX', 2:'X-Box 360' } + */ +#define POWER_SUPPLY 0 + +#if POWER_SUPPLY > 0 + // Enable this option to leave the PSU off at startup. + // Power to steppers and heaters will need to be turned on with M80. + //#define PS_DEFAULT_OFF +#endif + +// @section temperature + +//=========================================================================== +//============================= Thermal Settings ============================ +//=========================================================================== + +/** + * --NORMAL IS 4.7kohm PULLUP!-- 1kohm pullup can be used on hotend sensor, using correct resistor and table + * + * Temperature sensors available: + * + * -3 : thermocouple with MAX31855 (only for sensor 0) + * -2 : thermocouple with MAX6675 (only for sensor 0) + * -1 : thermocouple with AD595 + * 0 : not used + * 1 : 100k thermistor - best choice for EPCOS 100k (4.7k pullup) + * 2 : 200k thermistor - ATC Semitec 204GT-2 (4.7k pullup) + * 3 : Mendel-parts thermistor (4.7k pullup) + * 4 : 10k thermistor !! do not use it for a hotend. It gives bad resolution at high temp. !! + * 5 : 100K thermistor - ATC Semitec 104GT-2 (Used in ParCan & J-Head) (4.7k pullup) + * 6 : 100k EPCOS - Not as accurate as table 1 (created using a fluke thermocouple) (4.7k pullup) + * 7 : 100k Honeywell thermistor 135-104LAG-J01 (4.7k pullup) + * 71 : 100k Honeywell thermistor 135-104LAF-J01 (4.7k pullup) + * 8 : 100k 0603 SMD Vishay NTCS0603E3104FXT (4.7k pullup) + * 9 : 100k GE Sensing AL03006-58.2K-97-G1 (4.7k pullup) + * 10 : 100k RS thermistor 198-961 (4.7k pullup) + * 11 : 100k beta 3950 1% thermistor (4.7k pullup) + * 12 : 100k 0603 SMD Vishay NTCS0603E3104FXT (4.7k pullup) (calibrated for Makibox hot bed) + * 13 : 100k Hisens 3950 1% up to 300°C for hotend "Simple ONE " & "Hotend "All In ONE" + * 20 : the PT100 circuit found in the Ultimainboard V2.x + * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 + * 66 : 4.7M High Temperature thermistor from Dyze Design + * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad with NTC 100K MGB18-104F39050L32 thermistor + * + * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. + * (but gives greater accuracy and more stable PID) + * 51 : 100k thermistor - EPCOS (1k pullup) + * 52 : 200k thermistor - ATC Semitec 204GT-2 (1k pullup) + * 55 : 100k thermistor - ATC Semitec 104GT-2 (Used in ParCan & J-Head) (1k pullup) + * + * 1047 : Pt1000 with 4k7 pullup + * 1010 : Pt1000 with 1k pullup (non standard) + * 147 : Pt100 with 4k7 pullup + * 110 : Pt100 with 1k pullup (non standard) + * + * Use these for Testing or Development purposes. NEVER for production machine. + * 998 : Dummy Table that ALWAYS reads 25°C or the temperature defined below. + * 999 : Dummy Table that ALWAYS reads 100°C or the temperature defined below. + * + * :{ '0': "Not used", '1':"100k / 4.7k - EPCOS", '2':"200k / 4.7k - ATC Semitec 204GT-2", '3':"Mendel-parts / 4.7k", '4':"10k !! do not use for a hotend. Bad resolution at high temp. !!", '5':"100K / 4.7k - ATC Semitec 104GT-2 (Used in ParCan & J-Head)", '6':"100k / 4.7k EPCOS - Not as accurate as Table 1", '7':"100k / 4.7k Honeywell 135-104LAG-J01", '8':"100k / 4.7k 0603 SMD Vishay NTCS0603E3104FXT", '9':"100k / 4.7k GE Sensing AL03006-58.2K-97-G1", '10':"100k / 4.7k RS 198-961", '11':"100k / 4.7k beta 3950 1%", '12':"100k / 4.7k 0603 SMD Vishay NTCS0603E3104FXT (calibrated for Makibox hot bed)", '13':"100k Hisens 3950 1% up to 300°C for hotend 'Simple ONE ' & hotend 'All In ONE'", '20':"PT100 (Ultimainboard V2.x)", '51':"100k / 1k - EPCOS", '52':"200k / 1k - ATC Semitec 204GT-2", '55':"100k / 1k - ATC Semitec 104GT-2 (Used in ParCan & J-Head)", '60':"100k Maker's Tool Works Kapton Bed Thermistor beta=3950", '66':"Dyze Design 4.7M High Temperature thermistor", '70':"the 100K thermistor found in the bq Hephestos 2", '71':"100k / 4.7k Honeywell 135-104LAF-J01", '147':"Pt100 / 4.7k", '1047':"Pt1000 / 4.7k", '110':"Pt100 / 1k (non-standard)", '1010':"Pt1000 / 1k (non standard)", '-3':"Thermocouple + MAX31855 (only for sensor 0)", '-2':"Thermocouple + MAX6675 (only for sensor 0)", '-1':"Thermocouple + AD595",'998':"Dummy 1", '999':"Dummy 2" } + */ +#define TEMP_SENSOR_0 1 +#define TEMP_SENSOR_1 0 +#define TEMP_SENSOR_2 0 +#define TEMP_SENSOR_3 0 +#define TEMP_SENSOR_BED 0 + +// Dummy thermistor constant temperature readings, for use with 998 and 999 +#define DUMMY_THERMISTOR_998_VALUE 25 +#define DUMMY_THERMISTOR_999_VALUE 100 + +// Use temp sensor 1 as a redundant sensor with sensor 0. If the readings +// from the two sensors differ too much the print will be aborted. +//#define TEMP_SENSOR_1_AS_REDUNDANT +#define MAX_REDUNDANT_TEMP_SENSOR_DIFF 10 + +// Extruder temperature must be close to target for this long before M109 returns success +#define TEMP_RESIDENCY_TIME 10 // (seconds) +#define TEMP_HYSTERESIS 3 // (degC) range of +/- temperatures considered "close" to the target one +#define TEMP_WINDOW 1 // (degC) Window around target to start the residency timer x degC early. + +// Bed temperature must be close to target for this long before M190 returns success +#define TEMP_BED_RESIDENCY_TIME 10 // (seconds) +#define TEMP_BED_HYSTERESIS 3 // (degC) range of +/- temperatures considered "close" to the target one +#define TEMP_BED_WINDOW 1 // (degC) Window around target to start the residency timer x degC early. + +// The minimal temperature defines the temperature below which the heater will not be enabled It is used +// to check that the wiring to the thermistor is not broken. +// Otherwise this would lead to the heater being powered on all the time. +#define HEATER_0_MINTEMP 5 +#define HEATER_1_MINTEMP 5 +#define HEATER_2_MINTEMP 5 +#define HEATER_3_MINTEMP 5 +#define BED_MINTEMP 5 + +// When temperature exceeds max temp, your heater will be switched off. +// This feature exists to protect your hotend from overheating accidentally, but *NOT* from thermistor short/failure! +// You should use MINTEMP for thermistor short/failure protection. +#define HEATER_0_MAXTEMP 275 +#define HEATER_1_MAXTEMP 275 +#define HEATER_2_MAXTEMP 275 +#define HEATER_3_MAXTEMP 275 +#define BED_MAXTEMP 150 + +//=========================================================================== +//============================= PID Settings ================================ +//=========================================================================== +// PID Tuning Guide here: http://reprap.org/wiki/PID_Tuning + +// Comment the following line to disable PID and enable bang-bang. +#define PIDTEMP +#define BANG_MAX 255 // limits current to nozzle while in bang-bang mode; 255=full current +#define PID_MAX BANG_MAX // limits current to nozzle while PID is active (see PID_FUNCTIONAL_RANGE below); 255=full current +#if ENABLED(PIDTEMP) + //#define PID_AUTOTUNE_MENU // Add PID Autotune to the LCD "Temperature" menu to run M303 and apply the result. + //#define PID_DEBUG // Sends debug data to the serial port. + //#define PID_OPENLOOP 1 // Puts PID in open loop. M104/M140 sets the output power from 0 to PID_MAX + //#define SLOW_PWM_HEATERS // PWM with very low frequency (roughly 0.125Hz=8s) and minimum state time of approximately 1s useful for heaters driven by a relay + //#define PID_PARAMS_PER_HOTEND // Uses separate PID parameters for each extruder (useful for mismatched extruders) + // Set/get with gcode: M301 E[extruder number, 0-2] + #define PID_FUNCTIONAL_RANGE 10 // If the temperature difference between the target temperature and the actual temperature + // is more than PID_FUNCTIONAL_RANGE then the PID will be shut off and the heater will be set to min/max. + #define K1 0.95 //smoothing factor within the PID + + // If you are using a pre-configured hotend then you can use one of the value sets by uncommenting it + // Ultimaker + #define DEFAULT_Kp 22.2 + #define DEFAULT_Ki 1.08 + #define DEFAULT_Kd 114 + + // MakerGear + //#define DEFAULT_Kp 7.0 + //#define DEFAULT_Ki 0.1 + //#define DEFAULT_Kd 12 + + // Mendel Parts V9 on 12V + //#define DEFAULT_Kp 63.0 + //#define DEFAULT_Ki 2.25 + //#define DEFAULT_Kd 440 + +#endif // PIDTEMP + +//=========================================================================== +//============================= PID > Bed Temperature Control =============== +//=========================================================================== +// Select PID or bang-bang with PIDTEMPBED. If bang-bang, BED_LIMIT_SWITCHING will enable hysteresis +// +// Uncomment this to enable PID on the bed. It uses the same frequency PWM as the extruder. +// If your PID_dT is the default, and correct for your hardware/configuration, that means 7.689Hz, +// which is fine for driving a square wave into a resistive load and does not significantly impact you FET heating. +// This also works fine on a Fotek SSR-10DA Solid State Relay into a 250W heater. +// If your configuration is significantly different than this and you don't understand the issues involved, you probably +// shouldn't use bed PID until someone else verifies your hardware works. +// If this is enabled, find your own PID constants below. +//#define PIDTEMPBED + +//#define BED_LIMIT_SWITCHING + +// This sets the max power delivered to the bed, and replaces the HEATER_BED_DUTY_CYCLE_DIVIDER option. +// all forms of bed control obey this (PID, bang-bang, bang-bang with hysteresis) +// setting this to anything other than 255 enables a form of PWM to the bed just like HEATER_BED_DUTY_CYCLE_DIVIDER did, +// so you shouldn't use it unless you are OK with PWM on your bed. (see the comment on enabling PIDTEMPBED) +#define MAX_BED_POWER 255 // limits duty cycle to bed; 255=full current + +#if ENABLED(PIDTEMPBED) + + //#define PID_BED_DEBUG // Sends debug data to the serial port. + + //120V 250W silicone heater into 4mm borosilicate (MendelMax 1.5+) + //from FOPDT model - kp=.39 Tp=405 Tdead=66, Tc set to 79.2, aggressive factor of .15 (vs .1, 1, 10) + #define DEFAULT_bedKp 10.00 + #define DEFAULT_bedKi .023 + #define DEFAULT_bedKd 305.4 + + //120V 250W silicone heater into 4mm borosilicate (MendelMax 1.5+) + //from pidautotune + //#define DEFAULT_bedKp 97.1 + //#define DEFAULT_bedKi 1.41 + //#define DEFAULT_bedKd 1675.16 + + // FIND YOUR OWN: "M303 E-1 C8 S90" to run autotune on the bed at 90 degreesC for 8 cycles. +#endif // PIDTEMPBED + +// @section extruder + +// This option prevents extrusion if the temperature is below EXTRUDE_MINTEMP. +// It also enables the M302 command to set the minimum extrusion temperature +// or to allow moving the extruder regardless of the hotend temperature. +// *** IT IS HIGHLY RECOMMENDED TO LEAVE THIS OPTION ENABLED! *** +#define PREVENT_COLD_EXTRUSION +#define EXTRUDE_MINTEMP 170 + +// This option prevents a single extrusion longer than EXTRUDE_MAXLENGTH. +// Note that for Bowden Extruders a too-small value here may prevent loading. +#define PREVENT_LENGTHY_EXTRUDE +#define EXTRUDE_MAXLENGTH 200 + +//=========================================================================== +//======================== Thermal Runaway Protection ======================= +//=========================================================================== + +/** + * Thermal Protection protects your printer from damage and fire if a + * thermistor falls out or temperature sensors fail in any way. + * + * The issue: If a thermistor falls out or a temperature sensor fails, + * Marlin can no longer sense the actual temperature. Since a disconnected + * thermistor reads as a low temperature, the firmware will keep the heater on. + * + * If you get "Thermal Runaway" or "Heating failed" errors the + * details can be tuned in Configuration_adv.h + */ + +#define THERMAL_PROTECTION_HOTENDS // Enable thermal protection for all extruders +#define THERMAL_PROTECTION_BED // Enable thermal protection for the heated bed + +//=========================================================================== +//============================= Mechanical Settings ========================= +//=========================================================================== + +// @section machine + +// Uncomment one of these options to enable CoreXY, CoreXZ, or CoreYZ kinematics +// either in the usual order or reversed +//#define COREXY +//#define COREXZ +//#define COREYZ +//#define COREYX +//#define COREZX +//#define COREZY + +// Enable this option for Toshiba steppers +//#define CONFIG_STEPPERS_TOSHIBA + +//=========================================================================== +//============================== Endstop Settings =========================== +//=========================================================================== + +// @section homing + +// Specify here all the endstop connectors that are connected to any endstop or probe. +// Almost all printers will be using one per axis. Probes will use one or more of the +// extra connectors. Leave undefined any used for non-endstop and non-probe purposes. +#define USE_XMIN_PLUG +#define USE_YMIN_PLUG +#define USE_ZMIN_PLUG +//#define USE_XMAX_PLUG +//#define USE_YMAX_PLUG +//#define USE_ZMAX_PLUG + +// coarse Endstop Settings +#define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors + +#if DISABLED(ENDSTOPPULLUPS) + // fine endstop settings: Individual pullups. will be ignored if ENDSTOPPULLUPS is defined + //#define ENDSTOPPULLUP_XMAX + //#define ENDSTOPPULLUP_YMAX + //#define ENDSTOPPULLUP_ZMAX + //#define ENDSTOPPULLUP_XMIN + //#define ENDSTOPPULLUP_YMIN + //#define ENDSTOPPULLUP_ZMIN + //#define ENDSTOPPULLUP_ZMIN_PROBE +#endif + +// Mechanical endstop with COM to ground and NC to Signal uses "false" here (most common setup). +#define X_MIN_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Y_MIN_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Z_MIN_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define X_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Y_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Z_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. +#define Z_MIN_PROBE_ENDSTOP_INVERTING false // set to true to invert the logic of the probe. + +// Enable this feature if all enabled endstop pins are interrupt-capable. +// This will remove the need to poll the interrupt pins, saving many CPU cycles. +//#define ENDSTOP_INTERRUPTS_FEATURE + +//============================================================================= +//============================== Movement Settings ============================ +//============================================================================= +// @section motion + +/** + * Default Settings + * + * These settings can be reset by M502 + * + * You can set distinct factors for each E stepper, if needed. + * If fewer factors are given, the last will apply to the rest. + * + * Note that if EEPROM is enabled, saved values will override these. + */ + +/** + * Default Axis Steps Per Unit (steps/mm) + * Override with M92 + * X, Y, Z, E0 [, E1[, E2[, E3]]] + */ +#define DEFAULT_AXIS_STEPS_PER_UNIT { 80, 80, 4000, 500 } + +/** + * Default Max Feed Rate (mm/s) + * Override with M203 + * X, Y, Z, E0 [, E1[, E2[, E3]]] + */ +#define DEFAULT_MAX_FEEDRATE { 300, 300, 5, 25 } + +/** + * Default Max Acceleration (change/s) change = mm/s + * (Maximum start speed for accelerated moves) + * Override with M201 + * X, Y, Z, E0 [, E1[, E2[, E3]]] + */ +#define DEFAULT_MAX_ACCELERATION { 3000, 3000, 100, 10000 } + + +/** + * Default Acceleration (change/s) change = mm/s + * Override with M204 + * + * M204 P Acceleration + * M204 R Retract Acceleration + * M204 T Travel Acceleration + */ +#define DEFAULT_ACCELERATION 3000 // X, Y, Z and E acceleration for printing moves +#define DEFAULT_RETRACT_ACCELERATION 3000 // E acceleration for retracts +#define DEFAULT_TRAVEL_ACCELERATION 3000 // X, Y, Z acceleration for travel (non printing) moves + +/** + * Default Jerk (mm/s) + * Override with M205 X Y Z E + * + * "Jerk" specifies the minimum speed change that requires acceleration. + * When changing speed and direction, if the difference is less than the + * value set here, it may happen instantaneously. + */ +#define DEFAULT_XJERK 20.0 +#define DEFAULT_YJERK 20.0 +#define DEFAULT_ZJERK 0.4 +#define DEFAULT_EJERK 5.0 + + +//=========================================================================== +//============================= Z Probe Options ============================= +//=========================================================================== +// @section probes + +// +// Probe Type +// Probes are sensors/switches that are activated / deactivated before/after use. +// +// Allen Key Probes, Servo Probes, Z-Sled Probes, FIX_MOUNTED_PROBE, etc. +// You must activate one of these to use Auto Bed Leveling below. +// +// Use M851 to set the Z probe vertical offset from the nozzle. Store with M500. +// + +// A Fix-Mounted Probe either doesn't deploy or needs manual deployment. +// For example an inductive probe, or a setup that uses the nozzle to probe. +// An inductive probe must be deactivated to go below +// its trigger-point if hardware endstops are active. +//#define FIX_MOUNTED_PROBE + +// The BLTouch probe emulates a servo probe. +// The default connector is SERVO 0. Set Z_ENDSTOP_SERVO_NR below to override. +//#define BLTOUCH + +// Z Servo Probe, such as an endstop switch on a rotating arm. +//#define Z_ENDSTOP_SERVO_NR 0 +//#define Z_SERVO_ANGLES {70,0} // Z Servo Deploy and Stow angles + +// Enable if you have a Z probe mounted on a sled like those designed by Charles Bell. +//#define Z_PROBE_SLED +//#define SLED_DOCKING_OFFSET 5 // The extra distance the X axis must travel to pickup the sled. 0 should be fine but you can push it further if you'd like. + +// Z Probe to nozzle (X,Y) offset, relative to (0, 0). +// X and Y offsets must be integers. +// +// In the following example the X and Y offsets are both positive: +// #define X_PROBE_OFFSET_FROM_EXTRUDER 10 +// #define Y_PROBE_OFFSET_FROM_EXTRUDER 10 +// +// +-- BACK ---+ +// | | +// L | (+) P | R <-- probe (20,20) +// E | | I +// F | (-) N (+) | G <-- nozzle (10,10) +// T | | H +// | (-) | T +// | | +// O-- FRONT --+ +// (0,0) +#define X_PROBE_OFFSET_FROM_EXTRUDER 10 // X offset: -left +right [of the nozzle] +#define Y_PROBE_OFFSET_FROM_EXTRUDER 10 // Y offset: -front +behind [the nozzle] +#define Z_PROBE_OFFSET_FROM_EXTRUDER 0 // Z offset: -below +above [the nozzle] + +// X and Y axis travel speed (mm/m) between probes +#define XY_PROBE_SPEED 8000 +// Speed for the first approach when double-probing (with PROBE_DOUBLE_TOUCH) +#define Z_PROBE_SPEED_FAST HOMING_FEEDRATE_Z +// Speed for the "accurate" probe of each point +#define Z_PROBE_SPEED_SLOW (Z_PROBE_SPEED_FAST / 2) +// Use double touch for probing +//#define PROBE_DOUBLE_TOUCH + +// +// Allen Key Probe is defined in the Delta example configurations. +// + +// *** PLEASE READ ALL INSTRUCTIONS BELOW FOR SAFETY! *** +// +// To continue using the Z-min-endstop for homing, be sure to disable Z_SAFE_HOMING. +// Example: To park the head outside the bed area when homing with G28. +// +// To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. +// +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. +// +// - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. +// - Use 5V for powered (usu. inductive) sensors. +// - Otherwise connect: +// - normally-closed switches to GND and D32. +// - normally-open switches to 5V and D32. +// +// Normally-closed switches are advised and are the default. +// + +// +// The Z_MIN_PROBE_PIN sets the Arduino pin to use. (See your board's pins file.) +// Since the RAMPS Aux4->D32 pin maps directly to the Arduino D32 pin, D32 is the +// default pin for all RAMPS-based boards. Most boards use the X_MAX_PIN by default. +// To use a different pin you can override it here. +// +// WARNING: +// Setting the wrong pin may have unexpected and potentially disastrous consequences. +// Use with caution and do your homework. +// +//#define Z_MIN_PROBE_PIN X_MAX_PIN + +// +// Enable Z_MIN_PROBE_ENDSTOP to use _both_ a Z Probe and a Z-min-endstop on the same machine. +// With this option the Z_MIN_PROBE_PIN will only be used for probing, never for homing. +// +//#define Z_MIN_PROBE_ENDSTOP + +// Enable Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN to use the Z_MIN_PIN for your Z_MIN_PROBE. +// The Z_MIN_PIN will then be used for both Z-homing and probing. +#define Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN + +// To use a probe you must enable one of the two options above! + +// Enable Z Probe Repeatability test to see how accurate your probe is +//#define Z_MIN_PROBE_REPEATABILITY_TEST + +/** + * Z probes require clearance when deploying, stowing, and moving between + * probe points to avoid hitting the bed and other hardware. + * Servo-mounted probes require extra space for the arm to rotate. + * Inductive probes need space to keep from triggering early. + * + * Use these settings to specify the distance (mm) to raise the probe (or + * lower the bed). The values set here apply over and above any (negative) + * probe Z Offset set with Z_PROBE_OFFSET_FROM_EXTRUDER, M851, or the LCD. + * Only integer values >= 1 are valid here. + * + * Example: `M851 Z-5` with a CLEARANCE of 4 => 9mm from bed to nozzle. + * But: `M851 Z+1` with a CLEARANCE of 2 => 2mm from bed to nozzle. + */ +#define Z_CLEARANCE_DEPLOY_PROBE 10 // Z Clearance for Deploy/Stow +#define Z_CLEARANCE_BETWEEN_PROBES 5 // Z Clearance between probe points + +// +// For M851 give a range for adjusting the Z probe offset +// +#define Z_PROBE_OFFSET_RANGE_MIN -20 +#define Z_PROBE_OFFSET_RANGE_MAX 20 + +// For Inverting Stepper Enable Pins (Active Low) use 0, Non Inverting (Active High) use 1 +// :{ 0:'Low', 1:'High' } +#define X_ENABLE_ON 0 +#define Y_ENABLE_ON 0 +#define Z_ENABLE_ON 0 +#define E_ENABLE_ON 0 // For all extruders + +// Disables axis stepper immediately when it's not being used. +// WARNING: When motors turn off there is a chance of losing position accuracy! +#define DISABLE_X false +#define DISABLE_Y false +#define DISABLE_Z false +// Warn on display about possibly reduced accuracy +//#define DISABLE_REDUCED_ACCURACY_WARNING + +// @section extruder + +#define DISABLE_E false // For all extruders +#define DISABLE_INACTIVE_EXTRUDER true //disable only inactive extruders and keep active extruder enabled + +// @section machine + +// Invert the stepper direction. Change (or reverse the motor connector) if an axis goes the wrong way. +#define INVERT_X_DIR false +#define INVERT_Y_DIR true +#define INVERT_Z_DIR false + +// @section extruder + +// For direct drive extruder v9 set to true, for geared extruder set to false. +#define INVERT_E0_DIR false +#define INVERT_E1_DIR false +#define INVERT_E2_DIR false +#define INVERT_E3_DIR false + +// @section homing + +//#define Z_HOMING_HEIGHT 4 // (in mm) Minimal z height before homing (G28) for Z clearance above the bed, clamps, ... + // Be sure you have this distance over your Z_MAX_POS in case. + +// Direction of endstops when homing; 1=MAX, -1=MIN +// :[-1,1] +#define X_HOME_DIR -1 +#define Y_HOME_DIR -1 +#define Z_HOME_DIR -1 + +// @section machine + +// Travel limits after homing (units are in mm) +#define X_MIN_POS 0 +#define Y_MIN_POS 0 +#define Z_MIN_POS 0 +#define X_MAX_POS 200 +#define Y_MAX_POS 200 +#define Z_MAX_POS 200 + +// If enabled, axes won't move below MIN_POS in response to movement commands. +#define MIN_SOFTWARE_ENDSTOPS +// If enabled, axes won't move above MAX_POS in response to movement commands. +#define MAX_SOFTWARE_ENDSTOPS + +/** + * Filament Runout Sensor + * A mechanical or opto endstop is used to check for the presence of filament. + * + * RAMPS-based boards use SERVO3_PIN. + * For other boards you may need to define FIL_RUNOUT_PIN. + * By default the firmware assumes HIGH = has filament, LOW = ran out + */ +//#define FILAMENT_RUNOUT_SENSOR +#if ENABLED(FILAMENT_RUNOUT_SENSOR) + #define FIL_RUNOUT_INVERTING false // set to true to invert the logic of the sensor. + #define ENDSTOPPULLUP_FIL_RUNOUT // Uncomment to use internal pullup for filament runout pins if the sensor is defined. + #define FILAMENT_RUNOUT_SCRIPT "M600" +#endif + +//=========================================================================== +//=============================== Bed Leveling ============================== +//========================================================================== +// @section bedlevel + +/** + * Select one form of Auto Bed Leveling below. + * + * If you're also using the Probe for Z Homing, it's + * highly recommended to enable Z_SAFE_HOMING also! + * + * - 3POINT + * Probe 3 arbitrary points on the bed (that aren't collinear) + * You specify the XY coordinates of all 3 points. + * The result is a single tilted plane. Best for a flat bed. + * + * - LINEAR + * Probe several points in a grid. + * You specify the rectangle and the density of sample points. + * The result is a single tilted plane. Best for a flat bed. + * + * - BILINEAR + * Probe several points in a grid. + * You specify the rectangle and the density of sample points. + * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. + */ +//#define AUTO_BED_LEVELING_3POINT +//#define AUTO_BED_LEVELING_LINEAR +//#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL + + +/** + * Enable detailed logging of G28, G29, M48, etc. + * Turn on with the command 'M111 S32'. + * NOTE: Requires a lot of PROGMEM! + */ +//#define DEBUG_LEVELING_FEATURE + +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + +#if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) + + // Set the number of grid points per dimension. + #define ABL_GRID_MAX_POINTS_X 3 + #define ABL_GRID_MAX_POINTS_Y ABL_GRID_MAX_POINTS_X + + // Set the boundaries for probing (where the probe can reach). + #define LEFT_PROBE_BED_POSITION 15 + #define RIGHT_PROBE_BED_POSITION 170 + #define FRONT_PROBE_BED_POSITION 20 + #define BACK_PROBE_BED_POSITION 170 + + // The Z probe minimum outer margin (to validate G29 parameters). + #define MIN_PROBE_EDGE 10 + + // Probe along the Y axis, advancing X after each column + //#define PROBE_Y_FIRST + + #if ENABLED(AUTO_BED_LEVELING_BILINEAR) + + // + // Experimental Subdivision of the grid by Catmull-Rom method. + // Synthesizes intermediate points to produce a more detailed mesh. + // + //#define ABL_BILINEAR_SUBDIVISION + #if ENABLED(ABL_BILINEAR_SUBDIVISION) + // Number of subdivisions between probe points + #define BILINEAR_SUBDIVISIONS 3 + #endif + + #endif + +#elif ENABLED(AUTO_BED_LEVELING_3POINT) + + // 3 arbitrary points to probe. + // A simple cross-product is used to estimate the plane of the bed. + + #define ABL_PROBE_PT_1_X 15 + #define ABL_PROBE_PT_1_Y 180 + #define ABL_PROBE_PT_2_X 15 + #define ABL_PROBE_PT_2_Y 20 + #define ABL_PROBE_PT_3_X 170 + #define ABL_PROBE_PT_3_Y 20 + +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING + +/** + * Commands to execute at the end of G29 probing. + * Useful to retract or move the Z probe out of the way. + */ +//#define Z_PROBE_END_SCRIPT "G1 Z10 F12000\nG1 X15 Y330\nG1 Z0.5\nG1 Z10" + + +// @section homing + +// The center of the bed is at (X=0, Y=0) +//#define BED_CENTER_AT_0_0 + +// Manually set the home position. Leave these undefined for automatic settings. +// For DELTA this is the top-center of the Cartesian print volume. +//#define MANUAL_X_HOME_POS 0 +//#define MANUAL_Y_HOME_POS 0 +//#define MANUAL_Z_HOME_POS 0 + +// Use "Z Safe Homing" to avoid homing with a Z probe outside the bed area. +// +// With this feature enabled: +// +// - Allow Z homing only after X and Y homing AND stepper drivers still enabled. +// - If stepper drivers time out, it will need X and Y homing again before Z homing. +// - Move the Z probe (or nozzle) to a defined XY point before Z Homing when homing all axes (G28). +// - Prevent Z homing when the Z probe is outside bed area. +//#define Z_SAFE_HOMING + +#if ENABLED(Z_SAFE_HOMING) + #define Z_SAFE_HOMING_X_POINT ((X_MIN_POS + X_MAX_POS) / 2) // X point for Z homing when homing all axis (G28). + #define Z_SAFE_HOMING_Y_POINT ((Y_MIN_POS + Y_MAX_POS) / 2) // Y point for Z homing when homing all axis (G28). +#endif + +// Homing speeds (mm/m) +#define HOMING_FEEDRATE_XY (50*60) +#define HOMING_FEEDRATE_Z (4*60) + +//============================================================================= +//============================= Additional Features =========================== +//============================================================================= + +// @section extras + +// +// EEPROM +// +// The microcontroller can store settings in the EEPROM, e.g. max velocity... +// M500 - stores parameters in EEPROM +// M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily). +// M502 - reverts to the default "factory settings". You still need to store them in EEPROM afterwards if you want to. +//define this to enable EEPROM support +//#define EEPROM_SETTINGS + +#if ENABLED(EEPROM_SETTINGS) + // To disable EEPROM Serial responses and decrease program space by ~1700 byte: comment this out: + #define EEPROM_CHITCHAT // Please keep turned on if you can. +#endif + +// +// Host Keepalive +// +// When enabled Marlin will send a busy status message to the host +// every couple of seconds when it can't accept commands. +// +#define HOST_KEEPALIVE_FEATURE // Disable this if your host doesn't like keepalive messages +#define DEFAULT_KEEPALIVE_INTERVAL 2 // Number of seconds between "busy" messages. Set with M113. + +// +// M100 Free Memory Watcher +// +//#define M100_FREE_MEMORY_WATCHER // uncomment to add the M100 Free Memory Watcher for debug purpose + +// +// G20/G21 Inch mode support +// +//#define INCH_MODE_SUPPORT + +// +// M149 Set temperature units support +// +//#define TEMPERATURE_UNITS_SUPPORT + +// @section temperature + +// Preheat Constants +#define PREHEAT_1_TEMP_HOTEND 180 +#define PREHEAT_1_TEMP_BED 70 +#define PREHEAT_1_FAN_SPEED 0 // Value from 0 to 255 + +#define PREHEAT_2_TEMP_HOTEND 240 +#define PREHEAT_2_TEMP_BED 110 +#define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255 + +// +// Nozzle Park -- EXPERIMENTAL +// +// When enabled allows the user to define a special XYZ position, inside the +// machine's topology, to park the nozzle when idle or when receiving the G27 +// command. +// +// The "P" paramenter controls what is the action applied to the Z axis: +// P0: (Default) If current Z-pos is lower than Z-park then the nozzle will +// be raised to reach Z-park height. +// +// P1: No matter the current Z-pos, the nozzle will be raised/lowered to +// reach Z-park height. +// +// P2: The nozzle height will be raised by Z-park amount but never going over +// the machine's limit of Z_MAX_POS. +// +//#define NOZZLE_PARK_FEATURE + +#if ENABLED(NOZZLE_PARK_FEATURE) + // Specify a park position as { X, Y, Z } + #define NOZZLE_PARK_POINT { (X_MIN_POS + 10), (Y_MAX_POS - 10), 20 } +#endif + +// +// 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. S defines "strokes" i.e. +// back-and-forth movements between the starting and end points. +// +// P1: This starts a zig-zag pattern between (X0, Y0) and (X1, Y1), "T" +// defines the number of zig-zag triangles to be done. "S" defines the +// number of strokes aka one back-and-forth movement. Zig-zags will +// be performed in whichever dimension is smallest. As an example, +// sending "G12 P1 S1 T3" will execute: +// +// -- +// | (X0, Y1) | /\ /\ /\ | (X1, Y1) +// | | / \ / \ / \ | +// A | | / \ / \ / \ | +// | | / \ / \ / \ | +// | (X0, Y0) | / \/ \/ \ | (X1, Y0) +// -- +--------------------------------+ +// |________|_________|_________| +// T1 T2 T3 +// +// P2: This starts a circular pattern with circle with middle in +// NOZZLE_CLEAN_CIRCLE_MIDDLE radius of R and stroke count of S. +// Before starting the circle nozzle goes to NOZZLE_CLEAN_START_POINT. +// +// 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) + // Default number of pattern repetitions + #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 + + // Specify positions as { X, Y, Z } + #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} + #define NOZZLE_CLEAN_END_POINT {100, 60, (Z_MIN_POS + 1)} + + // Circular pattern radius + #define NOZZLE_CLEAN_CIRCLE_RADIUS 6.5 + // Circular pattern circle fragments number + #define NOZZLE_CLEAN_CIRCLE_FN 10 + // Middle point of circle + #define NOZZLE_CLEAN_CIRCLE_MIDDLE NOZZLE_CLEAN_START_POINT + + // Moves the nozzle to the initial position + #define NOZZLE_CLEAN_GOBACK +#endif + +// +// Print job timer +// +// Enable this option to automatically start and stop the +// print job timer when M104/M109/M190 commands are received. +// M104 (extruder without wait) - high temp = none, low temp = stop timer +// M109 (extruder with wait) - high temp = start timer, low temp = stop timer +// M190 (bed with wait) - high temp = start timer, low temp = none +// +// In all cases the timer can be started and stopped using +// the following commands: +// +// - M75 - Start the print job timer +// - M76 - Pause the print job timer +// - M77 - Stop the print job timer +#define PRINTJOB_TIMER_AUTOSTART + +// +// Print Counter +// +// When enabled Marlin will keep track of some print statistical data such as: +// - Total print jobs +// - Total successful print jobs +// - Total failed print jobs +// - Total time printing +// +// This information can be viewed by the M78 command. +//#define PRINTCOUNTER + +//============================================================================= +//============================= LCD and SD support ============================ +//============================================================================= + +// @section lcd + +// +// LCD LANGUAGE +// +// Here you may choose the language used by Marlin on the LCD menus, the following +// list of languages are available: +// en, an, bg, ca, cn, cz, de, el, el-gr, es, eu, fi, fr, gl, hr, it, +// kana, kana_utf8, nl, pl, pt, pt_utf8, pt-br, pt-br_utf8, ru, tr, uk, test +// +// :{ 'en':'English', 'an':'Aragonese', 'bg':'Bulgarian', 'ca':'Catalan', 'cn':'Chinese', 'cz':'Czech', 'de':'German', 'el':'Greek', 'el-gr':'Greek (Greece)', 'es':'Spanish', 'eu':'Basque-Euskera', 'fi':'Finnish', 'fr':'French', 'gl':'Galician', 'hr':'Croatian', 'it':'Italian', 'kana':'Japanese', 'kana_utf8':'Japanese (UTF8)', 'nl':'Dutch', 'pl':'Polish', 'pt':'Portuguese', 'pt-br':'Portuguese (Brazilian)', 'pt-br_utf8':'Portuguese (Brazilian UTF8)', 'pt_utf8':'Portuguese (UTF8)', 'ru':'Russian', 'tr':'Turkish', 'uk':'Ukrainian', 'test':'TEST' } +// +#define LCD_LANGUAGE en + +// +// LCD Character Set +// +// Note: This option is NOT applicable to Graphical Displays. +// +// All character-based LCD's provide ASCII plus one of these +// language extensions: +// +// - JAPANESE ... the most common +// - WESTERN ... with more accented characters +// - CYRILLIC ... for the Russian language +// +// To determine the language extension installed on your controller: +// +// - Compile and upload with LCD_LANGUAGE set to 'test' +// - Click the controller to view the LCD menu +// - The LCD will display Japanese, Western, or Cyrillic text +// +// See https://github.com/MarlinFirmware/Marlin/wiki/LCD-Language +// +// :['JAPANESE', 'WESTERN', 'CYRILLIC'] +// +#define DISPLAY_CHARSET_HD44780 JAPANESE + +// +// LCD TYPE +// +// You may choose ULTRA_LCD if you have character based LCD with 16x2, 16x4, 20x2, +// 20x4 char/lines or DOGLCD for the full graphics display with 128x64 pixels +// (ST7565R family). (This option will be set automatically for certain displays.) +// +// IMPORTANT NOTE: The U8glib library is required for Full Graphic Display! +// https://github.com/olikraus/U8glib_Arduino +// +//#define ULTRA_LCD // Character based +//#define DOGLCD // Full graphics display + +// +// SD CARD +// +// SD Card support is disabled by default. If your controller has an SD slot, +// you must uncomment the following option or it won't work. +// +//#define SDSUPPORT + +// +// SD CARD: SPI SPEED +// +// Uncomment ONE of the following items to use a slower SPI transfer +// speed. This is usually required if you're getting volume init errors. +// +//#define SPI_SPEED SPI_HALF_SPEED +//#define SPI_SPEED SPI_QUARTER_SPEED +//#define SPI_SPEED SPI_EIGHTH_SPEED + +// +// SD CARD: ENABLE CRC +// +// Use CRC checks and retries on the SD communication. +// +//#define SD_CHECK_AND_RETRY + +// +// ENCODER SETTINGS +// +// This option overrides the default number of encoder pulses needed to +// produce one step. Should be increased for high-resolution encoders. +// +//#define ENCODER_PULSES_PER_STEP 1 + +// +// Use this option to override the number of step signals required to +// move between next/prev menu items. +// +//#define ENCODER_STEPS_PER_MENU_ITEM 5 + +/** + * Encoder Direction Options + * + * Test your encoder's behavior first with both options disabled. + * + * Reversed Value Edit and Menu Nav? Enable REVERSE_ENCODER_DIRECTION. + * Reversed Menu Navigation only? Enable REVERSE_MENU_DIRECTION. + * Reversed Value Editing only? Enable BOTH options. + */ + +// +// This option reverses the encoder direction everywhere +// +// Set this option if CLOCKWISE causes values to DECREASE +// +//#define REVERSE_ENCODER_DIRECTION + +// +// This option reverses the encoder direction for navigating LCD menus. +// +// If CLOCKWISE normally moves DOWN this makes it go UP. +// If CLOCKWISE normally moves UP this makes it go DOWN. +// +//#define REVERSE_MENU_DIRECTION + +// +// Individual Axis Homing +// +// Add individual axis homing items (Home X, Home Y, and Home Z) to the LCD menu. +// +//#define INDIVIDUAL_AXIS_HOMING_MENU + +// +// SPEAKER/BUZZER +// +// If you have a speaker that can produce tones, enable it here. +// By default Marlin assumes you have a buzzer with a fixed frequency. +// +//#define SPEAKER + +// +// The duration and frequency for the UI feedback sound. +// Set these to 0 to disable audio feedback in the LCD menus. +// +// Note: Test audio output with the G-Code: +// M300 S P +// +//#define LCD_FEEDBACK_FREQUENCY_DURATION_MS 100 +//#define LCD_FEEDBACK_FREQUENCY_HZ 1000 + +// +// CONTROLLER TYPE: Standard +// +// Marlin supports a wide variety of controllers. +// Enable one of the following options to specify your controller. +// + +// +// ULTIMAKER Controller. +// +//#define ULTIMAKERCONTROLLER + +// +// ULTIPANEL as seen on Thingiverse. +// +//#define ULTIPANEL + +// +// Cartesio UI +// http://mauk.cc/webshop/cartesio-shop/electronics/user-interface +// +//#define CARTESIO_UI + +// +// PanelOne from T3P3 (via RAMPS 1.4 AUX2/AUX3) +// http://reprap.org/wiki/PanelOne +// +//#define PANEL_ONE + +// +// MaKr3d Makr-Panel with graphic controller and SD support. +// http://reprap.org/wiki/MaKr3d_MaKrPanel +// +//#define MAKRPANEL + +// +// ReprapWorld Graphical LCD +// https://reprapworld.com/?products_details&products_id/1218 +// +//#define REPRAPWORLD_GRAPHICAL_LCD + +// +// Activate one of these if you have a Panucatt Devices +// Viki 2.0 or mini Viki with Graphic LCD +// http://panucatt.com +// +//#define VIKI2 +//#define miniVIKI + +// +// Adafruit ST7565 Full Graphic Controller. +// https://github.com/eboston/Adafruit-ST7565-Full-Graphic-Controller/ +// +//#define ELB_FULL_GRAPHIC_CONTROLLER + +// +// RepRapDiscount Smart Controller. +// http://reprap.org/wiki/RepRapDiscount_Smart_Controller +// +// Note: Usually sold with a white PCB. +// +//#define REPRAP_DISCOUNT_SMART_CONTROLLER + +// +// GADGETS3D G3D LCD/SD Controller +// http://reprap.org/wiki/RAMPS_1.3/1.4_GADGETS3D_Shield_with_Panel +// +// Note: Usually sold with a blue PCB. +// +//#define G3D_PANEL + +// +// RepRapDiscount FULL GRAPHIC Smart Controller +// http://reprap.org/wiki/RepRapDiscount_Full_Graphic_Smart_Controller +// +//#define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER + +// +// MakerLab Mini Panel with graphic +// controller and SD support - http://reprap.org/wiki/Mini_panel +// +//#define MINIPANEL + +// +// RepRapWorld REPRAPWORLD_KEYPAD v1.1 +// http://reprapworld.com/?products_details&products_id=202&cPath=1591_1626 +// +// REPRAPWORLD_KEYPAD_MOVE_STEP sets how much should the robot move when a key +// is pressed, a value of 10.0 means 10mm per click. +// +//#define REPRAPWORLD_KEYPAD +//#define REPRAPWORLD_KEYPAD_MOVE_STEP 1.0 + +// +// RigidBot Panel V1.0 +// http://www.inventapart.com/ +// +//#define RIGIDBOT_PANEL + +// +// BQ LCD Smart Controller shipped by +// default with the BQ Hephestos 2 and Witbox 2. +// +//#define BQ_LCD_SMART_CONTROLLER + +// +// CONTROLLER TYPE: I2C +// +// Note: These controllers require the installation of Arduino's LiquidCrystal_I2C +// library. For more info: https://github.com/kiyoshigawa/LiquidCrystal_I2C +// + +// +// Elefu RA Board Control Panel +// http://www.elefu.com/index.php?route=product/product&product_id=53 +// +//#define RA_CONTROL_PANEL + +// +// Sainsmart YW Robot (LCM1602) LCD Display +// +//#define LCD_I2C_SAINSMART_YWROBOT + +// +// Generic LCM1602 LCD adapter +// +//#define LCM1602 + +// +// PANELOLU2 LCD with status LEDs, +// separate encoder and click inputs. +// +// Note: This controller requires Arduino's LiquidTWI2 library v1.2.3 or later. +// For more info: https://github.com/lincomatic/LiquidTWI2 +// +// Note: The PANELOLU2 encoder click input can either be directly connected to +// a pin (if BTN_ENC defined to != -1) or read through I2C (when BTN_ENC == -1). +// +//#define LCD_I2C_PANELOLU2 + +// +// Panucatt VIKI LCD with status LEDs, +// integrated click & L/R/U/D buttons, separate encoder inputs. +// +//#define LCD_I2C_VIKI + +// +// SSD1306 OLED full graphics generic display +// +//#define U8GLIB_SSD1306 + +// +// SAV OLEd LCD module support using either SSD1306 or SH1106 based LCD modules +// +//#define SAV_3DGLCD +#if ENABLED(SAV_3DGLCD) + //#define U8GLIB_SSD1306 + #define U8GLIB_SH1106 +#endif + +// +// CONTROLLER TYPE: Shift register panels +// +// 2 wire Non-latching LCD SR from https://goo.gl/aJJ4sH +// LCD configuration: http://reprap.org/wiki/SAV_3D_LCD +// +//#define SAV_3DLCD + +//============================================================================= +//=============================== Extra Features ============================== +//============================================================================= + +// @section extras + +// Increase the FAN PWM frequency. Removes the PWM noise but increases heating in the FET/Arduino +//#define FAST_PWM_FAN + +// Use software PWM to drive the fan, as for the heaters. This uses a very low frequency +// which is not as annoying as with the hardware PWM. On the other hand, if this frequency +// is too low, you should also increment SOFT_PWM_SCALE. +//#define FAN_SOFT_PWM + +// Incrementing this by 1 will double the software PWM frequency, +// affecting heaters, and the fan if FAN_SOFT_PWM is enabled. +// However, control resolution will be halved for each increment; +// at zero value, there are 128 effective control positions. +#define SOFT_PWM_SCALE 0 + +// Temperature status LEDs that display the hotend and bed temperature. +// If all hotends and bed temperature and temperature setpoint are < 54C then the BLUE led is on. +// Otherwise the RED led is on. There is 1C hysteresis. +//#define TEMP_STAT_LEDS + +// M240 Triggers a camera by emulating a Canon RC-1 Remote +// Data from: http://www.doc-diy.net/photo/rc-1_hacked/ +//#define PHOTOGRAPH_PIN 23 + +// SkeinForge sends the wrong arc g-codes when using Arc Point as fillet procedure +//#define SF_ARC_FIX + +// Support for the BariCUDA Paste Extruder. +//#define BARICUDA + +//define BlinkM/CyzRgb Support +//#define BLINKM + +// Support for an RGB LED using 3 separate pins with optional PWM +//#define RGB_LED +#if ENABLED(RGB_LED) + #define RGB_LED_R_PIN 34 + #define RGB_LED_G_PIN 43 + #define RGB_LED_B_PIN 35 +#endif + +/*********************************************************************\ +* R/C SERVO support +* Sponsored by TrinityLabs, Reworked by codexmas +**********************************************************************/ + +// Number of servos +// +// If you select a configuration below, this will receive a default value and does not need to be set manually +// set it manually if you have more servos than extruders and wish to manually control some +// leaving it undefined or defining as 0 will disable the servo subsystem +// If unsure, leave commented / disabled +// +//#define NUM_SERVOS 3 // Servo index starts with 0 for M280 command + +// Delay (in milliseconds) before the next move will start, to give the servo time to reach its target angle. +// 300ms is a good value but you can try less delay. +// If the servo can't reach the requested position, increase it. +#define SERVO_DELAY 300 + +// Servo deactivation +// +// With this option servos are powered only during movement, then turned off to prevent jitter. +//#define DEACTIVATE_SERVOS_AFTER_MOVE + +/**********************************************************************\ + * Support for a filament diameter sensor + * Also allows adjustment of diameter at print time (vs at slicing) + * Single extruder only at this point (extruder 0) + * + * Motherboards + * 34 - RAMPS1.4 - uses Analog input 5 on the AUX2 connector + * 81 - Printrboard - Uses Analog input 2 on the Exp1 connector (version B,C,D,E) + * 301 - Rambo - uses Analog input 3 + * Note may require analog pins to be defined for different motherboards + **********************************************************************/ +// Uncomment below to enable +//#define FILAMENT_WIDTH_SENSOR + +#define DEFAULT_NOMINAL_FILAMENT_DIA 3.00 //Enter the diameter (in mm) of the filament generally used (3.0 mm or 1.75 mm) - this is then used in the slicer software. Used for sensor reading validation + +#if ENABLED(FILAMENT_WIDTH_SENSOR) + #define FILAMENT_SENSOR_EXTRUDER_NUM 0 //The number of the extruder that has the filament sensor (0,1,2) + #define MEASUREMENT_DELAY_CM 14 //measurement delay in cm. This is the distance from filament sensor to middle of barrel + + #define MEASURED_UPPER_LIMIT 3.30 //upper limit factor used for sensor reading validation in mm + #define MEASURED_LOWER_LIMIT 1.90 //lower limit factor for sensor reading validation in mm + #define MAX_MEASUREMENT_DELAY 20 //delay buffer size in bytes (1 byte = 1cm)- limits maximum measurement delay allowable (must be larger than MEASUREMENT_DELAY_CM and lower number saves RAM) + + #define DEFAULT_MEASURED_FILAMENT_DIA DEFAULT_NOMINAL_FILAMENT_DIA //set measured to nominal initially + + //When using an LCD, uncomment the line below to display the Filament sensor data on the last line instead of status. Status will appear for 5 sec. + //#define FILAMENT_LCD_DISPLAY +#endif + + + +#endif // CONFIGURATION_H diff --git a/Marlin/example_configurations/Roxys_printers/original_release_files/Configuration_adv.h b/Marlin/example_configurations/Roxys_printers/original_release_files/Configuration_adv.h new file mode 100644 index 000000000..af217e50d --- /dev/null +++ b/Marlin/example_configurations/Roxys_printers/original_release_files/Configuration_adv.h @@ -0,0 +1,1085 @@ +/** + * 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 . + * + */ + +/** + * Configuration_adv.h + * + * Advanced settings. + * Only change these if you know exactly what you're doing. + * Some of these settings can damage your printer if improperly set! + * + * Basic settings can be found in Configuration.h + * + */ +#ifndef CONFIGURATION_ADV_H +#define CONFIGURATION_ADV_H + +/** + * + * *********************************** + * ** ATTENTION TO ALL DEVELOPERS ** + * *********************************** + * + * You must increment this version number for every significant change such as, + * but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option. + * + * Note: Update also Version.h ! + */ +#define CONFIGURATION_ADV_H_VERSION 010100 + +// @section temperature + +//=========================================================================== +//=============================Thermal Settings ============================ +//=========================================================================== + +#if DISABLED(PIDTEMPBED) + #define BED_CHECK_INTERVAL 5000 // ms between checks in bang-bang control + #if ENABLED(BED_LIMIT_SWITCHING) + #define BED_HYSTERESIS 2 // Only disable heating if T>target+BED_HYSTERESIS and enable heating if T>target-BED_HYSTERESIS + #endif +#endif + +/** + * Thermal Protection protects your printer from damage and fire if a + * thermistor falls out or temperature sensors fail in any way. + * + * The issue: If a thermistor falls out or a temperature sensor fails, + * Marlin can no longer sense the actual temperature. Since a disconnected + * thermistor reads as a low temperature, the firmware will keep the heater on. + * + * The solution: Once the temperature reaches the target, start observing. + * If the temperature stays too far below the target (hysteresis) for too long (period), + * the firmware will halt the machine as a safety precaution. + * + * If you get false positives for "Thermal Runaway" increase THERMAL_PROTECTION_HYSTERESIS and/or THERMAL_PROTECTION_PERIOD + */ +#if ENABLED(THERMAL_PROTECTION_HOTENDS) + #define THERMAL_PROTECTION_PERIOD 40 // Seconds + #define THERMAL_PROTECTION_HYSTERESIS 4 // Degrees Celsius + + /** + * Whenever an M104 or M109 increases the target temperature the firmware will wait for the + * WATCH_TEMP_PERIOD to expire, and if the temperature hasn't increased by WATCH_TEMP_INCREASE + * degrees, the machine is halted, requiring a hard reset. This test restarts with any M104/M109, + * but only if the current temperature is far enough below the target for a reliable test. + * + * If you get false positives for "Heating failed" increase WATCH_TEMP_PERIOD and/or decrease WATCH_TEMP_INCREASE + * WATCH_TEMP_INCREASE should not be below 2. + */ + #define WATCH_TEMP_PERIOD 20 // Seconds + #define WATCH_TEMP_INCREASE 2 // Degrees Celsius +#endif + +/** + * Thermal Protection parameters for the bed are just as above for hotends. + */ +#if ENABLED(THERMAL_PROTECTION_BED) + #define THERMAL_PROTECTION_BED_PERIOD 20 // Seconds + #define THERMAL_PROTECTION_BED_HYSTERESIS 2 // Degrees Celsius + + /** + * Whenever an M140 or M190 increases the target temperature the firmware will wait for the + * WATCH_BED_TEMP_PERIOD to expire, and if the temperature hasn't increased by WATCH_BED_TEMP_INCREASE + * degrees, the machine is halted, requiring a hard reset. This test restarts with any M140/M190, + * but only if the current temperature is far enough below the target for a reliable test. + * + * If you get too many "Heating failed" errors, increase WATCH_BED_TEMP_PERIOD and/or decrease + * WATCH_BED_TEMP_INCREASE. (WATCH_BED_TEMP_INCREASE should not be below 2.) + */ + #define WATCH_BED_TEMP_PERIOD 60 // Seconds + #define WATCH_BED_TEMP_INCREASE 2 // Degrees Celsius +#endif + +#if ENABLED(PIDTEMP) + // this adds an experimental additional term to the heating power, proportional to the extrusion speed. + // if Kc is chosen well, the additional required power due to increased melting should be compensated. + //#define PID_EXTRUSION_SCALING + #if ENABLED(PID_EXTRUSION_SCALING) + #define DEFAULT_Kc (100) //heating power=Kc*(e_speed) + #define LPQ_MAX_LEN 50 + #endif +#endif + +/** + * Automatic Temperature: + * The hotend target temperature is calculated by all the buffered lines of gcode. + * The maximum buffered steps/sec of the extruder motor is called "se". + * Start autotemp mode with M109 S B F + * The target temperature is set to mintemp+factor*se[steps/sec] and is limited by + * mintemp and maxtemp. Turn this off by executing M109 without F* + * Also, if the temperature is set to a value below mintemp, it will not be changed by autotemp. + * On an Ultimaker, some initial testing worked with M109 S215 B260 F1 in the start.gcode + */ +#define AUTOTEMP +#if ENABLED(AUTOTEMP) + #define AUTOTEMP_OLDWEIGHT 0.98 +#endif + +//Show Temperature ADC value +//The M105 command return, besides traditional information, the ADC value read from temperature sensors. +//#define SHOW_TEMP_ADC_VALUES + +/** + * High Temperature Thermistor Support + * + * Thermistors able to support high temperature tend to have a hard time getting + * good readings at room and lower temperatures. This means HEATER_X_RAW_LO_TEMP + * will probably be caught when the heating element first turns on during the + * preheating process, which will trigger a min_temp_error as a safety measure + * and force stop everything. + * To circumvent this limitation, we allow for a preheat time (during which, + * min_temp_error won't be triggered) and add a min_temp buffer to handle + * aberrant readings. + * + * If you want to enable this feature for your hotend thermistor(s) + * uncomment and set values > 0 in the constants below + */ + +// The number of consecutive low temperature errors that can occur +// before a min_temp_error is triggered. (Shouldn't be more than 10.) +//#define MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED 0 + +// The number of milliseconds a hotend will preheat before starting to check +// the temperature. This value should NOT be set to the time it takes the +// hot end to reach the target temperature, but the time it takes to reach +// the minimum temperature your thermistor can read. The lower the better/safer. +// This shouldn't need to be more than 30 seconds (30000) +//#define MILLISECONDS_PREHEAT_TIME 0 + +// @section extruder + +// Extruder runout prevention. +// If the machine is idle and the temperature over MINTEMP +// then extrude some filament every couple of SECONDS. +//#define EXTRUDER_RUNOUT_PREVENT +#if ENABLED(EXTRUDER_RUNOUT_PREVENT) + #define EXTRUDER_RUNOUT_MINTEMP 190 + #define EXTRUDER_RUNOUT_SECONDS 30 + #define EXTRUDER_RUNOUT_SPEED 1500 // mm/m + #define EXTRUDER_RUNOUT_EXTRUDE 5 // mm +#endif + +// @section temperature + +//These defines help to calibrate the AD595 sensor in case you get wrong temperature measurements. +//The measured temperature is defined as "actualTemp = (measuredTemp * TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET" +#define TEMP_SENSOR_AD595_OFFSET 0.0 +#define TEMP_SENSOR_AD595_GAIN 1.0 + +//This is for controlling a fan to cool down the stepper drivers +//it will turn on when any driver is enabled +//and turn off after the set amount of seconds from last driver being disabled again +#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) +#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run +#define CONTROLLERFAN_SPEED 255 // == full speed + +// When first starting the main fan, run it at full speed for the +// given number of milliseconds. This gets the fan spinning reliably +// before setting a PWM value. (Does not work with software PWM for fan on Sanguinololu) +//#define FAN_KICKSTART_TIME 100 + +// This defines the minimal speed for the main fan, run in PWM mode +// to enable uncomment and set minimal PWM speed for reliable running (1-255) +// if fan speed is [1 - (FAN_MIN_PWM-1)] it is set to FAN_MIN_PWM +//#define FAN_MIN_PWM 50 + +// @section extruder + +/** + * Extruder cooling fans + * + * Extruder auto fans automatically turn on when their extruders' + * temperatures go above EXTRUDER_AUTO_FAN_TEMPERATURE. + * + * Your board's pins file specifies the recommended pins. Override those here + * or set to -1 to disable completely. + * + * Multiple extruders can be assigned to the same pin in which case + * the fan will turn on when any selected extruder is above the threshold. + */ +#define E0_AUTO_FAN_PIN -1 +#define E1_AUTO_FAN_PIN -1 +#define E2_AUTO_FAN_PIN -1 +#define E3_AUTO_FAN_PIN -1 +#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 +#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed + +// Define a pin to turn case light on/off +//#define CASE_LIGHT_PIN 4 +#if PIN_EXISTS(CASE_LIGHT) + #define INVERT_CASE_LIGHT false // Set to true if HIGH is the OFF state (active low) + //#define CASE_LIGHT_DEFAULT_ON // Uncomment to set default state to on + //#define MENU_ITEM_CASE_LIGHT // Uncomment to have a Case Light On / Off entry in main menu +#endif + +//=========================================================================== +//============================ Mechanical Settings ========================== +//=========================================================================== + +// @section homing + +// If you want endstops to stay on (by default) even when not homing +// enable this option. Override at any time with M120, M121. +//#define ENDSTOPS_ALWAYS_ON_DEFAULT + +// @section extras + +//#define Z_LATE_ENABLE // Enable Z the last moment. Needed if your Z driver overheats. + +// Dual X Steppers +// Uncomment this option to drive two X axis motors. +// The next unused E driver will be assigned to the second X stepper. +//#define X_DUAL_STEPPER_DRIVERS +#if ENABLED(X_DUAL_STEPPER_DRIVERS) + // Set true if the two X motors need to rotate in opposite directions + #define INVERT_X2_VS_X_DIR true +#endif + + +// Dual Y Steppers +// Uncomment this option to drive two Y axis motors. +// The next unused E driver will be assigned to the second Y stepper. +//#define Y_DUAL_STEPPER_DRIVERS +#if ENABLED(Y_DUAL_STEPPER_DRIVERS) + // Set true if the two Y motors need to rotate in opposite directions + #define INVERT_Y2_VS_Y_DIR true +#endif + +// A single Z stepper driver is usually used to drive 2 stepper motors. +// Uncomment this option to use a separate stepper driver for each Z axis motor. +// The next unused E driver will be assigned to the second Z stepper. +//#define Z_DUAL_STEPPER_DRIVERS + +#if ENABLED(Z_DUAL_STEPPER_DRIVERS) + + // Z_DUAL_ENDSTOPS is a feature to enable the use of 2 endstops for both Z steppers - Let's call them Z stepper and Z2 stepper. + // That way the machine is capable to align the bed during home, since both Z steppers are homed. + // There is also an implementation of M666 (software endstops adjustment) to this feature. + // After Z homing, this adjustment is applied to just one of the steppers in order to align the bed. + // One just need to home the Z axis and measure the distance difference between both Z axis and apply the math: Z adjust = Z - Z2. + // If the Z stepper axis is closer to the bed, the measure Z > Z2 (yes, it is.. think about it) and the Z adjust would be positive. + // Play a little bit with small adjustments (0.5mm) and check the behaviour. + // The M119 (endstops report) will start reporting the Z2 Endstop as well. + + //#define Z_DUAL_ENDSTOPS + + #if ENABLED(Z_DUAL_ENDSTOPS) + #define Z2_USE_ENDSTOP _XMAX_ + #endif + +#endif // Z_DUAL_STEPPER_DRIVERS + +// Enable this for dual x-carriage printers. +// A dual x-carriage design has the advantage that the inactive extruder can be parked which +// prevents hot-end ooze contaminating the print. It also reduces the weight of each x-carriage +// allowing faster printing speeds. Connect your X2 stepper to the first unused E plug. +//#define DUAL_X_CARRIAGE +#if ENABLED(DUAL_X_CARRIAGE) + // Configuration for second X-carriage + // Note: the first x-carriage is defined as the x-carriage which homes to the minimum endstop; + // the second x-carriage always homes to the maximum endstop. + #define X2_MIN_POS 80 // set minimum to ensure second x-carriage doesn't hit the parked first X-carriage + #define X2_MAX_POS 353 // set maximum to the distance between toolheads when both heads are homed + #define X2_HOME_DIR 1 // the second X-carriage always homes to the maximum endstop position + #define X2_HOME_POS X2_MAX_POS // default home position is the maximum carriage position + // However: In this mode the HOTEND_OFFSET_X value for the second extruder provides a software + // override for X2_HOME_POS. This also allow recalibration of the distance between the two endstops + // without modifying the firmware (through the "M218 T1 X???" command). + // Remember: you should set the second extruder x-offset to 0 in your slicer. + + // There are a few selectable movement modes for dual x-carriages using M605 S + // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results + // as long as it supports dual x-carriages. (M605 S0) + // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so + // that additional slicer support is not required. (M605 S1) + // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all + // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at + // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) + + // This is the default power-up mode which can be later using M605. + #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE + + // Default settings in "Auto-park Mode" + #define TOOLCHANGE_PARK_ZLIFT 0.2 // the distance to raise Z axis when parking an extruder + #define TOOLCHANGE_UNPARK_ZLIFT 1 // the distance to raise Z axis when unparking an extruder + + // Default x offset in duplication mode (typically set to half print bed width) + #define DEFAULT_DUPLICATION_X_OFFSET 100 + +#endif //DUAL_X_CARRIAGE + +// @section homing + +//homing hits the endstop, then retracts by this distance, before it tries to slowly bump again: +#define X_HOME_BUMP_MM 5 +#define Y_HOME_BUMP_MM 5 +#define Z_HOME_BUMP_MM 2 +#define HOMING_BUMP_DIVISOR {2, 2, 4} // Re-Bump Speed Divisor (Divides the Homing Feedrate) +//#define QUICK_HOME //if this is defined, if both x and y are to be homed, a diagonal move will be performed initially. + +// When G28 is called, this option will make Y home before X +//#define HOME_Y_BEFORE_X + +// @section machine + +#define AXIS_RELATIVE_MODES {false, false, false, false} + +// Allow duplication mode with a basic dual-nozzle extruder +//#define DUAL_NOZZLE_DUPLICATION_MODE + +// By default pololu step drivers require an active high signal. However, some high power drivers require an active low signal as step. +#define INVERT_X_STEP_PIN false +#define INVERT_Y_STEP_PIN false +#define INVERT_Z_STEP_PIN false +#define INVERT_E_STEP_PIN false + +// Default stepper release if idle. Set to 0 to deactivate. +// Steppers will shut down DEFAULT_STEPPER_DEACTIVE_TIME seconds after the last move when DISABLE_INACTIVE_? is true. +// Time can be set by M18 and M84. +#define DEFAULT_STEPPER_DEACTIVE_TIME 120 +#define DISABLE_INACTIVE_X true +#define DISABLE_INACTIVE_Y true +#define DISABLE_INACTIVE_Z true // set to false if the nozzle will fall down on your printed part when print has finished. +#define DISABLE_INACTIVE_E true + +#define DEFAULT_MINIMUMFEEDRATE 0.0 // minimum feedrate +#define DEFAULT_MINTRAVELFEEDRATE 0.0 + +// @section lcd + +#if ENABLED(ULTIPANEL) + #define MANUAL_FEEDRATE {50*60, 50*60, 4*60, 60} // Feedrates for manual moves along X, Y, Z, E from panel + #define ULTIPANEL_FEEDMULTIPLY // Comment to disable setting feedrate multiplier via encoder +#endif + +// @section extras + +// minimum time in microseconds that a movement needs to take if the buffer is emptied. +#define DEFAULT_MINSEGMENTTIME 20000 + +// If defined the movements slow down when the look ahead buffer is only half full +#define SLOWDOWN + +// Frequency limit +// See nophead's blog for more info +// Not working O +//#define XY_FREQUENCY_LIMIT 15 + +// Minimum planner junction speed. Sets the default minimum speed the planner plans for at the end +// of the buffer and all stops. This should not be much greater than zero and should only be changed +// if unwanted behavior is observed on a user's machine when running at very slow speeds. +#define MINIMUM_PLANNER_SPEED 0.05// (mm/sec) + +// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. +#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] + +// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) +#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) + +// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) +//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps + +// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro +//#define DIGIPOT_I2C +// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 +#define DIGIPOT_I2C_NUM_CHANNELS 8 +// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS +#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} + +//=========================================================================== +//=============================Additional Features=========================== +//=========================================================================== + +#define ENCODER_RATE_MULTIPLIER // If defined, certain menu edit operations automatically multiply the steps when the encoder is moved quickly +#define ENCODER_10X_STEPS_PER_SEC 75 // If the encoder steps per sec exceeds this value, multiply steps moved x10 to quickly advance the value +#define ENCODER_100X_STEPS_PER_SEC 160 // If the encoder steps per sec exceeds this value, multiply steps moved x100 to really quickly advance the value + +//#define CHDK 4 //Pin for triggering CHDK to take a picture see how to use it here http://captain-slow.dk/2014/03/09/3d-printing-timelapses/ +#define CHDK_DELAY 50 //How long in ms the pin should stay HIGH before going LOW again + +// @section lcd + +// Include a page of printer information in the LCD Main Menu +//#define LCD_INFO_MENU + +// On the Info Screen, display XY with one decimal place when possible +//#define LCD_DECIMAL_SMALL_XY + +// The timeout (in ms) to return to the status screen from sub-menus +//#define LCD_TIMEOUT_TO_STATUS 15000 + +#if ENABLED(SDSUPPORT) + + // Some RAMPS and other boards don't detect when an SD card is inserted. You can work + // around this by connecting a push button or single throw switch to the pin defined + // as SD_DETECT_PIN in your board's pins definitions. + // This setting should be disabled unless you are using a push button, pulling the pin to ground. + // Note: This is always disabled for ULTIPANEL (except ELB_FULL_GRAPHIC_CONTROLLER). + #define SD_DETECT_INVERTED + + #define SD_FINISHED_STEPPERRELEASE true //if sd support and the file is finished: disable steppers? + #define SD_FINISHED_RELEASECOMMAND "M84 X Y Z E" // You might want to keep the z enabled so your bed stays in place. + + #define SDCARD_RATHERRECENTFIRST //reverse file order of sd card menu display. Its sorted practically after the file system block order. + // if a file is deleted, it frees a block. hence, the order is not purely chronological. To still have auto0.g accessible, there is again the option to do that. + // using: + //#define MENU_ADDAUTOSTART + + /** + * Sort SD file listings in alphabetical order. + * + * With this option enabled, items on SD cards will be sorted + * by name for easier navigation. + * + * By default... + * + * - Use the slowest -but safest- method for sorting. + * - Folders are sorted to the top. + * - The sort key is statically allocated. + * - No added G-code (M34) support. + * - 40 item sorting limit. (Items after the first 40 are unsorted.) + * + * SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the + * compiler to calculate the worst-case usage and throw an error if the SRAM + * limit is exceeded. + * + * - SDSORT_USES_RAM provides faster sorting via a static directory buffer. + * - SDSORT_USES_STACK does the same, but uses a local stack-based buffer. + * - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!) + * - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!) + */ + //#define SDCARD_SORT_ALPHA + + // SD Card Sorting options + #if ENABLED(SDCARD_SORT_ALPHA) + #define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256). + #define FOLDER_SORTING -1 // -1=above 0=none 1=below + #define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code. + #define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting. + #define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.) + #define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option. + #define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use! + #endif + + // Show a progress bar on HD44780 LCDs for SD printing + //#define LCD_PROGRESS_BAR + + #if ENABLED(LCD_PROGRESS_BAR) + // Amount of time (ms) to show the bar + #define PROGRESS_BAR_BAR_TIME 2000 + // Amount of time (ms) to show the status message + #define PROGRESS_BAR_MSG_TIME 3000 + // Amount of time (ms) to retain the status message (0=forever) + #define PROGRESS_MSG_EXPIRE 0 + // Enable this to show messages for MSG_TIME then hide them + //#define PROGRESS_MSG_ONCE + // Add a menu item to test the progress bar: + //#define LCD_PROGRESS_BAR_TEST + #endif + + // This allows hosts to request long names for files and folders with M33 + //#define LONG_FILENAME_HOST_SUPPORT + + // This option allows you to abort SD printing when any endstop is triggered. + // This feature must be enabled with "M540 S1" or from the LCD menu. + // To have any effect, endstops must be enabled during SD printing. + //#define ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED + +#endif // SDSUPPORT + +/** + * Additional options for Graphical Displays + * + * Use the optimizations here to improve printing performance, + * which can be adversely affected by graphical display drawing, + * especially when doing several short moves, and when printing + * on DELTA and SCARA machines. + * + * Some of these options may result in the display lagging behind + * controller events, as there is a trade-off between reliable + * printing performance versus fast display updates. + */ +#if ENABLED(DOGLCD) + // Enable to save many cycles by drawing a hollow frame on the Info Screen + #define XYZ_HOLLOW_FRAME + + // Enable to save many cycles by drawing a hollow frame on Menu Screens + #define MENU_HOLLOW_FRAME + + // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. + // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. + //#define USE_BIG_EDIT_FONT + + // A smaller font may be used on the Info Screen. Costs 2300 bytes of PROGMEM. + // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. + //#define USE_SMALL_INFOFONT + + // Enable this option and reduce the value to optimize screen updates. + // The normal delay is 10µs. Use the lowest value that still gives a reliable display. + //#define DOGM_SPI_DELAY_US 5 +#endif // DOGLCD + +// @section safety + +// The hardware watchdog should reset the microcontroller disabling all outputs, +// in case the firmware gets stuck and doesn't do temperature regulation. +#define USE_WATCHDOG + +#if ENABLED(USE_WATCHDOG) + // If you have a watchdog reboot in an ArduinoMega2560 then the device will hang forever, as a watchdog reset will leave the watchdog on. + // The "WATCHDOG_RESET_MANUAL" goes around this by not using the hardware reset. + // However, THIS FEATURE IS UNSAFE!, as it will only work if interrupts are disabled. And the code could hang in an interrupt routine with interrupts disabled. + //#define WATCHDOG_RESET_MANUAL +#endif + +// @section lcd + +// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process +// it can e.g. be used to change z-positions in the print startup phase in real-time +// does not respect endstops! +//#define BABYSTEPPING +#if ENABLED(BABYSTEPPING) + #define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions + //not implemented for deltabots! + #define BABYSTEP_INVERT_Z false //true for inverse movements in Z + #define BABYSTEP_MULTIPLICATOR 1 //faster movements +#endif + +// @section extruder + +// extruder advance constant (s2/mm3) +// +// advance (steps) = STEPS_PER_CUBIC_MM_E * EXTRUDER_ADVANCE_K * cubic mm per second ^ 2 +// +// Hooke's law says: force = k * distance +// Bernoulli's principle says: v ^ 2 / 2 + g . h + pressure / density = constant +// so: v ^ 2 is proportional to number of steps we advance the extruder +//#define ADVANCE + +#if ENABLED(ADVANCE) + #define EXTRUDER_ADVANCE_K .0 + #define D_FILAMENT 2.85 +#endif + +/** + * Implementation of linear pressure control + * + * Assumption: advance = k * (delta velocity) + * K=0 means advance disabled. + * See Marlin documentation for calibration instructions. + */ +//#define LIN_ADVANCE + +#if ENABLED(LIN_ADVANCE) + #define LIN_ADVANCE_K 75 + + /** + * Some Slicers produce Gcode with randomly jumping extrusion widths occasionally. + * For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width. + * While this is harmless for normal printing (the fluid nature of the filament will + * close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption. + * + * For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio + * to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures + * if the slicer is using variable widths or layer heights within one print! + * + * This option sets the default E:D ratio at startup. Use `M905` to override this value. + * + * Example: `M905 W0.4 H0.2 D1.75`, where: + * - W is the extrusion width in mm + * - H is the layer height in mm + * - D is the filament diameter in mm + * + * Set to 0 to auto-detect the ratio based on given Gcode G1 print moves. + * + * Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode. + * Cura (as of this writing) may produce Gcode incompatible with the automatic mode. + */ + #define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI) + // Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135 +#endif + +// @section leveling + +// Default mesh area is an area with an inset margin on the print area. +// Below are the macros that are used to define the borders for the mesh area, +// made available here for specialized needs, ie dual extruder setup. +#if ENABLED(MESH_BED_LEVELING) + #define MESH_MIN_X (X_MIN_POS + MESH_INSET) + #define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) + #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) + #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) +#endif + +#if ENABLED(AUTO_BED_LEVELING_UBL) + #define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET) + #define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET)) + #define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET) + #define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET)) +#endif + +// @section extras + +// Arc interpretation settings: +#define ARC_SUPPORT // Disabling this saves ~2738 bytes +#define MM_PER_ARC_SEGMENT 1 +#define N_ARC_CORRECTION 25 + +// Support for G5 with XYZE destination and IJPQ offsets. Requires ~2666 bytes. +//#define BEZIER_CURVE_SUPPORT + +// G38.2 and G38.3 Probe Target +//#define G38_PROBE_TARGET +#if ENABLED(G38_PROBE_TARGET) + #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) +#endif + +// Moves (or segments) with fewer steps than this will be joined with the next move +#define MIN_STEPS_PER_SEGMENT 6 + +// The minimum pulse width (in µs) for stepping a stepper. +// Set this if you find stepping unreliable, or if using a very fast CPU. +#define MINIMUM_STEPPER_PULSE 0 // (µs) The smallest stepper pulse allowed + +// @section temperature + +// Control heater 0 and heater 1 in parallel. +//#define HEATERS_PARALLEL + +//=========================================================================== +//================================= Buffers ================================= +//=========================================================================== + +// @section hidden + +// The number of linear motions that can be in the plan at any give time. +// THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2, i.g. 8,16,32 because shifts and ors are used to do the ring-buffering. +#if ENABLED(SDSUPPORT) + #define BLOCK_BUFFER_SIZE 16 // SD,LCD,Buttons take more memory, block buffer needs to be smaller +#else + #define BLOCK_BUFFER_SIZE 16 // maximize block buffer +#endif + +// @section serial + +// The ASCII buffer for serial input +#define MAX_CMD_SIZE 96 +#define BUFSIZE 4 + +// Transfer Buffer Size +// To save 386 bytes of PROGMEM (and TX_BUFFER_SIZE+3 bytes of RAM) set to 0. +// To buffer a simple "ok" you need 4 bytes. +// For ADVANCED_OK (M105) you need 32 bytes. +// For debug-echo: 128 bytes for the optimal speed. +// Other output doesn't need to be that speedy. +// :[0, 2, 4, 8, 16, 32, 64, 128, 256] +#define TX_BUFFER_SIZE 0 + +// Enable an emergency-command parser to intercept certain commands as they +// enter the serial receive buffer, so they cannot be blocked. +// Currently handles M108, M112, M410 +// Does not work on boards using AT90USB (USBCON) processors! +//#define EMERGENCY_PARSER + +// Bad Serial-connections can miss a received command by sending an 'ok' +// Therefore some clients abort after 30 seconds in a timeout. +// Some other clients start sending commands while receiving a 'wait'. +// This "wait" is only sent when the buffer is empty. 1 second is a good value here. +//#define NO_TIMEOUTS 1000 // Milliseconds + +// Some clients will have this feature soon. This could make the NO_TIMEOUTS unnecessary. +//#define ADVANCED_OK + +// @section fwretract + +// Firmware based and LCD controlled retract +// M207 and M208 can be used to define parameters for the retraction. +// The retraction can be called by the slicer using G10 and G11 +// until then, intended retractions can be detected by moves that only extrude and the direction. +// the moves are than replaced by the firmware controlled ones. + +//#define FWRETRACT //ONLY PARTIALLY TESTED +#if ENABLED(FWRETRACT) + #define MIN_RETRACT 0.1 //minimum extruded mm to accept a automatic gcode retraction attempt + #define RETRACT_LENGTH 3 //default retract length (positive mm) + #define RETRACT_LENGTH_SWAP 13 //default swap retract length (positive mm), for extruder change + #define RETRACT_FEEDRATE 45 //default feedrate for retracting (mm/s) + #define RETRACT_ZLIFT 0 //default retract Z-lift + #define RETRACT_RECOVER_LENGTH 0 //default additional recover length (mm, added to retract length when recovering) + #define RETRACT_RECOVER_LENGTH_SWAP 0 //default additional swap recover length (mm, added to retract length when recovering from extruder change) + #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) +#endif + +/** + * Filament Change + * Experimental filament change support. + * Adds the GCode M600 for initiating filament change. + * + * Requires an LCD display. + * This feature is required for the default FILAMENT_RUNOUT_SCRIPT. + */ +//#define FILAMENT_CHANGE_FEATURE +#if ENABLED(FILAMENT_CHANGE_FEATURE) + #define FILAMENT_CHANGE_X_POS 3 // X position of hotend + #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend + #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) + #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) + #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) + #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s + #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm + // It is a short retract used immediately after print interrupt before move to filament exchange position + #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast + #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm + // Longer length for bowden printers to unload filament from whole bowden tube, + // shorter length for printers without bowden to unload filament from extruder only, + // 0 to disable unloading for manual unloading + #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast + #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm + // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, + // Short or zero length for printers without bowden where loading is not used + #define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate + #define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend, + // 0 to disable for manual extrusion + // Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, + // or until outcoming filament color is not clear for filament color change + #define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45L // Turn off nozzle if user doesn't change filament within this time limit in seconds + #define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5L // Number of alert beeps before printer goes quiet + #define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change + // even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME. +#endif + +// @section tmc + +/** + * Enable this section if you have TMC26X motor drivers. + * You will need to import the TMC26XStepper library into the Arduino IDE for this + * (https://github.com/trinamic/TMC26XStepper.git) + */ +//#define HAVE_TMCDRIVER + +#if ENABLED(HAVE_TMCDRIVER) + + //#define X_IS_TMC + //#define X2_IS_TMC + //#define Y_IS_TMC + //#define Y2_IS_TMC + //#define Z_IS_TMC + //#define Z2_IS_TMC + //#define E0_IS_TMC + //#define E1_IS_TMC + //#define E2_IS_TMC + //#define E3_IS_TMC + + #define X_MAX_CURRENT 1000 // in mA + #define X_SENSE_RESISTOR 91 // in mOhms + #define X_MICROSTEPS 16 // number of microsteps + + #define X2_MAX_CURRENT 1000 + #define X2_SENSE_RESISTOR 91 + #define X2_MICROSTEPS 16 + + #define Y_MAX_CURRENT 1000 + #define Y_SENSE_RESISTOR 91 + #define Y_MICROSTEPS 16 + + #define Y2_MAX_CURRENT 1000 + #define Y2_SENSE_RESISTOR 91 + #define Y2_MICROSTEPS 16 + + #define Z_MAX_CURRENT 1000 + #define Z_SENSE_RESISTOR 91 + #define Z_MICROSTEPS 16 + + #define Z2_MAX_CURRENT 1000 + #define Z2_SENSE_RESISTOR 91 + #define Z2_MICROSTEPS 16 + + #define E0_MAX_CURRENT 1000 + #define E0_SENSE_RESISTOR 91 + #define E0_MICROSTEPS 16 + + #define E1_MAX_CURRENT 1000 + #define E1_SENSE_RESISTOR 91 + #define E1_MICROSTEPS 16 + + #define E2_MAX_CURRENT 1000 + #define E2_SENSE_RESISTOR 91 + #define E2_MICROSTEPS 16 + + #define E3_MAX_CURRENT 1000 + #define E3_SENSE_RESISTOR 91 + #define E3_MICROSTEPS 16 + +#endif + +// @section TMC2130 + +/** + * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. + * + * You'll also need the TMC2130Stepper Arduino library + * (https://github.com/teemuatlut/TMC2130Stepper). + * + * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to + * the hardware SPI interface on your board and define the required CS pins + * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). + */ +//#define HAVE_TMC2130 + +#if ENABLED(HAVE_TMC2130) + #define STEALTHCHOP + + /** + * Let Marlin automatically control stepper current. + * This is still an experimental feature. + * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered, + * then decrease current by CURRENT_STEP until temperature prewarn is cleared. + * Adjusting starts from X/Y/Z/E_MAX_CURRENT but will not increase over AUTO_ADJUST_MAX + */ + //#define AUTOMATIC_CURRENT_CONTROL + #define CURRENT_STEP 50 // [mA] + #define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak + + // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY + //#define X_IS_TMC2130 + //#define X2_IS_TMC2130 + //#define Y_IS_TMC2130 + //#define Y2_IS_TMC2130 + //#define Z_IS_TMC2130 + //#define Z2_IS_TMC2130 + //#define E0_IS_TMC2130 + //#define E1_IS_TMC2130 + //#define E2_IS_TMC2130 + //#define E3_IS_TMC2130 + + /** + * Stepper driver settings + */ + + #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130 + #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current + #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256 + + #define X_MAX_CURRENT 1000 // rms current in mA + #define X_MICROSTEPS 16 // FULLSTEP..256 + #define X_CHIP_SELECT 40 // Pin + + #define Y_MAX_CURRENT 1000 + #define Y_MICROSTEPS 16 + #define Y_CHIP_SELECT 42 + + #define Z_MAX_CURRENT 1000 + #define Z_MICROSTEPS 16 + #define Z_CHIP_SELECT 65 + + //#define X2_MAX_CURRENT 1000 + //#define X2_MICROSTEPS 16 + //#define X2_CHIP_SELECT -1 + + //#define Y2_MAX_CURRENT 1000 + //#define Y2_MICROSTEPS 16 + //#define Y2_CHIP_SELECT -1 + + //#define Z2_MAX_CURRENT 1000 + //#define Z2_MICROSTEPS 16 + //#define Z2_CHIP_SELECT -1 + + //#define E0_MAX_CURRENT 1000 + //#define E0_MICROSTEPS 16 + //#define E0_CHIP_SELECT -1 + + //#define E1_MAX_CURRENT 1000 + //#define E1_MICROSTEPS 16 + //#define E1_CHIP_SELECT -1 + + //#define E2_MAX_CURRENT 1000 + //#define E2_MICROSTEPS 16 + //#define E2_CHIP_SELECT -1 + + //#define E3_MAX_CURRENT 1000 + //#define E3_MICROSTEPS 16 + //#define E3_CHIP_SELECT -1 + + /** + * You can set your own advanced settings by filling in predefined functions. + * A list of available functions can be found on the library github page + * https://github.com/teemuatlut/TMC2130Stepper + * + * Example: + * #define TMC2130_ADV() { \ + * stepperX.diag0_temp_prewarn(1); \ + * stepperX.interpolate(0); \ + * } + */ + #define TMC2130_ADV() { } + +#endif // ENABLED(HAVE_TMC2130) + +/** + * Enable this section if you have L6470 motor drivers. + * You need to import the L6470 library into the Arduino IDE for this. + * (https://github.com/ameyer/Arduino-L6470) + */ + +// @section l6470 + +//#define HAVE_L6470DRIVER +#if ENABLED(HAVE_L6470DRIVER) + + //#define X_IS_L6470 + //#define X2_IS_L6470 + //#define Y_IS_L6470 + //#define Y2_IS_L6470 + //#define Z_IS_L6470 + //#define Z2_IS_L6470 + //#define E0_IS_L6470 + //#define E1_IS_L6470 + //#define E2_IS_L6470 + //#define E3_IS_L6470 + + #define X_MICROSTEPS 16 // number of microsteps + #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high + #define X_OVERCURRENT 2000 // maxc current in mA. If the current goes over this value, the driver will switch off + #define X_STALLCURRENT 1500 // current in mA where the driver will detect a stall + + #define X2_MICROSTEPS 16 + #define X2_K_VAL 50 + #define X2_OVERCURRENT 2000 + #define X2_STALLCURRENT 1500 + + #define Y_MICROSTEPS 16 + #define Y_K_VAL 50 + #define Y_OVERCURRENT 2000 + #define Y_STALLCURRENT 1500 + + #define Y2_MICROSTEPS 16 + #define Y2_K_VAL 50 + #define Y2_OVERCURRENT 2000 + #define Y2_STALLCURRENT 1500 + + #define Z_MICROSTEPS 16 + #define Z_K_VAL 50 + #define Z_OVERCURRENT 2000 + #define Z_STALLCURRENT 1500 + + #define Z2_MICROSTEPS 16 + #define Z2_K_VAL 50 + #define Z2_OVERCURRENT 2000 + #define Z2_STALLCURRENT 1500 + + #define E0_MICROSTEPS 16 + #define E0_K_VAL 50 + #define E0_OVERCURRENT 2000 + #define E0_STALLCURRENT 1500 + + #define E1_MICROSTEPS 16 + #define E1_K_VAL 50 + #define E1_OVERCURRENT 2000 + #define E1_STALLCURRENT 1500 + + #define E2_MICROSTEPS 16 + #define E2_K_VAL 50 + #define E2_OVERCURRENT 2000 + #define E2_STALLCURRENT 1500 + + #define E3_MICROSTEPS 16 + #define E3_K_VAL 50 + #define E3_OVERCURRENT 2000 + #define E3_STALLCURRENT 1500 + +#endif + +/** + * TWI/I2C BUS + * + * This feature is an EXPERIMENTAL feature so it shall not be used on production + * machines. Enabling this will allow you to send and receive I2C data from slave + * devices on the bus. + * + * ; Example #1 + * ; This macro send the string "Marlin" to the slave device with address 0x63 (99) + * ; It uses multiple M260 commands with one B arg + * M260 A99 ; Target slave address + * M260 B77 ; M + * M260 B97 ; a + * M260 B114 ; r + * M260 B108 ; l + * M260 B105 ; i + * M260 B110 ; n + * M260 S1 ; Send the current buffer + * + * ; Example #2 + * ; Request 6 bytes from slave device with address 0x63 (99) + * M261 A99 B5 + * + * ; Example #3 + * ; Example serial output of a M261 request + * echo:i2c-reply: from:99 bytes:5 data:hello + */ + +// @section i2cbus + +//#define EXPERIMENTAL_I2CBUS +#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave + +/** + * Add M43, M44 and M45 commands for pins info and testing + */ +//#define PINS_DEBUGGING + +/** + * Auto-report temperatures with M155 S + */ +//#define AUTO_REPORT_TEMPERATURES + +/** + * Include capabilities in M115 output + */ +//#define EXTENDED_CAPABILITIES_REPORT + +/** + * Double-click the Encoder button on the Status Screen for Z Babystepping. + */ +//#define DOUBLECLICK_FOR_Z_BABYSTEPPING +#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds. + // Note: You may need to add extra time to mitigate controller latency. + +/** + * Volumetric extrusion default state + * Activate to make volumetric extrusion the default method, + * with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter. + * + * M200 D0 to disable, M200 Dn to set a new diameter. + */ +//#define VOLUMETRIC_DEFAULT_ON + +/** + * Enable this option for a leaner build of Marlin that removes all + * workspace offsets, simplifying coordinate transformations, leveling, etc. + * + * - M206 and M428 are disabled. + * - G92 will revert to its behavior from Marlin 1.0. + */ +//#define NO_WORKSPACE_OFFSETS + +#endif // CONFIGURATION_ADV_H diff --git a/Marlin/example_configurations/SCARA/Configuration.h b/Marlin/example_configurations/SCARA/Configuration.h index 73efa36ef..99de7a7c4 100644 --- a/Marlin/example_configurations/SCARA/Configuration.h +++ b/Marlin/example_configurations/SCARA/Configuration.h @@ -263,6 +263,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -618,8 +619,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -756,35 +756,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -808,10 +782,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -820,6 +806,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -840,11 +833,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -868,7 +856,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/TAZ4/Configuration.h b/Marlin/example_configurations/TAZ4/Configuration.h index 613c15bc2..22b279ad5 100644 --- a/Marlin/example_configurations/TAZ4/Configuration.h +++ b/Marlin/example_configurations/TAZ4/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -624,8 +625,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -762,35 +762,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -814,10 +788,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -826,6 +812,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -846,11 +839,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -874,7 +862,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/WITBOX/Configuration.h b/Marlin/example_configurations/WITBOX/Configuration.h index 2c57ac958..b00123423 100644 --- a/Marlin/example_configurations/WITBOX/Configuration.h +++ b/Marlin/example_configurations/WITBOX/Configuration.h @@ -234,6 +234,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -595,8 +596,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -733,35 +733,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -785,10 +759,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -797,6 +783,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -817,11 +810,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -845,7 +833,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/adafruit/ST7565/Configuration.h b/Marlin/example_configurations/adafruit/ST7565/Configuration.h index 736996fcd..1d292f8e8 100644 --- a/Marlin/example_configurations/adafruit/ST7565/Configuration.h +++ b/Marlin/example_configurations/adafruit/ST7565/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -603,8 +604,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -741,35 +741,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -793,10 +767,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -805,6 +791,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -825,11 +818,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -853,7 +841,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/delta/flsun_kossel_mini/Configuration.h b/Marlin/example_configurations/delta/flsun_kossel_mini/Configuration.h index b651b0dce..6eeaea08f 100644 --- a/Marlin/example_configurations/delta/flsun_kossel_mini/Configuration.h +++ b/Marlin/example_configurations/delta/flsun_kossel_mini/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -705,8 +706,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -844,35 +844,7 @@ #endif //=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== -// -// MESH_BED_LEVELING does not yet support DELTA printers. -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING - -//=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -896,10 +868,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT // Only AUTO_BED_LEVELING_BILINEAR is supported for DELTA bed leveling. //#define AUTO_BED_LEVELING_LINEAR // Only AUTO_BED_LEVELING_BILINEAR is supported for DELTA bed leveling. #define AUTO_BED_LEVELING_BILINEAR // Only AUTO_BED_LEVELING_BILINEAR is supported for DELTA bed leveling. +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -908,6 +892,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + //#define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -928,12 +919,6 @@ //#define PROBE_Y_FIRST #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - //#define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -957,7 +942,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/delta/generic/Configuration.h b/Marlin/example_configurations/delta/generic/Configuration.h index ca714ec54..a0abd3eea 100644 --- a/Marlin/example_configurations/delta/generic/Configuration.h +++ b/Marlin/example_configurations/delta/generic/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -689,8 +690,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -827,35 +827,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -879,10 +853,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -891,6 +877,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + //#define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -912,12 +905,6 @@ //#define PROBE_Y_FIRST #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - //#define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -941,7 +928,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/delta/kossel_mini/Configuration.h b/Marlin/example_configurations/delta/kossel_mini/Configuration.h index c7df7807e..b505ed75d 100644 --- a/Marlin/example_configurations/delta/kossel_mini/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_mini/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -692,8 +693,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -830,35 +830,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -882,10 +856,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -894,6 +880,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + //#define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -916,11 +909,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -944,7 +932,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/delta/kossel_pro/Configuration.h b/Marlin/example_configurations/delta/kossel_pro/Configuration.h index 344eead85..b88f00c67 100644 --- a/Marlin/example_configurations/delta/kossel_pro/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_pro/Configuration.h @@ -235,6 +235,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -691,8 +692,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -829,35 +829,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -881,10 +855,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR -#define AUTO_BED_LEVELING_BILINEAR +//#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -893,6 +879,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + //#define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -915,11 +908,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - //#define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -943,7 +931,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/delta/kossel_xl/Configuration.h b/Marlin/example_configurations/delta/kossel_xl/Configuration.h index 0d1cc036c..a6fafab2b 100644 --- a/Marlin/example_configurations/delta/kossel_xl/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_xl/Configuration.h @@ -74,6 +74,13 @@ // example_configurations/delta directory. // +//=========================================================================== +//============================= SCARA Printer =============================== +//=========================================================================== +// For a Scara printer replace the configuration files with the files in the +// example_configurations/SCARA directory. +// + // @section info // User-specified version info of this build to display in [Pronterface, etc] terminal window during @@ -224,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -695,8 +703,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -833,35 +840,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -885,10 +866,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR -#define AUTO_BED_LEVELING_BILINEAR +//#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -897,6 +890,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + //#define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -918,12 +918,6 @@ //#define PROBE_Y_FIRST #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - //#define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -947,7 +941,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/makibox/Configuration.h b/Marlin/example_configurations/makibox/Configuration.h index 9cbfde94b..4a3d8229b 100644 --- a/Marlin/example_configurations/makibox/Configuration.h +++ b/Marlin/example_configurations/makibox/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -606,8 +607,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -744,35 +744,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -796,10 +770,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -808,6 +794,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -828,11 +821,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -856,7 +844,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/tvrrug/Round2/Configuration.h b/Marlin/example_configurations/tvrrug/Round2/Configuration.h index 1f984aa89..089d47516 100644 --- a/Marlin/example_configurations/tvrrug/Round2/Configuration.h +++ b/Marlin/example_configurations/tvrrug/Round2/Configuration.h @@ -231,6 +231,7 @@ * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 * 66 : 4.7M High Temperature thermistor from Dyze Design * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor * * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. * (but gives greater accuracy and more stable PID) @@ -599,8 +600,7 @@ // // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN. // -// For a servo-based Z probe, you must set up servo support below, including -// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES. +// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above. // // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin. // - Use 5V for powered (usu. inductive) sensors. @@ -737,35 +737,9 @@ #define FILAMENT_RUNOUT_SCRIPT "M600" #endif -//=========================================================================== -//============================ Mesh Bed Leveling ============================ -//=========================================================================== - -//#define MESH_BED_LEVELING // Enable mesh bed leveling. - -#if ENABLED(MESH_BED_LEVELING) - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif // MANUAL_BED_LEVELING - - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - -#endif // MESH_BED_LEVELING //=========================================================================== -//============================ Auto Bed Leveling ============================ +//=============================== Bed Leveling ============================== //=========================================================================== // @section bedlevel @@ -789,10 +763,22 @@ * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. + * + * - UBL Unified Bed Leveling + * A comprehensive bed leveling system that combines features and benefits from previous + * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use + * Mesh Generation, Mesh Validation and Mesh Editing system. + * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with + * that said, it was primarily designed to handle poor quality Delta Printers. If you feel + * adventurous and have a Delta, please post an issue if something doesn't work correctly. + * Initially, you will need to reduce your declared bed size so you have a rectangular area to + * test on. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR +//#define MESH_BED_LEVELING +//#define AUTO_BED_LEVELING_UBL /** * Enable detailed logging of G28, G29, M48, etc. @@ -801,6 +787,13 @@ */ //#define DEBUG_LEVELING_FEATURE +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + #define ENABLE_LEVELING_FADE_HEIGHT +#endif + #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) // Set the number of grid points per dimension. @@ -821,11 +814,6 @@ #if ENABLED(AUTO_BED_LEVELING_BILINEAR) - // Gradually reduce leveling correction until a set height is reached, - // at which point movement will be level to the machine's XY plane. - // The height can be set with M420 Z - #define ENABLE_LEVELING_FADE_HEIGHT - // // Experimental Subdivision of the grid by Catmull-Rom method. // Synthesizes intermediate points to produce a more detailed mesh. @@ -849,7 +837,42 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#endif +#elif ENABLED(MESH_BED_LEVELING) + +//=========================================================================== +//=================================== Mesh ================================== +//=========================================================================== + + #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0. + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0] + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif // MANUAL_BED_LEVELING + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + +//=========================================================================== +//========================= Unified Bed Leveling ============================ +//=========================================================================== + + #define UBL_MESH_INSET 1 // Mesh inset margin on print area + #define UBL_MESH_NUM_X_POINTS 10 // Don't use more than 15 points per axis, implementation limited. + #define UBL_MESH_NUM_Y_POINTS 10 + #define UBL_PROBE_PT_1_X 39 // These set the probe locations for when UBL does a 3-Point leveling + #define UBL_PROBE_PT_1_Y 180 // of the mesh. + #define UBL_PROBE_PT_2_X 39 + #define UBL_PROBE_PT_2_Y 20 + #define UBL_PROBE_PT_3_X 180 + #define UBL_PROBE_PT_3_Y 20 + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/hex_print_routines.cpp b/Marlin/hex_print_routines.cpp new file mode 100644 index 000000000..19563ccb8 --- /dev/null +++ b/Marlin/hex_print_routines.cpp @@ -0,0 +1,47 @@ +/** + * 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 . + * + */ + + +#include "Marlin.h" +#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER) + +#include "hex_print_routines.h" + +void prt_hex_nibble(uint8_t n) { + if (n <= 9) + SERIAL_ECHO(n); + else + SERIAL_ECHO((char)('A' + n - 10)); + delay(3); +} + +void prt_hex_byte(uint8_t b) { + prt_hex_nibble((b & 0xF0) >> 4); + prt_hex_nibble(b & 0x0F); +} + +void prt_hex_word(uint16_t w) { + prt_hex_byte((w & 0xFF00) >> 8); + prt_hex_byte(w & 0x0FF); +} + +#endif // AUTO_BED_LEVELING_UBL || M100_FREE_MEMORY_WATCHER diff --git a/Marlin/hex_print_routines.h b/Marlin/hex_print_routines.h new file mode 100644 index 000000000..f6b7b28e2 --- /dev/null +++ b/Marlin/hex_print_routines.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 HEX_PRINT_ROUTINES_H +#define HEX_PRINT_ROUTINES_H + +// +// 3 support routines to print hex numbers. We can print a nibble, byte and word +// +void prt_hex_nibble(uint8_t n); +void prt_hex_byte(uint8_t b); +void prt_hex_word(uint16_t w); + +#endif // HEX_PRINT_ROUTINES_H \ No newline at end of file diff --git a/Marlin/printcounter.cpp b/Marlin/printcounter.cpp index b6cef6e71..b91b850b9 100644 --- a/Marlin/printcounter.cpp +++ b/Marlin/printcounter.cpp @@ -120,7 +120,7 @@ void PrintCounter::showStats() { #if ENABLED(DEBUG_PRINTCOUNTER) SERIAL_ECHOPGM(" ("); SERIAL_ECHO(this->data.printTime); - SERIAL_ECHOPGM(")"); + SERIAL_CHAR(')'); #endif elapsed = this->data.longestPrint; @@ -132,7 +132,7 @@ void PrintCounter::showStats() { #if ENABLED(DEBUG_PRINTCOUNTER) SERIAL_ECHOPGM(" ("); SERIAL_ECHO(this->data.longestPrint); - SERIAL_ECHOPGM(")"); + SERIAL_CHAR(')'); #endif SERIAL_EOL; diff --git a/Marlin/temperature.cpp b/Marlin/temperature.cpp index af76edb0f..883133806 100644 --- a/Marlin/temperature.cpp +++ b/Marlin/temperature.cpp @@ -24,6 +24,8 @@ * temperature.cpp - temperature control */ + + #include "Marlin.h" #include "ultralcd.h" #include "temperature.h" @@ -666,6 +668,17 @@ float Temperature::get_pid_output(int e) { * - Apply filament width to the extrusion rate (may move) * - Update the heated bed PID output value */ + +/** + * The following line SOMETIMES results in the dreaded "unable to find a register to spill in class 'POINTER_REGS'" + * compile error. + * thermal_runaway_protection(&thermal_runaway_state_machine[e], &thermal_runaway_timer[e], current_temperature[e], target_temperature[e], e, THERMAL_PROTECTION_PERIOD, THERMAL_PROTECTION_HYSTERESIS); + * + * This is due to a bug in the C++ compiler used by the Arduino IDE from 1.6.10 to at least 1.8.1. + * + * The work around is to add the compiler flag "__attribute__((__optimize__("O2")))" to the declaration for manage_heater() + */ +//void Temperature::manage_heater() __attribute__((__optimize__("O2"))); void Temperature::manage_heater() { if (!temp_meas_ready) return; diff --git a/Marlin/temperature.h b/Marlin/temperature.h index e59214844..d6451554f 100644 --- a/Marlin/temperature.h +++ b/Marlin/temperature.h @@ -241,7 +241,8 @@ class Temperature { /** * Call periodically to manage heaters */ - static void manage_heater(); + //static void manage_heater(); // changed to address compiler error + static void manage_heater() __attribute__((__optimize__("O2"))); /** * Preheating hotends diff --git a/Marlin/thermistornames.h b/Marlin/thermistornames.h index 64829ce74..2e672a450 100644 --- a/Marlin/thermistornames.h +++ b/Marlin/thermistornames.h @@ -65,6 +65,8 @@ #define THERMISTOR_NAME "Makers Tool" #elif THERMISTOR_ID == 70 #define THERMISTOR_NAME "Hephestos 2" +#elif THERMISTOR_ID == 75 + #define THERMISTOR_NAME "MGB18" // Modified thermistors #elif THERMISTOR_ID == 51 diff --git a/Marlin/thermistortable_75.h b/Marlin/thermistortable_75.h new file mode 100644 index 000000000..01be61146 --- /dev/null +++ b/Marlin/thermistortable_75.h @@ -0,0 +1,69 @@ +/** + * 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 . + * + */ + +// Generic Silicon Heat Pad with NTC 100K thermistor ( Beta 25/50 3950K) +// +// Many of the generic silicon heat pads use the MGB18-104F39050L32 Thermistor It is used for various +// wattage and voltage heat pads. This table is correct if this part is used. It has been +// optimized to provide good granularity around the 60 C. and 110 C. which corrisponds to bed temperatures +// for PLA and ABS. If you are printing higher temperature filament such as nylon you can uncomment +// the higher earlier entries in the table to give better accuracy. But for speed reasons, if these +// temperatures are not going to be used, it is better to leave them commented out. + +const short temptable_75[][2] PROGMEM = { // Generic Silicon Heat Pad with NTC 100K MGB18-104F39050L32 thermistor + { (short) ( 111.06 * OVERSAMPLENR ), 200 }, // v=0.542 r=571.747 res=0.501 degC/count +// { (short) ( 174.87 * OVERSAMPLENR ), 175 }, // v=0.854 r=967.950 res=0.311 degC/count These values are valid. But they serve no +// { (short) ( 191.64 * OVERSAMPLENR ), 170 }, // v=0.936 r=1082.139 res=0.284 degC/count purpose. It is better to delete them so +// { (short) ( 209.99 * OVERSAMPLENR ), 165 }, // v=1.025 r=1212.472 res=0.260 degC/count the search is quicker and get to the meaningful +// { (short) ( 230.02 * OVERSAMPLENR ), 160 }, // v=1.123 r=1361.590 res=0.239 degC/count part of the table sooner. +// { (short) ( 251.80 * OVERSAMPLENR ), 155 }, // v=1.230 r=1532.621 res=0.220 degC/count + { (short) ( 275.43 * OVERSAMPLENR ), 150 }, // v=1.345 r=1729.283 res=0.203 degC/count +// { (short) ( 300.92 * OVERSAMPLENR ), 145 }, // v=1.469 r=1956.004 res=0.189 degC/coun + { (short) ( 328.32 * OVERSAMPLENR ), 140 }, // v=1.603 r=2218.081 res=0.176 degC/count + { (short) ( 388.65 * OVERSAMPLENR ), 130 }, // v=1.898 r=2874.980 res=0.156 degC/count + { (short) ( 421.39 * OVERSAMPLENR ), 125 }, // v=2.058 r=3286.644 res=0.149 degC/count + { (short) ( 455.65 * OVERSAMPLENR ), 120 }, // v=2.225 r=3768.002 res=0.143 degC/count + { (short) ( 491.17 * OVERSAMPLENR ), 115 }, // v=2.398 r=4332.590 res=0.139 degC/count + { (short) ( 527.68 * OVERSAMPLENR ), 110 }, // v=2.577 r=4996.905 res=0.136 degC/count + { (short) ( 564.81 * OVERSAMPLENR ), 105 }, // v=2.758 r=5781.120 res=0.134 degC/count + { (short) ( 602.19 * OVERSAMPLENR ), 100 }, // v=2.940 r=6710.000 res=0.134 degC/count + { (short) ( 676.03 * OVERSAMPLENR ), 90 }, // v=3.301 r=9131.018 res=0.138 degC/count + { (short) ( 745.85 * OVERSAMPLENR ), 80 }, // v=3.642 r=12602.693 res=0.150 degC/count + { (short) ( 778.31 * OVERSAMPLENR ), 75 }, // v=3.800 r=14889.001 res=0.159 degC/count + { (short) ( 808.75 * OVERSAMPLENR ), 70 }, // v=3.949 r=17658.700 res=0.171 degC/count + { (short) ( 836.94 * OVERSAMPLENR ), 65 }, // v=4.087 r=21028.040 res=0.185 degC/count + { (short) ( 862.74 * OVERSAMPLENR ), 60 }, // v=4.213 r=25144.568 res=0.204 degC/count + { (short) ( 886.08 * OVERSAMPLENR ), 55 }, // v=4.327 r=30196.449 res=0.227 degC/count + { (short) ( 906.97 * OVERSAMPLENR ), 50 }, // v=4.429 r=36424.838 res=0.255 degC/count + { (short) ( 941.65 * OVERSAMPLENR ), 40 }, // v=4.598 r=53745.337 res=0.333 degC/count + { (short) ( 967.76 * OVERSAMPLENR ), 30 }, // v=4.725 r=80880.630 res=0.452 degC/count + { (short) ( 978.03 * OVERSAMPLENR ), 25 }, // v=4.776 r=100000.000 res=0.535 degC/count + { (short) ( 981.68 * OVERSAMPLENR ), 23 }, // v=4.793 r=109024.395 res=0.573 degC/count + { (short) ( 983.41 * OVERSAMPLENR ), 22 }, // v=4.802 r=113875.430 res=0.594 degC/count + { (short) ( 985.08 * OVERSAMPLENR ), 21 }, // v=4.810 r=118968.955 res=0.616 degC/count + { (short) ( 986.70 * OVERSAMPLENR ), 20 }, // v=4.818 r=124318.354 res=0.638 degC/count + { (short) ( 993.94 * OVERSAMPLENR ), 15 }, // v=4.853 r=155431.302 res=0.768 degC/count + { (short) ( 999.96 * OVERSAMPLENR ), 10 }, // v=4.883 r=195480.023 res=0.934 degC/count + { (short) (1008.95 * OVERSAMPLENR ), 0 } // v=4.926 r=314997.575 res=1.418 degC/count +}; + + diff --git a/Marlin/thermistortables.h b/Marlin/thermistortables.h index 36e5fe93b..421cfb7b7 100644 --- a/Marlin/thermistortables.h +++ b/Marlin/thermistortables.h @@ -103,6 +103,9 @@ #if ANY_THERMISTOR_IS(70) // bqh2 stock thermistor #include "thermistortable_70.h" #endif +#if ANY_THERMISTOR_IS(75) // Many of the generic silicon heat pads use the MGB18-104F39050L32 Thermistor + #include "thermistortable_75.h" +#endif #if ANY_THERMISTOR_IS(110) // Pt100 with 1k0 pullup #include "thermistortable_110.h" #endif diff --git a/Marlin/ultralcd.cpp b/Marlin/ultralcd.cpp index 2ba5419c5..e36444582 100755 --- a/Marlin/ultralcd.cpp +++ b/Marlin/ultralcd.cpp @@ -30,6 +30,8 @@ #include "configuration_store.h" #include "utility.h" +extern float zprobe_zoffset; + #if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER) #include "buzzer.h" #endif @@ -121,6 +123,11 @@ uint16_t max_display_update_time = 0; bool encoderRateMultiplierEnabled; int32_t lastEncoderMovementMillis; + #if ENABLED(AUTO_BED_LEVELING_UBL) + extern int UBL_has_control_of_LCD_Panel; + extern int G29_encoderDiff; + #endif + #if HAS_POWER_SWITCH extern bool powersupply; #endif @@ -801,6 +808,89 @@ void kill_screen(const char* lcd_msg) { #endif //BABYSTEPPING + #if ENABLED(AUTO_BED_LEVELING_UBL) + + float Mesh_Edit_Value, Mesh_Edit_Accumulator; // We round Mesh_Edit_Value to 2.5 decimal places. So we keep a + // seperate value that doesn't lose precision. + static int loop_cnt=0, last_seen_bits; + + static void _lcd_mesh_fine_tune( const char* msg) { + static unsigned long last_click=0; + int last_digit, movement; + long int rounded; + + defer_return_to_status = true; + if (encoderPosition) { // If moving the Encoder wheel very slowly, we just go + if ( (millis() - last_click) > 500L) { // up or down by 1 position + if ( ((int32_t)encoderPosition) > 0 ) { + encoderPosition = 1; + } + else { + encoderPosition = (uint32_t) -1; + } + } + last_click = millis(); + + Mesh_Edit_Accumulator += ( (float) ((int32_t)encoderPosition)) * .005 / 2.0 ; + Mesh_Edit_Value = Mesh_Edit_Accumulator; + encoderPosition = 0; + lcdDrawUpdate = LCDVIEW_REDRAW_NOW; + + rounded = (long int) (Mesh_Edit_Value * 1000.0); + last_digit = rounded % 5L; //10L; + rounded = rounded - last_digit; + last_digit = rounded % 5L; //10L; + Mesh_Edit_Value = ((float) rounded) / 1000.0; + } + + if (lcdDrawUpdate) { + lcd_implementation_drawedit(msg, ftostr43sign( (float) Mesh_Edit_Value )); + } + + if ( !UBL_has_control_of_LCD_Panel && LCD_CLICKED ) { + UBL_has_control_of_LCD_Panel=1; // We need to lock the normal LCD Panel System outbecause G29 (and G26) are looking for + lcd_return_to_status(); // long presses of the Encoder Wheel and the LCD System goes spastic when that happens. + // We will give back control from those routines when the switch is debounced. + } + } + + + void _lcd_mesh_edit() { + _lcd_mesh_fine_tune( PSTR("Mesh Editor: ")); + } + + float lcd_mesh_edit() { + lcd_goto_screen(_lcd_mesh_edit); + return Mesh_Edit_Value; + } + + void lcd_mesh_edit_setup(float inital) { + Mesh_Edit_Value = inital; + Mesh_Edit_Accumulator = inital; + lcd_goto_screen(_lcd_mesh_edit); + return ; + } + + void _lcd_z_offset_edit() { + _lcd_mesh_fine_tune( PSTR("Z-Offset: ")); + } + + float lcd_z_offset_edit() { + lcd_goto_screen(_lcd_z_offset_edit); + return Mesh_Edit_Value; + } + + void lcd_z_offset_edit_setup(float inital) { + Mesh_Edit_Value = inital; + Mesh_Edit_Accumulator = inital; + lcd_goto_screen(_lcd_z_offset_edit); + return ; + } + + + #endif // AUTO_BED_LEVELING_UBL + + /** * Watch temperature callbacks */ @@ -1307,7 +1397,11 @@ KeepDrawing: void _lcd_level_bed_moving() { if (lcdDrawUpdate) { char msg[10]; - sprintf_P(msg, PSTR("%i / %u"), (int)(manual_probe_index + 1), (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS)); + #if ENABLED(MESH_BED_LEVELING) + sprintf_P(msg, PSTR("%i / %u"), (int)(manual_probe_index + 1), (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS)); + #elif ENABLED(AUTO_BED_LEVELING_UBL) + sprintf_P(msg, PSTR("%i / %u"), (int)(manual_probe_index + 1), (UBL_MESH_NUM_X_POINTS) * (UBL_MESH_NUM_Y_POINTS)); + #endif lcd_implementation_drawedit(PSTR(MSG_LEVEL_BED_NEXT_POINT), msg); } @@ -3110,8 +3204,14 @@ void lcd_update() { lcd_buttons_update(); + #if ENABLED(AUTO_BED_LEVELING_UBL) + const bool UBL_CONDITION = !UBL_has_control_of_LCD_Panel; + #else + constexpr bool UBL_CONDITION = true; + #endif + // If the action button is pressed... - if (LCD_CLICKED) { + if (UBL_CONDITION && LCD_CLICKED) { if (!wait_for_unclick) { // If not waiting for a debounce release: wait_for_unclick = true; // Set debounce flag to ignore continous clicks lcd_clicked = !wait_for_user; // Keep the click if not waiting for a user-click @@ -3520,8 +3620,15 @@ void lcd_reset_alert_level() { lcd_status_message_level = 0; } case encrot2: ENCODER_SPIN(encrot1, encrot3); break; case encrot3: ENCODER_SPIN(encrot2, encrot0); break; } + #if ENABLED(AUTO_BED_LEVELING_UBL) + if (UBL_has_control_of_LCD_Panel) { + G29_encoderDiff = encoderDiff; // Make the encoder's rotation available to G29's Mesh Editor + encoderDiff = 0; // We are going to lie to the LCD Panel and claim the encoder + // wheel has not turned. + } + #endif + lastEncoderBits = enc; } - lastEncoderBits = enc; } #if (ENABLED(LCD_I2C_TYPE_MCP23017) || ENABLED(LCD_I2C_TYPE_MCP23008)) && ENABLED(DETECT_DEVICE) @@ -3530,6 +3637,19 @@ void lcd_reset_alert_level() { lcd_status_message_level = 0; } bool lcd_detected() { return true; } #endif + #if ENABLED(AUTO_BED_LEVELING_UBL) + void chirp_at_user() { + #if ENABLED(LCD_USE_I2C_BUZZER) + lcd.buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ); + #elif PIN_EXISTS(BEEPER) + buzzer.tone(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ); + #endif + } + + bool G29_lcd_clicked() { return LCD_CLICKED; } + + #endif + #endif // ULTIPANEL #endif // ULTRA_LCD diff --git a/Marlin/ultralcd_impl_DOGM.h b/Marlin/ultralcd_impl_DOGM.h index cbfecacfe..5f1e4447f 100644 --- a/Marlin/ultralcd_impl_DOGM.h +++ b/Marlin/ultralcd_impl_DOGM.h @@ -320,7 +320,7 @@ void lcd_kill_screen() { lcd_printPGM(PSTR(MSG_PLEASE_RESET)); } -static void lcd_implementation_clear() { } // Automatically cleared by Picture Loop +void lcd_implementation_clear() { } // Automatically cleared by Picture Loop // // Status Screen diff --git a/Marlin/ultralcd_impl_HD44780.h b/Marlin/ultralcd_impl_HD44780.h index 8ccc96123..7ac7f86b8 100644 --- a/Marlin/ultralcd_impl_HD44780.h +++ b/Marlin/ultralcd_impl_HD44780.h @@ -378,7 +378,7 @@ static void lcd_implementation_init( lcd.clear(); } -static void lcd_implementation_clear() { lcd.clear(); } +void lcd_implementation_clear() { lcd.clear(); } /* Arduino < 1.0.0 is missing a function to print PROGMEM strings, so we need to implement our own */ void lcd_printPGM(const char *str) {