Add Extra ProUI features

Marlin/src/core/utility.h

@@ -33,7 +33,7 @@ void safe_delay(millis_t ms);           // Delay ensuring that temperatures are
   inline void serial_delay(const millis_t) {}
 #endif
 
-#if GRID_MAX_POINTS
+#if TERN(PROUI_GRID_PNTS, HAS_MESH, GRID_MAX_POINTS)
 
   // 16x16 bit arrays
   template <int W, int H>
@@ -49,7 +49,7 @@ void safe_delay(millis_t ms);           // Delay ensuring that temperatures are
     inline bool marked(const xy_int8_t &xy)       { return marked(xy.x, xy.y); }
   };
 
-  typedef FlagBits<GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y> MeshFlags;
+  typedef FlagBits<TERN(PROUI_GRID_PNTS, GRID_LIMIT, GRID_MAX_POINTS_X), TERN(PROUI_GRID_PNTS, GRID_LIMIT, GRID_MAX_POINTS_Y)> MeshFlags;
 
 #endif
 

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

@@ -37,12 +37,12 @@
 
 LevelingBilinear bedlevel;
 
-xy_pos_t LevelingBilinear::grid_spacing,
-         LevelingBilinear::grid_start;
 xy_float_t LevelingBilinear::grid_factor;
-bed_mesh_t LevelingBilinear::z_values;
-xy_pos_t LevelingBilinear::cached_rel;
+xy_pos_t LevelingBilinear::grid_spacing,
+         LevelingBilinear::grid_start,
+         LevelingBilinear::cached_rel;
 xy_int8_t LevelingBilinear::cached_g;
