From f8b5749235eea19134a58656095e2a0f499a2fc7 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Sat, 23 Jul 2016 19:36:26 -0700 Subject: [PATCH] Replace division in planner with multiplication --- Marlin/Marlin_main.cpp | 10 +++---- Marlin/configuration_store.cpp | 6 +++++ Marlin/planner.cpp | 49 ++++++++++++++++++++-------------- Marlin/planner.h | 4 ++- Marlin/stepper.cpp | 2 +- Marlin/stepper.h | 2 +- Marlin/temperature.cpp | 2 +- Marlin/ultralcd.cpp | 13 ++++----- 8 files changed, 53 insertions(+), 35 deletions(-) diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 1ad4b8011..70b23a4d3 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -911,16 +911,15 @@ void setup() { // Send "ok" after commands by default for (int8_t i = 0; i < BUFSIZE; i++) send_ok[i] = true; - // loads data from EEPROM if available else uses defaults (and resets step acceleration rate) + // Load data from EEPROM if available (or use defaults) + // This also updates variables in the planner, elsewhere Config_RetrieveSettings(); // Initialize current position based on home_offset memcpy(current_position, home_offset, sizeof(home_offset)); - #if ENABLED(DELTA) || ENABLED(SCARA) - // Vital to init kinematic equivalent for X0 Y0 Z0 - SYNC_PLAN_POSITION_KINEMATIC(); - #endif + // Vital to init stepper/planner equivalent for current_position + SYNC_PLAN_POSITION_KINEMATIC(); thermalManager.init(); // Initialize temperature loop @@ -5148,6 +5147,7 @@ inline void gcode_M92() { } } } + planner.refresh_positioning(); } /** diff --git a/Marlin/configuration_store.cpp b/Marlin/configuration_store.cpp index 6a581ee1f..233a28cd5 100644 --- a/Marlin/configuration_store.cpp +++ b/Marlin/configuration_store.cpp @@ -171,10 +171,16 @@ void Config_Postprocess() { // steps per s2 needs to be updated to agree with units per s2 planner.reset_acceleration_rates(); + // Make sure delta kinematics are updated before refreshing the + // planner position so the stepper counts will be set correctly. #if ENABLED(DELTA) recalc_delta_settings(delta_radius, delta_diagonal_rod); #endif + // Refresh steps_to_mm with the reciprocal of axis_steps_per_mm + // and init stepper.count[], planner.position[] with current_position + planner.refresh_positioning(); + #if ENABLED(PIDTEMP) thermalManager.updatePID(); #endif diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp index 26ffd5e80..decea1576 100644 --- a/Marlin/planner.cpp +++ b/Marlin/planner.cpp @@ -82,6 +82,7 @@ volatile uint8_t Planner::block_buffer_tail = 0; float Planner::max_feedrate_mm_s[NUM_AXIS]; // Max speeds in mm per second float Planner::axis_steps_per_mm[NUM_AXIS]; +float Planner::steps_to_mm[NUM_AXIS]; unsigned long Planner::max_acceleration_steps_per_s2[NUM_AXIS]; unsigned long Planner::max_acceleration_mm_per_s2[NUM_AXIS]; // Use M201 to override by software @@ -783,23 +784,23 @@ void Planner::check_axes_activity() { #if ENABLED(COREXY) || ENABLED(COREXZ) || ENABLED(COREYZ) float delta_mm[6]; #if ENABLED(COREXY) - delta_mm[X_HEAD] = dx / axis_steps_per_mm[A_AXIS]; - delta_mm[Y_HEAD] = dy / axis_steps_per_mm[B_AXIS]; - delta_mm[Z_AXIS] = dz / axis_steps_per_mm[Z_AXIS]; - delta_mm[A_AXIS] = (dx + dy) / axis_steps_per_mm[A_AXIS]; - delta_mm[B_AXIS] = (dx - dy) / axis_steps_per_mm[B_AXIS]; + delta_mm[X_HEAD] = dx * steps_to_mm[A_AXIS]; + delta_mm[Y_HEAD] = dy * steps_to_mm[B_AXIS]; + delta_mm[Z_AXIS] = dz * steps_to_mm[Z_AXIS]; + delta_mm[A_AXIS] = (dx + dy) * steps_to_mm[A_AXIS]; + delta_mm[B_AXIS] = (dx - dy) * steps_to_mm[B_AXIS]; #elif ENABLED(COREXZ) - delta_mm[X_HEAD] = dx / axis_steps_per_mm[A_AXIS]; - delta_mm[Y_AXIS] = dy / axis_steps_per_mm[Y_AXIS]; - delta_mm[Z_HEAD] = dz / axis_steps_per_mm[C_AXIS]; - delta_mm[A_AXIS] = (dx + dz) / axis_steps_per_mm[A_AXIS]; - delta_mm[C_AXIS] = (dx - dz) / axis_steps_per_mm[C_AXIS]; + delta_mm[X_HEAD] = dx * steps_to_mm[A_AXIS]; + delta_mm[Y_AXIS] = dy * steps_to_mm[Y_AXIS]; + delta_mm[Z_HEAD] = dz * steps_to_mm[C_AXIS]; + delta_mm[A_AXIS] = (dx + dz) * steps_to_mm[A_AXIS]; + delta_mm[C_AXIS] = (dx - dz) * steps_to_mm[C_AXIS]; #elif ENABLED(COREYZ) - delta_mm[X_AXIS] = dx / axis_steps_per_mm[X_AXIS]; - delta_mm[Y_HEAD] = dy / axis_steps_per_mm[B_AXIS]; - delta_mm[Z_HEAD] = dz / axis_steps_per_mm[C_AXIS]; - delta_mm[B_AXIS] = (dy + dz) / axis_steps_per_mm[B_AXIS]; - delta_mm[C_AXIS] = (dy - dz) / axis_steps_per_mm[C_AXIS]; + delta_mm[X_AXIS] = dx * steps_to_mm[X_AXIS]; + delta_mm[Y_HEAD] = dy * steps_to_mm[B_AXIS]; + delta_mm[Z_HEAD] = dz * steps_to_mm[C_AXIS]; + delta_mm[B_AXIS] = (dy + dz) * steps_to_mm[B_AXIS]; + delta_mm[C_AXIS] = (dy - dz) * steps_to_mm[C_AXIS]; #endif #else float delta_mm[4]; @@ -808,12 +809,12 @@ void Planner::check_axes_activity() { // so calculate distance in steps first, then do one division // at the end to get millimeters #else - delta_mm[X_AXIS] = dx / axis_steps_per_mm[X_AXIS]; - delta_mm[Y_AXIS] = dy / axis_steps_per_mm[Y_AXIS]; - delta_mm[Z_AXIS] = dz / axis_steps_per_mm[Z_AXIS]; + delta_mm[X_AXIS] = dx * steps_to_mm[X_AXIS]; + delta_mm[Y_AXIS] = dy * steps_to_mm[Y_AXIS]; + delta_mm[Z_AXIS] = dz * steps_to_mm[Z_AXIS]; #endif #endif - delta_mm[E_AXIS] = (de / axis_steps_per_mm[E_AXIS]) * volumetric_multiplier[extruder] * extruder_multiplier[extruder] / 100.0; + delta_mm[E_AXIS] = (de * steps_to_mm[E_AXIS]) * volumetric_multiplier[extruder] * extruder_multiplier[extruder] / 100.0; if (block->steps[X_AXIS] <= dropsegments && block->steps[Y_AXIS] <= dropsegments && block->steps[Z_AXIS] <= dropsegments) { block->millimeters = fabs(delta_mm[E_AXIS]); @@ -833,7 +834,7 @@ void Planner::check_axes_activity() { #endif ) #if ENABLED(DELTA) - / axis_steps_per_mm[X_AXIS] + * steps_to_mm[X_AXIS] #endif ; } @@ -1176,6 +1177,7 @@ void Planner::check_axes_activity() { void Planner::set_e_position_mm(const float& e) { position[E_AXIS] = lround(e * axis_steps_per_mm[E_AXIS]); stepper.set_e_position(position[E_AXIS]); + previous_speed[E_AXIS] = 0.0; } // Recalculate the steps/s^2 acceleration rates, based on the mm/s^2 @@ -1184,6 +1186,13 @@ void Planner::reset_acceleration_rates() { max_acceleration_steps_per_s2[i] = max_acceleration_mm_per_s2[i] * axis_steps_per_mm[i]; } +// Recalculate position, steps_to_mm if axis_steps_per_mm changes! +void Planner::refresh_positioning() { + LOOP_XYZE(i) planner.steps_to_mm[i] = 1.0 / planner.axis_steps_per_mm[i]; + set_position_mm(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); + reset_acceleration_rates(); +} + #if ENABLED(AUTOTEMP) void Planner::autotemp_M109() { diff --git a/Marlin/planner.h b/Marlin/planner.h index 74abd1cb2..eac1ae5c6 100644 --- a/Marlin/planner.h +++ b/Marlin/planner.h @@ -121,6 +121,7 @@ class Planner { static float max_feedrate_mm_s[NUM_AXIS]; // Max speeds in mm per second static float axis_steps_per_mm[NUM_AXIS]; + static float steps_to_mm[NUM_AXIS]; static unsigned long max_acceleration_steps_per_s2[NUM_AXIS]; static unsigned long max_acceleration_mm_per_s2[NUM_AXIS]; // Use M201 to override by software @@ -142,7 +143,7 @@ class Planner { /** * The current position of the tool in absolute steps - * Reclculated if any axis_steps_per_mm are changed by gcode + * Recalculated if any axis_steps_per_mm are changed by gcode */ static long position[NUM_AXIS]; @@ -187,6 +188,7 @@ class Planner { */ static void reset_acceleration_rates(); + static void refresh_positioning(); // Manage fans, paste pressure, etc. static void check_axes_activity(); diff --git a/Marlin/stepper.cpp b/Marlin/stepper.cpp index 90a1ddf65..63a5d0b31 100644 --- a/Marlin/stepper.cpp +++ b/Marlin/stepper.cpp @@ -951,7 +951,7 @@ float Stepper::get_axis_position_mm(AxisEnum axis) { #else axis_steps = position(axis); #endif - return axis_steps / planner.axis_steps_per_mm[axis]; + return axis_steps * planner.steps_to_mm[axis]; } void Stepper::finish_and_disable() { diff --git a/Marlin/stepper.h b/Marlin/stepper.h index 45c8753aa..3ecf93a71 100644 --- a/Marlin/stepper.h +++ b/Marlin/stepper.h @@ -262,7 +262,7 @@ class Stepper { // Triggered position of an axis in mm (not core-savvy) // static FORCE_INLINE float triggered_position_mm(AxisEnum axis) { - return endstops_trigsteps[axis] / planner.axis_steps_per_mm[axis]; + return endstops_trigsteps[axis] * planner.steps_to_mm[axis]; } #if ENABLED(LIN_ADVANCE) diff --git a/Marlin/temperature.cpp b/Marlin/temperature.cpp index db2805285..82d6477b8 100644 --- a/Marlin/temperature.cpp +++ b/Marlin/temperature.cpp @@ -572,7 +572,7 @@ float Temperature::get_pid_output(int e) { lpq[lpq_ptr] = 0; } if (++lpq_ptr >= lpq_len) lpq_ptr = 0; - cTerm[HOTEND_INDEX] = (lpq[lpq_ptr] / planner.axis_steps_per_mm[E_AXIS]) * PID_PARAM(Kc, HOTEND_INDEX); + cTerm[HOTEND_INDEX] = (lpq[lpq_ptr] * planner.steps_to_mm[E_AXIS]) * PID_PARAM(Kc, HOTEND_INDEX); pid_output += cTerm[HOTEND_INDEX]; } #endif //PID_ADD_EXTRUSION_RATE diff --git a/Marlin/ultralcd.cpp b/Marlin/ultralcd.cpp index 2a9e6e90e..65c3ba9cc 100755 --- a/Marlin/ultralcd.cpp +++ b/Marlin/ultralcd.cpp @@ -678,7 +678,7 @@ void kill_screen(const char* lcd_msg) { } if (lcdDrawUpdate) lcd_implementation_drawedit(msg, ftostr43sign( - ((1000 * babysteps_done) / planner.axis_steps_per_mm[axis]) * 0.001f + ((1000 * babysteps_done) * planner.steps_to_mm[axis]) * 0.001f )); } @@ -1769,6 +1769,7 @@ void kill_screen(const char* lcd_msg) { } static void _reset_acceleration_rates() { planner.reset_acceleration_rates(); } + static void _planner_refresh_positioning() { planner.refresh_positioning(); } /** * @@ -1805,14 +1806,14 @@ void kill_screen(const char* lcd_msg) { MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E, &planner.max_acceleration_mm_per_s2[E_AXIS], 100, 99000, _reset_acceleration_rates); MENU_ITEM_EDIT(float5, MSG_A_RETRACT, &planner.retract_acceleration, 100, 99000); MENU_ITEM_EDIT(float5, MSG_A_TRAVEL, &planner.travel_acceleration, 100, 99000); - MENU_ITEM_EDIT(float52, MSG_XSTEPS, &planner.axis_steps_per_mm[X_AXIS], 5, 9999); - MENU_ITEM_EDIT(float52, MSG_YSTEPS, &planner.axis_steps_per_mm[Y_AXIS], 5, 9999); + MENU_ITEM_EDIT_CALLBACK(float52, MSG_XSTEPS, &planner.axis_steps_per_mm[X_AXIS], 5, 9999, _planner_refresh_positioning); + MENU_ITEM_EDIT_CALLBACK(float52, MSG_YSTEPS, &planner.axis_steps_per_mm[Y_AXIS], 5, 9999, _planner_refresh_positioning); #if ENABLED(DELTA) - MENU_ITEM_EDIT(float52, MSG_ZSTEPS, &planner.axis_steps_per_mm[Z_AXIS], 5, 9999); + MENU_ITEM_EDIT_CALLBACK(float52, MSG_ZSTEPS, &planner.axis_steps_per_mm[Z_AXIS], 5, 9999, _planner_refresh_positioning); #else - MENU_ITEM_EDIT(float51, MSG_ZSTEPS, &planner.axis_steps_per_mm[Z_AXIS], 5, 9999); + MENU_ITEM_EDIT_CALLBACK(float51, MSG_ZSTEPS, &planner.axis_steps_per_mm[Z_AXIS], 5, 9999, _planner_refresh_positioning); #endif - MENU_ITEM_EDIT(float51, MSG_ESTEPS, &planner.axis_steps_per_mm[E_AXIS], 5, 9999); + MENU_ITEM_EDIT_CALLBACK(float51, MSG_ESTEPS, &planner.axis_steps_per_mm[E_AXIS], 5, 9999, _planner_refresh_positioning); #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) MENU_ITEM_EDIT(bool, MSG_ENDSTOP_ABORT, &stepper.abort_on_endstop_hit); #endif