From 94c2a6cadd52242a0a4b394bb95e56de48e004a8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Krzysztof=20B=C5=82a=C5=BCewicz?= Date: Thu, 1 Dec 2022 10:34:27 +0100 Subject: [PATCH] E3V2/LCD: unify limits for feedrate, acc, jerk and steps --- Marlin/src/lcd/e3v2/common/limits.h | 123 ++++++++++++++++++++++++++ Marlin/src/lcd/e3v2/creality/dwin.cpp | 29 ++---- Marlin/src/lcd/e3v2/creality/dwin.h | 1 + Marlin/src/lcd/e3v2/jyersui/dwin.cpp | 76 ++++++++-------- Marlin/src/lcd/e3v2/jyersui/dwin.h | 1 + Marlin/src/lcd/e3v2/proui/dwin.cpp | 65 ++++---------- Marlin/src/lcd/e3v2/proui/dwin.h | 1 + 7 files changed, 185 insertions(+), 111 deletions(-) create mode 100644 Marlin/src/lcd/e3v2/common/limits.h diff --git a/Marlin/src/lcd/e3v2/common/limits.h b/Marlin/src/lcd/e3v2/common/limits.h new file mode 100644 index 000000000000..f8280dc0b237 --- /dev/null +++ b/Marlin/src/lcd/e3v2/common/limits.h @@ -0,0 +1,123 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2022 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 . + * + */ +#pragma once + +/***************************************************************************** + * @file lcd/e3v2/common/limits.h + * @brief Limits for UI values + ****************************************************************************/ + +#include "../../../inc/MarlinConfig.h" + +// If max edit values are not specified use default *DEFAULT_MAX_MULTIPLIER +#define DEFAULT_MAX_MULTIPLIER 2 + +/* feedrate limits */ + +#define MIN_FEEDRATE_EDIT_VALUE 1 + +constexpr float min_feedrate_edit_values[] = { + [X_AXIS] = MIN_FEEDRATE_EDIT_VALUE, + [Y_AXIS] = MIN_FEEDRATE_EDIT_VALUE, + [Z_AXIS] = MIN_FEEDRATE_EDIT_VALUE, + [E_AXIS] = MIN_FEEDRATE_EDIT_VALUE, +}; +constexpr float default_max_feedrate[] = DEFAULT_MAX_FEEDRATE; +constexpr float max_feedrate_edit_values[] = + #ifdef MAX_FEEDRATE_EDIT_VALUES + MAX_FEEDRATE_EDIT_VALUES + #else + { + [X_AXIS] = default_max_feedrate[X_AXIS] * DEFAULT_MAX_MULTIPLIER, + [Y_AXIS] = default_max_feedrate[Y_AXIS] * DEFAULT_MAX_MULTIPLIER, + [Z_AXIS] = default_max_feedrate[Z_AXIS] * DEFAULT_MAX_MULTIPLIER, + [E_AXIS] = default_max_feedrate[E_AXIS] * DEFAULT_MAX_MULTIPLIER, + } + #endif +; + +/* acceleration limits */ + +#define MIN_ACCELERATION_EDIT_VALUE 1 + +constexpr float min_acceleration_edit_values[] = { + [X_AXIS] = MIN_ACCELERATION_EDIT_VALUE, + [Y_AXIS] = MIN_ACCELERATION_EDIT_VALUE, + [Z_AXIS] = MIN_ACCELERATION_EDIT_VALUE, + [E_AXIS] = MIN_ACCELERATION_EDIT_VALUE, +}; +constexpr float default_max_acceleration[] = DEFAULT_MAX_ACCELERATION; +constexpr float max_acceleration_edit_values[] = + #ifdef MAX_ACCEL_EDIT_VALUES + MAX_ACCEL_EDIT_VALUES + #else + { + [X_AXIS] = default_max_acceleration[X_AXIS] * DEFAULT_MAX_MULTIPLIER, + [Y_AXIS] = default_max_acceleration[Y_AXIS] * DEFAULT_MAX_MULTIPLIER, + [Z_AXIS] = default_max_acceleration[Z_AXIS] * DEFAULT_MAX_MULTIPLIER, + [E_AXIS] = default_max_acceleration[E_AXIS] * DEFAULT_MAX_MULTIPLIER, + } + #endif +; + +/* max jerk limits */ + +#define MIN_JERK_EDIT_VALUE 0.1 + +#if HAS_CLASSIC_JERK + constexpr float min_jerk_edit_values[] = { + [X_AXIS] = MIN_JERK_EDIT_VALUE, + [Y_AXIS] = MIN_JERK_EDIT_VALUE, + [Z_AXIS] = MIN_JERK_EDIT_VALUE, + [E_AXIS] = MIN_JERK_EDIT_VALUE, + }; + constexpr float max_jerk_edit_values[] = + #ifdef MAX_JERK_EDIT_VALUES + MAX_JERK_EDIT_VALUES + #else + { + [X_AXIS] = DEFAULT_XJERK * DEFAULT_MAX_MULTIPLIER, + [Y_AXIS] = DEFAULT_YJERK * DEFAULT_MAX_MULTIPLIER, + [Z_AXIS] = DEFAULT_ZJERK * DEFAULT_MAX_MULTIPLIER, + [E_AXIS] = DEFAULT_EJERK * DEFAULT_MAX_MULTIPLIER, + } + #endif + ; +#endif + +/* steps per mm limits */ + +#define MIN_STEPS_EDIT_VALUE 1 + +constexpr float min_steps_edit_values[] = { + [X_AXIS] = MIN_STEPS_EDIT_VALUE, + [Y_AXIS] = MIN_STEPS_EDIT_VALUE, + [Z_AXIS] = MIN_STEPS_EDIT_VALUE, + [E_AXIS] = MIN_STEPS_EDIT_VALUE, +}; +constexpr float default_steps[] = DEFAULT_AXIS_STEPS_PER_UNIT; +constexpr float max_steps_edit_values[] = { + [X_AXIS] = default_steps[X_AXIS] * DEFAULT_MAX_MULTIPLIER, + [Y_AXIS] = default_steps[Y_AXIS] * DEFAULT_MAX_MULTIPLIER, + [Z_AXIS] = default_steps[Z_AXIS] * DEFAULT_MAX_MULTIPLIER, + [E_AXIS] = default_steps[E_AXIS] * DEFAULT_MAX_MULTIPLIER, +}; diff --git a/Marlin/src/lcd/e3v2/creality/dwin.cpp b/Marlin/src/lcd/e3v2/creality/dwin.cpp index 08d928684a6f..c88aa7cc2cfa 100644 --- a/Marlin/src/lcd/e3v2/creality/dwin.cpp +++ b/Marlin/src/lcd/e3v2/creality/dwin.cpp @@ -101,12 +101,6 @@ #define MIN_PRINT_SPEED 10 #define MAX_PRINT_SPEED 999 -// Feedspeed limit (max feedspeed = DEFAULT_MAX_FEEDRATE * 2) -#define MIN_MAXFEEDSPEED 1 -#define MIN_MAXACCELERATION 1 -#define MIN_MAXJERK 0.1 -#define MIN_STEP 1 - #define FEEDRATE_E (60) // Minimum unit (0.1) : multiple (10) @@ -181,13 +175,6 @@ uint8_t index_file = MROWS, bool dwin_abort_flag = false; // Flag to reset feedrate, return to Home -constexpr float default_max_feedrate[] = DEFAULT_MAX_FEEDRATE; -constexpr float default_max_acceleration[] = DEFAULT_MAX_ACCELERATION; - -#if HAS_CLASSIC_JERK - constexpr float default_max_jerk[] = { DEFAULT_XJERK, DEFAULT_YJERK, DEFAULT_ZJERK, DEFAULT_EJERK }; -#endif - static uint8_t _card_percent = 0; static uint16_t _remain_time = 0; @@ -1568,8 +1555,7 @@ void HMI_MaxFeedspeedXYZE() { } // MaxFeedspeed limit if (WITHIN(HMI_flag.feedspeed_axis, X_AXIS, LAST_AXIS)) - NOMORE(HMI_ValueStruct.Max_Feedspeed, default_max_feedrate[HMI_flag.feedspeed_axis] * 2); - if (HMI_ValueStruct.Max_Feedspeed < MIN_MAXFEEDSPEED) HMI_ValueStruct.Max_Feedspeed = MIN_MAXFEEDSPEED; + LIMIT(HMI_ValueStruct.Max_Feedspeed, min_feedrate_edit_values[HMI_flag.feedspeed_axis], max_feedrate_edit_values[HMI_flag.feedspeed_axis]); // MaxFeedspeed value Draw_Edit_Integer4(select_speed.now, HMI_ValueStruct.Max_Feedspeed, true); } @@ -1587,8 +1573,7 @@ void HMI_MaxAccelerationXYZE() { } // MaxAcceleration limit if (WITHIN(HMI_flag.acc_axis, X_AXIS, LAST_AXIS)) - NOMORE(HMI_ValueStruct.Max_Acceleration, default_max_acceleration[HMI_flag.acc_axis] * 2); - if (HMI_ValueStruct.Max_Acceleration < MIN_MAXACCELERATION) HMI_ValueStruct.Max_Acceleration = MIN_MAXACCELERATION; + LIMIT(HMI_ValueStruct.Max_Acceleration, min_acceleration_edit_values[HMI_flag.acc_axis], max_acceleration_edit_values[HMI_flag.acc_axis]); // MaxAcceleration value Draw_Edit_Integer4(select_acc.now, HMI_ValueStruct.Max_Acceleration, true); } @@ -1602,14 +1587,13 @@ void HMI_MaxAccelerationXYZE() { checkkey = MaxJerk; EncoderRate.enabled = false; if (WITHIN(HMI_flag.jerk_axis, X_AXIS, LAST_AXIS)) - planner.set_max_jerk(HMI_flag.jerk_axis, HMI_ValueStruct.Max_Jerk_scaled / 10); + planner.set_max_jerk(HMI_flag.jerk_axis, HMI_ValueStruct.Max_Jerk_scaled / MINUNITMULT); Draw_Edit_Float3(select_jerk.now, HMI_ValueStruct.Max_Jerk_scaled); return; } // MaxJerk limit if (WITHIN(HMI_flag.jerk_axis, X_AXIS, LAST_AXIS)) - NOMORE(HMI_ValueStruct.Max_Jerk_scaled, default_max_jerk[HMI_flag.jerk_axis] * 2 * MINUNITMULT); - NOLESS(HMI_ValueStruct.Max_Jerk_scaled, (MIN_MAXJERK) * MINUNITMULT); + LIMIT(HMI_ValueStruct.Max_Jerk_scaled, min_jerk_edit_values[HMI_flag.jerk_axis] * MINUNITMULT, max_jerk_edit_values[HMI_flag.jerk_axis] * MINUNITMULT); // MaxJerk value Draw_Edit_Float3(select_jerk.now, HMI_ValueStruct.Max_Jerk_scaled, true); } @@ -1623,14 +1607,13 @@ void HMI_StepXYZE() { checkkey = Step; EncoderRate.enabled = false; if (WITHIN(HMI_flag.step_axis, X_AXIS, LAST_AXIS)) - planner.settings.axis_steps_per_mm[HMI_flag.step_axis] = HMI_ValueStruct.Max_Step_scaled / 10; + planner.settings.axis_steps_per_mm[HMI_flag.step_axis] = HMI_ValueStruct.Max_Step_scaled / MINUNITMULT; Draw_Edit_Float3(select_step.now, HMI_ValueStruct.Max_Step_scaled); return; } // Step limit if (WITHIN(HMI_flag.step_axis, X_AXIS, LAST_AXIS)) - NOMORE(HMI_ValueStruct.Max_Step_scaled, 999.9 * MINUNITMULT); - NOLESS(HMI_ValueStruct.Max_Step_scaled, MIN_STEP); + LIMIT(HMI_ValueStruct.Max_Step_scaled, min_steps_edit_values[HMI_flag.step_axis] * MINUNITMULT, max_steps_edit_values[HMI_flag.step_axis] * MINUNITMULT); // Step value Draw_Edit_Float3(select_step.now, HMI_ValueStruct.Max_Step_scaled, true); } diff --git a/Marlin/src/lcd/e3v2/creality/dwin.h b/Marlin/src/lcd/e3v2/creality/dwin.h index 487f309ed996..854a011c5e3f 100644 --- a/Marlin/src/lcd/e3v2/creality/dwin.h +++ b/Marlin/src/lcd/e3v2/creality/dwin.h @@ -27,6 +27,7 @@ #include "dwin_lcd.h" #include "../common/encoder.h" +#include "../common/limits.h" #include "../../../libs/BL24CXX.h" #include "../../../inc/MarlinConfigPre.h" diff --git a/Marlin/src/lcd/e3v2/jyersui/dwin.cpp b/Marlin/src/lcd/e3v2/jyersui/dwin.cpp index cba90c7ac581..5acd402fc74c 100644 --- a/Marlin/src/lcd/e3v2/jyersui/dwin.cpp +++ b/Marlin/src/lcd/e3v2/jyersui/dwin.cpp @@ -121,6 +121,11 @@ #define MIN_BED_TEMP 0 #endif +#define FEEDRATE_UNIT 1 +#define ACCELERATION_UNIT 1 +#define JERK_UNIT 10 +#define STEPS_UNIT 10 + /** * Custom menu items with jyersLCD */ @@ -149,13 +154,6 @@ constexpr uint16_t TROWS = 6, MROWS = TROWS - 1, #define MBASE(L) (49 + MLINE * (L)) -constexpr float default_max_feedrate[] = DEFAULT_MAX_FEEDRATE; -constexpr float default_max_acceleration[] = DEFAULT_MAX_ACCELERATION; -constexpr float default_steps[] = DEFAULT_AXIS_STEPS_PER_UNIT; -#if HAS_CLASSIC_JERK - constexpr float default_max_jerk[] = { DEFAULT_XJERK, DEFAULT_YJERK, DEFAULT_ZJERK, DEFAULT_EJERK }; -#endif - enum SelectItem : uint8_t { PAGE_PRINT = 0, PAGE_PREPARE, @@ -2352,20 +2350,20 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/ case SPEED_X: if (draw) { Draw_Menu_Item(row, ICON_MaxSpeedX, F("X Axis")); - Draw_Float(planner.settings.max_feedrate_mm_s[X_AXIS], row, false, 1); + Draw_Float(planner.settings.max_feedrate_mm_s[X_AXIS], row, false, FEEDRATE_UNIT); } else - Modify_Value(planner.settings.max_feedrate_mm_s[X_AXIS], 0, default_max_feedrate[X_AXIS] * 2, 1); + Modify_Value(planner.settings.max_feedrate_mm_s[X_AXIS], min_feedrate_edit_values[X_AXIS], max_feedrate_edit_values[X_AXIS], FEEDRATE_UNIT); break; #if HAS_Y_AXIS case SPEED_Y: if (draw) { Draw_Menu_Item(row, ICON_MaxSpeedY, F("Y Axis")); - Draw_Float(planner.settings.max_feedrate_mm_s[Y_AXIS], row, false, 1); + Draw_Float(planner.settings.max_feedrate_mm_s[Y_AXIS], row, false, FEEDRATE_UNIT); } else - Modify_Value(planner.settings.max_feedrate_mm_s[Y_AXIS], 0, default_max_feedrate[Y_AXIS] * 2, 1); + Modify_Value(planner.settings.max_feedrate_mm_s[Y_AXIS], min_feedrate_edit_values[Y_AXIS], max_feedrate_edit_values[Y_AXIS], FEEDRATE_UNIT); break; #endif @@ -2373,10 +2371,10 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/ case SPEED_Z: if (draw) { Draw_Menu_Item(row, ICON_MaxSpeedZ, F("Z Axis")); - Draw_Float(planner.settings.max_feedrate_mm_s[Z_AXIS], row, false, 1); + Draw_Float(planner.settings.max_feedrate_mm_s[Z_AXIS], row, false, FEEDRATE_UNIT); } else - Modify_Value(planner.settings.max_feedrate_mm_s[Z_AXIS], 0, default_max_feedrate[Z_AXIS] * 2, 1); + Modify_Value(planner.settings.max_feedrate_mm_s[Z_AXIS], min_feedrate_edit_values[Z_AXIS], max_feedrate_edit_values[Z_AXIS], FEEDRATE_UNIT); break; #endif @@ -2384,10 +2382,10 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/ case SPEED_E: if (draw) { Draw_Menu_Item(row, ICON_MaxSpeedE, F("Extruder")); - Draw_Float(planner.settings.max_feedrate_mm_s[E_AXIS], row, false, 1); + Draw_Float(planner.settings.max_feedrate_mm_s[E_AXIS], row, false, FEEDRATE_UNIT); } else - Modify_Value(planner.settings.max_feedrate_mm_s[E_AXIS], 0, default_max_feedrate[E_AXIS] * 2, 1); + Modify_Value(planner.settings.max_feedrate_mm_s[E_AXIS], min_feedrate_edit_values[E_AXIS], max_feedrate_edit_values[E_AXIS], FEEDRATE_UNIT); break; #endif } @@ -2412,35 +2410,35 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/ case ACCEL_X: if (draw) { Draw_Menu_Item(row, ICON_MaxAccX, F("X Axis")); - Draw_Float(planner.settings.max_acceleration_mm_per_s2[X_AXIS], row, false, 1); + Draw_Float(planner.settings.max_acceleration_mm_per_s2[X_AXIS], row, false, ACCELERATION_UNIT); } else - Modify_Value(planner.settings.max_acceleration_mm_per_s2[X_AXIS], 0, default_max_acceleration[X_AXIS] * 2, 1); + Modify_Value(planner.settings.max_acceleration_mm_per_s2[X_AXIS], min_acceleration_edit_values[X_AXIS], max_acceleration_edit_values[X_AXIS], ACCELERATION_UNIT); break; case ACCEL_Y: if (draw) { Draw_Menu_Item(row, ICON_MaxAccY, F("Y Axis")); - Draw_Float(planner.settings.max_acceleration_mm_per_s2[Y_AXIS], row, false, 1); + Draw_Float(planner.settings.max_acceleration_mm_per_s2[Y_AXIS], row, false, ACCELERATION_UNIT); } else - Modify_Value(planner.settings.max_acceleration_mm_per_s2[Y_AXIS], 0, default_max_acceleration[Y_AXIS] * 2, 1); + Modify_Value(planner.settings.max_acceleration_mm_per_s2[Y_AXIS], min_acceleration_edit_values[Y_AXIS], max_acceleration_edit_values[Y_AXIS], ACCELERATION_UNIT); break; case ACCEL_Z: if (draw) { Draw_Menu_Item(row, ICON_MaxAccZ, F("Z Axis")); - Draw_Float(planner.settings.max_acceleration_mm_per_s2[Z_AXIS], row, false, 1); + Draw_Float(planner.settings.max_acceleration_mm_per_s2[Z_AXIS], row, false, ACCELERATION_UNIT); } else - Modify_Value(planner.settings.max_acceleration_mm_per_s2[Z_AXIS], 0, default_max_acceleration[Z_AXIS] * 2, 1); + Modify_Value(planner.settings.max_acceleration_mm_per_s2[Z_AXIS], min_acceleration_edit_values[Z_AXIS], max_acceleration_edit_values[Z_AXIS], ACCELERATION_UNIT); break; #if HAS_HOTEND case ACCEL_E: if (draw) { Draw_Menu_Item(row, ICON_MaxAccE, F("Extruder")); - Draw_Float(planner.settings.max_acceleration_mm_per_s2[E_AXIS], row, false, 1); + Draw_Float(planner.settings.max_acceleration_mm_per_s2[E_AXIS], row, false, ACCELERATION_UNIT); } else - Modify_Value(planner.settings.max_acceleration_mm_per_s2[E_AXIS], 0, default_max_acceleration[E_AXIS] * 2, 1); + Modify_Value(planner.settings.max_acceleration_mm_per_s2[E_AXIS], min_acceleration_edit_values[E_AXIS], max_acceleration_edit_values[E_AXIS], ACCELERATION_UNIT); break; #endif } @@ -2465,35 +2463,35 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/ case JERK_X: if (draw) { Draw_Menu_Item(row, ICON_MaxSpeedJerkX, F("X Axis")); - Draw_Float(planner.max_jerk.x, row, false, 10); + Draw_Float(planner.max_jerk.x, row, false, JERK_UNIT); } else - Modify_Value(planner.max_jerk.x, 0, default_max_jerk[X_AXIS] * 2, 10); + Modify_Value(planner.max_jerk.x, min_jerk_edit_values[X_AXIS], max_jerk_edit_values[X_AXIS], JERK_UNIT); break; case JERK_Y: if (draw) { Draw_Menu_Item(row, ICON_MaxSpeedJerkY, F("Y Axis")); - Draw_Float(planner.max_jerk.y, row, false, 10); + Draw_Float(planner.max_jerk.y, row, false, JERK_UNIT); } else - Modify_Value(planner.max_jerk.y, 0, default_max_jerk[Y_AXIS] * 2, 10); + Modify_Value(planner.max_jerk.y, min_jerk_edit_values[Y_AXIS], max_jerk_edit_values[Y_AXIS], JERK_UNIT); break; case JERK_Z: if (draw) { Draw_Menu_Item(row, ICON_MaxSpeedJerkZ, F("Z Axis")); - Draw_Float(planner.max_jerk.z, row, false, 10); + Draw_Float(planner.max_jerk.z, row, false, JERK_UNIT); } else - Modify_Value(planner.max_jerk.z, 0, default_max_jerk[Z_AXIS] * 2, 10); + Modify_Value(planner.max_jerk.z, min_jerk_edit_values[Z_AXIS], max_jerk_edit_values[Z_AXIS], JERK_UNIT); break; #if HAS_HOTEND case JERK_E: if (draw) { Draw_Menu_Item(row, ICON_MaxSpeedJerkE, F("Extruder")); - Draw_Float(planner.max_jerk.e, row, false, 10); + Draw_Float(planner.max_jerk.e, row, false, JERK_UNIT); } else - Modify_Value(planner.max_jerk.e, 0, default_max_jerk[E_AXIS] * 2, 10); + Modify_Value(planner.max_jerk.e, min_jerk_edit_values[E_AXIS], max_jerk_edit_values[E_AXIS], JERK_UNIT); break; #endif } @@ -2518,35 +2516,35 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/ case STEPS_X: if (draw) { Draw_Menu_Item(row, ICON_StepX, F("X Axis")); - Draw_Float(planner.settings.axis_steps_per_mm[X_AXIS], row, false, 10); + Draw_Float(planner.settings.axis_steps_per_mm[X_AXIS], row, false, STEPS_UNIT); } else - Modify_Value(planner.settings.axis_steps_per_mm[X_AXIS], 0, default_steps[X_AXIS] * 2, 10); + Modify_Value(planner.settings.axis_steps_per_mm[X_AXIS], min_steps_edit_values[X_AXIS], max_steps_edit_values[X_AXIS], STEPS_UNIT); break; case STEPS_Y: if (draw) { Draw_Menu_Item(row, ICON_StepY, F("Y Axis")); - Draw_Float(planner.settings.axis_steps_per_mm[Y_AXIS], row, false, 10); + Draw_Float(planner.settings.axis_steps_per_mm[Y_AXIS], row, false, STEPS_UNIT); } else - Modify_Value(planner.settings.axis_steps_per_mm[Y_AXIS], 0, default_steps[Y_AXIS] * 2, 10); + Modify_Value(planner.settings.axis_steps_per_mm[Y_AXIS], min_steps_edit_values[Y_AXIS], max_steps_edit_values[Y_AXIS], STEPS_UNIT); break; case STEPS_Z: if (draw) { Draw_Menu_Item(row, ICON_StepZ, F("Z Axis")); - Draw_Float(planner.settings.axis_steps_per_mm[Z_AXIS], row, false, 10); + Draw_Float(planner.settings.axis_steps_per_mm[Z_AXIS], row, false, STEPS_UNIT); } else - Modify_Value(planner.settings.axis_steps_per_mm[Z_AXIS], 0, default_steps[Z_AXIS] * 2, 10); + Modify_Value(planner.settings.axis_steps_per_mm[Z_AXIS], min_steps_edit_values[Z_AXIS], max_steps_edit_values[Z_AXIS], STEPS_UNIT); break; #if HAS_HOTEND case STEPS_E: if (draw) { Draw_Menu_Item(row, ICON_StepE, F("Extruder")); - Draw_Float(planner.settings.axis_steps_per_mm[E_AXIS], row, false, 10); + Draw_Float(planner.settings.axis_steps_per_mm[E_AXIS], row, false, STEPS_UNIT); } else - Modify_Value(planner.settings.axis_steps_per_mm[E_AXIS], 0, 1000, 10); + Modify_Value(planner.settings.axis_steps_per_mm[E_AXIS], min_steps_edit_values[E_AXIS], max_steps_edit_values[E_AXIS], STEPS_UNIT); break; #endif } diff --git a/Marlin/src/lcd/e3v2/jyersui/dwin.h b/Marlin/src/lcd/e3v2/jyersui/dwin.h index 7e213a65e540..cdc6c8e39bf4 100644 --- a/Marlin/src/lcd/e3v2/jyersui/dwin.h +++ b/Marlin/src/lcd/e3v2/jyersui/dwin.h @@ -30,6 +30,7 @@ #include "../common/dwin_font.h" #include "../common/dwin_color.h" #include "../common/encoder.h" +#include "../common/limits.h" #include "../../../libs/BL24CXX.h" #include "../../../inc/MarlinConfigPre.h" diff --git a/Marlin/src/lcd/e3v2/proui/dwin.cpp b/Marlin/src/lcd/e3v2/proui/dwin.cpp index fcceb2d52d51..20a2da529c25 100644 --- a/Marlin/src/lcd/e3v2/proui/dwin.cpp +++ b/Marlin/src/lcd/e3v2/proui/dwin.cpp @@ -177,13 +177,6 @@ // Load and Unload limits #define MAX_LOAD_UNLOAD 500 -// Feedspeed limit (max feedspeed = MAX_FEEDRATE_EDIT_VALUES) -#define MIN_MAXFEEDSPEED 1 -#define MIN_MAXACCELERATION 1 -#define MIN_MAXJERK 0.1 -#define MIN_STEP 1 -#define MAX_STEP 999.9 - // Editable temperature limits #define MIN_ETEMP 0 #define MAX_ETEMP (HEATER_0_MAXTEMP - (HOTEND_OVERSHOOT)) @@ -239,32 +232,6 @@ uint8_t index_file = MROWS; bool hash_changed = true; // Flag to know if message status was changed -constexpr float max_feedrate_edit_values[] = - #ifdef MAX_FEEDRATE_EDIT_VALUES - MAX_FEEDRATE_EDIT_VALUES - #else - { 1000, 1000, 10, 50 } - #endif -; - -constexpr float max_acceleration_edit_values[] = - #ifdef MAX_ACCEL_EDIT_VALUES - MAX_ACCEL_EDIT_VALUES - #else - { 1000, 1000, 200, 2000 } - #endif -; - -#if HAS_CLASSIC_JERK - constexpr float max_jerk_edit_values[] = - #ifdef MAX_JERK_EDIT_VALUES - MAX_JERK_EDIT_VALUES - #else - { DEFAULT_XJERK * 2, DEFAULT_YJERK * 2, DEFAULT_ZJERK * 2, DEFAULT_EJERK * 2 } - #endif - ; -#endif - static uint8_t _percent_done = 0; static uint32_t _remain_time = 0; @@ -2637,36 +2604,36 @@ void TramC () { Tram(4); } #endif void ApplyMaxSpeed() { planner.set_max_feedrate(HMI_value.axis, MenuData.Value / MINUNITMULT); } -void SetMaxSpeedX() { HMI_value.axis = X_AXIS, SetFloatOnClick(MIN_MAXFEEDSPEED, max_feedrate_edit_values[X_AXIS], UNITFDIGITS, planner.settings.max_feedrate_mm_s[X_AXIS], ApplyMaxSpeed); } -void SetMaxSpeedY() { HMI_value.axis = Y_AXIS, SetFloatOnClick(MIN_MAXFEEDSPEED, max_feedrate_edit_values[Y_AXIS], UNITFDIGITS, planner.settings.max_feedrate_mm_s[Y_AXIS], ApplyMaxSpeed); } -void SetMaxSpeedZ() { HMI_value.axis = Z_AXIS, SetFloatOnClick(MIN_MAXFEEDSPEED, max_feedrate_edit_values[Z_AXIS], UNITFDIGITS, planner.settings.max_feedrate_mm_s[Z_AXIS], ApplyMaxSpeed); } +void SetMaxSpeedX() { HMI_value.axis = X_AXIS, SetFloatOnClick(min_feedrate_edit_values[X_AXIS], max_feedrate_edit_values[X_AXIS], UNITFDIGITS, planner.settings.max_feedrate_mm_s[X_AXIS], ApplyMaxSpeed); } +void SetMaxSpeedY() { HMI_value.axis = Y_AXIS, SetFloatOnClick(min_feedrate_edit_values[Y_AXIS], max_feedrate_edit_values[Y_AXIS], UNITFDIGITS, planner.settings.max_feedrate_mm_s[Y_AXIS], ApplyMaxSpeed); } +void SetMaxSpeedZ() { HMI_value.axis = Z_AXIS, SetFloatOnClick(min_feedrate_edit_values[Z_AXIS], max_feedrate_edit_values[Z_AXIS], UNITFDIGITS, planner.settings.max_feedrate_mm_s[Z_AXIS], ApplyMaxSpeed); } #if HAS_HOTEND - void SetMaxSpeedE() { HMI_value.axis = E_AXIS; SetFloatOnClick(MIN_MAXFEEDSPEED, max_feedrate_edit_values[E_AXIS], UNITFDIGITS, planner.settings.max_feedrate_mm_s[E_AXIS], ApplyMaxSpeed); } + void SetMaxSpeedE() { HMI_value.axis = E_AXIS; SetFloatOnClick(min_feedrate_edit_values[E_AXIS], max_feedrate_edit_values[E_AXIS], UNITFDIGITS, planner.settings.max_feedrate_mm_s[E_AXIS], ApplyMaxSpeed); } #endif void ApplyMaxAccel() { planner.set_max_acceleration(HMI_value.axis, MenuData.Value); } -void SetMaxAccelX() { HMI_value.axis = X_AXIS, SetIntOnClick(MIN_MAXACCELERATION, max_acceleration_edit_values[X_AXIS], planner.settings.max_acceleration_mm_per_s2[X_AXIS], ApplyMaxAccel); } -void SetMaxAccelY() { HMI_value.axis = Y_AXIS, SetIntOnClick(MIN_MAXACCELERATION, max_acceleration_edit_values[Y_AXIS], planner.settings.max_acceleration_mm_per_s2[Y_AXIS], ApplyMaxAccel); } -void SetMaxAccelZ() { HMI_value.axis = Z_AXIS, SetIntOnClick(MIN_MAXACCELERATION, max_acceleration_edit_values[Z_AXIS], planner.settings.max_acceleration_mm_per_s2[Z_AXIS], ApplyMaxAccel); } +void SetMaxAccelX() { HMI_value.axis = X_AXIS, SetIntOnClick(min_acceleration_edit_values[X_AXIS], max_acceleration_edit_values[X_AXIS], planner.settings.max_acceleration_mm_per_s2[X_AXIS], ApplyMaxAccel); } +void SetMaxAccelY() { HMI_value.axis = Y_AXIS, SetIntOnClick(min_acceleration_edit_values[Y_AXIS], max_acceleration_edit_values[Y_AXIS], planner.settings.max_acceleration_mm_per_s2[Y_AXIS], ApplyMaxAccel); } +void SetMaxAccelZ() { HMI_value.axis = Z_AXIS, SetIntOnClick(min_acceleration_edit_values[Z_AXIS], max_acceleration_edit_values[Z_AXIS], planner.settings.max_acceleration_mm_per_s2[Z_AXIS], ApplyMaxAccel); } #if HAS_HOTEND - void SetMaxAccelE() { HMI_value.axis = E_AXIS; SetIntOnClick(MIN_MAXACCELERATION, max_acceleration_edit_values[E_AXIS], planner.settings.max_acceleration_mm_per_s2[E_AXIS], ApplyMaxAccel); } + void SetMaxAccelE() { HMI_value.axis = E_AXIS; SetIntOnClick(min_acceleration_edit_values[E_AXIS], max_acceleration_edit_values[E_AXIS], planner.settings.max_acceleration_mm_per_s2[E_AXIS], ApplyMaxAccel); } #endif #if HAS_CLASSIC_JERK void ApplyMaxJerk() { planner.set_max_jerk(HMI_value.axis, MenuData.Value / MINUNITMULT); } - void SetMaxJerkX() { HMI_value.axis = X_AXIS, SetFloatOnClick(MIN_MAXJERK, max_jerk_edit_values[X_AXIS], UNITFDIGITS, planner.max_jerk.x, ApplyMaxJerk); } - void SetMaxJerkY() { HMI_value.axis = Y_AXIS, SetFloatOnClick(MIN_MAXJERK, max_jerk_edit_values[Y_AXIS], UNITFDIGITS, planner.max_jerk.y, ApplyMaxJerk); } - void SetMaxJerkZ() { HMI_value.axis = Z_AXIS, SetFloatOnClick(MIN_MAXJERK, max_jerk_edit_values[Z_AXIS], UNITFDIGITS, planner.max_jerk.z, ApplyMaxJerk); } + void SetMaxJerkX() { HMI_value.axis = X_AXIS, SetFloatOnClick(min_jerk_edit_values[X_AXIS], max_jerk_edit_values[X_AXIS], UNITFDIGITS, planner.max_jerk.x, ApplyMaxJerk); } + void SetMaxJerkY() { HMI_value.axis = Y_AXIS, SetFloatOnClick(min_jerk_edit_values[Y_AXIS], max_jerk_edit_values[Y_AXIS], UNITFDIGITS, planner.max_jerk.y, ApplyMaxJerk); } + void SetMaxJerkZ() { HMI_value.axis = Z_AXIS, SetFloatOnClick(min_jerk_edit_values[Z_AXIS], max_jerk_edit_values[Z_AXIS], UNITFDIGITS, planner.max_jerk.z, ApplyMaxJerk); } #if HAS_HOTEND - void SetMaxJerkE() { HMI_value.axis = E_AXIS; SetFloatOnClick(MIN_MAXJERK, max_jerk_edit_values[E_AXIS], UNITFDIGITS, planner.max_jerk.e, ApplyMaxJerk); } + void SetMaxJerkE() { HMI_value.axis = E_AXIS; SetFloatOnClick(min_jerk_edit_values[E_AXIS], max_jerk_edit_values[E_AXIS], UNITFDIGITS, planner.max_jerk.e, ApplyMaxJerk); } #endif #endif -void SetStepsX() { HMI_value.axis = X_AXIS, SetPFloatOnClick( MIN_STEP, MAX_STEP, UNITFDIGITS); } -void SetStepsY() { HMI_value.axis = Y_AXIS, SetPFloatOnClick( MIN_STEP, MAX_STEP, UNITFDIGITS); } -void SetStepsZ() { HMI_value.axis = Z_AXIS, SetPFloatOnClick( MIN_STEP, MAX_STEP, UNITFDIGITS); } +void SetStepsX() { HMI_value.axis = X_AXIS, SetPFloatOnClick( min_steps_edit_values[X_AXIS], max_steps_edit_values[X_AXIS], UNITFDIGITS); } +void SetStepsY() { HMI_value.axis = Y_AXIS, SetPFloatOnClick( min_steps_edit_values[Y_AXIS], max_steps_edit_values[Y_AXIS], UNITFDIGITS); } +void SetStepsZ() { HMI_value.axis = Z_AXIS, SetPFloatOnClick( min_steps_edit_values[Z_AXIS], max_steps_edit_values[Z_AXIS], UNITFDIGITS); } #if HAS_HOTEND - void SetStepsE() { HMI_value.axis = E_AXIS; SetPFloatOnClick( MIN_STEP, MAX_STEP, UNITFDIGITS); } + void SetStepsE() { HMI_value.axis = E_AXIS; SetPFloatOnClick( min_steps_edit_values[E_AXIS], max_steps_edit_values[E_AXIS], UNITFDIGITS); } #if ENABLED(PIDTEMP) void SetHotendPidT() { SetPIntOnClick(MIN_ETEMP, MAX_ETEMP); } #endif diff --git a/Marlin/src/lcd/e3v2/proui/dwin.h b/Marlin/src/lcd/e3v2/proui/dwin.h index f4c06186916d..bd4b0c546bd4 100644 --- a/Marlin/src/lcd/e3v2/proui/dwin.h +++ b/Marlin/src/lcd/e3v2/proui/dwin.h @@ -31,6 +31,7 @@ #include "dwin_defines.h" #include "dwinui.h" #include "../common/encoder.h" +#include "../common/limits.h" #include "../../../libs/BL24CXX.h" #include "../../../inc/MarlinConfig.h"