UBL core and support files

Marlin/UBL.h

@@ -0,0 +1,331 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016, 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "Marlin.h"
+#include "math.h"
+
+#ifndef UNIFIED_BED_LEVELING_H
+#define UNIFIED_BED_LEVELING_H
+
+  #if ENABLED(AUTO_BED_LEVELING_UBL)
+
+    #define UBL_OK false
+    #define UBL_ERR true
+
+    typedef struct {
+      int x_index, y_index;
+      float distance; // Not always used. But when populated, it is the distance
+                      // from the search location
+    } mesh_index_pair;
+
+    struct vector { double dx, dy, dz; };
+
+    enum Mesh_Point_Type { INVALID, REAL, SET_IN_BITMAP };
+
+    bool axis_unhomed_error(bool, bool, bool);
+    void dump(char *str, float f);
+    bool G29_lcd_clicked();
+    void probe_entire_mesh(float, float, bool, bool);
+    void UBL_line_to_destination(const float&, const float&, const float&, const float&, const float&, uint8_t);
+    void manually_probe_remaining_mesh(float, float, float, float, bool);
+    struct vector tilt_mesh_based_on_3pts(float, float, float);
+    void new_set_bed_level_equation_3pts(float, float, float);
+    float measure_business_card_thickness(float);
+    mesh_index_pair find_closest_mesh_point_of_type(Mesh_Point_Type, float, float, bool, unsigned int[16]);
+    void Find_Mean_Mesh_Height();
+    void Shift_Mesh_Height();
+    bool G29_Parameter_Parsing();
+    void G29_What_Command();
+    void G29_EEPROM_Dump();
+    void G29_Kompare_Current_Mesh_to_Stored_Mesh();
+    void fine_tune_mesh(float, float, float, bool);
+    void bit_clear(uint16_t bits[16], uint8_t x, uint8_t y);
+    void bit_set(uint16_t bits[16], uint8_t x, uint8_t y);
+    bool is_bit_set(uint16_t bits[16], uint8_t x, uint8_t y);
+    char *ftostr43sign(const float&, char);
+
+    void gcode_G26();
+    void gcode_G28();
+    void gcode_G29();
+    extern char conv[9];
+
+    void save_UBL_active_state_and_disable();
+    void restore_UBL_active_state_and_leave();
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    #if ENABLED(ULTRA_LCD)
+      extern char lcd_status_message[];
+      void lcd_quick_feedback();
+    #endif
+
+    enum MBLStatus { MBL_STATUS_NONE = 0, MBL_STATUS_HAS_MESH_BIT = 0, MBL_STATUS_ACTIVE_BIT = 1 };
+
+    #define MESH_X_DIST ((float(UBL_MESH_MAX_X) - float(UBL_MESH_MIN_X)) / (float(UBL_MESH_NUM_X_POINTS) - 1.0))
+    #define MESH_Y_DIST ((float(UBL_MESH_MAX_Y) - float(UBL_MESH_MIN_Y)) / (float(UBL_MESH_NUM_Y_POINTS) - 1.0))
+
+    extern bool G26_Debug_flag;
+    extern float last_specified_z;
+    extern float fade_scaling_factor_for_current_height;
+    extern float z_values[UBL_MESH_NUM_X_POINTS][UBL_MESH_NUM_Y_POINTS];
+    extern float mesh_index_to_X_location[UBL_MESH_NUM_X_POINTS + 1]; // +1 just because of paranoia that we might end up on the
+    extern float mesh_index_to_Y_location[UBL_MESH_NUM_Y_POINTS + 1]; // the last Mesh Line and that is the start of a whole new cell
+
+    class bed_leveling {
+      public:
+      struct ubl_state {
+        bool active = false;
+        float z_offset = 0.0;
+        int EEPROM_storage_slot = -1,
+            n_x = UBL_MESH_NUM_X_POINTS,
+            n_y = UBL_MESH_NUM_Y_POINTS;
+        float mesh_x_min = UBL_MESH_MIN_X,
+              mesh_y_min = UBL_MESH_MIN_Y,
+              mesh_x_max = UBL_MESH_MAX_X,
+              mesh_y_max = UBL_MESH_MAX_Y,
+              mesh_x_dist = MESH_X_DIST,
+              mesh_y_dist = MESH_Y_DIST,
+              G29_Correction_Fade_Height = 10.0,
+              G29_Fade_Height_Multiplier = 1.0 / 10.0; // It is cheaper to do a floating point multiply than a floating
+                                                       // point divide. So, we keep this number in both forms. The first
+                                                       // is for the user. The second one is the one that is actually used
+                                                       // again and again and again during the correction calculations.
+
+        unsigned char padding[24];  // This is just to allow room to add state variables without
+                                    // changing the location of data structures in the EEPROM.
+                                    // This is for compatability with future versions to keep
+                                    // people from having to regenerate thier mesh data.
+                                    //
+                                    // If you change the contents of this struct, please adjust
+                                    // the padding[] to keep the size the same!
+      } state, pre_initialized;
+
+      bed_leveling();
+      //  ~bed_leveling();  // No destructor because this object never goes away!
+
+      void display_map(int);
+
+      void reset();
+      void invalidate();
+
+      void store_state();
+      void load_state();
+      void store_mesh(int);
+      void load_mesh(int);
+
+      bool sanity_check();
+
+      FORCE_INLINE float map_x_index_to_bed_location(int8_t i){ return ((float) UBL_MESH_MIN_X) + (((float) MESH_X_DIST) * (float) i); };
+      FORCE_INLINE float map_y_index_to_bed_location(int8_t i){ return ((float) UBL_MESH_MIN_Y) + (((float) MESH_Y_DIST) * (float) i); };
+
+      void set_z(const int8_t px, const int8_t py, const float z) { z_values[px][py] = z; }
+
+      int8_t get_cell_index_x(float x) {
+        int8_t cx = (x - (UBL_MESH_MIN_X)) * (1.0 / (MESH_X_DIST));
+        return constrain(cx, 0, (UBL_MESH_NUM_X_POINTS) - 1);   // -1 is appropriate if we want all movement to the X_MAX
+      }                                                         // position. But with this defined this way, it is possible
+                                                                // to extrapolate off of this point even further out. Probably
+                                                                // that is OK because something else should be keeping that from
+                                                                // happening and should not be worried about at this level.
+      int8_t get_cell_index_y(float y) {
+        int8_t cy = (y - (UBL_MESH_MIN_Y)) * (1.0 / (MESH_Y_DIST));
+        return constrain(cy, 0, (UBL_MESH_NUM_Y_POINTS) - 1);   // -1 is appropriate if we want all movement to the Y_MAX
+      }                                                         // position. But with this defined this way, it is possible
+                                                                // to extrapolate off of this point even further out. Probably
+                                                                // that is OK because something else should be keeping that from
+                                                                // happening and should not be worried about at this level.
+
+      int8_t find_closest_x_index(float x) {
+        int8_t px = (x - (UBL_MESH_MIN_X) + (MESH_X_DIST) * 0.5) * (1.0 / (MESH_X_DIST));
+        return (px >= 0 && px < (UBL_MESH_NUM_X_POINTS)) ? px : -1;
+      }
+
+      int8_t find_closest_y_index(float y) {
+        int8_t py = (y - (UBL_MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * (1.0 / (MESH_Y_DIST));
+        return (py >= 0 && py < (UBL_MESH_NUM_Y_POINTS)) ? py : -1;
+      }
+
+      /**
+       *                           z2   --|
+       *                 z0        |      |
+       *                  |        |      + (z2-z1)
+       *   z1             |        |      |
+       * ---+-------------+--------+--  --|
+       *   a1            a0        a2
+       *    |<---delta_a---------->|
+       *
+       *  calc_z0 is the basis for all the Mesh Based correction. It is used to
+       *  find the expected Z Height at a position between two known Z-Height locations
+       *
+       *  It is farly expensive with its 4 floating point additions and 2 floating point
+       *  multiplications.
+       */
+      inline float calc_z0(float a0, float a1, float z1, float a2, float z2) {
+        float delta_z = (z2 - z1);
+        float delta_a = (a0 - a1) / (a2 - a1);
+        return z1 + delta_a * delta_z;
+      }
+
+      /**
+       * get_z_correction_at_Y_intercept(float x0, int x1_i, int yi) only takes
+       * three parameters. It assumes the x0 point is on a Mesh line denoted by yi. In theory
+       * we could use get_cell_index_x(float x) to obtain the 2nd parameter x1_i but any code calling
+       * the get_z_correction_along_vertical_mesh_line_at_specific_X routine  will already have
+       * the X index of the x0 intersection available and we don't want to perform any extra floating
+       * point operations.
+       */
+      inline float get_z_correction_along_horizontal_mesh_line_at_specific_X(float x0, int x1_i, int yi) {
+        if (x1_i < 0 || yi < 0 || x1_i >= UBL_MESH_NUM_X_POINTS || yi >= UBL_MESH_NUM_Y_POINTS) {
+          SERIAL_ECHOPAIR("? in get_z_correction_along_horizontal_mesh_line_at_specific_X(x0=", x0);
+          SERIAL_ECHOPAIR(",x1_i=", x1_i);
+          SERIAL_ECHOPAIR(",yi=", yi);
+          SERIAL_CHAR(')');
+          SERIAL_EOL;
+          return NAN;
+        }
+
+        const float a0ma1diva2ma1 = (x0 - mesh_index_to_X_location[x1_i]) * (1.0 / (MESH_X_DIST)),
+                    z1 = z_values[x1_i][yi],
+                    z2 = z_values[x1_i + 1][yi],
+                    dz = (z2 - z1);
+
+        return z1 + a0ma1diva2ma1 * dz;
+      }
+
+      //
+      // See comments above for get_z_correction_along_horizontal_mesh_line_at_specific_X
+      //
+      inline float get_z_correction_along_vertical_mesh_line_at_specific_Y(float y0, int xi, int y1_i) {
+        if (xi < 0 || y1_i < 0 || xi >= UBL_MESH_NUM_X_POINTS || y1_i >= UBL_MESH_NUM_Y_POINTS) {
+          SERIAL_ECHOPAIR("? in get_z_correction_along_vertical_mesh_line_at_specific_X(y0=", y0);
+          SERIAL_ECHOPAIR(", x1_i=", xi);
+          SERIAL_ECHOPAIR(", yi=", y1_i);
+          SERIAL_CHAR(')');
+          SERIAL_EOL;
+          return NAN;
+        }
+
+        const float a0ma1diva2ma1 = (y0 - mesh_index_to_Y_location[y1_i]) * (1.0 / (MESH_Y_DIST)),
+                    z1 = z_values[xi][y1_i],
+                    z2 = z_values[xi][y1_i + 1],
+                    dz = (z2 - z1);
+
+        return z1 + a0ma1diva2ma1 * dz;
+      }
+
+      /**
+       * This is the generic Z-Correction. It works anywhere within a Mesh Cell. It first
+       * does a linear interpolation along both of the bounding X-Mesh-Lines to find the
+       * Z-Height at both ends. Then it does a linear interpolation of these heights based
+       * on the Y position within the cell.
+       */
+      float get_z_correction(float x0, float y0) {
+        int8_t cx = get_cell_index_x(x0),
+        cy = get_cell_index_y(y0);
+
+        if (cx < 0 || cy < 0 || cx >= UBL_MESH_NUM_X_POINTS || cy >= UBL_MESH_NUM_Y_POINTS) {
+
+          SERIAL_ECHOPAIR("? in get_z_correction(x0=", x0);
+          SERIAL_ECHOPAIR(", y0=", y0);
+          SERIAL_CHAR(')');
+          SERIAL_EOL;
+
+          #if ENABLED(ULTRA_LCD)
+            strcpy(lcd_status_message, "get_z_correction() indexes out of range.");
+            lcd_quick_feedback();
+          #endif
+          return 0.0; // this used to return state.z_offset
+        }
+
+        float z1 = calc_z0(x0,
+          map_x_index_to_bed_location(cx), z_values[cx][cy],
+          map_x_index_to_bed_location(cx + 1), z_values[cx + 1][cy]);
+        float z2 = calc_z0(x0,
+          map_x_index_to_bed_location(cx), z_values[cx][cy + 1],
+          map_x_index_to_bed_location(cx + 1), z_values[cx + 1][cy + 1]);
+        float z0 = calc_z0(y0,
+          map_y_index_to_bed_location(cy), z1,
+          map_y_index_to_bed_location(cy + 1), z2);
+
+        #if ENABLED(DEBUG_LEVELING_FEATURE)
+          if (DEBUGGING(MESH_ADJUST)) {
+            SERIAL_ECHOPAIR(" raw get_z_correction(", x0);
+            SERIAL_ECHOPAIR(",", y0);
+            SERIAL_ECHOPGM(")=");
+            SERIAL_PROTOCOL_F(z0, 6);
+          }
+        #endif
+
+        #if ENABLED(DEBUG_LEVELING_FEATURE)
+          if (DEBUGGING(MESH_ADJUST)) {
+            SERIAL_ECHOPGM(" >>>---> ");
+            SERIAL_PROTOCOL_F(z0, 6);
+            SERIAL_EOL;
+          }
+        #endif
+
+        if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN
+          z0 = 0.0;      // in blm.z_values[][] and propagate through the
+                         // calculations. If our correction is NAN, we throw it out
+                         // because part of the Mesh is undefined and we don't have the
+                         // information we need to complete the height correction.
+
+          #if ENABLED(DEBUG_LEVELING_FEATURE)
+            if (DEBUGGING(MESH_ADJUST)) {
+              SERIAL_ECHOPGM("??? Yikes!  NAN in get_z_correction( ");
+              SERIAL_ECHO(x0);
+              SERIAL_ECHOPGM(", ");
+              SERIAL_ECHO(y0);
+              SERIAL_ECHOLNPGM(" )");
+            }
+          #endif
+        }
+        return z0; // there used to be a +state.z_offset on this line
+      }
+
+      /**
+       * This routine is used to scale the Z correction depending upon the current nozzle height. It is
+       * optimized for speed. It avoids floating point operations by checking if the requested scaling
+       * factor is going to be the same as the last time the function calculated a value. If so, it just
+       * returns it.
+       *
+       * If it must do a calcuation, it will return a scaling factor of 0.0 if the UBL System is not active
+       * or if the current Z Height is past the specified 'Fade Height'
+       */
+      FORCE_INLINE float fade_scaling_factor_for_Z(float current_z) {
+        if (last_specified_z == current_z)
+          return fade_scaling_factor_for_current_height;
+
+        last_specified_z = current_z;
+        fade_scaling_factor_for_current_height =
+          state.active && current_z < state.G29_Correction_Fade_Height
+          ? 1.0 - (current_z * state.G29_Fade_Height_Multiplier)
+          : 0.0;
+        return fade_scaling_factor_for_current_height;
+      }
+    };
+
+    extern bed_leveling blm;
+    extern int Unified_Bed_Leveling_EEPROM_start;
+
+#endif // AUTO_BED_LEVELING_UBL
+#endif // UNIFIED_BED_LEVELING_H

Marlin/UBL_Bed_Leveling.cpp

@@ -0,0 +1,296 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "Marlin.h"
+#include "math.h"
+
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+  #include "UBL.h"
+  #include "hex_print_routines.h"
+
+  /**
+   * These variables used to be declared inside the bed_leveling class.  We are going to still declare
+   * them within the .cpp file for bed leveling.   But there is only one instance of the bed leveling
+   * object and we can get rid of a level of inderection by not making them 'member data'.  So, in the
+   * interest of speed, we do it this way.    When we move to a 32-Bit processor, they can be moved
+   * back inside the bed leveling class.
+   */
+  float last_specified_z,
+        fade_scaling_factor_for_current_height,
+        z_values[UBL_MESH_NUM_X_POINTS][UBL_MESH_NUM_Y_POINTS],
+        mesh_index_to_X_location[UBL_MESH_NUM_X_POINTS + 1], // +1 just because of paranoia that we might end up on the
+        mesh_index_to_Y_location[UBL_MESH_NUM_Y_POINTS + 1]; // the last Mesh Line and that is the start of a whole new cell
+
+  bed_leveling::bed_leveling() {
+    for (uint8_t i = 0; i <= UBL_MESH_NUM_X_POINTS; i++)  // We go one past what we expect to ever need for safety
+      mesh_index_to_X_location[i] = double(UBL_MESH_MIN_X) + double(MESH_X_DIST) * double(i);
+
+    for (uint8_t i = 0; i <= UBL_MESH_NUM_Y_POINTS; i++)  // We go one past what we expect to ever need for safety
+      mesh_index_to_Y_location[i] = double(UBL_MESH_MIN_Y) + double(MESH_Y_DIST) * double(i);
+
+    reset();
+  }
+
+  void bed_leveling::store_state() {
+    int k = E2END - sizeof(blm.state);
+    eeprom_write_block((void *)&blm.state, (void *)k, sizeof(blm.state));
+  }
+
+  void bed_leveling::load_state() {
+    int k = E2END - sizeof(blm.state);
+    eeprom_read_block((void *)&blm.state, (void *)k, sizeof(blm.state));
+
+    if (sanity_check())
+      SERIAL_PROTOCOLLNPGM("?In load_state() sanity_check() failed.\n");
+
+    // These lines can go away in a few weeks.  They are just
+    // to make sure people updating thier firmware won't be using
+    if (blm.state.G29_Fade_Height_Multiplier != 1.0 / blm.state.G29_Correction_Fade_Height) { // an incomplete Bed_Leveling.state structure. For speed
+      blm.state.G29_Fade_Height_Multiplier = 1.0 / blm.state.G29_Correction_Fade_Height;      // we now multiply by the inverse of the Fade Height instead of
+      store_state();   // dividing by it. Soon... all of the old structures will be
+    }                  // updated, but until then, we try to ease the transition
+                       // for our Beta testers.
+  }
+
+  void bed_leveling::load_mesh(int m) {
+    int k = E2END - sizeof(blm.state),
+        j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values);
+
+    if (m == -1) {
+      SERIAL_PROTOCOLLNPGM("?No mesh saved in EEPROM. Zeroing mesh in memory.\n");
+      reset();
+      return;
+    }
+
+    if (m < 0 || m >= j || Unified_Bed_Leveling_EEPROM_start <= 0) {
+      SERIAL_PROTOCOLLNPGM("?EEPROM storage not available to load mesh.\n");
+      return;
+    }
+
+    j = k - (m + 1) * sizeof(z_values);
+    eeprom_read_block((void *)&z_values , (void *)j, sizeof(z_values));
+
+    SERIAL_PROTOCOLPGM("Mesh loaded from slot ");
+    SERIAL_PROTOCOL(m);
+    SERIAL_PROTOCOLPGM("  at offset 0x");
+    prt_hex_word(j);
+    SERIAL_EOL;
+  }
+
+  void bed_leveling:: store_mesh(int m) {
+    int k = E2END - sizeof(state),
+        j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values);
+
+    if (m < 0 || m >= j || Unified_Bed_Leveling_EEPROM_start <= 0) {
+      SERIAL_PROTOCOLLNPGM("?EEPROM storage not available to load mesh.\n");
+      SERIAL_PROTOCOL(m);
+      SERIAL_PROTOCOLLNPGM(" mesh slots available.\n");
+      SERIAL_PROTOCOLLNPAIR("E2END     : ", E2END);
+      SERIAL_PROTOCOLLNPAIR("k         : ", k);
+      SERIAL_PROTOCOLLNPAIR("j         : ", j);
+      SERIAL_PROTOCOLLNPAIR("m         : ", m);
+      SERIAL_EOL;
+      return;
+    }
+
+    j = k - (m + 1) * sizeof(z_values);
+    eeprom_write_block((const void *)&z_values, (void *)j, sizeof(z_values));
+
+    SERIAL_PROTOCOLPGM("Mesh saved in slot ");
+    SERIAL_PROTOCOL(m);
+    SERIAL_PROTOCOLPGM("  at offset 0x");
+    prt_hex_word(j);
+    SERIAL_EOL;
+  }
+
+  void bed_leveling::reset() {
+    state.active = false;
+    state.z_offset = 0;
+    state.EEPROM_storage_slot = -1;
+
+    ZERO(z_values);
+
+    last_specified_z = -999.9;        // We can't pre-initialize these values in the declaration
+    fade_scaling_factor_for_current_height = 0.0; // due to C++11 constraints
+  }
+
+  void bed_leveling::invalidate() {
+    prt_hex_word((unsigned int)this);
+    SERIAL_EOL;
+
+    state.active = false;
+    state.z_offset = 0;
+    for (int x = 0; x < UBL_MESH_NUM_X_POINTS; x++)
+      for (int y = 0; y < UBL_MESH_NUM_Y_POINTS; y++)
+        z_values[x][y] = NAN;
+  }
+
+  void bed_leveling::display_map(int map_type) {
+    float f, current_xi, current_yi;
+    int8_t i, j;
+    UNUSED(map_type);
+
+    SERIAL_PROTOCOLLNPGM("\nBed Topography Report:\n");
+
+    SERIAL_ECHOPAIR("(", 0);
+    SERIAL_ECHOPAIR(", ", UBL_MESH_NUM_Y_POINTS - 1);
+    SERIAL_ECHOPGM(")    ");
+
+    current_xi = blm.get_cell_index_x(current_position[X_AXIS] + (MESH_X_DIST) / 2.0);
+    current_yi = blm.get_cell_index_y(current_position[Y_AXIS] + (MESH_Y_DIST) / 2.0);
+
+    for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++)
+      SERIAL_ECHOPGM("                 ");
+
+    SERIAL_ECHOPAIR("(", UBL_MESH_NUM_X_POINTS - 1);
+    SERIAL_ECHOPAIR(",", UBL_MESH_NUM_Y_POINTS - 1);
+    SERIAL_ECHOLNPGM(")");
+
+    //  if (map_type || 1) {
+    SERIAL_ECHOPAIR("(", UBL_MESH_MIN_X);
+    SERIAL_ECHOPAIR(",", UBL_MESH_MAX_Y);
+    SERIAL_CHAR(')');
+
+    for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++)
+      SERIAL_ECHOPGM("                 ");
+
+    SERIAL_ECHOPAIR("(", UBL_MESH_MAX_X);
+    SERIAL_ECHOPAIR(",", UBL_MESH_MAX_Y);
+    SERIAL_ECHOLNPGM(")");
+    //  }
+
+    for (j = UBL_MESH_NUM_Y_POINTS - 1; j >= 0; j--) {
+      for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) {
+        f = z_values[i][j];
+
+        // is the nozzle here?  if so, mark the number
+        SERIAL_CHAR(i == current_xi && j == current_yi ? '[' : ' ');
+
+        if (isnan(f))
+          SERIAL_PROTOCOLPGM("      .       ");
+        else {
+          // if we don't do this, the columns won't line up nicely
+          if (f >= 0.0) SERIAL_CHAR(' ');
+          SERIAL_PROTOCOL_F(f, 5);
+          idle();
+        }
+        if (i == current_xi && j == current_yi) // is the nozzle here? if so, finish marking the number
+          SERIAL_CHAR(']');
+        else
+          SERIAL_PROTOCOL("  ");
+
+        SERIAL_CHAR(' ');
+      }
+      SERIAL_EOL;
+      if (j) { // we want the (0,0) up tight against the block of numbers
+        SERIAL_CHAR(' ');
+        SERIAL_EOL;
+      }
+    }
+
+    //  if (map_type) {
+    SERIAL_ECHOPAIR("(", int(UBL_MESH_MIN_X));
+    SERIAL_ECHOPAIR(",", int(UBL_MESH_MIN_Y));
+    SERIAL_ECHOPGM(")    ");
+
+    for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++)
+      SERIAL_ECHOPGM("                 ");
+
+    SERIAL_ECHOPAIR("(", int(UBL_MESH_MAX_X));
+    SERIAL_ECHOPAIR(",", int(UBL_MESH_MIN_Y));
+    SERIAL_CHAR(')');
+    //  }
+
+    SERIAL_ECHOPAIR("(", 0);
+    SERIAL_ECHOPAIR(",", 0);
+    SERIAL_ECHOPGM(")       ");
+
+    for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++)
+      SERIAL_ECHOPGM("                 ");
+
+    SERIAL_ECHOPAIR("(", UBL_MESH_NUM_X_POINTS-1);
+    SERIAL_ECHOPAIR(",", 0);
+    SERIAL_CHAR(')');
+
+    SERIAL_CHAR(' ');
+    SERIAL_EOL;
+  }
+
+  bool bed_leveling::sanity_check() {
+    uint8_t error_flag = 0;
+
+    if (state.n_x !=  UBL_MESH_NUM_X_POINTS)  {
+      SERIAL_PROTOCOLLNPGM("?UBL_MESH_NUM_X_POINTS set wrong\n");
+      error_flag++;
+    }
+
+    if (state.n_y !=  UBL_MESH_NUM_Y_POINTS)  {
+      SERIAL_PROTOCOLLNPGM("?UBL_MESH_NUM_Y_POINTS set wrong\n");
+      error_flag++;
+    }
+
+    if (state.mesh_x_min !=  UBL_MESH_MIN_X)  {
+      SERIAL_PROTOCOLLNPGM("?UBL_MESH_MIN_X set wrong\n");
+      error_flag++;
+    }
+
+    if (state.mesh_y_min !=  UBL_MESH_MIN_Y)  {
+      SERIAL_PROTOCOLLNPGM("?UBL_MESH_MIN_Y set wrong\n");
+      error_flag++;
+    }
+
+    if (state.mesh_x_max !=  UBL_MESH_MAX_X)  {
+      SERIAL_PROTOCOLLNPGM("?UBL_MESH_MAX_X set wrong\n");
+      error_flag++;
+    }
+
+    if (state.mesh_y_max !=  UBL_MESH_MAX_Y)  {
+      SERIAL_PROTOCOLLNPGM("?UBL_MESH_MAX_Y set wrong\n");
+      error_flag++;
+    }
+
+    if (state.mesh_x_dist !=  MESH_X_DIST)  {
+      SERIAL_PROTOCOLLNPGM("?MESH_X_DIST set wrong\n");
+      error_flag++;
+    }
+
+    if (state.mesh_y_dist !=  MESH_Y_DIST)  {
+      SERIAL_PROTOCOLLNPGM("?MESH_Y_DIST set wrong\n");
+      error_flag++;
+    }
+
+    int k = E2END - sizeof(blm.state),
+        j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values);
+
+    if (j < 1) {
+      SERIAL_PROTOCOLLNPGM("?No EEPROM storage available for a mesh of this size.\n");
+      error_flag++;
+    }
+
+    //  SERIAL_PROTOCOLPGM("?sanity_check() return value: ");
+    //  SERIAL_PROTOCOL(error_flag);
+    //  SERIAL_EOL;
+
+    return !!error_flag;
+  }
+
+#endif // AUTO_BED_LEVELING_UBL

