3DPrinting/MarlinFirmware
0
0
Fork 0
mirror of https://github.com/MarlinFirmware/Marlin.git synced 2025-02-16 22:37:35 +00:00
Code Issues Releases Wiki Activity

✨ EDITABLE_STEPS_PER_UNIT (#26618)

Browse source 
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
This commit is contained in:
plampix 2024-01-10 07:33:54 +01:00 committed by GitHub
parent 1d46e67de2
commit 854f3315af
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
38 changed files with 723 additions and 619 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
Marlin/Configuration.h
View file

@ -1231,11 +1231,16 @@
/**
* Default Axis Steps Per Unit (linear=steps/mm, rotational=steps/°)
* Override with M92
* Override with M92 (when enabled below)
* X, Y, Z [, I [, J [, K...]]], E0 [, E1[, E2...]]
*/
#define DEFAULT_AXIS_STEPS_PER_UNIT { 80, 80, 400, 500 }
/**
* Enable support for M92. Disable to save at least ~530 bytes of flash.
*/
#define EDITABLE_STEPS_PER_UNIT
/**
* Default Max Feed Rate (linear=mm/s, rotational=°/s)
* Override with M203

8
Marlin/src/feature/encoder_i2c.cpp
View file

@ -422,22 +422,22 @@ void I2CPositionEncoder::calibrate_steps_mm(const uint8_t iter) {
travelledDistance = mm_from_count(ABS(stopCount - startCount));
SERIAL_ECHOLNPGM("Attempted travel: ", travelDistance, "mm");
SERIAL_ECHOLNPGM(" Actual travel: ", travelledDistance, "mm");
SERIAL_ECHOLNPGM(" Actual travel: ", travelledDistance, "mm");
//Calculate new axis steps per unit
// Calculate new axis steps per unit
old_steps_mm = planner.settings.axis_steps_per_mm[encoderAxis];
new_steps_mm = (old_steps_mm * travelDistance) / travelledDistance;
SERIAL_ECHOLNPGM("Old steps/mm: ", old_steps_mm);
SERIAL_ECHOLNPGM("New steps/mm: ", new_steps_mm);
//Save new value
// Save new value
planner.settings.axis_steps_per_mm[encoderAxis] = new_steps_mm;
if (iter > 1) {
total += new_steps_mm;
// swap start and end points so next loop runs from current position
// Swap start and end points so next loop runs from current position
const float tempCoord = startCoord[encoderAxis];
startCoord[encoderAxis] = endCoord[encoderAxis];
endCoord[encoderAxis] = tempCoord;

7
Marlin/src/gcode/config/M92.cpp
View file

@ -20,6 +20,10 @@
*
*/
#include "../../inc/MarlinConfigPre.h"
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
#include "../gcode.h"
#include "../../module/planner.h"
@ -37,6 +41,7 @@
* H<microsteps> - Specify micro-steps to use. Best guess if not supplied.
* L<linear> - Desired layer height in current units. Nearest good heights are shown.
*/
void GcodeSuite::M92() {
const int8_t target_extruder = get_target_extruder_from_command();
@ -127,3 +132,5 @@ void GcodeSuite::M92_report(const bool forReplay/*=true*/, const int8_t e/*=-1*/
UNUSED(e);
#endif
}
#endif // EDITABLE_STEPS_PER_UNIT

5
Marlin/src/gcode/gcode.cpp
View file

@ -669,7 +669,10 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
case 87: M87(); break; // M87: Cancel Hotend Idle Timeout
#endif
case 92: M92(); break; // M92: Set the steps-per-unit for one or more axes
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
case 92: M92(); break; // M92: Set the steps-per-unit for one or more axes
#endif
case 114: M114(); break; // M114: Report current position
#if ENABLED(CAPABILITIES_REPORT)

8
Marlin/src/gcode/gcode.h
View file

@ -128,7 +128,7 @@
* M84 - Disable steppers until next move, or use S<seconds> to specify an idle
* duration after which steppers should turn off. S0 disables the timeout.
* M85 - Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default)
* M92 - Set planner.settings.axis_steps_per_mm for one or more axes.
* M92 - Set planner.settings.axis_steps_per_mm for one or more axes. (Requires EDITABLE_STEPS_PER_UNIT)
*
* M100 - Watch Free Memory (for debugging) (Requires M100_FREE_MEMORY_WATCHER)
*
@ -719,8 +719,10 @@ private:
static void M87();
#endif
static void M92();
static void M92_report(const bool forReplay=true, const int8_t e=-1);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
static void M92();
static void M92_report(const bool forReplay=true, const int8_t e=-1);
#endif
#if ENABLED(M100_FREE_MEMORY_WATCHER)
static void M100();

2
Marlin/src/inc/SanityCheck.h
View file

@ -458,6 +458,8 @@ static_assert(COUNT(arm) == LOGICAL_AXES, "AXIS_RELATIVE_MODES must contain " _L
#if ENABLED(I2C_POSITION_ENCODERS)
#if !ALL(BABYSTEPPING, BABYSTEP_XY)
#error "I2C_POSITION_ENCODERS requires BABYSTEPPING and BABYSTEP_XY."
#elif DISABLED(EDITABLE_STEPS_PER_UNIT)
#error "EDITABLE_STEPS_PER_UNIT is required for I2C_POSITION_ENCODERS."
#elif !WITHIN(I2CPE_ENCODER_CNT, 1, 5)
#error "I2CPE_ENCODER_CNT must be between 1 and 5."
#endif

7
Marlin/src/inc/Warnings.cpp
View file

@ -833,3 +833,10 @@
#if ALL(FT_MOTION, I2S_STEPPER_STREAM)
#warning "FT_MOTION has not been tested with I2S_STEPPER_STREAM."
#endif
/**
* User doesn't have or disabled G92?
*/
#if DISABLED(EDITABLE_STEPS_PER_UNIT)
#warning "EDITABLE_STEPS_PER_UNIT is required to enable G92 runtime configuration of steps-per-unit."
#endif

38
Marlin/src/lcd/e3v2/creality/dwin.cpp
View file

@ -1619,23 +1619,27 @@ void hmiMaxAccelerationXYZE() {
#endif // CLASSIC_JERK
void hmiStepXYZE() {
EncoderState encoder_diffState = encoderReceiveAnalyze();
if (encoder_diffState == ENCODER_DIFF_NO) return;
if (applyEncoder(encoder_diffState, hmiValues.maxStepScaled)) {
checkkey = ID_Step;
encoderRate.enabled = false;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
void hmiStepXYZE() {
EncoderState encoder_diffState = encoderReceiveAnalyze();
if (encoder_diffState == ENCODER_DIFF_NO) return;
if (applyEncoder(encoder_diffState, hmiValues.maxStepScaled)) {
checkkey = ID_Step;
encoderRate.enabled = false;
if (WITHIN(hmiFlag.step_axis, X_AXIS, LAST_AXIS))
planner.settings.axis_steps_per_mm[hmiFlag.step_axis] = hmiValues.maxStepScaled / MINUNITMULT;
drawEditFloat3(select_step.now, hmiValues.maxStepScaled);
return;
}
// Step limit
if (WITHIN(hmiFlag.step_axis, X_AXIS, LAST_AXIS))
planner.settings.axis_steps_per_mm[hmiFlag.step_axis] = hmiValues.maxStepScaled / MINUNITMULT;
drawEditFloat3(select_step.now, hmiValues.maxStepScaled);
return;
LIMIT(hmiValues.maxStepScaled, min_steps_edit_values[hmiFlag.step_axis] * MINUNITMULT, max_steps_edit_values[hmiFlag.step_axis] * MINUNITMULT);
// Step value
drawEditFloat3(select_step.now, hmiValues.maxStepScaled, true);
}
// Step limit
if (WITHIN(hmiFlag.step_axis, X_AXIS, LAST_AXIS))
LIMIT(hmiValues.maxStepScaled, min_steps_edit_values[hmiFlag.step_axis] * MINUNITMULT, max_steps_edit_values[hmiFlag.step_axis] * MINUNITMULT);
// Step value
drawEditFloat3(select_step.now, hmiValues.maxStepScaled, true);
}
#endif // EDITABLE_STEPS_PER_UNIT
// Draw X, Y, Z and blink if in an un-homed or un-trusted state
void _update_axis_value(const AxisEnum axis, const uint16_t x, const uint16_t y, const bool blink, const bool force) {
@ -4279,7 +4283,9 @@ void dwinHandleScreen() {
#if ENABLED(CLASSIC_JERK)
case ID_MaxJerkValue: hmiMaxJerkXYZE(); break;
#endif
case ID_StepValue: hmiStepXYZE(); break;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
case ID_StepValue: hmiStepXYZE(); break;
#endif
default: break;
}
}

5
Marlin/src/lcd/e3v2/creality/dwin.h
View file

@ -204,7 +204,10 @@ void hmiPrintSpeed();
void hmiMaxFeedspeedXYZE();
void hmiMaxAccelerationXYZE();
void hmiMaxJerkXYZE();
void hmiStepXYZE();
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
void hmiStepXYZE();
#endif
void hmiSetLanguageCache();
void updateVariable();

139
Marlin/src/lcd/e3v2/jyersui/dwin.cpp
View file

@ -2364,6 +2364,7 @@ void JyersDWIN::menuItemHandler(const uint8_t menu, const uint8_t item, bool dra
else
drawMenu(ID_MaxAcceleration);
break;
#if ENABLED(CLASSIC_JERK)
case MOTION_JERK:
if (draw)
@ -2372,12 +2373,16 @@ void JyersDWIN::menuItemHandler(const uint8_t menu, const uint8_t item, bool dra
drawMenu(ID_MaxJerk);
break;
#endif
case MOTION_STEPS:
if (draw)
drawMenuItem(row, ICON_Step, GET_TEXT_F(MSG_STEPS_PER_MM), nullptr, true);
else
drawMenu(ID_Steps);
break;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
case MOTION_STEPS:
if (draw)
drawMenuItem(row, ICON_Step, GET_TEXT_F(MSG_STEPS_PER_MM), nullptr, true);
else
drawMenu(ID_Steps);
break;
#endif
#if HAS_HOTEND
case MOTION_FLOW:
if (draw) {
@ -2388,6 +2393,7 @@ void JyersDWIN::menuItemHandler(const uint8_t menu, const uint8_t item, bool dra
modifyValue(planner.flow_percentage[0], MIN_FLOW_RATE, MAX_FLOW_RATE, 1, []{ planner.refresh_e_factor(0); });
break;
#endif
#if ENABLED(LIN_ADVANCE)
case MOTION_LA:
if (draw) {
@ -2613,64 +2619,69 @@ void JyersDWIN::menuItemHandler(const uint8_t menu, const uint8_t item, bool dra
}
break;
#endif
case ID_Steps:
#define STEPS_BACK 0
#define STEPS_X (STEPS_BACK + ENABLED(HAS_X_AXIS))
#define STEPS_Y (STEPS_X + ENABLED(HAS_Y_AXIS))
#define STEPS_Z (STEPS_Y + ENABLED(HAS_Z_AXIS))
#define STEPS_E (STEPS_Z + ENABLED(HAS_HOTEND))
#define STEPS_TOTAL STEPS_E
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
switch (item) {
case STEPS_BACK:
if (draw)
drawMenuItem(row, ICON_Back, GET_TEXT_F(MSG_BACK));
else
drawMenu(ID_Motion, MOTION_STEPS);
break;
#if HAS_X_AXIS
case STEPS_X:
if (draw) {
drawMenuItem(row, ICON_StepX, GET_TEXT_F(MSG_A_STEPS));
drawFloat(planner.settings.axis_steps_per_mm[X_AXIS], row, false, STEPS_UNIT);
}
case ID_Steps:
#define STEPS_BACK 0
#define STEPS_X (STEPS_BACK + ENABLED(HAS_X_AXIS))
#define STEPS_Y (STEPS_X + ENABLED(HAS_Y_AXIS))
#define STEPS_Z (STEPS_Y + ENABLED(HAS_Z_AXIS))
#define STEPS_E (STEPS_Z + ENABLED(HAS_HOTEND))
#define STEPS_TOTAL STEPS_E
switch (item) {
case STEPS_BACK:
if (draw)
drawMenuItem(row, ICON_Back, GET_TEXT_F(MSG_BACK));
else
modifyValue(planner.settings.axis_steps_per_mm[X_AXIS], min_steps_edit_values.x, max_steps_edit_values.x, STEPS_UNIT);
drawMenu(ID_Motion, MOTION_STEPS);
break;
#endif
#if HAS_Y_AXIS
case STEPS_Y:
if (draw) {
drawMenuItem(row, ICON_StepY, GET_TEXT_F(MSG_B_STEPS));
drawFloat(planner.settings.axis_steps_per_mm[Y_AXIS], row, false, STEPS_UNIT);
}
else
modifyValue(planner.settings.axis_steps_per_mm[Y_AXIS], min_steps_edit_values.y, max_steps_edit_values.y, STEPS_UNIT);
break;
#endif
#if HAS_Z_AXIS
case STEPS_Z:
if (draw) {
drawMenuItem(row, ICON_StepZ, GET_TEXT_F(MSG_C_STEPS));
drawFloat(planner.settings.axis_steps_per_mm[Z_AXIS], row, false, STEPS_UNIT);
}
else
modifyValue(planner.settings.axis_steps_per_mm[Z_AXIS], min_steps_edit_values.z, max_steps_edit_values.z, STEPS_UNIT);
break;
#endif
#if HAS_HOTEND
case STEPS_E:
if (draw) {
drawMenuItem(row, ICON_StepE, GET_TEXT_F(MSG_E_STEPS));
drawFloat(planner.settings.axis_steps_per_mm[E_AXIS], row, false, STEPS_UNIT);
}
else
modifyValue(planner.settings.axis_steps_per_mm[E_AXIS], min_steps_edit_values.e, max_steps_edit_values.e, STEPS_UNIT);
break;
#endif
}
break;
#if HAS_X_AXIS
case STEPS_X:
if (draw) {
drawMenuItem(row, ICON_StepX, GET_TEXT_F(MSG_A_STEPS));
drawFloat(planner.settings.axis_steps_per_mm[X_AXIS], row, false, STEPS_UNIT);
}
else
modifyValue(planner.settings.axis_steps_per_mm[X_AXIS], min_steps_edit_values.x, max_steps_edit_values.x, STEPS_UNIT);
break;
#endif
#if HAS_Y_AXIS
case STEPS_Y:
if (draw) {
drawMenuItem(row, ICON_StepY, GET_TEXT_F(MSG_B_STEPS));
drawFloat(planner.settings.axis_steps_per_mm[Y_AXIS], row, false, STEPS_UNIT);
}
else
modifyValue(planner.settings.axis_steps_per_mm[Y_AXIS], min_steps_edit_values.y, max_steps_edit_values.y, STEPS_UNIT);
break;
#endif
#if HAS_Z_AXIS
case STEPS_Z:
if (draw) {
drawMenuItem(row, ICON_StepZ, GET_TEXT_F(MSG_C_STEPS));
drawFloat(planner.settings.axis_steps_per_mm[Z_AXIS], row, false, STEPS_UNIT);
}
else
modifyValue(planner.settings.axis_steps_per_mm[Z_AXIS], min_steps_edit_values.z, max_steps_edit_values.z, STEPS_UNIT);
break;
#endif
#if HAS_HOTEND
case STEPS_E:
if (draw) {
drawMenuItem(row, ICON_StepE, GET_TEXT_F(MSG_E_STEPS));
drawFloat(planner.settings.axis_steps_per_mm[E_AXIS], row, false, STEPS_UNIT);
}
else
modifyValue(planner.settings.axis_steps_per_mm[E_AXIS], min_steps_edit_values.e, max_steps_edit_values.e, STEPS_UNIT);
break;
#endif
}
break;
#endif // EDITABLE_STEPS_PER_UNIT
case ID_Visual:
@ -4173,7 +4184,9 @@ FSTR_P JyersDWIN::getMenuTitle(const uint8_t menu) {
#if ENABLED(CLASSIC_JERK)
case ID_MaxJerk: return F("Max Jerk");
#endif
case ID_Steps: return GET_TEXT_F(MSG_STEPS_PER_MM);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
case ID_Steps: return GET_TEXT_F(MSG_STEPS_PER_MM);
#endif
case ID_Visual: return F("Visual Settings");
case ID_Advanced: return GET_TEXT_F(MSG_ADVANCED_SETTINGS);
#if HAS_BED_PROBE
@ -4250,7 +4263,9 @@ uint8_t JyersDWIN::getMenuSize(const uint8_t menu) {
#if ENABLED(CLASSIC_JERK)
case ID_MaxJerk: return JERK_TOTAL;
#endif
case ID_Steps: return STEPS_TOTAL;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
case ID_Steps: return STEPS_TOTAL;
#endif
case ID_Visual: return VISUAL_TOTAL;
case ID_Advanced: return ADVANCED_TOTAL;
#if HAS_BED_PROBE

2
Marlin/src/lcd/e3v2/jyersui/dwin.h
View file

@ -101,7 +101,7 @@ enum menuID : uint8_t {
ID_MaxSpeed,
ID_MaxAcceleration,
ID_MaxJerk,
ID_Steps,
OPTITEM(EDITABLE_STEPS_PER_UNIT, ID_Steps)
ID_Visual,
ID_ColorSettings,
ID_Advanced,

44
Marlin/src/lcd/e3v2/proui/dwin.cpp
View file

@ -3528,7 +3528,9 @@ void drawMotionMenu() {
#if ENABLED(ADAPTIVE_STEP_SMOOTHING)
EDIT_ITEM(ICON_UBLActive, MSG_STEP_SMOOTHING, onDrawChkbMenu, setAdaptiveStepSmoothing, &hmiData.adaptiveStepSmoothing);
#endif
MENU_ITEM(ICON_Step, MSG_STEPS_PER_MM, onDrawSteps, drawStepsMenu);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
MENU_ITEM(ICON_Step, MSG_STEPS_PER_MM, onDrawSteps, drawStepsMenu);
#endif
EDIT_ITEM(ICON_Flow, MSG_FLOW, onDrawPIntMenu, setFlow, &planner.flow_percentage[0]);
EDIT_ITEM(ICON_Speed, MSG_SPEED, onDrawPIntMenu, setSpeed, &feedrate_percentage);
}
@ -3703,25 +3705,29 @@ void drawMaxAccelMenu() {
#endif // CLASSIC_JERK
void drawStepsMenu() {
checkkey = ID_Menu;
if (SET_MENU_R(stepsMenu, selrect({1, 16, 28, 13}), MSG_STEPS_PER_MM, 5)) {
BACK_ITEM(drawMotionMenu);
#if HAS_X_AXIS
EDIT_ITEM(ICON_StepX, MSG_A_STEPS, onDrawStepsX, setStepsX, &planner.settings.axis_steps_per_mm[X_AXIS]);
#endif
#if HAS_Y_AXIS
EDIT_ITEM(ICON_StepY, MSG_B_STEPS, onDrawStepsY, setStepsY, &planner.settings.axis_steps_per_mm[Y_AXIS]);
#endif
#if HAS_Z_AXIS
EDIT_ITEM(ICON_StepZ, MSG_C_STEPS, onDrawStepsZ, setStepsZ, &planner.settings.axis_steps_per_mm[Z_AXIS]);
#endif
#if HAS_HOTEND
EDIT_ITEM(ICON_StepE, MSG_E_STEPS, onDrawStepsE, setStepsE, &planner.settings.axis_steps_per_mm[E_AXIS]);
#endif
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
void drawStepsMenu() {
checkkey = ID_Menu;
if (SET_MENU_R(stepsMenu, selrect({1, 16, 28, 13}), MSG_STEPS_PER_MM, 5)) {
BACK_ITEM(drawMotionMenu);
#if HAS_X_AXIS
EDIT_ITEM(ICON_StepX, MSG_A_STEPS, onDrawStepsX, setStepsX, &planner.settings.axis_steps_per_mm[X_AXIS]);
#endif
#if HAS_Y_AXIS
EDIT_ITEM(ICON_StepY, MSG_B_STEPS, onDrawStepsY, setStepsY, &planner.settings.axis_steps_per_mm[Y_AXIS]);
#endif
#if HAS_Z_AXIS
EDIT_ITEM(ICON_StepZ, MSG_C_STEPS, onDrawStepsZ, setStepsZ, &planner.settings.axis_steps_per_mm[Z_AXIS]);
#endif
#if HAS_HOTEND
EDIT_ITEM(ICON_StepE, MSG_E_STEPS, onDrawStepsE, setStepsE, &planner.settings.axis_steps_per_mm[E_AXIS]);
#endif
}
updateMenu(stepsMenu);
}
updateMenu(stepsMenu);
}
#endif
//=============================================================================
// UI editable custom colors

4
Marlin/src/lcd/e3v2/proui/dwin.h
View file

@ -345,7 +345,9 @@ void drawMaxAccelMenu();
#if ENABLED(CLASSIC_JERK)
void drawMaxJerkMenu();
#endif
void drawStepsMenu();
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
void drawStepsMenu();
#endif
#if ANY(HAS_BED_PROBE, BABYSTEPPING)
void drawZOffsetWizMenu();
#endif

60
Marlin/src/lcd/extui/dgus/DGUSScreenHandler.cpp
View file

@ -469,36 +469,40 @@ void DGUSScreenHandler::handleSettings(DGUS_VP_Variable &var, void *val_ptr) {
}
}
void DGUSScreenHandler::handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t value_raw = BE16_P(val_ptr);
const float value = (float)value_raw / 10;
ExtUI::axis_t axis;
switch (var.VP) {
case VP_X_STEP_PER_MM: axis = ExtUI::axis_t::X; break;
case VP_Y_STEP_PER_MM: axis = ExtUI::axis_t::Y; break;
case VP_Z_STEP_PER_MM: axis = ExtUI::axis_t::Z; break;
default: return;
}
ExtUI::setAxisSteps_per_mm(value, axis);
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
void DGUSScreenHandler::handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t value_raw = BE16_P(val_ptr);
const float value = (float)value_raw / 10;
ExtUI::extruder_t extruder;
switch (var.VP) {
default: return;
#if HAS_EXTRUDERS
case VP_E0_STEP_PER_MM: extruder = ExtUI::extruder_t::E0; break;
#if HAS_MULTI_EXTRUDER
case VP_E1_STEP_PER_MM: extruder = ExtUI::extruder_t::E1; break;
#endif
#endif
void DGUSScreenHandler::handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t value_raw = BE16_P(val_ptr);
const float value = (float)value_raw / 10;
ExtUI::axis_t axis;
switch (var.VP) {
case VP_X_STEP_PER_MM: axis = ExtUI::axis_t::X; break;
case VP_Y_STEP_PER_MM: axis = ExtUI::axis_t::Y; break;
case VP_Z_STEP_PER_MM: axis = ExtUI::axis_t::Z; break;
default: return;
}
ExtUI::setAxisSteps_per_mm(value, axis);
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
ExtUI::setAxisSteps_per_mm(value, extruder);
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandler::handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t value_raw = BE16_P(val_ptr);
const float value = (float)value_raw / 10;
ExtUI::extruder_t extruder;
switch (var.VP) {
default: return;
#if HAS_EXTRUDERS
case VP_E0_STEP_PER_MM: extruder = ExtUI::extruder_t::E0; break;
#if HAS_MULTI_EXTRUDER
case VP_E1_STEP_PER_MM: extruder = ExtUI::extruder_t::E1; break;
#endif
#endif
}
ExtUI::setAxisSteps_per_mm(value, extruder);
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // EDITABLE_STEPS_PER_UNIT
#if HAS_PID_HEATING
void DGUSScreenHandler::handlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr) {

7
Marlin/src/lcd/extui/dgus/DGUSScreenHandlerBase.h
View file

@ -80,8 +80,11 @@ public:
#endif
// Hook for settings
static void handleSettings(DGUS_VP_Variable &var, void *val_ptr);
static void handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
static void handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_PID_HEATING
// Hook for "Change this temperature PID para"

16
Marlin/src/lcd/extui/dgus/fysetc/DGUSDisplayDef.cpp
View file

@ -431,13 +431,15 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
VPHELPER_STR(VP_PrintsTotal, nullptr, VP_PrintsTotal_LEN, nullptr, screen.sendPrintsTotalToDisplay),
#endif
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_EXTRUDERS
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_MULTI_EXTRUDER
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_EXTRUDERS
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_MULTI_EXTRUDER
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#endif
#endif
#endif

16
Marlin/src/lcd/extui/dgus/hiprecy/DGUSDisplayDef.cpp
View file

@ -424,13 +424,15 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
VPHELPER_STR(VP_PrintsTotal, nullptr, VP_PrintsTotal_LEN, nullptr, screen.sendPrintsTotalToDisplay),
#endif
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_HOTEND
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_HOTEND
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#endif
#endif
#endif

18
Marlin/src/lcd/extui/dgus/mks/DGUSDisplayDef.cpp
View file

@ -646,9 +646,11 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
VPHELPER_STR(VP_PrintsTotal, nullptr, VP_PrintsTotal_LEN, nullptr, screen.sendPrintsTotalToDisplay),
#endif
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<0>),
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<0>),
#endif
VPHELPER(VP_X_MAX_SPEED, &planner.settings.max_feedrate_mm_s[X_AXIS], screen.handleMaxSpeedChange, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Y_MAX_SPEED, &planner.settings.max_feedrate_mm_s[Y_AXIS], screen.handleMaxSpeedChange, screen.sendFloatAsIntValueToDisplay<0>),
@ -742,10 +744,12 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
VPHELPER(VP_AutoTurnOffSw, nullptr, screen.getTurnOffCtrl, nullptr),
#if HAS_HOTEND
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<0>),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<0>),
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
#if HAS_HOTEND
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<0>),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<0>),
#endif
#endif
#endif

62
Marlin/src/lcd/extui/dgus/mks/DGUSScreenHandler.cpp
View file

@ -872,40 +872,44 @@ void DGUSScreenHandlerMKS::handleChangeLevelPoint(DGUS_VP_Variable &var, void *v
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t raw = BE16_P(val_ptr);
const float value = (float)raw;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
ExtUI::axis_t axis;
switch (var.VP) {
default: return;
case VP_X_STEP_PER_MM: axis = ExtUI::axis_t::X; break;
case VP_Y_STEP_PER_MM: axis = ExtUI::axis_t::Y; break;
case VP_Z_STEP_PER_MM: axis = ExtUI::axis_t::Z; break;
void DGUSScreenHandlerMKS::handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t raw = BE16_P(val_ptr);
const float value = (float)raw;
ExtUI::axis_t axis;
switch (var.VP) {
default: return;
case VP_X_STEP_PER_MM: axis = ExtUI::axis_t::X; break;
case VP_Y_STEP_PER_MM: axis = ExtUI::axis_t::Y; break;
case VP_Z_STEP_PER_MM: axis = ExtUI::axis_t::Z; break;
}
ExtUI::setAxisSteps_per_mm(value, axis);
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
ExtUI::setAxisSteps_per_mm(value, axis);
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t raw = BE16_P(val_ptr);
const float value = (float)raw;
void DGUSScreenHandlerMKS::handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t raw = BE16_P(val_ptr);
const float value = (float)raw;
ExtUI::extruder_t extruder;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_STEP_PER_MM: extruder = ExtUI::extruder_t::E0; break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_STEP_PER_MM: extruder = ExtUI::extruder_t::E1; break;
#endif
ExtUI::extruder_t extruder;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_STEP_PER_MM: extruder = ExtUI::extruder_t::E0; break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_STEP_PER_MM: extruder = ExtUI::extruder_t::E1; break;
#endif
}
ExtUI::setAxisSteps_per_mm(value, extruder);
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
ExtUI::setAxisSteps_per_mm(value, extruder);
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // EDITABLE_STEPS_PER_UNIT
void DGUSScreenHandlerMKS::handleMaxSpeedChange(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t raw = BE16_P(val_ptr);

7
Marlin/src/lcd/extui/dgus/mks/DGUSScreenHandler.h
View file

@ -63,8 +63,11 @@ public:
static void lcdBLKAdjust(DGUS_VP_Variable &var, void *val_ptr);
static void sdFileBack(DGUS_VP_Variable &var, void *val_ptr);
static void handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
static void handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
#endif
static void handleMaxSpeedChange(DGUS_VP_Variable &var, void *val_ptr);
static void handleExtruderMaxSpeedChange(DGUS_VP_Variable &var, void *val_ptr);
static void handleAccChange(DGUS_VP_Variable &var, void *val_ptr);

16
Marlin/src/lcd/extui/dgus/origin/DGUSDisplayDef.cpp
View file

@ -232,13 +232,15 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
VPHELPER_STR(VP_PrintsTotal, nullptr, VP_PrintsTotal_LEN, nullptr, screen.sendPrintsTotalToDisplay),
#endif
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_HOTEND
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_HOTEND
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#endif
#endif
#endif

13
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.h
View file

@ -51,11 +51,14 @@ namespace DGUSRxHandler {
float maxJerk = dgus.fromFixedPoint<uint16_t, float, 2>(Endianness::fromBE_P<uint16_t>(data));
ExtUI::setAxisMaxJerk_mm_s(maxJerk, axis);
}
template <typename T, T axis>
void stepsPerMM(DGUS_VP &vp, void *data) {
float stepsPerMm = dgus.fromFixedPoint<uint16_t, float, 1>(Endianness::fromBE_P<uint16_t>(data));
ExtUI::setAxisSteps_per_mm(stepsPerMm, axis);
}
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
template <typename T, T axis>
void stepsPerMM(DGUS_VP &vp, void *data) {
float stepsPerMm = dgus.fromFixedPoint<uint16_t, float, 1>(Endianness::fromBE_P<uint16_t>(data));
ExtUI::setAxisSteps_per_mm(stepsPerMm, axis);
}
#endif
#if ENABLED(PIDTEMP)
template <ExtUI::extruder_t extruder>

55
Marlin/src/lcd/extui/ia_creality/ia_creality_rts.cpp
View file

@ -654,12 +654,19 @@ void RTS::handleData() {
switch (recdat.addr) {
case Flowrate:
case StepMM_X ... StepMM_E:
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
case StepMM_X ... StepMM_E:
#endif
case ProbeOffset_X ... ProbeOffset_Y:
case HotendPID_AutoTmp ... BedPID_AutoTmp:
case HotendPID_P ... HotendPID_D:
case BedPID_P ... BedPID_D:
case T2Offset_X ... T2StepMM_E:
#if ENABLED(DUAL_X_CARRIAGE)
case T2Offset_X ... T2Offset_Z
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
case T2StepMM_E:
#endif
#endif
case Accel_X ... Accel_E:
case Feed_X ... Feed_E:
case Jerk_X ... Jerk_E:
@ -940,25 +947,33 @@ void RTS::handleData() {
tmp_float_handling = (float(recdat.data[0]) - 65536) / 100;
else
tmp_float_handling = float(recdat.data[0]) / 100;
if (recdat.addr == StepMM_X) {
setAxisSteps_per_mm(tmp_float_handling * 10, X);
}
else if (recdat.addr == StepMM_Y) {
setAxisSteps_per_mm(tmp_float_handling * 10, Y);
}
else if (recdat.addr == StepMM_Z) {
setAxisSteps_per_mm(tmp_float_handling * 10, Z);
}
else if (recdat.addr == StepMM_E) {
setAxisSteps_per_mm(tmp_float_handling * 10, E0);
#if DISABLED(DUAL_X_CARRIAGE)
setAxisSteps_per_mm(tmp_float_handling * 10, E1);
#endif
}
#if ENABLED(DUAL_X_CARRIAGE)
else if (recdat.addr == T2StepMM_E) {
setAxisSteps_per_mm(tmp_float_handling * 10, E1);
if (false) {}
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
else if (recdat.addr == StepMM_X) {
setAxisSteps_per_mm(tmp_float_handling * 10, X);
}
else if (recdat.addr == StepMM_Y) {
setAxisSteps_per_mm(tmp_float_handling * 10, Y);
}
else if (recdat.addr == StepMM_Z) {
setAxisSteps_per_mm(tmp_float_handling * 10, Z);
}
else if (recdat.addr == StepMM_E) {
setAxisSteps_per_mm(tmp_float_handling * 10, E0);
#if DISABLED(DUAL_X_CARRIAGE)
setAxisSteps_per_mm(tmp_float_handling * 10, E1);
#endif
}
#endif // EDITABLE_STEPS_PER_UNIT
#if ENABLED(DUAL_X_CARRIAGE)
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
else if (recdat.addr == T2StepMM_E) {
setAxisSteps_per_mm(tmp_float_handling * 10, E1);
}
#endif
else if (recdat.addr == T2Offset_X) {
setNozzleOffset_mm(tmp_float_handling * 10, X, E1);
}

42
Marlin/src/lcd/extui/mks_ui/draw_dialog.cpp
View file

@ -380,6 +380,7 @@ void lv_draw_dialog(uint8_t type) {
lv_label_set_text(labelDialog, DIALOG_UPDATE_NO_DEVICE_EN);
lv_obj_align(labelDialog, nullptr, LV_ALIGN_CENTER, 0, -20);
}
#if ENABLED(MKS_WIFI_MODULE)
else if (DIALOG_IS(TYPE_UPLOAD_FILE)) {
if (upload_result == 1) {
@ -391,28 +392,12 @@ void lv_draw_dialog(uint8_t type) {
lv_obj_align(labelDialog, nullptr, LV_ALIGN_CENTER, 0, -20);
}
else if (upload_result == 3) {
char buf[200];
int _index = 0;
strcpy_P(buf, PSTR(DIALOG_UPLOAD_FINISH_EN));
_index = strlen(buf);
buf[_index++] = '\n';
strcat_P(buf, PSTR(DIALOG_UPLOAD_SIZE_EN));
_index = strlen(buf);
buf[_index++] = ':';
sprintf_P(&buf[_index], PSTR(" %d KBytes\n"), (int)(upload_size / 1024));
strcat_P(buf, PSTR(DIALOG_UPLOAD_TIME_EN));
_index = strlen(buf);
buf[_index++] = ':';
sprintf_P(&buf[_index], PSTR(" %d s\n"), (int)upload_time_sec);
strcat_P(buf, PSTR(DIALOG_UPLOAD_SPEED_EN));
_index = strlen(buf);
buf[_index++] = ':';
sprintf_P(&buf[_index], PSTR(" %d KBytes/s\n"), (int)(upload_size / upload_time_sec / 1024));
MString<200> buf(
F(DIALOG_UPLOAD_FINISH_EN), '\n',
F(DIALOG_UPLOAD_SIZE_EN), F(": "), int(upload_size / 1024), F(" KBytes\n"),
F(DIALOG_UPLOAD_TIME_EN), F(": "), int(upload_time_sec), F(" s\n"),
F(DIALOG_UPLOAD_SPEED_EN), F(": "), int(upload_size / upload_time_sec / 1024), F(" KBytes/s\n"),
);
lv_label_set_text(labelDialog, buf);
lv_obj_align(labelDialog, nullptr, LV_ALIGN_CENTER, 0, -20);
}
@ -422,6 +407,7 @@ void lv_draw_dialog(uint8_t type) {
lv_obj_align(labelDialog, nullptr, LV_ALIGN_CENTER, 0, -20);
}
#endif // MKS_WIFI_MODULE
else if (DIALOG_IS(TYPE_FILAMENT_LOAD_HEAT)) {
lv_label_set_text(labelDialog, filament_menu.filament_dialog_load_heat);
lv_obj_align(labelDialog, nullptr, LV_ALIGN_CENTER, 0, -20);
@ -491,7 +477,11 @@ void filament_dialog_handle() {
planner.synchronize();
uiCfg.filament_loading_time_flg = true;
uiCfg.filament_loading_time_cnt = 0;
sprintf_P(public_buf_m, PSTR("T%d\nG91\nG1 E%d F%d\nG90"), uiCfg.extruderIndex, gCfgItems.filamentchange_load_length, gCfgItems.filamentchange_load_speed);
#if HAS_TOOLCHANGE
sprintf_P(public_buf_m, PSTR("T%d\nG91\nG1 E%d F%d\nG90"), uiCfg.extruderIndex, gCfgItems.filamentchange_load_length, gCfgItems.filamentchange_load_speed);
#else
sprintf_P(public_buf_m, PSTR("G91\nG1 E%d F%d\nG90"), gCfgItems.filamentchange_load_length, gCfgItems.filamentchange_load_speed);
#endif
queue.inject(public_buf_m);
}
if (uiCfg.filament_heat_completed_unload) {
@ -501,7 +491,11 @@ void filament_dialog_handle() {
planner.synchronize();
uiCfg.filament_unloading_time_flg = true;
uiCfg.filament_unloading_time_cnt = 0;
sprintf_P(public_buf_m, PSTR("T%d\nG91\nG1 E-%d F%d\nG90"), uiCfg.extruderIndex, gCfgItems.filamentchange_unload_length, gCfgItems.filamentchange_unload_speed);
#if HAS_TOOLCHANGE
sprintf_P(public_buf_m, PSTR("T%d\nG91\nG1 E-%d F%d\nG90"), uiCfg.extruderIndex, gCfgItems.filamentchange_unload_length, gCfgItems.filamentchange_unload_speed);
#else
sprintf_P(public_buf_m, PSTR("G91\nG1 E-%d F%d\nG90"), gCfgItems.filamentchange_unload_length, gCfgItems.filamentchange_unload_speed);
#endif
queue.inject(public_buf_m);
}

44
Marlin/src/lcd/extui/mks_ui/draw_motor_settings.cpp
View file

@ -34,7 +34,7 @@ static lv_obj_t *scr;
enum {
ID_MOTOR_RETURN = 1,
ID_MOTOR_STEPS,
OPTITEM(EDITABLE_STEPS_PER_UNIT, ID_MOTOR_STEPS)
ID_MOTOR_TMC_CURRENT,
ID_MOTOR_STEP_MODE,
ID_HOME_SENSE
@ -44,26 +44,20 @@ static void event_handler(lv_obj_t *obj, lv_event_t event) {
if (event != LV_EVENT_RELEASED) return;
lv_clear_motor_settings();
switch (obj->mks_obj_id) {
case ID_MOTOR_RETURN:
draw_return_ui();
break;
case ID_MOTOR_STEPS:
lv_draw_step_settings();
break;
case ID_MOTOR_RETURN: draw_return_ui(); break;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
case ID_MOTOR_STEPS: lv_draw_step_settings(); break;
#endif
#if USE_SENSORLESS
case ID_HOME_SENSE:
lv_draw_homing_sensitivity_settings();
break;
case ID_HOME_SENSE: lv_draw_homing_sensitivity_settings(); break;
#endif
#if HAS_TRINAMIC_CONFIG
case ID_MOTOR_TMC_CURRENT:
lv_draw_tmc_current_settings();
break;
case ID_MOTOR_TMC_CURRENT: lv_draw_tmc_current_settings(); break;
#if HAS_STEALTHCHOP
case ID_MOTOR_STEP_MODE:
lv_draw_tmc_step_mode_settings();
break;
case ID_MOTOR_STEP_MODE: lv_draw_tmc_step_mode_settings(); break;
#endif
#endif
}
@ -73,17 +67,19 @@ void lv_draw_motor_settings() {
int index = 0;
scr = lv_screen_create(MOTOR_SETTINGS_UI, machine_menu.MotorConfTitle);
lv_screen_menu_item(scr, machine_menu.StepsConf, PARA_UI_POS_X, PARA_UI_POS_Y, event_handler, ID_MOTOR_STEPS, index++);
#if USE_SENSORLESS
lv_screen_menu_item(scr, machine_menu.HomingSensitivityConf, PARA_UI_POS_X, PARA_UI_POS_Y * (index + 1), event_handler, ID_HOME_SENSE, index);
index++;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
lv_screen_menu_item(scr, machine_menu.StepsConf, PARA_UI_POS_X, PARA_UI_POS_Y, event_handler, ID_MOTOR_STEPS, index++);
#endif
#if USE_SENSORLESS
lv_screen_menu_item(scr, machine_menu.HomingSensitivityConf, PARA_UI_POS_X, PARA_UI_POS_Y * (index + 1), event_handler, ID_HOME_SENSE, index++);
#endif
#if HAS_TRINAMIC_CONFIG
lv_screen_menu_item(scr, machine_menu.TMCcurrentConf, PARA_UI_POS_X, PARA_UI_POS_Y * (index + 1), event_handler, ID_MOTOR_TMC_CURRENT, index);
index++;
lv_screen_menu_item(scr, machine_menu.TMCcurrentConf, PARA_UI_POS_X, PARA_UI_POS_Y * (index + 1), event_handler, ID_MOTOR_TMC_CURRENT, index++);
#if HAS_STEALTHCHOP
lv_screen_menu_item(scr, machine_menu.TMCStepModeConf, PARA_UI_POS_X, PARA_UI_POS_Y * (index + 1), event_handler, ID_MOTOR_STEP_MODE, index);
index++;
lv_screen_menu_item(scr, machine_menu.TMCStepModeConf, PARA_UI_POS_X, PARA_UI_POS_Y * (index + 1), event_handler, ID_MOTOR_STEP_MODE, index++);
#endif
#endif
lv_big_button_create(scr, "F:/bmp_back70x40.bin", common_menu.text_back, PARA_UI_BACK_POS_X + 10, PARA_UI_BACK_POS_Y, event_handler, ID_MOTOR_RETURN, true);

473
Marlin/src/lcd/extui/mks_ui/draw_number_key.cpp
View file

@ -56,15 +56,9 @@ static bool point_flag = true;
enum {
ID_NUM_KEY1 = 1,
ID_NUM_KEY2,
ID_NUM_KEY3,
ID_NUM_KEY4,
ID_NUM_KEY5,
ID_NUM_KEY6,
ID_NUM_KEY7,
ID_NUM_KEY8,
ID_NUM_KEY9,
ID_NUM_KEY0,
ID_NUM_KEY2, ID_NUM_KEY3, ID_NUM_KEY4,
ID_NUM_KEY5, ID_NUM_KEY6, ID_NUM_KEY7,
ID_NUM_KEY8, ID_NUM_KEY9, ID_NUM_KEY0,
ID_NUM_BACK,
ID_NUM_RESET,
ID_NUM_CONFIRM,
@ -86,201 +80,136 @@ static void disp_key_value() {
case TravelAcceleration:
dtostrf(planner.settings.travel_acceleration, 1, 1, public_buf_m);
break;
case XAcceleration:
itoa(planner.settings.max_acceleration_mm_per_s2[X_AXIS], public_buf_m, 10);
break;
case YAcceleration:
itoa(planner.settings.max_acceleration_mm_per_s2[Y_AXIS], public_buf_m, 10);
break;
case ZAcceleration:
itoa(planner.settings.max_acceleration_mm_per_s2[Z_AXIS], public_buf_m, 10);
break;
case E0Acceleration:
itoa(planner.settings.max_acceleration_mm_per_s2[E_AXIS], public_buf_m, 10);
break;
case E1Acceleration:
itoa(planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(1)], public_buf_m, 10);
break;
case XMaxFeedRate:
dtostrf(planner.settings.max_feedrate_mm_s[X_AXIS], 1, 1, public_buf_m);
break;
case YMaxFeedRate:
dtostrf(planner.settings.max_feedrate_mm_s[Y_AXIS], 1, 1, public_buf_m);
break;
case ZMaxFeedRate:
dtostrf(planner.settings.max_feedrate_mm_s[Z_AXIS], 1, 1, public_buf_m);
break;
case E0MaxFeedRate:
dtostrf(planner.settings.max_feedrate_mm_s[E_AXIS], 1, 1, public_buf_m);
break;
case E1MaxFeedRate:
dtostrf(planner.settings.max_feedrate_mm_s[E_AXIS_N(1)], 1, 1, public_buf_m);
break;
case XJerk:
#if ENABLED(CLASSIC_JERK)
dtostrf(planner.max_jerk.x, 1, 1, public_buf_m);
#endif
break;
case YJerk:
#if ENABLED(CLASSIC_JERK)
dtostrf(planner.max_jerk.y, 1, 1, public_buf_m);
#endif
break;
case ZJerk:
#if ENABLED(CLASSIC_JERK)
dtostrf(planner.max_jerk.z, 1, 1, public_buf_m);
#endif
break;
case EJerk:
#if ENABLED(CLASSIC_JERK)
dtostrf(planner.max_jerk.e, 1, 1, public_buf_m);
#endif
break;
case Xstep:
dtostrf(planner.settings.axis_steps_per_mm[X_AXIS], 1, 1, public_buf_m);
break;
case Ystep:
dtostrf(planner.settings.axis_steps_per_mm[Y_AXIS], 1, 1, public_buf_m);
break;
case Zstep:
dtostrf(planner.settings.axis_steps_per_mm[Z_AXIS], 1, 1, public_buf_m);
break;
case E0step:
dtostrf(planner.settings.axis_steps_per_mm[E_AXIS], 1, 1, public_buf_m);
break;
case E1step:
dtostrf(planner.settings.axis_steps_per_mm[E_AXIS_N(1)], 1, 1, public_buf_m);
break;
case Xcurrent:
#if AXIS_IS_TMC(X)
milliamps = stepperX.getMilliamps();
dtostrf(milliamps, 1, 1, public_buf_m);
#endif
break;
case Ycurrent:
#if AXIS_IS_TMC(Y)
milliamps = stepperY.getMilliamps();
dtostrf(milliamps, 1, 1, public_buf_m);
#endif
break;
case Zcurrent:
#if AXIS_IS_TMC(Z)
milliamps = stepperZ.getMilliamps();
dtostrf(milliamps, 1, 1, public_buf_m);
#endif
break;
case E0current:
#if AXIS_IS_TMC(E0)
milliamps = stepperE0.getMilliamps();
dtostrf(milliamps, 1, 1, public_buf_m);
#endif
break;
case E1current:
#if AXIS_IS_TMC(E1)
milliamps = stepperE1.getMilliamps();
dtostrf(milliamps, 1, 1, public_buf_m);
#endif
break;
case pause_pos_x:
dtostrf(gCfgItems.pausePosX, 1, 1, public_buf_m);
break;
case pause_pos_y:
dtostrf(gCfgItems.pausePosY, 1, 1, public_buf_m);
break;
case pause_pos_z:
dtostrf(gCfgItems.pausePosZ, 1, 1, public_buf_m);
break;
case level_pos_x1:
itoa(gCfgItems.trammingPos[0].x, public_buf_m, 10);
break;
case level_pos_y1:
itoa(gCfgItems.trammingPos[0].y, public_buf_m, 10);
break;
case level_pos_x2:
itoa(gCfgItems.trammingPos[1].x, public_buf_m, 10);
break;
case level_pos_y2:
itoa(gCfgItems.trammingPos[1].y, public_buf_m, 10);
break;
case level_pos_x3:
itoa(gCfgItems.trammingPos[2].x, public_buf_m, 10);
break;
case level_pos_y3:
itoa(gCfgItems.trammingPos[2].y, public_buf_m, 10);
break;
case level_pos_x4:
itoa(gCfgItems.trammingPos[3].x, public_buf_m, 10);
break;
case level_pos_y4:
itoa(gCfgItems.trammingPos[3].y, public_buf_m, 10);
break;
case level_pos_x5:
itoa(gCfgItems.trammingPos[4].x, public_buf_m, 10);
break;
case level_pos_y5:
itoa(gCfgItems.trammingPos[4].y, public_buf_m, 10);
break;
#if HAS_BED_PROBE
case x_offset:
#if HAS_PROBE_XY_OFFSET
dtostrf(probe.offset.x, 1, 3, public_buf_m);
#endif
break;
case y_offset:
#if HAS_PROBE_XY_OFFSET
dtostrf(probe.offset.y, 1, 3, public_buf_m);
#endif
break;
case z_offset:
dtostrf(probe.offset.z, 1, 3, public_buf_m);
break;
#if HAS_X_AXIS
case XAcceleration: itoa(planner.settings.max_acceleration_mm_per_s2[X_AXIS], public_buf_m, 10); break;
#endif
case load_length:
itoa(gCfgItems.filamentchange_load_length, public_buf_m, 10);
break;
case load_speed:
itoa(gCfgItems.filamentchange_load_speed, public_buf_m, 10);
break;
case unload_length:
itoa(gCfgItems.filamentchange_unload_length, public_buf_m, 10);
break;
case unload_speed:
itoa(gCfgItems.filamentchange_unload_speed, public_buf_m, 10);
break;
case filament_temp:
itoa(gCfgItems.filament_limit_temp, public_buf_m, 10);
break;
case x_sensitivity:
#if X_SENSORLESS
itoa(TERN(X_SENSORLESS, stepperX.homing_threshold(), 0), public_buf_m, 10);
#if HAS_Y_AXIS
case YAcceleration: itoa(planner.settings.max_acceleration_mm_per_s2[Y_AXIS], public_buf_m, 10); break;
#endif
#if HAS_Z_AXIS
case ZAcceleration: itoa(planner.settings.max_acceleration_mm_per_s2[Z_AXIS], public_buf_m, 10); break;
#endif
#if HAS_EXTRUDERS
case E0Acceleration:
itoa(planner.settings.max_acceleration_mm_per_s2[E_AXIS], public_buf_m, 10);
break;
#if HAS_MULTI_EXTRUDER
case E1Acceleration:
itoa(planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(1)], public_buf_m, 10);
break;
#endif
break;
case y_sensitivity:
#if Y_SENSORLESS
itoa(TERN(Y_SENSORLESS, stepperY.homing_threshold(), 0), public_buf_m, 10);
#endif
#if HAS_X_AXIS
case XMaxFeedRate: dtostrf(planner.settings.max_feedrate_mm_s[X_AXIS], 1, 1, public_buf_m); break;
#endif
#if HAS_Y_AXIS
case YMaxFeedRate: dtostrf(planner.settings.max_feedrate_mm_s[Y_AXIS], 1, 1, public_buf_m); break;
#endif
#if HAS_Z_AXIS
case ZMaxFeedRate: dtostrf(planner.settings.max_feedrate_mm_s[Z_AXIS], 1, 1, public_buf_m); break;
#endif
#if HAS_EXTRUDERS
case E0MaxFeedRate: dtostrf(planner.settings.max_feedrate_mm_s[E_AXIS], 1, 1, public_buf_m); break;
#if HAS_MULTI_EXTRUDER
case E1MaxFeedRate: dtostrf(planner.settings.max_feedrate_mm_s[E_AXIS_N(1)], 1, 1, public_buf_m); break;
#endif
break;
case z_sensitivity:
#if Z_SENSORLESS
itoa(TERN(Z_SENSORLESS, stepperZ.homing_threshold(), 0), public_buf_m, 10);
#endif
#if ENABLED(CLASSIC_JERK)
#if HAS_X_AXIS
case XJerk: dtostrf(planner.max_jerk.x, 1, 1, public_buf_m); break;
#endif
break;
case z2_sensitivity:
#if Z2_SENSORLESS
itoa(TERN(Z2_SENSORLESS, stepperZ2.homing_threshold(), 0), public_buf_m, 10);
#if HAS_Y_AXIS
case YJerk: dtostrf(planner.max_jerk.y, 1, 1, public_buf_m); break;
#endif
break;
#if HAS_Z_AXIS
case ZJerk: dtostrf(planner.max_jerk.z, 1, 1, public_buf_m); break;
#endif
#if HAS_EXTRUDERS
case EJerk: dtostrf(planner.max_jerk.e, 1, 1, public_buf_m); break;
#endif
#endif
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
#if HAS_X_AXIS
case Xstep: dtostrf(planner.settings.axis_steps_per_mm[X_AXIS], 1, 1, public_buf_m); break;
#endif
#if HAS_Y_AXIS
case Ystep: dtostrf(planner.settings.axis_steps_per_mm[Y_AXIS], 1, 1, public_buf_m); break;
#endif
#if HAS_Z_AXIS
case Zstep: dtostrf(planner.settings.axis_steps_per_mm[Z_AXIS], 1, 1, public_buf_m); break;
#endif
#if HAS_EXTRUDERS
case E0step: dtostrf(planner.settings.axis_steps_per_mm[E_AXIS], 1, 1, public_buf_m); break;
#if HAS_MULTI_EXTRUDER
case E1step: dtostrf(planner.settings.axis_steps_per_mm[E_AXIS_N(1)], 1, 1, public_buf_m); break;
#endif
#endif
#endif
#if AXIS_IS_TMC(X)
case Xcurrent: dtostrf(stepperX.getMilliamps(), 1, 1, public_buf_m); break;
#endif
#if AXIS_IS_TMC(Y)
case Ycurrent: dtostrf(stepperY.getMilliamps(), 1, 1, public_buf_m); break;
#endif
#if AXIS_IS_TMC(Z)
case Zcurrent: dtostrf(stepperZ.getMilliamps(), 1, 1, public_buf_m); break;
#endif
#if AXIS_IS_TMC(E0)
case E0current: dtostrf(stepperE0.getMilliamps(), 1, 1, public_buf_m); break;
#endif
#if AXIS_IS_TMC(E1)
case E1current: dtostrf(stepperE1.getMilliamps(), 1, 1, public_buf_m); break;
#endif
case pause_pos_x: dtostrf(gCfgItems.pausePosX, 1, 1, public_buf_m); break;
case pause_pos_y: dtostrf(gCfgItems.pausePosY, 1, 1, public_buf_m); break;
case pause_pos_z: dtostrf(gCfgItems.pausePosZ, 1, 1, public_buf_m); break;
case level_pos_x1: itoa(gCfgItems.trammingPos[0].x, public_buf_m, 10); break;
case level_pos_y1: itoa(gCfgItems.trammingPos[0].y, public_buf_m, 10); break;
case level_pos_x2: itoa(gCfgItems.trammingPos[1].x, public_buf_m, 10); break;
case level_pos_y2: itoa(gCfgItems.trammingPos[1].y, public_buf_m, 10); break;
case level_pos_x3: itoa(gCfgItems.trammingPos[2].x, public_buf_m, 10); break;
case level_pos_y3: itoa(gCfgItems.trammingPos[2].y, public_buf_m, 10); break;
case level_pos_x4: itoa(gCfgItems.trammingPos[3].x, public_buf_m, 10); break;
case level_pos_y4: itoa(gCfgItems.trammingPos[3].y, public_buf_m, 10); break;
case level_pos_x5: itoa(gCfgItems.trammingPos[4].x, public_buf_m, 10); break;
case level_pos_y5: itoa(gCfgItems.trammingPos[4].y, public_buf_m, 10); break;
#if HAS_BED_PROBE
#if HAS_PROBE_XY_OFFSET
case x_offset: dtostrf(probe.offset.x, 1, 3, public_buf_m); break;
#endif
#if HAS_PROBE_XY_OFFSET
case y_offset: dtostrf(probe.offset.y, 1, 3, public_buf_m); break;
#endif
case z_offset: dtostrf(probe.offset.z, 1, 3, public_buf_m); break;
#endif
// TODO: Use built-in filament change instead of the MKS UI implementation
case load_length: itoa(gCfgItems.filamentchange_load_length, public_buf_m, 10); break;
case load_speed: itoa(gCfgItems.filamentchange_load_speed, public_buf_m, 10); break;
case unload_length: itoa(gCfgItems.filamentchange_unload_length, public_buf_m, 10); break;
case unload_speed: itoa(gCfgItems.filamentchange_unload_speed, public_buf_m, 10); break;
case filament_temp: itoa(gCfgItems.filament_limit_temp, public_buf_m, 10); break;
#if X_SENSORLESS
case x_sensitivity: itoa(TERN(X_SENSORLESS, stepperX.homing_threshold(), 0), public_buf_m, 10); break;
#endif
#if Y_SENSORLESS
case y_sensitivity: itoa(TERN(Y_SENSORLESS, stepperY.homing_threshold(), 0), public_buf_m, 10); break;
#endif
#if Z_SENSORLESS
case z_sensitivity: itoa(TERN(Z_SENSORLESS, stepperZ.homing_threshold(), 0), public_buf_m, 10); break;
#endif
#if Z2_SENSORLESS
case z2_sensitivity: itoa(TERN(Z2_SENSORLESS, stepperZ2.homing_threshold(), 0), public_buf_m, 10); break;
#endif
}
strcpy(key_value, public_buf_m);
@ -297,53 +226,74 @@ static void set_value_confirm() {
case PrintAcceleration: planner.settings.acceleration = atof(key_value); break;
case RetractAcceleration: planner.settings.retract_acceleration = atof(key_value); break;
case TravelAcceleration: planner.settings.travel_acceleration = atof(key_value); break;
case XAcceleration: planner.settings.max_acceleration_mm_per_s2[X_AXIS] = atof(key_value); break;
case YAcceleration: planner.settings.max_acceleration_mm_per_s2[Y_AXIS] = atof(key_value); break;
case ZAcceleration: planner.settings.max_acceleration_mm_per_s2[Z_AXIS] = atof(key_value); break;
case E0Acceleration: planner.settings.max_acceleration_mm_per_s2[E_AXIS] = atof(key_value); break;
case E1Acceleration: planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(1)] = atof(key_value); break;
case XMaxFeedRate: planner.settings.max_feedrate_mm_s[X_AXIS] = atof(key_value); break;
case YMaxFeedRate: planner.settings.max_feedrate_mm_s[Y_AXIS] = atof(key_value); break;
case ZMaxFeedRate: planner.settings.max_feedrate_mm_s[Z_AXIS] = atof(key_value); break;
case E0MaxFeedRate: planner.settings.max_feedrate_mm_s[E_AXIS] = atof(key_value); break;
case E1MaxFeedRate: planner.settings.max_feedrate_mm_s[E_AXIS_N(1)] = atof(key_value); break;
case XJerk: TERN_(CLASSIC_JERK, planner.max_jerk.x = atof(key_value)); break;
case YJerk: TERN_(CLASSIC_JERK, planner.max_jerk.y = atof(key_value)); break;
case ZJerk: TERN_(CLASSIC_JERK, planner.max_jerk.z = atof(key_value)); break;
case EJerk: TERN_(CLASSIC_JERK, planner.max_jerk.e = atof(key_value)); break;
case Xstep: planner.settings.axis_steps_per_mm[X_AXIS] = atof(key_value); planner.refresh_positioning(); break;
case Ystep: planner.settings.axis_steps_per_mm[Y_AXIS] = atof(key_value); planner.refresh_positioning(); break;
case Zstep: planner.settings.axis_steps_per_mm[Z_AXIS] = atof(key_value); planner.refresh_positioning(); break;
case E0step: planner.settings.axis_steps_per_mm[E_AXIS] = atof(key_value); planner.refresh_positioning(); break;
case E1step: planner.settings.axis_steps_per_mm[E_AXIS_N(1)] = atof(key_value); planner.refresh_positioning(); break;
case Xcurrent:
#if AXIS_IS_TMC(X)
stepperX.rms_current(atoi(key_value));
#if HAS_X_AXIS
case XAcceleration: planner.settings.max_acceleration_mm_per_s2[X_AXIS] = atof(key_value); break;
#endif
#if HAS_Y_AXIS
case YAcceleration: planner.settings.max_acceleration_mm_per_s2[Y_AXIS] = atof(key_value); break;
#endif
#if HAS_Z_AXIS
case ZAcceleration: planner.settings.max_acceleration_mm_per_s2[Z_AXIS] = atof(key_value); break;
#endif
#if HAS_EXTRUDERS
case E0Acceleration: planner.settings.max_acceleration_mm_per_s2[E_AXIS] = atof(key_value); break;
#if HAS_MULTI_EXTRUDER
case E1Acceleration: planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(1)] = atof(key_value); break;
#endif
break;
case Ycurrent:
#if AXIS_IS_TMC(Y)
stepperY.rms_current(atoi(key_value));
#endif
break;
case Zcurrent:
#if AXIS_IS_TMC(Z)
stepperZ.rms_current(atoi(key_value));
#endif
break;
case E0current:
#if AXIS_IS_TMC(E0)
stepperE0.rms_current(atoi(key_value));
#endif
break;
case E1current:
#if AXIS_IS_TMC(E1)
stepperE1.rms_current(atoi(key_value));
#endif
break;
#endif
#if HAS_X_AXIS
case XMaxFeedRate: planner.settings.max_feedrate_mm_s[X_AXIS] = atof(key_value); break;
#endif
#if HAS_Y_AXIS
case YMaxFeedRate: planner.settings.max_feedrate_mm_s[Y_AXIS] = atof(key_value); break;
#endif
#if HAS_Z_AXIS
case ZMaxFeedRate: planner.settings.max_feedrate_mm_s[Z_AXIS] = atof(key_value); break;
#endif
#if HAS_E0_AXIS
case E0MaxFeedRate: planner.settings.max_feedrate_mm_s[E_AXIS] = atof(key_value); break;
#endif
#if HAS_E1_AXIS
case E1MaxFeedRate: planner.settings.max_feedrate_mm_s[E_AXIS_N(1)] = atof(key_value); break;
#endif
#if ENABLED(CLASSIC_JERK)
case XJerk: planner.max_jerk.x = atof(key_value); break;
case YJerk: planner.max_jerk.y = atof(key_value); break;
case ZJerk: planner.max_jerk.z = atof(key_value); break;
case EJerk: planner.max_jerk.e = atof(key_value); break;
#endif
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
case Xstep: planner.settings.axis_steps_per_mm[X_AXIS] = atof(key_value); planner.refresh_positioning(); break;
case Ystep: planner.settings.axis_steps_per_mm[Y_AXIS] = atof(key_value); planner.refresh_positioning(); break;
case Zstep: planner.settings.axis_steps_per_mm[Z_AXIS] = atof(key_value); planner.refresh_positioning(); break;
case E0step: planner.settings.axis_steps_per_mm[E_AXIS] = atof(key_value); planner.refresh_positioning(); break;
case E1step: planner.settings.axis_steps_per_mm[E_AXIS_N(1)] = atof(key_value); planner.refresh_positioning(); break;
#endif
#if AXIS_IS_TMC(X)
case Xcurrent: stepperX.rms_current(atoi(key_value)); break;
#endif
#if AXIS_IS_TMC(Y)
case Ycurrent: stepperY.rms_current(atoi(key_value)); break;
#endif
#if AXIS_IS_TMC(Z)
case Zcurrent: stepperZ.rms_current(atoi(key_value)); break;
#endif
#if AXIS_IS_TMC(E0)
case E0current: stepperE0.rms_current(atoi(key_value)); break;
#endif
#if AXIS_IS_TMC(E1)
case E1current: stepperE1.rms_current(atoi(key_value)); break;
#endif
case pause_pos_x: gCfgItems.pausePosX = atof(key_value); update_spi_flash(); break;
case pause_pos_y: gCfgItems.pausePosY = atof(key_value); update_spi_flash(); break;
case pause_pos_z: gCfgItems.pausePosZ = atof(key_value); update_spi_flash(); break;
case level_pos_x1: gCfgItems.trammingPos[0].x = atoi(key_value); update_spi_flash(); break;
case level_pos_y1: gCfgItems.trammingPos[0].y = atoi(key_value); update_spi_flash(); break;
case level_pos_x2: gCfgItems.trammingPos[1].x = atoi(key_value); update_spi_flash(); break;
@ -354,51 +304,51 @@ static void set_value_confirm() {
case level_pos_y4: gCfgItems.trammingPos[3].y = atoi(key_value); update_spi_flash(); break;
case level_pos_x5: gCfgItems.trammingPos[4].x = atoi(key_value); update_spi_flash(); break;
case level_pos_y5: gCfgItems.trammingPos[4].y = atoi(key_value); update_spi_flash(); break;
#if HAS_BED_PROBE
case x_offset: {
#if HAS_PROBE_XY_OFFSET
#if HAS_PROBE_XY_OFFSET
case x_offset: {
const float x = atof(key_value);
if (WITHIN(x, PROBE_OFFSET_XMIN, PROBE_OFFSET_XMAX))
probe.offset.x = x;
#endif
} break;
case y_offset: {
#if HAS_PROBE_XY_OFFSET
if (WITHIN(x, PROBE_OFFSET_XMIN, PROBE_OFFSET_XMAX)) probe.offset.x = x;
} break;
#endif
#if HAS_PROBE_XY_OFFSET
case y_offset: {
const float y = atof(key_value);
if (WITHIN(y, PROBE_OFFSET_YMIN, PROBE_OFFSET_YMAX))
probe.offset.y = y;
#endif
} break;
if (WITHIN(y, PROBE_OFFSET_YMIN, PROBE_OFFSET_YMAX)) probe.offset.y = y;
} break;
#endif
case z_offset: {
const float z = atof(key_value);
if (WITHIN(z, PROBE_OFFSET_ZMIN, PROBE_OFFSET_ZMAX))
probe.offset.z = z;
if (WITHIN(z, PROBE_OFFSET_ZMIN, PROBE_OFFSET_ZMAX)) probe.offset.z = z;
} break;
#endif
case load_length:
gCfgItems.filamentchange_load_length = atoi(key_value);
uiCfg.filament_loading_time = (uint32_t)((gCfgItems.filamentchange_load_length*60.0/gCfgItems.filamentchange_load_speed)+0.5);
uiCfg.filament_loading_time = uint32_t((gCfgItems.filamentchange_load_length * 60.0f / gCfgItems.filamentchange_load_speed) + 0.5f);
update_spi_flash();
break;
case load_speed:
gCfgItems.filamentchange_load_speed = atoi(key_value);
uiCfg.filament_loading_time = (uint32_t)((gCfgItems.filamentchange_load_length*60.0/gCfgItems.filamentchange_load_speed)+0.5);
uiCfg.filament_loading_time = uint32_t((gCfgItems.filamentchange_load_length * 60.0f / gCfgItems.filamentchange_load_speed) + 0.5f);
update_spi_flash();
break;
case unload_length:
gCfgItems.filamentchange_unload_length = atoi(key_value);
uiCfg.filament_unloading_time = (uint32_t)((gCfgItems.filamentchange_unload_length*60.0/gCfgItems.filamentchange_unload_speed)+0.5);
uiCfg.filament_unloading_time = uint32_t((gCfgItems.filamentchange_unload_length * 60.0f / gCfgItems.filamentchange_unload_speed) + 0.5f);
update_spi_flash();
break;
case unload_speed:
gCfgItems.filamentchange_unload_speed = atoi(key_value);
uiCfg.filament_unloading_time = (uint32_t)((gCfgItems.filamentchange_unload_length*60.0/gCfgItems.filamentchange_unload_speed)+0.5);
uiCfg.filament_unloading_time = uint32_t((gCfgItems.filamentchange_unload_length * 60.0f / gCfgItems.filamentchange_unload_speed) + 0.5f);
update_spi_flash();
break;
case filament_temp:
gCfgItems.filament_limit_temp = atoi(key_value);
update_spi_flash();
break;
case x_sensitivity: TERN_(X_SENSORLESS, stepperX.homing_threshold(atoi(key_value))); break;
case y_sensitivity: TERN_(Y_SENSORLESS, stepperY.homing_threshold(atoi(key_value))); break;
case z_sensitivity: TERN_(Z_SENSORLESS, stepperZ.homing_threshold(atoi(key_value))); break;
@ -530,9 +480,8 @@ void lv_draw_number_key() {
}
void lv_clear_number_key() {
#if HAS_ROTARY_ENCODER
if (gCfgItems.encoder_enable) lv_group_remove_all_objs(g);
#endif
if (TERN0(HAS_ROTARY_ENCODER, gCfgItems.encoder_enable))
lv_group_remove_all_objs(g);
lv_obj_del(scr);
}

4
Marlin/src/lcd/extui/mks_ui/draw_step_settings.cpp
View file

@ -22,7 +22,7 @@
#include "../../../inc/MarlinConfigPre.h"
#if HAS_TFT_LVGL_UI
#if ALL(HAS_TFT_LVGL_UI, EDITABLE_STEPS_PER_UNIT)
#include "draw_ui.h"
#include <lv_conf.h>
@ -114,4 +114,4 @@ void lv_clear_step_settings() {
lv_obj_del(scr);
}
#endif // HAS_TFT_LVGL_UI
#endif // HAS_TFT_LVGL_UI && EDITABLE_STEPS_PER_UNIT

4
Marlin/src/lcd/extui/mks_ui/draw_ui.cpp
View file

@ -1059,7 +1059,9 @@ void draw_return_ui() {
case DELTA_LEVELING_PARA_UI: break;
case MANUAL_LEVELING_POSITION_UI: lv_draw_tramming_pos_settings(); break;
case MAXFEEDRATE_UI: lv_draw_max_feedrate_settings(); break;
case STEPS_UI: lv_draw_step_settings(); break;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
case STEPS_UI: lv_draw_step_settings(); break;
#endif
case ACCELERATION_UI: lv_draw_acceleration_settings(); break;
#if ENABLED(CLASSIC_JERK)
case JERK_UI: lv_draw_jerk_settings(); break;

10
Marlin/src/lcd/extui/mks_ui/draw_ui.h
View file

@ -294,9 +294,7 @@ typedef enum {
LEVELING_UI,
MESHLEVELING_UI,
BIND_UI,
#if HAS_BED_PROBE
NOZZLE_PROBE_OFFSET_UI,
#endif
OPTITEM(HAS_BED_PROBE, NOZZLE_PROBE_OFFSET_UI)
TOOL_UI,
HARDWARE_TEST_UI,
WIFI_LIST_UI,
@ -402,11 +400,11 @@ typedef enum {
level_pos_y4,
level_pos_x5,
level_pos_y5,
#if HAS_BED_PROBE
x_offset,
y_offset,
z_offset,
x_offset, y_offset, z_offset,
#endif
load_length,
load_speed,
unload_length,

56
Marlin/src/lcd/extui/mks_ui/tft_multi_language.cpp
View file

@ -208,12 +208,14 @@ void machine_setting_disp() {
machine_menu.Z_Jerk = Z_JERK_CN;
machine_menu.E_Jerk = E_JERK_CN;
machine_menu.StepsConfTitle = STEPS_CONF_TITLE_CN;
machine_menu.X_Steps = X_STEPS_CN;
machine_menu.Y_Steps = Y_STEPS_CN;
machine_menu.Z_Steps = Z_STEPS_CN;
machine_menu.E0_Steps = E0_STEPS_CN;
machine_menu.E1_Steps = E1_STEPS_CN;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
machine_menu.StepsConfTitle = STEPS_CONF_TITLE_CN;
machine_menu.X_Steps = X_STEPS_CN;
machine_menu.Y_Steps = Y_STEPS_CN;
machine_menu.Z_Steps = Z_STEPS_CN;
machine_menu.E0_Steps = E0_STEPS_CN;
machine_menu.E1_Steps = E1_STEPS_CN;
#endif
machine_menu.TmcCurrentConfTitle = TMC_CURRENT_CONF_TITLE_CN;
machine_menu.X_Current = X_TMC_CURRENT_CN;
@ -436,12 +438,14 @@ void machine_setting_disp() {
machine_menu.Z_Jerk = Z_JERK_T_CN;
machine_menu.E_Jerk = E_JERK_T_CN;
machine_menu.StepsConfTitle = STEPS_CONF_TITLE_T_CN;
machine_menu.X_Steps = X_STEPS_T_CN;
machine_menu.Y_Steps = Y_STEPS_T_CN;
machine_menu.Z_Steps = Z_STEPS_T_CN;
machine_menu.E0_Steps = E0_STEPS_T_CN;
machine_menu.E1_Steps = E1_STEPS_T_CN;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
machine_menu.StepsConfTitle = STEPS_CONF_TITLE_T_CN;
machine_menu.X_Steps = X_STEPS_T_CN;
machine_menu.Y_Steps = Y_STEPS_T_CN;
machine_menu.Z_Steps = Z_STEPS_T_CN;
machine_menu.E0_Steps = E0_STEPS_T_CN;
machine_menu.E1_Steps = E1_STEPS_T_CN;
#endif
machine_menu.TmcCurrentConfTitle = TMC_CURRENT_CONF_TITLE_T_CN;
machine_menu.X_Current = X_TMC_CURRENT_T_CN;
@ -668,12 +672,14 @@ void machine_setting_disp() {
machine_menu.Z_Jerk = Z_JERK_EN;
machine_menu.E_Jerk = E_JERK_EN;
machine_menu.StepsConfTitle = STEPS_CONF_TITLE_EN;
machine_menu.X_Steps = X_STEPS_EN;
machine_menu.Y_Steps = Y_STEPS_EN;
machine_menu.Z_Steps = Z_STEPS_EN;
machine_menu.E0_Steps = E0_STEPS_EN;
machine_menu.E1_Steps = E1_STEPS_EN;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
machine_menu.StepsConfTitle = STEPS_CONF_TITLE_EN;
machine_menu.X_Steps = X_STEPS_EN;
machine_menu.Y_Steps = Y_STEPS_EN;
machine_menu.Z_Steps = Z_STEPS_EN;
machine_menu.E0_Steps = E0_STEPS_EN;
machine_menu.E1_Steps = E1_STEPS_EN;
#endif
machine_menu.TmcCurrentConfTitle = TMC_CURRENT_CONF_TITLE_EN;
machine_menu.X_Current = X_TMC_CURRENT_EN;
@ -1747,12 +1753,14 @@ void disp_language_init() {
machine_menu.Z_Jerk = Z_JERK_RU;
machine_menu.E_Jerk = E_JERK_RU;
machine_menu.StepsConfTitle = STEPS_CONF_TITLE_RU;
machine_menu.X_Steps = X_STEPS_RU;
machine_menu.Y_Steps = Y_STEPS_RU;
machine_menu.Z_Steps = Z_STEPS_RU;
machine_menu.E0_Steps = E0_STEPS_RU;
machine_menu.E1_Steps = E1_STEPS_RU;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
machine_menu.StepsConfTitle = STEPS_CONF_TITLE_RU;
machine_menu.X_Steps = X_STEPS_RU;
machine_menu.Y_Steps = Y_STEPS_RU;
machine_menu.Z_Steps = Z_STEPS_RU;
machine_menu.E0_Steps = E0_STEPS_RU;
machine_menu.E1_Steps = E1_STEPS_RU;
#endif
machine_menu.TmcCurrentConfTitle = TMC_CURRENT_CONF_TITLE_RU;
machine_menu.X_Current = X_TMC_CURRENT_RU;

20
Marlin/src/lcd/extui/ui_api.cpp
View file

@ -672,16 +672,18 @@ namespace ExtUI {
return planner.settings.axis_steps_per_mm[E_AXIS_N(extruder - E0)];
}
void setAxisSteps_per_mm(const_float_t value, const axis_t axis) {
planner.settings.axis_steps_per_mm[axis] = value;
planner.refresh_positioning();
}
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
void setAxisSteps_per_mm(const_float_t value, const axis_t axis) {
planner.settings.axis_steps_per_mm[axis] = value;
planner.refresh_positioning();
}
void setAxisSteps_per_mm(const_float_t value, const extruder_t extruder) {
UNUSED(extruder);
planner.settings.axis_steps_per_mm[E_AXIS_N(extruder - E0)] = value;
planner.refresh_positioning();
}
void setAxisSteps_per_mm(const_float_t value, const extruder_t extruder) {
UNUSED(extruder);
planner.settings.axis_steps_per_mm[E_AXIS_N(extruder - E0)] = value;
planner.refresh_positioning();
}
#endif
feedRate_t getAxisMaxFeedrate_mm_s(const axis_t axis) {
return planner.settings.max_feedrate_mm_s[axis];

6
Marlin/src/lcd/extui/ui_api.h
View file

@ -265,8 +265,10 @@ namespace ExtUI {
void setAxisPosition_mm(const_float_t, const extruder_t, const feedRate_t=0);
// Planner Control
void setAxisSteps_per_mm(const_float_t, const axis_t);
void setAxisSteps_per_mm(const_float_t, const extruder_t);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
void setAxisSteps_per_mm(const_float_t, const axis_t);
void setAxisSteps_per_mm(const_float_t, const extruder_t);
#endif
void setAxisMaxFeedrate_mm_s(const feedRate_t, const axis_t);
void setAxisMaxFeedrate_mm_s(const feedRate_t, const extruder_t);
void setAxisMaxAcceleration_mm_s2(const_float_t, const axis_t);

53
Marlin/src/lcd/menu/menu_advanced.cpp
View file

@ -641,32 +641,38 @@ void menu_backlash();
#endif // !SLIM_LCD_MENUS
// M92 Steps-per-mm
void menu_advanced_steps_per_mm() {
START_MENU();
BACK_ITEM(MSG_ADVANCED_SETTINGS);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
LOOP_NUM_AXES(a)
EDIT_ITEM_FAST_N(float72, a, MSG_N_STEPS, &planner.settings.axis_steps_per_mm[a], 5, 9999, []{ planner.refresh_positioning(); });
// M92 Steps-per-mm
void menu_advanced_steps_per_mm() {
START_MENU();
BACK_ITEM(MSG_ADVANCED_SETTINGS);
#if ENABLED(DISTINCT_E_FACTORS)
for (uint8_t n = 0; n < E_STEPPERS; ++n)
EDIT_ITEM_FAST_N(float72, n, MSG_EN_STEPS, &planner.settings.axis_steps_per_mm[E_AXIS_N(n)], 5, 9999, []{
const uint8_t e = MenuItemBase::itemIndex;
if (e == active_extruder)
planner.refresh_positioning();
else
planner.mm_per_step[E_AXIS_N(e)] = 1.0f / planner.settings.axis_steps_per_mm[E_AXIS_N(e)];
});
#elif E_STEPPERS
EDIT_ITEM_FAST_N(float72, E_AXIS, MSG_N_STEPS, &planner.settings.axis_steps_per_mm[E_AXIS], 5, 9999, []{ planner.refresh_positioning(); });
#endif
LOOP_NUM_AXES(a)
EDIT_ITEM_FAST_N(float72, a, MSG_N_STEPS, &planner.settings.axis_steps_per_mm[a], 5, 9999, []{ planner.refresh_positioning(); });
END_MENU();
}
#if ENABLED(DISTINCT_E_FACTORS)
for (uint8_t n = 0; n < E_STEPPERS; ++n)
EDIT_ITEM_FAST_N(float72, n, MSG_EN_STEPS, &planner.settings.axis_steps_per_mm[E_AXIS_N(n)], 5, 9999, []{
const uint8_t e = MenuItemBase::itemIndex;
if (e == active_extruder)
planner.refresh_positioning();
else
planner.mm_per_step[E_AXIS_N(e)] = 1.0f / planner.settings.axis_steps_per_mm[E_AXIS_N(e)];
});
#elif E_STEPPERS
EDIT_ITEM_FAST_N(float72, E_AXIS, MSG_N_STEPS, &planner.settings.axis_steps_per_mm[E_AXIS], 5, 9999, []{ planner.refresh_positioning(); });
#endif
END_MENU();
}
#endif // EDITABLE_STEPS_PER_UNIT
void menu_advanced_settings() {
const bool is_busy = printer_busy();
#if ANY(POLARGRAPH, SHAPING_MENU, HAS_BED_PROBE, EDITABLE_STEPS_PER_UNIT)
const bool is_busy = printer_busy();
#endif
#if ENABLED(SD_FIRMWARE_UPDATE)
bool sd_update_state = settings.sd_update_status();
@ -722,8 +728,9 @@ void menu_advanced_settings() {
#endif // !SLIM_LCD_MENUS
// M92 - Steps Per mm
if (!is_busy)
SUBMENU(MSG_STEPS_PER_MM, menu_advanced_steps_per_mm);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
if (!is_busy) SUBMENU(MSG_STEPS_PER_MM, menu_advanced_steps_per_mm);
#endif
#if ENABLED(BACKLASH_GCODE)
SUBMENU(MSG_BACKLASH, menu_backlash);

12
Marlin/src/module/planner.cpp
View file

@ -133,6 +133,12 @@ volatile uint8_t Planner::block_buffer_head, // Index of the next block to be
uint16_t Planner::cleaning_buffer_counter; // A counter to disable queuing of blocks
uint8_t Planner::delay_before_delivering; // Delay block delivery so initial blocks in an empty queue may merge
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
float Planner::mm_per_step[DISTINCT_AXES]; // (mm) Millimeters per step
#else
constexpr float PlannerSettings::axis_steps_per_mm[DISTINCT_AXES];
constexpr float Planner::mm_per_step[DISTINCT_AXES];
#endif
planner_settings_t Planner::settings; // Initialized by settings.load()
/**
@ -146,8 +152,6 @@ planner_settings_t Planner::settings; // Initialized by settings.load(
uint32_t Planner::max_acceleration_steps_per_s2[DISTINCT_AXES]; // (steps/s^2) Derived from mm_per_s2
float Planner::mm_per_step[DISTINCT_AXES]; // (mm) Millimeters per step
#if HAS_JUNCTION_DEVIATION
float Planner::junction_deviation_mm; // (mm) M205 J
#if HAS_LINEAR_E_JERK
@ -3308,7 +3312,9 @@ void Planner::refresh_acceleration_rates() {
* Must be called whenever settings.axis_steps_per_mm changes!
*/
void Planner::refresh_positioning() {
LOOP_DISTINCT_AXES(i) mm_per_step[i] = 1.0f / settings.axis_steps_per_mm[i];
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
LOOP_DISTINCT_AXES(i) mm_per_step[i] = 1.0f / settings.axis_steps_per_mm[i];
#endif
set_position_mm(current_position);
refresh_acceleration_rates();
}

43
Marlin/src/module/planner.h
View file

@ -340,10 +340,30 @@ constexpr uint8_t block_inc_mod(const uint8_t v1, const uint8_t v2) {
} laser_state_t;
#endif
typedef struct {
#if DISABLED(EDITABLE_STEPS_PER_UNIT)
static constexpr float _dasu[] = DEFAULT_AXIS_STEPS_PER_UNIT;
#endif
typedef struct PlannerSettings {
uint32_t max_acceleration_mm_per_s2[DISTINCT_AXES], // (mm/s^2) M201 XYZE
min_segment_time_us; // (µs) M205 B
float axis_steps_per_mm[DISTINCT_AXES]; // (steps) M92 XYZE - Steps per millimeter
// (steps) M92 XYZE - Steps per millimeter
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
float axis_steps_per_mm[DISTINCT_AXES];
#else
#define _DLIM(I) _MIN(I, (signed)COUNT(_dasu) - 1)
#define _DASU(N) _dasu[_DLIM(N)],
#define _EASU(N) _dasu[_DLIM(E_AXIS + N)],
static constexpr float axis_steps_per_mm[DISTINCT_AXES] = {
REPEAT(NUM_AXES, _DASU)
TERN_(HAS_EXTRUDERS, REPEAT(DISTINCT_E, _EASU))
};
#undef _EASU
#undef _DASU
#undef _DLIM
#endif
feedRate_t max_feedrate_mm_s[DISTINCT_AXES]; // (mm/s) M203 XYZE - Max speeds
float acceleration, // (mm/s^2) M204 S - Normal acceleration. DEFAULT ACCELERATION for all printing moves.
retract_acceleration, // (mm/s^2) M204 R - Retract acceleration. Filament pull-back and push-forward while standing still in the other axes
@ -450,15 +470,15 @@ class Planner {
#endif
#if DISABLED(NO_VOLUMETRICS)
static float filament_size[EXTRUDERS], // diameter of filament (in millimeters), typically around 1.75 or 2.85, 0 disables the volumetric calculations for the extruder
volumetric_area_nominal, // Nominal cross-sectional area
volumetric_multiplier[EXTRUDERS]; // Reciprocal of cross-sectional area of filament (in mm^2). Pre-calculated to reduce computation in the planner
static float filament_size[EXTRUDERS], // (mm) Diameter of filament, typically around 1.75 or 2.85, 0 disables the volumetric calculations for the extruder
volumetric_area_nominal, // (mm^3) Nominal cross-sectional area
volumetric_multiplier[EXTRUDERS]; // (1/mm^2) Reciprocal of cross-sectional area of filament. Pre-calculated to reduce computation in the planner
// May be auto-adjusted by a filament width sensor
#endif
#if ENABLED(VOLUMETRIC_EXTRUDER_LIMIT)
static float volumetric_extruder_limit[EXTRUDERS], // Maximum mm^3/sec the extruder can handle
volumetric_extruder_feedrate_limit[EXTRUDERS]; // Feedrate limit (mm/s) calculated from volume limit
static float volumetric_extruder_limit[EXTRUDERS], // (mm^3/sec) Maximum volume the extruder can handle
volumetric_extruder_feedrate_limit[EXTRUDERS]; // (mm/s) Feedrate limit calculated from volume limit
#endif
static planner_settings_t settings;
@ -468,7 +488,14 @@ class Planner {
#endif
static uint32_t max_acceleration_steps_per_s2[DISTINCT_AXES]; // (steps/s^2) Derived from mm_per_s2
static float mm_per_step[DISTINCT_AXES]; // Millimeters per step
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
static float mm_per_step[DISTINCT_AXES]; // Millimeters per step
#else
#define _RSTEP(N) RECIPROCAL(settings.axis_steps_per_mm[N]),
static constexpr float mm_per_step[DISTINCT_AXES] = { REPEAT(DISTINCT_AXES, _RSTEP) };
#undef _RSTEP
#endif
#if HAS_JUNCTION_DEVIATION
static float junction_deviation_mm; // (mm) M205 J

27
Marlin/src/module/settings.cpp
View file

@ -198,8 +198,10 @@ typedef struct { bool NUM_AXIS_LIST_(X:1, Y:1, Z:1, I:1, J:1, K:1, U:1, V:1,
// Defaults for reset / fill in on load
static const uint32_t _DMA[] PROGMEM = DEFAULT_MAX_ACCELERATION;
static const float _DASU[] PROGMEM = DEFAULT_AXIS_STEPS_PER_UNIT;
static const feedRate_t _DMF[] PROGMEM = DEFAULT_MAX_FEEDRATE;
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
static const float _DASU[] PROGMEM = DEFAULT_AXIS_STEPS_PER_UNIT;
#endif
/**
* Current EEPROM Layout
@ -1855,17 +1857,22 @@ void MarlinSettings::postprocess() {
// Get only the number of E stepper parameters previously stored
// Any steppers added later are set to their defaults
uint32_t tmp1[NUM_AXES + e_factors];
float tmp2[NUM_AXES + e_factors];
feedRate_t tmp3[NUM_AXES + e_factors];
EEPROM_READ((uint8_t *)tmp1, sizeof(tmp1)); // max_acceleration_mm_per_s2
EEPROM_READ(planner.settings.min_segment_time_us);
float tmp2[NUM_AXES + e_factors];
EEPROM_READ((uint8_t *)tmp2, sizeof(tmp2)); // axis_steps_per_mm
feedRate_t tmp3[NUM_AXES + e_factors];
EEPROM_READ((uint8_t *)tmp3, sizeof(tmp3)); // max_feedrate_mm_s
if (!validating) LOOP_DISTINCT_AXES(i) {
const bool in = (i < e_factors + NUM_AXES);
planner.settings.max_acceleration_mm_per_s2[i] = in ? tmp1[i] : pgm_read_dword(&_DMA[ALIM(i, _DMA)]);
planner.settings.axis_steps_per_mm[i] = in ? tmp2[i] : pgm_read_float(&_DASU[ALIM(i, _DASU)]);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
planner.settings.axis_steps_per_mm[i] = in ? tmp2[i] : pgm_read_float(&_DASU[ALIM(i, _DASU)]);
#endif
planner.settings.max_feedrate_mm_s[i] = in ? tmp3[i] : pgm_read_float(&_DMF[ALIM(i, _DMF)]);
}
@ -3082,7 +3089,9 @@ void MarlinSettings::postprocess() {
void MarlinSettings::reset() {
LOOP_DISTINCT_AXES(i) {
planner.settings.max_acceleration_mm_per_s2[i] = pgm_read_dword(&_DMA[ALIM(i, _DMA)]);
planner.settings.axis_steps_per_mm[i] = pgm_read_float(&_DASU[ALIM(i, _DASU)]);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
planner.settings.axis_steps_per_mm[i] = pgm_read_float(&_DASU[ALIM(i, _DASU)]);
#endif
planner.settings.max_feedrate_mm_s[i] = pgm_read_float(&_DMF[ALIM(i, _DMF)]);
}
@ -3664,7 +3673,9 @@ void MarlinSettings::reset() {
#define CONFIG_ECHO_MSG_P(V...) do{ CONFIG_ECHO_START(); SERIAL_ECHOLNPGM_P(V); }while(0)
#define CONFIG_ECHO_HEADING(STR) gcode.report_heading(forReplay, F(STR))
void M92_report(const bool echo=true, const int8_t e=-1);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
void M92_report(const bool echo=true, const int8_t e=-1);
#endif
/**
* M503 - Report current settings in RAM
@ -3702,7 +3713,9 @@ void MarlinSettings::reset() {
//
// M92 Steps per Unit
//
gcode.M92_report(forReplay);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
gcode.M92_report(forReplay);
#endif
//
// M203 Maximum feedrates (units/s)

1
ini/features.ini
View file

@ -288,6 +288,7 @@ HAS_EXTRA_ENDSTOPS = build_src_filter=+<src/gcode/calibrate/
SKEW_CORRECTION_GCODE = build_src_filter=+<src/gcode/calibrate/M852.cpp>
DIRECT_PIN_CONTROL = build_src_filter=+<src/gcode/control/M42.cpp> +<src/gcode/control/M226.cpp>
PINS_DEBUGGING = build_src_filter=+<src/gcode/config/M43.cpp>
EDITABLE_STEPS_PER_UNIT = build_src_filter=+<src/gcode/config/M92.cpp>
HAS_MULTI_EXTRUDER = build_src_filter=+<src/gcode/config/M217.cpp>
HAS_HOTEND_OFFSET = build_src_filter=+<src/gcode/config/M218.cpp>
EDITABLE_SERVO_ANGLES = build_src_filter=+<src/gcode/config/M281.cpp>

1
platformio.ini
View file

@ -97,7 +97,6 @@ default_src_filter = +<src/*> -<src/config> -<src/tests>
; Minimal Requirements
;
+<src/gcode/calibrate/G28.cpp>
+<src/gcode/config/M92.cpp>
+<src/gcode/config/M200-M205.cpp>
+<src/gcode/config/M220.cpp>
+<src/gcode/control/M17_M18_M84.cpp>