Update V4.2.84

Add Mesh Bed Level

Documentation/GCodes.md

@@ -127,6 +127,8 @@
 *  M407 - Displays measured filament diameter
 *  M408 - Report JSON-style response
 *  M410 - Quickstop. Abort all the planned moves
+*  M420 - Enable/Disable Mesh Bed Leveling
+*  M421 - Set a single Mesh Bed Leveling Z coordinate. M421 X<mm> Y<mm> Z<mm>' or 'M421 I<xindex> J<yindex> Z<mm>
 *  M428 - Set the home_offset logically based on the current_position
 *  M500 - stores paramters in EEPROM
 *  M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily).

Documentation/changelog.md

+### Version 4.2.84
+* Add Mesh Bed Level (MBL)
+
 ### Version 4.2.83
 * Add Cooler and Hot Chamber
 * Add Laser Beam PWM and raster base64

MK/Configuration_Cartesian.h

@@ -8,6 +8,7 @@
  * - Endstop pullup resistors
  * - Endstops logic
  * - Endstops min or max
+ * - Min Z height for homing
  * - Stepper enable logic
  * - Stepper step logic
  * - Stepper direction
@@ -104,6 +105,18 @@
 /*****************************************************************************************/
 
 
+/*****************************************************************************************
+ ***************************** MIN Z HEIGHT FOR HOMING **********************************
+ *****************************************************************************************
+ *                                                                                       *
+ * (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.                           *
+ *                                                                                       *
+ *****************************************************************************************/
+#define MIN_Z_HEIGHT_FOR_HOMING   0
+/*****************************************************************************************/
+
+
 /*****************************************************************************************
  ********************************* Stepper enable logic **********************************
  *****************************************************************************************
@@ -233,7 +246,27 @@
 
 
 /*****************************************************************************************
- ******************************* Auto bed levelling **************************************
+ ******************************* Mesh bed leveling ***************************************
+ *****************************************************************************************/
+//#define 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 MESH_HOME_SEARCH_Z  5   // Z after Home, bed somewhere below but above 0.0.
+
+// After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0]
+//#define MESH_G28_REST_ORIGIN
+
+// Add display menu option for bed leveling.
+//#define MANUAL_BED_LEVELING
+// Step size while manually probing Z axis.
+#define MBL_Z_STEP 0.025
+/*****************************************************************************************/
+
+
+/*****************************************************************************************
+ ******************************* Auto bed leveling ***************************************
  *****************************************************************************************
  *                                                                                       *
  * There are 2 different ways to specify probing locations                               *
@@ -292,9 +325,6 @@
 #define Y_PROBE_OFFSET_FROM_EXTRUDER  0     // Y offset: -front [of the nozzle] +behind
 #define Z_PROBE_OFFSET_FROM_EXTRUDER -1     // Z offset: -below [of the nozzle] (always negative!)
 
-#define Z_RAISE_BEFORE_HOMING        10     // (in mm) Raise Z before homing (G28) for Probe Clearance.
-                                            // Be sure you have this distance over your Z_MAX_POS in case
-
 #define Z_RAISE_BEFORE_PROBING       10     //How much the extruder will be raised before travelling to the first probing point.
 #define Z_RAISE_BETWEEN_PROBINGS      5     //How much the extruder will be raised when travelling from between next probing points
 #define Z_RAISE_AFTER_PROBING         5     //How much the extruder will be raised after the last probing point.

MK/Configuration_Core.h

@@ -9,6 +9,7 @@
  * - Endstop pullup resistors
  * - Endstops logic
  * - Endstops min or max
+ * - Min Z height for homing
  * - Stepper enable logic
  * - Stepper step logic
  * - Stepper direction
@@ -126,6 +127,18 @@
 /*****************************************************************************************/
 
 
+/*****************************************************************************************
+ ***************************** MIN Z HEIGHT FOR HOMING **********************************
+ *****************************************************************************************
+ *                                                                                       *
+ * (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.                           *
+ *                                                                                       *
+ *****************************************************************************************/
+#define MIN_Z_HEIGHT_FOR_HOMING   0
+/*****************************************************************************************/
+
+
 /*****************************************************************************************
  ********************************* Stepper enable logic **********************************
  *****************************************************************************************
@@ -255,7 +268,27 @@
 
 
 /*****************************************************************************************
- ******************************* Auto bed levelling **************************************
+ ******************************* Mesh bed leveling ***************************************
+ *****************************************************************************************/
+//#define 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 MESH_HOME_SEARCH_Z  5   // Z after Home, bed somewhere below but above 0.0.
+
+// After homing all axes ('G28' or 'G28 XYZ') rest at origin [0,0,0]
+//#define MESH_G28_REST_ORIGIN
+
+// Add display menu option for bed leveling.
+//#define MANUAL_BED_LEVELING
+// Step size while manually probing Z axis.
+#define MBL_Z_STEP 0.025
+/*****************************************************************************************/
+
+
+/*****************************************************************************************
+ ******************************* Auto bed leveling ***************************************
  *****************************************************************************************
  *                                                                                       *
  * There are 2 different ways to specify probing locations                               *
@@ -293,9 +326,9 @@
 #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
+#define ABL_PROBE_PT_2_Y 15
+#define ABL_PROBE_PT_3_X 180
+#define ABL_PROBE_PT_3_Y 15
 // no AUTO_BED_LEVELING_GRID
 
 // Offsets to the probe relative to the extruder tip (Hotend - Probe)
@@ -314,9 +347,6 @@
 #define Y_PROBE_OFFSET_FROM_EXTRUDER  0     // Y offset: -front [of the nozzle] +behind
 #define Z_PROBE_OFFSET_FROM_EXTRUDER -1     // Z offset: -below [of the nozzle] (always negative!)
 
-#define Z_RAISE_BEFORE_HOMING        10     // (in mm) Raise Z before homing (G28) for Probe Clearance.
-                                            // Be sure you have this distance over your Z_MAX_POS in case
-
 #define Z_RAISE_BEFORE_PROBING       10     //How much the extruder will be raised before travelling to the first probing point.
 #define Z_RAISE_BETWEEN_PROBINGS      5     //How much the extruder will be raised when travelling from between next probing points
 #define Z_RAISE_AFTER_PROBING         5     //How much the extruder will be raised after the last probing point.
@@ -325,7 +355,7 @@
                                                                   // Useful to retract a deployable Z probe.
 
 //#define Z_PROBE_SLED          // turn on if you have a z-probe mounted on a sled like those designed by Charles Bell
-//#define SLED_DOCKING_OFFSET 5       // the extra distance the X axis must travel to pick up the sled. 0 should be fine but you can push it further if you'd like.
+#define SLED_DOCKING_OFFSET 5   // the extra distance the X axis must travel to pick up the sled. 0 should be fine but you can push it further if you'd like.
 /*****************************************************************************************/
 
 
