From 4ebeb140261493eb85b068d77ee00c7db526998e Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:01:49 -0500 Subject: [PATCH 01/12] Update README.md Changed "Bed Auto Level" (and variants) to "Auto Bed Compensation". --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 9e28c85ac..0f1fb233c 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,7 @@ Features: * Configurable serial port to support connection of wireless adaptors. * Automatic operation of extruder/cold-end cooling fans based on nozzle temperature * RC Servo Support, specify angle or duration for continuous rotation servos. -* Bed Auto Leveling. +* Auto Bed Compensation. * Support for a filament diameter sensor, which adjusts extrusion volume The default baudrate is 250000. This baudrate has less jitter and hence errors than the usual 115200 baud, but is less supported by drivers and host-environments. @@ -279,7 +279,7 @@ If all goes well the firmware is uploading That's ok. Enjoy Silky Smooth Printing. =============================================== -Instructions for configuring Bed Auto Leveling +Instructions for configuring Auto Bed Compensation =============================================== There are two options for this feature. You may choose to use a servo mounted on the X carriage or you may use a sled that mounts on the X axis and can be docked when not in use. See the section for each option below for specifics about installation and configuration. Also included are instructions that apply to both options. @@ -295,7 +295,7 @@ If jumping the arduino Vcc do RAMPS 5V rail, take care to not use a power hungry Instructions for Both Options ----------------------------- -Uncomment the "ENABLE_AUTO_BED_LEVELING" define (commented by default) +Uncomment the "ENABLE_AUTO_BED_COMPENSATION" define (commented by default) The following options define the probing positions. These are good starting values. I recommend to keep a better clearance from borders in the first run and then make the probes as close as possible to borders: @@ -391,7 +391,7 @@ For example, suppose you measured the endstop position and it was 20mm to the ri * \#define Y_PROBE_OFFSET_FROM_EXTRUDER 10 * \#define Z_PROBE_OFFSET_FROM_EXTRUDER 2.75 -That's it.. enjoy never having to calibrate your Z endstop neither leveling your bed by hand anymore ;-) +That's it.. enjoy never having to calibrate your Z endstop neither tramming your bed by hand anymore ;-) Filament Sensor --------------- From 81568c3c6d84673833dc81d0b906e39e66ffb74c Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:06:56 -0500 Subject: [PATCH 02/12] Update Configuration.h Changed Auto Bed Level to Auto Bed Compensation --- Marlin/Configuration.h | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index b99ec6a29..29032f87a 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -340,12 +340,12 @@ const bool Z_MAX_ENDSTOP_INVERTING = true; // set to true to invert the logic of #define X_MAX_LENGTH (X_MAX_POS - X_MIN_POS) #define Y_MAX_LENGTH (Y_MAX_POS - Y_MIN_POS) #define Z_MAX_LENGTH (Z_MAX_POS - Z_MIN_POS) -//============================= Bed Auto Leveling =========================== +//============================= Bed Auto Compensation =========================== -//#define ENABLE_AUTO_BED_LEVELING // Delete the comment to enable (remove // at the start of the line) -#define Z_PROBE_REPEATABILITY_TEST // If not commented out, Z-Probe Repeatability test will be included if Auto Bed Leveling is Enabled. +//#define ENABLE_AUTO_BED_COMPENSATION // Delete the comment to enable (remove // at the start of the line) +#define Z_PROBE_REPEATABILITY_TEST // If not commented out, Z-Probe Repeatability test will be included if Auto Bed Compensation is Enabled. -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION // There are 2 different ways to pick the X and Y locations to probe: @@ -353,18 +353,18 @@ const bool Z_MAX_ENDSTOP_INVERTING = true; // set to true to invert the logic of // Probe every point in a rectangular grid // You must specify the rectangle, and the density of sample points // This mode is preferred because there are more measurements. -// It used to be called ACCURATE_BED_LEVELING but "grid" is more descriptive +// It used to be called ACCURATE_BED_COMPENSATION but "grid" is more descriptive // - "3-point" mode // Probe 3 arbitrary points on the bed (that aren't colinear) // You must specify the X & Y coordinates of all 3 points - #define AUTO_BED_LEVELING_GRID - // with AUTO_BED_LEVELING_GRID, the bed is sampled in a - // AUTO_BED_LEVELING_GRID_POINTSxAUTO_BED_LEVELING_GRID_POINTS grid + #define AUTO_BED_COMPENSATION_GRID + // with AUTO_BED_COMPENSATION_GRID, the bed is sampled in a + // AUTO_BED_COMPENSATION_GRID_POINTSxAUTO_BED_COMPENSATION_GRID_POINTS grid // and least squares solution is calculated // Note: this feature occupies 10'206 byte - #ifdef AUTO_BED_LEVELING_GRID + #ifdef AUTO_BED_COMPENSATION_GRID // set the rectangle in which to probe #define LEFT_PROBE_BED_POSITION 15 @@ -374,10 +374,10 @@ const bool Z_MAX_ENDSTOP_INVERTING = true; // set to true to invert the logic of // set the number of grid points per dimension // I wouldn't see a reason to go above 3 (=9 probing points on the bed) - #define AUTO_BED_LEVELING_GRID_POINTS 2 + #define AUTO_BED_COMPENSATION_GRID_POINTS 2 - #else // not AUTO_BED_LEVELING_GRID + #else // not AUTO_BED_COMPENSATION_GRID // with no grid, just probe 3 arbitrary points. A simple cross-product // is used to esimate the plane of the print bed @@ -388,7 +388,7 @@ const bool Z_MAX_ENDSTOP_INVERTING = true; // set to true to invert the logic of #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 - #endif // AUTO_BED_LEVELING_GRID + #endif // AUTO_BED_COMPENSATION_GRID // these are the offsets to the probe relative to the extruder tip (Hotend - Probe) @@ -414,7 +414,7 @@ const bool Z_MAX_ENDSTOP_INVERTING = true; // set to true to invert the logic of // #define PROBE_SERVO_DEACTIVATION_DELAY 300 -//If you have enabled the Bed Auto Leveling and are using the same Z Probe for Z Homing, +//If you have enabled the Bed Auto Compensation and are using the same Z Probe for Z Homing, //it is highly recommended you let this Z_SAFE_HOMING enabled!!! #define Z_SAFE_HOMING // This feature is meant to avoid Z homing with probe outside the bed area. @@ -431,7 +431,7 @@ const bool Z_MAX_ENDSTOP_INVERTING = true; // set to true to invert the logic of #endif -#endif // ENABLE_AUTO_BED_LEVELING +#endif // ENABLE_AUTO_BED_COMPENSATION // The position of the homing switches From 7464d3c96acb892bbac95a9c4ab3d03a94378fa0 Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:08:43 -0500 Subject: [PATCH 03/12] Update ConfigurationStore.cpp Changed AUTO_BED_LEVEL to AUTO_BED_COMPENSATION --- Marlin/ConfigurationStore.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Marlin/ConfigurationStore.cpp b/Marlin/ConfigurationStore.cpp index 54e69c013..4ce2f85d7 100644 --- a/Marlin/ConfigurationStore.cpp +++ b/Marlin/ConfigurationStore.cpp @@ -319,7 +319,7 @@ void Config_ResetDefault() absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP; absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED; #endif -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION zprobe_zoffset = -Z_PROBE_OFFSET_FROM_EXTRUDER; #endif #ifdef DOGLCD From cfe80e1defdbb8e717933c4ebc40b50baf42932f Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:14:35 -0500 Subject: [PATCH 04/12] Update vector_3.h --- Marlin/vector_3.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Marlin/vector_3.h b/Marlin/vector_3.h index 0b9decafa..7d3544fef 100644 --- a/Marlin/vector_3.h +++ b/Marlin/vector_3.h @@ -1,5 +1,5 @@ /* - vector_3.cpp - Vector library for bed leveling + vector_3.cpp - Vector library for bed compensation Copyright (c) 2012 Lars Brubaker. All right reserved. This library is free software; you can redistribute it and/or @@ -19,7 +19,7 @@ #ifndef VECTOR_3_H #define VECTOR_3_H -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION class matrix_3x3; struct vector_3 @@ -57,6 +57,6 @@ struct matrix_3x3 void apply_rotation_xyz(matrix_3x3 rotationMatrix, float &x, float& y, float& z); -#endif // ENABLE_AUTO_BED_LEVELING +#endif // ENABLE_AUTO_BED_COMPENSATION #endif // VECTOR_3_H From 825c46024d308f78b1aa1a2734e735248784857d Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:16:31 -0500 Subject: [PATCH 05/12] Update vector_3.cpp Changed AUTO_BED_LEVEL to AUTO_BED_COMPENSATION --- Marlin/vector_3.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Marlin/vector_3.cpp b/Marlin/vector_3.cpp index 5f1c294ed..d2fed0501 100644 --- a/Marlin/vector_3.cpp +++ b/Marlin/vector_3.cpp @@ -1,5 +1,5 @@ /* - vector_3.cpp - Vector library for bed leveling + vector_3.cpp - Vector library for bed compensation Copyright (c) 2012 Lars Brubaker. All right reserved. This library is free software; you can redistribute it and/or @@ -19,7 +19,7 @@ #include #include "Marlin.h" -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION #include "vector_3.h" vector_3::vector_3() : x(0), y(0), z(0) { } @@ -163,5 +163,5 @@ void matrix_3x3::debug(char* title) } } -#endif // #ifdef ENABLE_AUTO_BED_LEVELING +#endif // #ifdef ENABLE_AUTO_BED_COMPENSATION From 58c4473beafee320f00138daff90361b678fe4d6 Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:18:55 -0500 Subject: [PATCH 06/12] Update Servo.cpp Changed AUTO_BED_LEVELING to AUTO_BED_COMPENSATION --- Marlin/Servo.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Marlin/Servo.cpp b/Marlin/Servo.cpp index 5f8c7efe3..2f766188c 100644 --- a/Marlin/Servo.cpp +++ b/Marlin/Servo.cpp @@ -262,7 +262,7 @@ uint8_t Servo::attach(int pin) uint8_t Servo::attach(int pin, int min, int max) { if(this->servoIndex < MAX_SERVOS ) { -#if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) +#if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) if (pin > 0) this->pin = pin; else pin = this->pin; #endif pinMode( pin, OUTPUT) ; // set servo pin to output From f21c65918f27ce7f8fda69a5b56a9ed811747e61 Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:20:09 -0500 Subject: [PATCH 07/12] Update Servo.h Changed AUTO_BED_LEVELING to AUTO_BED_COMPENSATION --- Marlin/Servo.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Marlin/Servo.h b/Marlin/Servo.h index 204497a4a..ba7a414a0 100644 --- a/Marlin/Servo.h +++ b/Marlin/Servo.h @@ -123,7 +123,7 @@ public: int read(); // returns current pulse width as an angle between 0 and 180 degrees int readMicroseconds(); // returns current pulse width in microseconds for this servo (was read_us() in first release) bool attached(); // return true if this servo is attached, otherwise false -#if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) +#if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) int pin; // store the hardware pin of the servo #endif private: From 4315c2547adc41ba3653d45beb8f94de13eb973f Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:41:29 -0500 Subject: [PATCH 08/12] Update Marlin_main.cpp Changed level and leveling to compensation (except with "verbose_level" and "lcd_reset_alert_level"). --- Marlin/Marlin_main.cpp | 114 ++++++++++++++++++++--------------------- 1 file changed, 57 insertions(+), 57 deletions(-) diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 7efc15ada..d12d050d9 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -29,12 +29,12 @@ #include "Marlin.h" -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION #include "vector_3.h" - #ifdef AUTO_BED_LEVELING_GRID + #ifdef AUTO_BED_COMPENSATION_GRID #include "qr_solve.h" #endif -#endif // ENABLE_AUTO_BED_LEVELING +#endif // ENABLE_AUTO_BED_COMPENSATION #include "ultralcd.h" #include "planner.h" @@ -520,7 +520,7 @@ void servo_init() } #endif - #if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) + #if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) delay(PROBE_SERVO_DEACTIVATION_DELAY); servos[servo_endstops[Z_AXIS]].detach(); #endif @@ -962,16 +962,16 @@ static void axis_is_at_home(int axis) { #endif } -#ifdef ENABLE_AUTO_BED_LEVELING -#ifdef AUTO_BED_LEVELING_GRID -static void set_bed_level_equation_lsq(double *plane_equation_coefficients) +#ifdef ENABLE_AUTO_BED_COMPENSATION +#ifdef AUTO_BED_COMPENSATION_GRID +static void set_bed_compensation_equation_lsq(double *plane_equation_coefficients) { vector_3 planeNormal = vector_3(-plane_equation_coefficients[0], -plane_equation_coefficients[1], 1); planeNormal.debug("planeNormal"); - plan_bed_level_matrix = matrix_3x3::create_look_at(planeNormal); - //bedLevel.debug("bedLevel"); + plan_bed_compensation_matrix = matrix_3x3::create_look_at(planeNormal); + //bedCompensation.debug("bedCompensation"); - //plan_bed_level_matrix.debug("bed level before"); + //plan_bed_compensation_matrix.debug("bed compensation before"); //vector_3 uncorrected_position = plan_get_position_mm(); //uncorrected_position.debug("position before"); @@ -987,11 +987,11 @@ static void set_bed_level_equation_lsq(double *plane_equation_coefficients) plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); } -#else // not AUTO_BED_LEVELING_GRID +#else // not AUTO_BED_COMPENSATION_GRID -static void set_bed_level_equation_3pts(float z_at_pt_1, float z_at_pt_2, float z_at_pt_3) { +static void set_bed_compensation_equation_3pts(float z_at_pt_1, float z_at_pt_2, float z_at_pt_3) { - plan_bed_level_matrix.set_to_identity(); + plan_bed_compensation_matrix.set_to_identity(); vector_3 pt1 = vector_3(ABL_PROBE_PT_1_X, ABL_PROBE_PT_1_Y, z_at_pt_1); vector_3 pt2 = vector_3(ABL_PROBE_PT_2_X, ABL_PROBE_PT_2_Y, z_at_pt_2); @@ -1002,7 +1002,7 @@ static void set_bed_level_equation_3pts(float z_at_pt_1, float z_at_pt_2, float vector_3 planeNormal = vector_3::cross(from_2_to_1, from_2_to_3).get_normal(); planeNormal = vector_3(planeNormal.x, planeNormal.y, abs(planeNormal.z)); - plan_bed_level_matrix = matrix_3x3::create_look_at(planeNormal); + plan_bed_compensation_matrix = matrix_3x3::create_look_at(planeNormal); vector_3 corrected_position = plan_get_position(); current_position[X_AXIS] = corrected_position.x; @@ -1016,10 +1016,10 @@ static void set_bed_level_equation_3pts(float z_at_pt_1, float z_at_pt_2, float } -#endif // AUTO_BED_LEVELING_GRID +#endif // AUTO_BED_COMPENSATION_GRID static void run_z_probe() { - plan_bed_level_matrix.set_to_identity(); + plan_bed_compensation_matrix.set_to_identity(); feedrate = homing_feedrate[Z_AXIS]; // move down until you find the bed @@ -1088,11 +1088,11 @@ static void engage_z_probe() { // Engage Z Servo endstop if enabled #ifdef SERVO_ENDSTOPS if (servo_endstops[Z_AXIS] > -1) { -#if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) +#if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) servos[servo_endstops[Z_AXIS]].attach(0); #endif servos[servo_endstops[Z_AXIS]].write(servo_endstop_angles[Z_AXIS * 2]); -#if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) +#if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) delay(PROBE_SERVO_DEACTIVATION_DELAY); servos[servo_endstops[Z_AXIS]].detach(); #endif @@ -1104,11 +1104,11 @@ static void retract_z_probe() { // Retract Z Servo endstop if enabled #ifdef SERVO_ENDSTOPS if (servo_endstops[Z_AXIS] > -1) { -#if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) +#if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) servos[servo_endstops[Z_AXIS]].attach(0); #endif servos[servo_endstops[Z_AXIS]].write(servo_endstop_angles[Z_AXIS * 2 + 1]); -#if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) +#if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) delay(PROBE_SERVO_DEACTIVATION_DELAY); servos[servo_endstops[Z_AXIS]].detach(); #endif @@ -1142,7 +1142,7 @@ static float probe_pt(float x, float y, float z_before) { return measured_z; } -#endif // #ifdef ENABLE_AUTO_BED_LEVELING +#endif // #ifdef ENABLE_AUTO_BED_COMPENSATION static void homeaxis(int axis) { #define HOMEAXIS_DO(LETTER) \ @@ -1165,7 +1165,7 @@ static void homeaxis(int axis) { #ifndef Z_PROBE_SLED // Engage Servo endstop if enabled #ifdef SERVO_ENDSTOPS - #if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) + #if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) if (axis==Z_AXIS) { engage_z_probe(); } @@ -1216,7 +1216,7 @@ static void homeaxis(int axis) { servos[servo_endstops[axis]].write(servo_endstop_angles[axis * 2 + 1]); } #endif -#if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) +#if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) #ifndef Z_PROBE_SLED if (axis==Z_AXIS) retract_z_probe(); #endif @@ -1325,7 +1325,7 @@ void process_commands() { unsigned long codenum; //throw away variable char *starpos = NULL; -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION float x_tmp, y_tmp, z_tmp, real_z; #endif if(code_seen('G')) @@ -1399,9 +1399,9 @@ void process_commands() break; #endif //FWRETRACT case 28: //G28 Home all Axis one at a time -#ifdef ENABLE_AUTO_BED_LEVELING - plan_bed_level_matrix.set_to_identity(); //Reset the plane ("erase" all leveling data) -#endif //ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION + plan_bed_compensation_matrix.set_to_identity(); //Reset the plane ("erase" all compensation data) +#endif //ENABLE_AUTO_BED_COMPENSATION saved_feedrate = feedrate; saved_feedmultiply = feedmultiply; @@ -1605,7 +1605,7 @@ void process_commands() current_position[Z_AXIS]=code_value()+add_homing[Z_AXIS]; } } - #ifdef ENABLE_AUTO_BED_LEVELING + #ifdef ENABLE_AUTO_BED_COMPENSATION if((home_all_axis) || (code_seen(axis_codes[Z_AXIS]))) { current_position[Z_AXIS] += zprobe_zoffset; //Add Z_Probe offset (the distance is negative) } @@ -1628,11 +1628,11 @@ void process_commands() endstops_hit_on_purpose(); break; -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION case 29: // G29 Detailed Z-Probe, probes the bed at 3 or more points. { #if Z_MIN_PIN == -1 - #error "You must have a Z_MIN endstop in order to enable Auto Bed Leveling feature!!! Z_MIN_PIN must point to a valid hardware pin." + #error "You must have a Z_MIN endstop in order to enable Auto Bed Compensation feature!!! Z_MIN_PIN must point to a valid hardware pin." #endif // Prevent user from running a G29 without first homing in X and Y @@ -1648,10 +1648,10 @@ void process_commands() dock_sled(false); #endif // Z_PROBE_SLED st_synchronize(); - // make sure the bed_level_rotation_matrix is identity or the planner will get it incorectly + // make sure the bed_compensation_rotation_matrix is identity or the planner will get it incorectly //vector_3 corrected_position = plan_get_position_mm(); //corrected_position.debug("position before G29"); - plan_bed_level_matrix.set_to_identity(); + plan_bed_compensation_matrix.set_to_identity(); vector_3 uncorrected_position = plan_get_position(); //uncorrected_position.debug("position durring G29"); current_position[X_AXIS] = uncorrected_position.x; @@ -1661,11 +1661,11 @@ void process_commands() setup_for_endstop_move(); feedrate = homing_feedrate[Z_AXIS]; -#ifdef AUTO_BED_LEVELING_GRID +#ifdef AUTO_BED_COMPENSATION_GRID // probe at the points of a lattice grid - int xGridSpacing = (RIGHT_PROBE_BED_POSITION - LEFT_PROBE_BED_POSITION) / (AUTO_BED_LEVELING_GRID_POINTS-1); - int yGridSpacing = (BACK_PROBE_BED_POSITION - FRONT_PROBE_BED_POSITION) / (AUTO_BED_LEVELING_GRID_POINTS-1); + int xGridSpacing = (RIGHT_PROBE_BED_POSITION - LEFT_PROBE_BED_POSITION) / (AUTO_BED_COMPENSATION_GRID_POINTS-1); + int yGridSpacing = (BACK_PROBE_BED_POSITION - FRONT_PROBE_BED_POSITION) / (AUTO_BED_COMPENSATION_GRID_POINTS-1); // solve the plane equation ax + by + d = z @@ -1675,9 +1675,9 @@ void process_commands() // so Vx = -a Vy = -b Vz = 1 (we want the vector facing towards positive Z // "A" matrix of the linear system of equations - double eqnAMatrix[AUTO_BED_LEVELING_GRID_POINTS*AUTO_BED_LEVELING_GRID_POINTS*3]; + double eqnAMatrix[AUTO_BED_COMPENSATION_GRID_POINTS*AUTO_BED_COMPENSATION_GRID_POINTS*3]; // "B" vector of Z points - double eqnBVector[AUTO_BED_LEVELING_GRID_POINTS*AUTO_BED_LEVELING_GRID_POINTS]; + double eqnBVector[AUTO_BED_COMPENSATION_GRID_POINTS*AUTO_BED_COMPENSATION_GRID_POINTS]; int probePointCounter = 0; @@ -1700,7 +1700,7 @@ void process_commands() zig = true; } - for (int xCount=0; xCount < AUTO_BED_LEVELING_GRID_POINTS; xCount++) + for (int xCount=0; xCount < AUTO_BED_COMPENSATION_GRID_POINTS; xCount++) { float z_before; if (probePointCounter == 0) @@ -1717,9 +1717,9 @@ void process_commands() eqnBVector[probePointCounter] = measured_z; - eqnAMatrix[probePointCounter + 0*AUTO_BED_LEVELING_GRID_POINTS*AUTO_BED_LEVELING_GRID_POINTS] = xProbe; - eqnAMatrix[probePointCounter + 1*AUTO_BED_LEVELING_GRID_POINTS*AUTO_BED_LEVELING_GRID_POINTS] = yProbe; - eqnAMatrix[probePointCounter + 2*AUTO_BED_LEVELING_GRID_POINTS*AUTO_BED_LEVELING_GRID_POINTS] = 1; + eqnAMatrix[probePointCounter + 0*AUTO_BED_COMPENSATION_GRID_POINTS*AUTO_BED_COMPENSATION_GRID_POINTS] = xProbe; + eqnAMatrix[probePointCounter + 1*AUTO_BED_COMPENSATION_GRID_POINTS*AUTO_BED_COMPENSATION_GRID_POINTS] = yProbe; + eqnAMatrix[probePointCounter + 2*AUTO_BED_COMPENSATION_GRID_POINTS*AUTO_BED_COMPENSATION_GRID_POINTS] = 1; probePointCounter++; xProbe += xInc; } @@ -1727,7 +1727,7 @@ void process_commands() clean_up_after_endstop_move(); // solve lsq problem - double *plane_equation_coefficients = qr_solve(AUTO_BED_LEVELING_GRID_POINTS*AUTO_BED_LEVELING_GRID_POINTS, 3, eqnAMatrix, eqnBVector); + double *plane_equation_coefficients = qr_solve(AUTO_BED_COMPENSATION_GRID_POINTS*AUTO_BED_COMPENSATION_GRID_POINTS, 3, eqnAMatrix, eqnBVector); SERIAL_PROTOCOLPGM("Eqn coefficients: a: "); SERIAL_PROTOCOL(plane_equation_coefficients[0]); @@ -1737,11 +1737,11 @@ void process_commands() SERIAL_PROTOCOLLN(plane_equation_coefficients[2]); - set_bed_level_equation_lsq(plane_equation_coefficients); + set_bed_compensation_equation_lsq(plane_equation_coefficients); free(plane_equation_coefficients); -#else // AUTO_BED_LEVELING_GRID not defined +#else // AUTO_BED_COMPENSATION_GRID not defined // Probe at 3 arbitrary points // probe 1 @@ -1755,21 +1755,21 @@ void process_commands() clean_up_after_endstop_move(); - set_bed_level_equation_3pts(z_at_pt_1, z_at_pt_2, z_at_pt_3); + set_bed_compensation_equation_3pts(z_at_pt_1, z_at_pt_2, z_at_pt_3); -#endif // AUTO_BED_LEVELING_GRID +#endif // AUTO_BED_COMPENSATION_GRID st_synchronize(); // The following code correct the Z height difference from z-probe position and hotend tip position. // The Z height on homing is measured by Z-Probe, but the probe is quite far from the hotend. // When the bed is uneven, this height must be corrected. - real_z = float(st_get_position(Z_AXIS))/axis_steps_per_unit[Z_AXIS]; //get the real Z (since the auto bed leveling is already correcting the plane) + real_z = float(st_get_position(Z_AXIS))/axis_steps_per_unit[Z_AXIS]; //get the real Z (since the auto bed compensation is already correcting the plane) x_tmp = current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER; y_tmp = current_position[Y_AXIS] + Y_PROBE_OFFSET_FROM_EXTRUDER; z_tmp = current_position[Z_AXIS]; - apply_rotation_xyz(plan_bed_level_matrix, x_tmp, y_tmp, z_tmp); //Apply the correction sending the probe offset + apply_rotation_xyz(plan_bed_compensation_matrix, x_tmp, y_tmp, z_tmp); //Apply the correction sending the probe offset current_position[Z_AXIS] = z_tmp - real_z + current_position[Z_AXIS]; //The difference is added to current position and sent to planner. plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); #ifdef Z_PROBE_SLED @@ -1782,7 +1782,7 @@ void process_commands() { engage_z_probe(); // Engage Z Servo endstop if available st_synchronize(); - // TODO: make sure the bed_level_rotation_matrix is identity or the planner will get set incorectly + // TODO: make sure the bed_compensation_rotation_matrix is identity or the planner will get set incorectly setup_for_endstop_move(); feedrate = homing_feedrate[Z_AXIS]; @@ -1809,7 +1809,7 @@ void process_commands() dock_sled(false); break; #endif // Z_PROBE_SLED -#endif // ENABLE_AUTO_BED_LEVELING +#endif // ENABLE_AUTO_BED_COMPENSATION case 90: // G90 relative_mode = false; break; @@ -2068,7 +2068,7 @@ void process_commands() // // This function assumes the bed has been homed. Specificaly, that a G28 command // as been issued prior to invoking the M48 Z-Probe repeatability measurement function. -// Any information generated by a prior G29 Bed leveling command will be lost and need to be +// Any information generated by a prior G29 Bed compensation command will be lost and need to be // regenerated. // // The number of samples will default to 10 if not specified. You can use upper or lower case @@ -2076,7 +2076,7 @@ void process_commands() // N for its communication protocol and will get horribly confused if you send it a capital N. // -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION #ifdef Z_PROBE_REPEATABILITY_TEST case 48: // M48 Z-Probe repeatability @@ -2154,7 +2154,7 @@ void process_commands() // st_synchronize(); - plan_bed_level_matrix.set_to_identity(); + plan_bed_compensation_matrix.set_to_identity(); plan_buffer_line( X_current, Y_current, Z_start_location, ext_position, homing_feedrate[Z_AXIS]/60, @@ -2333,7 +2333,7 @@ Sigma_Exit: break; } #endif // Z_PROBE_REPEATABILITY_TEST -#endif // ENABLE_AUTO_BED_LEVELING +#endif // ENABLE_AUTO_BED_COMPENSATION case 104: // M104 if(setTargetedHotend(104)){ @@ -3093,11 +3093,11 @@ Sigma_Exit: if (code_seen('S')) { servo_position = code_value(); if ((servo_index >= 0) && (servo_index < NUM_SERVOS)) { -#if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) +#if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) servos[servo_index].attach(0); #endif servos[servo_index].write(servo_position); -#if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) +#if defined (ENABLE_AUTO_BED_COMPENSATION) && (PROBE_SERVO_DEACTIVATION_DELAY > 0) delay(PROBE_SERVO_DEACTIVATION_DELAY); servos[servo_index].detach(); #endif @@ -3362,7 +3362,7 @@ Sigma_Exit: st_synchronize(); } break; -#if defined(ENABLE_AUTO_BED_LEVELING) && defined(SERVO_ENDSTOPS) && not defined(Z_PROBE_SLED) +#if defined(ENABLE_AUTO_BED_COMPENSATION) && defined(SERVO_ENDSTOPS) && not defined(Z_PROBE_SLED) case 401: { engage_z_probe(); // Engage Z Servo endstop if available From ac204028e717a83b7a96a636d42eee732fbde24f Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:49:22 -0500 Subject: [PATCH 09/12] Update planner.cpp Changed level and leveling to compensation --- Marlin/planner.cpp | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp index c8942251e..c877070df 100644 --- a/Marlin/planner.cpp +++ b/Marlin/planner.cpp @@ -75,14 +75,14 @@ float max_e_jerk; float mintravelfeedrate; unsigned long axis_steps_per_sqr_second[NUM_AXIS]; -#ifdef ENABLE_AUTO_BED_LEVELING -// this holds the required transform to compensate for bed level -matrix_3x3 plan_bed_level_matrix = { +#ifdef ENABLE_AUTO_BED_COMPENSATION +// this holds the required transform to compensate for bed compensation +matrix_3x3 plan_bed_compensation_matrix = { 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, }; -#endif // #ifdef ENABLE_AUTO_BED_LEVELING +#endif // #ifdef ENABLE_AUTO_BED_COMPENSATION // The current position of the tool in absolute steps long position[NUM_AXIS]; //rescaled from extern when axis_steps_per_unit are changed by gcode @@ -528,11 +528,11 @@ float junction_deviation = 0.1; // Add a new linear movement to the buffer. steps_x, _y and _z is the absolute position in // mm. Microseconds specify how many microseconds the move should take to perform. To aid acceleration // calculation the caller must also provide the physical length of the line in millimeters. -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, const uint8_t &extruder) #else void plan_buffer_line(const float &x, const float &y, const float &z, const float &e, float feed_rate, const uint8_t &extruder) -#endif //ENABLE_AUTO_BED_LEVELING +#endif //ENABLE_AUTO_BED_COMPENSATION { // Calculate the buffer head after we push this byte int next_buffer_head = next_block_index(block_buffer_head); @@ -546,9 +546,9 @@ void plan_buffer_line(const float &x, const float &y, const float &z, const floa lcd_update(); } -#ifdef ENABLE_AUTO_BED_LEVELING - apply_rotation_xyz(plan_bed_level_matrix, x, y, z); -#endif // ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION + apply_rotation_xyz(plan_bed_compensation_matrix, x, y, z); +#endif // ENABLE_AUTO_BED_COMPENSATION // The target position of the tool in absolute steps // Calculate target position in absolute steps @@ -1021,29 +1021,29 @@ block->steps_y = labs((target[X_AXIS]-position[X_AXIS]) - (target[Y_AXIS]-positi st_wake_up(); } -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION vector_3 plan_get_position() { vector_3 position = vector_3(st_get_position_mm(X_AXIS), st_get_position_mm(Y_AXIS), st_get_position_mm(Z_AXIS)); //position.debug("in plan_get position"); - //plan_bed_level_matrix.debug("in plan_get bed_level"); - matrix_3x3 inverse = matrix_3x3::transpose(plan_bed_level_matrix); + //plan_bed_compensation_matrix.debug("in plan_get bed_compensation"); + matrix_3x3 inverse = matrix_3x3::transpose(plan_bed_compensation_matrix); //inverse.debug("in plan_get inverse"); position.apply_rotation(inverse); //position.debug("after rotation"); return position; } -#endif // ENABLE_AUTO_BED_LEVELING +#endif // ENABLE_AUTO_BED_COMPENSATION -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION void plan_set_position(float x, float y, float z, const float &e) { - apply_rotation_xyz(plan_bed_level_matrix, x, y, z); + apply_rotation_xyz(plan_bed_compensation_matrix, x, y, z); #else void plan_set_position(const float &x, const float &y, const float &z, const float &e) { -#endif // ENABLE_AUTO_BED_LEVELING +#endif // ENABLE_AUTO_BED_COMPENSATION position[X_AXIS] = lround(x*axis_steps_per_unit[X_AXIS]); position[Y_AXIS] = lround(y*axis_steps_per_unit[Y_AXIS]); From e99f24ff2f3adcafe64be55598f4fb8d7cb46d68 Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:51:14 -0500 Subject: [PATCH 10/12] Update planner.h Changed level and leveling to compensation. --- Marlin/planner.h | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/Marlin/planner.h b/Marlin/planner.h index 0952b9dd3..47aab59fc 100644 --- a/Marlin/planner.h +++ b/Marlin/planner.h @@ -26,9 +26,9 @@ #include "Marlin.h" -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION #include "vector_3.h" -#endif // ENABLE_AUTO_BED_LEVELING +#endif // ENABLE_AUTO_BED_COMPENSATION // This struct is used when buffering the setup for each linear movement "nominal" values are as specified in // the source g-code and may never actually be reached if acceleration management is active. @@ -71,10 +71,10 @@ typedef struct { volatile char busy; } block_t; -#ifdef ENABLE_AUTO_BED_LEVELING -// this holds the required transform to compensate for bed level -extern matrix_3x3 plan_bed_level_matrix; -#endif // #ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION +// this holds the required transform to compensate for bed compensation +extern matrix_3x3 plan_bed_compensation_matrix; +#endif // #ifdef ENABLE_AUTO_BED_COMPENSATION // Initialize the motion plan subsystem void plan_init(); @@ -82,21 +82,21 @@ void plan_init(); // Add a new linear movement to the buffer. x, y and z is the signed, absolute target position in // millimaters. Feed rate specifies the speed of the motion. -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, const uint8_t &extruder); -// Get the position applying the bed level matrix if enabled +// Get the position applying the bed compensation matrix if enabled vector_3 plan_get_position(); #else void plan_buffer_line(const float &x, const float &y, const float &z, const float &e, float feed_rate, const uint8_t &extruder); -#endif // ENABLE_AUTO_BED_LEVELING +#endif // ENABLE_AUTO_BED_COMPENSATION // Set position. Used for G92 instructions. -#ifdef ENABLE_AUTO_BED_LEVELING +#ifdef ENABLE_AUTO_BED_COMPENSATION void plan_set_position(float x, float y, float z, const float &e); #else void plan_set_position(const float &x, const float &y, const float &z, const float &e); -#endif // ENABLE_AUTO_BED_LEVELING +#endif // ENABLE_AUTO_BED_COMPENSATION void plan_set_e_position(const float &e); From 6325968a3955d7a7e51eb993e664ad65976abe86 Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:52:13 -0500 Subject: [PATCH 11/12] Update qr_solve.cpp Changed leveling to compensation --- Marlin/qr_solve.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Marlin/qr_solve.cpp b/Marlin/qr_solve.cpp index f19d989d4..5179d155c 100644 --- a/Marlin/qr_solve.cpp +++ b/Marlin/qr_solve.cpp @@ -1,6 +1,6 @@ #include "qr_solve.h" -#ifdef AUTO_BED_LEVELING_GRID +#ifdef AUTO_BED_COMPENSATION_GRID #include #include From 39d28a9bbf5f8b89c83f2e2b8f353168de60ce4c Mon Sep 17 00:00:00 2001 From: John Davis Date: Fri, 19 Dec 2014 17:53:55 -0500 Subject: [PATCH 12/12] Update qr_solve.h Changed level to compensation --- Marlin/qr_solve.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Marlin/qr_solve.h b/Marlin/qr_solve.h index b38086aad..b80b6ca47 100644 --- a/Marlin/qr_solve.h +++ b/Marlin/qr_solve.h @@ -1,6 +1,6 @@ #include "Configuration.h" -#ifdef AUTO_BED_LEVELING_GRID +#ifdef AUTO_BED_COMPENSATION_GRID void daxpy ( int n, double da, double dx[], int incx, double dy[], int incy ); double ddot ( int n, double dx[], int incx, double dy[], int incy );