diff --git a/Marlin/Marlin.h b/Marlin/Marlin.h index 9cd13c90e..f6f488df8 100644 --- a/Marlin/Marlin.h +++ b/Marlin/Marlin.h @@ -216,7 +216,7 @@ void manage_inactivity(bool ignore_stepper_queue = false); */ enum AxisEnum {X_AXIS = 0, A_AXIS = 0, Y_AXIS = 1, B_AXIS = 1, Z_AXIS = 2, C_AXIS = 2, E_AXIS = 3, X_HEAD = 4, Y_HEAD = 5, Z_HEAD = 5}; -enum EndstopEnum {X_MIN = 0, Y_MIN = 1, Z_MIN = 2, Z_MIN_PROBE = 3, X_MAX = 4, Y_MAX = 5, Z_MAX = 6, Z2_MIN = 7, Z2_MAX = 8}; +#define _AXIS(AXIS) AXIS ##_AXIS void enable_all_steppers(); void disable_all_steppers(); @@ -283,6 +283,12 @@ extern float sw_endstop_max[3]; // axis[n].sw_endstop_max extern bool axis_known_position[3]; // axis[n].is_known extern bool axis_homed[3]; // axis[n].is_homed +// GCode support for external objects +extern bool code_seen(char); +extern float code_value(); +extern long code_value_long(); +extern int16_t code_value_short(); + #if ENABLED(DELTA) #ifndef DELTA_RADIUS_TRIM_TOWER_1 #define DELTA_RADIUS_TRIM_TOWER_1 0.0 diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 37c472f3c..4100e629a 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -48,6 +48,7 @@ #include "ultralcd.h" #include "planner.h" #include "stepper.h" +#include "endstops.h" #include "temperature.h" #include "cardreader.h" #include "configuration_store.h" @@ -148,7 +149,7 @@ * M84 - Disable steppers until next move, * or use S to specify an inactivity timeout, after which the steppers will be disabled. S0 to disable the timeout. * M85 - Set inactivity shutdown timer with parameter S. To disable set zero (default) - * M92 - Set axis_steps_per_unit - same syntax as G92 + * M92 - Set planner.axis_steps_per_unit - same syntax as G92 * M104 - Set extruder target temp * M105 - Read current temp * M106 - Fan on @@ -539,7 +540,7 @@ static void report_current_position(); if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position_delta", current_position); #endif calculate_delta(current_position); - plan_set_position(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS]); + planner.set_position(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS]); } #endif @@ -547,10 +548,6 @@ static void report_current_position(); float extrude_min_temp = EXTRUDE_MINTEMP; #endif -#if ENABLED(HAS_Z_MIN_PROBE) - extern volatile bool z_probe_is_active; -#endif - #if ENABLED(SDSUPPORT) #include "SdFatUtil.h" int freeMemory() { return SdFatUtil::FreeRam(); } @@ -711,7 +708,7 @@ void servo_init() { #if HAS_SERVO_ENDSTOPS - z_probe_is_active = false; + endstops.enable_z_probe(false); /** * Set position of all defined Servo Endstops @@ -820,7 +817,6 @@ void setup() { lcd_init(); tp_init(); // Initialize temperature loop - plan_init(); // Initialize planner; #if ENABLED(DELTA) || ENABLED(SCARA) // Vital to init kinematic equivalent for X0 Y0 Z0 @@ -831,7 +827,7 @@ void setup() { watchdog_init(); #endif - st_init(); // Initialize stepper, this enables interrupts! + stepper.init(); // Initialize stepper, this enables interrupts! setup_photpin(); servo_init(); @@ -915,7 +911,7 @@ void loop() { commands_in_queue--; cmd_queue_index_r = (cmd_queue_index_r + 1) % BUFSIZE; } - checkHitEndstops(); + endstops.report_state(); idle(); } @@ -1408,17 +1404,17 @@ inline void set_homing_bump_feedrate(AxisEnum axis) { // (or from wherever it has been told it is located). // inline void line_to_current_position() { - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate / 60, active_extruder); + planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate / 60, active_extruder); } inline void line_to_z(float zPosition) { - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS], feedrate / 60, active_extruder); + planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS], feedrate / 60, active_extruder); } // // line_to_destination // Move the planner, not necessarily synced with current_position // inline void line_to_destination(float mm_m) { - plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], mm_m / 60, active_extruder); + planner.buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], mm_m / 60, active_extruder); } inline void line_to_destination() { line_to_destination(feedrate); @@ -1433,9 +1429,9 @@ inline void sync_plan_position() { #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position", current_position); #endif - plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); + planner.set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); } -inline void sync_plan_position_e() { plan_set_e_position(current_position[E_AXIS]); } +inline void sync_plan_position_e() { planner.set_e_position(current_position[E_AXIS]); } inline void set_current_to_destination() { memcpy(current_position, destination, sizeof(current_position)); } inline void set_destination_to_current() { memcpy(destination, current_position, sizeof(destination)); } @@ -1445,9 +1441,9 @@ static void setup_for_endstop_move() { feedrate_multiplier = 100; refresh_cmd_timeout(); #if ENABLED(DEBUG_LEVELING_FEATURE) - if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("setup_for_endstop_move > enable_endstops(true)"); + if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("setup_for_endstop_move > endstops.enable()"); #endif - enable_endstops(true); + endstops.enable(); } #if ENABLED(AUTO_BED_LEVELING_FEATURE) @@ -1462,7 +1458,7 @@ static void setup_for_endstop_move() { #endif refresh_cmd_timeout(); calculate_delta(destination); - plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], (feedrate / 60) * (feedrate_multiplier / 100.0), active_extruder); + planner.buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], (feedrate / 60) * (feedrate_multiplier / 100.0), active_extruder); set_current_to_destination(); } #endif @@ -1473,21 +1469,21 @@ static void setup_for_endstop_move() { static void set_bed_level_equation_lsq(double* plane_equation_coefficients) { - //plan_bed_level_matrix.debug("bed level before"); + //planner.bed_level_matrix.debug("bed level before"); #if ENABLED(DEBUG_LEVELING_FEATURE) - plan_bed_level_matrix.set_to_identity(); + planner.bed_level_matrix.set_to_identity(); if (DEBUGGING(LEVELING)) { - vector_3 uncorrected_position = plan_get_position(); + vector_3 uncorrected_position = planner.adjusted_position(); DEBUG_POS(">>> set_bed_level_equation_lsq", uncorrected_position); DEBUG_POS(">>> set_bed_level_equation_lsq", current_position); } #endif vector_3 planeNormal = vector_3(-plane_equation_coefficients[0], -plane_equation_coefficients[1], 1); - plan_bed_level_matrix = matrix_3x3::create_look_at(planeNormal); + planner.bed_level_matrix = matrix_3x3::create_look_at(planeNormal); - vector_3 corrected_position = plan_get_position(); + vector_3 corrected_position = planner.adjusted_position(); current_position[X_AXIS] = corrected_position.x; current_position[Y_AXIS] = corrected_position.y; current_position[Z_AXIS] = corrected_position.z; @@ -1505,7 +1501,7 @@ static void setup_for_endstop_move() { static void set_bed_level_equation_3pts(float z_at_pt_1, float z_at_pt_2, float z_at_pt_3) { - plan_bed_level_matrix.set_to_identity(); + planner.bed_level_matrix.set_to_identity(); vector_3 pt1 = vector_3(ABL_PROBE_PT_1_X, ABL_PROBE_PT_1_Y, z_at_pt_1); vector_3 pt2 = vector_3(ABL_PROBE_PT_2_X, ABL_PROBE_PT_2_Y, z_at_pt_2); @@ -1518,9 +1514,9 @@ static void setup_for_endstop_move() { planeNormal.z = -planeNormal.z; } - plan_bed_level_matrix = matrix_3x3::create_look_at(planeNormal); + planner.bed_level_matrix = matrix_3x3::create_look_at(planeNormal); - vector_3 corrected_position = plan_get_position(); + vector_3 corrected_position = planner.adjusted_position(); #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) { @@ -1553,7 +1549,7 @@ static void setup_for_endstop_move() { #if ENABLED(DELTA) float start_z = current_position[Z_AXIS]; - long start_steps = st_get_position(Z_AXIS); + long start_steps = stepper.position(Z_AXIS); #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("run_z_probe (DELTA) 1"); @@ -1563,15 +1559,15 @@ static void setup_for_endstop_move() { feedrate = homing_feedrate[Z_AXIS] / 4; destination[Z_AXIS] = -10; prepare_move_raw(); // this will also set_current_to_destination - st_synchronize(); - endstops_hit_on_purpose(); // clear endstop hit flags + stepper.synchronize(); + endstops.hit_on_purpose(); // clear endstop hit flags /** * We have to let the planner know where we are right now as it * is not where we said to go. */ - long stop_steps = st_get_position(Z_AXIS); - float mm = start_z - float(start_steps - stop_steps) / axis_steps_per_unit[Z_AXIS]; + long stop_steps = stepper.position(Z_AXIS); + float mm = start_z - float(start_steps - stop_steps) / planner.axis_steps_per_unit[Z_AXIS]; current_position[Z_AXIS] = mm; #if ENABLED(DEBUG_LEVELING_FEATURE) @@ -1582,17 +1578,17 @@ static void setup_for_endstop_move() { #else // !DELTA - plan_bed_level_matrix.set_to_identity(); + planner.bed_level_matrix.set_to_identity(); feedrate = homing_feedrate[Z_AXIS]; // Move down until the Z probe (or endstop?) is triggered float zPosition = -(Z_MAX_LENGTH + 10); line_to_z(zPosition); - st_synchronize(); + stepper.synchronize(); // Tell the planner where we ended up - Get this from the stepper handler - zPosition = st_get_axis_position_mm(Z_AXIS); - plan_set_position( + zPosition = stepper.get_axis_position_mm(Z_AXIS); + planner.set_position( current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS] ); @@ -1600,19 +1596,19 @@ static void setup_for_endstop_move() { // move up the retract distance zPosition += home_bump_mm(Z_AXIS); line_to_z(zPosition); - st_synchronize(); - endstops_hit_on_purpose(); // clear endstop hit flags + stepper.synchronize(); + endstops.hit_on_purpose(); // clear endstop hit flags // move back down slowly to find bed set_homing_bump_feedrate(Z_AXIS); zPosition -= home_bump_mm(Z_AXIS) * 2; line_to_z(zPosition); - st_synchronize(); - endstops_hit_on_purpose(); // clear endstop hit flags + stepper.synchronize(); + endstops.hit_on_purpose(); // clear endstop hit flags // Get the current stepper position after bumping an endstop - current_position[Z_AXIS] = st_get_axis_position_mm(Z_AXIS); + current_position[Z_AXIS] = stepper.get_axis_position_mm(Z_AXIS); sync_plan_position(); #if ENABLED(DEBUG_LEVELING_FEATURE) @@ -1641,7 +1637,7 @@ static void setup_for_endstop_move() { destination[Y_AXIS] = y; destination[Z_AXIS] = z; prepare_move_raw(); // this will also set_current_to_destination - st_synchronize(); + stepper.synchronize(); #else @@ -1649,14 +1645,14 @@ static void setup_for_endstop_move() { current_position[Z_AXIS] = z; line_to_current_position(); - st_synchronize(); + stepper.synchronize(); feedrate = xy_travel_speed; current_position[X_AXIS] = x; current_position[Y_AXIS] = y; line_to_current_position(); - st_synchronize(); + stepper.synchronize(); #endif @@ -1681,9 +1677,9 @@ static void setup_for_endstop_move() { static void clean_up_after_endstop_move() { #if ENABLED(DEBUG_LEVELING_FEATURE) - if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("clean_up_after_endstop_move > ENDSTOPS_ONLY_FOR_HOMING > endstops_not_homing()"); + if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("clean_up_after_endstop_move > ENDSTOPS_ONLY_FOR_HOMING > endstops.not_homing()"); #endif - endstops_not_homing(); + endstops.not_homing(); feedrate = saved_feedrate; feedrate_multiplier = saved_feedrate_multiplier; refresh_cmd_timeout(); @@ -1697,7 +1693,7 @@ static void setup_for_endstop_move() { if (DEBUGGING(LEVELING)) DEBUG_POS("deploy_z_probe", current_position); #endif - if (z_probe_is_active) return; + if (endstops.z_probe_enabled) return; #if HAS_SERVO_ENDSTOPS @@ -1757,7 +1753,7 @@ static void setup_for_endstop_move() { destination[Y_AXIS] = destination[Y_AXIS] * 0.75; prepare_move_raw(); // this will also set_current_to_destination - st_synchronize(); + stepper.synchronize(); #if ENABLED(Z_MIN_PROBE_ENDSTOP) z_probe_endstop = (READ(Z_MIN_PROBE_PIN) != Z_MIN_PROBE_ENDSTOP_INVERTING); @@ -1778,10 +1774,10 @@ static void setup_for_endstop_move() { #endif // Z_PROBE_ALLEN_KEY #if ENABLED(FIX_MOUNTED_PROBE) - // Noting to be done. Just set z_probe_is_active + // Noting to be done. Just set endstops.z_probe_enabled #endif - z_probe_is_active = true; + endstops.enable_z_probe(); } @@ -1793,7 +1789,7 @@ static void setup_for_endstop_move() { if (DEBUGGING(LEVELING)) DEBUG_POS("stow_z_probe", current_position); #endif - if (!z_probe_is_active) return; + if (!endstops.z_probe_enabled) return; #if HAS_SERVO_ENDSTOPS @@ -1811,7 +1807,7 @@ static void setup_for_endstop_move() { } #endif raise_z_after_probing(); // this also updates current_position - st_synchronize(); + stepper.synchronize(); } #endif @@ -1861,7 +1857,7 @@ static void setup_for_endstop_move() { destination[Y_AXIS] = 0; prepare_move_raw(); // this will also set_current_to_destination - st_synchronize(); + stepper.synchronize(); #if ENABLED(Z_MIN_PROBE_ENDSTOP) bool z_probe_endstop = (READ(Z_MIN_PROBE_PIN) != Z_MIN_PROBE_ENDSTOP_INVERTING); @@ -1881,10 +1877,10 @@ static void setup_for_endstop_move() { #endif // Z_PROBE_ALLEN_KEY #if ENABLED(FIX_MOUNTED_PROBE) - // Nothing to do here. Just clear z_probe_is_active + // Nothing to do here. Just clear endstops.z_probe_enabled #endif - z_probe_is_active = false; + endstops.enable_z_probe(false); } #endif // HAS_Z_MIN_PROBE @@ -2081,13 +2077,13 @@ static void setup_for_endstop_move() { } #endif - if (z_probe_is_active == dock) return; - if (!axis_homed[X_AXIS] || !axis_homed[Y_AXIS]) { axis_unhomed_error(); return; } + if (endstops.z_probe_enabled == !dock) return; // already docked/undocked? + float oldXpos = current_position[X_AXIS]; // save x position if (dock) { #if Z_RAISE_AFTER_PROBING > 0 @@ -2105,7 +2101,7 @@ static void setup_for_endstop_move() { } do_blocking_move_to_x(oldXpos); // return to position before docking - z_probe_is_active = dock; + endstops.enable_z_probe(!dock); // logically disable docked probe } #endif // Z_PROBE_SLED @@ -2167,39 +2163,39 @@ static void homeaxis(AxisEnum axis) { // Engage an X or Y Servo endstop if enabled if (_Z_SERVO_TEST && servo_endstop_id[axis] >= 0) { servo[servo_endstop_id[axis]].move(servo_endstop_angle[axis][0]); - if (_Z_PROBE_SUBTEST) z_probe_is_active = true; + if (_Z_PROBE_SUBTEST) endstops.z_probe_enabled = true; } #endif // Set a flag for Z motor locking #if ENABLED(Z_DUAL_ENDSTOPS) - if (axis == Z_AXIS) In_Homing_Process(true); + if (axis == Z_AXIS) stepper.set_homing_flag(true); #endif // Move towards the endstop until an endstop is triggered destination[axis] = 1.5 * max_length(axis) * axis_home_dir; feedrate = homing_feedrate[axis]; line_to_destination(); - st_synchronize(); + stepper.synchronize(); // Set the axis position as setup for the move current_position[axis] = 0; sync_plan_position(); #if ENABLED(DEBUG_LEVELING_FEATURE) - if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> enable_endstops(false)"); + if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> endstops.enable(false)"); #endif - enable_endstops(false); // Disable endstops while moving away + endstops.enable(false); // Disable endstops while moving away // Move away from the endstop by the axis HOME_BUMP_MM destination[axis] = -home_bump_mm(axis) * axis_home_dir; line_to_destination(); - st_synchronize(); + stepper.synchronize(); #if ENABLED(DEBUG_LEVELING_FEATURE) - if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> enable_endstops(true)"); + if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> endstops.enable(true)"); #endif - enable_endstops(true); // Enable endstops for next homing move + endstops.enable(true); // Enable endstops for next homing move // Slow down the feedrate for the next move set_homing_bump_feedrate(axis); @@ -2207,7 +2203,7 @@ static void homeaxis(AxisEnum axis) { // Move slowly towards the endstop until triggered destination[axis] = 2 * home_bump_mm(axis) * axis_home_dir; line_to_destination(); - st_synchronize(); + stepper.synchronize(); #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) DEBUG_POS("> TRIGGER ENDSTOP", current_position); @@ -2224,17 +2220,17 @@ static void homeaxis(AxisEnum axis) { else lockZ1 = (z_endstop_adj < 0); - if (lockZ1) Lock_z_motor(true); else Lock_z2_motor(true); + if (lockZ1) stepper.set_z_lock(true); else stepper.set_z2_lock(true); sync_plan_position(); // Move to the adjusted endstop height feedrate = homing_feedrate[axis]; destination[Z_AXIS] = adj; line_to_destination(); - st_synchronize(); + stepper.synchronize(); - if (lockZ1) Lock_z_motor(false); else Lock_z2_motor(false); - In_Homing_Process(false); + if (lockZ1) stepper.set_z_lock(false); else stepper.set_z2_lock(false); + stepper.set_homing_flag(false); } // Z_AXIS #endif @@ -2242,9 +2238,9 @@ static void homeaxis(AxisEnum axis) { // retrace by the amount specified in endstop_adj if (endstop_adj[axis] * axis_home_dir < 0) { #if ENABLED(DEBUG_LEVELING_FEATURE) - if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> enable_endstops(false)"); + if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> endstops.enable(false)"); #endif - enable_endstops(false); // Disable endstops while moving away + endstops.enable(false); // Disable endstops while moving away sync_plan_position(); destination[axis] = endstop_adj[axis]; #if ENABLED(DEBUG_LEVELING_FEATURE) @@ -2254,11 +2250,11 @@ static void homeaxis(AxisEnum axis) { } #endif line_to_destination(); - st_synchronize(); + stepper.synchronize(); #if ENABLED(DEBUG_LEVELING_FEATURE) - if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> enable_endstops(true)"); + if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> endstops.enable(true)"); #endif - enable_endstops(true); // Enable endstops for next homing move + endstops.enable(true); // Enable endstops for next homing move } #if ENABLED(DEBUG_LEVELING_FEATURE) else { @@ -2280,7 +2276,7 @@ static void homeaxis(AxisEnum axis) { destination[axis] = current_position[axis]; feedrate = 0.0; - endstops_hit_on_purpose(); // clear endstop hit flags + endstops.hit_on_purpose(); // clear endstop hit flags axis_known_position[axis] = true; axis_homed[axis] = true; @@ -2301,7 +2297,7 @@ static void homeaxis(AxisEnum axis) { if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> SERVO_ENDSTOPS > Stow with servo.move()"); #endif servo[servo_endstop_id[axis]].move(servo_endstop_angle[axis][1]); - if (_Z_PROBE_SUBTEST) z_probe_is_active = false; + if (_Z_PROBE_SUBTEST) endstops.enable_z_probe(false); } #endif @@ -2499,7 +2495,7 @@ inline void gcode_G4() { if (code_seen('P')) codenum = code_value_long(); // milliseconds to wait if (code_seen('S')) codenum = code_value() * 1000UL; // seconds to wait - st_synchronize(); + stepper.synchronize(); refresh_cmd_timeout(); codenum += previous_cmd_ms; // keep track of when we started waiting @@ -2551,11 +2547,11 @@ inline void gcode_G28() { #endif // Wait for planner moves to finish! - st_synchronize(); + stepper.synchronize(); // For auto bed leveling, clear the level matrix #if ENABLED(AUTO_BED_LEVELING_FEATURE) - plan_bed_level_matrix.set_to_identity(); + planner.bed_level_matrix.set_to_identity(); #if ENABLED(DELTA) reset_bed_level(); #endif @@ -2594,8 +2590,8 @@ inline void gcode_G28() { for (int i = X_AXIS; i <= Z_AXIS; i++) destination[i] = 3 * (Z_MAX_LENGTH); feedrate = 1.732 * homing_feedrate[X_AXIS]; line_to_destination(); - st_synchronize(); - endstops_hit_on_purpose(); // clear endstop hit flags + stepper.synchronize(); + endstops.hit_on_purpose(); // clear endstop hit flags // Destination reached for (int i = X_AXIS; i <= Z_AXIS; i++) current_position[i] = destination[i]; @@ -2633,7 +2629,7 @@ inline void gcode_G28() { // Raise Z before homing any other axes and z is not already high enough (never lower z) if (current_position[Z_AXIS] <= MIN_Z_HEIGHT_FOR_HOMING) { destination[Z_AXIS] = MIN_Z_HEIGHT_FOR_HOMING; - feedrate = max_feedrate[Z_AXIS] * 60; // feedrate (mm/m) = max_feedrate (mm/s) + feedrate = planner.max_feedrate[Z_AXIS] * 60; // feedrate (mm/m) = max_feedrate (mm/s) #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) { SERIAL_ECHOPAIR("Raise Z (before homing) to ", (MIN_Z_HEIGHT_FOR_HOMING)); @@ -2643,7 +2639,7 @@ inline void gcode_G28() { } #endif line_to_destination(); - st_synchronize(); + stepper.synchronize(); /** * Update the current Z position even if it currently not real from @@ -2676,7 +2672,7 @@ inline void gcode_G28() { destination[Y_AXIS] = 1.5 * mly * home_dir(Y_AXIS); feedrate = min(homing_feedrate[X_AXIS], homing_feedrate[Y_AXIS]) * sqrt(mlratio * mlratio + 1); line_to_destination(); - st_synchronize(); + stepper.synchronize(); set_axis_is_at_home(X_AXIS); set_axis_is_at_home(Y_AXIS); @@ -2690,8 +2686,8 @@ inline void gcode_G28() { destination[Y_AXIS] = current_position[Y_AXIS]; line_to_destination(); feedrate = 0.0; - st_synchronize(); - endstops_hit_on_purpose(); // clear endstop hit flags + stepper.synchronize(); + endstops.hit_on_purpose(); // clear endstop hit flags current_position[X_AXIS] = destination[X_AXIS]; current_position[Y_AXIS] = destination[Y_AXIS]; @@ -2784,7 +2780,7 @@ inline void gcode_G28() { // Move in the XY plane line_to_destination(); - st_synchronize(); + stepper.synchronize(); /** * Update the current positions for XY, Z is still at least at @@ -2857,10 +2853,10 @@ inline void gcode_G28() { #endif #if ENABLED(ENDSTOPS_ONLY_FOR_HOMING) - enable_endstops(false); + endstops.enable(false); #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) { - SERIAL_ECHOLNPGM("ENDSTOPS_ONLY_FOR_HOMING enable_endstops(false)"); + SERIAL_ECHOLNPGM("ENDSTOPS_ONLY_FOR_HOMING endstops.enable(false)"); } #endif #endif @@ -2875,7 +2871,7 @@ inline void gcode_G28() { set_destination_to_current(); feedrate = homing_feedrate[Z_AXIS]; line_to_destination(); - st_synchronize(); + stepper.synchronize(); #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) DEBUG_POS("mbl_was_active", current_position); #endif @@ -2885,7 +2881,7 @@ inline void gcode_G28() { feedrate = saved_feedrate; feedrate_multiplier = saved_feedrate_multiplier; refresh_cmd_timeout(); - endstops_hit_on_purpose(); // clear endstop hit flags + endstops.hit_on_purpose(); // clear endstop hit flags #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) { @@ -2921,7 +2917,7 @@ inline void gcode_G28() { #endif feedrate = saved_feedrate; - st_synchronize(); + stepper.synchronize(); } /** @@ -3015,7 +3011,7 @@ inline void gcode_G28() { #endif ; line_to_current_position(); - st_synchronize(); + stepper.synchronize(); // After recording the last point, activate the mbl and home SERIAL_PROTOCOLLNPGM("Mesh probing done."); @@ -3204,22 +3200,22 @@ inline void gcode_G28() { #if ENABLED(DEBUG_LEVELING_FEATURE) && DISABLED(DELTA) if (DEBUGGING(LEVELING)) { - vector_3 corrected_position = plan_get_position(); + vector_3 corrected_position = planner.adjusted_position(); DEBUG_POS("BEFORE matrix.set_to_identity", corrected_position); DEBUG_POS("BEFORE matrix.set_to_identity", current_position); } #endif // make sure the bed_level_rotation_matrix is identity or the planner will get it wrong - plan_bed_level_matrix.set_to_identity(); + planner.bed_level_matrix.set_to_identity(); #if ENABLED(DELTA) reset_bed_level(); #else //!DELTA - //vector_3 corrected_position = plan_get_position(); + //vector_3 corrected_position = planner.adjusted_position(); //corrected_position.debug("position before G29"); - vector_3 uncorrected_position = plan_get_position(); + vector_3 uncorrected_position = planner.adjusted_position(); //uncorrected_position.debug("position during G29"); current_position[X_AXIS] = uncorrected_position.x; current_position[Y_AXIS] = uncorrected_position.y; @@ -3240,7 +3236,7 @@ inline void gcode_G28() { deploy_z_probe(); #endif - st_synchronize(); + stepper.synchronize(); setup_for_endstop_move(); @@ -3418,7 +3414,7 @@ inline void gcode_G28() { y_tmp = eqnAMatrix[ind + 1 * abl2], z_tmp = 0; - apply_rotation_xyz(plan_bed_level_matrix, x_tmp, y_tmp, z_tmp); + apply_rotation_xyz(planner.bed_level_matrix, x_tmp, y_tmp, z_tmp); NOMORE(min_diff, eqnBVector[ind] - z_tmp); @@ -3441,7 +3437,7 @@ inline void gcode_G28() { y_tmp = eqnAMatrix[ind + 1 * abl2], z_tmp = 0; - apply_rotation_xyz(plan_bed_level_matrix, x_tmp, y_tmp, z_tmp); + apply_rotation_xyz(planner.bed_level_matrix, x_tmp, y_tmp, z_tmp); float diff = eqnBVector[ind] - z_tmp - min_diff; if (diff >= 0.0) @@ -3500,7 +3496,7 @@ inline void gcode_G28() { #endif #else // !DELTA if (verbose_level > 0) - plan_bed_level_matrix.debug(" \n\nBed Level Correction Matrix:"); + planner.bed_level_matrix.debug(" \n\nBed Level Correction Matrix:"); if (!dryrun) { /** @@ -3511,7 +3507,7 @@ inline void gcode_G28() { float x_tmp = current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER, y_tmp = current_position[Y_AXIS] + Y_PROBE_OFFSET_FROM_EXTRUDER, z_tmp = current_position[Z_AXIS], - real_z = st_get_axis_position_mm(Z_AXIS); //get the real Z (since plan_get_position is now correcting the plane) + real_z = stepper.get_axis_position_mm(Z_AXIS); //get the real Z (since planner.adjusted_position is now correcting the plane) #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) { @@ -3523,13 +3519,13 @@ inline void gcode_G28() { #endif // Apply the correction sending the Z probe offset - apply_rotation_xyz(plan_bed_level_matrix, x_tmp, y_tmp, z_tmp); + apply_rotation_xyz(planner.bed_level_matrix, x_tmp, y_tmp, z_tmp); /* * Get the current Z position and send it to the planner. * * >> (z_tmp - real_z) : The rotated current Z minus the uncorrected Z - * (most recent plan_set_position/sync_plan_position) + * (most recent planner.set_position/sync_plan_position) * * >> zprobe_zoffset : Z distance from nozzle to Z probe * (set by default, M851, EEPROM, or Menu) @@ -3588,9 +3584,9 @@ inline void gcode_G28() { #endif enqueue_and_echo_commands_P(PSTR(Z_PROBE_END_SCRIPT)); #if ENABLED(HAS_Z_MIN_PROBE) - z_probe_is_active = false; + endstops.enable_z_probe(false); #endif - st_synchronize(); + stepper.synchronize(); #endif KEEPALIVE_STATE(IN_HANDLER); @@ -3615,7 +3611,7 @@ inline void gcode_G28() { #endif deploy_z_probe(); // Engage Z Servo endstop if available. Z_PROBE_SLED is missed here. - st_synchronize(); + stepper.synchronize(); // TODO: clear the leveling matrix or the planner will be set incorrectly setup_for_endstop_move(); // Too late. Must be done before deploying. @@ -3650,7 +3646,7 @@ inline void gcode_G28() { inline void gcode_G92() { bool didE = code_seen(axis_codes[E_AXIS]); - if (!didE) st_synchronize(); + if (!didE) stepper.synchronize(); bool didXYZ = false; for (int i = 0; i < NUM_AXIS; i++) { @@ -3712,7 +3708,7 @@ inline void gcode_G92() { } lcd_ignore_click(); - st_synchronize(); + stepper.synchronize(); refresh_cmd_timeout(); if (codenum > 0) { codenum += previous_cmd_ms; // wait until this time for a click @@ -3853,7 +3849,7 @@ inline void gcode_M31() { */ inline void gcode_M32() { if (card.sdprinting) - st_synchronize(); + stepper.synchronize(); char* namestartpos = strchr(current_command_args, '!'); // Find ! to indicate filename string start. if (!namestartpos) @@ -4068,7 +4064,7 @@ inline void gcode_M42() { reset_bed_level(); #else // we don't do bed level correction in M48 because we want the raw data when we probe - plan_bed_level_matrix.set_to_identity(); + planner.bed_level_matrix.set_to_identity(); #endif if (Z_start_location < Z_RAISE_BEFORE_PROBING * 2.0) @@ -4457,10 +4453,7 @@ inline void gcode_M109() { } #if ENABLED(AUTOTEMP) - autotemp_enabled = code_seen('F'); - if (autotemp_enabled) autotemp_factor = code_value(); - if (code_seen('S')) autotemp_min = code_value(); - if (code_seen('B')) autotemp_max = code_value(); + planner.autotemp_M109(); #endif #if TEMP_RESIDENCY_TIME > 0 @@ -4819,7 +4812,7 @@ inline void gcode_M140() { */ inline void gcode_M81() { disable_all_heaters(); - finishAndDisableSteppers(); + stepper.finish_and_disable(); #if FAN_COUNT > 0 #if FAN_COUNT > 1 for (uint8_t i = 0; i < FAN_COUNT; i++) fanSpeeds[i] = 0; @@ -4829,7 +4822,7 @@ inline void gcode_M81() { #endif delay(1000); // Wait 1 second before switching off #if HAS_SUICIDE - st_synchronize(); + stepper.synchronize(); suicide(); #elif HAS_POWER_SWITCH OUT_WRITE(PS_ON_PIN, PS_ON_ASLEEP); @@ -4864,10 +4857,10 @@ inline void gcode_M18_M84() { else { bool all_axis = !((code_seen(axis_codes[X_AXIS])) || (code_seen(axis_codes[Y_AXIS])) || (code_seen(axis_codes[Z_AXIS])) || (code_seen(axis_codes[E_AXIS]))); if (all_axis) { - finishAndDisableSteppers(); + stepper.finish_and_disable(); } else { - st_synchronize(); + stepper.synchronize(); if (code_seen('X')) disable_x(); if (code_seen('Y')) disable_y(); if (code_seen('Z')) disable_z(); @@ -4900,15 +4893,15 @@ inline void gcode_M92() { if (i == E_AXIS) { float value = code_value(); if (value < 20.0) { - float factor = axis_steps_per_unit[i] / value; // increase e constants if M92 E14 is given for netfab. - max_e_jerk *= factor; - max_feedrate[i] *= factor; - axis_steps_per_sqr_second[i] *= factor; + float factor = planner.axis_steps_per_unit[i] / value; // increase e constants if M92 E14 is given for netfab. + planner.max_e_jerk *= factor; + planner.max_feedrate[i] *= factor; + planner.axis_steps_per_sqr_second[i] *= factor; } - axis_steps_per_unit[i] = value; + planner.axis_steps_per_unit[i] = value; } else { - axis_steps_per_unit[i] = code_value(); + planner.axis_steps_per_unit[i] = code_value(); } } } @@ -4927,35 +4920,7 @@ static void report_current_position() { SERIAL_PROTOCOLPGM(" E:"); SERIAL_PROTOCOL(current_position[E_AXIS]); - CRITICAL_SECTION_START; - extern volatile long count_position[NUM_AXIS]; - long xpos = count_position[X_AXIS], - ypos = count_position[Y_AXIS], - zpos = count_position[Z_AXIS]; - CRITICAL_SECTION_END; - - #if ENABLED(COREXY) || ENABLED(COREXZ) - SERIAL_PROTOCOLPGM(MSG_COUNT_A); - #else - SERIAL_PROTOCOLPGM(MSG_COUNT_X); - #endif - SERIAL_PROTOCOL(xpos); - - #if ENABLED(COREXY) - SERIAL_PROTOCOLPGM(" B:"); - #else - SERIAL_PROTOCOLPGM(" Y:"); - #endif - SERIAL_PROTOCOL(ypos); - - #if ENABLED(COREXZ) - SERIAL_PROTOCOLPGM(" C:"); - #else - SERIAL_PROTOCOLPGM(" Z:"); - #endif - SERIAL_PROTOCOL(zpos); - - SERIAL_EOL; + stepper.report_positions(); #if ENABLED(SCARA) SERIAL_PROTOCOLPGM("SCARA Theta:"); @@ -4971,9 +4936,9 @@ static void report_current_position() { SERIAL_EOL; SERIAL_PROTOCOLPGM("SCARA step Cal - Theta:"); - SERIAL_PROTOCOL(delta[X_AXIS] / 90 * axis_steps_per_unit[X_AXIS]); + SERIAL_PROTOCOL(delta[X_AXIS] / 90 * planner.axis_steps_per_unit[X_AXIS]); SERIAL_PROTOCOLPGM(" Psi+Theta:"); - SERIAL_PROTOCOL((delta[Y_AXIS] - delta[X_AXIS]) / 90 * axis_steps_per_unit[Y_AXIS]); + SERIAL_PROTOCOL((delta[Y_AXIS] - delta[X_AXIS]) / 90 * planner.axis_steps_per_unit[Y_AXIS]); SERIAL_EOL; SERIAL_EOL; #endif } @@ -5000,51 +4965,17 @@ inline void gcode_M117() { /** * M119: Output endstop states to serial output */ -inline void gcode_M119() { - SERIAL_PROTOCOLLN(MSG_M119_REPORT); - #if HAS_X_MIN - SERIAL_PROTOCOLPGM(MSG_X_MIN); - SERIAL_PROTOCOLLN(((READ(X_MIN_PIN)^X_MIN_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); - #endif - #if HAS_X_MAX - SERIAL_PROTOCOLPGM(MSG_X_MAX); - SERIAL_PROTOCOLLN(((READ(X_MAX_PIN)^X_MAX_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); - #endif - #if HAS_Y_MIN - SERIAL_PROTOCOLPGM(MSG_Y_MIN); - SERIAL_PROTOCOLLN(((READ(Y_MIN_PIN)^Y_MIN_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); - #endif - #if HAS_Y_MAX - SERIAL_PROTOCOLPGM(MSG_Y_MAX); - SERIAL_PROTOCOLLN(((READ(Y_MAX_PIN)^Y_MAX_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); - #endif - #if HAS_Z_MIN - SERIAL_PROTOCOLPGM(MSG_Z_MIN); - SERIAL_PROTOCOLLN(((READ(Z_MIN_PIN)^Z_MIN_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); - #endif - #if HAS_Z_MAX - SERIAL_PROTOCOLPGM(MSG_Z_MAX); - SERIAL_PROTOCOLLN(((READ(Z_MAX_PIN)^Z_MAX_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); - #endif - #if HAS_Z2_MAX - SERIAL_PROTOCOLPGM(MSG_Z2_MAX); - SERIAL_PROTOCOLLN(((READ(Z2_MAX_PIN)^Z2_MAX_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); - #endif - #if HAS_Z_PROBE - SERIAL_PROTOCOLPGM(MSG_Z_PROBE); - SERIAL_PROTOCOLLN(((READ(Z_MIN_PROBE_PIN)^Z_MIN_PROBE_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); - #endif -} +inline void gcode_M119() { endstops.M119(); } /** * M120: Enable endstops and set non-homing endstop state to "enabled" */ -inline void gcode_M120() { enable_endstops_globally(true); } +inline void gcode_M120() { endstops.enable_globally(true); } /** * M121: Disable endstops and set non-homing endstop state to "disabled" */ -inline void gcode_M121() { enable_endstops_globally(false); } +inline void gcode_M121() { endstops.enable_globally(false); } #if ENABLED(BLINKM) @@ -5148,17 +5079,17 @@ inline void gcode_M200() { inline void gcode_M201() { for (int8_t i = 0; i < NUM_AXIS; i++) { if (code_seen(axis_codes[i])) { - max_acceleration_units_per_sq_second[i] = code_value(); + planner.max_acceleration_units_per_sq_second[i] = code_value(); } } // steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner) - reset_acceleration_rates(); + planner.reset_acceleration_rates(); } #if 0 // Not used for Sprinter/grbl gen6 inline void gcode_M202() { for (int8_t i = 0; i < NUM_AXIS; i++) { - if (code_seen(axis_codes[i])) axis_travel_steps_per_sqr_second[i] = code_value() * axis_steps_per_unit[i]; + if (code_seen(axis_codes[i])) axis_travel_steps_per_sqr_second[i] = code_value() * planner.axis_steps_per_unit[i]; } } #endif @@ -5170,7 +5101,7 @@ inline void gcode_M201() { inline void gcode_M203() { for (int8_t i = 0; i < NUM_AXIS; i++) { if (code_seen(axis_codes[i])) { - max_feedrate[i] = code_value(); + planner.max_feedrate[i] = code_value(); } } } @@ -5186,23 +5117,23 @@ inline void gcode_M203() { */ inline void gcode_M204() { if (code_seen('S')) { // Kept for legacy compatibility. Should NOT BE USED for new developments. - travel_acceleration = acceleration = code_value(); - SERIAL_ECHOPAIR("Setting Print and Travel Acceleration: ", acceleration); + planner.travel_acceleration = planner.acceleration = code_value(); + SERIAL_ECHOPAIR("Setting Print and Travel Acceleration: ", planner.acceleration); SERIAL_EOL; } if (code_seen('P')) { - acceleration = code_value(); - SERIAL_ECHOPAIR("Setting Print Acceleration: ", acceleration); + planner.acceleration = code_value(); + SERIAL_ECHOPAIR("Setting Print Acceleration: ", planner.acceleration); SERIAL_EOL; } if (code_seen('R')) { - retract_acceleration = code_value(); - SERIAL_ECHOPAIR("Setting Retract Acceleration: ", retract_acceleration); + planner.retract_acceleration = code_value(); + SERIAL_ECHOPAIR("Setting Retract Acceleration: ", planner.retract_acceleration); SERIAL_EOL; } if (code_seen('T')) { - travel_acceleration = code_value(); - SERIAL_ECHOPAIR("Setting Travel Acceleration: ", travel_acceleration); + planner.travel_acceleration = code_value(); + SERIAL_ECHOPAIR("Setting Travel Acceleration: ", planner.travel_acceleration); SERIAL_EOL; } } @@ -5218,12 +5149,12 @@ inline void gcode_M204() { * E = Max E Jerk (mm/s/s) */ inline void gcode_M205() { - if (code_seen('S')) minimumfeedrate = code_value(); - if (code_seen('T')) mintravelfeedrate = code_value(); - if (code_seen('B')) minsegmenttime = code_value(); - if (code_seen('X')) max_xy_jerk = code_value(); - if (code_seen('Z')) max_z_jerk = code_value(); - if (code_seen('E')) max_e_jerk = code_value(); + if (code_seen('S')) planner.min_feedrate = code_value(); + if (code_seen('T')) planner.min_travel_feedrate = code_value(); + if (code_seen('B')) planner.min_segment_time = code_value(); + if (code_seen('X')) planner.max_xy_jerk = code_value(); + if (code_seen('Z')) planner.max_z_jerk = code_value(); + if (code_seen('E')) planner.max_e_jerk = code_value(); } /** @@ -5439,7 +5370,7 @@ inline void gcode_M226() { if (pin_number > -1) { int target = LOW; - st_synchronize(); + stepper.synchronize(); pinMode(pin_number, INPUT); @@ -5801,7 +5732,7 @@ inline void gcode_M303() { /** * M400: Finish all moves */ -inline void gcode_M400() { st_synchronize(); } +inline void gcode_M400() { stepper.synchronize(); } #if ENABLED(AUTO_BED_LEVELING_FEATURE) && DISABLED(Z_PROBE_SLED) && (HAS_SERVO_ENDSTOPS || ENABLED(Z_PROBE_ALLEN_KEY)) @@ -5887,7 +5818,7 @@ inline void gcode_M400() { st_synchronize(); } * This will stop the carriages mid-move, so most likely they * will be out of sync with the stepper position after this. */ -inline void gcode_M410() { quickStop(); } +inline void gcode_M410() { stepper.quick_stop(); } #if ENABLED(MESH_BED_LEVELING) @@ -6069,7 +6000,7 @@ inline void gcode_M503() { #if ENABLED(DELTA) #define RUNPLAN calculate_delta(destination); \ - plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], fr60, active_extruder); + planner.buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], fr60, active_extruder); #else #define RUNPLAN line_to_destination(); #endif @@ -6111,7 +6042,7 @@ inline void gcode_M503() { RUNPLAN; //finish moves - st_synchronize(); + stepper.synchronize(); //disable extruder steppers so filament can be removed disable_e0(); disable_e1(); @@ -6135,7 +6066,7 @@ inline void gcode_M503() { current_position[E_AXIS] += AUTO_FILAMENT_CHANGE_LENGTH; destination[E_AXIS] = current_position[E_AXIS]; line_to_destination(AUTO_FILAMENT_CHANGE_FEEDRATE); - st_synchronize(); + stepper.synchronize(); #endif } // while(!lcd_clicked) KEEPALIVE_STATE(IN_HANDLER); @@ -6143,7 +6074,7 @@ inline void gcode_M503() { #if ENABLED(AUTO_FILAMENT_CHANGE) current_position[E_AXIS] = 0; - st_synchronize(); + stepper.synchronize(); #endif //return to normal @@ -6162,8 +6093,8 @@ inline void gcode_M503() { #if ENABLED(DELTA) // Move XYZ to starting position, then E calculate_delta(lastpos); - plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], fr60, active_extruder); - plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], lastpos[E_AXIS], fr60, active_extruder); + planner.buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], fr60, active_extruder); + planner.buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], lastpos[E_AXIS], fr60, active_extruder); #else // Move XY to starting position, then Z, then E destination[X_AXIS] = lastpos[X_AXIS]; @@ -6198,7 +6129,7 @@ inline void gcode_M503() { * Note: the X axis should be homed after changing dual x-carriage mode. */ inline void gcode_M605() { - st_synchronize(); + stepper.synchronize(); if (code_seen('S')) dual_x_carriage_mode = code_value(); switch (dual_x_carriage_mode) { case DXC_DUPLICATION_MODE: @@ -6357,7 +6288,7 @@ inline void gcode_T(uint8_t tmp_extruder) { #ifdef XY_TRAVEL_SPEED feedrate = XY_TRAVEL_SPEED; #else - feedrate = min(max_feedrate[X_AXIS], max_feedrate[Y_AXIS]); + feedrate = min(planner.max_feedrate[X_AXIS], planner.max_feedrate[Y_AXIS]); #endif } @@ -6369,13 +6300,13 @@ inline void gcode_T(uint8_t tmp_extruder) { if (dual_x_carriage_mode == DXC_AUTO_PARK_MODE && IsRunning() && (delayed_move_time || current_position[X_AXIS] != x_home_pos(active_extruder))) { // Park old head: 1) raise 2) move to park position 3) lower - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + TOOLCHANGE_PARK_ZLIFT, - current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder); - plan_buffer_line(x_home_pos(active_extruder), current_position[Y_AXIS], current_position[Z_AXIS] + TOOLCHANGE_PARK_ZLIFT, - current_position[E_AXIS], max_feedrate[X_AXIS], active_extruder); - plan_buffer_line(x_home_pos(active_extruder), current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder); - st_synchronize(); + planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + TOOLCHANGE_PARK_ZLIFT, + current_position[E_AXIS], planner.max_feedrate[Z_AXIS], active_extruder); + planner.buffer_line(x_home_pos(active_extruder), current_position[Y_AXIS], current_position[Z_AXIS] + TOOLCHANGE_PARK_ZLIFT, + current_position[E_AXIS], planner.max_feedrate[X_AXIS], active_extruder); + planner.buffer_line(x_home_pos(active_extruder), current_position[Y_AXIS], current_position[Z_AXIS], + current_position[E_AXIS], planner.max_feedrate[Z_AXIS], active_extruder); + stepper.synchronize(); } // apply Y & Z extruder offset (x offset is already used in determining home pos) @@ -6443,24 +6374,31 @@ inline void gcode_T(uint8_t tmp_extruder) { #endif #else // !AUTO_BED_LEVELING_FEATURE + // Offset extruder (only by XY) for (int i=X_AXIS; i<=Y_AXIS; i++) current_position[i] += extruder_offset[i][tmp_extruder] - extruder_offset[i][active_extruder]; + #endif // !AUTO_BED_LEVELING_FEATURE + // Set the new active extruder and position active_extruder = tmp_extruder; + #endif // !DUAL_X_CARRIAGE + #if ENABLED(DELTA) sync_plan_position_delta(); #else sync_plan_position(); #endif + // Move to the old position if (IsRunning()) prepare_move(); + } // (tmp_extruder != active_extruder) #if ENABLED(EXT_SOLENOID) - st_synchronize(); + stepper.synchronize(); disable_all_solenoids(); enable_solenoid_on_active_extruder(); #endif // EXT_SOLENOID @@ -7251,9 +7189,9 @@ void clamp_to_software_endstops(float target[3]) { #if ENABLED(MESH_BED_LEVELING) // This function is used to split lines on mesh borders so each segment is only part of one mesh area -void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_rate, const uint8_t& extruder, uint8_t x_splits = 0xff, uint8_t y_splits = 0xff) { +void mesh_buffer_line(float x, float y, float z, const float e, float feed_rate, const uint8_t& extruder, uint8_t x_splits = 0xff, uint8_t y_splits = 0xff) { if (!mbl.active) { - plan_buffer_line(x, y, z, e, feed_rate, extruder); + planner.buffer_line(x, y, z, e, feed_rate, extruder); set_current_to_destination(); return; } @@ -7267,7 +7205,7 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_ iy = min(iy, MESH_NUM_Y_POINTS - 2); if (pix == ix && piy == iy) { // Start and end on same mesh square - plan_buffer_line(x, y, z, e, feed_rate, extruder); + planner.buffer_line(x, y, z, e, feed_rate, extruder); set_current_to_destination(); return; } @@ -7306,7 +7244,7 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_ } else { // Already split on a border - plan_buffer_line(x, y, z, e, feed_rate, extruder); + planner.buffer_line(x, y, z, e, feed_rate, extruder); set_current_to_destination(); return; } @@ -7315,12 +7253,12 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_ destination[Y_AXIS] = ny; destination[Z_AXIS] = nz; destination[E_AXIS] = ne; - mesh_plan_buffer_line(nx, ny, nz, ne, feed_rate, extruder, x_splits, y_splits); + mesh_buffer_line(nx, ny, nz, ne, feed_rate, extruder, x_splits, y_splits); destination[X_AXIS] = x; destination[Y_AXIS] = y; destination[Z_AXIS] = z; destination[E_AXIS] = e; - mesh_plan_buffer_line(x, y, z, e, feed_rate, extruder, x_splits, y_splits); + mesh_buffer_line(x, y, z, e, feed_rate, extruder, x_splits, y_splits); } #endif // MESH_BED_LEVELING @@ -7379,7 +7317,7 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_ //DEBUG_POS("prepare_move_delta", target); //DEBUG_POS("prepare_move_delta", delta); - plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], target[E_AXIS], feedrate / 60 * feedrate_multiplier / 100.0, active_extruder); + planner.buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], target[E_AXIS], feedrate / 60 * feedrate_multiplier / 100.0, active_extruder); } return true; } @@ -7396,11 +7334,11 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_ if (active_extruder_parked) { if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && active_extruder == 0) { // move duplicate extruder into correct duplication position. - plan_set_position(inactive_extruder_x_pos, current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); - plan_buffer_line(current_position[X_AXIS] + duplicate_extruder_x_offset, - current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], max_feedrate[X_AXIS], 1); + planner.set_position(inactive_extruder_x_pos, current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); + planner.buffer_line(current_position[X_AXIS] + duplicate_extruder_x_offset, + current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], planner.max_feedrate[X_AXIS], 1); sync_plan_position(); - st_synchronize(); + stepper.synchronize(); extruder_duplication_enabled = true; active_extruder_parked = false; } @@ -7418,9 +7356,9 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_ } delayed_move_time = 0; // unpark extruder: 1) raise, 2) move into starting XY position, 3) lower - plan_buffer_line(raised_parked_position[X_AXIS], raised_parked_position[Y_AXIS], raised_parked_position[Z_AXIS], current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], raised_parked_position[Z_AXIS], current_position[E_AXIS], min(max_feedrate[X_AXIS], max_feedrate[Y_AXIS]), active_extruder); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder); + planner.buffer_line(raised_parked_position[X_AXIS], raised_parked_position[Y_AXIS], raised_parked_position[Z_AXIS], current_position[E_AXIS], planner.max_feedrate[Z_AXIS], active_extruder); + planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], raised_parked_position[Z_AXIS], current_position[E_AXIS], min(planner.max_feedrate[X_AXIS], planner.max_feedrate[Y_AXIS]), active_extruder); + planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], planner.max_feedrate[Z_AXIS], active_extruder); active_extruder_parked = false; } } @@ -7438,7 +7376,7 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_ } else { #if ENABLED(MESH_BED_LEVELING) - mesh_plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], (feedrate / 60) * (feedrate_multiplier / 100.0), active_extruder); + mesh_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], (feedrate / 60) * (feedrate_multiplier / 100.0), active_extruder); return false; #else line_to_destination(feedrate * feedrate_multiplier / 100.0); @@ -7452,7 +7390,7 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_ /** * Prepare a single move and get ready for the next one * - * (This may call plan_buffer_line several times to put + * (This may call planner.buffer_line several times to put * smaller moves into the planner for DELTA or SCARA.) */ void prepare_move() { @@ -7596,9 +7534,9 @@ void plan_arc( #if ENABLED(AUTO_BED_LEVELING_FEATURE) adjust_delta(arc_target); #endif - plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], arc_target[E_AXIS], feed_rate, active_extruder); + planner.buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], arc_target[E_AXIS], feed_rate, active_extruder); #else - plan_buffer_line(arc_target[X_AXIS], arc_target[Y_AXIS], arc_target[Z_AXIS], arc_target[E_AXIS], feed_rate, active_extruder); + planner.buffer_line(arc_target[X_AXIS], arc_target[Y_AXIS], arc_target[Z_AXIS], arc_target[E_AXIS], feed_rate, active_extruder); #endif } @@ -7608,9 +7546,9 @@ void plan_arc( #if ENABLED(AUTO_BED_LEVELING_FEATURE) adjust_delta(target); #endif - plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], target[E_AXIS], feed_rate, active_extruder); + planner.buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], target[E_AXIS], feed_rate, active_extruder); #else - plan_buffer_line(target[X_AXIS], target[Y_AXIS], target[Z_AXIS], target[E_AXIS], feed_rate, active_extruder); + planner.buffer_line(target[X_AXIS], target[Y_AXIS], target[Z_AXIS], target[E_AXIS], feed_rate, active_extruder); #endif // As far as the parser is concerned, the position is now == target. In reality the @@ -7827,7 +7765,7 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) { if (max_inactive_time && ELAPSED(ms, previous_cmd_ms + max_inactive_time)) kill(PSTR(MSG_KILLED)); if (stepper_inactive_time && ELAPSED(ms, previous_cmd_ms + stepper_inactive_time) - && !ignore_stepper_queue && !blocks_queued()) { + && !ignore_stepper_queue && !planner.blocks_queued()) { #if ENABLED(DISABLE_INACTIVE_X) disable_x(); #endif @@ -7920,14 +7858,14 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) { #endif } float oldepos = current_position[E_AXIS], oldedes = destination[E_AXIS]; - plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], - destination[E_AXIS] + (EXTRUDER_RUNOUT_EXTRUDE) * (EXTRUDER_RUNOUT_ESTEPS) / axis_steps_per_unit[E_AXIS], - (EXTRUDER_RUNOUT_SPEED) / 60. * (EXTRUDER_RUNOUT_ESTEPS) / axis_steps_per_unit[E_AXIS], active_extruder); + planner.buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], + destination[E_AXIS] + (EXTRUDER_RUNOUT_EXTRUDE) * (EXTRUDER_RUNOUT_ESTEPS) / planner.axis_steps_per_unit[E_AXIS], + (EXTRUDER_RUNOUT_SPEED) / 60. * (EXTRUDER_RUNOUT_ESTEPS) / planner.axis_steps_per_unit[E_AXIS], active_extruder); current_position[E_AXIS] = oldepos; destination[E_AXIS] = oldedes; - plan_set_e_position(oldepos); + planner.set_e_position(oldepos); previous_cmd_ms = ms; // refresh_cmd_timeout() - st_synchronize(); + stepper.synchronize(); switch (active_extruder) { case 0: E0_ENABLE_WRITE(oldstatus); @@ -7965,7 +7903,7 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) { handle_status_leds(); #endif - check_axes_activity(); + planner.check_axes_activity(); } void kill(const char* lcd_msg) { @@ -8004,7 +7942,7 @@ void kill(const char* lcd_msg) { if (!filament_ran_out) { filament_ran_out = true; enqueue_and_echo_commands_P(PSTR(FILAMENT_RUNOUT_SCRIPT)); - st_synchronize(); + stepper.synchronize(); } } diff --git a/Marlin/cardreader.cpp b/Marlin/cardreader.cpp index fbe4ae7e7..1e9aab3b6 100644 --- a/Marlin/cardreader.cpp +++ b/Marlin/cardreader.cpp @@ -596,7 +596,7 @@ void CardReader::updir() { } void CardReader::printingHasFinished() { - st_synchronize(); + stepper.synchronize(); if (file_subcall_ctr > 0) { // Heading up to a parent file that called current as a procedure. file.close(); file_subcall_ctr--; diff --git a/Marlin/configuration_store.cpp b/Marlin/configuration_store.cpp index 057f95b1c..8946156b1 100644 --- a/Marlin/configuration_store.cpp +++ b/Marlin/configuration_store.cpp @@ -43,18 +43,18 @@ * * 100 Version (char x4) * - * 104 M92 XYZE axis_steps_per_unit (float x4) - * 120 M203 XYZE max_feedrate (float x4) - * 136 M201 XYZE max_acceleration_units_per_sq_second (uint32_t x4) - * 152 M204 P acceleration (float) - * 156 M204 R retract_acceleration (float) - * 160 M204 T travel_acceleration (float) - * 164 M205 S minimumfeedrate (float) - * 168 M205 T mintravelfeedrate (float) - * 172 M205 B minsegmenttime (ulong) - * 176 M205 X max_xy_jerk (float) - * 180 M205 Z max_z_jerk (float) - * 184 M205 E max_e_jerk (float) + * 104 M92 XYZE planner.axis_steps_per_unit (float x4) + * 120 M203 XYZE planner.max_feedrate (float x4) + * 136 M201 XYZE planner.max_acceleration_units_per_sq_second (uint32_t x4) + * 152 M204 P planner.acceleration (float) + * 156 M204 R planner.retract_acceleration (float) + * 160 M204 T planner.travel_acceleration (float) + * 164 M205 S planner.min_feedrate (float) + * 168 M205 T planner.min_travel_feedrate (float) + * 172 M205 B planner.min_segment_time (ulong) + * 176 M205 X planner.max_xy_jerk (float) + * 180 M205 Z planner.max_z_jerk (float) + * 184 M205 E planner.max_e_jerk (float) * 188 M206 XYZ home_offset (float x3) * * Mesh bed leveling: @@ -173,18 +173,18 @@ void Config_StoreSettings() { char ver[4] = "000"; int i = EEPROM_OFFSET; EEPROM_WRITE_VAR(i, ver); // invalidate data first - EEPROM_WRITE_VAR(i, axis_steps_per_unit); - EEPROM_WRITE_VAR(i, max_feedrate); - EEPROM_WRITE_VAR(i, max_acceleration_units_per_sq_second); - EEPROM_WRITE_VAR(i, acceleration); - EEPROM_WRITE_VAR(i, retract_acceleration); - EEPROM_WRITE_VAR(i, travel_acceleration); - EEPROM_WRITE_VAR(i, minimumfeedrate); - EEPROM_WRITE_VAR(i, mintravelfeedrate); - EEPROM_WRITE_VAR(i, minsegmenttime); - EEPROM_WRITE_VAR(i, max_xy_jerk); - EEPROM_WRITE_VAR(i, max_z_jerk); - EEPROM_WRITE_VAR(i, max_e_jerk); + EEPROM_WRITE_VAR(i, planner.axis_steps_per_unit); + EEPROM_WRITE_VAR(i, planner.max_feedrate); + EEPROM_WRITE_VAR(i, planner.max_acceleration_units_per_sq_second); + EEPROM_WRITE_VAR(i, planner.acceleration); + EEPROM_WRITE_VAR(i, planner.retract_acceleration); + EEPROM_WRITE_VAR(i, planner.travel_acceleration); + EEPROM_WRITE_VAR(i, planner.min_feedrate); + EEPROM_WRITE_VAR(i, planner.min_travel_feedrate); + EEPROM_WRITE_VAR(i, planner.min_segment_time); + EEPROM_WRITE_VAR(i, planner.max_xy_jerk); + EEPROM_WRITE_VAR(i, planner.max_z_jerk); + EEPROM_WRITE_VAR(i, planner.max_e_jerk); EEPROM_WRITE_VAR(i, home_offset); uint8_t mesh_num_x = 3; @@ -351,22 +351,22 @@ void Config_RetrieveSettings() { float dummy = 0; // version number match - EEPROM_READ_VAR(i, axis_steps_per_unit); - EEPROM_READ_VAR(i, max_feedrate); - EEPROM_READ_VAR(i, max_acceleration_units_per_sq_second); + EEPROM_READ_VAR(i, planner.axis_steps_per_unit); + EEPROM_READ_VAR(i, planner.max_feedrate); + EEPROM_READ_VAR(i, planner.max_acceleration_units_per_sq_second); // steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner) - reset_acceleration_rates(); + planner.reset_acceleration_rates(); - EEPROM_READ_VAR(i, acceleration); - EEPROM_READ_VAR(i, retract_acceleration); - EEPROM_READ_VAR(i, travel_acceleration); - EEPROM_READ_VAR(i, minimumfeedrate); - EEPROM_READ_VAR(i, mintravelfeedrate); - EEPROM_READ_VAR(i, minsegmenttime); - EEPROM_READ_VAR(i, max_xy_jerk); - EEPROM_READ_VAR(i, max_z_jerk); - EEPROM_READ_VAR(i, max_e_jerk); + EEPROM_READ_VAR(i, planner.acceleration); + EEPROM_READ_VAR(i, planner.retract_acceleration); + EEPROM_READ_VAR(i, planner.travel_acceleration); + EEPROM_READ_VAR(i, planner.min_feedrate); + EEPROM_READ_VAR(i, planner.min_travel_feedrate); + EEPROM_READ_VAR(i, planner.min_segment_time); + EEPROM_READ_VAR(i, planner.max_xy_jerk); + EEPROM_READ_VAR(i, planner.max_z_jerk); + EEPROM_READ_VAR(i, planner.max_e_jerk); EEPROM_READ_VAR(i, home_offset); uint8_t dummy_uint8 = 0, mesh_num_x = 0, mesh_num_y = 0; @@ -528,9 +528,9 @@ void Config_ResetDefault() { float tmp2[] = DEFAULT_MAX_FEEDRATE; long tmp3[] = DEFAULT_MAX_ACCELERATION; for (uint8_t i = 0; i < NUM_AXIS; i++) { - axis_steps_per_unit[i] = tmp1[i]; - max_feedrate[i] = tmp2[i]; - max_acceleration_units_per_sq_second[i] = tmp3[i]; + planner.axis_steps_per_unit[i] = tmp1[i]; + planner.max_feedrate[i] = tmp2[i]; + planner.max_acceleration_units_per_sq_second[i] = tmp3[i]; #if ENABLED(SCARA) if (i < COUNT(axis_scaling)) axis_scaling[i] = 1; @@ -538,17 +538,17 @@ void Config_ResetDefault() { } // steps per sq second need to be updated to agree with the units per sq second - reset_acceleration_rates(); + planner.reset_acceleration_rates(); - acceleration = DEFAULT_ACCELERATION; - retract_acceleration = DEFAULT_RETRACT_ACCELERATION; - travel_acceleration = DEFAULT_TRAVEL_ACCELERATION; - minimumfeedrate = DEFAULT_MINIMUMFEEDRATE; - minsegmenttime = DEFAULT_MINSEGMENTTIME; - mintravelfeedrate = DEFAULT_MINTRAVELFEEDRATE; - max_xy_jerk = DEFAULT_XYJERK; - max_z_jerk = DEFAULT_ZJERK; - max_e_jerk = DEFAULT_EJERK; + planner.acceleration = DEFAULT_ACCELERATION; + planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION; + planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION; + planner.min_feedrate = DEFAULT_MINIMUMFEEDRATE; + planner.min_segment_time = DEFAULT_MINSEGMENTTIME; + planner.min_travel_feedrate = DEFAULT_MINTRAVELFEEDRATE; + planner.max_xy_jerk = DEFAULT_XYJERK; + planner.max_z_jerk = DEFAULT_ZJERK; + planner.max_e_jerk = DEFAULT_EJERK; home_offset[X_AXIS] = home_offset[Y_AXIS] = home_offset[Z_AXIS] = 0; #if ENABLED(MESH_BED_LEVELING) @@ -653,10 +653,10 @@ void Config_PrintSettings(bool forReplay) { SERIAL_ECHOLNPGM("Steps per unit:"); CONFIG_ECHO_START; } - SERIAL_ECHOPAIR(" M92 X", axis_steps_per_unit[X_AXIS]); - SERIAL_ECHOPAIR(" Y", axis_steps_per_unit[Y_AXIS]); - SERIAL_ECHOPAIR(" Z", axis_steps_per_unit[Z_AXIS]); - SERIAL_ECHOPAIR(" E", axis_steps_per_unit[E_AXIS]); + SERIAL_ECHOPAIR(" M92 X", planner.axis_steps_per_unit[X_AXIS]); + SERIAL_ECHOPAIR(" Y", planner.axis_steps_per_unit[Y_AXIS]); + SERIAL_ECHOPAIR(" Z", planner.axis_steps_per_unit[Z_AXIS]); + SERIAL_ECHOPAIR(" E", planner.axis_steps_per_unit[E_AXIS]); SERIAL_EOL; CONFIG_ECHO_START; @@ -677,10 +677,10 @@ void Config_PrintSettings(bool forReplay) { SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):"); CONFIG_ECHO_START; } - SERIAL_ECHOPAIR(" M203 X", max_feedrate[X_AXIS]); - SERIAL_ECHOPAIR(" Y", max_feedrate[Y_AXIS]); - SERIAL_ECHOPAIR(" Z", max_feedrate[Z_AXIS]); - SERIAL_ECHOPAIR(" E", max_feedrate[E_AXIS]); + SERIAL_ECHOPAIR(" M203 X", planner.max_feedrate[X_AXIS]); + SERIAL_ECHOPAIR(" Y", planner.max_feedrate[Y_AXIS]); + SERIAL_ECHOPAIR(" Z", planner.max_feedrate[Z_AXIS]); + SERIAL_ECHOPAIR(" E", planner.max_feedrate[E_AXIS]); SERIAL_EOL; CONFIG_ECHO_START; @@ -688,19 +688,19 @@ void Config_PrintSettings(bool forReplay) { SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):"); CONFIG_ECHO_START; } - SERIAL_ECHOPAIR(" M201 X", max_acceleration_units_per_sq_second[X_AXIS]); - SERIAL_ECHOPAIR(" Y", max_acceleration_units_per_sq_second[Y_AXIS]); - SERIAL_ECHOPAIR(" Z", max_acceleration_units_per_sq_second[Z_AXIS]); - SERIAL_ECHOPAIR(" E", max_acceleration_units_per_sq_second[E_AXIS]); + SERIAL_ECHOPAIR(" M201 X", planner.max_acceleration_units_per_sq_second[X_AXIS]); + SERIAL_ECHOPAIR(" Y", planner.max_acceleration_units_per_sq_second[Y_AXIS]); + SERIAL_ECHOPAIR(" Z", planner.max_acceleration_units_per_sq_second[Z_AXIS]); + SERIAL_ECHOPAIR(" E", planner.max_acceleration_units_per_sq_second[E_AXIS]); SERIAL_EOL; CONFIG_ECHO_START; if (!forReplay) { SERIAL_ECHOLNPGM("Accelerations: P=printing, R=retract and T=travel"); CONFIG_ECHO_START; } - SERIAL_ECHOPAIR(" M204 P", acceleration); - SERIAL_ECHOPAIR(" R", retract_acceleration); - SERIAL_ECHOPAIR(" T", travel_acceleration); + SERIAL_ECHOPAIR(" M204 P", planner.acceleration); + SERIAL_ECHOPAIR(" R", planner.retract_acceleration); + SERIAL_ECHOPAIR(" T", planner.travel_acceleration); SERIAL_EOL; CONFIG_ECHO_START; @@ -708,12 +708,12 @@ void Config_PrintSettings(bool forReplay) { SERIAL_ECHOLNPGM("Advanced variables: S=Min feedrate (mm/s), T=Min travel feedrate (mm/s), B=minimum segment time (ms), X=maximum XY jerk (mm/s), Z=maximum Z jerk (mm/s), E=maximum E jerk (mm/s)"); CONFIG_ECHO_START; } - SERIAL_ECHOPAIR(" M205 S", minimumfeedrate); - SERIAL_ECHOPAIR(" T", mintravelfeedrate); - SERIAL_ECHOPAIR(" B", minsegmenttime); - SERIAL_ECHOPAIR(" X", max_xy_jerk); - SERIAL_ECHOPAIR(" Z", max_z_jerk); - SERIAL_ECHOPAIR(" E", max_e_jerk); + SERIAL_ECHOPAIR(" M205 S", planner.min_feedrate); + SERIAL_ECHOPAIR(" T", planner.min_travel_feedrate); + SERIAL_ECHOPAIR(" B", planner.min_segment_time); + SERIAL_ECHOPAIR(" X", planner.max_xy_jerk); + SERIAL_ECHOPAIR(" Z", planner.max_z_jerk); + SERIAL_ECHOPAIR(" E", planner.max_e_jerk); SERIAL_EOL; CONFIG_ECHO_START; diff --git a/Marlin/endstops.cpp b/Marlin/endstops.cpp new file mode 100644 index 000000000..ac37c5805 --- /dev/null +++ b/Marlin/endstops.cpp @@ -0,0 +1,356 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] + * + * Based on Sprinter and grbl. + * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +/** + * endstops.cpp - A singleton object to manage endstops + */ + +#include "Marlin.h" +#include "endstops.h" +#include "stepper.h" +#include "ultralcd.h" + +// TEST_ENDSTOP: test the old and the current status of an endstop +#define TEST_ENDSTOP(ENDSTOP) (TEST(current_endstop_bits & old_endstop_bits, ENDSTOP)) + +Endstops endstops; + +Endstops::Endstops() { + enable_globally(ENABLED(ENDSTOPS_ONLY_FOR_HOMING)); + enable(true); + #if ENABLED(HAS_Z_MIN_PROBE) + enable_z_probe(false); + #endif +} // Endstops::Endstops + +void Endstops::init() { + + #if HAS_X_MIN + SET_INPUT(X_MIN_PIN); + #if ENABLED(ENDSTOPPULLUP_XMIN) + WRITE(X_MIN_PIN,HIGH); + #endif + #endif + + #if HAS_Y_MIN + SET_INPUT(Y_MIN_PIN); + #if ENABLED(ENDSTOPPULLUP_YMIN) + WRITE(Y_MIN_PIN,HIGH); + #endif + #endif + + #if HAS_Z_MIN + SET_INPUT(Z_MIN_PIN); + #if ENABLED(ENDSTOPPULLUP_ZMIN) + WRITE(Z_MIN_PIN,HIGH); + #endif + #endif + + #if HAS_Z2_MIN + SET_INPUT(Z2_MIN_PIN); + #if ENABLED(ENDSTOPPULLUP_ZMIN) + WRITE(Z2_MIN_PIN,HIGH); + #endif + #endif + + #if HAS_X_MAX + SET_INPUT(X_MAX_PIN); + #if ENABLED(ENDSTOPPULLUP_XMAX) + WRITE(X_MAX_PIN,HIGH); + #endif + #endif + + #if HAS_Y_MAX + SET_INPUT(Y_MAX_PIN); + #if ENABLED(ENDSTOPPULLUP_YMAX) + WRITE(Y_MAX_PIN,HIGH); + #endif + #endif + + #if HAS_Z_MAX + SET_INPUT(Z_MAX_PIN); + #if ENABLED(ENDSTOPPULLUP_ZMAX) + WRITE(Z_MAX_PIN,HIGH); + #endif + #endif + + #if HAS_Z2_MAX + SET_INPUT(Z2_MAX_PIN); + #if ENABLED(ENDSTOPPULLUP_ZMAX) + WRITE(Z2_MAX_PIN,HIGH); + #endif + #endif + + #if HAS_Z_PROBE && ENABLED(Z_MIN_PROBE_ENDSTOP) // Check for Z_MIN_PROBE_ENDSTOP so we don't pull a pin high unless it's to be used. + SET_INPUT(Z_MIN_PROBE_PIN); + #if ENABLED(ENDSTOPPULLUP_ZMIN_PROBE) + WRITE(Z_MIN_PROBE_PIN,HIGH); + #endif + #endif + +} // Endstops::init + +void Endstops::report_state() { + if (endstop_hit_bits) { + #if ENABLED(ULTRA_LCD) + char chrX = ' ', chrY = ' ', chrZ = ' ', chrP = ' '; + #define _SET_STOP_CHAR(A,C) (chr## A = C) + #else + #define _SET_STOP_CHAR(A,C) ; + #endif + + #define _ENDSTOP_HIT_ECHO(A,C) do{ \ + SERIAL_ECHOPAIR(" " STRINGIFY(A) ":", stepper.triggered_position_mm(A ##_AXIS)); \ + _SET_STOP_CHAR(A,C); }while(0) + + #define _ENDSTOP_HIT_TEST(A,C) \ + if (TEST(endstop_hit_bits, A ##_MIN) || TEST(endstop_hit_bits, A ##_MAX)) \ + _ENDSTOP_HIT_ECHO(A,C) + + SERIAL_ECHO_START; + SERIAL_ECHOPGM(MSG_ENDSTOPS_HIT); + _ENDSTOP_HIT_TEST(X, 'X'); + _ENDSTOP_HIT_TEST(Y, 'Y'); + _ENDSTOP_HIT_TEST(Z, 'Z'); + + #if ENABLED(Z_MIN_PROBE_ENDSTOP) + #define P_AXIS Z_AXIS + if (TEST(endstop_hit_bits, Z_MIN_PROBE)) _ENDSTOP_HIT_ECHO(P, 'P'); + #endif + SERIAL_EOL; + + #if ENABLED(ULTRA_LCD) + char msg[3 * strlen(MSG_LCD_ENDSTOPS) + 8 + 1]; // Room for a UTF 8 string + sprintf_P(msg, PSTR(MSG_LCD_ENDSTOPS " %c %c %c %c"), chrX, chrY, chrZ, chrP); + lcd_setstatus(msg); + #endif + + hit_on_purpose(); + + #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) && ENABLED(SDSUPPORT) + if (abort_on_endstop_hit) { + card.sdprinting = false; + card.closefile(); + stepper.quick_stop(); + disable_all_heaters(); // switch off all heaters. + } + #endif + } +} // Endstops::report_state + +void Endstops::M119() { + SERIAL_PROTOCOLLN(MSG_M119_REPORT); + #if HAS_X_MIN + SERIAL_PROTOCOLPGM(MSG_X_MIN); + SERIAL_PROTOCOLLN(((READ(X_MIN_PIN)^X_MIN_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); + #endif + #if HAS_X_MAX + SERIAL_PROTOCOLPGM(MSG_X_MAX); + SERIAL_PROTOCOLLN(((READ(X_MAX_PIN)^X_MAX_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); + #endif + #if HAS_Y_MIN + SERIAL_PROTOCOLPGM(MSG_Y_MIN); + SERIAL_PROTOCOLLN(((READ(Y_MIN_PIN)^Y_MIN_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); + #endif + #if HAS_Y_MAX + SERIAL_PROTOCOLPGM(MSG_Y_MAX); + SERIAL_PROTOCOLLN(((READ(Y_MAX_PIN)^Y_MAX_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); + #endif + #if HAS_Z_MIN + SERIAL_PROTOCOLPGM(MSG_Z_MIN); + SERIAL_PROTOCOLLN(((READ(Z_MIN_PIN)^Z_MIN_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); + #endif + #if HAS_Z_MAX + SERIAL_PROTOCOLPGM(MSG_Z_MAX); + SERIAL_PROTOCOLLN(((READ(Z_MAX_PIN)^Z_MAX_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); + #endif + #if HAS_Z2_MAX + SERIAL_PROTOCOLPGM(MSG_Z2_MAX); + SERIAL_PROTOCOLLN(((READ(Z2_MAX_PIN)^Z2_MAX_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); + #endif + #if HAS_Z_PROBE + SERIAL_PROTOCOLPGM(MSG_Z_PROBE); + SERIAL_PROTOCOLLN(((READ(Z_MIN_PROBE_PIN)^Z_MIN_PROBE_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); + #endif +} // Endstops::M119 + +#if ENABLED(Z_DUAL_ENDSTOPS) + + // Pass the result of the endstop test + void Endstops::test_dual_z_endstops(EndstopEnum es1, EndstopEnum es2) { + byte z_test = TEST_ENDSTOP(es1) | (TEST_ENDSTOP(es2) << 1); // bit 0 for Z, bit 1 for Z2 + if (stepper.current_block->steps[Z_AXIS] > 0) { + stepper.endstop_triggered(Z_AXIS); + SBI(endstop_hit_bits, Z_MIN); + if (!stepper.performing_homing || (z_test == 0x3)) //if not performing home or if both endstops were trigged during homing... + stepper.kill_current_block(); + } + } + +#endif + +// Check endstops - Called from ISR! +void Endstops::update() { + + #define _ENDSTOP_PIN(AXIS, MINMAX) AXIS ##_## MINMAX ##_PIN + #define _ENDSTOP_INVERTING(AXIS, MINMAX) AXIS ##_## MINMAX ##_ENDSTOP_INVERTING + #define _ENDSTOP_HIT(AXIS) SBI(endstop_hit_bits, _ENDSTOP(AXIS, MIN)) + #define _ENDSTOP(AXIS, MINMAX) AXIS ##_## MINMAX + + // UPDATE_ENDSTOP_BIT: set the current endstop bits for an endstop to its status + #define UPDATE_ENDSTOP_BIT(AXIS, MINMAX) SET_BIT(current_endstop_bits, _ENDSTOP(AXIS, MINMAX), (READ(_ENDSTOP_PIN(AXIS, MINMAX)) != _ENDSTOP_INVERTING(AXIS, MINMAX))) + // COPY_BIT: copy the value of COPY_BIT to BIT in bits + #define COPY_BIT(bits, COPY_BIT, BIT) SET_BIT(bits, BIT, TEST(bits, COPY_BIT)) + + #define UPDATE_ENDSTOP(AXIS,MINMAX) do { \ + UPDATE_ENDSTOP_BIT(AXIS, MINMAX); \ + if (TEST_ENDSTOP(_ENDSTOP(AXIS, MINMAX)) && stepper.current_block->steps[_AXIS(AXIS)] > 0) { \ + _ENDSTOP_HIT(AXIS); \ + stepper.endstop_triggered(_AXIS(AXIS)); \ + } \ + } while(0) + + #if ENABLED(COREXY) || ENABLED(COREXZ) + // Head direction in -X axis for CoreXY and CoreXZ bots. + // If Delta1 == -Delta2, the movement is only in Y or Z axis + if ((stepper.current_block->steps[A_AXIS] != stepper.current_block->steps[CORE_AXIS_2]) || (stepper.motor_direction(A_AXIS) == stepper.motor_direction(CORE_AXIS_2))) { + if (stepper.motor_direction(X_HEAD)) + #else + if (stepper.motor_direction(X_AXIS)) // stepping along -X axis (regular Cartesian bot) + #endif + { // -direction + #if ENABLED(DUAL_X_CARRIAGE) + // with 2 x-carriages, endstops are only checked in the homing direction for the active extruder + if ((stepper.current_block->active_extruder == 0 && X_HOME_DIR == -1) || (stepper.current_block->active_extruder != 0 && X2_HOME_DIR == -1)) + #endif + { + #if HAS_X_MIN + UPDATE_ENDSTOP(X, MIN); + #endif + } + } + else { // +direction + #if ENABLED(DUAL_X_CARRIAGE) + // with 2 x-carriages, endstops are only checked in the homing direction for the active extruder + if ((stepper.current_block->active_extruder == 0 && X_HOME_DIR == 1) || (stepper.current_block->active_extruder != 0 && X2_HOME_DIR == 1)) + #endif + { + #if HAS_X_MAX + UPDATE_ENDSTOP(X, MAX); + #endif + } + } + #if ENABLED(COREXY) || ENABLED(COREXZ) + } + #endif + + #if ENABLED(COREXY) + // Head direction in -Y axis for CoreXY bots. + // If DeltaX == DeltaY, the movement is only in X axis + if ((stepper.current_block->steps[A_AXIS] != stepper.current_block->steps[B_AXIS]) || (stepper.motor_direction(A_AXIS) != stepper.motor_direction(B_AXIS))) { + if (stepper.motor_direction(Y_HEAD)) + #else + if (stepper.motor_direction(Y_AXIS)) // -direction + #endif + { // -direction + #if HAS_Y_MIN + UPDATE_ENDSTOP(Y, MIN); + #endif + } + else { // +direction + #if HAS_Y_MAX + UPDATE_ENDSTOP(Y, MAX); + #endif + } + #if ENABLED(COREXY) + } + #endif + + #if ENABLED(COREXZ) + // Head direction in -Z axis for CoreXZ bots. + // If DeltaX == DeltaZ, the movement is only in X axis + if ((stepper.current_block->steps[A_AXIS] != stepper.current_block->steps[C_AXIS]) || (stepper.motor_direction(A_AXIS) != stepper.motor_direction(C_AXIS))) { + if (stepper.motor_direction(Z_HEAD)) + #else + if (stepper.motor_direction(Z_AXIS)) + #endif + { // z -direction + #if HAS_Z_MIN + + #if ENABLED(Z_DUAL_ENDSTOPS) + + UPDATE_ENDSTOP_BIT(Z, MIN); + #if HAS_Z2_MIN + UPDATE_ENDSTOP_BIT(Z2, MIN); + #else + COPY_BIT(current_endstop_bits, Z_MIN, Z2_MIN); + #endif + + test_dual_z_endstops(Z_MIN, Z2_MIN); + + #else // !Z_DUAL_ENDSTOPS + + #if ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN) && ENABLED(HAS_Z_MIN_PROBE) + if (z_probe_enabled) UPDATE_ENDSTOP(Z, MIN); + #else + UPDATE_ENDSTOP(Z, MIN); + #endif + + #endif // !Z_DUAL_ENDSTOPS + + #endif // HAS_Z_MIN + + #if ENABLED(Z_MIN_PROBE_ENDSTOP) && DISABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN) && ENABLED(HAS_Z_MIN_PROBE) + if (z_probe_enabled) { + UPDATE_ENDSTOP(Z, MIN_PROBE); + if (TEST_ENDSTOP(Z_MIN_PROBE)) SBI(endstop_hit_bits, Z_MIN_PROBE); + } + #endif + } + else { // z +direction + #if HAS_Z_MAX + + #if ENABLED(Z_DUAL_ENDSTOPS) + + UPDATE_ENDSTOP_BIT(Z, MAX); + #if HAS_Z2_MAX + UPDATE_ENDSTOP_BIT(Z2, MAX); + #else + COPY_BIT(current_endstop_bits, Z_MAX, Z2_MAX); + #endif + + test_dual_z_endstops(Z_MAX, Z2_MAX); + + #else // !Z_DUAL_ENDSTOPS + + UPDATE_ENDSTOP(Z, MAX); + + #endif // !Z_DUAL_ENDSTOPS + #endif // Z_MAX_PIN + } + #if ENABLED(COREXZ) + } + #endif + + old_endstop_bits = current_endstop_bits; + +} // Endstops::update() diff --git a/Marlin/endstops.h b/Marlin/endstops.h new file mode 100644 index 000000000..a72306728 --- /dev/null +++ b/Marlin/endstops.h @@ -0,0 +1,105 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] + * + * Based on Sprinter and grbl. + * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +/** + * endstops.h - manages endstops + */ + +#ifndef ENDSTOPS_H +#define ENDSTOPS_H + +enum EndstopEnum {X_MIN = 0, Y_MIN = 1, Z_MIN = 2, Z_MIN_PROBE = 3, X_MAX = 4, Y_MAX = 5, Z_MAX = 6, Z2_MIN = 7, Z2_MAX = 8}; + +class Endstops { + + public: + + volatile char endstop_hit_bits; // use X_MIN, Y_MIN, Z_MIN and Z_MIN_PROBE as BIT value + + #if ENABLED(Z_DUAL_ENDSTOPS) + uint16_t current_endstop_bits = 0, + old_endstop_bits = 0; + #else + byte current_endstop_bits = 0, + old_endstop_bits = 0; + #endif + + + bool enabled = true; + bool enabled_globally = + #if ENABLED(ENDSTOPS_ONLY_FOR_HOMING) + false + #else + true + #endif + ; + + Endstops(); + + /** + * Initialize the endstop pins + */ + void init(); + + /** + * Update the endstops bits from the pins + */ + void update(); + + /** + * Print an error message reporting the position when the endstops were last hit. + */ + void report_state(); //call from somewhere to create an serial error message with the locations the endstops where hit, in case they were triggered + + /** + * Report endstop positions in response to M119 + */ + void M119(); + + // Enable / disable endstop checking globally + FORCE_INLINE void enable_globally(bool onoff=true) { enabled_globally = enabled = onoff; } + + // Enable / disable endstop checking + FORCE_INLINE void enable(bool onoff=true) { enabled = onoff; } + + // Disable / Enable endstops based on ENSTOPS_ONLY_FOR_HOMING and global enable + FORCE_INLINE void not_homing() { enabled = enabled_globally; } + + // Clear endstops (i.e., they were hit intentionally) to suppress the report + FORCE_INLINE void hit_on_purpose() { endstop_hit_bits = 0; } + + // Enable / disable endstop z-probe checking + #if ENABLED(HAS_Z_MIN_PROBE) + volatile bool z_probe_enabled = false; + FORCE_INLINE void enable_z_probe(bool onoff=true) { z_probe_enabled = onoff; } + #endif + + private: + + #if ENABLED(Z_DUAL_ENDSTOPS) + void test_dual_z_endstops(EndstopEnum es1, EndstopEnum es2); + #endif +}; + +extern Endstops endstops; + +#endif // ENDSTOPS_H diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp index f5062d2a7..5e55c7dd8 100644 --- a/Marlin/planner.cpp +++ b/Marlin/planner.cpp @@ -81,105 +81,27 @@ #include "mesh_bed_leveling.h" #endif -//=========================================================================== -//============================= public variables ============================ -//=========================================================================== +Planner planner; -millis_t minsegmenttime; -float max_feedrate[NUM_AXIS]; // Max speeds in mm per minute -float axis_steps_per_unit[NUM_AXIS]; -unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software -float minimumfeedrate; -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 mintravelfeedrate; -unsigned long axis_steps_per_sqr_second[NUM_AXIS]; - -#if ENABLED(AUTO_BED_LEVELING_FEATURE) - // Transform required to compensate for bed level - matrix_3x3 plan_bed_level_matrix = { - 1.0, 0.0, 0.0, - 0.0, 1.0, 0.0, - 0.0, 0.0, 1.0 - }; -#endif // AUTO_BED_LEVELING_FEATURE - -#if ENABLED(AUTOTEMP) - float autotemp_max = 250; - float autotemp_min = 210; - float autotemp_factor = 0.1; - bool autotemp_enabled = false; -#endif - -#if ENABLED(FAN_SOFT_PWM) - extern unsigned char fanSpeedSoftPwm[FAN_COUNT]; -#endif - -//=========================================================================== -//============ semi-private variables, used in inline functions ============= -//=========================================================================== - -block_t block_buffer[BLOCK_BUFFER_SIZE]; // A ring buffer for motion instfructions -volatile unsigned char block_buffer_head; // Index of the next block to be pushed -volatile unsigned char block_buffer_tail; // Index of the block to process now - -//=========================================================================== -//============================ private variables ============================ -//=========================================================================== - -// The current position of the tool in absolute steps -long position[NUM_AXIS]; // Rescaled from extern when axis_steps_per_unit are changed by gcode -static float previous_speed[NUM_AXIS]; // Speed of previous path line segment -static float previous_nominal_speed; // Nominal speed of previous path line segment - -uint8_t g_uc_extruder_last_move[EXTRUDERS] = { 0 }; - -#ifdef XY_FREQUENCY_LIMIT - // Used for the frequency limit - #define MAX_FREQ_TIME (1000000.0/XY_FREQUENCY_LIMIT) - // Old direction bits. Used for speed calculations - static unsigned char old_direction_bits = 0; - // 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} }; -#endif - -#if ENABLED(DUAL_X_CARRIAGE) - extern bool extruder_duplication_enabled; -#endif - -//=========================================================================== -//================================ functions ================================ -//=========================================================================== - -// Get the next / previous index of the next block in the ring buffer -// NOTE: Using & here (not %) because BLOCK_BUFFER_SIZE is always a power of 2 -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); } - -// Calculates 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) { - if (acceleration == 0) return 0; // acceleration was 0, set acceleration distance to 0 - return (target_rate * target_rate - initial_rate * initial_rate) / (acceleration * 2); +Planner::Planner() { + #if ENABLED(AUTO_BED_LEVELING_FEATURE) + bed_level_matrix.set_to_identity(); + #endif + init(); } -// This function gives you the point at which you must start braking (at the rate of -acceleration) if -// you started at speed initial_rate and accelerated until this point and want to end at the final_rate after -// a total travel of distance. This can be used to compute the intersection point between acceleration and -// deceleration in the 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) { - 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); +void Planner::init() { + block_buffer_head = block_buffer_tail = 0; + memset(position, 0, sizeof(position)); // clear position + for (int i = 0; i < NUM_AXIS; i++) previous_speed[i] = 0.0; + previous_nominal_speed = 0.0; } -// Calculates trapezoid parameters so that the entry- and exit-speed is compensated by the provided factors. - -void calculate_trapezoid_for_block(block_t* block, float entry_factor, float exit_factor) { +/** + * Calculate trapezoid parameters, multiplying the entry- and exit-speeds + * by the provided factors. + */ +void Planner::calculate_trapezoid_for_block(block_t* block, float entry_factor, float exit_factor) { unsigned long initial_rate = ceil(block->nominal_rate * entry_factor), final_rate = ceil(block->nominal_rate * exit_factor); // (steps per second) @@ -225,12 +147,6 @@ void calculate_trapezoid_for_block(block_t* block, float entry_factor, float exi CRITICAL_SECTION_END; } -// Calculates the maximum allowable speed at this point when you must be able to reach target_velocity using the -// acceleration within the allotted distance. -FORCE_INLINE float max_allowable_speed(float acceleration, float target_velocity, float distance) { - return sqrt(target_velocity * target_velocity - 2 * acceleration * distance); -} - // "Junction jerk" in this context is the immediate change in speed at the junction of two blocks. // This method will calculate the junction jerk as the euclidean distance between the nominal // velocities of the respective blocks. @@ -240,8 +156,8 @@ FORCE_INLINE float max_allowable_speed(float acceleration, float target_velocity //} -// The kernel called by planner_recalculate() when scanning the plan from last to first entry. -void planner_reverse_pass_kernel(block_t* previous, block_t* current, block_t* next) { +// The kernel called by recalculate() when scanning the plan from last to first entry. +void Planner::reverse_pass_kernel(block_t* previous, block_t* current, block_t* next) { if (!current) return; UNUSED(previous); @@ -267,31 +183,34 @@ void planner_reverse_pass_kernel(block_t* previous, block_t* current, block_t* n } // Skip last block. Already initialized and set for recalculation. } -// planner_recalculate() needs to go over the current plan twice. Once in reverse and once forward. This -// implements the reverse pass. -void planner_reverse_pass() { - uint8_t block_index = block_buffer_head; +/** + * recalculate() needs to go over the current plan twice. + * Once in reverse and once forward. This implements the reverse pass. + */ +void Planner::reverse_pass() { - //Make a local copy of block_buffer_tail, because the interrupt can alter it - CRITICAL_SECTION_START; - unsigned char tail = block_buffer_tail; - CRITICAL_SECTION_END + if (movesplanned() > 3) { - if (BLOCK_MOD(block_buffer_head - tail + BLOCK_BUFFER_SIZE) > 3) { // moves queued - block_index = BLOCK_MOD(block_buffer_head - 3); block_t* block[3] = { NULL, NULL, NULL }; - while (block_index != tail) { - block_index = prev_block_index(block_index); + + // Make a local copy of block_buffer_tail, because the interrupt can alter it + CRITICAL_SECTION_START; + uint8_t tail = block_buffer_tail; + CRITICAL_SECTION_END + + uint8_t b = BLOCK_MOD(block_buffer_head - 3); + while (b != tail) { + b = prev_block_index(b); block[2] = block[1]; block[1] = block[0]; - block[0] = &block_buffer[block_index]; - planner_reverse_pass_kernel(block[0], block[1], block[2]); + block[0] = &block_buffer[b]; + reverse_pass_kernel(block[0], block[1], block[2]); } } } -// The kernel called by planner_recalculate() when scanning the plan from first to last entry. -void planner_forward_pass_kernel(block_t* previous, block_t* current, block_t* next) { +// The kernel called by recalculate() when scanning the plan from first to last entry. +void Planner::forward_pass_kernel(block_t* previous, block_t* current, block_t* next) { if (!previous) return; UNUSED(next); @@ -312,26 +231,28 @@ void planner_forward_pass_kernel(block_t* previous, block_t* current, block_t* n } } -// planner_recalculate() needs to go over the current plan twice. Once in reverse and once forward. This -// implements the forward pass. -void planner_forward_pass() { - uint8_t block_index = block_buffer_tail; +/** + * recalculate() needs to go over the current plan twice. + * Once in reverse and once forward. This implements the forward pass. + */ +void Planner::forward_pass() { block_t* block[3] = { NULL, NULL, NULL }; - while (block_index != block_buffer_head) { + for (uint8_t b = block_buffer_tail; b != block_buffer_head; b = next_block_index(b)) { block[0] = block[1]; block[1] = block[2]; - block[2] = &block_buffer[block_index]; - planner_forward_pass_kernel(block[0], block[1], block[2]); - block_index = next_block_index(block_index); + block[2] = &block_buffer[b]; + forward_pass_kernel(block[0], block[1], block[2]); } - planner_forward_pass_kernel(block[1], block[2], NULL); + forward_pass_kernel(block[1], block[2], NULL); } -// Recalculates the trapezoid speed profiles for all blocks in the plan according to the -// entry_factor for each junction. Must be called by planner_recalculate() after -// updating the blocks. -void planner_recalculate_trapezoids() { +/** + * Recalculate the trapezoid speed profiles for all blocks in the plan + * according to the entry_factor for each junction. Must be called by + * recalculate() after updating the blocks. + */ +void Planner::recalculate_trapezoids() { int8_t block_index = block_buffer_tail; block_t* current; block_t* next = NULL; @@ -358,54 +279,52 @@ void planner_recalculate_trapezoids() { } } -// Recalculates the motion plan according to the following algorithm: -// -// 1. Go over every block in reverse order and calculate a junction speed reduction (i.e. block_t.entry_factor) -// so that: -// a. The junction jerk is within the set limit -// b. No speed reduction within one block requires faster deceleration than the one, true constant -// acceleration. -// 2. Go over every block in chronological order and dial down junction speed reduction values if -// a. The speed increase within one block would require faster acceleration than the one, true -// constant acceleration. -// -// When these stages are complete all blocks have an entry_factor that will allow all speed changes to -// be performed using only the one, true constant acceleration, and where no junction jerk is jerkier than -// the set limit. Finally it will: -// -// 3. Recalculate trapezoids for all blocks. - -void planner_recalculate() { - planner_reverse_pass(); - planner_forward_pass(); - planner_recalculate_trapezoids(); -} - -void plan_init() { - block_buffer_head = block_buffer_tail = 0; - memset(position, 0, sizeof(position)); // clear position - for (int i = 0; i < NUM_AXIS; i++) previous_speed[i] = 0.0; - previous_nominal_speed = 0.0; +/* + * Recalculate the motion plan according to the following algorithm: + * + * 1. Go over every block in reverse order... + * + * Calculate a junction speed reduction (block_t.entry_factor) so: + * + * a. The junction jerk is within the set limit, and + * + * b. No speed reduction within one block requires faster + * deceleration than the one, true constant acceleration. + * + * 2. Go over every block in chronological order... + * + * Dial down junction speed reduction values if: + * a. The speed increase within one block would require faster + * acceleration than the one, true constant acceleration. + * + * After that, all blocks will have an entry_factor allowing all speed changes to + * be performed using only the one, true constant acceleration, and where no junction + * jerk is jerkier than the set limit, Jerky. Finally it will: + * + * 3. Recalculate "trapezoids" for all blocks. + */ +void Planner::recalculate() { + reverse_pass(); + forward_pass(); + recalculate_trapezoids(); } #if ENABLED(AUTOTEMP) - void getHighESpeed() { + + void Planner::getHighESpeed() { static float oldt = 0; if (!autotemp_enabled) return; if (degTargetHotend0() + 2 < autotemp_min) return; // probably temperature set to zero. float high = 0.0; - uint8_t block_index = block_buffer_tail; - - while (block_index != block_buffer_head) { - block_t* block = &block_buffer[block_index]; + for (uint8_t b = block_buffer_tail; b != block_buffer_head; b = next_block_index(b)) { + block_t* block = &block_buffer[b]; if (block->steps[X_AXIS] || block->steps[Y_AXIS] || block->steps[Z_AXIS]) { float se = (float)block->steps[E_AXIS] / block->step_event_count * block->nominal_speed; // mm/sec; NOLESS(high, se); } - block_index = next_block_index(block_index); } float t = autotemp_min + high * autotemp_factor; @@ -417,9 +336,13 @@ void plan_init() { oldt = t; setTargetHotend0(t); } + #endif //AUTOTEMP -void check_axes_activity() { +/** + * Maintain fans, paste extruder pressure, + */ +void Planner::check_axes_activity() { unsigned char axis_active[NUM_AXIS] = { 0 }, tail_fan_speed[FAN_COUNT]; @@ -432,26 +355,23 @@ void check_axes_activity() { tail_e_to_p_pressure = baricuda_e_to_p_pressure; #endif - block_t* block; - if (blocks_queued()) { - uint8_t block_index = block_buffer_tail; - #if FAN_COUNT > 0 - for (uint8_t i = 0; i < FAN_COUNT; i++) tail_fan_speed[i] = block_buffer[block_index].fan_speed[i]; + for (uint8_t i = 0; i < FAN_COUNT; i++) tail_fan_speed[i] = block_buffer[block_buffer_tail].fan_speed[i]; #endif + block_t* block; + #if ENABLED(BARICUDA) - block = &block_buffer[block_index]; + block = &block_buffer[block_buffer_tail]; tail_valve_pressure = block->valve_pressure; tail_e_to_p_pressure = block->e_to_p_pressure; #endif - while (block_index != block_buffer_head) { - block = &block_buffer[block_index]; + for (uint8_t b = block_buffer_tail; b != block_buffer_head; b = next_block_index(b)) { + block = &block_buffer[b]; for (int i = 0; i < NUM_AXIS; i++) if (block->steps[i]) axis_active[i]++; - block_index = next_block_index(block_index); } } #if ENABLED(DISABLE_X) @@ -549,15 +469,20 @@ void check_axes_activity() { #endif } +/** + * Planner::buffer_line + * + * Add a new linear movement to the buffer. + * + * x,y,z,e - target position in mm + * feed_rate - (target) speed of the move + * extruder - target extruder + */ -float junction_deviation = 0.1; -// Add a new linear movement to the buffer. steps[X_AXIS], _y and _z is the absolute position in -// mm. Microseconds specify how many microseconds the move should take to perform. To aid acceleration -// calculation the caller must also provide the physical length of the line in millimeters. #if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING) - void plan_buffer_line(float x, float y, float z, const float& e, float feed_rate, const uint8_t extruder) + void Planner::buffer_line(float x, float y, float z, const float& e, float feed_rate, const uint8_t extruder) #else - void plan_buffer_line(const float& x, const float& y, const float& z, const float& e, float feed_rate, const uint8_t extruder) + void Planner::buffer_line(const float& x, const float& y, const float& z, const float& e, float feed_rate, const uint8_t extruder) #endif // AUTO_BED_LEVELING_FEATURE { // Calculate the buffer head after we push this byte @@ -570,7 +495,7 @@ float junction_deviation = 0.1; #if ENABLED(MESH_BED_LEVELING) if (mbl.active) z += mbl.get_z(x - home_offset[X_AXIS], y - home_offset[Y_AXIS]); #elif ENABLED(AUTO_BED_LEVELING_FEATURE) - apply_rotation_xyz(plan_bed_level_matrix, x, y, z); + apply_rotation_xyz(bed_level_matrix, x, y, z); #endif // The target position of the tool in absolute steps @@ -703,7 +628,8 @@ float junction_deviation = 0.1; // Enable extruder(s) if (block->steps[E_AXIS]) { - if (DISABLE_INACTIVE_EXTRUDER) { //enable only selected extruder + + #if ENABLED(DISABLE_INACTIVE_EXTRUDER) // Enable only the selected extruder for (int i = 0; i < EXTRUDERS; i++) if (g_uc_extruder_last_move[i] > 0) g_uc_extruder_last_move[i]--; @@ -762,19 +688,18 @@ float junction_deviation = 0.1; #endif // EXTRUDERS > 2 #endif // EXTRUDERS > 1 } - } - else { // enable all + #else enable_e0(); enable_e1(); enable_e2(); enable_e3(); - } + #endif } if (block->steps[E_AXIS]) - NOLESS(feed_rate, minimumfeedrate); + NOLESS(feed_rate, min_feedrate); else - NOLESS(feed_rate, mintravelfeedrate); + NOLESS(feed_rate, min_travel_feedrate); /** * This part of the code calculates the total length of the movement. @@ -837,9 +762,9 @@ float junction_deviation = 0.1; // segment time im micro seconds unsigned long segment_time = lround(1000000.0/inverse_second); if (mq) { - if (segment_time < minsegmenttime) { + 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_second = 1000000.0 / (segment_time + lround(2 * (minsegmenttime - segment_time) / moves_queued)); + inverse_second = 1000000.0 / (segment_time + lround(2 * (min_segment_time - segment_time) / moves_queued)); #ifdef XY_FREQUENCY_LIMIT segment_time = lround(1000000.0 / inverse_second); #endif @@ -968,6 +893,9 @@ float junction_deviation = 0.1; block->acceleration_rate = (long)(acc_st * 16777216.0 / (F_CPU / 8.0)); #if 0 // Use old jerk for now + + float junction_deviation = 0.1; + // Compute path unit vector double unit_vec[3]; @@ -1083,11 +1011,11 @@ float junction_deviation = 0.1; // Update position for (int i = 0; i < NUM_AXIS; i++) position[i] = target[i]; - planner_recalculate(); + recalculate(); - st_wake_up(); + stepper.wake_up(); -} // plan_buffer_line() +} // buffer_line() #if ENABLED(AUTO_BED_LEVELING_FEATURE) && DISABLED(DELTA) @@ -1096,13 +1024,15 @@ float junction_deviation = 0.1; * * On CORE machines XYZ is derived from ABC. */ - vector_3 plan_get_position() { - vector_3 position = vector_3(st_get_axis_position_mm(X_AXIS), st_get_axis_position_mm(Y_AXIS), st_get_axis_position_mm(Z_AXIS)); + vector_3 Planner::adjusted_position() { + vector_3 position = vector_3(stepper.get_axis_position_mm(X_AXIS), stepper.get_axis_position_mm(Y_AXIS), stepper.get_axis_position_mm(Z_AXIS)); + + //position.debug("in Planner::position"); + //bed_level_matrix.debug("in Planner::position"); + + matrix_3x3 inverse = matrix_3x3::transpose(bed_level_matrix); + //inverse.debug("in Planner::inverse"); - //position.debug("in plan_get position"); - //plan_bed_level_matrix.debug("in plan_get_position"); - matrix_3x3 inverse = matrix_3x3::transpose(plan_bed_level_matrix); - //inverse.debug("in plan_get inverse"); position.apply_rotation(inverse); //position.debug("after rotation"); @@ -1117,34 +1047,48 @@ float junction_deviation = 0.1; * On CORE machines stepper ABC will be translated from the given XYZ. */ #if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING) - void plan_set_position(float x, float y, float z, const float& e) + void Planner::set_position(float x, float y, float z, const float& e) #else - void plan_set_position(const float& x, const float& y, const float& z, const float& e) + void Planner::set_position(const float& x, const float& y, const float& z, const float& e) #endif // AUTO_BED_LEVELING_FEATURE || MESH_BED_LEVELING { #if ENABLED(MESH_BED_LEVELING) if (mbl.active) z += mbl.get_z(x - home_offset[X_AXIS], y - home_offset[Y_AXIS]); #elif ENABLED(AUTO_BED_LEVELING_FEATURE) - apply_rotation_xyz(plan_bed_level_matrix, x, y, z); + apply_rotation_xyz(bed_level_matrix, x, y, z); #endif long nx = position[X_AXIS] = lround(x * axis_steps_per_unit[X_AXIS]), ny = position[Y_AXIS] = lround(y * axis_steps_per_unit[Y_AXIS]), nz = position[Z_AXIS] = lround(z * axis_steps_per_unit[Z_AXIS]), ne = position[E_AXIS] = lround(e * axis_steps_per_unit[E_AXIS]); - st_set_position(nx, ny, nz, ne); + stepper.set_position(nx, ny, nz, ne); previous_nominal_speed = 0.0; // Resets planner junction speeds. Assumes start from rest. for (int i = 0; i < NUM_AXIS; i++) previous_speed[i] = 0.0; } -void plan_set_e_position(const float& e) { +/** + * Directly set the planner E position (hence the stepper E position). + */ +void Planner::set_e_position(const float& e) { position[E_AXIS] = lround(e * axis_steps_per_unit[E_AXIS]); - st_set_e_position(position[E_AXIS]); + stepper.set_e_position(position[E_AXIS]); } -// Calculate the steps/s^2 acceleration rates, based on the mm/s^s -void reset_acceleration_rates() { +// Recalculate the steps/s^2 acceleration rates, based on the mm/s^2 +void Planner::reset_acceleration_rates() { for (int i = 0; i < NUM_AXIS; i++) axis_steps_per_sqr_second[i] = max_acceleration_units_per_sq_second[i] * axis_steps_per_unit[i]; } + +#if ENABLED(AUTOTEMP) + + void Planner::autotemp_M109() { + autotemp_enabled = code_seen('F'); + if (autotemp_enabled) autotemp_factor = code_value(); + if (code_seen('S')) autotemp_min = code_value(); + if (code_seen('B')) autotemp_max = code_value(); + } + +#endif diff --git a/Marlin/planner.h b/Marlin/planner.h index dd724424b..f4e126c0b 100644 --- a/Marlin/planner.h +++ b/Marlin/planner.h @@ -48,17 +48,36 @@ #include "Marlin.h" -// This struct is used when buffering the setup for each linear movement "nominal" values are as specified in -// the source g-code and may never actually be reached if acceleration management is active. +#if ENABLED(AUTO_BED_LEVELING_FEATURE) + #include "vector_3.h" +#endif + +class Planner; +extern Planner planner; + +/** + * struct block_t + * + * A single entry in the planner buffer. + * Tracks linear movement over multiple axes. + * + * The "nominal" values are as-specified by gcode, and + * may never actually be reached due to acceleration limits. + */ typedef struct { + + unsigned char active_extruder; // The extruder to move (if E move) + // Fields used by the bresenham algorithm for tracing the line long steps[NUM_AXIS]; // Step count along each axis unsigned long step_event_count; // The number of step events required to complete this block + long accelerate_until; // The index of the step event on which to stop acceleration long decelerate_after; // The index of the step event on which to start decelerating long acceleration_rate; // The acceleration rate used for acceleration calculation + unsigned char direction_bits; // The direction bit set for this block (refers to *_DIRECTION_BIT in config.h) - unsigned char active_extruder; // Selects the active extruder + #if ENABLED(ADVANCE) long advance_rate; volatile long initial_advance; @@ -67,7 +86,6 @@ typedef struct { #endif // Fields used by the motion planner to manage acceleration - // float speed_x, speed_y, speed_z, speed_e; // Nominal mm/sec for each axis float nominal_speed; // The nominal speed for this block in mm/sec float entry_speed; // Entry speed at previous-current junction in mm/sec float max_entry_speed; // Maximum allowable junction entry speed in mm/sec @@ -97,102 +115,220 @@ typedef struct { #define BLOCK_MOD(n) ((n)&(BLOCK_BUFFER_SIZE-1)) -// Initialize the motion plan subsystem -void plan_init(); +class Planner { -void check_axes_activity(); - -// Get the number of buffered moves -extern volatile unsigned char block_buffer_head; -extern volatile unsigned char block_buffer_tail; -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) - - #if ENABLED(AUTO_BED_LEVELING_FEATURE) - #include "vector_3.h" - - // Transform required to compensate for bed level - extern matrix_3x3 plan_bed_level_matrix; + public: /** - * Get the position applying the bed level matrix + * A ring buffer of moves described in steps */ - vector_3 plan_get_position(); - #endif // AUTO_BED_LEVELING_FEATURE + 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; - /** - * Add a new linear movement to the buffer. x, y, z are the signed, absolute target position in - * millimeters. Feed rate specifies the (target) speed of the motion. - */ - void plan_buffer_line(float x, float y, float z, const float& e, float feed_rate, const uint8_t extruder); + 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 - /** - * Set the planner positions. Used for G92 instructions. - * Multiplies by axis_steps_per_unit[] to set stepper positions. - * Clears previous speed values. - */ - void plan_set_position(float x, float y, float z, const float& e); + 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; -#else + #if ENABLED(AUTO_BED_LEVELING_FEATURE) + matrix_3x3 bed_level_matrix; // Transform to compensate for bed level + #endif - void plan_buffer_line(const float& x, const float& y, const float& z, const float& e, float feed_rate, const uint8_t extruder); - void plan_set_position(const float& x, const float& y, const float& z, const float& e); + private: -#endif // AUTO_BED_LEVELING_FEATURE || MESH_BED_LEVELING + /** + * 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 }; -void plan_set_e_position(const float& e); + /** + * Speed of previous path line segment + */ + float previous_speed[NUM_AXIS]; -//=========================================================================== -//============================= public variables ============================ -//=========================================================================== + /** + * Nominal speed of previous path line segment + */ + float previous_nominal_speed; -extern millis_t minsegmenttime; -extern float max_feedrate[NUM_AXIS]; // Max speeds in mm per minute -extern float axis_steps_per_unit[NUM_AXIS]; -extern unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software -extern float minimumfeedrate; -extern float acceleration; // Normal acceleration mm/s^2 DEFAULT ACCELERATION for all printing moves. M204 SXXXX -extern float retract_acceleration; // Retract acceleration mm/s^2 filament pull-back and push-forward while standing still in the other axes M204 TXXXX -extern float travel_acceleration; // Travel acceleration mm/s^2 DEFAULT ACCELERATION for all NON printing moves. M204 MXXXX -extern float max_xy_jerk; // The largest speed change requiring no acceleration -extern float max_z_jerk; -extern float max_e_jerk; -extern float mintravelfeedrate; -extern unsigned long axis_steps_per_sqr_second[NUM_AXIS]; + #if ENABLED(DISABLE_INACTIVE_EXTRUDER) + /** + * Counters to manage disabling inactive extruders + */ + uint8_t g_uc_extruder_last_move[EXTRUDERS] = { 0 }; + #endif // DISABLE_INACTIVE_EXTRUDER -#if ENABLED(AUTOTEMP) - extern bool autotemp_enabled; - extern float autotemp_max; - extern float autotemp_min; - extern float autotemp_factor; -#endif + #ifdef XY_FREQUENCY_LIMIT + // Used for the frequency limit + #define MAX_FREQ_TIME (1000000.0/XY_FREQUENCY_LIMIT) + // Old direction bits. Used for speed calculations + static unsigned char old_direction_bits = 0; + // 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} }; + #endif -extern block_t block_buffer[BLOCK_BUFFER_SIZE]; // A ring buffer for motion instructions -extern volatile unsigned char block_buffer_head; // Index of the next block to be pushed -extern volatile unsigned char block_buffer_tail; + #if ENABLED(DUAL_X_CARRIAGE) + extern bool extruder_duplication_enabled; + #endif -// Returns true if the buffer has a queued block, false otherwise -FORCE_INLINE bool blocks_queued() { return (block_buffer_head != block_buffer_tail); } + public: -// Called when the current block is no longer needed. Discards -// the block and makes the memory available for new blocks. -FORCE_INLINE void plan_discard_current_block() { - if (blocks_queued()) - block_buffer_tail = BLOCK_MOD(block_buffer_tail + 1); -} + Planner(); -// Gets the current block. Returns NULL if buffer empty -FORCE_INLINE block_t* plan_get_current_block() { - if (blocks_queued()) { - block_t* block = &block_buffer[block_buffer_tail]; - block->busy = true; - return block; - } - else - return NULL; -} + void init(); -void reset_acceleration_rates(); + void reset_acceleration_rates(); + + // Manage fans, paste pressure, etc. + 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); } + + #if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING) + + #if ENABLED(AUTO_BED_LEVELING_FEATURE) + /** + * The corrected position, applying the bed level matrix + */ + vector_3 adjusted_position(); + #endif + + /** + * Add a new linear movement to the buffer. + * + * x,y,z,e - target position in mm + * 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); + + /** + * Set the planner.position and individual stepper positions. + * Used by G92, G28, G29, and other procedures. + * + * Multiplies by axis_steps_per_unit[] and does necessary conversion + * for COREXY / COREXZ to set the corresponding stepper positions. + * + * Clears previous speed values. + */ + 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); + + #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); + + /** + * Does the buffer have any blocks queued? + */ + 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() { + if (blocks_queued()) + block_buffer_tail = BLOCK_MOD(block_buffer_tail + 1); + } + + /** + * The current block. NULL if the buffer is empty. + * This also marks the block as busy. + */ + FORCE_INLINE block_t* get_current_block() { + if (blocks_queued()) { + block_t* block = &block_buffer[block_buffer_tail]; + block->busy = true; + return block; + } + else + return NULL; + } + + /** + * 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); } + + /** + * 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) { + if (acceleration == 0) return 0; // acceleration was 0, set acceleration distance to 0 + return (target_rate * target_rate - initial_rate * initial_rate) / (acceleration * 2); + } + + /** + * Return the point at which you must start braking (at the rate of -'acceleration') if + * you start at 'initial_rate', accelerate (until reaching the point), and want to end at + * 'final_rate' after traveling 'distance'. + * + * 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) { + 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); + } + + /** + * Calculate the maximum allowable speed at this point, in order + * to reach 'target_velocity' using 'acceleration' within a given + * 'distance'. + */ + FORCE_INLINE float max_allowable_speed(float acceleration, float target_velocity, float distance) { + return sqrt(target_velocity * target_velocity - 2 * acceleration * distance); + } + + + #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(); + #endif + + private: + + 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); + + void reverse_pass(); + void forward_pass(); + + void recalculate_trapezoids(); + + void recalculate(); + +}; #endif // PLANNER_H diff --git a/Marlin/stepper.cpp b/Marlin/stepper.cpp index 4b52edac9..e28280137 100644 --- a/Marlin/stepper.cpp +++ b/Marlin/stepper.cpp @@ -21,7 +21,7 @@ */ /** - * stepper.cpp - stepper motor driver: executes motion plans using stepper motors + * stepper.cpp - A singleton object to execute motion plans using stepper motors * Marlin Firmware * * Derived from Grbl @@ -46,6 +46,7 @@ #include "Marlin.h" #include "stepper.h" +#include "endstops.h" #include "planner.h" #include "temperature.h" #include "ultralcd.h" @@ -57,85 +58,7 @@ #include #endif -//=========================================================================== -//============================= public variables ============================ -//=========================================================================== -block_t* current_block; // A pointer to the block currently being traced - -#if ENABLED(HAS_Z_MIN_PROBE) - volatile bool z_probe_is_active = false; -#endif - -//=========================================================================== -//============================= private variables =========================== -//=========================================================================== -//static makes it impossible to be called from outside of this file by extern.! - -// Variables used by The Stepper Driver Interrupt -static unsigned char out_bits = 0; // The next stepping-bits to be output -static unsigned int cleaning_buffer_counter; - -#if ENABLED(Z_DUAL_ENDSTOPS) - static bool performing_homing = false, - locked_z_motor = false, - locked_z2_motor = false; -#endif - -// Counter variables for the Bresenham line tracer -static long counter_x, counter_y, counter_z, counter_e; -volatile static unsigned long step_events_completed; // The number of step events executed in the current block - -#if ENABLED(ADVANCE) - static long advance_rate, advance, final_advance = 0; - static long old_advance = 0; - static long e_steps[4]; -#endif - -static long acceleration_time, deceleration_time; -//static unsigned long accelerate_until, decelerate_after, acceleration_rate, initial_rate, final_rate, nominal_rate; -static unsigned short acc_step_rate; // needed for deceleration start point -static uint8_t step_loops; -static uint8_t step_loops_nominal; -static unsigned short OCR1A_nominal; - -volatile long endstops_trigsteps[3] = { 0 }; -volatile long endstops_stepsTotal, endstops_stepsDone; -static volatile char endstop_hit_bits = 0; // use X_MIN, Y_MIN, Z_MIN and Z_MIN_PROBE as BIT value - -#if DISABLED(Z_DUAL_ENDSTOPS) - static byte -#else - static uint16_t -#endif - old_endstop_bits = 0; // use X_MIN, X_MAX... Z_MAX, Z_MIN_PROBE, Z2_MIN, Z2_MAX - -#if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) - bool abort_on_endstop_hit = false; -#endif - -#if HAS_MOTOR_CURRENT_PWM - #ifndef PWM_MOTOR_CURRENT - #define PWM_MOTOR_CURRENT DEFAULT_PWM_MOTOR_CURRENT - #endif - const int motor_current_setting[3] = PWM_MOTOR_CURRENT; -#endif - -static bool check_endstops = true; -static bool check_endstops_global = - #if ENABLED(ENDSTOPS_ONLY_FOR_HOMING) - false - #else - true - #endif -; - -volatile long count_position[NUM_AXIS] = { 0 }; // Positions of stepper motors, in step units -volatile signed char count_direction[NUM_AXIS] = { 1 }; - - -//=========================================================================== -//================================ functions ================================ -//=========================================================================== +Stepper stepper; // Singleton #if ENABLED(DUAL_X_CARRIAGE) #define X_APPLY_DIR(v,ALWAYS) \ @@ -173,12 +96,12 @@ volatile signed char count_direction[NUM_AXIS] = { 1 }; #define Z_APPLY_STEP(v,Q) \ if (performing_homing) { \ if (Z_HOME_DIR > 0) {\ - if (!(TEST(old_endstop_bits, Z_MAX) && (count_direction[Z_AXIS] > 0)) && !locked_z_motor) Z_STEP_WRITE(v); \ - if (!(TEST(old_endstop_bits, Z2_MAX) && (count_direction[Z_AXIS] > 0)) && !locked_z2_motor) Z2_STEP_WRITE(v); \ + if (!(TEST(endstops.old_endstop_bits, Z_MAX) && (count_direction[Z_AXIS] > 0)) && !locked_z_motor) Z_STEP_WRITE(v); \ + if (!(TEST(endstops.old_endstop_bits, Z2_MAX) && (count_direction[Z_AXIS] > 0)) && !locked_z2_motor) Z2_STEP_WRITE(v); \ } \ else { \ - if (!(TEST(old_endstop_bits, Z_MIN) && (count_direction[Z_AXIS] < 0)) && !locked_z_motor) Z_STEP_WRITE(v); \ - if (!(TEST(old_endstop_bits, Z2_MIN) && (count_direction[Z_AXIS] < 0)) && !locked_z2_motor) Z2_STEP_WRITE(v); \ + if (!(TEST(endstops.old_endstop_bits, Z_MIN) && (count_direction[Z_AXIS] < 0)) && !locked_z_motor) Z_STEP_WRITE(v); \ + if (!(TEST(endstops.old_endstop_bits, Z2_MIN) && (count_direction[Z_AXIS] < 0)) && !locked_z2_motor) Z2_STEP_WRITE(v); \ } \ } \ else { \ @@ -195,31 +118,6 @@ volatile signed char count_direction[NUM_AXIS] = { 1 }; #define E_APPLY_STEP(v,Q) E_STEP_WRITE(v) -// intRes = intIn1 * intIn2 >> 16 -// uses: -// r26 to store 0 -// r27 to store the byte 1 of the 24 bit result -#define MultiU16X8toH16(intRes, charIn1, intIn2) \ - asm volatile ( \ - "clr r26 \n\t" \ - "mul %A1, %B2 \n\t" \ - "movw %A0, r0 \n\t" \ - "mul %A1, %A2 \n\t" \ - "add %A0, r1 \n\t" \ - "adc %B0, r26 \n\t" \ - "lsr r0 \n\t" \ - "adc %A0, r26 \n\t" \ - "adc %B0, r26 \n\t" \ - "clr r1 \n\t" \ - : \ - "=&r" (intRes) \ - : \ - "d" (charIn1), \ - "d" (intIn2) \ - : \ - "r26" \ - ) - // intRes = longIn1 * longIn2 >> 24 // uses: // r26 to store 0 @@ -281,312 +179,38 @@ volatile signed char count_direction[NUM_AXIS] = { 1 }; #define ENABLE_STEPPER_DRIVER_INTERRUPT() SBI(TIMSK1, OCIE1A) #define DISABLE_STEPPER_DRIVER_INTERRUPT() CBI(TIMSK1, OCIE1A) -void enable_endstops(bool check) { check_endstops = check; } - -void enable_endstops_globally(bool check) { check_endstops_global = check_endstops = check; } - -void endstops_not_homing() { check_endstops = check_endstops_global; } - -void endstops_hit_on_purpose() { endstop_hit_bits = 0; } - -void checkHitEndstops() { - if (endstop_hit_bits) { - #if ENABLED(ULTRA_LCD) - char chrX = ' ', chrY = ' ', chrZ = ' ', chrP = ' '; - #define _SET_STOP_CHAR(A,C) (chr## A = C) - #else - #define _SET_STOP_CHAR(A,C) ; - #endif - - #define _ENDSTOP_HIT_ECHO(A,C) do{ \ - SERIAL_ECHOPAIR(" " STRINGIFY(A) ":", endstops_trigsteps[A ##_AXIS] / axis_steps_per_unit[A ##_AXIS]); \ - _SET_STOP_CHAR(A,C); }while(0) - - #define _ENDSTOP_HIT_TEST(A,C) \ - if (TEST(endstop_hit_bits, A ##_MIN) || TEST(endstop_hit_bits, A ##_MAX)) \ - _ENDSTOP_HIT_ECHO(A,C) - - SERIAL_ECHO_START; - SERIAL_ECHOPGM(MSG_ENDSTOPS_HIT); - _ENDSTOP_HIT_TEST(X, 'X'); - _ENDSTOP_HIT_TEST(Y, 'Y'); - _ENDSTOP_HIT_TEST(Z, 'Z'); - - #if ENABLED(Z_MIN_PROBE_ENDSTOP) - #define P_AXIS Z_AXIS - if (TEST(endstop_hit_bits, Z_MIN_PROBE)) _ENDSTOP_HIT_ECHO(P, 'P'); - #endif - SERIAL_EOL; - - #if ENABLED(ULTRA_LCD) - char msg[3 * strlen(MSG_LCD_ENDSTOPS) + 8 + 1]; // Room for a UTF 8 string - sprintf_P(msg, PSTR(MSG_LCD_ENDSTOPS " %c %c %c %c"), chrX, chrY, chrZ, chrP); - lcd_setstatus(msg); - #endif - - endstops_hit_on_purpose(); - - #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) && ENABLED(SDSUPPORT) - if (abort_on_endstop_hit) { - card.sdprinting = false; - card.closefile(); - quickStop(); - disable_all_heaters(); // switch off all heaters. - } - #endif - } -} - -// Check endstops - Called from ISR! -inline void update_endstops() { - - #if ENABLED(Z_DUAL_ENDSTOPS) - uint16_t - #else - byte - #endif - current_endstop_bits = 0; - - #define _ENDSTOP_PIN(AXIS, MINMAX) AXIS ##_## MINMAX ##_PIN - #define _ENDSTOP_INVERTING(AXIS, MINMAX) AXIS ##_## MINMAX ##_ENDSTOP_INVERTING - #define _AXIS(AXIS) AXIS ##_AXIS - #define _ENDSTOP_HIT(AXIS) SBI(endstop_hit_bits, _ENDSTOP(AXIS, MIN)) - #define _ENDSTOP(AXIS, MINMAX) AXIS ##_## MINMAX - - // SET_ENDSTOP_BIT: set the current endstop bits for an endstop to its status - #define SET_ENDSTOP_BIT(AXIS, MINMAX) SET_BIT(current_endstop_bits, _ENDSTOP(AXIS, MINMAX), (READ(_ENDSTOP_PIN(AXIS, MINMAX)) != _ENDSTOP_INVERTING(AXIS, MINMAX))) - // COPY_BIT: copy the value of COPY_BIT to BIT in bits - #define COPY_BIT(bits, COPY_BIT, BIT) SET_BIT(bits, BIT, TEST(bits, COPY_BIT)) - // TEST_ENDSTOP: test the old and the current status of an endstop - #define TEST_ENDSTOP(ENDSTOP) (TEST(current_endstop_bits, ENDSTOP) && TEST(old_endstop_bits, ENDSTOP)) - - #if ENABLED(COREXY) || ENABLED(COREXZ) - - #define _SET_TRIGSTEPS(AXIS) do { \ - float axis_pos = count_position[_AXIS(AXIS)]; \ - if (_AXIS(AXIS) == A_AXIS) \ - axis_pos = (axis_pos + count_position[CORE_AXIS_2]) / 2; \ - else if (_AXIS(AXIS) == CORE_AXIS_2) \ - axis_pos = (count_position[A_AXIS] - axis_pos) / 2; \ - endstops_trigsteps[_AXIS(AXIS)] = axis_pos; \ - } while(0) - - #else - - #define _SET_TRIGSTEPS(AXIS) endstops_trigsteps[_AXIS(AXIS)] = count_position[_AXIS(AXIS)] - - #endif // COREXY || COREXZ - - #define UPDATE_ENDSTOP(AXIS,MINMAX) do { \ - SET_ENDSTOP_BIT(AXIS, MINMAX); \ - if (TEST_ENDSTOP(_ENDSTOP(AXIS, MINMAX)) && current_block->steps[_AXIS(AXIS)] > 0) { \ - _SET_TRIGSTEPS(AXIS); \ - _ENDSTOP_HIT(AXIS); \ - step_events_completed = current_block->step_event_count; \ - } \ - } while(0) - - #if ENABLED(COREXY) || ENABLED(COREXZ) - // Head direction in -X axis for CoreXY and CoreXZ bots. - // If Delta1 == -Delta2, the movement is only in Y or Z axis - if ((current_block->steps[A_AXIS] != current_block->steps[CORE_AXIS_2]) || (TEST(out_bits, A_AXIS) == TEST(out_bits, CORE_AXIS_2))) { - if (TEST(out_bits, X_HEAD)) - #else - if (TEST(out_bits, X_AXIS)) // stepping along -X axis (regular Cartesian bot) - #endif - { // -direction - #if ENABLED(DUAL_X_CARRIAGE) - // with 2 x-carriages, endstops are only checked in the homing direction for the active extruder - if ((current_block->active_extruder == 0 && X_HOME_DIR == -1) || (current_block->active_extruder != 0 && X2_HOME_DIR == -1)) - #endif - { - #if HAS_X_MIN - UPDATE_ENDSTOP(X, MIN); - #endif - } - } - else { // +direction - #if ENABLED(DUAL_X_CARRIAGE) - // with 2 x-carriages, endstops are only checked in the homing direction for the active extruder - if ((current_block->active_extruder == 0 && X_HOME_DIR == 1) || (current_block->active_extruder != 0 && X2_HOME_DIR == 1)) - #endif - { - #if HAS_X_MAX - UPDATE_ENDSTOP(X, MAX); - #endif - } - } - #if ENABLED(COREXY) || ENABLED(COREXZ) - } - #endif - - #if ENABLED(COREXY) - // Head direction in -Y axis for CoreXY bots. - // If DeltaX == DeltaY, the movement is only in X axis - if ((current_block->steps[A_AXIS] != current_block->steps[B_AXIS]) || (TEST(out_bits, A_AXIS) != TEST(out_bits, B_AXIS))) { - if (TEST(out_bits, Y_HEAD)) - #else - if (TEST(out_bits, Y_AXIS)) // -direction - #endif - { // -direction - #if HAS_Y_MIN - UPDATE_ENDSTOP(Y, MIN); - #endif - } - else { // +direction - #if HAS_Y_MAX - UPDATE_ENDSTOP(Y, MAX); - #endif - } - #if ENABLED(COREXY) - } - #endif - - #if ENABLED(COREXZ) - // Head direction in -Z axis for CoreXZ bots. - // If DeltaX == DeltaZ, the movement is only in X axis - if ((current_block->steps[A_AXIS] != current_block->steps[C_AXIS]) || (TEST(out_bits, A_AXIS) != TEST(out_bits, C_AXIS))) { - if (TEST(out_bits, Z_HEAD)) - #else - if (TEST(out_bits, Z_AXIS)) - #endif - { // z -direction - #if HAS_Z_MIN - - #if ENABLED(Z_DUAL_ENDSTOPS) - SET_ENDSTOP_BIT(Z, MIN); - #if HAS_Z2_MIN - SET_ENDSTOP_BIT(Z2, MIN); - #else - COPY_BIT(current_endstop_bits, Z_MIN, Z2_MIN); - #endif - - byte z_test = TEST_ENDSTOP(Z_MIN) | (TEST_ENDSTOP(Z2_MIN) << 1); // bit 0 for Z, bit 1 for Z2 - - if (z_test && current_block->steps[Z_AXIS] > 0) { // z_test = Z_MIN || Z2_MIN - endstops_trigsteps[Z_AXIS] = count_position[Z_AXIS]; - SBI(endstop_hit_bits, Z_MIN); - if (!performing_homing || (z_test == 0x3)) //if not performing home or if both endstops were trigged during homing... - step_events_completed = current_block->step_event_count; - } - #else // !Z_DUAL_ENDSTOPS - - #if ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN) && ENABLED(HAS_Z_MIN_PROBE) - if (z_probe_is_active) UPDATE_ENDSTOP(Z, MIN); - #else - UPDATE_ENDSTOP(Z, MIN); - #endif - #endif // !Z_DUAL_ENDSTOPS - #endif - - #if ENABLED(Z_MIN_PROBE_ENDSTOP) && DISABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN) && ENABLED(HAS_Z_MIN_PROBE) - if (z_probe_is_active) { - UPDATE_ENDSTOP(Z, MIN_PROBE); - if (TEST_ENDSTOP(Z_MIN_PROBE)) SBI(endstop_hit_bits, Z_MIN_PROBE); - } - #endif - } - else { // z +direction - #if HAS_Z_MAX - - #if ENABLED(Z_DUAL_ENDSTOPS) - - SET_ENDSTOP_BIT(Z, MAX); - #if HAS_Z2_MAX - SET_ENDSTOP_BIT(Z2, MAX); - #else - COPY_BIT(current_endstop_bits, Z_MAX, Z2_MAX); - #endif - - byte z_test = TEST_ENDSTOP(Z_MAX) | (TEST_ENDSTOP(Z2_MAX) << 1); // bit 0 for Z, bit 1 for Z2 - - if (z_test && current_block->steps[Z_AXIS] > 0) { // t_test = Z_MAX || Z2_MAX - endstops_trigsteps[Z_AXIS] = count_position[Z_AXIS]; - SBI(endstop_hit_bits, Z_MIN); - if (!performing_homing || (z_test == 0x3)) //if not performing home or if both endstops were trigged during homing... - step_events_completed = current_block->step_event_count; - } - - #else // !Z_DUAL_ENDSTOPS - - UPDATE_ENDSTOP(Z, MAX); - - #endif // !Z_DUAL_ENDSTOPS - #endif // Z_MAX_PIN - } - #if ENABLED(COREXZ) - } - #endif - old_endstop_bits = current_endstop_bits; -} - -// __________________________ -// /| |\ _________________ ^ -// / | | \ /| |\ | -// / | | \ / | | \ s -// / | | | | | \ p -// / | | | | | \ e -// +-----+------------------------+---+--+---------------+----+ e -// | BLOCK 1 | BLOCK 2 | d -// -// time -----> -// -// The trapezoid is the shape the speed curve over time. It starts at block->initial_rate, accelerates -// first block->accelerate_until step_events_completed, then keeps going at constant speed until -// step_events_completed reaches block->decelerate_after after which it decelerates until the trapezoid generator is reset. -// The slope of acceleration is calculated using v = u + at where t is the accumulated timer values of the steps so far. - -void st_wake_up() { +/** + * __________________________ + * /| |\ _________________ ^ + * / | | \ /| |\ | + * / | | \ / | | \ s + * / | | | | | \ p + * / | | | | | \ e + * +-----+------------------------+---+--+---------------+----+ e + * | BLOCK 1 | BLOCK 2 | d + * + * time -----> + * + * The trapezoid is the shape the speed curve over time. It starts at block->initial_rate, accelerates + * first block->accelerate_until step_events_completed, then keeps going at constant speed until + * step_events_completed reaches block->decelerate_after after which it decelerates until the trapezoid generator is reset. + * The slope of acceleration is calculated using v = u + at where t is the accumulated timer values of the steps so far. + */ +void Stepper::wake_up() { // TCNT1 = 0; ENABLE_STEPPER_DRIVER_INTERRUPT(); } -FORCE_INLINE unsigned short calc_timer(unsigned short step_rate) { - unsigned short timer; - - NOMORE(step_rate, MAX_STEP_FREQUENCY); - - if (step_rate > 20000) { // If steprate > 20kHz >> step 4 times - step_rate = (step_rate >> 2) & 0x3fff; - step_loops = 4; - } - else if (step_rate > 10000) { // If steprate > 10kHz >> step 2 times - step_rate = (step_rate >> 1) & 0x7fff; - step_loops = 2; - } - else { - step_loops = 1; - } - - NOLESS(step_rate, F_CPU / 500000); - step_rate -= F_CPU / 500000; // Correct for minimal speed - if (step_rate >= (8 * 256)) { // higher step rate - unsigned short table_address = (unsigned short)&speed_lookuptable_fast[(unsigned char)(step_rate >> 8)][0]; - unsigned char tmp_step_rate = (step_rate & 0x00ff); - unsigned short gain = (unsigned short)pgm_read_word_near(table_address + 2); - MultiU16X8toH16(timer, tmp_step_rate, gain); - timer = (unsigned short)pgm_read_word_near(table_address) - timer; - } - else { // lower step rates - unsigned short table_address = (unsigned short)&speed_lookuptable_slow[0][0]; - table_address += ((step_rate) >> 1) & 0xfffc; - timer = (unsigned short)pgm_read_word_near(table_address); - timer -= (((unsigned short)pgm_read_word_near(table_address + 2) * (unsigned char)(step_rate & 0x0007)) >> 3); - } - if (timer < 100) { timer = 100; MYSERIAL.print(MSG_STEPPER_TOO_HIGH); MYSERIAL.println(step_rate); }//(20kHz this should never happen) - return timer; -} - /** * Set the stepper direction of each axis * * X_AXIS=A_AXIS and Y_AXIS=B_AXIS for COREXY * X_AXIS=A_AXIS and Z_AXIS=C_AXIS for COREXZ */ -void set_stepper_direction() { +void Stepper::set_directions() { #define SET_STEP_DIR(AXIS) \ - if (TEST(out_bits, AXIS ##_AXIS)) { \ + if (motor_direction(AXIS ##_AXIS)) { \ AXIS ##_APPLY_DIR(INVERT_## AXIS ##_DIR, false); \ count_direction[AXIS ##_AXIS] = -1; \ } \ @@ -600,7 +224,7 @@ void set_stepper_direction() { SET_STEP_DIR(Z); // C #if DISABLED(ADVANCE) - if (TEST(out_bits, E_AXIS)) { + if (motor_direction(E_AXIS)) { REV_E_DIR(); count_direction[E_AXIS] = -1; } @@ -611,52 +235,14 @@ void set_stepper_direction() { #endif //!ADVANCE } -// Initializes the trapezoid generator from the current block. Called whenever a new -// block begins. -FORCE_INLINE void trapezoid_generator_reset() { - - static int8_t last_extruder = -1; - - if (current_block->direction_bits != out_bits || current_block->active_extruder != last_extruder) { - out_bits = current_block->direction_bits; - last_extruder = current_block->active_extruder; - set_stepper_direction(); - } - - #if ENABLED(ADVANCE) - advance = current_block->initial_advance; - final_advance = current_block->final_advance; - // Do E steps + advance steps - e_steps[current_block->active_extruder] += ((advance >>8) - old_advance); - old_advance = advance >>8; - #endif - deceleration_time = 0; - // step_rate to timer interval - OCR1A_nominal = calc_timer(current_block->nominal_rate); - // make a note of the number of step loops required at nominal speed - step_loops_nominal = step_loops; - acc_step_rate = current_block->initial_rate; - acceleration_time = calc_timer(acc_step_rate); - OCR1A = acceleration_time; - - // SERIAL_ECHO_START; - // SERIAL_ECHOPGM("advance :"); - // SERIAL_ECHO(current_block->advance/256.0); - // SERIAL_ECHOPGM("advance rate :"); - // SERIAL_ECHO(current_block->advance_rate/256.0); - // SERIAL_ECHOPGM("initial advance :"); - // SERIAL_ECHO(current_block->initial_advance/256.0); - // SERIAL_ECHOPGM("final advance :"); - // SERIAL_ECHOLN(current_block->final_advance/256.0); -} - // "The Stepper Driver Interrupt" - This timer interrupt is the workhorse. // It pops blocks from the block_buffer and executes them by pulsing the stepper pins appropriately. -ISR(TIMER1_COMPA_vect) { +ISR(TIMER1_COMPA_vect) { stepper.isr(); } +void Stepper::isr() { if (cleaning_buffer_counter) { current_block = NULL; - plan_discard_current_block(); + planner.discard_current_block(); #ifdef SD_FINISHED_RELEASECOMMAND if ((cleaning_buffer_counter == 1) && (SD_FINISHED_STEPPERRELEASE)) enqueue_and_echo_commands_P(PSTR(SD_FINISHED_RELEASECOMMAND)); #endif @@ -668,12 +254,12 @@ ISR(TIMER1_COMPA_vect) { // If there is no current block, attempt to pop one from the buffer if (!current_block) { // Anything in the buffer? - current_block = plan_get_current_block(); + current_block = planner.get_current_block(); if (current_block) { current_block->busy = true; trapezoid_generator_reset(); - counter_x = -(current_block->step_event_count >> 1); - counter_y = counter_z = counter_e = counter_x; + counter_X = -(current_block->step_event_count >> 1); + counter_Y = counter_Z = counter_E = counter_X; step_events_completed = 0; #if ENABLED(Z_LATE_ENABLE) @@ -697,9 +283,9 @@ ISR(TIMER1_COMPA_vect) { // Update endstops state, if enabled #if ENABLED(HAS_Z_MIN_PROBE) - if (check_endstops || z_probe_is_active) update_endstops(); + if (endstops.enabled || endstops.z_probe_enabled) endstops.update(); #else - if (check_endstops) update_endstops(); + if (endstops.enabled) endstops.update(); #endif // Take multiple steps per interrupt (For high speed moves) @@ -709,48 +295,47 @@ ISR(TIMER1_COMPA_vect) { #endif #if ENABLED(ADVANCE) - counter_e += current_block->steps[E_AXIS]; - if (counter_e > 0) { - counter_e -= current_block->step_event_count; - e_steps[current_block->active_extruder] += TEST(out_bits, E_AXIS) ? -1 : 1; + counter_E += current_block->steps[E_AXIS]; + if (counter_E > 0) { + counter_E -= current_block->step_event_count; + e_steps[current_block->active_extruder] += motor_direction(E_AXIS) ? -1 : 1; } #endif //ADVANCE - #define _COUNTER(axis) counter_## axis + #define _COUNTER(AXIS) counter_## AXIS #define _APPLY_STEP(AXIS) AXIS ##_APPLY_STEP #define _INVERT_STEP_PIN(AXIS) INVERT_## AXIS ##_STEP_PIN - #define STEP_ADD(axis, AXIS) \ - _COUNTER(axis) += current_block->steps[_AXIS(AXIS)]; \ - if (_COUNTER(axis) > 0) { _APPLY_STEP(AXIS)(!_INVERT_STEP_PIN(AXIS),0); } + #define STEP_ADD(AXIS) \ + _COUNTER(AXIS) += current_block->steps[_AXIS(AXIS)]; \ + if (_COUNTER(AXIS) > 0) { _APPLY_STEP(AXIS)(!_INVERT_STEP_PIN(AXIS),0); } - STEP_ADD(x,X); - STEP_ADD(y,Y); - STEP_ADD(z,Z); + STEP_ADD(X); + STEP_ADD(Y); + STEP_ADD(Z); #if DISABLED(ADVANCE) - STEP_ADD(e,E); + STEP_ADD(E); #endif - #define STEP_IF_COUNTER(axis, AXIS) \ - if (_COUNTER(axis) > 0) { \ - _COUNTER(axis) -= current_block->step_event_count; \ + #define STEP_IF_COUNTER(AXIS) \ + if (_COUNTER(AXIS) > 0) { \ + _COUNTER(AXIS) -= current_block->step_event_count; \ count_position[_AXIS(AXIS)] += count_direction[_AXIS(AXIS)]; \ _APPLY_STEP(AXIS)(_INVERT_STEP_PIN(AXIS),0); \ } - STEP_IF_COUNTER(x, X); - STEP_IF_COUNTER(y, Y); - STEP_IF_COUNTER(z, Z); + STEP_IF_COUNTER(X); + STEP_IF_COUNTER(Y); + STEP_IF_COUNTER(Z); #if DISABLED(ADVANCE) - STEP_IF_COUNTER(e, E); + STEP_IF_COUNTER(E); #endif step_events_completed++; if (step_events_completed >= current_block->step_event_count) break; } // Calculate new timer value - unsigned short timer; - unsigned short step_rate; + unsigned short timer, step_rate; if (step_events_completed <= (unsigned long)current_block->accelerate_until) { MultiU24X32toH16(acc_step_rate, acceleration_time, current_block->acceleration_rate); @@ -811,16 +396,17 @@ ISR(TIMER1_COMPA_vect) { // If current block is finished, reset pointer if (step_events_completed >= current_block->step_event_count) { current_block = NULL; - plan_discard_current_block(); + planner.discard_current_block(); } } } #if ENABLED(ADVANCE) - unsigned char old_OCR0A; // Timer interrupt for E. e_steps is set in the main routine; // Timer 0 is shared with millies - ISR(TIMER0_COMPA_vect) { + ISR(TIMER0_COMPA_vect) { stepper.advance_isr(); } + + void Stepper::advance_isr() { old_OCR0A += 52; // ~10kHz interrupt (250000 / 26 = 9615kHz) OCR0A = old_OCR0A; @@ -852,9 +438,10 @@ ISR(TIMER1_COMPA_vect) { #endif } } + #endif // ADVANCE -void st_init() { +void Stepper::init() { digipot_init(); //Initialize Digipot Motor Current microstep_init(); //Initialize Microstepping Pins @@ -944,70 +531,10 @@ void st_init() { if (!E_ENABLE_ON) E3_ENABLE_WRITE(HIGH); #endif - //endstops and pullups - - #if HAS_X_MIN - SET_INPUT(X_MIN_PIN); - #if ENABLED(ENDSTOPPULLUP_XMIN) - WRITE(X_MIN_PIN,HIGH); - #endif - #endif - - #if HAS_Y_MIN - SET_INPUT(Y_MIN_PIN); - #if ENABLED(ENDSTOPPULLUP_YMIN) - WRITE(Y_MIN_PIN,HIGH); - #endif - #endif - - #if HAS_Z_MIN - SET_INPUT(Z_MIN_PIN); - #if ENABLED(ENDSTOPPULLUP_ZMIN) - WRITE(Z_MIN_PIN,HIGH); - #endif - #endif - - #if HAS_Z2_MIN - SET_INPUT(Z2_MIN_PIN); - #if ENABLED(ENDSTOPPULLUP_ZMIN) - WRITE(Z2_MIN_PIN,HIGH); - #endif - #endif - - #if HAS_X_MAX - SET_INPUT(X_MAX_PIN); - #if ENABLED(ENDSTOPPULLUP_XMAX) - WRITE(X_MAX_PIN,HIGH); - #endif - #endif - - #if HAS_Y_MAX - SET_INPUT(Y_MAX_PIN); - #if ENABLED(ENDSTOPPULLUP_YMAX) - WRITE(Y_MAX_PIN,HIGH); - #endif - #endif - - #if HAS_Z_MAX - SET_INPUT(Z_MAX_PIN); - #if ENABLED(ENDSTOPPULLUP_ZMAX) - WRITE(Z_MAX_PIN,HIGH); - #endif - #endif - - #if HAS_Z2_MAX - SET_INPUT(Z2_MAX_PIN); - #if ENABLED(ENDSTOPPULLUP_ZMAX) - WRITE(Z2_MAX_PIN,HIGH); - #endif - #endif - - #if HAS_Z_PROBE && ENABLED(Z_MIN_PROBE_ENDSTOP) // Check for Z_MIN_PROBE_ENDSTOP so we don't pull a pin high unless it's to be used. - SET_INPUT(Z_MIN_PROBE_PIN); - #if ENABLED(ENDSTOPPULLUP_ZMIN_PROBE) - WRITE(Z_MIN_PROBE_PIN,HIGH); - #endif - #endif + // + // Init endstops and pullups here + // + endstops.init(); #define _STEP_INIT(AXIS) AXIS ##_STEP_INIT #define _WRITE_STEP(AXIS, HIGHLOW) AXIS ##_STEP_WRITE(HIGHLOW) @@ -1083,17 +610,17 @@ void st_init() { SBI(TIMSK0, OCIE0A); #endif //ADVANCE - enable_endstops(true); // Start with endstops active. After homing they can be disabled + endstops.enable(true); // Start with endstops active. After homing they can be disabled sei(); - set_stepper_direction(); // Init directions to out_bits = 0 + set_directions(); // Init directions to last_direction_bits = 0 } /** * Block until all buffered steps are executed */ -void st_synchronize() { while (blocks_queued()) idle(); } +void Stepper::synchronize() { while (planner.blocks_queued()) idle(); } /** * Set the stepper positions directly in steps @@ -1101,10 +628,10 @@ void st_synchronize() { while (blocks_queued()) idle(); } * The input is based on the typical per-axis XYZ steps. * For CORE machines XYZ needs to be translated to ABC. * - * This allows st_get_axis_position_mm to correctly + * This allows get_axis_position_mm to correctly * derive the current XYZ position later on. */ -void st_set_position(const long& x, const long& y, const long& z, const long& e) { +void Stepper::set_position(const long& x, const long& y, const long& z, const long& e) { CRITICAL_SECTION_START; #if ENABLED(COREXY) @@ -1129,7 +656,7 @@ void st_set_position(const long& x, const long& y, const long& z, const long& e) CRITICAL_SECTION_END; } -void st_set_e_position(const long& e) { +void Stepper::set_e_position(const long& e) { CRITICAL_SECTION_START; count_position[E_AXIS] = e; CRITICAL_SECTION_END; @@ -1138,7 +665,7 @@ void st_set_e_position(const long& e) { /** * Get a stepper's position in steps. */ -long st_get_position(AxisEnum axis) { +long Stepper::position(AxisEnum axis) { CRITICAL_SECTION_START; long count_pos = count_position[axis]; CRITICAL_SECTION_END; @@ -1149,7 +676,7 @@ long st_get_position(AxisEnum axis) { * Get an axis position according to stepper position(s) * For CORE machines apply translation from ABC to XYZ. */ -float st_get_axis_position_mm(AxisEnum axis) { +float Stepper::get_axis_position_mm(AxisEnum axis) { float axis_steps; #if ENABLED(COREXY) | ENABLED(COREXZ) if (axis == X_AXIS || axis == CORE_AXIS_2) { @@ -1162,31 +689,82 @@ float st_get_axis_position_mm(AxisEnum axis) { axis_steps = (pos1 + ((axis == X_AXIS) ? pos2 : -pos2)) / 2.0f; } else - axis_steps = st_get_position(axis); + axis_steps = position(axis); #else - axis_steps = st_get_position(axis); + axis_steps = position(axis); #endif - return axis_steps / axis_steps_per_unit[axis]; + return axis_steps / planner.axis_steps_per_unit[axis]; } -void finishAndDisableSteppers() { - st_synchronize(); +void Stepper::finish_and_disable() { + synchronize(); disable_all_steppers(); } -void quickStop() { +void Stepper::quick_stop() { cleaning_buffer_counter = 5000; DISABLE_STEPPER_DRIVER_INTERRUPT(); - while (blocks_queued()) plan_discard_current_block(); + while (planner.blocks_queued()) planner.discard_current_block(); current_block = NULL; ENABLE_STEPPER_DRIVER_INTERRUPT(); } +void Stepper::endstop_triggered(AxisEnum axis) { + + #if ENABLED(COREXY) || ENABLED(COREXZ) + + float axis_pos = count_position[axis]; + if (axis == A_AXIS) + axis_pos = (axis_pos + count_position[CORE_AXIS_2]) / 2; + else if (axis == CORE_AXIS_2) + axis_pos = (count_position[A_AXIS] - axis_pos) / 2; + endstops_trigsteps[axis] = axis_pos; + + #else // !COREXY && !COREXZ + + endstops_trigsteps[axis] = count_position[axis]; + + #endif // !COREXY && !COREXZ + + kill_current_block(); +} + +void Stepper::report_positions() { + CRITICAL_SECTION_START; + long xpos = count_position[X_AXIS], + ypos = count_position[Y_AXIS], + zpos = count_position[Z_AXIS]; + CRITICAL_SECTION_END; + + #if ENABLED(COREXY) || ENABLED(COREXZ) + SERIAL_PROTOCOLPGM(MSG_COUNT_A); + #else + SERIAL_PROTOCOLPGM(MSG_COUNT_X); + #endif + SERIAL_PROTOCOL(xpos); + + #if ENABLED(COREXY) || ENABLED(COREXZ) + SERIAL_PROTOCOLPGM(" B:"); + #else + SERIAL_PROTOCOLPGM(" Y:"); + #endif + SERIAL_PROTOCOL(ypos); + + #if ENABLED(COREXZ) || ENABLED(COREXZ) + SERIAL_PROTOCOLPGM(" C:"); + #else + SERIAL_PROTOCOLPGM(" Z:"); + #endif + SERIAL_PROTOCOL(zpos); + + SERIAL_EOL; +} + #if ENABLED(BABYSTEPPING) // MUST ONLY BE CALLED BY AN ISR, // No other ISR should ever interrupt this! - void babystep(const uint8_t axis, const bool direction) { + void Stepper::babystep(const uint8_t axis, const bool direction) { #define _ENABLE(axis) enable_## axis() #define _READ_DIR(AXIS) AXIS ##_DIR_READ @@ -1256,10 +834,14 @@ void quickStop() { #endif //BABYSTEPPING +/** + * Software-controlled Stepper Motor Current + */ + #if HAS_DIGIPOTSS // From Arduino DigitalPotControl example - void digitalPotWrite(int address, int value) { + void Stepper::digitalPotWrite(int address, int value) { digitalWrite(DIGIPOTSS_PIN, LOW); // take the SS pin low to select the chip SPI.transfer(address); // send in the address and value via SPI: SPI.transfer(value); @@ -1269,8 +851,7 @@ void quickStop() { #endif //HAS_DIGIPOTSS -// Initialize Digipot Motor Current -void digipot_init() { +void Stepper::digipot_init() { #if HAS_DIGIPOTSS const uint8_t digipot_motor_current[] = DIGIPOT_MOTOR_CURRENT; @@ -1299,7 +880,7 @@ void digipot_init() { #endif } -void digipot_current(uint8_t driver, int current) { +void Stepper::digipot_current(uint8_t driver, int current) { #if HAS_DIGIPOTSS const uint8_t digipot_ch[] = DIGIPOT_CHANNELS; digitalPotWrite(digipot_ch[driver], current); @@ -1322,7 +903,7 @@ void digipot_current(uint8_t driver, int current) { #endif } -void microstep_init() { +void Stepper::microstep_init() { #if HAS_MICROSTEPS_E1 pinMode(E1_MS1_PIN, OUTPUT); pinMode(E1_MS2_PIN, OUTPUT); @@ -1343,7 +924,11 @@ void microstep_init() { #endif } -void microstep_ms(uint8_t driver, int8_t ms1, int8_t ms2) { +/** + * Software-controlled Microstepping + */ + +void Stepper::microstep_ms(uint8_t driver, int8_t ms1, int8_t ms2) { if (ms1 >= 0) switch (driver) { case 0: digitalWrite(X_MS1_PIN, ms1); break; case 1: digitalWrite(Y_MS1_PIN, ms1); break; @@ -1364,7 +949,7 @@ void microstep_ms(uint8_t driver, int8_t ms1, int8_t ms2) { } } -void microstep_mode(uint8_t driver, uint8_t stepping_mode) { +void Stepper::microstep_mode(uint8_t driver, uint8_t stepping_mode) { switch (stepping_mode) { case 1: microstep_ms(driver, MICROSTEP1); break; case 2: microstep_ms(driver, MICROSTEP2); break; @@ -1374,7 +959,7 @@ void microstep_mode(uint8_t driver, uint8_t stepping_mode) { } } -void microstep_readings() { +void Stepper::microstep_readings() { SERIAL_PROTOCOLPGM("MS1,MS2 Pins\n"); SERIAL_PROTOCOLPGM("X: "); SERIAL_PROTOCOL(digitalRead(X_MS1_PIN)); @@ -1396,7 +981,7 @@ void microstep_readings() { } #if ENABLED(Z_DUAL_ENDSTOPS) - void In_Homing_Process(bool state) { performing_homing = state; } - void Lock_z_motor(bool state) { locked_z_motor = state; } - void Lock_z2_motor(bool state) { locked_z2_motor = state; } + void Stepper::set_homing_flag(bool state) { performing_homing = state; } + void Stepper::set_z_lock(bool state) { locked_z_motor = state; } + void Stepper::set_z2_lock(bool state) { locked_z2_motor = state; } #endif diff --git a/Marlin/stepper.h b/Marlin/stepper.h index b0230b8cd..6f2e99dc9 100644 --- a/Marlin/stepper.h +++ b/Marlin/stepper.h @@ -21,90 +21,313 @@ */ /** - stepper.h - stepper motor driver: executes motion plans of planner.c using the stepper motors - Part of Grbl + * stepper.h - stepper motor driver: executes motion plans of planner.c using the stepper motors + * Part of Grbl + * + * Copyright (c) 2009-2011 Simen Svale Skogsrud + * + * Grbl is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Grbl is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Grbl. If not, see . + */ - Copyright (c) 2009-2011 Simen Svale Skogsrud - - Grbl is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - Grbl is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with Grbl. If not, see . -*/ - -#ifndef stepper_h -#define stepper_h +#ifndef STEPPER_H +#define STEPPER_H #include "planner.h" +#include "speed_lookuptable.h" #include "stepper_indirection.h" +#include "language.h" -#if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) - extern bool abort_on_endstop_hit; -#endif +class Stepper; +extern Stepper stepper; -// Initialize and start the stepper motor subsystem -void st_init(); +// intRes = intIn1 * intIn2 >> 16 +// uses: +// r26 to store 0 +// r27 to store the byte 1 of the 24 bit result +#define MultiU16X8toH16(intRes, charIn1, intIn2) \ + asm volatile ( \ + "clr r26 \n\t" \ + "mul %A1, %B2 \n\t" \ + "movw %A0, r0 \n\t" \ + "mul %A1, %A2 \n\t" \ + "add %A0, r1 \n\t" \ + "adc %B0, r26 \n\t" \ + "lsr r0 \n\t" \ + "adc %A0, r26 \n\t" \ + "adc %B0, r26 \n\t" \ + "clr r1 \n\t" \ + : \ + "=&r" (intRes) \ + : \ + "d" (charIn1), \ + "d" (intIn2) \ + : \ + "r26" \ + ) -// Block until all buffered steps are executed -void st_synchronize(); +class Stepper { -// Set current position in steps -void st_set_position(const long& x, const long& y, const long& z, const long& e); -void st_set_e_position(const long& e); + public: -// Get current position in steps -long st_get_position(AxisEnum axis); + block_t* current_block = NULL; // A pointer to the block currently being traced -// Get current axis position in mm -float st_get_axis_position_mm(AxisEnum axis); + #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) + bool abort_on_endstop_hit = false; + #endif -// The stepper subsystem goes to sleep when it runs out of things to execute. Call this -// to notify the subsystem that it is time to go to work. -void st_wake_up(); + #if ENABLED(Z_DUAL_ENDSTOPS) + bool performing_homing = false; + #endif + #if ENABLED(ADVANCE) + long e_steps[4]; + #endif -void checkHitEndstops(); //call from somewhere to create an serial error message with the locations the endstops where hit, in case they were triggered -void endstops_hit_on_purpose(); //avoid creation of the message, i.e. after homing and before a routine call of checkHitEndstops(); + private: -void enable_endstops(bool check); // Enable/disable endstop checking + unsigned char last_direction_bits = 0; // The next stepping-bits to be output + unsigned int cleaning_buffer_counter = 0; -void enable_endstops_globally(bool check); -void endstops_not_homing(); + #if ENABLED(Z_DUAL_ENDSTOPS) + bool locked_z_motor = false, + locked_z2_motor = false; + #endif -void checkStepperErrors(); //Print errors detected by the stepper + // Counter variables for the Bresenham line tracer + long counter_X = 0, counter_Y = 0, counter_Z = 0, counter_E = 0; + volatile unsigned long step_events_completed = 0; // The number of step events executed in the current block -void finishAndDisableSteppers(); + #if ENABLED(ADVANCE) + unsigned char old_OCR0A; + long advance_rate, advance, final_advance = 0; + long old_advance = 0; + #endif -extern block_t* current_block; // A pointer to the block currently being traced + long acceleration_time, deceleration_time; + //unsigned long accelerate_until, decelerate_after, acceleration_rate, initial_rate, final_rate, nominal_rate; + unsigned short acc_step_rate; // needed for deceleration start point + uint8_t step_loops; + uint8_t step_loops_nominal; + unsigned short OCR1A_nominal; -void quickStop(); + volatile long endstops_trigsteps[3]; + volatile long endstops_stepsTotal, endstops_stepsDone; -#if HAS_DIGIPOTSS - void digitalPotWrite(int address, int value); -#endif -void microstep_ms(uint8_t driver, int8_t ms1, int8_t ms2); -void microstep_mode(uint8_t driver, uint8_t stepping); -void digipot_init(); -void digipot_current(uint8_t driver, int current); -void microstep_init(); -void microstep_readings(); + #if HAS_MOTOR_CURRENT_PWM + #ifndef PWM_MOTOR_CURRENT + #define PWM_MOTOR_CURRENT DEFAULT_PWM_MOTOR_CURRENT + #endif + const int motor_current_setting[3] = PWM_MOTOR_CURRENT; + #endif -#if ENABLED(Z_DUAL_ENDSTOPS) - void In_Homing_Process(bool state); - void Lock_z_motor(bool state); - void Lock_z2_motor(bool state); -#endif + // + // Positions of stepper motors, in step units + // + volatile long count_position[NUM_AXIS] = { 0 }; -#if ENABLED(BABYSTEPPING) - void babystep(const uint8_t axis, const bool direction); // perform a short step with a single stepper motor, outside of any convention -#endif + // + // Current direction of stepper motors (+1 or -1) + // + volatile signed char count_direction[NUM_AXIS] = { 1 }; -#endif + public: + + // + // Constructor / initializer + // + Stepper() {}; + + // + // Initialize stepper hardware + // + void init(); + + // + // Interrupt Service Routines + // + + void isr(); + + #if ENABLED(ADVANCE) + void advance_isr(); + #endif + + // + // Block until all buffered steps are executed + // + void synchronize(); + + // + // Set the current position in steps + // + void set_position(const long& x, const long& y, const long& z, const long& e); + void set_e_position(const long& e); + + // + // Set direction bits for all steppers + // + void set_directions(); + + // + // Get the position of a stepper, in steps + // + long position(AxisEnum axis); + + // + // Report the positions of the steppers, in steps + // + void report_positions(); + + // + // Get the position (mm) of an axis based on stepper position(s) + // + float get_axis_position_mm(AxisEnum axis); + + // + // The stepper subsystem goes to sleep when it runs out of things to execute. Call this + // to notify the subsystem that it is time to go to work. + // + void wake_up(); + + // + // Wait for moves to finish and disable all steppers + // + void finish_and_disable(); + + // + // Quickly stop all steppers and clear the blocks queue + // + void quick_stop(); + + // + // The direction of a single motor + // + FORCE_INLINE bool motor_direction(AxisEnum axis) { return TEST(last_direction_bits, axis); } + + #if HAS_DIGIPOTSS + void digitalPotWrite(int address, int value); + #endif + void microstep_ms(uint8_t driver, int8_t ms1, int8_t ms2); + void digipot_current(uint8_t driver, int current); + void microstep_readings(); + + #if ENABLED(Z_DUAL_ENDSTOPS) + void set_homing_flag(bool state); + void set_z_lock(bool state); + void set_z2_lock(bool state); + #endif + + #if ENABLED(BABYSTEPPING) + void babystep(const uint8_t axis, const bool direction); // perform a short step with a single stepper motor, outside of any convention + #endif + + inline void kill_current_block() { + step_events_completed = current_block->step_event_count; + } + + // + // Handle a triggered endstop + // + void endstop_triggered(AxisEnum axis); + + // + // Triggered position of an axis in mm (not core-savvy) + // + FORCE_INLINE float triggered_position_mm(AxisEnum axis) { + return endstops_trigsteps[axis] / planner.axis_steps_per_unit[axis]; + } + + FORCE_INLINE unsigned short calc_timer(unsigned short step_rate) { + unsigned short timer; + + NOMORE(step_rate, MAX_STEP_FREQUENCY); + + if (step_rate > 20000) { // If steprate > 20kHz >> step 4 times + step_rate = (step_rate >> 2) & 0x3fff; + step_loops = 4; + } + else if (step_rate > 10000) { // If steprate > 10kHz >> step 2 times + step_rate = (step_rate >> 1) & 0x7fff; + step_loops = 2; + } + else { + step_loops = 1; + } + + NOLESS(step_rate, F_CPU / 500000); + step_rate -= F_CPU / 500000; // Correct for minimal speed + if (step_rate >= (8 * 256)) { // higher step rate + unsigned short table_address = (unsigned short)&speed_lookuptable_fast[(unsigned char)(step_rate >> 8)][0]; + unsigned char tmp_step_rate = (step_rate & 0x00ff); + unsigned short gain = (unsigned short)pgm_read_word_near(table_address + 2); + MultiU16X8toH16(timer, tmp_step_rate, gain); + timer = (unsigned short)pgm_read_word_near(table_address) - timer; + } + else { // lower step rates + unsigned short table_address = (unsigned short)&speed_lookuptable_slow[0][0]; + table_address += ((step_rate) >> 1) & 0xfffc; + timer = (unsigned short)pgm_read_word_near(table_address); + timer -= (((unsigned short)pgm_read_word_near(table_address + 2) * (unsigned char)(step_rate & 0x0007)) >> 3); + } + if (timer < 100) { timer = 100; MYSERIAL.print(MSG_STEPPER_TOO_HIGH); MYSERIAL.println(step_rate); }//(20kHz this should never happen) + return timer; + } + + // Initializes the trapezoid generator from the current block. Called whenever a new + // block begins. + FORCE_INLINE void trapezoid_generator_reset() { + + static int8_t last_extruder = -1; + + if (current_block->direction_bits != last_direction_bits || current_block->active_extruder != last_extruder) { + last_direction_bits = current_block->direction_bits; + last_extruder = current_block->active_extruder; + set_directions(); + } + + #if ENABLED(ADVANCE) + advance = current_block->initial_advance; + final_advance = current_block->final_advance; + // Do E steps + advance steps + e_steps[current_block->active_extruder] += ((advance >>8) - old_advance); + old_advance = advance >>8; + #endif + deceleration_time = 0; + // step_rate to timer interval + OCR1A_nominal = calc_timer(current_block->nominal_rate); + // make a note of the number of step loops required at nominal speed + step_loops_nominal = step_loops; + acc_step_rate = current_block->initial_rate; + acceleration_time = calc_timer(acc_step_rate); + OCR1A = acceleration_time; + + // SERIAL_ECHO_START; + // SERIAL_ECHOPGM("advance :"); + // SERIAL_ECHO(current_block->advance/256.0); + // SERIAL_ECHOPGM("advance rate :"); + // SERIAL_ECHO(current_block->advance_rate/256.0); + // SERIAL_ECHOPGM("initial advance :"); + // SERIAL_ECHO(current_block->initial_advance/256.0); + // SERIAL_ECHOPGM("final advance :"); + // SERIAL_ECHOLN(current_block->final_advance/256.0); + } + + private: + void microstep_mode(uint8_t driver, uint8_t stepping); + void digipot_init(); + void microstep_init(); + +}; + +#endif // STEPPER_H \ No newline at end of file diff --git a/Marlin/temperature.cpp b/Marlin/temperature.cpp index 5713cb693..7c5db54c8 100644 --- a/Marlin/temperature.cpp +++ b/Marlin/temperature.cpp @@ -604,7 +604,7 @@ float get_pid_output(int e) { #if ENABLED(PID_ADD_EXTRUSION_RATE) cTerm[e] = 0; if (e == active_extruder) { - long e_position = st_get_position(E_AXIS); + long e_position = stepper.position(E_AXIS); if (e_position > last_position[e]) { lpq[lpq_ptr++] = e_position - last_position[e]; last_position[e] = e_position; @@ -613,7 +613,7 @@ float get_pid_output(int e) { lpq[lpq_ptr++] = 0; } if (lpq_ptr >= lpq_len) lpq_ptr = 0; - cTerm[e] = (lpq[lpq_ptr] / axis_steps_per_unit[E_AXIS]) * PID_PARAM(Kc, e); + cTerm[e] = (lpq[lpq_ptr] / planner.axis_steps_per_unit[E_AXIS]) * PID_PARAM(Kc, e); pid_output += cTerm[e]; } #endif //PID_ADD_EXTRUSION_RATE diff --git a/Marlin/temperature.h b/Marlin/temperature.h index c49f2c46a..11406c533 100644 --- a/Marlin/temperature.h +++ b/Marlin/temperature.h @@ -79,6 +79,10 @@ extern float current_temperature_bed; extern unsigned char soft_pwm_bed; #endif +#if ENABLED(FAN_SOFT_PWM) + extern unsigned char fanSpeedSoftPwm[FAN_COUNT]; +#endif + #if ENABLED(PIDTEMP) #if ENABLED(PID_PARAMS_PER_EXTRUDER) @@ -178,9 +182,9 @@ void checkExtruderAutoFans(); FORCE_INLINE void autotempShutdown() { #if ENABLED(AUTOTEMP) - if (autotemp_enabled) { - autotemp_enabled = false; - if (degTargetHotend(active_extruder) > autotemp_min) + if (planner.autotemp_enabled) { + planner.autotemp_enabled = false; + if (degTargetHotend(active_extruder) > planner.autotemp_min) setTargetHotend(0, active_extruder); } #endif diff --git a/Marlin/ultralcd.cpp b/Marlin/ultralcd.cpp index 97a07f523..6acb889ec 100644 --- a/Marlin/ultralcd.cpp +++ b/Marlin/ultralcd.cpp @@ -463,9 +463,9 @@ static void lcd_status_screen() { inline void line_to_current(AxisEnum axis) { #if ENABLED(DELTA) calculate_delta(current_position); - plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis]/60, active_extruder); + planner.buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis]/60, active_extruder); #else - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis]/60, active_extruder); + planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis]/60, active_extruder); #endif } @@ -476,7 +476,7 @@ inline void line_to_current(AxisEnum axis) { static void lcd_sdcard_resume() { card.startFileprint(); } static void lcd_sdcard_stop() { - quickStop(); + stepper.quick_stop(); card.sdprinting = false; card.closefile(); autotempShutdown(); @@ -495,7 +495,7 @@ inline void line_to_current(AxisEnum axis) { static void lcd_main_menu() { START_MENU(); MENU_ITEM(back, MSG_WATCH); - if (movesplanned() || IS_SD_PRINTING) { + if (planner.movesplanned() || IS_SD_PRINTING) { MENU_ITEM(submenu, MSG_TUNE, lcd_tune_menu); } else { @@ -911,7 +911,7 @@ void lcd_cooldown() { current_position[Z_AXIS] = MESH_HOME_SEARCH_Z; line_to_current(Z_AXIS); #endif - st_synchronize(); + stepper.synchronize(); } static void _lcd_level_goto_next_point(); @@ -934,7 +934,7 @@ void lcd_cooldown() { ENCODER_DIRECTION_NORMAL(); // Encoder wheel adjusts the Z position - if (encoderPosition && movesplanned() <= 3) { + if (encoderPosition && planner.movesplanned() <= 3) { refresh_cmd_timeout(); current_position[Z_AXIS] += float((int32_t)encoderPosition) * (MBL_Z_STEP); NOLESS(current_position[Z_AXIS], 0); @@ -964,7 +964,7 @@ void lcd_cooldown() { #endif ; line_to_current(Z_AXIS); - st_synchronize(); + stepper.synchronize(); mbl.active = true; enqueue_and_echo_commands_P(PSTR("G28")); @@ -1037,7 +1037,7 @@ void lcd_cooldown() { if (LCD_CLICKED) { _lcd_level_bed_position = 0; current_position[Z_AXIS] = MESH_HOME_SEARCH_Z; - plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); + planner.set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); lcd_goto_menu(_lcd_level_goto_next_point, true); } } @@ -1191,7 +1191,7 @@ float move_menu_scale; static void _lcd_move(const char* name, AxisEnum axis, float min, float max) { ENCODER_DIRECTION_NORMAL(); - if (encoderPosition && movesplanned() <= 3) { + if (encoderPosition && planner.movesplanned() <= 3) { refresh_cmd_timeout(); current_position[axis] += float((int32_t)encoderPosition) * move_menu_scale; if (min_software_endstops) NOLESS(current_position[axis], min); @@ -1223,7 +1223,7 @@ static void lcd_move_e( unsigned short original_active_extruder = active_extruder; active_extruder = e; #endif - if (encoderPosition && movesplanned() <= 3) { + if (encoderPosition && planner.movesplanned() <= 3) { current_position[E_AXIS] += float((int32_t)encoderPosition) * move_menu_scale; line_to_current(E_AXIS); lcdDrawUpdate = LCDVIEW_REDRAW_NOW; @@ -1511,10 +1511,10 @@ static void lcd_control_temperature_menu() { // Autotemp, Min, Max, Fact // #if ENABLED(AUTOTEMP) && (TEMP_SENSOR_0 != 0) - MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &autotemp_enabled); - MENU_ITEM_EDIT(float3, MSG_MIN, &autotemp_min, 0, HEATER_0_MAXTEMP - 15); - MENU_ITEM_EDIT(float3, MSG_MAX, &autotemp_max, 0, HEATER_0_MAXTEMP - 15); - MENU_ITEM_EDIT(float32, MSG_FACTOR, &autotemp_factor, 0.0, 1.0); + MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &planner.autotemp_enabled); + MENU_ITEM_EDIT(float3, MSG_MIN, &planner.autotemp_min, 0, HEATER_0_MAXTEMP - 15); + MENU_ITEM_EDIT(float3, MSG_MAX, &planner.autotemp_max, 0, HEATER_0_MAXTEMP - 15); + MENU_ITEM_EDIT(float32, MSG_FACTOR, &planner.autotemp_factor, 0.0, 1.0); #endif // @@ -1618,6 +1618,8 @@ static void lcd_control_temperature_preheat_abs_settings_menu() { END_MENU(); } +static void _reset_acceleration_rates() { planner.reset_acceleration_rates(); } + /** * * "Control" > "Motion" submenu @@ -1633,34 +1635,34 @@ static void lcd_control_motion_menu() { #if ENABLED(MANUAL_BED_LEVELING) MENU_ITEM_EDIT(float43, MSG_BED_Z, &mbl.z_offset, -1, 1); #endif - MENU_ITEM_EDIT(float5, MSG_ACC, &acceleration, 10, 99000); - MENU_ITEM_EDIT(float3, MSG_VXY_JERK, &max_xy_jerk, 1, 990); + MENU_ITEM_EDIT(float5, MSG_ACC, &planner.acceleration, 10, 99000); + MENU_ITEM_EDIT(float3, MSG_VXY_JERK, &planner.max_xy_jerk, 1, 990); #if ENABLED(DELTA) - MENU_ITEM_EDIT(float3, MSG_VZ_JERK, &max_z_jerk, 1, 990); + MENU_ITEM_EDIT(float3, MSG_VZ_JERK, &planner.max_z_jerk, 1, 990); #else - MENU_ITEM_EDIT(float52, MSG_VZ_JERK, &max_z_jerk, 0.1, 990); + MENU_ITEM_EDIT(float52, MSG_VZ_JERK, &planner.max_z_jerk, 0.1, 990); #endif - MENU_ITEM_EDIT(float3, MSG_VE_JERK, &max_e_jerk, 1, 990); - MENU_ITEM_EDIT(float3, MSG_VMAX MSG_X, &max_feedrate[X_AXIS], 1, 999); - MENU_ITEM_EDIT(float3, MSG_VMAX MSG_Y, &max_feedrate[Y_AXIS], 1, 999); - MENU_ITEM_EDIT(float3, MSG_VMAX MSG_Z, &max_feedrate[Z_AXIS], 1, 999); - MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E, &max_feedrate[E_AXIS], 1, 999); - MENU_ITEM_EDIT(float3, MSG_VMIN, &minimumfeedrate, 0, 999); - MENU_ITEM_EDIT(float3, MSG_VTRAV_MIN, &mintravelfeedrate, 0, 999); - MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_X, &max_acceleration_units_per_sq_second[X_AXIS], 100, 99000, reset_acceleration_rates); - MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_Y, &max_acceleration_units_per_sq_second[Y_AXIS], 100, 99000, reset_acceleration_rates); - MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_Z, &max_acceleration_units_per_sq_second[Z_AXIS], 10, 99000, reset_acceleration_rates); - MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E, &max_acceleration_units_per_sq_second[E_AXIS], 100, 99000, reset_acceleration_rates); - MENU_ITEM_EDIT(float5, MSG_A_RETRACT, &retract_acceleration, 100, 99000); - MENU_ITEM_EDIT(float5, MSG_A_TRAVEL, &travel_acceleration, 100, 99000); - MENU_ITEM_EDIT(float52, MSG_XSTEPS, &axis_steps_per_unit[X_AXIS], 5, 9999); - MENU_ITEM_EDIT(float52, MSG_YSTEPS, &axis_steps_per_unit[Y_AXIS], 5, 9999); + MENU_ITEM_EDIT(float3, MSG_VE_JERK, &planner.max_e_jerk, 1, 990); + MENU_ITEM_EDIT(float3, MSG_VMAX MSG_X, &planner.max_feedrate[X_AXIS], 1, 999); + MENU_ITEM_EDIT(float3, MSG_VMAX MSG_Y, &planner.max_feedrate[Y_AXIS], 1, 999); + MENU_ITEM_EDIT(float3, MSG_VMAX MSG_Z, &planner.max_feedrate[Z_AXIS], 1, 999); + MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E, &planner.max_feedrate[E_AXIS], 1, 999); + MENU_ITEM_EDIT(float3, MSG_VMIN, &planner.min_feedrate, 0, 999); + MENU_ITEM_EDIT(float3, MSG_VTRAV_MIN, &planner.min_travel_feedrate, 0, 999); + MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_X, &planner.max_acceleration_units_per_sq_second[X_AXIS], 100, 99000, _reset_acceleration_rates); + MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_Y, &planner.max_acceleration_units_per_sq_second[Y_AXIS], 100, 99000, _reset_acceleration_rates); + MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_Z, &planner.max_acceleration_units_per_sq_second[Z_AXIS], 10, 99000, _reset_acceleration_rates); + MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E, &planner.max_acceleration_units_per_sq_second[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_unit[X_AXIS], 5, 9999); + MENU_ITEM_EDIT(float52, MSG_YSTEPS, &planner.axis_steps_per_unit[Y_AXIS], 5, 9999); #if ENABLED(DELTA) - MENU_ITEM_EDIT(float52, MSG_ZSTEPS, &axis_steps_per_unit[Z_AXIS], 5, 9999); + MENU_ITEM_EDIT(float52, MSG_ZSTEPS, &planner.axis_steps_per_unit[Z_AXIS], 5, 9999); #else - MENU_ITEM_EDIT(float51, MSG_ZSTEPS, &axis_steps_per_unit[Z_AXIS], 5, 9999); + MENU_ITEM_EDIT(float51, MSG_ZSTEPS, &planner.axis_steps_per_unit[Z_AXIS], 5, 9999); #endif - MENU_ITEM_EDIT(float51, MSG_ESTEPS, &axis_steps_per_unit[E_AXIS], 5, 9999); + MENU_ITEM_EDIT(float51, MSG_ESTEPS, &planner.axis_steps_per_unit[E_AXIS], 5, 9999); #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) MENU_ITEM_EDIT(bool, MSG_ENDSTOP_ABORT, &abort_on_endstop_hit); #endif