diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h index a3cb9f0ea..9850d5570 100644 --- a/Marlin/Configuration_adv.h +++ b/Marlin/Configuration_adv.h @@ -496,24 +496,33 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif -// Enabling ENSURE_SMOOTH_MOVES ensures your printer will never stutter (for example in circles with a short segments). That's done in two steps: -// --1-- -// During short segments like in circles, the update of the LCD Display can take so long that the block buffer gets completely drained. -// If that happens, the movement of the printer gets very jerky until a longer segment like a longer straight line allows the buffer -// to be filled again. This small stops also effects print quality in a bad way. -// Enable ENSURE_SMOOTH_MOVES to update the LCD only when there is enough time during a move to do so. -// Note that this means the display will not show actual values during this time and your printer will also not react to buttons -// pressed immediately, except ALWAYS_ALLOW_MENU is also enabled. -// --2-- -// No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main loop to add a new block to the buffer, checking temps, -// including all interruptions due to interrupts, but without LCD update. If we would allow shorter moves, the buffer would start continously draining. +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// //#define ENSURE_SMOOTH_MOVES #if ENABLED(ENSURE_SMOOTH_MOVES) - //#define ALWAYS_ALLOW_MENU // If enabled, the menu will be always accessible. - // WARNING: If the menu is entered or navigated during short moves, the printer will stutter like without ENSURE_SMOOTH_MOVES! - #define LCD_UPDATE_THRESHOLD 170 // Minimum duration in ms of the current segment to allow a LCD update. - // Default value is valid for graphical LCDs like the REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER. - #define MIN_BLOCK_TIME 6 // Minimum duration in ms a single block has to take. You shouldn't need to modify this. + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. #endif // @section extruder diff --git a/Marlin/example_configurations/Cartesio/Configuration_adv.h b/Marlin/example_configurations/Cartesio/Configuration_adv.h index 886cdd38f..463254c04 100644 --- a/Marlin/example_configurations/Cartesio/Configuration_adv.h +++ b/Marlin/example_configurations/Cartesio/Configuration_adv.h @@ -496,6 +496,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/Felix/Configuration_adv.h b/Marlin/example_configurations/Felix/Configuration_adv.h index 70d4d434e..80c52620b 100644 --- a/Marlin/example_configurations/Felix/Configuration_adv.h +++ b/Marlin/example_configurations/Felix/Configuration_adv.h @@ -496,6 +496,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/Hephestos/Configuration_adv.h b/Marlin/example_configurations/Hephestos/Configuration_adv.h index a749bcde0..17c200ba3 100644 --- a/Marlin/example_configurations/Hephestos/Configuration_adv.h +++ b/Marlin/example_configurations/Hephestos/Configuration_adv.h @@ -496,6 +496,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/Hephestos_2/Configuration_adv.h b/Marlin/example_configurations/Hephestos_2/Configuration_adv.h index cddfc6ede..5f54de89e 100644 --- a/Marlin/example_configurations/Hephestos_2/Configuration_adv.h +++ b/Marlin/example_configurations/Hephestos_2/Configuration_adv.h @@ -496,6 +496,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/K8200/Configuration_adv.h b/Marlin/example_configurations/K8200/Configuration_adv.h index 5ff3899fc..4d4335bb3 100644 --- a/Marlin/example_configurations/K8200/Configuration_adv.h +++ b/Marlin/example_configurations/K8200/Configuration_adv.h @@ -509,6 +509,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/K8400/Configuration_adv.h b/Marlin/example_configurations/K8400/Configuration_adv.h index d785efb7a..d2f3aea8b 100644 --- a/Marlin/example_configurations/K8400/Configuration_adv.h +++ b/Marlin/example_configurations/K8400/Configuration_adv.h @@ -496,6 +496,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/RigidBot/Configuration_adv.h b/Marlin/example_configurations/RigidBot/Configuration_adv.h index 6a2e56f3a..2b45809ff 100644 --- a/Marlin/example_configurations/RigidBot/Configuration_adv.h +++ b/Marlin/example_configurations/RigidBot/Configuration_adv.h @@ -496,6 +496,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/SCARA/Configuration_adv.h b/Marlin/example_configurations/SCARA/Configuration_adv.h index 3aac74fe1..e2b39c89c 100644 --- a/Marlin/example_configurations/SCARA/Configuration_adv.h +++ b/Marlin/example_configurations/SCARA/Configuration_adv.h @@ -496,6 +496,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/TAZ4/Configuration_adv.h b/Marlin/example_configurations/TAZ4/Configuration_adv.h index 176c73edf..c8067fd6d 100644 --- a/Marlin/example_configurations/TAZ4/Configuration_adv.h +++ b/Marlin/example_configurations/TAZ4/Configuration_adv.h @@ -504,6 +504,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/WITBOX/Configuration_adv.h b/Marlin/example_configurations/WITBOX/Configuration_adv.h index a749bcde0..17c200ba3 100644 --- a/Marlin/example_configurations/WITBOX/Configuration_adv.h +++ b/Marlin/example_configurations/WITBOX/Configuration_adv.h @@ -496,6 +496,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/delta/biv2.5/Configuration_adv.h b/Marlin/example_configurations/delta/biv2.5/Configuration_adv.h index f0370b5d7..630b10060 100644 --- a/Marlin/example_configurations/delta/biv2.5/Configuration_adv.h +++ b/Marlin/example_configurations/delta/biv2.5/Configuration_adv.h @@ -498,6 +498,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/delta/generic/Configuration_adv.h b/Marlin/example_configurations/delta/generic/Configuration_adv.h index d897d4662..703c42f26 100644 --- a/Marlin/example_configurations/delta/generic/Configuration_adv.h +++ b/Marlin/example_configurations/delta/generic/Configuration_adv.h @@ -498,6 +498,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/delta/kossel_mini/Configuration_adv.h b/Marlin/example_configurations/delta/kossel_mini/Configuration_adv.h index d897d4662..703c42f26 100644 --- a/Marlin/example_configurations/delta/kossel_mini/Configuration_adv.h +++ b/Marlin/example_configurations/delta/kossel_mini/Configuration_adv.h @@ -498,6 +498,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/delta/kossel_pro/Configuration_adv.h b/Marlin/example_configurations/delta/kossel_pro/Configuration_adv.h index 8805a3b4c..0ccc9cf4b 100644 --- a/Marlin/example_configurations/delta/kossel_pro/Configuration_adv.h +++ b/Marlin/example_configurations/delta/kossel_pro/Configuration_adv.h @@ -503,6 +503,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/delta/kossel_xl/Configuration_adv.h b/Marlin/example_configurations/delta/kossel_xl/Configuration_adv.h index ea4118977..35e119b49 100644 --- a/Marlin/example_configurations/delta/kossel_xl/Configuration_adv.h +++ b/Marlin/example_configurations/delta/kossel_xl/Configuration_adv.h @@ -498,6 +498,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/makibox/Configuration_adv.h b/Marlin/example_configurations/makibox/Configuration_adv.h index 9a5213329..150ed0f7d 100644 --- a/Marlin/example_configurations/makibox/Configuration_adv.h +++ b/Marlin/example_configurations/makibox/Configuration_adv.h @@ -496,6 +496,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3) diff --git a/Marlin/example_configurations/tvrrug/Round2/Configuration_adv.h b/Marlin/example_configurations/tvrrug/Round2/Configuration_adv.h index 0d1575c08..373a73d98 100644 --- a/Marlin/example_configurations/tvrrug/Round2/Configuration_adv.h +++ b/Marlin/example_configurations/tvrrug/Round2/Configuration_adv.h @@ -496,6 +496,35 @@ #define BABYSTEP_MULTIPLICATOR 1 //faster movements #endif +// +// Ensure Smooth Moves +// +// Enable this option to prevent the machine from stuttering when printing multiple short segments. +// This feature uses two strategies to eliminate stuttering: +// +// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets +// completely drained. When this happens pauses are introduced between short segments, and print moves +// will become jerky until a longer segment provides enough time for the buffer to be filled again. +// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue +// by pausing the LCD until there's enough time to safely update. +// +// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive. +// Enable ALWAYS_ALLOW_MENU to keep the controller responsive. +// +// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main +// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to +// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from +// draining. +// +//#define ENSURE_SMOOTH_MOVES +#if ENABLED(ENSURE_SMOOTH_MOVES) + //#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive. + // WARNING: Menu navigation during short moves may cause stuttering! + #define LCD_UPDATE_THRESHOLD 170 // (ms) Minimum duration for the current segment to allow an LCD update. + // Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER). + #define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this. +#endif + // @section extruder // extruder advance constant (s2/mm3)