bissen21/Marlin_Firmware
1
0
Fork 0
Code Issues Pull Requests Projects Releases 4 Wiki Activity

Configurable Max Accel, Max Feedrate, Max Jerk edit limits (#13929)

Browse Source
This commit is contained in:
InsanityAutomation
2019-10-01 20:59:48 -04:00
committed by Scott Lahteine
parent f9400b6a3c
commit 438835f6a5
130 changed files with 1912 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Marlin/src/HAL/HAL_DUE/HAL.cpp
View File

@ -87,7 +87,7 @@ extern "C" {
// Return free memory between end of heap (or end bss) and whatever is current
int freeMemory() {
int free_memory, heap_end = (int)_sbrk(0);
return (int)&free_memory - (heap_end ? heap_end : (int)&_ebss);
return (int)&free_memory - (heap_end ?: (int)&_ebss);
}
// ------------------------

2
Marlin/src/HAL/HAL_SAMD51/HAL.cpp
View File

@ -414,7 +414,7 @@ extern "C" {
// Return free memory between end of heap (or end bss) and whatever is current
int freeMemory() {
int free_memory, heap_end = (int)_sbrk(0);
return (int)&free_memory - (heap_end ? heap_end : (int)&__bss_end__);
return (int)&free_memory - (heap_end ?: (int)&__bss_end__);
}
// ------------------------

2
Marlin/src/Marlin.cpp
View File

@ -762,7 +762,7 @@ void kill(PGM_P const lcd_msg/*=nullptr*/, const bool steppers_off/*=false*/) {
SERIAL_ERROR_MSG(MSG_ERR_KILLED);
#if HAS_DISPLAY
ui.kill_screen(lcd_msg ? lcd_msg : PSTR(MSG_KILLED));
ui.kill_screen(lcd_msg ?: PSTR(MSG_KILLED));
#else
UNUSED(lcd_msg);
#endif

8
Marlin/src/feature/joystick.cpp
View File

@ -112,10 +112,10 @@ Joystick joystick;
static bool injecting_now; // = false;
if (injecting_now) return;
static constexpr int QUEUE_DEPTH = 5; // Insert up to this many movements
static constexpr float target_lag = 0.25f, // Aim for 1/4 second lag
seg_time = target_lag / QUEUE_DEPTH; // 0.05 seconds, short segments inserted every 1/20th of a second
static constexpr millis_t timer_limit_ms = millis_t(seg_time * 500); // 25 ms minimum delay between insertions
static constexpr int QUEUE_DEPTH = 5; // Insert up to this many movements
static constexpr float target_lag = 0.25f, // Aim for 1/4 second lag
seg_time = target_lag / QUEUE_DEPTH; // 0.05 seconds, short segments inserted every 1/20th of a second
static constexpr millis_t timer_limit_ms = millis_t(seg_time * 500); // 25 ms minimum delay between insertions
// The planner can merge/collapse small moves, so the movement queue is unreliable to control the lag
static millis_t next_run = 0;

2
Marlin/src/feature/tmc_util.cpp
View File

@ -507,7 +507,7 @@
case TMC_GLOBAL_SCALER:
{
uint16_t value = st.GLOBAL_SCALER();
SERIAL_PRINT(value ? value : 256, DEC);
SERIAL_PRINT(value ?: 256, DEC);
SERIAL_ECHOPGM("/256");
}
break;

16
Marlin/src/gcode/config/M200-M205.cpp
View File

@ -62,11 +62,9 @@ void GcodeSuite::M201() {
LOOP_XYZE(i) {
if (parser.seen(axis_codes[i])) {
const uint8_t a = (i == E_AXIS ? uint8_t(E_AXIS_N(target_extruder)) : i);
planner.settings.max_acceleration_mm_per_s2[a] = parser.value_axis_units((AxisEnum)a);
planner.set_max_acceleration(a, parser.value_axis_units((AxisEnum)a));
}
}
planner.reset_acceleration_rates();
}
/**
@ -82,7 +80,7 @@ void GcodeSuite::M203() {
LOOP_XYZE(i)
if (parser.seen(axis_codes[i])) {
const uint8_t a = (i == E_AXIS ? uint8_t(E_AXIS_N(target_extruder)) : i);
planner.settings.max_feedrate_mm_s[a] = parser.value_axis_units((AxisEnum)a);
planner.set_max_feedrate(a, parser.value_axis_units((AxisEnum)a));
}
}
@ -152,17 +150,17 @@ void GcodeSuite::M205() {
}
#endif
#if HAS_CLASSIC_JERK
if (parser.seen('X')) planner.max_jerk.x = parser.value_linear_units();
if (parser.seen('Y')) planner.max_jerk.y = parser.value_linear_units();
if (parser.seen('X')) planner.set_max_jerk(X_AXIS, parser.value_linear_units());
if (parser.seen('Y')) planner.set_max_jerk(Y_AXIS, parser.value_linear_units());
if (parser.seen('Z')) {
planner.max_jerk.z = parser.value_linear_units();
#if HAS_MESH
planner.set_max_jerk(Z_AXIS, parser.value_linear_units());
#if HAS_MESH && DISABLED(LIMITED_JERK_EDITING)
if (planner.max_jerk.z <= 0.1f)
SERIAL_ECHOLNPGM("WARNING! Low Z Jerk may lead to unwanted pauses.");
#endif
}
#if !BOTH(JUNCTION_DEVIATION, LIN_ADVANCE)
if (parser.seen('E')) planner.max_jerk.e = parser.value_linear_units();
if (parser.seen('E')) planner.set_max_jerk(E_AXIS, parser.value_linear_units());
#endif
#endif
}

2
Marlin/src/gcode/config/M92.cpp
View File

@ -98,7 +98,7 @@ void GcodeSuite::M92() {
const float wanted = parser.floatval('L');
if (parser.seen('H') || wanted) {
const uint16_t argH = parser.ushortval('H'),
micro_steps = argH ? argH : Z_MICROSTEPS;
micro_steps = argH ?: Z_MICROSTEPS;
const float z_full_step_mm = micro_steps * planner.steps_to_mm[Z_AXIS];
SERIAL_ECHO_START();
SERIAL_ECHOPAIR("{ micro_steps:", micro_steps, ", z_full_step_mm:", z_full_step_mm);

3
Marlin/src/gcode/parser.cpp
View File

@ -222,8 +222,7 @@ void GCodeParser::parse(char *p) {
// Only use string_arg for these M codes
if (letter == 'M') switch (codenum) {
#if ENABLED(GCODE_MACROS)
case 810: case 811: case 812: case 813: case 814:
case 815: case 816: case 817: case 818: case 819:
case 810 ... 819:
#endif
#if ENABLED(EXPECTED_PRINTER_CHECK)
case 16:

42
Marlin/src/inc/SanityCheck.h
View File

@ -2233,27 +2233,63 @@ constexpr float sanity_arr_1[] = DEFAULT_AXIS_STEPS_PER_UNIT,
#define _ARR_TEST(N,I) (sanity_arr_##N[_MIN(I,int(COUNT(sanity_arr_##N))-1)] > 0)
static_assert(COUNT(sanity_arr_1) >= XYZE, "DEFAULT_AXIS_STEPS_PER_UNIT requires X, Y, Z and E elements.");
static_assert(COUNT(sanity_arr_1) >= XYZE, "DEFAULT_AXIS_STEPS_PER_UNIT requires X, Y, Z and E elements.");
static_assert(COUNT(sanity_arr_1) <= XYZE_N, "DEFAULT_AXIS_STEPS_PER_UNIT has too many elements. (Did you forget to enable DISTINCT_E_FACTORS?)");
static_assert( _ARR_TEST(1,0) && _ARR_TEST(1,1) && _ARR_TEST(1,2)
&& _ARR_TEST(1,3) && _ARR_TEST(1,4) && _ARR_TEST(1,5)
&& _ARR_TEST(1,6) && _ARR_TEST(1,7) && _ARR_TEST(1,8),
"DEFAULT_AXIS_STEPS_PER_UNIT values must be positive.");
static_assert(COUNT(sanity_arr_2) >= XYZE, "DEFAULT_MAX_FEEDRATE requires X, Y, Z and E elements.");
static_assert(COUNT(sanity_arr_2) >= XYZE, "DEFAULT_MAX_FEEDRATE requires X, Y, Z and E elements.");
static_assert(COUNT(sanity_arr_2) <= XYZE_N, "DEFAULT_MAX_FEEDRATE has too many elements. (Did you forget to enable DISTINCT_E_FACTORS?)");
static_assert( _ARR_TEST(2,0) && _ARR_TEST(2,1) && _ARR_TEST(2,2)
&& _ARR_TEST(2,3) && _ARR_TEST(2,4) && _ARR_TEST(2,5)
&& _ARR_TEST(2,6) && _ARR_TEST(2,7) && _ARR_TEST(2,8),
"DEFAULT_MAX_FEEDRATE values must be positive.");
static_assert(COUNT(sanity_arr_3) >= XYZE, "DEFAULT_MAX_ACCELERATION requires X, Y, Z and E elements.");
static_assert(COUNT(sanity_arr_3) >= XYZE, "DEFAULT_MAX_ACCELERATION requires X, Y, Z and E elements.");
static_assert(COUNT(sanity_arr_3) <= XYZE_N, "DEFAULT_MAX_ACCELERATION has too many elements. (Did you forget to enable DISTINCT_E_FACTORS?)");
static_assert( _ARR_TEST(3,0) && _ARR_TEST(3,1) && _ARR_TEST(3,2)
&& _ARR_TEST(3,3) && _ARR_TEST(3,4) && _ARR_TEST(3,5)
&& _ARR_TEST(3,6) && _ARR_TEST(3,7) && _ARR_TEST(3,8),
"DEFAULT_MAX_ACCELERATION values must be positive.");
#if ENABLED(LIMITED_MAX_ACCEL_EDITING)
#ifdef MAX_ACCEL_EDIT_VALUES
constexpr float sanity_arr_4[] = MAX_ACCEL_EDIT_VALUES;
static_assert(COUNT(sanity_arr_4) >= XYZE, "MAX_ACCEL_EDIT_VALUES requires X, Y, Z and E elements.");
static_assert(COUNT(sanity_arr_4) <= XYZE, "MAX_ACCEL_EDIT_VALUES has too many elements. X, Y, Z and E elements only.");
static_assert( _ARR_TEST(4,0) && _ARR_TEST(4,1) && _ARR_TEST(4,2)
&& _ARR_TEST(4,3) && _ARR_TEST(4,4) && _ARR_TEST(4,5)
&& _ARR_TEST(4,6) && _ARR_TEST(4,7) && _ARR_TEST(4,8),
"MAX_ACCEL_EDIT_VALUES values must be positive.");
#endif
#endif
#if ENABLED(LIMITED_MAX_FR_EDITING)
#ifdef MAX_FEEDRATE_EDIT_VALUES
constexpr float sanity_arr_5[] = MAX_FEEDRATE_EDIT_VALUES;
static_assert(COUNT(sanity_arr_5) >= XYZE, "MAX_FEEDRATE_EDIT_VALUES requires X, Y, Z and E elements.");
static_assert(COUNT(sanity_arr_5) <= XYZE, "MAX_FEEDRATE_EDIT_VALUES has too many elements. X, Y, Z and E elements only.");
static_assert( _ARR_TEST(5,0) && _ARR_TEST(5,1) && _ARR_TEST(5,2)
&& _ARR_TEST(5,3) && _ARR_TEST(5,4) && _ARR_TEST(5,5)
&& _ARR_TEST(5,6) && _ARR_TEST(5,7) && _ARR_TEST(5,8),
"MAX_FEEDRATE_EDIT_VALUES values must be positive.");
#endif
#endif
#if ENABLED(LIMITED_JERK_EDITING)
#ifdef MAX_JERK_EDIT_VALUES
constexpr float sanity_arr_6[] = MAX_JERK_EDIT_VALUES;
static_assert(COUNT(sanity_arr_6) >= XYZE, "MAX_JERK_EDIT_VALUES requires X, Y, Z and E elements.");
static_assert(COUNT(sanity_arr_6) <= XYZE, "MAX_JERK_EDIT_VALUES has too many elements. X, Y, Z and E elements only.");
static_assert( _ARR_TEST(6,0) && _ARR_TEST(6,1) && _ARR_TEST(6,2)
&& _ARR_TEST(6,3) && _ARR_TEST(6,4) && _ARR_TEST(6,5)
&& _ARR_TEST(6,6) && _ARR_TEST(6,7) && _ARR_TEST(6,8),
"MAX_JERK_EDIT_VALUES values must be positive.");
#endif
#endif
#undef _ARR_TEST
#if BOTH(CNC_COORDINATE_SYSTEMS, NO_WORKSPACE_OFFSETS)

4
Marlin/src/lcd/extensible_ui/lib/lulzbot/ftdi_eve_lib/extended/dl_cache.cpp
View File

@ -115,12 +115,12 @@ bool DLCache::store(uint32_t num_bytes /* = 0*/) {
// If we are allocating new space...
dl_addr = CLCD::mem_read_32(DL_FREE_ADDR);
free_space = MAP::RAM_G_SIZE - dl_addr;
dl_alloc = num_bytes ? num_bytes : new_dl_size;
dl_alloc = num_bytes ?: new_dl_size;
dl_size = new_dl_size;
} else {
// Otherwise, we can only store as much space
// as was previously allocated.
free_space = num_bytes ? num_bytes : dl_size;
free_space = num_bytes ?: dl_size;
dl_alloc = 0;
dl_size = new_dl_size;
}

14
Marlin/src/lcd/extensible_ui/ui_api.cpp
View File

@ -577,12 +577,11 @@ namespace ExtUI {
}
void setAxisMaxFeedrate_mm_s(const feedRate_t value, const axis_t axis) {
planner.settings.max_feedrate_mm_s[axis] = value;
planner.set_max_feedrate(axis, value);
}
void setAxisMaxFeedrate_mm_s(const feedRate_t value, const extruder_t extruder) {
UNUSED_E(extruder);
planner.settings.max_feedrate_mm_s[E_AXIS_N(axis - E0)] = value;
planner.set_max_feedrate(E_AXIS_N(extruder - E0), value);
}
float getAxisMaxAcceleration_mm_s2(const axis_t axis) {
@ -595,12 +594,11 @@ namespace ExtUI {
}
void setAxisMaxAcceleration_mm_s2(const float value, const axis_t axis) {
planner.settings.max_acceleration_mm_per_s2[axis] = value;
planner.set_max_acceleration(axis, value);
}
void setAxisMaxAcceleration_mm_s2(const float value, const extruder_t extruder) {
UNUSED_E(extruder);
planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(extruder - E0)] = value;
planner.set_max_acceleration(E_AXIS_N(extruder - E0), value);
}
#if HAS_FILAMENT_SENSOR
@ -648,11 +646,11 @@ namespace ExtUI {
}
void setAxisMaxJerk_mm_s(const float value, const axis_t axis) {
planner.max_jerk[axis] = value;
planner.set_max_jerk((AxisEnum)axis, value);
}
void setAxisMaxJerk_mm_s(const float value, const extruder_t) {
planner.max_jerk.e = value;
planner.set_max_jerk(E_AXIS, value);
}
#endif

67
Marlin/src/lcd/menu/menu_advanced.cpp
View File

@ -453,14 +453,28 @@ void menu_backlash();
MENU_BACK(MSG_ADVANCED_SETTINGS);
// M203 Max Feedrate
#define EDIT_VMAX(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_##N, &planner.settings.max_feedrate_mm_s[_AXIS(N)], 1, 999)
constexpr xyze_feedrate_t max_fr_edit =
#ifdef MAX_FEEDRATE_EDIT_VALUES
MAX_FEEDRATE_EDIT_VALUES
#elif ENABLED(LIMITED_MAX_FR_EDITING)
DEFAULT_MAX_FEEDRATE
#else
{ 999, 999, 999, 999 }
#endif
;
#if ENABLED(LIMITED_MAX_FR_EDITING) && !defined(MAX_FEEDRATE_EDIT_VALUES)
const xyze_feedrate_t max_fr_edit_scaled = max_fr_edit * 2;
#else
const xyze_feedrate_t &max_fr_edit_scaled = max_fr_edit;
#endif
#define EDIT_VMAX(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_##N, &planner.settings.max_feedrate_mm_s[_AXIS(N)], 1, max_fr_edit_scaled[_AXIS(N)])
EDIT_VMAX(A);
EDIT_VMAX(B);
EDIT_VMAX(C);
#if ENABLED(DISTINCT_E_FACTORS)
#define EDIT_VMAX_E(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_E##N, &planner.settings.max_feedrate_mm_s[E_AXIS_N(N-1)], 1, 999)
MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_E, &planner.settings.max_feedrate_mm_s[E_AXIS_N(active_extruder)], 1, 999);
#define EDIT_VMAX_E(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_E##N, &planner.settings.max_feedrate_mm_s[E_AXIS_N(N-1)], 1, max_fr_edit_scaled.e)
MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_E, &planner.settings.max_feedrate_mm_s[E_AXIS_N(active_extruder)], 1, max_fr_edit_scaled.e);
EDIT_VMAX_E(1);
EDIT_VMAX_E(2);
#if E_STEPPERS > 2
@ -476,7 +490,7 @@ void menu_backlash();
#endif // E_STEPPERS > 3
#endif // E_STEPPERS > 2
#elif E_STEPPERS
MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_E, &planner.settings.max_feedrate_mm_s[E_AXIS], 1, 999);
MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_E, &planner.settings.max_feedrate_mm_s[E_AXIS], 1, max_fr_edit_scaled.e);
#endif
// M205 S Min Feedrate
@ -493,25 +507,41 @@ void menu_backlash();
START_MENU();
MENU_BACK(MSG_ADVANCED_SETTINGS);
static float max_accel = _MAX(planner.settings.max_acceleration_mm_per_s2[A_AXIS], planner.settings.max_acceleration_mm_per_s2[B_AXIS], planner.settings.max_acceleration_mm_per_s2[C_AXIS]);
// M204 P Acceleration
MENU_MULTIPLIER_ITEM_EDIT(float5_25, MSG_ACC, &planner.settings.acceleration, 25, 99000);
MENU_MULTIPLIER_ITEM_EDIT(float5_25, MSG_ACC, &planner.settings.acceleration, 25, max_accel);
// M204 R Retract Acceleration
MENU_MULTIPLIER_ITEM_EDIT(float5, MSG_A_RETRACT, &planner.settings.retract_acceleration, 100, 99000);
MENU_MULTIPLIER_ITEM_EDIT(float5, MSG_A_RETRACT, &planner.settings.retract_acceleration, 100, max_accel);
// M204 T Travel Acceleration
MENU_MULTIPLIER_ITEM_EDIT(float5_25, MSG_A_TRAVEL, &planner.settings.travel_acceleration, 25, 99000);
MENU_MULTIPLIER_ITEM_EDIT(float5_25, MSG_A_TRAVEL, &planner.settings.travel_acceleration, 25, max_accel);
// M201 settings
#define EDIT_AMAX(Q,L) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5_25, MSG_AMAX MSG_##Q, &planner.settings.max_acceleration_mm_per_s2[_AXIS(Q)], L, 99000, _reset_acceleration_rates)
constexpr xyze_ulong_t max_accel_edit =
#ifdef MAX_ACCEL_EDIT_VALUES
MAX_ACCEL_EDIT_VALUES
#elif ENABLED(LIMITED_MAX_ACCEL_EDITING)
DEFAULT_MAX_ACCELERATION
#else
{ 99000, 99000, 99000, 99000 }
#endif
;
#if ENABLED(LIMITED_MAX_ACCEL_EDITING) && !defined(MAX_ACCEL_EDIT_VALUES)
const xyze_ulong_t max_accel_edit_scaled = max_accel_edit * 2;
#else
const xyze_ulong_t &max_accel_edit_scaled = max_accel_edit;
#endif
#define EDIT_AMAX(Q,L) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5_25, MSG_AMAX MSG_##Q, &planner.settings.max_acceleration_mm_per_s2[_AXIS(Q)], L, max_accel_edit_scaled[_AXIS(Q)], _reset_acceleration_rates)
EDIT_AMAX(A,100);
EDIT_AMAX(B,100);
EDIT_AMAX(C, 10);
#if ENABLED(DISTINCT_E_FACTORS)
#define EDIT_AMAX_E(N,E) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E##N, &planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(E)], 100, 99000, _reset_e##E##_acceleration_rate)
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E, &planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(active_extruder)], 100, 99000, _reset_acceleration_rates);
#define EDIT_AMAX_E(N,E) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5_25, MSG_AMAX MSG_E##N, &planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(E)], 100, max_accel_edit_scaled.e, _reset_e##E##_acceleration_rate)
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5_25, MSG_AMAX MSG_E, &planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(active_extruder)], 100, max_accel_edit_scaled.e, _reset_acceleration_rates);
EDIT_AMAX_E(1,0);
EDIT_AMAX_E(2,1);
#if E_STEPPERS > 2
@ -527,7 +557,7 @@ void menu_backlash();
#endif // E_STEPPERS > 3
#endif // E_STEPPERS > 2
#elif E_STEPPERS
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E, &planner.settings.max_acceleration_mm_per_s2[E_AXIS], 100, 99000, _reset_acceleration_rates);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5_25, MSG_AMAX MSG_E, &planner.settings.max_acceleration_mm_per_s2[E_AXIS], 100, max_accel_edit_scaled.e, _reset_acceleration_rates);
#endif
END_MENU();
@ -546,16 +576,25 @@ void menu_backlash();
#endif
#endif
#if HAS_CLASSIC_JERK
#define EDIT_JERK(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_V##N##_JERK, &planner.max_jerk[_AXIS(N)], 1, 990)
constexpr xyze_float_t max_jerk_edit =
#ifdef MAX_ACCEL_EDIT_VALUES
MAX_JERK_EDIT_VALUES
#elif ENABLED(LIMITED_JERK_EDITING)
{ (DEFAULT_XJERK) * 2, (DEFAULT_YJERK) * 2, (DEFAULT_ZJERK) * 2, (DEFAULT_EJERK) * 2 }
#else
{ 990, 990, 990, 990 }
#endif
;
#define EDIT_JERK(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_V##N##_JERK, &planner.max_jerk[_AXIS(N)], 1, max_jerk_edit[_AXIS(N)])
EDIT_JERK(A);
EDIT_JERK(B);
#if ENABLED(DELTA)
EDIT_JERK(C);
#else
MENU_MULTIPLIER_ITEM_EDIT(float52sign, MSG_VC_JERK, &planner.max_jerk.c, 0.1f, 990);
MENU_MULTIPLIER_ITEM_EDIT(float52sign, MSG_VC_JERK, &planner.max_jerk.c, 0.1f, max_jerk_edit.c);
#endif
#if !BOTH(JUNCTION_DEVIATION, LIN_ADVANCE)
EDIT_JERK(E);
MENU_MULTIPLIER_ITEM_EDIT(float52sign, MSG_VE_JERK, &planner.max_jerk.e, 0.1f, max_jerk_edit.e);
#endif
#endif

