Update - new mesh set

Author: classicrocker883

Marlin/src/feature/bedlevel/abl/bbl.cpp

@@ -38,10 +38,10 @@
 LevelingBilinear bedlevel;
 
 xy_float_t LevelingBilinear::grid_factor;
-xy_pos_t LevelingBilinear::grid_spacing,
-         LevelingBilinear::grid_start,
-         LevelingBilinear::cached_rel;
-xy_int8_t LevelingBilinear::cached_g;
+xy_pos_t   LevelingBilinear::grid_spacing,
+           LevelingBilinear::grid_start,
+           LevelingBilinear::cached_rel;
+xy_int8_t  LevelingBilinear::cached_g;
 bed_mesh_t LevelingBilinear::z_values;
 
 /**
@@ -110,17 +110,14 @@ void LevelingBilinear::reset() {
  * Set grid spacing and start position
  */
 void LevelingBilinear::set_grid(const xy_pos_t& _grid_spacing, const xy_pos_t& _grid_start) {
-#if ENABLED(PROUI_MESH_EDIT)
-  UNUSED(_grid_spacing);
-  UNUSED(_grid_start);
-  grid_spacing.x = MESH_X_DIST;
-  grid_spacing.y = MESH_Y_DIST;
-  grid_start.x = MESH_MIN_X;
-  grid_start.y = MESH_MIN_Y;
-#else
-  grid_spacing = _grid_spacing;
-  grid_start = _grid_start;
-#endif
+  #if ENABLED(PROUI_MESH_EDIT)
+    UNUSED(_grid_spacing); UNUSED(_grid_start);
+    grid_start = mesh_min;
+    grid_spacing.set(MESH_X_DIST, MESH_Y_DIST);
+  #else
+    grid_spacing = _grid_spacing;
+    grid_start = _grid_start;
+  #endif
   grid_factor = grid_spacing.reciprocal();
 }
 

Marlin/src/feature/bedlevel/abl/bbl.h

@@ -24,8 +24,8 @@
 #include "../../../inc/MarlinConfigPre.h"
 
 #if ENABLED(PROUI_MESH_EDIT)
-  #define MESH_X_DIST (float((MESH_MAX_X) - (MESH_MIN_X)) / (GRID_MAX_CELLS_X))
-  #define MESH_Y_DIST (float((MESH_MAX_Y) - (MESH_MIN_Y)) / (GRID_MAX_CELLS_Y))
+  #define MESH_X_DIST ((mesh_max.x - mesh_min.x) / (GRID_MAX_CELLS_X))
+  #define MESH_Y_DIST ((mesh_max.y - mesh_min.y) / (GRID_MAX_CELLS_Y))
 #endif
 
 class LevelingBilinear {

Marlin/src/feature/bedlevel/bedlevel.cpp

@@ -51,11 +51,13 @@
 #endif
 
 bool leveling_is_valid() {
-  #if ALL(HAS_MESH, DWIN_LCD_PROUI)
-    return bedLevelTools.meshValidate();
-  #else
-    return TERN1(HAS_MESH, bedlevel.mesh_is_valid());
-  #endif
+  return (
+    #if ALL(HAS_MESH, DWIN_LCD_PROUI)
+      bedLevelTools.meshValidate()
+    #else
+      TERN1(HAS_MESH, bedlevel.mesh_is_valid())
+    #endif
+  );
 }
 
 /**

Marlin/src/feature/bedlevel/hilbert_curve.cpp

@@ -111,8 +111,8 @@ bool hilbert_curve::search_from(uint8_t x, uint8_t y, hilbert_curve::callback_pt
  */
 bool hilbert_curve::search_from_closest(const xy_pos_t &pos, hilbert_curve::callback_ptr func, void *data) {
   // Find closest grid intersection
-  const uint8_t grid_x = LROUND(constrain(float(pos.x - (MESH_MIN_X)) / (MESH_X_DIST), 0, (GRID_MAX_POINTS_X) - 1));
-  const uint8_t grid_y = LROUND(constrain(float(pos.y - (MESH_MIN_Y)) / (MESH_Y_DIST), 0, (GRID_MAX_POINTS_Y) - 1));
+  const uint8_t grid_x = LROUND(constrain((pos.x - mesh_min.x) / (MESH_X_DIST), 0, (GRID_MAX_POINTS_X) - 1));
+  const uint8_t grid_y = LROUND(constrain((pos.y - mesh_min.y) / (MESH_Y_DIST), 0, (GRID_MAX_POINTS_Y) - 1));
   return search_from(grid_x, grid_y, func, data);
 }
 

Marlin/src/feature/bedlevel/mbl/mesh_bed_leveling.cpp

@@ -26,8 +26,6 @@
 
   #include "../bedlevel.h"
 
-  #include "../../../module/motion.h"
-
   #if ENABLED(EXTENSIBLE_UI)
     #include "../../../lcd/extui/ui_api.h"
   #endif
@@ -46,19 +44,11 @@
 
   mesh_bed_leveling::mesh_bed_leveling() { initialize(); }
 
-  void mesh_bed_leveling::reset() {
-    z_offset = 0;
-    ZERO(z_values);
-    #if ENABLED(EXTENSIBLE_UI)
-      GRID_LOOP(x, y) ExtUI::onMeshUpdate(x, y, 0);
-    #endif
-  }
-
   void mesh_bed_leveling::initialize() {
     for (uint8_t i = 0; i < GRID_MAX_POINTS_X; ++i)
-      index_to_xpos[i] = MESH_MIN_X + i * (MESH_X_DIST);
+      index_to_xpos[i] = mesh_min.x + i * (MESH_X_DIST);
     for (uint8_t j = 0; j < GRID_MAX_POINTS_Y; ++j)
-      index_to_ypos[j] = MESH_MIN_Y + j * (MESH_Y_DIST);
+      index_to_ypos[j] = mesh_min.y + j * (MESH_Y_DIST);
     reset();
   }
 
@@ -67,6 +57,14 @@
     print_2d_array(GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y, 5, z_values[0]);
   }
 
