From 0e51e53813c3f2ccd64e09c2cbc16c2740b3974c Mon Sep 17 00:00:00 2001 From: Edward Patel Date: Sun, 15 Mar 2015 10:43:26 +0100 Subject: [PATCH 01/11] WIP. Adding bed leveling code. --- Marlin/Configuration.h | 16 ++++++++ Marlin/Marlin_main.cpp | 73 ++++++++++++++++++++++++++++++++++-- Marlin/mesh_bed_leveling.cpp | 7 ++++ Marlin/mesh_bed_leveling.h | 69 ++++++++++++++++++++++++++++++++++ Marlin/planner.cpp | 21 ++++++++--- Marlin/planner.h | 11 +++--- 6 files changed, 184 insertions(+), 13 deletions(-) create mode 100644 Marlin/mesh_bed_leveling.cpp create mode 100644 Marlin/mesh_bed_leveling.h diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index a2c43bd3d..63be50d38 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -372,6 +372,22 @@ const bool Z_MAX_ENDSTOP_INVERTING = false; // set to true to invert the logic o //const bool FIL_RUNOUT_INVERTING = true; // Should be uncommented and true or false should assigned //#define ENDSTOPPULLUP_FIL_RUNOUT // Uncomment to use internal pullup for filament runout pins if the sensor is defined. +//=========================================================================== +//============================ Manual Bed Leveling ========================== +//=========================================================================== + +#define MANUAL_BED_LEVELING // Add display menu option for bed leveling +#define MESH_BED_LEVELING // Enable mesh bed leveling + +#if defined(MESH_BED_LEVELING) + #define MESH_MIN_X 10 + #define MESH_MAX_X (X_MAX_POS - MESH_MIN_X) + #define MESH_MIN_Y 10 + #define MESH_MAX_Y (Y_MAX_POS - MESH_MIN_Y) + #define MESH_NUM_X_POINTS 4 + #define MESH_NUM_Y_POINTS 3 +#endif // MESH_BED_LEVELING + //=========================================================================== //============================= Bed Auto Leveling =========================== //=========================================================================== diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index e7298c43c..b07a2db1e 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -41,6 +41,10 @@ #define SERVO_LEVELING defined(ENABLE_AUTO_BED_LEVELING) && PROBE_SERVO_DEACTIVATION_DELAY > 0 +#if defined(MESH_BED_LEVELING) + #include "mesh_bed_leveling.h" +#endif // MESH_BED_LEVELING + #include "ultralcd.h" #include "planner.h" #include "stepper.h" @@ -4987,6 +4991,65 @@ void calculate_delta(float cartesian[3]) } #endif +#if defined(MESH_BED_LEVELING) +#if !defined(MIN) +#define MIN(_v1, _v2) (((_v1) < (_v2)) ? (_v1) : (_v2)) +#endif // ! MIN +// This function is used to split lines on mesh borders so each segment is only part of one mesh area +void mesh_plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, const uint8_t &extruder, uint8_t x_splits=0xff, uint8_t y_splits=0xff) +{ + int pix = mbl.select_x_index(current_position[X_AXIS]); + int piy = mbl.select_y_index(current_position[Y_AXIS]); + int ix = mbl.select_x_index(x); + int iy = mbl.select_y_index(y); + pix = MIN(pix, MESH_NUM_X_POINTS-2); + piy = MIN(piy, MESH_NUM_Y_POINTS-2); + ix = MIN(ix, MESH_NUM_X_POINTS-2); + iy = MIN(iy, MESH_NUM_Y_POINTS-2); + if (ix > pix && (x_splits)&(1< piy && (y_splits)&(1< get_x(i) && i < MESH_NUM_X_POINTS-1) { + i++; + } + return i-1; + } + + int select_y_index(float y) { + int i = 1; + while (y > get_y(i) && i < MESH_NUM_Y_POINTS-1) { + i++; + } + return i-1; + } + + float calc_z0(float a0, float a1, float z1, float a2, float z2) { + float delta_z = (z2 - z1)/(a2 - a1); + float delta_a = a0 - a1; + return z1 + delta_a * delta_z; + } + + float get_z(float x0, float y0) { + int x_index = select_x_index(x0); + int y_index = select_y_index(y0); + float z1 = calc_z0(x0, + get_x(x_index), z_values[y_index][x_index], + get_x(x_index+1), z_values[y_index][x_index+1]); + float z2 = calc_z0(x0, + get_x(x_index), z_values[y_index+1][x_index], + get_x(x_index+1), z_values[y_index+1][x_index+1]); + float z0 = calc_z0(y0, + get_y(y_index), z1, + get_y(y_index+1), z2); + return z0; + } +}; + +extern mesh_bed_leveling mbl; + +#endif // MESH_BED_LEVELING diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp index 9bcad5661..1c7a3a9b3 100644 --- a/Marlin/planner.cpp +++ b/Marlin/planner.cpp @@ -58,6 +58,10 @@ #include "ultralcd.h" #include "language.h" +#if defined(MESH_BED_LEVELING) + #include "mesh_bed_leveling.h" +#endif // MESH_BED_LEVELING + //=========================================================================== //============================= public variables ============================ //=========================================================================== @@ -530,7 +534,7 @@ 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 +#if defined(ENABLE_AUTO_BED_LEVELING) || defined(MESH_BED_LEVELING) 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) @@ -548,6 +552,10 @@ void plan_buffer_line(const float &x, const float &y, const float &z, const floa lcd_update(); } +#if defined(MESH_BED_LEVELING) + z += mbl.get_z(x, y); +#endif // MESH_BED_LEVELING + #ifdef ENABLE_AUTO_BED_LEVELING apply_rotation_xyz(plan_bed_level_matrix, x, y, z); #endif // ENABLE_AUTO_BED_LEVELING @@ -1078,14 +1086,17 @@ vector_3 plan_get_position() { } #endif // ENABLE_AUTO_BED_LEVELING -#ifdef ENABLE_AUTO_BED_LEVELING +#if defined(ENABLE_AUTO_BED_LEVELING) || defined(MESH_BED_LEVELING) void plan_set_position(float x, float y, float z, const float &e) -{ - apply_rotation_xyz(plan_bed_level_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 || MESH_BED_LEVELING { -#endif // ENABLE_AUTO_BED_LEVELING +#if defined(ENABLE_AUTO_BED_LEVELING) + apply_rotation_xyz(plan_bed_level_matrix, x, y, z); +#elif defined(MESH_BED_LEVELING) + z += mbl.get_z(x, y); +#endif // ENABLE_AUTO_BED_LEVELING position[X_AXIS] = lround(x*axis_steps_per_unit[X_AXIS]); position[Y_AXIS] = lround(y*axis_steps_per_unit[Y_AXIS]); diff --git a/Marlin/planner.h b/Marlin/planner.h index a64a0f0d3..22443c05f 100644 --- a/Marlin/planner.h +++ b/Marlin/planner.h @@ -82,21 +82,22 @@ 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 +#if defined(ENABLE_AUTO_BED_LEVELING) || defined(MESH_BED_LEVELING) 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 +#if defined(ENABLE_AUTO_BED_LEVELING) vector_3 plan_get_position(); +#endif // ENABLE_AUTO_BED_LEVELING #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_LEVELING || MESH_BED_LEVELING // Set position. Used for G92 instructions. -#ifdef ENABLE_AUTO_BED_LEVELING +#if defined(ENABLE_AUTO_BED_LEVELING) || defined(MESH_BED_LEVELING) 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_LEVELING || MESH_BED_LEVELING void plan_set_e_position(const float &e); From 8005d22c8107bfa60c265969a636219fd0ed86fc Mon Sep 17 00:00:00 2001 From: Edward Patel Date: Sun, 15 Mar 2015 23:18:11 +0100 Subject: [PATCH 02/11] Added menu option for bed leveling. --- Marlin/Configuration.h | 3 +- Marlin/ConfigurationStore.cpp | 24 +++++++++- Marlin/Marlin_main.cpp | 55 +++++++++++++++++++++- Marlin/language_en.h | 3 ++ Marlin/mesh_bed_leveling.cpp | 13 +++++ Marlin/mesh_bed_leveling.h | 14 ++---- Marlin/planner.cpp | 8 +++- Marlin/ultralcd.cpp | 89 ++++++++++++++++++++++++++++++++++- 8 files changed, 192 insertions(+), 17 deletions(-) diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index 63be50d38..23be01105 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -384,8 +384,9 @@ const bool Z_MAX_ENDSTOP_INVERTING = false; // set to true to invert the logic o #define MESH_MAX_X (X_MAX_POS - MESH_MIN_X) #define MESH_MIN_Y 10 #define MESH_MAX_Y (Y_MAX_POS - MESH_MIN_Y) - #define MESH_NUM_X_POINTS 4 + #define MESH_NUM_X_POINTS 3 #define MESH_NUM_Y_POINTS 3 + #define MESH_HOME_SEARCH_Z 4 // Z after Home, bed somewhere below but above 0.0 #endif // MESH_BED_LEVELING //=========================================================================== diff --git a/Marlin/ConfigurationStore.cpp b/Marlin/ConfigurationStore.cpp index 0dee05ba7..6e0eeb04c 100644 --- a/Marlin/ConfigurationStore.cpp +++ b/Marlin/ConfigurationStore.cpp @@ -20,6 +20,10 @@ * max_e_jerk * add_homing (x3) * + * Mesh bed leveling: + * active + * z_values[][] + * * DELTA: * endstop_adj (x3) * delta_radius @@ -69,6 +73,10 @@ #include "ultralcd.h" #include "ConfigurationStore.h" +#if defined(MESH_BED_LEVELING) + #include "mesh_bed_leveling.h" +#endif // MESH_BED_LEVELING + void _EEPROM_writeData(int &pos, uint8_t* value, uint8_t size) { uint8_t c; while(size--) { @@ -128,6 +136,11 @@ void Config_StoreSettings() { EEPROM_WRITE_VAR(i, max_e_jerk); EEPROM_WRITE_VAR(i, add_homing); + #if defined(MESH_BED_LEVELING) + EEPROM_WRITE_VAR(i, mbl.active); + EEPROM_WRITE_VAR(i, mbl.z_values); + #endif // MESH_BED_LEVELING + #ifdef DELTA EEPROM_WRITE_VAR(i, endstop_adj); // 3 floats EEPROM_WRITE_VAR(i, delta_radius); // 1 float @@ -250,7 +263,7 @@ void Config_RetrieveSettings() { EEPROM_READ_VAR(i, max_feedrate); EEPROM_READ_VAR(i, max_acceleration_units_per_sq_second); - // steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner) + // steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner) reset_acceleration_rates(); EEPROM_READ_VAR(i, acceleration); @@ -264,6 +277,11 @@ void Config_RetrieveSettings() { EEPROM_READ_VAR(i, max_e_jerk); EEPROM_READ_VAR(i, add_homing); + #if defined(MESH_BED_LEVELING) + EEPROM_READ_VAR(i, mbl.active); + EEPROM_READ_VAR(i, mbl.z_values); + #endif // MESH_BED_LEVELING + #ifdef DELTA EEPROM_READ_VAR(i, endstop_adj); // 3 floats EEPROM_READ_VAR(i, delta_radius); // 1 float @@ -392,6 +410,10 @@ void Config_ResetDefault() { max_e_jerk = DEFAULT_EJERK; add_homing[X_AXIS] = add_homing[Y_AXIS] = add_homing[Z_AXIS] = 0; + #if defined(MESH_BED_LEVELING) + mbl.active = 0; + #endif // MESH_BED_LEVELING + #ifdef DELTA endstop_adj[X_AXIS] = endstop_adj[Y_AXIS] = endstop_adj[Z_AXIS] = 0; delta_radius = DELTA_RADIUS; diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index b07a2db1e..5fc6d9c04 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -1566,6 +1566,11 @@ inline void gcode_G28() { plan_bed_level_matrix.set_to_identity(); //Reset the plane ("erase" all leveling data) #endif + #if defined(MESH_BED_LEVELING) + uint8_t mbl_was_active = mbl.active; + mbl.active = 0; + #endif // MESH_BED_LEVELING + saved_feedrate = feedrate; saved_feedmultiply = feedmultiply; feedmultiply = 100; @@ -1780,6 +1785,23 @@ inline void gcode_G28() { enable_endstops(false); #endif + #if defined(MESH_BED_LEVELING) + if (mbl_was_active) { + current_position[X_AXIS] = mbl.get_x(0); + current_position[Y_AXIS] = mbl.get_y(0); + destination[X_AXIS] = current_position[X_AXIS]; + destination[Y_AXIS] = current_position[Y_AXIS]; + destination[Z_AXIS] = current_position[Z_AXIS]; + destination[E_AXIS] = current_position[E_AXIS]; + feedrate = homing_feedrate[X_AXIS]; + plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate, active_extruder); + st_synchronize(); + current_position[Z_AXIS] = MESH_HOME_SEARCH_Z; + plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); + mbl.active = 1; + } + #endif + feedrate = saved_feedrate; feedmultiply = saved_feedmultiply; previous_millis_cmd = millis(); @@ -4998,6 +5020,13 @@ void calculate_delta(float cartesian[3]) // This function is used to split lines on mesh borders so each segment is only part of one mesh area void mesh_plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, const uint8_t &extruder, uint8_t x_splits=0xff, uint8_t y_splits=0xff) { + if (!mbl.active) { + plan_buffer_line(x, y, z, e, feed_rate, extruder); + for(int8_t i=0; i < NUM_AXIS; i++) { + current_position[i] = destination[i]; + } + return; + } int pix = mbl.select_x_index(current_position[X_AXIS]); int piy = mbl.select_y_index(current_position[Y_AXIS]); int ix = mbl.select_x_index(x); @@ -5012,7 +5041,13 @@ void mesh_plan_buffer_line(float x, float y, float z, const float &e, float feed float ny = current_position[Y_AXIS] + (y - current_position[Y_AXIS]) * normalized_dist; float ne = current_position[E_AXIS] + (e - current_position[E_AXIS]) * normalized_dist; x_splits ^= 1 << ix; + destination[X_AXIS] = nx; + destination[Y_AXIS] = ny; + destination[E_AXIS] = ne; mesh_plan_buffer_line(nx, ny, z, ne, feed_rate, extruder, x_splits, y_splits); + destination[X_AXIS] = x; + destination[Y_AXIS] = y; + destination[E_AXIS] = e; mesh_plan_buffer_line(x, y, z, e, feed_rate, extruder, x_splits, y_splits); return; } else if (ix < pix && (x_splits)&(1< piy && (y_splits)&(1< timeoutToStatus) { + if (currentMenu != lcd_status_screen && + #if defined(MANUAL_BED_LEVELING) + currentMenu != _lcd_level_bed && + currentMenu != _lcd_level_bed_homing && + #endif // MANUAL_BED_LEVELING + millis() > timeoutToStatus) { lcd_return_to_status(); lcdDrawUpdate = 2; } @@ -1745,4 +1761,75 @@ char *ftostr52(const float &x) return conv; } +#if defined(MANUAL_BED_LEVELING) +static int _lcd_level_bed_position; +static void _lcd_level_bed() +{ + if (encoderPosition != 0) { + refresh_cmd_timeout(); + current_position[Z_AXIS] += float((int)encoderPosition) * 0.05; + if (min_software_endstops && current_position[Z_AXIS] < Z_MIN_POS) current_position[Z_AXIS] = Z_MIN_POS; + if (max_software_endstops && current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS; + encoderPosition = 0; + plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[Z_AXIS]/60, active_extruder); + lcdDrawUpdate = 1; + } + if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR("Z"), ftostr32(current_position[Z_AXIS])); + static bool debounce_click = false; + if (LCD_CLICKED) { + if (!debounce_click) { + debounce_click = true; + int ix = _lcd_level_bed_position % MESH_NUM_X_POINTS; + int iy = _lcd_level_bed_position / MESH_NUM_X_POINTS; + mbl.set_z(ix, iy, current_position[Z_AXIS]); + _lcd_level_bed_position++; + if (_lcd_level_bed_position == MESH_NUM_X_POINTS*MESH_NUM_Y_POINTS) { + current_position[Z_AXIS] = MESH_HOME_SEARCH_Z; + plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[X_AXIS]/60, active_extruder); + mbl.active = 1; + enquecommands_P(PSTR("G28")); + lcd_return_to_status(); + } else { + current_position[Z_AXIS] = MESH_HOME_SEARCH_Z; + plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[X_AXIS]/60, active_extruder); + ix = _lcd_level_bed_position % MESH_NUM_X_POINTS; + iy = _lcd_level_bed_position / MESH_NUM_X_POINTS; + if (iy&1) { // Zig zag + ix = (MESH_NUM_X_POINTS - 1) - ix; + } + current_position[X_AXIS] = mbl.get_x(ix); + current_position[Y_AXIS] = mbl.get_y(iy); + plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[X_AXIS]/60, active_extruder); + lcdDrawUpdate = 1; + } + } + } else { + debounce_click = false; + } +} +static void _lcd_level_bed_homing() +{ + if (axis_known_position[X_AXIS] && + axis_known_position[Y_AXIS] && + axis_known_position[Z_AXIS]) { + current_position[Z_AXIS] = MESH_HOME_SEARCH_Z; + plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); + current_position[X_AXIS] = MESH_MIN_X; + current_position[Y_AXIS] = MESH_MIN_Y; + plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[X_AXIS]/60, active_extruder); + _lcd_level_bed_position = 0; + lcd_goto_menu(_lcd_level_bed); + } +} +static void lcd_level_bed() +{ + axis_known_position[X_AXIS] = false; + axis_known_position[Y_AXIS] = false; + axis_known_position[Z_AXIS] = false; + mbl.reset(); + enquecommands_P(PSTR("G28")); + lcd_goto_menu(_lcd_level_bed_homing); +} +#endif // MANUAL_BED_LEVELING + #endif //ULTRA_LCD From f34b9c83d1596057f724d0eeb5c21233a546cd13 Mon Sep 17 00:00:00 2001 From: Edward Patel Date: Mon, 16 Mar 2015 01:48:46 +0100 Subject: [PATCH 03/11] Added comment about MESH_NUM axis points. --- Marlin/Configuration.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index 23be01105..6fc0362b9 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -384,7 +384,7 @@ const bool Z_MAX_ENDSTOP_INVERTING = false; // set to true to invert the logic o #define MESH_MAX_X (X_MAX_POS - MESH_MIN_X) #define MESH_MIN_Y 10 #define MESH_MAX_Y (Y_MAX_POS - MESH_MIN_Y) - #define MESH_NUM_X_POINTS 3 + #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_HOME_SEARCH_Z 4 // Z after Home, bed somewhere below but above 0.0 #endif // MESH_BED_LEVELING From e983a5ab92b7db6aa6577d85425ca399771ff424 Mon Sep 17 00:00:00 2001 From: Edward Patel Date: Mon, 16 Mar 2015 02:50:11 +0100 Subject: [PATCH 04/11] Disable option. Enable for use/test. --- Marlin/Configuration.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index 6fc0362b9..da9d2b60a 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -376,8 +376,8 @@ const bool Z_MAX_ENDSTOP_INVERTING = false; // set to true to invert the logic o //============================ Manual Bed Leveling ========================== //=========================================================================== -#define MANUAL_BED_LEVELING // Add display menu option for bed leveling -#define MESH_BED_LEVELING // Enable mesh bed leveling +// #define MANUAL_BED_LEVELING // Add display menu option for bed leveling +// #define MESH_BED_LEVELING // Enable mesh bed leveling #if defined(MESH_BED_LEVELING) #define MESH_MIN_X 10 From 0d43898a22b0d8f77ef0c84e0809e6a254cde1e5 Mon Sep 17 00:00:00 2001 From: Edward Patel Date: Tue, 17 Mar 2015 22:55:29 +0100 Subject: [PATCH 05/11] Remove of mesh_plan_buffer_line parameter reference (e) --- Marlin/Marlin_main.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 82d28b1b5..81cfe9951 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -5307,7 +5307,7 @@ void prepare_move_raw() #define MIN(_v1, _v2) (((_v1) < (_v2)) ? (_v1) : (_v2)) #endif // ! MIN // This function is used to split lines on mesh borders so each segment is only part of one mesh area -void mesh_plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, const uint8_t &extruder, uint8_t x_splits=0xff, uint8_t y_splits=0xff) +void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_rate, const uint8_t &extruder, uint8_t x_splits=0xff, uint8_t y_splits=0xff) { if (!mbl.active) { plan_buffer_line(x, y, z, e, feed_rate, extruder); From 28c91deb5c3813acb8f92f36afe3c3b975f01146 Mon Sep 17 00:00:00 2001 From: Edward Patel Date: Wed, 18 Mar 2015 21:00:31 +0100 Subject: [PATCH 06/11] EEPROM saving of z_values. Tried to make it a little intelligent. --- Marlin/ConfigurationStore.cpp | 41 +++++++++++++++++++++++++++++++++-- 1 file changed, 39 insertions(+), 2 deletions(-) diff --git a/Marlin/ConfigurationStore.cpp b/Marlin/ConfigurationStore.cpp index 6e0eeb04c..1d582d9ac 100644 --- a/Marlin/ConfigurationStore.cpp +++ b/Marlin/ConfigurationStore.cpp @@ -113,7 +113,7 @@ void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size) { // wrong data being written to the variables. // ALSO: always make sure the variables in the Store and retrieve sections are in the same order. -#define EEPROM_VERSION "V16" +#define EEPROM_VERSION "V17" #ifdef EEPROM_SETTINGS @@ -136,9 +136,26 @@ void Config_StoreSettings() { EEPROM_WRITE_VAR(i, max_e_jerk); EEPROM_WRITE_VAR(i, add_homing); + uint8_t mesh_num_x = 3; + uint8_t mesh_num_y = 3; #if defined(MESH_BED_LEVELING) + // Compile time test that sizeof(mbl.z_values) is as expected + typedef char c_assert[(sizeof(mbl.z_values) == MESH_NUM_X_POINTS*MESH_NUM_Y_POINTS*sizeof(dummy)) ? 1 : -1]; + mesh_num_x = MESH_NUM_X_POINTS; + mesh_num_y = MESH_NUM_Y_POINTS; EEPROM_WRITE_VAR(i, mbl.active); + EEPROM_WRITE_VAR(i, mesh_num_x); + EEPROM_WRITE_VAR(i, mesh_num_y); EEPROM_WRITE_VAR(i, mbl.z_values); + #else + uint8_t dummy_uint8 = 0; + EEPROM_WRITE_VAR(i, dummy_uint8); + EEPROM_WRITE_VAR(i, mesh_num_x); + EEPROM_WRITE_VAR(i, mesh_num_y); + dummy = 0.0f; + for (int q=0; q Date: Thu, 19 Mar 2015 20:15:38 +0100 Subject: [PATCH 07/11] Shortened mesh_plan_buffer_line() --- Marlin/Marlin_main.cpp | 109 ++++++++++++++++++----------------------- 1 file changed, 47 insertions(+), 62 deletions(-) diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 6994184b8..0489c63ea 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -5331,71 +5331,56 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_ piy = MIN(piy, MESH_NUM_Y_POINTS-2); ix = MIN(ix, MESH_NUM_X_POINTS-2); iy = MIN(iy, MESH_NUM_Y_POINTS-2); - if (ix > pix && (x_splits)&(1< piy && (y_splits)&(1< pix && (x_splits) & BIT(ix)) { + nx = mbl.get_x(ix); + normalized_dist = (nx - current_position[X_AXIS])/(x - current_position[X_AXIS]); + ny = current_position[Y_AXIS] + (y - current_position[Y_AXIS]) * normalized_dist; + ne = current_position[E_AXIS] + (e - current_position[E_AXIS]) * normalized_dist; + x_splits ^= BIT(ix); + } else if (ix < pix && (x_splits) & BIT(pix)) { + nx = mbl.get_x(pix); + normalized_dist = (nx - current_position[X_AXIS])/(x - current_position[X_AXIS]); + ny = current_position[Y_AXIS] + (y - current_position[Y_AXIS]) * normalized_dist; + ne = current_position[E_AXIS] + (e - current_position[E_AXIS]) * normalized_dist; + x_splits ^= BIT(pix); + } else if (iy > piy && (y_splits) & BIT(iy)) { + ny = mbl.get_y(iy); + normalized_dist = (ny - current_position[Y_AXIS])/(y - current_position[Y_AXIS]); + nx = current_position[X_AXIS] + (x - current_position[X_AXIS]) * normalized_dist; + ne = current_position[E_AXIS] + (e - current_position[E_AXIS]) * normalized_dist; + y_splits ^= BIT(iy); + } else if (iy < piy && (y_splits) & BIT(piy)) { + ny = mbl.get_y(piy); + normalized_dist = (ny - current_position[Y_AXIS])/(y - current_position[Y_AXIS]); + nx = current_position[X_AXIS] + (x - current_position[X_AXIS]) * normalized_dist; + ne = current_position[E_AXIS] + (e - current_position[E_AXIS]) * normalized_dist; + y_splits ^= BIT(piy); + } else { + // Already split on a border + plan_buffer_line(x, y, z, e, feed_rate, extruder); + for(int8_t i=0; i < NUM_AXIS; i++) { + current_position[i] = destination[i]; + } + return; } + // Do the split and look for more borders + destination[X_AXIS] = nx; + destination[Y_AXIS] = ny; + destination[E_AXIS] = ne; + mesh_plan_buffer_line(nx, ny, z, ne, feed_rate, extruder, x_splits, y_splits); + destination[X_AXIS] = x; + destination[Y_AXIS] = y; + destination[E_AXIS] = e; + mesh_plan_buffer_line(x, y, z, e, feed_rate, extruder, x_splits, y_splits); } #endif // MESH_BED_LEVELING From 5112cf84227de2d8739c4368f7e33e7dea1cb2ad Mon Sep 17 00:00:00 2001 From: Edward Patel Date: Fri, 20 Mar 2015 11:46:47 +0100 Subject: [PATCH 08/11] Added comment for the EEPROM storage --- Marlin/ConfigurationStore.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Marlin/ConfigurationStore.cpp b/Marlin/ConfigurationStore.cpp index 1d582d9ac..16d94760b 100644 --- a/Marlin/ConfigurationStore.cpp +++ b/Marlin/ConfigurationStore.cpp @@ -22,6 +22,8 @@ * * Mesh bed leveling: * active + * mesh_num_x + * mesh_num_y * z_values[][] * * DELTA: From 64e3d33893978bc3a0db0d7e08540946cb48fb96 Mon Sep 17 00:00:00 2001 From: AnHardt Date: Fri, 20 Mar 2015 23:36:14 +0100 Subject: [PATCH 09/11] Fix shrinked menucode by updating 'encoderPosition' in END_MENU() line 1. --- Marlin/ultralcd.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Marlin/ultralcd.cpp b/Marlin/ultralcd.cpp index 610b21ccb..8a3c18b50 100644 --- a/Marlin/ultralcd.cpp +++ b/Marlin/ultralcd.cpp @@ -198,8 +198,8 @@ static void menu_action_setting_edit_callback_long5(const char* pstr, unsigned l #define MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(type, label, args...) MENU_ITEM(setting_edit_callback_ ## type, label, PSTR(label), ## args) #endif //!ENCODER_RATE_MULTIPLIER #define END_MENU() \ - if (encoderPosition / ENCODER_STEPS_PER_MENU_ITEM >= _menuItemNr) encoderPosition = _menuItemNr * ENCODER_STEPS_PER_MENU_ITEM - 1; \ - if ((uint8_t)(encoderPosition / ENCODER_STEPS_PER_MENU_ITEM) >= currentMenuViewOffset + LCD_HEIGHT) { currentMenuViewOffset = (encoderPosition / ENCODER_STEPS_PER_MENU_ITEM) - LCD_HEIGHT + 1; lcdDrawUpdate = 1; _lineNr = currentMenuViewOffset - 1; _drawLineNr = -1; } \ + if (encoderLine >= _menuItemNr) encoderPosition = _menuItemNr * ENCODER_STEPS_PER_MENU_ITEM - 1; encoderLine = encoderPosition / ENCODER_STEPS_PER_MENU_ITEM;\ + if (encoderLine >= currentMenuViewOffset + LCD_HEIGHT) { currentMenuViewOffset = encoderLine - LCD_HEIGHT + 1; lcdDrawUpdate = 1; _lineNr = currentMenuViewOffset - 1; _drawLineNr = -1; } \ } } while(0) /** Used variables to keep track of the menu */ From 3d0a060a7a998b91d815a822bdf7774e3a8b9f6a Mon Sep 17 00:00:00 2001 From: Edward Patel Date: Sat, 21 Mar 2015 14:50:47 +0100 Subject: [PATCH 10/11] Added G29 command --- Marlin/Marlin_main.cpp | 89 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 87eb77a14..41955d86a 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -1983,6 +1983,89 @@ inline void gcode_G28() { endstops_hit_on_purpose(); } +#if defined(MESH_BED_LEVELING) + + inline void gcode_G29() { + static int probe_point = -1; + int state = 0; + if (code_seen('S') || code_seen('s')) { + state = code_value_long(); + if (state < 0 || state > 2) { + SERIAL_PROTOCOLPGM("S out of range (0-2).\n"); + return; + } + } + + if (state == 0) { // Dump mesh_bed_leveling + if (mbl.active) { + SERIAL_PROTOCOLPGM("Num X,Y: "); + SERIAL_PROTOCOL(MESH_NUM_X_POINTS); + SERIAL_PROTOCOLPGM(","); + SERIAL_PROTOCOL(MESH_NUM_Y_POINTS); + SERIAL_PROTOCOLPGM("\nZ search height: "); + SERIAL_PROTOCOL(MESH_HOME_SEARCH_Z); + SERIAL_PROTOCOLPGM("\nMeasured points:\n"); + for (int y=0; y Date: Sat, 21 Mar 2015 14:23:43 -0700 Subject: [PATCH 11/11] Fix temperature min/max test - Base tests on all thermistors/thermocouples, not just heater 0 --- Marlin/temperature.cpp | 101 +++++++++++++++++++++++++++-------------- 1 file changed, 67 insertions(+), 34 deletions(-) diff --git a/Marlin/temperature.cpp b/Marlin/temperature.cpp index 506474206..26360a514 100644 --- a/Marlin/temperature.cpp +++ b/Marlin/temperature.cpp @@ -145,7 +145,7 @@ static volatile bool temp_meas_ready = false; static float temp_iState_min_bed; static float temp_iState_max_bed; #else //PIDTEMPBED - static unsigned long previous_millis_bed_heater; + static unsigned long previous_millis_bed_heater; #endif //PIDTEMPBED static unsigned char soft_pwm[EXTRUDERS]; @@ -243,7 +243,7 @@ void PID_autotune(float temp, int extruder, int ncycles) SERIAL_ECHOLN(MSG_PID_BAD_EXTRUDER_NUM); return; } - + SERIAL_ECHOLN(MSG_PID_AUTOTUNE_START); disable_heater(); // switch off all heaters. @@ -755,8 +755,8 @@ void manage_heater() { #ifdef FILAMENT_SENSOR if (filament_sensor) { meas_shift_index = delay_index1 - meas_delay_cm; - if (meas_shift_index < 0) meas_shift_index += MAX_MEASUREMENT_DELAY + 1; //loop around buffer if needed - + if (meas_shift_index < 0) meas_shift_index += MAX_MEASUREMENT_DELAY + 1; //loop around buffer if needed + // Get the delayed info and add 100 to reconstitute to a percent of // the nominal filament diameter then square it to get an area meas_shift_index = constrain(meas_shift_index, 0, MAX_MEASUREMENT_DELAY); @@ -1259,10 +1259,7 @@ enum TempState { ISR(TIMER0_COMPB_vect) { //these variables are only accesible from the ISR, but static, so they don't lose their value static unsigned char temp_count = 0; - static unsigned long raw_temp_0_value = 0; - static unsigned long raw_temp_1_value = 0; - static unsigned long raw_temp_2_value = 0; - static unsigned long raw_temp_3_value = 0; + static unsigned long raw_temp_value[EXTRUDERS] = { 0 }; static unsigned long raw_temp_bed_value = 0; static TempState temp_state = StartupDelay; static unsigned char pwm_count = BIT(SOFT_PWM_SCALE); @@ -1474,7 +1471,7 @@ ISR(TIMER0_COMPB_vect) { break; case MeasureTemp_0: #if HAS_TEMP_0 - raw_temp_0_value += ADC; + raw_temp_value[0] += ADC; #endif temp_state = PrepareTemp_BED; break; @@ -1500,7 +1497,7 @@ ISR(TIMER0_COMPB_vect) { break; case MeasureTemp_1: #if HAS_TEMP_1 - raw_temp_1_value += ADC; + raw_temp_value[1] += ADC; #endif temp_state = PrepareTemp_2; break; @@ -1513,7 +1510,7 @@ ISR(TIMER0_COMPB_vect) { break; case MeasureTemp_2: #if HAS_TEMP_2 - raw_temp_2_value += ADC; + raw_temp_value[2] += ADC; #endif temp_state = PrepareTemp_3; break; @@ -1526,7 +1523,7 @@ ISR(TIMER0_COMPB_vect) { break; case MeasureTemp_3: #if HAS_TEMP_3 - raw_temp_3_value += ADC; + raw_temp_value[3] += ADC; #endif temp_state = Prepare_FILWIDTH; break; @@ -1561,19 +1558,19 @@ ISR(TIMER0_COMPB_vect) { if (temp_count >= OVERSAMPLENR) { // 10 * 16 * 1/(16000000/64/256) = 164ms. if (!temp_meas_ready) { //Only update the raw values if they have been read. Else we could be updating them during reading. #ifndef HEATER_0_USES_MAX6675 - current_temperature_raw[0] = raw_temp_0_value; + current_temperature_raw[0] = raw_temp_value[0]; #endif #if EXTRUDERS > 1 - current_temperature_raw[1] = raw_temp_1_value; + current_temperature_raw[1] = raw_temp_value[1]; #if EXTRUDERS > 2 - current_temperature_raw[2] = raw_temp_2_value; + current_temperature_raw[2] = raw_temp_value[2]; #if EXTRUDERS > 3 - current_temperature_raw[3] = raw_temp_3_value; + current_temperature_raw[3] = raw_temp_value[3]; #endif #endif #endif #ifdef TEMP_SENSOR_1_AS_REDUNDANT - redundant_temperature_raw = raw_temp_1_value; + redundant_temperature_raw = raw_temp_value[1]; #endif current_temperature_bed_raw = raw_temp_bed_value; } //!temp_meas_ready @@ -1585,31 +1582,67 @@ ISR(TIMER0_COMPB_vect) { temp_meas_ready = true; temp_count = 0; - raw_temp_0_value = 0; - raw_temp_1_value = 0; - raw_temp_2_value = 0; - raw_temp_3_value = 0; + for (int i = 0; i < EXTRUDERS; i++) raw_temp_value[i] = 0; raw_temp_bed_value = 0; #if HEATER_0_RAW_LO_TEMP > HEATER_0_RAW_HI_TEMP - #define MAXTEST <= - #define MINTEST >= + #define GE0 <= + #define LE0 >= #else - #define MAXTEST >= - #define MINTEST <= + #define GE0 >= + #define LE0 <= #endif + if (current_temperature_raw[0] GE0 maxttemp_raw[0]) max_temp_error(0); + if (current_temperature_raw[0] LE0 minttemp_raw[0]) min_temp_error(0); + + #if EXTRUDERS > 1 + #if HEATER_1_RAW_LO_TEMP > HEATER_1_RAW_HI_TEMP + #define GE1 <= + #define LE1 >= + #else + #define GE1 >= + #define LE1 <= + #endif + if (current_temperature_raw[1] GE1 maxttemp_raw[1]) max_temp_error(1); + if (current_temperature_raw[1] LE1 minttemp_raw[1]) min_temp_error(1); + #if EXTRUDERS > 2 + #if HEATER_2_RAW_LO_TEMP > HEATER_2_RAW_HI_TEMP + #define GE2 <= + #define LE2 >= + #else + #define GE2 >= + #define LE2 <= + #endif + if (current_temperature_raw[2] GE2 maxttemp_raw[2]) max_temp_error(2); + if (current_temperature_raw[2] LE2 minttemp_raw[2]) min_temp_error(2); + #if EXTRUDERS > 3 + #if HEATER_3_RAW_LO_TEMP > HEATER_3_RAW_HI_TEMP + #define GE3 <= + #define LE3 >= + #else + #define GE3 >= + #define LE3 <= + #endif + if (current_temperature_raw[3] GE3 maxttemp_raw[3]) max_temp_error(3); + if (current_temperature_raw[3] LE3 minttemp_raw[3]) min_temp_error(3); + #endif // EXTRUDERS > 3 + #endif // EXTRUDERS > 2 + #endif // EXTRUDERS > 1 - for (int i=0; i HEATER_BED_RAW_HI_TEMP + #define GEBED <= + #define LEBED >= + #else + #define GEBED >= + #define LEBED <= + #endif + if (current_temperature_bed_raw GEBED bed_maxttemp_raw) { + target_temperature_bed = 0; + bed_max_temp_error(); + } #endif + } // temp_count >= OVERSAMPLENR #ifdef BABYSTEPPING