diff --git a/Marlin/Marlin.h b/Marlin/Marlin.h
index 9cd13c90ee192a72f69eb3b2c8692a46084ab114..f6f488df849194515da1672c2310fed3e01f53bd 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 37c472f3cabd58bc771155eb631a0e9fdaed9073..4100e629a52eb91fdf6e94aee59bde1c99c1d9bb 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<seconds> 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<seconds>. 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 fbe4ae7e703929fec6aefebbb24679d6614c1c1d..1e9aab3b66305872b590876eff337341c92933b4 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 057f95b1c57c25985067a0c032eaa867b3181fc9..8946156b111c30e0d4ab79e2c893e825c6bdaf08 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();
-
- 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);
+ planner.reset_acceleration_rates();
+
+ 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();
-
- 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.reset_acceleration_rates();
+
+ 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 0000000000000000000000000000000000000000..ac37c5805fc9154a67782718d4547e62ce22a3e3
--- /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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * 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 0000000000000000000000000000000000000000..a72306728e0202ee30dbbc8ae50d4a6c7cff301b
--- /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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * 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 f5062d2a7d944581b2a47f997a98acf0bb28303a..5e55c7dd8879f384b6f4524672dd275611a4a5d8 100644
--- a/Marlin/planner.cpp
+++ b/Marlin/planner.cpp
@@ -81,105 +81,27 @@
#include "mesh_bed_leveling.h"
#endif
-//===========================================================================
-//============================= public variables ============================
-//===========================================================================
-
-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
+Planner planner;
-#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 dd724424b6459820c2340b777bd22db90e6184fd..f4e126c0bd0af870b6d3bc0bc9f7d0f8bd27f084 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();
+ public:
-// 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); }
+ /**
+ * A ring buffer of moves described in steps
+ */
+ block_t block_buffer[BLOCK_BUFFER_SIZE];
+ volatile uint8_t block_buffer_head = 0; // Index of the next block to be pushed
+ volatile uint8_t block_buffer_tail = 0;
+
+ 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
+
+ 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;
+
+ #if ENABLED(AUTO_BED_LEVELING_FEATURE)
+ matrix_3x3 bed_level_matrix; // Transform to compensate for bed level
+ #endif
+
+ private:
-#if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(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 };
- #if ENABLED(AUTO_BED_LEVELING_FEATURE)
- #include "vector_3.h"
+ /**
+ * Speed of previous path line segment
+ */
+ float previous_speed[NUM_AXIS];
+
+ /**
+ * Nominal speed of previous path line segment
+ */
+ float previous_nominal_speed;
+
+ #if ENABLED(DISABLE_INACTIVE_EXTRUDER)
+ /**
+ * Counters to manage disabling inactive extruders
+ */
+ uint8_t g_uc_extruder_last_move[EXTRUDERS] = { 0 };
+ #endif // DISABLE_INACTIVE_EXTRUDER
+
+ #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
- // Transform required to compensate for bed level
- extern matrix_3x3 plan_bed_level_matrix;
+ public:
+
+ Planner();
+
+ void init();
+
+ void reset_acceleration_rates();
+
+ // Manage fans, paste pressure, etc.
+ void check_axes_activity();
/**
- * Get the position applying the bed level matrix
+ * Number of moves currently in the planner
*/
- vector_3 plan_get_position();
- #endif // AUTO_BED_LEVELING_FEATURE
-
- /**
- * 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);
-
- /**
- * 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);
-
-#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 plan_set_position(const float& x, const float& y, const float& z, const float& e);
-
-#endif // AUTO_BED_LEVELING_FEATURE || MESH_BED_LEVELING
-
-void plan_set_e_position(const float& e);
-
-//===========================================================================
-//============================= public variables ============================
-//===========================================================================
-
-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(AUTOTEMP)
- extern bool autotemp_enabled;
- extern float autotemp_max;
- extern float autotemp_min;
- extern float autotemp_factor;
-#endif
+ 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();
-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;
-
-// Returns true if the buffer has a queued block, false otherwise
-FORCE_INLINE bool blocks_queued() { return (block_buffer_head != block_buffer_tail); }
-
-// 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);
-}
-
-// 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 reset_acceleration_rates();
+};
#endif // PLANNER_H
diff --git a/Marlin/stepper.cpp b/Marlin/stepper.cpp
index 4b52edac9b99a758c946b121fb8e0a8a29024d59..e282801373221b9b9b2d3a605b3785d747635804 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 <SPI.h>
#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 b0230b8cd23734a7e24b7c9e4736de404fba440e..6f2e99dc992fd70e808402e406fe7aaf045d3e7c 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 <http://www.gnu.org/licenses/>.
+ */
- Copyright (c) 2009-2011 Simen Svale Skogsrud
+#ifndef STEPPER_H
+#define STEPPER_H
- 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.
+#include "planner.h"
+#include "speed_lookuptable.h"
+#include "stepper_indirection.h"
+#include "language.h"
- 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.
+class Stepper;
+extern Stepper stepper;
- You should have received a copy of the GNU General Public License
- along with Grbl. If not, see <http://www.gnu.org/licenses/>.
-*/
+// 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" \
+ )
-#ifndef stepper_h
-#define stepper_h
+class Stepper {
-#include "planner.h"
-#include "stepper_indirection.h"
+ public:
+
+ block_t* current_block = NULL; // A pointer to the block currently being traced
+
+ #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
+ bool abort_on_endstop_hit = false;
+ #endif
+
+ #if ENABLED(Z_DUAL_ENDSTOPS)
+ bool performing_homing = false;
+ #endif
+
+ #if ENABLED(ADVANCE)
+ long e_steps[4];
+ #endif
+
+ private:
+
+ unsigned char last_direction_bits = 0; // The next stepping-bits to be output
+ unsigned int cleaning_buffer_counter = 0;
+
+ #if ENABLED(Z_DUAL_ENDSTOPS)
+ bool locked_z_motor = false,
+ locked_z2_motor = false;
+ #endif
+
+ // 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
+
+ #if ENABLED(ADVANCE)
+ unsigned char old_OCR0A;
+ long advance_rate, advance, final_advance = 0;
+ long old_advance = 0;
+ #endif
+
+ 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;
+
+ volatile long endstops_trigsteps[3];
+ volatile long endstops_stepsTotal, endstops_stepsDone;
+
+ #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
+
+ //
+ // Positions of stepper motors, in step units
+ //
+ volatile long count_position[NUM_AXIS] = { 0 };
+
+ //
+ // Current direction of stepper motors (+1 or -1)
+ //
+ volatile signed char count_direction[NUM_AXIS] = { 1 };
+
+ 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();
-#if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
- extern bool abort_on_endstop_hit;
-#endif
+ //
+ // The direction of a single motor
+ //
+ FORCE_INLINE bool motor_direction(AxisEnum axis) { return TEST(last_direction_bits, axis); }
-// Initialize and start the stepper motor subsystem
-void st_init();
+ #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();
-// Block until all buffered steps are executed
-void st_synchronize();
+ #if ENABLED(Z_DUAL_ENDSTOPS)
+ void set_homing_flag(bool state);
+ void set_z_lock(bool state);
+ void set_z2_lock(bool state);
+ #endif
-// 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);
+ #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
-// Get current position in steps
-long st_get_position(AxisEnum axis);
+ inline void kill_current_block() {
+ step_events_completed = current_block->step_event_count;
+ }
-// Get current axis position in mm
-float st_get_axis_position_mm(AxisEnum axis);
+ //
+ // Handle a triggered endstop
+ //
+ void endstop_triggered(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 st_wake_up();
+ //
+ // 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;
-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();
+ NOMORE(step_rate, MAX_STEP_FREQUENCY);
-void enable_endstops(bool check); // Enable/disable endstop checking
+ 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;
+ }
-void enable_endstops_globally(bool check);
-void endstops_not_homing();
+ 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;
+ }
-void checkStepperErrors(); //Print errors detected by the stepper
+ // Initializes the trapezoid generator from the current block. Called whenever a new
+ // block begins.
+ FORCE_INLINE void trapezoid_generator_reset() {
-void finishAndDisableSteppers();
+ static int8_t last_extruder = -1;
-extern block_t* current_block; // A pointer to the block currently being traced
+ 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();
+ }
-void quickStop();
+ #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;
-#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();
+ // 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);
+ }
-#if ENABLED(Z_DUAL_ENDSTOPS)
- void In_Homing_Process(bool state);
- void Lock_z_motor(bool state);
- void Lock_z2_motor(bool state);
-#endif
+ private:
+ void microstep_mode(uint8_t driver, uint8_t stepping);
+ void digipot_init();
+ void microstep_init();
-#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
+};
-#endif
+#endif // STEPPER_H
\ No newline at end of file
diff --git a/Marlin/temperature.cpp b/Marlin/temperature.cpp
index 5713cb693742ca8cc08ffdd27572f4a9223ff168..7c5db54c8f75852a315ebbc77628e1094ef618cf 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 c49f2c46a5f78deedb1fad9f864c97493ffb6fbe..11406c53399009cc7cd1a7def55d27d06df1ba15 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 97a07f523244d3bf9f9f9dc9e6e4e7e48e17703d..6acb889ec7ce0d762f9a38b8d10679f0cef05651 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