From 470d5ac09f5b5fa54b3961944e9ba0ae2bbbbefa Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Thu, 26 May 2016 11:22:51 -0700 Subject: [PATCH 1/2] Apply static to Planner class --- Marlin/planner.cpp | 58 +++++++++++++++++++++++ Marlin/planner.h | 116 ++++++++++++++++++++++++--------------------- 2 files changed, 120 insertions(+), 54 deletions(-) diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp index 05a3c7174e..3627f27612 100644 --- a/Marlin/planner.cpp +++ b/Marlin/planner.cpp @@ -71,6 +71,64 @@ Planner planner; + // public: + +/** + * A ring buffer of moves described in steps + */ +block_t Planner::block_buffer[BLOCK_BUFFER_SIZE]; +volatile uint8_t Planner::block_buffer_head = 0; // Index of the next block to be pushed +volatile uint8_t Planner::block_buffer_tail = 0; + +float Planner::max_feedrate[NUM_AXIS]; // Max speeds in mm per minute +float Planner::axis_steps_per_unit[NUM_AXIS]; +unsigned long Planner::axis_steps_per_sqr_second[NUM_AXIS]; +unsigned long Planner::max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software + +millis_t Planner::min_segment_time; +float Planner::min_feedrate; +float Planner::acceleration; // Normal acceleration mm/s^2 DEFAULT ACCELERATION for all printing moves. M204 SXXXX +float Planner::retract_acceleration; // Retract acceleration mm/s^2 filament pull-back and push-forward while standing still in the other axes M204 TXXXX +float Planner::travel_acceleration; // Travel acceleration mm/s^2 DEFAULT ACCELERATION for all NON printing moves. M204 MXXXX +float Planner::max_xy_jerk; // The largest speed change requiring no acceleration +float Planner::max_z_jerk; +float Planner::max_e_jerk; +float Planner::min_travel_feedrate; + +#if ENABLED(AUTO_BED_LEVELING_FEATURE) + matrix_3x3 Planner::bed_level_matrix; // Transform to compensate for bed level +#endif + +#if ENABLED(AUTOTEMP) + float Planner::autotemp_max = 250; + float Planner::autotemp_min = 210; + float Planner::autotemp_factor = 0.1; + bool Planner::autotemp_enabled = false; +#endif + +// private: + +long Planner::position[NUM_AXIS] = { 0 }; + +float Planner::previous_speed[NUM_AXIS]; + +float Planner::previous_nominal_speed; + +#if ENABLED(DISABLE_INACTIVE_EXTRUDER) + uint8_t Planner::g_uc_extruder_last_move[EXTRUDERS] = { 0 }; +#endif // DISABLE_INACTIVE_EXTRUDER + +#ifdef XY_FREQUENCY_LIMIT + // Old direction bits. Used for speed calculations + unsigned char Planner::old_direction_bits = 0; + // Segment times (in µs). Used for speed calculations + long Planner::axis_segment_time[2][3] = { {MAX_FREQ_TIME + 1, 0, 0}, {MAX_FREQ_TIME + 1, 0, 0} }; +#endif + +/** + * Class and Instance Methods + */ + Planner::Planner() { #if ENABLED(AUTO_BED_LEVELING_FEATURE) bed_level_matrix.set_to_identity(); diff --git a/Marlin/planner.h b/Marlin/planner.h index f62398397a..580bf765dc 100644 --- a/Marlin/planner.h +++ b/Marlin/planner.h @@ -108,27 +108,27 @@ class Planner { /** * A ring buffer of moves described in steps */ - block_t block_buffer[BLOCK_BUFFER_SIZE]; - volatile uint8_t block_buffer_head = 0; // Index of the next block to be pushed - volatile uint8_t block_buffer_tail = 0; + static block_t block_buffer[BLOCK_BUFFER_SIZE]; + static volatile uint8_t block_buffer_head; // Index of the next block to be pushed + static volatile uint8_t block_buffer_tail; - float max_feedrate[NUM_AXIS]; // Max speeds in mm per minute - float axis_steps_per_unit[NUM_AXIS]; - unsigned long axis_steps_per_sqr_second[NUM_AXIS]; - unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software + static float max_feedrate[NUM_AXIS]; // Max speeds in mm per minute + static float axis_steps_per_unit[NUM_AXIS]; + static unsigned long axis_steps_per_sqr_second[NUM_AXIS]; + static unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software - millis_t min_segment_time; - float min_feedrate; - float acceleration; // Normal acceleration mm/s^2 DEFAULT ACCELERATION for all printing moves. M204 SXXXX - float retract_acceleration; // Retract acceleration mm/s^2 filament pull-back and push-forward while standing still in the other axes M204 TXXXX - float travel_acceleration; // Travel acceleration mm/s^2 DEFAULT ACCELERATION for all NON printing moves. M204 MXXXX - float max_xy_jerk; // The largest speed change requiring no acceleration - float max_z_jerk; - float max_e_jerk; - float min_travel_feedrate; + static millis_t min_segment_time; + static float min_feedrate; + static float acceleration; // Normal acceleration mm/s^2 DEFAULT ACCELERATION for all printing moves. M204 SXXXX + static float retract_acceleration; // Retract acceleration mm/s^2 filament pull-back and push-forward while standing still in the other axes M204 TXXXX + static float travel_acceleration; // Travel acceleration mm/s^2 DEFAULT ACCELERATION for all NON printing moves. M204 MXXXX + static float max_xy_jerk; // The largest speed change requiring no acceleration + static float max_z_jerk; + static float max_e_jerk; + static float min_travel_feedrate; #if ENABLED(AUTO_BED_LEVELING_FEATURE) - matrix_3x3 bed_level_matrix; // Transform to compensate for bed level + static matrix_3x3 bed_level_matrix; // Transform to compensate for bed level #endif private: @@ -137,49 +137,57 @@ class Planner { * The current position of the tool in absolute steps * Reclculated if any axis_steps_per_unit are changed by gcode */ - long position[NUM_AXIS] = { 0 }; + static long position[NUM_AXIS]; /** * Speed of previous path line segment */ - float previous_speed[NUM_AXIS]; + static float previous_speed[NUM_AXIS]; /** * Nominal speed of previous path line segment */ - float previous_nominal_speed; + static float previous_nominal_speed; #if ENABLED(DISABLE_INACTIVE_EXTRUDER) /** * Counters to manage disabling inactive extruders */ - uint8_t g_uc_extruder_last_move[EXTRUDERS] = { 0 }; + static uint8_t g_uc_extruder_last_move[EXTRUDERS]; #endif // DISABLE_INACTIVE_EXTRUDER #ifdef XY_FREQUENCY_LIMIT // Used for the frequency limit - #define MAX_FREQ_TIME (1000000.0/XY_FREQUENCY_LIMIT) + #define MAX_FREQ_TIME long(1000000.0/XY_FREQUENCY_LIMIT) // Old direction bits. Used for speed calculations - static unsigned char old_direction_bits = 0; + static unsigned char old_direction_bits; // Segment times (in µs). Used for speed calculations - static long axis_segment_time[2][3] = { {MAX_FREQ_TIME + 1, 0, 0}, {MAX_FREQ_TIME + 1, 0, 0} }; + static long axis_segment_time[2][3]; #endif public: + /** + * Instance Methods + */ + Planner(); void init(); - void reset_acceleration_rates(); + /** + * Static (class) Methods + */ + + static void reset_acceleration_rates(); // Manage fans, paste pressure, etc. - void check_axes_activity(); + static void check_axes_activity(); /** * Number of moves currently in the planner */ - FORCE_INLINE uint8_t movesplanned() { return BLOCK_MOD(block_buffer_head - block_buffer_tail + BLOCK_BUFFER_SIZE); } + static FORCE_INLINE uint8_t movesplanned() { return BLOCK_MOD(block_buffer_head - block_buffer_tail + BLOCK_BUFFER_SIZE); } #if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING) @@ -187,7 +195,7 @@ class Planner { /** * The corrected position, applying the bed level matrix */ - vector_3 adjusted_position(); + static vector_3 adjusted_position(); #endif /** @@ -197,7 +205,7 @@ class Planner { * feed_rate - (target) speed of the move * extruder - target extruder */ - void buffer_line(float x, float y, float z, const float& e, float feed_rate, const uint8_t extruder); + static void buffer_line(float x, float y, float z, const float& e, float feed_rate, const uint8_t extruder); /** * Set the planner.position and individual stepper positions. @@ -208,30 +216,30 @@ class Planner { * * Clears previous speed values. */ - void set_position(float x, float y, float z, const float& e); + static void set_position(float x, float y, float z, const float& e); #else - void buffer_line(const float& x, const float& y, const float& z, const float& e, float feed_rate, const uint8_t extruder); - void set_position(const float& x, const float& y, const float& z, const float& e); + static void buffer_line(const float& x, const float& y, const float& z, const float& e, float feed_rate, const uint8_t extruder); + static void set_position(const float& x, const float& y, const float& z, const float& e); #endif // AUTO_BED_LEVELING_FEATURE || MESH_BED_LEVELING /** * Set the E position (mm) of the planner (and the E stepper) */ - void set_e_position(const float& e); + static void set_e_position(const float& e); /** * Does the buffer have any blocks queued? */ - FORCE_INLINE bool blocks_queued() { return (block_buffer_head != block_buffer_tail); } + static FORCE_INLINE bool blocks_queued() { return (block_buffer_head != block_buffer_tail); } /** * "Discards" the block and "releases" the memory. * Called when the current block is no longer needed. */ - FORCE_INLINE void discard_current_block() { + static FORCE_INLINE void discard_current_block() { if (blocks_queued()) block_buffer_tail = BLOCK_MOD(block_buffer_tail + 1); } @@ -240,7 +248,7 @@ class Planner { * The current block. NULL if the buffer is empty. * This also marks the block as busy. */ - FORCE_INLINE block_t* get_current_block() { + static FORCE_INLINE block_t* get_current_block() { if (blocks_queued()) { block_t* block = &block_buffer[block_buffer_tail]; block->busy = true; @@ -251,12 +259,12 @@ class Planner { } #if ENABLED(AUTOTEMP) - float autotemp_max = 250; - float autotemp_min = 210; - float autotemp_factor = 0.1; - bool autotemp_enabled = false; - void getHighESpeed(); - void autotemp_M109(); + static float autotemp_max; + static float autotemp_min; + static float autotemp_factor; + static bool autotemp_enabled; + static void getHighESpeed(); + static void autotemp_M109(); #endif private: @@ -264,14 +272,14 @@ class Planner { /** * Get the index of the next / previous block in the ring buffer */ - FORCE_INLINE int8_t next_block_index(int8_t block_index) { return BLOCK_MOD(block_index + 1); } - FORCE_INLINE int8_t prev_block_index(int8_t block_index) { return BLOCK_MOD(block_index - 1); } + static FORCE_INLINE int8_t next_block_index(int8_t block_index) { return BLOCK_MOD(block_index + 1); } + static FORCE_INLINE int8_t prev_block_index(int8_t block_index) { return BLOCK_MOD(block_index - 1); } /** * Calculate the distance (not time) it takes to accelerate * from initial_rate to target_rate using the given acceleration: */ - FORCE_INLINE float estimate_acceleration_distance(float initial_rate, float target_rate, float acceleration) { + static FORCE_INLINE float estimate_acceleration_distance(float initial_rate, float target_rate, float acceleration) { if (acceleration == 0) return 0; // acceleration was 0, set acceleration distance to 0 return (target_rate * target_rate - initial_rate * initial_rate) / (acceleration * 2); } @@ -284,7 +292,7 @@ class Planner { * This is used to compute the intersection point between acceleration and deceleration * in cases where the "trapezoid" has no plateau (i.e., never reaches maximum speed) */ - FORCE_INLINE float intersection_distance(float initial_rate, float final_rate, float acceleration, float distance) { + static FORCE_INLINE float intersection_distance(float initial_rate, float final_rate, float acceleration, float distance) { if (acceleration == 0) return 0; // acceleration was 0, set intersection distance to 0 return (acceleration * 2 * distance - initial_rate * initial_rate + final_rate * final_rate) / (acceleration * 4); } @@ -294,21 +302,21 @@ class Planner { * to reach 'target_velocity' using 'acceleration' within a given * 'distance'. */ - FORCE_INLINE float max_allowable_speed(float acceleration, float target_velocity, float distance) { + static FORCE_INLINE float max_allowable_speed(float acceleration, float target_velocity, float distance) { return sqrt(target_velocity * target_velocity - 2 * acceleration * distance); } - void calculate_trapezoid_for_block(block_t* block, float entry_factor, float exit_factor); + static void calculate_trapezoid_for_block(block_t* block, float entry_factor, float exit_factor); - void reverse_pass_kernel(block_t* previous, block_t* current, block_t* next); - void forward_pass_kernel(block_t* previous, block_t* current, block_t* next); + static void reverse_pass_kernel(block_t* previous, block_t* current, block_t* next); + static void forward_pass_kernel(block_t* previous, block_t* current, block_t* next); - void reverse_pass(); - void forward_pass(); + static void reverse_pass(); + static void forward_pass(); - void recalculate_trapezoids(); + static void recalculate_trapezoids(); - void recalculate(); + static void recalculate(); }; From ff53819856f45e036c483e9435f8e8257dee15f2 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Mon, 30 May 2016 17:18:28 -0700 Subject: [PATCH 2/2] Drop FORCE_INLINE in planner.h This change actually does increase the binary size by about 12 bytes, but how does it affect performance? --- Marlin/planner.h | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/Marlin/planner.h b/Marlin/planner.h index 580bf765dc..b263e2dfa0 100644 --- a/Marlin/planner.h +++ b/Marlin/planner.h @@ -187,7 +187,7 @@ class Planner { /** * Number of moves currently in the planner */ - static FORCE_INLINE uint8_t movesplanned() { return BLOCK_MOD(block_buffer_head - block_buffer_tail + BLOCK_BUFFER_SIZE); } + static uint8_t movesplanned() { return BLOCK_MOD(block_buffer_head - block_buffer_tail + BLOCK_BUFFER_SIZE); } #if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING) @@ -233,13 +233,13 @@ class Planner { /** * Does the buffer have any blocks queued? */ - static FORCE_INLINE bool blocks_queued() { return (block_buffer_head != block_buffer_tail); } + static bool blocks_queued() { return (block_buffer_head != block_buffer_tail); } /** * "Discards" the block and "releases" the memory. * Called when the current block is no longer needed. */ - static FORCE_INLINE void discard_current_block() { + static void discard_current_block() { if (blocks_queued()) block_buffer_tail = BLOCK_MOD(block_buffer_tail + 1); } @@ -248,7 +248,7 @@ class Planner { * The current block. NULL if the buffer is empty. * This also marks the block as busy. */ - static FORCE_INLINE block_t* get_current_block() { + static block_t* get_current_block() { if (blocks_queued()) { block_t* block = &block_buffer[block_buffer_tail]; block->busy = true; @@ -272,14 +272,14 @@ class Planner { /** * Get the index of the next / previous block in the ring buffer */ - static FORCE_INLINE int8_t next_block_index(int8_t block_index) { return BLOCK_MOD(block_index + 1); } - static FORCE_INLINE int8_t prev_block_index(int8_t block_index) { return BLOCK_MOD(block_index - 1); } + static int8_t next_block_index(int8_t block_index) { return BLOCK_MOD(block_index + 1); } + static int8_t prev_block_index(int8_t block_index) { return BLOCK_MOD(block_index - 1); } /** * Calculate the distance (not time) it takes to accelerate * from initial_rate to target_rate using the given acceleration: */ - static FORCE_INLINE float estimate_acceleration_distance(float initial_rate, float target_rate, float acceleration) { + static float estimate_acceleration_distance(float initial_rate, float target_rate, float acceleration) { if (acceleration == 0) return 0; // acceleration was 0, set acceleration distance to 0 return (target_rate * target_rate - initial_rate * initial_rate) / (acceleration * 2); } @@ -292,7 +292,7 @@ class Planner { * This is used to compute the intersection point between acceleration and deceleration * in cases where the "trapezoid" has no plateau (i.e., never reaches maximum speed) */ - static FORCE_INLINE float intersection_distance(float initial_rate, float final_rate, float acceleration, float distance) { + static float intersection_distance(float initial_rate, float final_rate, float acceleration, float distance) { if (acceleration == 0) return 0; // acceleration was 0, set intersection distance to 0 return (acceleration * 2 * distance - initial_rate * initial_rate + final_rate * final_rate) / (acceleration * 4); } @@ -302,7 +302,7 @@ class Planner { * to reach 'target_velocity' using 'acceleration' within a given * 'distance'. */ - static FORCE_INLINE float max_allowable_speed(float acceleration, float target_velocity, float distance) { + static float max_allowable_speed(float acceleration, float target_velocity, float distance) { return sqrt(target_velocity * target_velocity - 2 * acceleration * distance); }