@@ -336,26 +366,26 @@
  * If you have enabled the Auto bed levelling this add the Support for                   *
  * a dedicated Z PROBE endstop separate from the Z MIN endstop.                          *
  * If you would like to use both a Z PROBE and a Z MIN endstop together                  *
- * or just a Z PROBE with a custom pin, uncomment #define Z_PROBE_ENDSTOP                *
+ * or just a Z PROBE with a custom pin, uncomment #define Z PROBE ENDSTOP                *
  * and read the instructions below.                                                      *
  *                                                                                       *
  * If you want to still use the Z min endstop for homing,                                *
- * disable Z_SAFE_HOMING.                                                                *
+ * disable Z SAFE HOMING.                                                                *
  * Eg: to park the head outside the bed area when homing with G28.                       *
  *                                                                                       *
  * WARNING: The Z MIN endstop will need to set properly as it would                      *
  * without a Z PROBE to prevent head crashes and premature stopping                      *
  * during a print.                                                                       *
- * To use a separte Z PROBE endstop, you must have a Z_PROBE_PIN                         *
+ * To use a separte Z PROBE endstop, you must have a Z PROBE PIN                         *
  * defined in the pins.h file for your control board.                                    *
  * If you are using a servo based Z PROBE, you will need to enable                       *
- * NUM_SERVOS, SERVO_ENDSTOPS and SERVO_ENDSTOPS_ANGLES in                               *
+ * NUM SERVOS, SERVO ENDSTOPS and SERVO ENDSTOPS ANGLES in                               *
  * Configuration_Feature R/C Servo section.                                              *
  *                                                                                       *
  * WARNING: Setting the wrong pin may have unexpected and potentially                    *
  * disastrous outcomes. Use with caution and do your homework.                           *
  *                                                                                       *
- * Uncomment Z_PROBE_ENDSTOP to enable.                                                  *
+ * Uncomment Z PROBE ENDSTOP to enable.                                                  *
  *                                                                                       *
  *****************************************************************************************/
 //#define Z_PROBE_ENDSTOP
@@ -364,7 +394,7 @@
 
 /*****************************************************************************************
  ******************************** Manual home positions **********************************
-/*****************************************************************************************/
+ *****************************************************************************************/
 // The position of the homing switches
 //#define MANUAL_HOME_POSITIONS   // If defined, MANUAL_*_HOME_POS below will be used
 //#define BED_CENTER_AT_0_0       // If defined, the center of the bed is at (X=0, Y=0)

MK/Configuration_Feature.h

@@ -23,6 +23,7 @@
  * - Software endstops
  * - Endstops only for homing
  * - Abort on endstop hit feature
+ * - Mesh Level Area
  * - R/C Servo
  * - Late Z axis
  * - Ahead slowdown
@@ -437,6 +438,23 @@
  **************************************************************************/
 //#define ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
 #define ABORT_ON_ENDSTOP_HIT_INIT true
+/**************************************************************************/
+
+
+/**************************************************************************
+ *************************** Mesh Level Area ******************************
+ **************************************************************************
+ *                                                                        *
+ * 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.                       *
+ *                                                                        *
+ **************************************************************************/
+#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))
+/**************************************************************************/
 
 
 /**************************************************************************

MK/Configuration_Store.cpp

@@ -179,6 +179,14 @@ void Config_StoreSettings() {
   EEPROM_WRITE_VAR(i, home_offset);
   EEPROM_WRITE_VAR(i, hotend_offset);
 
+  #if ENABLED(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];
+    EEPROM_WRITE_VAR(i, mbl.active);
+    EEPROM_WRITE_VAR(i, mbl.z_offset);
+    EEPROM_WRITE_VAR(i, mbl.z_values);
+  #endif
+
   #if !MECH(DELTA)
     EEPROM_WRITE_VAR(i, zprobe_zoffset);
   #endif
@@ -338,6 +346,12 @@ void Config_RetrieveSettings() {
     EEPROM_READ_VAR(i, home_offset);
     EEPROM_READ_VAR(i, hotend_offset);
 
+    #if ENABLED(MESH_BED_LEVELING)
+      EPROM_READ_VAR(i, mbl.active);
+      EEPROM_READ_VAR(i, mbl.z_offset);
+      EEPROM_READ_VAR(i, mbl.z_values);
+    #endif
+
     #if !MECH(DELTA)
       EEPROM_READ_VAR(i, zprobe_zoffset);
     #endif
@@ -540,6 +554,10 @@ void Config_ResetDefault() {
   max_z_jerk = DEFAULT_ZJERK;
   home_offset[X_AXIS] = home_offset[Y_AXIS] = home_offset[Z_AXIS] = 0;
 
+  #if ENABLED(MESH_BED_LEVELING)
+    mbl.active = false;
+  #endif
+
   #if ENABLED(AUTO_BED_LEVELING_FEATURE)
     zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER;
   #elif !MECH(DELTA)
@@ -745,6 +763,23 @@ void Config_ResetDefault() {
       ECHO_EMV(" Z", hotend_offset[Z_AXIS][h]);
     }
 
+    #if ENABLED(MESH_BED_LEVELING)
+      if (!forReplay) {
+        ECHO_LM(CFG, "Mesh bed leveling:");
+      }
+      ECHO_SMV(CFG, "  M420 S", mbl.active);
+      ECHO_MV(" X", MESH_NUM_X_POINTS);
+      ECHO_EMV(" Y", MESH_NUM_Y_POINTS);
+
+      for (int py = 1; py <= MESH_NUM_Y_POINTS; py++) {
+        for (int px = 1; px <= MESH_NUM_X_POINTS; px++) {
+          ECHO_SMV(CFG, "  G29 S3 X", px);
+          ECHO_MV(" Y", py);
+          ECHO_EMV(" Z", mbl.z_values[py-1][px-1], 5);
+        }
+      }
+    #endif
+  
     #if HEATER_USES_AD595
       if (!forReplay) {
         ECHO_LM(CFG, "AD595 Offset and Gain:");

MK/Configuration_Version.h

@@ -24,7 +24,7 @@
   #define CONFIGURATION_VERSION_H
 
   #define FIRMWARE_NAME "MK"
-  #define SHORT_BUILD_VERSION "4.2.83_dev"
+  #define SHORT_BUILD_VERSION "4.2.84_dev"
   #define BUILD_VERSION FIRMWARE_NAME "_" SHORT_BUILD_VERSION
   #define STRING_DISTRIBUTION_DATE __DATE__ " " __TIME__    // build date and time
   // It might also be appropriate to define a location where additional information can be found

MK/MK.ino

@@ -170,6 +170,8 @@
  * M407 - Display measured filament diameter
  * M408 - Report JSON-style response
  * M410 - Quickstop. Abort all the planned moves
+ * M420 - Enable/Disable Mesh Bed Leveling
+ * M421 - Set a single Mesh Bed Leveling Z coordinate. M421 X<mm> Y<mm> Z<mm>' or 'M421 I<xindex> J<yindex> Z<mm>
  * M428 - Set the home_offset logically based on the current_position
  * M500 - Store parameters in EEPROM
  * M501 - Read parameters from EEPROM (if you need reset them after you changed them temporarily).

MK/base.h

@@ -52,6 +52,10 @@
 #include "module/HAL/HAL.h"
 #include "module/communication/communication.h"
 
+#if ENABLED(MESH_BED_LEVELING)
+  #include "module/mbl/mesh_bed_leveling.h"
+#endif
+
 #include "Configuration_Store.h"
 
 #include "module/language/language.h"

MK/module/conditionals.h

@@ -376,11 +376,13 @@
    * CoreXY or CoreYX or CoreXZ or CoreZX
    */
   #if MECH(COREXY) || MECH(COREYX)