+  void mesh_bed_leveling::reset() {
+    z_offset = 0;
+    ZERO(z_values);
+    #if ENABLED(EXTENSIBLE_UI)
+      GRID_LOOP(x, y) ExtUI::onMeshUpdate(x, y, 0);
+    #endif
+  }
+
   #if IS_CARTESIAN && DISABLED(SEGMENT_LEVELED_MOVES)
 
     /**

Marlin/src/feature/bedlevel/mbl/mesh_bed_leveling.h

@@ -23,6 +23,8 @@
 
 #include "../../../inc/MarlinConfig.h"
 
+#include "../../../module/motion.h"
+
 enum MeshLevelingState : char {
   MeshReport,     // G29 S0
   MeshStart,      // G29 S1
@@ -32,8 +34,8 @@ enum MeshLevelingState : char {
   MeshReset       // G29 S5
 };
 
-#define MESH_X_DIST (float((MESH_MAX_X) - (MESH_MIN_X)) / (GRID_MAX_CELLS_X))
-#define MESH_Y_DIST (float((MESH_MAX_Y) - (MESH_MIN_Y)) / (GRID_MAX_CELLS_Y))
+#define MESH_X_DIST ((mesh_max.x - mesh_min.x) / (GRID_MAX_CELLS_X))
+#define MESH_Y_DIST ((mesh_max.y - mesh_min.y) / (GRID_MAX_CELLS_Y))
 
 class mesh_bed_leveling {
 public:
@@ -50,12 +52,12 @@ class mesh_bed_leveling {
 
   mesh_bed_leveling();
 
-  static void reset();
-
   static void initialize();
 
   static void report_mesh();
 
+  static void reset();
+
   FORCE_INLINE static bool has_mesh() {
     GRID_LOOP(x, y) if (z_values[x][y]) return true;
     return false;
@@ -81,11 +83,11 @@ class mesh_bed_leveling {
   static float get_mesh_y(const uint8_t j) { return index_to_ypos[j]; }
 
   static uint8_t cell_index_x(const float x) {
-    int8_t cx = (x - (MESH_MIN_X)) * RECIPROCAL(MESH_X_DIST);
+    int8_t cx = (x - mesh_min.x) * RECIPROCAL(MESH_X_DIST);
     return constrain(cx, 0, GRID_MAX_CELLS_X - 1);
   }
   static uint8_t cell_index_y(const float y) {
-    int8_t cy = (y - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST);
+    int8_t cy = (y - mesh_min.y) * RECIPROCAL(MESH_Y_DIST);
     return constrain(cy, 0, GRID_MAX_CELLS_Y - 1);
   }
   static xy_uint8_t cell_indexes(const float x, const float y) {
@@ -94,11 +96,11 @@ class mesh_bed_leveling {
   static xy_uint8_t cell_indexes(const xy_pos_t &xy) { return cell_indexes(xy.x, xy.y); }
 
   static int8_t probe_index_x(const float x) {
-    int8_t px = (x - (MESH_MIN_X) + 0.5f * (MESH_X_DIST)) * RECIPROCAL(MESH_X_DIST);
+    int8_t px = (x - mesh_min.x + 0.5f * (MESH_X_DIST)) * RECIPROCAL(MESH_X_DIST);
     return WITHIN(px, 0, (GRID_MAX_POINTS_X) - 1) ? px : -1;
   }
   static int8_t probe_index_y(const float y) {
-    int8_t py = (y - (MESH_MIN_Y) + 0.5f * (MESH_Y_DIST)) * RECIPROCAL(MESH_Y_DIST);
+    int8_t py = (y - mesh_min.y + 0.5f * (MESH_Y_DIST)) * RECIPROCAL(MESH_Y_DIST);
     return WITHIN(py, 0, (GRID_MAX_POINTS_Y) - 1) ? py : -1;
   }
   static xy_int8_t probe_indexes(const float x, const float y) {

Marlin/src/feature/bedlevel/ubl/ubl.cpp

@@ -177,8 +177,8 @@ void unified_bed_leveling::display_map(const uint8_t map_type) {
   SERIAL_ECHOPGM("\nBed Topography Report");
   if (human) {
     SERIAL_ECHOLNPGM(":\n");
-    serial_echo_xy(4, MESH_MIN_X, MESH_MAX_Y);
-    serial_echo_xy(twixt, MESH_MAX_X, MESH_MAX_Y);
+    serial_echo_xy(4, mesh_min.x, mesh_max.y);
+    serial_echo_xy(twixt, mesh_max.x, mesh_max.y);
     SERIAL_EOL();
     serial_echo_column_labels(eachsp - 2);
   }
@@ -236,8 +236,8 @@ void unified_bed_leveling::display_map(const uint8_t map_type) {
   if (human) {
     serial_echo_column_labels(eachsp - 2);
     SERIAL_EOL();
-    serial_echo_xy(4, MESH_MIN_X, MESH_MIN_Y);
-    serial_echo_xy(twixt, MESH_MAX_X, MESH_MIN_Y);
+    serial_echo_xy(4, mesh_min.x, mesh_min.y);
+    serial_echo_xy(twixt, mesh_max.x, mesh_min.y);
     SERIAL_EOL();
     SERIAL_EOL();
   }

Marlin/src/feature/bedlevel/ubl/ubl.h

@@ -38,8 +38,8 @@ enum MeshPointType : char { INVALID, REAL, SET_IN_BITMAP, CLOSEST };
 
 struct mesh_index_pair;
 
-#define MESH_X_DIST (float((MESH_MAX_X) - (MESH_MIN_X)) / (GRID_MAX_CELLS_X))
-#define MESH_Y_DIST (float((MESH_MAX_Y) - (MESH_MIN_Y)) / (GRID_MAX_CELLS_Y))
+#define MESH_X_DIST ((mesh_max.x - mesh_min.x) / (GRID_MAX_CELLS_X))
+#define MESH_Y_DIST ((mesh_max.y - mesh_min.y) / (GRID_MAX_CELLS_Y))
 
 #if ENABLED(OPTIMIZED_MESH_STORAGE)
   #if ANY(PROUI_EX, PROUI_GRID_PNTS)
@@ -140,11 +140,11 @@ class unified_bed_leveling {
   FORCE_INLINE static void set_z(const int8_t px, const int8_t py, const float z) { z_values[px][py] = z; }
 
   static int8_t cell_index_x_raw(const float x) {
-    return FLOOR((x - (MESH_MIN_X)) * RECIPROCAL(MESH_X_DIST));
+    return FLOOR((x - mesh_min.x) * RECIPROCAL(MESH_X_DIST));
   }
 
   static int8_t cell_index_y_raw(const float y) {
-    return FLOOR((y - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST));
+    return FLOOR((y - mesh_min.y) * RECIPROCAL(MESH_Y_DIST));
   }
 
   static bool cell_index_x_valid(const float x) {
@@ -169,11 +169,11 @@ class unified_bed_leveling {
   static xy_uint8_t cell_indexes(const xy_pos_t &xy) { return cell_indexes(xy.x, xy.y); }
 
   static int8_t closest_x_index(const float x) {
-    const int8_t px = (x - (MESH_MIN_X) + (MESH_X_DIST) * 0.5) * RECIPROCAL(MESH_X_DIST);
+    const int8_t px = (x - mesh_min.x + (MESH_X_DIST) * 0.5) * RECIPROCAL(MESH_X_DIST);
     return WITHIN(px, 0, (GRID_MAX_POINTS_X) - 1) ? px : -1;
   }
   static int8_t closest_y_index(const float y) {
-    const int8_t py = (y - (MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * RECIPROCAL(MESH_Y_DIST);
+    const int8_t py = (y - mesh_min.y + (MESH_Y_DIST) * 0.5) * RECIPROCAL(MESH_Y_DIST);
     return WITHIN(py, 0, (GRID_MAX_POINTS_Y) - 1) ? py : -1;
   }
   static xy_int8_t closest_indexes(const xy_pos_t &xy) {
@@ -266,7 +266,7 @@ class unified_bed_leveling {
      * UBL_Z_RAISE_WHEN_OFF_MESH is specified, that value is returned.
      */
     #ifdef UBL_Z_RAISE_WHEN_OFF_MESH