Marlin/UBL_line_to_destination.cpp

@@ -0,0 +1,553 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#include "Marlin.h"
+
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+
+  #include "UBL.h"
+  #include "planner.h"
+  #include <avr/io.h>
+  #include <math.h>
+
+  extern void set_current_to_destination();
+  extern bool G26_Debug_flag;
+  void debug_current_and_destination(char *title);
+
+  void wait_for_button_press();
+
+  void UBL_line_to_destination(const float &x_end, const float &y_end, const float &z_end, const float &e_end, const float &feed_rate, uint8_t extruder) {
+
+    int cell_start_xi, cell_start_yi, cell_dest_xi, cell_dest_yi;
+    int left_flag, down_flag;
+    int current_xi, current_yi;
+    int dxi, dyi, xi_cnt, yi_cnt;
+    bool use_X_dist, inf_normalized_flag, inf_m_flag;
+    float x_start, y_start;
+    float x, y, z1, z2, z0 /*, z_optimized */;
+    float next_mesh_line_x, next_mesh_line_y, a0ma1diva2ma1;
+    float on_axis_distance, e_normalized_dist, e_position, e_start, z_normalized_dist, z_position, z_start;
+    float dx, dy, adx, ady, m, c;
+
+    //
+    // Much of the nozzle movement will be within the same cell.  So we will do as little computation
+    // as possible to determine if this is the case.  If this move is within the same cell, we will
+    // just do the required Z-Height correction, call the Planner's buffer_line() routine, and leave
+    //
+
+    x_start = current_position[X_AXIS];
+    y_start = current_position[Y_AXIS];
+    z_start = current_position[Z_AXIS];
+    e_start = current_position[E_AXIS];
+
+    cell_start_xi = blm.get_cell_index_x(x_start);
+    cell_start_yi = blm.get_cell_index_y(y_start);
+    cell_dest_xi  = blm.get_cell_index_x(x_end);
+    cell_dest_yi  = blm.get_cell_index_y(y_end);
+
+    if (G26_Debug_flag!=0) {
+      SERIAL_ECHOPGM(" UBL_line_to_destination(xe=");
+      SERIAL_ECHO(x_end);
+      SERIAL_ECHOPGM(",ye=");
+      SERIAL_ECHO(y_end);
+      SERIAL_ECHOPGM(",ze=");
+      SERIAL_ECHO(z_end);
+      SERIAL_ECHOPGM(",ee=");
+      SERIAL_ECHO(e_end);
+      SERIAL_ECHOPGM(")\n");
+      debug_current_and_destination( (char *) "Start of UBL_line_to_destination()");
+    }
+
+    if ((cell_start_xi == cell_dest_xi) && (cell_start_yi == cell_dest_yi)) { // if the whole move is within the same cell,
+      // we don't need to break up the move
+      //
+      // If we are moving off the print bed, we are going to allow the move at this level.
+      // But we detect it and isolate it.   For now, we just pass along the request.
+      //
+
+      if (cell_dest_xi<0 || cell_dest_yi<0 || cell_dest_xi >= UBL_MESH_NUM_X_POINTS || cell_dest_yi >= UBL_MESH_NUM_Y_POINTS) {
+
+        // Note:  There is no Z Correction in this case.  We are off the grid and don't know what
+        // a reasonable correction would be.
+
+        planner.buffer_line(x_end, y_end, z_end + blm.state.z_offset, e_end, feed_rate, extruder);
+        set_current_to_destination();
+        if (G26_Debug_flag!=0) {
+          debug_current_and_destination( (char *) "out of bounds in UBL_line_to_destination()");
+        }
+        return;
+      }
+
+      // we can optimize some floating point operations here.  We could call float get_z_correction(float x0, float y0) to
+      // generate the correction for us.  But we can lighten the load on the CPU by doing a modified version of the function.
+      // We are going to only calculate the amount we are from the first mesh line towards the second mesh line once.
+      // We will use this fraction in both of the original two Z Height calculations for the bi-linear interpolation.  And,
+      // instead of doing a generic divide of the distance, we know the distance is MESH_X_DIST so we can use the preprocessor
+      // to create a 1-over number for us.  That will allow us to do a floating point multiply instead of a floating point divide.
+
+      FINAL_MOVE:
+      a0ma1diva2ma1 = (x_end - mesh_index_to_X_location[cell_dest_xi]) * (float) (1.0 / MESH_X_DIST);
+
+      z1 = z_values[cell_dest_xi][cell_dest_yi] +
+      (z_values[cell_dest_xi + 1][cell_dest_yi] - z_values[cell_dest_xi][cell_dest_yi]) * a0ma1diva2ma1;
+
+      z2 = z_values[cell_dest_xi][cell_dest_yi+1] +
+      (z_values[cell_dest_xi+1][cell_dest_yi+1] - z_values[cell_dest_xi][cell_dest_yi+1]) * a0ma1diva2ma1;
+
+      // we are done with the fractional X distance into the cell.  Now with the two Z-Heights we have calculated, we
+      // are going to apply the Y-Distance into the cell to interpolate the final Z correction.
+
+      a0ma1diva2ma1 = (y_end - mesh_index_to_Y_location[cell_dest_yi]) * (float) (1.0 / MESH_Y_DIST);
+
+      z0 = z1 + (z2 - z1) * a0ma1diva2ma1;
+
+      // debug code to use non-optimized get_z_correction() and to do a sanity check
+      // that the correct value is being passed to planner.buffer_line()
+      //
+      /*
+        z_optimized = z0;
+        z0 = blm.get_z_correction( x_end, y_end);
+        if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) )  {
+        debug_current_and_destination( (char *) "FINAL_MOVE: z_correction()");
+        if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN  ");
+        if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN  ");
+        SERIAL_ECHOPAIR("  x_end=", x_end);
+        SERIAL_ECHOPAIR("  y_end=", y_end);
+        SERIAL_ECHOPAIR("  z0=", z0);
+        SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
+        SERIAL_ECHOPAIR("  err=",fabs(z_optimized - z0));
+        SERIAL_EOL;
+        }
+      */
+      z0 = z0 * blm.fade_scaling_factor_for_Z( z_end );
+
+      if (isnan(z0)) {  // if part of the Mesh is undefined, it will show up as NAN
+        z0 = 0.0; // in z_values[][] and propagate through the
+        // calculations. If our correction is NAN, we throw it out
+        // because part of the Mesh is undefined and we don't have the
+        // information we need to complete the height correction.
+      }
+
+      planner.buffer_line(x_end, y_end, z_end + z0 + blm.state.z_offset, e_end, feed_rate, extruder);
+      if (G26_Debug_flag!=0) {
+        debug_current_and_destination( (char *) "FINAL_MOVE in UBL_line_to_destination()");
+      }
+      set_current_to_destination();
+      return;
+    }
+
+    //
+    //  If we get here, we are processing a move that crosses at least one Mesh Line.   We will check
+    //  for the simple case of just crossing X or just crossing Y Mesh Lines after we get all the details
+    //  of the move figured out.  We can process the easy case of just crossing an X or Y Mesh Line with less
+    //  computation and in fact most lines are of this nature.  We will check for that in the following
+    //  blocks of code:
+
+    left_flag = 0;
+    down_flag = 0;
+    inf_m_flag = false;
+    inf_normalized_flag = false;
+
+    dx = x_end - x_start;
+    dy = y_end - y_start;
+
+    if (dx<0.0) {     // figure out which way we need to move to get to the next cell
+      dxi = -1;
+      adx = -dx;  // absolute value of dx.  We already need to check if dx and dy are negative.
+    }
+    else {   // We may as well generate the appropriate values for adx and ady right now
+      dxi = 1;  // to save setting up the abs() function call and actually doing the call.
+      adx = dx;
+    }
+    if (dy<0.0) {
+      dyi = -1;
+      ady = -dy;  // absolute value of dy
+    }
+    else {
+      dyi = 1;
+      ady = dy;
+    }
+
+    if (dx<0.0) left_flag = 1;
+    if (dy<0.0) down_flag = 1;
+    if (cell_start_xi == cell_dest_xi) dxi = 0;
+    if (cell_start_yi == cell_dest_yi) dyi = 0;
+
+    //
+    // Compute the scaling factor for the extruder for each partial move.
+    // We need to watch out for zero length moves because it will cause us to
+    // have an infinate scaling factor.  We are stuck doing a floating point
+    // divide to get our scaling factor, but after that, we just multiply by this
+    // number.   We also pick our scaling factor based on whether the X or Y
+    // component is larger.  We use the biggest of the two to preserve precision.
+    //
+    if ( adx > ady ) {
+      use_X_dist = true;
+      on_axis_distance   = x_end-x_start;
+    }
+    else {
+      use_X_dist = false;
+      on_axis_distance   = y_end-y_start;
+    }
+    e_position = e_end - e_start;
+    e_normalized_dist = e_position / on_axis_distance;
+
+    z_position = z_end - z_start;
+    z_normalized_dist = z_position / on_axis_distance;
+
+    if (e_normalized_dist==INFINITY || e_normalized_dist==-INFINITY) {
+      inf_normalized_flag = true;
+    }
+    current_xi = cell_start_xi;
+    current_yi = cell_start_yi;
+
+    m = dy / dx;
+    c = y_start - m*x_start;
+    if (m == INFINITY || m == -INFINITY) {
+      inf_m_flag = true;
+    }
+    //
+    // This block handles vertical lines.  These are lines that stay within the same
+    // X Cell column.  They do not need to be perfectly vertical.  They just can
+    // not cross into another X Cell column.
+    //
+    if (dxi == 0) {       // Check for a vertical line
+      current_yi += down_flag;  // Line is heading down, we just want to go to the bottom
+      while (current_yi != cell_dest_yi + down_flag) {
+        current_yi += dyi;
+        next_mesh_line_y = mesh_index_to_Y_location[current_yi];
+        if (inf_m_flag) {
+          x = x_start;  // if the slope of the line is infinite, we won't do the calculations
+        }
+        // we know the next X is the same so we can recover and continue!
+        else {
+          x = (next_mesh_line_y - c) / m; // Calculate X at the next Y mesh line
+        }
+
+        z0 = blm.get_z_correction_along_horizontal_mesh_line_at_specific_X(x, current_xi, current_yi);
+
+        //
+        // debug code to use non-optimized get_z_correction() and to do a sanity check
+        // that the correct value is being passed to planner.buffer_line()
+        //
+        /*
+          z_optimized = z0;
+          z0 = blm.get_z_correction( x, next_mesh_line_y);
+          if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) )  {
+          debug_current_and_destination( (char *) "VERTICAL z_correction()");
+          if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN  ");
+          if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN  ");
+          SERIAL_ECHOPAIR("  x=", x);
+          SERIAL_ECHOPAIR("  next_mesh_line_y=", next_mesh_line_y);
+          SERIAL_ECHOPAIR("  z0=", z0);
+          SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
+          SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
+          SERIAL_ECHO("\n");
+          }
+        */
+
+        z0 = z0 * blm.fade_scaling_factor_for_Z( z_end );
+
+        if (isnan(z0)) {  // if part of the Mesh is undefined, it will show up as NAN
+          z0 = 0.0; // in z_values[][] and propagate through the
+          // calculations. If our correction is NAN, we throw it out
+          // because part of the Mesh is undefined and we don't have the
+          // information we need to complete the height correction.
+        }
+        y = mesh_index_to_Y_location[current_yi];
+
+        // Without this check, it is possible for the algorythm to generate a zero length move in the case
+        // where the line is heading down and it is starting right on a Mesh Line boundary.  For how often that
+        // happens, it might be best to remove the check and always 'schedule' the move because
+        // the planner.buffer_line() routine will filter it if that happens.
+        if ( y!=y_start)   {
+          if ( inf_normalized_flag == false ) {
+            on_axis_distance   = y - y_start;       // we don't need to check if the extruder position
+            e_position = e_start + on_axis_distance * e_normalized_dist;  // is based on X or Y because this is a vertical move
+            z_position = z_start + on_axis_distance * z_normalized_dist;
+          }
+          else {
+            e_position = e_start;
+            z_position = z_start;
+          }
+
+          planner.buffer_line(x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder);
+        } //else printf("FIRST MOVE PRUNED  ");
+      }
+      //
+      // Check if we are at the final destination.  Usually, we won't be, but if it is on a Y Mesh Line, we are done.
+      //
+      if (G26_Debug_flag!=0) {
+        debug_current_and_destination( (char *) "vertical move done in UBL_line_to_destination()");
+      }
+      if (current_position[X_AXIS] != x_end || current_position[Y_AXIS] != y_end) {
+        goto FINAL_MOVE;
+      }
+      set_current_to_destination();
+      return;
+    }
+
+    //
+    // This block handles horizontal lines.  These are lines that stay within the same
+    // Y Cell row.  They do not need to be perfectly horizontal.  They just can
+    // not cross into another Y Cell row.
+    //
+
+    if (dyi == 0) {       // Check for a horiziontal line
+      current_xi += left_flag;  // Line is heading left, we just want to go to the left
+      // edge of this cell for the first move.
+      while (current_xi != cell_dest_xi + left_flag) {
+        current_xi += dxi;
+        next_mesh_line_x = mesh_index_to_X_location[current_xi];
+        y = m * next_mesh_line_x + c;   // Calculate X at the next Y mesh line
+
+        z0 = blm.get_z_correction_along_vertical_mesh_line_at_specific_Y(y, current_xi, current_yi);
+
+        //
+        // debug code to use non-optimized get_z_correction() and to do a sanity check
+        // that the correct value is being passed to planner.buffer_line()
+        //
+        /*
+          z_optimized = z0;
+          z0 = blm.get_z_correction( next_mesh_line_x, y);
+          if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) )  {
+          debug_current_and_destination( (char *) "HORIZONTAL z_correction()");
+          if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN  ");
+          if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN  ");
+          SERIAL_ECHOPAIR("  next_mesh_line_x=", next_mesh_line_x);
+          SERIAL_ECHOPAIR("  y=", y);
+          SERIAL_ECHOPAIR("  z0=", z0);
+          SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
+          SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
+          SERIAL_ECHO("\n");
+          }
+        */
+
+        z0 = z0 * blm.fade_scaling_factor_for_Z( z_end );
+
+        if (isnan(z0)) {  // if part of the Mesh is undefined, it will show up as NAN
+          z0 = 0.0; // in z_values[][] and propagate through the
+          // calculations. If our correction is NAN, we throw it out
+          // because part of the Mesh is undefined and we don't have the
+          // information we need to complete the height correction.
+        }
+        x = mesh_index_to_X_location[current_xi];
+
+        // Without this check, it is possible for the algorythm to generate a zero length move in the case
+        // where the line is heading left and it is starting right on a Mesh Line boundary.  For how often
+        // that happens, it might be best to remove the check and always 'schedule' the move because
+        // the planner.buffer_line() routine will filter it if that happens.
+        if ( x!=x_start)   {
+          if ( inf_normalized_flag == false ) {
+            on_axis_distance   = x - x_start;       // we don't need to check if the extruder position
+            e_position = e_start + on_axis_distance * e_normalized_dist;  // is based on X or Y because this is a horizontal move
+            z_position = z_start + on_axis_distance * z_normalized_dist;
+          }
+          else {
+            e_position = e_start;
+            z_position = z_start;
+          }
+
+          planner.buffer_line(x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder);
+        } //else printf("FIRST MOVE PRUNED  ");
+      }
+      if (G26_Debug_flag!=0) {
+        debug_current_and_destination( (char *) "horizontal move done in UBL_line_to_destination()");
+      }
+      if (current_position[X_AXIS] != x_end || current_position[Y_AXIS] != y_end) {
+        goto FINAL_MOVE;
+      }
+      set_current_to_destination();
+      return;
+    }
+
+    //
+    //
+    //
+    //
+    // This block handles the generic case of a line crossing both X and Y
+    // Mesh lines.
+    //
+    //
+    //
+    //
+
+    xi_cnt = cell_start_xi - cell_dest_xi;
+    if ( xi_cnt < 0 ) {
+      xi_cnt = -xi_cnt;
+    }
+
+    yi_cnt = cell_start_yi - cell_dest_yi;
+    if ( yi_cnt < 0 ) {
+      yi_cnt = -yi_cnt;
+    }
+
+    current_xi += left_flag;
+    current_yi += down_flag;
+
+    while ( xi_cnt>0 || yi_cnt>0 )    {
+
+      next_mesh_line_x = mesh_index_to_X_location[current_xi + dxi];
+      next_mesh_line_y = mesh_index_to_Y_location[current_yi + dyi];
+
+      y = m * next_mesh_line_x + c; // Calculate Y at the next X mesh line
+      x = (next_mesh_line_y-c) / m; // Calculate X at the next Y mesh line    (we don't have to worry
+      // about m being equal to 0.0  If this was the case, we would have
+      // detected this as a vertical line move up above and we wouldn't
+      // be down here doing a generic type of move.
+
+      if ((left_flag && (x>next_mesh_line_x)) || (!left_flag && (x<next_mesh_line_x))) { // Check if we hit the Y line first
+        //
+        // Yes!  Crossing a Y Mesh Line next
+        //
+        z0 = blm.get_z_correction_along_horizontal_mesh_line_at_specific_X(x, current_xi-left_flag, current_yi+dyi);
+
+        //
+        // debug code to use non-optimized get_z_correction() and to do a sanity check
+        // that the correct value is being passed to planner.buffer_line()
+        //
+
+        /*
+
+          z_optimized = z0;
+
+          z0 = blm.get_z_correction( x, next_mesh_line_y);
+          if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) )  {
+            debug_current_and_destination( (char *) "General_1: z_correction()");
+            if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN  ");
+            if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN  "); {
+              SERIAL_ECHOPAIR("  x=", x);
+            }
+            SERIAL_ECHOPAIR("  next_mesh_line_y=", next_mesh_line_y);
+            SERIAL_ECHOPAIR("  z0=", z0);
+            SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
+            SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
+            SERIAL_ECHO("\n");
+          }
+        */
+
+        z0 = z0 * blm.fade_scaling_factor_for_Z( z_end );
+        if (isnan(z0)) {  // if part of the Mesh is undefined, it will show up as NAN
+          z0 = 0.0; // in z_values[][] and propagate through the
+          // calculations. If our correction is NAN, we throw it out
+          // because part of the Mesh is undefined and we don't have the
+          // information we need to complete the height correction.
+        }
+
+        if ( inf_normalized_flag == false ) {
+          if ( use_X_dist ) {
+            on_axis_distance   = x - x_start;
+          }
+          else {
+            on_axis_distance   = next_mesh_line_y - y_start;
+          }
+          e_position = e_start + on_axis_distance * e_normalized_dist;
+          z_position = z_start + on_axis_distance * z_normalized_dist;
+        }
+        else {
+          e_position = e_start;
+          z_position = z_start;
+        }
+        planner.buffer_line(x, next_mesh_line_y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder);
+        current_yi += dyi;
+        yi_cnt--;
+      }
+      else {
+        //
+        // Yes!  Crossing a X Mesh Line next
+        //
+        z0 = blm.get_z_correction_along_vertical_mesh_line_at_specific_Y(y, current_xi+dxi, current_yi-down_flag);
+
+
+        //
+        // debug code to use non-optimized get_z_correction() and to do a sanity check
+        // that the correct value is being passed to planner.buffer_line()
+        //
+        /*
+          z_optimized = z0;
+          z0 = blm.get_z_correction( next_mesh_line_x, y);
+          if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) )  {
+          debug_current_and_destination( (char *) "General_2: z_correction()");
+          if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN  ");
+          if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN  ");
+          SERIAL_ECHOPAIR("  next_mesh_line_x=", next_mesh_line_x);
+          SERIAL_ECHOPAIR("  y=", y);
+          SERIAL_ECHOPAIR("  z0=", z0);
+          SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
+          SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
+          SERIAL_ECHO("\n");
+          }
+        */
+
+        z0 = z0 * blm.fade_scaling_factor_for_Z( z_end );
+
+        if (isnan(z0)) {  // if part of the Mesh is undefined, it will show up as NAN
+          z0 = 0.0; // in z_values[][] and propagate through the
+          // calculations. If our correction is NAN, we throw it out
+          // because part of the Mesh is undefined and we don't have the
+          // information we need to complete the height correction.
+        }
+        if ( inf_normalized_flag == false ) {
+          if ( use_X_dist ) {
+            on_axis_distance   = next_mesh_line_x - x_start;
+          }
+          else {
+            on_axis_distance   = y - y_start;
+          }
+          e_position = e_start + on_axis_distance * e_normalized_dist;
+          z_position = z_start + on_axis_distance * z_normalized_dist;
+        }
+        else {
+          e_position = e_start;
+          z_position = z_start;
+        }
+
+        planner.buffer_line(next_mesh_line_x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder);
+        current_xi += dxi;
+        xi_cnt--;
+      }
+    }
+    if (G26_Debug_flag) {
+      debug_current_and_destination( (char *) "generic move done in UBL_line_to_destination()");
+    }
+    if (current_position[0] != x_end || current_position[1] != y_end)  {
+      goto FINAL_MOVE;
+    }
+    set_current_to_destination();
+    return;
+  }
+
+  void wait_for_button_press() {
+    //  if ( !been_to_2_6 )
+    //return;   // bob - I think this should be commented out
+
+    SET_INPUT_PULLUP(66); // Roxy's Left Switch is on pin 66.  Right Switch is on pin 65
+    SET_OUTPUT(64);
+    while (READ(66) & 0x01) idle();
+
+    delay(50);
+    while (!(READ(66) & 0x01)) idle();
+    delay(50);
+  }
+
+#endif
+
+

