diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h index f750c42fa..9850d5570 100644 --- a/Marlin/Configuration_adv.h +++ b/Marlin/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/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) diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp index ab03d9fe3..c9d681e9b 100644 --- a/Marlin/planner.cpp +++ b/Marlin/planner.cpp @@ -937,12 +937,24 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const if (segment_time < min_segment_time) { // buffer is draining, add extra time. The amount of time added increases if the buffer is still emptied more. inverse_mm_s = 1000000.0 / (segment_time + lround(2 * (min_segment_time - segment_time) / moves_queued)); - #ifdef XY_FREQUENCY_LIMIT + #if defined(XY_FREQUENCY_LIMIT) || ENABLED(ENSURE_SMOOTH_MOVES) segment_time = lround(1000000.0 / inverse_mm_s); #endif } } #endif + + #if ENABLED(ENSURE_SMOOTH_MOVES) + #if DISABLED(SLOWDOWN) + unsigned long segment_time = lround(1000000.0 / inverse_mm_s); + #endif + if (segment_time < (MIN_BLOCK_TIME) * 1000UL) { + // buffer will be draining, set to MIN_BLOCK_TIME. + inverse_mm_s = 1000000.0 / (1000.0 * (MIN_BLOCK_TIME)); + segment_time = (MIN_BLOCK_TIME) * 1000UL; + } + block->segment_time = segment_time; + #endif block->nominal_speed = block->millimeters * inverse_mm_s; // (mm/sec) Always > 0 block->nominal_rate = ceil(block->step_event_count * inverse_mm_s); // (step/sec) Always > 0 diff --git a/Marlin/planner.h b/Marlin/planner.h index 8b8d49865..3121f1943 100644 --- a/Marlin/planner.h +++ b/Marlin/planner.h @@ -123,6 +123,10 @@ typedef struct { #if ENABLED(BARICUDA) uint32_t valve_pressure, e_to_p_pressure; #endif + + #if ENABLED(ENSURE_SMOOTH_MOVES) + uint32_t segment_time; + #endif } block_t; @@ -366,6 +370,17 @@ class Planner { return NULL; } + #if ENABLED(ENSURE_SMOOTH_MOVES) + static bool long_move() { + if (blocks_queued()) { + block_t* block = &block_buffer[block_buffer_tail]; + return block->segment_time > (LCD_UPDATE_THRESHOLD) * 1000UL; + } + else + return true; + } + #endif + #if ENABLED(AUTOTEMP) static float autotemp_max; static float autotemp_min; diff --git a/Marlin/ultralcd.cpp b/Marlin/ultralcd.cpp index 2216a9f1c..7073b9125 100755 --- a/Marlin/ultralcd.cpp +++ b/Marlin/ultralcd.cpp @@ -2707,77 +2707,93 @@ void lcd_update() { } #endif // ULTIPANEL + #if ENABLED(ENSURE_SMOOTH_MOVES) && ENABLED(ALWAYS_ALLOW_MENU) + #define STATUS_UPDATE_CONDITION planner.long_move() + #else + #define STATUS_UPDATE_CONDITION true + #endif + #if ENABLED(ENSURE_SMOOTH_MOVES) && DISABLED(ALWAYS_ALLOW_MENU) + #define LCD_HANDLER_CONDITION planner.long_move() + #else + #define LCD_HANDLER_CONDITION true + #endif + // We arrive here every ~100ms when idling often enough. // Instead of tracking the changes simply redraw the Info Screen ~1 time a second. static int8_t lcd_status_update_delay = 1; // first update one loop delayed - if ( + if (STATUS_UPDATE_CONDITION && #if ENABLED(ULTIPANEL) currentScreen == lcd_status_screen && #endif - !lcd_status_update_delay--) { + !lcd_status_update_delay-- + ) { lcd_status_update_delay = 9; lcdDrawUpdate = LCDVIEW_REDRAW_NOW; } - if (lcdDrawUpdate) { + if (LCD_HANDLER_CONDITION) { - switch (lcdDrawUpdate) { - case LCDVIEW_CALL_NO_REDRAW: - lcdDrawUpdate = LCDVIEW_NONE; - break; - case LCDVIEW_CLEAR_CALL_REDRAW: // set by handlers, then altered after (rarely occurs here) - case LCDVIEW_CALL_REDRAW_NEXT: // set by handlers, then altered after (never occurs here?) - lcdDrawUpdate = LCDVIEW_REDRAW_NOW; - case LCDVIEW_REDRAW_NOW: // set above, or by a handler through LCDVIEW_CALL_REDRAW_NEXT - case LCDVIEW_NONE: - break; + if (lcdDrawUpdate) { + + switch (lcdDrawUpdate) { + case LCDVIEW_CALL_NO_REDRAW: + lcdDrawUpdate = LCDVIEW_NONE; + break; + case LCDVIEW_CLEAR_CALL_REDRAW: // set by handlers, then altered after (rarely occurs here) + case LCDVIEW_CALL_REDRAW_NEXT: // set by handlers, then altered after (never occurs here?) + lcdDrawUpdate = LCDVIEW_REDRAW_NOW; + case LCDVIEW_REDRAW_NOW: // set above, or by a handler through LCDVIEW_CALL_REDRAW_NEXT + case LCDVIEW_NONE: + break; + } // switch + + #if ENABLED(ULTIPANEL) + #define CURRENTSCREEN() (*currentScreen)(), lcd_clicked = false + #else + #define CURRENTSCREEN() lcd_status_screen() + #endif + + #if ENABLED(DOGLCD) // Changes due to different driver architecture of the DOGM display + static int8_t dot_color = 0; + dot_color = 1 - dot_color; + u8g.firstPage(); + do { + lcd_setFont(FONT_MENU); + u8g.setPrintPos(125, 0); + u8g.setColorIndex(dot_color); // Set color for the alive dot + u8g.drawPixel(127, 63); // draw alive dot + u8g.setColorIndex(1); // black on white + CURRENTSCREEN(); + } while (u8g.nextPage()); + #else + CURRENTSCREEN(); + #endif } #if ENABLED(ULTIPANEL) - #define CURRENTSCREEN() (*currentScreen)(), lcd_clicked = false - #else - #define CURRENTSCREEN() lcd_status_screen() - #endif - #if ENABLED(DOGLCD) // Changes due to different driver architecture of the DOGM display - static int8_t dot_color = 0; - dot_color = 1 - dot_color; - u8g.firstPage(); - do { - lcd_setFont(FONT_MENU); - u8g.setPrintPos(125, 0); - u8g.setColorIndex(dot_color); // Set color for the alive dot - u8g.drawPixel(127, 63); // draw alive dot - u8g.setColorIndex(1); // black on white - CURRENTSCREEN(); - } while (u8g.nextPage()); - #else - CURRENTSCREEN(); - #endif - } + // Return to Status Screen after a timeout + if (currentScreen == lcd_status_screen || defer_return_to_status) + return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS; + else if (ELAPSED(ms, return_to_status_ms)) + lcd_return_to_status(); - #if ENABLED(ULTIPANEL) + #endif // ULTIPANEL - // Return to Status Screen after a timeout - if (currentScreen == lcd_status_screen || defer_return_to_status) - return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS; - else if (ELAPSED(ms, return_to_status_ms)) - lcd_return_to_status(); + switch (lcdDrawUpdate) { + case LCDVIEW_CLEAR_CALL_REDRAW: + lcd_implementation_clear(); + case LCDVIEW_CALL_REDRAW_NEXT: + lcdDrawUpdate = LCDVIEW_REDRAW_NOW; + break; + case LCDVIEW_REDRAW_NOW: + lcdDrawUpdate = LCDVIEW_NONE; + break; + case LCDVIEW_NONE: + break; + } // switch - #endif // ULTIPANEL - - switch (lcdDrawUpdate) { - case LCDVIEW_CLEAR_CALL_REDRAW: - lcd_implementation_clear(); - case LCDVIEW_CALL_REDRAW_NEXT: - lcdDrawUpdate = LCDVIEW_REDRAW_NOW; - break; - case LCDVIEW_REDRAW_NOW: - lcdDrawUpdate = LCDVIEW_NONE; - break; - case LCDVIEW_NONE: - break; - } + } // LCD_HANDLER_CONDITION } }