6
Marlin/src/module/motion.cpp
View File

@ -344,8 +344,8 @@ void _internal_move_to_destination(const feedRate_t &fr_mm_s/*=0.0f*/
void do_blocking_move_to(const float rx, const float ry, const float rz, const feedRate_t &fr_mm_s/*=0.0*/) {
if (DEBUGGING(LEVELING)) DEBUG_XYZ(">>> do_blocking_move_to", rx, ry, rz);
const feedRate_t z_feedrate = fr_mm_s ? fr_mm_s : homing_feedrate(Z_AXIS),
xy_feedrate = fr_mm_s ? fr_mm_s : feedRate_t(XY_PROBE_FEEDRATE_MM_S);
const feedRate_t z_feedrate = fr_mm_s ?: homing_feedrate(Z_AXIS),
xy_feedrate = fr_mm_s ?: feedRate_t(XY_PROBE_FEEDRATE_MM_S);
#if ENABLED(DELTA)
@ -1255,7 +1255,7 @@ void do_homing_move(const AxisEnum axis, const float distance, const feedRate_t
#endif
}
const feedRate_t real_fr_mm_s = fr_mm_s ? fr_mm_s : homing_feedrate(axis);
const feedRate_t real_fr_mm_s = fr_mm_s ?: homing_feedrate(axis);
#if IS_SCARA
// Tell the planner the axis is at 0
current_position[axis] = 0;

64
Marlin/src/module/planner.cpp
View File

@ -2653,7 +2653,7 @@ bool Planner::buffer_line(const float &rx, const float &ry, const float &rz, con
#if ENABLED(SCARA_FEEDRATE_SCALING)
// For SCARA scale the feed rate from mm/s to degrees/s
// i.e., Complete the angular vector in the given time.
const float duration_recip = inv_duration ? inv_duration : fr_mm_s / mm;
const float duration_recip = inv_duration ?: fr_mm_s / mm;
const feedRate_t feedrate = HYPOT(delta.a - position_float.a, delta.b - position_float.b) * duration_recip;
#else
const feedRate_t feedrate = fr_mm_s;
@ -2772,6 +2772,68 @@ void Planner::refresh_positioning() {
reset_acceleration_rates();
}
inline void limit_and_warn(float &val, const uint8_t axis, PGM_P const setting_name, const xyze_float_t &max_limit) {
const uint8_t lim_axis = axis > E_AXIS ? E_AXIS : axis;
const float before = val;
LIMIT(val, 1, max_limit[lim_axis]);
if (before != val) {
SERIAL_CHAR(axis_codes[lim_axis]);
SERIAL_ECHOPGM(" Max ");
serialprintPGM(setting_name);
SERIAL_ECHOLNPAIR(" limited to ", val);
}
}
void Planner::set_max_acceleration(const uint8_t axis, float targetValue) {
#if ENABLED(LIMITED_MAX_ACCEL_EDITING)
#ifdef MAX_ACCEL_EDIT_VALUES
constexpr xyze_float_t max_accel_edit = MAX_ACCEL_EDIT_VALUES;
const xyze_float_t &max_acc_edit_scaled = max_accel_edit;
#else
constexpr xyze_float_t max_accel_edit = DEFAULT_MAX_ACCELERATION,
max_acc_edit_scaled = max_accel_edit * 2;
#endif
limit_and_warn(targetValue, axis, PSTR("Acceleration"), max_acc_edit_scaled);
#endif
settings.max_acceleration_mm_per_s2[axis] = targetValue;
// Update steps per s2 to agree with the units per s2 (since they are used in the planner)
reset_acceleration_rates();
}
void Planner::set_max_feedrate(const uint8_t axis, float targetValue) {
#if ENABLED(LIMITED_MAX_FR_EDITING)
#ifdef MAX_FEEDRATE_EDIT_VALUES
constexpr xyze_float_t max_fr_edit = MAX_FEEDRATE_EDIT_VALUES;
const xyze_float_t &max_fr_edit_scaled = max_fr_edit;
#else
constexpr xyze_float_t max_fr_edit = DEFAULT_MAX_FEEDRATE,
max_fr_edit_scaled = max_fr_edit * 2;
#endif
limit_and_warn(targetValue, axis, PSTR("Feedrate"), max_fr_edit_scaled);
#endif
settings.max_feedrate_mm_s[axis] = targetValue;
}
void Planner::set_max_jerk(const AxisEnum axis, float targetValue) {
#if HAS_CLASSIC_JERK
#if ENABLED(LIMITED_JERK_EDITING)
constexpr xyze_float_t max_jerk_edit =
#ifdef MAX_JERK_EDIT_VALUES
MAX_JERK_EDIT_VALUES
#else
{ (DEFAULT_XJERK) * 2, (DEFAULT_YJERK) * 2,
(DEFAULT_ZJERK) * 2, (DEFAULT_EJERK) * 2 }
#endif
;
limit_and_warn(targetValue, axis, PSTR("Jerk"), max_jerk_edit);
#endif
max_jerk[axis] = targetValue;
#else
UNUSED(axis); UNUSED(targetValue);
#endif
}
#if ENABLED(AUTOTEMP)
void Planner::autotemp_M104_M109() {

4
Marlin/src/module/planner.h
View File

@ -358,6 +358,10 @@ class Planner {
static void reset_acceleration_rates();
static void refresh_positioning();
static void set_max_acceleration(const uint8_t axis, float targetValue);
static void set_max_feedrate(const uint8_t axis, float targetValue);
static void set_max_jerk(const AxisEnum axis, float targetValue);
#if EXTRUDERS
FORCE_INLINE static void refresh_e_factor(const uint8_t e) {