Marlin/hex_print_routines.cpp

@@ -0,0 +1,47 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#include "Marlin.h"
+#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER)
+
+#include "hex_print_routines.h"
+
+void prt_hex_nibble(uint8_t n) {
+  if (n <= 9)
+    SERIAL_ECHO(n);
+  else
+    SERIAL_ECHO((char)('A' + n - 10));
+  delay(3);
+}
+
+void prt_hex_byte(uint8_t b) {
+  prt_hex_nibble((b & 0xF0) >> 4);
+  prt_hex_nibble(b & 0x0F);
+}
+
+void prt_hex_word(uint16_t w) {
+  prt_hex_byte((w & 0xFF00) >> 8);
+  prt_hex_byte(w & 0x0FF);
+}
+
+#endif // AUTO_BED_LEVELING_UBL || M100_FREE_MEMORY_WATCHER

Marlin/hex_print_routines.h

@@ -0,0 +1,33 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HEX_PRINT_ROUTINES_H
+#define HEX_PRINT_ROUTINES_H
+
+//
+// 3 support routines to print hex numbers.  We can print a nibble, byte and word
+//
+void prt_hex_nibble(uint8_t n);
+void prt_hex_byte(uint8_t b);
+void prt_hex_word(uint16_t w);
+
+#endif // HEX_PRINT_ROUTINES_H