From 7c275285eaa6802614aae5533262065d6b406551 Mon Sep 17 00:00:00 2001 From: Marcio T Date: Sat, 27 Mar 2021 21:57:12 -0600 Subject: [PATCH] Refactor Hilbert curve. Enhance Touch UI Bed Level Screen. (#21453) --- Marlin/src/feature/bedlevel/hilbert_curve.cpp | 112 +++++++++++++ Marlin/src/feature/bedlevel/hilbert_curve.h | 32 ++++ Marlin/src/feature/bedlevel/ubl/ubl.h | 5 - Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp | 158 +++++++++--------- .../ftdi_eve_lib/extras/adjuster_widget.cpp | 41 ++--- .../ftdi_eve_lib/extras/adjuster_widget.h | 7 + .../ftdi_eve_touch_ui/language/language_en.h | 5 +- .../screens/bed_mesh_screen.cpp | 21 ++- .../screens/bed_mesh_screen.h | 2 + .../screens/leveling_menu.cpp | 67 +++++--- .../ftdi_eve_touch_ui/screens/tune_menu.cpp | 2 +- Marlin/src/lcd/extui/ui_api.cpp | 31 ++-- platformio.ini | 2 + 13 files changed, 341 insertions(+), 144 deletions(-) create mode 100644 Marlin/src/feature/bedlevel/hilbert_curve.cpp create mode 100644 Marlin/src/feature/bedlevel/hilbert_curve.h diff --git a/Marlin/src/feature/bedlevel/hilbert_curve.cpp b/Marlin/src/feature/bedlevel/hilbert_curve.cpp new file mode 100644 index 000000000..6150226e0 --- /dev/null +++ b/Marlin/src/feature/bedlevel/hilbert_curve.cpp @@ -0,0 +1,112 @@ +/********************* + * hilbert_curve.cpp * + *********************/ + +/**************************************************************************** + * Written By Marcio Teixeira 2021 - SynDaver Labs, Inc. * + * * + * 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. * + * * + * To view a copy of the GNU General Public License, go to the following * + * location: . * + ****************************************************************************/ + +#include "../../inc/MarlinConfig.h" + +#if ENABLED(UBL_HILBERT_CURVE) + +#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(n >> 1) : 0; } +constexpr uint8_t order(uint8_t n) { return uint8_t(log2(n - 1)) + 1; } +constexpr uint8_t ord = order(_MAX(GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y)); +constexpr uint8_t dim = _BV(ord); + +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 + // curve, so cull unecessary points + return x < GRID_MAX_POINTS_X && y < GRID_MAX_POINTS_Y ? func(x, y, data) : false; +} + +bool hilbert_curve::hilbert(int8_t x, int8_t y, int8_t xi, int8_t xj, int8_t yi, int8_t yj, uint8_t n, hilbert_curve::callback_ptr func, void *data) { + /** + * Hilbert space-filling curve implementation + * + * x and y : coordinates of the bottom left corner + * xi and xj : i and j components of the unit x vector of the frame + * yi and yj : i and j components of the unit y vector of the frame + * + * From: http://www.fundza.com/algorithmic/space_filling/hilbert/basics/index.html + */ + if (n) + return hilbert(x, y, yi/2, yj/2, xi/2, xj/2, n-1, func, data) || + hilbert(x+xi/2, y+xj/2, xi/2, xj/2, yi/2, yj/2, n-1, func, data) || + hilbert(x+xi/2+yi/2, y+xj/2+yj/2, xi/2, xj/2, yi/2, yj/2, n-1, func, data) || + hilbert(x+xi/2+yi, y+xj/2+yj, -yi/2, -yj/2, -xi/2, -xj/2, n-1, func, data); + else + return eval_candidate(to_int(x+(xi+yi)/2), to_int(y+(xj+yj)/2), func, data); +} + +/** + * Calls func(x, y, data) for all points in the Hilbert curve. + * If that function returns true, the search is terminated. + */ +bool hilbert_curve::search(hilbert_curve::callback_ptr func, void *data) { + return hilbert(to_fix(0), to_fix(0),to_fix(dim), to_fix(0), to_fix(0), to_fix(dim), ord, func, data); +} + +/* Helper function for starting the search at a particular point */ + +typedef struct { + uint8_t x, y; + bool found_1st; + hilbert_curve::callback_ptr func; + void *data; +} search_from_t; + +static bool search_from_helper(uint8_t x, uint8_t y, void *data) { + search_from_t *d = (search_from_t *) data; + if (d->x == x && d->y == y) + d->found_1st = true; + return d->found_1st ? d->func(x, y, d->data) : false; +} + +/** + * Same as search, except start at a specific grid intersection point. + */ +bool hilbert_curve::search_from(uint8_t x, uint8_t y, hilbert_curve::callback_ptr func, void *data) { + search_from_t d; + d.x = x; + d.y = y; + d.found_1st = false; + d.func = func; + d.data = data; + // Call twice to allow search to wrap back to the beginning and picked up points prior to the start. + return search(search_from_helper, &d) || search(search_from_helper, &d); +} + +/** + * Like search_from, but takes a bed position and starts from the nearest + * point on the Hilbert curve. + */ +bool hilbert_curve::search_from_closest(const xy_pos_t &pos, hilbert_curve::callback_ptr func, void *data) { + // Find closest grid intersection + uint8_t grid_x = LROUND(float(pos.x - MESH_MIN_X) / MESH_X_DIST); + uint8_t grid_y = LROUND(float(pos.y - MESH_MIN_Y) / MESH_Y_DIST); + LIMIT(grid_x, 0, GRID_MAX_POINTS_X); + LIMIT(grid_y, 0, GRID_MAX_POINTS_Y); + return search_from(grid_x, grid_y, func, data); +} + +#endif // UBL_HILBERT_CURVE diff --git a/Marlin/src/feature/bedlevel/hilbert_curve.h b/Marlin/src/feature/bedlevel/hilbert_curve.h new file mode 100644 index 000000000..a5dce8a22 --- /dev/null +++ b/Marlin/src/feature/bedlevel/hilbert_curve.h @@ -0,0 +1,32 @@ +/******************* + * hilbert_curve.h * + *******************/ + +/**************************************************************************** + * Written By Marcio Teixeira 2021 - SynDaver Labs, Inc. * + * * + * 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. * + * * + * To view a copy of the GNU General Public License, go to the following * + * location: . * + ****************************************************************************/ + +#pragma once + +class hilbert_curve { + public: + typedef bool (*callback_ptr)(uint8_t x, uint8_t y, void *data); + static bool search(callback_ptr func, void *data); + static bool search_from(uint8_t x, uint8_t y, callback_ptr func, void *data); + static bool search_from_closest(const xy_pos_t &pos, callback_ptr func, void *data); + private: + static bool hilbert(int8_t x, int8_t y, int8_t xi, int8_t xj, int8_t yi, int8_t yj, uint8_t n, callback_ptr func, void *data); +}; diff --git a/Marlin/src/feature/bedlevel/ubl/ubl.h b/Marlin/src/feature/bedlevel/ubl/ubl.h index 67a9b0a60..56de4e45b 100644 --- a/Marlin/src/feature/bedlevel/ubl/ubl.h +++ b/Marlin/src/feature/bedlevel/ubl/ubl.h @@ -101,11 +101,6 @@ public: static void display_map(const int) _O0; static mesh_index_pair find_closest_mesh_point_of_type(const MeshPointType, const xy_pos_t&, const bool=false, MeshFlags *done_flags=nullptr) _O0; static mesh_index_pair find_furthest_invalid_mesh_point() _O0; - #if ENABLED(UBL_HILBERT_CURVE) - static void check_if_missing(mesh_index_pair &pt, int x, int y); - static void hilbert(mesh_index_pair &pt, int8_t x, int8_t y, int8_t xi, int8_t xj, int8_t yi, int8_t yj, uint8_t n); - static mesh_index_pair find_next_mesh_point(); - #endif static void reset(); static void invalidate(); static void set_all_mesh_points_to_value(const float value); diff --git a/Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp b/Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp index c1f824714..2003e9b6f 100644 --- a/Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp +++ b/Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp @@ -49,6 +49,10 @@ #include "../../../lcd/extui/ui_api.h" #endif +#if ENABLED(UBL_HILBERT_CURVE) + #include "../hilbert_curve.h" +#endif + #include #define UBL_G29_P31 @@ -747,11 +751,9 @@ void unified_bed_leveling::shift_mesh_height() { } #endif - best = do_furthest ? find_furthest_invalid_mesh_point() - : TERN(UBL_HILBERT_CURVE, - find_next_mesh_point(), - find_closest_mesh_point_of_type(INVALID, nearby, true) - ); + best = do_furthest + ? find_furthest_invalid_mesh_point() + : find_closest_mesh_point_of_type(INVALID, nearby, true); if (best.pos.x >= 0) { // mesh point found and is reachable by probe TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(best.pos, ExtUI::PROBE_START)); @@ -1269,97 +1271,93 @@ mesh_index_pair unified_bed_leveling::find_furthest_invalid_mesh_point() { return farthest; } -mesh_index_pair unified_bed_leveling::find_closest_mesh_point_of_type(const MeshPointType type, const xy_pos_t &pos, const bool probe_relative/*=false*/, MeshFlags *done_flags/*=nullptr*/) { - mesh_index_pair closest; - closest.invalidate(); - closest.distance = -99999.9f; +#if ENABLED(UBL_HILBERT_CURVE) - // Get the reference position, either nozzle or probe - const xy_pos_t ref = probe_relative ? pos + probe.offset_xy : pos; + typedef struct { + MeshPointType type; + MeshFlags *done_flags; + bool probe_relative; + mesh_index_pair closest; + } find_closest_t; - float best_so_far = 99999.99f; - - GRID_LOOP(i, j) { - if ( (type == (isnan(z_values[i][j]) ? INVALID : REAL)) - || (type == SET_IN_BITMAP && !done_flags->marked(i, j)) + static bool test_func(uint8_t i, uint8_t j, void *data) { + find_closest_t *d = (find_closest_t*)data; + if ( (d->type == (isnan(ubl.z_values[i][j]) ? INVALID : REAL)) + || (d->type == SET_IN_BITMAP && !d->done_flags->marked(i, j)) ) { // Found a Mesh Point of the specified type! - const xy_pos_t mpos = { mesh_index_to_xpos(i), mesh_index_to_ypos(j) }; + const xy_pos_t mpos = { ubl.mesh_index_to_xpos(i), ubl.mesh_index_to_ypos(j) }; // If using the probe as the reference there are some unreachable locations. // Also for round beds, there are grid points outside the bed the nozzle can't reach. // Prune them from the list and ignore them till the next Phase (manual nozzle probing). - if (!(probe_relative ? probe.can_reach(mpos) : position_is_reachable(mpos))) - continue; - - // Reachable. Check if it's the best_so_far location to the nozzle. - - const xy_pos_t diff = current_position - mpos; - const float distance = (ref - mpos).magnitude() + diff.magnitude() * 0.1f; - - // factor in the distance from the current location for the normal case - // so the nozzle isn't running all over the bed. - if (distance < best_so_far) { - best_so_far = distance; // Found a closer location with the desired value type. - closest.pos.set(i, j); - closest.distance = best_so_far; - } - } - } // GRID_LOOP - - return closest; -} - -#if ENABLED(UBL_HILBERT_CURVE) - - constexpr int8_t to_fix(int8_t v) { return v << 1; } - constexpr int8_t to_int(int8_t v) { return v >> 1; } - constexpr uint8_t log2(uint8_t n) { return (n > 1) ? 1 + log2(n >> 1) : 0; } - constexpr uint8_t order(uint8_t n) { return uint8_t(log2(n - 1)) + 1; } - - void unified_bed_leveling::hilbert(mesh_index_pair &pt, int8_t x, int8_t y, int8_t xi, int8_t xj, int8_t yi, int8_t yj, uint8_t n) { - /* Hilbert space filling curve implementation - * - * x and y are the coordinates of the bottom left corner - * xi & xj are the i & j components of the unit x vector of the frame - * similarly yi and yj - * - * From: http://www.fundza.com/algorithmic/space_filling/hilbert/basics/index.html - */ - if (n <= 0) - check_if_missing(pt, to_int(x+(xi+yi)/2),to_int(y+(xj+yj)/2)); - else { - hilbert(pt, x, y, yi/2, yj/2, xi/2, xj/2, n-1); - hilbert(pt, x+xi/2, y+xj/2, xi/2, xj/2, yi/2, yj/2, n-1); - hilbert(pt, x+xi/2+yi/2, y+xj/2+yj/2, xi/2, xj/2, yi/2, yj/2, n-1); - hilbert(pt, x+xi/2+yi, y+xj/2+yj, -yi/2, -yj/2, -xi/2, -xj/2, n-1); + if (!(d->probe_relative ? probe.can_reach(mpos) : position_is_reachable(mpos))) + return false; + d->closest.pos.set(i, j); + return true; } + return false; } - void unified_bed_leveling::check_if_missing(mesh_index_pair &pt, int x, int y) { - if ( pt.distance < 0 - && x < GRID_MAX_POINTS_X - && y < GRID_MAX_POINTS_Y - && isnan(z_values[x][y]) - && probe.can_reach(mesh_index_to_xpos(x), mesh_index_to_ypos(y)) +#endif + +mesh_index_pair unified_bed_leveling::find_closest_mesh_point_of_type(const MeshPointType type, const xy_pos_t &pos, const bool probe_relative/*=false*/, MeshFlags *done_flags/*=nullptr*/) { + + #if ENABLED(UBL_HILBERT_CURVE) + + find_closest_t d; + d.type = type; + d.done_flags = done_flags; + d.probe_relative = probe_relative; + d.closest.invalidate(); + hilbert_curve::search_from_closest(pos, test_func, &d); + return d.closest; + + #else + + mesh_index_pair closest; + closest.invalidate(); + closest.distance = -99999.9f; + + // Get the reference position, either nozzle or probe + const xy_pos_t ref = probe_relative ? pos + probe.offset_xy : pos; + + float best_so_far = 99999.99f; + + GRID_LOOP(i, j) { + if ( (type == (isnan(z_values[i][j]) ? INVALID : REAL)) + || (type == SET_IN_BITMAP && !done_flags->marked(i, j)) ) { - pt.pos.set(x, y); - pt.distance = 1; + // Found a Mesh Point of the specified type! + const xy_pos_t mpos = { mesh_index_to_xpos(i), mesh_index_to_ypos(j) }; + + // If using the probe as the reference there are some unreachable locations. + // Also for round beds, there are grid points outside the bed the nozzle can't reach. + // Prune them from the list and ignore them till the next Phase (manual nozzle probing). + + if (!(probe_relative ? probe.can_reach(mpos) : position_is_reachable(mpos))) + continue; + + // Reachable. Check if it's the best_so_far location to the nozzle. + + const xy_pos_t diff = current_position - mpos; + const float distance = (ref - mpos).magnitude() + diff.magnitude() * 0.1f; + + // factor in the distance from the current location for the normal case + // so the nozzle isn't running all over the bed. + if (distance < best_so_far) { + best_so_far = distance; // Found a closer location with the desired value type. + closest.pos.set(i, j); + closest.distance = best_so_far; + } } - } + } // GRID_LOOP - mesh_index_pair unified_bed_leveling::find_next_mesh_point() { - mesh_index_pair pt; - pt.invalidate(); - pt.distance = -99999.9f; - constexpr uint8_t ord = order(_MAX(GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y)); - constexpr uint8_t dim = _BV(ord); - hilbert(pt, to_fix(0), to_fix(0), to_fix(dim), to_fix(0), to_fix(0), to_fix(dim), ord); - return pt; - } + return closest; -#endif // UBL_HILBERT_CURVE + #endif +} /** * 'Smart Fill': Scan from the outward edges of the mesh towards the center. diff --git a/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/extras/adjuster_widget.cpp b/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/extras/adjuster_widget.cpp index 084c9c014..ef3cb565d 100644 --- a/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/extras/adjuster_widget.cpp +++ b/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/extras/adjuster_widget.cpp @@ -30,25 +30,28 @@ #define INC_POS SUB_POS(6,1), SUB_SIZE(2,1) #define DEC_POS SUB_POS(8,1), SUB_SIZE(2,1) -void draw_adjuster(CommandProcessor& cmd, int16_t x, int16_t y, int16_t w, int16_t h, uint8_t tag, float value, progmem_str units, int8_t width, uint8_t precision, draw_mode_t what) { - if (what & BACKGROUND) - cmd.tag(0).button(VAL_POS, F(""), FTDI::OPT_FLAT); +void draw_adjuster_value(CommandProcessor& cmd, int16_t x, int16_t y, int16_t w, int16_t h, float value, progmem_str units, int8_t width, uint8_t precision) { + char str[width + precision + 10 + (units ? strlen_P((const char*) units) : 0)]; + if (isnan(value)) + strcpy_P(str, PSTR("-")); + else + dtostrf(value, width, precision, str); - if (what & FOREGROUND) { - char str[width + precision + 10 + (units ? strlen_P((const char*) units) : 0)]; - if (isnan(value)) - strcpy_P(str, PSTR("-")); - else - dtostrf(value, width, precision, str); + if (units) { + strcat_P(str, PSTR(" ")); + strcat_P(str, (const char*) units); + } - if (units) { - strcat_P(str, PSTR(" ")); - strcat_P(str, (const char*) units); - } - - cmd.tag(0) - .text(VAL_POS, str) - .tag(tag ).button(INC_POS, F("-")) - .tag(tag+1).button(DEC_POS, F("+")); - } + cmd.text(VAL_POS, str); +} + +void draw_adjuster(CommandProcessor& cmd, int16_t x, int16_t y, int16_t w, int16_t h, uint8_t tag, float value, progmem_str units, int8_t width, uint8_t precision, draw_mode_t what) { + if (what & BACKGROUND) + cmd.tag(0).button(VAL_POS, F(""), FTDI::OPT_FLAT); + + if (what & FOREGROUND) { + draw_adjuster_value(cmd, x, y, w, h, value, units, width, precision); + cmd.tag(tag ).button(INC_POS, F("-")) + .tag(tag+1).button(DEC_POS, F("+")); + } } diff --git a/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/extras/adjuster_widget.h b/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/extras/adjuster_widget.h index c48e37f62..9b5cab0df 100644 --- a/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/extras/adjuster_widget.h +++ b/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/extras/adjuster_widget.h @@ -22,6 +22,13 @@ #pragma once #include "../extended/screen_types.h" +void draw_adjuster_value( + CommandProcessor& cmd, + int16_t x, int16_t y, int16_t w, int16_t h, + float value, progmem_str units = nullptr, + int8_t width = 5, uint8_t precision = 1 +); + void draw_adjuster( CommandProcessor& cmd, int16_t x, int16_t y, int16_t w, int16_t h, diff --git a/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/language/language_en.h b/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/language/language_en.h index f6603e514..c34d5b775 100644 --- a/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/language/language_en.h +++ b/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/language/language_en.h @@ -140,10 +140,13 @@ namespace Language_en { PROGMEM Language_Str MSG_TOUCH_CALIBRATION_START = u8"Release to begin screen calibration"; PROGMEM Language_Str MSG_TOUCH_CALIBRATION_PROMPT = u8"Touch the dots to calibrate"; - PROGMEM Language_Str MSG_AUTOLEVEL_X_AXIS = u8"Level X Axis"; PROGMEM Language_Str MSG_BED_MAPPING_DONE = u8"Bed mapping finished"; PROGMEM Language_Str MSG_BED_MAPPING_INCOMPLETE = u8"Not all points probed"; PROGMEM Language_Str MSG_LEVELING = u8"Leveling"; + PROGMEM Language_Str MSG_AXIS_LEVELING = u8"Axis Leveling"; + PROGMEM Language_Str MSG_PROBE_BED = u8"Probe Mesh"; + PROGMEM Language_Str MSG_SHOW_MESH = u8"View Mesh"; + PROGMEM Language_Str MSG_PRINT_TEST = u8"Print Test"; #if ENABLED(TOUCH_UI_LULZBOT_BIO) PROGMEM Language_Str MSG_MOVE_TO_HOME = u8"Move to Home"; diff --git a/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/bed_mesh_screen.cpp b/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/bed_mesh_screen.cpp index c87329ebe..053f4ebd7 100644 --- a/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/bed_mesh_screen.cpp +++ b/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/bed_mesh_screen.cpp @@ -225,6 +225,7 @@ bool BedMeshScreen::tagToPoint(uint8_t tag, xy_uint8_t &pt) { } void BedMeshScreen::onEntry() { + mydata.allowEditing = true; mydata.highlightedTag = 0; mydata.zAdjustment = 0; mydata.count = GRID_MAX_POINTS; @@ -259,16 +260,16 @@ void BedMeshScreen::adjustHighlightedValue(float increment) { } void BedMeshScreen::saveAdjustedHighlightedValue() { - if(mydata.zAdjustment) { + if (mydata.zAdjustment) { BedMeshScreen::setHighlightedValue(BedMeshScreen::getHighlightedValue(true) + mydata.zAdjustment); mydata.zAdjustment = 0; } } void BedMeshScreen::changeHighlightedValue(uint8_t tag) { - saveAdjustedHighlightedValue(); + if (mydata.allowEditing) saveAdjustedHighlightedValue(); mydata.highlightedTag = tag; - moveToHighlightedValue(); + if (mydata.allowEditing) moveToHighlightedValue(); } void BedMeshScreen::drawHighlightedPointValue() { @@ -277,7 +278,12 @@ void BedMeshScreen::drawHighlightedPointValue() { .colors(normal_btn) .text(Z_LABEL_POS, GET_TEXT_F(MSG_MESH_EDIT_Z)) .font(font_small); - draw_adjuster(cmd, Z_VALUE_POS, 2, getHighlightedValue(true) + mydata.zAdjustment, GET_TEXT_F(MSG_UNITS_MM), 4, 3); + + if (mydata.allowEditing) + draw_adjuster(cmd, Z_VALUE_POS, 2, getHighlightedValue(true) + mydata.zAdjustment, GET_TEXT_F(MSG_UNITS_MM), 4, 3); + else + draw_adjuster_value(cmd, Z_VALUE_POS, getHighlightedValue(true) + mydata.zAdjustment, GET_TEXT_F(MSG_UNITS_MM), 4, 3); + cmd.colors(action_btn) .tag(1).button(OKAY_POS, GET_TEXT_F(MSG_BUTTON_OKAY)) .tag(0); @@ -347,6 +353,7 @@ void BedMeshScreen::onMeshUpdate(const int8_t, const int8_t, const float) { void BedMeshScreen::onMeshUpdate(const int8_t x, const int8_t y, const ExtUI::probe_state_t state) { switch (state) { case ExtUI::MESH_START: + mydata.allowEditing = false; mydata.count = 0; mydata.message = mydata.MSG_NONE; break; @@ -369,10 +376,16 @@ void BedMeshScreen::onMeshUpdate(const int8_t x, const int8_t y, const ExtUI::pr void BedMeshScreen::startMeshProbe() { GOTO_SCREEN(BedMeshScreen); + mydata.allowEditing = false; mydata.count = 0; injectCommands_P(PSTR(BED_LEVELING_COMMANDS)); } +void BedMeshScreen::showMesh() { + GOTO_SCREEN(BedMeshScreen); + mydata.allowEditing = false; +} + void BedMeshScreen::showMeshEditor() { SpinnerDialogBox::enqueueAndWait_P(ExtUI::isMachineHomed() ? F("M420 S1") : F("G28\nM420 S1")); // After the spinner, go to this screen. diff --git a/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/bed_mesh_screen.h b/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/bed_mesh_screen.h index 804bb57ad..21a7a7372 100644 --- a/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/bed_mesh_screen.h +++ b/Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/bed_mesh_screen.h @@ -33,6 +33,7 @@ struct BedMeshScreenData { uint8_t count; uint8_t highlightedTag; float zAdjustment; + bool allowEditing; }; class BedMeshScreen : public BaseScreen, public CachedScreen { @@ -63,5 +64,6 @@ class BedMeshScreen : public BaseScreen, public CachedScreen - - + - - - - - - + - - - - - - @@ -306,6 +307,7 @@ AUTO_BED_LEVELING_BILINEAR = src_filter=+ AUTO_BED_LEVELING_(3POINT|(BI)?LINEAR) = src_filter=+ MESH_BED_LEVELING = src_filter=+ + AUTO_BED_LEVELING_UBL = src_filter=+ + +UBL_HILBERT_CURVE = src_filter=+ BACKLASH_COMPENSATION = src_filter=+ BARICUDA = src_filter=+ + BINARY_FILE_TRANSFER = src_filter=+ +