+bed_mesh_t LevelingBilinear::z_values;
 
 /**
  * Extrapolate a single point from its neighbors
@@ -118,18 +118,18 @@ void LevelingBilinear::set_grid(const xy_pos_t& _grid_spacing, const xy_pos_t& _
  */
 void LevelingBilinear::extrapolate_unprobed_bed_level() {
   #ifdef HALF_IN_X
-    constexpr uint8_t ctrx2 = 0, xend = GRID_MAX_POINTS_X - 1;
+    TERN(PROUI_GRID_PNTS, const, constexpr) uint8_t ctrx2 = 0, xend = GRID_MAX_POINTS_X - 1;
   #else
-    constexpr uint8_t ctrx1 = (GRID_MAX_CELLS_X) / 2, // left-of-center
-                      ctrx2 = (GRID_MAX_POINTS_X) / 2,  // right-of-center
+    TERN(PROUI_GRID_PNTS, const, constexpr) uint8_t ctrx1 = (GRID_MAX_CELLS_X) / 2,  // left-of-center
+                      ctrx2 = (GRID_MAX_POINTS_X) / 2, // right-of-center
                       xend = ctrx1;
   #endif
 
   #ifdef HALF_IN_Y
-    constexpr uint8_t ctry2 = 0, yend = GRID_MAX_POINTS_Y - 1;
+    TERN(PROUI_GRID_PNTS, const, constexpr) uint8_t ctry2 = 0, yend = GRID_MAX_POINTS_Y - 1;
   #else
-    constexpr uint8_t ctry1 = (GRID_MAX_CELLS_Y) / 2, // top-of-center
-                      ctry2 = (GRID_MAX_POINTS_Y) / 2,  // bottom-of-center
+    TERN(PROUI_GRID_PNTS, const, constexpr) uint8_t ctry1 = (GRID_MAX_CELLS_Y) / 2,  // top-of-center
+                      ctry2 = (GRID_MAX_POINTS_Y) / 2, // bottom-of-center
                       yend = ctry1;
   #endif
 

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

@@ -36,8 +36,14 @@ class LevelingBilinear {
   static void extrapolate_one_point(const uint8_t x, const uint8_t y, const int8_t xdir, const int8_t ydir);
 
   #if ENABLED(ABL_BILINEAR_SUBDIVISION)
-    #define ABL_GRID_POINTS_VIRT_X (GRID_MAX_CELLS_X * (BILINEAR_SUBDIVISIONS) + 1)
-    #define ABL_GRID_POINTS_VIRT_Y (GRID_MAX_CELLS_Y * (BILINEAR_SUBDIVISIONS) + 1)
+    #if PROUI_GRID_PNTS
+      #define ABL_GRID_POINTS_VIRT_N (GRID_LIMIT - 1) * (BILINEAR_SUBDIVISIONS) + 1
+      #define ABL_GRID_POINTS_VIRT_X ABL_GRID_POINTS_VIRT_N
+      #define ABL_GRID_POINTS_VIRT_Y ABL_GRID_POINTS_VIRT_N
+    #else
+      #define ABL_GRID_POINTS_VIRT_X (GRID_MAX_CELLS_X * (BILINEAR_SUBDIVISIONS) + 1)
+      #define ABL_GRID_POINTS_VIRT_Y (GRID_MAX_CELLS_Y * (BILINEAR_SUBDIVISIONS) + 1)
+    #endif
 
     static float z_values_virt[ABL_GRID_POINTS_VIRT_X][ABL_GRID_POINTS_VIRT_Y];
     static xy_pos_t grid_spacing_virt;

Marlin/src/feature/bedlevel/bedlevel.cpp

@@ -46,8 +46,16 @@
   #include "../../lcd/extui/ui_api.h"
 #endif
 
+#if ALL(MESH_BED_LEVELING, DWIN_LCD_PROUI)
+  #include "../../lcd/e3v2/proui/bedlevel_tools.h"
+#endif
+
 bool leveling_is_valid() {
-  return TERN1(HAS_MESH, bedlevel.mesh_is_valid());
+  #if ALL(MESH_BED_LEVELING, DWIN_LCD_PROUI)
+    return bedLevelTools.meshValidate();
+  #else
+    return TERN1(HAS_MESH, bedlevel.mesh_is_valid());
+  #endif
 }
 
 /**

Marlin/src/feature/bedlevel/bedlevel.h

@@ -59,7 +59,7 @@ class TemporaryBedLevelingState {
 
 #if HAS_MESH
 
-  typedef float bed_mesh_t[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
+  typedef float bed_mesh_t[TERN(PROUI_GRID_PNTS, GRID_LIMIT, GRID_MAX_POINTS_X)][TERN(PROUI_GRID_PNTS, GRID_LIMIT, GRID_MAX_POINTS_Y)];
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
     #include "abl/bbl.h"

Marlin/src/feature/bedlevel/hilbert_curve.cpp

@@ -26,12 +26,21 @@
 #include "bedlevel.h"
 #include "hilbert_curve.h"
 
-constexpr int8_t  to_fix(int8_t  v) { return v * 2; }
-constexpr int8_t  to_int(int8_t  v) { return v / 2; }
-constexpr uint8_t   log2(uint8_t n) { return (n > 1) ? 1 + log2(uint8_t(n >> 1)) : 0; }
-constexpr uint8_t  order(uint8_t n) { return uint8_t(log2(uint8_t(n - 1))) + 1; }
-constexpr uint8_t ord = order(_MAX(GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y));
-constexpr uint8_t dim = _BV(ord);
+#if PROUI_GRID_PNTS
+  int8_t  to_fix(int8_t  v) { return v * 2; }
+  int8_t  to_int(int8_t  v) { return v / 2; }
+  uint8_t   log2(uint8_t n) { return (n > 1) ? 1 + log2(uint8_t(n >> 1)) : 0; }
+  uint8_t  order(uint8_t n) { return uint8_t(log2(uint8_t(n - 1))) + 1; }
+  #define ord order(GRID_MAX_POINTS_X)
+  #define dim _BV(ord)
+#else
+  constexpr int8_t  to_fix(int8_t  v) { return v * 2; }
+  constexpr int8_t  to_int(int8_t  v) { return v / 2; }
+  constexpr uint8_t   log2(uint8_t n) { return (n > 1) ? 1 + log2(uint8_t(n >> 1)) : 0; }
+  constexpr uint8_t  order(uint8_t n) { return uint8_t(log2(uint8_t(n - 1))) + 1; }
+  constexpr uint8_t ord = order(_MAX(GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y));
+  constexpr uint8_t dim = _BV(ord);
+#endif
 
 static inline bool eval_candidate(int8_t x, int8_t y, hilbert_curve::callback_ptr func, void *data) {
   // The print bed likely has fewer points than the full Hilbert

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

@@ -35,9 +35,15 @@
   mesh_bed_leveling bedlevel;
 
   float mesh_bed_leveling::z_offset,
-        mesh_bed_leveling::z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y],
+     #if PROUI_GRID_PNTS
+        mesh_bed_leveling::index_to_xpos[GRID_LIMIT],
+        mesh_bed_leveling::index_to_ypos[GRID_LIMIT];
+        bed_mesh_t mesh_bed_leveling::z_values;
+     #else
         mesh_bed_leveling::index_to_xpos[GRID_MAX_POINTS_X],
         mesh_bed_leveling::index_to_ypos[GRID_MAX_POINTS_Y];
+        bed_mesh_t mesh_bed_leveling::z_values;
+     #endif
 
   mesh_bed_leveling::mesh_bed_leveling() {
     for (uint8_t i = 0; i < GRID_MAX_POINTS_X; ++i)

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

@@ -38,9 +38,15 @@ enum MeshLevelingState : char {
 class mesh_bed_leveling {
 public:
   static float z_offset,
+    #if PROUI_GRID_PNTS
+               z_values[GRID_LIMIT][GRID_LIMIT],
+               index_to_xpos[GRID_LIMIT],
+               index_to_ypos[GRID_LIMIT];
+    #else
                z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y],
                index_to_xpos[GRID_MAX_POINTS_X],
                index_to_ypos[GRID_MAX_POINTS_Y];
+    #endif
 
   mesh_bed_leveling();
 
@@ -70,7 +76,7 @@ class mesh_bed_leveling {
   }
 
   static float get_mesh_x(const uint8_t i) { return index_to_xpos[i]; }
-  static float get_mesh_y(const uint8_t i) { return index_to_ypos[i]; }
+  static float get_mesh_y(const uint8_t j) { return index_to_ypos[j]; }
 
   static uint8_t cell_index_x(const_float_t x) {
     int8_t cx = (x - (MESH_MIN_X)) * RECIPROCAL(MESH_X_DIST);

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

@@ -64,23 +64,25 @@ void unified_bed_leveling::report_state() {
 
 int8_t unified_bed_leveling::storage_slot;
 
-float unified_bed_leveling::z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
-
-#define _GRIDPOS(A,N) (MESH_MIN_##A + N * (MESH_##A##_DIST))
-
-const float
-unified_bed_leveling::_mesh_index_to_xpos[GRID_MAX_POINTS_X] PROGMEM = ARRAY_N(GRID_MAX_POINTS_X,
-  _GRIDPOS(X,  0), _GRIDPOS(X,  1), _GRIDPOS(X,  2), _GRIDPOS(X,  3),
-  _GRIDPOS(X,  4), _GRIDPOS(X,  5), _GRIDPOS(X,  6), _GRIDPOS(X,  7),
-  _GRIDPOS(X,  8), _GRIDPOS(X,  9), _GRIDPOS(X, 10), _GRIDPOS(X, 11),
-  _GRIDPOS(X, 12), _GRIDPOS(X, 13), _GRIDPOS(X, 14), _GRIDPOS(X, 15)
-),
-unified_bed_leveling::_mesh_index_to_ypos[GRID_MAX_POINTS_Y] PROGMEM = ARRAY_N(GRID_MAX_POINTS_Y,
-  _GRIDPOS(Y,  0), _GRIDPOS(Y,  1), _GRIDPOS(Y,  2), _GRIDPOS(Y,  3),
-  _GRIDPOS(Y,  4), _GRIDPOS(Y,  5), _GRIDPOS(Y,  6), _GRIDPOS(Y,  7),
-  _GRIDPOS(Y,  8), _GRIDPOS(Y,  9), _GRIDPOS(Y, 10), _GRIDPOS(Y, 11),
-  _GRIDPOS(Y, 12), _GRIDPOS(Y, 13), _GRIDPOS(Y, 14), _GRIDPOS(Y, 15)
-);
+bed_mesh_t unified_bed_leveling::z_values;
+
+#if DISABLED(PROUI_MESH_EDIT)
+  #define _GRIDPOS(A,N) (MESH_MIN_##A + N * (MESH_##A##_DIST))
+
+  const bed_mesh_t
+  unified_bed_leveling::_mesh_index_to_xpos PROGMEM = ARRAY_N(GRID_MAX_POINTS_X,
+    _GRIDPOS(X,  0), _GRIDPOS(X,  1), _GRIDPOS(X,  2), _GRIDPOS(X,  3),
+    _GRIDPOS(X,  4), _GRIDPOS(X,  5), _GRIDPOS(X,  6), _GRIDPOS(X,  7),
+    _GRIDPOS(X,  8), _GRIDPOS(X,  9), _GRIDPOS(X, 10), _GRIDPOS(X, 11),
+    _GRIDPOS(X, 12), _GRIDPOS(X, 13), _GRIDPOS(X, 14), _GRIDPOS(X, 15)
+  ),
+  unified_bed_leveling::_mesh_index_to_ypos PROGMEM = ARRAY_N(GRID_MAX_POINTS_Y,
+    _GRIDPOS(Y,  0), _GRIDPOS(Y,  1), _GRIDPOS(Y,  2), _GRIDPOS(Y,  3),
+    _GRIDPOS(Y,  4), _GRIDPOS(Y,  5), _GRIDPOS(Y,  6), _GRIDPOS(Y,  7),
+    _GRIDPOS(Y,  8), _GRIDPOS(Y,  9), _GRIDPOS(Y, 10), _GRIDPOS(Y, 11),
+    _GRIDPOS(Y, 12), _GRIDPOS(Y, 13), _GRIDPOS(Y, 14), _GRIDPOS(Y, 15)
+  );
+#endif
 
 volatile int16_t unified_bed_leveling::encoder_diff;
 
@@ -166,7 +168,7 @@ static void serial_echo_column_labels(const uint8_t sp) {
 void unified_bed_leveling::display_map(const uint8_t map_type) {
   const bool was = gcode.set_autoreport_paused(true);
 
-  constexpr uint8_t eachsp = 1 + 6 + 1,                           // [-3.567]
+  IF_DISABLED(PROUI_GRID_PNTS, constexpr) uint8_t eachsp = 1 + 6 + 1,    // [-3.567]
                     twixt = eachsp * (GRID_MAX_POINTS_X) - 9 * 2; // Leading 4sp, Coordinates 9sp each
 
   const bool human = !(map_type & 0x3), csv = map_type == 1, lcd = map_type == 2, comp = map_type & 0x4;

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

@@ -42,7 +42,7 @@ struct mesh_index_pair;
 #define MESH_Y_DIST (float((MESH_MAX_Y) - (MESH_MIN_Y)) / (GRID_MAX_CELLS_Y))
 
 #if ENABLED(OPTIMIZED_MESH_STORAGE)
-  typedef int16_t mesh_store_t[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
+  typedef int16_t mesh_store_t[TERN(PROUI_GRID_PNTS, GRID_LIMIT, GRID_MAX_POINTS_X)][TERN(PROUI_GRID_PNTS, GRID_LIMIT, GRID_MAX_POINTS_Y)];
 #endif
 
 typedef struct {
@@ -116,8 +116,11 @@ class unified_bed_leveling {
     static void set_store_from_mesh(const bed_mesh_t &in_values, mesh_store_t &stored_values);
     static void set_mesh_from_store(const mesh_store_t &stored_values, bed_mesh_t &out_values);
   #endif
-  static const float _mesh_index_to_xpos[GRID_MAX_POINTS_X],
-                     _mesh_index_to_ypos[GRID_MAX_POINTS_Y];
+
+  #if DISABLED(PROUI_MESH_EDIT)
+    static const bed_mesh_t _mesh_index_to_xpos,
+                            _mesh_index_to_ypos;
+  #endif
 
   #if HAS_MARLINUI_MENU
     static bool lcd_map_control;
@@ -287,12 +290,21 @@ class unified_bed_leveling {
 
   static constexpr float get_z_offset() { return 0.0f; }
 
-  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);
-  }
-  static float get_mesh_y(const uint8_t i) {
-    return i < (GRID_MAX_POINTS_Y) ? pgm_read_float(&_mesh_index_to_ypos[i]) : MESH_MIN_Y + i * (MESH_Y_DIST);
-  }
+  #if 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);
+    }
+  #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);
+    }
+    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);
+    }
+  #endif
 
   #if UBL_SEGMENTED
     static bool line_to_destination_segmented(const_feedRate_t scaled_fr_mm_s);