+    #define CORE_AXIS_1 A_AXIS
     #define CORE_AXIS_2 B_AXIS
-    #define CORE_AXIS_3 Z_AXIS
+    #define NORMAL_AXIS Z_AXIS
   #elif MECH(COREXZ) || MECH(COREZX)
+    #define CORE_AXIS_1 A_AXIS
     #define CORE_AXIS_2 C_AXIS
-    #define CORE_AXIS_3 Y_AXIS
+    #define NORMAL_AXIS Y_AXIS
   #endif
 
   /**

MK/module/language/language.h

@@ -116,6 +116,8 @@
 #define SERIAL_Z_PROBE                          "z_probe: "
 #define SERIAL_E_MIN                            "e_min: "
 #define SERIAL_ERR_MATERIAL_INDEX               "M145 S<index> out of range (0-2)"
+#define SERIAL_ERR_M421_PARAMETERS              "M421 requires XYZ or IJZ parameters"
+#define SERIAL_ERR_MESH_XY                      "Mesh XY or IJ cannot be resolved"
 #define SERIAL_ERR_M428_TOO_FAR                 "Too far from reference point"
 #define SERIAL_M119_REPORT                      "Reporting endstop status"
 #define SERIAL_ENDSTOP_HIT                      "TRIGGERED"

MK/module/language/language_en.h

@@ -45,15 +45,11 @@
 #define MSG_AUTO_HOME_X                     "Home X"
 #define MSG_AUTO_HOME_Y                     "Home Y"
 #define MSG_AUTO_HOME_Z                     "Home Z"
-#define MSG_MBL_SETTING                     "Manual Bed Leveling"
-#define MSG_MBL_BUTTON                      " Press the button   "
-#define MSG_MBL_INTRO                       " Leveling bed...    "
-#define MSG_MBL_1                           " Adjust first point "
-#define MSG_MBL_2                           " Adjust second point"
-#define MSG_MBL_3                           " Adjust third point "
-#define MSG_MBL_4                           " Adjust fourth point"
-#define MSG_MBL_5                           "    Is it ok?       "
-#define MSG_MBL_6                           " BED leveled!       "
+#define MSG_LEVEL_BED_HOMING                "Homing XYZ"
+#define MSG_LEVEL_BED_WAITING               "Click to Begin"
+#define MSG_LEVEL_BED_NEXT_POINT            "Next Point"
+#define MSG_LEVEL_BED_DONE                  "Leveling Done!"
+#define MSG_LEVEL_BED_CANCEL                "Cancel"
 #define MSG_SET_HOME_OFFSETS                "Set home offsets"
 #define MSG_SET_ORIGIN                      "Set origin"
 #define MSG_ONFOR                           "On x:"
@@ -83,6 +79,7 @@
 #define MSG_SPEED                           "Speed"
 #define MSG_NOZZLE                          "Nozzle"
 #define MSG_BED                             "Bed"
+#define MSG_BED_Z                           "Bed Z"
 #define MSG_FAN_SPEED                       "Fan speed"
 #define MSG_FLOW                            "Flow"
 #define MSG_CONTROL                         "Control"

MK/module/language/language_it.h

@@ -42,15 +42,10 @@
 #define MSG_AUTOSTART                       "Autostart"
 #define MSG_DISABLE_STEPPERS                "Disabilita Motori"
 #define MSG_AUTO_HOME                       "Auto Home"
-#define MSG_MBL_SETTING                     "Liv. piatto manuale "
-#define MSG_MBL_BUTTON                      " Premi il tasto   "
-#define MSG_MBL_INTRO                       " Liv. piatto...    "
-#define MSG_MBL_1                           " Calibra il primo punto"
-#define MSG_MBL_2                           " Calibra il secondo punto"
-#define MSG_MBL_3                           " Calibra il terzo punto"
-#define MSG_MBL_4                           " Calibra il quarto punto"
-#define MSG_MBL_5                           "    Va bene?       "
-#define MSG_MBL_6                           " Piatto livellato!       "
+#define MSG_LEVEL_BED_HOMING                "Home assi XYZ"
+#define MSG_LEVEL_BED_WAITING               "Premi per iniziare"
+#define MSG_LEVEL_BED_DONE                  "Livel. terminato!"
+#define MSG_LEVEL_BED_CANCEL                "Annulla"
 #define MSG_SET_HOME_OFFSETS                "Setta offset home"
 #define MSG_SET_ORIGIN                      "Imposta Origine"
 #define MSG_ONFOR                           "On x:"
@@ -76,10 +71,11 @@
 #define MSG_EXTRUDE                         "Estrudi"
 #define MSG_RETRACT                         "Ritrai"
 #define MSG_PURGE                           "Purge"
-#define MSG_LEVEL_BED                       "Liv. piatto"
+#define MSG_LEVEL_BED                       "Livella piano"
 #define MSG_SPEED                           "Velocita"
 #define MSG_NOZZLE                          "Ugello"
 #define MSG_BED                             "Piatto"
+#define MSG_BED_Z                           "piatto Z"
 #define MSG_FAN_SPEED                       "Ventola"
 #define MSG_FLOW                            "Flusso"
 #define MSG_CONTROL                         "Controllo"

MK/module/laser/laser.cpp

+
 /**
  * MK & MK4due 3D Printer Firmware
  *
@@ -23,7 +24,6 @@
 /**
  * laser.cpp - Laser control library for Arduino using 16 bit timers- Version 1
  * Copyright (c) 2013 Timothy Schmidt.  All right reserved.
- * Copyright (c) 2016 Franco (nextime) Lanza
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -335,6 +335,7 @@
         }
       }
     }
+
   #endif // LASER_PERIPHERALS
 
 #endif // LASERBEAM

MK/module/laser/laser.h

@@ -23,7 +23,6 @@
 /**
  * laser.cpp - Laser control library for Arduino using 16 bit timers- Version 1
  * Copyright (c) 2013 Timothy Schmidt.  All right reserved.
- * Copyright (c) 2016 Franco (nextime) Lanza
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

MK/module/lcd/dogm_lcd_implementation.h

@@ -137,7 +137,7 @@
   #define LCD_WIDTH_EDIT       22
 #endif
 
-#if DISABLED(TALL_FONT_CORRECTION)
+#ifndef TALL_FONT_CORRECTION
   #define TALL_FONT_CORRECTION 0
 #endif
 
@@ -158,7 +158,10 @@
   U8GLIB_LM6059 u8g(DOGLCD_CS, DOGLCD_A0);
 #elif ENABLED(U8GLIB_SSD1306)
   // Generic support for SSD1306 OLED I2C LCDs
-  U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE);
+  U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE | U8G_I2C_OPT_FAST);
+#elif ENABLED(U8GLIB_SH1106)
+  // Generic support for SH1106 OLED I2C LCDs
+  U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE | U8G_I2C_OPT_FAST);
 #elif ENABLED(MINIPANEL)
   // The MINIPanel display
   U8GLIB_MINI12864 u8g(DOGLCD_CS, DOGLCD_A0);
@@ -167,10 +170,10 @@
   U8GLIB_DOGM128 u8g(DOGLCD_CS, DOGLCD_A0);  // HW-SPI Com: CS, A0
 #endif
 
-#if DISABLED(LCD_PIXEL_WIDTH)
+#ifndef LCD_PIXEL_WIDTH
   #define LCD_PIXEL_WIDTH 128
 #endif
-#if DISABLED(LCD_PIXEL_HEIGHT)
+#ifndef LCD_PIXEL_HEIGHT
   #define LCD_PIXEL_HEIGHT 64
 #endif
 
@@ -269,7 +272,7 @@ static void lcd_implementation_init() {
       if (show_bootscreen) {
         u8g.drawBitmapP(offx, offy, START_BMPBYTEWIDTH, START_BMPHEIGHT, start_bmp);
         lcd_setFont(FONT_MENU);
-        #if DISABLED(STRING_SPLASH_LINE2)
+        #ifndef STRING_SPLASH_LINE2
           u8g.drawStr(txt1X, u8g.getHeight() - (DOG_CHAR_HEIGHT), STRING_SPLASH_LINE1);
         #else
           int txt2X = (u8g.getWidth() - (sizeof(STRING_SPLASH_LINE2) - 1) * (DOG_CHAR_WIDTH)) / 2;

MK/module/lcd/ultralcd.h

@@ -55,10 +55,6 @@
     void lcd_setcontrast(uint8_t value);
   #endif
 
-  #if !MECH(DELTA) && DISABLED(Z_SAFE_HOMING) && Z_HOME_DIR < 0
-    void set_pageShowInfo(int value);
-  #endif
-
   #define LCD_MESSAGEPGM(x) lcd_setstatuspgm(PSTR(x))
   #define LCD_ALERTMESSAGEPGM(x) lcd_setalertstatuspgm(PSTR(x))
 
@@ -102,7 +98,7 @@
   #endif
   void lcd_quick_feedback(); // Audible feedback for a button click - could also be visual
   bool lcd_clicked();
-  void lcd_ignore_click(bool b = true);
+  void lcd_ignore_click(bool b=true);
   bool lcd_blink();
 
   #if ENABLED(ULTIPANEL) && ENABLED(REPRAPWORLD_KEYPAD)
@@ -138,6 +134,7 @@
   #endif // ULTIPANEL && REPRAPWORLD_KEYPAD
 
   #if ENABLED(NEWPANEL)
+
     #define EN_C (_BV(BLEN_C))
     #define EN_B (_BV(BLEN_B))
     #define EN_A (_BV(BLEN_A))
@@ -179,25 +176,23 @@
 
   char* itostr2(const uint8_t& x);
   char* itostr3sign(const int& x);
-  char* itostr3(const int& xx);
-  char* itostr3left(const int& xx);
-  char* itostr4(const int& xx);
+  char* itostr3(const int& x);
+  char* itostr3left(const int& x);
+  char* itostr4(const int& x);
   char* itostr4sign(const int& x);
 
-  char* ltostr7(const long& xx);
-
   char* ftostr3(const float& x);
   char* ftostr4sign(const float& x);
-  char* ftostr30(const float& x);
   char* ftostr31ns(const float& x); // float to string without sign character
   char* ftostr31(const float& x);
   char* ftostr32(const float& x);
-  char* ftostr43(const float& x);
+  char* ftostr43(const float& x, char plus=' ');
   char* ftostr12ns(const float& x);
   char* ftostr32sp(const float& x); // remove zero-padding from ftostr32
   char* ftostr5(const float& x);
   char* ftostr51(const float& x);
   char* ftostr52(const float& x);
+  char* ltostr7(const long& x);
 
 #elif DISABLED(NEXTION)
 

MK/module/lcd/ultralcd_implementation_hitachi_HD44780.h

@@ -416,7 +416,7 @@ static void lcd_implementation_init(
   #elif ENABLED(LCD_I2C_TYPE_MCP23017)
     lcd.setMCPType(LTI_TYPE_MCP23017);
     lcd.begin(LCD_WIDTH, LCD_HEIGHT);
-    lcd.setBacklight(0); //set all the LEDs off to begin with
+    lcd_implementation_update_indicators();
 
   #elif ENABLED(LCD_I2C_TYPE_MCP23008)
     lcd.setMCPType(LTI_TYPE_MCP23008);
@@ -990,14 +990,14 @@ void lcd_implementation_drawedit(const char* pstr, const char* value = NULL) {
     static uint8_t ledsprev = 0;
     uint8_t leds = 0;
 
-    if (target_temperature_bed > 0) leds |= LED_A;
+    if (degTargetBed() > 0) leds |= LED_A;
 
-    if (target_temperature[0] > 0) leds |= LED_B;
+    if (degTargetHotend(0) > 0) leds |= LED_B;
 
     if (fanSpeed) leds |= LED_C;
 
     #if HOTENDS > 1
-      if (target_temperature[1] > 0) leds |= LED_C;
+      if (degTargetHotend(1) > 0) leds |= LED_C;
     #endif
 
     if (leds != ledsprev) {

MK/module/lcd/ultralcd_st7920_u8glib_rrd.h

@@ -97,11 +97,11 @@ uint8_t u8g_dev_rrd_st7920_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, vo
       ST7920_WRITE_BYTE(0x01);       //clear CGRAM ram
       u8g_Delay(15);                 //delay for CGRAM clear
       ST7920_WRITE_BYTE(0x3E);       //extended mode + GDRAM active
-      for (y = 0; y < LCD_PIXEL_HEIGHT / 2; y++) { //clear GDRAM
+      for (y = 0; y < (LCD_PIXEL_HEIGHT) / 2; y++) { //clear GDRAM
         ST7920_WRITE_BYTE(0x80 | y); //set y
         ST7920_WRITE_BYTE(0x80);     //set x = 0
         ST7920_SET_DAT();
-        for (i = 0; i < 2 * LCD_PIXEL_WIDTH / 8; i++) //2x width clears both segments
+        for (i = 0; i < 2 * (LCD_PIXEL_WIDTH) / 8; i++) //2x width clears both segments
           ST7920_WRITE_BYTE(0);
         ST7920_SET_CMD();
       }
@@ -129,7 +129,7 @@ uint8_t u8g_dev_rrd_st7920_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, vo
           ST7920_WRITE_BYTE(0x80 | 8);       //x=64
         }
         ST7920_SET_DAT();
-        ST7920_WRITE_BYTES(ptr, LCD_PIXEL_WIDTH / 8); //ptr is incremented inside of macro
+        ST7920_WRITE_BYTES(ptr, (LCD_PIXEL_WIDTH) / 8); //ptr is incremented inside of macro
         y++;
       }
       ST7920_NCS();
@@ -145,7 +145,7 @@ uint8_t u8g_dev_rrd_st7920_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, vo
 #endif
 }
 
-uint8_t   u8g_dev_st7920_128x64_rrd_buf[LCD_PIXEL_WIDTH * (PAGE_HEIGHT / 8)] U8G_NOCOMMON;
+uint8_t   u8g_dev_st7920_128x64_rrd_buf[(LCD_PIXEL_WIDTH) * (PAGE_HEIGHT) / 8] U8G_NOCOMMON;
 u8g_pb_t  u8g_dev_st7920_128x64_rrd_pb = {{PAGE_HEIGHT, LCD_PIXEL_HEIGHT, 0, 0, 0}, LCD_PIXEL_WIDTH, u8g_dev_st7920_128x64_rrd_buf};
 u8g_dev_t u8g_dev_st7920_128x64_rrd_sw_spi = {u8g_dev_rrd_st7920_128x64_fn, &u8g_dev_st7920_128x64_rrd_pb, &u8g_com_null_fn};
 

MK/module/lcd/utf_mapper.h

+/**
+ * MK & MK4due 3D Printer Firmware
+ *
+ * Based on Marlin, Sprinter and grbl
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (C) 2013 - 2016 Alberto Cotronei @MagoKimbra
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
 #ifndef UTF_MAPPER_H
 #define UTF_MAPPER_H
 
@@ -50,7 +72,7 @@
   //          ヰ    ヱ    ヲ    ン    フ    ?    ?   ?    ?    ?    ヲ    ・    ー    ヽ    ヽ   ?
            };
     #elif ENABLED(MAPPER_D0D1)
-      #error( "Cyrillic on a japanese dsplay makes no sense. There are no matching symbols.");
+      #error "Cyrillic on a JAPANESE display makes no sense. There are no matching symbols."
     #endif
 
   #elif ENABLED(DISPLAY_CHARSET_HD44780_WESTERN)
@@ -84,7 +106,7 @@
   //          p    c    T    y    Ф    x    Ч    ч    Ш    Щ    Ъ    Ы    b    Э    Ю    Я
             };
     #elif ENABLED(MAPPER_E382E383)
-      #error( "Katakana on a western display makes no sense. There are no matching symbols." );
+      #error "Katakana on a WESTERN display makes no sense. There are no matching symbols."
     #endif
 
   #elif ENABLED(DISPLAY_CHARSET_HD44780_CYRILLIC)
@@ -111,13 +133,13 @@
              // ш    щ    ъ    ы    ь    э    ю    я      // 7  Ѱ ѱ Ѳ ѳ Ѵ ѵ Ѷ ѷ
              };                                           //    ѻ ѹ Ѻ ѻ Ѽ ѽ Ѿ ѿ
     #elif ENABLED(MAPPER_C2C3)
-      #error( "Western languages on a cyrillic display makes no sense. There are no matching symbols." );
+      #error "Western languages on a CYRILLIC display makes no sense. There are no matching symbols."
     #elif ENABLED(MAPPER_E382E383)
-      #error( "Katakana on a cyrillic display makes no sense. There are no matching symbols." );
+      #error "Katakana on a CYRILLIC display makes no sense. There are no matching symbols."
     #endif
   #else
-    #error("Something went wrong in the selection of DISPLAY_CHARSET_HD44780's");
-  #endif // DISPLAY_CHARSET_HD44780_CYRILLIC
+    #error "Something went wrong in the setting of DISPLAY_CHARSET_HD44780"
+  #endif // DISPLAY_CHARSET_HD44780
 #endif // SIMULATE_ROMFONT
 
 #if ENABLED(MAPPER_NON)
@@ -209,7 +231,7 @@
       }
       else if (seen_d5) {
         d &= 0x3fu;
-        #if DISABLED(MAPPER_ONE_TO_ONE)
+        #ifndef MAPPER_ONE_TO_ONE
           HARDWARE_CHAR_OUT((char)pgm_read_byte_near(utf_recode + d + (utf_hi_char << 6) - 0x20));
         #else
           HARDWARE_CHAR_OUT((char)(0xa0u + (utf_hi_char << 6) + d)) ;
@@ -245,7 +267,7 @@
       }
       else if (seen_e3 && seen_82_83) {
         d &= 0x3f;
-        #if DISABLED(MAPPER_ONE_TO_ONE)
+        #ifndef MAPPER_ONE_TO_ONE
           HARDWARE_CHAR_OUT((char)pgm_read_byte_near(utf_recode + d + (utf_hi_char << 6) - 0x20));
         #else
           HARDWARE_CHAR_OUT((char)(0x80 + (utf_hi_char << 6) + d)) ;

MK/module/mbl/mesh_bed_leveling.cpp

+/**
+ * MK & MK4due 3D Printer Firmware
+ *
+ * Based on Marlin, Sprinter and grbl
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (C) 2013 - 2016 Alberto Cotronei @MagoKimbra
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../base.h"
+
+#if ENABLED(MESH_BED_LEVELING)
+
+  mesh_bed_leveling mbl;
+
+  mesh_bed_leveling::mesh_bed_leveling() { reset(); }
+
+  void mesh_bed_leveling::reset() {
+    active = 0;
+    z_offset = 0;
+    for (int8_t y = MESH_NUM_Y_POINTS; y--;)
+      for (int8_t x = MESH_NUM_X_POINTS; x--;)
+        z_values[y][x] = 0;
+  }
+
+#endif  // MESH_BED_LEVELING

MK/module/mbl/mesh_bed_leveling.h

+/**
+ * MK & MK4due 3D Printer Firmware
+ *
+ * Based on Marlin, Sprinter and grbl
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (C) 2013 - 2016 Alberto Cotronei @MagoKimbra
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#if ENABLED(MESH_BED_LEVELING)
+
+  #define MESH_X_DIST ((MESH_MAX_X - (MESH_MIN_X))/(MESH_NUM_X_POINTS - 1))
+  #define MESH_Y_DIST ((MESH_MAX_Y - (MESH_MIN_Y))/(MESH_NUM_Y_POINTS - 1))
+
+  class mesh_bed_leveling {
+  public:
+    bool active;
+    float z_offset;
+    float z_values[MESH_NUM_Y_POINTS][MESH_NUM_X_POINTS];
+
+    mesh_bed_leveling();
+
+    void reset();
+
+    static FORCE_INLINE float get_probe_x(int8_t i) { return MESH_MIN_X + (MESH_X_DIST) * i; }
+    static FORCE_INLINE float get_probe_y(int8_t i) { return MESH_MIN_Y + (MESH_Y_DIST) * i; }
+    void set_z(const int8_t px, const int8_t py, const float z) { z_values[py][px] = z; }
+
+    inline void zigzag(int8_t index, int8_t &px, int8_t &py) {
+      px = index % (MESH_NUM_X_POINTS);
+      py = index / (MESH_NUM_X_POINTS);
+      if (py & 1) px = (MESH_NUM_X_POINTS - 1) - px; // Zig zag
+    }
+
+    void set_zigzag_z(int8_t index, float z) {
+      int8_t px, py;
+      zigzag(index, px, py);
+      set_z(px, py, z);
+    }
+
+    int8_t cel_index_x(float x) {
+      int8_t cx = int(x - (MESH_MIN_X)) / (MESH_X_DIST);
+      return constrain(cx, 0, (MESH_NUM_X_POINTS) - 2);
+    }
+
+    int8_t cel_index_y(float y) {
+      int8_t cy = int(y - (MESH_MIN_Y)) / (MESH_Y_DIST);
+      return constrain(cy, 0, (MESH_NUM_Y_POINTS) - 2);
+    }
+
+    int8_t probe_index_x(float x) {
+      int8_t px = int(x - (MESH_MIN_X) + (MESH_X_DIST) / 2) / (MESH_X_DIST);
+      return (px >= 0 && px < (MESH_NUM_X_POINTS)) ? px : -1;
+    }
+
+    int8_t probe_index_y(float y) {
+      int8_t py = int(y - (MESH_MIN_Y) + (MESH_Y_DIST) / 2) / (MESH_Y_DIST);
+      return (py >= 0 && py < (MESH_NUM_Y_POINTS)) ? py : -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) {
+      int8_t cx = cel_index_x(x0),
+             cy = cel_index_y(y0);
+      if (cx < 0 || cy < 0) return z_offset;
+      float z1 = calc_z0(x0,
+                         get_probe_x(cx), z_values[cy][cx],
+                         get_probe_x(cx + 1), z_values[cy][cx + 1]);
+      float z2 = calc_z0(x0,
+                         get_probe_x(cx), z_values[cy + 1][cx],
+                         get_probe_x(cx + 1), z_values[cy + 1][cx + 1]);
+      float z0 = calc_z0(y0,
+                         get_probe_y(cy), z1,
+                         get_probe_y(cy + 1), z2);
+      return z0 + z_offset;
+    }
+  };
+
+  extern mesh_bed_leveling mbl;
+
+#endif  // MESH_BED_LEVELING

MK/module/motion/endstops.cpp

@@ -32,6 +32,34 @@
 
 Endstops endstops;
 
+// public:
+
+bool  Endstops::enabled = true,
+      Endstops::enabled_globally =
+        #if ENABLED(ENDSTOPS_ONLY_FOR_HOMING)
+          false
+        #else
+          true
+        #endif
+      ;
+volatile char Endstops::endstop_hit_bits; // use X_MIN, Y_MIN, Z_MIN and Z_MIN_PROBE as BIT value
+
+#if ENABLED(Z_DUAL_ENDSTOPS)
+  uint16_t
+#else
+  byte
+#endif
+    Endstops::current_endstop_bits = 0,
+    Endstops::old_endstop_bits = 0;
+
+#if HAS(Z_PROBE)
+  volatile bool Endstops::z_probe_enabled = false;
+#endif
+
+/**
+ * Class and Instance Methods
+ */
+
 Endstops::Endstops() {
   enable_globally(
     #if ENABLED(ENDSTOPS_ONLY_FOR_HOMING)
@@ -41,7 +69,7 @@ Endstops::Endstops() {
     #endif
   );
   enable(true);
-  #if ENABLED(HAS_Z_PROBE)
+  #if HAS(Z_PROBE)
     enable_z_probe(false);
   #endif
 } // Endstops::Endstops
@@ -240,8 +268,8 @@ void Endstops::update() {
 
   #if MECH(COREXY) || MECH(COREYX)|| MECH(COREXZ) || MECH(COREZX)
     // Head direction in -X axis for CoreXY and CoreXZ bots.
-    // If Delta1 == -Delta2, the movement is only in Y or Z axis
-    if ((current_block->steps[A_AXIS] != current_block->steps[CORE_AXIS_2]) || (motor_direction(A_AXIS) == motor_direction(CORE_AXIS_2))) {
+    // If DeltaA == -DeltaB, the movement is only in Y or Z axis
+    if ((current_block->steps[CORE_AXIS_1] != current_block->steps[CORE_AXIS_2]) || (motor_direction(CORE_AXIS_1) == motor_direction(CORE_AXIS_2))) {
       if (motor_direction(X_HEAD))
   #else
     if (motor_direction(X_AXIS))   // stepping along -X axis (regular Cartesian bot)
@@ -274,8 +302,8 @@ void Endstops::update() {
 
   #if MECH(COREXY) || MECH(COREYX)
     // Head direction in -Y axis for CoreXY bots.
-    // If DeltaX == DeltaY, the movement is only in X axis
-    if ((current_block->steps[A_AXIS] != current_block->steps[B_AXIS]) || (motor_direction(A_AXIS) != motor_direction(B_AXIS))) {
+    // If DeltaA == DeltaB, the movement is only in X axis
+    if ((current_block->steps[CORE_AXIS_1] != current_block->steps[CORE_AXIS_2]) || (motor_direction(CORE_AXIS_1) != motor_direction(CORE_AXIS_2))) {
       if (motor_direction(Y_HEAD))
   #else
       if (motor_direction(Y_AXIS))   // -direction
@@ -296,8 +324,8 @@ void Endstops::update() {
 
   #if MECH(COREXZ) || MECH(COREZX)
     // Head direction in -Z axis for CoreXZ bots.
-    // If DeltaX == DeltaZ, the movement is only in X axis
-    if ((current_block->steps[A_AXIS] != current_block->steps[C_AXIS]) || (motor_direction(A_AXIS) != motor_direction(C_AXIS))) {
+    // If DeltaA == DeltaB, the movement is only in X axis
+    if ((current_block->steps[CORE_AXIS_1] != current_block->steps[CORE_AXIS_2]) || (motor_direction(CORE_AXIS_1) !) != motor_direction(CORE_AXIS_2))) {
       if (motor_direction(Z_HEAD))
   #else
       if (motor_direction(Z_AXIS))

MK/module/motion/endstops.h

@@ -33,25 +33,15 @@ class Endstops {
 
   public:
 
-    volatile char endstop_hit_bits; // use X_MIN, Y_MIN, Z_MIN and Z_PROBE as BIT value
+    static bool enabled, enabled_globally;
+    static volatile char endstop_hit_bits; // use X_MIN, Y_MIN, Z_MIN and Z_PROBE as BIT value
 
     #if ENABLED(Z_DUAL_ENDSTOPS)
-      uint16_t current_endstop_bits = 0,
-                   old_endstop_bits = 0;
+      static uint16_t
     #else
-      byte current_endstop_bits = 0,
-               old_endstop_bits = 0;
+      static byte
     #endif
-        
-
-    bool enabled = true;
-    bool enabled_globally =
-      #if ENABLED(ENDSTOPS_ONLY_FOR_HOMING)
-        false
-      #else
-        true
-      #endif
-    ;
+        current_endstop_bits, old_endstop_bits;
 
     Endstops();
 
@@ -63,40 +53,40 @@ class Endstops {
     /**
      * Update the endstops bits from the pins
      */
-    void update();
+    static void update();
 
     /**
      * Print an error message reporting the position when the endstops were last hit.
      */
-    void report_state(); // call from somewhere to create an serial error message with the locations the endstops where hit, in case they were triggered
+    static void report_state(); // call from somewhere to create an serial error message with the locations the endstops where hit, in case they were triggered
 
     /**
      * Report endstop positions in response to M119
      */
-    void M119();
+    static void M119();
 
     // Enable / disable endstop checking globally
-    FORCE_INLINE void enable_globally(bool onoff = true) { enabled_globally = enabled = onoff; }
+    static void enable_globally(bool onoff = true) { enabled_globally = enabled = onoff; }
 
     // Enable / disable endstop checking
-    FORCE_INLINE void enable(bool onoff = true) { enabled = onoff; }
+    static void enable(bool onoff = true) { enabled = onoff; }
 
     // Disable / Enable endstops based on ENSTOPS_ONLY_FOR_HOMING and global enable
-    FORCE_INLINE void not_homing() { enabled = enabled_globally; }
+    static void not_homing() { enabled = enabled_globally; }
 
     // Clear endstops (i.e., they were hit intentionally) to suppress the report
-    FORCE_INLINE void hit_on_purpose() { endstop_hit_bits = 0; }
+    static void hit_on_purpose() { endstop_hit_bits = 0; }
 
     // Enable / disable endstop z-probe checking
-    #if ENABLED(HAS_Z_PROBE)
-      volatile bool z_probe_enabled = false;
-      FORCE_INLINE void enable_z_probe(bool onoff = true) { z_probe_enabled = onoff; }
+    #if HAS(Z_PROBE)
+      static volatile bool z_probe_enabled;
+      static void enable_z_probe(bool onoff = true) { z_probe_enabled = onoff; }
     #endif
 
   private:
 
     #if ENABLED(Z_DUAL_ENDSTOPS)
-      void test_dual_z_endstops(EndstopEnum es1, EndstopEnum es2);
+      static void test_dual_z_endstops(EndstopEnum es1, EndstopEnum es2);
     #endif
 };
 

MK/module/motion/planner.h

@@ -127,29 +127,43 @@ void check_axes_activity();
 // Get the number of buffered moves
 extern volatile unsigned char block_buffer_head;
 extern volatile unsigned char block_buffer_tail;
+
+/**
+ * Number of moves currently in the planner
+ */
 FORCE_INLINE uint8_t movesplanned() { return BLOCK_MOD(block_buffer_head - block_buffer_tail + BLOCK_BUFFER_SIZE); }
 
-#if ENABLED(AUTO_BED_LEVELING_FEATURE)
+#if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING)
+
+  #if ENABLED(AUTO_BED_LEVELING_FEATURE)
 
     #include "vector_3.h"
 
-  // Transform required to compensate for bed level
+    // Transform to compensate for bed level
     extern matrix_3x3 plan_bed_level_matrix;
 
     /**
-   * Get the position applying the bed level matrix
+     * The corrected position, applying the bed level matrix
      */
-  vector_3 plan_get_position();
+    vector_3 plan_adjusted_position();
+  #endif
 
   /**
-   * Add a new linear movement to the buffer. x, y, z are the signed, absolute target position in
-   * millimeters. Feed rate specifies the (target) speed of the motion.
+   * Add a new linear movement to the buffer.
+   *
+   *  x,y,z,e   - target position in mm
+   *  feed_rate - (target) speed of the move
+   *  extruder  - target extruder
    */
   void plan_buffer_line(float x, float y, float z, const float& e, float feed_rate, const uint8_t extruder, const uint8_t driver);
 
   /**
-   * Set the planner positions. Used for G92 instructions.
-   * Multiplies by axis_steps_per_unit[] to set stepper positions.
+   * Set the planner.position and individual stepper positions.
+   * Used by G92, G28, G29, and other procedures.
+   *
+   * Multiplies by axis_steps_per_unit[] and does necessary conversion
+   * for COREXY / COREXZ to set the corresponding stepper positions.
+   *
    * Clears previous speed values.
    */
   void plan_set_position(float x, float y, float z, const float& e);
@@ -159,8 +173,11 @@ FORCE_INLINE uint8_t movesplanned() { return BLOCK_MOD(block_buffer_head - block
   void plan_buffer_line(const float& x, const float& y, const float& z, const float& e, float feed_rate, const uint8_t extruder, const uint8_t driver);
   void plan_set_position(const float& x, const float& y, const float& z, const float& e);
 
-#endif // AUTO_BED_LEVELING_FEATURE
+#endif // AUTO_BED_LEVELING_FEATURE || MESH_BED_LEVELING
 
+/**
+ * Set the E position (mm) of the planner (and the E stepper)
+ */
 void plan_set_e_position(const float& e);
 
 //===========================================================================
@@ -193,17 +210,24 @@ extern block_t block_buffer[BLOCK_BUFFER_SIZE];            // A ring buffer for
 extern volatile unsigned char block_buffer_head;           // Index of the next block to be pushed
 extern volatile unsigned char block_buffer_tail;
 
-// Returns true if the buffer has a queued block, false otherwise
+/**
+ * Does the buffer have any blocks queued?
+ */
 FORCE_INLINE bool blocks_queued() { return (block_buffer_head != block_buffer_tail); }
 
-// Called when the current block is no longer needed. Discards
-// the block and makes the memory available for new blocks.
+/**
+ * "Discards" the block and "releases" the memory.
+ * Called when the current block is no longer needed.
+ */
 FORCE_INLINE void plan_discard_current_block() {
   if (blocks_queued())
     block_buffer_tail = BLOCK_MOD(block_buffer_tail + 1);
 }
 
-// Gets the current block. Returns NULL if buffer empty
+/**
+ * The current block. NULL if the buffer is empty.
+ * This also marks the block as busy.
+ */
 FORCE_INLINE block_t* plan_get_current_block() {
   if (blocks_queued()) {
     block_t* block = &block_buffer[block_buffer_tail];

MK/module/motion/stepper.cpp

@@ -1104,14 +1104,14 @@ long st_get_position(uint8_t axis) {
 float st_get_axis_position_mm(AxisEnum axis) {
   float axis_pos;
   #if MECH(COREXY) || MECH(COREYX) || MECH(COREXZ) || MECH(COREZX)
-    if (axis == X_AXIS || axis == CORE_AXIS_2) {
+    if (axis == CORE_AXIS_1 || axis == CORE_AXIS_2) {
       CRITICAL_SECTION_START;
-      long  pos1 = count_position[A_AXIS],
+      long  pos1 = count_position[CORE_AXIS_1],
             pos2 = count_position[CORE_AXIS_2];
       CRITICAL_SECTION_END;
       // ((a1+a2)+(a1-a2))/2 -> (a1+a2+a1-a2)/2 -> (a1+a1)/2 -> a1
       // ((a1+a2)-(a1-a2))/2 -> (a1+a2-a1+a2)/2 -> (a2+a2)/2 -> a2
-      axis_pos = (pos1 + ((axis == X_AXIS) ? pos2 : -pos2)) / 2.0f;
+      axis_pos = (pos1 + ((axis == CORE_AXIS_1) ? pos2 : -pos2)) / 2.0f;
     }
     else
       axis_pos = st_get_position(axis);
@@ -1160,10 +1160,10 @@ void endstop_triggered(AxisEnum axis) {
   #if MECH(COREXY) || MECH(COREYX) || MECH(COREXZ) || MECH(COREZX)
 
     float axis_pos = count_position[axis];
-    if (axis == A_AXIS)
+    if (axis == CORE_AXIS_1)
       axis_pos = (axis_pos + count_position[CORE_AXIS_2]) / 2;
     else if (axis == CORE_AXIS_2)
-      axis_pos = (count_position[A_AXIS] - axis_pos) / 2;
+      axis_pos = (count_position[CORE_AXIS_1] - axis_pos) / 2;
     endstops_trigsteps[axis] = axis_pos;
 
   #else // ! COREXY || COREYX || COREXZ || COREZX

MK/module/sanitycheck.h

@@ -530,6 +530,27 @@
   #if DISABLED(SOFTWARE_MAX_ENDSTOPS)
     #error DEPENDENCY ERROR: Missing setting SOFTWARE_MAX_ENDSTOPS
   #endif
+
+  /**
+   * Mesh Bed Leveling
+   */
+  #if ENABLED(MESH_BED_LEVELING)
+    #if MECH(DELTA)
+      #error "MESH_BED_LEVELING does not yet support DELTA printers."
+    #endif
+    #if ENABLED(AUTO_BED_LEVELING_FEATURE)
+      #error "Select AUTO_BED_LEVELING_FEATURE or MESH_BED_LEVELING, not both."
+    #endif
+    #if MESH_NUM_X_POINTS > 7 || MESH_NUM_Y_POINTS > 7
+      #error "MESH_NUM_X_POINTS and MESH_NUM_Y_POINTS need to be less than 8."
+    #endif
+  #elif ENABLED(MANUAL_BED_LEVELING)
+    #error "MESH_BED_LEVELING is required for MANUAL_BED_LEVELING."
+  #endif
+
+  /**
+   * Auto Bed Leveling
+   */
   #if ENABLED(AUTO_BED_LEVELING_FEATURE)
     #if ENABLED(AUTO_BED_LEVELING_GRID)
       #if DISABLED(MIN_PROBE_EDGE)
@@ -1924,4 +1945,12 @@
     #error DEPENDENCY ERROR: You have to set SLED_PIN to a valid pin if you enable Z_PROBE_SLED
   #endif
 
+  /**
+   * Warnings for old configurations
+   */
+  #if WATCH_TEMP_PERIOD > 500
+    #error "WATCH_TEMP_PERIOD now uses seconds instead of milliseconds."
+  #elif defined(Z_RAISE_BEFORE_HOMING)
+    #error "Z_RAISE_BEFORE_HOMING is deprecated. Use MIN_Z_HEIGHT_FOR_HOMING instead."
+  #endif
 #endif //SANITYCHECK_H

README.md

@@ -48,6 +48,7 @@ Added Hysteresis and Z-Wobble correction (only cartesian printers).
 Added support reader TAG width MFRC522
 Added Cooler and Hot Chamber
 Added Laser beam and raster base64
+Addes Mesh Bed Level (MBL)
 
 ## Credits