-      if (!WITHIN(rx0, MESH_MIN_X, MESH_MAX_X) || !WITHIN(ry0, MESH_MIN_Y, MESH_MAX_Y))
+      if (!WITHIN(rx0, mesh_min.x, mesh_max.x) || !WITHIN(ry0, mesh_min.y, mesh_max.y))
         return UBL_Z_RAISE_WHEN_OFF_MESH;
     #endif
 
@@ -294,22 +294,23 @@ class unified_bed_leveling {
 
   static constexpr float get_z_offset() { return 0.0f; }
 
+  #if !ALL(PROUI_EX, PROUI_MESH_EDIT) || DISABLED(DWIN_LCD_PROUI)
+    static float _get_mesh_x(const uint8_t i) { return mesh_min.x + i * (MESH_X_DIST); }
+    static float _get_mesh_y(const uint8_t j) { return mesh_min.y + j * (MESH_Y_DIST); }
+  #endif
+
   #if ALL(PROUI_EX, PROUI_MESH_EDIT)
     static float get_mesh_x(const uint8_t i);
     static float get_mesh_y(const uint8_t j);
-  #elif ENABLED(PROUI_MESH_EDIT)
-    static float get_mesh_x(const uint8_t i) {
-      return MESH_MIN_X + i * (MESH_X_DIST);
-    }
-    static float get_mesh_y(const uint8_t j) {
-      return MESH_MIN_Y + j * (MESH_Y_DIST);
-    }
+  #elif ENABLED(DWIN_LCD_PROUI)
+    static float get_mesh_x(const uint8_t i) { return _get_mesh_x(i); }
+    static float get_mesh_y(const uint8_t j) { return _get_mesh_y(j); }
   #else
     static float get_mesh_x(const uint8_t i) {
-      return i < (GRID_MAX_POINTS_X) ? pgm_read_float(&_mesh_index_to_xpos[i]) : MESH_MIN_X + i * (MESH_X_DIST);
+      return i < (GRID_MAX_POINTS_X) ? pgm_read_float(&_mesh_index_to_xpos[i]) : _get_mesh_x(i);
     }
     static float get_mesh_y(const uint8_t j) {
-      return j < (GRID_MAX_POINTS_Y) ? pgm_read_float(&_mesh_index_to_ypos[j]) : MESH_MIN_Y + j * (MESH_Y_DIST);
+      return j < (GRID_MAX_POINTS_Y) ? pgm_read_float(&_mesh_index_to_ypos[j]) : _get_mesh_y(j);
     }
   #endif